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