zd1211.c

ZYDAS zd1211b driver for Linux2.4

        return 0;

}



int zd1211_USB_WRITE_EEPROM_DATA(struct zd1205_private *macp, PUSB_EEPROM_DATA	pData, int DataLen)
{
        int ret;
        u8 *pBuffer;
        //int memflags = GFP_KERNEL;

        ZD1211DEBUG(0, "USB_WRITE_EEPROM_DATA\n");

        if (!macp->bUSBDeveiceAttached)
        {
                return 1;
        }

        down(&macp->reg_sem);

        pBuffer = kmalloc(DataLen, GFP_KERNEL);

        if (!pBuffer)
        {
                up(&macp->reg_sem);
                return -ENOMEM;
        } else
                memcpy(pBuffer, (u8 *)pData, DataLen);

        if (macp->ep4isIntOut)
                usb_fill_int_urb(macp->reg_urb, macp->usb,
                                 usb_sndintpipe(macp->usb, EP_REG_OUT),
                                 pBuffer, DataLen,
                                 zd1211_reg_cb, macp, 1);
        else
                usb_fill_bulk_urb(macp->reg_urb, macp->usb,
                                  usb_sndbulkpipe(macp->usb, EP_REG_OUT),
                                  pBuffer, DataLen,
                                  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 reg_urb\n");
                zd1211_DumpErrorCode(macp, ret);
                goto out;
        }

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

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

#if fPROG_FLASH_BY_FW
int zd1211_USB_ProgramFlash(struct zd1205_private *macp, u16 *Value, u16 RegCount)
{
        u8 *pRegBuffer = NULL;

        int ret;
        u16 size = sizeof(USB_WRITE_REG);

        u16 bufSize;
        int ii;

        ZD1211DEBUG(0, "USB_ProgramFlash\n");

        if ((RegCount == 0) || (!macp->bUSBDeveiceAttached))
                return 0;

        down(&macp->reg_sem);
        pRegBuffer = kmalloc(size, GFP_KERNEL);

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

        /* ath_desc: bigendian support */
        ((PUSB_WRITE_REG)pRegBuffer)->RequestID = cpu_to_le16(REGID_PROG_FLSH);
        ((PUSB_SET_RF) pRegBuffer)->Value       = cpu_to_le16(Value[0]);
        ((PUSB_SET_RF) pRegBuffer)->Index       = cpu_to_le16(Value[1]);

        for (ii = 2; ii < RegCount; ii ++)
                ((PUSB_SET_RF)pRegBuffer)->Data[ii - 2] = cpu_to_le16(Value[ii]);

        bufSize = sizeof(u16) * (1+RegCount);

        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_KERNEL)))
        {
                printk(KERN_ERR "zd1211: failed reg_urb\n");
                zd1211_DumpErrorCode(macp, ret);
                goto out;
        }

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

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


