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                 break;
 182         case RQT_DL_FILE_START:
 183                 send_rsp(rsp);
 184                 return download_file_start();
 185         case RQT_DL_FILE_END:
 186                 thor_debug("DL FILE_END\n");
 187                 break;
 188         case RQT_DL_EXIT:
 189                 thor_debug("DL EXIT\n");
 190                 break;
 191         default:
 192                 thor_debug("Operation not supported: %d", rqt->rqt_data);
 193                 ret = -ENOTSUPP;
 194         }
 195
 196         send_rsp(rsp);
 197         return ret;
 198 }
 199
 200 static int process_rqt_info(const struct rqt_box *rqt)
 201 {
 202         struct rsp_box *rsp = &rsp_buf;
 203         memset(rsp, 0, sizeof(struct rsp_box));
 204
 205         rsp->rsp = rqt->rqt;
 206         rsp->rsp_data = rqt->rqt_data;
 207
 208         switch (rqt->rqt_data) {
 209         case RQT_INFO_VER_PROTOCOL:
 210                 rsp->int_data[0] = VER_PROTOCOL_MAJOR;
 211                 rsp->int_data[1] = VER_PROTOCOL_MINOR;
 212                 break;
 213         case RQT_INIT_VER_HW:
 214                 break;
 215         case RQT_INIT_VER_BOOT:
 216                 sprintf(rsp->str_data[0], "%s", U_BOOT_VERSION);
 217                 break;
 218         case RQT_INIT_VER_KERNEL:
 219                 sprintf(rsp->str_data[0], "%s", "k unknown");
 220                 break;
 221         case RQT_INIT_VER_PLATFORM:
 222                 sprintf(rsp->str_data[0], "%s", "p unknown");
 223                 break;
 224         case RQT_INIT_VER_CSC:
 225                 sprintf(rsp->str_data[0], "%s", "c unknown");
 226                 break;
 227         default:
 228                 return -EINVAL;
 229         }
 230
 231         send_rsp(rsp);
 232         return 1;
 233 }
 234
 235 static int process_rqt_cmd(const struct rqt_box *rqt)
 236 {
 237         struct rsp_box *rsp = &rsp_buf;
 238         memset(rsp, 0, sizeof(struct rsp_box));
 239
 240         rsp->rsp = rqt->rqt;
 241         rsp->rsp_data = rqt->rqt_data;
 242
 243         switch (rqt->rqt_data) {
 244         case RQT_CMD_REBOOT:
 245                 thor_debug("TARGET RESET\n");
 246                 send_rsp(rsp);
 247
 248                 udc_power_off();
 249                 thor_save_env("thor");
 250                 reset_cpu(0);
 251
 252                 break;
 253         case RQT_CMD_POWEROFF:
 254         case RQT_CMD_EFSCLEAR:
 255                 send_rsp(rsp);
 256         default:
 257                 thor_debug("Command not supported -> cmd: %d\n", rqt->rqt_data);
 258                 return -EINVAL;
 259         }
 260
 261         return 1;
 262 }
 263
 264 static int process_data(void)
 265 {
 266         struct rqt_box *rqt = &rqt_buf;
 267         int ret = -EINVAL;
 268
 269         memcpy(rqt, thor_rx_data_buf, sizeof(struct rqt_box));
 270
 271         thor_debug("+RQT: %d, %d\n", rqt->rqt, rqt->rqt_data);
 272
 273         switch (rqt->rqt) {
 274         case RQT_INFO:
 275                 ret = process_rqt_info(rqt);
 276                 break;
 277         case RQT_CMD:
 278                 ret = process_rqt_cmd(rqt);
 279                 break;
 280         case RQT_DL:
 281                 ret = (int) process_rqt_download(rqt);
 282                 break;
 283         case RQT_UL:
 284                 break;
 285         default:
 286                 thor_debug("unknown request (%d)", rqt->rqt);
 287         }
 288
 289         return ret;
 290 }
 291
 292 int thor_handle(void)
 293 {
 294         int ret;
 295
 296 retry:
 297         /* receive the data from Host PC */
 298         while (1) {
 299                 if (thor_usb_is_connected()) {
 300                         ret = USB_ReadEx(thor_rx_data_buf, strlen("THOR"));
 301                         if (!strncmp(thor_rx_data_buf, "THOR", strlen("THOR")))
 302                         {
 303                                 USB_WriteEx("ROHT", strlen("ROHT"));
 304                                 goto retry;
 305                         }
 306                         ret = USB_ReadEx(thor_rx_data_buf + strlen("THOR"), sizeof(thor_rx_data_buf) - strlen("THOR"));
 307
 308                         if (ret > 0) {
 309                                 ret = process_data();
 310                                 if (ret < 0)
 311                                         return ret;
 312                         } else {
 313                                 thor_debug("%s: No data received!\n", __func__);
 314                                 return ret;
 315                         }
 316                 }
 317         }
 318
 319         return 0;
 320 }
 321
 322 extern int hw_revision;
 323 void thor_mode(void)
 324 {
 325         lcd_set_cur_pos(1, 2);
 326         lcd_printf("THOR MODE\n");
 327
 328         lcd_set_cur_pos(3, 2);
 329         lcd_setfgcolor (CONSOLE_COLOR_WHITE);
 330         lcd_printf("HW REV: %d\n", hw_revision);
 331
 332         MMU_DisableIDCM();
 333         thor_USB_Init();
 334
 335         return;
 336 }