zd1211.c

ZYDAS zd1211b driver for Linux2.4

/* src/zd1211.c
*
*                                            
*
* Copyright (C) 2004 ZyDAS Inc.  All Rights Reserved.
* --------------------------------------------------------------------
*
*
*
*   The contents of this file are subject to the Mozilla Public
*   License Version 1.1 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.mozilla.org/MPL/
*
*   Software distributed under the License is distributed on an "AS
*   IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*   implied. See the License for the specific language governing
*   rights and limitations under the License.
*
*   Alternatively, the contents of this file may be used under the
*   terms of the GNU Public License version 2 (the "GPL"), in which
*   case the provisions of the GPL are applicable instead of the
*   above.  If you wish to allow the use of your version of this file
*   only under the terms of the GPL and not to allow others to use
*   your version of this file under the MPL, indicate your decision
*   by deleting the provisions above and replace them with the notice
*   and other provisions required by the GPL.  If you do not delete
*   the provisions above, a recipient may use your version of this
*   file under either the MPL or the GPL.
*
* -------------------------------------------------------------------- */

#include <linux/config.h>
#include <net/checksum.h>
#include <linux/tcp.h>
#include <linux/udp.h>


#include "zddebug.h"
#include "zdhw.h"
#include "zd1211.h"
#include "zdcompat.h"

u8 WS11UPh[]
#if fMERGE_RX_FRAME
	#include "WS11UPhR.h"
u8 WS11UPhm[]
#include "WS11UPhm.h"
#else
    #include "WS11UPhm.h"
#endif

u8 WS11Ur[]
#include "WS11Ur.h"

u8 WS11Ub[]
#include "WS11Ub.h"


u8 WS11Ur2[(0xEE00 - 0xEC00) * 2] = { 0x0F, 0x9F, 0x00, 0xEE };  // JMP 0xEE00


extern zd_80211Obj_t dot11Obj;
extern struct net_device *g_dev;

/* ath_desc: use usb_kill_urb() instead of usb_unlink_urb() in 2.6.8+ */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8)
#  define ZD_USB_KILL_URB(u)       usb_kill_urb(u)
#else
#  define ZD_USB_KILL_URB(u)       usb_unlink_urb(u)
#endif

/* ath_desc: URB_ASYNC_UNLINK has been removed in Linux 2.6.14 */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
#  define URB_ASYNC_UNLINK 0
#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) /* tune me! */
#  define SUBMIT_URB(u,f)       usb_submit_urb(u,f)
#  define USB_ALLOC_URB(u,f)    usb_alloc_urb(u,f)
#else
#  define SUBMIT_URB(u,f)       usb_submit_urb(u)
#  define USB_ALLOC_URB(u,f)    usb_alloc_urb(u)
#endif