// return 0: success
int zd1211_USB_PACKAGE_READ_REGISTER(u16 *Address, u16 *pValue, u16 RegCount, u8 bAddUSBCSRAddress)
{
        struct zd1205_private *macp = g_dev->priv;
        u8 *pRegBuffer = NULL;
        int ret = 0;
        u16 size = sizeof(USB_READ_REG_REQ);
        u16 bufSize;
        int ii;
        //int memflags = GFP_KERNEL;

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

        if (in_interrupt()) {
#else

        if (in_atomic()) {
#endif
                printk(KERN_ERR "********zd1211_USB_PACKAGE_READ_REGISTER in_interrupt*********\n");
                return 0;
        }
        down(&macp->reg_sem);

        if ((RegCount == 0) || (!macp->bUSBDeveiceAttached) || (!test_bit(ZD1211_RUNNING, &macp->flags))) {
                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_READ_REG_REQ)pRegBuffer)->RequestID  = cpu_to_le16(REGID_READ);

        for (ii = 0; ii < RegCount; ii ++) {
                if ((Address[ii] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
                        Address[ii] = Address[ii] - USB_BASE_ADDR_HOST + macp->AddrEntryTable;
                else if ((Address[ii] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_EEPROM)
                        Address[ii] = ((Address[ii] - USB_BASE_ADDR_EEPROM) / 2) + cFIRMWARE_EEPROM_OFFSET;
                //0x9900                     //0xF817
                ((PUSB_READ_REG_REQ) pRegBuffer)->Address[ii] = cpu_to_le16(Address[ii]);
        }

        bufSize = sizeof(u16) * (1+RegCount);

        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 reg_urb\n");
                zd1211_DumpErrorCode(macp, ret);
                up(&macp->reg_sem);
                kfree(pRegBuffer);
                return ret;
        }

        //wait command complete
        macp->regWaitRCompCnt++;
        //printk(KERN_ERR "before wait 4\n");
        wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
        //printk(KERN_ERR "after wait 4\n");
        macp->regRWCompCnt++;

        clear_bit(ZD1211_CMD_FINISH, &macp->flags);
        kfree(pRegBuffer);

        if (ret != 0)
                goto out;

        //wait response complete
        macp->regWaitRspCnt++;

#if 0//(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))

        if (wait_event_interruptible_timeout(macp->iorwRsp_wait, test_bit(ZD1211_REQ_COMP, &macp->flags), HZ/2)) { //use it, we may can't wake up

                //interrupt by a signal
                memset(macp->IntEPBuffer, 0, MAX_EPINT_BUFFER);
                macp->regUnCompCnt++;
                ret = -ERESTARTSYS;
                goto out;
        } else
                macp->regRspCompCnt++;
#else
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))

        interruptible_sleep_on_timeout(&macp->iorwRsp_wait, 1); //magic delay
#else

        interruptible_sleep_on_timeout(&macp->iorwRsp_wait, 1); //magic delay
#endif

        //interruptible_sleep_on_timeout(&macp->iorwRsp_wait, HZ/40); //magic delay
        if (!test_bit(ZD1211_REQ_COMP, &macp->flags)) {
                //check if Rsp has completed, race condition may happen,
                macp->regRdSleepCnt++;
                //we waste time_out time
                //printk(KERN_ERR "before wait 2\n");
                interruptible_sleep_on_timeout(&macp->iorwRsp_wait, HZ/10);
                //wake up, check if timeout or ompleted

        }
        if (test_bit(ZD1211_REQ_COMP, &macp->flags))
                macp->regRspCompCnt++;
        else {
                memset(macp->IntEPBuffer, 0x0, MAX_EPINT_BUFFER);
                macp->regUnCompCnt++;
                ret = -1;
                goto out;
        }
#endif

        // Get data
        if ((macp->ReadRegCount == 0) || (macp->ReadRegCount > MAX_EPINT_BUFFER)) {
                ret = 1;
        } else {
                for (ii = 0; ii < (macp->ReadRegCount-2) / 4; ii++) {
                        pValue[ii] = cpu_to_le16(*((u16 *) macp->IntEPBuffer2 + 1 + ii * 2 + 1));
                }
                ret = 0;
        }

out:
        clear_bit(ZD1211_REQ_COMP, &macp->flags);
        up(&macp->reg_sem);
        return ret;
}

u32 zd1211_readl(u32 Address, u8 bAddUSBCSRAddress) {
        struct zd1205_private *macp = g_dev->priv;

        u16  ReadAddr[2];
        u16  ReadData[2];
        int bRet = 1;
        u32 value;
        int count = 0;

        if (bAddUSBCSRAddress) {
                Address += macp->USBCSRAddress;

                if ((Address & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
                        ReadAddr[1] = (u16) Address + 1;
                else
                        ReadAddr[1] = (u16) Address + 2;
        } else
                ReadAddr[1] = (u16) Address + 1;

        ReadAddr[0] = (u16) Address;    // Read Low Word first

        while (bRet != 0) {
                bRet = zd1211_USB_PACKAGE_READ_REGISTER(ReadAddr, ReadData, 2, false);
                count++;

                if (count > 5) {
                        printk(KERN_ERR "1211_readl failed for 5 attempts...Very Serious");
                        break;
                }
        }

        value = (((u32) ReadData[1]) << 16) + ReadData[0];
        return value;
}

//return 0: success
int zd1211_USB_PACKAGE_WRITE_REGISTER(u16 *Address, u16 *Value, u16 RegCount, u8 bAddUSBCSRAddress) {
        struct zd1205_private *macp = g_dev->priv;
        u8 *pRegBuffer = NULL;
        int ret;
        u16 size = sizeof(USB_WRITE_REG);
        u16 bufSize;
        int i;

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

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

        down(&macp->reg_sem);

        if ((RegCount == 0) || (!macp->bUSBDeveiceAttached) || !test_bit(ZD1211_RUNNING, &macp->flags)) {
                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_WRITE_REG)pRegBuffer)->RequestID	= cpu_to_le16(REGID_WRITE);

        if (RegCount > cMIN_MULTI_WRITE_REG_NUM) {
                for (i=cMIN_MULTI_WRITE_REG_NUM; i<RegCount; i++) {
                        if (bAddUSBCSRAddress)
                                Address[i] += macp->USBCSRAddress;

                        if ((Address[i] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
                                Address[i] = Address[i] - USB_BASE_ADDR_HOST + macp->AddrEntryTable;
                        else if ((Address[i] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_EEPROM)
                                Address[i] = ((Address[i] - USB_BASE_ADDR_EEPROM) / 2) + cFIRMWARE_EEPROM_OFFSET;