Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* ibmtr.c: A shared-memory IBM Token Ring 16/4 driver for linux |
2 | * | |
3 | * Written 1993 by Mark Swanson and Peter De Schrijver. | |
4 | * This software may be used and distributed according to the terms | |
5 | * of the GNU General Public License, incorporated herein by reference. | |
6 | * | |
7 | * This device driver should work with Any IBM Token Ring Card that does | |
8 | * not use DMA. | |
9 | * | |
10 | * I used Donald Becker's (becker@scyld.com) device driver work | |
11 | * as a base for most of my initial work. | |
12 | * | |
13 | * Changes by Peter De Schrijver | |
14 | * (Peter.Deschrijver@linux.cc.kuleuven.ac.be) : | |
15 | * | |
16 | * + changed name to ibmtr.c in anticipation of other tr boards. | |
17 | * + changed reset code and adapter open code. | |
18 | * + added SAP open code. | |
19 | * + a first attempt to write interrupt, transmit and receive routines. | |
20 | * | |
21 | * Changes by David W. Morris (dwm@shell.portal.com) : | |
22 | * 941003 dwm: - Restructure tok_probe for multiple adapters, devices. | |
23 | * + Add comments, misc reorg for clarity. | |
24 | * + Flatten interrupt handler levels. | |
25 | * | |
26 | * Changes by Farzad Farid (farzy@zen.via.ecp.fr) | |
27 | * and Pascal Andre (andre@chimay.via.ecp.fr) (March 9 1995) : | |
28 | * + multi ring support clean up. | |
29 | * + RFC1042 compliance enhanced. | |
30 | * | |
31 | * Changes by Pascal Andre (andre@chimay.via.ecp.fr) (September 7 1995) : | |
32 | * + bug correction in tr_tx | |
33 | * + removed redundant information display | |
34 | * + some code reworking | |
35 | * | |
36 | * Changes by Michel Lespinasse (walken@via.ecp.fr), | |
37 | * Yann Doussot (doussot@via.ecp.fr) and Pascal Andre (andre@via.ecp.fr) | |
38 | * (February 18, 1996) : | |
39 | * + modified shared memory and mmio access port the driver to | |
40 | * alpha platform (structure access -> readb/writeb) | |
41 | * | |
42 | * Changes by Steve Kipisz (bungy@ibm.net or kipisz@vnet.ibm.com) | |
43 | * (January 18 1996): | |
44 | * + swapped WWOR and WWCR in ibmtr.h | |
45 | * + moved some init code from tok_probe into trdev_init. The | |
46 | * PCMCIA code can call trdev_init to complete initializing | |
47 | * the driver. | |
48 | * + added -DPCMCIA to support PCMCIA | |
49 | * + detecting PCMCIA Card Removal in interrupt handler. If | |
50 | * ISRP is FF, then a PCMCIA card has been removed | |
51 | * 10/2000 Burt needed a new method to avoid crashing the OS | |
52 | * | |
53 | * Changes by Paul Norton (pnorton@cts.com) : | |
54 | * + restructured the READ.LOG logic to prevent the transmit SRB | |
55 | * from being rudely overwritten before the transmit cycle is | |
56 | * complete. (August 15 1996) | |
57 | * + completed multiple adapter support. (November 20 1996) | |
58 | * + implemented csum_partial_copy in tr_rx and increased receive | |
59 | * buffer size and count. Minor fixes. (March 15, 1997) | |
60 | * | |
61 | * Changes by Christopher Turcksin <wabbit@rtfc.demon.co.uk> | |
62 | * + Now compiles ok as a module again. | |
63 | * | |
64 | * Changes by Paul Norton (pnorton@ieee.org) : | |
65 | * + moved the header manipulation code in tr_tx and tr_rx to | |
66 | * net/802/tr.c. (July 12 1997) | |
67 | * + add retry and timeout on open if cable disconnected. (May 5 1998) | |
68 | * + lifted 2000 byte mtu limit. now depends on shared-RAM size. | |
69 | * May 25 1998) | |
70 | * + can't allocate 2k recv buff at 8k shared-RAM. (20 October 1998) | |
71 | * | |
72 | * Changes by Joel Sloan (jjs@c-me.com) : | |
73 | * + disable verbose debug messages by default - to enable verbose | |
74 | * debugging, edit the IBMTR_DEBUG_MESSAGES define below | |
75 | * | |
76 | * Changes by Mike Phillips <phillim@amtrak.com> : | |
77 | * + Added extra #ifdef's to work with new PCMCIA Token Ring Code. | |
78 | * The PCMCIA code now just sets up the card so it can be recognized | |
79 | * by ibmtr_probe. Also checks allocated memory vs. on-board memory | |
80 | * for correct figure to use. | |
81 | * | |
82 | * Changes by Tim Hockin (thockin@isunix.it.ilstu.edu) : | |
83 | * + added spinlocks for SMP sanity (10 March 1999) | |
84 | * | |
85 | * Changes by Jochen Friedrich to enable RFC1469 Option 2 multicasting | |
86 | * i.e. using functional address C0 00 00 04 00 00 to transmit and | |
87 | * receive multicast packets. | |
88 | * | |
89 | * Changes by Mike Sullivan (based on original sram patch by Dave Grothe | |
90 | * to support windowing into on adapter shared ram. | |
91 | * i.e. Use LANAID to setup a PnP configuration with 16K RAM. Paging | |
92 | * will shift this 16K window over the entire available shared RAM. | |
93 | * | |
94 | * Changes by Peter De Schrijver (p2@mind.be) : | |
95 | * + fixed a problem with PCMCIA card removal | |
96 | * | |
97 | * Change by Mike Sullivan et al.: | |
98 | * + added turbo card support. No need to use lanaid to configure | |
99 | * the adapter into isa compatiblity mode. | |
100 | * | |
101 | * Changes by Burt Silverman to allow the computer to behave nicely when | |
102 | * a cable is pulled or not in place, or a PCMCIA card is removed hot. | |
103 | */ | |
104 | ||
105 | /* change the define of IBMTR_DEBUG_MESSAGES to a nonzero value | |
106 | in the event that chatty debug messages are desired - jjs 12/30/98 */ | |
107 | ||
108 | #define IBMTR_DEBUG_MESSAGES 0 | |
109 | ||
110 | #include <linux/module.h> | |
111 | ||
112 | #ifdef PCMCIA /* required for ibmtr_cs.c to build */ | |
113 | #undef MODULE /* yes, really */ | |
114 | #undef ENABLE_PAGING | |
115 | #else | |
116 | #define ENABLE_PAGING 1 | |
117 | #endif | |
118 | ||
1da177e4 LT |
119 | /* changes the output format of driver initialization */ |
120 | #define TR_VERBOSE 0 | |
121 | ||
122 | /* some 95 OS send many non UI frame; this allow removing the warning */ | |
123 | #define TR_FILTERNONUI 1 | |
124 | ||
125 | #include <linux/ioport.h> | |
126 | #include <linux/netdevice.h> | |
127 | #include <linux/ip.h> | |
128 | #include <linux/trdevice.h> | |
129 | #include <linux/ibmtr.h> | |
130 | ||
131 | #include <net/checksum.h> | |
132 | ||
133 | #include <asm/io.h> | |
134 | ||
135 | #define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args) | |
136 | #define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args) | |
137 | ||
138 | /* version and credits */ | |
139 | #ifndef PCMCIA | |
6d2cdb4f | 140 | static char version[] __devinitdata = |
1da177e4 LT |
141 | "\nibmtr.c: v1.3.57 8/ 7/94 Peter De Schrijver and Mark Swanson\n" |
142 | " v2.1.125 10/20/98 Paul Norton <pnorton@ieee.org>\n" | |
143 | " v2.2.0 12/30/98 Joel Sloan <jjs@c-me.com>\n" | |
144 | " v2.2.1 02/08/00 Mike Sullivan <sullivam@us.ibm.com>\n" | |
145 | " v2.2.2 07/27/00 Burt Silverman <burts@us.ibm.com>\n" | |
146 | " v2.4.0 03/01/01 Mike Sullivan <sullivan@us.ibm.com>\n"; | |
147 | #endif | |
148 | ||
149 | /* this allows displaying full adapter information */ | |
150 | ||
de70b4c8 | 151 | static char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" }; |
1da177e4 LT |
152 | |
153 | static char pcchannelid[] __devinitdata = { | |
154 | 0x05, 0x00, 0x04, 0x09, | |
155 | 0x04, 0x03, 0x04, 0x0f, | |
156 | 0x03, 0x06, 0x03, 0x01, | |
157 | 0x03, 0x01, 0x03, 0x00, | |
158 | 0x03, 0x09, 0x03, 0x09, | |
159 | 0x03, 0x00, 0x02, 0x00 | |
160 | }; | |
161 | ||
162 | static char mcchannelid[] __devinitdata = { | |
163 | 0x04, 0x0d, 0x04, 0x01, | |
164 | 0x05, 0x02, 0x05, 0x03, | |
165 | 0x03, 0x06, 0x03, 0x03, | |
166 | 0x05, 0x08, 0x03, 0x04, | |
167 | 0x03, 0x05, 0x03, 0x01, | |
168 | 0x03, 0x08, 0x02, 0x00 | |
169 | }; | |
170 | ||
de70b4c8 | 171 | static char __devinit *adapter_def(char type) |
1da177e4 LT |
172 | { |
173 | switch (type) { | |
174 | case 0xF: return "PC Adapter | PC Adapter II | Adapter/A"; | |
175 | case 0xE: return "16/4 Adapter | 16/4 Adapter/A (long)"; | |
176 | case 0xD: return "16/4 Adapter/A (short) | 16/4 ISA-16 Adapter"; | |
177 | case 0xC: return "Auto 16/4 Adapter"; | |
178 | default: return "adapter (unknown type)"; | |
179 | }; | |
180 | }; | |
181 | ||
182 | #define TRC_INIT 0x01 /* Trace initialization & PROBEs */ | |
183 | #define TRC_INITV 0x02 /* verbose init trace points */ | |
de70b4c8 | 184 | static unsigned char ibmtr_debug_trace = 0; |
1da177e4 | 185 | |
1da177e4 LT |
186 | static int ibmtr_probe1(struct net_device *dev, int ioaddr); |
187 | static unsigned char get_sram_size(struct tok_info *adapt_info); | |
188 | static int trdev_init(struct net_device *dev); | |
189 | static int tok_open(struct net_device *dev); | |
190 | static int tok_init_card(struct net_device *dev); | |
de70b4c8 | 191 | static void tok_open_adapter(unsigned long dev_addr); |
1da177e4 LT |
192 | static void open_sap(unsigned char type, struct net_device *dev); |
193 | static void tok_set_multicast_list(struct net_device *dev); | |
194 | static int tok_send_packet(struct sk_buff *skb, struct net_device *dev); | |
195 | static int tok_close(struct net_device *dev); | |
7d12e780 | 196 | static irqreturn_t tok_interrupt(int irq, void *dev_id); |
1da177e4 LT |
197 | static void initial_tok_int(struct net_device *dev); |
198 | static void tr_tx(struct net_device *dev); | |
199 | static void tr_rx(struct net_device *dev); | |
de70b4c8 | 200 | static void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev); |
1da177e4 | 201 | static void tok_rerun(unsigned long dev_addr); |
de70b4c8 | 202 | static void ibmtr_readlog(struct net_device *dev); |
1da177e4 | 203 | static struct net_device_stats *tok_get_stats(struct net_device *dev); |
de70b4c8 | 204 | static int ibmtr_change_mtu(struct net_device *dev, int mtu); |
1da177e4 LT |
205 | static void find_turbo_adapters(int *iolist); |
206 | ||
207 | static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = { | |
208 | 0xa20, 0xa24, 0, 0, 0 | |
209 | }; | |
210 | static int __devinitdata turbo_io[IBMTR_MAX_ADAPTERS] = {0}; | |
211 | static int __devinitdata turbo_irq[IBMTR_MAX_ADAPTERS] = {0}; | |
212 | static int __devinitdata turbo_searched = 0; | |
213 | ||
214 | #ifndef PCMCIA | |
6d2cdb4f | 215 | static __u32 ibmtr_mem_base __devinitdata = 0xd0000; |
1da177e4 LT |
216 | #endif |
217 | ||
218 | static void __devinit PrtChanID(char *pcid, short stride) | |
219 | { | |
220 | short i, j; | |
221 | for (i = 0, j = 0; i < 24; i++, j += stride) | |
222 | printk("%1x", ((int) pcid[j]) & 0x0f); | |
223 | printk("\n"); | |
224 | } | |
225 | ||
226 | static void __devinit HWPrtChanID(void __iomem *pcid, short stride) | |
227 | { | |
228 | short i, j; | |
229 | for (i = 0, j = 0; i < 24; i++, j += stride) | |
230 | printk("%1x", ((int) readb(pcid + j)) & 0x0f); | |
231 | printk("\n"); | |
232 | } | |
233 | ||
234 | /* We have to ioremap every checked address, because isa_readb is | |
235 | * going away. | |
236 | */ | |
237 | ||
238 | static void __devinit find_turbo_adapters(int *iolist) | |
239 | { | |
240 | int ram_addr; | |
241 | int index=0; | |
242 | void __iomem *chanid; | |
243 | int found_turbo=0; | |
244 | unsigned char *tchanid, ctemp; | |
245 | int i, j; | |
246 | unsigned long jif; | |
247 | void __iomem *ram_mapped ; | |
248 | ||
249 | if (turbo_searched == 1) return; | |
250 | turbo_searched=1; | |
251 | for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) { | |
252 | ||
253 | __u32 intf_tbl=0; | |
254 | ||
255 | found_turbo=1; | |
256 | ram_mapped = ioremap((u32)ram_addr,0x1fff) ; | |
257 | if (ram_mapped==NULL) | |
258 | continue ; | |
259 | chanid=(CHANNEL_ID + ram_mapped); | |
260 | tchanid=pcchannelid; | |
261 | ctemp=readb(chanid) & 0x0f; | |
262 | if (ctemp != *tchanid) continue; | |
263 | for (i=2,j=1; i<=46; i=i+2,j++) { | |
264 | if ((readb(chanid+i) & 0x0f) != tchanid[j]){ | |
265 | found_turbo=0; | |
266 | break; | |
267 | } | |
268 | } | |
269 | if (!found_turbo) continue; | |
270 | ||
271 | writeb(0x90, ram_mapped+0x1E01); | |
272 | for(i=2; i<0x0f; i++) { | |
273 | writeb(0x00, ram_mapped+0x1E01+i); | |
274 | } | |
275 | writeb(0x00, ram_mapped+0x1E01); | |
276 | for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif);); | |
277 | intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN)); | |
278 | if (intf_tbl) { | |
279 | #if IBMTR_DEBUG_MESSAGES | |
280 | printk("ibmtr::find_turbo_adapters, Turbo found at " | |
281 | "ram_addr %x\n",ram_addr); | |
282 | printk("ibmtr::find_turbo_adapters, interface_table "); | |
283 | for(i=0; i<6; i++) { | |
284 | printk("%x:",readb(ram_addr+intf_tbl+i)); | |
285 | } | |
286 | printk("\n"); | |
287 | #endif | |
288 | turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4)); | |
289 | turbo_irq[index]=readb(ram_mapped+intf_tbl+3); | |
290 | outb(0, turbo_io[index] + ADAPTRESET); | |
291 | for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif);); | |
292 | outb(0, turbo_io[index] + ADAPTRESETREL); | |
293 | index++; | |
294 | continue; | |
295 | } | |
296 | #if IBMTR_DEBUG_MESSAGES | |
297 | printk("ibmtr::find_turbo_adapters, ibmtr card found at" | |
298 | " %x but not a Turbo model\n",ram_addr); | |
299 | #endif | |
300 | iounmap(ram_mapped) ; | |
301 | } /* for */ | |
302 | for(i=0; i<IBMTR_MAX_ADAPTERS; i++) { | |
303 | if(!turbo_io[i]) break; | |
304 | for (j=0; j<IBMTR_MAX_ADAPTERS; j++) { | |
305 | if ( iolist[j] && iolist[j] != turbo_io[i]) continue; | |
306 | iolist[j]=turbo_io[i]; | |
307 | break; | |
308 | } | |
309 | } | |
310 | } | |
311 | ||
312 | static void ibmtr_cleanup_card(struct net_device *dev) | |
313 | { | |
314 | if (dev->base_addr) { | |
315 | outb(0,dev->base_addr+ADAPTRESET); | |
316 | ||
3173c890 | 317 | schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */ |
1da177e4 LT |
318 | |
319 | outb(0,dev->base_addr+ADAPTRESETREL); | |
320 | } | |
321 | ||
322 | #ifndef PCMCIA | |
323 | free_irq(dev->irq, dev); | |
324 | release_region(dev->base_addr, IBMTR_IO_EXTENT); | |
325 | ||
326 | { | |
eda10531 | 327 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
328 | iounmap(ti->mmio); |
329 | iounmap(ti->sram_virt); | |
330 | } | |
331 | #endif | |
332 | } | |
333 | ||
1da177e4 LT |
334 | /**************************************************************************** |
335 | * ibmtr_probe(): Routine specified in the network device structure | |
336 | * to probe for an IBM Token Ring Adapter. Routine outline: | |
337 | * I. Interrogate hardware to determine if an adapter exists | |
338 | * and what the speeds and feeds are | |
339 | * II. Setup data structures to control execution based upon | |
340 | * adapter characteristics. | |
341 | * | |
342 | * We expect ibmtr_probe to be called once for each device entry | |
343 | * which references it. | |
344 | ****************************************************************************/ | |
345 | ||
abf0437b | 346 | static int __devinit ibmtr_probe(struct net_device *dev) |
1da177e4 LT |
347 | { |
348 | int i; | |
349 | int base_addr = dev->base_addr; | |
350 | ||
351 | if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */ | |
352 | return -ENXIO; | |
353 | if (base_addr > 0x1ff) { /* Check a single specified location. */ | |
354 | if (!ibmtr_probe1(dev, base_addr)) return 0; | |
355 | return -ENODEV; | |
356 | } | |
357 | find_turbo_adapters(ibmtr_portlist); | |
358 | for (i = 0; ibmtr_portlist[i]; i++) { | |
359 | int ioaddr = ibmtr_portlist[i]; | |
360 | ||
361 | if (!ibmtr_probe1(dev, ioaddr)) return 0; | |
362 | } | |
363 | return -ENODEV; | |
364 | } | |
365 | ||
abf0437b | 366 | int __devinit ibmtr_probe_card(struct net_device *dev) |
82c00b62 RB |
367 | { |
368 | int err = ibmtr_probe(dev); | |
369 | if (!err) { | |
370 | err = register_netdev(dev); | |
371 | if (err) | |
372 | ibmtr_cleanup_card(dev); | |
373 | } | |
374 | return err; | |
375 | } | |
376 | ||
1da177e4 LT |
377 | /*****************************************************************************/ |
378 | ||
379 | static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr) | |
380 | { | |
381 | ||
382 | unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0; | |
383 | void __iomem * t_mmio = NULL; | |
eda10531 | 384 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
385 | void __iomem *cd_chanid; |
386 | unsigned char *tchanid, ctemp; | |
387 | #ifndef PCMCIA | |
388 | unsigned char t_irq=0; | |
389 | unsigned long timeout; | |
390 | static int version_printed; | |
391 | #endif | |
392 | ||
393 | /* Query the adapter PIO base port which will return | |
394 | * indication of where MMIO was placed. We also have a | |
395 | * coded interrupt number. | |
396 | */ | |
397 | segment = inb(PIOaddr); | |
398 | if (segment < 0x40 || segment > 0xe0) { | |
399 | /* Out of range values so we'll assume non-existent IO device | |
400 | * but this is not necessarily a problem, esp if a turbo | |
401 | * adapter is being used. */ | |
402 | #if IBMTR_DEBUG_MESSAGES | |
403 | DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, " | |
404 | "Hardware Problem?\n",PIOaddr,segment); | |
405 | #endif | |
406 | return -ENODEV; | |
407 | } | |
408 | /* | |
409 | * Compute the linear base address of the MMIO area | |
410 | * as LINUX doesn't care about segments | |
411 | */ | |
412 | t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048); | |
413 | if (!t_mmio) { | |
414 | DPRINTK("Cannot remap mmiobase memory area") ; | |
415 | return -ENODEV ; | |
416 | } | |
417 | intr = segment & 0x03; /* low bits is coded interrupt # */ | |
418 | if (ibmtr_debug_trace & TRC_INIT) | |
419 | DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n" | |
420 | , PIOaddr, (int) segment, t_mmio, (int) intr); | |
421 | ||
422 | /* | |
423 | * Now we will compare expected 'channelid' strings with | |
424 | * what we is there to learn of ISA/MCA or not TR card | |
425 | */ | |
426 | #ifdef PCMCIA | |
427 | iounmap(t_mmio); | |
428 | t_mmio = ti->mmio; /*BMS to get virtual address */ | |
429 | irq = ti->irq; /*BMS to display the irq! */ | |
430 | #endif | |
431 | cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */ | |
432 | tchanid = pcchannelid; | |
433 | cardpresent = TR_ISA; /* try ISA */ | |
434 | ||
435 | /* Suboptimize knowing first byte different */ | |
436 | ctemp = readb(cd_chanid) & 0x0f; | |
437 | if (ctemp != *tchanid) { /* NOT ISA card, try MCA */ | |
438 | tchanid = mcchannelid; | |
439 | cardpresent = TR_MCA; | |
440 | if (ctemp != *tchanid) /* Neither ISA nor MCA */ | |
441 | cardpresent = NOTOK; | |
442 | } | |
443 | if (cardpresent != NOTOK) { | |
444 | /* Know presumed type, try rest of ID */ | |
445 | for (i = 2, j = 1; i <= 46; i = i + 2, j++) { | |
446 | if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue; | |
447 | /* match failed, not TR card */ | |
448 | cardpresent = NOTOK; | |
449 | break; | |
450 | } | |
451 | } | |
452 | /* | |
453 | * If we have an ISA board check for the ISA P&P version, | |
454 | * as it has different IRQ settings | |
455 | */ | |
456 | if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e)) | |
457 | cardpresent = TR_ISAPNP; | |
458 | if (cardpresent == NOTOK) { /* "channel_id" did not match, report */ | |
459 | if (!(ibmtr_debug_trace & TRC_INIT)) { | |
460 | #ifndef PCMCIA | |
461 | iounmap(t_mmio); | |
462 | #endif | |
463 | return -ENODEV; | |
464 | } | |
465 | DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n", | |
466 | PIOaddr); | |
467 | DPRINTK("Expected for ISA: "); | |
468 | PrtChanID(pcchannelid, 1); | |
469 | DPRINTK(" found: "); | |
470 | /* BMS Note that this can be misleading, when hardware is flaky, because you | |
471 | are reading it a second time here. So with my flaky hardware, I'll see my- | |
472 | self in this block, with the HW ID matching the ISA ID exactly! */ | |
473 | HWPrtChanID(cd_chanid, 2); | |
474 | DPRINTK("Expected for MCA: "); | |
475 | PrtChanID(mcchannelid, 1); | |
476 | } | |
477 | /* Now, setup some of the pl0 buffers for this driver.. */ | |
478 | /* If called from PCMCIA, it is already set up, so no need to | |
479 | waste the memory, just use the existing structure */ | |
480 | #ifndef PCMCIA | |
481 | ti->mmio = t_mmio; | |
482 | for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) { | |
483 | if (turbo_io[i] != PIOaddr) | |
484 | continue; | |
485 | #if IBMTR_DEBUG_MESSAGES | |
486 | printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n", | |
487 | PIOaddr); | |
488 | #endif | |
489 | ti->turbo = 1; | |
490 | t_irq = turbo_irq[i]; | |
491 | } | |
492 | #endif /* !PCMCIA */ | |
493 | ti->readlog_pending = 0; | |
494 | init_waitqueue_head(&ti->wait_for_reset); | |
495 | ||
496 | /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP | |
497 | * depending which card is inserted. */ | |
498 | ||
499 | #ifndef PCMCIA | |
500 | switch (cardpresent) { | |
501 | case TR_ISA: | |
502 | if (intr == 0) irq = 9; /* irq2 really is irq9 */ | |
503 | if (intr == 1) irq = 3; | |
504 | if (intr == 2) irq = 6; | |
505 | if (intr == 3) irq = 7; | |
506 | ti->adapter_int_enable = PIOaddr + ADAPTINTREL; | |
507 | break; | |
508 | case TR_MCA: | |
509 | if (intr == 0) irq = 9; | |
510 | if (intr == 1) irq = 3; | |
511 | if (intr == 2) irq = 10; | |
512 | if (intr == 3) irq = 11; | |
513 | ti->global_int_enable = 0; | |
514 | ti->adapter_int_enable = 0; | |
515 | ti->sram_phys=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12; | |
516 | break; | |
517 | case TR_ISAPNP: | |
518 | if (!t_irq) { | |
519 | if (intr == 0) irq = 9; | |
520 | if (intr == 1) irq = 3; | |
521 | if (intr == 2) irq = 10; | |
522 | if (intr == 3) irq = 11; | |
523 | } else | |
524 | irq=t_irq; | |
525 | timeout = jiffies + TR_SPIN_INTERVAL; | |
526 | while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){ | |
527 | if (!time_after(jiffies, timeout)) continue; | |
528 | DPRINTK( "Hardware timeout during initialization.\n"); | |
529 | iounmap(t_mmio); | |
1da177e4 LT |
530 | return -ENODEV; |
531 | } | |
532 | ti->sram_phys = | |
533 | ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12); | |
534 | ti->adapter_int_enable = PIOaddr + ADAPTINTREL; | |
535 | break; | |
536 | } /*end switch (cardpresent) */ | |
537 | #endif /*not PCMCIA */ | |
538 | ||
539 | if (ibmtr_debug_trace & TRC_INIT) { /* just report int */ | |
540 | DPRINTK("irq=%d", irq); | |
541 | printk(", sram_phys=0x%x", ti->sram_phys); | |
542 | if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */ | |
543 | DPRINTK(", ti->mmio=%p", ti->mmio); | |
544 | printk(", segment=%02X", segment); | |
545 | } | |
546 | printk(".\n"); | |
547 | } | |
548 | ||
549 | /* Get hw address of token ring card */ | |
550 | j = 0; | |
551 | for (i = 0; i < 0x18; i = i + 2) { | |
552 | /* technical reference states to do this */ | |
553 | temp = readb(ti->mmio + AIP + i) & 0x0f; | |
554 | ti->hw_address[j] = temp; | |
555 | if (j & 1) | |
556 | dev->dev_addr[(j / 2)] = | |
557 | ti->hw_address[j]+ (ti->hw_address[j - 1] << 4); | |
558 | ++j; | |
559 | } | |
560 | /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */ | |
561 | ti->adapter_type = readb(ti->mmio + AIPADAPTYPE); | |
562 | ||
563 | /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */ | |
564 | ti->data_rate = readb(ti->mmio + AIPDATARATE); | |
565 | ||
566 | /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */ | |
567 | ti->token_release = readb(ti->mmio + AIPEARLYTOKEN); | |
568 | ||
569 | /* How much shared RAM is on adapter ? */ | |
570 | if (ti->turbo) { | |
571 | ti->avail_shared_ram=127; | |
572 | } else { | |
573 | ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */ | |
574 | } | |
575 | /* We need to set or do a bunch of work here based on previous results*/ | |
576 | /* Support paging? What sizes?: F=no, E=16k, D=32k, C=16 & 32k */ | |
577 | ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE); | |
578 | ||
579 | /* Available DHB 4Mb size: F=2048, E=4096, D=4464 */ | |
580 | switch (readb(ti->mmio + AIP4MBDHB)) { | |
581 | case 0xe: ti->dhb_size4mb = 4096; break; | |
582 | case 0xd: ti->dhb_size4mb = 4464; break; | |
583 | default: ti->dhb_size4mb = 2048; break; | |
584 | } | |
585 | ||
586 | /* Available DHB 16Mb size: F=2048, E=4096, D=8192, C=16384, B=17960 */ | |
587 | switch (readb(ti->mmio + AIP16MBDHB)) { | |
588 | case 0xe: ti->dhb_size16mb = 4096; break; | |
589 | case 0xd: ti->dhb_size16mb = 8192; break; | |
590 | case 0xc: ti->dhb_size16mb = 16384; break; | |
591 | case 0xb: ti->dhb_size16mb = 17960; break; | |
592 | default: ti->dhb_size16mb = 2048; break; | |
593 | } | |
594 | ||
595 | /* We must figure out how much shared memory space this adapter | |
596 | * will occupy so that if there are two adapters we can fit both | |
597 | * in. Given a choice, we will limit this adapter to 32K. The | |
598 | * maximum space will will use for two adapters is 64K so if the | |
599 | * adapter we are working on demands 64K (it also doesn't support | |
600 | * paging), then only one adapter can be supported. | |
601 | */ | |
602 | ||
603 | /* | |
604 | * determine how much of total RAM is mapped into PC space | |
605 | */ | |
606 | ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/ | |
607 | 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4); | |
608 | ti->page_mask = 0; | |
609 | if (ti->turbo) ti->page_mask=0xf0; | |
610 | else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */ | |
611 | else { | |
612 | #ifdef ENABLE_PAGING | |
613 | unsigned char pg_size = 0; | |
614 | /* BMS: page size: PCMCIA, use configuration register; | |
615 | ISAPNP, use LANAIDC config tool from www.ibm.com */ | |
616 | switch (ti->shared_ram_paging) { | |
617 | case 0xf: | |
618 | break; | |
619 | case 0xe: | |
620 | ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0; | |
621 | pg_size = 32; /* 16KB page size */ | |
622 | break; | |
623 | case 0xd: | |
624 | ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0; | |
625 | pg_size = 64; /* 32KB page size */ | |
626 | break; | |
627 | case 0xc: | |
628 | switch (ti->mapped_ram_size) { | |
629 | case 32: | |
630 | ti->page_mask = 0xc0; | |
631 | pg_size = 32; | |
632 | break; | |
633 | case 64: | |
634 | ti->page_mask = 0x80; | |
635 | pg_size = 64; | |
636 | break; | |
637 | } | |
638 | break; | |
639 | default: | |
640 | DPRINTK("Unknown shared ram paging info %01X\n", | |
641 | ti->shared_ram_paging); | |
642 | iounmap(t_mmio); | |
1da177e4 LT |
643 | return -ENODEV; |
644 | break; | |
645 | } /*end switch shared_ram_paging */ | |
646 | ||
647 | if (ibmtr_debug_trace & TRC_INIT) | |
648 | DPRINTK("Shared RAM paging code: %02X, " | |
649 | "mapped RAM size: %dK, shared RAM size: %dK, " | |
650 | "page mask: %02X\n:", | |
651 | ti->shared_ram_paging, ti->mapped_ram_size / 2, | |
652 | ti->avail_shared_ram / 2, ti->page_mask); | |
653 | #endif /*ENABLE_PAGING */ | |
654 | } | |
655 | ||
656 | #ifndef PCMCIA | |
657 | /* finish figuring the shared RAM address */ | |
658 | if (cardpresent == TR_ISA) { | |
659 | static __u32 ram_bndry_mask[] = | |
660 | { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 }; | |
661 | __u32 new_base, rrr_32, chk_base, rbm; | |
662 | ||
663 | rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03; | |
664 | rbm = ram_bndry_mask[rrr_32]; | |
665 | new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */ | |
666 | chk_base = new_base + (ti->mapped_ram_size << 9); | |
667 | if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) { | |
668 | DPRINTK("Shared RAM for this adapter (%05x) exceeds " | |
669 | "driver limit (%05x), adapter not started.\n", | |
670 | chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE); | |
671 | iounmap(t_mmio); | |
1da177e4 LT |
672 | return -ENODEV; |
673 | } else { /* seems cool, record what we have figured out */ | |
674 | ti->sram_base = new_base >> 12; | |
675 | ibmtr_mem_base = chk_base; | |
676 | } | |
677 | } | |
678 | else ti->sram_base = ti->sram_phys >> 12; | |
679 | ||
680 | /* The PCMCIA has already got the interrupt line and the io port, | |
681 | so no chance of anybody else getting it - MLP */ | |
682 | if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) { | |
683 | DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n", | |
684 | irq); | |
685 | iounmap(t_mmio); | |
1da177e4 LT |
686 | return -ENODEV; |
687 | } | |
688 | /*?? Now, allocate some of the PIO PORTs for this driver.. */ | |
689 | /* record PIOaddr range as busy */ | |
690 | if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) { | |
691 | DPRINTK("Could not grab PIO range. Halting driver.\n"); | |
692 | free_irq(dev->irq, dev); | |
693 | iounmap(t_mmio); | |
1da177e4 LT |
694 | return -EBUSY; |
695 | } | |
696 | ||
697 | if (!version_printed++) { | |
698 | printk(version); | |
699 | } | |
700 | #endif /* !PCMCIA */ | |
701 | DPRINTK("%s %s found\n", | |
702 | channel_def[cardpresent - 1], adapter_def(ti->adapter_type)); | |
703 | DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n", | |
704 | irq, PIOaddr, ti->mapped_ram_size / 2); | |
e174961c | 705 | DPRINTK("Hardware address : %pM\n", dev->dev_addr); |
1da177e4 LT |
706 | if (ti->page_mask) |
707 | DPRINTK("Shared RAM paging enabled. " | |
708 | "Page size: %uK Shared Ram size %dK\n", | |
709 | ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2); | |
710 | else | |
711 | DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n", | |
712 | ti->page_mask); | |
713 | ||
714 | /* Calculate the maximum DHB we can use */ | |
715 | /* two cases where avail_shared_ram doesn't equal mapped_ram_size: | |
716 | 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical) | |
717 | 2. user has configured adapter for less than avail_shared_ram | |
718 | but is not using paging (she should use paging, I believe) | |
719 | */ | |
720 | if (!ti->page_mask) { | |
721 | ti->avail_shared_ram= | |
722 | min(ti->mapped_ram_size,ti->avail_shared_ram); | |
723 | } | |
724 | ||
725 | switch (ti->avail_shared_ram) { | |
726 | case 16: /* 8KB shared RAM */ | |
727 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048); | |
728 | ti->rbuf_len4 = 1032; | |
729 | ti->rbuf_cnt4=2; | |
730 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048); | |
731 | ti->rbuf_len16 = 1032; | |
732 | ti->rbuf_cnt16=2; | |
733 | break; | |
734 | case 32: /* 16KB shared RAM */ | |
735 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464); | |
736 | ti->rbuf_len4 = 1032; | |
737 | ti->rbuf_cnt4=4; | |
738 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096); | |
739 | ti->rbuf_len16 = 1032; /*1024 usable */ | |
740 | ti->rbuf_cnt16=4; | |
741 | break; | |
742 | case 64: /* 32KB shared RAM */ | |
743 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464); | |
744 | ti->rbuf_len4 = 1032; | |
745 | ti->rbuf_cnt4=6; | |
746 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240); | |
747 | ti->rbuf_len16 = 1032; | |
748 | ti->rbuf_cnt16=6; | |
749 | break; | |
750 | case 127: /* 63.5KB shared RAM */ | |
751 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464); | |
752 | ti->rbuf_len4 = 1032; | |
753 | ti->rbuf_cnt4=6; | |
754 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384); | |
755 | ti->rbuf_len16 = 1032; | |
756 | ti->rbuf_cnt16=16; | |
757 | break; | |
758 | case 128: /* 64KB shared RAM */ | |
759 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464); | |
760 | ti->rbuf_len4 = 1032; | |
761 | ti->rbuf_cnt4=6; | |
762 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960); | |
763 | ti->rbuf_len16 = 1032; | |
764 | ti->rbuf_cnt16=16; | |
765 | break; | |
766 | default: | |
767 | ti->dhb_size4mb = 2048; | |
768 | ti->rbuf_len4 = 1032; | |
769 | ti->rbuf_cnt4=2; | |
770 | ti->dhb_size16mb = 2048; | |
771 | ti->rbuf_len16 = 1032; | |
772 | ti->rbuf_cnt16=2; | |
773 | break; | |
774 | } | |
775 | /* this formula is not smart enough for the paging case | |
776 | ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE - | |
777 | ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH - | |
778 | DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB - | |
779 | SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>; | |
780 | */ | |
781 | ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN; | |
782 | ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN; | |
783 | /*BMS assuming 18 bytes of Routing Information (usually works) */ | |
784 | DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n", | |
785 | ti->maxmtu16, ti->maxmtu4); | |
786 | ||
787 | dev->base_addr = PIOaddr; /* set the value for device */ | |
788 | dev->mem_start = ti->sram_base << 12; | |
789 | dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1; | |
790 | trdev_init(dev); | |
791 | return 0; /* Return 0 to indicate we have found a Token Ring card. */ | |
792 | } /*ibmtr_probe1() */ | |
793 | ||
794 | /*****************************************************************************/ | |
795 | ||
796 | /* query the adapter for the size of shared RAM */ | |
797 | /* the function returns the RAM size in units of 512 bytes */ | |
798 | ||
799 | static unsigned char __devinit get_sram_size(struct tok_info *adapt_info) | |
800 | { | |
801 | unsigned char avail_sram_code; | |
802 | static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 }; | |
803 | /* Adapter gives | |
804 | 'F' -- use RRR bits 3,2 | |
805 | 'E' -- 8kb 'D' -- 16kb | |
806 | 'C' -- 32kb 'A' -- 64KB | |
807 | 'B' - 64KB less 512 bytes at top | |
808 | (WARNING ... must zero top bytes in INIT */ | |
809 | ||
810 | avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM); | |
811 | if (avail_sram_code) return size_code[avail_sram_code]; | |
812 | else /* for code 'F', must compute size from RRR(3,2) bits */ | |
813 | return 1 << | |
814 | ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4); | |
815 | } | |
816 | ||
817 | /*****************************************************************************/ | |
818 | ||
819 | static int __devinit trdev_init(struct net_device *dev) | |
820 | { | |
eda10531 | 821 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
822 | |
823 | SET_PAGE(ti->srb_page); | |
824 | ti->open_failure = NO ; | |
825 | dev->open = tok_open; | |
826 | dev->stop = tok_close; | |
827 | dev->hard_start_xmit = tok_send_packet; | |
828 | dev->get_stats = tok_get_stats; | |
829 | dev->set_multicast_list = tok_set_multicast_list; | |
830 | dev->change_mtu = ibmtr_change_mtu; | |
831 | ||
832 | return 0; | |
833 | } | |
834 | ||
835 | /*****************************************************************************/ | |
836 | ||
837 | static int tok_init_card(struct net_device *dev) | |
838 | { | |
839 | struct tok_info *ti; | |
840 | short PIOaddr; | |
841 | unsigned long i; | |
842 | ||
843 | PIOaddr = dev->base_addr; | |
eda10531 | 844 | ti = netdev_priv(dev); |
1da177e4 LT |
845 | /* Special processing for first interrupt after reset */ |
846 | ti->do_tok_int = FIRST_INT; | |
847 | /* Reset adapter */ | |
848 | writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN); | |
849 | outb(0, PIOaddr + ADAPTRESET); | |
850 | ||
3173c890 | 851 | schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */ |
1da177e4 LT |
852 | |
853 | outb(0, PIOaddr + ADAPTRESETREL); | |
854 | #ifdef ENABLE_PAGING | |
855 | if (ti->page_mask) | |
856 | writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN); | |
857 | #endif | |
858 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
859 | i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ); | |
860 | return i? 0 : -EAGAIN; | |
861 | } | |
862 | ||
863 | /*****************************************************************************/ | |
864 | static int tok_open(struct net_device *dev) | |
865 | { | |
eda10531 | 866 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
867 | int i; |
868 | ||
869 | /*the case we were left in a failure state during a previous open */ | |
870 | if (ti->open_failure == YES) { | |
871 | DPRINTK("Last time you were disconnected, how about now?\n"); | |
872 | printk("You can't insert with an ICS connector half-cocked.\n"); | |
873 | } | |
874 | ||
875 | ti->open_status = CLOSED; /* CLOSED or OPEN */ | |
876 | ti->sap_status = CLOSED; /* CLOSED or OPEN */ | |
877 | ti->open_failure = NO; /* NO or YES */ | |
878 | ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */ | |
1da177e4 LT |
879 | |
880 | ti->sram_phys &= ~1; /* to reverse what we do in tok_close */ | |
881 | /* init the spinlock */ | |
882 | spin_lock_init(&ti->lock); | |
883 | init_timer(&ti->tr_timer); | |
884 | ||
885 | i = tok_init_card(dev); | |
886 | if (i) return i; | |
887 | ||
888 | while (1){ | |
889 | tok_open_adapter((unsigned long) dev); | |
890 | i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ); | |
891 | /* sig catch: estimate opening adapter takes more than .5 sec*/ | |
892 | if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */ | |
893 | if (i==0) break; | |
894 | if (ti->open_status == OPEN && ti->sap_status==OPEN) { | |
895 | netif_start_queue(dev); | |
896 | DPRINTK("Adapter is up and running\n"); | |
897 | return 0; | |
898 | } | |
3173c890 NA |
899 | i=schedule_timeout_interruptible(TR_RETRY_INTERVAL); |
900 | /* wait 30 seconds */ | |
1da177e4 LT |
901 | if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */ |
902 | } | |
903 | outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/ | |
904 | DPRINTK("TERMINATED via signal\n"); /*BMS useful */ | |
905 | return -EAGAIN; | |
906 | } | |
907 | ||
908 | /*****************************************************************************/ | |
909 | ||
910 | #define COMMAND_OFST 0 | |
911 | #define OPEN_OPTIONS_OFST 8 | |
912 | #define NUM_RCV_BUF_OFST 24 | |
913 | #define RCV_BUF_LEN_OFST 26 | |
914 | #define DHB_LENGTH_OFST 28 | |
915 | #define NUM_DHB_OFST 30 | |
916 | #define DLC_MAX_SAP_OFST 32 | |
917 | #define DLC_MAX_STA_OFST 33 | |
918 | ||
de70b4c8 | 919 | static void tok_open_adapter(unsigned long dev_addr) |
1da177e4 LT |
920 | { |
921 | struct net_device *dev = (struct net_device *) dev_addr; | |
922 | struct tok_info *ti; | |
923 | int i; | |
924 | ||
eda10531 | 925 | ti = netdev_priv(dev); |
1da177e4 LT |
926 | SET_PAGE(ti->init_srb_page); |
927 | writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD); | |
928 | for (i = 0; i < sizeof(struct dir_open_adapter); i++) | |
929 | writeb(0, ti->init_srb + i); | |
930 | writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST); | |
931 | writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST); | |
932 | if (ti->ring_speed == 16) { | |
933 | writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST); | |
934 | writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST); | |
935 | writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST); | |
936 | } else { | |
937 | writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST); | |
938 | writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST); | |
939 | writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST); | |
940 | } | |
941 | writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST); | |
942 | writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST); | |
943 | writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST); | |
944 | ti->srb = ti->init_srb; /* We use this one in the interrupt handler */ | |
945 | ti->srb_page = ti->init_srb_page; | |
946 | DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n", | |
947 | readb(ti->init_srb + NUM_DHB_OFST), | |
948 | ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)), | |
949 | ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)), | |
950 | ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST))); | |
951 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
952 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
953 | } | |
954 | ||
955 | /*****************************************************************************/ | |
956 | ||
957 | static void open_sap(unsigned char type, struct net_device *dev) | |
958 | { | |
959 | int i; | |
eda10531 | 960 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
961 | |
962 | SET_PAGE(ti->srb_page); | |
963 | for (i = 0; i < sizeof(struct dlc_open_sap); i++) | |
964 | writeb(0, ti->srb + i); | |
965 | ||
966 | #define MAX_I_FIELD_OFST 14 | |
967 | #define SAP_VALUE_OFST 16 | |
968 | #define SAP_OPTIONS_OFST 17 | |
969 | #define STATION_COUNT_OFST 18 | |
970 | ||
971 | writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST); | |
972 | writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST); | |
973 | writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST); | |
974 | writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST); | |
975 | writeb(type, ti->srb + SAP_VALUE_OFST); | |
976 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
977 | } | |
978 | ||
979 | ||
980 | /*****************************************************************************/ | |
981 | ||
982 | static void tok_set_multicast_list(struct net_device *dev) | |
983 | { | |
eda10531 | 984 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
985 | struct dev_mc_list *mclist; |
986 | unsigned char address[4]; | |
987 | ||
988 | int i; | |
989 | ||
990 | /*BMS the next line is CRUCIAL or you may be sad when you */ | |
991 | /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/ | |
992 | if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return; | |
993 | address[0] = address[1] = address[2] = address[3] = 0; | |
994 | mclist = dev->mc_list; | |
995 | for (i = 0; i < dev->mc_count; i++) { | |
996 | address[0] |= mclist->dmi_addr[2]; | |
997 | address[1] |= mclist->dmi_addr[3]; | |
998 | address[2] |= mclist->dmi_addr[4]; | |
999 | address[3] |= mclist->dmi_addr[5]; | |
1000 | mclist = mclist->next; | |
1001 | } | |
1002 | SET_PAGE(ti->srb_page); | |
1003 | for (i = 0; i < sizeof(struct srb_set_funct_addr); i++) | |
1004 | writeb(0, ti->srb + i); | |
1005 | ||
1006 | #define FUNCT_ADDRESS_OFST 6 | |
1007 | ||
1008 | writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST); | |
1009 | for (i = 0; i < 4; i++) | |
1010 | writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i); | |
1011 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1012 | #if TR_VERBOSE | |
1013 | DPRINTK("Setting functional address: "); | |
1014 | for (i=0;i<4;i++) printk("%02X ", address[i]); | |
1015 | printk("\n"); | |
1016 | #endif | |
1017 | } | |
1018 | ||
1019 | /*****************************************************************************/ | |
1020 | ||
1021 | #define STATION_ID_OFST 4 | |
1022 | ||
1023 | static int tok_send_packet(struct sk_buff *skb, struct net_device *dev) | |
1024 | { | |
1025 | struct tok_info *ti; | |
1026 | unsigned long flags; | |
eda10531 | 1027 | ti = netdev_priv(dev); |
1da177e4 LT |
1028 | |
1029 | netif_stop_queue(dev); | |
1030 | ||
1031 | /* lock against other CPUs */ | |
1032 | spin_lock_irqsave(&(ti->lock), flags); | |
1033 | ||
1034 | /* Save skb; we'll need it when the adapter asks for the data */ | |
1035 | ti->current_skb = skb; | |
1036 | SET_PAGE(ti->srb_page); | |
1037 | writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST); | |
1038 | writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST); | |
1039 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1040 | spin_unlock_irqrestore(&(ti->lock), flags); | |
1041 | dev->trans_start = jiffies; | |
1042 | return 0; | |
1043 | } | |
1044 | ||
1045 | /*****************************************************************************/ | |
1046 | ||
1047 | static int tok_close(struct net_device *dev) | |
1048 | { | |
eda10531 | 1049 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1050 | |
1051 | /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */ | |
1052 | /* unloading the module from memory, and then if a timer pops, ouch */ | |
1053 | del_timer_sync(&ti->tr_timer); | |
1054 | outb(0, dev->base_addr + ADAPTRESET); | |
1055 | ti->sram_phys |= 1; | |
1056 | ti->open_status = CLOSED; | |
1057 | ||
1058 | netif_stop_queue(dev); | |
1059 | DPRINTK("Adapter is closed.\n"); | |
1060 | return 0; | |
1061 | } | |
1062 | ||
1063 | /*****************************************************************************/ | |
1064 | ||
1065 | #define RETCODE_OFST 2 | |
1066 | #define OPEN_ERROR_CODE_OFST 6 | |
1067 | #define ASB_ADDRESS_OFST 8 | |
1068 | #define SRB_ADDRESS_OFST 10 | |
1069 | #define ARB_ADDRESS_OFST 12 | |
1070 | #define SSB_ADDRESS_OFST 14 | |
1071 | ||
1072 | static char *printphase[]= {"Lobe media test","Physical insertion", | |
1073 | "Address verification","Roll call poll","Request Parameters"}; | |
1074 | static char *printerror[]={"Function failure","Signal loss","Reserved", | |
1075 | "Frequency error","Timeout","Ring failure","Ring beaconing", | |
1076 | "Duplicate node address", | |
1077 | "Parameter request-retry count exceeded","Remove received", | |
1078 | "IMPL force received","Duplicate modifier", | |
1079 | "No monitor detected","Monitor contention failed for RPL"}; | |
1080 | ||
1081 | static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page) | |
1082 | { | |
1083 | if (ti->page_mask) { | |
1084 | *page = (index >> 8) & ti->page_mask; | |
1085 | index &= ~(ti->page_mask << 8); | |
1086 | } | |
1087 | return ti->sram_virt + index; | |
1088 | } | |
1089 | ||
de70b4c8 | 1090 | static void dir_open_adapter (struct net_device *dev) |
1da177e4 | 1091 | { |
eda10531 | 1092 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1093 | unsigned char ret_code; |
1094 | __u16 err; | |
1095 | ||
1096 | ti->srb = map_address(ti, | |
1097 | ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)), | |
1098 | &ti->srb_page); | |
1099 | ti->ssb = map_address(ti, | |
1100 | ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)), | |
1101 | &ti->ssb_page); | |
1102 | ti->arb = map_address(ti, | |
1103 | ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)), | |
1104 | &ti->arb_page); | |
1105 | ti->asb = map_address(ti, | |
1106 | ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)), | |
1107 | &ti->asb_page); | |
1108 | ti->current_skb = NULL; | |
1109 | ret_code = readb(ti->init_srb + RETCODE_OFST); | |
1110 | err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST)); | |
1111 | if (!ret_code) { | |
1112 | ti->open_status = OPEN; /* TR adapter is now available */ | |
1113 | if (ti->open_mode == AUTOMATIC) { | |
1114 | DPRINTK("Adapter reopened.\n"); | |
1115 | } | |
1116 | writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD); | |
1117 | open_sap(EXTENDED_SAP, dev); | |
1118 | return; | |
1119 | } | |
1120 | ti->open_failure = YES; | |
1121 | if (ret_code == 7){ | |
1122 | if (err == 0x24) { | |
1123 | if (!ti->auto_speedsave) { | |
1124 | DPRINTK("Open failed: Adapter speed must match " | |
1125 | "ring speed if Automatic Ring Speed Save is " | |
1126 | "disabled.\n"); | |
1127 | ti->open_action = FAIL; | |
1128 | }else | |
1129 | DPRINTK("Retrying open to adjust to " | |
1130 | "ring speed, "); | |
1131 | } else if (err == 0x2d) { | |
1132 | DPRINTK("Physical Insertion: No Monitor Detected, "); | |
1133 | printk("retrying after %ds delay...\n", | |
1134 | TR_RETRY_INTERVAL/HZ); | |
1135 | } else if (err == 0x11) { | |
1136 | DPRINTK("Lobe Media Function Failure (0x11), "); | |
1137 | printk(" retrying after %ds delay...\n", | |
1138 | TR_RETRY_INTERVAL/HZ); | |
1139 | } else { | |
1140 | char **prphase = printphase; | |
1141 | char **prerror = printerror; | |
1142 | DPRINTK("TR Adapter misc open failure, error code = "); | |
1143 | printk("0x%x, Phase: %s, Error: %s\n", | |
1144 | err, prphase[err/16 -1], prerror[err%16 -1]); | |
1145 | printk(" retrying after %ds delay...\n", | |
1146 | TR_RETRY_INTERVAL/HZ); | |
1147 | } | |
1148 | } else DPRINTK("open failed: ret_code = %02X..., ", ret_code); | |
1149 | if (ti->open_action != FAIL) { | |
1150 | if (ti->open_mode==AUTOMATIC){ | |
1151 | ti->open_action = REOPEN; | |
1152 | ibmtr_reset_timer(&(ti->tr_timer), dev); | |
1153 | return; | |
1154 | } | |
1155 | wake_up(&ti->wait_for_reset); | |
1156 | return; | |
1157 | } | |
1158 | DPRINTK("FAILURE, CAPUT\n"); | |
1159 | } | |
1160 | ||
1161 | /******************************************************************************/ | |
1162 | ||
7d12e780 | 1163 | static irqreturn_t tok_interrupt(int irq, void *dev_id) |
1da177e4 LT |
1164 | { |
1165 | unsigned char status; | |
1166 | /* unsigned char status_even ; */ | |
1167 | struct tok_info *ti; | |
1168 | struct net_device *dev; | |
1169 | #ifdef ENABLE_PAGING | |
1170 | unsigned char save_srpr; | |
1171 | #endif | |
1172 | ||
1173 | dev = dev_id; | |
1174 | #if TR_VERBOSE | |
7d12e780 | 1175 | DPRINTK("Int from tok_driver, dev : %p irq%d\n", dev,irq); |
1da177e4 | 1176 | #endif |
eda10531 | 1177 | ti = netdev_priv(dev); |
1da177e4 LT |
1178 | if (ti->sram_phys & 1) |
1179 | return IRQ_NONE; /* PCMCIA card extraction flag */ | |
1180 | spin_lock(&(ti->lock)); | |
1181 | #ifdef ENABLE_PAGING | |
1182 | save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN); | |
1183 | #endif | |
1184 | ||
1185 | /* Disable interrupts till processing is finished */ | |
1186 | writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN); | |
1187 | ||
1188 | /* Reset interrupt for ISA boards */ | |
1189 | if (ti->adapter_int_enable) | |
1190 | outb(0, ti->adapter_int_enable); | |
1191 | else /* used for PCMCIA cards */ | |
1192 | outb(0, ti->global_int_enable); | |
1193 | if (ti->do_tok_int == FIRST_INT){ | |
1194 | initial_tok_int(dev); | |
1195 | #ifdef ENABLE_PAGING | |
1196 | writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN); | |
1197 | #endif | |
1198 | spin_unlock(&(ti->lock)); | |
1199 | return IRQ_HANDLED; | |
1200 | } | |
1201 | /* Begin interrupt handler HERE inline to avoid the extra | |
1202 | levels of logic and call depth for the original solution. */ | |
1203 | status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD); | |
1204 | /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */ | |
1205 | /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */ | |
1206 | /*BMS status,status_even); */ | |
1207 | ||
1208 | if (status & ADAP_CHK_INT) { | |
1209 | int i; | |
1210 | void __iomem *check_reason; | |
1211 | __u8 check_reason_page = 0; | |
1212 | check_reason = map_address(ti, | |
1213 | ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN)), | |
1214 | &check_reason_page); | |
1215 | SET_PAGE(check_reason_page); | |
1216 | ||
1217 | DPRINTK("Adapter check interrupt\n"); | |
1218 | DPRINTK("8 reason bytes follow: "); | |
1219 | for (i = 0; i < 8; i++, check_reason++) | |
1220 | printk("%02X ", (int) readb(check_reason)); | |
1221 | printk("\n"); | |
1222 | writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD); | |
1223 | status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN); | |
1224 | DPRINTK("ISRA_EVEN == 0x02%x\n",status); | |
1225 | ti->open_status = CLOSED; | |
1226 | ti->sap_status = CLOSED; | |
1227 | ti->open_mode = AUTOMATIC; | |
7d17c1d6 | 1228 | netif_carrier_off(dev); |
1da177e4 LT |
1229 | netif_stop_queue(dev); |
1230 | ti->open_action = RESTART; | |
1231 | outb(0, dev->base_addr + ADAPTRESET); | |
1232 | ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/ | |
1233 | spin_unlock(&(ti->lock)); | |
1234 | return IRQ_HANDLED; | |
1235 | } | |
1236 | if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) | |
1237 | & (TCR_INT | ERR_INT | ACCESS_INT)) { | |
1238 | DPRINTK("adapter error: ISRP_EVEN : %02x\n", | |
1239 | (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN)); | |
1240 | writeb(~(TCR_INT | ERR_INT | ACCESS_INT), | |
1241 | ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN); | |
1242 | status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/ | |
1243 | DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/ | |
1244 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
1245 | #ifdef ENABLE_PAGING | |
1246 | writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN); | |
1247 | #endif | |
1248 | spin_unlock(&(ti->lock)); | |
1249 | return IRQ_HANDLED; | |
1250 | } | |
1251 | if (status & SRB_RESP_INT) { /* SRB response */ | |
1252 | SET_PAGE(ti->srb_page); | |
1253 | #if TR_VERBOSE | |
1254 | DPRINTK("SRB resp: cmd=%02X rsp=%02X\n", | |
1255 | readb(ti->srb), readb(ti->srb + RETCODE_OFST)); | |
1256 | #endif | |
1257 | switch (readb(ti->srb)) { /* SRB command check */ | |
1258 | case XMIT_DIR_FRAME:{ | |
1259 | unsigned char xmit_ret_code; | |
1260 | xmit_ret_code = readb(ti->srb + RETCODE_OFST); | |
1261 | if (xmit_ret_code == 0xff) break; | |
1262 | DPRINTK("error on xmit_dir_frame request: %02X\n", | |
1263 | xmit_ret_code); | |
1264 | if (ti->current_skb) { | |
1265 | dev_kfree_skb_irq(ti->current_skb); | |
1266 | ti->current_skb = NULL; | |
1267 | } | |
1268 | /*dev->tbusy = 0;*/ | |
1269 | netif_wake_queue(dev); | |
1270 | if (ti->readlog_pending) | |
1271 | ibmtr_readlog(dev); | |
1272 | break; | |
1273 | } | |
1274 | case XMIT_UI_FRAME:{ | |
1275 | unsigned char xmit_ret_code; | |
1276 | ||
1277 | xmit_ret_code = readb(ti->srb + RETCODE_OFST); | |
1278 | if (xmit_ret_code == 0xff) break; | |
1279 | DPRINTK("error on xmit_ui_frame request: %02X\n", | |
1280 | xmit_ret_code); | |
1281 | if (ti->current_skb) { | |
1282 | dev_kfree_skb_irq(ti->current_skb); | |
1283 | ti->current_skb = NULL; | |
1284 | } | |
1285 | netif_wake_queue(dev); | |
1286 | if (ti->readlog_pending) | |
1287 | ibmtr_readlog(dev); | |
1288 | break; | |
1289 | } | |
1290 | case DIR_OPEN_ADAPTER: | |
1291 | dir_open_adapter(dev); | |
1292 | break; | |
1293 | case DLC_OPEN_SAP: | |
1294 | if (readb(ti->srb + RETCODE_OFST)) { | |
1295 | DPRINTK("open_sap failed: ret_code = %02X, " | |
1296 | "retrying\n", | |
1297 | (int) readb(ti->srb + RETCODE_OFST)); | |
1298 | ti->open_action = REOPEN; | |
1299 | ibmtr_reset_timer(&(ti->tr_timer), dev); | |
1300 | break; | |
1301 | } | |
1302 | ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST); | |
1303 | ti->sap_status = OPEN;/* TR adapter is now available */ | |
1304 | if (ti->open_mode==MANUAL){ | |
1305 | wake_up(&ti->wait_for_reset); | |
1306 | break; | |
1307 | } | |
1308 | netif_wake_queue(dev); | |
7d17c1d6 | 1309 | netif_carrier_on(dev); |
1da177e4 LT |
1310 | break; |
1311 | case DIR_INTERRUPT: | |
1312 | case DIR_MOD_OPEN_PARAMS: | |
1313 | case DIR_SET_GRP_ADDR: | |
1314 | case DIR_SET_FUNC_ADDR: | |
1315 | case DLC_CLOSE_SAP: | |
1316 | if (readb(ti->srb + RETCODE_OFST)) | |
1317 | DPRINTK("error on %02X: %02X\n", | |
1318 | (int) readb(ti->srb + COMMAND_OFST), | |
1319 | (int) readb(ti->srb + RETCODE_OFST)); | |
1320 | break; | |
1321 | case DIR_READ_LOG: | |
1322 | if (readb(ti->srb + RETCODE_OFST)){ | |
1323 | DPRINTK("error on dir_read_log: %02X\n", | |
1324 | (int) readb(ti->srb + RETCODE_OFST)); | |
1325 | netif_wake_queue(dev); | |
1326 | break; | |
1327 | } | |
1328 | #if IBMTR_DEBUG_MESSAGES | |
1329 | ||
1330 | #define LINE_ERRORS_OFST 0 | |
1331 | #define INTERNAL_ERRORS_OFST 1 | |
1332 | #define BURST_ERRORS_OFST 2 | |
1333 | #define AC_ERRORS_OFST 3 | |
1334 | #define ABORT_DELIMITERS_OFST 4 | |
1335 | #define LOST_FRAMES_OFST 6 | |
1336 | #define RECV_CONGEST_COUNT_OFST 7 | |
1337 | #define FRAME_COPIED_ERRORS_OFST 8 | |
1338 | #define FREQUENCY_ERRORS_OFST 9 | |
1339 | #define TOKEN_ERRORS_OFST 10 | |
1340 | ||
1341 | DPRINTK("Line errors %02X, Internal errors %02X, " | |
1342 | "Burst errors %02X\n" "A/C errors %02X, " | |
1343 | "Abort delimiters %02X, Lost frames %02X\n" | |
1344 | "Receive congestion count %02X, " | |
1345 | "Frame copied errors %02X\nFrequency errors %02X, " | |
1346 | "Token errors %02X\n", | |
1347 | (int) readb(ti->srb + LINE_ERRORS_OFST), | |
1348 | (int) readb(ti->srb + INTERNAL_ERRORS_OFST), | |
1349 | (int) readb(ti->srb + BURST_ERRORS_OFST), | |
1350 | (int) readb(ti->srb + AC_ERRORS_OFST), | |
1351 | (int) readb(ti->srb + ABORT_DELIMITERS_OFST), | |
1352 | (int) readb(ti->srb + LOST_FRAMES_OFST), | |
1353 | (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST), | |
1354 | (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST), | |
1355 | (int) readb(ti->srb + FREQUENCY_ERRORS_OFST), | |
1356 | (int) readb(ti->srb + TOKEN_ERRORS_OFST)); | |
1357 | #endif | |
1358 | netif_wake_queue(dev); | |
1359 | break; | |
1360 | default: | |
1361 | DPRINTK("Unknown command %02X encountered\n", | |
1362 | (int) readb(ti->srb)); | |
1363 | } /* end switch SRB command check */ | |
1364 | writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD); | |
1365 | } /* if SRB response */ | |
1366 | if (status & ASB_FREE_INT) { /* ASB response */ | |
1367 | SET_PAGE(ti->asb_page); | |
1368 | #if TR_VERBOSE | |
1369 | DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb)); | |
1370 | #endif | |
1371 | ||
1372 | switch (readb(ti->asb)) { /* ASB command check */ | |
1373 | case REC_DATA: | |
1374 | case XMIT_UI_FRAME: | |
1375 | case XMIT_DIR_FRAME: | |
1376 | break; | |
1377 | default: | |
1378 | DPRINTK("unknown command in asb %02X\n", | |
1379 | (int) readb(ti->asb)); | |
1380 | } /* switch ASB command check */ | |
1381 | if (readb(ti->asb + 2) != 0xff) /* checks ret_code */ | |
1382 | DPRINTK("ASB error %02X in cmd %02X\n", | |
1383 | (int) readb(ti->asb + 2), (int) readb(ti->asb)); | |
1384 | writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD); | |
1385 | } /* if ASB response */ | |
1386 | ||
1387 | #define STATUS_OFST 6 | |
1388 | #define NETW_STATUS_OFST 6 | |
1389 | ||
1390 | if (status & ARB_CMD_INT) { /* ARB response */ | |
1391 | SET_PAGE(ti->arb_page); | |
1392 | #if TR_VERBOSE | |
1393 | DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb)); | |
1394 | #endif | |
1395 | ||
1396 | switch (readb(ti->arb)) { /* ARB command check */ | |
1397 | case DLC_STATUS: | |
1398 | DPRINTK("DLC_STATUS new status: %02X on station %02X\n", | |
1399 | ntohs(readw(ti->arb + STATUS_OFST)), | |
1400 | ntohs(readw(ti->arb+ STATION_ID_OFST))); | |
1401 | break; | |
1402 | case REC_DATA: | |
1403 | tr_rx(dev); | |
1404 | break; | |
1405 | case RING_STAT_CHANGE:{ | |
1406 | unsigned short ring_status; | |
1407 | ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST)); | |
1408 | if (ibmtr_debug_trace & TRC_INIT) | |
1409 | DPRINTK("Ring Status Change...(0x%x)\n", | |
1410 | ring_status); | |
1411 | if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){ | |
1412 | netif_stop_queue(dev); | |
7d17c1d6 | 1413 | netif_carrier_off(dev); |
1da177e4 LT |
1414 | DPRINTK("Remove received, or Auto-removal error" |
1415 | ", or Lobe fault\n"); | |
1416 | DPRINTK("We'll try to reopen the closed adapter" | |
1417 | " after a %d second delay.\n", | |
1418 | TR_RETRY_INTERVAL/HZ); | |
1419 | /*I was confused: I saw the TR reopening but */ | |
1420 | /*forgot:with an RJ45 in an RJ45/ICS adapter */ | |
1421 | /*but adapter not in the ring, the TR will */ | |
1422 | /* open, and then soon close and come here. */ | |
1423 | ti->open_mode = AUTOMATIC; | |
1424 | ti->open_status = CLOSED; /*12/2000 BMS*/ | |
1425 | ti->open_action = REOPEN; | |
1426 | ibmtr_reset_timer(&(ti->tr_timer), dev); | |
1427 | } else if (ring_status & LOG_OVERFLOW) { | |
1428 | if(netif_queue_stopped(dev)) | |
1429 | ti->readlog_pending = 1; | |
1430 | else | |
1431 | ibmtr_readlog(dev); | |
1432 | } | |
1433 | break; | |
1434 | } | |
1435 | case XMIT_DATA_REQ: | |
1436 | tr_tx(dev); | |
1437 | break; | |
1438 | default: | |
1439 | DPRINTK("Unknown command %02X in arb\n", | |
1440 | (int) readb(ti->arb)); | |
1441 | break; | |
1442 | } /* switch ARB command check */ | |
1443 | writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD); | |
1444 | writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1445 | } /* if ARB response */ | |
1446 | if (status & SSB_RESP_INT) { /* SSB response */ | |
1447 | unsigned char retcode; | |
1448 | SET_PAGE(ti->ssb_page); | |
1449 | #if TR_VERBOSE | |
1450 | DPRINTK("SSB resp: cmd=%02X rsp=%02X\n", | |
1451 | readb(ti->ssb), readb(ti->ssb + 2)); | |
1452 | #endif | |
1453 | ||
1454 | switch (readb(ti->ssb)) { /* SSB command check */ | |
1455 | case XMIT_DIR_FRAME: | |
1456 | case XMIT_UI_FRAME: | |
1457 | retcode = readb(ti->ssb + 2); | |
1458 | if (retcode && (retcode != 0x22))/* checks ret_code */ | |
1459 | DPRINTK("xmit ret_code: %02X xmit error code: " | |
1460 | "%02X\n", | |
1461 | (int)retcode, (int)readb(ti->ssb + 6)); | |
1462 | else | |
1463 | ti->tr_stats.tx_packets++; | |
1464 | break; | |
1465 | case XMIT_XID_CMD: | |
1466 | DPRINTK("xmit xid ret_code: %02X\n", | |
1467 | (int) readb(ti->ssb + 2)); | |
1468 | default: | |
1469 | DPRINTK("Unknown command %02X in ssb\n", | |
1470 | (int) readb(ti->ssb)); | |
1471 | } /* SSB command check */ | |
1472 | writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD); | |
1473 | writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1474 | } /* if SSB response */ | |
1475 | #ifdef ENABLE_PAGING | |
1476 | writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN); | |
1477 | #endif | |
1478 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
1479 | spin_unlock(&(ti->lock)); | |
1480 | return IRQ_HANDLED; | |
1481 | } /*tok_interrupt */ | |
1482 | ||
1483 | /*****************************************************************************/ | |
1484 | ||
1485 | #define INIT_STATUS_OFST 1 | |
1486 | #define INIT_STATUS_2_OFST 2 | |
1487 | #define ENCODED_ADDRESS_OFST 8 | |
1488 | ||
1489 | static void initial_tok_int(struct net_device *dev) | |
1490 | { | |
1491 | ||
1492 | __u32 encoded_addr, hw_encoded_addr; | |
1493 | struct tok_info *ti; | |
1494 | unsigned char init_status; /*BMS 12/2000*/ | |
1495 | ||
eda10531 | 1496 | ti = netdev_priv(dev); |
1da177e4 LT |
1497 | |
1498 | ti->do_tok_int = NOT_FIRST; | |
1499 | ||
1500 | /* we assign the shared-ram address for ISA devices */ | |
1501 | writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN); | |
1502 | #ifndef PCMCIA | |
1503 | ti->sram_virt = ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram); | |
1504 | #endif | |
1505 | ti->init_srb = map_address(ti, | |
1506 | ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN)), | |
1507 | &ti->init_srb_page); | |
1508 | if (ti->page_mask && ti->avail_shared_ram == 127) { | |
1509 | void __iomem *last_512; | |
1510 | __u8 last_512_page=0; | |
1511 | int i; | |
1512 | last_512 = map_address(ti, 0xfe00, &last_512_page); | |
1513 | /* initialize high section of ram (if necessary) */ | |
1514 | SET_PAGE(last_512_page); | |
1515 | for (i = 0; i < 512; i++) | |
1516 | writeb(0, last_512 + i); | |
1517 | } | |
1518 | SET_PAGE(ti->init_srb_page); | |
1519 | ||
1520 | #if TR_VERBOSE | |
1521 | { | |
1522 | int i; | |
1523 | ||
1524 | DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page); | |
1525 | DPRINTK("init_srb(%p):", ti->init_srb ); | |
1526 | for (i = 0; i < 20; i++) | |
1527 | printk("%02X ", (int) readb(ti->init_srb + i)); | |
1528 | printk("\n"); | |
1529 | } | |
1530 | #endif | |
1531 | ||
1532 | hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST); | |
1533 | encoded_addr = ntohs(hw_encoded_addr); | |
1534 | init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/ | |
1535 | readb(ti->init_srb+offsetof(struct srb_init_response,init_status)); | |
1536 | /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/ | |
1537 | ti->ring_speed = init_status & 0x01 ? 16 : 4; | |
1538 | DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n", | |
1539 | ti->ring_speed, (unsigned int)dev->mem_start); | |
2d6d749d | 1540 | ti->auto_speedsave = (readb(ti->init_srb+INIT_STATUS_2_OFST) & 4) != 0; |
1da177e4 LT |
1541 | |
1542 | if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset); | |
1543 | else tok_open_adapter((unsigned long)dev); | |
1544 | ||
1545 | } /*initial_tok_int() */ | |
1546 | ||
1547 | /*****************************************************************************/ | |
1548 | ||
1549 | #define CMD_CORRELATE_OFST 1 | |
1550 | #define DHB_ADDRESS_OFST 6 | |
1551 | ||
1552 | #define FRAME_LENGTH_OFST 6 | |
1553 | #define HEADER_LENGTH_OFST 8 | |
1554 | #define RSAP_VALUE_OFST 9 | |
1555 | ||
1556 | static void tr_tx(struct net_device *dev) | |
1557 | { | |
eda10531 | 1558 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1559 | struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data; |
1560 | unsigned int hdr_len; | |
1561 | __u32 dhb=0,dhb_base; | |
1562 | void __iomem *dhbuf = NULL; | |
1563 | unsigned char xmit_command; | |
1564 | int i,dhb_len=0x4000,src_len,src_offset; | |
1565 | struct trllc *llc; | |
1566 | struct srb_xmit xsrb; | |
1567 | __u8 dhb_page = 0; | |
1568 | __u8 llc_ssap; | |
1569 | ||
1570 | SET_PAGE(ti->asb_page); | |
1571 | ||
1572 | if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n"); | |
1573 | ||
1574 | /* in providing the transmit interrupts, is telling us it is ready for | |
1575 | data and providing a shared memory address for us to stuff with data. | |
1576 | Here we compute the effective address where we will place data. | |
1577 | */ | |
1578 | SET_PAGE(ti->arb_page); | |
1579 | dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST)); | |
1580 | if (ti->page_mask) { | |
1581 | dhb_page = (dhb_base >> 8) & ti->page_mask; | |
1582 | dhb=dhb_base & ~(ti->page_mask << 8); | |
1583 | } | |
1584 | dhbuf = ti->sram_virt + dhb; | |
1585 | ||
1586 | /* Figure out the size of the 802.5 header */ | |
1587 | if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */ | |
1588 | hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN; | |
1589 | else | |
1590 | hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8) | |
1591 | + sizeof(struct trh_hdr) - TR_MAXRIFLEN; | |
1592 | ||
1593 | llc = (struct trllc *) (ti->current_skb->data + hdr_len); | |
1594 | ||
1595 | llc_ssap = llc->ssap; | |
1596 | SET_PAGE(ti->srb_page); | |
1597 | memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb)); | |
1598 | SET_PAGE(ti->asb_page); | |
1599 | xmit_command = xsrb.command; | |
1600 | ||
1601 | writeb(xmit_command, ti->asb + COMMAND_OFST); | |
1602 | writew(xsrb.station_id, ti->asb + STATION_ID_OFST); | |
1603 | writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST); | |
1604 | writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST); | |
1605 | writeb(0, ti->asb + RETCODE_OFST); | |
1606 | if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) { | |
1607 | writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST); | |
1608 | writeb(0x0e, ti->asb + HEADER_LENGTH_OFST); | |
1609 | SET_PAGE(dhb_page); | |
1610 | writeb(AC, dhbuf); | |
1611 | writeb(LLC_FRAME, dhbuf + 1); | |
1612 | for (i = 0; i < TR_ALEN; i++) | |
1613 | writeb((int) 0x0FF, dhbuf + i + 2); | |
1614 | for (i = 0; i < TR_ALEN; i++) | |
1615 | writeb(0, dhbuf + i + TR_ALEN + 2); | |
1616 | writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1617 | return; | |
1618 | } | |
1619 | /* | |
1620 | * the token ring packet is copied from sk_buff to the adapter | |
1621 | * buffer identified in the command data received with the interrupt. | |
1622 | */ | |
1623 | writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST); | |
1624 | writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST); | |
1625 | src_len=ti->current_skb->len; | |
1626 | src_offset=0; | |
1627 | dhb=dhb_base; | |
1628 | while(1) { | |
1629 | if (ti->page_mask) { | |
1630 | dhb_page=(dhb >> 8) & ti->page_mask; | |
1631 | dhb=dhb & ~(ti->page_mask << 8); | |
1632 | dhb_len=0x4000-dhb; /* remaining size of this page */ | |
1633 | } | |
1634 | dhbuf = ti->sram_virt + dhb; | |
1635 | SET_PAGE(dhb_page); | |
1636 | if (src_len > dhb_len) { | |
1637 | memcpy_toio(dhbuf,&ti->current_skb->data[src_offset], | |
1638 | dhb_len); | |
1639 | src_len -= dhb_len; | |
1640 | src_offset += dhb_len; | |
1641 | dhb_base+=dhb_len; | |
1642 | dhb=dhb_base; | |
1643 | continue; | |
1644 | } | |
1645 | memcpy_toio(dhbuf, &ti->current_skb->data[src_offset], src_len); | |
1646 | break; | |
1647 | } | |
1648 | writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1649 | ti->tr_stats.tx_bytes += ti->current_skb->len; | |
1650 | dev_kfree_skb_irq(ti->current_skb); | |
1651 | ti->current_skb = NULL; | |
1652 | netif_wake_queue(dev); | |
1653 | if (ti->readlog_pending) | |
1654 | ibmtr_readlog(dev); | |
1655 | } /*tr_tx */ | |
1656 | ||
1657 | /*****************************************************************************/ | |
1658 | ||
1659 | ||
1660 | #define RECEIVE_BUFFER_OFST 6 | |
1661 | #define LAN_HDR_LENGTH_OFST 8 | |
1662 | #define DLC_HDR_LENGTH_OFST 9 | |
1663 | ||
1664 | #define DSAP_OFST 0 | |
1665 | #define SSAP_OFST 1 | |
1666 | #define LLC_OFST 2 | |
1667 | #define PROTID_OFST 3 | |
1668 | #define ETHERTYPE_OFST 6 | |
1669 | ||
1670 | static void tr_rx(struct net_device *dev) | |
1671 | { | |
eda10531 | 1672 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1673 | __u32 rbuffer; |
1674 | void __iomem *rbuf, *rbufdata, *llc; | |
1675 | __u8 rbuffer_page = 0; | |
1676 | unsigned char *data; | |
1677 | unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length; | |
1678 | unsigned char dlc_hdr_len; | |
1679 | struct sk_buff *skb; | |
1680 | unsigned int skb_size = 0; | |
1681 | int IPv4_p = 0; | |
1682 | unsigned int chksum = 0; | |
1683 | struct iphdr *iph; | |
1684 | struct arb_rec_req rarb; | |
1685 | ||
1686 | SET_PAGE(ti->arb_page); | |
1687 | memcpy_fromio(&rarb, ti->arb, sizeof(rarb)); | |
1688 | rbuffer = ntohs(rarb.rec_buf_addr) ; | |
1689 | rbuf = map_address(ti, rbuffer, &rbuffer_page); | |
1690 | ||
1691 | SET_PAGE(ti->asb_page); | |
1692 | ||
1693 | if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n"); | |
1694 | ||
1695 | writeb(REC_DATA, ti->asb + COMMAND_OFST); | |
1696 | writew(rarb.station_id, ti->asb + STATION_ID_OFST); | |
1697 | writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST); | |
1698 | ||
1699 | lan_hdr_len = rarb.lan_hdr_len; | |
1700 | if (lan_hdr_len > sizeof(struct trh_hdr)) { | |
1701 | DPRINTK("Linux cannot handle greater than 18 bytes RIF\n"); | |
1702 | return; | |
1703 | } /*BMS I added this above just to be very safe */ | |
1704 | dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST); | |
1705 | hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr); | |
1706 | ||
1707 | SET_PAGE(rbuffer_page); | |
1708 | llc = rbuf + offsetof(struct rec_buf, data) + lan_hdr_len; | |
1709 | ||
1710 | #if TR_VERBOSE | |
1711 | DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n", | |
1712 | (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len); | |
1713 | DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n", | |
1714 | llc, ntohs(rarb.rec_buf_addr), dev->mem_start); | |
1715 | DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, " | |
1716 | "ethertype: %04X\n", | |
1717 | (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST), | |
1718 | (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST), | |
1719 | (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2), | |
1720 | (int) ntohs(readw(llc + ETHERTYPE_OFST))); | |
1721 | #endif | |
1722 | if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) { | |
1723 | SET_PAGE(ti->asb_page); | |
1724 | writeb(DATA_LOST, ti->asb + RETCODE_OFST); | |
1725 | ti->tr_stats.rx_dropped++; | |
1726 | writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1727 | return; | |
1728 | } | |
1729 | length = ntohs(rarb.frame_len); | |
1730 | if (readb(llc + DSAP_OFST) == EXTENDED_SAP && | |
1731 | readb(llc + SSAP_OFST) == EXTENDED_SAP && | |
1732 | length >= hdr_len) IPv4_p = 1; | |
1733 | #if TR_VERBOSE | |
1734 | #define SADDR_OFST 8 | |
1735 | #define DADDR_OFST 2 | |
1736 | ||
1737 | if (!IPv4_p) { | |
1738 | ||
1739 | void __iomem *trhhdr = rbuf + offsetof(struct rec_buf, data); | |
0795af57 JP |
1740 | u8 saddr[6]; |
1741 | u8 daddr[6]; | |
0795af57 JP |
1742 | int i; |
1743 | for (i = 0 ; i < 6 ; i++) | |
1744 | saddr[i] = readb(trhhdr + SADDR_OFST + i); | |
1745 | for (i = 0 ; i < 6 ; i++) | |
1746 | daddr[i] = readb(trhhdr + DADDR_OFST + i); | |
1da177e4 LT |
1747 | DPRINTK("Probably non-IP frame received.\n"); |
1748 | DPRINTK("ssap: %02X dsap: %02X " | |
e174961c | 1749 | "saddr: %pM daddr: %pM\n", |
1da177e4 | 1750 | readb(llc + SSAP_OFST), readb(llc + DSAP_OFST), |
e174961c | 1751 | saddr, daddr); |
1da177e4 LT |
1752 | } |
1753 | #endif | |
1754 | ||
1755 | /*BMS handle the case she comes in with few hops but leaves with many */ | |
1756 | skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc); | |
1757 | ||
1758 | if (!(skb = dev_alloc_skb(skb_size))) { | |
1759 | DPRINTK("out of memory. frame dropped.\n"); | |
1760 | ti->tr_stats.rx_dropped++; | |
1761 | SET_PAGE(ti->asb_page); | |
1762 | writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code)); | |
1763 | writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1764 | return; | |
1765 | } | |
1766 | /*BMS again, if she comes in with few but leaves with many */ | |
1767 | skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len); | |
1768 | skb_put(skb, length); | |
1da177e4 LT |
1769 | data = skb->data; |
1770 | rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len))); | |
1771 | rbufdata = rbuf + offsetof(struct rec_buf, data); | |
1772 | ||
1773 | if (IPv4_p) { | |
1774 | /* Copy the headers without checksumming */ | |
1775 | memcpy_fromio(data, rbufdata, hdr_len); | |
1776 | ||
1777 | /* Watch for padded packets and bogons */ | |
1778 | iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc)); | |
1779 | ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr); | |
1780 | length -= hdr_len; | |
1781 | if ((ip_len <= length) && (ip_len > 7)) | |
1782 | length = ip_len; | |
1783 | data += hdr_len; | |
1784 | rbuffer_len -= hdr_len; | |
1785 | rbufdata += hdr_len; | |
1786 | } | |
1787 | /* Copy the payload... */ | |
1788 | #define BUFFER_POINTER_OFST 2 | |
1789 | #define BUFFER_LENGTH_OFST 6 | |
1790 | for (;;) { | |
1791 | if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len) | |
1792 | DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n", | |
1793 | length,rbuffer_len); | |
1794 | if (IPv4_p) | |
1795 | chksum=csum_partial_copy_nocheck((void*)rbufdata, | |
1796 | data,length<rbuffer_len?length:rbuffer_len,chksum); | |
1797 | else | |
1798 | memcpy_fromio(data, rbufdata, rbuffer_len); | |
1799 | rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ; | |
1800 | if (!rbuffer) | |
1801 | break; | |
1802 | rbuffer -= 2; | |
1803 | length -= rbuffer_len; | |
1804 | data += rbuffer_len; | |
1805 | rbuf = map_address(ti, rbuffer, &rbuffer_page); | |
1806 | SET_PAGE(rbuffer_page); | |
1807 | rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST)); | |
1808 | rbufdata = rbuf + offsetof(struct rec_buf, data); | |
1809 | } | |
1810 | ||
1811 | SET_PAGE(ti->asb_page); | |
1812 | writeb(0, ti->asb + offsetof(struct asb_rec, ret_code)); | |
1813 | ||
1814 | writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1815 | ||
1816 | ti->tr_stats.rx_bytes += skb->len; | |
1817 | ti->tr_stats.rx_packets++; | |
1818 | ||
1819 | skb->protocol = tr_type_trans(skb, dev); | |
1820 | if (IPv4_p) { | |
1821 | skb->csum = chksum; | |
ee28b0da | 1822 | skb->ip_summed = CHECKSUM_COMPLETE; |
1da177e4 LT |
1823 | } |
1824 | netif_rx(skb); | |
1825 | dev->last_rx = jiffies; | |
1826 | } /*tr_rx */ | |
1827 | ||
1828 | /*****************************************************************************/ | |
1829 | ||
de70b4c8 | 1830 | static void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev) |
1da177e4 LT |
1831 | { |
1832 | tmr->expires = jiffies + TR_RETRY_INTERVAL; | |
1833 | tmr->data = (unsigned long) dev; | |
1834 | tmr->function = tok_rerun; | |
1835 | init_timer(tmr); | |
1836 | add_timer(tmr); | |
1837 | } | |
1838 | ||
1839 | /*****************************************************************************/ | |
1840 | ||
1841 | void tok_rerun(unsigned long dev_addr){ | |
1842 | ||
1843 | struct net_device *dev = (struct net_device *)dev_addr; | |
eda10531 | 1844 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1845 | |
1846 | if ( ti->open_action == RESTART){ | |
1847 | ti->do_tok_int = FIRST_INT; | |
1848 | outb(0, dev->base_addr + ADAPTRESETREL); | |
1849 | #ifdef ENABLE_PAGING | |
1850 | if (ti->page_mask) | |
1851 | writeb(SRPR_ENABLE_PAGING, | |
1852 | ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN); | |
1853 | #endif | |
1854 | ||
1855 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
1856 | } else | |
1857 | tok_open_adapter(dev_addr); | |
1858 | } | |
1859 | ||
1860 | /*****************************************************************************/ | |
1861 | ||
de70b4c8 | 1862 | static void ibmtr_readlog(struct net_device *dev) |
1da177e4 LT |
1863 | { |
1864 | struct tok_info *ti; | |
1865 | ||
eda10531 | 1866 | ti = netdev_priv(dev); |
1da177e4 LT |
1867 | |
1868 | ti->readlog_pending = 0; | |
1869 | SET_PAGE(ti->srb_page); | |
1870 | writeb(DIR_READ_LOG, ti->srb); | |
1871 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
1872 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1873 | ||
1874 | netif_stop_queue(dev); | |
1875 | ||
1876 | } | |
1877 | ||
1878 | /*****************************************************************************/ | |
1879 | ||
1880 | /* tok_get_stats(): Basically a scaffold routine which will return | |
1881 | the address of the tr_statistics structure associated with | |
1882 | this device -- the tr.... structure is an ethnet look-alike | |
1883 | so at least for this iteration may suffice. */ | |
1884 | ||
1885 | static struct net_device_stats *tok_get_stats(struct net_device *dev) | |
1886 | { | |
1887 | ||
1888 | struct tok_info *toki; | |
eda10531 | 1889 | toki = netdev_priv(dev); |
1da177e4 LT |
1890 | return (struct net_device_stats *) &toki->tr_stats; |
1891 | } | |
1892 | ||
1893 | /*****************************************************************************/ | |
1894 | ||
de70b4c8 | 1895 | static int ibmtr_change_mtu(struct net_device *dev, int mtu) |
1da177e4 | 1896 | { |
eda10531 | 1897 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1898 | |
1899 | if (ti->ring_speed == 16 && mtu > ti->maxmtu16) | |
1900 | return -EINVAL; | |
1901 | if (ti->ring_speed == 4 && mtu > ti->maxmtu4) | |
1902 | return -EINVAL; | |
1903 | dev->mtu = mtu; | |
1904 | return 0; | |
1905 | } | |
1906 | ||
1907 | /*****************************************************************************/ | |
1908 | #ifdef MODULE | |
1909 | ||
1910 | /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */ | |
1911 | static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS]; | |
1912 | static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 }; | |
1913 | static int irq[IBMTR_MAX_ADAPTERS]; | |
1914 | static int mem[IBMTR_MAX_ADAPTERS]; | |
1915 | ||
1916 | MODULE_LICENSE("GPL"); | |
1917 | ||
1918 | module_param_array(io, int, NULL, 0); | |
1919 | module_param_array(irq, int, NULL, 0); | |
1920 | module_param_array(mem, int, NULL, 0); | |
1921 | ||
1922 | static int __init ibmtr_init(void) | |
1923 | { | |
1924 | int i; | |
1925 | int count=0; | |
1926 | ||
1927 | find_turbo_adapters(io); | |
1928 | ||
1929 | for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) { | |
1930 | struct net_device *dev; | |
1931 | irq[i] = 0; | |
1932 | mem[i] = 0; | |
1933 | dev = alloc_trdev(sizeof(struct tok_info)); | |
1934 | if (dev == NULL) { | |
1935 | if (i == 0) | |
1936 | return -ENOMEM; | |
1937 | break; | |
1938 | } | |
1939 | dev->base_addr = io[i]; | |
1940 | dev->irq = irq[i]; | |
1941 | dev->mem_start = mem[i]; | |
1942 | ||
1943 | if (ibmtr_probe_card(dev)) { | |
1944 | free_netdev(dev); | |
1945 | continue; | |
1946 | } | |
1947 | dev_ibmtr[i] = dev; | |
1948 | count++; | |
1949 | } | |
1950 | if (count) return 0; | |
1951 | printk("ibmtr: register_netdev() returned non-zero.\n"); | |
1952 | return -EIO; | |
1953 | } | |
1954 | module_init(ibmtr_init); | |
1955 | ||
1956 | static void __exit ibmtr_cleanup(void) | |
1957 | { | |
1958 | int i; | |
1959 | ||
1960 | for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){ | |
1961 | if (!dev_ibmtr[i]) | |
1962 | continue; | |
1963 | unregister_netdev(dev_ibmtr[i]); | |
1964 | ibmtr_cleanup_card(dev_ibmtr[i]); | |
1965 | free_netdev(dev_ibmtr[i]); | |
1966 | } | |
1967 | } | |
1968 | module_exit(ibmtr_cleanup); | |
1969 | #endif |