zdreq.c

zd1211b芯片的无线网卡的驱动,移植到s3c2410平台

    U8 macmode;
    int i;

    ZDPRODUCTDBG("****** ZD1205EM_Custom_QueryInformation ******\r\n");

/* DUMP InformationBuffer */
#if 0
    {
        int ii;
        UCHAR *p = (UCHAR *) InformationBuffer;

        for(ii = 0; ii < InformationBufferLength;)
        {
            ZDPRODUCTDBG("0x%02x ", p[ii]);

            if ((++ii % 16) == 0)
                ZDPRODUCTDBG("\n");
        }

    }
#endif

    Status = NDIS_STATUS_SUCCESS;

    switch(Oid)
    {
        case OID_GEN_MEDIA_CONNECT_STATUS:
            printk(KERN_ERR "OID_GEN_MEDIA_CONNECT_STATUS\n");
//if (macp->adapterReady == TRUE)
            GenericUlong = cpu_to_le32(NdisMediaStateConnected);
//else
//	GenericUlong = NdisMediaStateDisconnected;

            memcpy(InformationBuffer, &GenericUlong, sizeof(GenericUlong));
            *BytesWritten = sizeof(GenericUlong);
            *BytesNeeded = 0;
            Status = NDIS_STATUS_SUCCESS;
            break;

        case OID_GEN_DRIVER_VERSION:
            ZDPRODUCTDBG("OID_GEN_DRIVER_VERSION\r\n");

            GenericUlong = cpu_to_le32(ZD1205_DRIVER_VERSION);
            memcpy(InformationBuffer, &GenericUlong, sizeof(GenericUlong));
            *BytesWritten = sizeof(GenericUlong);
            *BytesNeeded = 0;
            Status = NDIS_STATUS_SUCCESS;
            break;

        case OID_802_11_DESIRED_RATES:
            ZDPRODUCTDBG("OID_802_11_DESIRED_RATES\r\n");

            if (InformationBuffer == 0 || ((UINT)InformationBufferLength < macp->AllowRateArrayCount))
            {
                Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                *BytesWritten = 0;
                *BytesNeeded = macp->AllowRateArrayCount;
                break;
            }

            ZDPRODUCTDBG("OID_802_11_DESIRED_RATES %d\r\n", macp->cardSetting.FixedRate);

//for(i = 0; i < macp->AllowRateArrayCount; i++){
            *((PUCHAR)InformationBuffer) = Rate_Convert_to_MS(macp->cardSetting.FixedRate);
//}

// need to check
            *BytesWritten = macp->AllowRateArrayCount;
//*BytesWritten = 1;
            *BytesNeeded = 0;
            Status = NDIS_STATUS_SUCCESS;
            break;

        case OID_802_11_CONFIGURATION:
        case OID_ZDX_802_11_CONFIGURATION:
            ZDPRODUCTDBG("OID_802_11_CONFIGURATION\r\n");
            if (InformationBuffer == NULL ||
                (InformationBufferLength < sizeof(NDIS_802_11_CONFIGURATION)))
            {
                Status = NDIS_STATUS_BUFFER_TOO_SHORT;

                *BytesWritten = 0;
                *BytesNeeded = sizeof(NDIS_802_11_CONFIGURATION);
                break;
            }

            pConfiguration = (PNDIS_802_11_CONFIGURATION)InformationBuffer;
            pConfiguration->Length = cpu_to_le32(sizeof(NDIS_802_11_CONFIGURATION));
            pConfiguration->BeaconPeriod = cpu_to_le32(macp->cardSetting.BeaconInterval);
            pConfiguration->ATIMWindow = cpu_to_le32(macp->cardSetting.ATIMWindow);
            pConfiguration->DSConfig = cpu_to_le32((2412+(macp->cardSetting.Channel-1)*5)*1000);

            if (macp->cardSetting.Channel == 14)
                pConfiguration->DSConfig = cpu_to_le32(2484000);
#ifdef ZDCONF_80211A_SUPPORT
            if(mMacMode == PURE_A_MODE)
                pConfiguration->DSConfig = channel_11A_to_Freq(macp->cardSetting.Channel)*1000;
#endif
            *BytesWritten = sizeof(NDIS_802_11_CONFIGURATION);
            *BytesNeeded = 0;
            return NDIS_STATUS_SUCCESS;

        case OID_802_11_INFRASTRUCTURE_MODE:
        case OID_ZDX_802_11_INFRASTRUCTURE_MODE:
            ZDPRODUCTDBG("OID_802_11_INFRASTRUCTURE_MODE\r\n");

            macmode = macp->cardSetting.BssType;
            switch(macmode)
            {
                case INDEPENDENT_BSS:
                    GenericUlong = cpu_to_le32(Ndis802_11IBSS);
                    break;

                case INFRASTRUCTURE_BSS:
                    GenericUlong = cpu_to_le32(Ndis802_11Infrastructure);
                    break;

                case AP_BSS:
                    GenericUlong = cpu_to_le32(AP_BSS);
                    break;

                case PSEUDO_IBSS:
                    GenericUlong = cpu_to_le32(PSEUDO_IBSS);
                    break;
            }

            memcpy(InformationBuffer, &GenericUlong, sizeof(GenericUlong));
            *BytesWritten = sizeof(GenericUlong);
            *BytesNeeded = 0;
            Status = NDIS_STATUS_SUCCESS;
            break;

        case OID_ZDX_802_11_SSID:
        case OID_802_11_NETWORK_TYPE_IN_USE:
            ZDPRODUCTDBG("OID_ZDX_802_11_SSID\r\n");

// 11G
            GenericUlong = cpu_to_le32(Ndis802_11OFDM24);

            memcpy(InformationBuffer, &GenericUlong, sizeof(GenericUlong));
            *BytesWritten = sizeof(GenericUlong);
            *BytesNeeded = 0;
            Status = NDIS_STATUS_SUCCESS;
            break;
    case OID_802_3_CURRENT_ADDRESS:
        ZDPRODUCTDBG("OID_802_3_CURRENT_ADDRESS\n");
        GenericUlong = zd_readl(E2P_MACADDR_P1);
        ((u8 *)InformationBuffer)[0]= (u8)GenericUlong ;
        ((u8 *)InformationBuffer)[1]= (u8)(GenericUlong >>  8);
        ((u8 *)InformationBuffer)[2]= (u8)(GenericUlong >> 16);
        ((u8 *)InformationBuffer)[3]= (u8)(GenericUlong >> 24);

        GenericUlong= zd_readl(E2P_MACADDR_P2);
        ((u8 *)InformationBuffer)[4]= (u8)GenericUlong ;
        ((u8 *)InformationBuffer)[5]= (u8)(GenericUlong >>  8);

        *BytesWritten = ETH_ALEN;
        *BytesNeeded = 0;
        Status = NDIS_STATUS_SUCCESS;
        break;

        case OID_ZD_RD:
            ZDPRODUCTDBG("OID_ZD_RD\r\n");

            if (InformationBufferLength < sizeof(ZD_RD_STRUCT)-4)
            {
                ZDPRODUCTDBG("OID_ZD_RD: NDIS_STATUS_BUFFER_TOO_SHORT,%d,%d\r\n",InformationBufferLength,sizeof(ZD_RD_STRUCT));
                *BytesNeeded = sizeof(ZD_RD_STRUCT);
                *BytesWritten = 0;
                Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                break;
            }

            pZDRD = (PZD_RD_STRUCT)InformationBuffer;

            switch (le32_to_cpu(pZDRD->ZDRdFuncId))
            {
                case ZDAccessPHYRegister1B:
                    ZDPRODUCTDBG("ZDAccessPHYRegister1B\r\n");

                    if (le32_to_cpu(pZDRD->ZDRdLength) < sizeof(ZD_RD_STRUCT))
                    {
                        ZDPRODUCTDBG("ZDAccessPHYRegister1B: NDIS_STATUS_BUFFER_TOO_SHORT\r\n");
                        pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
                        *BytesNeeded = sizeof(ZD_RD_STRUCT);
                        *BytesWritten = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        break;
                    }

// Write PHY registers
                    LockPhyReg(&dot11Obj);

/* Remap some special PHY registers */
                    switch(le32_to_cpu(pZDRD->Buffer[0]))
                    {
                        case 4:                   //CR4
                            IoAddress = 0x20;
                            break;
                        case 5:                   //CR5
                            IoAddress = 0x10;
                            break;
                        case 6:                   //CR6
                            IoAddress = 0x14;
                            break;
                        case 7:                   //CR7
                            IoAddress = 0x18;
                            break;
                        case 8:                   //CR8
                            IoAddress = 0x1C;
                            break;
                        case 132:                 //CR132
                            IoAddress = 0x0210;

                        default:
                            IoAddress = le32_to_cpu(pZDRD->Buffer[0]) << 2;
                            break;
                    }
//if (!NeedReadProtection(Adapter, IoAddress, &(pZDRD->Buffer[1]))){
                    pZDRD->Buffer[1] = dot11Obj.GetReg(reg, IoAddress);
//}

                    pZDRD->Buffer[1] &= 0xFFFF;
                    ZDPRODUCTDBG("Read Phy Reg (0x%x) = %x\r\n", IoAddress, pZDRD->Buffer[1]);
                    UnLockPhyReg(&dot11Obj);

                    pZDRD->Buffer[1] = cpu_to_le32(pZDRD->Buffer[1]);
                    pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
                    *BytesWritten = sizeof(ZD_RD_STRUCT);
                    *BytesNeeded = 0;
                    Status = NDIS_STATUS_SUCCESS;

                    break;

                case ZDAccessMACRegister4B:
                    ZDPRODUCTDBG("ZDAccessMACRegister4B\r\n");

                    if (le32_to_cpu(pZDRD->ZDRdLength) < (sizeof(ZD_RD_STRUCT)))
                    {
                        ZDPRODUCTDBG("ZDAccessMACRegister4B: NDIS_STATUS_BUFFER_TOO_SHORT\r\n");
                        pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
                        *BytesNeeded = sizeof(ZD_RD_STRUCT);
                        *BytesWritten = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        break;
                    }

                    if (le32_to_cpu(pZDRD->Buffer[0]) < 0x1000)
                    {
                        pZDRD->Buffer[1] = cpu_to_le32(dot11Obj.GetReg(reg, le32_to_cpu(pZDRD->Buffer[0])));
                    }
//else if (!NeedReadProtection(Adapter, pZDRD->Buffer[0], &(pZDRD->Buffer[1]))){
//pZDRD->Buffer[1] = dot11Obj.GetReg(reg, pZDRD->Buffer[0]);
                    else
                        pZDRD->Buffer[1] = 0;

                    pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
                    *BytesWritten = sizeof(ZD_RD_STRUCT);
                    *BytesNeeded = 0;
                    Status = NDIS_STATUS_SUCCESS;
                    break;
                case ZDAccessROMData:

                    ZDPRODUCTDBG("ZDAccessROM read\r\n");

                    if (le32_to_cpu(pZDRD->ZDRdLength) < (sizeof(ZD_RD_STRUCT) + 4))
                    {
                        pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT) + 4);
                        *BytesNeeded = (sizeof(ZD_RD_STRUCT) + 4);
                        *BytesWritten = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        break;
                    }

                    {
                        int ReadLength = le32_to_cpu(pZDRD->Buffer[1]);
//int ReadOffset = le32_to_cpu(pZDRD->Buffer[0]);
                        PUCHAR pDataPtr = (PUCHAR)(pZDRD+1);
                        ULONG tmpULONG;
                        PUCHAR pTmpBuffer = 0, pOldTmpBuffer;

/* Update the total EEPROM content */
                        //ORIGION NOT MARK
                        //RamAddr is 2nd argument, it differs from Win
                        HW_EEPROM_ACCESS(&dot11Obj, cFIRMWARE_EEPROM_OFFSET, cEPDATA_OFFSET, (E2P_END-E2P_SUBID)/2, 0);
						//ZD1205_WriteE2P(&dot11Obj);

                        pTmpBuffer = kmalloc(E2P_END - E2P_SUBID+1, GFP_ATOMIC);

                        if (!pTmpBuffer)
                        {
                            Status = NDIS_STATUS_RESOURCES;
                            break;
                        }

                        pOldTmpBuffer = pTmpBuffer;

                        for (i = E2P_SUBID; i < E2P_END; i += 4)
                        {
                            tmpULONG = dot11Obj.GetReg(reg, i);
                            *pTmpBuffer = (UCHAR)(tmpULONG & 0xFF);
                            pTmpBuffer++;
                            *pTmpBuffer = (UCHAR)((tmpULONG >> 8) & 0xFF);
                            pTmpBuffer++;
                            *pTmpBuffer = (UCHAR)((tmpULONG >> 16) & 0xFF);
                            pTmpBuffer++;
                            *pTmpBuffer = (UCHAR)((tmpULONG >> 24) & 0xFF);
                            pTmpBuffer++;
                        }

                        memcpy(pDataPtr, pOldTmpBuffer, (E2P_END - E2P_SUBID + 1) );
                        kfree(pOldTmpBuffer);
                        *BytesWritten = sizeof(ZD_RD_STRUCT) + ReadLength;
                        *BytesNeeded = 0;
                        Status = NDIS_STATUS_SUCCESS;
                    }

                    break;

                case ZDGetNICAdapterTally:
                    ZDPRODUCTDBG("ZDGetNICAdapterTally\r\n");

