This source file includes following definitions.
- de620_ready
- de620_send_command
- de620_put_byte
- de620_read_byte
- de620_write_block
- de620_read_block
- de620_set_delay
- de620_set_register
- de620_get_register
- de620_open
- de620_close
- get_stats
- de620_set_multicast_list
- de620_start_xmit
- de620_interrupt
- de620_rx_intr
- adapter_init
- de620_probe
- ReadAWord
- read_eeprom
- init_module
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41 static const char *version =
42 "de620.c: $Revision: 1.31 $, Bjorn Ekwall <bj0rn@blox.se>\n";
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68 #ifndef READ_DELAY
69 #define READ_DELAY 100
70 #endif
71
72 #ifndef WRITE_DELAY
73 #define WRITE_DELAY 100
74 #endif
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95 #ifdef LOWSPEED
96
97
98
99
100
101
102 #endif
103 static int bnc = 0, utp = 0;
104
105
106
107
108
109
110
111 #ifdef MODULE
112 #include <linux/module.h>
113 #include <linux/version.h>
114 #endif
115
116 #include <linux/kernel.h>
117 #include <linux/sched.h>
118 #include <linux/types.h>
119 #include <linux/fcntl.h>
120 #include <linux/string.h>
121 #include <linux/interrupt.h>
122 #include <linux/ioport.h>
123 #include <asm/io.h>
124 #include <linux/in.h>
125 #include <linux/ptrace.h>
126 #include <asm/system.h>
127 #include <linux/errno.h>
128
129 #include <linux/inet.h>
130 #include <linux/netdevice.h>
131 #include <linux/etherdevice.h>
132 #include <linux/skbuff.h>
133
134
135 #include "de620.h"
136
137 #define netstats enet_statistics
138 typedef unsigned char byte;
139
140
141
142
143
144
145
146 #ifndef DE620_IO
147 #define DE620_IO 0x378
148 #endif
149
150 #ifndef DE620_IRQ
151 #define DE620_IRQ 7
152 #endif
153
154 #define DATA_PORT (dev->base_addr)
155 #define STATUS_PORT (dev->base_addr + 1)
156 #define COMMAND_PORT (dev->base_addr + 2)
157
158 #define RUNT 60
159 #define GIANT 1514
160
161 #ifdef DE620_DEBUG
162 #define PRINTK(x) if (de620_debug >= 2) printk x
163 #else
164 #define DE620_DEBUG 0
165 #define PRINTK(x)
166 #endif
167
168
169
170
171
172
173
174
175
176
177
178
179 static int de620_open(struct device *);
180 static int de620_close(struct device *);
181 static struct netstats *get_stats(struct device *);
182 static void de620_set_multicast_list(struct device *, int, void *);
183 static int de620_start_xmit(struct sk_buff *, struct device *);
184
185
186 static void de620_interrupt(int, struct pt_regs *);
187 static int de620_rx_intr(struct device *);
188
189
190 static int adapter_init(struct device *);
191 int de620_probe(struct device *);
192 static int read_eeprom(struct device *);
193
194
195
196
197
198 #define SCR_DEF NIBBLEMODE |INTON | SLEEP | AUTOTX
199 #define TCR_DEF RXPB
200 #define DE620_RX_START_PAGE 12
201 #define DEF_NIC_CMD IRQEN | ICEN | DS1
202
203 unsigned int de620_debug = DE620_DEBUG;
204
205 static volatile byte NIC_Cmd;
206 static volatile byte next_rx_page;
207 static byte first_rx_page;
208 static byte last_rx_page;
209 static byte EIPRegister;
210
211 static struct nic {
212 byte NodeID[6];
213 byte RAM_Size;
214 byte Model;
215 byte Media;
216 byte SCR;
217 } nic_data;
218
219
220
221
222
223
224 #define de620_tx_buffs(dd) (inb(STATUS_PORT) & (TXBF0 | TXBF1))
225 #define de620_flip_ds(dd) NIC_Cmd ^= DS0 | DS1; outb(NIC_Cmd, COMMAND_PORT);
226
227
228 #ifdef COUNT_LOOPS
229 static int tot_cnt;
230 #endif
231 static inline byte
232 de620_ready(struct device *dev)
233 {
234 byte value;
235 register short int cnt = 0;
236
237 while ((((value = inb(STATUS_PORT)) & READY) == 0) && (cnt <= 1000))
238 ++cnt;
239
240 #ifdef COUNT_LOOPS
241 tot_cnt += cnt;
242 #endif
243 return value & 0xf0;
244 }
245
246 static inline void
247 de620_send_command(struct device *dev, byte cmd)
248 {
249 de620_ready(dev);
250 if (cmd == W_DUMMY)
251 outb(NIC_Cmd, COMMAND_PORT);
252
253 outb(cmd, DATA_PORT);
254
255 outb(NIC_Cmd ^ CS0, COMMAND_PORT);
256 de620_ready(dev);
257 outb(NIC_Cmd, COMMAND_PORT);
258 }
259
260 static inline void
261 de620_put_byte(struct device *dev, byte value)
262 {
263
264 de620_ready(dev);
265 outb(value, DATA_PORT);
266 de620_flip_ds(dev);
267 }
268
269 static inline byte
270 de620_read_byte(struct device *dev)
271 {
272 byte value;
273
274
275 value = de620_ready(dev);
276 de620_flip_ds(dev);
277 value |= de620_ready(dev) >> 4;
278 return value;
279 }
280
281 static inline void
282 de620_write_block(struct device *dev, byte *buffer, int count)
283 {
284 #ifndef LOWSPEED
285 byte uflip = NIC_Cmd ^ (DS0 | DS1);
286 byte dflip = NIC_Cmd;
287 #else
288 #ifdef COUNT_LOOPS
289 int bytes = count;
290 #endif
291 #endif
292
293 #ifdef LOWSPEED
294 #ifdef COUNT_LOOPS
295 tot_cnt = 0;
296 #endif
297
298 for ( ; count > 0; --count, ++buffer) {
299 de620_put_byte(dev,*buffer);
300 }
301 de620_send_command(dev,W_DUMMY);
302 #ifdef COUNT_LOOPS
303
304 printk("WRITE(%d)\n", tot_cnt/((bytes?bytes:1)));
305 #endif
306 #else
307 for ( ; count > 0; count -=2) {
308 outb(*buffer++, DATA_PORT);
309 outb(uflip, COMMAND_PORT);
310 outb(*buffer++, DATA_PORT);
311 outb(dflip, COMMAND_PORT);
312 }
313 de620_send_command(dev,W_DUMMY);
314 #endif
315 }
316
317 static inline void
318 de620_read_block(struct device *dev, byte *data, int count)
319 {
320 #ifndef LOWSPEED
321 byte value;
322 byte uflip = NIC_Cmd ^ (DS0 | DS1);
323 byte dflip = NIC_Cmd;
324 #else
325 #ifdef COUNT_LOOPS
326 int bytes = count;
327
328 tot_cnt = 0;
329 #endif
330 #endif
331
332 #ifdef LOWSPEED
333
334 while (count-- > 0) {
335 *data++ = de620_read_byte(dev);
336 de620_flip_ds(dev);
337 }
338 #ifdef COUNT_LOOPS
339
340 printk("READ(%d)\n", tot_cnt/(2*(bytes?bytes:1)));
341 #endif
342 #else
343 while (count-- > 0) {
344 value = inb(STATUS_PORT) & 0xf0;
345 outb(uflip, COMMAND_PORT);
346 *data++ = value | inb(STATUS_PORT) >> 4;
347 outb(dflip , COMMAND_PORT);
348 }
349 #endif
350 }
351
352 static inline void
353 de620_set_delay(struct device *dev)
354 {
355 de620_ready(dev);
356 outb(W_DFR, DATA_PORT);
357 outb(NIC_Cmd ^ CS0, COMMAND_PORT);
358
359 de620_ready(dev);
360 #ifdef LOWSPEED
361 outb(WRITE_DELAY, DATA_PORT);
362 #else
363 outb(0, DATA_PORT);
364 #endif
365 de620_flip_ds(dev);
366
367 de620_ready(dev);
368 #ifdef LOWSPEED
369 outb(READ_DELAY, DATA_PORT);
370 #else
371 outb(0, DATA_PORT);
372 #endif
373 de620_flip_ds(dev);
374 }
375
376 static inline void
377 de620_set_register(struct device *dev, byte reg, byte value)
378 {
379 de620_ready(dev);
380 outb(reg, DATA_PORT);
381 outb(NIC_Cmd ^ CS0, COMMAND_PORT);
382
383 de620_put_byte(dev, value);
384 }
385
386 static inline byte
387 de620_get_register(struct device *dev, byte reg)
388 {
389 byte value;
390
391 de620_send_command(dev,reg);
392 value = de620_read_byte(dev);
393 de620_send_command(dev,W_DUMMY);
394
395 return value;
396 }
397
398
399
400
401
402
403
404
405
406
407 static int
408 de620_open(struct device *dev)
409 {
410 if (request_irq(DE620_IRQ, de620_interrupt, 0, "de620")) {
411 printk ("%s: unable to get IRQ %d\n", dev->name, DE620_IRQ);
412 return 1;
413 }
414 irq2dev_map[DE620_IRQ] = dev;
415
416 #ifdef MODULE
417 MOD_INC_USE_COUNT;
418 #endif
419 if (adapter_init(dev)) {
420 return 1;
421 }
422 dev->start = 1;
423 return 0;
424 }
425
426
427
428
429
430
431 static int
432 de620_close(struct device *dev)
433 {
434
435 de620_set_register(dev, W_TCR, RXOFF);
436
437 free_irq(DE620_IRQ);
438 irq2dev_map[DE620_IRQ] = NULL;
439
440 dev->start = 0;
441 #ifdef MODULE
442 MOD_DEC_USE_COUNT;
443 #endif
444 return 0;
445 }
446
447
448
449
450
451
452 static struct netstats *
453 get_stats(struct device *dev)
454 {
455 return (struct netstats *)(dev->priv);
456 }
457
458
459
460
461
462
463
464
465
466
467
468 static void
469 de620_set_multicast_list(struct device *dev, int num_addrs, void *addrs)
470 {
471 if (num_addrs)
472 {
473
474
475
476
477
478 dev->flags|=IFF_PROMISC;
479
480 de620_set_register(dev, W_TCR, (TCR_DEF & ~RXPBM) | RXALL);
481 }
482 else {
483 de620_set_register(dev, W_TCR, TCR_DEF);
484 }
485 }
486
487
488
489
490
491
492 static int
493 de620_start_xmit(struct sk_buff *skb, struct device *dev)
494 {
495 unsigned long flags;
496 int len;
497 int tickssofar;
498 byte *buffer = skb->data;
499 byte using_txbuf;
500
501
502
503
504
505
506
507 if (skb == NULL) {
508 dev_tint(dev);
509 return 0;
510 }
511
512 using_txbuf = de620_tx_buffs(dev);
513 dev->tbusy = (using_txbuf == (TXBF0 | TXBF1));
514
515 if (dev->tbusy) {
516 tickssofar = jiffies - dev->trans_start;
517
518 if (tickssofar < 5)
519 return 1;
520
521
522 printk("%s: transmit timed out (%d), %s?\n",
523 dev->name,
524 tickssofar,
525 "network cable problem"
526 );
527
528 if (adapter_init(dev))
529 return 1;
530 }
531
532 if ((len = skb->len) < RUNT)
533 len = RUNT;
534 if (len & 1)
535 ++len;
536
537
538 save_flags(flags);
539 cli();
540
541 PRINTK(("de620_start_xmit: len=%d, bufs 0x%02x\n",
542 (int)skb->len, using_txbuf));
543
544
545 switch (using_txbuf) {
546 default:
547 case TXBF1:
548 de620_send_command(dev,W_CR | RW0);
549 using_txbuf |= TXBF0;
550 break;
551
552 case TXBF0:
553 de620_send_command(dev,W_CR | RW1);
554 using_txbuf |= TXBF1;
555 break;
556
557 case (TXBF0 | TXBF1):
558 printk("de620: Ouch! No tx-buffer available!\n");
559 restore_flags(flags);
560 return 1;
561 break;
562 }
563 de620_write_block(dev, buffer, len);
564
565 dev->trans_start = jiffies;
566 dev->tbusy = (using_txbuf == (TXBF0 | TXBF1));
567
568 ((struct netstats *)(dev->priv))->tx_packets++;
569
570 restore_flags(flags);
571
572 dev_kfree_skb (skb, FREE_WRITE);
573
574 return 0;
575 }
576
577
578
579
580
581
582 static void
583 de620_interrupt(int irq, struct pt_regs *regs)
584 {
585 struct device *dev = irq2dev_map[irq];
586 byte irq_status;
587 int bogus_count = 0;
588 int again = 0;
589
590
591 if ((dev == NULL) || (DE620_IRQ != irq)) {
592 printk("%s: bogus interrupt %d\n", dev?dev->name:"DE620", irq);
593 return;
594 }
595
596 cli();
597 dev->interrupt = 1;
598
599
600 irq_status = de620_get_register(dev, R_STS);
601
602 PRINTK(("de620_interrupt (%2.2X)\n", irq_status));
603
604 if (irq_status & RXGOOD) {
605 do {
606 again = de620_rx_intr(dev);
607 PRINTK(("again=%d\n", again));
608 }
609 while (again && (++bogus_count < 100));
610 }
611
612 dev->tbusy = (de620_tx_buffs(dev) == (TXBF0 | TXBF1));
613
614 dev->interrupt = 0;
615 sti();
616 return;
617 }
618
619
620
621
622
623
624
625
626 static int
627 de620_rx_intr(struct device *dev)
628 {
629 struct header_buf {
630 byte status;
631 byte Rx_NextPage;
632 unsigned short Rx_ByteCount;
633 } header_buf;
634 struct sk_buff *skb;
635 int size;
636 byte *buffer;
637 byte pagelink;
638 byte curr_page;
639
640 PRINTK(("de620_rx_intr: next_rx_page = %d\n", next_rx_page));
641
642
643 de620_send_command(dev, W_CR | RRN);
644 de620_set_register(dev, W_RSA1, next_rx_page);
645 de620_set_register(dev, W_RSA0, 0);
646
647
648 de620_read_block(dev, (byte *)&header_buf, sizeof(struct header_buf));
649 PRINTK(("page status=0x%02x, nextpage=%d, packetsize=%d\n",
650 header_buf.status, header_buf.Rx_NextPage, header_buf.Rx_ByteCount));
651
652
653 pagelink = header_buf.Rx_NextPage;
654 if ((pagelink < first_rx_page) || (last_rx_page < pagelink)) {
655
656 printk("%s: Ring overrun? Restoring...\n", dev->name);
657
658 adapter_init(dev);
659 ((struct netstats *)(dev->priv))->rx_over_errors++;
660 return 0;
661 }
662
663
664
665 pagelink = next_rx_page +
666 ((header_buf.Rx_ByteCount + (4 - 1 + 0x100)) >> 8);
667
668
669 if (pagelink > last_rx_page)
670 pagelink -= (last_rx_page - first_rx_page + 1);
671
672
673 if (pagelink != header_buf.Rx_NextPage) {
674
675 printk("%s: Page link out of sync! Restoring...\n", dev->name);
676 next_rx_page = header_buf.Rx_NextPage;
677 de620_send_command(dev, W_DUMMY);
678 de620_set_register(dev, W_NPRF, next_rx_page);
679 ((struct netstats *)(dev->priv))->rx_over_errors++;
680 return 0;
681 }
682 next_rx_page = pagelink;
683
684 size = header_buf.Rx_ByteCount - 4;
685 if ((size < RUNT) || (GIANT < size)) {
686 printk("%s: Illegal packet size: %d!\n", dev->name, size);
687 }
688 else {
689 skb = dev_alloc_skb(size+2);
690 if (skb == NULL) {
691 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
692 dev->name, size);
693 ((struct netstats *)(dev->priv))->rx_dropped++;
694 }
695 else {
696 skb_reserve(skb,2);
697 skb->dev = dev;
698 skb->free = 1;
699
700 buffer = skb_put(skb,size);
701
702 de620_read_block(dev, buffer, size);
703 PRINTK(("Read %d bytes\n", size));
704 skb->protocol=eth_type_trans(skb,dev);
705 netif_rx(skb);
706
707 ((struct netstats *)(dev->priv))->rx_packets++;
708 }
709 }
710
711
712
713 curr_page = de620_get_register(dev, R_CPR);
714 de620_set_register(dev, W_NPRF, next_rx_page);
715 PRINTK(("next_rx_page=%d CPR=%d\n", next_rx_page, curr_page));
716
717 return (next_rx_page != curr_page);
718 }
719
720
721
722
723
724
725 static int
726 adapter_init(struct device *dev)
727 {
728 int i;
729 static int was_down = 0;
730
731 if ((nic_data.Model == 3) || (nic_data.Model == 0)) {
732 EIPRegister = NCTL0;
733 if (nic_data.Media != 1)
734 EIPRegister |= NIS0;
735 }
736 else if (nic_data.Model == 2) {
737 EIPRegister = NCTL0 | NIS0;
738 }
739
740 if (utp)
741 EIPRegister = NCTL0 | NIS0;
742 if (bnc)
743 EIPRegister = NCTL0;
744
745 de620_send_command(dev, W_CR | RNOP | CLEAR);
746 de620_send_command(dev, W_CR | RNOP);
747
748 de620_set_register(dev, W_SCR, SCR_DEF);
749
750 de620_set_register(dev, W_TCR, RXOFF);
751
752
753 for (i = 0; i < 6; ++i) {
754 de620_set_register(dev, W_PAR0 + i, dev->dev_addr[i]);
755 }
756
757 de620_set_register(dev, W_EIP, EIPRegister);
758
759 next_rx_page = first_rx_page = DE620_RX_START_PAGE;
760 if (nic_data.RAM_Size)
761 last_rx_page = nic_data.RAM_Size - 1;
762 else
763 last_rx_page = 255;
764
765 de620_set_register(dev, W_SPR, first_rx_page);
766 de620_set_register(dev, W_EPR, last_rx_page);
767 de620_set_register(dev, W_CPR, first_rx_page);
768 de620_send_command(dev, W_NPR | first_rx_page);
769 de620_send_command(dev, W_DUMMY);
770 de620_set_delay(dev);
771
772
773
774 #define CHECK_MASK ( 0 | TXSUC | T16 | 0 | RXCRC | RXSHORT | 0 | 0 )
775 #define CHECK_OK ( 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 )
776
777
778
779 if (((i = de620_get_register(dev, R_STS)) & CHECK_MASK) != CHECK_OK) {
780 printk("Something has happened to the DE-620! Please check it"
781 #ifdef SHUTDOWN_WHEN_LOST
782 " and do a new ifconfig"
783 #endif
784 "! (%02x)\n", i);
785 #ifdef SHUTDOWN_WHEN_LOST
786
787 dev->flags &= ~IFF_UP;
788 de620_close(dev);
789 #endif
790 was_down = 1;
791 return 1;
792 }
793 if (was_down) {
794 printk("Thanks, I feel much better now!\n");
795 was_down = 0;
796 }
797
798
799 de620_set_register(dev, W_TCR, TCR_DEF);
800
801 return 0;
802 }
803
804
805
806
807
808
809
810
811
812
813 int
814 de620_probe(struct device *dev)
815 {
816 static struct netstats de620_netstats;
817 int i;
818 byte checkbyte = 0xa5;
819
820 if (de620_debug)
821 printk(version);
822
823 printk("D-Link DE-620 pocket adapter");
824
825
826 NIC_Cmd = DEF_NIC_CMD;
827 de620_set_register(dev, W_EIP, EIPRegister);
828
829
830 de620_set_register(dev, W_CPR, checkbyte);
831 checkbyte = de620_get_register(dev, R_CPR);
832
833 if ((checkbyte != 0xa5) || (read_eeprom(dev) != 0)) {
834 printk(" not identified in the printer port\n");
835 return ENODEV;
836 }
837
838 #if 0
839 if (check_region(DE620_IO, 3)) {
840 printk(", port 0x%x busy\n", DE620_IO);
841 return EBUSY;
842 }
843 #endif
844 request_region(DE620_IO, 3, "de620");
845
846
847 printk(", Ethernet Address: %2.2X",
848 dev->dev_addr[0] = nic_data.NodeID[0]);
849 for (i = 1; i < ETH_ALEN; i++) {
850 printk(":%2.2X", dev->dev_addr[i] = nic_data.NodeID[i]);
851 dev->broadcast[i] = 0xff;
852 }
853
854 printk(" (%dk RAM,",
855 (nic_data.RAM_Size) ? (nic_data.RAM_Size >> 2) : 64);
856
857 if (nic_data.Media == 1)
858 printk(" BNC)\n");
859 else
860 printk(" UTP)\n");
861
862
863
864 dev->priv = &de620_netstats;
865
866 memset(dev->priv, 0, sizeof(struct netstats));
867 dev->get_stats = get_stats;
868 dev->open = de620_open;
869 dev->stop = de620_close;
870 dev->hard_start_xmit = &de620_start_xmit;
871 dev->set_multicast_list = &de620_set_multicast_list;
872 dev->base_addr = DE620_IO;
873 dev->irq = DE620_IRQ;
874
875 ether_setup(dev);
876
877
878 if (de620_debug) {
879 printk("\nEEPROM contents:\n");
880 printk("RAM_Size = 0x%02X\n", nic_data.RAM_Size);
881 printk("NodeID = %02X:%02X:%02X:%02X:%02X:%02X\n",
882 nic_data.NodeID[0], nic_data.NodeID[1],
883 nic_data.NodeID[2], nic_data.NodeID[3],
884 nic_data.NodeID[4], nic_data.NodeID[5]);
885 printk("Model = %d\n", nic_data.Model);
886 printk("Media = %d\n", nic_data.Media);
887 printk("SCR = 0x%02x\n", nic_data.SCR);
888 }
889
890 return 0;
891 }
892
893
894
895
896
897
898
899 #define sendit(dev,data) de620_set_register(dev, W_EIP, data | EIPRegister);
900
901 static unsigned short
902 ReadAWord(struct device *dev, int from)
903 {
904 unsigned short data;
905 int nbits;
906
907
908
909
910 sendit(dev, 0); sendit(dev, 1); sendit(dev, 5); sendit(dev, 4);
911
912
913 for (nbits = 9; nbits > 0; --nbits, from <<= 1) {
914 if (from & 0x0100) {
915
916
917
918 sendit(dev, 6); sendit(dev, 7); sendit(dev, 7); sendit(dev, 6);
919 }
920 else {
921
922
923
924 sendit(dev, 4); sendit(dev, 5); sendit(dev, 5); sendit(dev, 4);
925 }
926 }
927
928
929 for (data = 0, nbits = 16; nbits > 0; --nbits) {
930
931
932
933 sendit(dev, 4); sendit(dev, 5); sendit(dev, 5); sendit(dev, 4);
934 data = (data << 1) | ((de620_get_register(dev, R_STS) & EEDI) >> 7);
935 }
936
937
938
939 sendit(dev, 0); sendit(dev, 1); sendit(dev, 1); sendit(dev, 0);
940
941 return data;
942 }
943
944 static int
945 read_eeprom(struct device *dev)
946 {
947 unsigned short wrd;
948
949
950 wrd = ReadAWord(dev, 0x1aa);
951 if (wrd != htons(0x0080))
952 return -1;
953 nic_data.NodeID[0] = wrd & 0xff;
954 nic_data.NodeID[1] = wrd >> 8;
955
956 wrd = ReadAWord(dev, 0x1ab);
957 if ((wrd & 0xff) != 0xc8)
958 return -1;
959 nic_data.NodeID[2] = wrd & 0xff;
960 nic_data.NodeID[3] = wrd >> 8;
961
962 wrd = ReadAWord(dev, 0x1ac);
963 nic_data.NodeID[4] = wrd & 0xff;
964 nic_data.NodeID[5] = wrd >> 8;
965
966 wrd = ReadAWord(dev, 0x1ad);
967 nic_data.RAM_Size = (wrd >> 8);
968
969 wrd = ReadAWord(dev, 0x1ae);
970 nic_data.Model = (wrd & 0xff);
971
972 wrd = ReadAWord(dev, 0x1af);
973 nic_data.Media = (wrd & 0xff);
974
975 wrd = ReadAWord(dev, 0x1a8);
976 nic_data.SCR = (wrd >> 8);
977
978 return 0;
979 }
980
981
982
983
984
985
986 #ifdef MODULE
987 char kernel_version[] = UTS_RELEASE;
988 static char nullname[8] = "";
989 static struct device de620_dev = {
990 nullname, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, de620_probe };
991
992 int de620_io = DE620_IO;
993 int de620_irq = DE620_IRQ;
994
995 int
996 init_module(void)
997 {
998 de620_dev.base_addr = de620_io;
999 de620_dev.irq = de620_irq;
1000 if (register_netdev(&de620_dev) != 0)
1001 return -EIO;
1002 return 0;
1003 }
1004
1005 void
1006 cleanup_module(void)
1007 {
1008 unregister_netdev(&de620_dev);
1009 release_region(de620_dev.base_addr, 3);
1010 }
1011 #endif
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027