inline void zd1211_DumpErrorCode(struct zd1205_private *macp, int err)
{
        switch (err)
        {
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
        case USB_ST_CRC:
                ZD1211DEBUG(0, "USB_ST_CRC\n");
                break;

                //case USB_ST_BITSTUFF:
                //ZD1211DEBUG(0, "USB_ST_BITSTUFF\n");
                //break;

                //case USB_ST_NORESPONSE:
                //ZD1211DEBUG(0, "USB_ST_NORESPONSE\n");
                //break;

        case USB_ST_DATAOVERRUN:
                ZD1211DEBUG(0, "USB_ST_DATAOVERRUN\n");
                break;

        case USB_ST_DATAUNDERRUN:
                ZD1211DEBUG(0, "USB_ST_DATAUNDERRUN\n");
                break;

        case USB_ST_BUFFEROVERRUN:
                ZD1211DEBUG(0, "USB_ST_BUFFEROVERRUN\n");
                break;

        case USB_ST_BUFFERUNDERRUN:
                ZD1211DEBUG(0, "USB_ST_BUFFERUNDERRUN\n");
                break;

        case USB_ST_INTERNALERROR:
                ZD1211DEBUG(0, "USB_ST_INTERNALERROR\n");
                break;

                //case USB_ST_SHORT_PACKET:
                //ZD1211DEBUG(0, "USB_ST_SHORT_PACKET\n");
                //break;

        case USB_ST_PARTIAL_ERROR:
                ZD1211DEBUG(0, "USB_ST_PARTIAL_ERROR\n");
                break;

        case USB_ST_URB_KILLED:
                ZD1211DEBUG(0, "USB_ST_URB_KILLED\n");
                break;

        case USB_ST_URB_PENDING:
                ZD1211DEBUG(0, "USB_ST_URB_PENDING\n");
                break;

        case USB_ST_REMOVED:
                ZD1211DEBUG(0, "USB_ST_REMOVED\n");
                break;

        case USB_ST_TIMEOUT:
                ZD1211DEBUG(0, "USB_ST_TIMEOUT\n");
                break;

        case USB_ST_NOTSUPPORTED:
                ZD1211DEBUG(0, "USB_ST_NOTSUPPORTED\n");
                break;





        case USB_ST_BANDWIDTH_ERROR:
                ZD1211DEBUG(0, "USB_ST_BANDWIDTH_ERROR\n");
                break;

        case USB_ST_URB_INVALID_ERROR:
                ZD1211DEBUG(0, "USB_ST_URB_INVALID_ERROR\n");
                break;

        case USB_ST_URB_REQUEST_ERROR:
                ZD1211DEBUG(0, "USB_ST_URB_REQUEST_ERROR\n");
                break;

        case USB_ST_STALL:
                ZD1211DEBUG(0, "USB_ST_STALL\n");
                break;

        case -ENOMEM:
                ZD1211DEBUG(0, "ENOMEM\n");
                break;
#endif

        default:
                ZD1211DEBUG(0, "USB ST Code = %d\n",err);

                break;
        }
        /* ath_desc: reenable iwpriv dbg_flag */
        /* ath_old: macp->dbg_flag=0; */
        /* do not reset dbg_flag on USB error */

}


void zd1211_DumpReadMultipleReg(struct zd1205_private *macp, u16 adr0)
{
        u16  ReadAddr[cMAX_MULTI_READ_REG_NUM];
        u16  ReadData[cMAX_MULTI_READ_REG_NUM];
        u16  ReadIndex = 0;

        FPRINT_V("adr0", adr0);

        for (ReadIndex = 0; ReadIndex < cMAX_MULTI_READ_REG_NUM;)



                mFILL_READ_REGISTER(adr0++);

        zd1211_USB_PACKAGE_READ_REGISTER(ReadAddr, ReadData, ReadIndex, false);

        for (ReadIndex = 0; ReadIndex < 8; ReadIndex ++)
                printk("%04X, ", ReadData[ReadIndex]);

        printk("\n");
        printk("      ");

        for (; ReadIndex < cMAX_MULTI_READ_REG_NUM; ReadIndex ++)
                printk("%04X, ", ReadData[ReadIndex]);
        printk("\n");
}



// len0: in word, adr: word offset
void zd1211_WriteEEPROM(struct zd1205_private *macp, u16 rom_adr, u16 ram_adr, u16 len0)
{
        u32  tmpvalue;
        u16  WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
        u16  WriteData[cMAX_MULTI_WRITE_REG_NUM];
        u16  WriteIndex = 0;

        tmpvalue = zd1211_readl(ZD1211_CLOCK_CTRL, false);
        mFILL_WRITE_REGISTER(ZD1211_CLOCK_CTRL, mSET_BIT((u16) tmpvalue, bZD1211_CLOCK_EEPROM));
        mFILL_WRITE_REGISTER(UMAC_EPROM_ROM_ADDR, rom_adr);
        mFILL_WRITE_REGISTER(UMAC_EPROM_RAM_ADDR, ram_adr);
        mFILL_WRITE_REGISTER(UMAC_EPROM_DMA_LEN_DIR, bmEPROM_XFER_DIR | len0);
        mFILL_WRITE_REGISTER(ZD1211_CLOCK_CTRL, mCLR_BIT((u16) tmpvalue, bZD1211_CLOCK_EEPROM));
        zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
}


