?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ok. I didn't make 2.4.0 in 2000. Tough. I tried, but we had some
[davej-history.git] / drivers / net / pcmcia / pcnet_cs.c
blob21ced0318a515b3795b9da27b3e57d329697a725
1 /*======================================================================
2
3 A PCMCIA ethernet driver for NS8390-based cards
4
5 This driver supports the D-Link DE-650 and Linksys EthernetCard
6 cards, the newer D-Link and Linksys combo cards, Accton EN2212
7 cards, the RPTI EP400, and the PreMax PE-200 in non-shared-memory
8 mode, and the IBM Credit Card Adapter, the NE4100, the Thomas
9 Conrad ethernet card, and the Kingston KNE-PCM/x in shared-memory
10 mode. It will also handle the Socket EA card in either mode.
11
12 Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
13
14 pcnet_cs.c 1.126 2000/10/02 20:38:23
15
16 The network driver code is based on Donald Becker's NE2000 code:
17
18 Written 1992,1993 by Donald Becker.
19 Copyright 1993 United States Government as represented by the
20 Director, National Security Agency. This software may be used and
21 distributed according to the terms of the GNU Public License,
22 incorporated herein by reference.
23 Donald Becker may be reached at becker@cesdis1.gsfc.nasa.gov
24
25 Based also on Keith Moore's changes to Don Becker's code, for IBM
26 CCAE support. Drivers merged back together, and shared-memory
27 Socket EA support added, by Ken Raeburn, September 1995.
28
29 ======================================================================*/
30
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/init.h>
34 #include <linux/sched.h>
35 #include <linux/ptrace.h>
36 #include <linux/malloc.h>
37 #include <linux/string.h>
38 #include <linux/timer.h>
39 #include <linux/delay.h>
40 #include <asm/io.h>
41 #include <asm/system.h>
42
43 #include <linux/netdevice.h>
44 #include <../drivers/net/8390.h>
45
46 #include <pcmcia/version.h>
47 #include <pcmcia/cs_types.h>
48 #include <pcmcia/cs.h>
49 #include <pcmcia/cistpl.h>
50 #include <pcmcia/ciscode.h>
51 #include <pcmcia/ds.h>
52 #include <pcmcia/cisreg.h>
53
54 #define PCNET_CMD 0x00
55 #define PCNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */
56 #define PCNET_RESET 0x1f /* Issue a read to reset, a write to clear. */
57 #define PCNET_MISC 0x18 /* For IBM CCAE and Socket EA cards */
58
59 #define PCNET_START_PG 0x40 /* First page of TX buffer */
60 #define PCNET_STOP_PG 0x80 /* Last page +1 of RX ring */
61
62 /* Socket EA cards have a larger packet buffer */
63 #define SOCKET_START_PG 0x01
64 #define SOCKET_STOP_PG 0xff
65
66 #define PCNET_RDC_TIMEOUT 0x02 /* Max wait in jiffies for Tx RDC */
67
68 static char *if_names[] = { "auto", "10baseT", "10base2"};
69
70 #ifdef PCMCIA_DEBUG
71 static int pc_debug = PCMCIA_DEBUG;
72 MODULE_PARM(pc_debug, "i");
73 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
74 static char *version =
75 "pcnet_cs.c 1.126 2000/10/02 20:38:23 (David Hinds)";
76 #else
77 #define DEBUG(n, args...)
78 #endif
79
80 /*====================================================================*/
81
82 /* Parameters that can be set with 'insmod' */
83
84 #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
85
86 /* Bit map of interrupts to choose from */
87 INT_MODULE_PARM(irq_mask, 0xdeb8);
88 static int irq_list[4] = { -1 };
89 MODULE_PARM(irq_list, "1-4i");
90
91 INT_MODULE_PARM(if_port, 1); /* Transceiver type */
92 INT_MODULE_PARM(use_big_buf, 1); /* use 64K packet buffer? */
93 INT_MODULE_PARM(mem_speed, 0); /* shared mem speed, in ns */
94 INT_MODULE_PARM(delay_output, 0); /* pause after xmit? */
95 INT_MODULE_PARM(delay_time, 4); /* in usec */
96 INT_MODULE_PARM(use_shmem, -1); /* use shared memory? */
97
98 /* Ugh! Let the user hardwire the hardware address for queer cards */
99 static int hw_addr[6] = { 0, /* ... */ };
100 MODULE_PARM(hw_addr, "6i");
101
102 /*====================================================================*/
103
104 static void pcnet_config(dev_link_t *link);
105 static void pcnet_release(u_long arg);
106 static int pcnet_event(event_t event, int priority,
107 event_callback_args_t *args);
108 static int pcnet_open(struct net_device *dev);
109 static int pcnet_close(struct net_device *dev);
110 static int do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
111 static void ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs);
112 static void ei_watchdog(u_long arg);
113 static void pcnet_reset_8390(struct net_device *dev);
114 static int set_config(struct net_device *dev, struct ifmap *map);
115 static int setup_shmem_window(dev_link_t *link, int start_pg,
116 int stop_pg, int cm_offset);
117 static int setup_dma_config(dev_link_t *link, int start_pg,
118 int stop_pg);
119
120 static dev_link_t *pcnet_attach(void);
121 static void pcnet_detach(dev_link_t *);
122
123 static dev_info_t dev_info = "pcnet_cs";
124 static dev_link_t *dev_list;
125
126 /*====================================================================*/
127
128 typedef struct hw_info_t {
129 u_int offset;
130 u_char a0, a1, a2;
131 u_int flags;
132 } hw_info_t;
133
134 #define DELAY_OUTPUT 0x01
135 #define HAS_MISC_REG 0x02
136 #define USE_BIG_BUF 0x04
137 #define HAS_IBM_MISC 0x08
138 #define IS_DL10019 0x10
139 #define IS_DL10022 0x20
140 #define IS_AX88190 0x40
141 #define USE_SHMEM 0x80 /* autodetected */
142
143 static hw_info_t hw_info[] = {
144 { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT },
145 { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
146 { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
147 { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94,
148 DELAY_OUTPUT | HAS_IBM_MISC },
149 { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 },
150 { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 },
151 { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 },
152 { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 },
153 { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 },
154 { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 },
155 { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48,
156 HAS_MISC_REG | HAS_IBM_MISC },
157 { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 },
158 { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 },
159 { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a,
160 HAS_MISC_REG | HAS_IBM_MISC },
161 { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac,
162 HAS_MISC_REG | HAS_IBM_MISC },
163 { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29,
164 HAS_MISC_REG | HAS_IBM_MISC },
165 { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a,
166 HAS_MISC_REG | HAS_IBM_MISC },
167 { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac,
168 HAS_MISC_REG | HAS_IBM_MISC },
169 { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87,
170 HAS_MISC_REG | HAS_IBM_MISC },
171 { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17,
172 HAS_MISC_REG | HAS_IBM_MISC },
173 { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8,
174 HAS_MISC_REG | HAS_IBM_MISC },
175 { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0,
176 HAS_MISC_REG | HAS_IBM_MISC },
177 { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0,
178 HAS_MISC_REG | HAS_IBM_MISC },
179 { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 },
180 { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 },
181 { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0,
182 HAS_MISC_REG | HAS_IBM_MISC },
183 { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f,
184 HAS_MISC_REG | HAS_IBM_MISC },
185 { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 },
186 { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 },
187 { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 },
188 { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 },
189 { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65,
190 HAS_MISC_REG | HAS_IBM_MISC },
191 { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45,
192 HAS_MISC_REG | HAS_IBM_MISC },
193 { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 },
194 { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 },
195 { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 },
196 { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b,
197 DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF },
198 { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 },
199 { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 },
200 { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 },
201 { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 }
202 };
203
204 #define NR_INFO (sizeof(hw_info)/sizeof(hw_info_t))
205
206 static hw_info_t default_info = { 0, 0, 0, 0, 0 };
207 static hw_info_t dl10019_info = { 0, 0, 0, 0, IS_DL10019 };
208 static hw_info_t dl10022_info = { 0, 0, 0, 0, IS_DL10019|IS_DL10022 };
209
210 typedef struct pcnet_dev_t {
211 struct net_device dev; /* so &dev == &pcnet_dev_t */
212 dev_link_t link;
213 dev_node_t node;
214 u_int flags;
215 caddr_t base;
216 struct timer_list watchdog;
217 int stale, fast_poll;
218 u_short link_status;
219 } pcnet_dev_t;
220
221 /*======================================================================
222
223 This bit of code is used to avoid unregistering network devices
224 at inappropriate times. 2.2 and later kernels are fairly picky
225 about when this can happen.
226
227 ======================================================================*/
228
229 static void flush_stale_links(void)
230 {
231 dev_link_t *link, *next;
232 for (link = dev_list; link; link = next) {
233 next = link->next;
234 if (link->state & DEV_STALE_LINK)
235 pcnet_detach(link);
236 }
237 }
238
239 /*====================================================================*/
240
241 static void cs_error(client_handle_t handle, int func, int ret)
242 {
243 error_info_t err = { func, ret };
244 CardServices(ReportError, handle, &err);
245 }
246
247 /*======================================================================
248
249 We never need to do anything when a pcnet device is "initialized"
250 by the net software, because we only register already-found cards.
251
252 ======================================================================*/
253
254 static int pcnet_init(struct net_device *dev)
255 {
256 return 0;
257 }
258
259 /*======================================================================
260
261 pcnet_attach() creates an "instance" of the driver, allocating
262 local data structures for one device. The device is registered
263 with Card Services.
264
265 ======================================================================*/
266
267 static dev_link_t *pcnet_attach(void)
268 {
269 pcnet_dev_t *info;
270 dev_link_t *link;
271 struct net_device *dev;
272 client_reg_t client_reg;
273 int i, ret;
274
275 DEBUG(0, "pcnet_attach()\n");
276 flush_stale_links();
277
278 /* Create new ethernet device */
279 info = kmalloc(sizeof(*info), GFP_KERNEL);
280 if (!info) return NULL;
281 memset(info, 0, sizeof(*info));
282 link = &info->link; dev = &info->dev;
283 link->priv = info;
284
285 link->release.function = &pcnet_release;
286 link->release.data = (u_long)link;
287 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
288 link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
289 if (irq_list[0] == -1)
290 link->irq.IRQInfo2 = irq_mask;
291 else
292 for (i = 0; i < 4; i++)
293 link->irq.IRQInfo2 |= 1 << irq_list[i];
294 link->conf.Attributes = CONF_ENABLE_IRQ;
295 link->conf.IntType = INT_MEMORY_AND_IO;
296
297 ethdev_init(dev);
298 dev->init = &pcnet_init;
299 dev->open = &pcnet_open;
300 dev->stop = &pcnet_close;
301 dev->set_config = &set_config;
302
303 /* Register with Card Services */
304 link->next = dev_list;
305 dev_list = link;
306 client_reg.dev_info = &dev_info;
307 client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
308 client_reg.EventMask =
309 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
310 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
311 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
312 client_reg.event_handler = &pcnet_event;
313 client_reg.Version = 0x0210;
314 client_reg.event_callback_args.client_data = link;
315 ret = CardServices(RegisterClient, &link->handle, &client_reg);
316 if (ret != CS_SUCCESS) {
317 cs_error(link->handle, RegisterClient, ret);
318 pcnet_detach(link);
319 return NULL;
320 }
321
322 return link;
323 } /* pcnet_attach */
324
325 /*======================================================================
326
327 This deletes a driver "instance". The device is de-registered
328 with Card Services. If it has been released, all local data
329 structures are freed. Otherwise, the structures will be freed
330 when the device is released.
331
332 ======================================================================*/
333
334 static void pcnet_detach(dev_link_t *link)
335 {
336 pcnet_dev_t *info = link->priv;
337 dev_link_t **linkp;
338
339 DEBUG(0, "pcnet_detach(0x%p)\n", link);
340
341 /* Locate device structure */
342 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
343 if (*linkp == link) break;
344 if (*linkp == NULL)
345 return;
346
347 del_timer(&link->release);
348 if (link->state & DEV_CONFIG) {
349 pcnet_release((u_long)link);
350 if (link->state & DEV_STALE_CONFIG) {
351 link->state |= DEV_STALE_LINK;
352 return;
353 }
354 }
355
356 if (link->handle)
357 CardServices(DeregisterClient, link->handle);
358
359 /* Unlink device structure, free bits */
360 *linkp = link->next;
361 if (link->dev)
362 unregister_netdev(&info->dev);
363 kfree(info);
364
365 } /* pcnet_detach */
366
367 /*======================================================================
368
369 This probes for a card's hardware address, for card types that
370 encode this information in their CIS.
371
372 ======================================================================*/
373
374 static hw_info_t *get_hwinfo(dev_link_t *link)
375 {
376 struct net_device *dev = link->priv;
377 win_req_t req;
378 memreq_t mem;
379 u_char *base, *virt;
380 int i, j;
381
382 /* Allocate a small memory window */
383 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
384 req.Base = 0; req.Size = 0;
385 req.AccessSpeed = 0;
386 link->win = (window_handle_t)link->handle;
387 i = CardServices(RequestWindow, &link->win, &req);
388 if (i != CS_SUCCESS) {
389 cs_error(link->handle, RequestWindow, i);
390 return NULL;
391 }
392
393 virt = ioremap(req.Base, req.Size);
394 mem.Page = 0;
395 for (i = 0; i < NR_INFO; i++) {
396 mem.CardOffset = hw_info[i].offset & ~(req.Size-1);
397 CardServices(MapMemPage, link->win, &mem);
398 base = &virt[hw_info[i].offset & (req.Size-1)];
399 if ((readb(base+0) == hw_info[i].a0) &&
400 (readb(base+2) == hw_info[i].a1) &&
401 (readb(base+4) == hw_info[i].a2))
402 break;
403 }
404 if (i < NR_INFO) {
405 for (j = 0; j < 6; j++)
406 dev->dev_addr[j] = readb(base + (j<<1));
407 }
408
409 iounmap(virt);
410 j = CardServices(ReleaseWindow, link->win);
411 if (j != CS_SUCCESS)
412 cs_error(link->handle, ReleaseWindow, j);
413 return (i < NR_INFO) ? hw_info+i : NULL;
414 } /* get_hwinfo */
415
416 /*======================================================================
417
418 This probes for a card's hardware address by reading the PROM.
419 It checks the address against a list of known types, then falls
420 back to a simple NE2000 clone signature check.
421
422 ======================================================================*/
423
424 static hw_info_t *get_prom(dev_link_t *link)
425 {
426 struct net_device *dev = link->priv;
427 ioaddr_t ioaddr = dev->base_addr;
428 u_char prom[32];
429 int i, j;
430
431 /* This is lifted straight from drivers/net/ne.c */
432 struct {
433 u_char value, offset;
434 } program_seq[] = {
435 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
436 {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
437 {0x00, EN0_RCNTLO}, /* Clear the count regs. */
438 {0x00, EN0_RCNTHI},
439 {0x00, EN0_IMR}, /* Mask completion irq. */
440 {0xFF, EN0_ISR},
441 {E8390_RXOFF, EN0_RXCR}, /* 0x20 Set to monitor */
442 {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */
443 {32, EN0_RCNTLO},
444 {0x00, EN0_RCNTHI},
445 {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
446 {0x00, EN0_RSARHI},
447 {E8390_RREAD+E8390_START, E8390_CMD},
448 };
449
450 pcnet_reset_8390(dev);
451 mdelay(10);
452
453 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
454 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
455
456 for (i = 0; i < 32; i++)
457 prom[i] = inb(ioaddr + PCNET_DATAPORT);
458 for (i = 0; i < NR_INFO; i++) {
459 if ((prom[0] == hw_info[i].a0) &&
460 (prom[2] == hw_info[i].a1) &&
461 (prom[4] == hw_info[i].a2))
462 break;
463 }
464 if ((i < NR_INFO) || ((prom[28] == 0x57) && (prom[30] == 0x57))) {
465 for (j = 0; j < 6; j++)
466 dev->dev_addr[j] = prom[j<<1];
467 return (i < NR_INFO) ? hw_info+i : &default_info;
468 }
469 return NULL;
470 } /* get_prom */
471
472 /*======================================================================
473
474 For DL10019 based cards, like the Linksys EtherFast
475
476 ======================================================================*/
477
478 static hw_info_t *get_dl10019(dev_link_t *link)
479 {
480 struct net_device *dev = link->priv;
481 int i;
482 u_char sum;
483
484 for (sum = 0, i = 0x14; i < 0x1c; i++)
485 sum += inb_p(dev->base_addr + i);
486 if (sum != 0xff)
487 return NULL;
488 for (i = 0; i < 6; i++)
489 dev->dev_addr[i] = inb_p(dev->base_addr + 0x14 + i);
490 i = inb(dev->base_addr + 0x1f);
491 return ((i == 0x91)||(i == 0x99)) ? &dl10022_info : &dl10019_info;
492 }
493
494 /*======================================================================
495
496 For Asix AX88190 based cards
497
498 ======================================================================*/
499
500 static hw_info_t *get_ax88190(dev_link_t *link)
501 {
502 struct net_device *dev = link->priv;
503 ioaddr_t ioaddr = dev->base_addr;
504 int i, j;
505
506 /* Not much of a test, but the alternatives are messy */
507 if (link->conf.ConfigBase != 0x03c0)
508 return NULL;
509
510 outb_p(0x01, EN0_DCFG); /* Set word-wide access. */
511 outb_p(0x00, EN0_RSARLO); /* DMA starting at 0x0400. */
512 outb_p(0x04, EN0_RSARHI);
513 outb_p(E8390_RREAD+E8390_START, E8390_CMD);
514
515 for (i = 0; i < 6; i += 2) {
516 j = inw(ioaddr + PCNET_DATAPORT);
517 dev->dev_addr[i] = j & 0xff;
518 dev->dev_addr[i+1] = j >> 8;
519 }
520 printk(KERN_INFO "pcnet_cs: sorry, the AX88190 chipset is not "
521 "supported.\n");
522 return NULL;
523 }
524
525 /*======================================================================
526
527 This should be totally unnecessary... but when we can't figure
528 out the hardware address any other way, we'll let the user hard
529 wire it when the module is initialized.
530
531 ======================================================================*/
532
533 static hw_info_t *get_hwired(dev_link_t *link)
534 {
535 struct net_device *dev = link->priv;
536 int i;
537
538 for (i = 0; i < 6; i++)
539 if (hw_addr[i] != 0) break;
540 if (i == 6)
541 return NULL;
542
543 for (i = 0; i < 6; i++)
544 dev->dev_addr[i] = hw_addr[i];
545
546 return &default_info;
547 } /* get_hwired */
548
549 /*======================================================================
550
551 pcnet_config() is scheduled to run after a CARD_INSERTION event
552 is received, to configure the PCMCIA socket, and to make the
553 ethernet device available to the system.
554
555 ======================================================================*/
556
557 #define CS_CHECK(fn, args...) \
558 while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed
559
560 #define CFG_CHECK(fn, args...) \
561 if (CardServices(fn, args) != 0) goto next_entry
562
563 static int try_io_port(dev_link_t *link)
564 {
565 int j, ret;
566 if (link->io.NumPorts1 == 32) {
567 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
568 if (link->io.NumPorts2 > 0) {
569 /* for master/slave multifunction cards */
570 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
571 link->irq.Attributes =
572 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
573 }
574 } else {
575 /* This should be two 16-port windows */
576 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
577 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
578 }
579 if (link->io.BasePort1 == 0) {
580 link->io.IOAddrLines = 16;
581 for (j = 0; j < 0x400; j += 0x20) {
582 link->io.BasePort1 = j ^ 0x300;
583 link->io.BasePort2 = (j ^ 0x300) + 0x10;
584 ret = CardServices(RequestIO, link->handle, &link->io);
585 if (ret == CS_SUCCESS) return ret;
586 }
587 return ret;
588 } else {
589 return CardServices(RequestIO, link->handle, &link->io);
590 }
591 }
592
593 static void pcnet_config(dev_link_t *link)
594 {
595 client_handle_t handle = link->handle;
596 pcnet_dev_t *info = link->priv;
597 struct net_device *dev = &info->dev;
598 tuple_t tuple;
599 cisparse_t parse;
600 int i, last_ret, last_fn, start_pg, stop_pg, cm_offset;
601 int manfid = 0, prodid = 0, has_shmem = 0;
602 u_short buf[64];
603 config_info_t conf;
604 hw_info_t *hw_info;
605
606 DEBUG(0, "pcnet_config(0x%p)\n", link);
607
608 tuple.Attributes = 0;
609 tuple.TupleData = (cisdata_t *)buf;
610 tuple.TupleDataMax = sizeof(buf);
611 tuple.TupleOffset = 0;
612 tuple.DesiredTuple = CISTPL_CONFIG;
613 CS_CHECK(GetFirstTuple, handle, &tuple);
614 CS_CHECK(GetTupleData, handle, &tuple);
615 CS_CHECK(ParseTuple, handle, &tuple, &parse);
616 link->conf.ConfigBase = parse.config.base;
617 link->conf.Present = parse.config.rmask[0];
618
619 /* Configure card */
620 link->state |= DEV_CONFIG;
621
622 /* Look up current Vcc */
623 CS_CHECK(GetConfigurationInfo, handle, &conf);
624 link->conf.Vcc = conf.Vcc;
625
626 tuple.DesiredTuple = CISTPL_MANFID;
627 tuple.Attributes = TUPLE_RETURN_COMMON;
628 if ((CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS) &&
629 (CardServices(GetTupleData, handle, &tuple) == CS_SUCCESS)) {
630 manfid = le16_to_cpu(buf[0]);
631 prodid = le16_to_cpu(buf[1]);
632 }
633
634 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
635 tuple.Attributes = 0;
636 CS_CHECK(GetFirstTuple, handle, &tuple);
637 while (last_ret == CS_SUCCESS) {
638 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
639 cistpl_io_t *io = &(parse.cftable_entry.io);
640
641 CFG_CHECK(GetTupleData, handle, &tuple);
642 CFG_CHECK(ParseTuple, handle, &tuple, &parse);
643 if ((cfg->index == 0) || (cfg->io.nwin == 0))
644 goto next_entry;
645
646 link->conf.ConfigIndex = cfg->index;
647 /* For multifunction cards, by convention, we configure the
648 network function with window 0, and serial with window 1 */
649 if (io->nwin > 1) {
650 i = (io->win[1].len > io->win[0].len);
651 link->io.BasePort2 = io->win[1-i].base;
652 link->io.NumPorts2 = io->win[1-i].len;
653 } else {
654 i = link->io.NumPorts2 = 0;
655 }
656 has_shmem = ((cfg->mem.nwin == 1) &&
657 (cfg->mem.win[0].len >= 0x4000));
658 link->io.BasePort1 = io->win[i].base;
659 link->io.NumPorts1 = io->win[i].len;
660 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
661 if (link->io.NumPorts1 + link->io.NumPorts2 >= 32) {
662 last_ret = try_io_port(link);
663 if (last_ret == CS_SUCCESS) break;
664 }
665 next_entry:
666 last_ret = CardServices(GetNextTuple, handle, &tuple);
667 }
668 if (last_ret != CS_SUCCESS) {
669 cs_error(handle, RequestIO, last_ret);
670 goto failed;
671 }
672
673 CS_CHECK(RequestIRQ, handle, &link->irq);
674
675 if (link->io.NumPorts2 == 8) {
676 link->conf.Attributes |= CONF_ENABLE_SPKR;
677 link->conf.Status = CCSR_AUDIO_ENA;
678 }
679 if ((manfid == MANFID_IBM) &&
680 (prodid == PRODID_IBM_HOME_AND_AWAY))
681 link->conf.ConfigIndex |= 0x10;
682
683 CS_CHECK(RequestConfiguration, handle, &link->conf);
684 dev->irq = link->irq.AssignedIRQ;
685 dev->base_addr = link->io.BasePort1;
686 if (info->flags & HAS_MISC_REG) {
687 if ((if_port == 1) || (if_port == 2))
688 dev->if_port = if_port;
689 else
690 printk(KERN_NOTICE "pcnet_cs: invalid if_port requested\n");
691 } else {
692 dev->if_port = 0;
693 }
694 if (register_netdev(dev) != 0) {
695 printk(KERN_NOTICE "pcnet_cs: register_netdev() failed\n");
696 goto failed;
697 }
698
699 hw_info = get_hwinfo(link);
700 if (hw_info == NULL)
701 hw_info = get_prom(link);
702 if (hw_info == NULL)
703 hw_info = get_dl10019(link);
704 if (hw_info == NULL)
705 hw_info = get_ax88190(link);
706 if (hw_info == NULL)
707 hw_info = get_hwired(link);
708
709 if (hw_info == NULL) {
710 printk(KERN_NOTICE "pcnet_cs: unable to read hardware net"
711 " address for io base %#3lx\n", dev->base_addr);
712 unregister_netdev(dev);
713 goto failed;
714 }
715
716 info->flags = hw_info->flags;
717 /* Check for user overrides */
718 info->flags |= (delay_output) ? DELAY_OUTPUT : 0;
719 if ((manfid == MANFID_SOCKET) &&
720 ((prodid == PRODID_SOCKET_LPE) ||
721 (prodid == PRODID_SOCKET_EIO)))
722 info->flags &= ~USE_BIG_BUF;
723 if (!use_big_buf)
724 info->flags &= ~USE_BIG_BUF;
725
726 if (info->flags & USE_BIG_BUF) {
727 start_pg = SOCKET_START_PG;
728 stop_pg = SOCKET_STOP_PG;
729 cm_offset = 0x10000;
730 } else {
731 start_pg = PCNET_START_PG;
732 stop_pg = PCNET_STOP_PG;
733 cm_offset = 0;
734 }
735
736 /* has_shmem is ignored if use_shmem != -1 */
737 if ((use_shmem == 0) || (!has_shmem && (use_shmem == -1)) ||
738 (setup_shmem_window(link, start_pg, stop_pg, cm_offset) != 0))
739 setup_dma_config(link, start_pg, stop_pg);
740
741 ei_status.name = "NE2000";
742 ei_status.word16 = 1;
743 ei_status.reset_8390 = &pcnet_reset_8390;
744
745 strcpy(info->node.dev_name, dev->name);
746 link->dev = &info->node;
747 link->state &= ~DEV_CONFIG_PENDING;
748
749 if (info->flags & IS_DL10019) {
750 dev->do_ioctl = &do_ioctl;
751 printk(KERN_INFO "%s: NE2000 (DL100%d rev %02x): ",
752 dev->name, ((info->flags & IS_DL10022) ? 22 : 19),
753 inb(dev->base_addr + 0x1a));
754 } else if (info->flags & IS_AX88190) {
755 printk(KERN_INFO "%s: NE2000 (AX88190): ", dev->name);
756 } else
757 printk(KERN_INFO "%s: NE2000 Compatible: ", dev->name);
758 printk("io %#3lx, irq %d,", dev->base_addr, dev->irq);
759 if (info->flags & USE_SHMEM)
760 printk (" mem %#5lx,", dev->mem_start);
761 if (info->flags & HAS_MISC_REG)
762 printk(" %s xcvr,", if_names[dev->if_port]);
763 printk(" hw_addr ");
764 for (i = 0; i < 6; i++)
765 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
766 return;
767
768 cs_failed:
769 cs_error(link->handle, last_fn, last_ret);
770 failed:
771 pcnet_release((u_long)link);
772 return;
773 } /* pcnet_config */
774
775 /*======================================================================
776
777 After a card is removed, pcnet_release() will unregister the net
778 device, and release the PCMCIA configuration. If the device is
779 still open, this will be postponed until it is closed.
780
781 ======================================================================*/
782
783 static void pcnet_release(u_long arg)
784 {
785 dev_link_t *link = (dev_link_t *)arg;
786 pcnet_dev_t *info = link->priv;
787
788 DEBUG(0, "pcnet_release(0x%p)\n", link);
789
790 if (link->open) {
791 DEBUG(1, "pcnet_cs: release postponed, '%s' still open\n",
792 info->node.dev_name);
793 link->state |= DEV_STALE_CONFIG;
794 return;
795 }
796
797 if (info->flags & USE_SHMEM) {
798 iounmap(info->base);
799 CardServices(ReleaseWindow, link->win);
800 }
801 CardServices(ReleaseConfiguration, link->handle);
802 CardServices(ReleaseIO, link->handle, &link->io);
803 CardServices(ReleaseIRQ, link->handle, &link->irq);
804
805 link->state &= ~DEV_CONFIG;
806
807 } /* pcnet_release */
808
809 /*======================================================================
810
811 The card status event handler. Mostly, this schedules other
812 stuff to run after an event is received. A CARD_REMOVAL event
813 also sets some flags to discourage the net drivers from trying
814 to talk to the card any more.
815
816 ======================================================================*/
817
818 static int pcnet_event(event_t event, int priority,
819 event_callback_args_t *args)
820 {
821 dev_link_t *link = args->client_data;
822 pcnet_dev_t *info = link->priv;
823
824 DEBUG(2, "pcnet_event(0x%06x)\n", event);
825
826 switch (event) {
827 case CS_EVENT_CARD_REMOVAL:
828 link->state &= ~DEV_PRESENT;
829 if (link->state & DEV_CONFIG) {
830 netif_device_detach(&info->dev);
831 mod_timer(&link->release, jiffies + HZ/20);
832 }
833 break;
834 case CS_EVENT_CARD_INSERTION:
835 link->state |= DEV_PRESENT;
836 pcnet_config(link);
837 break;
838 case CS_EVENT_PM_SUSPEND:
839 link->state |= DEV_SUSPEND;
840 /* Fall through... */
841 case CS_EVENT_RESET_PHYSICAL:
842 if (link->state & DEV_CONFIG) {
843 if (link->open)
844 netif_device_detach(&info->dev);
845 CardServices(ReleaseConfiguration, link->handle);
846 }
847 break;
848 case CS_EVENT_PM_RESUME:
849 link->state &= ~DEV_SUSPEND;
850 /* Fall through... */
851 case CS_EVENT_CARD_RESET:
852 if (link->state & DEV_CONFIG) {
853 CardServices(RequestConfiguration, link->handle, &link->conf);
854 if (link->open) {
855 pcnet_reset_8390(&info->dev);
856 NS8390_init(&info->dev, 1);
857 netif_device_attach(&info->dev);
858 }
859 }
860 break;
861 }
862 return 0;
863 } /* pcnet_event */
864
865 /*======================================================================
866
867 MII interface support for DL10019 and DL10022 based cards
868
869 On the DL10019, the MII IO direction bit is 0x10; on the DL10022
870 it is 0x20. Setting both bits seems to work on both card types.
871
872 ======================================================================*/
873
874 #define DLINK_GPIO 0x1c
875 #define DLINK_DIAG 0x1d
876 #define MDIO_SHIFT_CLK 0x80
877 #define MDIO_DATA_OUT 0x40
878 #define MDIO_DIR_WRITE 0x30
879 #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
880 #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
881 #define MDIO_DATA_READ 0x10
882 #define MDIO_MASK 0x0f
883
884 static void mdio_sync(ioaddr_t addr)
885 {
886 int bits, mask = inb(addr) & MDIO_MASK;
887 for (bits = 0; bits < 32; bits++) {
888 outb(mask | MDIO_DATA_WRITE1, addr);
889 outb(mask | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
890 }
891 }
892
893 static int mdio_read(ioaddr_t addr, int phy_id, int loc)
894 {
895 u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
896 int i, retval = 0, mask = inb(addr) & MDIO_MASK;
897
898 mdio_sync(addr);
899 for (i = 13; i >= 0; i--) {
900 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
901 outb(mask | dat, addr);
902 outb(mask | dat | MDIO_SHIFT_CLK, addr);
903 }
904 for (i = 19; i > 0; i--) {
905 outb(mask, addr);
906 retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
907 outb(mask | MDIO_SHIFT_CLK, addr);
908 }
909 return (retval>>1) & 0xffff;
910 }
911
912 static void mdio_write(ioaddr_t addr, int phy_id, int loc, int value)
913 {
914 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
915 int i, mask = inb(addr) & MDIO_MASK;
916
917 mdio_sync(addr);
918 for (i = 31; i >= 0; i--) {
919 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
920 outb(mask | dat, addr);
921 outb(mask | dat | MDIO_SHIFT_CLK, addr);
922 }
923 for (i = 1; i >= 0; i--) {
924 outb(mask, addr);
925 outb(mask | MDIO_SHIFT_CLK, addr);
926 }
927 }
928
929 static void mdio_reset(ioaddr_t addr, int phy_id)
930 {
931 outb_p(0x08, addr);
932 outb_p(0x0c, addr);
933 outb_p(0x08, addr);
934 outb_p(0x0c, addr);
935 outb_p(0x00, addr);
936 }
937
938 /*====================================================================*/
939
940 static void set_misc_reg(struct net_device *dev)
941 {
942 ioaddr_t nic_base = dev->base_addr;
943 pcnet_dev_t *info = (pcnet_dev_t *)dev;
944 u_char tmp;
945
946 if (info->flags & HAS_MISC_REG) {
947 tmp = inb_p(nic_base + PCNET_MISC) & ~3;
948 if (dev->if_port == 2)
949 tmp |= 1;
950 if (info->flags & USE_BIG_BUF)
951 tmp |= 2;
952 if (info->flags & HAS_IBM_MISC)
953 tmp |= 8;
954 outb_p(tmp, nic_base + PCNET_MISC);
955 }
956 if (info->flags & IS_DL10022) {
957 mdio_reset(nic_base + DLINK_GPIO, 0);
958 /* Restart MII autonegotiation */
959 mdio_write(nic_base + DLINK_GPIO, 0, 0, 0x0000);
960 mdio_write(nic_base + DLINK_GPIO, 0, 0, 0x1200);
961 }
962 }
963
964 /*====================================================================*/
965
966 static int pcnet_open(struct net_device *dev)
967 {
968 pcnet_dev_t *info = (pcnet_dev_t *)dev;
969 dev_link_t *link = &info->link;
970
971 DEBUG(2, "pcnet_open('%s')\n", dev->name);
972
973 if (!DEV_OK(link))
974 return -ENODEV;
975
976 link->open++;
977 MOD_INC_USE_COUNT;
978
979 set_misc_reg(dev);
980 request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev);
981
982 info->link_status = 0x00;
983 info->watchdog.function = &ei_watchdog;
984 info->watchdog.data = (u_long)info;
985 info->watchdog.expires = jiffies + HZ;
986 add_timer(&info->watchdog);
987
988 return ei_open(dev);
989 } /* pcnet_open */
990
991 /*====================================================================*/
992
993 static int pcnet_close(struct net_device *dev)
994 {
995 pcnet_dev_t *info = (pcnet_dev_t *)dev;
996 dev_link_t *link = &info->link;
997
998 DEBUG(2, "pcnet_close('%s')\n", dev->name);
999
1000 free_irq(dev->irq, dev);
1001
1002 link->open--;
1003 netif_stop_queue(dev);
1004 del_timer(&info->watchdog);
1005 if (link->state & DEV_STALE_CONFIG)
1006 mod_timer(&link->release, jiffies + HZ/20);
1007
1008 MOD_DEC_USE_COUNT;
1009
1010 return 0;
1011 } /* pcnet_close */
1012
1013 /*======================================================================
1014
1015 Hard reset the card. This used to pause for the same period that
1016 a 8390 reset command required, but that shouldn't be necessary.
1017
1018 ======================================================================*/
1019
1020 static void pcnet_reset_8390(struct net_device *dev)
1021 {
1022 ioaddr_t nic_base = dev->base_addr;
1023 int i;
1024
1025 ei_status.txing = ei_status.dmaing = 0;
1026
1027 outb(inb(nic_base + PCNET_RESET), nic_base + PCNET_RESET);
1028
1029 for (i = 0; i < 100; i++) {
1030 if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
1031 break;
1032 udelay(100);
1033 }
1034 outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
1035
1036 if (i == 100)
1037 printk(KERN_ERR "%s: pcnet_reset_8390() did not complete.\n",
1038 dev->name);
1039 set_misc_reg(dev);
1040
1041 } /* pcnet_reset_8390 */
1042
1043 /*====================================================================*/
1044
1045 static int set_config(struct net_device *dev, struct ifmap *map)
1046 {
1047 pcnet_dev_t *info = (pcnet_dev_t *)dev;
1048 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1049 if (!(info->flags & HAS_MISC_REG))
1050 return -EOPNOTSUPP;
1051 else if ((map->port < 1) || (map->port > 2))
1052 return -EINVAL;
1053 dev->if_port = map->port;
1054 printk(KERN_INFO "%s: switched to %s port\n",
1055 dev->name, if_names[dev->if_port]);
1056 NS8390_init(dev, 1);
1057 }
1058 return 0;
1059 }
1060
1061 /*====================================================================*/
1062
1063 static void ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs)
1064 {
1065 pcnet_dev_t *info = dev_id;
1066 info->stale = 0;
1067 ei_interrupt(irq, dev_id, regs);
1068 }
1069
1070 static void ei_watchdog(u_long arg)
1071 {
1072 pcnet_dev_t *info = (pcnet_dev_t *)(arg);
1073 struct net_device *dev = &info->dev;
1074 ioaddr_t nic_base = dev->base_addr;
1075 u_short link;
1076
1077 if (!netif_device_present(dev)) goto reschedule;
1078
1079 /* Check for pending interrupt with expired latency timer: with
1080 this, we can limp along even if the interrupt is blocked */
1081 outb_p(E8390_NODMA+E8390_PAGE0, nic_base + E8390_CMD);
1082 if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
1083 if (!info->fast_poll)
1084 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1085 ei_irq_wrapper(dev->irq, dev, NULL);
1086 info->fast_poll = HZ;
1087 }
1088 if (info->fast_poll) {
1089 info->fast_poll--;
1090 info->watchdog.expires = jiffies + 1;
1091 add_timer(&info->watchdog);
1092 return;
1093 }
1094
1095 if (!(info->flags & IS_DL10019))
1096 goto reschedule;
1097
1098 link = mdio_read(dev->base_addr + DLINK_GPIO, 0, 1) & 0x0004;
1099 if (link != info->link_status) {
1100 u_short p = mdio_read(dev->base_addr + DLINK_GPIO, 0, 5);
1101 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1102 (link) ? "found" : "lost");
1103 if (link && (info->flags & IS_DL10022)) {
1104 /* Disable collision detection on full duplex links */
1105 outb((p & 0x0140) ? 4 : 0, dev->base_addr + DLINK_DIAG);
1106 }
1107 if (link) {
1108 if (p)
1109 printk(KERN_INFO "%s: autonegotiation complete: "
1110 "%sbaseT-%cD selected\n", dev->name,
1111 ((p & 0x0180) ? "100" : "10"),
1112 ((p & 0x0140) ? 'F' : 'H'));
1113 else
1114 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
1115 dev->name);
1116 NS8390_init(dev, 1);
1117 }
1118 info->link_status = link;
1119 }
1120
1121 reschedule:
1122 info->watchdog.expires = jiffies + HZ;
1123 add_timer(&info->watchdog);
1124 }
1125
1126 /*====================================================================*/
1127
1128 static int do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1129 {
1130 u16 *data = (u16 *)&rq->ifr_data;
1131 ioaddr_t addr = dev->base_addr + DLINK_GPIO;
1132 switch (cmd) {
1133 case SIOCDEVPRIVATE:
1134 data[0] = 0;
1135 case SIOCDEVPRIVATE+1:
1136 data[3] = mdio_read(addr, data[0], data[1] & 0x1f);
1137 return 0;
1138 case SIOCDEVPRIVATE+2:
1139 if (!capable(CAP_NET_ADMIN))
1140 return -EPERM;
1141 mdio_write(addr, data[0], data[1] & 0x1f, data[2]);
1142 return 0;
1143 }
1144 return -EOPNOTSUPP;
1145 }
1146
1147 /*====================================================================*/
1148
1149 static void dma_get_8390_hdr(struct net_device *dev,
1150 struct e8390_pkt_hdr *hdr,
1151 int ring_page)
1152 {
1153 ioaddr_t nic_base = dev->base_addr;
1154
1155 if (ei_status.dmaing) {
1156 printk(KERN_NOTICE "%s: DMAing conflict in dma_block_input."
1157 "[DMAstat:%1x][irqlock:%1x]\n",
1158 dev->name, ei_status.dmaing, ei_status.irqlock);
1159 return;
1160 }
1161
1162 ei_status.dmaing |= 0x01;
1163 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
1164 outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
1165 outb_p(0, nic_base + EN0_RCNTHI);
1166 outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
1167 outb_p(ring_page, nic_base + EN0_RSARHI);
1168 outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
1169
1170 insw(nic_base + PCNET_DATAPORT, hdr,
1171 sizeof(struct e8390_pkt_hdr)>>1);
1172 /* Fix for big endian systems */
1173 hdr->count = le16_to_cpu(hdr->count);
1174
1175 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
1176 ei_status.dmaing &= ~0x01;
1177 }
1178
1179 /*====================================================================*/
1180
1181 static void dma_block_input(struct net_device *dev, int count,
1182 struct sk_buff *skb, int ring_offset)
1183 {
1184 ioaddr_t nic_base = dev->base_addr;
1185 int xfer_count = count;
1186 char *buf = skb->data;
1187
1188 #ifdef PCMCIA_DEBUG
1189 if ((ei_debug > 4) && (count != 4))
1190 printk(KERN_DEBUG "%s: [bi=%d]\n", dev->name, count+4);
1191 #endif
1192 if (ei_status.dmaing) {
1193 printk(KERN_NOTICE "%s: DMAing conflict in dma_block_input."
1194 "[DMAstat:%1x][irqlock:%1x]\n",
1195 dev->name, ei_status.dmaing, ei_status.irqlock);
1196 return;
1197 }
1198 ei_status.dmaing |= 0x01;
1199 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
1200 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1201 outb_p(count >> 8, nic_base + EN0_RCNTHI);
1202 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
1203 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
1204 outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
1205
1206 insw(nic_base + PCNET_DATAPORT,buf,count>>1);
1207 if (count & 0x01)
1208 buf[count-1] = inb(nic_base + PCNET_DATAPORT), xfer_count++;
1209
1210 /* This was for the ALPHA version only, but enough people have
1211 encountering problems that it is still here. */
1212 #ifdef PCMCIA_DEBUG
1213 if (ei_debug > 4) { /* DMA termination address check... */
1214 int addr, tries = 20;
1215 do {
1216 /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
1217 -- it's broken for Rx on some cards! */
1218 int high = inb_p(nic_base + EN0_RSARHI);
1219 int low = inb_p(nic_base + EN0_RSARLO);
1220 addr = (high << 8) + low;
1221 if (((ring_offset + xfer_count) & 0xff) == (addr & 0xff))
1222 break;
1223 } while (--tries > 0);
1224 if (tries <= 0)
1225 printk(KERN_NOTICE "%s: RX transfer address mismatch,"
1226 "%#4.4x (expected) vs. %#4.4x (actual).\n",
1227 dev->name, ring_offset + xfer_count, addr);
1228 }
1229 #endif
1230 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
1231 ei_status.dmaing &= ~0x01;
1232 } /* dma_block_input */
1233
1234 /*====================================================================*/
1235
1236 static void dma_block_output(struct net_device *dev, int count,
1237 const u_char *buf, const int start_page)
1238 {
1239 ioaddr_t nic_base = dev->base_addr;
1240 pcnet_dev_t *info = (pcnet_dev_t *)dev;
1241 #ifdef PCMCIA_DEBUG
1242 int retries = 0;
1243 #endif
1244 u_long dma_start;
1245
1246 #ifdef PCMCIA_DEBUG
1247 if (ei_debug > 4)
1248 printk(KERN_DEBUG "%s: [bo=%d]\n", dev->name, count);
1249 #endif
1250
1251 /* Round the count up for word writes. Do we need to do this?
1252 What effect will an odd byte count have on the 8390?
1253 I should check someday. */
1254 if (count & 0x01)
1255 count++;
1256 if (ei_status.dmaing) {
1257 printk(KERN_NOTICE "%s: DMAing conflict in dma_block_output."
1258 "[DMAstat:%1x][irqlock:%1x]\n",
1259 dev->name, ei_status.dmaing, ei_status.irqlock);
1260 return;
1261 }
1262 ei_status.dmaing |= 0x01;
1263 /* We should already be in page 0, but to be safe... */
1264 outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base+PCNET_CMD);
1265
1266 #ifdef PCMCIA_DEBUG
1267 retry:
1268 #endif
1269
1270 outb_p(ENISR_RDC, nic_base + EN0_ISR);
1271
1272 /* Now the normal output. */
1273 outb_p(count & 0xff, nic_base + EN0_RCNTLO);
1274 outb_p(count >> 8, nic_base + EN0_RCNTHI);
1275 outb_p(0x00, nic_base + EN0_RSARLO);
1276 outb_p(start_page, nic_base + EN0_RSARHI);
1277
1278 outb_p(E8390_RWRITE+E8390_START, nic_base + PCNET_CMD);
1279 outsw(nic_base + PCNET_DATAPORT, buf, count>>1);
1280
1281 dma_start = jiffies;
1282
1283 #ifdef PCMCIA_DEBUG
1284 /* This was for the ALPHA version only, but enough people have
1285 encountering problems that it is still here. */
1286 if (ei_debug > 4) { /* DMA termination address check... */
1287 int addr, tries = 20;
1288 do {
1289 int high = inb_p(nic_base + EN0_RSARHI);
1290 int low = inb_p(nic_base + EN0_RSARLO);
1291 addr = (high << 8) + low;
1292 if ((start_page << 8) + count == addr)
1293 break;
1294 } while (--tries > 0);
1295 if (tries <= 0) {
1296 printk(KERN_NOTICE "%s: Tx packet transfer address mismatch,"
1297 "%#4.4x (expected) vs. %#4.4x (actual).\n",
1298 dev->name, (start_page << 8) + count, addr);
1299 if (retries++ == 0)
1300 goto retry;
1301 }
1302 }
1303 #endif
1304
1305 while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
1306 if (jiffies - dma_start > PCNET_RDC_TIMEOUT) {
1307 printk(KERN_NOTICE "%s: timeout waiting for Tx RDC.\n",
1308 dev->name);
1309 pcnet_reset_8390(dev);
1310 NS8390_init(dev, 1);
1311 break;
1312 }
1313
1314 outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
1315 if (info->flags & DELAY_OUTPUT)
1316 udelay((long)delay_time);
1317 ei_status.dmaing &= ~0x01;
1318 }
1319
1320 /*====================================================================*/
1321
1322 static int setup_dma_config(dev_link_t *link, int start_pg,
1323 int stop_pg)
1324 {
1325 struct net_device *dev = link->priv;
1326
1327 ei_status.tx_start_page = start_pg;
1328 ei_status.rx_start_page = start_pg + TX_PAGES;
1329 ei_status.stop_page = stop_pg;
1330
1331 /* set up block i/o functions */
1332 ei_status.get_8390_hdr = &dma_get_8390_hdr;
1333 ei_status.block_input = &dma_block_input;
1334 ei_status.block_output = &dma_block_output;
1335
1336 return 0;
1337 }
1338
1339 /*====================================================================*/
1340
1341 static void copyin(u_char *dest, u_char *src, int c)
1342 {
1343 u_short *d = (u_short *)dest, *s = (u_short *)src;
1344 int odd;
1345
1346 if (c <= 0)
1347 return;
1348 odd = (c & 1); c >>= 1;
1349
1350 if (c) {
1351 do { *d++ = __raw_readw(s++); } while (--c);
1352 }
1353 /* get last byte by fetching a word and masking */
1354 if (odd)
1355 *((u_char *)d) = readw(s) & 0xff;
1356 }
1357
1358 static void copyout(u_char *dest, const u_char *src, int c)
1359 {
1360 u_short *d = (u_short *)dest, *s = (u_short *)src;
1361 int odd;
1362
1363 if (c <= 0)
1364 return;
1365 odd = (c & 1); c >>= 1;
1366
1367 if (c) {
1368 do { __raw_writew(*s++, d++); } while (--c);
1369 }
1370 /* copy last byte doing a read-modify-write */
1371 if (odd)
1372 writew((readw(d) & 0xff00) | *(u_char *)s, d);
1373 }
1374
1375 /*====================================================================*/
1376
1377 static void shmem_get_8390_hdr(struct net_device *dev,
1378 struct e8390_pkt_hdr *hdr,
1379 int ring_page)
1380 {
1381 void *xfer_start = (void *)(dev->rmem_start + (ring_page << 8)
1382 - (ei_status.rx_start_page << 8));
1383
1384 copyin((void *)hdr, xfer_start, sizeof(struct e8390_pkt_hdr));
1385 /* Fix for big endian systems */
1386 hdr->count = le16_to_cpu(hdr->count);
1387 }
1388
1389 /*====================================================================*/
1390
1391 static void shmem_block_input(struct net_device *dev, int count,
1392 struct sk_buff *skb, int ring_offset)
1393 {
1394 void *xfer_start = (void *)(dev->rmem_start + ring_offset
1395 - (ei_status.rx_start_page << 8));
1396 char *buf = skb->data;
1397
1398 if (xfer_start + count > (void *)dev->rmem_end) {
1399 /* We must wrap the input move. */
1400 int semi_count = (void*)dev->rmem_end - xfer_start;
1401 copyin(buf, xfer_start, semi_count);
1402 buf += semi_count;
1403 ring_offset = ei_status.rx_start_page << 8;
1404 xfer_start = (void *)dev->rmem_start;
1405 count -= semi_count;
1406 }
1407 copyin(buf, xfer_start, count);
1408 }
1409
1410 /*====================================================================*/
1411
1412 static void shmem_block_output(struct net_device *dev, int count,
1413 const u_char *buf, const int start_page)
1414 {
1415 void *shmem = (void *)dev->mem_start + (start_page << 8);
1416 shmem -= ei_status.tx_start_page << 8;
1417 copyout(shmem, buf, count);
1418 }
1419
1420 /*====================================================================*/
1421
1422 static int setup_shmem_window(dev_link_t *link, int start_pg,
1423 int stop_pg, int cm_offset)
1424 {
1425 struct net_device *dev = link->priv;
1426 pcnet_dev_t *info = link->priv;
1427 win_req_t req;
1428 memreq_t mem;
1429 int i, window_size, offset, last_ret, last_fn;
1430
1431 window_size = (stop_pg - start_pg) << 8;
1432 if (window_size > 32 * 1024)
1433 window_size = 32 * 1024;
1434
1435 /* Make sure it's a power of two. */
1436 while ((window_size & (window_size - 1)) != 0)
1437 window_size += window_size & ~(window_size - 1);
1438
1439 /* Allocate a memory window */
1440 req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
1441 req.Attributes |= WIN_USE_WAIT;
1442 req.Base = 0; req.Size = window_size;
1443 req.AccessSpeed = mem_speed;
1444 link->win = (window_handle_t)link->handle;
1445 CS_CHECK(RequestWindow, &link->win, &req);
1446
1447 mem.CardOffset = (start_pg << 8) + cm_offset;
1448 offset = mem.CardOffset % window_size;
1449 mem.CardOffset -= offset;
1450 mem.Page = 0;
1451 CS_CHECK(MapMemPage, link->win, &mem);
1452
1453 /* Try scribbling on the buffer */
1454 info->base = ioremap(req.Base, window_size);
1455 for (i = 0; i < (TX_PAGES<<8); i += 2)
1456 __raw_writew((i>>1), info->base+offset+i);
1457 udelay(100);
1458 for (i = 0; i < (TX_PAGES<<8); i += 2)
1459 if (__raw_readw(info->base+offset+i) != (i>>1)) break;
1460 pcnet_reset_8390(dev);
1461 if (i != (TX_PAGES<<8)) {
1462 iounmap(info->base);
1463 CardServices(ReleaseWindow, link->win);
1464 info->base = NULL; link->win = NULL;
1465 goto failed;
1466 }
1467
1468 dev->mem_start = (u_long)info->base + offset;
1469 dev->rmem_start = dev->mem_start + (TX_PAGES<<8);
1470 dev->mem_end = dev->rmem_end = (u_long)info->base + req.Size;
1471
1472 ei_status.tx_start_page = start_pg;
1473 ei_status.rx_start_page = start_pg + TX_PAGES;
1474 ei_status.stop_page = start_pg + ((req.Size - offset) >> 8);
1475
1476 /* set up block i/o functions */
1477 ei_status.get_8390_hdr = &shmem_get_8390_hdr;
1478 ei_status.block_input = &shmem_block_input;
1479 ei_status.block_output = &shmem_block_output;
1480
1481 info->flags |= USE_SHMEM;
1482 return 0;
1483
1484 cs_failed:
1485 cs_error(link->handle, last_fn, last_ret);
1486 failed:
1487 return 1;
1488 }
1489
1490 /*====================================================================*/
1491
1492 static int __init init_pcnet_cs(void)
1493 {
1494 servinfo_t serv;
1495 DEBUG(0, "%s\n", version);
1496 CardServices(GetCardServicesInfo, &serv);
1497 if (serv.Revision != CS_RELEASE_CODE) {
1498 printk(KERN_NOTICE "pcnet_cs: Card Services release "
1499 "does not match!\n");
1500 return -1;
1501 }
1502 register_pccard_driver(&dev_info, &pcnet_attach, &pcnet_detach);
1503 return 0;
1504 }
1505
1506 static void __exit exit_pcnet_cs(void)
1507 {
1508 DEBUG(0, "pcnet_cs: unloading\n");
1509 unregister_pccard_driver(&dev_info);
1510 while (dev_list != NULL)
1511 pcnet_detach(dev_list);
1512 }
1513
1514 module_init(init_pcnet_cs);
1515 module_exit(exit_pcnet_cs);
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux