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