Changeset 33489


Ignore:
Timestamp:
2012-09-20T01:50:12+02:00 (5 years ago)
Author:
nbd
Message:

cns3xxx: merge ethernet driver changes from gateworks

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/cns3xxx/patches-3.3/051-cns3xxx_gigabit.patch

    r33487 r33489  
    11--- /dev/null 
    22+++ b/drivers/net/ethernet/cavium/cns3xxx_eth.c 
    3 @@ -0,0 +1,1270 @@ 
     3@@ -0,0 +1,1298 @@ 
    44+/* 
    55+ * Cavium CNS3xxx Gigabit driver for Linux 
     
    3737+#define TX_POOL_ALLOC_SIZE (sizeof(struct tx_desc) * TX_DESCS) 
    3838+#define REGS_SIZE 336 
    39 +#define MAX_MRU        9500 
     39+#define MAX_MRU (1536 + SKB_DMA_REALIGN) 
     40+#define CNS3XXX_MAX_MTU (1536) 
    4041+ 
    4142+#define NAPI_WEIGHT 64 
     
    5859+ 
    5960+/* Port Config Defines */ 
     61+#define PORT_BP_ENABLE 0x00020000 
    6062+#define PORT_DISABLE 0x00040000 
     63+#define PORT_LEARN_DIS 0x00080000 
     64+#define PORT_BLOCK_STATE 0x00100000 
     65+#define PORT_BLOCK_MODE 0x00200000 
     66+ 
    6167+#define PROMISC_OFFSET 29 
    6268+ 
     
    7985+#define QUEUE_THRESHOLD 0x000000f0 
    8086+#define CLR_FS_STATE 0x80000000 
     87+ 
     88+/* Interrupt Status Defines */ 
     89+#define MAC0_STATUS_CHANGE 0x00004000 
     90+#define MAC1_STATUS_CHANGE 0x00008000 
     91+#define MAC2_STATUS_CHANGE 0x00010000 
     92+#define MAC0_RX_ERROR 0x00100000 
     93+#define MAC1_RX_ERROR 0x00200000 
     94+#define MAC2_RX_ERROR 0x00400000 
    8195+ 
    8296+struct tx_desc 
     
    188202+       u8 alignment[16]; /* for 32 byte alignment */ 
    189203+}; 
     204+ 
    190205+ 
    191206+struct switch_regs { 
     
    234249+       u32 fs_desc_ptr1; 
    235250+       u32 fs_desc_base_addr1; 
     251+       u32 __res7[109]; 
     252+       u32 mac_counter0[13]; 
    236253+}; 
    237254+ 
     
    241258+       struct tx_desc *cur_addr; 
    242259+       struct sk_buff *buff_tab[TX_DESCS]; 
     260+       unsigned int phys_tab[TX_DESCS]; 
    243261+       u32 free_index; 
    244262+       u32 count_index; 
     
    253271+       struct rx_desc *cur_addr; 
    254272+       struct sk_buff *buff_tab[RX_DESCS]; 
     273+       unsigned int phys_tab[RX_DESCS]; 
    255274+       u32 cur_index; 
    256275+       u32 alloc_index; 
     
    265284+       struct _tx_ring *tx_ring; 
    266285+       struct _rx_ring *rx_ring; 
    267 +       u32 mtu; 
    268286+}; 
    269287+ 
     
    274292+       int id;                 /* logical port ID */ 
    275293+       int speed, duplex; 
    276 +       u32 mtu; 
    277294+}; 
    278295+ 
    279296+static spinlock_t mdio_lock; 
    280 +static spinlock_t tx_lock; 
    281 +static spinlock_t stat_lock; 
     297+static DEFINE_SPINLOCK(tx_lock); 
    282298+static struct switch_regs __iomem *mdio_regs; /* mdio command and status only */ 
    283299+struct mii_bus *mdio_bus; 
    284300+static int ports_open; 
    285 +static struct port *switch_port_tab[3]; 
     301+static struct port *switch_port_tab[4]; 
    286302+static struct dma_pool *rx_dma_pool; 
    287303+static struct dma_pool *tx_dma_pool; 
     
    381397+} 
    382398+ 
     399+static void enable_tx_dma(struct sw *sw) 
     400+{ 
     401+       __raw_writel(0x1, &sw->regs->ts_dma_ctrl0); 
     402+} 
     403+ 
     404+static void enable_rx_dma(struct sw *sw) 
     405+{ 
     406+       __raw_writel(0x1, &sw->regs->fs_dma_ctrl0); 
     407+} 
     408+ 
    383409+static void cns3xxx_adjust_link(struct net_device *dev) 
    384410+{ 
     
    415441+} 
    416442+ 
     443+irqreturn_t eth_stat_irq(int irq, void *pdev) 
     444+{ 
     445+       struct net_device *dev = pdev; 
     446+       struct sw *sw = netdev_priv(dev); 
     447+       u32 cfg; 
     448+       u32 stat = __raw_readl(&sw->regs->intr_stat); 
     449+       __raw_writel(0xffffffff, &sw->regs->intr_stat); 
     450+ 
     451+       if (stat & MAC2_RX_ERROR) 
     452+               switch_port_tab[3]->netdev->stats.rx_dropped++; 
     453+       if (stat & MAC1_RX_ERROR) 
     454+               switch_port_tab[1]->netdev->stats.rx_dropped++; 
     455+       if (stat & MAC0_RX_ERROR) 
     456+               switch_port_tab[0]->netdev->stats.rx_dropped++; 
     457+ 
     458+       if (stat & MAC0_STATUS_CHANGE) { 
     459+               cfg = __raw_readl(&sw->regs->mac_cfg[0]); 
     460+               switch_port_tab[0]->phydev->link = (cfg & 0x1); 
     461+               switch_port_tab[0]->phydev->duplex = ((cfg >> 4) & 0x1); 
     462+               if (((cfg >> 2) & 0x3) == 2) 
     463+                       switch_port_tab[0]->phydev->speed = 1000; 
     464+               else if (((cfg >> 2) & 0x3) == 1) 
     465+                       switch_port_tab[0]->phydev->speed = 100; 
     466+               else 
     467+                       switch_port_tab[0]->phydev->speed = 10; 
     468+               cns3xxx_adjust_link(switch_port_tab[0]->netdev); 
     469+       } 
     470+ 
     471+       if (stat & MAC1_STATUS_CHANGE) { 
     472+               cfg = __raw_readl(&sw->regs->mac_cfg[1]); 
     473+               switch_port_tab[1]->phydev->link = (cfg & 0x1); 
     474+               switch_port_tab[1]->phydev->duplex = ((cfg >> 4) & 0x1); 
     475+               if (((cfg >> 2) & 0x3) == 2) 
     476+                       switch_port_tab[1]->phydev->speed = 1000; 
     477+               else if (((cfg >> 2) & 0x3) == 1) 
     478+                       switch_port_tab[1]->phydev->speed = 100; 
     479+               else 
     480+                       switch_port_tab[1]->phydev->speed = 10; 
     481+               cns3xxx_adjust_link(switch_port_tab[1]->netdev); 
     482+       } 
     483+ 
     484+       if (stat & MAC2_STATUS_CHANGE) { 
     485+               cfg = __raw_readl(&sw->regs->mac_cfg[3]); 
     486+               switch_port_tab[3]->phydev->link = (cfg & 0x1); 
     487+               switch_port_tab[3]->phydev->duplex = ((cfg >> 4) & 0x1); 
     488+               if (((cfg >> 2) & 0x3) == 2) 
     489+                       switch_port_tab[3]->phydev->speed = 1000; 
     490+               else if (((cfg >> 2) & 0x3) == 1) 
     491+                       switch_port_tab[3]->phydev->speed = 100; 
     492+               else 
     493+                       switch_port_tab[3]->phydev->speed = 10; 
     494+               cns3xxx_adjust_link(switch_port_tab[3]->netdev); 
     495+       } 
     496+ 
     497+       return (IRQ_HANDLED); 
     498+} 
     499+ 
     500+ 
    417501+static void cns3xxx_alloc_rx_buf(struct sw *sw, int received) 
    418502+{ 
    419503+       struct _rx_ring *rx_ring = sw->rx_ring; 
    420504+       unsigned int i = rx_ring->alloc_index; 
    421 +       struct rx_desc *desc; 
     505+       struct rx_desc *desc = &(rx_ring)->desc[i]; 
    422506+       struct sk_buff *skb; 
    423 +       u32 mtu = sw->mtu; 
    424 + 
    425 +       rx_ring->alloc_count += received; 
    426 + 
    427 +       for (received = rx_ring->alloc_count; received > 0; received--) { 
    428 +               desc = &(rx_ring)->desc[i]; 
    429 + 
    430 +               if ((skb = dev_alloc_skb(mtu))) { 
     507+       unsigned int phys; 
     508+ 
     509+       for (received += rx_ring->alloc_count; received > 0; received--) { 
     510+               if ((skb = dev_alloc_skb(MAX_MRU))) { 
    431511+                       if (SKB_DMA_REALIGN) 
    432512+                               skb_reserve(skb, SKB_DMA_REALIGN); 
    433513+                       skb_reserve(skb, NET_IP_ALIGN); 
    434 +                       desc->sdp = dma_map_single(NULL, skb->data, 
    435 +                                   mtu, DMA_FROM_DEVICE); 
    436 +                       if (dma_mapping_error(NULL, desc->sdp)) { 
     514+                       phys = dma_map_single(NULL, skb->data, 
     515+                                   CNS3XXX_MAX_MTU, DMA_FROM_DEVICE); 
     516+                       if (dma_mapping_error(NULL, phys)) { 
    437517+                               dev_kfree_skb(skb); 
    438518+                               /* Failed to map, better luck next time */ 
    439519+                               goto out;; 
    440520+                       } 
     521+                       desc->sdp = phys; 
    441522+               } else { 
    442523+                       /* Failed to allocate skb, try again next time */ 
     
    446527+               /* put the new buffer on RX-free queue */ 
    447528+               rx_ring->buff_tab[i] = skb; 
    448 + 
    449 +               if (++i == RX_DESCS) { 
     529+               rx_ring->phys_tab[i] = phys; 
     530+               if (i == RX_DESCS - 1) { 
    450531+                       i = 0; 
    451532+                       desc->config0 = END_OF_RING | FIRST_SEGMENT | 
    452 +                                       LAST_SEGMENT | mtu; 
     533+                                       LAST_SEGMENT | CNS3XXX_MAX_MTU; 
     534+                       desc = &(rx_ring)->desc[i]; 
    453535+               } else { 
    454 +                       desc->config0 = FIRST_SEGMENT | LAST_SEGMENT | mtu; 
     536+                       desc->config0 = FIRST_SEGMENT | LAST_SEGMENT | CNS3XXX_MAX_MTU; 
     537+                       i++; 
     538+                       desc++; 
    455539+               } 
    456540+       } 
     
    460544+} 
    461545+ 
    462 +static void update_tx_stats(struct sw *sw) 
     546+static void clear_tx_desc(struct sw *sw) 
    463547+{ 
    464548+       struct _tx_ring *tx_ring = sw->tx_ring; 
    465549+       struct tx_desc *desc; 
    466 +       struct tx_desc *next_desc; 
    467 +       struct sk_buff *skb; 
    468550+       int i; 
    469551+       int index; 
    470 +       int num_count; 
    471 + 
    472 +       spin_lock_bh(&stat_lock); 
    473 + 
    474 +       num_count = tx_ring->num_count; 
    475 + 
    476 +       if (!num_count) { 
    477 +               spin_unlock_bh(&stat_lock); 
    478 +               return; 
    479 +       } 
    480 + 
    481 +       index = tx_ring->count_index; 
    482 +       desc = &(tx_ring)->desc[index]; 
    483 +       for (i = 0; i < num_count; i++) { 
    484 +               skb = tx_ring->buff_tab[index]; 
    485 +               if (desc->cown) { 
    486 +                       tx_ring->buff_tab[index] = 0; 
    487 +                       if (unlikely(++index == TX_DESCS)) index = 0; 
    488 +                       next_desc = &(tx_ring)->desc[index]; 
    489 +                       prefetch(next_desc + 4); 
    490 +                       if (likely(skb)) { 
    491 +                               skb->dev->stats.tx_packets++; 
    492 +                               skb->dev->stats.tx_bytes += skb->len; 
    493 +                               dev_kfree_skb_any(skb); 
    494 +                       } 
    495 +                       desc = next_desc; 
    496 +               } else { 
    497 +                       break; 
    498 +               } 
    499 +       } 
    500 +       tx_ring->num_count -= i; 
    501 +       tx_ring->count_index = index; 
    502 + 
    503 +       spin_unlock_bh(&stat_lock); 
    504 +} 
    505 + 
    506 +static void clear_tx_desc(struct sw *sw) 
    507 +{ 
    508 +       struct _tx_ring *tx_ring = sw->tx_ring; 
    509 +       struct tx_desc *desc; 
    510 +       struct tx_desc *next_desc; 
    511 +       int i; 
    512 +       int index; 
    513 +       int num_used = tx_ring->num_used - tx_ring->num_count; 
     552+       int num_used = tx_ring->num_used; 
     553+       struct sk_buff *skb; 
    514554+ 
    515555+       if (num_used < (TX_DESCS >> 1)) 
     
    520560+       for (i = 0; i < num_used; i++) { 
    521561+               if (desc->cown) { 
    522 +                       if (unlikely(++index == TX_DESCS)) index = 0; 
    523 +                       next_desc = &(tx_ring)->desc[index]; 
    524 +                       prefetch(next_desc); 
    525 +                       prefetch(next_desc + 4); 
    526 +                       if (likely(desc->sdp)) 
    527 +                               dma_unmap_single(NULL, desc->sdp, 
    528 +                                       desc->sdl, DMA_TO_DEVICE); 
    529 +                       desc = next_desc; 
     562+                       skb = tx_ring->buff_tab[index]; 
     563+                       tx_ring->buff_tab[index] = 0; 
     564+                       if (skb) 
     565+                               dev_kfree_skb_any(skb); 
     566+                       dma_unmap_single(NULL, tx_ring->phys_tab[index], 
     567+                               desc->sdl, DMA_TO_DEVICE); 
     568+                       if (++index == TX_DESCS) { 
     569+                               index = 0; 
     570+                               desc = &(tx_ring)->desc[index]; 
     571+                       } else { 
     572+                               desc++; 
     573+                       } 
    530574+               } else { 
    531575+                       break; 
     
    544588+       unsigned int length; 
    545589+       unsigned int i = rx_ring->cur_index; 
    546 +       struct rx_desc *next_desc; 
    547590+       struct rx_desc *desc = &(rx_ring)->desc[i]; 
    548 +       int port_id; 
    549591+ 
    550592+       while (desc->cown) { 
     
    556598+               skb = rx_ring->buff_tab[i]; 
    557599+ 
    558 +               if (++i == RX_DESCS) i = 0; 
    559 +               next_desc = &(rx_ring)->desc[i]; 
    560 +               prefetch(next_desc); 
    561 + 
    562 +               port_id = desc->sp; 
    563 +               if (port_id == 4) 
    564 +                       dev = switch_port_tab[2]->netdev; 
    565 +               else 
    566 +                       dev = switch_port_tab[port_id]->netdev; 
     600+               dev = switch_port_tab[desc->sp]->netdev; 
    567601+ 
    568602+               length = desc->sdl; 
    569603+               /* process received frame */ 
    570 +               dma_unmap_single(&dev->dev, desc->sdp, 
     604+               dma_unmap_single(&dev->dev, rx_ring->phys_tab[i], 
    571605+                                length, DMA_FROM_DEVICE); 
    572606+ 
     
    579613+               dev->stats.rx_bytes += length; 
    580614+ 
     615+               /* RX Hardware checksum offload */ 
    581616+               switch (desc->prot) { 
    582617+                       case 1: 
     
    599634+ 
    600635+               received++; 
    601 +               desc = next_desc; 
     636+ 
     637+               if (++i == RX_DESCS) { 
     638+                       i = 0; 
     639+                       desc = &(rx_ring)->desc[i]; 
     640+               } else { 
     641+                       desc++; 
     642+               } 
    602643+       } 
    603644+ 
    604645+       cns3xxx_alloc_rx_buf(sw, received); 
     646+ 
    605647+       rx_ring->cur_index = i; 
    606648+ 
     
    609651+               enable_irq(IRQ_CNS3XXX_SW_R0RXC); 
    610652+       } 
     653+ 
     654+       enable_rx_dma(sw); 
    611655+ 
    612656+       return received; 
     
    620664+       struct tx_desc *tx_desc; 
    621665+       int index; 
    622 +       int len = skb->len; 
     666+       int len; 
    623667+       char pmap = (1 << port->id); 
     668+       unsigned int phys; 
     669+       int nr_frags = skb_shinfo(skb)->nr_frags; 
     670+       struct skb_frag_struct *frag; 
     671+       unsigned int i; 
    624672+ 
    625673+       if (pmap == 8) 
    626674+               pmap = (1 << 4); 
    627675+ 
    628 +       if (unlikely(len > sw->mtu)) { 
     676+       if (skb->len > CNS3XXX_MAX_MTU) { 
    629677+               dev_kfree_skb(skb); 
    630678+               dev->stats.tx_errors++; 
     
    632680+       } 
    633681+ 
    634 +       update_tx_stats(sw); 
    635 + 
    636 +       spin_lock_bh(&tx_lock); 
    637 + 
    638 +       clear_tx_desc(sw); 
    639 + 
    640 +       if (unlikely(tx_ring->num_used == TX_DESCS)) { 
    641 +               spin_unlock_bh(&tx_lock); 
    642 +               return NETDEV_TX_BUSY; 
     682+       spin_lock(&tx_lock); 
     683+ 
     684+       if ((tx_ring->num_used + nr_frags) >= TX_DESCS) { 
     685+               clear_tx_desc(sw); 
     686+               if ((tx_ring->num_used + nr_frags) >= TX_DESCS) { 
     687+                       spin_unlock(&tx_lock); 
     688+                       return NETDEV_TX_BUSY; 
     689+               } 
    643690+       } 
    644691+ 
    645692+       index = tx_ring->cur_index; 
    646 + 
    647 +       if (unlikely(++tx_ring->cur_index == TX_DESCS)) 
    648 +               tx_ring->cur_index = 0; 
    649 + 
    650 +       tx_ring->num_used++; 
    651 +       tx_ring->num_count++; 
    652 + 
    653 +       spin_unlock_bh(&tx_lock); 
    654 + 
    655 +       tx_desc = &(tx_ring)->desc[index]; 
    656 + 
    657 +       tx_desc->sdp = dma_map_single(NULL, skb->data, len, 
    658 +                                     DMA_TO_DEVICE); 
    659 + 
    660 +       if (dma_mapping_error(NULL, tx_desc->sdp)) { 
    661 +               dev_kfree_skb(skb); 
    662 +               dev->stats.tx_errors++; 
    663 +               return NETDEV_TX_OK; 
    664 +       } 
    665 + 
    666 +       tx_desc->pmap = pmap; 
    667 +       tx_ring->buff_tab[index] = skb; 
    668 + 
    669 +       if (index == TX_DESCS - 1) { 
    670 +               tx_desc->config0 = END_OF_RING | FIRST_SEGMENT | LAST_SEGMENT | 
    671 +                                  FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
    672 +                                  TCP_CHECKSUM | len; 
     693+       tx_ring->cur_index = ((tx_ring->cur_index + nr_frags + 1) % TX_DESCS); 
     694+ 
     695+       spin_unlock(&tx_lock); 
     696+ 
     697+       if (!nr_frags) { 
     698+               tx_desc = &(tx_ring)->desc[index]; 
     699+ 
     700+               len = skb->len; 
     701+ 
     702+               phys = dma_map_single(NULL, skb->data, len, 
     703+                                       DMA_TO_DEVICE); 
     704+ 
     705+               tx_desc->sdp = phys; 
     706+               tx_desc->pmap = pmap; 
     707+               tx_ring->phys_tab[index] = phys; 
     708+ 
     709+               tx_ring->buff_tab[index] = skb; 
     710+               if (index == TX_DESCS - 1) { 
     711+                       tx_desc->config0 = END_OF_RING | FIRST_SEGMENT | LAST_SEGMENT | 
     712+                                       FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
     713+                                       TCP_CHECKSUM | len; 
     714+               } else { 
     715+                       tx_desc->config0 = FIRST_SEGMENT | LAST_SEGMENT | 
     716+                                       FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
     717+                                       TCP_CHECKSUM | len; 
     718+               } 
    673719+       } else { 
    674 +               tx_desc->config0 = FIRST_SEGMENT | LAST_SEGMENT | 
    675 +                                  FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
    676 +                                  TCP_CHECKSUM | len; 
    677 +       } 
     720+               unsigned int config; 
     721+ 
     722+               index = ((index + nr_frags) % TX_DESCS); 
     723+               tx_desc = &(tx_ring)->desc[index]; 
     724+ 
     725+               /* fragments */ 
     726+               for (i = nr_frags; i > 0; i--) { 
     727+                       void *addr; 
     728+ 
     729+                       frag = &skb_shinfo(skb)->frags[i-1]; 
     730+                       len = frag->size; 
     731+ 
     732+                       addr = page_address(skb_frag_page(frag)) + 
     733+                              frag->page_offset; 
     734+                       phys = dma_map_single(NULL, addr, len, DMA_TO_DEVICE); 
     735+ 
     736+                       tx_desc->sdp = phys; 
     737+ 
     738+                       tx_desc->pmap = pmap; 
     739+                       tx_ring->phys_tab[index] = phys; 
     740+ 
     741+                       config = FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
     742+                               TCP_CHECKSUM | len; 
     743+                       if (i == nr_frags) { 
     744+                               config |= LAST_SEGMENT; 
     745+                               tx_ring->buff_tab[index] = skb; 
     746+                       } 
     747+                       if (index == TX_DESCS - 1) 
     748+                               config |= END_OF_RING; 
     749+                       tx_desc->config0 = config; 
     750+ 
     751+                       if (index == 0) { 
     752+                               index = TX_DESCS - 1; 
     753+                               tx_desc = &(tx_ring)->desc[index]; 
     754+                       } else { 
     755+                               index--; 
     756+                               tx_desc--; 
     757+                       } 
     758+               } 
     759+ 
     760+               /* header */ 
     761+               len = skb->len - skb->data_len; 
     762+ 
     763+               phys = dma_map_single(NULL, skb->data, len, 
     764+                                       DMA_TO_DEVICE); 
     765+ 
     766+               tx_desc->sdp = phys; 
     767+               tx_desc->pmap = pmap; 
     768+               tx_ring->phys_tab[index] = phys; 
     769+ 
     770+               if (index == TX_DESCS - 1) { 
     771+                       tx_desc->config0 = END_OF_RING | FIRST_SEGMENT | 
     772+                                       FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
     773+                                       TCP_CHECKSUM | len; 
     774+               } else { 
     775+                       tx_desc->config0 = FIRST_SEGMENT | 
     776+                                       FORCE_ROUTE | IP_CHECKSUM | UDP_CHECKSUM | 
     777+                                       TCP_CHECKSUM | len; 
     778+               } 
     779+       } 
     780+ 
     781+       mb(); 
     782+ 
     783+       spin_lock(&tx_lock); 
     784+       tx_ring->num_used += nr_frags + 1; 
     785+       spin_unlock(&tx_lock); 
     786+ 
     787+       dev->stats.tx_packets++; 
     788+       dev->stats.tx_bytes += skb->len; 
     789+ 
     790+       enable_tx_dma(sw); 
    678791+ 
    679792+       return NETDEV_TX_OK; 
     
    751864+               struct rx_desc *desc = &(rx_ring)->desc[i]; 
    752865+               struct sk_buff *skb; 
    753 +               if (!(skb = dev_alloc_skb(sw->mtu))) 
     866+               if (!(skb = dev_alloc_skb(MAX_MRU))) 
    754867+                       return -ENOMEM; 
    755868+               if (SKB_DMA_REALIGN) 
    756869+                       skb_reserve(skb, SKB_DMA_REALIGN); 
    757870+               skb_reserve(skb, NET_IP_ALIGN); 
    758 +               desc->sdl = sw->mtu; 
     871+               desc->sdl = CNS3XXX_MAX_MTU; 
    759872+               if (i == (RX_DESCS - 1)) 
    760873+                       desc->eor = 1; 
     
    763876+ 
    764877+               desc->sdp = dma_map_single(NULL, skb->data, 
    765 +                                           sw->mtu, DMA_FROM_DEVICE); 
     878+                                           CNS3XXX_MAX_MTU, DMA_FROM_DEVICE); 
    766879+               if (dma_mapping_error(NULL, desc->sdp)) { 
    767880+                       return -EIO; 
    768881+               } 
    769882+               rx_ring->buff_tab[i] = skb; 
     883+               rx_ring->phys_tab[i] = desc->sdp; 
    770884+               desc->cown = 0; 
    771885+       } 
     
    808922+                               dma_unmap_single(NULL, 
    809923+                                                desc->sdp, 
    810 +                                                sw->mtu, DMA_FROM_DEVICE); 
     924+                                                CNS3XXX_MAX_MTU, DMA_FROM_DEVICE); 
    811925+                               dev_kfree_skb(skb); 
    812926+                       } 
     
    848962+       if (!ports_open) { 
    849963+               request_irq(IRQ_CNS3XXX_SW_R0RXC, eth_rx_irq, IRQF_SHARED, "gig_switch", napi_dev); 
     964+               request_irq(IRQ_CNS3XXX_SW_STATUS, eth_stat_irq, IRQF_SHARED, "gig_stat", napi_dev); 
    850965+               napi_enable(&sw->napi); 
    851966+               netif_start_queue(napi_dev); 
    852 +               //enable_irq(IRQ_CNS3XXX_SW_R0RXC); 
     967+ 
     968+               __raw_writel(~(MAC0_STATUS_CHANGE | MAC1_STATUS_CHANGE | MAC2_STATUS_CHANGE | 
     969+                              MAC0_RX_ERROR | MAC1_RX_ERROR | MAC2_RX_ERROR), &sw->regs->intr_mask); 
    853970+ 
    854971+               temp = __raw_readl(&sw->regs->mac_cfg[2]); 
     
    860977+               __raw_writel(temp, &sw->regs->dma_auto_poll_cfg); 
    861978+ 
    862 +               __raw_writel((TS_POLL_EN | FS_POLL_EN), &sw->regs->dma_auto_poll_cfg); 
     979+               enable_rx_dma(sw); 
    863980+       } 
    864981+       temp = __raw_readl(&sw->regs->mac_cfg[port->id]); 
     
    8911008+               disable_irq(IRQ_CNS3XXX_SW_R0RXC); 
    8921009+               free_irq(IRQ_CNS3XXX_SW_R0RXC, napi_dev); 
     1010+               disable_irq(IRQ_CNS3XXX_SW_STATUS); 
     1011+               free_irq(IRQ_CNS3XXX_SW_STATUS, napi_dev); 
    8931012+               napi_disable(&sw->napi); 
    8941013+               netif_stop_queue(napi_dev); 
     
    9801099+} 
    9811100+ 
    982 +static int cns3xxx_change_mtu(struct net_device *netdev, int new_mtu) 
    983 +{ 
    984 +       struct port *port = netdev_priv(netdev); 
    985 +       struct sw *sw = port->sw; 
    986 +       u32 temp; 
    987 +       int i; 
    988 +       struct _rx_ring *rx_ring = sw->rx_ring; 
    989 +       struct rx_desc *desc; 
    990 +       struct sk_buff *skb; 
    991 + 
    992 +       if (new_mtu > MAX_MRU) 
    993 +               return -EINVAL; 
    994 + 
    995 +       netdev->mtu = new_mtu; 
    996 + 
    997 +       new_mtu += 36 + SKB_DMA_REALIGN; 
    998 +       port->mtu = new_mtu; 
    999 + 
    1000 +       new_mtu = 0; 
    1001 +       for (i = 0; i < 3; i++) { 
    1002 +               if (switch_port_tab[i]) { 
    1003 +                       if (switch_port_tab[i]->mtu > new_mtu) 
    1004 +                               new_mtu = switch_port_tab[i]->mtu; 
    1005 +               } 
    1006 +       } 
    1007 + 
    1008 + 
    1009 +       if (new_mtu == sw->mtu) 
    1010 +               return 0; 
    1011 + 
    1012 +       disable_irq(IRQ_CNS3XXX_SW_R0RXC); 
    1013 + 
    1014 +       sw->mtu = new_mtu; 
    1015 + 
    1016 +       /* Disable DMA */ 
    1017 +       __raw_writel(TS_SUSPEND | FS_SUSPEND, &sw->regs->dma_auto_poll_cfg); 
    1018 + 
    1019 +       for (i = 0; i < RX_DESCS; i++) { 
    1020 +               desc = &(rx_ring)->desc[i]; 
    1021 +               /* Check if we own it, if we do, it will get set correctly 
    1022 +                * when it is re-used */ 
    1023 +               if (!desc->cown) { 
    1024 +                       skb = rx_ring->buff_tab[i]; 
    1025 +                       dma_unmap_single(NULL, desc->sdp, desc->sdl, 
    1026 +                                        DMA_FROM_DEVICE); 
    1027 +                       dev_kfree_skb(skb); 
    1028 + 
    1029 +                       if ((skb = dev_alloc_skb(new_mtu))) { 
    1030 +                               if (SKB_DMA_REALIGN) 
    1031 +                                       skb_reserve(skb, SKB_DMA_REALIGN); 
    1032 +                               skb_reserve(skb, NET_IP_ALIGN); 
    1033 +                               desc->sdp = dma_map_single(NULL, skb->data, 
    1034 +                                           new_mtu, DMA_FROM_DEVICE); 
    1035 +                               if (dma_mapping_error(NULL, desc->sdp)) { 
    1036 +                                       dev_kfree_skb(skb); 
    1037 +                                       skb = NULL; 
    1038 +                               } 
    1039 +                       } 
    1040 + 
    1041 +                       /* put the new buffer on RX-free queue */ 
    1042 +                       rx_ring->buff_tab[i] = skb; 
    1043 + 
    1044 +                       if (i == RX_DESCS - 1) 
    1045 +                               desc->config0 = END_OF_RING | FIRST_SEGMENT | 
    1046 +                                               LAST_SEGMENT | new_mtu; 
    1047 +                       else 
    1048 +                               desc->config0 = FIRST_SEGMENT | 
    1049 +                                               LAST_SEGMENT | new_mtu; 
    1050 +               } 
    1051 +       } 
    1052 + 
    1053 +       /* Re-ENABLE DMA */ 
    1054 +       temp = __raw_readl(&sw->regs->dma_auto_poll_cfg); 
    1055 +       temp &= ~(TS_SUSPEND | FS_SUSPEND); 
    1056 +       __raw_writel(temp, &sw->regs->dma_auto_poll_cfg); 
    1057 + 
    1058 +       __raw_writel((TS_POLL_EN | FS_POLL_EN), &sw->regs->dma_auto_poll_cfg); 
    1059 + 
    1060 +       enable_irq(IRQ_CNS3XXX_SW_R0RXC); 
    1061 + 
    1062 +       return 0; 
    1063 +} 
    1064 + 
    10651101+static const struct net_device_ops cns3xxx_netdev_ops = { 
    10661102+       .ndo_open = eth_open, 
     
    10691105+       .ndo_set_rx_mode = eth_rx_mode, 
    10701106+       .ndo_do_ioctl = eth_ioctl, 
    1071 +       .ndo_change_mtu = cns3xxx_change_mtu, 
     1107+       .ndo_change_mtu = eth_change_mtu, 
    10721108+       .ndo_set_mac_address = eth_set_mac, 
    10731109+       .ndo_validate_addr = eth_validate_addr, 
     
    10861122+       u32 temp; 
    10871123+ 
    1088 +       spin_lock_init(&tx_lock); 
    1089 +       spin_lock_init(&stat_lock); 
    1090 + 
    10911124+       if (!(napi_dev = alloc_etherdev(sizeof(struct sw)))) 
    10921125+               return -ENOMEM; 
    10931126+       strcpy(napi_dev->name, "switch%d"); 
     1127+       napi_dev->features = NETIF_F_IP_CSUM | NETIF_F_SG; 
    10941128+ 
    10951129+       SET_NETDEV_DEV(napi_dev, &pdev->dev); 
     
    11041138+       } 
    11051139+ 
    1106 +       sw->mtu = 1536 + SKB_DMA_REALIGN; 
    1107 + 
    11081140+       for (i = 0; i < 4; i++) { 
    11091141+               temp = __raw_readl(&sw->regs->mac_cfg[i]); 
    1110 +               temp |= (PORT_DISABLE) | 0x80000000; 
     1142+               temp |= (PORT_DISABLE); 
    11111143+               __raw_writel(temp, &sw->regs->mac_cfg[i]); 
    11121144+       } 
     
    11191151+       __raw_writel(temp, &sw->regs->vlan_cfg); 
    11201152+ 
    1121 +       __raw_writel(UNKNOWN_VLAN_TO_CPU | ACCEPT_CRC_PACKET | 
     1153+       __raw_writel(UNKNOWN_VLAN_TO_CPU | 
    11221154+                    CRC_STRIPPING, &sw->regs->mac_glob_cfg); 
    11231155+ 
     
    11521184+               } 
    11531185+ 
    1154 +               //SET_NETDEV_DEV(dev, &pdev->dev); 
    11551186+               port = netdev_priv(dev); 
    11561187+               port->netdev = dev; 
     
    11601191+                       port->id = i; 
    11611192+               port->sw = sw; 
    1162 +               port->mtu = sw->mtu; 
    11631193+ 
    11641194+               temp = __raw_readl(&sw->regs->mac_cfg[port->id]); 
    1165 +               temp |= (PORT_DISABLE); 
     1195+               temp |= (PORT_DISABLE | PORT_BLOCK_STATE | PORT_LEARN_DIS); 
    11661196+               __raw_writel(temp, &sw->regs->mac_cfg[port->id]); 
    11671197+ 
     
    11691199+               dev->ethtool_ops = &cns3xxx_ethtool_ops; 
    11701200+               dev->tx_queue_len = 1000; 
    1171 +               dev->features = NETIF_F_HW_CSUM; 
    1172 + 
    1173 +               dev->vlan_features = NETIF_F_HW_CSUM; 
    1174 + 
    1175 +               switch_port_tab[i] = port; 
     1201+               dev->features = NETIF_F_IP_CSUM | NETIF_F_SG; 
     1202+ 
     1203+               switch_port_tab[port->id] = port; 
    11761204+               memcpy(dev->dev_addr, &plat->hwaddr[i], ETH_ALEN); 
    11771205+ 
     
    11801208+                       PHY_INTERFACE_MODE_RGMII); 
    11811209+               if ((err = IS_ERR(port->phydev))) { 
    1182 +                       switch_port_tab[i] = 0; 
     1210+                       switch_port_tab[port->id] = 0; 
    11831211+                       free_netdev(dev); 
    11841212+                       goto free_ports; 
    11851213+               } 
    11861214+ 
    1187 +               port->phydev->irq = PHY_POLL; 
     1215+               port->phydev->irq = PHY_IGNORE_INTERRUPT; 
    11881216+ 
    11891217+               if ((err = register_netdev(dev))) { 
    11901218+                       phy_disconnect(port->phydev); 
    1191 +                       switch_port_tab[i] = 0; 
     1219+                       switch_port_tab[port->id] = 0; 
    11921220+                       free_netdev(dev); 
    11931221+                       goto free_ports; 
     
    12291257+       destroy_rings(sw); 
    12301258+ 
    1231 +       for (i = 2; i >= 0; i--) { 
     1259+       for (i = 3; i >= 0; i--) { 
    12321260+               if (switch_port_tab[i]) { 
    12331261+                       struct port *port = switch_port_tab[i]; 
Note: See TracChangeset for help on using the changeset viewer.