drivers/staging/rtl8723bs/core/rtw_eeprom.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  ******************************************************************************/
  15 #define _RTW_EEPROM_C_
  16
  17 #include <drv_conf.h>
  18 #include <osdep_service.h>
  19 #include <drv_types.h>
  20
  21 void up_clk(_adapter *padapter,  u16 *x)
  22 {
  23 _func_enter_;
  24         *x = *x | _EESK;
  25         rtw_write8(padapter, EE_9346CR, (u8)*x);
  26         udelay(CLOCK_RATE);
  27
  28 _func_exit_;
  29
  30 }
  31
  32 void down_clk(_adapter *padapter, u16 *x)
  33 {
  34 _func_enter_;
  35         *x = *x & ~_EESK;
  36         rtw_write8(padapter, EE_9346CR, (u8)*x);
  37         udelay(CLOCK_RATE);
  38 _func_exit_;
  39 }
  40
  41 void shift_out_bits(_adapter *padapter, u16 data, u16 count)
  42 {
  43         u16 x, mask;
  44 _func_enter_;
  45
  46         if (padapter->bSurpriseRemoved == true) {
  47                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
  48                 goto out;
  49         }
  50         mask = 0x01 << (count - 1);
  51         x = rtw_read8(padapter, EE_9346CR);
  52
  53         x &= ~(_EEDO | _EEDI);
  54
  55         do {
  56                 x &= ~_EEDI;
  57                 if (data & mask)
  58                         x |= _EEDI;
  59                 if (padapter->bSurpriseRemoved == true) {
  60                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
  61                 goto out;
  62                 }
  63                 rtw_write8(padapter, EE_9346CR, (u8)x);
  64                 udelay(CLOCK_RATE);
  65                 up_clk(padapter, &x);
  66                 down_clk(padapter, &x);
  67                 mask = mask >> 1;
  68         } while (mask);
  69         if (padapter->bSurpriseRemoved == true) {
  70                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
  71                 goto out;
  72         }
  73         x &= ~_EEDI;
  74         rtw_write8(padapter, EE_9346CR, (u8)x);
  75 out:
  76 _func_exit_;
  77 }
  78
  79 u16 shift_in_bits(_adapter *padapter)
  80 {
  81         u16 x, d = 0, i;
  82 _func_enter_;
  83         if (padapter->bSurpriseRemoved == true) {
  84                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
  85                 goto out;
  86         }
  87         x = rtw_read8(padapter, EE_9346CR);
  88
  89         x &= ~(_EEDO | _EEDI);
  90         d = 0;
  91
  92         for (i = 0; i < 16; i++) {
  93                 d = d << 1;
  94                 up_clk(padapter, &x);
  95         if (padapter->bSurpriseRemoved == true) {
  96                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
  97                 goto out;
  98         }
  99                 x = rtw_read8(padapter, EE_9346CR);
 100
 101                 x &= ~(_EEDI);
 102                 if (x & _EEDO)
 103                 d |= 1;
 104
 105                 down_clk(padapter, &x);
 106         }
 107 out:
 108 _func_exit_;
 109
 110         return d;
 111 }
 112
 113 void standby(_adapter *padapter)
 114 {
 115         u8   x;
 116 _func_enter_;
 117         x = rtw_read8(padapter, EE_9346CR);
 118
 119         x &= ~(_EECS | _EESK);
 120         rtw_write8(padapter, EE_9346CR, x);
 121
 122         udelay(CLOCK_RATE);
 123         x |= _EECS;
 124         rtw_write8(padapter, EE_9346CR, x);
 125         udelay(CLOCK_RATE);
 126 _func_exit_;
 127 }
 128
 129 u16 wait_eeprom_cmd_done(_adapter *padapter)
 130 {
 131         u8 x;
 132         u16 i, res = false;
 133 _func_enter_;
 134         standby(padapter);
 135         for (i = 0; i < 200; i++) {
 136                 x = rtw_read8(padapter, EE_9346CR);
 137                 if (x & _EEDO) {
 138                         res = true;
 139                         goto exit;
 140                         }
 141                 udelay(CLOCK_RATE);
 142         }
 143 exit:
 144 _func_exit_;
 145         return res;
 146 }
 147
 148 void eeprom_clean(_adapter *padapter)
 149 {
 150         u16 x;
 151 _func_enter_;
 152         if (padapter->bSurpriseRemoved == true) {
 153                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 154                 goto out;
 155         }
 156         x = rtw_read8(padapter, EE_9346CR);
 157         if (padapter->bSurpriseRemoved == true) {
 158                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 159                 goto out;
 160         }
 161         x &= ~(_EECS | _EEDI);
 162         rtw_write8(padapter, EE_9346CR, (u8)x);
 163         if (padapter->bSurpriseRemoved == true) {
 164                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 165                 goto out;
 166         }
 167         up_clk(padapter, &x);
 168                 if (padapter->bSurpriseRemoved == true) {
 169                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 170                 goto out;
 171         }
 172         down_clk(padapter, &x);
 173 out:
 174 _func_exit_;
 175 }
 176
 177 void eeprom_write16(_adapter *padapter, u16 reg, u16 data)
 178 {
 179         u8 x;
 180
 181 _func_enter_;
 182
 183         x = rtw_read8(padapter, EE_9346CR);
 184
 185         x &= ~(_EEDI | _EEDO | _EESK | _EEM0);
 186         x |= _EEM1 | _EECS;
 187         rtw_write8(padapter, EE_9346CR, x);
 188
 189         shift_out_bits(padapter, EEPROM_EWEN_OPCODE, 5);
 190
 191         if (padapter->EepromAddressSize == 8)   /*CF+ and SDIO*/
 192                 shift_out_bits(padapter, 0, 6);
 193         else                                                                    /*USB*/
 194                 shift_out_bits(padapter, 0, 4);
 195
 196         standby(padapter);
 197
 198 /* Commented out by rcnjko, 2004.0
 199 *        Erase this particular word.  Write the erase opcode and register
 200 *        number in that order. The opcode is 3bits in length; reg is 6 bits long.
 201 *       shift_out_bits(Adapter, EEPROM_ERASE_OPCODE, 3);
 202 *       shift_out_bits(Adapter, reg, Adapter->EepromAddressSize);
 203 *
 204 *       if (wait_eeprom_cmd_done(Adapter ) == false)
 205 *       {
 206 *               return;
 207 *       }
 208 */
 209
 210         standby(padapter);
 211
 212         /* write the new word to the EEPROM*/
 213
 214         /* send the write opcode the EEPORM*/
 215         shift_out_bits(padapter, EEPROM_WRITE_OPCODE, 3);
 216
 217         /* select which word in the EEPROM that we are writing to.*/
 218         shift_out_bits(padapter, reg, padapter->EepromAddressSize);
 219
 220         /* write the data to the selected EEPROM word.*/
 221         shift_out_bits(padapter, data, 16);
 222
 223         if (wait_eeprom_cmd_done(padapter) == false) {
 224
 225                 goto exit;
 226         }
 227
 228         standby(padapter);
 229
 230         shift_out_bits(padapter, EEPROM_EWDS_OPCODE, 5);
 231         shift_out_bits(padapter, reg, 4);
 232
 233         eeprom_clean(padapter);
 234 exit:
 235 _func_exit_;
 236         return;
 237 }
 238
 239 u16 eeprom_read16(_adapter *padapter, u16 reg) /*ReadEEprom*/
 240 {
 241
 242         u16 x;
 243         u16 data = 0;
 244
 245 _func_enter_;
 246
 247         if (padapter->bSurpriseRemoved == true) {
 248                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 249                 goto out;
 250         }
 251         /* select EEPROM, reset bits, set _EECS*/
 252         x = rtw_read8(padapter, EE_9346CR);
 253
 254         if (padapter->bSurpriseRemoved == true) {
 255                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 256                 goto out;
 257         }
 258
 259         x &= ~(_EEDI | _EEDO | _EESK | _EEM0);
 260         x |= _EEM1 | _EECS;
 261         rtw_write8(padapter, EE_9346CR, (unsigned char)x);
 262
 263         /* write the read opcode and register number in that order*/
 264         /* The opcode is 3bits in length, reg is 6 bits long*/
 265         shift_out_bits(padapter, EEPROM_READ_OPCODE, 3);
 266         shift_out_bits(padapter, reg, padapter->EepromAddressSize);
 267
 268         /* Now read the data (16 bits) in from the selected EEPROM word*/
 269         data = shift_in_bits(padapter);
 270
 271         eeprom_clean(padapter);
 272 out:
 273 _func_exit_;
 274         return data;
 275
 276
 277 }
 278
 279
 280
 281
 282 /*From even offset*/
 283 void eeprom_read_sz(_adapter *padapter, u16 reg, u8 *data, u32 sz)
 284 {
 285
 286         u16 x, data16;
 287         u32 i;
 288 _func_enter_;
 289         if (padapter->bSurpriseRemoved == true) {
 290                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 291                 goto out;
 292         }
 293         /* select EEPROM, reset bits, set _EECS*/
 294         x = rtw_read8(padapter, EE_9346CR);
 295
 296         if (padapter->bSurpriseRemoved == true) {
 297                 RT_TRACE(_module_rtl871x_eeprom_c_, _drv_err_, ("padapter->bSurpriseRemoved==true"));
 298                 goto out;
 299         }
 300
 301         x &= ~(_EEDI | _EEDO | _EESK | _EEM0);
 302         x |= _EEM1 | _EECS;
 303         rtw_write8(padapter, EE_9346CR, (unsigned char)x);
 304
 305         /* write the read opcode and register number in that order*/
 306         /* The opcode is 3bits in length, reg is 6 bits long*/
 307         shift_out_bits(padapter, EEPROM_READ_OPCODE, 3);
 308         shift_out_bits(padapter, reg, padapter->EepromAddressSize);
 309
 310
 311         for (i = 0; i < sz; i += 2) {
 312                 data16 = shift_in_bits(padapter);
 313                 data[i] = data16 & 0xff;
 314                 data[i+1] = data16 >> 8;
 315         }
 316
 317         eeprom_clean(padapter);
 318 out:
 319 _func_exit_;
 320
 321
 322
 323 }
 324
 325
 326 /*addr_off : address offset of the entry in eeprom (not the tuple number of eeprom (reg); that is addr_off !=reg)*/
 327 u8 eeprom_read(_adapter *padapter, u32 addr_off, u8 sz, u8 *rbuf)
 328 {
 329         u8 quotient, remainder, addr_2align_odd;
 330         u16 reg, stmp, i = 0, idx = 0;
 331 _func_enter_;
 332         reg = (u16)(addr_off >> 1);
 333         addr_2align_odd = (u8)(addr_off & 0x1);
 334
 335         /*read that start at high part: e.g  1,3,5,7,9,...*/
 336         if (addr_2align_odd) {
 337                 stmp = eeprom_read16(padapter, reg);
 338                 rbuf[idx++] = (u8) ((stmp>>8)&0xff); /*return hogh-part of the short*/
 339                 reg++; sz--;
 340         }
 341
 342         quotient = sz >> 1;
 343         remainder = sz & 0x1;
 344
 345         for (i = 0; i < quotient; i++) {
 346                 stmp = eeprom_read16(padapter, reg+i);
 347                 rbuf[idx++] = (u8) (stmp&0xff);
 348                 rbuf[idx++] = (u8) ((stmp>>8)&0xff);
 349         }
 350
 351         reg = reg+i;
 352         if (remainder) { /*end of read at lower part of short : 0,2,4,6,...*/
 353                 stmp = eeprom_read16(padapter, reg);
 354                 rbuf[idx] = (u8)(stmp & 0xff);
 355         }
 356 _func_exit_;
 357         return true;
 358 }
 359
 360
 361
 362 void read_eeprom_content(_adapter *padapter)
 363 {
 364
 365 _func_enter_;
 366
 367
 368 _func_exit_;
 369 }