module_param: make bool parameters really bool (net & drivers/net)
[linux-2.6.git] / drivers / net / irda / donauboe.c
1 /*****************************************************************
2  *
3  * Filename:            donauboe.c
4  * Version:             2.17
5  * Description:   Driver for the Toshiba OBOE (or type-O or 701)
6  *                FIR Chipset, also supports the DONAUOBOE (type-DO
7  *                or d01) FIR chipset which as far as I know is
8  *                register compatible.
9  * Documentation: http://libxg.free.fr/irda/lib-irda.html
10  * Status:        Experimental.
11  * Author:        James McKenzie <james@fishsoup.dhs.org>
12  * Created at:    Sat May 8  12:35:27 1999
13  * Modified:      Paul Bristow <paul.bristow@technologist.com>
14  * Modified:      Mon Nov 11 19:10:05 1999
15  * Modified:      James McKenzie <james@fishsoup.dhs.org>
16  * Modified:      Thu Mar 16 12:49:00 2000 (Substantial rewrite)
17  * Modified:      Sat Apr 29 00:23:03 2000 (Added DONAUOBOE support)
18  * Modified:      Wed May 24 23:45:02 2000 (Fixed chipio_t structure)
19  * Modified: 2.13 Christian Gennerat <christian.gennerat@polytechnique.org>
20  * Modified: 2.13 dim jan 07 21:57:39 2001 (tested with kernel 2.4 & irnet/ppp)
21  * Modified: 2.14 Christian Gennerat <christian.gennerat@polytechnique.org>
22  * Modified: 2.14 lun fev 05 17:55:59 2001 (adapted to patch-2.4.1-pre8-irda1)
23  * Modified: 2.15 Martin Lucina <mato@kotelna.sk>
24  * Modified: 2.15 Fri Jun 21 20:40:59 2002 (sync with 2.4.18, substantial fixes)
25  * Modified: 2.16 Martin Lucina <mato@kotelna.sk>
26  * Modified: 2.16 Sat Jun 22 18:54:29 2002 (fix freeregion, default to verbose)
27  * Modified: 2.17 Christian Gennerat <christian.gennerat@polytechnique.org>
28  * Modified: 2.17 jeu sep 12 08:50:20 2002 (save_flags();cli(); replaced by spinlocks)
29  * Modified: 2.18 Christian Gennerat <christian.gennerat@polytechnique.org>
30  * Modified: 2.18 ven jan 10 03:14:16 2003 Change probe default options
31  *
32  *     Copyright (c) 1999 James McKenzie, All Rights Reserved.
33  *
34  *     This program is free software; you can redistribute it and/or
35  *     modify it under the terms of the GNU General Public License as
36  *     published by the Free Software Foundation; either version 2 of
37  *     the License, or (at your option) any later version.
38  *
39  *     Neither James McKenzie nor Cambridge University admit liability nor
40  *     provide warranty for any of this software. This material is
41  *     provided "AS-IS" and at no charge.
42  *
43  *     Applicable Models : Libretto 100/110CT and many more.
44  *     Toshiba refers to this chip as the type-O IR port,
45  *     or the type-DO IR port.
46  *
47  ********************************************************************/
48
49 /* Look at toshoboe.h (currently in include/net/irda) for details of */
50 /* Where to get documentation on the chip         */
51
52 /* See below for a description of the logic in this driver */
53
54 /* User servicable parts */
55 /* USE_PROBE Create the code which probes the chip and does a few tests */
56 /* do_probe module parameter Enable this code */
57 /* Probe code is very useful for understanding how the hardware works */
58 /* Use it with various combinations of TT_LEN, RX_LEN */
59 /* Strongly recommended, disable if the probe fails on your machine */
60 /* and send me <james@fishsoup.dhs.org> the output of dmesg */
61 #define USE_PROBE 1
62 #undef  USE_PROBE
63
64 /* Trace Transmit ring, interrupts, Receive ring or not ? */
65 #define PROBE_VERBOSE 1
66
67 /* Debug option, examine sent and received raw data */
68 /* Irdadump is better, but does not see all packets. enable it if you want. */
69 #undef DUMP_PACKETS
70
71 /* MIR mode has not been tested. Some behaviour is different */
72 /* Seems to work against an Ericsson R520 for me. -Martin */
73 #define USE_MIR
74
75 /* Schedule back to back hardware transmits wherever possible, otherwise */
76 /* we need an interrupt for every frame, unset if oboe works for a bit and */
77 /* then hangs */
78 #define OPTIMIZE_TX
79
80 /* Set the number of slots in the rings */
81 /* If you get rx/tx fifo overflows at high bitrates, you can try increasing */
82 /* these */
83
84 #define RING_SIZE (OBOE_RING_SIZE_RX8 | OBOE_RING_SIZE_TX8)
85 #define TX_SLOTS    8
86 #define RX_SLOTS    8
87
88
89 /* Less user servicable parts below here */
90
91 /* Test, Transmit and receive buffer sizes, adjust at your peril */
92 /* remarks: nfs usually needs 1k blocks */
93 /* remarks: in SIR mode, CRC is received, -> RX_LEN=TX_LEN+2 */
94 /* remarks: test accepts large blocks. Standard is 0x80 */
95 /* When TT_LEN > RX_LEN (SIR mode) data is stored in successive slots. */
96 /* When 3 or more slots are needed for each test packet, */
97 /* data received in the first slots is overwritten, even */
98 /* if OBOE_CTL_RX_HW_OWNS is not set, without any error! */
99 #define TT_LEN      0x80
100 #define TX_LEN      0xc00
101 #define RX_LEN      0xc04
102 /* Real transmitted length (SIR mode) is about 14+(2%*TX_LEN) more */
103 /* long than user-defined length (see async_wrap_skb) and is less then 4K */
104 /* Real received length is (max RX_LEN) differs from user-defined */
105 /* length only b the CRC (2 or 4 bytes) */
106 #define BUF_SAFETY  0x7a
107 #define RX_BUF_SZ   (RX_LEN)
108 #define TX_BUF_SZ   (TX_LEN+BUF_SAFETY)
109
110
111 /* Logic of the netdev part of this driver                             */
112
113 /* The RX ring is filled with buffers, when a packet arrives           */
114 /* it is DMA'd into the buffer which is marked used and RxDone called  */
115 /* RxDone forms an skb (and checks the CRC if in SIR mode) and ships   */
116 /* the packet off upstairs */
117
118 /* The transmitter on the oboe chip can work in one of two modes       */
119 /* for each ring->tx[] the transmitter can either                      */
120 /* a) transmit the packet, leave the trasmitter enabled and proceed to */
121 /*    the next ring                                                    */
122 /* OR                                                                  */
123 /* b) transmit the packet, switch off the transmitter and issue TxDone */
124
125 /* All packets are entered into the ring in mode b), if the ring was   */
126 /* empty the transmitter is started.                                   */
127
128 /* If OPTIMIZE_TX is defined then in TxDone if the ring contains       */
129 /* more than one packet, all but the last are set to mode a) [HOWEVER  */
130 /* the hardware may not notice this, this is why we start in mode b) ] */
131 /* then restart the transmitter                                        */
132
133 /* If OPTIMIZE_TX is not defined then we just restart the transmitter  */
134 /* if the ring isn't empty */
135
136 /* Speed changes are delayed until the TxRing is empty                 */
137 /* mtt is handled by generating packets with bad CRCs, before the data */
138
139 /* TODO: */
140 /* check the mtt works ok      */
141 /* finish the watchdog         */
142
143 /* No user servicable parts below here */
144
145 #include <linux/module.h>
146
147 #include <linux/kernel.h>
148 #include <linux/types.h>
149 #include <linux/skbuff.h>
150 #include <linux/netdevice.h>
151 #include <linux/ioport.h>
152 #include <linux/delay.h>
153 #include <linux/slab.h>
154 #include <linux/init.h>
155 #include <linux/interrupt.h>
156 #include <linux/pci.h>
157 #include <linux/rtnetlink.h>
158
159 #include <asm/system.h>
160 #include <asm/io.h>
161
162 #include <net/irda/wrapper.h>
163 #include <net/irda/irda.h>
164 //#include <net/irda/irmod.h>
165 //#include <net/irda/irlap_frame.h>
166 #include <net/irda/irda_device.h>
167 #include <net/irda/crc.h>
168
169 #include "donauboe.h"
170
171 #define INB(port)       inb_p(port)
172 #define OUTB(val,port)  outb_p(val,port)
173 #define OUTBP(val,port) outb_p(val,port)
174
175 #define PROMPT  OUTB(OBOE_PROMPT_BIT,OBOE_PROMPT);
176
177 #if PROBE_VERBOSE
178 #define PROBE_DEBUG(args...) (printk (args))
179 #else
180 #define PROBE_DEBUG(args...) ;
181 #endif
182
183 /* Set the DMA to be byte at a time */
184 #define CONFIG0H_DMA_OFF OBOE_CONFIG0H_RCVANY
185 #define CONFIG0H_DMA_ON_NORX CONFIG0H_DMA_OFF| OBOE_CONFIG0H_ENDMAC
186 #define CONFIG0H_DMA_ON CONFIG0H_DMA_ON_NORX | OBOE_CONFIG0H_ENRX
187
188 static DEFINE_PCI_DEVICE_TABLE(toshoboe_pci_tbl) = {
189         { PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_FIR701, PCI_ANY_ID, PCI_ANY_ID, },
190         { PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_FIRD01, PCI_ANY_ID, PCI_ANY_ID, },
191         { }                     /* Terminating entry */
192 };
193 MODULE_DEVICE_TABLE(pci, toshoboe_pci_tbl);
194
195 #define DRIVER_NAME "toshoboe"
196 static char *driver_name = DRIVER_NAME;
197
198 static int max_baud = 4000000;
199 #ifdef USE_PROBE
200 static bool do_probe = false;
201 #endif
202
203
204 /**********************************************************************/
205 static int
206 toshoboe_checkfcs (unsigned char *buf, int len)
207 {
208   int i;
209   union
210   {
211     __u16 value;
212     __u8 bytes[2];
213   }
214   fcs;
215
216   fcs.value = INIT_FCS;
217
218   for (i = 0; i < len; ++i)
219     fcs.value = irda_fcs (fcs.value, *(buf++));
220
221   return fcs.value == GOOD_FCS;
222 }
223
224 /***********************************************************************/
225 /* Generic chip handling code */
226 #ifdef DUMP_PACKETS
227 static unsigned char dump[50];
228 static void
229 _dumpbufs (unsigned char *data, int len, char tete)
230 {
231 int i,j;
232 char head=tete;
233 for (i=0;i<len;i+=16) {
234     for (j=0;j<16 && i+j<len;j++) { sprintf(&dump[3*j],"%02x.",data[i+j]); }
235     dump [3*j]=0;
236     IRDA_DEBUG (2, "%c%s\n",head , dump);
237     head='+';
238     }
239 }
240 #endif
241
242 #ifdef USE_PROBE
243 /* Dump the registers */
244 static void
245 toshoboe_dumpregs (struct toshoboe_cb *self)
246 {
247   __u32 ringbase;
248
249   IRDA_DEBUG (4, "%s()\n", __func__);
250
251   ringbase = INB (OBOE_RING_BASE0) << 10;
252   ringbase |= INB (OBOE_RING_BASE1) << 18;
253   ringbase |= INB (OBOE_RING_BASE2) << 26;
254
255   printk (KERN_ERR DRIVER_NAME ": Register dump:\n");
256   printk (KERN_ERR "Interrupts: Tx:%d Rx:%d TxUnder:%d RxOver:%d Sip:%d\n",
257           self->int_tx, self->int_rx, self->int_txunder, self->int_rxover,
258           self->int_sip);
259   printk (KERN_ERR "RX %02x TX %02x RingBase %08x\n",
260           INB (OBOE_RXSLOT), INB (OBOE_TXSLOT), ringbase);
261   printk (KERN_ERR "RING_SIZE %02x IER %02x ISR %02x\n",
262           INB (OBOE_RING_SIZE), INB (OBOE_IER), INB (OBOE_ISR));
263   printk (KERN_ERR "CONFIG1 %02x STATUS %02x\n",
264           INB (OBOE_CONFIG1), INB (OBOE_STATUS));
265   printk (KERN_ERR "CONFIG0 %02x%02x ENABLE %02x%02x\n",
266           INB (OBOE_CONFIG0H), INB (OBOE_CONFIG0L),
267           INB (OBOE_ENABLEH), INB (OBOE_ENABLEL));
268   printk (KERN_ERR "NEW_PCONFIG %02x%02x CURR_PCONFIG %02x%02x\n",
269           INB (OBOE_NEW_PCONFIGH), INB (OBOE_NEW_PCONFIGL),
270           INB (OBOE_CURR_PCONFIGH), INB (OBOE_CURR_PCONFIGL));
271   printk (KERN_ERR "MAXLEN %02x%02x RXCOUNT %02x%02x\n",
272           INB (OBOE_MAXLENH), INB (OBOE_MAXLENL),
273           INB (OBOE_RXCOUNTL), INB (OBOE_RXCOUNTH));
274
275   if (self->ring)
276     {
277       int i;
278       ringbase = virt_to_bus (self->ring);
279       printk (KERN_ERR "Ring at %08x:\n", ringbase);
280       printk (KERN_ERR "RX:");
281       for (i = 0; i < RX_SLOTS; ++i)
282         printk (" (%d,%02x)",self->ring->rx[i].len,self->ring->rx[i].control);
283       printk ("\n");
284       printk (KERN_ERR "TX:");
285       for (i = 0; i < RX_SLOTS; ++i)
286         printk (" (%d,%02x)",self->ring->tx[i].len,self->ring->tx[i].control);
287       printk ("\n");
288     }
289 }
290 #endif
291
292 /*Don't let the chip look at memory */
293 static void
294 toshoboe_disablebm (struct toshoboe_cb *self)
295 {
296   __u8 command;
297   IRDA_DEBUG (4, "%s()\n", __func__);
298
299   pci_read_config_byte (self->pdev, PCI_COMMAND, &command);
300   command &= ~PCI_COMMAND_MASTER;
301   pci_write_config_byte (self->pdev, PCI_COMMAND, command);
302
303 }
304
305 /* Shutdown the chip and point the taskfile reg somewhere else */
306 static void
307 toshoboe_stopchip (struct toshoboe_cb *self)
308 {
309   IRDA_DEBUG (4, "%s()\n", __func__);
310
311   /*Disable interrupts */
312   OUTB (0x0, OBOE_IER);
313   /*Disable DMA, Disable Rx, Disable Tx */
314   OUTB (CONFIG0H_DMA_OFF, OBOE_CONFIG0H);
315   /*Disable SIR MIR FIR, Tx and Rx */
316   OUTB (0x00, OBOE_ENABLEH);
317   /*Point the ring somewhere safe */
318   OUTB (0x3f, OBOE_RING_BASE2);
319   OUTB (0xff, OBOE_RING_BASE1);
320   OUTB (0xff, OBOE_RING_BASE0);
321
322   OUTB (RX_LEN >> 8, OBOE_MAXLENH);
323   OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
324
325   /*Acknoledge any pending interrupts */
326   OUTB (0xff, OBOE_ISR);
327
328   /*Why */
329   OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
330
331   /*switch it off */
332   OUTB (OBOE_CONFIG1_OFF, OBOE_CONFIG1);
333
334   toshoboe_disablebm (self);
335 }
336
337 /* Transmitter initialization */
338 static void
339 toshoboe_start_DMA (struct toshoboe_cb *self, int opts)
340 {
341   OUTB (0x0, OBOE_ENABLEH);
342   OUTB (CONFIG0H_DMA_ON | opts,  OBOE_CONFIG0H);
343   OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
344   PROMPT;
345 }
346
347 /*Set the baud rate */
348 static void
349 toshoboe_setbaud (struct toshoboe_cb *self)
350 {
351   __u16 pconfig = 0;
352   __u8 config0l = 0;
353
354   IRDA_DEBUG (2, "%s(%d/%d)\n", __func__, self->speed, self->io.speed);
355
356   switch (self->speed)
357     {
358     case 2400:
359     case 4800:
360     case 9600:
361     case 19200:
362     case 38400:
363     case 57600:
364     case 115200:
365 #ifdef USE_MIR
366     case 1152000:
367 #endif
368     case 4000000:
369       break;
370     default:
371
372       printk (KERN_ERR DRIVER_NAME ": switch to unsupported baudrate %d\n",
373               self->speed);
374       return;
375     }
376
377   switch (self->speed)
378     {
379       /* For SIR the preamble is done by adding XBOFs */
380       /* to the packet */
381       /* set to filtered SIR mode, filter looks for BOF and EOF */
382     case 2400:
383       pconfig |= 47 << OBOE_PCONFIG_BAUDSHIFT;
384       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
385       break;
386     case 4800:
387       pconfig |= 23 << OBOE_PCONFIG_BAUDSHIFT;
388       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
389       break;
390     case 9600:
391       pconfig |= 11 << OBOE_PCONFIG_BAUDSHIFT;
392       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
393       break;
394     case 19200:
395       pconfig |= 5 << OBOE_PCONFIG_BAUDSHIFT;
396       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
397       break;
398     case 38400:
399       pconfig |= 2 << OBOE_PCONFIG_BAUDSHIFT;
400       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
401       break;
402     case 57600:
403       pconfig |= 1 << OBOE_PCONFIG_BAUDSHIFT;
404       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
405       break;
406     case 115200:
407       pconfig |= 0 << OBOE_PCONFIG_BAUDSHIFT;
408       pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
409       break;
410     default:
411       /*Set to packet based reception */
412       OUTB (RX_LEN >> 8, OBOE_MAXLENH);
413       OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
414       break;
415     }
416
417   switch (self->speed)
418     {
419     case 2400:
420     case 4800:
421     case 9600:
422     case 19200:
423     case 38400:
424     case 57600:
425     case 115200:
426       config0l = OBOE_CONFIG0L_ENSIR;
427       if (self->async)
428         {
429           /*Set to character based reception */
430           /*System will lock if MAXLEN=0 */
431           /*so have to be careful */
432           OUTB (0x01, OBOE_MAXLENH);
433           OUTB (0x01, OBOE_MAXLENL);
434           OUTB (0x00, OBOE_MAXLENH);
435         }
436       else
437         {
438           /*Set to packet based reception */
439           config0l |= OBOE_CONFIG0L_ENSIRF;
440           OUTB (RX_LEN >> 8, OBOE_MAXLENH);
441           OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
442         }
443       break;
444
445 #ifdef USE_MIR
446       /* MIR mode */
447       /* Set for 16 bit CRC and enable MIR */
448       /* Preamble now handled by the chip */
449     case 1152000:
450       pconfig |= 0 << OBOE_PCONFIG_BAUDSHIFT;
451       pconfig |= 8 << OBOE_PCONFIG_WIDTHSHIFT;
452       pconfig |= 1 << OBOE_PCONFIG_PREAMBLESHIFT;
453       config0l = OBOE_CONFIG0L_CRC16 | OBOE_CONFIG0L_ENMIR;
454       break;
455 #endif
456       /* FIR mode */
457       /* Set for 32 bit CRC and enable FIR */
458       /* Preamble handled by the chip */
459     case 4000000:
460       pconfig |= 0 << OBOE_PCONFIG_BAUDSHIFT;
461       /* Documentation says 14, but toshiba use 15 in their drivers */
462       pconfig |= 15 << OBOE_PCONFIG_PREAMBLESHIFT;
463       config0l = OBOE_CONFIG0L_ENFIR;
464       break;
465     }
466
467   /* Copy into new PHY config buffer */
468   OUTBP (pconfig >> 8, OBOE_NEW_PCONFIGH);
469   OUTB (pconfig & 0xff, OBOE_NEW_PCONFIGL);
470   OUTB (config0l, OBOE_CONFIG0L);
471
472   /* Now make OBOE copy from new PHY to current PHY */
473   OUTB (0x0, OBOE_ENABLEH);
474   OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
475   PROMPT;
476
477   /* speed change executed */
478   self->new_speed = 0;
479   self->io.speed = self->speed;
480 }
481
482 /*Let the chip look at memory */
483 static void
484 toshoboe_enablebm (struct toshoboe_cb *self)
485 {
486   IRDA_DEBUG (4, "%s()\n", __func__);
487   pci_set_master (self->pdev);
488 }
489
490 /*setup the ring */
491 static void
492 toshoboe_initring (struct toshoboe_cb *self)
493 {
494   int i;
495
496   IRDA_DEBUG (4, "%s()\n", __func__);
497
498   for (i = 0; i < TX_SLOTS; ++i)
499     {
500       self->ring->tx[i].len = 0;
501       self->ring->tx[i].control = 0x00;
502       self->ring->tx[i].address = virt_to_bus (self->tx_bufs[i]);
503     }
504
505   for (i = 0; i < RX_SLOTS; ++i)
506     {
507       self->ring->rx[i].len = RX_LEN;
508       self->ring->rx[i].len = 0;
509       self->ring->rx[i].address = virt_to_bus (self->rx_bufs[i]);
510       self->ring->rx[i].control = OBOE_CTL_RX_HW_OWNS;
511     }
512 }
513
514 static void
515 toshoboe_resetptrs (struct toshoboe_cb *self)
516 {
517   /* Can reset pointers by twidling DMA */
518   OUTB (0x0, OBOE_ENABLEH);
519   OUTBP (CONFIG0H_DMA_OFF, OBOE_CONFIG0H);
520   OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
521
522   self->rxs = inb_p (OBOE_RXSLOT) & OBOE_SLOT_MASK;
523   self->txs = inb_p (OBOE_TXSLOT) & OBOE_SLOT_MASK;
524 }
525
526 /* Called in locked state */
527 static void
528 toshoboe_initptrs (struct toshoboe_cb *self)
529 {
530
531   /* spin_lock_irqsave(self->spinlock, flags); */
532   /* save_flags (flags); */
533
534   /* Can reset pointers by twidling DMA */
535   toshoboe_resetptrs (self);
536
537   OUTB (0x0, OBOE_ENABLEH);
538   OUTB (CONFIG0H_DMA_ON, OBOE_CONFIG0H);
539   OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
540
541   self->txpending = 0;
542
543   /* spin_unlock_irqrestore(self->spinlock, flags); */
544   /* restore_flags (flags); */
545 }
546
547 /* Wake the chip up and get it looking at the rings */
548 /* Called in locked state */
549 static void
550 toshoboe_startchip (struct toshoboe_cb *self)
551 {
552   __u32 physaddr;
553
554   IRDA_DEBUG (4, "%s()\n", __func__);
555
556   toshoboe_initring (self);
557   toshoboe_enablebm (self);
558   OUTBP (OBOE_CONFIG1_RESET, OBOE_CONFIG1);
559   OUTBP (OBOE_CONFIG1_ON, OBOE_CONFIG1);
560
561   /* Stop the clocks */
562   OUTB (0, OBOE_ENABLEH);
563
564   /*Set size of rings */
565   OUTB (RING_SIZE, OBOE_RING_SIZE);
566
567   /*Acknoledge any pending interrupts */
568   OUTB (0xff, OBOE_ISR);
569
570   /*Enable ints */
571   OUTB (OBOE_INT_TXDONE  | OBOE_INT_RXDONE |
572         OBOE_INT_TXUNDER | OBOE_INT_RXOVER | OBOE_INT_SIP , OBOE_IER);
573
574   /*Acknoledge any pending interrupts */
575   OUTB (0xff, OBOE_ISR);
576
577   /*Set the maximum packet length to 0xfff (4095) */
578   OUTB (RX_LEN >> 8, OBOE_MAXLENH);
579   OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
580
581   /*Shutdown DMA */
582   OUTB (CONFIG0H_DMA_OFF, OBOE_CONFIG0H);
583
584   /*Find out where the rings live */
585   physaddr = virt_to_bus (self->ring);
586
587   IRDA_ASSERT ((physaddr & 0x3ff) == 0,
588                printk (KERN_ERR DRIVER_NAME "ring not correctly aligned\n");
589                return;);
590
591   OUTB ((physaddr >> 10) & 0xff, OBOE_RING_BASE0);
592   OUTB ((physaddr >> 18) & 0xff, OBOE_RING_BASE1);
593   OUTB ((physaddr >> 26) & 0x3f, OBOE_RING_BASE2);
594
595   /*Enable DMA controller in byte mode and RX */
596   OUTB (CONFIG0H_DMA_ON, OBOE_CONFIG0H);
597
598   /* Start up the clocks */
599   OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
600
601   /*set to sensible speed */
602   self->speed = 9600;
603   toshoboe_setbaud (self);
604   toshoboe_initptrs (self);
605 }
606
607 static void
608 toshoboe_isntstuck (struct toshoboe_cb *self)
609 {
610 }
611
612 static void
613 toshoboe_checkstuck (struct toshoboe_cb *self)
614 {
615   unsigned long flags;
616
617   if (0)
618     {
619       spin_lock_irqsave(&self->spinlock, flags);
620
621       /* This will reset the chip completely */
622       printk (KERN_ERR DRIVER_NAME ": Resetting chip\n");
623
624       toshoboe_stopchip (self);
625       toshoboe_startchip (self);
626       spin_unlock_irqrestore(&self->spinlock, flags);
627     }
628 }
629
630 /*Generate packet of about mtt us long */
631 static int
632 toshoboe_makemttpacket (struct toshoboe_cb *self, void *buf, int mtt)
633 {
634   int xbofs;
635
636   xbofs = ((int) (mtt/100)) * (int) (self->speed);
637   xbofs=xbofs/80000; /*Eight bits per byte, and mtt is in us*/
638   xbofs++;
639
640   IRDA_DEBUG (2, DRIVER_NAME
641       ": generated mtt of %d bytes for %d us at %d baud\n"
642           , xbofs,mtt,self->speed);
643
644   if (xbofs > TX_LEN)
645     {
646       printk (KERN_ERR DRIVER_NAME ": wanted %d bytes MTT but TX_LEN is %d\n",
647               xbofs, TX_LEN);
648       xbofs = TX_LEN;
649     }
650
651   /*xbofs will do for SIR, MIR and FIR,SIR mode doesn't generate a checksum anyway */
652   memset (buf, XBOF, xbofs);
653
654   return xbofs;
655 }
656
657 #ifdef USE_PROBE
658 /***********************************************************************/
659 /* Probe code */
660
661 static void
662 toshoboe_dumptx (struct toshoboe_cb *self)
663 {
664   int i;
665   PROBE_DEBUG(KERN_WARNING "TX:");
666   for (i = 0; i < RX_SLOTS; ++i)
667     PROBE_DEBUG(" (%d,%02x)",self->ring->tx[i].len,self->ring->tx[i].control);
668   PROBE_DEBUG(" [%d]\n",self->speed);
669 }
670
671 static void
672 toshoboe_dumprx (struct toshoboe_cb *self, int score)
673 {
674   int i;
675   PROBE_DEBUG(" %d\nRX:",score);
676   for (i = 0; i < RX_SLOTS; ++i)
677     PROBE_DEBUG(" (%d,%02x)",self->ring->rx[i].len,self->ring->rx[i].control);
678   PROBE_DEBUG("\n");
679 }
680
681 static inline int
682 stuff_byte (__u8 byte, __u8 * buf)
683 {
684   switch (byte)
685     {
686     case BOF:                  /* FALLTHROUGH */
687     case EOF:                  /* FALLTHROUGH */
688     case CE:
689       /* Insert transparently coded */
690       buf[0] = CE;              /* Send link escape */
691       buf[1] = byte ^ IRDA_TRANS; /* Complement bit 5 */
692       return 2;
693       /* break; */
694     default:
695       /* Non-special value, no transparency required */
696       buf[0] = byte;
697       return 1;
698       /* break; */
699     }
700 }
701
702 static irqreturn_t
703 toshoboe_probeinterrupt (int irq, void *dev_id)
704 {
705   struct toshoboe_cb *self = dev_id;
706   __u8 irqstat;
707
708   irqstat = INB (OBOE_ISR);
709
710 /* was it us */
711   if (!(irqstat & OBOE_INT_MASK))
712     return IRQ_NONE;
713
714 /* Ack all the interrupts */
715   OUTB (irqstat, OBOE_ISR);
716
717   if (irqstat & OBOE_INT_TXDONE)
718     {
719       int txp;
720
721       self->int_tx++;
722       PROBE_DEBUG("T");
723
724       txp = INB (OBOE_TXSLOT) & OBOE_SLOT_MASK;
725       if (self->ring->tx[txp].control & OBOE_CTL_TX_HW_OWNS)
726         {
727           self->int_tx+=100;
728           PROBE_DEBUG("S");
729           toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
730         }
731     }
732
733   if (irqstat & OBOE_INT_RXDONE) {
734     self->int_rx++;
735     PROBE_DEBUG("R"); }
736   if (irqstat & OBOE_INT_TXUNDER) {
737     self->int_txunder++;
738     PROBE_DEBUG("U"); }
739   if (irqstat & OBOE_INT_RXOVER) {
740     self->int_rxover++;
741     PROBE_DEBUG("O"); }
742   if (irqstat & OBOE_INT_SIP) {
743     self->int_sip++;
744     PROBE_DEBUG("I"); }
745   return IRQ_HANDLED;
746 }
747
748 static int
749 toshoboe_maketestpacket (unsigned char *buf, int badcrc, int fir)
750 {
751   int i;
752   int len = 0;
753   union
754   {
755     __u16 value;
756     __u8 bytes[2];
757   }
758   fcs;
759
760   if (fir)
761     {
762       memset (buf, 0, TT_LEN);
763       return TT_LEN;
764     }
765
766   fcs.value = INIT_FCS;
767
768   memset (buf, XBOF, 10);
769   len += 10;
770   buf[len++] = BOF;
771
772   for (i = 0; i < TT_LEN; ++i)
773     {
774       len += stuff_byte (i, buf + len);
775       fcs.value = irda_fcs (fcs.value, i);
776     }
777
778   len += stuff_byte (fcs.bytes[0] ^ badcrc, buf + len);
779   len += stuff_byte (fcs.bytes[1] ^ badcrc, buf + len);
780   buf[len++] = EOF;
781   len++;
782   return len;
783 }
784
785 static int
786 toshoboe_probefail (struct toshoboe_cb *self, char *msg)
787 {
788   printk (KERN_ERR DRIVER_NAME "probe(%d) failed %s\n",self-> speed, msg);
789   toshoboe_dumpregs (self);
790   toshoboe_stopchip (self);
791   free_irq (self->io.irq, (void *) self);
792   return 0;
793 }
794
795 static int
796 toshoboe_numvalidrcvs (struct toshoboe_cb *self)
797 {
798   int i, ret = 0;
799   for (i = 0; i < RX_SLOTS; ++i)
800     if ((self->ring->rx[i].control & 0xe0) == 0)
801       ret++;
802
803   return ret;
804 }
805
806 static int
807 toshoboe_numrcvs (struct toshoboe_cb *self)
808 {
809   int i, ret = 0;
810   for (i = 0; i < RX_SLOTS; ++i)
811     if (!(self->ring->rx[i].control & OBOE_CTL_RX_HW_OWNS))
812       ret++;
813
814   return ret;
815 }
816
817 static int
818 toshoboe_probe (struct toshoboe_cb *self)
819 {
820   int i, j, n;
821 #ifdef USE_MIR
822   static const int bauds[] = { 9600, 115200, 4000000, 1152000 };
823 #else
824   static const int bauds[] = { 9600, 115200, 4000000 };
825 #endif
826   unsigned long flags;
827
828   IRDA_DEBUG (4, "%s()\n", __func__);
829
830   if (request_irq (self->io.irq, toshoboe_probeinterrupt,
831                    self->io.irqflags, "toshoboe", (void *) self))
832     {
833       printk (KERN_ERR DRIVER_NAME ": probe failed to allocate irq %d\n",
834               self->io.irq);
835       return 0;
836     }
837
838   /* test 1: SIR filter and back to back */
839
840   for (j = 0; j < ARRAY_SIZE(bauds); ++j)
841     {
842       int fir = (j > 1);
843       toshoboe_stopchip (self);
844
845
846       spin_lock_irqsave(&self->spinlock, flags);
847       /*Address is already setup */
848       toshoboe_startchip (self);
849       self->int_rx = self->int_tx = 0;
850       self->speed = bauds[j];
851       toshoboe_setbaud (self);
852       toshoboe_initptrs (self);
853       spin_unlock_irqrestore(&self->spinlock, flags);
854
855       self->ring->tx[self->txs].control =
856 /*   (FIR only) OBOE_CTL_TX_SIP needed for switching to next slot */
857 /*    MIR: all received data is stored in one slot */
858         (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX
859               : OBOE_CTL_TX_HW_OWNS ;
860       self->ring->tx[self->txs].len =
861         toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
862       self->txs++;
863       self->txs %= TX_SLOTS;
864
865       self->ring->tx[self->txs].control =
866         (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_SIP
867               : OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX ;
868       self->ring->tx[self->txs].len =
869         toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
870       self->txs++;
871       self->txs %= TX_SLOTS;
872
873       self->ring->tx[self->txs].control =
874         (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX
875               : OBOE_CTL_TX_HW_OWNS ;
876       self->ring->tx[self->txs].len =
877         toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
878       self->txs++;
879       self->txs %= TX_SLOTS;
880
881       self->ring->tx[self->txs].control =
882         (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX
883               | OBOE_CTL_TX_SIP     | OBOE_CTL_TX_BAD_CRC
884               : OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX ;
885       self->ring->tx[self->txs].len =
886         toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
887       self->txs++;
888       self->txs %= TX_SLOTS;
889
890       toshoboe_dumptx (self);
891       /* Turn on TX and RX and loopback */
892       toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
893
894       i = 0;
895       n = fir ? 1 : 4;
896       while (toshoboe_numvalidrcvs (self) != n)
897         {
898           if (i > 4800)
899               return toshoboe_probefail (self, "filter test");
900           udelay ((9600*(TT_LEN+16))/self->speed);
901           i++;
902         }
903
904       n = fir ? 203 : 102;
905       while ((toshoboe_numrcvs(self) != self->int_rx) || (self->int_tx != n))
906         {
907           if (i > 4800)
908               return toshoboe_probefail (self, "interrupt test");
909           udelay ((9600*(TT_LEN+16))/self->speed);
910           i++;
911         }
912      toshoboe_dumprx (self,i);
913
914      }
915
916   /* test 2: SIR in char at a time */
917
918   toshoboe_stopchip (self);
919   self->int_rx = self->int_tx = 0;
920
921   spin_lock_irqsave(&self->spinlock, flags);
922   toshoboe_startchip (self);
923   spin_unlock_irqrestore(&self->spinlock, flags);
924
925   self->async = 1;
926   self->speed = 115200;
927   toshoboe_setbaud (self);
928   self->ring->tx[self->txs].control =
929     OBOE_CTL_TX_RTCENTX | OBOE_CTL_TX_HW_OWNS;
930   self->ring->tx[self->txs].len = 4;
931
932   ((unsigned char *) self->tx_bufs[self->txs])[0] = 'f';
933   ((unsigned char *) self->tx_bufs[self->txs])[1] = 'i';
934   ((unsigned char *) self->tx_bufs[self->txs])[2] = 's';
935   ((unsigned char *) self->tx_bufs[self->txs])[3] = 'h';
936   toshoboe_dumptx (self);
937   toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
938
939   i = 0;
940   while (toshoboe_numvalidrcvs (self) != 4)
941     {
942       if (i > 100)
943           return toshoboe_probefail (self, "Async test");
944       udelay (100);
945       i++;
946     }
947
948   while ((toshoboe_numrcvs (self) != self->int_rx) || (self->int_tx != 1))
949     {
950       if (i > 100)
951           return toshoboe_probefail (self, "Async interrupt test");
952       udelay (100);
953       i++;
954     }
955   toshoboe_dumprx (self,i);
956
957   self->async = 0;
958   self->speed = 9600;
959   toshoboe_setbaud (self);
960   toshoboe_stopchip (self);
961
962   free_irq (self->io.irq, (void *) self);
963
964   printk (KERN_WARNING DRIVER_NAME ": Self test passed ok\n");
965
966   return 1;
967 }
968 #endif
969
970 /******************************************************************/
971 /* Netdev style code */
972
973 /* Transmit something */
974 static netdev_tx_t
975 toshoboe_hard_xmit (struct sk_buff *skb, struct net_device *dev)
976 {
977   struct toshoboe_cb *self;
978   __s32 speed;
979   int mtt, len, ctl;
980   unsigned long flags;
981   struct irda_skb_cb *cb = (struct irda_skb_cb *) skb->cb;
982
983   self = netdev_priv(dev);
984
985   IRDA_ASSERT (self != NULL, return NETDEV_TX_OK; );
986
987   IRDA_DEBUG (1, "%s.tx:%x(%x)%x\n", __func__
988       ,skb->len,self->txpending,INB (OBOE_ENABLEH));
989   if (!cb->magic) {
990       IRDA_DEBUG (2, "%s.Not IrLAP:%x\n", __func__, cb->magic);
991 #ifdef DUMP_PACKETS
992       _dumpbufs(skb->data,skb->len,'>');
993 #endif
994     }
995
996   /* change speed pending, wait for its execution */
997   if (self->new_speed)
998       return NETDEV_TX_BUSY;
999
1000   /* device stopped (apm) wait for restart */
1001   if (self->stopped)
1002       return NETDEV_TX_BUSY;
1003
1004   toshoboe_checkstuck (self);
1005
1006  /* Check if we need to change the speed */
1007   /* But not now. Wait after transmission if mtt not required */
1008   speed=irda_get_next_speed(skb);
1009   if ((speed != self->io.speed) && (speed != -1))
1010     {
1011       spin_lock_irqsave(&self->spinlock, flags);
1012
1013       if (self->txpending || skb->len)
1014         {
1015           self->new_speed = speed;
1016           IRDA_DEBUG (1, "%s: Queued TxDone scheduled speed change %d\n" ,
1017                       __func__, speed);
1018           /* if no data, that's all! */
1019           if (!skb->len)
1020             {
1021               spin_unlock_irqrestore(&self->spinlock, flags);
1022               dev_kfree_skb (skb);
1023               return NETDEV_TX_OK;
1024             }
1025           /* True packet, go on, but */
1026           /* do not accept anything before change speed execution */
1027           netif_stop_queue(dev);
1028           /* ready to process TxDone interrupt */
1029           spin_unlock_irqrestore(&self->spinlock, flags);
1030         }
1031       else
1032         {
1033           /* idle and no data, change speed now */
1034           self->speed = speed;
1035           toshoboe_setbaud (self);
1036           spin_unlock_irqrestore(&self->spinlock, flags);
1037           dev_kfree_skb (skb);
1038           return NETDEV_TX_OK;
1039         }
1040
1041     }
1042
1043   if ((mtt = irda_get_mtt(skb)))
1044     {
1045       /* This is fair since the queue should be empty anyway */
1046       spin_lock_irqsave(&self->spinlock, flags);
1047
1048       if (self->txpending)
1049         {
1050           spin_unlock_irqrestore(&self->spinlock, flags);
1051           return NETDEV_TX_BUSY;
1052         }
1053
1054       /* If in SIR mode we need to generate a string of XBOFs */
1055       /* In MIR and FIR we need to generate a string of data */
1056       /* which we will add a wrong checksum to */
1057
1058       mtt = toshoboe_makemttpacket (self, self->tx_bufs[self->txs], mtt);
1059       IRDA_DEBUG (1, "%s.mtt:%x(%x)%d\n", __func__
1060           ,skb->len,mtt,self->txpending);
1061       if (mtt)
1062         {
1063           self->ring->tx[self->txs].len = mtt & 0xfff;
1064
1065           ctl = OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX;
1066           if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_FIRON)
1067             {
1068               ctl |= OBOE_CTL_TX_BAD_CRC | OBOE_CTL_TX_SIP ;
1069             }
1070 #ifdef USE_MIR
1071           else if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_MIRON)
1072             {
1073               ctl |= OBOE_CTL_TX_BAD_CRC;
1074             }
1075 #endif
1076           self->ring->tx[self->txs].control = ctl;
1077
1078           OUTB (0x0, OBOE_ENABLEH);
1079           /* It is only a timer. Do not send mtt packet outside! */
1080           toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
1081
1082           self->txpending++;
1083
1084           self->txs++;
1085           self->txs %= TX_SLOTS;
1086
1087         }
1088       else
1089         {
1090           printk(KERN_ERR DRIVER_NAME ": problem with mtt packet - ignored\n");
1091         }
1092       spin_unlock_irqrestore(&self->spinlock, flags);
1093     }
1094
1095 #ifdef DUMP_PACKETS
1096 dumpbufs(skb->data,skb->len,'>');
1097 #endif
1098
1099   spin_lock_irqsave(&self->spinlock, flags);
1100
1101   if (self->ring->tx[self->txs].control & OBOE_CTL_TX_HW_OWNS)
1102     {
1103       IRDA_DEBUG (0, "%s.ful:%x(%x)%x\n", __func__
1104           ,skb->len, self->ring->tx[self->txs].control, self->txpending);
1105       toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
1106       spin_unlock_irqrestore(&self->spinlock, flags);
1107       return NETDEV_TX_BUSY;
1108     }
1109
1110   if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_SIRON)
1111     {
1112       len = async_wrap_skb (skb, self->tx_bufs[self->txs], TX_BUF_SZ);
1113     }
1114   else
1115     {
1116       len = skb->len;
1117       skb_copy_from_linear_data(skb, self->tx_bufs[self->txs], len);
1118     }
1119   self->ring->tx[self->txs].len = len & 0x0fff;
1120
1121   /*Sometimes the HW doesn't see us assert RTCENTX in the interrupt code */
1122   /*later this plays safe, we garuntee the last packet to be transmitted */
1123   /*has RTCENTX set */
1124
1125   ctl = OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX;
1126   if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_FIRON)
1127     {
1128       ctl |= OBOE_CTL_TX_SIP ;
1129     }
1130   self->ring->tx[self->txs].control = ctl;
1131
1132   /* If transmitter is idle start in one-shot mode */
1133
1134   if (!self->txpending)
1135       toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
1136
1137   self->txpending++;
1138
1139   self->txs++;
1140   self->txs %= TX_SLOTS;
1141
1142   spin_unlock_irqrestore(&self->spinlock, flags);
1143   dev_kfree_skb (skb);
1144
1145   return NETDEV_TX_OK;
1146 }
1147
1148 /*interrupt handler */
1149 static irqreturn_t
1150 toshoboe_interrupt (int irq, void *dev_id)
1151 {
1152   struct toshoboe_cb *self = dev_id;
1153   __u8 irqstat;
1154   struct sk_buff *skb = NULL;
1155
1156   irqstat = INB (OBOE_ISR);
1157
1158 /* was it us */
1159   if (!(irqstat & OBOE_INT_MASK))
1160       return IRQ_NONE;
1161
1162 /* Ack all the interrupts */
1163   OUTB (irqstat, OBOE_ISR);
1164
1165   toshoboe_isntstuck (self);
1166
1167 /* Txdone */
1168   if (irqstat & OBOE_INT_TXDONE)
1169     {
1170       int txp, txpc;
1171       int i;
1172
1173       txp = self->txpending;
1174       self->txpending = 0;
1175
1176       for (i = 0; i < TX_SLOTS; ++i)
1177         {
1178           if (self->ring->tx[i].control & OBOE_CTL_TX_HW_OWNS)
1179               self->txpending++;
1180         }
1181       IRDA_DEBUG (1, "%s.txd(%x)%x/%x\n", __func__
1182           ,irqstat,txp,self->txpending);
1183
1184       txp = INB (OBOE_TXSLOT) & OBOE_SLOT_MASK;
1185
1186       /* Got anything queued ? start it together */
1187       if (self->ring->tx[txp].control & OBOE_CTL_TX_HW_OWNS)
1188         {
1189           txpc = txp;
1190 #ifdef OPTIMIZE_TX
1191           while (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS)
1192             {
1193               txp = txpc;
1194               txpc++;
1195               txpc %= TX_SLOTS;
1196               self->netdev->stats.tx_packets++;
1197               if (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS)
1198                   self->ring->tx[txp].control &= ~OBOE_CTL_TX_RTCENTX;
1199             }
1200           self->netdev->stats.tx_packets--;
1201 #else
1202           self->netdev->stats.tx_packets++;
1203 #endif
1204           toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
1205         }
1206
1207       if ((!self->txpending) && (self->new_speed))
1208         {
1209           self->speed = self->new_speed;
1210           IRDA_DEBUG (1, "%s: Executed TxDone scheduled speed change %d\n",
1211                       __func__, self->speed);
1212           toshoboe_setbaud (self);
1213         }
1214
1215       /* Tell network layer that we want more frames */
1216       if (!self->new_speed)
1217           netif_wake_queue(self->netdev);
1218     }
1219
1220   if (irqstat & OBOE_INT_RXDONE)
1221     {
1222       while (!(self->ring->rx[self->rxs].control & OBOE_CTL_RX_HW_OWNS))
1223         {
1224           int len = self->ring->rx[self->rxs].len;
1225           skb = NULL;
1226           IRDA_DEBUG (3, "%s.rcv:%x(%x)\n", __func__
1227                       ,len,self->ring->rx[self->rxs].control);
1228
1229 #ifdef DUMP_PACKETS
1230 dumpbufs(self->rx_bufs[self->rxs],len,'<');
1231 #endif
1232
1233           if (self->ring->rx[self->rxs].control == 0)
1234             {
1235               __u8 enable = INB (OBOE_ENABLEH);
1236
1237               /* In SIR mode we need to check the CRC as this */
1238               /* hasn't been done by the hardware */
1239               if (enable & OBOE_ENABLEH_SIRON)
1240                 {
1241                   if (!toshoboe_checkfcs (self->rx_bufs[self->rxs], len))
1242                       len = 0;
1243                   /*Trim off the CRC */
1244                   if (len > 1)
1245                       len -= 2;
1246                   else
1247                       len = 0;
1248                   IRDA_DEBUG (1, "%s.SIR:%x(%x)\n", __func__, len,enable);
1249                 }
1250
1251 #ifdef USE_MIR
1252               else if (enable & OBOE_ENABLEH_MIRON)
1253                 {
1254                   if (len > 1)
1255                       len -= 2;
1256                   else
1257                       len = 0;
1258                   IRDA_DEBUG (2, "%s.MIR:%x(%x)\n", __func__, len,enable);
1259                 }
1260 #endif
1261               else if (enable & OBOE_ENABLEH_FIRON)
1262                 {
1263                   if (len > 3)
1264                       len -= 4;   /*FIXME: check this */
1265                   else
1266                       len = 0;
1267                   IRDA_DEBUG (1, "%s.FIR:%x(%x)\n", __func__, len,enable);
1268                 }
1269               else
1270                   IRDA_DEBUG (0, "%s.?IR:%x(%x)\n", __func__, len,enable);
1271
1272               if (len)
1273                 {
1274                   skb = dev_alloc_skb (len + 1);
1275                   if (skb)
1276                     {
1277                       skb_reserve (skb, 1);
1278
1279                       skb_put (skb, len);
1280                       skb_copy_to_linear_data(skb, self->rx_bufs[self->rxs],
1281                                               len);
1282                       self->netdev->stats.rx_packets++;
1283                       skb->dev = self->netdev;
1284                       skb_reset_mac_header(skb);
1285                       skb->protocol = htons (ETH_P_IRDA);
1286                     }
1287                   else
1288                     {
1289                       printk (KERN_INFO
1290                               "%s(), memory squeeze, dropping frame.\n",
1291                               __func__);
1292                     }
1293                 }
1294             }
1295           else
1296             {
1297             /* TODO: =========================================== */
1298             /*  if OBOE_CTL_RX_LENGTH, our buffers are too small */
1299             /* (MIR or FIR) data is lost. */
1300             /* (SIR) data is splitted in several slots. */
1301             /* we have to join all the received buffers received */
1302             /*in a large buffer before checking CRC. */
1303             IRDA_DEBUG (0, "%s.err:%x(%x)\n", __func__
1304                 ,len,self->ring->rx[self->rxs].control);
1305             }
1306
1307           self->ring->rx[self->rxs].len = 0x0;
1308           self->ring->rx[self->rxs].control = OBOE_CTL_RX_HW_OWNS;
1309
1310           self->rxs++;
1311           self->rxs %= RX_SLOTS;
1312
1313           if (skb)
1314               netif_rx (skb);
1315
1316         }
1317     }
1318
1319   if (irqstat & OBOE_INT_TXUNDER)
1320     {
1321       printk (KERN_WARNING DRIVER_NAME ": tx fifo underflow\n");
1322     }
1323   if (irqstat & OBOE_INT_RXOVER)
1324     {
1325       printk (KERN_WARNING DRIVER_NAME ": rx fifo overflow\n");
1326     }
1327 /* This must be useful for something... */
1328   if (irqstat & OBOE_INT_SIP)
1329     {
1330       self->int_sip++;
1331       IRDA_DEBUG (1, "%s.sip:%x(%x)%x\n", __func__
1332               ,self->int_sip,irqstat,self->txpending);
1333     }
1334   return IRQ_HANDLED;
1335 }
1336
1337
1338 static int
1339 toshoboe_net_open (struct net_device *dev)
1340 {
1341   struct toshoboe_cb *self;
1342   unsigned long flags;
1343   int rc;
1344
1345   IRDA_DEBUG (4, "%s()\n", __func__);
1346
1347   self = netdev_priv(dev);
1348
1349   if (self->async)
1350     return -EBUSY;
1351
1352   if (self->stopped)
1353     return 0;
1354
1355   rc = request_irq (self->io.irq, toshoboe_interrupt,
1356                     IRQF_SHARED | IRQF_DISABLED, dev->name, self);
1357   if (rc)
1358         return rc;
1359
1360   spin_lock_irqsave(&self->spinlock, flags);
1361   toshoboe_startchip (self);
1362   spin_unlock_irqrestore(&self->spinlock, flags);
1363
1364   /* Ready to play! */
1365   netif_start_queue(dev);
1366
1367   /*
1368    * Open new IrLAP layer instance, now that everything should be
1369    * initialized properly
1370    */
1371   self->irlap = irlap_open (dev, &self->qos, driver_name);
1372
1373   self->irdad = 1;
1374
1375   return 0;
1376 }
1377
1378 static int
1379 toshoboe_net_close (struct net_device *dev)
1380 {
1381   struct toshoboe_cb *self;
1382
1383   IRDA_DEBUG (4, "%s()\n", __func__);
1384
1385   IRDA_ASSERT (dev != NULL, return -1; );
1386   self = netdev_priv(dev);
1387
1388   /* Stop device */
1389   netif_stop_queue(dev);
1390
1391   /* Stop and remove instance of IrLAP */
1392   if (self->irlap)
1393     irlap_close (self->irlap);
1394   self->irlap = NULL;
1395
1396   self->irdad = 0;
1397
1398   free_irq (self->io.irq, (void *) self);
1399
1400   if (!self->stopped)
1401     {
1402       toshoboe_stopchip (self);
1403     }
1404
1405   return 0;
1406 }
1407
1408 /*
1409  * Function toshoboe_net_ioctl (dev, rq, cmd)
1410  *
1411  *    Process IOCTL commands for this device
1412  *
1413  */
1414 static int
1415 toshoboe_net_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1416 {
1417   struct if_irda_req *irq = (struct if_irda_req *) rq;
1418   struct toshoboe_cb *self;
1419   unsigned long flags;
1420   int ret = 0;
1421
1422   IRDA_ASSERT (dev != NULL, return -1; );
1423
1424   self = netdev_priv(dev);
1425
1426   IRDA_ASSERT (self != NULL, return -1; );
1427
1428   IRDA_DEBUG (5, "%s(), %s, (cmd=0x%X)\n", __func__, dev->name, cmd);
1429
1430   /* Disable interrupts & save flags */
1431   spin_lock_irqsave(&self->spinlock, flags);
1432
1433   switch (cmd)
1434     {
1435     case SIOCSBANDWIDTH:       /* Set bandwidth */
1436       /* This function will also be used by IrLAP to change the
1437        * speed, so we still must allow for speed change within
1438        * interrupt context.
1439        */
1440       IRDA_DEBUG (1, "%s(BANDWIDTH), %s, (%X/%ld\n", __func__
1441           ,dev->name, INB (OBOE_STATUS), irq->ifr_baudrate );
1442       if (!in_interrupt () && !capable (CAP_NET_ADMIN)) {
1443         ret = -EPERM;
1444         goto out;
1445       }
1446
1447       /* self->speed=irq->ifr_baudrate; */
1448       /* toshoboe_setbaud(self); */
1449       /* Just change speed once - inserted by Paul Bristow */
1450       self->new_speed = irq->ifr_baudrate;
1451       break;
1452     case SIOCSMEDIABUSY:       /* Set media busy */
1453       IRDA_DEBUG (1, "%s(MEDIABUSY), %s, (%X/%x)\n", __func__
1454           ,dev->name, INB (OBOE_STATUS), capable (CAP_NET_ADMIN) );
1455       if (!capable (CAP_NET_ADMIN)) {
1456         ret = -EPERM;
1457         goto out;
1458       }
1459       irda_device_set_media_busy (self->netdev, TRUE);
1460       break;
1461     case SIOCGRECEIVING:       /* Check if we are receiving right now */
1462       irq->ifr_receiving = (INB (OBOE_STATUS) & OBOE_STATUS_RXBUSY) ? 1 : 0;
1463       IRDA_DEBUG (3, "%s(RECEIVING), %s, (%X/%x)\n", __func__
1464           ,dev->name, INB (OBOE_STATUS), irq->ifr_receiving );
1465       break;
1466     default:
1467       IRDA_DEBUG (1, "%s(?), %s, (cmd=0x%X)\n", __func__, dev->name, cmd);
1468       ret = -EOPNOTSUPP;
1469     }
1470 out:
1471   spin_unlock_irqrestore(&self->spinlock, flags);
1472   return ret;
1473
1474 }
1475
1476 MODULE_DESCRIPTION("Toshiba OBOE IrDA Device Driver");
1477 MODULE_AUTHOR("James McKenzie <james@fishsoup.dhs.org>");
1478 MODULE_LICENSE("GPL");
1479
1480 module_param (max_baud, int, 0);
1481 MODULE_PARM_DESC(max_baud, "Maximum baud rate");
1482
1483 #ifdef USE_PROBE
1484 module_param (do_probe, bool, 0);
1485 MODULE_PARM_DESC(do_probe, "Enable/disable chip probing and self-test");
1486 #endif
1487
1488 static void
1489 toshoboe_close (struct pci_dev *pci_dev)
1490 {
1491   int i;
1492   struct toshoboe_cb *self = (struct toshoboe_cb*)pci_get_drvdata(pci_dev);
1493
1494   IRDA_DEBUG (4, "%s()\n", __func__);
1495
1496   IRDA_ASSERT (self != NULL, return; );
1497
1498   if (!self->stopped)
1499     {
1500       toshoboe_stopchip (self);
1501     }
1502
1503   release_region (self->io.fir_base, self->io.fir_ext);
1504
1505   for (i = 0; i < TX_SLOTS; ++i)
1506     {
1507       kfree (self->tx_bufs[i]);
1508       self->tx_bufs[i] = NULL;
1509     }
1510
1511   for (i = 0; i < RX_SLOTS; ++i)
1512     {
1513       kfree (self->rx_bufs[i]);
1514       self->rx_bufs[i] = NULL;
1515     }
1516
1517   unregister_netdev(self->netdev);
1518
1519   kfree (self->ringbuf);
1520   self->ringbuf = NULL;
1521   self->ring = NULL;
1522
1523   free_netdev(self->netdev);
1524 }
1525
1526 static const struct net_device_ops toshoboe_netdev_ops = {
1527         .ndo_open       = toshoboe_net_open,
1528         .ndo_stop       = toshoboe_net_close,
1529         .ndo_start_xmit = toshoboe_hard_xmit,
1530         .ndo_do_ioctl   = toshoboe_net_ioctl,
1531 };
1532
1533 static int
1534 toshoboe_open (struct pci_dev *pci_dev, const struct pci_device_id *pdid)
1535 {
1536   struct toshoboe_cb *self;
1537   struct net_device *dev;
1538   int i = 0;
1539   int ok = 0;
1540   int err;
1541
1542   IRDA_DEBUG (4, "%s()\n", __func__);
1543
1544   if ((err=pci_enable_device(pci_dev)))
1545     return err;
1546
1547   dev = alloc_irdadev(sizeof (struct toshoboe_cb));
1548   if (dev == NULL)
1549     {
1550       printk (KERN_ERR DRIVER_NAME ": can't allocate memory for "
1551               "IrDA control block\n");
1552       return -ENOMEM;
1553     }
1554
1555   self = netdev_priv(dev);
1556   self->netdev = dev;
1557   self->pdev = pci_dev;
1558   self->base = pci_resource_start(pci_dev,0);
1559
1560   self->io.fir_base = self->base;
1561   self->io.fir_ext = OBOE_IO_EXTENT;
1562   self->io.irq = pci_dev->irq;
1563   self->io.irqflags = IRQF_SHARED | IRQF_DISABLED;
1564
1565   self->speed = self->io.speed = 9600;
1566   self->async = 0;
1567
1568   /* Lock the port that we need */
1569   if (NULL==request_region (self->io.fir_base, self->io.fir_ext, driver_name))
1570     {
1571       printk (KERN_ERR DRIVER_NAME ": can't get iobase of 0x%03x\n"
1572               ,self->io.fir_base);
1573       err = -EBUSY;
1574       goto freeself;
1575     }
1576
1577   spin_lock_init(&self->spinlock);
1578
1579   irda_init_max_qos_capabilies (&self->qos);
1580   self->qos.baud_rate.bits = 0;
1581
1582   if (max_baud >= 2400)
1583     self->qos.baud_rate.bits |= IR_2400;
1584   /*if (max_baud>=4800) idev->qos.baud_rate.bits|=IR_4800; */
1585   if (max_baud >= 9600)
1586     self->qos.baud_rate.bits |= IR_9600;
1587   if (max_baud >= 19200)
1588     self->qos.baud_rate.bits |= IR_19200;
1589   if (max_baud >= 115200)
1590     self->qos.baud_rate.bits |= IR_115200;
1591 #ifdef USE_MIR
1592   if (max_baud >= 1152000)
1593     {
1594       self->qos.baud_rate.bits |= IR_1152000;
1595     }
1596 #endif
1597   if (max_baud >= 4000000)
1598     {
1599       self->qos.baud_rate.bits |= (IR_4000000 << 8);
1600     }
1601
1602   /*FIXME: work this out... */
1603   self->qos.min_turn_time.bits = 0xff;
1604
1605   irda_qos_bits_to_value (&self->qos);
1606
1607   /* Allocate twice the size to guarantee alignment */
1608   self->ringbuf = kmalloc(OBOE_RING_LEN << 1, GFP_KERNEL);
1609   if (!self->ringbuf)
1610     {
1611       printk (KERN_ERR DRIVER_NAME ": can't allocate DMA buffers\n");
1612       err = -ENOMEM;
1613       goto freeregion;
1614     }
1615
1616 #if (BITS_PER_LONG == 64)
1617 #error broken on 64-bit:  casts pointer to 32-bit, and then back to pointer.
1618 #endif
1619
1620   /*We need to align the taskfile on a taskfile size boundary */
1621   {
1622     unsigned long addr;
1623
1624     addr = (__u32) self->ringbuf;
1625     addr &= ~(OBOE_RING_LEN - 1);
1626     addr += OBOE_RING_LEN;
1627     self->ring = (struct OboeRing *) addr;
1628   }
1629
1630   memset (self->ring, 0, OBOE_RING_LEN);
1631   self->io.mem_base = (__u32) self->ring;
1632
1633   ok = 1;
1634   for (i = 0; i < TX_SLOTS; ++i)
1635     {
1636       self->tx_bufs[i] = kmalloc (TX_BUF_SZ, GFP_KERNEL);
1637       if (!self->tx_bufs[i])
1638         ok = 0;
1639     }
1640
1641   for (i = 0; i < RX_SLOTS; ++i)
1642     {
1643       self->rx_bufs[i] = kmalloc (RX_BUF_SZ, GFP_KERNEL);
1644       if (!self->rx_bufs[i])
1645         ok = 0;
1646     }
1647
1648   if (!ok)
1649     {
1650       printk (KERN_ERR DRIVER_NAME ": can't allocate rx/tx buffers\n");
1651       err = -ENOMEM;
1652       goto freebufs;
1653     }
1654
1655
1656 #ifdef USE_PROBE
1657   if (do_probe)
1658     if (!toshoboe_probe (self))
1659       {
1660         err = -ENODEV;
1661         goto freebufs;
1662       }
1663 #endif
1664
1665   SET_NETDEV_DEV(dev, &pci_dev->dev);
1666   dev->netdev_ops = &toshoboe_netdev_ops;
1667
1668   err = register_netdev(dev);
1669   if (err)
1670     {
1671       printk (KERN_ERR DRIVER_NAME ": register_netdev() failed\n");
1672       err = -ENOMEM;
1673       goto freebufs;
1674     }
1675   printk (KERN_INFO "IrDA: Registered device %s\n", dev->name);
1676
1677   pci_set_drvdata(pci_dev,self);
1678
1679   printk (KERN_INFO DRIVER_NAME ": Using multiple tasks\n");
1680
1681   return 0;
1682
1683 freebufs:
1684   for (i = 0; i < TX_SLOTS; ++i)
1685     kfree (self->tx_bufs[i]);
1686   for (i = 0; i < RX_SLOTS; ++i)
1687     kfree (self->rx_bufs[i]);
1688   kfree(self->ringbuf);
1689
1690 freeregion:
1691   release_region (self->io.fir_base, self->io.fir_ext);
1692
1693 freeself:
1694   free_netdev(dev);
1695
1696   return err;
1697 }
1698
1699 static int
1700 toshoboe_gotosleep (struct pci_dev *pci_dev, pm_message_t crap)
1701 {
1702   struct toshoboe_cb *self = (struct toshoboe_cb*)pci_get_drvdata(pci_dev);
1703   unsigned long flags;
1704   int i = 10;
1705
1706   IRDA_DEBUG (4, "%s()\n", __func__);
1707
1708   if (!self || self->stopped)
1709     return 0;
1710
1711   if ((!self->irdad) && (!self->async))
1712     return 0;
1713
1714 /* Flush all packets */
1715   while ((i--) && (self->txpending))
1716     udelay (10000);
1717
1718   spin_lock_irqsave(&self->spinlock, flags);
1719
1720   toshoboe_stopchip (self);
1721   self->stopped = 1;
1722   self->txpending = 0;
1723
1724   spin_unlock_irqrestore(&self->spinlock, flags);
1725   return 0;
1726 }
1727
1728 static int
1729 toshoboe_wakeup (struct pci_dev *pci_dev)
1730 {
1731   struct toshoboe_cb *self = (struct toshoboe_cb*)pci_get_drvdata(pci_dev);
1732   unsigned long flags;
1733
1734   IRDA_DEBUG (4, "%s()\n", __func__);
1735
1736   if (!self || !self->stopped)
1737     return 0;
1738
1739   if ((!self->irdad) && (!self->async))
1740     return 0;
1741
1742   spin_lock_irqsave(&self->spinlock, flags);
1743
1744   toshoboe_startchip (self);
1745   self->stopped = 0;
1746
1747   netif_wake_queue(self->netdev);
1748   spin_unlock_irqrestore(&self->spinlock, flags);
1749   return 0;
1750 }
1751
1752 static struct pci_driver donauboe_pci_driver = {
1753         .name           = "donauboe",
1754         .id_table       = toshoboe_pci_tbl,
1755         .probe          = toshoboe_open,
1756         .remove         = toshoboe_close,
1757         .suspend        = toshoboe_gotosleep,
1758         .resume         = toshoboe_wakeup 
1759 };
1760
1761 static int __init
1762 donauboe_init (void)
1763 {
1764   return pci_register_driver(&donauboe_pci_driver);
1765 }
1766
1767 static void __exit
1768 donauboe_cleanup (void)
1769 {
1770   pci_unregister_driver(&donauboe_pci_driver);
1771 }
1772
1773 module_init(donauboe_init);
1774 module_exit(donauboe_cleanup);