1 /* wd.c: A WD80x3 ethernet driver for linux. */
2 /*
3 Written 1993-94 by Donald Becker.
4
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
7
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
10
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
14 Annapolis MD 21403
15
16 This is a driver for WD8003 and WD8013 "compatible" ethercards.
17
18 Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
19
20 Changelog:
21
22 Paul Gortmaker : multiple card support for module users, support
23 for non-standard memory sizes.
24
25
26 */
27
28 static const char version[] =
29 "wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
30
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/string.h>
35 #include <linux/init.h>
36 #include <linux/interrupt.h>
37 #include <linux/delay.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40
41 #include <asm/io.h>
42
43 #include "8390.h"
44
45 #define DRV_NAME "wd"
46
47 /* A zero-terminated list of I/O addresses to be probed. */
48 static unsigned int wd_portlist[] __initdata =
49 {0x300, 0x280, 0x380, 0x240, 0};
50
51 static int wd_probe1(struct net_device *dev, int ioaddr);
52
53 static int wd_open(struct net_device *dev);
54 static void wd_reset_8390(struct net_device *dev);
55 static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
56 int ring_page);
57 static void wd_block_input(struct net_device *dev, int count,
58 struct sk_buff *skb, int ring_offset);
59 static void wd_block_output(struct net_device *dev, int count,
60 const unsigned char *buf, int start_page);
61 static int wd_close(struct net_device *dev);
62
63 static u32 wd_msg_enable;
64
65 #define WD_START_PG 0x00 /* First page of TX buffer */
66 #define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */
67 #define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */
68
69 #define WD_CMDREG 0 /* Offset to ASIC command register. */
70 #define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */
71 #define WD_MEMENB 0x40 /* Enable the shared memory. */
72 #define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */
73 #define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */
74 #define NIC16 0x40 /* Enable 16 bit access from the 8390. */
75 #define WD_NIC_OFFSET 16 /* Offset to the 8390 from the base_addr. */
76 #define WD_IO_EXTENT 32
77
78
79 /* Probe for the WD8003 and WD8013. These cards have the station
80 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
81 following. A Soundblaster can have the same checksum as an WDethercard,
82 so we have an extra exclusionary check for it.
83
84 The wd_probe1() routine initializes the card and fills the
85 station address field. */
86
do_wd_probe(struct net_device * dev)87 static int __init do_wd_probe(struct net_device *dev)
88 {
89 int i;
90 struct resource *r;
91 int base_addr = dev->base_addr;
92 int irq = dev->irq;
93 int mem_start = dev->mem_start;
94 int mem_end = dev->mem_end;
95
96 if (base_addr > 0x1ff) { /* Check a user specified location. */
97 r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
98 if ( r == NULL)
99 return -EBUSY;
100 i = wd_probe1(dev, base_addr);
101 if (i != 0)
102 release_region(base_addr, WD_IO_EXTENT);
103 else
104 r->name = dev->name;
105 return i;
106 }
107 else if (base_addr != 0) /* Don't probe at all. */
108 return -ENXIO;
109
110 for (i = 0; wd_portlist[i]; i++) {
111 int ioaddr = wd_portlist[i];
112 r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
113 if (r == NULL)
114 continue;
115 if (wd_probe1(dev, ioaddr) == 0) {
116 r->name = dev->name;
117 return 0;
118 }
119 release_region(ioaddr, WD_IO_EXTENT);
120 dev->irq = irq;
121 dev->mem_start = mem_start;
122 dev->mem_end = mem_end;
123 }
124
125 return -ENODEV;
126 }
127
128 #ifndef MODULE
wd_probe(int unit)129 struct net_device * __init wd_probe(int unit)
130 {
131 struct net_device *dev = alloc_ei_netdev();
132 int err;
133
134 if (!dev)
135 return ERR_PTR(-ENOMEM);
136
137 sprintf(dev->name, "eth%d", unit);
138 netdev_boot_setup_check(dev);
139
140 err = do_wd_probe(dev);
141 if (err)
142 goto out;
143 return dev;
144 out:
145 free_netdev(dev);
146 return ERR_PTR(err);
147 }
148 #endif
149
150 static const struct net_device_ops wd_netdev_ops = {
151 .ndo_open = wd_open,
152 .ndo_stop = wd_close,
153 .ndo_start_xmit = ei_start_xmit,
154 .ndo_tx_timeout = ei_tx_timeout,
155 .ndo_get_stats = ei_get_stats,
156 .ndo_set_rx_mode = ei_set_multicast_list,
157 .ndo_validate_addr = eth_validate_addr,
158 .ndo_set_mac_address = eth_mac_addr,
159 #ifdef CONFIG_NET_POLL_CONTROLLER
160 .ndo_poll_controller = ei_poll,
161 #endif
162 };
163
wd_probe1(struct net_device * dev,int ioaddr)164 static int __init wd_probe1(struct net_device *dev, int ioaddr)
165 {
166 int i;
167 int err;
168 int checksum = 0;
169 int ancient = 0; /* An old card without config registers. */
170 int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
171 const char *model_name;
172 static unsigned version_printed;
173 struct ei_device *ei_local = netdev_priv(dev);
174
175 for (i = 0; i < 8; i++)
176 checksum += inb(ioaddr + 8 + i);
177 if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
178 || inb(ioaddr + 9) == 0xff
179 || (checksum & 0xff) != 0xFF)
180 return -ENODEV;
181
182 /* Check for semi-valid mem_start/end values if supplied. */
183 if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
184 netdev_warn(dev,
185 "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
186 dev->mem_start = 0;
187 dev->mem_end = 0;
188 }
189
190 if ((wd_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
191 netdev_info(dev, version);
192
193 for (i = 0; i < 6; i++)
194 dev->dev_addr[i] = inb(ioaddr + 8 + i);
195
196 netdev_info(dev, "WD80x3 at %#3x, %pM", ioaddr, dev->dev_addr);
197
198 /* The following PureData probe code was contributed by
199 Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
200 configuration differently from others so we have to check for them.
201 This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
202 */
203 if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
204 unsigned char reg5 = inb(ioaddr+5);
205
206 switch (inb(ioaddr+2)) {
207 case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
208 case 0x05: word16 = 0; model_name = "PDUC8023"; break;
209 case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
210 /* Either 0x01 (dumb) or they've released a new version. */
211 default: word16 = 0; model_name = "PDI8023"; break;
212 }
213 dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
214 dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
215 } else { /* End of PureData probe */
216 /* This method of checking for a 16-bit board is borrowed from the
217 we.c driver. A simpler method is just to look in ASIC reg. 0x03.
218 I'm comparing the two method in alpha test to make certain they
219 return the same result. */
220 /* Check for the old 8 bit board - it has register 0/8 aliasing.
221 Do NOT check i>=6 here -- it hangs the old 8003 boards! */
222 for (i = 0; i < 6; i++)
223 if (inb(ioaddr+i) != inb(ioaddr+8+i))
224 break;
225 if (i >= 6) {
226 ancient = 1;
227 model_name = "WD8003-old";
228 word16 = 0;
229 } else {
230 int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
231 outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
232 if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
233 && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
234 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
235 /* Magic to set ASIC to word-wide mode. */
236 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
237 outb(tmp, ioaddr+1);
238 model_name = "WD8013";
239 word16 = 1; /* We have a 16bit board here! */
240 } else {
241 model_name = "WD8003";
242 word16 = 0;
243 }
244 outb(tmp, ioaddr+1); /* Restore original reg1 value. */
245 }
246 #ifndef final_version
247 if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
248 pr_cont("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
249 word16 ? 16 : 8,
250 (inb(ioaddr+1) & 0x01) ? 16 : 8);
251 #endif
252 }
253
254 #if defined(WD_SHMEM) && WD_SHMEM > 0x80000
255 /* Allow a compile-time override. */
256 dev->mem_start = WD_SHMEM;
257 #else
258 if (dev->mem_start == 0) {
259 /* Sanity and old 8003 check */
260 int reg0 = inb(ioaddr);
261 if (reg0 == 0xff || reg0 == 0) {
262 /* Future plan: this could check a few likely locations first. */
263 dev->mem_start = 0xd0000;
264 pr_cont(" assigning address %#lx", dev->mem_start);
265 } else {
266 int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
267 /* Some boards don't have the register 5 -- it returns 0xff. */
268 if (high_addr_bits == 0x1f || word16 == 0)
269 high_addr_bits = 0x01;
270 dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
271 }
272 }
273 #endif
274
275 /* The 8390 isn't at the base address -- the ASIC regs are there! */
276 dev->base_addr = ioaddr+WD_NIC_OFFSET;
277
278 if (dev->irq < 2) {
279 static const int irqmap[] = {9, 3, 5, 7, 10, 11, 15, 4};
280 int reg1 = inb(ioaddr+1);
281 int reg4 = inb(ioaddr+4);
282 if (ancient || reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
283 short nic_addr = ioaddr+WD_NIC_OFFSET;
284 unsigned long irq_mask;
285
286 /* We have an old-style ethercard that doesn't report its IRQ
287 line. Do autoirq to find the IRQ line. Note that this IS NOT
288 a reliable way to trigger an interrupt. */
289 outb_p(E8390_NODMA + E8390_STOP, nic_addr);
290 outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
291
292 irq_mask = probe_irq_on();
293 outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
294 outb_p(0x00, nic_addr + EN0_RCNTLO);
295 outb_p(0x00, nic_addr + EN0_RCNTHI);
296 outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
297 mdelay(20);
298 dev->irq = probe_irq_off(irq_mask);
299
300 outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
301
302 if (wd_msg_enable & NETIF_MSG_PROBE)
303 pr_cont(" autoirq is %d", dev->irq);
304 if (dev->irq < 2)
305 dev->irq = word16 ? 10 : 5;
306 } else
307 dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
308 } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
309 dev->irq = 9;
310
311 /* Snarf the interrupt now. There's no point in waiting since we cannot
312 share and the board will usually be enabled. */
313 i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
314 if (i) {
315 pr_cont(" unable to get IRQ %d.\n", dev->irq);
316 return i;
317 }
318
319 /* OK, were are certain this is going to work. Setup the device. */
320 ei_status.name = model_name;
321 ei_status.word16 = word16;
322 ei_status.tx_start_page = WD_START_PG;
323 ei_status.rx_start_page = WD_START_PG + TX_PAGES;
324
325 /* Don't map in the shared memory until the board is actually opened. */
326
327 /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
328 if (dev->mem_end != 0) {
329 ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
330 ei_status.priv = dev->mem_end - dev->mem_start;
331 } else {
332 ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
333 dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
334 ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
335 }
336
337 ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
338 if (!ei_status.mem) {
339 free_irq(dev->irq, dev);
340 return -ENOMEM;
341 }
342
343 pr_cont(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
344 model_name, dev->irq, dev->mem_start, dev->mem_end-1);
345
346 ei_status.reset_8390 = wd_reset_8390;
347 ei_status.block_input = wd_block_input;
348 ei_status.block_output = wd_block_output;
349 ei_status.get_8390_hdr = wd_get_8390_hdr;
350
351 dev->netdev_ops = &wd_netdev_ops;
352 NS8390_init(dev, 0);
353 ei_local->msg_enable = wd_msg_enable;
354
355 #if 1
356 /* Enable interrupt generation on softconfig cards -- M.U */
357 /* .. but possibly potentially unsafe - Donald */
358 if (inb(ioaddr+14) & 0x20)
359 outb(inb(ioaddr+4)|0x80, ioaddr+4);
360 #endif
361
362 err = register_netdev(dev);
363 if (err) {
364 free_irq(dev->irq, dev);
365 iounmap(ei_status.mem);
366 }
367 return err;
368 }
369
370 static int
wd_open(struct net_device * dev)371 wd_open(struct net_device *dev)
372 {
373 int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
374
375 /* Map in the shared memory. Always set register 0 last to remain
376 compatible with very old boards. */
377 ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
378 ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
379
380 if (ei_status.word16)
381 outb(ei_status.reg5, ioaddr+WD_CMDREG5);
382 outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
383
384 return ei_open(dev);
385 }
386
387 static void
wd_reset_8390(struct net_device * dev)388 wd_reset_8390(struct net_device *dev)
389 {
390 int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
391 struct ei_device *ei_local = netdev_priv(dev);
392
393 outb(WD_RESET, wd_cmd_port);
394 netif_dbg(ei_local, hw, dev, "resetting the WD80x3 t=%lu...\n",
395 jiffies);
396 ei_status.txing = 0;
397
398 /* Set up the ASIC registers, just in case something changed them. */
399 outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
400 if (ei_status.word16)
401 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
402
403 netif_dbg(ei_local, hw, dev, "reset done\n");
404 }
405
406 /* Grab the 8390 specific header. Similar to the block_input routine, but
407 we don't need to be concerned with ring wrap as the header will be at
408 the start of a page, so we optimize accordingly. */
409
410 static void
wd_get_8390_hdr(struct net_device * dev,struct e8390_pkt_hdr * hdr,int ring_page)411 wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
412 {
413
414 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
415 void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
416
417 /* We'll always get a 4 byte header read followed by a packet read, so
418 we enable 16 bit mode before the header, and disable after the body. */
419 if (ei_status.word16)
420 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
421
422 #ifdef __BIG_ENDIAN
423 /* Officially this is what we are doing, but the readl() is faster */
424 /* unfortunately it isn't endian aware of the struct */
425 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
426 hdr->count = le16_to_cpu(hdr->count);
427 #else
428 ((unsigned int*)hdr)[0] = readl(hdr_start);
429 #endif
430 }
431
432 /* Block input and output are easy on shared memory ethercards, and trivial
433 on the Western digital card where there is no choice of how to do it.
434 The only complications are that the ring buffer wraps, and need to map
435 switch between 8- and 16-bit modes. */
436
437 static void
wd_block_input(struct net_device * dev,int count,struct sk_buff * skb,int ring_offset)438 wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
439 {
440 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
441 unsigned long offset = ring_offset - (WD_START_PG<<8);
442 void __iomem *xfer_start = ei_status.mem + offset;
443
444 if (offset + count > ei_status.priv) {
445 /* We must wrap the input move. */
446 int semi_count = ei_status.priv - offset;
447 memcpy_fromio(skb->data, xfer_start, semi_count);
448 count -= semi_count;
449 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
450 } else {
451 /* Packet is in one chunk -- we can copy + cksum. */
452 memcpy_fromio(skb->data, xfer_start, count);
453 }
454
455 /* Turn off 16 bit access so that reboot works. ISA brain-damage */
456 if (ei_status.word16)
457 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
458 }
459
460 static void
wd_block_output(struct net_device * dev,int count,const unsigned char * buf,int start_page)461 wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
462 int start_page)
463 {
464 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
465 void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
466
467
468 if (ei_status.word16) {
469 /* Turn on and off 16 bit access so that reboot works. */
470 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
471 memcpy_toio(shmem, buf, count);
472 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
473 } else
474 memcpy_toio(shmem, buf, count);
475 }
476
477
478 static int
wd_close(struct net_device * dev)479 wd_close(struct net_device *dev)
480 {
481 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
482 struct ei_device *ei_local = netdev_priv(dev);
483
484 netif_dbg(ei_local, ifdown, dev, "Shutting down ethercard.\n");
485 ei_close(dev);
486
487 /* Change from 16-bit to 8-bit shared memory so reboot works. */
488 if (ei_status.word16)
489 outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
490
491 /* And disable the shared memory. */
492 outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
493
494 return 0;
495 }
496
497
498 #ifdef MODULE
499 #define MAX_WD_CARDS 4 /* Max number of wd cards per module */
500 static struct net_device *dev_wd[MAX_WD_CARDS];
501 static int io[MAX_WD_CARDS];
502 static int irq[MAX_WD_CARDS];
503 static int mem[MAX_WD_CARDS];
504 static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */
505
506 module_param_hw_array(io, int, ioport, NULL, 0);
507 module_param_hw_array(irq, int, irq, NULL, 0);
508 module_param_hw_array(mem, int, iomem, NULL, 0);
509 module_param_hw_array(mem_end, int, iomem, NULL, 0);
510 module_param_named(msg_enable, wd_msg_enable, uint, 0444);
511 MODULE_PARM_DESC(io, "I/O base address(es)");
512 MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
513 MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
514 MODULE_PARM_DESC(mem_end, "memory end address(es)");
515 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
516 MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
517 MODULE_LICENSE("GPL");
518
519 /* This is set up so that only a single autoprobe takes place per call.
520 ISA device autoprobes on a running machine are not recommended. */
521
init_module(void)522 int __init init_module(void)
523 {
524 struct net_device *dev;
525 int this_dev, found = 0;
526
527 for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
528 if (io[this_dev] == 0) {
529 if (this_dev != 0) break; /* only autoprobe 1st one */
530 printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
531 }
532 dev = alloc_ei_netdev();
533 if (!dev)
534 break;
535 dev->irq = irq[this_dev];
536 dev->base_addr = io[this_dev];
537 dev->mem_start = mem[this_dev];
538 dev->mem_end = mem_end[this_dev];
539 if (do_wd_probe(dev) == 0) {
540 dev_wd[found++] = dev;
541 continue;
542 }
543 free_netdev(dev);
544 printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
545 break;
546 }
547 if (found)
548 return 0;
549 return -ENXIO;
550 }
551
cleanup_card(struct net_device * dev)552 static void cleanup_card(struct net_device *dev)
553 {
554 free_irq(dev->irq, dev);
555 release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
556 iounmap(ei_status.mem);
557 }
558
559 void __exit
cleanup_module(void)560 cleanup_module(void)
561 {
562 int this_dev;
563
564 for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
565 struct net_device *dev = dev_wd[this_dev];
566 if (dev) {
567 unregister_netdev(dev);
568 cleanup_card(dev);
569 free_netdev(dev);
570 }
571 }
572 }
573 #endif /* MODULE */
574
