zd1205.c

ZYDAS zd1211b driver for Linux2.4

        u8 *pByte;
        u32 currPos = 0;
        u8 elemId, elemLen;

        if ((*(pMacBody+CAP_OFFSET)) & BIT_1) //IBSS
                pBssid = pWlanHdr->Address3;
        else
                pBssid = pWlanHdr->Address2;

        for (i=0; i<macp->bss_index; i++)
        {
                for (j=0; j<6; j++) {
                        if (macp->BSSInfo[i].bssid[j] != pBssid[j]) {
                                break;
                        }
                }

                if (j==6) {
                        bssidmatched = 1;
                        break;
                }
        }

        if (bssidmatched)
                return;

        //get bssid
        for (i=0; i<6; i++)
        {
                macp->BSSInfo[macp->bss_index].bssid[i] = pBssid[i];
        }


        //get beacon interval
        pByte = pMacBody+BCN_INTERVAL_OFFSET;
        macp->BSSInfo[macp->bss_index].beaconInterval = ((*pByte) + ((u16)(*(pByte+1))<<8));

        //get capability
        pByte = pMacBody+CAP_OFFSET;
        macp->BSSInfo[macp->bss_index].cap = ((*pByte) + ((u16)(*(pByte+1))<<8) );

        //get element
        pByte = pMacBody+SSID_OFFSET;
        currPos = SSID_OFFSET;

        while(currPos < bodyLen)
        {
                elemId = *pByte;
                elemLen = *(pByte+1);

                switch(elemId) {
                case ELEID_SSID: //ssid
                        for (i=0; i<elemLen+2; i++) {
                                macp->BSSInfo[macp->bss_index].ssid[i] = *pByte;
                                pByte++;
                        }
                        break;

                case ELEID_SUPRATES: //supported rateS

                        for (i=0; i<elemLen+2; i++) {
                                macp->BSSInfo[macp->bss_index].supRates[i] = *pByte;
                                pByte++;
                        }
                        break;


                case ELEID_DSPARMS: //ds parameter
                        macp->BSSInfo[macp->bss_index].channel = *(pByte+2);
                        pByte += (elemLen+2);
                        break;

                case ELEID_EXT_RATES:

                        pByte += (elemLen+2);
                        break;

                default:

                        pByte += (elemLen+2);
                        break;
                }

                currPos += elemLen+2;
        }

        macp->BSSInfo[macp->bss_index].signalStrength = macp->rxSignalStrength;
        macp->BSSInfo[macp->bss_index].signalQuality = macp->rxSignalQuality;

        if (macp->bss_index < (BSS_INFO_NUM-1))
        {
                macp->bss_index ++;
        }

        return;
}

void zd1205_dump_rfds(struct zd1205_private *macp)
{
        struct rx_list_elem *rx_struct = NULL;
        struct list_head *entry_ptr = NULL;
        zd1205_RFD_t *rfd = 0;
        struct sk_buff *skb;

        int i = 0;

        list_for_each(entry_ptr, &(macp->active_rx_list))
        {

                rx_struct = list_entry(entry_ptr, struct rx_list_elem, list_elem);
                if (!rx_struct)
                        return;
#ifndef HOST_IF_USB

                pci_dma_sync_single(macp->pdev, rx_struct->dma_addr,
                                    macp->rfd_size, PCI_DMA_FROMDEVICE);
#endif

                skb = rx_struct->skb;
                rfd = RFD_POINTER(skb, macp);	/* locate RFD within skb */
#if 0

                printk(KERN_DEBUG "zd1205: i = %x\n", i);
                printk(KERN_DEBUG "zd1205: rx_struct = %x\n", (u32)rx_struct);

                printk(KERN_DEBUG "zd1205: rx_struct->dma_addr = %x\n", (u32)rx_struct->dma_addr);
                printk(KERN_DEBUG "zd1205: rx_struct->skb = %x\n", (u32)rx_struct->skb);
                printk(KERN_DEBUG "zd1205: rfd = %x\n", (u32)rfd);
                printk(KERN_DEBUG "zd1205: CbStatus = %x\n", le32_to_cpu(rfd->CbStatus));

                printk(KERN_DEBUG "zd1205: CbCommand = %x\n", le32_to_cpu(rfd->CbCommand));
                printk(KERN_DEBUG "zd1205: NextCbPhyAddrLowPart = %x\n", le32_to_cpu(rfd->NextCbPhyAddrLowPart));
                printk(KERN_DEBUG "zd1205: NextCbPhyAddrHighPart = %x\n", le32_to_cpu(rfd->NextCbPhyAddrHighPart));
#endif

                zd1205_dump_data("rfd", (u8 *)rfd, 24);
                i++;

        }

}

