property/thor_mode.c

   1 #include <boot_mode.h>
   2 #include <config.h>
   3 #include <common.h>
   4 #include <div64.h>
   5 #include <errno.h>
   6 #include <version.h>
   7 #include <lcd.h>
   8 #include <linux/string.h>
   9 #include "../drivers/mmc/card_sdio.h"
  10 #include "thor_mode.h"
  11 #include "tizen_misc.h"
  12
  13 #ifdef THOR_DEBUG
  14 #define thor_debug(fmt, arg...)         printf(fmt, ## arg)
  15 #else
  16 #define thor_debug(fmt, arg...)
  17 #endif
  18
  19 static unsigned char thor_tx_data_buf[sizeof(struct rsp_box)];
  20 static unsigned char thor_rx_data_buf[sizeof(struct rqt_box)];
  21
  22 static struct rqt_box rqt_buf;
  23 static struct rsp_box rsp_buf;
  24 static struct data_rsp_box data_rsp_buf;
  25
  26 static unsigned int thor_file_size;
  27 static unsigned long long total_file_size;
  28 static unsigned long long downloaded_file_size;
  29
  30 static u32 download_addr = CONFIG_THOR_TRANSFER_BUFFER;
  31
  32 /* partition info */
  33 struct thor_part_info part_info;
  34 static char f_name[F_NAME_BUF_SIZE];
  35
  36 static void thor_clear_part_info(void)
  37 {
  38         part_info.offset = 0;
  39         part_info.size = 0;
  40         part_info.blksz = 0;
  41         part_info.valid = 0;
  42         part_info.erase = 0;
  43 }
  44
  45 static void send_rsp(const struct rsp_box *rsp)
  46 {
  47         memcpy(thor_tx_data_buf, rsp, sizeof(struct rsp_box));
  48         USB_WriteEx(thor_tx_data_buf, sizeof(struct rsp_box));
  49
  50         thor_debug("-RSP: %d, %d\n", rsp->rsp, rsp->rsp_data);
  51 }
  52
  53 static void send_data_rsp(signed int ack, signed int count)
  54 {
  55         struct data_rsp_box *rsp = &data_rsp_buf;
  56
  57         rsp->ack = ack;
  58         rsp->count = count;
  59
  60         memcpy(thor_tx_data_buf, rsp, sizeof(struct data_rsp_box));
  61         USB_WriteEx(thor_tx_data_buf, sizeof(struct data_rsp_box));
  62
  63         thor_debug("-DATA RSP: %d, %d\n", ack, count);
  64 }
  65
  66 static int download_file_start(void)
  67 {
  68         unsigned int dn_addr;
  69         unsigned int buffered = 0;
  70         unsigned int remained = thor_file_size;
  71         unsigned int progressed = 0;
  72         unsigned int write_ofs = 0;
  73
  74         int ret;
  75         int count = 0;
  76         int download_done = 0;
  77         int usb_pkt_cnt = 0;
  78         int per = 0;
  79
  80         thor_debug("Download file start\n");
  81
  82         while (!download_done) {
  83                 dn_addr = download_addr + buffered;
  84                 ret = USB_ReadEx((char *) dn_addr, THOR_PACKET_SIZE);
  85                 if (ret <= 0)
  86                         return ret;
  87                 buffered += ret;
  88                 progressed += ret;
  89
  90                 if (progressed >= thor_file_size)
  91                         download_done = 1;
  92
  93                 if (download_done)
  94                         downloaded_file_size += thor_file_size % ret;
  95                 else
  96                         downloaded_file_size += ret;
  97
  98                 per = (int) lldiv(100 * downloaded_file_size, total_file_size);
  99                 draw_progress(per);
 100
 101                 /* MAX UNIT SIZE or done */
 102                 if ((buffered >= THOR_STORE_UNIT_SIZE) || download_done) {
 103                         unsigned int count, remain, mod;
 104
 105                         remain = MIN(buffered, remained);
 106                         mod = remain % part_info.blksz;
 107                         count = remain / part_info.blksz;
 108
 109                         /* write remain byte < block_size */
 110                         if (mod)
 111                                 count++;
 112
 113 #ifdef CONFIG_SIG
 114                         /* check board signature when download u-boot-mmc.bin */
 115                         ret = check_board_signature(f_name, download_addr, thor_file_size);
 116                         if (ret) {
 117                                 lcd_printf("Signature Check Failed\n");
 118                                 return -EINVAL;
 119                         }
 120 #endif
 121                         ret = Emmc_Write(PARTITION_USER, part_info.offset + write_ofs, count, download_addr);
 122                         if (!ret)
 123                                 return -EIO;
 124
 125                         write_ofs += count;
 126                         remained -= buffered;
 127                         buffered = 0;
 128                 }
 129
 130                 send_data_rsp(0, ++usb_pkt_cnt);
 131         }
 132
 133         return ret;
 134 }
 135
 136 static long long int process_rqt_download(const struct rqt_box *rqt)
 137 {
 138         struct rsp_box *rsp = &rsp_buf;
 139         static long long int left, ret_head;
 140         int file_type, ret = 0;
 141
 142         memset(rsp, 0, sizeof(struct rsp_box));
 143         rsp->rsp = rqt->rqt;
 144         rsp->rsp_data = rqt->rqt_data;
 145
 146         switch (rqt->rqt_data) {
 147         case RQT_DL_INIT:
 148                 thor_file_size = rqt->int_data[0];
 149                 total_file_size = thor_file_size;
 150
 151                 downloaded_file_size = 0;
 152                 /* clear partition info */
 153                 thor_clear_part_info();
 154
 155                 thor_debug("INIT: total %d bytes\n", rqt->int_data[0]);
 156                 break;
 157         case RQT_DL_FILE_INFO:
 158                 file_type = rqt->int_data[0];
 159                 if (file_type == FILE_TYPE_PIT) {
 160                         thor_debug("PIT table file - not supported\n");
 161                         rsp->ack = -ENOTSUPP;
 162                         ret = rsp->ack;
 163                         break;
 164                 }
 165
 166                 thor_file_size = rqt->int_data[1];
 167                 memcpy(f_name, rqt->str_data[0], F_NAME_BUF_SIZE);
 168
 169                 thor_debug("INFO: name(%s, %d), size(%llu), type(%d)\n",
 170                       f_name, 0, thor_file_size, file_type);
 171
 172                 rsp->int_data[0] = THOR_PACKET_SIZE;
 173                 /* Get partition info by binary name */
 174                 ret = thor_get_part_info(&part_info, f_name);
 175                 if (ret < 0) {
 176                         thor_debug("Unsupported binary\n");
 177                         rsp->ack = -ENODEV;
 178                         ret = rsp->ack;
 179                 }
 180
 181                 if (thor_file_size > part_info.size * part_info.blksz) {
 182                         thor_debug("Too large binary\n");
 183                         rsp->ack = -EFBIG;
 184                         ret = rsp->ack;
 185                 }
 186
 187                 break;
 188         case RQT_DL_FILE_START:
 189                 send_rsp(rsp);
 190                 return download_file_start();
 191         case RQT_DL_FILE_END:
 192                 thor_debug("DL FILE_END\n");
 193                 break;
 194         case RQT_DL_EXIT:
 195                 thor_debug("DL EXIT\n");
 196                 break;
 197         default:
 198                 thor_debug("Operation not supported: %d", rqt->rqt_data);
 199                 ret = -ENOTSUPP;
 200         }
 201
 202         send_rsp(rsp);
 203         return ret;
 204 }
 205
 206 static int process_rqt_info(const struct rqt_box *rqt)
 207 {
 208         struct rsp_box *rsp = &rsp_buf;
 209         memset(rsp, 0, sizeof(struct rsp_box));
 210
 211         rsp->rsp = rqt->rqt;
 212         rsp->rsp_data = rqt->rqt_data;
 213
 214         switch (rqt->rqt_data) {
 215         case RQT_INFO_VER_PROTOCOL:
 216                 rsp->int_data[0] = VER_PROTOCOL_MAJOR;
 217                 rsp->int_data[1] = VER_PROTOCOL_MINOR;
 218                 break;
 219         case RQT_INIT_VER_HW:
 220                 break;
 221         case RQT_INIT_VER_BOOT:
 222                 sprintf(rsp->str_data[0], "%s", U_BOOT_VERSION);
 223                 break;
 224         case RQT_INIT_VER_KERNEL:
 225                 sprintf(rsp->str_data[0], "%s", "k unknown");
 226                 break;
 227         case RQT_INIT_VER_PLATFORM:
 228                 sprintf(rsp->str_data[0], "%s", "p unknown");
 229                 break;
 230         case RQT_INIT_VER_CSC:
 231                 sprintf(rsp->str_data[0], "%s", "c unknown");
 232                 break;
 233         default:
 234                 return -EINVAL;
 235         }
 236
 237         send_rsp(rsp);
 238         return 1;
 239 }
 240
 241 static int process_rqt_cmd(const struct rqt_box *rqt)
 242 {
 243         struct rsp_box *rsp = &rsp_buf;
 244         memset(rsp, 0, sizeof(struct rsp_box));
 245
 246         rsp->rsp = rqt->rqt;
 247         rsp->rsp_data = rqt->rqt_data;
 248
 249         switch (rqt->rqt_data) {
 250         case RQT_CMD_REBOOT:
 251                 thor_debug("TARGET RESET\n");
 252                 send_rsp(rsp);
 253
 254                 udc_power_off();
 255                 thor_save_env("thor");
 256                 reset_cpu(0);
 257
 258                 break;
 259         case RQT_CMD_POWEROFF:
 260         case RQT_CMD_EFSCLEAR:
 261                 send_rsp(rsp);
 262         default:
 263                 thor_debug("Command not supported -> cmd: %d\n", rqt->rqt_data);
 264                 return -EINVAL;
 265         }
 266
 267         return 1;
 268 }
 269
 270 static int process_data(void)
 271 {
 272         struct rqt_box *rqt = &rqt_buf;
 273         int ret = -EINVAL;
 274
 275         memcpy(rqt, thor_rx_data_buf, sizeof(struct rqt_box));
 276
 277         thor_debug("+RQT: %d, %d\n", rqt->rqt, rqt->rqt_data);
 278
 279         switch (rqt->rqt) {
 280         case RQT_INFO:
 281                 ret = process_rqt_info(rqt);
 282                 break;
 283         case RQT_CMD:
 284                 ret = process_rqt_cmd(rqt);
 285                 break;
 286         case RQT_DL:
 287                 ret = (int) process_rqt_download(rqt);
 288                 break;
 289         case RQT_UL:
 290                 break;
 291         default:
 292                 thor_debug("unknown request (%d)", rqt->rqt);
 293         }
 294
 295         return ret;
 296 }
 297
 298 int thor_handle(void)
 299 {
 300         int ret;
 301
 302 retry:
 303         /* receive the data from Host PC */
 304         while (1) {
 305                 if (thor_usb_is_connected()) {
 306                         ret = USB_ReadEx(thor_rx_data_buf, strlen("THOR"));
 307                         if (!strncmp(thor_rx_data_buf, "THOR", strlen("THOR")))
 308                         {
 309                                 USB_WriteEx("ROHT", strlen("ROHT"));
 310                                 goto retry;
 311                         }
 312                         ret = USB_ReadEx(thor_rx_data_buf + strlen("THOR"), sizeof(thor_rx_data_buf) - strlen("THOR"));
 313
 314                         if (ret > 0) {
 315                                 ret = process_data();
 316                                 if (ret < 0)
 317                                         return ret;
 318                         } else {
 319                                 thor_debug("%s: No data received!\n", __func__);
 320                                 return ret;
 321                         }
 322                 }
 323         }
 324
 325         return 0;
 326 }
 327
 328 extern int hw_revision;
 329 void thor_mode(void)
 330 {
 331         lcd_set_cur_pos(1, 2);
 332         lcd_printf("THOR MODE\n");
 333
 334         lcd_set_cur_pos(3, 2);
 335         lcd_setfgcolor (CONSOLE_COLOR_WHITE);
 336         lcd_printf("HW REV: %d\n", hw_revision);
 337
 338         MMU_DisableIDCM();
 339         thor_USB_Init();
 340
 341         return;
 342 }
 343
 344 int do_thor_down(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 345 {
 346         puts("TIZEN \"THOR\" Downloader\n");
 347
 348         thor_mode();
 349 }
 350
 351 U_BOOT_CMD(thordown, 1, 1, do_thor_down,
 352            "TIZEN \"THOR\" downloader",
 353            ""
 354 );