zdreq.c

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

                    macp->cardSetting.Channel = 14;
                    HW_SwitchChannel(&dot11Obj, 14, 1,1);
                }
                else
                {
//macp->SaveChannel = (U8) ChannelNo;
                    macp->cardSetting.Channel = ChannelNo;
                    if(pConfiguration->DSConfig/1000> 4000)
                    {
                        if(mMacMode != PURE_A_MODE)
                        {
							mMacMode = PURE_A_MODE;
                            ChangeMacMode( PURE_A_MODE, ChannelNo);
                            HW_SwitchChannel(&dot11Obj, ChannelNo, 1,PURE_A_MODE);
                        }
                        else 
                        {
                            //For update iwconfig information only
                            ChangeMacMode(PURE_A_MODE, ChannelNo);     
                            HW_SwitchChannel(&dot11Obj, ChannelNo, 1,PURE_A_MODE);
                        }
                    }
                    else
                    {
                        if(mMacMode == PURE_A_MODE)
                        {
							mMacMode = MIXED_MODE;
                            ChangeMacMode(MIXED_MODE, ChannelNo);
                            HW_SwitchChannel(&dot11Obj, ChannelNo, 1,MIXED_MODE);
                        }
                        else
                        {
                            //For update iwconfig information only
                            ChangeMacMode(MIXED_MODE, ChannelNo);
                            HW_SwitchChannel(&dot11Obj, ChannelNo, 1,MIXED_MODE);
                        }
                    }
                }
/* Reset the Integration value */
				if(pConfiguration->DSConfig/1000 < 4000)
                IntValue = dot11Obj.IntValue[ChannelNo-1];
#ifdef ZDCONF_80211A_SUPPORT
                if(pConfiguration->DSConfig/1000>4000)
                {
                    u8 useless;
                    if(0xff == a_OSC_get_cal_int(ChannelNo, RATE_1M, &IntValue, &useless))
						printk("Read a_OSC_get_cal_int fail\n");;
					IntValue=20; //When Initial value is too larget. The Pwr Meter will be down
                }
#endif
                dot11Obj.TxGainSetting = IntValue;
                dot11Obj.TxGainSetting2 = IntValue;

                LockPhyReg(&dot11Obj);
                dot11Obj.SetReg(reg, IntValue, ZD_CR31);
//reg->CR31 = IntValue[ChannelNo-1];
                UnLockPhyReg(&dot11Obj);
            }

            Status = NDIS_STATUS_SUCCESS;
            break;

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

            if (InformationBuffer == NULL)
            {
                Status = (NDIS_STATUS_INVALID_LENGTH);
                break;
            }

            switch(le32_to_cpu(*(PULONG)InformationBuffer))
            {
                case Ndis802_11IBSS:
                    ZDPRODUCTDBG("Ndis802_11IBSS\r\n");
                    macp->cardSetting.BssType = INDEPENDENT_BSS;
                    zd_writel(STA_RX_FILTER, Rx_Filter);
                    break;
                case Ndis802_11Infrastructure:
                case Ndis802_11AutoUnknown:
                    ZDPRODUCTDBG("Ndis802_11Infrastructure\r\n");
                    macp->cardSetting.BssType = INFRASTRUCTURE_BSS;
                    macp->cardSetting.AuthMode = 0;
                    zd_writel(STA_RX_FILTER, Rx_Filter);
                    break;
                case AP_BSS:
                    ZDPRODUCTDBG("AP_BSS\r\n");
                    macp->cardSetting.BssType = AP_BSS;
/* Set bssid = MacAddress */
                    macp->BSSID[0] = macp->macAdr[0];
                    macp->BSSID[1] = macp->macAdr[1];
                    macp->BSSID[2] = macp->macAdr[2];
                    macp->BSSID[3] = macp->macAdr[3];
                    macp->BSSID[4] = macp->macAdr[4];
                    macp->BSSID[5] = macp->macAdr[5];

                    zd_writel(cpu_to_le32(*(u32 *)&macp->macAdr[0]), BSSID_P1);
                    zd_writel(cpu_to_le32(*(u32 *)&macp->macAdr[4]), BSSID_P2);
                    macp->cardSetting.AuthMode = 2;//auto auth
                    break;
                default:
                    ZDPRODUCTDBG("PSEUDO_IBSS\r\n");
                    macp->cardSetting.BssType = PSEUDO_IBSS;
                    macp->bPseudoIBSSMode = 1;
/* Disable beacon */
//GenericUlong = reg->BCNInterval;
                    GenericUlong = dot11Obj.GetReg(reg, BCNInterval);
                    GenericUlong &= ~BIT_24;
                    GenericUlong &= ~BIT_25;
                    dot11Obj.SetReg(reg, GenericUlong, BCNInterval);
                    dot11Obj.SetReg(reg, 0, Rx_Filter);
//reg->BCNInterval = GenericUlong;
//zd_writel(STA_RX_FILTER, Rx_Filter);
//reg->Rx_Filter = 0;
                    break;
            }

            zd_UpdateCardSetting(&macp->cardSetting);
            Status = NDIS_STATUS_SUCCESS;
            break;

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

            if (InformationBufferLength < sizeof(NDIS_802_11_SSID))
            {
                Status = (NDIS_STATUS_INVALID_LENGTH);
                break;
            }

            pSSID = (PNDIS_802_11_SSID)InformationBuffer;
            SSIDLen = le32_to_cpu(pSSID->SsidLength);

            if (SSIDLen > 32)
            {
                SSIDLen = 32;
            }

            zd1205_lock(macp);
            memcpy(&macp->cardSetting.Info_SSID[2], pSSID->Ssid, SSIDLen);
            macp->cardSetting.Info_SSID[1] = SSIDLen;
            zd1205_unlock(macp);

            Status = NDIS_STATUS_SUCCESS;
            break;

        case OID_802_11_NETWORK_TYPE_IN_USE:
            printk(KERN_ERR "OID_802_11_NETWORK_TYPE_IN_USE\n");

            //Status = NDIS_STATUS_NOT_SUPPORTED;
            //Linux doesn't have NETWORK_TYPE_IN_USE variable
            //But we need to reture a success result to GoGo
            Status = NDIS_STATUS_SUCCESS;
            break;

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

            if (le32_to_cpu(InformationBufferLength) < sizeof(ZD_RD_STRUCT)-4)
            {
                *BytesNeeded = sizeof(ZD_RD_STRUCT);
                *BytesRead = 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))
                    {
                        pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
                        *BytesNeeded = (sizeof(ZD_RD_STRUCT) + sizeof(ULONG));
                        *BytesRead = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        break;
                    }