void zd1205_dump_data(char *info, u8 *data, u32 data_len)
{
        int i;
        printk(KERN_DEBUG "%s data [%d]: \n", info, data_len);

        /* ath_desc: fix printks */
        // printk parses KERN_* macros only after newlines
        printk(KERN_DEBUG "");
        for (i=0; i<data_len; i++) {
                printk("%02x ", data[i]);
                if ((i>0) && ((i+1)%16 == 0))
                        printk("\n" KERN_DEBUG);
        }

        printk("\n");
}



/**
 * zd1205_get_rx_struct - retrieve cell to hold skb buff from the pool
 * @macp: atapter's private data struct
 
 *
 * Returns the new cell to hold sk_buff or %NULL.
 */

static struct rx_list_elem *
                        zd1205_get_rx_struct(struct zd1205_private *macp)
{
        struct rx_list_elem *rx_struct = NULL;

        if (!list_empty(&(macp->rx_struct_pool)))
        {

                rx_struct = list_entry(macp->rx_struct_pool.next,
                                       struct rx_list_elem, list_elem);
                list_del(&(rx_struct->list_elem));
        }

        return rx_struct;
}


/**
 * zd1205_alloc_skb - allocate an skb for the adapter
 * @macp: atapter's private data struct
 *
 * Allocates skb with enough room for rfd, and data, and reserve non-data space.
 * Returns the new cell with sk_buff or %NULL.
 */

static struct rx_list_elem *
                        zd1205_alloc_skb(struct zd1205_private *macp)
{
        struct sk_buff *new_skb;

        u32 skb_size = sizeof (zd1205_RFD_t);
        struct rx_list_elem *rx_struct;

        ZENTER(4);

        new_skb = (struct sk_buff *) dev_alloc_skb(skb_size);
        if (new_skb)
        {
                /* The IP data should be
                   DWORD aligned. since the ethernet header is 14 bytes long, 
                   we need to reserve 2 extra bytes so that the TCP/IP headers

                   will be DWORD aligned. */
                //skb_reserve(new_skb, 2); //for zd1202, rx dma must be 4-bytes aligmnebt
                if ((rx_struct = zd1205_get_rx_struct(macp)) == NULL)
                        goto err;

                /* ath_desc: AMD64 support */
                ZD1211DEBUG(4, "zd1211: rx_struct = %p\n", (void *)rx_struct);


                rx_struct->skb = new_skb;

                //Rx DMA address  must be 4 bytes alignment
#ifndef HOST_IF_USB

                rx_struct->dma_addr = pci_map_single(macp->pdev, new_skb->data, sizeof (zd1205_RFD_t), PCI_DMA_FROMDEVICE);

#endif

                ZD1211DEBUG(4, "zd1211: rx_struct->dma_addr = %p\n", (void *)rx_struct->dma_addr);

#ifndef HOST_IF_USB

                if (!rx_struct->dma_addr)
                        goto err;
#endif


                skb_reserve(new_skb, macp->rfd_size); //now skb->data point to RxBuffer

#ifdef HOST_IF_USB

                rx_struct->dma_addr = (dma_addr_t)new_skb->data;
                rx_struct->UnFinishFrmLen = 0;
#endif

                ZEXIT(4);
                return rx_struct;
        } else
        {
                macp->AllocSkbFailCnt++;
                printk(KERN_DEBUG "zd1205: dev_alloc_skb fail\n");
                return NULL;
        }

err:
        printk(KERN_DEBUG "zd1205: ****** err\n");
        dev_kfree_skb_irq(new_skb);

        return NULL;
}


/**
 * zd1205_add_skb_to_end - add an skb to the end of our rfd list
 
 * @macp: atapter's private data struct
 * @rx_struct: rx_list_elem with the new skb
 *
 * Adds a newly allocated skb to the end of our rfd list.
 */



