]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* hplance.c : the Linux/hp300/lance ethernet driver |
2 | * | |
3 | * Copyright (C) 05/1998 Peter Maydell <pmaydell@chiark.greenend.org.uk> | |
4 | * Based on the Sun Lance driver and the NetBSD HP Lance driver | |
5 | * Uses the generic 7990.c LANCE code. | |
6 | */ | |
7 | ||
8 | #include <linux/module.h> | |
9 | #include <linux/kernel.h> | |
10 | #include <linux/types.h> | |
11 | #include <linux/interrupt.h> | |
12 | #include <linux/ioport.h> | |
13 | #include <linux/slab.h> | |
14 | #include <linux/string.h> | |
15 | #include <linux/delay.h> | |
16 | #include <linux/init.h> | |
17 | #include <linux/errno.h> | |
18 | /* Used for the temporal inet entries and routing */ | |
19 | #include <linux/socket.h> | |
20 | #include <linux/route.h> | |
21 | #include <linux/dio.h> | |
22 | #include <linux/netdevice.h> | |
23 | #include <linux/etherdevice.h> | |
24 | #include <linux/skbuff.h> | |
25 | ||
26 | #include <asm/system.h> | |
27 | #include <asm/io.h> | |
28 | #include <asm/pgtable.h> | |
29 | ||
30 | #include "hplance.h" | |
31 | ||
32 | /* We have 16834 bytes of RAM for the init block and buffers. This places | |
33 | * an upper limit on the number of buffers we can use. NetBSD uses 8 Rx | |
34 | * buffers and 2 Tx buffers. | |
35 | */ | |
36 | #define LANCE_LOG_TX_BUFFERS 1 | |
37 | #define LANCE_LOG_RX_BUFFERS 3 | |
38 | ||
39 | #include "7990.h" /* use generic LANCE code */ | |
40 | ||
41 | /* Our private data structure */ | |
42 | struct hplance_private { | |
43 | struct lance_private lance; | |
44 | }; | |
45 | ||
46 | /* function prototypes... This is easy because all the grot is in the | |
47 | * generic LANCE support. All we have to support is probing for boards, | |
6aa20a22 | 48 | * plus board-specific init, open and close actions. |
1da177e4 LT |
49 | * Oh, and we need to tell the generic code how to read and write LANCE registers... |
50 | */ | |
51 | static int __devinit hplance_init_one(struct dio_dev *d, | |
52 | const struct dio_device_id *ent); | |
6aa20a22 | 53 | static void __devinit hplance_init(struct net_device *dev, |
1da177e4 LT |
54 | struct dio_dev *d); |
55 | static void __devexit hplance_remove_one(struct dio_dev *d); | |
56 | static void hplance_writerap(void *priv, unsigned short value); | |
57 | static void hplance_writerdp(void *priv, unsigned short value); | |
58 | static unsigned short hplance_readrdp(void *priv); | |
59 | static int hplance_open(struct net_device *dev); | |
60 | static int hplance_close(struct net_device *dev); | |
61 | ||
62 | static struct dio_device_id hplance_dio_tbl[] = { | |
63 | { DIO_ID_LAN }, | |
64 | { 0 } | |
65 | }; | |
66 | ||
67 | static struct dio_driver hplance_driver = { | |
68 | .name = "hplance", | |
69 | .id_table = hplance_dio_tbl, | |
70 | .probe = hplance_init_one, | |
71 | .remove = __devexit_p(hplance_remove_one), | |
72 | }; | |
73 | ||
74 | /* Find all the HP Lance boards and initialise them... */ | |
75 | static int __devinit hplance_init_one(struct dio_dev *d, | |
76 | const struct dio_device_id *ent) | |
77 | { | |
78 | struct net_device *dev; | |
79 | int err = -ENOMEM; | |
8e8858e9 | 80 | int i; |
1da177e4 LT |
81 | |
82 | dev = alloc_etherdev(sizeof(struct hplance_private)); | |
83 | if (!dev) | |
84 | goto out; | |
85 | ||
86 | err = -EBUSY; | |
87 | if (!request_mem_region(dio_resource_start(d), | |
88 | dio_resource_len(d), d->name)) | |
89 | goto out_free_netdev; | |
90 | ||
91 | hplance_init(dev, d); | |
92 | err = register_netdev(dev); | |
93 | if (err) | |
94 | goto out_release_mem_region; | |
95 | ||
96 | dio_set_drvdata(d, dev); | |
8e8858e9 KJ |
97 | |
98 | printk(KERN_INFO "%s: %s; select code %d, addr %2.2x", dev->name, d->name, d->scode, dev->dev_addr[0]); | |
99 | ||
100 | for (i=1; i<6; i++) { | |
101 | printk(":%2.2x", dev->dev_addr[i]); | |
102 | } | |
103 | ||
104 | printk(", irq %d\n", d->ipl); | |
105 | ||
1da177e4 LT |
106 | return 0; |
107 | ||
108 | out_release_mem_region: | |
109 | release_mem_region(dio_resource_start(d), dio_resource_len(d)); | |
110 | out_free_netdev: | |
111 | free_netdev(dev); | |
112 | out: | |
113 | return err; | |
114 | } | |
115 | ||
116 | static void __devexit hplance_remove_one(struct dio_dev *d) | |
117 | { | |
118 | struct net_device *dev = dio_get_drvdata(d); | |
119 | ||
120 | unregister_netdev(dev); | |
121 | release_mem_region(dio_resource_start(d), dio_resource_len(d)); | |
122 | free_netdev(dev); | |
123 | } | |
124 | ||
125 | /* Initialise a single lance board at the given DIO device */ | |
126 | static void __init hplance_init(struct net_device *dev, struct dio_dev *d) | |
127 | { | |
128 | unsigned long va = (d->resource.start + DIO_VIRADDRBASE); | |
129 | struct hplance_private *lp; | |
130 | int i; | |
6aa20a22 | 131 | |
1da177e4 LT |
132 | /* reset the board */ |
133 | out_8(va+DIO_IDOFF, 0xff); | |
134 | udelay(100); /* ariba! ariba! udelay! udelay! */ | |
135 | ||
136 | /* Fill the dev fields */ | |
137 | dev->base_addr = va; | |
138 | dev->open = &hplance_open; | |
139 | dev->stop = &hplance_close; | |
140 | #ifdef CONFIG_NET_POLL_CONTROLLER | |
141 | dev->poll_controller = lance_poll; | |
142 | #endif | |
143 | dev->hard_start_xmit = &lance_start_xmit; | |
1da177e4 LT |
144 | dev->set_multicast_list = &lance_set_multicast; |
145 | dev->dma = 0; | |
6aa20a22 | 146 | |
1da177e4 LT |
147 | for (i=0; i<6; i++) { |
148 | /* The NVRAM holds our ethernet address, one nibble per byte, | |
149 | * at bytes NVRAMOFF+1,3,5,7,9... | |
150 | */ | |
151 | dev->dev_addr[i] = ((in_8(va + HPLANCE_NVRAMOFF + i*4 + 1) & 0xF) << 4) | |
152 | | (in_8(va + HPLANCE_NVRAMOFF + i*4 + 3) & 0xF); | |
1da177e4 | 153 | } |
6aa20a22 | 154 | |
1da177e4 LT |
155 | lp = netdev_priv(dev); |
156 | lp->lance.name = (char*)d->name; /* discards const, shut up gcc */ | |
157 | lp->lance.base = va; | |
158 | lp->lance.init_block = (struct lance_init_block *)(va + HPLANCE_MEMOFF); /* CPU addr */ | |
a5d361fc | 159 | lp->lance.lance_init_block = NULL; /* LANCE addr of same RAM */ |
1da177e4 LT |
160 | lp->lance.busmaster_regval = LE_C3_BSWP; /* we're bigendian */ |
161 | lp->lance.irq = d->ipl; | |
162 | lp->lance.writerap = hplance_writerap; | |
163 | lp->lance.writerdp = hplance_writerdp; | |
164 | lp->lance.readrdp = hplance_readrdp; | |
165 | lp->lance.lance_log_rx_bufs = LANCE_LOG_RX_BUFFERS; | |
166 | lp->lance.lance_log_tx_bufs = LANCE_LOG_TX_BUFFERS; | |
167 | lp->lance.rx_ring_mod_mask = RX_RING_MOD_MASK; | |
168 | lp->lance.tx_ring_mod_mask = TX_RING_MOD_MASK; | |
1da177e4 LT |
169 | } |
170 | ||
171 | /* This is disgusting. We have to check the DIO status register for ack every | |
172 | * time we read or write the LANCE registers. | |
173 | */ | |
174 | static void hplance_writerap(void *priv, unsigned short value) | |
175 | { | |
176 | struct lance_private *lp = (struct lance_private *)priv; | |
177 | do { | |
178 | out_be16(lp->base + HPLANCE_REGOFF + LANCE_RAP, value); | |
179 | } while ((in_8(lp->base + HPLANCE_STATUS) & LE_ACK) == 0); | |
180 | } | |
181 | ||
182 | static void hplance_writerdp(void *priv, unsigned short value) | |
183 | { | |
184 | struct lance_private *lp = (struct lance_private *)priv; | |
185 | do { | |
186 | out_be16(lp->base + HPLANCE_REGOFF + LANCE_RDP, value); | |
187 | } while ((in_8(lp->base + HPLANCE_STATUS) & LE_ACK) == 0); | |
188 | } | |
189 | ||
190 | static unsigned short hplance_readrdp(void *priv) | |
191 | { | |
192 | struct lance_private *lp = (struct lance_private *)priv; | |
193 | __u16 value; | |
194 | do { | |
195 | value = in_be16(lp->base + HPLANCE_REGOFF + LANCE_RDP); | |
196 | } while ((in_8(lp->base + HPLANCE_STATUS) & LE_ACK) == 0); | |
197 | return value; | |
198 | } | |
199 | ||
200 | static int hplance_open(struct net_device *dev) | |
201 | { | |
202 | int status; | |
203 | struct lance_private *lp = netdev_priv(dev); | |
6aa20a22 | 204 | |
1da177e4 LT |
205 | status = lance_open(dev); /* call generic lance open code */ |
206 | if (status) | |
207 | return status; | |
208 | /* enable interrupts at board level. */ | |
209 | out_8(lp->base + HPLANCE_STATUS, LE_IE); | |
210 | ||
211 | return 0; | |
212 | } | |
213 | ||
214 | static int hplance_close(struct net_device *dev) | |
215 | { | |
216 | struct lance_private *lp = netdev_priv(dev); | |
217 | ||
218 | out_8(lp->base + HPLANCE_STATUS, 0); /* disable interrupts at boardlevel */ | |
219 | lance_close(dev); | |
220 | return 0; | |
221 | } | |
222 | ||
0b114078 | 223 | static int __init hplance_init_module(void) |
1da177e4 | 224 | { |
e51c01b0 | 225 | return dio_register_driver(&hplance_driver); |
1da177e4 LT |
226 | } |
227 | ||
0b114078 | 228 | static void __exit hplance_cleanup_module(void) |
1da177e4 LT |
229 | { |
230 | dio_unregister_driver(&hplance_driver); | |
231 | } | |
232 | ||
233 | module_init(hplance_init_module); | |
234 | module_exit(hplance_cleanup_module); | |
235 | ||
236 | MODULE_LICENSE("GPL"); |