//ZD_RD_STRUCT contain one ULONG
                    if (le32_to_cpu(pZDRD->ZDRdLength) < (sizeof(ZD_RD_STRUCT) + sizeof(ULONG)*36))
                    {
                        pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT) + sizeof(ULONG)*36);
                        *BytesNeeded = (sizeof(ZD_RD_STRUCT) + sizeof(ULONG)*37);
                        *BytesWritten = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        ZDPRODUCTDBG("ZDGetNICAdapterTally BUFFER_TOO_SHORT\r\n");
                        break;
                    }

                    zd1205_CollectHwTally(macp);

//txUnicastFrames
                    pZDRD->Buffer[0] = cpu_to_le32(macp->txUnicastFrm);
//txMulticastFrames
                    pZDRD->Buffer[1] = cpu_to_le32(macp->txMulticastFrm);
//txUniOctets  byte size
                    pZDRD->Buffer[2] = cpu_to_le32(macp->txUnicastOctets);
//txMultiOctets  byte size
                    pZDRD->Buffer[3] = cpu_to_le32(macp->txMulticastOctets);
                    pZDRD->Buffer[4] = 0;         //txFrmUpperNDIS
//txFrmDrvMgt
                    pZDRD->Buffer[5] = cpu_to_le32(macp->txFrmDrvMgt);