zd1211.c

ZYDAS zd1211b driver for Linux2.4

                mFILL_WRITE_REGISTER(Sec0, 0xD0);
        }

        zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
        UnLockPhyReg(&dot11Obj);
}





void zd1211_EraseFlash(struct zd1205_private *macp) {
        u32  ii;
        u32  tmpvalue;
        u16  low_addr, jj;

        macp->bDisableTx = 1;
        //USB_StopTxEP(Adapter);
        LockPhyReg(&dot11Obj);
        macp->bAllowAccessRegister = 0;


        zd1211_InitHighAddr(macp);

        if (macp->FlashType == cFLASH_MXIC)

        {
                zd1211_FlashCmdWrite(macp, 0x80);
                zd1211_FlashCmdWrite(macp, 0x10);
        } else
        {
                for (ii = 0; ii < 0x400000L; ii += 0x10000L) {
                        low_addr = zd1211_SetAbsAddr(macp, ii, NULL);
                        zd1211_FlashSecErase(macp, low_addr);
                        for (jj = 0; jj < 100; jj ++) {
                                tmpvalue = zd1211_readl(0, false);
                                if (tmpvalue & 0x8000)
                                        break;

                                mdelay(10);            // Sleep 10ms
                        }
                }

        }


        //macp->bAllowAccessRegister = 1;



        UnLockPhyReg(&dot11Obj);

        //macp->bDisableTx = 0;
}


#if !fPROG_FLASH_BY_FW
void FlashProgram(struct zd1205_private *macp, u16 addr0, u8 *pbuf, u16 tmpvalue) {
        u16  WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
        u16  WriteData[cMAX_MULTI_WRITE_REG_NUM];
        u16  WriteIndex = 0;
        u16  jj;

        if (macp->FlashType == cFLASH_MXIC)
        {
                for (jj = 0; jj < 16; jj ++) {
                        WriteIndex = 0;
                        mFLASH_SET_EVEN_ADDR(tmpvalue);
                        zd1211_FlashCmdWrite(macp, 0xA0);
                        mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2]);
                        zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false;
                                          }

                                          for (jj = 0; jj < 16; jj ++) {
                                                  WriteIndex = 0;
                                                  mFLASH_SET_ODD_ADDR(tmpvalue);
                                                  zd1211_FlashCmdWrite(macp, 0xA0);
                                                  mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2 + 1]);

                                                  if (jj == 15) {
                                                          // Read Word Addr

                                                          mFLASH_SET_EVEN_ADDR(tmpvalue);
                                                  }

                                                  zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
                                          }
                                  } else
                                  {
                                          mFLASH_SET_EVEN_ADDR(tmpvalue);
                                          mFILL_WRITE_REGISTER(addr0, 0xE8);
                                          mFILL_WRITE_REGISTER(addr0, 0x0F);
                                          for (jj = 0; jj < 8; jj ++)
                                                  mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2]);
                                          zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);


                                          WriteIndex = 0;
                                          for (jj = 8; jj < 16; jj ++)

                                                  mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2]);

                                          mFILL_WRITE_REGISTER(0, 0xD0);
                                          zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);

                                          WriteIndex = 0;
                                          mFLASH_SET_ODD_ADDR(tmpvalue);
                                          mFILL_WRITE_REGISTER(addr0, 0xE8);
                                          mFILL_WRITE_REGISTER(addr0, 0x0F);
                                          for (jj = 0; jj < 8; jj ++)
                                                  mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2 + 1]);
                                          zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);

                                          WriteIndex = 0;
                                          for (jj = 8; jj < 16; jj ++)
                                                  mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2 + 1]);
                                          mFILL_WRITE_REGISTER(0, 0xD0);
                                          zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
                                  }

                          }
