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 | |
06fe9fb4 | 99 | * the adapter into isa compatibility mode. |
1da177e4 LT |
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> | |
d43c36dc | 111 | #include <linux/sched.h> |
1da177e4 LT |
112 | |
113 | #ifdef PCMCIA /* required for ibmtr_cs.c to build */ | |
114 | #undef MODULE /* yes, really */ | |
115 | #undef ENABLE_PAGING | |
116 | #else | |
117 | #define ENABLE_PAGING 1 | |
118 | #endif | |
119 | ||
1da177e4 LT |
120 | /* changes the output format of driver initialization */ |
121 | #define TR_VERBOSE 0 | |
122 | ||
123 | /* some 95 OS send many non UI frame; this allow removing the warning */ | |
124 | #define TR_FILTERNONUI 1 | |
125 | ||
a6b7a407 | 126 | #include <linux/interrupt.h> |
1da177e4 LT |
127 | #include <linux/ioport.h> |
128 | #include <linux/netdevice.h> | |
129 | #include <linux/ip.h> | |
130 | #include <linux/trdevice.h> | |
131 | #include <linux/ibmtr.h> | |
132 | ||
133 | #include <net/checksum.h> | |
134 | ||
135 | #include <asm/io.h> | |
136 | ||
137 | #define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args) | |
138 | #define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args) | |
139 | ||
140 | /* version and credits */ | |
141 | #ifndef PCMCIA | |
6d2cdb4f | 142 | static char version[] __devinitdata = |
1da177e4 LT |
143 | "\nibmtr.c: v1.3.57 8/ 7/94 Peter De Schrijver and Mark Swanson\n" |
144 | " v2.1.125 10/20/98 Paul Norton <pnorton@ieee.org>\n" | |
145 | " v2.2.0 12/30/98 Joel Sloan <jjs@c-me.com>\n" | |
146 | " v2.2.1 02/08/00 Mike Sullivan <sullivam@us.ibm.com>\n" | |
147 | " v2.2.2 07/27/00 Burt Silverman <burts@us.ibm.com>\n" | |
148 | " v2.4.0 03/01/01 Mike Sullivan <sullivan@us.ibm.com>\n"; | |
149 | #endif | |
150 | ||
151 | /* this allows displaying full adapter information */ | |
152 | ||
de70b4c8 | 153 | static char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" }; |
1da177e4 LT |
154 | |
155 | static char pcchannelid[] __devinitdata = { | |
156 | 0x05, 0x00, 0x04, 0x09, | |
157 | 0x04, 0x03, 0x04, 0x0f, | |
158 | 0x03, 0x06, 0x03, 0x01, | |
159 | 0x03, 0x01, 0x03, 0x00, | |
160 | 0x03, 0x09, 0x03, 0x09, | |
161 | 0x03, 0x00, 0x02, 0x00 | |
162 | }; | |
163 | ||
164 | static char mcchannelid[] __devinitdata = { | |
165 | 0x04, 0x0d, 0x04, 0x01, | |
166 | 0x05, 0x02, 0x05, 0x03, | |
167 | 0x03, 0x06, 0x03, 0x03, | |
168 | 0x05, 0x08, 0x03, 0x04, | |
169 | 0x03, 0x05, 0x03, 0x01, | |
170 | 0x03, 0x08, 0x02, 0x00 | |
171 | }; | |
172 | ||
de70b4c8 | 173 | static char __devinit *adapter_def(char type) |
1da177e4 LT |
174 | { |
175 | switch (type) { | |
176 | case 0xF: return "PC Adapter | PC Adapter II | Adapter/A"; | |
177 | case 0xE: return "16/4 Adapter | 16/4 Adapter/A (long)"; | |
178 | case 0xD: return "16/4 Adapter/A (short) | 16/4 ISA-16 Adapter"; | |
179 | case 0xC: return "Auto 16/4 Adapter"; | |
180 | default: return "adapter (unknown type)"; | |
6403eab1 | 181 | } |
1da177e4 LT |
182 | }; |
183 | ||
184 | #define TRC_INIT 0x01 /* Trace initialization & PROBEs */ | |
185 | #define TRC_INITV 0x02 /* verbose init trace points */ | |
de70b4c8 | 186 | static unsigned char ibmtr_debug_trace = 0; |
1da177e4 | 187 | |
1da177e4 LT |
188 | static int ibmtr_probe1(struct net_device *dev, int ioaddr); |
189 | static unsigned char get_sram_size(struct tok_info *adapt_info); | |
190 | static int trdev_init(struct net_device *dev); | |
191 | static int tok_open(struct net_device *dev); | |
192 | static int tok_init_card(struct net_device *dev); | |
de70b4c8 | 193 | static void tok_open_adapter(unsigned long dev_addr); |
1da177e4 LT |
194 | static void open_sap(unsigned char type, struct net_device *dev); |
195 | static void tok_set_multicast_list(struct net_device *dev); | |
61a84108 SH |
196 | static netdev_tx_t tok_send_packet(struct sk_buff *skb, |
197 | struct net_device *dev); | |
1da177e4 | 198 | static int tok_close(struct net_device *dev); |
7d12e780 | 199 | static irqreturn_t tok_interrupt(int irq, void *dev_id); |
1da177e4 LT |
200 | static void initial_tok_int(struct net_device *dev); |
201 | static void tr_tx(struct net_device *dev); | |
202 | static void tr_rx(struct net_device *dev); | |
de70b4c8 | 203 | static void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev); |
1da177e4 | 204 | static void tok_rerun(unsigned long dev_addr); |
de70b4c8 | 205 | static void ibmtr_readlog(struct net_device *dev); |
de70b4c8 | 206 | static int ibmtr_change_mtu(struct net_device *dev, int mtu); |
1da177e4 LT |
207 | static void find_turbo_adapters(int *iolist); |
208 | ||
209 | static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = { | |
210 | 0xa20, 0xa24, 0, 0, 0 | |
211 | }; | |
212 | static int __devinitdata turbo_io[IBMTR_MAX_ADAPTERS] = {0}; | |
213 | static int __devinitdata turbo_irq[IBMTR_MAX_ADAPTERS] = {0}; | |
214 | static int __devinitdata turbo_searched = 0; | |
215 | ||
216 | #ifndef PCMCIA | |
6d2cdb4f | 217 | static __u32 ibmtr_mem_base __devinitdata = 0xd0000; |
1da177e4 LT |
218 | #endif |
219 | ||
220 | static void __devinit PrtChanID(char *pcid, short stride) | |
221 | { | |
222 | short i, j; | |
223 | for (i = 0, j = 0; i < 24; i++, j += stride) | |
224 | printk("%1x", ((int) pcid[j]) & 0x0f); | |
225 | printk("\n"); | |
226 | } | |
227 | ||
228 | static void __devinit HWPrtChanID(void __iomem *pcid, short stride) | |
229 | { | |
230 | short i, j; | |
231 | for (i = 0, j = 0; i < 24; i++, j += stride) | |
232 | printk("%1x", ((int) readb(pcid + j)) & 0x0f); | |
233 | printk("\n"); | |
234 | } | |
235 | ||
236 | /* We have to ioremap every checked address, because isa_readb is | |
237 | * going away. | |
238 | */ | |
239 | ||
240 | static void __devinit find_turbo_adapters(int *iolist) | |
241 | { | |
242 | int ram_addr; | |
243 | int index=0; | |
244 | void __iomem *chanid; | |
245 | int found_turbo=0; | |
246 | unsigned char *tchanid, ctemp; | |
247 | int i, j; | |
248 | unsigned long jif; | |
249 | void __iomem *ram_mapped ; | |
250 | ||
251 | if (turbo_searched == 1) return; | |
252 | turbo_searched=1; | |
253 | for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) { | |
254 | ||
255 | __u32 intf_tbl=0; | |
256 | ||
257 | found_turbo=1; | |
258 | ram_mapped = ioremap((u32)ram_addr,0x1fff) ; | |
259 | if (ram_mapped==NULL) | |
260 | continue ; | |
261 | chanid=(CHANNEL_ID + ram_mapped); | |
262 | tchanid=pcchannelid; | |
263 | ctemp=readb(chanid) & 0x0f; | |
264 | if (ctemp != *tchanid) continue; | |
265 | for (i=2,j=1; i<=46; i=i+2,j++) { | |
266 | if ((readb(chanid+i) & 0x0f) != tchanid[j]){ | |
267 | found_turbo=0; | |
268 | break; | |
269 | } | |
270 | } | |
271 | if (!found_turbo) continue; | |
272 | ||
273 | writeb(0x90, ram_mapped+0x1E01); | |
274 | for(i=2; i<0x0f; i++) { | |
275 | writeb(0x00, ram_mapped+0x1E01+i); | |
276 | } | |
277 | writeb(0x00, ram_mapped+0x1E01); | |
278 | for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif);); | |
279 | intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN)); | |
280 | if (intf_tbl) { | |
281 | #if IBMTR_DEBUG_MESSAGES | |
282 | printk("ibmtr::find_turbo_adapters, Turbo found at " | |
283 | "ram_addr %x\n",ram_addr); | |
284 | printk("ibmtr::find_turbo_adapters, interface_table "); | |
285 | for(i=0; i<6; i++) { | |
286 | printk("%x:",readb(ram_addr+intf_tbl+i)); | |
287 | } | |
288 | printk("\n"); | |
289 | #endif | |
290 | turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4)); | |
291 | turbo_irq[index]=readb(ram_mapped+intf_tbl+3); | |
292 | outb(0, turbo_io[index] + ADAPTRESET); | |
293 | for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif);); | |
294 | outb(0, turbo_io[index] + ADAPTRESETREL); | |
295 | index++; | |
296 | continue; | |
297 | } | |
298 | #if IBMTR_DEBUG_MESSAGES | |
299 | printk("ibmtr::find_turbo_adapters, ibmtr card found at" | |
300 | " %x but not a Turbo model\n",ram_addr); | |
301 | #endif | |
302 | iounmap(ram_mapped) ; | |
303 | } /* for */ | |
304 | for(i=0; i<IBMTR_MAX_ADAPTERS; i++) { | |
305 | if(!turbo_io[i]) break; | |
306 | for (j=0; j<IBMTR_MAX_ADAPTERS; j++) { | |
307 | if ( iolist[j] && iolist[j] != turbo_io[i]) continue; | |
308 | iolist[j]=turbo_io[i]; | |
309 | break; | |
310 | } | |
311 | } | |
312 | } | |
313 | ||
314 | static void ibmtr_cleanup_card(struct net_device *dev) | |
315 | { | |
316 | if (dev->base_addr) { | |
317 | outb(0,dev->base_addr+ADAPTRESET); | |
318 | ||
3173c890 | 319 | schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */ |
1da177e4 LT |
320 | |
321 | outb(0,dev->base_addr+ADAPTRESETREL); | |
322 | } | |
323 | ||
324 | #ifndef PCMCIA | |
325 | free_irq(dev->irq, dev); | |
326 | release_region(dev->base_addr, IBMTR_IO_EXTENT); | |
327 | ||
328 | { | |
eda10531 | 329 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
330 | iounmap(ti->mmio); |
331 | iounmap(ti->sram_virt); | |
332 | } | |
333 | #endif | |
334 | } | |
335 | ||
1da177e4 LT |
336 | /**************************************************************************** |
337 | * ibmtr_probe(): Routine specified in the network device structure | |
338 | * to probe for an IBM Token Ring Adapter. Routine outline: | |
339 | * I. Interrogate hardware to determine if an adapter exists | |
340 | * and what the speeds and feeds are | |
341 | * II. Setup data structures to control execution based upon | |
342 | * adapter characteristics. | |
343 | * | |
344 | * We expect ibmtr_probe to be called once for each device entry | |
345 | * which references it. | |
346 | ****************************************************************************/ | |
347 | ||
abf0437b | 348 | static int __devinit ibmtr_probe(struct net_device *dev) |
1da177e4 LT |
349 | { |
350 | int i; | |
351 | int base_addr = dev->base_addr; | |
352 | ||
353 | if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */ | |
354 | return -ENXIO; | |
355 | if (base_addr > 0x1ff) { /* Check a single specified location. */ | |
356 | if (!ibmtr_probe1(dev, base_addr)) return 0; | |
357 | return -ENODEV; | |
358 | } | |
359 | find_turbo_adapters(ibmtr_portlist); | |
360 | for (i = 0; ibmtr_portlist[i]; i++) { | |
361 | int ioaddr = ibmtr_portlist[i]; | |
362 | ||
363 | if (!ibmtr_probe1(dev, ioaddr)) return 0; | |
364 | } | |
365 | return -ENODEV; | |
366 | } | |
367 | ||
abf0437b | 368 | int __devinit ibmtr_probe_card(struct net_device *dev) |
82c00b62 RB |
369 | { |
370 | int err = ibmtr_probe(dev); | |
371 | if (!err) { | |
372 | err = register_netdev(dev); | |
373 | if (err) | |
374 | ibmtr_cleanup_card(dev); | |
375 | } | |
376 | return err; | |
377 | } | |
378 | ||
1da177e4 LT |
379 | /*****************************************************************************/ |
380 | ||
381 | static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr) | |
382 | { | |
383 | ||
384 | unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0; | |
385 | void __iomem * t_mmio = NULL; | |
eda10531 | 386 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
387 | void __iomem *cd_chanid; |
388 | unsigned char *tchanid, ctemp; | |
389 | #ifndef PCMCIA | |
390 | unsigned char t_irq=0; | |
391 | unsigned long timeout; | |
392 | static int version_printed; | |
393 | #endif | |
394 | ||
395 | /* Query the adapter PIO base port which will return | |
396 | * indication of where MMIO was placed. We also have a | |
397 | * coded interrupt number. | |
398 | */ | |
399 | segment = inb(PIOaddr); | |
400 | if (segment < 0x40 || segment > 0xe0) { | |
401 | /* Out of range values so we'll assume non-existent IO device | |
402 | * but this is not necessarily a problem, esp if a turbo | |
403 | * adapter is being used. */ | |
404 | #if IBMTR_DEBUG_MESSAGES | |
405 | DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, " | |
406 | "Hardware Problem?\n",PIOaddr,segment); | |
407 | #endif | |
408 | return -ENODEV; | |
409 | } | |
410 | /* | |
411 | * Compute the linear base address of the MMIO area | |
412 | * as LINUX doesn't care about segments | |
413 | */ | |
414 | t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048); | |
415 | if (!t_mmio) { | |
416 | DPRINTK("Cannot remap mmiobase memory area") ; | |
417 | return -ENODEV ; | |
418 | } | |
419 | intr = segment & 0x03; /* low bits is coded interrupt # */ | |
420 | if (ibmtr_debug_trace & TRC_INIT) | |
421 | DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n" | |
422 | , PIOaddr, (int) segment, t_mmio, (int) intr); | |
423 | ||
424 | /* | |
425 | * Now we will compare expected 'channelid' strings with | |
426 | * what we is there to learn of ISA/MCA or not TR card | |
427 | */ | |
428 | #ifdef PCMCIA | |
429 | iounmap(t_mmio); | |
430 | t_mmio = ti->mmio; /*BMS to get virtual address */ | |
431 | irq = ti->irq; /*BMS to display the irq! */ | |
432 | #endif | |
433 | cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */ | |
434 | tchanid = pcchannelid; | |
435 | cardpresent = TR_ISA; /* try ISA */ | |
436 | ||
437 | /* Suboptimize knowing first byte different */ | |
438 | ctemp = readb(cd_chanid) & 0x0f; | |
439 | if (ctemp != *tchanid) { /* NOT ISA card, try MCA */ | |
440 | tchanid = mcchannelid; | |
441 | cardpresent = TR_MCA; | |
442 | if (ctemp != *tchanid) /* Neither ISA nor MCA */ | |
443 | cardpresent = NOTOK; | |
444 | } | |
445 | if (cardpresent != NOTOK) { | |
446 | /* Know presumed type, try rest of ID */ | |
447 | for (i = 2, j = 1; i <= 46; i = i + 2, j++) { | |
448 | if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue; | |
449 | /* match failed, not TR card */ | |
450 | cardpresent = NOTOK; | |
451 | break; | |
452 | } | |
453 | } | |
454 | /* | |
455 | * If we have an ISA board check for the ISA P&P version, | |
456 | * as it has different IRQ settings | |
457 | */ | |
458 | if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e)) | |
459 | cardpresent = TR_ISAPNP; | |
460 | if (cardpresent == NOTOK) { /* "channel_id" did not match, report */ | |
461 | if (!(ibmtr_debug_trace & TRC_INIT)) { | |
462 | #ifndef PCMCIA | |
463 | iounmap(t_mmio); | |
464 | #endif | |
465 | return -ENODEV; | |
466 | } | |
467 | DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n", | |
468 | PIOaddr); | |
469 | DPRINTK("Expected for ISA: "); | |
470 | PrtChanID(pcchannelid, 1); | |
471 | DPRINTK(" found: "); | |
472 | /* BMS Note that this can be misleading, when hardware is flaky, because you | |
473 | are reading it a second time here. So with my flaky hardware, I'll see my- | |
474 | self in this block, with the HW ID matching the ISA ID exactly! */ | |
475 | HWPrtChanID(cd_chanid, 2); | |
476 | DPRINTK("Expected for MCA: "); | |
477 | PrtChanID(mcchannelid, 1); | |
478 | } | |
479 | /* Now, setup some of the pl0 buffers for this driver.. */ | |
480 | /* If called from PCMCIA, it is already set up, so no need to | |
481 | waste the memory, just use the existing structure */ | |
482 | #ifndef PCMCIA | |
483 | ti->mmio = t_mmio; | |
484 | for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) { | |
485 | if (turbo_io[i] != PIOaddr) | |
486 | continue; | |
487 | #if IBMTR_DEBUG_MESSAGES | |
488 | printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n", | |
489 | PIOaddr); | |
490 | #endif | |
491 | ti->turbo = 1; | |
492 | t_irq = turbo_irq[i]; | |
493 | } | |
494 | #endif /* !PCMCIA */ | |
495 | ti->readlog_pending = 0; | |
496 | init_waitqueue_head(&ti->wait_for_reset); | |
497 | ||
498 | /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP | |
499 | * depending which card is inserted. */ | |
500 | ||
501 | #ifndef PCMCIA | |
502 | switch (cardpresent) { | |
503 | case TR_ISA: | |
504 | if (intr == 0) irq = 9; /* irq2 really is irq9 */ | |
505 | if (intr == 1) irq = 3; | |
506 | if (intr == 2) irq = 6; | |
507 | if (intr == 3) irq = 7; | |
508 | ti->adapter_int_enable = PIOaddr + ADAPTINTREL; | |
509 | break; | |
510 | case TR_MCA: | |
511 | if (intr == 0) irq = 9; | |
512 | if (intr == 1) irq = 3; | |
513 | if (intr == 2) irq = 10; | |
514 | if (intr == 3) irq = 11; | |
515 | ti->global_int_enable = 0; | |
516 | ti->adapter_int_enable = 0; | |
517 | ti->sram_phys=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12; | |
518 | break; | |
519 | case TR_ISAPNP: | |
520 | if (!t_irq) { | |
521 | if (intr == 0) irq = 9; | |
522 | if (intr == 1) irq = 3; | |
523 | if (intr == 2) irq = 10; | |
524 | if (intr == 3) irq = 11; | |
525 | } else | |
526 | irq=t_irq; | |
527 | timeout = jiffies + TR_SPIN_INTERVAL; | |
528 | while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){ | |
529 | if (!time_after(jiffies, timeout)) continue; | |
530 | DPRINTK( "Hardware timeout during initialization.\n"); | |
531 | iounmap(t_mmio); | |
1da177e4 LT |
532 | return -ENODEV; |
533 | } | |
534 | ti->sram_phys = | |
535 | ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12); | |
536 | ti->adapter_int_enable = PIOaddr + ADAPTINTREL; | |
537 | break; | |
538 | } /*end switch (cardpresent) */ | |
539 | #endif /*not PCMCIA */ | |
540 | ||
541 | if (ibmtr_debug_trace & TRC_INIT) { /* just report int */ | |
542 | DPRINTK("irq=%d", irq); | |
543 | printk(", sram_phys=0x%x", ti->sram_phys); | |
544 | if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */ | |
545 | DPRINTK(", ti->mmio=%p", ti->mmio); | |
546 | printk(", segment=%02X", segment); | |
547 | } | |
548 | printk(".\n"); | |
549 | } | |
550 | ||
551 | /* Get hw address of token ring card */ | |
552 | j = 0; | |
553 | for (i = 0; i < 0x18; i = i + 2) { | |
554 | /* technical reference states to do this */ | |
555 | temp = readb(ti->mmio + AIP + i) & 0x0f; | |
556 | ti->hw_address[j] = temp; | |
557 | if (j & 1) | |
558 | dev->dev_addr[(j / 2)] = | |
559 | ti->hw_address[j]+ (ti->hw_address[j - 1] << 4); | |
560 | ++j; | |
561 | } | |
562 | /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */ | |
563 | ti->adapter_type = readb(ti->mmio + AIPADAPTYPE); | |
564 | ||
565 | /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */ | |
566 | ti->data_rate = readb(ti->mmio + AIPDATARATE); | |
567 | ||
568 | /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */ | |
569 | ti->token_release = readb(ti->mmio + AIPEARLYTOKEN); | |
570 | ||
571 | /* How much shared RAM is on adapter ? */ | |
572 | if (ti->turbo) { | |
573 | ti->avail_shared_ram=127; | |
574 | } else { | |
575 | ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */ | |
576 | } | |
577 | /* We need to set or do a bunch of work here based on previous results*/ | |
578 | /* Support paging? What sizes?: F=no, E=16k, D=32k, C=16 & 32k */ | |
579 | ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE); | |
580 | ||
581 | /* Available DHB 4Mb size: F=2048, E=4096, D=4464 */ | |
582 | switch (readb(ti->mmio + AIP4MBDHB)) { | |
583 | case 0xe: ti->dhb_size4mb = 4096; break; | |
584 | case 0xd: ti->dhb_size4mb = 4464; break; | |
585 | default: ti->dhb_size4mb = 2048; break; | |
586 | } | |
587 | ||
588 | /* Available DHB 16Mb size: F=2048, E=4096, D=8192, C=16384, B=17960 */ | |
589 | switch (readb(ti->mmio + AIP16MBDHB)) { | |
590 | case 0xe: ti->dhb_size16mb = 4096; break; | |
591 | case 0xd: ti->dhb_size16mb = 8192; break; | |
592 | case 0xc: ti->dhb_size16mb = 16384; break; | |
593 | case 0xb: ti->dhb_size16mb = 17960; break; | |
594 | default: ti->dhb_size16mb = 2048; break; | |
595 | } | |
596 | ||
597 | /* We must figure out how much shared memory space this adapter | |
598 | * will occupy so that if there are two adapters we can fit both | |
599 | * in. Given a choice, we will limit this adapter to 32K. The | |
600 | * maximum space will will use for two adapters is 64K so if the | |
601 | * adapter we are working on demands 64K (it also doesn't support | |
602 | * paging), then only one adapter can be supported. | |
603 | */ | |
604 | ||
605 | /* | |
606 | * determine how much of total RAM is mapped into PC space | |
607 | */ | |
608 | ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/ | |
609 | 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4); | |
610 | ti->page_mask = 0; | |
611 | if (ti->turbo) ti->page_mask=0xf0; | |
612 | else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */ | |
613 | else { | |
614 | #ifdef ENABLE_PAGING | |
615 | unsigned char pg_size = 0; | |
616 | /* BMS: page size: PCMCIA, use configuration register; | |
617 | ISAPNP, use LANAIDC config tool from www.ibm.com */ | |
618 | switch (ti->shared_ram_paging) { | |
619 | case 0xf: | |
620 | break; | |
621 | case 0xe: | |
622 | ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0; | |
623 | pg_size = 32; /* 16KB page size */ | |
624 | break; | |
625 | case 0xd: | |
626 | ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0; | |
627 | pg_size = 64; /* 32KB page size */ | |
628 | break; | |
629 | case 0xc: | |
630 | switch (ti->mapped_ram_size) { | |
631 | case 32: | |
632 | ti->page_mask = 0xc0; | |
633 | pg_size = 32; | |
634 | break; | |
635 | case 64: | |
636 | ti->page_mask = 0x80; | |
637 | pg_size = 64; | |
638 | break; | |
639 | } | |
640 | break; | |
641 | default: | |
642 | DPRINTK("Unknown shared ram paging info %01X\n", | |
643 | ti->shared_ram_paging); | |
644 | iounmap(t_mmio); | |
1da177e4 LT |
645 | return -ENODEV; |
646 | break; | |
647 | } /*end switch shared_ram_paging */ | |
648 | ||
649 | if (ibmtr_debug_trace & TRC_INIT) | |
650 | DPRINTK("Shared RAM paging code: %02X, " | |
651 | "mapped RAM size: %dK, shared RAM size: %dK, " | |
652 | "page mask: %02X\n:", | |
653 | ti->shared_ram_paging, ti->mapped_ram_size / 2, | |
654 | ti->avail_shared_ram / 2, ti->page_mask); | |
655 | #endif /*ENABLE_PAGING */ | |
656 | } | |
657 | ||
658 | #ifndef PCMCIA | |
659 | /* finish figuring the shared RAM address */ | |
660 | if (cardpresent == TR_ISA) { | |
215faf9c JP |
661 | static const __u32 ram_bndry_mask[] = { |
662 | 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 | |
663 | }; | |
1da177e4 LT |
664 | __u32 new_base, rrr_32, chk_base, rbm; |
665 | ||
666 | rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03; | |
667 | rbm = ram_bndry_mask[rrr_32]; | |
668 | new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */ | |
669 | chk_base = new_base + (ti->mapped_ram_size << 9); | |
670 | if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) { | |
671 | DPRINTK("Shared RAM for this adapter (%05x) exceeds " | |
672 | "driver limit (%05x), adapter not started.\n", | |
673 | chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE); | |
674 | iounmap(t_mmio); | |
1da177e4 LT |
675 | return -ENODEV; |
676 | } else { /* seems cool, record what we have figured out */ | |
677 | ti->sram_base = new_base >> 12; | |
678 | ibmtr_mem_base = chk_base; | |
679 | } | |
680 | } | |
681 | else ti->sram_base = ti->sram_phys >> 12; | |
682 | ||
683 | /* The PCMCIA has already got the interrupt line and the io port, | |
684 | so no chance of anybody else getting it - MLP */ | |
a0607fd3 | 685 | if (request_irq(dev->irq = irq, tok_interrupt, 0, "ibmtr", dev) != 0) { |
1da177e4 LT |
686 | DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n", |
687 | irq); | |
688 | iounmap(t_mmio); | |
1da177e4 LT |
689 | return -ENODEV; |
690 | } | |
691 | /*?? Now, allocate some of the PIO PORTs for this driver.. */ | |
692 | /* record PIOaddr range as busy */ | |
693 | if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) { | |
694 | DPRINTK("Could not grab PIO range. Halting driver.\n"); | |
695 | free_irq(dev->irq, dev); | |
696 | iounmap(t_mmio); | |
1da177e4 LT |
697 | return -EBUSY; |
698 | } | |
699 | ||
700 | if (!version_printed++) { | |
701 | printk(version); | |
702 | } | |
703 | #endif /* !PCMCIA */ | |
704 | DPRINTK("%s %s found\n", | |
705 | channel_def[cardpresent - 1], adapter_def(ti->adapter_type)); | |
706 | DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n", | |
707 | irq, PIOaddr, ti->mapped_ram_size / 2); | |
e174961c | 708 | DPRINTK("Hardware address : %pM\n", dev->dev_addr); |
1da177e4 LT |
709 | if (ti->page_mask) |
710 | DPRINTK("Shared RAM paging enabled. " | |
711 | "Page size: %uK Shared Ram size %dK\n", | |
712 | ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2); | |
713 | else | |
714 | DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n", | |
715 | ti->page_mask); | |
716 | ||
717 | /* Calculate the maximum DHB we can use */ | |
718 | /* two cases where avail_shared_ram doesn't equal mapped_ram_size: | |
719 | 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical) | |
720 | 2. user has configured adapter for less than avail_shared_ram | |
721 | but is not using paging (she should use paging, I believe) | |
722 | */ | |
723 | if (!ti->page_mask) { | |
724 | ti->avail_shared_ram= | |
725 | min(ti->mapped_ram_size,ti->avail_shared_ram); | |
726 | } | |
727 | ||
728 | switch (ti->avail_shared_ram) { | |
729 | case 16: /* 8KB shared RAM */ | |
730 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048); | |
731 | ti->rbuf_len4 = 1032; | |
732 | ti->rbuf_cnt4=2; | |
733 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048); | |
734 | ti->rbuf_len16 = 1032; | |
735 | ti->rbuf_cnt16=2; | |
736 | break; | |
737 | case 32: /* 16KB shared RAM */ | |
738 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464); | |
739 | ti->rbuf_len4 = 1032; | |
740 | ti->rbuf_cnt4=4; | |
741 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096); | |
742 | ti->rbuf_len16 = 1032; /*1024 usable */ | |
743 | ti->rbuf_cnt16=4; | |
744 | break; | |
745 | case 64: /* 32KB shared RAM */ | |
746 | ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464); | |
747 | ti->rbuf_len4 = 1032; | |
748 | ti->rbuf_cnt4=6; | |
749 | ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240); | |
750 | ti->rbuf_len16 = 1032; | |
751 | ti->rbuf_cnt16=6; | |
752 | break; | |
753 | case 127: /* 63.5KB 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)16384); | |
758 | ti->rbuf_len16 = 1032; | |
759 | ti->rbuf_cnt16=16; | |
760 | break; | |
761 | case 128: /* 64KB 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)17960); | |
766 | ti->rbuf_len16 = 1032; | |
767 | ti->rbuf_cnt16=16; | |
768 | break; | |
769 | default: | |
770 | ti->dhb_size4mb = 2048; | |
771 | ti->rbuf_len4 = 1032; | |
772 | ti->rbuf_cnt4=2; | |
773 | ti->dhb_size16mb = 2048; | |
774 | ti->rbuf_len16 = 1032; | |
775 | ti->rbuf_cnt16=2; | |
776 | break; | |
777 | } | |
778 | /* this formula is not smart enough for the paging case | |
779 | ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE - | |
780 | ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH - | |
781 | DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB - | |
782 | SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>; | |
783 | */ | |
784 | ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN; | |
785 | ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN; | |
786 | /*BMS assuming 18 bytes of Routing Information (usually works) */ | |
787 | DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n", | |
788 | ti->maxmtu16, ti->maxmtu4); | |
789 | ||
790 | dev->base_addr = PIOaddr; /* set the value for device */ | |
791 | dev->mem_start = ti->sram_base << 12; | |
792 | dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1; | |
793 | trdev_init(dev); | |
794 | return 0; /* Return 0 to indicate we have found a Token Ring card. */ | |
795 | } /*ibmtr_probe1() */ | |
796 | ||
797 | /*****************************************************************************/ | |
798 | ||
799 | /* query the adapter for the size of shared RAM */ | |
800 | /* the function returns the RAM size in units of 512 bytes */ | |
801 | ||
802 | static unsigned char __devinit get_sram_size(struct tok_info *adapt_info) | |
803 | { | |
804 | unsigned char avail_sram_code; | |
805 | static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 }; | |
806 | /* Adapter gives | |
807 | 'F' -- use RRR bits 3,2 | |
808 | 'E' -- 8kb 'D' -- 16kb | |
809 | 'C' -- 32kb 'A' -- 64KB | |
810 | 'B' - 64KB less 512 bytes at top | |
811 | (WARNING ... must zero top bytes in INIT */ | |
812 | ||
813 | avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM); | |
814 | if (avail_sram_code) return size_code[avail_sram_code]; | |
815 | else /* for code 'F', must compute size from RRR(3,2) bits */ | |
816 | return 1 << | |
817 | ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4); | |
818 | } | |
819 | ||
820 | /*****************************************************************************/ | |
821 | ||
c86d8740 SH |
822 | static const struct net_device_ops trdev_netdev_ops = { |
823 | .ndo_open = tok_open, | |
824 | .ndo_stop = tok_close, | |
825 | .ndo_start_xmit = tok_send_packet, | |
afc4b13d | 826 | .ndo_set_rx_mode = tok_set_multicast_list, |
c86d8740 SH |
827 | .ndo_change_mtu = ibmtr_change_mtu, |
828 | }; | |
829 | ||
1da177e4 LT |
830 | static int __devinit trdev_init(struct net_device *dev) |
831 | { | |
eda10531 | 832 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
833 | |
834 | SET_PAGE(ti->srb_page); | |
835 | ti->open_failure = NO ; | |
c86d8740 | 836 | dev->netdev_ops = &trdev_netdev_ops; |
1da177e4 LT |
837 | |
838 | return 0; | |
839 | } | |
840 | ||
841 | /*****************************************************************************/ | |
842 | ||
843 | static int tok_init_card(struct net_device *dev) | |
844 | { | |
845 | struct tok_info *ti; | |
846 | short PIOaddr; | |
847 | unsigned long i; | |
848 | ||
849 | PIOaddr = dev->base_addr; | |
eda10531 | 850 | ti = netdev_priv(dev); |
1da177e4 LT |
851 | /* Special processing for first interrupt after reset */ |
852 | ti->do_tok_int = FIRST_INT; | |
853 | /* Reset adapter */ | |
854 | writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN); | |
855 | outb(0, PIOaddr + ADAPTRESET); | |
856 | ||
3173c890 | 857 | schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */ |
1da177e4 LT |
858 | |
859 | outb(0, PIOaddr + ADAPTRESETREL); | |
860 | #ifdef ENABLE_PAGING | |
861 | if (ti->page_mask) | |
862 | writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN); | |
863 | #endif | |
864 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
865 | i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ); | |
866 | return i? 0 : -EAGAIN; | |
867 | } | |
868 | ||
869 | /*****************************************************************************/ | |
870 | static int tok_open(struct net_device *dev) | |
871 | { | |
eda10531 | 872 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
873 | int i; |
874 | ||
875 | /*the case we were left in a failure state during a previous open */ | |
876 | if (ti->open_failure == YES) { | |
877 | DPRINTK("Last time you were disconnected, how about now?\n"); | |
878 | printk("You can't insert with an ICS connector half-cocked.\n"); | |
879 | } | |
880 | ||
881 | ti->open_status = CLOSED; /* CLOSED or OPEN */ | |
882 | ti->sap_status = CLOSED; /* CLOSED or OPEN */ | |
883 | ti->open_failure = NO; /* NO or YES */ | |
884 | ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */ | |
1da177e4 LT |
885 | |
886 | ti->sram_phys &= ~1; /* to reverse what we do in tok_close */ | |
887 | /* init the spinlock */ | |
888 | spin_lock_init(&ti->lock); | |
889 | init_timer(&ti->tr_timer); | |
890 | ||
891 | i = tok_init_card(dev); | |
892 | if (i) return i; | |
893 | ||
894 | while (1){ | |
895 | tok_open_adapter((unsigned long) dev); | |
896 | i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ); | |
897 | /* sig catch: estimate opening adapter takes more than .5 sec*/ | |
898 | if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */ | |
899 | if (i==0) break; | |
900 | if (ti->open_status == OPEN && ti->sap_status==OPEN) { | |
901 | netif_start_queue(dev); | |
902 | DPRINTK("Adapter is up and running\n"); | |
903 | return 0; | |
904 | } | |
3173c890 NA |
905 | i=schedule_timeout_interruptible(TR_RETRY_INTERVAL); |
906 | /* wait 30 seconds */ | |
1da177e4 LT |
907 | if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */ |
908 | } | |
909 | outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/ | |
910 | DPRINTK("TERMINATED via signal\n"); /*BMS useful */ | |
911 | return -EAGAIN; | |
912 | } | |
913 | ||
914 | /*****************************************************************************/ | |
915 | ||
916 | #define COMMAND_OFST 0 | |
917 | #define OPEN_OPTIONS_OFST 8 | |
918 | #define NUM_RCV_BUF_OFST 24 | |
919 | #define RCV_BUF_LEN_OFST 26 | |
920 | #define DHB_LENGTH_OFST 28 | |
921 | #define NUM_DHB_OFST 30 | |
922 | #define DLC_MAX_SAP_OFST 32 | |
923 | #define DLC_MAX_STA_OFST 33 | |
924 | ||
de70b4c8 | 925 | static void tok_open_adapter(unsigned long dev_addr) |
1da177e4 LT |
926 | { |
927 | struct net_device *dev = (struct net_device *) dev_addr; | |
928 | struct tok_info *ti; | |
929 | int i; | |
930 | ||
eda10531 | 931 | ti = netdev_priv(dev); |
1da177e4 LT |
932 | SET_PAGE(ti->init_srb_page); |
933 | writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD); | |
934 | for (i = 0; i < sizeof(struct dir_open_adapter); i++) | |
935 | writeb(0, ti->init_srb + i); | |
936 | writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST); | |
937 | writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST); | |
938 | if (ti->ring_speed == 16) { | |
939 | writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST); | |
940 | writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST); | |
941 | writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST); | |
942 | } else { | |
943 | writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST); | |
944 | writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST); | |
945 | writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST); | |
946 | } | |
947 | writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST); | |
948 | writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST); | |
949 | writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST); | |
950 | ti->srb = ti->init_srb; /* We use this one in the interrupt handler */ | |
951 | ti->srb_page = ti->init_srb_page; | |
952 | DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n", | |
953 | readb(ti->init_srb + NUM_DHB_OFST), | |
954 | ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)), | |
955 | ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)), | |
956 | ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST))); | |
957 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
958 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
959 | } | |
960 | ||
961 | /*****************************************************************************/ | |
962 | ||
963 | static void open_sap(unsigned char type, struct net_device *dev) | |
964 | { | |
965 | int i; | |
eda10531 | 966 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
967 | |
968 | SET_PAGE(ti->srb_page); | |
969 | for (i = 0; i < sizeof(struct dlc_open_sap); i++) | |
970 | writeb(0, ti->srb + i); | |
971 | ||
972 | #define MAX_I_FIELD_OFST 14 | |
973 | #define SAP_VALUE_OFST 16 | |
974 | #define SAP_OPTIONS_OFST 17 | |
975 | #define STATION_COUNT_OFST 18 | |
976 | ||
977 | writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST); | |
978 | writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST); | |
979 | writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST); | |
980 | writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST); | |
981 | writeb(type, ti->srb + SAP_VALUE_OFST); | |
982 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
983 | } | |
984 | ||
985 | ||
986 | /*****************************************************************************/ | |
987 | ||
988 | static void tok_set_multicast_list(struct net_device *dev) | |
989 | { | |
eda10531 | 990 | struct tok_info *ti = netdev_priv(dev); |
22bedad3 | 991 | struct netdev_hw_addr *ha; |
1da177e4 LT |
992 | unsigned char address[4]; |
993 | ||
994 | int i; | |
995 | ||
996 | /*BMS the next line is CRUCIAL or you may be sad when you */ | |
997 | /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/ | |
998 | if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return; | |
999 | address[0] = address[1] = address[2] = address[3] = 0; | |
22bedad3 JP |
1000 | netdev_for_each_mc_addr(ha, dev) { |
1001 | address[0] |= ha->addr[2]; | |
1002 | address[1] |= ha->addr[3]; | |
1003 | address[2] |= ha->addr[4]; | |
1004 | address[3] |= ha->addr[5]; | |
1da177e4 LT |
1005 | } |
1006 | SET_PAGE(ti->srb_page); | |
1007 | for (i = 0; i < sizeof(struct srb_set_funct_addr); i++) | |
1008 | writeb(0, ti->srb + i); | |
1009 | ||
1010 | #define FUNCT_ADDRESS_OFST 6 | |
1011 | ||
1012 | writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST); | |
1013 | for (i = 0; i < 4; i++) | |
1014 | writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i); | |
1015 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1016 | #if TR_VERBOSE | |
1017 | DPRINTK("Setting functional address: "); | |
1018 | for (i=0;i<4;i++) printk("%02X ", address[i]); | |
1019 | printk("\n"); | |
1020 | #endif | |
1021 | } | |
1022 | ||
1023 | /*****************************************************************************/ | |
1024 | ||
1025 | #define STATION_ID_OFST 4 | |
1026 | ||
61a84108 SH |
1027 | static netdev_tx_t tok_send_packet(struct sk_buff *skb, |
1028 | struct net_device *dev) | |
1da177e4 LT |
1029 | { |
1030 | struct tok_info *ti; | |
1031 | unsigned long flags; | |
eda10531 | 1032 | ti = netdev_priv(dev); |
1da177e4 LT |
1033 | |
1034 | netif_stop_queue(dev); | |
1035 | ||
1036 | /* lock against other CPUs */ | |
1037 | spin_lock_irqsave(&(ti->lock), flags); | |
1038 | ||
1039 | /* Save skb; we'll need it when the adapter asks for the data */ | |
1040 | ti->current_skb = skb; | |
1041 | SET_PAGE(ti->srb_page); | |
1042 | writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST); | |
1043 | writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST); | |
1044 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1045 | spin_unlock_irqrestore(&(ti->lock), flags); | |
6ed10654 | 1046 | return NETDEV_TX_OK; |
1da177e4 LT |
1047 | } |
1048 | ||
1049 | /*****************************************************************************/ | |
1050 | ||
1051 | static int tok_close(struct net_device *dev) | |
1052 | { | |
eda10531 | 1053 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1054 | |
1055 | /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */ | |
1056 | /* unloading the module from memory, and then if a timer pops, ouch */ | |
1057 | del_timer_sync(&ti->tr_timer); | |
1058 | outb(0, dev->base_addr + ADAPTRESET); | |
1059 | ti->sram_phys |= 1; | |
1060 | ti->open_status = CLOSED; | |
1061 | ||
1062 | netif_stop_queue(dev); | |
1063 | DPRINTK("Adapter is closed.\n"); | |
1064 | return 0; | |
1065 | } | |
1066 | ||
1067 | /*****************************************************************************/ | |
1068 | ||
1069 | #define RETCODE_OFST 2 | |
1070 | #define OPEN_ERROR_CODE_OFST 6 | |
1071 | #define ASB_ADDRESS_OFST 8 | |
1072 | #define SRB_ADDRESS_OFST 10 | |
1073 | #define ARB_ADDRESS_OFST 12 | |
1074 | #define SSB_ADDRESS_OFST 14 | |
1075 | ||
1076 | static char *printphase[]= {"Lobe media test","Physical insertion", | |
1077 | "Address verification","Roll call poll","Request Parameters"}; | |
1078 | static char *printerror[]={"Function failure","Signal loss","Reserved", | |
1079 | "Frequency error","Timeout","Ring failure","Ring beaconing", | |
1080 | "Duplicate node address", | |
1081 | "Parameter request-retry count exceeded","Remove received", | |
1082 | "IMPL force received","Duplicate modifier", | |
1083 | "No monitor detected","Monitor contention failed for RPL"}; | |
1084 | ||
1085 | static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page) | |
1086 | { | |
1087 | if (ti->page_mask) { | |
1088 | *page = (index >> 8) & ti->page_mask; | |
1089 | index &= ~(ti->page_mask << 8); | |
1090 | } | |
1091 | return ti->sram_virt + index; | |
1092 | } | |
1093 | ||
de70b4c8 | 1094 | static void dir_open_adapter (struct net_device *dev) |
1da177e4 | 1095 | { |
eda10531 | 1096 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1097 | unsigned char ret_code; |
1098 | __u16 err; | |
1099 | ||
1100 | ti->srb = map_address(ti, | |
1101 | ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)), | |
1102 | &ti->srb_page); | |
1103 | ti->ssb = map_address(ti, | |
1104 | ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)), | |
1105 | &ti->ssb_page); | |
1106 | ti->arb = map_address(ti, | |
1107 | ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)), | |
1108 | &ti->arb_page); | |
1109 | ti->asb = map_address(ti, | |
1110 | ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)), | |
1111 | &ti->asb_page); | |
1112 | ti->current_skb = NULL; | |
1113 | ret_code = readb(ti->init_srb + RETCODE_OFST); | |
1114 | err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST)); | |
1115 | if (!ret_code) { | |
1116 | ti->open_status = OPEN; /* TR adapter is now available */ | |
1117 | if (ti->open_mode == AUTOMATIC) { | |
1118 | DPRINTK("Adapter reopened.\n"); | |
1119 | } | |
1120 | writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD); | |
1121 | open_sap(EXTENDED_SAP, dev); | |
1122 | return; | |
1123 | } | |
1124 | ti->open_failure = YES; | |
1125 | if (ret_code == 7){ | |
1126 | if (err == 0x24) { | |
1127 | if (!ti->auto_speedsave) { | |
1128 | DPRINTK("Open failed: Adapter speed must match " | |
1129 | "ring speed if Automatic Ring Speed Save is " | |
1130 | "disabled.\n"); | |
1131 | ti->open_action = FAIL; | |
1132 | }else | |
1133 | DPRINTK("Retrying open to adjust to " | |
1134 | "ring speed, "); | |
1135 | } else if (err == 0x2d) { | |
1136 | DPRINTK("Physical Insertion: No Monitor Detected, "); | |
1137 | printk("retrying after %ds delay...\n", | |
1138 | TR_RETRY_INTERVAL/HZ); | |
1139 | } else if (err == 0x11) { | |
1140 | DPRINTK("Lobe Media Function Failure (0x11), "); | |
1141 | printk(" retrying after %ds delay...\n", | |
1142 | TR_RETRY_INTERVAL/HZ); | |
1143 | } else { | |
1144 | char **prphase = printphase; | |
1145 | char **prerror = printerror; | |
18eb0893 | 1146 | int pnr = err / 16 - 1; |
1147 | int enr = err % 16 - 1; | |
1da177e4 | 1148 | DPRINTK("TR Adapter misc open failure, error code = "); |
18eb0893 | 1149 | if (pnr < 0 || pnr >= ARRAY_SIZE(printphase) || |
1150 | enr < 0 || | |
1151 | enr >= ARRAY_SIZE(printerror)) | |
1152 | printk("0x%x, invalid Phase/Error.", err); | |
1153 | else | |
1154 | printk("0x%x, Phase: %s, Error: %s\n", err, | |
1155 | prphase[pnr], prerror[enr]); | |
1da177e4 LT |
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 | ||
7d12e780 | 1174 | static irqreturn_t tok_interrupt(int irq, void *dev_id) |
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 | |
7d12e780 | 1186 | DPRINTK("Int from tok_driver, dev : %p irq%d\n", dev,irq); |
1da177e4 | 1187 | #endif |
eda10531 | 1188 | ti = netdev_priv(dev); |
1da177e4 LT |
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 | |
9fd3238e | 1474 | dev->stats.tx_packets++; |
1da177e4 LT |
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 | ||
eda10531 | 1507 | ti = netdev_priv(dev); |
1da177e4 LT |
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); | |
2d6d749d | 1551 | ti->auto_speedsave = (readb(ti->init_srb+INIT_STATUS_2_OFST) & 4) != 0; |
1da177e4 LT |
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 | { | |
eda10531 | 1569 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
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); | |
9fd3238e | 1660 | dev->stats.tx_bytes += ti->current_skb->len; |
1da177e4 LT |
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 | { | |
eda10531 | 1683 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
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); | |
9fd3238e | 1736 | dev->stats.rx_dropped++; |
1da177e4 LT |
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); | |
0795af57 JP |
1751 | u8 saddr[6]; |
1752 | u8 daddr[6]; | |
0795af57 JP |
1753 | int i; |
1754 | for (i = 0 ; i < 6 ; i++) | |
1755 | saddr[i] = readb(trhhdr + SADDR_OFST + i); | |
1756 | for (i = 0 ; i < 6 ; i++) | |
1757 | daddr[i] = readb(trhhdr + DADDR_OFST + i); | |
1da177e4 LT |
1758 | DPRINTK("Probably non-IP frame received.\n"); |
1759 | DPRINTK("ssap: %02X dsap: %02X " | |
e174961c | 1760 | "saddr: %pM daddr: %pM\n", |
1da177e4 | 1761 | readb(llc + SSAP_OFST), readb(llc + DSAP_OFST), |
e174961c | 1762 | saddr, daddr); |
1da177e4 LT |
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"); | |
9fd3238e | 1771 | dev->stats.rx_dropped++; |
1da177e4 LT |
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); | |
1da177e4 LT |
1780 | data = skb->data; |
1781 | rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len))); | |
1782 | rbufdata = rbuf + offsetof(struct rec_buf, data); | |
1783 | ||
1784 | if (IPv4_p) { | |
1785 | /* Copy the headers without checksumming */ | |
1786 | memcpy_fromio(data, rbufdata, hdr_len); | |
1787 | ||
1788 | /* Watch for padded packets and bogons */ | |
1789 | iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc)); | |
1790 | ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr); | |
1791 | length -= hdr_len; | |
1792 | if ((ip_len <= length) && (ip_len > 7)) | |
1793 | length = ip_len; | |
1794 | data += hdr_len; | |
1795 | rbuffer_len -= hdr_len; | |
1796 | rbufdata += hdr_len; | |
1797 | } | |
1798 | /* Copy the payload... */ | |
1799 | #define BUFFER_POINTER_OFST 2 | |
1800 | #define BUFFER_LENGTH_OFST 6 | |
1801 | for (;;) { | |
1802 | if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len) | |
1803 | DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n", | |
1804 | length,rbuffer_len); | |
1805 | if (IPv4_p) | |
1806 | chksum=csum_partial_copy_nocheck((void*)rbufdata, | |
1807 | data,length<rbuffer_len?length:rbuffer_len,chksum); | |
1808 | else | |
1809 | memcpy_fromio(data, rbufdata, rbuffer_len); | |
1810 | rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ; | |
1811 | if (!rbuffer) | |
1812 | break; | |
1813 | rbuffer -= 2; | |
1814 | length -= rbuffer_len; | |
1815 | data += rbuffer_len; | |
1816 | rbuf = map_address(ti, rbuffer, &rbuffer_page); | |
1817 | SET_PAGE(rbuffer_page); | |
1818 | rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST)); | |
1819 | rbufdata = rbuf + offsetof(struct rec_buf, data); | |
1820 | } | |
1821 | ||
1822 | SET_PAGE(ti->asb_page); | |
1823 | writeb(0, ti->asb + offsetof(struct asb_rec, ret_code)); | |
1824 | ||
1825 | writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1826 | ||
9fd3238e SH |
1827 | dev->stats.rx_bytes += skb->len; |
1828 | dev->stats.rx_packets++; | |
1da177e4 LT |
1829 | |
1830 | skb->protocol = tr_type_trans(skb, dev); | |
1831 | if (IPv4_p) { | |
1832 | skb->csum = chksum; | |
ee28b0da | 1833 | skb->ip_summed = CHECKSUM_COMPLETE; |
1da177e4 LT |
1834 | } |
1835 | netif_rx(skb); | |
1da177e4 LT |
1836 | } /*tr_rx */ |
1837 | ||
1838 | /*****************************************************************************/ | |
1839 | ||
de70b4c8 | 1840 | static void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev) |
1da177e4 LT |
1841 | { |
1842 | tmr->expires = jiffies + TR_RETRY_INTERVAL; | |
1843 | tmr->data = (unsigned long) dev; | |
1844 | tmr->function = tok_rerun; | |
1845 | init_timer(tmr); | |
1846 | add_timer(tmr); | |
1847 | } | |
1848 | ||
1849 | /*****************************************************************************/ | |
1850 | ||
27cd6ae5 HE |
1851 | static void tok_rerun(unsigned long dev_addr) |
1852 | { | |
1da177e4 | 1853 | struct net_device *dev = (struct net_device *)dev_addr; |
eda10531 | 1854 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1855 | |
1856 | if ( ti->open_action == RESTART){ | |
1857 | ti->do_tok_int = FIRST_INT; | |
1858 | outb(0, dev->base_addr + ADAPTRESETREL); | |
1859 | #ifdef ENABLE_PAGING | |
1860 | if (ti->page_mask) | |
1861 | writeb(SRPR_ENABLE_PAGING, | |
1862 | ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN); | |
1863 | #endif | |
1864 | ||
1865 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
1866 | } else | |
1867 | tok_open_adapter(dev_addr); | |
1868 | } | |
1869 | ||
1870 | /*****************************************************************************/ | |
1871 | ||
de70b4c8 | 1872 | static void ibmtr_readlog(struct net_device *dev) |
1da177e4 LT |
1873 | { |
1874 | struct tok_info *ti; | |
1875 | ||
eda10531 | 1876 | ti = netdev_priv(dev); |
1da177e4 LT |
1877 | |
1878 | ti->readlog_pending = 0; | |
1879 | SET_PAGE(ti->srb_page); | |
1880 | writeb(DIR_READ_LOG, ti->srb); | |
1881 | writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN); | |
1882 | writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD); | |
1883 | ||
1884 | netif_stop_queue(dev); | |
1885 | ||
1886 | } | |
1887 | ||
1888 | /*****************************************************************************/ | |
1889 | ||
de70b4c8 | 1890 | static int ibmtr_change_mtu(struct net_device *dev, int mtu) |
1da177e4 | 1891 | { |
eda10531 | 1892 | struct tok_info *ti = netdev_priv(dev); |
1da177e4 LT |
1893 | |
1894 | if (ti->ring_speed == 16 && mtu > ti->maxmtu16) | |
1895 | return -EINVAL; | |
1896 | if (ti->ring_speed == 4 && mtu > ti->maxmtu4) | |
1897 | return -EINVAL; | |
1898 | dev->mtu = mtu; | |
1899 | return 0; | |
1900 | } | |
1901 | ||
1902 | /*****************************************************************************/ | |
1903 | #ifdef MODULE | |
1904 | ||
1905 | /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */ | |
1906 | static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS]; | |
1907 | static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 }; | |
1908 | static int irq[IBMTR_MAX_ADAPTERS]; | |
1909 | static int mem[IBMTR_MAX_ADAPTERS]; | |
1910 | ||
1911 | MODULE_LICENSE("GPL"); | |
1912 | ||
1913 | module_param_array(io, int, NULL, 0); | |
1914 | module_param_array(irq, int, NULL, 0); | |
1915 | module_param_array(mem, int, NULL, 0); | |
1916 | ||
1917 | static int __init ibmtr_init(void) | |
1918 | { | |
1919 | int i; | |
1920 | int count=0; | |
1921 | ||
1922 | find_turbo_adapters(io); | |
1923 | ||
c65d3198 | 1924 | for (i = 0; i < IBMTR_MAX_ADAPTERS && io[i]; i++) { |
1da177e4 LT |
1925 | struct net_device *dev; |
1926 | irq[i] = 0; | |
1927 | mem[i] = 0; | |
1928 | dev = alloc_trdev(sizeof(struct tok_info)); | |
1929 | if (dev == NULL) { | |
1930 | if (i == 0) | |
1931 | return -ENOMEM; | |
1932 | break; | |
1933 | } | |
1934 | dev->base_addr = io[i]; | |
1935 | dev->irq = irq[i]; | |
1936 | dev->mem_start = mem[i]; | |
1937 | ||
1938 | if (ibmtr_probe_card(dev)) { | |
1939 | free_netdev(dev); | |
1940 | continue; | |
1941 | } | |
1942 | dev_ibmtr[i] = dev; | |
1943 | count++; | |
1944 | } | |
1945 | if (count) return 0; | |
1946 | printk("ibmtr: register_netdev() returned non-zero.\n"); | |
1947 | return -EIO; | |
1948 | } | |
1949 | module_init(ibmtr_init); | |
1950 | ||
1951 | static void __exit ibmtr_cleanup(void) | |
1952 | { | |
1953 | int i; | |
1954 | ||
1955 | for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){ | |
1956 | if (!dev_ibmtr[i]) | |
1957 | continue; | |
1958 | unregister_netdev(dev_ibmtr[i]); | |
1959 | ibmtr_cleanup_card(dev_ibmtr[i]); | |
1960 | free_netdev(dev_ibmtr[i]); | |
1961 | } | |
1962 | } | |
1963 | module_exit(ibmtr_cleanup); | |
1964 | #endif |