ath9k_htc/sboot/utility/patch_gen/patch.c

   1 /*
   2  * Copyright (c) 2013 Qualcomm Atheros, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted (subject to the limitations in the
   7  * disclaimer below) provided that the following conditions are met:
   8  *
   9  *  * Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  *  * Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  *  * Neither the name of Qualcomm Atheros nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
  22  * GRANTED BY THIS LICENSE.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
  23  * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
  24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  31  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  32  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  33  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 #include <stdio.h>
  36 #include "dt_defs.h"
  37 #include "patch.h"
  38
  39 //extern unsigned short m_crc16ccitt;
  40 uint16_t uRead = 0;
  41 uint8_t patchBuf[SIZE_HASH_BUFFER];
  42
  43
  44 int db_ascii_to_hex(char* num_str, unsigned long* hex_num)
  45 {
  46     int i = 0;
  47
  48     *hex_num = 0;
  49     while (num_str[i])
  50     {
  51         if ((num_str[i] >= '0') && (num_str[i] <= '9'))
  52         {
  53             *hex_num <<= 4;
  54             *hex_num += (num_str[i] - '0');
  55         }
  56         else if ((num_str[i] >= 'A') && (num_str[i] <= 'F'))
  57         {
  58             *hex_num <<= 4;
  59             *hex_num += (num_str[i] - 'A' + 10);
  60         }
  61         else if ((num_str[i] >= 'a') && (num_str[i] <= 'f'))
  62         {
  63             *hex_num <<= 4;
  64             *hex_num += (num_str[i] - 'a' + 10);
  65         }
  66         else
  67         {
  68             return -1;
  69         }
  70         i++;
  71     }
  72     return 0;
  73 }
  74
  75
  76 #if 0
  77 void dump_hex(uint8_t *buf, uint16_t size)
  78 {
  79         uint16_t i=0;
  80
  81
  82         for(i=0; i<size; i++)
  83         {
  84                 if( (i%16==0) )
  85                         printf("\n\r");
  86                 else if( (i>0) && (i%8==0) )
  87                         printf("- ");
  88
  89                 printf("%02x ", buf[i]);
  90         }
  91 }
  92 #endif
  93
  94
  95 BOOLEAN gen_patch_item(struct rom_patch_st *patch, uint8_t *file_name)
  96 {
  97         BOOLEAN retVal = FALSE;
  98         FILE *in;
  99         uint8_t *ptr;
 100         uint16_t size = 0;
 101
 102         if((in = fopen(file_name,"rb")) != NULL)
 103                 retVal = TRUE;
 104         else
 105                 goto ERR_DONE;
 106
 107         ptr = patchBuf;
 108         while (1)
 109         {
 110                 ptr += uRead;
 111                 uRead = fread(ptr, 1, SIZE_HASH_BUFFER, in);
 112
 113                 // debug to dump the data we read
 114                 //dump_hex(ptr, uRead);
 115
 116                 patch->len += uRead;
 117
 118                 if(uRead != SIZE_HASH_BUFFER)
 119                         break;
 120     }
 121
 122         memcpy(patch->fun, patchBuf, patch->len);
 123         patch->crc16 = patch->len; // bugs? workaround?
 124
 125         printf("\n\n");
 126
 127         fclose(in);
 128 ERR_DONE:
 129
 130         return retVal;
 131 }
 132
 133 BOOLEAN _patch_init(struct rom_patch_st *patch)
 134 {
 135         // init the pact_pack
 136         //memset((uint8_t *)patch_patck, 0x0, sizeof(struct rom_patch_pack_st));
 137         patch->crc16 = 0;
 138         patch->len = 0;
 139         patch->ld_addr = 0;
 140         patch->fun_addr = 0;
 141         patch->fun = NULL;
 142
 143         return TRUE;
 144 }
 145
 146 void _patch_dump(struct rom_patch_st *patch)
 147 {
 148         printf(" -----------------------------\n\r");
 149         printf(" patch code crc: 0x%04x\n\r", patch->crc16);
 150         printf(" patch code size: %d\n\r", patch->len);
 151         printf(" patch ld_addr: 0x%08x\n\r", patch->ld_addr);
 152         printf(" patch fun_addr: 0x%08x\n\r", patch->fun_addr);
 153         printf(" -----------------------------\n\r");
 154 }
 155
 156
 157 BOOLEAN _patch_oepn(uint8_t *buf, uint8_t *mFile)
 158 {
 159         FILE *in;
 160         BOOLEAN retVal = FALSE;
 161         uint16_t offset = 0;
 162
 163         if((in = fopen(mFile,"rb")) != NULL)
 164         {
 165                 printf("%s is opened successful!\n\r", mFile);
 166                 retVal = TRUE;
 167         }
 168         else
 169                 goto ERROR;
 170
 171         while (1)
 172         {
 173                 uRead = fread(buf+offset, 1, SIZE_HASH_BUFFER, in);
 174
 175                 // debug to dump the data we read
 176                 //dump_hex(buf+offset, uRead);
 177
 178                 offset += uRead;
 179                 if(uRead != SIZE_HASH_BUFFER) break;
 180
 181         }
 182 ERROR:
 183         if(in)
 184                 close(in);
 185
 186         return retVal;
 187 }
 188
 189 uint32_t _patch_append(uint8_t *buf, struct rom_patch_st *patch)
 190 {
 191
 192         memcpy(buf, (uint8_t *)patch, (sizeof(struct rom_patch_st)-4));
 193         memcpy(buf+(sizeof(struct rom_patch_st)-4), patch->fun, patch->len);
 194
 195         return 0;
 196 }
 197
 198