?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs: use kmem_cache_zalloc instead
[pv_ops_mirror.git] / drivers / net / rrunner.c
blob19152f54ef2b4f80a357b4b2ba59393a3ab721aa
1 /*
2 * rrunner.c: Linux driver for the Essential RoadRunner HIPPI board.
3 *
4 * Copyright (C) 1998-2002 by Jes Sorensen, <jes@wildopensource.com>.
5 *
6 * Thanks to Essential Communication for providing us with hardware
7 * and very comprehensive documentation without which I would not have
8 * been able to write this driver. A special thank you to John Gibbon
9 * for sorting out the legal issues, with the NDA, allowing the code to
10 * be released under the GPL.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * Thanks to Jayaram Bhat from ODS/Essential for fixing some of the
18 * stupid bugs in my code.
19 *
20 * Softnet support and various other patches from Val Henson of
21 * ODS/Essential.
22 *
23 * PCI DMA mapping code partly based on work by Francois Romieu.
24 */
25
26
27 #define DEBUG 1
28 #define RX_DMA_SKBUFF 1
29 #define PKT_COPY_THRESHOLD 512
30
31 #include <linux/module.h>
32 #include <linux/types.h>
33 #include <linux/errno.h>
34 #include <linux/ioport.h>
35 #include <linux/pci.h>
36 #include <linux/kernel.h>
37 #include <linux/netdevice.h>
38 #include <linux/hippidevice.h>
39 #include <linux/skbuff.h>
40 #include <linux/init.h>
41 #include <linux/delay.h>
42 #include <linux/mm.h>
43 #include <net/sock.h>
44
45 #include <asm/system.h>
46 #include <asm/cache.h>
47 #include <asm/byteorder.h>
48 #include <asm/io.h>
49 #include <asm/irq.h>
50 #include <asm/uaccess.h>
51
52 #define rr_if_busy(dev) netif_queue_stopped(dev)
53 #define rr_if_running(dev) netif_running(dev)
54
55 #include "rrunner.h"
56
57 #define RUN_AT(x) (jiffies + (x))
58
59
60 MODULE_AUTHOR("Jes Sorensen <jes@wildopensource.com>");
61 MODULE_DESCRIPTION("Essential RoadRunner HIPPI driver");
62 MODULE_LICENSE("GPL");
63
64 static char version[] __devinitdata = "rrunner.c: v0.50 11/11/2002 Jes Sorensen (jes@wildopensource.com)\n";
65
66 /*
67 * Implementation notes:
68 *
69 * The DMA engine only allows for DMA within physical 64KB chunks of
70 * memory. The current approach of the driver (and stack) is to use
71 * linear blocks of memory for the skbuffs. However, as the data block
72 * is always the first part of the skb and skbs are 2^n aligned so we
73 * are guarantted to get the whole block within one 64KB align 64KB
74 * chunk.
75 *
76 * On the long term, relying on being able to allocate 64KB linear
77 * chunks of memory is not feasible and the skb handling code and the
78 * stack will need to know about I/O vectors or something similar.
79 */
80
81 /*
82 * These are checked at init time to see if they are at least 256KB
83 * and increased to 256KB if they are not. This is done to avoid ending
84 * up with socket buffers smaller than the MTU size,
85 */
86 extern __u32 sysctl_wmem_max;
87 extern __u32 sysctl_rmem_max;
88
89 static int __devinit rr_init_one(struct pci_dev *pdev,
90 const struct pci_device_id *ent)
91 {
92 struct net_device *dev;
93 static int version_disp;
94 u8 pci_latency;
95 struct rr_private *rrpriv;
96 void *tmpptr;
97 dma_addr_t ring_dma;
98 int ret = -ENOMEM;
99
100 dev = alloc_hippi_dev(sizeof(struct rr_private));
101 if (!dev)
102 goto out3;
103
104 ret = pci_enable_device(pdev);
105 if (ret) {
106 ret = -ENODEV;
107 goto out2;
108 }
109
110 rrpriv = netdev_priv(dev);
111
112 SET_NETDEV_DEV(dev, &pdev->dev);
113
114 if (pci_request_regions(pdev, "rrunner")) {
115 ret = -EIO;
116 goto out;
117 }
118
119 pci_set_drvdata(pdev, dev);
120
121 rrpriv->pci_dev = pdev;
122
123 spin_lock_init(&rrpriv->lock);
124
125 dev->irq = pdev->irq;
126 dev->open = &rr_open;
127 dev->hard_start_xmit = &rr_start_xmit;
128 dev->stop = &rr_close;
129 dev->do_ioctl = &rr_ioctl;
130
131 dev->base_addr = pci_resource_start(pdev, 0);
132
133 /* display version info if adapter is found */
134 if (!version_disp) {
135 /* set display flag to TRUE so that */
136 /* we only display this string ONCE */
137 version_disp = 1;
138 printk(version);
139 }
140
141 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
142 if (pci_latency <= 0x58){
143 pci_latency = 0x58;
144 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, pci_latency);
145 }
146
147 pci_set_master(pdev);
148
149 printk(KERN_INFO "%s: Essential RoadRunner serial HIPPI "
150 "at 0x%08lx, irq %i, PCI latency %i\n", dev->name,
151 dev->base_addr, dev->irq, pci_latency);
152
153 /*
154 * Remap the regs into kernel space.
155 */
156
157 rrpriv->regs = ioremap(dev->base_addr, 0x1000);
158
159 if (!rrpriv->regs){
160 printk(KERN_ERR "%s: Unable to map I/O register, "
161 "RoadRunner will be disabled.\n", dev->name);
162 ret = -EIO;
163 goto out;
164 }
165
166 tmpptr = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
167 rrpriv->tx_ring = tmpptr;
168 rrpriv->tx_ring_dma = ring_dma;
169
170 if (!tmpptr) {
171 ret = -ENOMEM;
172 goto out;
173 }
174
175 tmpptr = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
176 rrpriv->rx_ring = tmpptr;
177 rrpriv->rx_ring_dma = ring_dma;
178
179 if (!tmpptr) {
180 ret = -ENOMEM;
181 goto out;
182 }
183
184 tmpptr = pci_alloc_consistent(pdev, EVT_RING_SIZE, &ring_dma);
185 rrpriv->evt_ring = tmpptr;
186 rrpriv->evt_ring_dma = ring_dma;
187
188 if (!tmpptr) {
189 ret = -ENOMEM;
190 goto out;
191 }
192
193 /*
194 * Don't access any register before this point!
195 */
196 #ifdef __BIG_ENDIAN
197 writel(readl(&rrpriv->regs->HostCtrl) | NO_SWAP,
198 &rrpriv->regs->HostCtrl);
199 #endif
200 /*
201 * Need to add a case for little-endian 64-bit hosts here.
202 */
203
204 rr_init(dev);
205
206 dev->base_addr = 0;
207
208 ret = register_netdev(dev);
209 if (ret)
210 goto out;
211 return 0;
212
213 out:
214 if (rrpriv->rx_ring)
215 pci_free_consistent(pdev, RX_TOTAL_SIZE, rrpriv->rx_ring,
216 rrpriv->rx_ring_dma);
217 if (rrpriv->tx_ring)
218 pci_free_consistent(pdev, TX_TOTAL_SIZE, rrpriv->tx_ring,
219 rrpriv->tx_ring_dma);
220 if (rrpriv->regs)
221 iounmap(rrpriv->regs);
222 if (pdev) {
223 pci_release_regions(pdev);
224 pci_set_drvdata(pdev, NULL);
225 }
226 out2:
227 free_netdev(dev);
228 out3:
229 return ret;
230 }
231
232 static void __devexit rr_remove_one (struct pci_dev *pdev)
233 {
234 struct net_device *dev = pci_get_drvdata(pdev);
235
236 if (dev) {
237 struct rr_private *rr = netdev_priv(dev);
238
239 if (!(readl(&rr->regs->HostCtrl) & NIC_HALTED)){
240 printk(KERN_ERR "%s: trying to unload running NIC\n",
241 dev->name);
242 writel(HALT_NIC, &rr->regs->HostCtrl);
243 }
244
245 pci_free_consistent(pdev, EVT_RING_SIZE, rr->evt_ring,
246 rr->evt_ring_dma);
247 pci_free_consistent(pdev, RX_TOTAL_SIZE, rr->rx_ring,
248 rr->rx_ring_dma);
249 pci_free_consistent(pdev, TX_TOTAL_SIZE, rr->tx_ring,
250 rr->tx_ring_dma);
251 unregister_netdev(dev);
252 iounmap(rr->regs);
253 free_netdev(dev);
254 pci_release_regions(pdev);
255 pci_disable_device(pdev);
256 pci_set_drvdata(pdev, NULL);
257 }
258 }
259
260
261 /*
262 * Commands are considered to be slow, thus there is no reason to
263 * inline this.
264 */
265 static void rr_issue_cmd(struct rr_private *rrpriv, struct cmd *cmd)
266 {
267 struct rr_regs __iomem *regs;
268 u32 idx;
269
270 regs = rrpriv->regs;
271 /*
272 * This is temporary - it will go away in the final version.
273 * We probably also want to make this function inline.
274 */
275 if (readl(&regs->HostCtrl) & NIC_HALTED){
276 printk("issuing command for halted NIC, code 0x%x, "
277 "HostCtrl %08x\n", cmd->code, readl(&regs->HostCtrl));
278 if (readl(&regs->Mode) & FATAL_ERR)
279 printk("error codes Fail1 %02x, Fail2 %02x\n",
280 readl(&regs->Fail1), readl(&regs->Fail2));
281 }
282
283 idx = rrpriv->info->cmd_ctrl.pi;
284
285 writel(*(u32*)(cmd), &regs->CmdRing[idx]);
286 wmb();
287
288 idx = (idx - 1) % CMD_RING_ENTRIES;
289 rrpriv->info->cmd_ctrl.pi = idx;
290 wmb();
291
292 if (readl(&regs->Mode) & FATAL_ERR)
293 printk("error code %02x\n", readl(&regs->Fail1));
294 }
295
296
297 /*
298 * Reset the board in a sensible manner. The NIC is already halted
299 * when we get here and a spin-lock is held.
300 */
301 static int rr_reset(struct net_device *dev)
302 {
303 struct rr_private *rrpriv;
304 struct rr_regs __iomem *regs;
305 struct eeprom *hw = NULL;
306 u32 start_pc;
307 int i;
308
309 rrpriv = netdev_priv(dev);
310 regs = rrpriv->regs;
311
312 rr_load_firmware(dev);
313
314 writel(0x01000000, &regs->TX_state);
315 writel(0xff800000, &regs->RX_state);
316 writel(0, &regs->AssistState);
317 writel(CLEAR_INTA, &regs->LocalCtrl);
318 writel(0x01, &regs->BrkPt);
319 writel(0, &regs->Timer);
320 writel(0, &regs->TimerRef);
321 writel(RESET_DMA, &regs->DmaReadState);
322 writel(RESET_DMA, &regs->DmaWriteState);
323 writel(0, &regs->DmaWriteHostHi);
324 writel(0, &regs->DmaWriteHostLo);
325 writel(0, &regs->DmaReadHostHi);
326 writel(0, &regs->DmaReadHostLo);
327 writel(0, &regs->DmaReadLen);
328 writel(0, &regs->DmaWriteLen);
329 writel(0, &regs->DmaWriteLcl);
330 writel(0, &regs->DmaWriteIPchecksum);
331 writel(0, &regs->DmaReadLcl);
332 writel(0, &regs->DmaReadIPchecksum);
333 writel(0, &regs->PciState);
334 #if (BITS_PER_LONG == 64) && defined __LITTLE_ENDIAN
335 writel(SWAP_DATA | PTR64BIT | PTR_WD_SWAP, &regs->Mode);
336 #elif (BITS_PER_LONG == 64)
337 writel(SWAP_DATA | PTR64BIT | PTR_WD_NOSWAP, &regs->Mode);
338 #else
339 writel(SWAP_DATA | PTR32BIT | PTR_WD_NOSWAP, &regs->Mode);
340 #endif
341
342 #if 0
343 /*
344 * Don't worry, this is just black magic.
345 */
346 writel(0xdf000, &regs->RxBase);
347 writel(0xdf000, &regs->RxPrd);
348 writel(0xdf000, &regs->RxCon);
349 writel(0xce000, &regs->TxBase);
350 writel(0xce000, &regs->TxPrd);
351 writel(0xce000, &regs->TxCon);
352 writel(0, &regs->RxIndPro);
353 writel(0, &regs->RxIndCon);
354 writel(0, &regs->RxIndRef);
355 writel(0, &regs->TxIndPro);
356 writel(0, &regs->TxIndCon);
357 writel(0, &regs->TxIndRef);
358 writel(0xcc000, &regs->pad10[0]);
359 writel(0, &regs->DrCmndPro);
360 writel(0, &regs->DrCmndCon);
361 writel(0, &regs->DwCmndPro);
362 writel(0, &regs->DwCmndCon);
363 writel(0, &regs->DwCmndRef);
364 writel(0, &regs->DrDataPro);
365 writel(0, &regs->DrDataCon);
366 writel(0, &regs->DrDataRef);
367 writel(0, &regs->DwDataPro);
368 writel(0, &regs->DwDataCon);
369 writel(0, &regs->DwDataRef);
370 #endif
371
372 writel(0xffffffff, &regs->MbEvent);
373 writel(0, &regs->Event);
374
375 writel(0, &regs->TxPi);
376 writel(0, &regs->IpRxPi);
377
378 writel(0, &regs->EvtCon);
379 writel(0, &regs->EvtPrd);
380
381 rrpriv->info->evt_ctrl.pi = 0;
382
383 for (i = 0; i < CMD_RING_ENTRIES; i++)
384 writel(0, &regs->CmdRing[i]);
385
386 /*
387 * Why 32 ? is this not cache line size dependent?
388 */
389 writel(RBURST_64|WBURST_64, &regs->PciState);
390 wmb();
391
392 start_pc = rr_read_eeprom_word(rrpriv, &hw->rncd_info.FwStart);
393
394 #if (DEBUG > 1)
395 printk("%s: Executing firmware at address 0x%06x\n",
396 dev->name, start_pc);
397 #endif
398
399 writel(start_pc + 0x800, &regs->Pc);
400 wmb();
401 udelay(5);
402
403 writel(start_pc, &regs->Pc);
404 wmb();
405
406 return 0;
407 }
408
409
410 /*
411 * Read a string from the EEPROM.
412 */
413 static unsigned int rr_read_eeprom(struct rr_private *rrpriv,
414 unsigned long offset,
415 unsigned char *buf,
416 unsigned long length)
417 {
418 struct rr_regs __iomem *regs = rrpriv->regs;
419 u32 misc, io, host, i;
420
421 io = readl(&regs->ExtIo);
422 writel(0, &regs->ExtIo);
423 misc = readl(&regs->LocalCtrl);
424 writel(0, &regs->LocalCtrl);
425 host = readl(&regs->HostCtrl);
426 writel(host | HALT_NIC, &regs->HostCtrl);
427 mb();
428
429 for (i = 0; i < length; i++){
430 writel((EEPROM_BASE + ((offset+i) << 3)), &regs->WinBase);
431 mb();
432 buf[i] = (readl(&regs->WinData) >> 24) & 0xff;
433 mb();
434 }
435
436 writel(host, &regs->HostCtrl);
437 writel(misc, &regs->LocalCtrl);
438 writel(io, &regs->ExtIo);
439 mb();
440 return i;
441 }
442
443
444 /*
445 * Shortcut to read one word (4 bytes) out of the EEPROM and convert
446 * it to our CPU byte-order.
447 */
448 static u32 rr_read_eeprom_word(struct rr_private *rrpriv,
449 void * offset)
450 {
451 u32 word;
452
453 if ((rr_read_eeprom(rrpriv, (unsigned long)offset,
454 (char *)&word, 4) == 4))
455 return be32_to_cpu(word);
456 return 0;
457 }
458
459
460 /*
461 * Write a string to the EEPROM.
462 *
463 * This is only called when the firmware is not running.
464 */
465 static unsigned int write_eeprom(struct rr_private *rrpriv,
466 unsigned long offset,
467 unsigned char *buf,
468 unsigned long length)
469 {
470 struct rr_regs __iomem *regs = rrpriv->regs;
471 u32 misc, io, data, i, j, ready, error = 0;
472
473 io = readl(&regs->ExtIo);
474 writel(0, &regs->ExtIo);
475 misc = readl(&regs->LocalCtrl);
476 writel(ENABLE_EEPROM_WRITE, &regs->LocalCtrl);
477 mb();
478
479 for (i = 0; i < length; i++){
480 writel((EEPROM_BASE + ((offset+i) << 3)), &regs->WinBase);
481 mb();
482 data = buf[i] << 24;
483 /*
484 * Only try to write the data if it is not the same
485 * value already.
486 */
487 if ((readl(&regs->WinData) & 0xff000000) != data){
488 writel(data, &regs->WinData);
489 ready = 0;
490 j = 0;
491 mb();
492 while(!ready){
493 udelay(20);
494 if ((readl(&regs->WinData) & 0xff000000) ==
495 data)
496 ready = 1;
497 mb();
498 if (j++ > 5000){
499 printk("data mismatch: %08x, "
500 "WinData %08x\n", data,
501 readl(&regs->WinData));
502 ready = 1;
503 error = 1;
504 }
505 }
506 }
507 }
508
509 writel(misc, &regs->LocalCtrl);
510 writel(io, &regs->ExtIo);
511 mb();
512
513 return error;
514 }
515
516
517 static int __devinit rr_init(struct net_device *dev)
518 {
519 struct rr_private *rrpriv;
520 struct rr_regs __iomem *regs;
521 struct eeprom *hw = NULL;
522 u32 sram_size, rev;
523 DECLARE_MAC_BUF(mac);
524
525 rrpriv = netdev_priv(dev);
526 regs = rrpriv->regs;
527
528 rev = readl(&regs->FwRev);
529 rrpriv->fw_rev = rev;
530 if (rev > 0x00020024)
531 printk(" Firmware revision: %i.%i.%i\n", (rev >> 16),
532 ((rev >> 8) & 0xff), (rev & 0xff));
533 else if (rev >= 0x00020000) {
534 printk(" Firmware revision: %i.%i.%i (2.0.37 or "
535 "later is recommended)\n", (rev >> 16),
536 ((rev >> 8) & 0xff), (rev & 0xff));
537 }else{
538 printk(" Firmware revision too old: %i.%i.%i, please "
539 "upgrade to 2.0.37 or later.\n",
540 (rev >> 16), ((rev >> 8) & 0xff), (rev & 0xff));
541 }
542
543 #if (DEBUG > 2)
544 printk(" Maximum receive rings %i\n", readl(&regs->MaxRxRng));
545 #endif
546
547 /*
548 * Read the hardware address from the eeprom. The HW address
549 * is not really necessary for HIPPI but awfully convenient.
550 * The pointer arithmetic to put it in dev_addr is ugly, but
551 * Donald Becker does it this way for the GigE version of this
552 * card and it's shorter and more portable than any
553 * other method I've seen. -VAL
554 */
555
556 *(u16 *)(dev->dev_addr) =
557 htons(rr_read_eeprom_word(rrpriv, &hw->manf.BoardULA));
558 *(u32 *)(dev->dev_addr+2) =
559 htonl(rr_read_eeprom_word(rrpriv, &hw->manf.BoardULA[4]));
560
561 printk(" MAC: %s\n", print_mac(mac, dev->dev_addr));
562
563 sram_size = rr_read_eeprom_word(rrpriv, (void *)8);
564 printk(" SRAM size 0x%06x\n", sram_size);
565
566 if (sysctl_rmem_max < 262144){
567 printk(" Receive socket buffer limit too low (%i), "
568 "setting to 262144\n", sysctl_rmem_max);
569 sysctl_rmem_max = 262144;
570 }
571
572 if (sysctl_wmem_max < 262144){
573 printk(" Transmit socket buffer limit too low (%i), "
574 "setting to 262144\n", sysctl_wmem_max);
575 sysctl_wmem_max = 262144;
576 }
577
578 return 0;
579 }
580
581
582 static int rr_init1(struct net_device *dev)
583 {
584 struct rr_private *rrpriv;
585 struct rr_regs __iomem *regs;
586 unsigned long myjif, flags;
587 struct cmd cmd;
588 u32 hostctrl;
589 int ecode = 0;
590 short i;
591
592 rrpriv = netdev_priv(dev);
593 regs = rrpriv->regs;
594
595 spin_lock_irqsave(&rrpriv->lock, flags);
596
597 hostctrl = readl(&regs->HostCtrl);
598 writel(hostctrl | HALT_NIC | RR_CLEAR_INT, &regs->HostCtrl);
599 wmb();
600
601 if (hostctrl & PARITY_ERR){
602 printk("%s: Parity error halting NIC - this is serious!\n",
603 dev->name);
604 spin_unlock_irqrestore(&rrpriv->lock, flags);
605 ecode = -EFAULT;
606 goto error;
607 }
608
609 set_rxaddr(regs, rrpriv->rx_ctrl_dma);
610 set_infoaddr(regs, rrpriv->info_dma);
611
612 rrpriv->info->evt_ctrl.entry_size = sizeof(struct event);
613 rrpriv->info->evt_ctrl.entries = EVT_RING_ENTRIES;
614 rrpriv->info->evt_ctrl.mode = 0;
615 rrpriv->info->evt_ctrl.pi = 0;
616 set_rraddr(&rrpriv->info->evt_ctrl.rngptr, rrpriv->evt_ring_dma);
617
618 rrpriv->info->cmd_ctrl.entry_size = sizeof(struct cmd);
619 rrpriv->info->cmd_ctrl.entries = CMD_RING_ENTRIES;
620 rrpriv->info->cmd_ctrl.mode = 0;
621 rrpriv->info->cmd_ctrl.pi = 15;
622
623 for (i = 0; i < CMD_RING_ENTRIES; i++) {
624 writel(0, &regs->CmdRing[i]);
625 }
626
627 for (i = 0; i < TX_RING_ENTRIES; i++) {
628 rrpriv->tx_ring[i].size = 0;
629 set_rraddr(&rrpriv->tx_ring[i].addr, 0);
630 rrpriv->tx_skbuff[i] = NULL;
631 }
632 rrpriv->info->tx_ctrl.entry_size = sizeof(struct tx_desc);
633 rrpriv->info->tx_ctrl.entries = TX_RING_ENTRIES;
634 rrpriv->info->tx_ctrl.mode = 0;
635 rrpriv->info->tx_ctrl.pi = 0;
636 set_rraddr(&rrpriv->info->tx_ctrl.rngptr, rrpriv->tx_ring_dma);
637
638 /*
639 * Set dirty_tx before we start receiving interrupts, otherwise
640 * the interrupt handler might think it is supposed to process
641 * tx ints before we are up and running, which may cause a null
642 * pointer access in the int handler.
643 */
644 rrpriv->tx_full = 0;
645 rrpriv->cur_rx = 0;
646 rrpriv->dirty_rx = rrpriv->dirty_tx = 0;
647
648 rr_reset(dev);
649
650 /* Tuning values */
651 writel(0x5000, &regs->ConRetry);
652 writel(0x100, &regs->ConRetryTmr);
653 writel(0x500000, &regs->ConTmout);
654 writel(0x60, &regs->IntrTmr);
655 writel(0x500000, &regs->TxDataMvTimeout);
656 writel(0x200000, &regs->RxDataMvTimeout);
657 writel(0x80, &regs->WriteDmaThresh);
658 writel(0x80, &regs->ReadDmaThresh);
659
660 rrpriv->fw_running = 0;
661 wmb();
662
663 hostctrl &= ~(HALT_NIC | INVALID_INST_B | PARITY_ERR);
664 writel(hostctrl, &regs->HostCtrl);
665 wmb();
666
667 spin_unlock_irqrestore(&rrpriv->lock, flags);
668
669 for (i = 0; i < RX_RING_ENTRIES; i++) {
670 struct sk_buff *skb;
671 dma_addr_t addr;
672
673 rrpriv->rx_ring[i].mode = 0;
674 skb = alloc_skb(dev->mtu + HIPPI_HLEN, GFP_ATOMIC);
675 if (!skb) {
676 printk(KERN_WARNING "%s: Unable to allocate memory "
677 "for receive ring - halting NIC\n", dev->name);
678 ecode = -ENOMEM;
679 goto error;
680 }
681 rrpriv->rx_skbuff[i] = skb;
682 addr = pci_map_single(rrpriv->pci_dev, skb->data,
683 dev->mtu + HIPPI_HLEN, PCI_DMA_FROMDEVICE);
684 /*
685 * Sanity test to see if we conflict with the DMA
686 * limitations of the Roadrunner.
687 */
688 if ((((unsigned long)skb->data) & 0xfff) > ~65320)
689 printk("skb alloc error\n");
690
691 set_rraddr(&rrpriv->rx_ring[i].addr, addr);
692 rrpriv->rx_ring[i].size = dev->mtu + HIPPI_HLEN;
693 }
694
695 rrpriv->rx_ctrl[4].entry_size = sizeof(struct rx_desc);
696 rrpriv->rx_ctrl[4].entries = RX_RING_ENTRIES;
697 rrpriv->rx_ctrl[4].mode = 8;
698 rrpriv->rx_ctrl[4].pi = 0;
699 wmb();
700 set_rraddr(&rrpriv->rx_ctrl[4].rngptr, rrpriv->rx_ring_dma);
701
702 udelay(1000);
703
704 /*
705 * Now start the FirmWare.
706 */
707 cmd.code = C_START_FW;
708 cmd.ring = 0;
709 cmd.index = 0;
710
711 rr_issue_cmd(rrpriv, &cmd);
712
713 /*
714 * Give the FirmWare time to chew on the `get running' command.
715 */
716 myjif = jiffies + 5 * HZ;
717 while (time_before(jiffies, myjif) && !rrpriv->fw_running)
718 cpu_relax();
719
720 netif_start_queue(dev);
721
722 return ecode;
723
724 error:
725 /*
726 * We might have gotten here because we are out of memory,
727 * make sure we release everything we allocated before failing
728 */
729 for (i = 0; i < RX_RING_ENTRIES; i++) {
730 struct sk_buff *skb = rrpriv->rx_skbuff[i];
731
732 if (skb) {
733 pci_unmap_single(rrpriv->pci_dev,
734 rrpriv->rx_ring[i].addr.addrlo,
735 dev->mtu + HIPPI_HLEN,
736 PCI_DMA_FROMDEVICE);
737 rrpriv->rx_ring[i].size = 0;
738 set_rraddr(&rrpriv->rx_ring[i].addr, 0);
739 dev_kfree_skb(skb);
740 rrpriv->rx_skbuff[i] = NULL;
741 }
742 }
743 return ecode;
744 }
745
746
747 /*
748 * All events are considered to be slow (RX/TX ints do not generate
749 * events) and are handled here, outside the main interrupt handler,
750 * to reduce the size of the handler.
751 */
752 static u32 rr_handle_event(struct net_device *dev, u32 prodidx, u32 eidx)
753 {
754 struct rr_private *rrpriv;
755 struct rr_regs __iomem *regs;
756 u32 tmp;
757
758 rrpriv = netdev_priv(dev);
759 regs = rrpriv->regs;
760
761 while (prodidx != eidx){
762 switch (rrpriv->evt_ring[eidx].code){
763 case E_NIC_UP:
764 tmp = readl(&regs->FwRev);
765 printk(KERN_INFO "%s: Firmware revision %i.%i.%i "
766 "up and running\n", dev->name,
767 (tmp >> 16), ((tmp >> 8) & 0xff), (tmp & 0xff));
768 rrpriv->fw_running = 1;
769 writel(RX_RING_ENTRIES - 1, &regs->IpRxPi);
770 wmb();
771 break;
772 case E_LINK_ON:
773 printk(KERN_INFO "%s: Optical link ON\n", dev->name);
774 break;
775 case E_LINK_OFF:
776 printk(KERN_INFO "%s: Optical link OFF\n", dev->name);
777 break;
778 case E_RX_IDLE:
779 printk(KERN_WARNING "%s: RX data not moving\n",
780 dev->name);
781 goto drop;
782 case E_WATCHDOG:
783 printk(KERN_INFO "%s: The watchdog is here to see "
784 "us\n", dev->name);
785 break;
786 case E_INTERN_ERR:
787 printk(KERN_ERR "%s: HIPPI Internal NIC error\n",
788 dev->name);
789 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
790 &regs->HostCtrl);
791 wmb();
792 break;
793 case E_HOST_ERR:
794 printk(KERN_ERR "%s: Host software error\n",
795 dev->name);
796 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
797 &regs->HostCtrl);
798 wmb();
799 break;
800 /*
801 * TX events.
802 */
803 case E_CON_REJ:
804 printk(KERN_WARNING "%s: Connection rejected\n",
805 dev->name);
806 dev->stats.tx_aborted_errors++;
807 break;
808 case E_CON_TMOUT:
809 printk(KERN_WARNING "%s: Connection timeout\n",
810 dev->name);
811 break;
812 case E_DISC_ERR:
813 printk(KERN_WARNING "%s: HIPPI disconnect error\n",
814 dev->name);
815 dev->stats.tx_aborted_errors++;
816 break;
817 case E_INT_PRTY:
818 printk(KERN_ERR "%s: HIPPI Internal Parity error\n",
819 dev->name);
820 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
821 &regs->HostCtrl);
822 wmb();
823 break;
824 case E_TX_IDLE:
825 printk(KERN_WARNING "%s: Transmitter idle\n",
826 dev->name);
827 break;
828 case E_TX_LINK_DROP:
829 printk(KERN_WARNING "%s: Link lost during transmit\n",
830 dev->name);
831 dev->stats.tx_aborted_errors++;
832 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
833 &regs->HostCtrl);
834 wmb();
835 break;
836 case E_TX_INV_RNG:
837 printk(KERN_ERR "%s: Invalid send ring block\n",
838 dev->name);
839 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
840 &regs->HostCtrl);
841 wmb();
842 break;
843 case E_TX_INV_BUF:
844 printk(KERN_ERR "%s: Invalid send buffer address\n",
845 dev->name);
846 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
847 &regs->HostCtrl);
848 wmb();
849 break;
850 case E_TX_INV_DSC:
851 printk(KERN_ERR "%s: Invalid descriptor address\n",
852 dev->name);
853 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
854 &regs->HostCtrl);
855 wmb();
856 break;
857 /*
858 * RX events.
859 */
860 case E_RX_RNG_OUT:
861 printk(KERN_INFO "%s: Receive ring full\n", dev->name);
862 break;
863
864 case E_RX_PAR_ERR:
865 printk(KERN_WARNING "%s: Receive parity error\n",
866 dev->name);
867 goto drop;
868 case E_RX_LLRC_ERR:
869 printk(KERN_WARNING "%s: Receive LLRC error\n",
870 dev->name);
871 goto drop;
872 case E_PKT_LN_ERR:
873 printk(KERN_WARNING "%s: Receive packet length "
874 "error\n", dev->name);
875 goto drop;
876 case E_DTA_CKSM_ERR:
877 printk(KERN_WARNING "%s: Data checksum error\n",
878 dev->name);
879 goto drop;
880 case E_SHT_BST:
881 printk(KERN_WARNING "%s: Unexpected short burst "
882 "error\n", dev->name);
883 goto drop;
884 case E_STATE_ERR:
885 printk(KERN_WARNING "%s: Recv. state transition"
886 " error\n", dev->name);
887 goto drop;
888 case E_UNEXP_DATA:
889 printk(KERN_WARNING "%s: Unexpected data error\n",
890 dev->name);
891 goto drop;
892 case E_LST_LNK_ERR:
893 printk(KERN_WARNING "%s: Link lost error\n",
894 dev->name);
895 goto drop;
896 case E_FRM_ERR:
897 printk(KERN_WARNING "%s: Framming Error\n",
898 dev->name);
899 goto drop;
900 case E_FLG_SYN_ERR:
901 printk(KERN_WARNING "%s: Flag sync. lost during"
902 "packet\n", dev->name);
903 goto drop;
904 case E_RX_INV_BUF:
905 printk(KERN_ERR "%s: Invalid receive buffer "
906 "address\n", dev->name);
907 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
908 &regs->HostCtrl);
909 wmb();
910 break;
911 case E_RX_INV_DSC:
912 printk(KERN_ERR "%s: Invalid receive descriptor "
913 "address\n", dev->name);
914 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
915 &regs->HostCtrl);
916 wmb();
917 break;
918 case E_RNG_BLK:
919 printk(KERN_ERR "%s: Invalid ring block\n",
920 dev->name);
921 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
922 &regs->HostCtrl);
923 wmb();
924 break;
925 drop:
926 /* Label packet to be dropped.
927 * Actual dropping occurs in rx
928 * handling.
929 *
930 * The index of packet we get to drop is
931 * the index of the packet following
932 * the bad packet. -kbf
933 */
934 {
935 u16 index = rrpriv->evt_ring[eidx].index;
936 index = (index + (RX_RING_ENTRIES - 1)) %
937 RX_RING_ENTRIES;
938 rrpriv->rx_ring[index].mode |=
939 (PACKET_BAD | PACKET_END);
940 }
941 break;
942 default:
943 printk(KERN_WARNING "%s: Unhandled event 0x%02x\n",
944 dev->name, rrpriv->evt_ring[eidx].code);
945 }
946 eidx = (eidx + 1) % EVT_RING_ENTRIES;
947 }
948
949 rrpriv->info->evt_ctrl.pi = eidx;
950 wmb();
951 return eidx;
952 }
953
954
955 static void rx_int(struct net_device *dev, u32 rxlimit, u32 index)
956 {
957 struct rr_private *rrpriv = netdev_priv(dev);
958 struct rr_regs __iomem *regs = rrpriv->regs;
959
960 do {
961 struct rx_desc *desc;
962 u32 pkt_len;
963
964 desc = &(rrpriv->rx_ring[index]);
965 pkt_len = desc->size;
966 #if (DEBUG > 2)
967 printk("index %i, rxlimit %i\n", index, rxlimit);
968 printk("len %x, mode %x\n", pkt_len, desc->mode);
969 #endif
970 if ( (rrpriv->rx_ring[index].mode & PACKET_BAD) == PACKET_BAD){
971 dev->stats.rx_dropped++;
972 goto defer;
973 }
974
975 if (pkt_len > 0){
976 struct sk_buff *skb, *rx_skb;
977
978 rx_skb = rrpriv->rx_skbuff[index];
979
980 if (pkt_len < PKT_COPY_THRESHOLD) {
981 skb = alloc_skb(pkt_len, GFP_ATOMIC);
982 if (skb == NULL){
983 printk(KERN_WARNING "%s: Unable to allocate skb (%i bytes), deferring packet\n", dev->name, pkt_len);
984 dev->stats.rx_dropped++;
985 goto defer;
986 } else {
987 pci_dma_sync_single_for_cpu(rrpriv->pci_dev,
988 desc->addr.addrlo,
989 pkt_len,
990 PCI_DMA_FROMDEVICE);
991
992 memcpy(skb_put(skb, pkt_len),
993 rx_skb->data, pkt_len);
994
995 pci_dma_sync_single_for_device(rrpriv->pci_dev,
996 desc->addr.addrlo,
997 pkt_len,
998 PCI_DMA_FROMDEVICE);
999 }
1000 }else{
1001 struct sk_buff *newskb;
1002
1003 newskb = alloc_skb(dev->mtu + HIPPI_HLEN,
1004 GFP_ATOMIC);
1005 if (newskb){
1006 dma_addr_t addr;
1007
1008 pci_unmap_single(rrpriv->pci_dev,
1009 desc->addr.addrlo, dev->mtu +
1010 HIPPI_HLEN, PCI_DMA_FROMDEVICE);
1011 skb = rx_skb;
1012 skb_put(skb, pkt_len);
1013 rrpriv->rx_skbuff[index] = newskb;
1014 addr = pci_map_single(rrpriv->pci_dev,
1015 newskb->data,
1016 dev->mtu + HIPPI_HLEN,
1017 PCI_DMA_FROMDEVICE);
1018 set_rraddr(&desc->addr, addr);
1019 } else {
1020 printk("%s: Out of memory, deferring "
1021 "packet\n", dev->name);
1022 dev->stats.rx_dropped++;
1023 goto defer;
1024 }
1025 }
1026 skb->protocol = hippi_type_trans(skb, dev);
1027
1028 netif_rx(skb); /* send it up */
1029
1030 dev->last_rx = jiffies;
1031 dev->stats.rx_packets++;
1032 dev->stats.rx_bytes += pkt_len;
1033 }
1034 defer:
1035 desc->mode = 0;
1036 desc->size = dev->mtu + HIPPI_HLEN;
1037
1038 if ((index & 7) == 7)
1039 writel(index, &regs->IpRxPi);
1040
1041 index = (index + 1) % RX_RING_ENTRIES;
1042 } while(index != rxlimit);
1043
1044 rrpriv->cur_rx = index;
1045 wmb();
1046 }
1047
1048
1049 static irqreturn_t rr_interrupt(int irq, void *dev_id)
1050 {
1051 struct rr_private *rrpriv;
1052 struct rr_regs __iomem *regs;
1053 struct net_device *dev = (struct net_device *)dev_id;
1054 u32 prodidx, rxindex, eidx, txcsmr, rxlimit, txcon;
1055
1056 rrpriv = netdev_priv(dev);
1057 regs = rrpriv->regs;
1058
1059 if (!(readl(&regs->HostCtrl) & RR_INT))
1060 return IRQ_NONE;
1061
1062 spin_lock(&rrpriv->lock);
1063
1064 prodidx = readl(&regs->EvtPrd);
1065 txcsmr = (prodidx >> 8) & 0xff;
1066 rxlimit = (prodidx >> 16) & 0xff;
1067 prodidx &= 0xff;
1068
1069 #if (DEBUG > 2)
1070 printk("%s: interrupt, prodidx = %i, eidx = %i\n", dev->name,
1071 prodidx, rrpriv->info->evt_ctrl.pi);
1072 #endif
1073 /*
1074 * Order here is important. We must handle events
1075 * before doing anything else in order to catch
1076 * such things as LLRC errors, etc -kbf
1077 */
1078
1079 eidx = rrpriv->info->evt_ctrl.pi;
1080 if (prodidx != eidx)
1081 eidx = rr_handle_event(dev, prodidx, eidx);
1082
1083 rxindex = rrpriv->cur_rx;
1084 if (rxindex != rxlimit)
1085 rx_int(dev, rxlimit, rxindex);
1086
1087 txcon = rrpriv->dirty_tx;
1088 if (txcsmr != txcon) {
1089 do {
1090 /* Due to occational firmware TX producer/consumer out
1091 * of sync. error need to check entry in ring -kbf
1092 */
1093 if(rrpriv->tx_skbuff[txcon]){
1094 struct tx_desc *desc;
1095 struct sk_buff *skb;
1096
1097 desc = &(rrpriv->tx_ring[txcon]);
1098 skb = rrpriv->tx_skbuff[txcon];
1099
1100 dev->stats.tx_packets++;
1101 dev->stats.tx_bytes += skb->len;
1102
1103 pci_unmap_single(rrpriv->pci_dev,
1104 desc->addr.addrlo, skb->len,
1105 PCI_DMA_TODEVICE);
1106 dev_kfree_skb_irq(skb);
1107
1108 rrpriv->tx_skbuff[txcon] = NULL;
1109 desc->size = 0;
1110 set_rraddr(&rrpriv->tx_ring[txcon].addr, 0);
1111 desc->mode = 0;
1112 }
1113 txcon = (txcon + 1) % TX_RING_ENTRIES;
1114 } while (txcsmr != txcon);
1115 wmb();
1116
1117 rrpriv->dirty_tx = txcon;
1118 if (rrpriv->tx_full && rr_if_busy(dev) &&
1119 (((rrpriv->info->tx_ctrl.pi + 1) % TX_RING_ENTRIES)
1120 != rrpriv->dirty_tx)){
1121 rrpriv->tx_full = 0;
1122 netif_wake_queue(dev);
1123 }
1124 }
1125
1126 eidx |= ((txcsmr << 8) | (rxlimit << 16));
1127 writel(eidx, &regs->EvtCon);
1128 wmb();
1129
1130 spin_unlock(&rrpriv->lock);
1131 return IRQ_HANDLED;
1132 }
1133
1134 static inline void rr_raz_tx(struct rr_private *rrpriv,
1135 struct net_device *dev)
1136 {
1137 int i;
1138
1139 for (i = 0; i < TX_RING_ENTRIES; i++) {
1140 struct sk_buff *skb = rrpriv->tx_skbuff[i];
1141
1142 if (skb) {
1143 struct tx_desc *desc = &(rrpriv->tx_ring[i]);
1144
1145 pci_unmap_single(rrpriv->pci_dev, desc->addr.addrlo,
1146 skb->len, PCI_DMA_TODEVICE);
1147 desc->size = 0;
1148 set_rraddr(&desc->addr, 0);
1149 dev_kfree_skb(skb);
1150 rrpriv->tx_skbuff[i] = NULL;
1151 }
1152 }
1153 }
1154
1155
1156 static inline void rr_raz_rx(struct rr_private *rrpriv,
1157 struct net_device *dev)
1158 {
1159 int i;
1160
1161 for (i = 0; i < RX_RING_ENTRIES; i++) {
1162 struct sk_buff *skb = rrpriv->rx_skbuff[i];
1163
1164 if (skb) {
1165 struct rx_desc *desc = &(rrpriv->rx_ring[i]);
1166
1167 pci_unmap_single(rrpriv->pci_dev, desc->addr.addrlo,
1168 dev->mtu + HIPPI_HLEN, PCI_DMA_FROMDEVICE);
1169 desc->size = 0;
1170 set_rraddr(&desc->addr, 0);
1171 dev_kfree_skb(skb);
1172 rrpriv->rx_skbuff[i] = NULL;
1173 }
1174 }
1175 }
1176
1177 static void rr_timer(unsigned long data)
1178 {
1179 struct net_device *dev = (struct net_device *)data;
1180 struct rr_private *rrpriv = netdev_priv(dev);
1181 struct rr_regs __iomem *regs = rrpriv->regs;
1182 unsigned long flags;
1183
1184 if (readl(&regs->HostCtrl) & NIC_HALTED){
1185 printk("%s: Restarting nic\n", dev->name);
1186 memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl));
1187 memset(rrpriv->info, 0, sizeof(struct rr_info));
1188 wmb();
1189
1190 rr_raz_tx(rrpriv, dev);
1191 rr_raz_rx(rrpriv, dev);
1192
1193 if (rr_init1(dev)) {
1194 spin_lock_irqsave(&rrpriv->lock, flags);
1195 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT,
1196 &regs->HostCtrl);
1197 spin_unlock_irqrestore(&rrpriv->lock, flags);
1198 }
1199 }
1200 rrpriv->timer.expires = RUN_AT(5*HZ);
1201 add_timer(&rrpriv->timer);
1202 }
1203
1204
1205 static int rr_open(struct net_device *dev)
1206 {
1207 struct rr_private *rrpriv = netdev_priv(dev);
1208 struct pci_dev *pdev = rrpriv->pci_dev;
1209 struct rr_regs __iomem *regs;
1210 int ecode = 0;
1211 unsigned long flags;
1212 dma_addr_t dma_addr;
1213
1214 regs = rrpriv->regs;
1215
1216 if (rrpriv->fw_rev < 0x00020000) {
1217 printk(KERN_WARNING "%s: trying to configure device with "
1218 "obsolete firmware\n", dev->name);
1219 ecode = -EBUSY;
1220 goto error;
1221 }
1222
1223 rrpriv->rx_ctrl = pci_alloc_consistent(pdev,
1224 256 * sizeof(struct ring_ctrl),
1225 &dma_addr);
1226 if (!rrpriv->rx_ctrl) {
1227 ecode = -ENOMEM;
1228 goto error;
1229 }
1230 rrpriv->rx_ctrl_dma = dma_addr;
1231 memset(rrpriv->rx_ctrl, 0, 256*sizeof(struct ring_ctrl));
1232
1233 rrpriv->info = pci_alloc_consistent(pdev, sizeof(struct rr_info),
1234 &dma_addr);
1235 if (!rrpriv->info) {
1236 ecode = -ENOMEM;
1237 goto error;
1238 }
1239 rrpriv->info_dma = dma_addr;
1240 memset(rrpriv->info, 0, sizeof(struct rr_info));
1241 wmb();
1242
1243 spin_lock_irqsave(&rrpriv->lock, flags);
1244 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, &regs->HostCtrl);
1245 readl(&regs->HostCtrl);
1246 spin_unlock_irqrestore(&rrpriv->lock, flags);
1247
1248 if (request_irq(dev->irq, rr_interrupt, IRQF_SHARED, dev->name, dev)) {
1249 printk(KERN_WARNING "%s: Requested IRQ %d is busy\n",
1250 dev->name, dev->irq);
1251 ecode = -EAGAIN;
1252 goto error;
1253 }
1254
1255 if ((ecode = rr_init1(dev)))
1256 goto error;
1257
1258 /* Set the timer to switch to check for link beat and perhaps switch
1259 to an alternate media type. */
1260 init_timer(&rrpriv->timer);
1261 rrpriv->timer.expires = RUN_AT(5*HZ); /* 5 sec. watchdog */
1262 rrpriv->timer.data = (unsigned long)dev;
1263 rrpriv->timer.function = &rr_timer; /* timer handler */
1264 add_timer(&rrpriv->timer);
1265
1266 netif_start_queue(dev);
1267
1268 return ecode;
1269
1270 error:
1271 spin_lock_irqsave(&rrpriv->lock, flags);
1272 writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, &regs->HostCtrl);
1273 spin_unlock_irqrestore(&rrpriv->lock, flags);
1274
1275 if (rrpriv->info) {
1276 pci_free_consistent(pdev, sizeof(struct rr_info), rrpriv->info,
1277 rrpriv->info_dma);
1278 rrpriv->info = NULL;
1279 }
1280 if (rrpriv->rx_ctrl) {
1281 pci_free_consistent(pdev, sizeof(struct ring_ctrl),
1282 rrpriv->rx_ctrl, rrpriv->rx_ctrl_dma);
1283 rrpriv->rx_ctrl = NULL;
1284 }
1285
1286 netif_stop_queue(dev);
1287
1288 return ecode;
1289 }
1290
1291
1292 static void rr_dump(struct net_device *dev)
1293 {
1294 struct rr_private *rrpriv;
1295 struct rr_regs __iomem *regs;
1296 u32 index, cons;
1297 short i;
1298 int len;
1299
1300 rrpriv = netdev_priv(dev);
1301 regs = rrpriv->regs;
1302
1303 printk("%s: dumping NIC TX rings\n", dev->name);
1304
1305 printk("RxPrd %08x, TxPrd %02x, EvtPrd %08x, TxPi %02x, TxCtrlPi %02x\n",
1306 readl(&regs->RxPrd), readl(&regs->TxPrd),
1307 readl(&regs->EvtPrd), readl(&regs->TxPi),
1308 rrpriv->info->tx_ctrl.pi);
1309
1310 printk("Error code 0x%x\n", readl(&regs->Fail1));
1311
1312 index = (((readl(&regs->EvtPrd) >> 8) & 0xff ) - 1) % EVT_RING_ENTRIES;
1313 cons = rrpriv->dirty_tx;
1314 printk("TX ring index %i, TX consumer %i\n",
1315 index, cons);
1316
1317 if (rrpriv->tx_skbuff[index]){
1318 len = min_t(int, 0x80, rrpriv->tx_skbuff[index]->len);
1319 printk("skbuff for index %i is valid - dumping data (0x%x bytes - DMA len 0x%x)\n", index, len, rrpriv->tx_ring[index].size);
1320 for (i = 0; i < len; i++){
1321 if (!(i & 7))
1322 printk("\n");
1323 printk("%02x ", (unsigned char) rrpriv->tx_skbuff[index]->data[i]);
1324 }
1325 printk("\n");
1326 }
1327
1328 if (rrpriv->tx_skbuff[cons]){
1329 len = min_t(int, 0x80, rrpriv->tx_skbuff[cons]->len);
1330 printk("skbuff for cons %i is valid - dumping data (0x%x bytes - skbuff len 0x%x)\n", cons, len, rrpriv->tx_skbuff[cons]->len);
1331 printk("mode 0x%x, size 0x%x,\n phys %08Lx, skbuff-addr %08lx, truesize 0x%x\n",
1332 rrpriv->tx_ring[cons].mode,
1333 rrpriv->tx_ring[cons].size,
1334 (unsigned long long) rrpriv->tx_ring[cons].addr.addrlo,
1335 (unsigned long)rrpriv->tx_skbuff[cons]->data,
1336 (unsigned int)rrpriv->tx_skbuff[cons]->truesize);
1337 for (i = 0; i < len; i++){
1338 if (!(i & 7))
1339 printk("\n");
1340 printk("%02x ", (unsigned char)rrpriv->tx_ring[cons].size);
1341 }
1342 printk("\n");
1343 }
1344
1345 printk("dumping TX ring info:\n");
1346 for (i = 0; i < TX_RING_ENTRIES; i++)
1347 printk("mode 0x%x, size 0x%x, phys-addr %08Lx\n",
1348 rrpriv->tx_ring[i].mode,
1349 rrpriv->tx_ring[i].size,
1350 (unsigned long long) rrpriv->tx_ring[i].addr.addrlo);
1351
1352 }
1353
1354
1355 static int rr_close(struct net_device *dev)
1356 {
1357 struct rr_private *rrpriv;
1358 struct rr_regs __iomem *regs;
1359 unsigned long flags;
1360 u32 tmp;
1361 short i;
1362
1363 netif_stop_queue(dev);
1364
1365 rrpriv = netdev_priv(dev);
1366 regs = rrpriv->regs;
1367
1368 /*
1369 * Lock to make sure we are not cleaning up while another CPU
1370 * is handling interrupts.
1371 */
1372 spin_lock_irqsave(&rrpriv->lock, flags);
1373
1374 tmp = readl(&regs->HostCtrl);
1375 if (tmp & NIC_HALTED){
1376 printk("%s: NIC already halted\n", dev->name);
1377 rr_dump(dev);
1378 }else{
1379 tmp |= HALT_NIC | RR_CLEAR_INT;
1380 writel(tmp, &regs->HostCtrl);
1381 readl(&regs->HostCtrl);
1382 }
1383
1384 rrpriv->fw_running = 0;
1385
1386 del_timer_sync(&rrpriv->timer);
1387
1388 writel(0, &regs->TxPi);
1389 writel(0, &regs->IpRxPi);
1390
1391 writel(0, &regs->EvtCon);
1392 writel(0, &regs->EvtPrd);
1393
1394 for (i = 0; i < CMD_RING_ENTRIES; i++)
1395 writel(0, &regs->CmdRing[i]);
1396
1397 rrpriv->info->tx_ctrl.entries = 0;
1398 rrpriv->info->cmd_ctrl.pi = 0;
1399 rrpriv->info->evt_ctrl.pi = 0;
1400 rrpriv->rx_ctrl[4].entries = 0;
1401
1402 rr_raz_tx(rrpriv, dev);
1403 rr_raz_rx(rrpriv, dev);
1404
1405 pci_free_consistent(rrpriv->pci_dev, 256 * sizeof(struct ring_ctrl),
1406 rrpriv->rx_ctrl, rrpriv->rx_ctrl_dma);
1407 rrpriv->rx_ctrl = NULL;
1408
1409 pci_free_consistent(rrpriv->pci_dev, sizeof(struct rr_info),
1410 rrpriv->info, rrpriv->info_dma);
1411 rrpriv->info = NULL;
1412
1413 free_irq(dev->irq, dev);
1414 spin_unlock_irqrestore(&rrpriv->lock, flags);
1415
1416 return 0;
1417 }
1418
1419
1420 static int rr_start_xmit(struct sk_buff *skb, struct net_device *dev)
1421 {
1422 struct rr_private *rrpriv = netdev_priv(dev);
1423 struct rr_regs __iomem *regs = rrpriv->regs;
1424 struct hippi_cb *hcb = (struct hippi_cb *) skb->cb;
1425 struct ring_ctrl *txctrl;
1426 unsigned long flags;
1427 u32 index, len = skb->len;
1428 u32 *ifield;
1429 struct sk_buff *new_skb;
1430
1431 if (readl(&regs->Mode) & FATAL_ERR)
1432 printk("error codes Fail1 %02x, Fail2 %02x\n",
1433 readl(&regs->Fail1), readl(&regs->Fail2));
1434
1435 /*
1436 * We probably need to deal with tbusy here to prevent overruns.
1437 */
1438
1439 if (skb_headroom(skb) < 8){
1440 printk("incoming skb too small - reallocating\n");
1441 if (!(new_skb = dev_alloc_skb(len + 8))) {
1442 dev_kfree_skb(skb);
1443 netif_wake_queue(dev);
1444 return -EBUSY;
1445 }
1446 skb_reserve(new_skb, 8);
1447 skb_put(new_skb, len);
1448 skb_copy_from_linear_data(skb, new_skb->data, len);
1449 dev_kfree_skb(skb);
1450 skb = new_skb;
1451 }
1452
1453 ifield = (u32 *)skb_push(skb, 8);
1454
1455 ifield[0] = 0;
1456 ifield[1] = hcb->ifield;
1457
1458 /*
1459 * We don't need the lock before we are actually going to start
1460 * fiddling with the control blocks.
1461 */
1462 spin_lock_irqsave(&rrpriv->lock, flags);
1463
1464 txctrl = &rrpriv->info->tx_ctrl;
1465
1466 index = txctrl->pi;
1467
1468 rrpriv->tx_skbuff[index] = skb;
1469 set_rraddr(&rrpriv->tx_ring[index].addr, pci_map_single(
1470 rrpriv->pci_dev, skb->data, len + 8, PCI_DMA_TODEVICE));
1471 rrpriv->tx_ring[index].size = len + 8; /* include IFIELD */
1472 rrpriv->tx_ring[index].mode = PACKET_START | PACKET_END;
1473 txctrl->pi = (index + 1) % TX_RING_ENTRIES;
1474 wmb();
1475 writel(txctrl->pi, &regs->TxPi);
1476
1477 if (txctrl->pi == rrpriv->dirty_tx){
1478 rrpriv->tx_full = 1;
1479 netif_stop_queue(dev);
1480 }
1481
1482 spin_unlock_irqrestore(&rrpriv->lock, flags);
1483
1484 dev->trans_start = jiffies;
1485 return 0;
1486 }
1487
1488
1489 /*
1490 * Read the firmware out of the EEPROM and put it into the SRAM
1491 * (or from user space - later)
1492 *
1493 * This operation requires the NIC to be halted and is performed with
1494 * interrupts disabled and with the spinlock hold.
1495 */
1496 static int rr_load_firmware(struct net_device *dev)
1497 {
1498 struct rr_private *rrpriv;
1499 struct rr_regs __iomem *regs;
1500 unsigned long eptr, segptr;
1501 int i, j;
1502 u32 localctrl, sptr, len, tmp;
1503 u32 p2len, p2size, nr_seg, revision, io, sram_size;
1504 struct eeprom *hw = NULL;
1505
1506 rrpriv = netdev_priv(dev);
1507 regs = rrpriv->regs;
1508
1509 if (dev->flags & IFF_UP)
1510 return -EBUSY;
1511
1512 if (!(readl(&regs->HostCtrl) & NIC_HALTED)){
1513 printk("%s: Trying to load firmware to a running NIC.\n",
1514 dev->name);
1515 return -EBUSY;
1516 }
1517
1518 localctrl = readl(&regs->LocalCtrl);
1519 writel(0, &regs->LocalCtrl);
1520
1521 writel(0, &regs->EvtPrd);
1522 writel(0, &regs->RxPrd);
1523 writel(0, &regs->TxPrd);
1524
1525 /*
1526 * First wipe the entire SRAM, otherwise we might run into all
1527 * kinds of trouble ... sigh, this took almost all afternoon
1528 * to track down ;-(
1529 */
1530 io = readl(&regs->ExtIo);
1531 writel(0, &regs->ExtIo);
1532 sram_size = rr_read_eeprom_word(rrpriv, (void *)8);
1533
1534 for (i = 200; i < sram_size / 4; i++){
1535 writel(i * 4, &regs->WinBase);
1536 mb();
1537 writel(0, &regs->WinData);
1538 mb();
1539 }
1540 writel(io, &regs->ExtIo);
1541 mb();
1542
1543 eptr = (unsigned long)rr_read_eeprom_word(rrpriv,
1544 &hw->rncd_info.AddrRunCodeSegs);
1545 eptr = ((eptr & 0x1fffff) >> 3);
1546
1547 p2len = rr_read_eeprom_word(rrpriv, (void *)(0x83*4));
1548 p2len = (p2len << 2);
1549 p2size = rr_read_eeprom_word(rrpriv, (void *)(0x84*4));
1550 p2size = ((p2size & 0x1fffff) >> 3);
1551
1552 if ((eptr < p2size) || (eptr > (p2size + p2len))){
1553 printk("%s: eptr is invalid\n", dev->name);
1554 goto out;
1555 }
1556
1557 revision = rr_read_eeprom_word(rrpriv, &hw->manf.HeaderFmt);
1558
1559 if (revision != 1){
1560 printk("%s: invalid firmware format (%i)\n",
1561 dev->name, revision);
1562 goto out;
1563 }
1564
1565 nr_seg = rr_read_eeprom_word(rrpriv, (void *)eptr);
1566 eptr +=4;
1567 #if (DEBUG > 1)
1568 printk("%s: nr_seg %i\n", dev->name, nr_seg);
1569 #endif
1570
1571 for (i = 0; i < nr_seg; i++){
1572 sptr = rr_read_eeprom_word(rrpriv, (void *)eptr);
1573 eptr += 4;
1574 len = rr_read_eeprom_word(rrpriv, (void *)eptr);
1575 eptr += 4;
1576 segptr = (unsigned long)rr_read_eeprom_word(rrpriv, (void *)eptr);
1577 segptr = ((segptr & 0x1fffff) >> 3);
1578 eptr += 4;
1579 #if (DEBUG > 1)
1580 printk("%s: segment %i, sram address %06x, length %04x, segptr %06x\n",
1581 dev->name, i, sptr, len, segptr);
1582 #endif
1583 for (j = 0; j < len; j++){
1584 tmp = rr_read_eeprom_word(rrpriv, (void *)segptr);
1585 writel(sptr, &regs->WinBase);
1586 mb();
1587 writel(tmp, &regs->WinData);
1588 mb();
1589 segptr += 4;
1590 sptr += 4;
1591 }
1592 }
1593
1594 out:
1595 writel(localctrl, &regs->LocalCtrl);
1596 mb();
1597 return 0;
1598 }
1599
1600
1601 static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1602 {
1603 struct rr_private *rrpriv;
1604 unsigned char *image, *oldimage;
1605 unsigned long flags;
1606 unsigned int i;
1607 int error = -EOPNOTSUPP;
1608
1609 rrpriv = netdev_priv(dev);
1610
1611 switch(cmd){
1612 case SIOCRRGFW:
1613 if (!capable(CAP_SYS_RAWIO)){
1614 return -EPERM;
1615 }
1616
1617 image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
1618 if (!image){
1619 printk(KERN_ERR "%s: Unable to allocate memory "
1620 "for EEPROM image\n", dev->name);
1621 return -ENOMEM;
1622 }
1623
1624
1625 if (rrpriv->fw_running){
1626 printk("%s: Firmware already running\n", dev->name);
1627 error = -EPERM;
1628 goto gf_out;
1629 }
1630
1631 spin_lock_irqsave(&rrpriv->lock, flags);
1632 i = rr_read_eeprom(rrpriv, 0, image, EEPROM_BYTES);
1633 spin_unlock_irqrestore(&rrpriv->lock, flags);
1634 if (i != EEPROM_BYTES){
1635 printk(KERN_ERR "%s: Error reading EEPROM\n",
1636 dev->name);
1637 error = -EFAULT;
1638 goto gf_out;
1639 }
1640 error = copy_to_user(rq->ifr_data, image, EEPROM_BYTES);
1641 if (error)
1642 error = -EFAULT;
1643 gf_out:
1644 kfree(image);
1645 return error;
1646
1647 case SIOCRRPFW:
1648 if (!capable(CAP_SYS_RAWIO)){
1649 return -EPERM;
1650 }
1651
1652 image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
1653 oldimage = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
1654 if (!image || !oldimage) {
1655 printk(KERN_ERR "%s: Unable to allocate memory "
1656 "for EEPROM image\n", dev->name);
1657 error = -ENOMEM;
1658 goto wf_out;
1659 }
1660
1661 error = copy_from_user(image, rq->ifr_data, EEPROM_BYTES);
1662 if (error) {
1663 error = -EFAULT;
1664 goto wf_out;
1665 }
1666
1667 if (rrpriv->fw_running){
1668 printk("%s: Firmware already running\n", dev->name);
1669 error = -EPERM;
1670 goto wf_out;
1671 }
1672
1673 printk("%s: Updating EEPROM firmware\n", dev->name);
1674
1675 spin_lock_irqsave(&rrpriv->lock, flags);
1676 error = write_eeprom(rrpriv, 0, image, EEPROM_BYTES);
1677 if (error)
1678 printk(KERN_ERR "%s: Error writing EEPROM\n",
1679 dev->name);
1680
1681 i = rr_read_eeprom(rrpriv, 0, oldimage, EEPROM_BYTES);
1682 spin_unlock_irqrestore(&rrpriv->lock, flags);
1683
1684 if (i != EEPROM_BYTES)
1685 printk(KERN_ERR "%s: Error reading back EEPROM "
1686 "image\n", dev->name);
1687
1688 error = memcmp(image, oldimage, EEPROM_BYTES);
1689 if (error){
1690 printk(KERN_ERR "%s: Error verifying EEPROM image\n",
1691 dev->name);
1692 error = -EFAULT;
1693 }
1694 wf_out:
1695 kfree(oldimage);
1696 kfree(image);
1697 return error;
1698
1699 case SIOCRRID:
1700 return put_user(0x52523032, (int __user *)rq->ifr_data);
1701 default:
1702 return error;
1703 }
1704 }
1705
1706 static struct pci_device_id rr_pci_tbl[] = {
1707 { PCI_VENDOR_ID_ESSENTIAL, PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER,
1708 PCI_ANY_ID, PCI_ANY_ID, },
1709 { 0,}
1710 };
1711 MODULE_DEVICE_TABLE(pci, rr_pci_tbl);
1712
1713 static struct pci_driver rr_driver = {
1714 .name = "rrunner",
1715 .id_table = rr_pci_tbl,
1716 .probe = rr_init_one,
1717 .remove = __devexit_p(rr_remove_one),
1718 };
1719
1720 static int __init rr_init_module(void)
1721 {
1722 return pci_register_driver(&rr_driver);
1723 }
1724
1725 static void __exit rr_cleanup_module(void)
1726 {
1727 pci_unregister_driver(&rr_driver);
1728 }
1729
1730 module_init(rr_init_module);
1731 module_exit(rr_cleanup_module);
1732
1733 /*
1734 * Local variables:
1735 * compile-command: "gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -pipe -fomit-frame-pointer -fno-strength-reduce -m486 -malign-loops=2 -malign-jumps=2 -malign-functions=2 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h -c rrunner.c"
1736 * End:
1737 */
Mirror for ia64_pv_ops.git