#endif



                          int zd1211_ProgFlash(struct zd1205_private *macp, u32 StartAddr,
                                               u32 BufLenInBytes, u8 *pDownloadBuffer) {
                                  int i;
                                  u32   ii;
                                  u16  low_addr, jj;
                                  int chk_flg = 1;
                                  u16  tmpvalue;
#if fPROG_FLASH_BY_FW

                                  u16  WriteData[cMAX_MULTI_RF_REG_NUM];
                                  u16  WriteIndex = 0;
#endif

#if fVERIFY_FLASH

                                  u16  ReadAddr[cMAX_MULTI_READ_REG_NUM];
                                  u16  ReadData[cMAX_MULTI_READ_REG_NUM];
                                  u16  ReadIndex = 0;
                                  u16  chk_cnt = 0;
#endif

                                  macp->bDisableTx = 1;
                                  //USB_StopTxEP(Adapter);

                                  LockPhyReg(&dot11Obj);
                                  macp->bAllowAccessRegister = 0;

                                  zd1211_InitHighAddr(macp);
                                  StartAddr /= 2;                         // Convert Byte Addr to Word Addr

                                  for (ii = 0; ii < BufLenInBytes / 2; ii += 16)
                                  {
                                          if (macp->FlashType == cFLASH_MXIC) {
                                                  if ((ii + StartAddr) >= 0x200000)   // 2M Word = 4M Byte
                                                          break;
                                          } else {
                                                  if ((ii + StartAddr) >= 0x400000)   // 4M Word = 8M Byte
                                                          break;
                                          }

                                          low_addr = zd1211_SetAbsAddr(macp, ii + StartAddr, &tmpvalue);

#if fPROG_FLASH_BY_FW

                                          WriteIndex = 0;
                                          tmpvalue &= 0x00FF;
                                          tmpvalue |= ((macp->FlashType) << 8);
                                          mFILL_RF_REGISTER(mCLR_BIT((tmpvalue), bmFLASH_A0));
                                          mFILL_RF_REGISTER(low_addr);

                                          for (jj = 0; jj < 16; jj ++)
                                                  mFILL_RF_REGISTER((u16) pDownloadBuffer[(ii + jj) * 2]);

                                          zd1211_USB_ProgramFlash(macp, WriteData, WriteIndex);
                                          WriteIndex = 0;
                                          mFILL_RF_REGISTER(mSET_BIT((tmpvalue), bmFLASH_A0));
                                          mFILL_RF_REGISTER(low_addr);

                                          for (jj = 0; jj < 16; jj ++)
                                                  mFILL_RF_REGISTER((u16) pDownloadBuffer[(ii + jj) * 2 + 1]);

                                          for (i=0; i<5; i++) {
                                                  if (zd1211_USB_ProgramFlash(macp, WriteData, WriteIndex))
                                                          break;
                                          }
#else
                                          zd1211_FlashProgram(macp, low_addr, pDownloadBuffer + 2 * ii, tmpvalue);
#endif

                                  }

                                  //macp->bAllowAccessRegister = 1;
                                  UnLockPhyReg(&dot11Obj);
                                  //macp->bDisableTx = 0;

                                  return chk_flg;
                          }

#endif

                          int zd1211_USB_SET_RF_REG(u16 *InputValue, int bIs3683A) {
                                  struct zd1205_private *macp = g_dev->priv;

                                  u8 *pRegBuffer = NULL;
                                  int ret;
                                  u16 size = sizeof(USB_SET_RF);
                                  u16 bufSize;
                                  u32	S_bit_cnt = dot11Obj.S_bit_cnt;
                                  u16 i;

#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))

                                  if (in_interrupt()) {
#else
                                  if (in_atomic()) {
#endif
                                          FPRINT("********zd1211_USB_SET_RF_REG in_interrupt*********");
                                          return 0;
                                  }

                                  down(&macp->reg_sem);

                                  if (!(macp->bUSBDeveiceAttached)) {
                                          up(&macp->reg_sem);
                                          return 0;
                                  }

                                  pRegBuffer = kmalloc(size, GFP_KERNEL);

                                  if (!pRegBuffer) {
                                          up(&macp->reg_sem);
                                          return -ENOMEM;
                                  } else
                                          memset(pRegBuffer, 0x0, size);

                                  ((PUSB_SET_RF)pRegBuffer)->RequestID = cpu_to_le16(REGID_RFOFDMSET);

                                  if (bIs3683A)
                                          ((PUSB_SET_RF)pRegBuffer)->Value = cpu_to_le16(1);
                                  else
                                          ((PUSB_SET_RF)pRegBuffer)->Value = cpu_to_le16(2);

                                  ((PUSB_SET_RF)pRegBuffer)->Index = cpu_to_le16((u16)S_bit_cnt);

                                  for (i = 0; i < S_bit_cnt; i ++)
                                          ((PUSB_SET_RF)pRegBuffer)->Data[i] = cpu_to_le16(InputValue[i]);

                                  bufSize = sizeof(u16) * (3+S_bit_cnt);

                                  if (macp->ep4isIntOut)
                                          usb_fill_int_urb(macp->reg_urb, macp->usb,
                                                           usb_sndintpipe(macp->usb, EP_REG_OUT),
                                                           pRegBuffer, bufSize,
                                                           zd1211_reg_cb, macp, 1);
                                  else
                                          usb_fill_bulk_urb(macp->reg_urb, macp->usb,
                                                            usb_sndbulkpipe(macp->usb, EP_REG_OUT),
                                                            pRegBuffer, bufSize,
                                                            zd1211_reg_cb, macp);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))

                                  macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
