📄 zd1211.c
字号:
//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 = zd_cpu_to_le16(REGID_RFOFDMSET);
if (bIs3683A)
((PUSB_SET_RF)pRegBuffer)->Value = zd_cpu_to_le16(1);
else
((PUSB_SET_RF)pRegBuffer)->Value = zd_cpu_to_le16(2);
((PUSB_SET_RF)pRegBuffer)->Index = zd_cpu_to_le16((u16)S_bit_cnt);
for (i = 0; i < S_bit_cnt; i ++)
((PUSB_SET_RF)pRegBuffer)->Data[i] = zd_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);
}
static void zd1211_tx_timeout(struct net_device *dev)
{
struct zd1205_private *macp = dev->priv;
if (!macp)
return;
printk("%s: Tx timed out.\n", dev->name);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8))
defer_kevent(macp, KEVENT_USB_KILL_TX_URB);
#else
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
macp->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
#endif
usb_unlink_urb(macp->tx_urb);
#endif
/*
zd1205_Ctrl_Set_t *pCtrlSet;
zd1205_SwTcb_t *sw_tcb;
zd1205_TBD_t *Tbd;
int i;
if(macp->activeTxQ->count)
{
sw_tcb = macp->activeTxQ->first;
pCtrlSet = sw_tcb->pHwCtrlPtr;
Tbd = sw_tcb->pFirstTbd;
Tbd++;
printk("##### Control Setting #####\n");
for(i=0;i<24;i++)
printk("%02x ", *((U8 *)pCtrlSet+i));
printk("\n");
printk("##### MAC Header #####\n");
for(i=0;i<24;i++)
printk("%02x ", *(U8 *)(Tbd->TbdBufferAddrLowPart+i));
printk("\n");
}
*/
}
int zd1211_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
struct zd1205_private *macp = dev->priv;
memcpy(&macp->ifreq, ifr, sizeof(struct ifreq));
macp->ifcmd = cmd;
defer_kevent(macp, KEVENT_STD_IOCTL);
return 0;
}
#define ZD1211_TX_TIMEOUT (HZ*10)
#define ZD1211_MTU 1500
extern struct iw_handler_def p80211wext_handler_def;
u8 zd1211_InitSetup(struct net_device *dev, struct zd1205_private *macp)
{
int res;
//return true; //for debug
ZENTER(1);
init_MUTEX(&macp->ps_sem);
init_MUTEX(&macp->reg_sem);
init_MUTEX(&macp->bcn_sem);
init_MUTEX(&macp->config_sem);
init_MUTEX(&macp->ioctl_sem);
spin_lock_init(&(macp->intr_lock));
spin_lock_init(&(macp->q_lock));
spin_lock_init(&(macp->cs_lock));
INIT_WORK(&macp->kevent, kevent, macp);
INIT_WORK(&macp->scan_tout_event, kevent, macp);
macp->numTcb = NUM_TCB;
macp->numTbd = NUM_TBD;
macp->numRfd = NUM_RFD;
macp->numTbdPerTcb = NUM_TBD_PER_TCB;
macp->rxOffset = ZD_RX_OFFSET;
macp->rfd_size = 24; // form CbStatus to NextCbPhyAddrHighPart
init_timer(&macp->watchdog_timer);
macp->watchdog_timer.data = (unsigned long) dev;
macp->watchdog_timer.function = (void *) &zd1205_watchdog_cb;
init_timer(&macp->tm_hking_id);
macp->tm_hking_id.data = (unsigned long) dev;
macp->tm_hking_id.function = (void *) &HKeepingCB;
init_timer(&macp->tm_mgt_id);
macp->tm_mgt_id.data = (unsigned long) dev;
macp->tm_mgt_id.function = (void *) &zd1205_mgt_mon_cb;
#if ZDCONF_LP_SUPPORT == 1
init_timer(&macp->tm_lp_poll_id);
macp->tm_lp_poll_id.data = (unsigned long) dev;
macp->tm_lp_poll_id.function = (void *)&zd1205_lp_poll_cb;
#endif
dot11Obj.reg = (void *)0x9000;
macp->regp = (void *)0x9000;
macp->USBCSRAddress = 0x9000;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
macp->in_interval = 10;
#else
macp->in_interval = 10;
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
usb_fill_int_urb(macp->intr_urb, macp->usb,
usb_rcvintpipe(macp->usb, EP_INT_IN),
macp->IntEPBuffer, MAX_EPINT_BUFFER,
zd1211_intr_cb, macp, macp->in_interval);
#else //fake it
usb_fill_bulk_urb(macp->intr_urb, macp->usb,
usb_rcvbulkpipe(macp->usb, EP_INT_IN),
macp->IntEPBuffer, MAX_EPINT_BUFFER,
zd1211_intr_cb, macp);
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
macp->intr_urb->transfer_flags |= URB_ASYNC_UNLINK;
#endif
#if 0
macp->intr_urb->transfer_dma = macp->IntBufferHandle;
macp->intr_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
#endif
if ((res = SUBMIT_URB(macp->intr_urb, GFP_KERNEL))){
printk(KERN_ERR "zd1211: failed intr_urb\n");
zd1211_DumpErrorCode(macp, res);
return false;
}
zd1205_init(macp);
dev->open = zd1205_open;
dev->stop = zd1205_close;
dev->watchdog_timeo = ZD1211_TX_TIMEOUT;
dev->do_ioctl = zd1205_ioctl;
#if WIRELESS_EXT > 12
dev->wireless_handlers = (struct iw_handler_def *)&p80211wext_handler_def;
#endif
dev->hard_start_xmit = zd1205_xmit_frame;
dev->set_multicast_list = zd1205_set_multi;
dev->get_stats = zd1205_get_stats;
#if ZDCONF_WE_STAT_SUPPORT == 1
dev->get_wireless_stats = zd1205_iw_getstats;
#elif !defined(ZDCONF_WE_STAT_SUPPORT)
#error "Undefine ZDCONF_WE_STAT_SUPPORT"
#endif
dev->mtu = ZD1211_MTU;
dev->set_mac_address = zd1205_set_mac;
dev->tx_timeout = &zd1211_tx_timeout;
//dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
dev->flags |= IFF_MULTICAST;
//memcpy(macp->ifname, dev->name, IFNAMSIZ);
//macp->ifname[IFNAMSIZ-1] = 0;
ZEXIT(1);
return true;
}
int zd1211_alloc_all_urbs(struct zd1205_private *macp)
{
struct usb_interface *interface = macp->interface;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
struct usb_interface_descriptor *iface_desc = &interface->altsetting[0];
#else
struct usb_host_interface *iface_desc = &interface->altsetting[0];
#endif
struct usb_endpoint_descriptor *endpoint;
struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
u8 num_bulk_in = 0;
u8 num_bulk_out = 0;
u8 num_interrupt_in = 0;
u8 num_interrupt_out = 0;
int i;
/* descriptor matches, let's find the endpoints needed */
/* check out the endpoints */
//ZD1211DEBUG(2, "bNumEndpoints = %d\n", iface_desc->bNumEndpoints);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
endpoint = &iface_desc->endpoint[i];
#else
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -