Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Amiga Linux/m68k and Linux/PPC Zorro NS8390 Ethernet Driver | |
3 | * | |
4 | * (C) Copyright 1998-2000 by some Elitist 680x0 Users(TM) | |
5 | * | |
6 | * --------------------------------------------------------------------------- | |
7 | * | |
8 | * This program is based on all the other NE2000 drivers for Linux | |
9 | * | |
10 | * --------------------------------------------------------------------------- | |
11 | * | |
12 | * This file is subject to the terms and conditions of the GNU General Public | |
13 | * License. See the file COPYING in the main directory of the Linux | |
14 | * distribution for more details. | |
15 | * | |
16 | * --------------------------------------------------------------------------- | |
17 | * | |
18 | * The Ariadne II and X-Surf are Zorro-II boards containing Realtek RTL8019AS | |
19 | * Ethernet Controllers. | |
20 | */ | |
21 | ||
22 | #include <linux/module.h> | |
23 | #include <linux/kernel.h> | |
24 | #include <linux/errno.h> | |
25 | #include <linux/init.h> | |
26 | #include <linux/delay.h> | |
27 | #include <linux/netdevice.h> | |
28 | #include <linux/etherdevice.h> | |
29 | #include <linux/zorro.h> | |
ff5688ae | 30 | #include <linux/jiffies.h> |
1da177e4 LT |
31 | |
32 | #include <asm/system.h> | |
33 | #include <asm/irq.h> | |
34 | #include <asm/amigaints.h> | |
35 | #include <asm/amigahw.h> | |
36 | ||
8c6270f9 AV |
37 | #define EI_SHIFT(x) (ei_local->reg_offset[x]) |
38 | #define ei_inb(port) in_8(port) | |
39 | #define ei_outb(val,port) out_8(port,val) | |
40 | #define ei_inb_p(port) in_8(port) | |
41 | #define ei_outb_p(val,port) out_8(port,val) | |
1da177e4 | 42 | |
8c6270f9 AV |
43 | static const char version[] = |
44 | "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n"; | |
45 | ||
46 | #include "lib8390.c" | |
1da177e4 LT |
47 | |
48 | #define DRV_NAME "zorro8390" | |
49 | ||
50 | #define NE_BASE (dev->base_addr) | |
51 | #define NE_CMD (0x00*2) | |
52 | #define NE_DATAPORT (0x10*2) /* NatSemi-defined port window offset. */ | |
53 | #define NE_RESET (0x1f*2) /* Issue a read to reset, a write to clear. */ | |
54 | #define NE_IO_EXTENT (0x20*2) | |
55 | ||
56 | #define NE_EN0_ISR (0x07*2) | |
57 | #define NE_EN0_DCFG (0x0e*2) | |
58 | ||
59 | #define NE_EN0_RSARLO (0x08*2) | |
60 | #define NE_EN0_RSARHI (0x09*2) | |
61 | #define NE_EN0_RCNTLO (0x0a*2) | |
62 | #define NE_EN0_RXCR (0x0c*2) | |
63 | #define NE_EN0_TXCR (0x0d*2) | |
64 | #define NE_EN0_RCNTHI (0x0b*2) | |
65 | #define NE_EN0_IMR (0x0f*2) | |
66 | ||
67 | #define NESM_START_PG 0x40 /* First page of TX buffer */ | |
68 | #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ | |
69 | ||
70 | ||
71 | #define WORDSWAP(a) ((((a)>>8)&0xff) | ((a)<<8)) | |
72 | ||
73 | ||
74 | static struct card_info { | |
75 | zorro_id id; | |
76 | const char *name; | |
77 | unsigned int offset; | |
78 | } cards[] __devinitdata = { | |
79 | { ZORRO_PROD_VILLAGE_TRONIC_ARIADNE2, "Ariadne II", 0x0600 }, | |
80 | { ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF, "X-Surf", 0x8600 }, | |
81 | }; | |
82 | ||
83 | static int __devinit zorro8390_init_one(struct zorro_dev *z, | |
84 | const struct zorro_device_id *ent); | |
85 | static int __devinit zorro8390_init(struct net_device *dev, | |
86 | unsigned long board, const char *name, | |
87 | unsigned long ioaddr); | |
88 | static int zorro8390_open(struct net_device *dev); | |
89 | static int zorro8390_close(struct net_device *dev); | |
90 | static void zorro8390_reset_8390(struct net_device *dev); | |
91 | static void zorro8390_get_8390_hdr(struct net_device *dev, | |
92 | struct e8390_pkt_hdr *hdr, int ring_page); | |
93 | static void zorro8390_block_input(struct net_device *dev, int count, | |
94 | struct sk_buff *skb, int ring_offset); | |
95 | static void zorro8390_block_output(struct net_device *dev, const int count, | |
96 | const unsigned char *buf, | |
97 | const int start_page); | |
98 | static void __devexit zorro8390_remove_one(struct zorro_dev *z); | |
99 | ||
100 | static struct zorro_device_id zorro8390_zorro_tbl[] __devinitdata = { | |
101 | { ZORRO_PROD_VILLAGE_TRONIC_ARIADNE2, }, | |
102 | { ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF, }, | |
103 | { 0 } | |
104 | }; | |
105 | ||
106 | static struct zorro_driver zorro8390_driver = { | |
107 | .name = "zorro8390", | |
108 | .id_table = zorro8390_zorro_tbl, | |
109 | .probe = zorro8390_init_one, | |
110 | .remove = __devexit_p(zorro8390_remove_one), | |
111 | }; | |
112 | ||
113 | static int __devinit zorro8390_init_one(struct zorro_dev *z, | |
114 | const struct zorro_device_id *ent) | |
115 | { | |
116 | struct net_device *dev; | |
117 | unsigned long board, ioaddr; | |
118 | int err, i; | |
119 | ||
120 | for (i = ARRAY_SIZE(cards)-1; i >= 0; i--) | |
121 | if (z->id == cards[i].id) | |
122 | break; | |
123 | board = z->resource.start; | |
124 | ioaddr = board+cards[i].offset; | |
b6114794 | 125 | dev = alloc_ei_netdev(); |
1da177e4 LT |
126 | if (!dev) |
127 | return -ENOMEM; | |
1da177e4 LT |
128 | if (!request_mem_region(ioaddr, NE_IO_EXTENT*2, DRV_NAME)) { |
129 | free_netdev(dev); | |
130 | return -EBUSY; | |
131 | } | |
132 | if ((err = zorro8390_init(dev, board, cards[i].name, | |
133 | ZTWO_VADDR(ioaddr)))) { | |
134 | release_mem_region(ioaddr, NE_IO_EXTENT*2); | |
135 | free_netdev(dev); | |
136 | return err; | |
137 | } | |
138 | zorro_set_drvdata(z, dev); | |
139 | return 0; | |
140 | } | |
141 | ||
b6114794 SH |
142 | static const struct net_device_ops zorro8390_netdev_ops = { |
143 | .ndo_open = zorro8390_open, | |
144 | .ndo_stop = zorro8390_close, | |
145 | .ndo_start_xmit = ei_start_xmit, | |
146 | .ndo_tx_timeout = ei_tx_timeout, | |
147 | .ndo_get_stats = ei_get_stats, | |
148 | .ndo_set_multicast_list = ei_set_multicast_list, | |
149 | .ndo_validate_addr = eth_validate_addr, | |
fe96aaa1 | 150 | .ndo_set_mac_address = eth_mac_addr, |
b6114794 SH |
151 | .ndo_change_mtu = eth_change_mtu, |
152 | #ifdef CONFIG_NET_POLL_CONTROLLER | |
153 | .ndo_poll_controller = ei_poll, | |
154 | #endif | |
155 | }; | |
156 | ||
1da177e4 LT |
157 | static int __devinit zorro8390_init(struct net_device *dev, |
158 | unsigned long board, const char *name, | |
159 | unsigned long ioaddr) | |
160 | { | |
161 | int i; | |
162 | int err; | |
163 | unsigned char SA_prom[32]; | |
164 | int start_page, stop_page; | |
165 | static u32 zorro8390_offsets[16] = { | |
166 | 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, | |
167 | 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, | |
168 | }; | |
169 | ||
170 | /* Reset card. Who knows what dain-bramaged state it was left in. */ | |
171 | { | |
172 | unsigned long reset_start_time = jiffies; | |
173 | ||
174 | z_writeb(z_readb(ioaddr + NE_RESET), ioaddr + NE_RESET); | |
175 | ||
176 | while ((z_readb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0) | |
ff5688ae | 177 | if (time_after(jiffies, reset_start_time + 2*HZ/100)) { |
1da177e4 LT |
178 | printk(KERN_WARNING " not found (no reset ack).\n"); |
179 | return -ENODEV; | |
180 | } | |
181 | ||
182 | z_writeb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */ | |
183 | } | |
184 | ||
185 | /* Read the 16 bytes of station address PROM. | |
186 | We must first initialize registers, similar to NS8390_init(eifdev, 0). | |
187 | We can't reliably read the SAPROM address without this. | |
188 | (I learned the hard way!). */ | |
189 | { | |
190 | struct { | |
191 | u32 value; | |
192 | u32 offset; | |
193 | } program_seq[] = { | |
194 | {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/ | |
195 | {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */ | |
196 | {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */ | |
197 | {0x00, NE_EN0_RCNTHI}, | |
198 | {0x00, NE_EN0_IMR}, /* Mask completion irq. */ | |
199 | {0xFF, NE_EN0_ISR}, | |
200 | {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */ | |
201 | {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */ | |
202 | {32, NE_EN0_RCNTLO}, | |
203 | {0x00, NE_EN0_RCNTHI}, | |
204 | {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */ | |
205 | {0x00, NE_EN0_RSARHI}, | |
206 | {E8390_RREAD+E8390_START, NE_CMD}, | |
207 | }; | |
ff8ac609 | 208 | for (i = 0; i < ARRAY_SIZE(program_seq); i++) { |
1da177e4 LT |
209 | z_writeb(program_seq[i].value, ioaddr + program_seq[i].offset); |
210 | } | |
211 | } | |
212 | for (i = 0; i < 16; i++) { | |
213 | SA_prom[i] = z_readb(ioaddr + NE_DATAPORT); | |
214 | (void)z_readb(ioaddr + NE_DATAPORT); | |
215 | } | |
216 | ||
217 | /* We must set the 8390 for word mode. */ | |
218 | z_writeb(0x49, ioaddr + NE_EN0_DCFG); | |
219 | start_page = NESM_START_PG; | |
220 | stop_page = NESM_STOP_PG; | |
221 | ||
222 | dev->base_addr = ioaddr; | |
223 | dev->irq = IRQ_AMIGA_PORTS; | |
224 | ||
225 | /* Install the Interrupt handler */ | |
8c6270f9 | 226 | i = request_irq(IRQ_AMIGA_PORTS, __ei_interrupt, IRQF_SHARED, DRV_NAME, dev); |
1da177e4 LT |
227 | if (i) return i; |
228 | ||
0795af57 JP |
229 | for(i = 0; i < ETHER_ADDR_LEN; i++) |
230 | dev->dev_addr[i] = SA_prom[i]; | |
231 | ||
1da177e4 | 232 | #ifdef DEBUG |
e174961c | 233 | printk("%pM", dev->dev_addr); |
1da177e4 | 234 | #endif |
1da177e4 LT |
235 | |
236 | ei_status.name = name; | |
237 | ei_status.tx_start_page = start_page; | |
238 | ei_status.stop_page = stop_page; | |
239 | ei_status.word16 = 1; | |
240 | ||
241 | ei_status.rx_start_page = start_page + TX_PAGES; | |
242 | ||
243 | ei_status.reset_8390 = &zorro8390_reset_8390; | |
244 | ei_status.block_input = &zorro8390_block_input; | |
245 | ei_status.block_output = &zorro8390_block_output; | |
246 | ei_status.get_8390_hdr = &zorro8390_get_8390_hdr; | |
247 | ei_status.reg_offset = zorro8390_offsets; | |
1da177e4 | 248 | |
b6114794 | 249 | dev->netdev_ops = &zorro8390_netdev_ops; |
8c6270f9 | 250 | __NS8390_init(dev, 0); |
1da177e4 LT |
251 | err = register_netdev(dev); |
252 | if (err) { | |
253 | free_irq(IRQ_AMIGA_PORTS, dev); | |
254 | return err; | |
255 | } | |
256 | ||
e174961c JB |
257 | printk(KERN_INFO "%s: %s at 0x%08lx, Ethernet Address %pM\n", |
258 | dev->name, name, board, dev->dev_addr); | |
1da177e4 LT |
259 | |
260 | return 0; | |
261 | } | |
262 | ||
263 | static int zorro8390_open(struct net_device *dev) | |
264 | { | |
8c6270f9 | 265 | __ei_open(dev); |
1da177e4 LT |
266 | return 0; |
267 | } | |
268 | ||
269 | static int zorro8390_close(struct net_device *dev) | |
270 | { | |
271 | if (ei_debug > 1) | |
272 | printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name); | |
8c6270f9 | 273 | __ei_close(dev); |
1da177e4 LT |
274 | return 0; |
275 | } | |
276 | ||
277 | /* Hard reset the card. This used to pause for the same period that a | |
278 | 8390 reset command required, but that shouldn't be necessary. */ | |
279 | static void zorro8390_reset_8390(struct net_device *dev) | |
280 | { | |
281 | unsigned long reset_start_time = jiffies; | |
282 | ||
283 | if (ei_debug > 1) | |
284 | printk(KERN_DEBUG "resetting the 8390 t=%ld...\n", jiffies); | |
285 | ||
286 | z_writeb(z_readb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); | |
287 | ||
288 | ei_status.txing = 0; | |
289 | ei_status.dmaing = 0; | |
290 | ||
291 | /* This check _should_not_ be necessary, omit eventually. */ | |
292 | while ((z_readb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0) | |
ff5688ae | 293 | if (time_after(jiffies, reset_start_time + 2*HZ/100)) { |
1da177e4 LT |
294 | printk(KERN_WARNING "%s: ne_reset_8390() did not complete.\n", |
295 | dev->name); | |
296 | break; | |
297 | } | |
298 | z_writeb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */ | |
299 | } | |
300 | ||
301 | /* Grab the 8390 specific header. Similar to the block_input routine, but | |
302 | we don't need to be concerned with ring wrap as the header will be at | |
303 | the start of a page, so we optimize accordingly. */ | |
304 | ||
305 | static void zorro8390_get_8390_hdr(struct net_device *dev, | |
306 | struct e8390_pkt_hdr *hdr, int ring_page) | |
307 | { | |
308 | int nic_base = dev->base_addr; | |
309 | int cnt; | |
310 | short *ptrs; | |
311 | ||
312 | /* This *shouldn't* happen. If it does, it's the last thing you'll see */ | |
313 | if (ei_status.dmaing) { | |
314 | printk(KERN_ERR "%s: DMAing conflict in ne_get_8390_hdr " | |
315 | "[DMAstat:%d][irqlock:%d].\n", dev->name, ei_status.dmaing, | |
316 | ei_status.irqlock); | |
317 | return; | |
318 | } | |
319 | ||
320 | ei_status.dmaing |= 0x01; | |
321 | z_writeb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); | |
322 | z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); | |
323 | z_writeb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO); | |
324 | z_writeb(0, nic_base + NE_EN0_RCNTHI); | |
325 | z_writeb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */ | |
326 | z_writeb(ring_page, nic_base + NE_EN0_RSARHI); | |
327 | z_writeb(E8390_RREAD+E8390_START, nic_base + NE_CMD); | |
328 | ||
329 | ptrs = (short*)hdr; | |
330 | for (cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++) | |
331 | *ptrs++ = z_readw(NE_BASE + NE_DATAPORT); | |
332 | ||
333 | z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */ | |
334 | ||
335 | hdr->count = WORDSWAP(hdr->count); | |
336 | ||
337 | ei_status.dmaing &= ~0x01; | |
338 | } | |
339 | ||
340 | /* Block input and output, similar to the Crynwr packet driver. If you | |
341 | are porting to a new ethercard, look at the packet driver source for hints. | |
342 | The NEx000 doesn't share the on-board packet memory -- you have to put | |
343 | the packet out through the "remote DMA" dataport using z_writeb. */ | |
344 | ||
345 | static void zorro8390_block_input(struct net_device *dev, int count, | |
346 | struct sk_buff *skb, int ring_offset) | |
347 | { | |
348 | int nic_base = dev->base_addr; | |
349 | char *buf = skb->data; | |
350 | short *ptrs; | |
351 | int cnt; | |
352 | ||
353 | /* This *shouldn't* happen. If it does, it's the last thing you'll see */ | |
354 | if (ei_status.dmaing) { | |
355 | printk(KERN_ERR "%s: DMAing conflict in ne_block_input " | |
356 | "[DMAstat:%d][irqlock:%d].\n", | |
357 | dev->name, ei_status.dmaing, ei_status.irqlock); | |
358 | return; | |
359 | } | |
360 | ei_status.dmaing |= 0x01; | |
361 | z_writeb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); | |
362 | z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); | |
363 | z_writeb(count & 0xff, nic_base + NE_EN0_RCNTLO); | |
364 | z_writeb(count >> 8, nic_base + NE_EN0_RCNTHI); | |
365 | z_writeb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO); | |
366 | z_writeb(ring_offset >> 8, nic_base + NE_EN0_RSARHI); | |
367 | z_writeb(E8390_RREAD+E8390_START, nic_base + NE_CMD); | |
368 | ptrs = (short*)buf; | |
369 | for (cnt = 0; cnt < (count>>1); cnt++) | |
370 | *ptrs++ = z_readw(NE_BASE + NE_DATAPORT); | |
371 | if (count & 0x01) | |
372 | buf[count-1] = z_readb(NE_BASE + NE_DATAPORT); | |
373 | ||
374 | z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */ | |
375 | ei_status.dmaing &= ~0x01; | |
376 | } | |
377 | ||
378 | static void zorro8390_block_output(struct net_device *dev, int count, | |
379 | const unsigned char *buf, | |
380 | const int start_page) | |
381 | { | |
382 | int nic_base = NE_BASE; | |
383 | unsigned long dma_start; | |
384 | short *ptrs; | |
385 | int cnt; | |
386 | ||
387 | /* Round the count up for word writes. Do we need to do this? | |
388 | What effect will an odd byte count have on the 8390? | |
389 | I should check someday. */ | |
390 | if (count & 0x01) | |
391 | count++; | |
392 | ||
393 | /* This *shouldn't* happen. If it does, it's the last thing you'll see */ | |
394 | if (ei_status.dmaing) { | |
395 | printk(KERN_ERR "%s: DMAing conflict in ne_block_output." | |
396 | "[DMAstat:%d][irqlock:%d]\n", dev->name, ei_status.dmaing, | |
397 | ei_status.irqlock); | |
398 | return; | |
399 | } | |
400 | ei_status.dmaing |= 0x01; | |
401 | /* We should already be in page 0, but to be safe... */ | |
402 | z_writeb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); | |
403 | ||
404 | z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); | |
405 | ||
406 | /* Now the normal output. */ | |
407 | z_writeb(count & 0xff, nic_base + NE_EN0_RCNTLO); | |
408 | z_writeb(count >> 8, nic_base + NE_EN0_RCNTHI); | |
409 | z_writeb(0x00, nic_base + NE_EN0_RSARLO); | |
410 | z_writeb(start_page, nic_base + NE_EN0_RSARHI); | |
411 | ||
412 | z_writeb(E8390_RWRITE+E8390_START, nic_base + NE_CMD); | |
413 | ptrs = (short*)buf; | |
414 | for (cnt = 0; cnt < count>>1; cnt++) | |
415 | z_writew(*ptrs++, NE_BASE+NE_DATAPORT); | |
416 | ||
417 | dma_start = jiffies; | |
418 | ||
419 | while ((z_readb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0) | |
ff5688ae | 420 | if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */ |
1da177e4 LT |
421 | printk(KERN_ERR "%s: timeout waiting for Tx RDC.\n", |
422 | dev->name); | |
423 | zorro8390_reset_8390(dev); | |
8c6270f9 | 424 | __NS8390_init(dev,1); |
1da177e4 LT |
425 | break; |
426 | } | |
427 | ||
428 | z_writeb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */ | |
429 | ei_status.dmaing &= ~0x01; | |
430 | return; | |
431 | } | |
432 | ||
433 | static void __devexit zorro8390_remove_one(struct zorro_dev *z) | |
434 | { | |
435 | struct net_device *dev = zorro_get_drvdata(z); | |
436 | ||
437 | unregister_netdev(dev); | |
438 | free_irq(IRQ_AMIGA_PORTS, dev); | |
439 | release_mem_region(ZTWO_PADDR(dev->base_addr), NE_IO_EXTENT*2); | |
440 | free_netdev(dev); | |
441 | } | |
442 | ||
443 | static int __init zorro8390_init_module(void) | |
444 | { | |
33d8675e | 445 | return zorro_register_driver(&zorro8390_driver); |
1da177e4 LT |
446 | } |
447 | ||
448 | static void __exit zorro8390_cleanup_module(void) | |
449 | { | |
450 | zorro_unregister_driver(&zorro8390_driver); | |
451 | } | |
452 | ||
453 | module_init(zorro8390_init_module); | |
454 | module_exit(zorro8390_cleanup_module); | |
455 | ||
456 | MODULE_LICENSE("GPL"); |