void
zd1205_add_skb_to_end(struct zd1205_private *macp, struct rx_list_elem *rx_struct)
{
        zd1205_RFD_t *rfdn;	/* The new rfd */

        zd1205_RFD_t *rfd;		/* The old rfd */
        struct rx_list_elem *rx_struct_last;

        ZENTER(4);


        (rx_struct->skb)->dev = macp->device;
        rfdn = RFD_POINTER(rx_struct->skb, macp);

        rfdn->CbCommand = __constant_cpu_to_le32(RFD_EL_BIT);
        wmb();
        rfdn->CbStatus = 0xffffffff;

        rfdn->ActualCount = 0;
        rfdn->MaxSize = __constant_cpu_to_le32(MAX_WLAN_SIZE);

#ifndef __LP64__
        rfdn->NextCbPhyAddrHighPart = 0;

        rfdn->NextCbPhyAddrLowPart = 0;

#else
        rfdn->NextCbPhyAddr = 0;
#endif

#ifndef HOST_IF_USB

        wmb();

        pci_dma_sync_single(macp->pdev, rx_struct->dma_addr, macp->rfd_size,
                            PCI_DMA_TODEVICE);
#endif

        if (!list_empty(&(macp->active_rx_list)))
        {
                rx_struct_last = list_entry(macp->active_rx_list.prev,

                                            struct rx_list_elem, list_elem);


                rfd = RFD_POINTER(rx_struct_last->skb, macp);
                ZD1211DEBUG(4, "zd1211: rfd = %p\n", (unsigned long *)rfd);

#ifndef HOST_IF_USB

                pci_dma_sync_single(macp->pdev, rx_struct_last->dma_addr,

                                    4, PCI_DMA_FROMDEVICE);
#endif

#ifndef __LP64__
                put_unaligned(cpu_to_le32(rx_struct->dma_addr),
                              ((u32 *) (&(rfd->NextCbPhyAddrLowPart))));
#else
                put_unaligned(cpu_to_le64(rx_struct->dma_addr),&(rfd->NextCbPhyAddr));
#endif
#ifndef HOST_IF_USB

                wmb();
                pci_dma_sync_single(macp->pdev, rx_struct_last->dma_addr,
                                    8, PCI_DMA_TODEVICE);

#endif

                rfd->CbCommand = 0;


#ifndef HOST_IF_USB

                wmb();
                pci_dma_sync_single(macp->pdev, rx_struct_last->dma_addr,
                                    4, PCI_DMA_TODEVICE);

#endif

        }

        list_add_tail(&(rx_struct->list_elem), &(macp->active_rx_list)); //add elem to active_rx_list
        ZEXIT(4);
}


void zd1205_alloc_skbs(struct zd1205_private *macp)
{
        for (; macp->skb_req > 0; macp->skb_req--)
        {
                struct rx_list_elem *rx_struct;

                if ((rx_struct = zd1205_alloc_skb(macp)) == NULL) {
                        printk(KERN_DEBUG "zd1205: zd1205_alloc_skb fail\n");
                        return;

                }
                zd1205_add_skb_to_end(macp, rx_struct);
        }

}


void zd1205_transmit_cleanup(struct zd1205_private *macp, zd1205_SwTcb_t *sw_tcb)
{
        zd1205_HwTCB_t *hw_tcb;
        u32 tbd_cnt;
        zd1205_TBD_t *tbd_arr = sw_tcb->pFirstTbd;

        ZENTER(2);

        hw_tcb = sw_tcb->pTcb;
        tbd_cnt = le32_to_cpu(hw_tcb->TxCbTbdNumber);
        tbd_arr += 2; //CtrlSetting and MacHeader

        ZD1211DEBUG(2, "zd1211: umap tbd cnt = %x\n", tbd_cnt-2);

#ifndef HOST_IF_USB

        for (i=0; i<tbd_cnt-2; i++, tbd_arr++)
        {
                ZD1211DEBUG(2, "zd1211: umap body_dma = %x\n", le32_to_cpu(tbd_arr->TbdBufferAddrLowPart));
                pci_unmap_single(macp->pdev,
                                 le32_to_cpu(tbd_arr->TbdBufferAddrLowPart),