// Write PHY registers
                    LockPhyReg(&dot11Obj);

                    switch(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 (!NeedWriteProtection(Adapter, IoAddress, pZDRD->Buffer[1])){
                    dot11Obj.SetReg(reg, IoAddress, le32_to_cpu(pZDRD->Buffer[1]));
//}

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

                    *BytesRead = sizeof(ZD_RD_STRUCT);

                    break;

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

                    if (le32_to_cpu(pZDRD->ZDRdLength) < sizeof(ZD_RD_STRUCT))
                    {
                        pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
                        *BytesNeeded = sizeof(ZD_RD_STRUCT);
                        *BytesRead = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        break;
                    }
                    if (le32_to_cpu(pZDRD->Buffer[0]) < 0x1000)
                    {
                        dot11Obj.SetReg(reg, le32_to_cpu(pZDRD->Buffer[0]), le32_to_cpu(pZDRD->Buffer[1]));
                    }
//else if (!NeedWriteProtection(Adapter, pZDRD->Buffer[0], pZDRD->Buffer[1])){
//	dot11Obj.SetReg(reg, pZDRD->Buffer[0], (pZDRD->Buffer[1]));
//}

                    *BytesRead = sizeof(ZD_RD_STRUCT);
                    break;
                case ZDAccessROMData:
                    ZDPRODUCTDBG("ZDAccessROM Write\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);
                        *BytesRead = 0;
                        Status = NDIS_STATUS_BUFFER_TOO_SHORT;
                        break;
                    }
                    {
                        int i;
                        int WriteLength = le32_to_cpu(pZDRD->Buffer[1]);
                        int WriteOffset = le32_to_cpu(pZDRD->Buffer[0]);
                        PUCHAR  pDataPtr = (PUCHAR) (pZDRD+1);
                        ULONG   tmpULONG;
                        PUCHAR  pTmpBuffer = 0, pOldTmpBuffer;

                        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++;
                        }

                        pTmpBuffer = pOldTmpBuffer;

                        if ((WriteOffset+WriteLength) <= (E2P_END - E2P_SUBID+1))
                            memcpy(pTmpBuffer+WriteOffset, pDataPtr, WriteLength);
                        else
                            Status = NDIS_STATUS_INVALID_LENGTH;

                        for (i = E2P_SUBID; i <= E2P_END; i += 4)
                        {
                            tmpULONG = *pTmpBuffer;
                            pTmpBuffer++;
                            tmpULONG |= ((ULONG)(*pTmpBuffer)) << 8;
                            pTmpBuffer++;
                            tmpULONG |= ((ULONG)(*pTmpBuffer)) << 16;
                            pTmpBuffer++;
                            tmpULONG |= ((ULONG)(*pTmpBuffer)) << 24;
                            pTmpBuffer++;

                            dot11Obj.SetReg(reg, i, tmpULONG);
                            dot11Obj.DelayUs(10);
                            ZDPRODUCTDBG("Write 0x%x with 0x%x\n", i, tmpULONG);
                        }

/* Update the total EEPROM content */
                        //RamAddr is 2nd argument, it differs from Win
                        HW_EEPROM_ACCESS(&dot11Obj, cFIRMWARE_EEPROM_OFFSET, cEPDATA_OFFSET, (E2P_END-E2P_SUBID)/2, 1);
						//ZD1205_WriteE2P(&dot11Obj);
                        kfree(pOldTmpBuffer);
                    }
                    break;
                case ZDROMUpdate:

                    ZDPRODUCTDBG("ZDROMUpdate Write\r\n");
                    {
                        int i;
                        PUCHAR pImage = (PUCHAR)pZDRD->Buffer;
                        USHORT ImageLen = (USHORT)le32_to_cpu(pZDRD->ZDRdLength)-sizeof(ZD_RD_STRUCT)+8;
                        PUCHAR pBuffer;
                        ULONG tmpULONG;

                        pBuffer = pImage;

                        if (ImageLen > EEPROM_SIZE)
                        {
                            Status = NDIS_STATUS_INVALID_LENGTH;
                            ZDPRODUCTDBG("ImageLen>EEPROM_SIZE in ZDROMUpdate Write\n");
                            ZDPRODUCTDBG("ImageLen:%d,EEPROM_SIZE:%d\n",ImageLen,EEPROM_SIZE);
                            break;
                        }

                        for (i = E2P_SUBID; i <= E2P_END; i += 4)
                        {
                            tmpULONG = *pBuffer;
                            pBuffer++;
                            tmpULONG |= ((ULONG)(*pBuffer)) << 8;
                            pBuffer++;
                            tmpULONG |= ((ULONG)(*pBuffer)) << 16;
                            pBuffer++;
                            tmpULONG |= ((ULONG)(*pBuffer)) << 24;
                            pBuffer++;

                            dot11Obj.SetReg(reg, i, tmpULONG);
                            dot11Obj.DelayUs(10);