drivers/staging/winbond/wb35reg.c

   1 #include "sysdef.h"
   2 #include "wb35reg_f.h"
   3
   4 #include <linux/usb.h>
   5 #include <linux/slab.h>
   6
   7 extern void phy_calibration_winbond(struct hw_data *phw_data, u32 frequency);
   8
   9 // true  : read command process successfully
  10 // false : register not support
  11 // RegisterNo : start base
  12 // pRegisterData : data point
  13 // NumberOfData : number of register data
  14 // Flag : AUTO_INCREMENT - RegisterNo will auto increment 4
  15 //                NO_INCREMENT - Function will write data into the same register
  16 unsigned char
  17 Wb35Reg_BurstWrite(struct hw_data * pHwData, u16 RegisterNo, u32 * pRegisterData, u8 NumberOfData, u8 Flag)
  18 {
  19         struct wb35_reg *reg = &pHwData->reg;
  20         struct urb      *urb = NULL;
  21         struct wb35_reg_queue *reg_queue = NULL;
  22         u16             UrbSize;
  23         struct      usb_ctrlrequest *dr;
  24         u16             i, DataSize = NumberOfData*4;
  25
  26         // Module shutdown
  27         if (pHwData->SurpriseRemove)
  28                 return false;
  29
  30         // Trying to use burst write function if use new hardware
  31         UrbSize = sizeof(struct wb35_reg_queue) + DataSize + sizeof(struct usb_ctrlrequest);
  32         reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
  33         urb = usb_alloc_urb(0, GFP_ATOMIC);
  34         if( urb && reg_queue ) {
  35                 reg_queue->DIRECT = 2;// burst write register
  36                 reg_queue->INDEX = RegisterNo;
  37                 reg_queue->pBuffer = (u32 *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
  38                 memcpy( reg_queue->pBuffer, pRegisterData, DataSize );
  39                 //the function for reversing register data from little endian to big endian
  40                 for( i=0; i<NumberOfData ; i++ )
  41                         reg_queue->pBuffer[i] = cpu_to_le32( reg_queue->pBuffer[i] );
  42
  43                 dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue) + DataSize);
  44                 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE;
  45                 dr->bRequest = 0x04; // USB or vendor-defined request code, burst mode
  46                 dr->wValue = cpu_to_le16( Flag ); // 0: Register number auto-increment, 1: No auto increment
  47                 dr->wIndex = cpu_to_le16( RegisterNo );
  48                 dr->wLength = cpu_to_le16( DataSize );
  49                 reg_queue->Next = NULL;
  50                 reg_queue->pUsbReq = dr;
  51                 reg_queue->urb = urb;
  52
  53                 spin_lock_irq( &reg->EP0VM_spin_lock );
  54                 if (reg->reg_first == NULL)
  55                         reg->reg_first = reg_queue;
  56                 else
  57                         reg->reg_last->Next = reg_queue;
  58                 reg->reg_last = reg_queue;
  59
  60                 spin_unlock_irq( &reg->EP0VM_spin_lock );
  61
  62                 // Start EP0VM
  63                 Wb35Reg_EP0VM_start(pHwData);
  64
  65                 return true;
  66         } else {
  67                 if (urb)
  68                         usb_free_urb(urb);
  69                 if (reg_queue)
  70                         kfree(reg_queue);
  71                 return false;
  72         }
  73    return false;
  74 }
  75
  76 void
  77 Wb35Reg_Update(struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue)
  78 {
  79         struct wb35_reg *reg = &pHwData->reg;
  80         switch (RegisterNo) {
  81         case 0x3b0: reg->U1B0 = RegisterValue; break;
  82         case 0x3bc: reg->U1BC_LEDConfigure = RegisterValue; break;
  83         case 0x400: reg->D00_DmaControl = RegisterValue; break;
  84         case 0x800: reg->M00_MacControl = RegisterValue; break;
  85         case 0x804: reg->M04_MulticastAddress1 = RegisterValue; break;
  86         case 0x808: reg->M08_MulticastAddress2 = RegisterValue; break;
  87         case 0x824: reg->M24_MacControl = RegisterValue; break;
  88         case 0x828: reg->M28_MacControl = RegisterValue; break;
  89         case 0x82c: reg->M2C_MacControl = RegisterValue; break;
  90         case 0x838: reg->M38_MacControl = RegisterValue; break;
  91         case 0x840: reg->M40_MacControl = RegisterValue; break;
  92         case 0x844: reg->M44_MacControl = RegisterValue; break;
  93         case 0x848: reg->M48_MacControl = RegisterValue; break;
  94         case 0x84c: reg->M4C_MacStatus = RegisterValue; break;
  95         case 0x860: reg->M60_MacControl = RegisterValue; break;
  96         case 0x868: reg->M68_MacControl = RegisterValue; break;
  97         case 0x870: reg->M70_MacControl = RegisterValue; break;
  98         case 0x874: reg->M74_MacControl = RegisterValue; break;
  99         case 0x878: reg->M78_ERPInformation = RegisterValue; break;
 100         case 0x87C: reg->M7C_MacControl = RegisterValue; break;
 101         case 0x880: reg->M80_MacControl = RegisterValue; break;
 102         case 0x884: reg->M84_MacControl = RegisterValue; break;
 103         case 0x888: reg->M88_MacControl = RegisterValue; break;
 104         case 0x898: reg->M98_MacControl = RegisterValue; break;
 105         case 0x100c: reg->BB0C = RegisterValue; break;
 106         case 0x102c: reg->BB2C = RegisterValue; break;
 107         case 0x1030: reg->BB30 = RegisterValue; break;
 108         case 0x103c: reg->BB3C = RegisterValue; break;
 109         case 0x1048: reg->BB48 = RegisterValue; break;
 110         case 0x104c: reg->BB4C = RegisterValue; break;
 111         case 0x1050: reg->BB50 = RegisterValue; break;
 112         case 0x1054: reg->BB54 = RegisterValue; break;
 113         case 0x1058: reg->BB58 = RegisterValue; break;
 114         case 0x105c: reg->BB5C = RegisterValue; break;
 115         case 0x1060: reg->BB60 = RegisterValue; break;
 116         }
 117 }
 118
 119 // true  : read command process successfully
 120 // false : register not support
 121 unsigned char
 122 Wb35Reg_WriteSync(  struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue )
 123 {
 124         struct wb35_reg *reg = &pHwData->reg;
 125         int ret = -1;
 126
 127         // Module shutdown
 128         if (pHwData->SurpriseRemove)
 129                 return false;
 130
 131         RegisterValue = cpu_to_le32(RegisterValue);
 132
 133         // update the register by send usb message------------------------------------
 134         reg->SyncIoPause = 1;
 135
 136         // 20060717.5 Wait until EP0VM stop
 137         while (reg->EP0vm_state != VM_STOP)
 138                 msleep(10);
 139
 140         // Sync IoCallDriver
 141         reg->EP0vm_state = VM_RUNNING;
 142         ret = usb_control_msg( pHwData->WbUsb.udev,
 143                                usb_sndctrlpipe( pHwData->WbUsb.udev, 0 ),
 144                                0x03, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 145                                0x0,RegisterNo, &RegisterValue, 4, HZ*100 );
 146         reg->EP0vm_state = VM_STOP;
 147         reg->SyncIoPause = 0;
 148
 149         Wb35Reg_EP0VM_start(pHwData);
 150
 151         if (ret < 0) {
 152                 #ifdef _PE_REG_DUMP_
 153                 printk("EP0 Write register usb message sending error\n");
 154                 #endif
 155
 156                 pHwData->SurpriseRemove = 1; // 20060704.2
 157                 return false;
 158         }
 159
 160         return true;
 161 }
 162
 163 // true  : read command process successfully
 164 // false : register not support
 165 unsigned char
 166 Wb35Reg_Write(  struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue )
 167 {
 168         struct wb35_reg *reg = &pHwData->reg;
 169         struct usb_ctrlrequest *dr;
 170         struct urb      *urb = NULL;
 171         struct wb35_reg_queue *reg_queue = NULL;
 172         u16             UrbSize;
 173
 174
 175         // Module shutdown
 176         if (pHwData->SurpriseRemove)
 177                 return false;
 178
 179         // update the register by send urb request------------------------------------
 180         UrbSize = sizeof(struct wb35_reg_queue) + sizeof(struct usb_ctrlrequest);
 181         reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
 182         urb = usb_alloc_urb(0, GFP_ATOMIC);
 183         if (urb && reg_queue) {
 184                 reg_queue->DIRECT = 1;// burst write register
 185                 reg_queue->INDEX = RegisterNo;
 186                 reg_queue->VALUE = cpu_to_le32(RegisterValue);
 187                 reg_queue->RESERVED_VALID = false;
 188                 dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
 189                 dr->bRequestType = USB_TYPE_VENDOR|USB_DIR_OUT |USB_RECIP_DEVICE;
 190                 dr->bRequest = 0x03; // USB or vendor-defined request code, burst mode
 191                 dr->wValue = cpu_to_le16(0x0);
 192                 dr->wIndex = cpu_to_le16(RegisterNo);
 193                 dr->wLength = cpu_to_le16(4);
 194
 195                 // Enter the sending queue
 196                 reg_queue->Next = NULL;
 197                 reg_queue->pUsbReq = dr;
 198                 reg_queue->urb = urb;
 199
 200                 spin_lock_irq(&reg->EP0VM_spin_lock );
 201                 if (reg->reg_first == NULL)
 202                         reg->reg_first = reg_queue;
 203                 else
 204                         reg->reg_last->Next = reg_queue;
 205                 reg->reg_last = reg_queue;
 206
 207                 spin_unlock_irq( &reg->EP0VM_spin_lock );
 208
 209                 // Start EP0VM
 210                 Wb35Reg_EP0VM_start(pHwData);
 211
 212                 return true;
 213         } else {
 214                 if (urb)
 215                         usb_free_urb(urb);
 216                 kfree(reg_queue);
 217                 return false;
 218         }
 219 }
 220
 221 //This command will be executed with a user defined value. When it completes,
 222 //this value is useful. For example, hal_set_current_channel will use it.
 223 // true  : read command process successfully
 224 // false : register not support
 225 unsigned char
 226 Wb35Reg_WriteWithCallbackValue( struct hw_data * pHwData, u16 RegisterNo, u32 RegisterValue,
 227                                 s8 *pValue, s8 Len)
 228 {
 229         struct wb35_reg *reg = &pHwData->reg;
 230         struct usb_ctrlrequest *dr;
 231         struct urb      *urb = NULL;
 232         struct wb35_reg_queue *reg_queue = NULL;
 233         u16             UrbSize;
 234
 235         // Module shutdown
 236         if (pHwData->SurpriseRemove)
 237                 return false;
 238
 239         // update the register by send urb request------------------------------------
 240         UrbSize = sizeof(struct wb35_reg_queue) + sizeof(struct usb_ctrlrequest);
 241         reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
 242         urb = usb_alloc_urb(0, GFP_ATOMIC);
 243         if (urb && reg_queue) {
 244                 reg_queue->DIRECT = 1;// burst write register
 245                 reg_queue->INDEX = RegisterNo;
 246                 reg_queue->VALUE = cpu_to_le32(RegisterValue);
 247                 //NOTE : Users must guarantee the size of value will not exceed the buffer size.
 248                 memcpy(reg_queue->RESERVED, pValue, Len);
 249                 reg_queue->RESERVED_VALID = true;
 250                 dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
 251                 dr->bRequestType = USB_TYPE_VENDOR|USB_DIR_OUT |USB_RECIP_DEVICE;
 252                 dr->bRequest = 0x03; // USB or vendor-defined request code, burst mode
 253                 dr->wValue = cpu_to_le16(0x0);
 254                 dr->wIndex = cpu_to_le16(RegisterNo);
 255                 dr->wLength = cpu_to_le16(4);
 256
 257                 // Enter the sending queue
 258                 reg_queue->Next = NULL;
 259                 reg_queue->pUsbReq = dr;
 260                 reg_queue->urb = urb;
 261                 spin_lock_irq (&reg->EP0VM_spin_lock );
 262                 if( reg->reg_first == NULL )
 263                         reg->reg_first = reg_queue;
 264                 else
 265                         reg->reg_last->Next = reg_queue;
 266                 reg->reg_last = reg_queue;
 267
 268                 spin_unlock_irq ( &reg->EP0VM_spin_lock );
 269
 270                 // Start EP0VM
 271                 Wb35Reg_EP0VM_start(pHwData);
 272                 return true;
 273         } else {
 274                 if (urb)
 275                         usb_free_urb(urb);
 276                 kfree(reg_queue);
 277                 return false;
 278         }
 279 }
 280
 281 // true  : read command process successfully
 282 // false : register not support
 283 // pRegisterValue : It must be a resident buffer due to asynchronous read register.
 284 unsigned char
 285 Wb35Reg_ReadSync(  struct hw_data * pHwData,  u16 RegisterNo,   u32 * pRegisterValue )
 286 {
 287         struct wb35_reg *reg = &pHwData->reg;
 288         u32 *   pltmp = pRegisterValue;
 289         int ret = -1;
 290
 291         // Module shutdown
 292         if (pHwData->SurpriseRemove)
 293                 return false;
 294
 295         // Read the register by send usb message------------------------------------
 296
 297         reg->SyncIoPause = 1;
 298
 299         // 20060717.5 Wait until EP0VM stop
 300         while (reg->EP0vm_state != VM_STOP)
 301                 msleep(10);
 302
 303         reg->EP0vm_state = VM_RUNNING;
 304         ret = usb_control_msg( pHwData->WbUsb.udev,
 305                                usb_rcvctrlpipe(pHwData->WbUsb.udev, 0),
 306                                0x01, USB_TYPE_VENDOR|USB_RECIP_DEVICE|USB_DIR_IN,
 307                                0x0, RegisterNo, pltmp, 4, HZ*100 );
 308
 309         *pRegisterValue = cpu_to_le32(*pltmp);
 310
 311         reg->EP0vm_state = VM_STOP;
 312
 313         Wb35Reg_Update( pHwData, RegisterNo, *pRegisterValue );
 314         reg->SyncIoPause = 0;
 315
 316         Wb35Reg_EP0VM_start( pHwData );
 317
 318         if (ret < 0) {
 319                 #ifdef _PE_REG_DUMP_
 320                 printk("EP0 Read register usb message sending error\n");
 321                 #endif
 322
 323                 pHwData->SurpriseRemove = 1; // 20060704.2
 324                 return false;
 325         }
 326
 327         return true;
 328 }
 329
 330 // true  : read command process successfully
 331 // false : register not support
 332 // pRegisterValue : It must be a resident buffer due to asynchronous read register.
 333 unsigned char
 334 Wb35Reg_Read(struct hw_data * pHwData, u16 RegisterNo,  u32 * pRegisterValue )
 335 {
 336         struct wb35_reg *reg = &pHwData->reg;
 337         struct usb_ctrlrequest * dr;
 338         struct urb      *urb;
 339         struct wb35_reg_queue *reg_queue;
 340         u16             UrbSize;
 341
 342         // Module shutdown
 343         if (pHwData->SurpriseRemove)
 344                 return false;
 345
 346         // update the variable by send Urb to read register ------------------------------------
 347         UrbSize = sizeof(struct wb35_reg_queue) + sizeof(struct usb_ctrlrequest);
 348         reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
 349         urb = usb_alloc_urb(0, GFP_ATOMIC);
 350         if( urb && reg_queue )
 351         {
 352                 reg_queue->DIRECT = 0;// read register
 353                 reg_queue->INDEX = RegisterNo;
 354                 reg_queue->pBuffer = pRegisterValue;
 355                 dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
 356                 dr->bRequestType = USB_TYPE_VENDOR|USB_RECIP_DEVICE|USB_DIR_IN;
 357                 dr->bRequest = 0x01; // USB or vendor-defined request code, burst mode
 358                 dr->wValue = cpu_to_le16(0x0);
 359                 dr->wIndex = cpu_to_le16 (RegisterNo);
 360                 dr->wLength = cpu_to_le16 (4);
 361
 362                 // Enter the sending queue
 363                 reg_queue->Next = NULL;
 364                 reg_queue->pUsbReq = dr;
 365                 reg_queue->urb = urb;
 366                 spin_lock_irq ( &reg->EP0VM_spin_lock );
 367                 if( reg->reg_first == NULL )
 368                         reg->reg_first = reg_queue;
 369                 else
 370                         reg->reg_last->Next = reg_queue;
 371                 reg->reg_last = reg_queue;
 372
 373                 spin_unlock_irq( &reg->EP0VM_spin_lock );
 374
 375                 // Start EP0VM
 376                 Wb35Reg_EP0VM_start( pHwData );
 377
 378                 return true;
 379         } else {
 380                 if (urb)
 381                         usb_free_urb( urb );
 382                 kfree(reg_queue);
 383                 return false;
 384         }
 385 }
 386
 387
 388 void
 389 Wb35Reg_EP0VM_start(  struct hw_data * pHwData )
 390 {
 391         struct wb35_reg *reg = &pHwData->reg;
 392
 393         if (atomic_inc_return(&reg->RegFireCount) == 1) {
 394                 reg->EP0vm_state = VM_RUNNING;
 395                 Wb35Reg_EP0VM(pHwData);
 396         } else
 397                 atomic_dec(&reg->RegFireCount);
 398 }
 399
 400 void
 401 Wb35Reg_EP0VM(struct hw_data * pHwData )
 402 {
 403         struct wb35_reg *reg = &pHwData->reg;
 404         struct urb      *urb;
 405         struct usb_ctrlrequest *dr;
 406         u32 *           pBuffer;
 407         int                     ret = -1;
 408         struct wb35_reg_queue *reg_queue;
 409
 410
 411         if (reg->SyncIoPause)
 412                 goto cleanup;
 413
 414         if (pHwData->SurpriseRemove)
 415                 goto cleanup;
 416
 417         // Get the register data and send to USB through Irp
 418         spin_lock_irq( &reg->EP0VM_spin_lock );
 419         reg_queue = reg->reg_first;
 420         spin_unlock_irq( &reg->EP0VM_spin_lock );
 421
 422         if (!reg_queue)
 423                 goto cleanup;
 424
 425         // Get an Urb, send it
 426         urb = (struct urb *)reg_queue->urb;
 427
 428         dr = reg_queue->pUsbReq;
 429         urb = reg_queue->urb;
 430         pBuffer = reg_queue->pBuffer;
 431         if (reg_queue->DIRECT == 1) // output
 432                 pBuffer = &reg_queue->VALUE;
 433
 434         usb_fill_control_urb( urb, pHwData->WbUsb.udev,
 435                               REG_DIRECTION(pHwData->WbUsb.udev,reg_queue),
 436                               (u8 *)dr,pBuffer,cpu_to_le16(dr->wLength),
 437                               Wb35Reg_EP0VM_complete, (void*)pHwData);
 438
 439         reg->EP0vm_state = VM_RUNNING;
 440
 441         ret = usb_submit_urb(urb, GFP_ATOMIC);
 442
 443         if (ret < 0) {
 444 #ifdef _PE_REG_DUMP_
 445                 printk("EP0 Irp sending error\n");
 446 #endif
 447                 goto cleanup;
 448         }
 449
 450         return;
 451
 452  cleanup:
 453         reg->EP0vm_state = VM_STOP;
 454         atomic_dec(&reg->RegFireCount);
 455 }
 456
 457
 458 void
 459 Wb35Reg_EP0VM_complete(struct urb *urb)
 460 {
 461         struct hw_data *  pHwData = (struct hw_data *)urb->context;
 462         struct wb35_reg *reg = &pHwData->reg;
 463         struct wb35_reg_queue *reg_queue;
 464
 465
 466         // Variable setting
 467         reg->EP0vm_state = VM_COMPLETED;
 468         reg->EP0VM_status = urb->status;
 469
 470         if (pHwData->SurpriseRemove) { // Let WbWlanHalt to handle surprise remove
 471                 reg->EP0vm_state = VM_STOP;
 472                 atomic_dec(&reg->RegFireCount);
 473         } else {
 474                 // Complete to send, remove the URB from the first
 475                 spin_lock_irq( &reg->EP0VM_spin_lock );
 476                 reg_queue = reg->reg_first;
 477                 if (reg_queue == reg->reg_last)
 478                         reg->reg_last = NULL;
 479                 reg->reg_first = reg->reg_first->Next;
 480                 spin_unlock_irq( &reg->EP0VM_spin_lock );
 481
 482                 if (reg->EP0VM_status) {
 483 #ifdef _PE_REG_DUMP_
 484                         printk("EP0 IoCompleteRoutine return error\n");
 485 #endif
 486                         reg->EP0vm_state = VM_STOP;
 487                         pHwData->SurpriseRemove = 1;
 488                 } else {
 489                         // Success. Update the result
 490
 491                         // Start the next send
 492                         Wb35Reg_EP0VM(pHwData);
 493                 }
 494
 495                 kfree(reg_queue);
 496         }
 497
 498         usb_free_urb(urb);
 499 }
 500
 501
 502 void
 503 Wb35Reg_destroy(struct hw_data * pHwData)
 504 {
 505         struct wb35_reg *reg = &pHwData->reg;
 506         struct urb      *urb;
 507         struct wb35_reg_queue *reg_queue;
 508
 509
 510         Uxx_power_off_procedure(pHwData);
 511
 512         // Wait for Reg operation completed
 513         do {
 514                 msleep(10); // Delay for waiting function enter 940623.1.a
 515         } while (reg->EP0vm_state != VM_STOP);
 516         msleep(10);  // Delay for waiting function enter 940623.1.b
 517
 518         // Release all the data in RegQueue
 519         spin_lock_irq( &reg->EP0VM_spin_lock );
 520         reg_queue = reg->reg_first;
 521         while (reg_queue) {
 522                 if (reg_queue == reg->reg_last)
 523                         reg->reg_last = NULL;
 524                 reg->reg_first = reg->reg_first->Next;
 525
 526                 urb = reg_queue->urb;
 527                 spin_unlock_irq( &reg->EP0VM_spin_lock );
 528                 if (urb) {
 529                         usb_free_urb(urb);
 530                         kfree(reg_queue);
 531                 } else {
 532                         #ifdef _PE_REG_DUMP_
 533                         printk("EP0 queue release error\n");
 534                         #endif
 535                 }
 536                 spin_lock_irq( &reg->EP0VM_spin_lock );
 537
 538                 reg_queue = reg->reg_first;
 539         }
 540         spin_unlock_irq( &reg->EP0VM_spin_lock );
 541 }
 542
 543 //====================================================================================
 544 // The function can be run in passive-level only.
 545 //====================================================================================
 546 unsigned char Wb35Reg_initial(struct hw_data * pHwData)
 547 {
 548         struct wb35_reg *reg=&pHwData->reg;
 549         u32 ltmp;
 550         u32 SoftwareSet, VCO_trim, TxVga, Region_ScanInterval;
 551
 552         // Spin lock is acquired for read and write IRP command
 553         spin_lock_init( &reg->EP0VM_spin_lock );
 554
 555         // Getting RF module type from EEPROM ------------------------------------
 556         Wb35Reg_WriteSync( pHwData, 0x03b4, 0x080d0000 ); // Start EEPROM access + Read + address(0x0d)
 557         Wb35Reg_ReadSync( pHwData, 0x03b4, &ltmp );
 558
 559         //Update RF module type and determine the PHY type by inf or EEPROM
 560         reg->EEPROMPhyType = (u8)( ltmp & 0xff );
 561         // 0 V MAX2825, 1 V MAX2827, 2 V MAX2828, 3 V MAX2829
 562         // 16V AL2230, 17 - AL7230, 18 - AL2230S
 563         // 32 Reserved
 564         // 33 - W89RF242(TxVGA 0~19), 34 - W89RF242(TxVGA 0~34)
 565         if (reg->EEPROMPhyType != RF_DECIDE_BY_INF) {
 566                 if( (reg->EEPROMPhyType == RF_MAXIM_2825)       ||
 567                         (reg->EEPROMPhyType == RF_MAXIM_2827)   ||
 568                         (reg->EEPROMPhyType == RF_MAXIM_2828)   ||
 569                         (reg->EEPROMPhyType == RF_MAXIM_2829)   ||
 570                         (reg->EEPROMPhyType == RF_MAXIM_V1)     ||
 571                         (reg->EEPROMPhyType == RF_AIROHA_2230)  ||
 572                         (reg->EEPROMPhyType == RF_AIROHA_2230S)    ||
 573                         (reg->EEPROMPhyType == RF_AIROHA_7230)  ||
 574                         (reg->EEPROMPhyType == RF_WB_242)               ||
 575                         (reg->EEPROMPhyType == RF_WB_242_1))
 576                         pHwData->phy_type = reg->EEPROMPhyType;
 577         }
 578
 579         // Power On procedure running. The relative parameter will be set according to phy_type
 580         Uxx_power_on_procedure( pHwData );
 581
 582         // Reading MAC address
 583         Uxx_ReadEthernetAddress( pHwData );
 584
 585         // Read VCO trim for RF parameter
 586         Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08200000 );
 587         Wb35Reg_ReadSync( pHwData, 0x03b4, &VCO_trim );
 588
 589         // Read Antenna On/Off of software flag
 590         Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08210000 );
 591         Wb35Reg_ReadSync( pHwData, 0x03b4, &SoftwareSet );
 592
 593         // Read TXVGA
 594         Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08100000 );
 595         Wb35Reg_ReadSync( pHwData, 0x03b4, &TxVga );
 596
 597         // Get Scan interval setting from EEPROM offset 0x1c
 598         Wb35Reg_WriteSync( pHwData, 0x03b4, 0x081d0000 );
 599         Wb35Reg_ReadSync( pHwData, 0x03b4, &Region_ScanInterval );
 600
 601         // Update Ethernet address
 602         memcpy( pHwData->CurrentMacAddress, pHwData->PermanentMacAddress, ETH_ALEN );
 603
 604         // Update software variable
 605         pHwData->SoftwareSet = (u16)(SoftwareSet & 0xffff);
 606         TxVga &= 0x000000ff;
 607         pHwData->PowerIndexFromEEPROM = (u8)TxVga;
 608         pHwData->VCO_trim = (u8)VCO_trim & 0xff;
 609         if (pHwData->VCO_trim == 0xff)
 610                 pHwData->VCO_trim = 0x28;
 611
 612         reg->EEPROMRegion = (u8)(Region_ScanInterval>>8); // 20060720
 613         if( reg->EEPROMRegion<1 || reg->EEPROMRegion>6 )
 614                 reg->EEPROMRegion = REGION_AUTO;
 615
 616         //For Get Tx VGA from EEPROM 20060315.5 move here
 617         GetTxVgaFromEEPROM( pHwData );
 618
 619         // Set Scan Interval
 620         pHwData->Scan_Interval = (u8)(Region_ScanInterval & 0xff) * 10;
 621         if ((pHwData->Scan_Interval == 2550) || (pHwData->Scan_Interval < 10)) // Is default setting 0xff * 10
 622                 pHwData->Scan_Interval = SCAN_MAX_CHNL_TIME;
 623
 624         // Initial register
 625         RFSynthesizer_initial(pHwData);
 626
 627         BBProcessor_initial(pHwData); // Async write, must wait until complete
 628
 629         Wb35Reg_phy_calibration(pHwData);
 630
 631         Mxx_initial(pHwData);
 632         Dxx_initial(pHwData);
 633
 634         if (pHwData->SurpriseRemove)
 635                 return false;
 636         else
 637                 return true; // Initial fail
 638 }
 639
 640 //===================================================================================
 641 //  CardComputeCrc --
 642 //
 643 //  Description:
 644 //    Runs the AUTODIN II CRC algorithm on buffer Buffer of length, Length.
 645 //
 646 //  Arguments:
 647 //    Buffer - the input buffer
 648 //    Length - the length of Buffer
 649 //
 650 //  Return Value:
 651 //    The 32-bit CRC value.
 652 //
 653 //  Note:
 654 //    This is adapted from the comments in the assembly language
 655 //    version in _GENREQ.ASM of the DWB NE1000/2000 driver.
 656 //==================================================================================
 657 u32
 658 CardComputeCrc(u8 * Buffer, u32 Length)
 659 {
 660     u32 Crc, Carry;
 661     u32  i, j;
 662     u8 CurByte;
 663
 664     Crc = 0xffffffff;
 665
 666     for (i = 0; i < Length; i++) {
 667
 668         CurByte = Buffer[i];
 669
 670         for (j = 0; j < 8; j++) {
 671
 672             Carry     = ((Crc & 0x80000000) ? 1 : 0) ^ (CurByte & 0x01);
 673             Crc     <<= 1;
 674             CurByte >>= 1;
 675
 676             if (Carry) {
 677                 Crc =(Crc ^ 0x04c11db6) | Carry;
 678             }
 679         }
 680     }
 681
 682     return Crc;
 683 }
 684
 685
 686 //==================================================================
 687 // BitReverse --
 688 //   Reverse the bits in the input argument, dwData, which is
 689 //   regarded as a string of bits with the length, DataLength.
 690 //
 691 // Arguments:
 692 //   dwData     :
 693 //   DataLength :
 694 //
 695 // Return:
 696 //   The converted value.
 697 //==================================================================
 698 u32 BitReverse( u32 dwData, u32 DataLength)
 699 {
 700         u32   HalfLength, i, j;
 701         u32   BitA, BitB;
 702
 703         if ( DataLength <= 0)       return 0;   // No conversion is done.
 704         dwData = dwData & (0xffffffff >> (32 - DataLength));
 705
 706         HalfLength = DataLength / 2;
 707         for ( i = 0, j = DataLength-1 ; i < HalfLength; i++, j--)
 708         {
 709                 BitA = GetBit( dwData, i);
 710                 BitB = GetBit( dwData, j);
 711                 if (BitA && !BitB) {
 712                         dwData = ClearBit( dwData, i);
 713                         dwData = SetBit( dwData, j);
 714                 } else if (!BitA && BitB) {
 715                         dwData = SetBit( dwData, i);
 716                         dwData = ClearBit( dwData, j);
 717                 } else
 718                 {
 719                         // Do nothing since these two bits are of the save values.
 720                 }
 721         }
 722
 723         return dwData;
 724 }
 725
 726 void Wb35Reg_phy_calibration(  struct hw_data * pHwData )
 727 {
 728         u32 BB3c, BB54;
 729
 730         if ((pHwData->phy_type == RF_WB_242) ||
 731                 (pHwData->phy_type == RF_WB_242_1)) {
 732                 phy_calibration_winbond ( pHwData, 2412 ); // Sync operation
 733                 Wb35Reg_ReadSync( pHwData, 0x103c, &BB3c );
 734                 Wb35Reg_ReadSync( pHwData, 0x1054, &BB54 );
 735
 736                 pHwData->BB3c_cal = BB3c;
 737                 pHwData->BB54_cal = BB54;
 738
 739                 RFSynthesizer_initial(pHwData);
 740                 BBProcessor_initial(pHwData); // Async operation
 741
 742                 Wb35Reg_WriteSync( pHwData, 0x103c, BB3c );
 743                 Wb35Reg_WriteSync( pHwData, 0x1054, BB54 );
 744         }
 745 }
 746
 747