Changeset 11853


Ignore:
Timestamp:
2008-07-17T12:09:15+02:00 (10 years ago)
Author:
florian
Message:

Working korina driver for 2.6.24, still needs fixing in the tx tasklet which introduces high latency when transmitting packets, rx path works ok

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/rb532/files-2.6.24/drivers/net/korina.c

    r11844 r11853  
    628628        lp = (struct rc32434_local *)dev->priv; 
    629629         
    630         spin_lock(&lp->lock); 
    631630        dmas = __raw_readl(&lp->rx_dma_regs->dmas); 
    632631        if(dmas & (DMAS_d_m|DMAS_h_m|DMAS_e_m)) { 
     
    634633                dmasm = __raw_readl(&lp->rx_dma_regs->dmasm); 
    635634                __raw_writel(dmasm | (DMASM_d_m | DMASM_h_m | DMASM_e_m), &lp->rx_dma_regs->dmasm); 
    636  
    637                 netif_rx_schedule_prep(dev, &lp->napi); 
    638                  
     635                netif_rx_schedule(dev, &lp->napi); 
     636 
    639637                if (dmas & DMAS_e_m) 
    640638                        ERR(": DMA error\n"); 
     
    645643                retval = IRQ_NONE; 
    646644         
    647         spin_unlock(&lp->lock); 
    648645        return retval; 
    649646} 
    650647 
    651 static int rc32434_poll(struct napi_struct *napi, int budget) 
    652 { 
    653         struct rc32434_local* lp = container_of(napi, struct rc32434_local, napi); 
    654         struct net_device *dev = lp->dev; 
     648 
     649static int rc32434_rx(struct net_device *dev, int limit) 
     650{ 
     651        struct rc32434_local *lp = netdev_priv(dev); 
    655652        volatile DMAD_t  rd = &lp->rd_ring[lp->rx_next_done]; 
    656         struct sk_buff *skb, *skb_new; 
    657         u8* pkt_buf; 
    658         u32 devcs, count, pkt_len, pktuncrc_len; 
    659         volatile u32 dmas; 
    660         u32 received = 0; 
    661         int rx_work_limit = min(budget, 64); 
     653        struct sk_buff *skb, *skb_new; 
     654        u8 *pkt_buf; 
     655        u32 devcs, pkt_len, dmas, rx_free_desc; 
     656        u32 pktuncrc_len; 
     657        int count; 
    662658 
    663659        dma_cache_inv((u32)rd, sizeof(*rd)); 
    664         while ( (count = RC32434_RBSIZE - (u32)DMA_COUNT(rd->control)) != 0) { 
    665                 if(--rx_work_limit <0) 
    666                 { 
    667                         break; 
    668                 } 
     660        for (count = 0; count < limit; count++) { 
    669661                /* init the var. used for the later operations within the while loop */ 
    670662                skb_new = NULL; 
     
    673665                skb = lp->rx_skb[lp->rx_next_done]; 
    674666       
    675                 if (count < 64) { 
    676                         lp->stats.rx_errors++; 
    677                         lp->stats.rx_dropped++;                  
    678                 } 
    679                 else if ((devcs & ( ETHRX_ld_m)) !=     ETHRX_ld_m) { 
     667                if ((devcs & ( ETHRX_ld_m)) !=  ETHRX_ld_m) { 
    680668                        /* check that this is a whole packet */ 
    681669                        /* WARNING: DMA_FD bit incorrectly set in Rc32434 (errata ref #077) */ 
     
    685673                else if ( (devcs & ETHRX_rok_m)  ) { 
    686674                         
    687                         { 
    688675                                /* must be the (first and) last descriptor then */ 
    689676                                pkt_buf = (u8*)lp->rx_skb[lp->rx_next_done]->data; 
     
    694681                                 
    695682                                /* Malloc up new buffer. */                                        
    696                                 skb_new = dev_alloc_skb(RC32434_RBSIZE + 2);                                                     
     683                                skb_new = netdev_alloc_skb(dev, RC32434_RBSIZE + 2);                                                     
    697684                                 
    698685                                if (skb_new != NULL){ 
     
    723710                                        lp->stats.rx_dropped++;                                  
    724711                                } 
    725                         } 
    726                          
    727712                }                        
    728713                else { 
     
    756741                        } 
    757742                } 
    758                  
    759743                rd->devcs = 0; 
    760744                 
    761745                /* restore descriptor's curr_addr */ 
    762                 if(skb_new) 
    763                         rd->ca = CPHYSADDR(skb_new->data);  
     746                if(skb_new) { 
     747                        rd->ca = CPHYSADDR(skb_new->data); 
     748                } 
    764749                else 
    765750                        rd->ca = CPHYSADDR(skb->data); 
     
    773758                __raw_writel( ~DMAS_d_m, &lp->rx_dma_regs->dmas); 
    774759        }        
    775         budget =- received; 
    776         if(rx_work_limit < 0) 
    777                 goto not_done; 
    778760         
    779761        dmas = __raw_readl(&lp->rx_dma_regs->dmas); 
    780762         
    781763        if(dmas & DMAS_h_m) { 
     764                /* Mask off halt and error bits */ 
    782765                __raw_writel( ~(DMAS_h_m | DMAS_e_m), &lp->rx_dma_regs->dmas); 
    783766#ifdef RC32434_PROC_DEBUG 
     
    791774        } 
    792775         
    793         netif_rx_complete(dev, &lp->napi); 
    794         /* Enable D H E bit in Rx DMA */ 
    795         __raw_writel(__raw_readl(&lp->rx_dma_regs->dmasm) & ~(DMASM_d_m | DMASM_h_m |DMASM_e_m), &lp->rx_dma_regs->dmasm);  
    796         return 0; 
    797  not_done: 
    798         return 1; 
    799 }        
     776        return count; 
     777} 
     778 
     779static int rc32434_poll(struct napi_struct *napi, int budget) 
     780{ 
     781        struct rc32434_local *lp = 
     782                container_of(napi, struct rc32434_local, napi); 
     783        struct net_device *dev = lp->dev; 
     784        int work_done; 
     785 
     786        work_done = rc32434_rx(dev, budget); 
     787        if (work_done < budget) { 
     788                netif_rx_complete(dev, napi); 
     789 
     790                /* Mask off interrupts */ 
     791                writel(readl(&lp->rx_dma_regs->dmasm) & 
     792                        (DMASM_d_m | DMASM_h_m |DMASM_e_m), 
     793                        &lp->rx_dma_regs->dmasm); 
     794        } 
     795        return work_done; 
     796} 
    800797 
    801798 
     
    813810         
    814811        lp = (struct rc32434_local *)dev->priv; 
    815          
    816         spin_lock(&lp->lock); 
    817812         
    818813        dmas = __raw_readl(&lp->tx_dma_regs->dmas); 
     
    839834        else 
    840835                retval = IRQ_NONE; 
    841          
    842         spin_unlock(&lp->lock); 
    843836         
    844837        return retval; 
     
    996989        __raw_writel(ETHINTFC_en_m, &lp->eth_regs->ethintfc);  
    997990         
    998 #ifndef CONFIG_IDT_USE_NAPI 
    999         tasklet_disable(lp->rx_tasklet); 
    1000 #endif 
    1001991        tasklet_disable(lp->tx_tasklet); 
    1002992         
Note: See TracChangeset for help on using the changeset viewer.