#if fMERGE_RX_FRAME
int zd1211_ChangeToFlashAble(struct zd1205_private *macp)
{
        u32 tmpvalue;

        if (!macp->bFlashable)
        {
                int	LoadRet;

                zd_writel(0x01, FW_SOFT_RESET);

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

                macp->bAllowAccessRegister = 0;

                LoadRet = zd1211_LoadUSBSpecCode(macp, WS11UPhm, sizeof(WS11UPhm),
                                                 cFIRMWARE_START_ADDR, true);
                if (LoadRet) {
                        FPRINT("Load WS11UPhm fail");
                        return 1;
                }

                ZD1211DEBUG(0, "Load WS11UPhm Done\n");

                //macp->bAllowAccessRegister = 1;
                macp->bFlashable = 1;

#if fWRITE_WORD_REG || fREAD_MUL_REG
                // Must get this information before any register write
                tmpvalue = zd1211_readl(cADDR_ENTRY_TABLE, FALSE);
                macp->AddrEntryTable = (u16) tmpvalue;
#endif

        }

        return 0;
}
#endif


int zd1211_UpdateBootCode(struct zd1205_private *macp, u16 *pCheckSum, u16 *pEEPROMData,
                          u32 EEPROMLen)
{
        u32 i;
        //int ret;
        u16  WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
        u16  WriteData[cMAX_MULTI_WRITE_REG_NUM];
        u16  WriteIndex = 0;
        u16  ROMBufAdr = cBOOTCODE_START_ADDR;

        ZD1211DEBUG(0, "UpdateBootCode\n");

        for (i=0; i<EEPROMLen; i+=(2*WRITE_WORD_TO_EEPROM_PER_TIME))
        {
                for (WriteIndex=0; WriteIndex<WRITE_WORD_TO_EEPROM_PER_TIME/2; ) {
                        u16 WriteValue;
                        if (ROMBufAdr >= cINT_VECT_ADDR) {
                                FPRINT("Exceed max address");
                                break;
                        }
                        /* ath: fixed ambiguous statement */
                        WriteValue = pEEPROMData[WriteIndex * 2] | (pEEPROMData[WriteIndex * 2 + 1] << 8);
                        mFILL_WRITE_REGISTER(ROMBufAdr ++, WriteValue);
                }

                if (WriteIndex)
                        zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);

                if (ROMBufAdr >= cINT_VECT_ADDR) {
                        FPRINT("Exceed max address1");
                        return 0;
                }

                pEEPROMData += WRITE_WORD_TO_EEPROM_PER_TIME;
        }

        if (EEPROMLen % (2*WRITE_WORD_TO_EEPROM_PER_TIME))
        {
                for (WriteIndex = 0; WriteIndex < (EEPROMLen % (2 * WRITE_WORD_TO_EEPROM_PER_TIME)) / 2;) {
                        u16 WriteValue;
                        if (ROMBufAdr >= cINT_VECT_ADDR) {
                                FPRINT("Exceed max address2");
                                break;
                        }
                        /* ath: fixed ambiguous statement */
                        WriteValue = pEEPROMData[WriteIndex * 2] | (pEEPROMData[WriteIndex * 2 + 1] << 8);
                        mFILL_WRITE_REGISTER(ROMBufAdr ++, WriteValue);
                                             
                }

                if (WriteIndex)
                        zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
        }

        return 0;
}




int zd1211_USB_Write_EEPROM(struct zd1205_private *macp, u16 *pEEPROMData, u32 EEPROMLen) //in bytes
{
        u16 CheckSum = 0;
        int ret;

        ZD1211DEBUG(0, "USB_Write_EEPROM\n");

        macp->bDisableTx = 1;

        //USB_StopTxEP(macp);

        ret = zd1211_UpdateBootCode(macp, &CheckSum, pEEPROMData, EEPROMLen);
        if (ret != 0)
                return ret;

        zd1211_WriteEEPROM(macp, 0, cBOOTCODE_START_ADDR, cEEPROM_SIZE - cLOAD_VECT_LEN);
        //macp->bDisableTx = 0;