2 * rrunner.c: Linux driver for the Essential RoadRunner HIPPI board.
4 * Copyright (C) 1998-2002 by Jes Sorensen, <jes@wildopensource.com>.
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.
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.
17 * Thanks to Jayaram Bhat from ODS/Essential for fixing some of the
18 * stupid bugs in my code.
20 * Softnet support and various other patches from Val Henson of
23 * PCI DMA mapping code partly based on work by Francois Romieu.
28 #define RX_DMA_SKBUFF 1
29 #define PKT_COPY_THRESHOLD 512
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>
45 #include <asm/system.h>
46 #include <asm/cache.h>
47 #include <asm/byteorder.h>
50 #include <asm/uaccess.h>
52 #define rr_if_busy(dev) netif_queue_stopped(dev)
53 #define rr_if_running(dev) netif_running(dev)
57 #define RUN_AT(x) (jiffies + (x))
60 MODULE_AUTHOR("Jes Sorensen <jes@wildopensource.com>");
61 MODULE_DESCRIPTION("Essential RoadRunner HIPPI driver");
62 MODULE_LICENSE("GPL");
64 static char version
[] __devinitdata
= "rrunner.c: v0.50 11/11/2002 Jes Sorensen (jes@wildopensource.com)\n";
67 * Implementation notes:
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
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.
82 * sysctl_[wr]mem_max are checked at init time to see if they are at
83 * least 256KB and increased to 256KB if they are not. This is done to
84 * avoid ending up with socket buffers smaller than the MTU size,
87 static int __devinit
rr_init_one(struct pci_dev
*pdev
,
88 const struct pci_device_id
*ent
)
90 struct net_device
*dev
;
91 static int version_disp
;
93 struct rr_private
*rrpriv
;
98 dev
= alloc_hippi_dev(sizeof(struct rr_private
));
102 ret
= pci_enable_device(pdev
);
108 rrpriv
= netdev_priv(dev
);
110 SET_NETDEV_DEV(dev
, &pdev
->dev
);
112 if (pci_request_regions(pdev
, "rrunner")) {
117 pci_set_drvdata(pdev
, dev
);
119 rrpriv
->pci_dev
= pdev
;
121 spin_lock_init(&rrpriv
->lock
);
123 dev
->irq
= pdev
->irq
;
124 dev
->open
= &rr_open
;
125 dev
->hard_start_xmit
= &rr_start_xmit
;
126 dev
->stop
= &rr_close
;
127 dev
->do_ioctl
= &rr_ioctl
;
129 dev
->base_addr
= pci_resource_start(pdev
, 0);
131 /* display version info if adapter is found */
133 /* set display flag to TRUE so that */
134 /* we only display this string ONCE */
139 pci_read_config_byte(pdev
, PCI_LATENCY_TIMER
, &pci_latency
);
140 if (pci_latency
<= 0x58){
142 pci_write_config_byte(pdev
, PCI_LATENCY_TIMER
, pci_latency
);
145 pci_set_master(pdev
);
147 printk(KERN_INFO
"%s: Essential RoadRunner serial HIPPI "
148 "at 0x%08lx, irq %i, PCI latency %i\n", dev
->name
,
149 dev
->base_addr
, dev
->irq
, pci_latency
);
152 * Remap the regs into kernel space.
155 rrpriv
->regs
= ioremap(dev
->base_addr
, 0x1000);
158 printk(KERN_ERR
"%s: Unable to map I/O register, "
159 "RoadRunner will be disabled.\n", dev
->name
);
164 tmpptr
= pci_alloc_consistent(pdev
, TX_TOTAL_SIZE
, &ring_dma
);
165 rrpriv
->tx_ring
= tmpptr
;
166 rrpriv
->tx_ring_dma
= ring_dma
;
173 tmpptr
= pci_alloc_consistent(pdev
, RX_TOTAL_SIZE
, &ring_dma
);
174 rrpriv
->rx_ring
= tmpptr
;
175 rrpriv
->rx_ring_dma
= ring_dma
;
182 tmpptr
= pci_alloc_consistent(pdev
, EVT_RING_SIZE
, &ring_dma
);
183 rrpriv
->evt_ring
= tmpptr
;
184 rrpriv
->evt_ring_dma
= ring_dma
;
192 * Don't access any register before this point!
195 writel(readl(&rrpriv
->regs
->HostCtrl
) | NO_SWAP
,
196 &rrpriv
->regs
->HostCtrl
);
199 * Need to add a case for little-endian 64-bit hosts here.
206 ret
= register_netdev(dev
);
213 pci_free_consistent(pdev
, RX_TOTAL_SIZE
, rrpriv
->rx_ring
,
214 rrpriv
->rx_ring_dma
);
216 pci_free_consistent(pdev
, TX_TOTAL_SIZE
, rrpriv
->tx_ring
,
217 rrpriv
->tx_ring_dma
);
219 iounmap(rrpriv
->regs
);
221 pci_release_regions(pdev
);
222 pci_set_drvdata(pdev
, NULL
);
230 static void __devexit
rr_remove_one (struct pci_dev
*pdev
)
232 struct net_device
*dev
= pci_get_drvdata(pdev
);
235 struct rr_private
*rr
= netdev_priv(dev
);
237 if (!(readl(&rr
->regs
->HostCtrl
) & NIC_HALTED
)){
238 printk(KERN_ERR
"%s: trying to unload running NIC\n",
240 writel(HALT_NIC
, &rr
->regs
->HostCtrl
);
243 pci_free_consistent(pdev
, EVT_RING_SIZE
, rr
->evt_ring
,
245 pci_free_consistent(pdev
, RX_TOTAL_SIZE
, rr
->rx_ring
,
247 pci_free_consistent(pdev
, TX_TOTAL_SIZE
, rr
->tx_ring
,
249 unregister_netdev(dev
);
252 pci_release_regions(pdev
);
253 pci_disable_device(pdev
);
254 pci_set_drvdata(pdev
, NULL
);
260 * Commands are considered to be slow, thus there is no reason to
263 static void rr_issue_cmd(struct rr_private
*rrpriv
, struct cmd
*cmd
)
265 struct rr_regs __iomem
*regs
;
270 * This is temporary - it will go away in the final version.
271 * We probably also want to make this function inline.
273 if (readl(®s
->HostCtrl
) & NIC_HALTED
){
274 printk("issuing command for halted NIC, code 0x%x, "
275 "HostCtrl %08x\n", cmd
->code
, readl(®s
->HostCtrl
));
276 if (readl(®s
->Mode
) & FATAL_ERR
)
277 printk("error codes Fail1 %02x, Fail2 %02x\n",
278 readl(®s
->Fail1
), readl(®s
->Fail2
));
281 idx
= rrpriv
->info
->cmd_ctrl
.pi
;
283 writel(*(u32
*)(cmd
), ®s
->CmdRing
[idx
]);
286 idx
= (idx
- 1) % CMD_RING_ENTRIES
;
287 rrpriv
->info
->cmd_ctrl
.pi
= idx
;
290 if (readl(®s
->Mode
) & FATAL_ERR
)
291 printk("error code %02x\n", readl(®s
->Fail1
));
296 * Reset the board in a sensible manner. The NIC is already halted
297 * when we get here and a spin-lock is held.
299 static int rr_reset(struct net_device
*dev
)
301 struct rr_private
*rrpriv
;
302 struct rr_regs __iomem
*regs
;
303 struct eeprom
*hw
= NULL
;
307 rrpriv
= netdev_priv(dev
);
310 rr_load_firmware(dev
);
312 writel(0x01000000, ®s
->TX_state
);
313 writel(0xff800000, ®s
->RX_state
);
314 writel(0, ®s
->AssistState
);
315 writel(CLEAR_INTA
, ®s
->LocalCtrl
);
316 writel(0x01, ®s
->BrkPt
);
317 writel(0, ®s
->Timer
);
318 writel(0, ®s
->TimerRef
);
319 writel(RESET_DMA
, ®s
->DmaReadState
);
320 writel(RESET_DMA
, ®s
->DmaWriteState
);
321 writel(0, ®s
->DmaWriteHostHi
);
322 writel(0, ®s
->DmaWriteHostLo
);
323 writel(0, ®s
->DmaReadHostHi
);
324 writel(0, ®s
->DmaReadHostLo
);
325 writel(0, ®s
->DmaReadLen
);
326 writel(0, ®s
->DmaWriteLen
);
327 writel(0, ®s
->DmaWriteLcl
);
328 writel(0, ®s
->DmaWriteIPchecksum
);
329 writel(0, ®s
->DmaReadLcl
);
330 writel(0, ®s
->DmaReadIPchecksum
);
331 writel(0, ®s
->PciState
);
332 #if (BITS_PER_LONG == 64) && defined __LITTLE_ENDIAN
333 writel(SWAP_DATA
| PTR64BIT
| PTR_WD_SWAP
, ®s
->Mode
);
334 #elif (BITS_PER_LONG == 64)
335 writel(SWAP_DATA
| PTR64BIT
| PTR_WD_NOSWAP
, ®s
->Mode
);
337 writel(SWAP_DATA
| PTR32BIT
| PTR_WD_NOSWAP
, ®s
->Mode
);
342 * Don't worry, this is just black magic.
344 writel(0xdf000, ®s
->RxBase
);
345 writel(0xdf000, ®s
->RxPrd
);
346 writel(0xdf000, ®s
->RxCon
);
347 writel(0xce000, ®s
->TxBase
);
348 writel(0xce000, ®s
->TxPrd
);
349 writel(0xce000, ®s
->TxCon
);
350 writel(0, ®s
->RxIndPro
);
351 writel(0, ®s
->RxIndCon
);
352 writel(0, ®s
->RxIndRef
);
353 writel(0, ®s
->TxIndPro
);
354 writel(0, ®s
->TxIndCon
);
355 writel(0, ®s
->TxIndRef
);
356 writel(0xcc000, ®s
->pad10
[0]);
357 writel(0, ®s
->DrCmndPro
);
358 writel(0, ®s
->DrCmndCon
);
359 writel(0, ®s
->DwCmndPro
);
360 writel(0, ®s
->DwCmndCon
);
361 writel(0, ®s
->DwCmndRef
);
362 writel(0, ®s
->DrDataPro
);
363 writel(0, ®s
->DrDataCon
);
364 writel(0, ®s
->DrDataRef
);
365 writel(0, ®s
->DwDataPro
);
366 writel(0, ®s
->DwDataCon
);
367 writel(0, ®s
->DwDataRef
);
370 writel(0xffffffff, ®s
->MbEvent
);
371 writel(0, ®s
->Event
);
373 writel(0, ®s
->TxPi
);
374 writel(0, ®s
->IpRxPi
);
376 writel(0, ®s
->EvtCon
);
377 writel(0, ®s
->EvtPrd
);
379 rrpriv
->info
->evt_ctrl
.pi
= 0;
381 for (i
= 0; i
< CMD_RING_ENTRIES
; i
++)
382 writel(0, ®s
->CmdRing
[i
]);
385 * Why 32 ? is this not cache line size dependent?
387 writel(RBURST_64
|WBURST_64
, ®s
->PciState
);
390 start_pc
= rr_read_eeprom_word(rrpriv
, &hw
->rncd_info
.FwStart
);
393 printk("%s: Executing firmware at address 0x%06x\n",
394 dev
->name
, start_pc
);
397 writel(start_pc
+ 0x800, ®s
->Pc
);
401 writel(start_pc
, ®s
->Pc
);
409 * Read a string from the EEPROM.
411 static unsigned int rr_read_eeprom(struct rr_private
*rrpriv
,
412 unsigned long offset
,
414 unsigned long length
)
416 struct rr_regs __iomem
*regs
= rrpriv
->regs
;
417 u32 misc
, io
, host
, i
;
419 io
= readl(®s
->ExtIo
);
420 writel(0, ®s
->ExtIo
);
421 misc
= readl(®s
->LocalCtrl
);
422 writel(0, ®s
->LocalCtrl
);
423 host
= readl(®s
->HostCtrl
);
424 writel(host
| HALT_NIC
, ®s
->HostCtrl
);
427 for (i
= 0; i
< length
; i
++){
428 writel((EEPROM_BASE
+ ((offset
+i
) << 3)), ®s
->WinBase
);
430 buf
[i
] = (readl(®s
->WinData
) >> 24) & 0xff;
434 writel(host
, ®s
->HostCtrl
);
435 writel(misc
, ®s
->LocalCtrl
);
436 writel(io
, ®s
->ExtIo
);
443 * Shortcut to read one word (4 bytes) out of the EEPROM and convert
444 * it to our CPU byte-order.
446 static u32
rr_read_eeprom_word(struct rr_private
*rrpriv
,
451 if ((rr_read_eeprom(rrpriv
, (unsigned long)offset
,
452 (char *)&word
, 4) == 4))
453 return be32_to_cpu(word
);
459 * Write a string to the EEPROM.
461 * This is only called when the firmware is not running.
463 static unsigned int write_eeprom(struct rr_private
*rrpriv
,
464 unsigned long offset
,
466 unsigned long length
)
468 struct rr_regs __iomem
*regs
= rrpriv
->regs
;
469 u32 misc
, io
, data
, i
, j
, ready
, error
= 0;
471 io
= readl(®s
->ExtIo
);
472 writel(0, ®s
->ExtIo
);
473 misc
= readl(®s
->LocalCtrl
);
474 writel(ENABLE_EEPROM_WRITE
, ®s
->LocalCtrl
);
477 for (i
= 0; i
< length
; i
++){
478 writel((EEPROM_BASE
+ ((offset
+i
) << 3)), ®s
->WinBase
);
482 * Only try to write the data if it is not the same
485 if ((readl(®s
->WinData
) & 0xff000000) != data
){
486 writel(data
, ®s
->WinData
);
492 if ((readl(®s
->WinData
) & 0xff000000) ==
497 printk("data mismatch: %08x, "
498 "WinData %08x\n", data
,
499 readl(®s
->WinData
));
507 writel(misc
, ®s
->LocalCtrl
);
508 writel(io
, ®s
->ExtIo
);
515 static int __devinit
rr_init(struct net_device
*dev
)
517 struct rr_private
*rrpriv
;
518 struct rr_regs __iomem
*regs
;
519 struct eeprom
*hw
= NULL
;
521 DECLARE_MAC_BUF(mac
);
523 rrpriv
= netdev_priv(dev
);
526 rev
= readl(®s
->FwRev
);
527 rrpriv
->fw_rev
= rev
;
528 if (rev
> 0x00020024)
529 printk(" Firmware revision: %i.%i.%i\n", (rev
>> 16),
530 ((rev
>> 8) & 0xff), (rev
& 0xff));
531 else if (rev
>= 0x00020000) {
532 printk(" Firmware revision: %i.%i.%i (2.0.37 or "
533 "later is recommended)\n", (rev
>> 16),
534 ((rev
>> 8) & 0xff), (rev
& 0xff));
536 printk(" Firmware revision too old: %i.%i.%i, please "
537 "upgrade to 2.0.37 or later.\n",
538 (rev
>> 16), ((rev
>> 8) & 0xff), (rev
& 0xff));
542 printk(" Maximum receive rings %i\n", readl(®s
->MaxRxRng
));
546 * Read the hardware address from the eeprom. The HW address
547 * is not really necessary for HIPPI but awfully convenient.
548 * The pointer arithmetic to put it in dev_addr is ugly, but
549 * Donald Becker does it this way for the GigE version of this
550 * card and it's shorter and more portable than any
551 * other method I've seen. -VAL
554 *(u16
*)(dev
->dev_addr
) =
555 htons(rr_read_eeprom_word(rrpriv
, &hw
->manf
.BoardULA
));
556 *(u32
*)(dev
->dev_addr
+2) =
557 htonl(rr_read_eeprom_word(rrpriv
, &hw
->manf
.BoardULA
[4]));
559 printk(" MAC: %s\n", print_mac(mac
, dev
->dev_addr
));
561 sram_size
= rr_read_eeprom_word(rrpriv
, (void *)8);
562 printk(" SRAM size 0x%06x\n", sram_size
);
564 if (sysctl_rmem_max
< 262144){
565 printk(" Receive socket buffer limit too low (%i), "
566 "setting to 262144\n", sysctl_rmem_max
);
567 sysctl_rmem_max
= 262144;
570 if (sysctl_wmem_max
< 262144){
571 printk(" Transmit socket buffer limit too low (%i), "
572 "setting to 262144\n", sysctl_wmem_max
);
573 sysctl_wmem_max
= 262144;
580 static int rr_init1(struct net_device
*dev
)
582 struct rr_private
*rrpriv
;
583 struct rr_regs __iomem
*regs
;
584 unsigned long myjif
, flags
;
590 rrpriv
= netdev_priv(dev
);
593 spin_lock_irqsave(&rrpriv
->lock
, flags
);
595 hostctrl
= readl(®s
->HostCtrl
);
596 writel(hostctrl
| HALT_NIC
| RR_CLEAR_INT
, ®s
->HostCtrl
);
599 if (hostctrl
& PARITY_ERR
){
600 printk("%s: Parity error halting NIC - this is serious!\n",
602 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
607 set_rxaddr(regs
, rrpriv
->rx_ctrl_dma
);
608 set_infoaddr(regs
, rrpriv
->info_dma
);
610 rrpriv
->info
->evt_ctrl
.entry_size
= sizeof(struct event
);
611 rrpriv
->info
->evt_ctrl
.entries
= EVT_RING_ENTRIES
;
612 rrpriv
->info
->evt_ctrl
.mode
= 0;
613 rrpriv
->info
->evt_ctrl
.pi
= 0;
614 set_rraddr(&rrpriv
->info
->evt_ctrl
.rngptr
, rrpriv
->evt_ring_dma
);
616 rrpriv
->info
->cmd_ctrl
.entry_size
= sizeof(struct cmd
);
617 rrpriv
->info
->cmd_ctrl
.entries
= CMD_RING_ENTRIES
;
618 rrpriv
->info
->cmd_ctrl
.mode
= 0;
619 rrpriv
->info
->cmd_ctrl
.pi
= 15;
621 for (i
= 0; i
< CMD_RING_ENTRIES
; i
++) {
622 writel(0, ®s
->CmdRing
[i
]);
625 for (i
= 0; i
< TX_RING_ENTRIES
; i
++) {
626 rrpriv
->tx_ring
[i
].size
= 0;
627 set_rraddr(&rrpriv
->tx_ring
[i
].addr
, 0);
628 rrpriv
->tx_skbuff
[i
] = NULL
;
630 rrpriv
->info
->tx_ctrl
.entry_size
= sizeof(struct tx_desc
);
631 rrpriv
->info
->tx_ctrl
.entries
= TX_RING_ENTRIES
;
632 rrpriv
->info
->tx_ctrl
.mode
= 0;
633 rrpriv
->info
->tx_ctrl
.pi
= 0;
634 set_rraddr(&rrpriv
->info
->tx_ctrl
.rngptr
, rrpriv
->tx_ring_dma
);
637 * Set dirty_tx before we start receiving interrupts, otherwise
638 * the interrupt handler might think it is supposed to process
639 * tx ints before we are up and running, which may cause a null
640 * pointer access in the int handler.
644 rrpriv
->dirty_rx
= rrpriv
->dirty_tx
= 0;
649 writel(0x5000, ®s
->ConRetry
);
650 writel(0x100, ®s
->ConRetryTmr
);
651 writel(0x500000, ®s
->ConTmout
);
652 writel(0x60, ®s
->IntrTmr
);
653 writel(0x500000, ®s
->TxDataMvTimeout
);
654 writel(0x200000, ®s
->RxDataMvTimeout
);
655 writel(0x80, ®s
->WriteDmaThresh
);
656 writel(0x80, ®s
->ReadDmaThresh
);
658 rrpriv
->fw_running
= 0;
661 hostctrl
&= ~(HALT_NIC
| INVALID_INST_B
| PARITY_ERR
);
662 writel(hostctrl
, ®s
->HostCtrl
);
665 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
667 for (i
= 0; i
< RX_RING_ENTRIES
; i
++) {
671 rrpriv
->rx_ring
[i
].mode
= 0;
672 skb
= alloc_skb(dev
->mtu
+ HIPPI_HLEN
, GFP_ATOMIC
);
674 printk(KERN_WARNING
"%s: Unable to allocate memory "
675 "for receive ring - halting NIC\n", dev
->name
);
679 rrpriv
->rx_skbuff
[i
] = skb
;
680 addr
= pci_map_single(rrpriv
->pci_dev
, skb
->data
,
681 dev
->mtu
+ HIPPI_HLEN
, PCI_DMA_FROMDEVICE
);
683 * Sanity test to see if we conflict with the DMA
684 * limitations of the Roadrunner.
686 if ((((unsigned long)skb
->data
) & 0xfff) > ~65320)
687 printk("skb alloc error\n");
689 set_rraddr(&rrpriv
->rx_ring
[i
].addr
, addr
);
690 rrpriv
->rx_ring
[i
].size
= dev
->mtu
+ HIPPI_HLEN
;
693 rrpriv
->rx_ctrl
[4].entry_size
= sizeof(struct rx_desc
);
694 rrpriv
->rx_ctrl
[4].entries
= RX_RING_ENTRIES
;
695 rrpriv
->rx_ctrl
[4].mode
= 8;
696 rrpriv
->rx_ctrl
[4].pi
= 0;
698 set_rraddr(&rrpriv
->rx_ctrl
[4].rngptr
, rrpriv
->rx_ring_dma
);
703 * Now start the FirmWare.
705 cmd
.code
= C_START_FW
;
709 rr_issue_cmd(rrpriv
, &cmd
);
712 * Give the FirmWare time to chew on the `get running' command.
714 myjif
= jiffies
+ 5 * HZ
;
715 while (time_before(jiffies
, myjif
) && !rrpriv
->fw_running
)
718 netif_start_queue(dev
);
724 * We might have gotten here because we are out of memory,
725 * make sure we release everything we allocated before failing
727 for (i
= 0; i
< RX_RING_ENTRIES
; i
++) {
728 struct sk_buff
*skb
= rrpriv
->rx_skbuff
[i
];
731 pci_unmap_single(rrpriv
->pci_dev
,
732 rrpriv
->rx_ring
[i
].addr
.addrlo
,
733 dev
->mtu
+ HIPPI_HLEN
,
735 rrpriv
->rx_ring
[i
].size
= 0;
736 set_rraddr(&rrpriv
->rx_ring
[i
].addr
, 0);
738 rrpriv
->rx_skbuff
[i
] = NULL
;
746 * All events are considered to be slow (RX/TX ints do not generate
747 * events) and are handled here, outside the main interrupt handler,
748 * to reduce the size of the handler.
750 static u32
rr_handle_event(struct net_device
*dev
, u32 prodidx
, u32 eidx
)
752 struct rr_private
*rrpriv
;
753 struct rr_regs __iomem
*regs
;
756 rrpriv
= netdev_priv(dev
);
759 while (prodidx
!= eidx
){
760 switch (rrpriv
->evt_ring
[eidx
].code
){
762 tmp
= readl(®s
->FwRev
);
763 printk(KERN_INFO
"%s: Firmware revision %i.%i.%i "
764 "up and running\n", dev
->name
,
765 (tmp
>> 16), ((tmp
>> 8) & 0xff), (tmp
& 0xff));
766 rrpriv
->fw_running
= 1;
767 writel(RX_RING_ENTRIES
- 1, ®s
->IpRxPi
);
771 printk(KERN_INFO
"%s: Optical link ON\n", dev
->name
);
774 printk(KERN_INFO
"%s: Optical link OFF\n", dev
->name
);
777 printk(KERN_WARNING
"%s: RX data not moving\n",
781 printk(KERN_INFO
"%s: The watchdog is here to see "
785 printk(KERN_ERR
"%s: HIPPI Internal NIC error\n",
787 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
792 printk(KERN_ERR
"%s: Host software error\n",
794 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
802 printk(KERN_WARNING
"%s: Connection rejected\n",
804 dev
->stats
.tx_aborted_errors
++;
807 printk(KERN_WARNING
"%s: Connection timeout\n",
811 printk(KERN_WARNING
"%s: HIPPI disconnect error\n",
813 dev
->stats
.tx_aborted_errors
++;
816 printk(KERN_ERR
"%s: HIPPI Internal Parity error\n",
818 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
823 printk(KERN_WARNING
"%s: Transmitter idle\n",
827 printk(KERN_WARNING
"%s: Link lost during transmit\n",
829 dev
->stats
.tx_aborted_errors
++;
830 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
835 printk(KERN_ERR
"%s: Invalid send ring block\n",
837 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
842 printk(KERN_ERR
"%s: Invalid send buffer address\n",
844 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
849 printk(KERN_ERR
"%s: Invalid descriptor address\n",
851 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
859 printk(KERN_INFO
"%s: Receive ring full\n", dev
->name
);
863 printk(KERN_WARNING
"%s: Receive parity error\n",
867 printk(KERN_WARNING
"%s: Receive LLRC error\n",
871 printk(KERN_WARNING
"%s: Receive packet length "
872 "error\n", dev
->name
);
875 printk(KERN_WARNING
"%s: Data checksum error\n",
879 printk(KERN_WARNING
"%s: Unexpected short burst "
880 "error\n", dev
->name
);
883 printk(KERN_WARNING
"%s: Recv. state transition"
884 " error\n", dev
->name
);
887 printk(KERN_WARNING
"%s: Unexpected data error\n",
891 printk(KERN_WARNING
"%s: Link lost error\n",
895 printk(KERN_WARNING
"%s: Framming Error\n",
899 printk(KERN_WARNING
"%s: Flag sync. lost during"
900 "packet\n", dev
->name
);
903 printk(KERN_ERR
"%s: Invalid receive buffer "
904 "address\n", dev
->name
);
905 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
910 printk(KERN_ERR
"%s: Invalid receive descriptor "
911 "address\n", dev
->name
);
912 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
917 printk(KERN_ERR
"%s: Invalid ring block\n",
919 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
924 /* Label packet to be dropped.
925 * Actual dropping occurs in rx
928 * The index of packet we get to drop is
929 * the index of the packet following
930 * the bad packet. -kbf
933 u16 index
= rrpriv
->evt_ring
[eidx
].index
;
934 index
= (index
+ (RX_RING_ENTRIES
- 1)) %
936 rrpriv
->rx_ring
[index
].mode
|=
937 (PACKET_BAD
| PACKET_END
);
941 printk(KERN_WARNING
"%s: Unhandled event 0x%02x\n",
942 dev
->name
, rrpriv
->evt_ring
[eidx
].code
);
944 eidx
= (eidx
+ 1) % EVT_RING_ENTRIES
;
947 rrpriv
->info
->evt_ctrl
.pi
= eidx
;
953 static void rx_int(struct net_device
*dev
, u32 rxlimit
, u32 index
)
955 struct rr_private
*rrpriv
= netdev_priv(dev
);
956 struct rr_regs __iomem
*regs
= rrpriv
->regs
;
959 struct rx_desc
*desc
;
962 desc
= &(rrpriv
->rx_ring
[index
]);
963 pkt_len
= desc
->size
;
965 printk("index %i, rxlimit %i\n", index
, rxlimit
);
966 printk("len %x, mode %x\n", pkt_len
, desc
->mode
);
968 if ( (rrpriv
->rx_ring
[index
].mode
& PACKET_BAD
) == PACKET_BAD
){
969 dev
->stats
.rx_dropped
++;
974 struct sk_buff
*skb
, *rx_skb
;
976 rx_skb
= rrpriv
->rx_skbuff
[index
];
978 if (pkt_len
< PKT_COPY_THRESHOLD
) {
979 skb
= alloc_skb(pkt_len
, GFP_ATOMIC
);
981 printk(KERN_WARNING
"%s: Unable to allocate skb (%i bytes), deferring packet\n", dev
->name
, pkt_len
);
982 dev
->stats
.rx_dropped
++;
985 pci_dma_sync_single_for_cpu(rrpriv
->pci_dev
,
990 memcpy(skb_put(skb
, pkt_len
),
991 rx_skb
->data
, pkt_len
);
993 pci_dma_sync_single_for_device(rrpriv
->pci_dev
,
999 struct sk_buff
*newskb
;
1001 newskb
= alloc_skb(dev
->mtu
+ HIPPI_HLEN
,
1006 pci_unmap_single(rrpriv
->pci_dev
,
1007 desc
->addr
.addrlo
, dev
->mtu
+
1008 HIPPI_HLEN
, PCI_DMA_FROMDEVICE
);
1010 skb_put(skb
, pkt_len
);
1011 rrpriv
->rx_skbuff
[index
] = newskb
;
1012 addr
= pci_map_single(rrpriv
->pci_dev
,
1014 dev
->mtu
+ HIPPI_HLEN
,
1015 PCI_DMA_FROMDEVICE
);
1016 set_rraddr(&desc
->addr
, addr
);
1018 printk("%s: Out of memory, deferring "
1019 "packet\n", dev
->name
);
1020 dev
->stats
.rx_dropped
++;
1024 skb
->protocol
= hippi_type_trans(skb
, dev
);
1026 netif_rx(skb
); /* send it up */
1028 dev
->last_rx
= jiffies
;
1029 dev
->stats
.rx_packets
++;
1030 dev
->stats
.rx_bytes
+= pkt_len
;
1034 desc
->size
= dev
->mtu
+ HIPPI_HLEN
;
1036 if ((index
& 7) == 7)
1037 writel(index
, ®s
->IpRxPi
);
1039 index
= (index
+ 1) % RX_RING_ENTRIES
;
1040 } while(index
!= rxlimit
);
1042 rrpriv
->cur_rx
= index
;
1047 static irqreturn_t
rr_interrupt(int irq
, void *dev_id
)
1049 struct rr_private
*rrpriv
;
1050 struct rr_regs __iomem
*regs
;
1051 struct net_device
*dev
= (struct net_device
*)dev_id
;
1052 u32 prodidx
, rxindex
, eidx
, txcsmr
, rxlimit
, txcon
;
1054 rrpriv
= netdev_priv(dev
);
1055 regs
= rrpriv
->regs
;
1057 if (!(readl(®s
->HostCtrl
) & RR_INT
))
1060 spin_lock(&rrpriv
->lock
);
1062 prodidx
= readl(®s
->EvtPrd
);
1063 txcsmr
= (prodidx
>> 8) & 0xff;
1064 rxlimit
= (prodidx
>> 16) & 0xff;
1068 printk("%s: interrupt, prodidx = %i, eidx = %i\n", dev
->name
,
1069 prodidx
, rrpriv
->info
->evt_ctrl
.pi
);
1072 * Order here is important. We must handle events
1073 * before doing anything else in order to catch
1074 * such things as LLRC errors, etc -kbf
1077 eidx
= rrpriv
->info
->evt_ctrl
.pi
;
1078 if (prodidx
!= eidx
)
1079 eidx
= rr_handle_event(dev
, prodidx
, eidx
);
1081 rxindex
= rrpriv
->cur_rx
;
1082 if (rxindex
!= rxlimit
)
1083 rx_int(dev
, rxlimit
, rxindex
);
1085 txcon
= rrpriv
->dirty_tx
;
1086 if (txcsmr
!= txcon
) {
1088 /* Due to occational firmware TX producer/consumer out
1089 * of sync. error need to check entry in ring -kbf
1091 if(rrpriv
->tx_skbuff
[txcon
]){
1092 struct tx_desc
*desc
;
1093 struct sk_buff
*skb
;
1095 desc
= &(rrpriv
->tx_ring
[txcon
]);
1096 skb
= rrpriv
->tx_skbuff
[txcon
];
1098 dev
->stats
.tx_packets
++;
1099 dev
->stats
.tx_bytes
+= skb
->len
;
1101 pci_unmap_single(rrpriv
->pci_dev
,
1102 desc
->addr
.addrlo
, skb
->len
,
1104 dev_kfree_skb_irq(skb
);
1106 rrpriv
->tx_skbuff
[txcon
] = NULL
;
1108 set_rraddr(&rrpriv
->tx_ring
[txcon
].addr
, 0);
1111 txcon
= (txcon
+ 1) % TX_RING_ENTRIES
;
1112 } while (txcsmr
!= txcon
);
1115 rrpriv
->dirty_tx
= txcon
;
1116 if (rrpriv
->tx_full
&& rr_if_busy(dev
) &&
1117 (((rrpriv
->info
->tx_ctrl
.pi
+ 1) % TX_RING_ENTRIES
)
1118 != rrpriv
->dirty_tx
)){
1119 rrpriv
->tx_full
= 0;
1120 netif_wake_queue(dev
);
1124 eidx
|= ((txcsmr
<< 8) | (rxlimit
<< 16));
1125 writel(eidx
, ®s
->EvtCon
);
1128 spin_unlock(&rrpriv
->lock
);
1132 static inline void rr_raz_tx(struct rr_private
*rrpriv
,
1133 struct net_device
*dev
)
1137 for (i
= 0; i
< TX_RING_ENTRIES
; i
++) {
1138 struct sk_buff
*skb
= rrpriv
->tx_skbuff
[i
];
1141 struct tx_desc
*desc
= &(rrpriv
->tx_ring
[i
]);
1143 pci_unmap_single(rrpriv
->pci_dev
, desc
->addr
.addrlo
,
1144 skb
->len
, PCI_DMA_TODEVICE
);
1146 set_rraddr(&desc
->addr
, 0);
1148 rrpriv
->tx_skbuff
[i
] = NULL
;
1154 static inline void rr_raz_rx(struct rr_private
*rrpriv
,
1155 struct net_device
*dev
)
1159 for (i
= 0; i
< RX_RING_ENTRIES
; i
++) {
1160 struct sk_buff
*skb
= rrpriv
->rx_skbuff
[i
];
1163 struct rx_desc
*desc
= &(rrpriv
->rx_ring
[i
]);
1165 pci_unmap_single(rrpriv
->pci_dev
, desc
->addr
.addrlo
,
1166 dev
->mtu
+ HIPPI_HLEN
, PCI_DMA_FROMDEVICE
);
1168 set_rraddr(&desc
->addr
, 0);
1170 rrpriv
->rx_skbuff
[i
] = NULL
;
1175 static void rr_timer(unsigned long data
)
1177 struct net_device
*dev
= (struct net_device
*)data
;
1178 struct rr_private
*rrpriv
= netdev_priv(dev
);
1179 struct rr_regs __iomem
*regs
= rrpriv
->regs
;
1180 unsigned long flags
;
1182 if (readl(®s
->HostCtrl
) & NIC_HALTED
){
1183 printk("%s: Restarting nic\n", dev
->name
);
1184 memset(rrpriv
->rx_ctrl
, 0, 256 * sizeof(struct ring_ctrl
));
1185 memset(rrpriv
->info
, 0, sizeof(struct rr_info
));
1188 rr_raz_tx(rrpriv
, dev
);
1189 rr_raz_rx(rrpriv
, dev
);
1191 if (rr_init1(dev
)) {
1192 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1193 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
,
1195 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1198 rrpriv
->timer
.expires
= RUN_AT(5*HZ
);
1199 add_timer(&rrpriv
->timer
);
1203 static int rr_open(struct net_device
*dev
)
1205 struct rr_private
*rrpriv
= netdev_priv(dev
);
1206 struct pci_dev
*pdev
= rrpriv
->pci_dev
;
1207 struct rr_regs __iomem
*regs
;
1209 unsigned long flags
;
1210 dma_addr_t dma_addr
;
1212 regs
= rrpriv
->regs
;
1214 if (rrpriv
->fw_rev
< 0x00020000) {
1215 printk(KERN_WARNING
"%s: trying to configure device with "
1216 "obsolete firmware\n", dev
->name
);
1221 rrpriv
->rx_ctrl
= pci_alloc_consistent(pdev
,
1222 256 * sizeof(struct ring_ctrl
),
1224 if (!rrpriv
->rx_ctrl
) {
1228 rrpriv
->rx_ctrl_dma
= dma_addr
;
1229 memset(rrpriv
->rx_ctrl
, 0, 256*sizeof(struct ring_ctrl
));
1231 rrpriv
->info
= pci_alloc_consistent(pdev
, sizeof(struct rr_info
),
1233 if (!rrpriv
->info
) {
1237 rrpriv
->info_dma
= dma_addr
;
1238 memset(rrpriv
->info
, 0, sizeof(struct rr_info
));
1241 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1242 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
, ®s
->HostCtrl
);
1243 readl(®s
->HostCtrl
);
1244 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1246 if (request_irq(dev
->irq
, rr_interrupt
, IRQF_SHARED
, dev
->name
, dev
)) {
1247 printk(KERN_WARNING
"%s: Requested IRQ %d is busy\n",
1248 dev
->name
, dev
->irq
);
1253 if ((ecode
= rr_init1(dev
)))
1256 /* Set the timer to switch to check for link beat and perhaps switch
1257 to an alternate media type. */
1258 init_timer(&rrpriv
->timer
);
1259 rrpriv
->timer
.expires
= RUN_AT(5*HZ
); /* 5 sec. watchdog */
1260 rrpriv
->timer
.data
= (unsigned long)dev
;
1261 rrpriv
->timer
.function
= &rr_timer
; /* timer handler */
1262 add_timer(&rrpriv
->timer
);
1264 netif_start_queue(dev
);
1269 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1270 writel(readl(®s
->HostCtrl
)|HALT_NIC
|RR_CLEAR_INT
, ®s
->HostCtrl
);
1271 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1274 pci_free_consistent(pdev
, sizeof(struct rr_info
), rrpriv
->info
,
1276 rrpriv
->info
= NULL
;
1278 if (rrpriv
->rx_ctrl
) {
1279 pci_free_consistent(pdev
, sizeof(struct ring_ctrl
),
1280 rrpriv
->rx_ctrl
, rrpriv
->rx_ctrl_dma
);
1281 rrpriv
->rx_ctrl
= NULL
;
1284 netif_stop_queue(dev
);
1290 static void rr_dump(struct net_device
*dev
)
1292 struct rr_private
*rrpriv
;
1293 struct rr_regs __iomem
*regs
;
1298 rrpriv
= netdev_priv(dev
);
1299 regs
= rrpriv
->regs
;
1301 printk("%s: dumping NIC TX rings\n", dev
->name
);
1303 printk("RxPrd %08x, TxPrd %02x, EvtPrd %08x, TxPi %02x, TxCtrlPi %02x\n",
1304 readl(®s
->RxPrd
), readl(®s
->TxPrd
),
1305 readl(®s
->EvtPrd
), readl(®s
->TxPi
),
1306 rrpriv
->info
->tx_ctrl
.pi
);
1308 printk("Error code 0x%x\n", readl(®s
->Fail1
));
1310 index
= (((readl(®s
->EvtPrd
) >> 8) & 0xff ) - 1) % EVT_RING_ENTRIES
;
1311 cons
= rrpriv
->dirty_tx
;
1312 printk("TX ring index %i, TX consumer %i\n",
1315 if (rrpriv
->tx_skbuff
[index
]){
1316 len
= min_t(int, 0x80, rrpriv
->tx_skbuff
[index
]->len
);
1317 printk("skbuff for index %i is valid - dumping data (0x%x bytes - DMA len 0x%x)\n", index
, len
, rrpriv
->tx_ring
[index
].size
);
1318 for (i
= 0; i
< len
; i
++){
1321 printk("%02x ", (unsigned char) rrpriv
->tx_skbuff
[index
]->data
[i
]);
1326 if (rrpriv
->tx_skbuff
[cons
]){
1327 len
= min_t(int, 0x80, rrpriv
->tx_skbuff
[cons
]->len
);
1328 printk("skbuff for cons %i is valid - dumping data (0x%x bytes - skbuff len 0x%x)\n", cons
, len
, rrpriv
->tx_skbuff
[cons
]->len
);
1329 printk("mode 0x%x, size 0x%x,\n phys %08Lx, skbuff-addr %08lx, truesize 0x%x\n",
1330 rrpriv
->tx_ring
[cons
].mode
,
1331 rrpriv
->tx_ring
[cons
].size
,
1332 (unsigned long long) rrpriv
->tx_ring
[cons
].addr
.addrlo
,
1333 (unsigned long)rrpriv
->tx_skbuff
[cons
]->data
,
1334 (unsigned int)rrpriv
->tx_skbuff
[cons
]->truesize
);
1335 for (i
= 0; i
< len
; i
++){
1338 printk("%02x ", (unsigned char)rrpriv
->tx_ring
[cons
].size
);
1343 printk("dumping TX ring info:\n");
1344 for (i
= 0; i
< TX_RING_ENTRIES
; i
++)
1345 printk("mode 0x%x, size 0x%x, phys-addr %08Lx\n",
1346 rrpriv
->tx_ring
[i
].mode
,
1347 rrpriv
->tx_ring
[i
].size
,
1348 (unsigned long long) rrpriv
->tx_ring
[i
].addr
.addrlo
);
1353 static int rr_close(struct net_device
*dev
)
1355 struct rr_private
*rrpriv
;
1356 struct rr_regs __iomem
*regs
;
1357 unsigned long flags
;
1361 netif_stop_queue(dev
);
1363 rrpriv
= netdev_priv(dev
);
1364 regs
= rrpriv
->regs
;
1367 * Lock to make sure we are not cleaning up while another CPU
1368 * is handling interrupts.
1370 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1372 tmp
= readl(®s
->HostCtrl
);
1373 if (tmp
& NIC_HALTED
){
1374 printk("%s: NIC already halted\n", dev
->name
);
1377 tmp
|= HALT_NIC
| RR_CLEAR_INT
;
1378 writel(tmp
, ®s
->HostCtrl
);
1379 readl(®s
->HostCtrl
);
1382 rrpriv
->fw_running
= 0;
1384 del_timer_sync(&rrpriv
->timer
);
1386 writel(0, ®s
->TxPi
);
1387 writel(0, ®s
->IpRxPi
);
1389 writel(0, ®s
->EvtCon
);
1390 writel(0, ®s
->EvtPrd
);
1392 for (i
= 0; i
< CMD_RING_ENTRIES
; i
++)
1393 writel(0, ®s
->CmdRing
[i
]);
1395 rrpriv
->info
->tx_ctrl
.entries
= 0;
1396 rrpriv
->info
->cmd_ctrl
.pi
= 0;
1397 rrpriv
->info
->evt_ctrl
.pi
= 0;
1398 rrpriv
->rx_ctrl
[4].entries
= 0;
1400 rr_raz_tx(rrpriv
, dev
);
1401 rr_raz_rx(rrpriv
, dev
);
1403 pci_free_consistent(rrpriv
->pci_dev
, 256 * sizeof(struct ring_ctrl
),
1404 rrpriv
->rx_ctrl
, rrpriv
->rx_ctrl_dma
);
1405 rrpriv
->rx_ctrl
= NULL
;
1407 pci_free_consistent(rrpriv
->pci_dev
, sizeof(struct rr_info
),
1408 rrpriv
->info
, rrpriv
->info_dma
);
1409 rrpriv
->info
= NULL
;
1411 free_irq(dev
->irq
, dev
);
1412 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1418 static int rr_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1420 struct rr_private
*rrpriv
= netdev_priv(dev
);
1421 struct rr_regs __iomem
*regs
= rrpriv
->regs
;
1422 struct hippi_cb
*hcb
= (struct hippi_cb
*) skb
->cb
;
1423 struct ring_ctrl
*txctrl
;
1424 unsigned long flags
;
1425 u32 index
, len
= skb
->len
;
1427 struct sk_buff
*new_skb
;
1429 if (readl(®s
->Mode
) & FATAL_ERR
)
1430 printk("error codes Fail1 %02x, Fail2 %02x\n",
1431 readl(®s
->Fail1
), readl(®s
->Fail2
));
1434 * We probably need to deal with tbusy here to prevent overruns.
1437 if (skb_headroom(skb
) < 8){
1438 printk("incoming skb too small - reallocating\n");
1439 if (!(new_skb
= dev_alloc_skb(len
+ 8))) {
1441 netif_wake_queue(dev
);
1444 skb_reserve(new_skb
, 8);
1445 skb_put(new_skb
, len
);
1446 skb_copy_from_linear_data(skb
, new_skb
->data
, len
);
1451 ifield
= (u32
*)skb_push(skb
, 8);
1454 ifield
[1] = hcb
->ifield
;
1457 * We don't need the lock before we are actually going to start
1458 * fiddling with the control blocks.
1460 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1462 txctrl
= &rrpriv
->info
->tx_ctrl
;
1466 rrpriv
->tx_skbuff
[index
] = skb
;
1467 set_rraddr(&rrpriv
->tx_ring
[index
].addr
, pci_map_single(
1468 rrpriv
->pci_dev
, skb
->data
, len
+ 8, PCI_DMA_TODEVICE
));
1469 rrpriv
->tx_ring
[index
].size
= len
+ 8; /* include IFIELD */
1470 rrpriv
->tx_ring
[index
].mode
= PACKET_START
| PACKET_END
;
1471 txctrl
->pi
= (index
+ 1) % TX_RING_ENTRIES
;
1473 writel(txctrl
->pi
, ®s
->TxPi
);
1475 if (txctrl
->pi
== rrpriv
->dirty_tx
){
1476 rrpriv
->tx_full
= 1;
1477 netif_stop_queue(dev
);
1480 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1482 dev
->trans_start
= jiffies
;
1488 * Read the firmware out of the EEPROM and put it into the SRAM
1489 * (or from user space - later)
1491 * This operation requires the NIC to be halted and is performed with
1492 * interrupts disabled and with the spinlock hold.
1494 static int rr_load_firmware(struct net_device
*dev
)
1496 struct rr_private
*rrpriv
;
1497 struct rr_regs __iomem
*regs
;
1498 unsigned long eptr
, segptr
;
1500 u32 localctrl
, sptr
, len
, tmp
;
1501 u32 p2len
, p2size
, nr_seg
, revision
, io
, sram_size
;
1502 struct eeprom
*hw
= NULL
;
1504 rrpriv
= netdev_priv(dev
);
1505 regs
= rrpriv
->regs
;
1507 if (dev
->flags
& IFF_UP
)
1510 if (!(readl(®s
->HostCtrl
) & NIC_HALTED
)){
1511 printk("%s: Trying to load firmware to a running NIC.\n",
1516 localctrl
= readl(®s
->LocalCtrl
);
1517 writel(0, ®s
->LocalCtrl
);
1519 writel(0, ®s
->EvtPrd
);
1520 writel(0, ®s
->RxPrd
);
1521 writel(0, ®s
->TxPrd
);
1524 * First wipe the entire SRAM, otherwise we might run into all
1525 * kinds of trouble ... sigh, this took almost all afternoon
1528 io
= readl(®s
->ExtIo
);
1529 writel(0, ®s
->ExtIo
);
1530 sram_size
= rr_read_eeprom_word(rrpriv
, (void *)8);
1532 for (i
= 200; i
< sram_size
/ 4; i
++){
1533 writel(i
* 4, ®s
->WinBase
);
1535 writel(0, ®s
->WinData
);
1538 writel(io
, ®s
->ExtIo
);
1541 eptr
= (unsigned long)rr_read_eeprom_word(rrpriv
,
1542 &hw
->rncd_info
.AddrRunCodeSegs
);
1543 eptr
= ((eptr
& 0x1fffff) >> 3);
1545 p2len
= rr_read_eeprom_word(rrpriv
, (void *)(0x83*4));
1546 p2len
= (p2len
<< 2);
1547 p2size
= rr_read_eeprom_word(rrpriv
, (void *)(0x84*4));
1548 p2size
= ((p2size
& 0x1fffff) >> 3);
1550 if ((eptr
< p2size
) || (eptr
> (p2size
+ p2len
))){
1551 printk("%s: eptr is invalid\n", dev
->name
);
1555 revision
= rr_read_eeprom_word(rrpriv
, &hw
->manf
.HeaderFmt
);
1558 printk("%s: invalid firmware format (%i)\n",
1559 dev
->name
, revision
);
1563 nr_seg
= rr_read_eeprom_word(rrpriv
, (void *)eptr
);
1566 printk("%s: nr_seg %i\n", dev
->name
, nr_seg
);
1569 for (i
= 0; i
< nr_seg
; i
++){
1570 sptr
= rr_read_eeprom_word(rrpriv
, (void *)eptr
);
1572 len
= rr_read_eeprom_word(rrpriv
, (void *)eptr
);
1574 segptr
= (unsigned long)rr_read_eeprom_word(rrpriv
, (void *)eptr
);
1575 segptr
= ((segptr
& 0x1fffff) >> 3);
1578 printk("%s: segment %i, sram address %06x, length %04x, segptr %06x\n",
1579 dev
->name
, i
, sptr
, len
, segptr
);
1581 for (j
= 0; j
< len
; j
++){
1582 tmp
= rr_read_eeprom_word(rrpriv
, (void *)segptr
);
1583 writel(sptr
, ®s
->WinBase
);
1585 writel(tmp
, ®s
->WinData
);
1593 writel(localctrl
, ®s
->LocalCtrl
);
1599 static int rr_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1601 struct rr_private
*rrpriv
;
1602 unsigned char *image
, *oldimage
;
1603 unsigned long flags
;
1605 int error
= -EOPNOTSUPP
;
1607 rrpriv
= netdev_priv(dev
);
1611 if (!capable(CAP_SYS_RAWIO
)){
1615 image
= kmalloc(EEPROM_WORDS
* sizeof(u32
), GFP_KERNEL
);
1617 printk(KERN_ERR
"%s: Unable to allocate memory "
1618 "for EEPROM image\n", dev
->name
);
1623 if (rrpriv
->fw_running
){
1624 printk("%s: Firmware already running\n", dev
->name
);
1629 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1630 i
= rr_read_eeprom(rrpriv
, 0, image
, EEPROM_BYTES
);
1631 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1632 if (i
!= EEPROM_BYTES
){
1633 printk(KERN_ERR
"%s: Error reading EEPROM\n",
1638 error
= copy_to_user(rq
->ifr_data
, image
, EEPROM_BYTES
);
1646 if (!capable(CAP_SYS_RAWIO
)){
1650 image
= kmalloc(EEPROM_WORDS
* sizeof(u32
), GFP_KERNEL
);
1651 oldimage
= kmalloc(EEPROM_WORDS
* sizeof(u32
), GFP_KERNEL
);
1652 if (!image
|| !oldimage
) {
1653 printk(KERN_ERR
"%s: Unable to allocate memory "
1654 "for EEPROM image\n", dev
->name
);
1659 error
= copy_from_user(image
, rq
->ifr_data
, EEPROM_BYTES
);
1665 if (rrpriv
->fw_running
){
1666 printk("%s: Firmware already running\n", dev
->name
);
1671 printk("%s: Updating EEPROM firmware\n", dev
->name
);
1673 spin_lock_irqsave(&rrpriv
->lock
, flags
);
1674 error
= write_eeprom(rrpriv
, 0, image
, EEPROM_BYTES
);
1676 printk(KERN_ERR
"%s: Error writing EEPROM\n",
1679 i
= rr_read_eeprom(rrpriv
, 0, oldimage
, EEPROM_BYTES
);
1680 spin_unlock_irqrestore(&rrpriv
->lock
, flags
);
1682 if (i
!= EEPROM_BYTES
)
1683 printk(KERN_ERR
"%s: Error reading back EEPROM "
1684 "image\n", dev
->name
);
1686 error
= memcmp(image
, oldimage
, EEPROM_BYTES
);
1688 printk(KERN_ERR
"%s: Error verifying EEPROM image\n",
1698 return put_user(0x52523032, (int __user
*)rq
->ifr_data
);
1704 static struct pci_device_id rr_pci_tbl
[] = {
1705 { PCI_VENDOR_ID_ESSENTIAL
, PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER
,
1706 PCI_ANY_ID
, PCI_ANY_ID
, },
1709 MODULE_DEVICE_TABLE(pci
, rr_pci_tbl
);
1711 static struct pci_driver rr_driver
= {
1713 .id_table
= rr_pci_tbl
,
1714 .probe
= rr_init_one
,
1715 .remove
= __devexit_p(rr_remove_one
),
1718 static int __init
rr_init_module(void)
1720 return pci_register_driver(&rr_driver
);
1723 static void __exit
rr_cleanup_module(void)
1725 pci_unregister_driver(&rr_driver
);
1728 module_init(rr_init_module
);
1729 module_exit(rr_cleanup_module
);
1733 * 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"