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