1 /* lasi_82596.c -- driver for the intel 82596 ethernet controller, as
2 munged into HPPA boxen .
4 This driver is based upon 82596.c, original credits are below...
5 but there were too many hoops which HP wants jumped through to
6 keep this code in there in a sane manner.
8 3 primary sources of the mess --
9 1) hppa needs *lots* of cacheline flushing to keep this kind of
12 2) The 82596 needs to see all of its pointers as their physical
13 address. Thus virt_to_bus/bus_to_virt are *everywhere*.
15 3) The implementation HP is using seems to be significantly pickier
16 about when and how the command and RX units are started. some
17 command ordering was changed.
19 Examination of the mach driver leads one to believe that there
20 might be a saner way to pull this off... anyone who feels like a
21 full rewrite can be my guest.
23 Split 02/13/2000 Sam Creasey (sammy@oh.verio.com)
25 02/01/2000 Initial modifications for parisc by Helge Deller (deller@gmx.de)
26 03/02/2000 changes for better/correct(?) cache-flushing (deller)
29 /* 82596.c: A generic 82596 ethernet driver for linux. */
32 Written 1994 by Mark Evans.
33 This driver is for the Apricot 82596 bus-master interface
35 Modularised 12/94 Mark Evans
38 Modified to support the 82596 ethernet chips on 680x0 VME boards.
39 by Richard Hirst <richard@sleepie.demon.co.uk>
42 980825: Changed to receive directly in to sk_buffs which are
43 allocated at open() time. Eliminates copy on incoming frames
44 (small ones are still copied). Shared data now held in a
45 non-cached page, so we can run on 68060 in copyback mode.
48 * look at deferring rx frames rather than discarding (as per tulip)
49 * handle tx ring full as per tulip
50 * performace test to tune rx_copybreak
52 Most of my modifications relate to the braindead big-endian
53 implementation by Intel. When the i596 is operating in
54 'big-endian' mode, it thinks a 32 bit value of 0x12345678
55 should be stored as 0x56781234. This is a real pain, when
56 you have linked lists which are shared by the 680x0 and the
60 Written 1993 by Donald Becker.
61 Copyright 1993 United States Government as represented by the Director,
62 National Security Agency. This software may only be used and distributed
63 according to the terms of the GNU General Public License as modified by SRC,
64 incorporated herein by reference.
66 The author may be reached as becker@scyld.com, or C/O
67 Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
71 #include <linux/module.h>
72 #include <linux/kernel.h>
73 #include <linux/string.h>
74 #include <linux/errno.h>
75 #include <linux/ioport.h>
76 #include <linux/slab.h>
77 #include <linux/interrupt.h>
78 #include <linux/delay.h>
79 #include <linux/netdevice.h>
80 #include <linux/etherdevice.h>
81 #include <linux/skbuff.h>
82 #include <linux/init.h>
83 #include <linux/types.h>
84 #include <linux/bitops.h>
85 #include <linux/dma-mapping.h>
87 #include <linux/irq.h>
92 #define DEB_INIT 0x0001
93 #define DEB_PROBE 0x0002
94 #define DEB_SERIOUS 0x0004
95 #define DEB_ERRORS 0x0008
96 #define DEB_MULTI 0x0010
97 #define DEB_TDR 0x0020
98 #define DEB_OPEN 0x0040
99 #define DEB_RESET 0x0080
100 #define DEB_ADDCMD 0x0100
101 #define DEB_STATUS 0x0200
102 #define DEB_STARTTX 0x0400
103 #define DEB_RXADDR 0x0800
104 #define DEB_TXADDR 0x1000
105 #define DEB_RXFRAME 0x2000
106 #define DEB_INTS 0x4000
107 #define DEB_STRUCT 0x8000
108 #define DEB_ANY 0xffff
111 #define DEB(x, y) if (i596_debug & (x)) { y; }
115 * The MPU_PORT command allows direct access to the 82596. With PORT access
116 * the following commands are available (p5-18). The 32-bit port command
117 * must be word-swapped with the most significant word written first.
118 * This only applies to VME boards.
120 #define PORT_RESET 0x00 /* reset 82596 */
121 #define PORT_SELFTEST 0x01 /* selftest */
122 #define PORT_ALTSCP 0x02 /* alternate SCB address */
123 #define PORT_ALTDUMP 0x03 /* Alternate DUMP address */
125 static int i596_debug
= (DEB_SERIOUS
|DEB_PROBE
);
127 /* Copy frames shorter than rx_copybreak, otherwise pass on up in
128 * a full sized sk_buff. Value of 100 stolen from tulip.c (!alpha).
130 static int rx_copybreak
= 100;
132 #define PKT_BUF_SZ 1536
133 #define MAX_MC_CNT 64
135 #define ISCP_BUSY 0x0001
137 #define I596_NULL ((u32)0xffffffff)
139 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
140 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
141 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
143 #define CMD_FLEX 0x0008 /* Enable flexible memory model */
146 CmdNOp
= 0, CmdSASetup
= 1, CmdConfigure
= 2, CmdMulticastList
= 3,
147 CmdTx
= 4, CmdTDR
= 5, CmdDump
= 6, CmdDiagnose
= 7
150 #define STAT_C 0x8000 /* Set to 0 after execution */
151 #define STAT_B 0x4000 /* Command being executed */
152 #define STAT_OK 0x2000 /* Command executed ok */
153 #define STAT_A 0x1000 /* Command aborted */
155 #define CUC_START 0x0100
156 #define CUC_RESUME 0x0200
157 #define CUC_SUSPEND 0x0300
158 #define CUC_ABORT 0x0400
159 #define RX_START 0x0010
160 #define RX_RESUME 0x0020
161 #define RX_SUSPEND 0x0030
162 #define RX_ABORT 0x0040
168 unsigned short porthi
;
169 unsigned short portlo
;
174 #define SIZE_MASK 0x3fff
181 u32 cache_pad
[5]; /* Total 32 bytes... */
184 /* The command structure has two 'next' pointers; v_next is the address of
185 * the next command as seen by the CPU, b_next is the address of the next
186 * command as seen by the 82596. The b_next pointer, as used by the 82596
187 * always references the status field of the next command, rather than the
188 * v_next field, because the 82596 is unaware of v_next. It may seem more
189 * logical to put v_next at the end of the structure, but we cannot do that
190 * because the 82596 expects other fields to be there, depending on command
195 struct i596_cmd
*v_next
; /* Address from CPUs viewpoint */
196 unsigned short status
;
197 unsigned short command
;
198 u32 b_next
; /* Address from i596 viewpoint */
206 struct sk_buff
*skb
; /* So we can free it after tx */
209 u32 cache_pad
[6]; /* Total 64 bytes... */
211 u32 cache_pad
[1]; /* Total 32 bytes... */
217 unsigned short status
;
224 char mc_addrs
[MAX_MC_CNT
*6];
234 char i596_config
[16];
240 u32 b_next
; /* Address from i596 viewpoint */
242 unsigned short count
;
244 struct i596_rfd
*v_next
; /* Address from CPUs viewpoint */
245 struct i596_rfd
*v_prev
;
247 u32 cache_pad
[2]; /* Total 32 bytes... */
253 unsigned short count
;
254 unsigned short zero1
;
256 u32 b_data
; /* Address from i596 viewpoint */
258 unsigned short zero2
;
261 struct i596_rbd
*v_next
;
262 u32 b_addr
; /* This rbd addr from i596 view */
263 unsigned char *v_data
; /* Address from CPUs viewpoint */
264 /* Total 32 bytes... */
270 /* These values as chosen so struct i596_dma fits in one page... */
272 #define TX_RING_SIZE 32
273 #define RX_RING_SIZE 16
276 unsigned short status
;
277 unsigned short command
;
287 unsigned short t_off
;
302 struct i596_scp scp
__attribute__((aligned(32)));
303 volatile struct i596_iscp iscp
__attribute__((aligned(32)));
304 volatile struct i596_scb scb
__attribute__((aligned(32)));
305 struct sa_cmd sa_cmd
__attribute__((aligned(32)));
306 struct cf_cmd cf_cmd
__attribute__((aligned(32)));
307 struct tdr_cmd tdr_cmd
__attribute__((aligned(32)));
308 struct mc_cmd mc_cmd
__attribute__((aligned(32)));
309 struct i596_rfd rfds
[RX_RING_SIZE
] __attribute__((aligned(32)));
310 struct i596_rbd rbds
[RX_RING_SIZE
] __attribute__((aligned(32)));
311 struct tx_cmd tx_cmds
[TX_RING_SIZE
] __attribute__((aligned(32)));
312 struct i596_tbd tbds
[TX_RING_SIZE
] __attribute__((aligned(32)));
315 struct i596_private
{
316 struct i596_dma
*dma
;
319 struct i596_rfd
*rfd_head
;
320 struct i596_rbd
*rbd_head
;
321 struct i596_cmd
*cmd_tail
;
322 struct i596_cmd
*cmd_head
;
327 spinlock_t lock
; /* serialize access to chip */
329 void __iomem
*mpu_port
;
333 static const char init_setup
[] =
335 0x8E, /* length, prefetch on */
336 0xC8, /* fifo to 8, monitor off */
337 0x80, /* don't save bad frames */
338 0x2E, /* No source address insertion, 8 byte preamble */
339 0x00, /* priority and backoff defaults */
340 0x60, /* interframe spacing */
341 0x00, /* slot time LSB */
342 0xf2, /* slot time and retries */
343 0x00, /* promiscuous mode */
344 0x00, /* collision detect */
345 0x40, /* minimum frame length */
348 0x7f /* *multi IA */ };
350 static int i596_open(struct net_device
*dev
);
351 static int i596_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
);
352 static irqreturn_t
i596_interrupt(int irq
, void *dev_id
);
353 static int i596_close(struct net_device
*dev
);
354 static void i596_add_cmd(struct net_device
*dev
, struct i596_cmd
*cmd
);
355 static void i596_tx_timeout (struct net_device
*dev
);
356 static void print_eth(unsigned char *buf
, char *str
);
357 static void set_multicast_list(struct net_device
*dev
);
358 static inline void ca(struct net_device
*dev
);
359 static void mpu_port(struct net_device
*dev
, int c
, dma_addr_t x
);
361 static int rx_ring_size
= RX_RING_SIZE
;
362 static int ticks_limit
= 100;
363 static int max_cmd_backlog
= TX_RING_SIZE
-1;
365 #ifdef CONFIG_NET_POLL_CONTROLLER
366 static void i596_poll_controller(struct net_device
*dev
);
370 static inline int wait_istat(struct net_device
*dev
, struct i596_dma
*dma
, int delcnt
, char *str
)
372 DMA_INV(dev
, &(dma
->iscp
), sizeof(struct i596_iscp
));
373 while (--delcnt
&& dma
->iscp
.stat
) {
375 DMA_INV(dev
, &(dma
->iscp
), sizeof(struct i596_iscp
));
378 printk(KERN_ERR
"%s: %s, iscp.stat %04x, didn't clear\n",
379 dev
->name
, str
, SWAP16(dma
->iscp
.stat
));
386 static inline int wait_cmd(struct net_device
*dev
, struct i596_dma
*dma
, int delcnt
, char *str
)
388 DMA_INV(dev
, &(dma
->scb
), sizeof(struct i596_scb
));
389 while (--delcnt
&& dma
->scb
.command
) {
391 DMA_INV(dev
, &(dma
->scb
), sizeof(struct i596_scb
));
394 printk(KERN_ERR
"%s: %s, status %4.4x, cmd %4.4x.\n",
396 SWAP16(dma
->scb
.status
),
397 SWAP16(dma
->scb
.command
));
404 static void i596_display_data(struct net_device
*dev
)
406 struct i596_private
*lp
= netdev_priv(dev
);
407 struct i596_dma
*dma
= lp
->dma
;
408 struct i596_cmd
*cmd
;
409 struct i596_rfd
*rfd
;
410 struct i596_rbd
*rbd
;
412 printk(KERN_DEBUG
"lp and scp at %p, .sysbus = %08x, .iscp = %08x\n",
413 &dma
->scp
, dma
->scp
.sysbus
, SWAP32(dma
->scp
.iscp
));
414 printk(KERN_DEBUG
"iscp at %p, iscp.stat = %08x, .scb = %08x\n",
415 &dma
->iscp
, SWAP32(dma
->iscp
.stat
), SWAP32(dma
->iscp
.scb
));
416 printk(KERN_DEBUG
"scb at %p, scb.status = %04x, .command = %04x,"
417 " .cmd = %08x, .rfd = %08x\n",
418 &dma
->scb
, SWAP16(dma
->scb
.status
), SWAP16(dma
->scb
.command
),
419 SWAP16(dma
->scb
.cmd
), SWAP32(dma
->scb
.rfd
));
420 printk(KERN_DEBUG
" errors: crc %x, align %x, resource %x,"
421 " over %x, rcvdt %x, short %x\n",
422 SWAP32(dma
->scb
.crc_err
), SWAP32(dma
->scb
.align_err
),
423 SWAP32(dma
->scb
.resource_err
), SWAP32(dma
->scb
.over_err
),
424 SWAP32(dma
->scb
.rcvdt_err
), SWAP32(dma
->scb
.short_err
));
426 while (cmd
!= NULL
) {
428 "cmd at %p, .status = %04x, .command = %04x,"
430 cmd
, SWAP16(cmd
->status
), SWAP16(cmd
->command
),
431 SWAP32(cmd
->b_next
));
435 printk(KERN_DEBUG
"rfd_head = %p\n", rfd
);
438 " %p .stat %04x, .cmd %04x, b_next %08x, rbd %08x,"
440 rfd
, SWAP16(rfd
->stat
), SWAP16(rfd
->cmd
),
441 SWAP32(rfd
->b_next
), SWAP32(rfd
->rbd
),
444 } while (rfd
!= lp
->rfd_head
);
446 printk(KERN_DEBUG
"rbd_head = %p\n", rbd
);
449 " %p .count %04x, b_next %08x, b_data %08x,"
451 rbd
, SWAP16(rbd
->count
), SWAP32(rbd
->b_next
),
452 SWAP32(rbd
->b_data
), SWAP16(rbd
->size
));
454 } while (rbd
!= lp
->rbd_head
);
455 DMA_INV(dev
, dma
, sizeof(struct i596_dma
));
459 #define virt_to_dma(lp, v) ((lp)->dma_addr + (dma_addr_t)((unsigned long)(v)-(unsigned long)((lp)->dma)))
461 static inline int init_rx_bufs(struct net_device
*dev
)
463 struct i596_private
*lp
= netdev_priv(dev
);
464 struct i596_dma
*dma
= lp
->dma
;
466 struct i596_rfd
*rfd
;
467 struct i596_rbd
*rbd
;
469 /* First build the Receive Buffer Descriptor List */
471 for (i
= 0, rbd
= dma
->rbds
; i
< rx_ring_size
; i
++, rbd
++) {
473 struct sk_buff
*skb
= netdev_alloc_skb(dev
, PKT_BUF_SZ
+ 4);
478 dma_addr
= dma_map_single(dev
->dev
.parent
, skb
->data
,
479 PKT_BUF_SZ
, DMA_FROM_DEVICE
);
481 rbd
->b_next
= SWAP32(virt_to_dma(lp
, rbd
+1));
482 rbd
->b_addr
= SWAP32(virt_to_dma(lp
, rbd
));
484 rbd
->v_data
= skb
->data
;
485 rbd
->b_data
= SWAP32(dma_addr
);
486 rbd
->size
= SWAP16(PKT_BUF_SZ
);
488 lp
->rbd_head
= dma
->rbds
;
489 rbd
= dma
->rbds
+ rx_ring_size
- 1;
490 rbd
->v_next
= dma
->rbds
;
491 rbd
->b_next
= SWAP32(virt_to_dma(lp
, dma
->rbds
));
493 /* Now build the Receive Frame Descriptor List */
495 for (i
= 0, rfd
= dma
->rfds
; i
< rx_ring_size
; i
++, rfd
++) {
496 rfd
->rbd
= I596_NULL
;
499 rfd
->b_next
= SWAP32(virt_to_dma(lp
, rfd
+1));
500 rfd
->cmd
= SWAP16(CMD_FLEX
);
502 lp
->rfd_head
= dma
->rfds
;
503 dma
->scb
.rfd
= SWAP32(virt_to_dma(lp
, dma
->rfds
));
505 rfd
->rbd
= SWAP32(virt_to_dma(lp
, lp
->rbd_head
));
506 rfd
->v_prev
= dma
->rfds
+ rx_ring_size
- 1;
507 rfd
= dma
->rfds
+ rx_ring_size
- 1;
508 rfd
->v_next
= dma
->rfds
;
509 rfd
->b_next
= SWAP32(virt_to_dma(lp
, dma
->rfds
));
510 rfd
->cmd
= SWAP16(CMD_EOL
|CMD_FLEX
);
512 DMA_WBACK_INV(dev
, dma
, sizeof(struct i596_dma
));
516 static inline void remove_rx_bufs(struct net_device
*dev
)
518 struct i596_private
*lp
= netdev_priv(dev
);
519 struct i596_rbd
*rbd
;
522 for (i
= 0, rbd
= lp
->dma
->rbds
; i
< rx_ring_size
; i
++, rbd
++) {
523 if (rbd
->skb
== NULL
)
525 dma_unmap_single(dev
->dev
.parent
,
526 (dma_addr_t
)SWAP32(rbd
->b_data
),
527 PKT_BUF_SZ
, DMA_FROM_DEVICE
);
528 dev_kfree_skb(rbd
->skb
);
533 static void rebuild_rx_bufs(struct net_device
*dev
)
535 struct i596_private
*lp
= netdev_priv(dev
);
536 struct i596_dma
*dma
= lp
->dma
;
539 /* Ensure rx frame/buffer descriptors are tidy */
541 for (i
= 0; i
< rx_ring_size
; i
++) {
542 dma
->rfds
[i
].rbd
= I596_NULL
;
543 dma
->rfds
[i
].cmd
= SWAP16(CMD_FLEX
);
545 dma
->rfds
[rx_ring_size
-1].cmd
= SWAP16(CMD_EOL
|CMD_FLEX
);
546 lp
->rfd_head
= dma
->rfds
;
547 dma
->scb
.rfd
= SWAP32(virt_to_dma(lp
, dma
->rfds
));
548 lp
->rbd_head
= dma
->rbds
;
549 dma
->rfds
[0].rbd
= SWAP32(virt_to_dma(lp
, dma
->rbds
));
551 DMA_WBACK_INV(dev
, dma
, sizeof(struct i596_dma
));
555 static int init_i596_mem(struct net_device
*dev
)
557 struct i596_private
*lp
= netdev_priv(dev
);
558 struct i596_dma
*dma
= lp
->dma
;
561 mpu_port(dev
, PORT_RESET
, 0);
562 udelay(100); /* Wait 100us - seems to help */
564 /* change the scp address */
566 lp
->last_cmd
= jiffies
;
568 dma
->scp
.sysbus
= SYSBUS
;
569 dma
->scp
.iscp
= SWAP32(virt_to_dma(lp
, &(dma
->iscp
)));
570 dma
->iscp
.scb
= SWAP32(virt_to_dma(lp
, &(dma
->scb
)));
571 dma
->iscp
.stat
= SWAP32(ISCP_BUSY
);
575 dma
->scb
.cmd
= I596_NULL
;
577 DEB(DEB_INIT
, printk(KERN_DEBUG
"%s: starting i82596.\n", dev
->name
));
579 DMA_WBACK(dev
, &(dma
->scp
), sizeof(struct i596_scp
));
580 DMA_WBACK(dev
, &(dma
->iscp
), sizeof(struct i596_iscp
));
581 DMA_WBACK(dev
, &(dma
->scb
), sizeof(struct i596_scb
));
583 mpu_port(dev
, PORT_ALTSCP
, virt_to_dma(lp
, &dma
->scp
));
585 if (wait_istat(dev
, dma
, 1000, "initialization timed out"))
587 DEB(DEB_INIT
, printk(KERN_DEBUG
588 "%s: i82596 initialization successful\n",
591 if (request_irq(dev
->irq
, &i596_interrupt
, 0, "i82596", dev
)) {
592 printk(KERN_ERR
"%s: IRQ %d not free\n", dev
->name
, dev
->irq
);
596 /* Ensure rx frame/buffer descriptors are tidy */
597 rebuild_rx_bufs(dev
);
599 dma
->scb
.command
= 0;
600 DMA_WBACK(dev
, &(dma
->scb
), sizeof(struct i596_scb
));
602 DEB(DEB_INIT
, printk(KERN_DEBUG
603 "%s: queuing CmdConfigure\n", dev
->name
));
604 memcpy(dma
->cf_cmd
.i596_config
, init_setup
, 14);
605 dma
->cf_cmd
.cmd
.command
= SWAP16(CmdConfigure
);
606 DMA_WBACK(dev
, &(dma
->cf_cmd
), sizeof(struct cf_cmd
));
607 i596_add_cmd(dev
, &dma
->cf_cmd
.cmd
);
609 DEB(DEB_INIT
, printk(KERN_DEBUG
"%s: queuing CmdSASetup\n", dev
->name
));
610 memcpy(dma
->sa_cmd
.eth_addr
, dev
->dev_addr
, 6);
611 dma
->sa_cmd
.cmd
.command
= SWAP16(CmdSASetup
);
612 DMA_WBACK(dev
, &(dma
->sa_cmd
), sizeof(struct sa_cmd
));
613 i596_add_cmd(dev
, &dma
->sa_cmd
.cmd
);
615 DEB(DEB_INIT
, printk(KERN_DEBUG
"%s: queuing CmdTDR\n", dev
->name
));
616 dma
->tdr_cmd
.cmd
.command
= SWAP16(CmdTDR
);
617 DMA_WBACK(dev
, &(dma
->tdr_cmd
), sizeof(struct tdr_cmd
));
618 i596_add_cmd(dev
, &dma
->tdr_cmd
.cmd
);
620 spin_lock_irqsave (&lp
->lock
, flags
);
622 if (wait_cmd(dev
, dma
, 1000, "timed out waiting to issue RX_START")) {
623 spin_unlock_irqrestore (&lp
->lock
, flags
);
624 goto failed_free_irq
;
626 DEB(DEB_INIT
, printk(KERN_DEBUG
"%s: Issuing RX_START\n", dev
->name
));
627 dma
->scb
.command
= SWAP16(RX_START
);
628 dma
->scb
.rfd
= SWAP32(virt_to_dma(lp
, dma
->rfds
));
629 DMA_WBACK(dev
, &(dma
->scb
), sizeof(struct i596_scb
));
633 spin_unlock_irqrestore (&lp
->lock
, flags
);
634 if (wait_cmd(dev
, dma
, 1000, "RX_START not processed"))
635 goto failed_free_irq
;
636 DEB(DEB_INIT
, printk(KERN_DEBUG
637 "%s: Receive unit started OK\n", dev
->name
));
641 free_irq(dev
->irq
, dev
);
643 printk(KERN_ERR
"%s: Failed to initialise 82596\n", dev
->name
);
644 mpu_port(dev
, PORT_RESET
, 0);
649 static inline int i596_rx(struct net_device
*dev
)
651 struct i596_private
*lp
= netdev_priv(dev
);
652 struct i596_rfd
*rfd
;
653 struct i596_rbd
*rbd
;
656 DEB(DEB_RXFRAME
, printk(KERN_DEBUG
657 "i596_rx(), rfd_head %p, rbd_head %p\n",
658 lp
->rfd_head
, lp
->rbd_head
));
661 rfd
= lp
->rfd_head
; /* Ref next frame to check */
663 DMA_INV(dev
, rfd
, sizeof(struct i596_rfd
));
664 while (rfd
->stat
& SWAP16(STAT_C
)) { /* Loop while complete frames */
665 if (rfd
->rbd
== I596_NULL
)
667 else if (rfd
->rbd
== lp
->rbd_head
->b_addr
) {
669 DMA_INV(dev
, rbd
, sizeof(struct i596_rbd
));
671 printk(KERN_ERR
"%s: rbd chain broken!\n", dev
->name
);
675 DEB(DEB_RXFRAME
, printk(KERN_DEBUG
676 " rfd %p, rfd.rbd %08x, rfd.stat %04x\n",
677 rfd
, rfd
->rbd
, rfd
->stat
));
679 if (rbd
!= NULL
&& (rfd
->stat
& SWAP16(STAT_OK
))) {
681 int pkt_len
= SWAP16(rbd
->count
) & 0x3fff;
682 struct sk_buff
*skb
= rbd
->skb
;
685 DEB(DEB_RXADDR
, print_eth(rbd
->v_data
, "received"));
688 /* Check if the packet is long enough to just accept
689 * without copying to a properly sized skbuff.
692 if (pkt_len
> rx_copybreak
) {
693 struct sk_buff
*newskb
;
696 dma_unmap_single(dev
->dev
.parent
,
697 (dma_addr_t
)SWAP32(rbd
->b_data
),
698 PKT_BUF_SZ
, DMA_FROM_DEVICE
);
699 /* Get fresh skbuff to replace filled one. */
700 newskb
= netdev_alloc_skb(dev
, PKT_BUF_SZ
+ 4);
701 if (newskb
== NULL
) {
702 skb
= NULL
; /* drop pkt */
705 skb_reserve(newskb
, 2);
707 /* Pass up the skb already on the Rx ring. */
708 skb_put(skb
, pkt_len
);
711 dma_addr
= dma_map_single(dev
->dev
.parent
,
715 rbd
->v_data
= newskb
->data
;
716 rbd
->b_data
= SWAP32(dma_addr
);
717 DMA_WBACK_INV(dev
, rbd
, sizeof(struct i596_rbd
));
719 skb
= netdev_alloc_skb(dev
, pkt_len
+ 2);
722 /* XXX tulip.c can defer packets here!! */
724 "%s: i596_rx Memory squeeze, dropping packet.\n",
726 dev
->stats
.rx_dropped
++;
729 /* 16 byte align the data fields */
730 dma_sync_single_for_cpu(dev
->dev
.parent
,
731 (dma_addr_t
)SWAP32(rbd
->b_data
),
732 PKT_BUF_SZ
, DMA_FROM_DEVICE
);
734 memcpy(skb_put(skb
, pkt_len
), rbd
->v_data
, pkt_len
);
735 dma_sync_single_for_device(dev
->dev
.parent
,
736 (dma_addr_t
)SWAP32(rbd
->b_data
),
737 PKT_BUF_SZ
, DMA_FROM_DEVICE
);
740 skb
->protocol
= eth_type_trans(skb
, dev
);
742 dev
->stats
.rx_packets
++;
743 dev
->stats
.rx_bytes
+= pkt_len
;
746 DEB(DEB_ERRORS
, printk(KERN_DEBUG
747 "%s: Error, rfd.stat = 0x%04x\n",
748 dev
->name
, rfd
->stat
));
749 dev
->stats
.rx_errors
++;
750 if (rfd
->stat
& SWAP16(0x0100))
751 dev
->stats
.collisions
++;
752 if (rfd
->stat
& SWAP16(0x8000))
753 dev
->stats
.rx_length_errors
++;
754 if (rfd
->stat
& SWAP16(0x0001))
755 dev
->stats
.rx_over_errors
++;
756 if (rfd
->stat
& SWAP16(0x0002))
757 dev
->stats
.rx_fifo_errors
++;
758 if (rfd
->stat
& SWAP16(0x0004))
759 dev
->stats
.rx_frame_errors
++;
760 if (rfd
->stat
& SWAP16(0x0008))
761 dev
->stats
.rx_crc_errors
++;
762 if (rfd
->stat
& SWAP16(0x0010))
763 dev
->stats
.rx_length_errors
++;
766 /* Clear the buffer descriptor count and EOF + F flags */
768 if (rbd
!= NULL
&& (rbd
->count
& SWAP16(0x4000))) {
770 lp
->rbd_head
= rbd
->v_next
;
771 DMA_WBACK_INV(dev
, rbd
, sizeof(struct i596_rbd
));
774 /* Tidy the frame descriptor, marking it as end of list */
776 rfd
->rbd
= I596_NULL
;
778 rfd
->cmd
= SWAP16(CMD_EOL
|CMD_FLEX
);
781 /* Update record of next frame descriptor to process */
783 lp
->dma
->scb
.rfd
= rfd
->b_next
;
784 lp
->rfd_head
= rfd
->v_next
;
785 DMA_WBACK_INV(dev
, rfd
, sizeof(struct i596_rfd
));
787 /* Remove end-of-list from old end descriptor */
789 rfd
->v_prev
->cmd
= SWAP16(CMD_FLEX
);
790 DMA_WBACK_INV(dev
, rfd
->v_prev
, sizeof(struct i596_rfd
));
792 DMA_INV(dev
, rfd
, sizeof(struct i596_rfd
));
795 DEB(DEB_RXFRAME
, printk(KERN_DEBUG
"frames %d\n", frames
));
801 static inline void i596_cleanup_cmd(struct net_device
*dev
, struct i596_private
*lp
)
803 struct i596_cmd
*ptr
;
805 while (lp
->cmd_head
!= NULL
) {
807 lp
->cmd_head
= ptr
->v_next
;
810 switch (SWAP16(ptr
->command
) & 0x7) {
813 struct tx_cmd
*tx_cmd
= (struct tx_cmd
*) ptr
;
814 struct sk_buff
*skb
= tx_cmd
->skb
;
815 dma_unmap_single(dev
->dev
.parent
,
817 skb
->len
, DMA_TO_DEVICE
);
821 dev
->stats
.tx_errors
++;
822 dev
->stats
.tx_aborted_errors
++;
825 ptr
->b_next
= I596_NULL
;
826 tx_cmd
->cmd
.command
= 0; /* Mark as free */
831 ptr
->b_next
= I596_NULL
;
833 DMA_WBACK_INV(dev
, ptr
, sizeof(struct i596_cmd
));
836 wait_cmd(dev
, lp
->dma
, 100, "i596_cleanup_cmd timed out");
837 lp
->dma
->scb
.cmd
= I596_NULL
;
838 DMA_WBACK(dev
, &(lp
->dma
->scb
), sizeof(struct i596_scb
));
842 static inline void i596_reset(struct net_device
*dev
, struct i596_private
*lp
)
846 DEB(DEB_RESET
, printk(KERN_DEBUG
"i596_reset\n"));
848 spin_lock_irqsave (&lp
->lock
, flags
);
850 wait_cmd(dev
, lp
->dma
, 100, "i596_reset timed out");
852 netif_stop_queue(dev
);
854 /* FIXME: this command might cause an lpmc */
855 lp
->dma
->scb
.command
= SWAP16(CUC_ABORT
| RX_ABORT
);
856 DMA_WBACK(dev
, &(lp
->dma
->scb
), sizeof(struct i596_scb
));
859 /* wait for shutdown */
860 wait_cmd(dev
, lp
->dma
, 1000, "i596_reset 2 timed out");
861 spin_unlock_irqrestore (&lp
->lock
, flags
);
863 i596_cleanup_cmd(dev
, lp
);
866 netif_start_queue(dev
);
871 static void i596_add_cmd(struct net_device
*dev
, struct i596_cmd
*cmd
)
873 struct i596_private
*lp
= netdev_priv(dev
);
874 struct i596_dma
*dma
= lp
->dma
;
877 DEB(DEB_ADDCMD
, printk(KERN_DEBUG
"i596_add_cmd cmd_head %p\n",
881 cmd
->command
|= SWAP16(CMD_EOL
| CMD_INTR
);
883 cmd
->b_next
= I596_NULL
;
884 DMA_WBACK(dev
, cmd
, sizeof(struct i596_cmd
));
886 spin_lock_irqsave (&lp
->lock
, flags
);
888 if (lp
->cmd_head
!= NULL
) {
889 lp
->cmd_tail
->v_next
= cmd
;
890 lp
->cmd_tail
->b_next
= SWAP32(virt_to_dma(lp
, &cmd
->status
));
891 DMA_WBACK(dev
, lp
->cmd_tail
, sizeof(struct i596_cmd
));
894 wait_cmd(dev
, dma
, 100, "i596_add_cmd timed out");
895 dma
->scb
.cmd
= SWAP32(virt_to_dma(lp
, &cmd
->status
));
896 dma
->scb
.command
= SWAP16(CUC_START
);
897 DMA_WBACK(dev
, &(dma
->scb
), sizeof(struct i596_scb
));
903 spin_unlock_irqrestore (&lp
->lock
, flags
);
905 if (lp
->cmd_backlog
> max_cmd_backlog
) {
906 unsigned long tickssofar
= jiffies
- lp
->last_cmd
;
908 if (tickssofar
< ticks_limit
)
912 "%s: command unit timed out, status resetting.\n",
920 static int i596_open(struct net_device
*dev
)
922 DEB(DEB_OPEN
, printk(KERN_DEBUG
923 "%s: i596_open() irq %d.\n", dev
->name
, dev
->irq
));
925 if (init_rx_bufs(dev
)) {
926 printk(KERN_ERR
"%s: Failed to init rx bufs\n", dev
->name
);
929 if (init_i596_mem(dev
)) {
930 printk(KERN_ERR
"%s: Failed to init memory\n", dev
->name
);
931 goto out_remove_rx_bufs
;
933 netif_start_queue(dev
);
942 static void i596_tx_timeout (struct net_device
*dev
)
944 struct i596_private
*lp
= netdev_priv(dev
);
946 /* Transmitter timeout, serious problems. */
947 DEB(DEB_ERRORS
, printk(KERN_DEBUG
948 "%s: transmit timed out, status resetting.\n",
951 dev
->stats
.tx_errors
++;
953 /* Try to restart the adaptor */
954 if (lp
->last_restart
== dev
->stats
.tx_packets
) {
955 DEB(DEB_ERRORS
, printk(KERN_DEBUG
"Resetting board.\n"));
956 /* Shutdown and restart */
957 i596_reset (dev
, lp
);
959 /* Issue a channel attention signal */
960 DEB(DEB_ERRORS
, printk(KERN_DEBUG
"Kicking board.\n"));
961 lp
->dma
->scb
.command
= SWAP16(CUC_START
| RX_START
);
962 DMA_WBACK_INV(dev
, &(lp
->dma
->scb
), sizeof(struct i596_scb
));
964 lp
->last_restart
= dev
->stats
.tx_packets
;
967 dev
->trans_start
= jiffies
;
968 netif_wake_queue (dev
);
972 static int i596_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
974 struct i596_private
*lp
= netdev_priv(dev
);
975 struct tx_cmd
*tx_cmd
;
976 struct i596_tbd
*tbd
;
977 short length
= skb
->len
;
978 dev
->trans_start
= jiffies
;
980 DEB(DEB_STARTTX
, printk(KERN_DEBUG
981 "%s: i596_start_xmit(%x,%p) called\n",
982 dev
->name
, skb
->len
, skb
->data
));
984 if (length
< ETH_ZLEN
) {
985 if (skb_padto(skb
, ETH_ZLEN
))
990 netif_stop_queue(dev
);
992 tx_cmd
= lp
->dma
->tx_cmds
+ lp
->next_tx_cmd
;
993 tbd
= lp
->dma
->tbds
+ lp
->next_tx_cmd
;
995 if (tx_cmd
->cmd
.command
) {
996 DEB(DEB_ERRORS
, printk(KERN_DEBUG
997 "%s: xmit ring full, dropping packet.\n",
999 dev
->stats
.tx_dropped
++;
1003 if (++lp
->next_tx_cmd
== TX_RING_SIZE
)
1004 lp
->next_tx_cmd
= 0;
1005 tx_cmd
->tbd
= SWAP32(virt_to_dma(lp
, tbd
));
1006 tbd
->next
= I596_NULL
;
1008 tx_cmd
->cmd
.command
= SWAP16(CMD_FLEX
| CmdTx
);
1014 tbd
->size
= SWAP16(EOF
| length
);
1016 tx_cmd
->dma_addr
= dma_map_single(dev
->dev
.parent
, skb
->data
,
1017 skb
->len
, DMA_TO_DEVICE
);
1018 tbd
->data
= SWAP32(tx_cmd
->dma_addr
);
1020 DEB(DEB_TXADDR
, print_eth(skb
->data
, "tx-queued"));
1021 DMA_WBACK_INV(dev
, tx_cmd
, sizeof(struct tx_cmd
));
1022 DMA_WBACK_INV(dev
, tbd
, sizeof(struct i596_tbd
));
1023 i596_add_cmd(dev
, &tx_cmd
->cmd
);
1025 dev
->stats
.tx_packets
++;
1026 dev
->stats
.tx_bytes
+= length
;
1029 netif_start_queue(dev
);
1034 static void print_eth(unsigned char *add
, char *str
)
1036 printk(KERN_DEBUG
"i596 0x%p, %pM --> %pM %02X%02X, %s\n",
1037 add
, add
+ 6, add
, add
[12], add
[13], str
);
1040 static int __devinit
i82596_probe(struct net_device
*dev
)
1043 struct i596_private
*lp
= netdev_priv(dev
);
1044 struct i596_dma
*dma
;
1046 /* This lot is ensure things have been cache line aligned. */
1047 BUILD_BUG_ON(sizeof(struct i596_rfd
) != 32);
1048 BUILD_BUG_ON(sizeof(struct i596_rbd
) & 31);
1049 BUILD_BUG_ON(sizeof(struct tx_cmd
) & 31);
1050 BUILD_BUG_ON(sizeof(struct i596_tbd
) != 32);
1052 BUILD_BUG_ON(sizeof(struct i596_dma
) > 4096);
1055 if (!dev
->base_addr
|| !dev
->irq
)
1058 dma
= (struct i596_dma
*) DMA_ALLOC(dev
->dev
.parent
,
1059 sizeof(struct i596_dma
), &lp
->dma_addr
, GFP_KERNEL
);
1061 printk(KERN_ERR
"%s: Couldn't get shared memory\n", __FILE__
);
1065 /* The 82596-specific entries in the device structure. */
1066 dev
->open
= i596_open
;
1067 dev
->stop
= i596_close
;
1068 dev
->hard_start_xmit
= i596_start_xmit
;
1069 dev
->set_multicast_list
= set_multicast_list
;
1070 dev
->tx_timeout
= i596_tx_timeout
;
1071 dev
->watchdog_timeo
= TX_TIMEOUT
;
1072 #ifdef CONFIG_NET_POLL_CONTROLLER
1073 dev
->poll_controller
= i596_poll_controller
;
1076 memset(dma
, 0, sizeof(struct i596_dma
));
1079 dma
->scb
.command
= 0;
1080 dma
->scb
.cmd
= I596_NULL
;
1081 dma
->scb
.rfd
= I596_NULL
;
1082 spin_lock_init(&lp
->lock
);
1084 DMA_WBACK_INV(dev
, dma
, sizeof(struct i596_dma
));
1086 i
= register_netdev(dev
);
1088 DMA_FREE(dev
->dev
.parent
, sizeof(struct i596_dma
),
1089 (void *)dma
, lp
->dma_addr
);
1093 DEB(DEB_PROBE
, printk(KERN_INFO
"%s: 82596 at %#3lx,",
1094 dev
->name
, dev
->base_addr
));
1095 for (i
= 0; i
< 6; i
++)
1096 DEB(DEB_PROBE
, printk(" %2.2X", dev
->dev_addr
[i
]));
1097 DEB(DEB_PROBE
, printk(" IRQ %d.\n", dev
->irq
));
1098 DEB(DEB_INIT
, printk(KERN_INFO
1099 "%s: dma at 0x%p (%d bytes), lp->scb at 0x%p\n",
1100 dev
->name
, dma
, (int)sizeof(struct i596_dma
),
1106 #ifdef CONFIG_NET_POLL_CONTROLLER
1107 static void i596_poll_controller(struct net_device
*dev
)
1109 disable_irq(dev
->irq
);
1110 i596_interrupt(dev
->irq
, dev
);
1111 enable_irq(dev
->irq
);
1115 static irqreturn_t
i596_interrupt(int irq
, void *dev_id
)
1117 struct net_device
*dev
= dev_id
;
1118 struct i596_private
*lp
;
1119 struct i596_dma
*dma
;
1120 unsigned short status
, ack_cmd
= 0;
1122 lp
= netdev_priv(dev
);
1125 spin_lock (&lp
->lock
);
1127 wait_cmd(dev
, dma
, 100, "i596 interrupt, timeout");
1128 status
= SWAP16(dma
->scb
.status
);
1130 DEB(DEB_INTS
, printk(KERN_DEBUG
1131 "%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1132 dev
->name
, dev
->irq
, status
));
1134 ack_cmd
= status
& 0xf000;
1137 DEB(DEB_ERRORS
, printk(KERN_DEBUG
1138 "%s: interrupt with no events\n",
1140 spin_unlock (&lp
->lock
);
1144 if ((status
& 0x8000) || (status
& 0x2000)) {
1145 struct i596_cmd
*ptr
;
1147 if ((status
& 0x8000))
1150 "%s: i596 interrupt completed command.\n",
1152 if ((status
& 0x2000))
1155 "%s: i596 interrupt command unit inactive %x.\n",
1156 dev
->name
, status
& 0x0700));
1158 while (lp
->cmd_head
!= NULL
) {
1159 DMA_INV(dev
, lp
->cmd_head
, sizeof(struct i596_cmd
));
1160 if (!(lp
->cmd_head
->status
& SWAP16(STAT_C
)))
1167 "cmd_head->status = %04x, ->command = %04x\n",
1168 SWAP16(lp
->cmd_head
->status
),
1169 SWAP16(lp
->cmd_head
->command
)));
1170 lp
->cmd_head
= ptr
->v_next
;
1173 switch (SWAP16(ptr
->command
) & 0x7) {
1176 struct tx_cmd
*tx_cmd
= (struct tx_cmd
*) ptr
;
1177 struct sk_buff
*skb
= tx_cmd
->skb
;
1179 if (ptr
->status
& SWAP16(STAT_OK
)) {
1181 print_eth(skb
->data
, "tx-done"));
1183 dev
->stats
.tx_errors
++;
1184 if (ptr
->status
& SWAP16(0x0020))
1185 dev
->stats
.collisions
++;
1186 if (!(ptr
->status
& SWAP16(0x0040)))
1187 dev
->stats
.tx_heartbeat_errors
++;
1188 if (ptr
->status
& SWAP16(0x0400))
1189 dev
->stats
.tx_carrier_errors
++;
1190 if (ptr
->status
& SWAP16(0x0800))
1191 dev
->stats
.collisions
++;
1192 if (ptr
->status
& SWAP16(0x1000))
1193 dev
->stats
.tx_aborted_errors
++;
1195 dma_unmap_single(dev
->dev
.parent
,
1197 skb
->len
, DMA_TO_DEVICE
);
1198 dev_kfree_skb_irq(skb
);
1200 tx_cmd
->cmd
.command
= 0; /* Mark free */
1205 unsigned short status
= SWAP16(((struct tdr_cmd
*)ptr
)->status
);
1207 if (status
& 0x8000) {
1209 printk(KERN_DEBUG
"%s: link ok.\n",
1212 if (status
& 0x4000)
1214 "%s: Transceiver problem.\n",
1216 if (status
& 0x2000)
1218 "%s: Termination problem.\n",
1220 if (status
& 0x1000)
1222 "%s: Short circuit.\n",
1226 printk(KERN_DEBUG
"%s: Time %d.\n",
1227 dev
->name
, status
& 0x07ff));
1233 * Zap command so set_multicast_list() know
1240 ptr
->b_next
= I596_NULL
;
1241 DMA_WBACK(dev
, ptr
, sizeof(struct i596_cmd
));
1242 lp
->last_cmd
= jiffies
;
1245 /* This mess is arranging that only the last of any outstanding
1246 * commands has the interrupt bit set. Should probably really
1247 * only add to the cmd queue when the CU is stopped.
1250 while ((ptr
!= NULL
) && (ptr
!= lp
->cmd_tail
)) {
1251 struct i596_cmd
*prev
= ptr
;
1253 ptr
->command
&= SWAP16(0x1fff);
1255 DMA_WBACK_INV(dev
, prev
, sizeof(struct i596_cmd
));
1258 if (lp
->cmd_head
!= NULL
)
1259 ack_cmd
|= CUC_START
;
1260 dma
->scb
.cmd
= SWAP32(virt_to_dma(lp
, &lp
->cmd_head
->status
));
1261 DMA_WBACK_INV(dev
, &dma
->scb
, sizeof(struct i596_scb
));
1263 if ((status
& 0x1000) || (status
& 0x4000)) {
1264 if ((status
& 0x4000))
1267 "%s: i596 interrupt received a frame.\n",
1270 /* Only RX_START if stopped - RGH 07-07-96 */
1271 if (status
& 0x1000) {
1272 if (netif_running(dev
)) {
1275 "%s: i596 interrupt receive unit inactive, status 0x%x\n",
1276 dev
->name
, status
));
1277 ack_cmd
|= RX_START
;
1278 dev
->stats
.rx_errors
++;
1279 dev
->stats
.rx_fifo_errors
++;
1280 rebuild_rx_bufs(dev
);
1284 wait_cmd(dev
, dma
, 100, "i596 interrupt, timeout");
1285 dma
->scb
.command
= SWAP16(ack_cmd
);
1286 DMA_WBACK(dev
, &dma
->scb
, sizeof(struct i596_scb
));
1288 /* DANGER: I suspect that some kind of interrupt
1289 acknowledgement aside from acking the 82596 might be needed
1290 here... but it's running acceptably without */
1294 wait_cmd(dev
, dma
, 100, "i596 interrupt, exit timeout");
1295 DEB(DEB_INTS
, printk(KERN_DEBUG
"%s: exiting interrupt.\n", dev
->name
));
1297 spin_unlock (&lp
->lock
);
1301 static int i596_close(struct net_device
*dev
)
1303 struct i596_private
*lp
= netdev_priv(dev
);
1304 unsigned long flags
;
1306 netif_stop_queue(dev
);
1310 "%s: Shutting down ethercard, status was %4.4x.\n",
1311 dev
->name
, SWAP16(lp
->dma
->scb
.status
)));
1313 spin_lock_irqsave(&lp
->lock
, flags
);
1315 wait_cmd(dev
, lp
->dma
, 100, "close1 timed out");
1316 lp
->dma
->scb
.command
= SWAP16(CUC_ABORT
| RX_ABORT
);
1317 DMA_WBACK(dev
, &lp
->dma
->scb
, sizeof(struct i596_scb
));
1321 wait_cmd(dev
, lp
->dma
, 100, "close2 timed out");
1322 spin_unlock_irqrestore(&lp
->lock
, flags
);
1323 DEB(DEB_STRUCT
, i596_display_data(dev
));
1324 i596_cleanup_cmd(dev
, lp
);
1326 free_irq(dev
->irq
, dev
);
1327 remove_rx_bufs(dev
);
1333 * Set or clear the multicast filter for this adaptor.
1336 static void set_multicast_list(struct net_device
*dev
)
1338 struct i596_private
*lp
= netdev_priv(dev
);
1339 struct i596_dma
*dma
= lp
->dma
;
1340 int config
= 0, cnt
;
1344 "%s: set multicast list, %d entries, promisc %s, allmulti %s\n",
1345 dev
->name
, dev
->mc_count
,
1346 dev
->flags
& IFF_PROMISC
? "ON" : "OFF",
1347 dev
->flags
& IFF_ALLMULTI
? "ON" : "OFF"));
1349 if ((dev
->flags
& IFF_PROMISC
) &&
1350 !(dma
->cf_cmd
.i596_config
[8] & 0x01)) {
1351 dma
->cf_cmd
.i596_config
[8] |= 0x01;
1354 if (!(dev
->flags
& IFF_PROMISC
) &&
1355 (dma
->cf_cmd
.i596_config
[8] & 0x01)) {
1356 dma
->cf_cmd
.i596_config
[8] &= ~0x01;
1359 if ((dev
->flags
& IFF_ALLMULTI
) &&
1360 (dma
->cf_cmd
.i596_config
[11] & 0x20)) {
1361 dma
->cf_cmd
.i596_config
[11] &= ~0x20;
1364 if (!(dev
->flags
& IFF_ALLMULTI
) &&
1365 !(dma
->cf_cmd
.i596_config
[11] & 0x20)) {
1366 dma
->cf_cmd
.i596_config
[11] |= 0x20;
1370 if (dma
->cf_cmd
.cmd
.command
)
1372 "%s: config change request already queued\n",
1375 dma
->cf_cmd
.cmd
.command
= SWAP16(CmdConfigure
);
1376 DMA_WBACK_INV(dev
, &dma
->cf_cmd
, sizeof(struct cf_cmd
));
1377 i596_add_cmd(dev
, &dma
->cf_cmd
.cmd
);
1381 cnt
= dev
->mc_count
;
1382 if (cnt
> MAX_MC_CNT
) {
1384 printk(KERN_NOTICE
"%s: Only %d multicast addresses supported",
1388 if (dev
->mc_count
> 0) {
1389 struct dev_mc_list
*dmi
;
1394 cmd
->cmd
.command
= SWAP16(CmdMulticastList
);
1395 cmd
->mc_cnt
= SWAP16(dev
->mc_count
* 6);
1397 for (dmi
= dev
->mc_list
;
1399 dmi
= dmi
->next
, cnt
--, cp
+= 6) {
1400 memcpy(cp
, dmi
->dmi_addr
, 6);
1404 "%s: Adding address %pM\n",
1407 DMA_WBACK_INV(dev
, &dma
->mc_cmd
, sizeof(struct mc_cmd
));
1408 i596_add_cmd(dev
, &cmd
->cmd
);
This page took 0.059524 seconds and 5 git commands to generate.