#endif

                                  if ((ret = SUBMIT_URB(macp->reg_urb, GFP_ATOMIC))) {
                                          printk(KERN_ERR "zd1211: failed rf reg_urb\n");
                                          zd1211_DumpErrorCode(macp, ret);
                                          goto out;
                                  }

                                  macp->regWaitWCompCnt++;
                                  wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
                                  macp->regRWCompCnt++;
                                  clear_bit(ZD1211_CMD_FINISH, &macp->flags);

                          out:
                                  kfree(pRegBuffer);
                                  up(&macp->reg_sem);
                                  return ret;
                          }

#define bmZD_IF_LE              1
#define bmZD_RF_CLK             2
#define bmZD_RF_DATA            3
                          void
                          HW_Set_IF_Synthesizer(zd_80211Obj_t *pObj, U32 InputValue) {
                                  u32	S_bit_cnt;
                                  u32	tmpvalue;
                                  u16 WriteData[cMAX_MULTI_RF_REG_NUM];
                                  u16 WriteIndex = 0;

                                  S_bit_cnt = pObj->S_bit_cnt;
                                  InputValue = InputValue << (31 - S_bit_cnt);

                                  //to avoid un-necessary register read/write
                                  //LockPhyReg(pObj);
                                  tmpvalue = zd_readl(ZD_CR203);
                                  tmpvalue = mCLR_BIT(tmpvalue, bmZD_IF_LE);

                                  // Configure RF by Software
                                  tmpvalue = mCLR_BIT(tmpvalue, bmZD_RF_CLK);

                                  while (S_bit_cnt) {
                                          InputValue = InputValue << 1;

                                          if (InputValue & 0x80000000) {
                                                  tmpvalue = mSET_BIT(tmpvalue, bmZD_RF_DATA);
                                                  mFILL_RF_REGISTER((u16) tmpvalue);
                                          } else {
                                                  tmpvalue = mCLR_BIT(tmpvalue, bmZD_RF_DATA);
                                                  mFILL_RF_REGISTER((u16) tmpvalue);
                                          }

                                          if (WriteIndex >= cMAX_MULTI_RF_REG_NUM) {
                                                  FPRINT_V("S_bit_cnt over range! ", (u32)pObj->S_bit_cnt);
                                                  break;
                                          }

                                          S_bit_cnt --;
                                  }

                                  zd1211_USB_SET_RF_REG(WriteData, 0);
                                  //UnLockPhyReg(pObj);
                          }

                          /* ath_desc: Defer tx kill_urb on Linux 2.6.8+ */
                          static void zd1211_kill_tx_urb(void *_macp) {
                                  struct zd1205_private *macp = (struct zd1205_private *)_macp;
                                  ZENTER(1);
                                  macp->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
                                  ZD_USB_KILL_URB(macp->tx_urb);
                          }

                          static void zd1211_tx_timeout(struct net_device *dev) {
                                  struct zd1205_private *macp = dev->priv;

                                  if (!macp)
                                          return;

                                  /* ath_desc: added Tx timeout reset */
                                  printk("%s: Tx timed out, trying reset\n", dev->name);
                                  macp->drv_stats.net_stats.tx_carrier_errors++;
                                  dev->trans_start = jiffies;
                                  defer_kevent(macp, KEVENT_UPDATE_SETTING);
                                  /* ath: On Linux 2