property/autodloader_mode.c

   1 #include <config.h>
   2 #include <linux/types.h>
   3 #include <asm/arch/bits.h>
   4 //#include <boot_mode.h>
   5 #include <common.h>
   6 #include <asm/io.h>
   7
   8 #include <asm/arch/dl_engine.h>
   9 #include <asm/arch/cmd_def.h>
  10 #include <asm/arch/fdl_channel.h>
  11 #include <asm/arch/packet.h>
  12 #include <asm/arch/regs_ahb.h>
  13 //#include "../drivers/mmc/card_sdio.h"
  14 #include <asm/arch/adi_hal_internal.h>
  15 #include <asm/arch/sprd_reg.h>
  16
  17
  18 #define USB_ENUM_MS 15000
  19 #define USB_IO_MS 100000
  20 #ifdef HWRST_STATUS_AUTODLOADER
  21 #undef HWRST_STATUS_AUTODLOADER
  22 #endif
  23 #define HWRST_STATUS_AUTODLOADER (0xa0)
  24
  25
  26 typedef struct _DL_FILE_STATUS
  27 {
  28     unsigned long start_address;
  29     unsigned long total_size;
  30     unsigned long recv_size;
  31     unsigned long next_address;
  32 } DL_FILE_STATUS, *PDL_FILE_STATUS;
  33
  34 static DL_FILE_STATUS g_file;
  35 static const char VERSION_STR[] = {"SPRD3"};
  36
  37
  38 extern int dwc_otg_driver_init(void);
  39 extern int usb_serial_init(void);
  40 extern int usb_is_port_open(void);
  41 extern int usb_is_configured(void);
  42 extern void usb_boot (uint32 ext_clk26M);
  43 extern void FDL_PacketInit (void);
  44 extern unsigned char FDL_DlReg (CMD_TYPE cmd, CMDPROC proc, void *arg);
  45
  46 int autodloader_initusb(void)
  47 {
  48         ulong start_time, now ;
  49         dwc_otg_driver_init();
  50         usb_serial_init();
  51         start_time = get_timer_masked();
  52         while(!usb_is_configured()){
  53                 now = get_timer_masked();
  54                 if(now - start_time > USB_ENUM_MS) {
  55                         printf("USB SERIAL CONFIGED failed \n");
  56                         return -1;
  57                 }
  58         }
  59         printf("USB SERIAL CONFIGED\n");
  60
  61          start_time = get_timer_masked();
  62         while(!usb_is_port_open()) {
  63                 now = get_timer_masked();
  64                 if(now - start_time > USB_IO_MS) {
  65                         printf("USB SERIAL PORT OPEN failed \n");
  66                         return -1;
  67                 }
  68         }
  69
  70         printf("USB SERIAL PORT OPENED\n");
  71
  72         //gs_open();
  73
  74         return 0;
  75 }
  76
  77 static unsigned int autodloader_EndianConv_32 (unsigned int value)
  78 {
  79 #ifdef _LITTLE_ENDIAN
  80     unsigned int nTmp = 0;
  81         nTmp = (value >> 24 | value << 24);
  82
  83     nTmp |= ( (value >> 8) & 0x0000FF00);
  84     nTmp |= ( (value << 8) & 0x00FF0000);
  85     return nTmp;
  86 #else
  87     return value;
  88 #endif
  89 }
  90 int autodloader_connect(PACKET_T *packet, void *arg)
  91 {
  92     FDL_SendAckPacket(BSL_REP_ACK);
  93     return 1;
  94 }
  95
  96 int autodloader_start(PACKET_T *packet, void *arg)
  97 {
  98     unsigned long *data = (unsigned long*)(packet->packet_body.content);
  99     unsigned long start_addr = *data;
 100     unsigned long file_size  = *(data + 1);
 101
 102 #if defined (CHIP_ENDIAN_LITTLE)
 103     start_addr = autodloader_EndianConv_32(start_addr);
 104     file_size  = autodloader_EndianConv_32(file_size);
 105 #endif
 106
 107     g_file.start_address = start_addr;
 108     g_file.total_size = file_size;
 109     g_file.recv_size = 0;
 110     g_file.next_address = start_addr;
 111
 112     memset((void*)start_addr, 0, file_size);
 113     if (!packet->ack_flag)
 114     {
 115         packet->ack_flag = 1;
 116         FDL_SendAckPacket(BSL_REP_ACK);
 117     }
 118     return 1;
 119 }
 120
 121 int autodloader_midst(PACKET_T *packet, void *arg)
 122 {
 123     unsigned short data_len = packet->packet_body.size;
 124
 125     if ((g_file.recv_size + data_len) > g_file.total_size) {
 126         FDL_SendAckPacket(BSL_REP_DOWN_SIZE_ERROR);
 127         return 0;
 128     }
 129
 130     memcpy((void *)g_file.next_address, (const void*)(packet->packet_body.content), data_len);
 131     g_file.next_address += data_len;
 132     g_file.recv_size += data_len;
 133     if (!packet->ack_flag)
 134     {
 135         packet->ack_flag = 1;
 136         FDL_SendAckPacket(BSL_REP_ACK);
 137     }
 138     return 1;
 139 }
 140
 141 int autodloader_end(PACKET_T *packet, void *arg)
 142 {
 143     if (!packet->ack_flag)
 144     {
 145         packet->ack_flag = 1;
 146         FDL_SendAckPacket(BSL_REP_ACK);
 147     }
 148     return 1;
 149 }
 150
 151 int autodloader_exec(PACKET_T *packet, void *arg)
 152 {
 153     FDL_SendAckPacket(BSL_REP_ACK);
 154     ANA_REG_SET(ANA_REG_GLB_POR_RST_MONITOR, HWRST_STATUS_AUTODLOADER);
 155 //    JumpToTarget(g_file.start_address);
 156     typedef void(*entry)(void);
 157     entry entry_func = (entry)((void*)g_file.start_address);
 158     entry_func();
 159     return 0;
 160 }
 161
 162
 163 int autodloader_mainhandler(void)
 164 {
 165         PACKET_T *packet;
 166         usb_boot(1);
 167         FDL_PacketInit();
 168
 169         FDL_DlInit();
 170         FDL_DlReg(BSL_CMD_CONNECT,        autodloader_connect,  0);
 171         FDL_DlReg(BSL_CMD_START_DATA, autodloader_start,        0);
 172         FDL_DlReg(BSL_CMD_MIDST_DATA, autodloader_midst,        0);
 173         FDL_DlReg(BSL_CMD_EXEC_DATA,  autodloader_exec, 0);
 174         FDL_DlReg(BSL_CMD_END_DATA,   autodloader_end,  0);
 175
 176         for (;;)
 177         {
 178                 char ch = gFdlUsedChannel->GetChar(gFdlUsedChannel);
 179                 if (0x7e == ch)
 180                         break;
 181         }
 182
 183         packet = FDL_MallocPacket();
 184         packet->packet_body.type = BSL_REP_VER;
 185         packet->packet_body.size = sizeof(VERSION_STR);
 186         memcpy(packet->packet_body.content, VERSION_STR, sizeof(VERSION_STR));
 187         FDL_SendPacket(packet);
 188         FDL_FreePacket(packet);
 189
 190         FDL_DlEntry(DL_STAGE_NONE);
 191
 192         return 0;
 193 }
 194
 195 static void __raw_bits_and(unsigned int v, unsigned int a)
 196 {
 197         __raw_writel((__raw_readl(a) & v), a);
 198 }
 199
 200 void autodlader_remap(void)
 201 {
 202         __raw_bits_and(~BIT_0, AHB_REMAP);
 203 }
 204
 205 #ifdef CONFIG_AUTODLOADER
 206 void autodloader_mode(void)
 207 {
 208         int i = 0;
 209         printf("%s\n", __FUNCTION__);
 210         //for(i = 0; i < 0xfffffff; i++)
 211                 //printf("hello world! \n");
 212
 213         //CARD_SDIO_PwrCtl(emmc_handle, FALSE);
 214
 215         /* initialize usb module*/
 216         if(autodloader_initusb())
 217                 return ;
 218         /* remap iram */
 219         autodlader_remap();
 220         /* main handler receive and jump */
 221         autodloader_mainhandler();
 222
 223         /* cannot reach here */
 224         for(;;);
 225 }
 226 #endif