1/* 2 * IXP2000 MSF network device driver 3 * Copyright (C) 2004, 2005 Lennert Buytenhek <buytenh@wantstofly.org> 4 * Dedicated to Marija Kulikova. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 12#include <linux/module.h> 13#include <linux/kernel.h> 14#include <linux/netdevice.h> 15#include <linux/etherdevice.h> 16#include <linux/init.h> 17#include <linux/moduleparam.h> 18#include <linux/gfp.h> 19#include <asm/hardware/uengine.h> 20#include <asm/io.h> 21#include "ixp2400_rx.ucode" 22#include "ixp2400_tx.ucode" 23#include "ixpdev_priv.h" 24#include "ixpdev.h" 25#include "pm3386.h" 26 27#define DRV_MODULE_VERSION "0.2" 28 29static int nds_count; 30static struct net_device **nds; 31static int nds_open; 32static void (*set_port_admin_status)(int port, int up); 33 34static struct ixpdev_rx_desc * const rx_desc = 35 (struct ixpdev_rx_desc *)(IXP2000_SRAM0_VIRT_BASE + RX_BUF_DESC_BASE); 36static struct ixpdev_tx_desc * const tx_desc = 37 (struct ixpdev_tx_desc *)(IXP2000_SRAM0_VIRT_BASE + TX_BUF_DESC_BASE); 38static int tx_pointer; 39 40 41static int ixpdev_xmit(struct sk_buff *skb, struct net_device *dev) 42{ 43 struct ixpdev_priv *ip = netdev_priv(dev); 44 struct ixpdev_tx_desc *desc; 45 int entry; 46 unsigned long flags; 47 48 if (unlikely(skb->len > PAGE_SIZE)) { 49 /* @@@ Count drops. */ 50 dev_kfree_skb(skb); 51 return NETDEV_TX_OK; 52 } 53 54 entry = tx_pointer; 55 tx_pointer = (tx_pointer + 1) % TX_BUF_COUNT; 56 57 desc = tx_desc + entry; 58 desc->pkt_length = skb->len; 59 desc->channel = ip->channel; 60 61 skb_copy_and_csum_dev(skb, phys_to_virt(desc->buf_addr)); 62 dev_kfree_skb(skb); 63 64 ixp2000_reg_write(RING_TX_PENDING, 65 TX_BUF_DESC_BASE + (entry * sizeof(struct ixpdev_tx_desc))); 66 67 local_irq_save(flags); 68 ip->tx_queue_entries++; 69 if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN) 70 netif_stop_queue(dev); 71 local_irq_restore(flags); 72 73 return NETDEV_TX_OK; 74} 75 76 77static int ixpdev_rx(struct net_device *dev, int processed, int budget) 78{ 79 while (processed < budget) { 80 struct ixpdev_rx_desc *desc; 81 struct sk_buff *skb; 82 void *buf; 83 u32 _desc; 84 85 _desc = ixp2000_reg_read(RING_RX_DONE); 86 if (_desc == 0) 87 return 0; 88 89 desc = rx_desc + 90 ((_desc - RX_BUF_DESC_BASE) / sizeof(struct ixpdev_rx_desc)); 91 buf = phys_to_virt(desc->buf_addr); 92 93 if (desc->pkt_length < 4 || desc->pkt_length > PAGE_SIZE) { 94 printk(KERN_ERR "ixp2000: rx err, length %d\n", 95 desc->pkt_length); 96 goto err; 97 } 98 99 if (desc->channel < 0 || desc->channel >= nds_count) { 100 printk(KERN_ERR "ixp2000: rx err, channel %d\n", 101 desc->channel); 102 goto err; 103 } 104 105 /* @@@ Make FCS stripping configurable. */ 106 desc->pkt_length -= 4; 107 108 if (unlikely(!netif_running(nds[desc->channel]))) 109 goto err; 110 111 skb = netdev_alloc_skb_ip_align(dev, desc->pkt_length); 112 if (likely(skb != NULL)) { 113 skb_copy_to_linear_data(skb, buf, desc->pkt_length); 114 skb_put(skb, desc->pkt_length); 115 skb->protocol = eth_type_trans(skb, nds[desc->channel]); 116 117 netif_receive_skb(skb); 118 } 119 120err: 121 ixp2000_reg_write(RING_RX_PENDING, _desc); 122 processed++; 123 } 124 125 return processed; 126} 127 128/* dev always points to nds[0]. */ 129static int ixpdev_poll(struct napi_struct *napi, int budget) 130{ 131 struct ixpdev_priv *ip = container_of(napi, struct ixpdev_priv, napi); 132 struct net_device *dev = ip->dev; 133 int rx; 134 135 rx = 0; 136 do { 137 ixp2000_reg_write(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0x00ff); 138 139 rx = ixpdev_rx(dev, rx, budget); 140 if (rx >= budget) 141 break; 142 } while (ixp2000_reg_read(IXP2000_IRQ_THD_RAW_STATUS_A_0) & 0x00ff); 143 144 napi_complete(napi); 145 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0x00ff); 146 147 return rx; 148} 149 150static void ixpdev_tx_complete(void) 151{ 152 int channel; 153 u32 wake; 154 155 wake = 0; 156 while (1) { 157 struct ixpdev_priv *ip; 158 u32 desc; 159 int entry; 160 161 desc = ixp2000_reg_read(RING_TX_DONE); 162 if (desc == 0) 163 break; 164 165 /* @@@ Check whether entries come back in order. */ 166 entry = (desc - TX_BUF_DESC_BASE) / sizeof(struct ixpdev_tx_desc); 167 channel = tx_desc[entry].channel; 168 169 if (channel < 0 || channel >= nds_count) { 170 printk(KERN_ERR "ixp2000: txcomp channel index " 171 "out of bounds (%d, %.8i, %d)\n", 172 channel, (unsigned int)desc, entry); 173 continue; 174 } 175 176 ip = netdev_priv(nds[channel]); 177 if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN) 178 wake |= 1 << channel; 179 ip->tx_queue_entries--; 180 } 181 182 for (channel = 0; wake != 0; channel++) { 183 if (wake & (1 << channel)) { 184 netif_wake_queue(nds[channel]); 185 wake &= ~(1 << channel); 186 } 187 } 188} 189 190static irqreturn_t ixpdev_interrupt(int irq, void *dev_id) 191{ 192 u32 status; 193 194 status = ixp2000_reg_read(IXP2000_IRQ_THD_STATUS_A_0); 195 if (status == 0) 196 return IRQ_NONE; 197 198 /* 199 * Any of the eight receive units signaled RX? 200 */ 201 if (status & 0x00ff) { 202 struct net_device *dev = nds[0]; 203 struct ixpdev_priv *ip = netdev_priv(dev); 204 205 ixp2000_reg_wrb(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0x00ff); 206 if (likely(napi_schedule_prep(&ip->napi))) { 207 __napi_schedule(&ip->napi); 208 } else { 209 printk(KERN_CRIT "ixp2000: irq while polling!!\n"); 210 } 211 } 212 213 /* 214 * Any of the eight transmit units signaled TXdone? 215 */ 216 if (status & 0xff00) { 217 ixp2000_reg_wrb(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0xff00); 218 ixpdev_tx_complete(); 219 } 220 221 return IRQ_HANDLED; 222} 223 224#ifdef CONFIG_NET_POLL_CONTROLLER 225static void ixpdev_poll_controller(struct net_device *dev) 226{ 227 disable_irq(IRQ_IXP2000_THDA0); 228 ixpdev_interrupt(IRQ_IXP2000_THDA0, dev); 229 enable_irq(IRQ_IXP2000_THDA0); 230} 231#endif 232 233static int ixpdev_open(struct net_device *dev) 234{ 235 struct ixpdev_priv *ip = netdev_priv(dev); 236 int err; 237 238 napi_enable(&ip->napi); 239 if (!nds_open++) { 240 err = request_irq(IRQ_IXP2000_THDA0, ixpdev_interrupt, 241 IRQF_SHARED, "ixp2000_eth", nds); 242 if (err) { 243 nds_open--; 244 napi_disable(&ip->napi); 245 return err; 246 } 247 248 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0xffff); 249 } 250 251 set_port_admin_status(ip->channel, 1); 252 netif_start_queue(dev); 253 254 return 0; 255} 256 257static int ixpdev_close(struct net_device *dev) 258{ 259 struct ixpdev_priv *ip = netdev_priv(dev); 260 261 netif_stop_queue(dev); 262 napi_disable(&ip->napi); 263 set_port_admin_status(ip->channel, 0); 264 265 if (!--nds_open) { 266 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0xffff); 267 free_irq(IRQ_IXP2000_THDA0, nds); 268 } 269 270 return 0; 271} 272 273static struct net_device_stats *ixpdev_get_stats(struct net_device *dev) 274{ 275 struct ixpdev_priv *ip = netdev_priv(dev); 276 277 pm3386_get_stats(ip->channel, &(dev->stats)); 278 279 return &(dev->stats); 280} 281 282static const struct net_device_ops ixpdev_netdev_ops = { 283 .ndo_open = ixpdev_open, 284 .ndo_stop = ixpdev_close, 285 .ndo_start_xmit = ixpdev_xmit, 286 .ndo_change_mtu = eth_change_mtu, 287 .ndo_validate_addr = eth_validate_addr, 288 .ndo_set_mac_address = eth_mac_addr, 289 .ndo_get_stats = ixpdev_get_stats, 290#ifdef CONFIG_NET_POLL_CONTROLLER 291 .ndo_poll_controller = ixpdev_poll_controller, 292#endif 293}; 294 295struct net_device *ixpdev_alloc(int channel, int sizeof_priv) 296{ 297 struct net_device *dev; 298 struct ixpdev_priv *ip; 299 300 dev = alloc_etherdev(sizeof_priv); 301 if (dev == NULL) 302 return NULL; 303 304 dev->netdev_ops = &ixpdev_netdev_ops; 305 306 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM; 307 308 ip = netdev_priv(dev); 309 ip->dev = dev; 310 netif_napi_add(dev, &ip->napi, ixpdev_poll, 64); 311 ip->channel = channel; 312 ip->tx_queue_entries = 0; 313 314 return dev; 315} 316 317int ixpdev_init(int __nds_count, struct net_device **__nds, 318 void (*__set_port_admin_status)(int port, int up)) 319{ 320 int i; 321 int err; 322 323 BUILD_BUG_ON(RX_BUF_COUNT > 192 || TX_BUF_COUNT > 192); 324 325 printk(KERN_INFO "IXP2000 MSF ethernet driver %s\n", DRV_MODULE_VERSION); 326 327 nds_count = __nds_count; 328 nds = __nds; 329 set_port_admin_status = __set_port_admin_status; 330 331 for (i = 0; i < RX_BUF_COUNT; i++) { 332 void *buf; 333 334 buf = (void *)get_zeroed_page(GFP_KERNEL); 335 if (buf == NULL) { 336 err = -ENOMEM; 337 while (--i >= 0) 338 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr)); 339 goto err_out; 340 } 341 rx_desc[i].buf_addr = virt_to_phys(buf); 342 rx_desc[i].buf_length = PAGE_SIZE; 343 } 344 345 /* @@@ Maybe we shouldn't be preallocating TX buffers. */ 346 for (i = 0; i < TX_BUF_COUNT; i++) { 347 void *buf; 348 349 buf = (void *)get_zeroed_page(GFP_KERNEL); 350 if (buf == NULL) { 351 err = -ENOMEM; 352 while (--i >= 0) 353 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr)); 354 goto err_free_rx; 355 } 356 tx_desc[i].buf_addr = virt_to_phys(buf); 357 } 358 359 /* 256 entries, ring status set means 'empty', base address 0x0000. */ 360 ixp2000_reg_write(RING_RX_PENDING_BASE, 0x44000000); 361 ixp2000_reg_write(RING_RX_PENDING_HEAD, 0x00000000); 362 ixp2000_reg_write(RING_RX_PENDING_TAIL, 0x00000000); 363 364 /* 256 entries, ring status set means 'full', base address 0x0400. */ 365 ixp2000_reg_write(RING_RX_DONE_BASE, 0x40000400); 366 ixp2000_reg_write(RING_RX_DONE_HEAD, 0x00000000); 367 ixp2000_reg_write(RING_RX_DONE_TAIL, 0x00000000); 368 369 for (i = 0; i < RX_BUF_COUNT; i++) { 370 ixp2000_reg_write(RING_RX_PENDING, 371 RX_BUF_DESC_BASE + (i * sizeof(struct ixpdev_rx_desc))); 372 } 373 374 ixp2000_uengine_load(0, &ixp2400_rx); 375 ixp2000_uengine_start_contexts(0, 0xff); 376 377 /* 256 entries, ring status set means 'empty', base address 0x0800. */ 378 ixp2000_reg_write(RING_TX_PENDING_BASE, 0x44000800); 379 ixp2000_reg_write(RING_TX_PENDING_HEAD, 0x00000000); 380 ixp2000_reg_write(RING_TX_PENDING_TAIL, 0x00000000); 381 382 /* 256 entries, ring status set means 'full', base address 0x0c00. */ 383 ixp2000_reg_write(RING_TX_DONE_BASE, 0x40000c00); 384 ixp2000_reg_write(RING_TX_DONE_HEAD, 0x00000000); 385 ixp2000_reg_write(RING_TX_DONE_TAIL, 0x00000000); 386 387 ixp2000_uengine_load(1, &ixp2400_tx); 388 ixp2000_uengine_start_contexts(1, 0xff); 389 390 for (i = 0; i < nds_count; i++) { 391 err = register_netdev(nds[i]); 392 if (err) { 393 while (--i >= 0) 394 unregister_netdev(nds[i]); 395 goto err_free_tx; 396 } 397 } 398 399 for (i = 0; i < nds_count; i++) { 400 printk(KERN_INFO "%s: IXP2000 MSF ethernet (port %d), " 401 "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x.\n", nds[i]->name, i, 402 nds[i]->dev_addr[0], nds[i]->dev_addr[1], 403 nds[i]->dev_addr[2], nds[i]->dev_addr[3], 404 nds[i]->dev_addr[4], nds[i]->dev_addr[5]); 405 } 406 407 return 0; 408 409err_free_tx: 410 for (i = 0; i < TX_BUF_COUNT; i++) 411 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr)); 412 413err_free_rx: 414 for (i = 0; i < RX_BUF_COUNT; i++) 415 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr)); 416 417err_out: 418 return err; 419} 420 421void ixpdev_deinit(void) 422{ 423 int i; 424 425 /* @@@ Flush out pending packets. */ 426 427 for (i = 0; i < nds_count; i++) 428 unregister_netdev(nds[i]); 429 430 ixp2000_uengine_stop_contexts(1, 0xff); 431 ixp2000_uengine_stop_contexts(0, 0xff); 432 ixp2000_uengine_reset(0x3); 433 434 for (i = 0; i < TX_BUF_COUNT; i++) 435 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr)); 436 437 for (i = 0; i < RX_BUF_COUNT; i++) 438 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr)); 439} 440