1 /*****************************************************************
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
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
32 * Copyright (c) 1999 James McKenzie, All Rights Reserved.
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.
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.
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.
47 ********************************************************************/
49 /* Look at toshoboe.h (currently in include/net/irda) for details of */
50 /* Where to get documentation on the chip */
52 /* See below for a description of the logic in this driver */
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 recomended, disable if the probe fails on your machine */
60 /* and send me <james@fishsoup.dhs.org> the output of dmesg */
64 /* Trace Transmit ring, interrupts, Receive ring or not ? */
65 #define PROBE_VERBOSE 1
67 /* Debug option, examine sent and received raw data */
68 /* Irdadump is better, but does not see all packets. enable it if you want. */
71 /* MIR mode has not been tested. Some behaviour is different */
72 /* Seems to work against an Ericsson R520 for me. -Martin */
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 */
80 /* Set the number of slots in the rings */
81 /* If you get rx/tx fifo overflows at high bitrates, you can try increasing */
84 #define RING_SIZE (OBOE_RING_SIZE_RX8 | OBOE_RING_SIZE_TX8)
89 /* Less user servicable parts below here */
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! */
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)
111 /* Logic of the netdev part of this driver */
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 */
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 */
123 /* b) transmit the packet, switch off the transmitter and issue TxDone */
125 /* All packets are entered into the ring in mode b), if the ring was */
126 /* empty the transmitter is started. */
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 */
133 /* If OPTIMIZE_TX is not defined then we just restart the transmitter */
134 /* if the ring isn't empty */
136 /* Speed changes are delayed until the TxRing is empty */
137 /* mtt is handled by generating packets with bad CRCs, before the data */
140 /* check the mtt works ok */
141 /* finish the watchdog */
143 /* No user servicable parts below here */
145 #include <linux/module.h>
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/pci.h>
156 #include <linux/rtnetlink.h>
158 #include <asm/system.h>
161 #include <net/irda/wrapper.h>
162 #include <net/irda/irda.h>
163 //#include <net/irda/irmod.h>
164 //#include <net/irda/irlap_frame.h>
165 #include <net/irda/irda_device.h>
166 #include <net/irda/crc.h>
168 #include "donauboe.h"
170 #define INB(port) inb_p(port)
171 #define OUTB(val,port) outb_p(val,port)
172 #define OUTBP(val,port) outb_p(val,port)
174 #define PROMPT OUTB(OBOE_PROMPT_BIT,OBOE_PROMPT);
177 #define PROBE_DEBUG(args...) (printk (args))
179 #define PROBE_DEBUG(args...) ;
182 /* Set the DMA to be byte at a time */
183 #define CONFIG0H_DMA_OFF OBOE_CONFIG0H_RCVANY
184 #define CONFIG0H_DMA_ON_NORX CONFIG0H_DMA_OFF| OBOE_CONFIG0H_ENDMAC
185 #define CONFIG0H_DMA_ON CONFIG0H_DMA_ON_NORX | OBOE_CONFIG0H_ENRX
187 static DEFINE_PCI_DEVICE_TABLE(toshoboe_pci_tbl
) = {
188 { PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_FIR701
, PCI_ANY_ID
, PCI_ANY_ID
, },
189 { PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_FIRD01
, PCI_ANY_ID
, PCI_ANY_ID
, },
190 { } /* Terminating entry */
192 MODULE_DEVICE_TABLE(pci
, toshoboe_pci_tbl
);
194 #define DRIVER_NAME "toshoboe"
195 static char *driver_name
= DRIVER_NAME
;
197 static int max_baud
= 4000000;
199 static int do_probe
= 0;
203 /**********************************************************************/
205 toshoboe_checkfcs (unsigned char *buf
, int len
)
215 fcs
.value
= INIT_FCS
;
217 for (i
= 0; i
< len
; ++i
)
218 fcs
.value
= irda_fcs (fcs
.value
, *(buf
++));
220 return fcs
.value
== GOOD_FCS
;
223 /***********************************************************************/
224 /* Generic chip handling code */
226 static unsigned char dump
[50];
228 _dumpbufs (unsigned char *data
, int len
, char tete
)
232 for (i
=0;i
<len
;i
+=16) {
233 for (j
=0;j
<16 && i
+j
<len
;j
++) { sprintf(&dump
[3*j
],"%02x.",data
[i
+j
]); }
235 IRDA_DEBUG (2, "%c%s\n",head
, dump
);
242 /* Dump the registers */
244 toshoboe_dumpregs (struct toshoboe_cb
*self
)
248 IRDA_DEBUG (4, "%s()\n", __func__
);
250 ringbase
= INB (OBOE_RING_BASE0
) << 10;
251 ringbase
|= INB (OBOE_RING_BASE1
) << 18;
252 ringbase
|= INB (OBOE_RING_BASE2
) << 26;
254 printk (KERN_ERR DRIVER_NAME
": Register dump:\n");
255 printk (KERN_ERR
"Interrupts: Tx:%d Rx:%d TxUnder:%d RxOver:%d Sip:%d\n",
256 self
->int_tx
, self
->int_rx
, self
->int_txunder
, self
->int_rxover
,
258 printk (KERN_ERR
"RX %02x TX %02x RingBase %08x\n",
259 INB (OBOE_RXSLOT
), INB (OBOE_TXSLOT
), ringbase
);
260 printk (KERN_ERR
"RING_SIZE %02x IER %02x ISR %02x\n",
261 INB (OBOE_RING_SIZE
), INB (OBOE_IER
), INB (OBOE_ISR
));
262 printk (KERN_ERR
"CONFIG1 %02x STATUS %02x\n",
263 INB (OBOE_CONFIG1
), INB (OBOE_STATUS
));
264 printk (KERN_ERR
"CONFIG0 %02x%02x ENABLE %02x%02x\n",
265 INB (OBOE_CONFIG0H
), INB (OBOE_CONFIG0L
),
266 INB (OBOE_ENABLEH
), INB (OBOE_ENABLEL
));
267 printk (KERN_ERR
"NEW_PCONFIG %02x%02x CURR_PCONFIG %02x%02x\n",
268 INB (OBOE_NEW_PCONFIGH
), INB (OBOE_NEW_PCONFIGL
),
269 INB (OBOE_CURR_PCONFIGH
), INB (OBOE_CURR_PCONFIGL
));
270 printk (KERN_ERR
"MAXLEN %02x%02x RXCOUNT %02x%02x\n",
271 INB (OBOE_MAXLENH
), INB (OBOE_MAXLENL
),
272 INB (OBOE_RXCOUNTL
), INB (OBOE_RXCOUNTH
));
277 ringbase
= virt_to_bus (self
->ring
);
278 printk (KERN_ERR
"Ring at %08x:\n", ringbase
);
279 printk (KERN_ERR
"RX:");
280 for (i
= 0; i
< RX_SLOTS
; ++i
)
281 printk (" (%d,%02x)",self
->ring
->rx
[i
].len
,self
->ring
->rx
[i
].control
);
283 printk (KERN_ERR
"TX:");
284 for (i
= 0; i
< RX_SLOTS
; ++i
)
285 printk (" (%d,%02x)",self
->ring
->tx
[i
].len
,self
->ring
->tx
[i
].control
);
291 /*Don't let the chip look at memory */
293 toshoboe_disablebm (struct toshoboe_cb
*self
)
296 IRDA_DEBUG (4, "%s()\n", __func__
);
298 pci_read_config_byte (self
->pdev
, PCI_COMMAND
, &command
);
299 command
&= ~PCI_COMMAND_MASTER
;
300 pci_write_config_byte (self
->pdev
, PCI_COMMAND
, command
);
304 /* Shutdown the chip and point the taskfile reg somewhere else */
306 toshoboe_stopchip (struct toshoboe_cb
*self
)
308 IRDA_DEBUG (4, "%s()\n", __func__
);
310 /*Disable interrupts */
311 OUTB (0x0, OBOE_IER
);
312 /*Disable DMA, Disable Rx, Disable Tx */
313 OUTB (CONFIG0H_DMA_OFF
, OBOE_CONFIG0H
);
314 /*Disable SIR MIR FIR, Tx and Rx */
315 OUTB (0x00, OBOE_ENABLEH
);
316 /*Point the ring somewhere safe */
317 OUTB (0x3f, OBOE_RING_BASE2
);
318 OUTB (0xff, OBOE_RING_BASE1
);
319 OUTB (0xff, OBOE_RING_BASE0
);
321 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
322 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
324 /*Acknoledge any pending interrupts */
325 OUTB (0xff, OBOE_ISR
);
328 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
331 OUTB (OBOE_CONFIG1_OFF
, OBOE_CONFIG1
);
333 toshoboe_disablebm (self
);
336 /* Transmitter initialization */
338 toshoboe_start_DMA (struct toshoboe_cb
*self
, int opts
)
340 OUTB (0x0, OBOE_ENABLEH
);
341 OUTB (CONFIG0H_DMA_ON
| opts
, OBOE_CONFIG0H
);
342 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
346 /*Set the baud rate */
348 toshoboe_setbaud (struct toshoboe_cb
*self
)
353 IRDA_DEBUG (2, "%s(%d/%d)\n", __func__
, self
->speed
, self
->io
.speed
);
371 printk (KERN_ERR DRIVER_NAME
": switch to unsupported baudrate %d\n",
378 /* For SIR the preamble is done by adding XBOFs */
380 /* set to filtered SIR mode, filter looks for BOF and EOF */
382 pconfig
|= 47 << OBOE_PCONFIG_BAUDSHIFT
;
383 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
386 pconfig
|= 23 << OBOE_PCONFIG_BAUDSHIFT
;
387 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
390 pconfig
|= 11 << OBOE_PCONFIG_BAUDSHIFT
;
391 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
394 pconfig
|= 5 << OBOE_PCONFIG_BAUDSHIFT
;
395 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
398 pconfig
|= 2 << OBOE_PCONFIG_BAUDSHIFT
;
399 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
402 pconfig
|= 1 << OBOE_PCONFIG_BAUDSHIFT
;
403 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
406 pconfig
|= 0 << OBOE_PCONFIG_BAUDSHIFT
;
407 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
410 /*Set to packet based reception */
411 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
412 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
425 config0l
= OBOE_CONFIG0L_ENSIR
;
428 /*Set to character based reception */
429 /*System will lock if MAXLEN=0 */
430 /*so have to be careful */
431 OUTB (0x01, OBOE_MAXLENH
);
432 OUTB (0x01, OBOE_MAXLENL
);
433 OUTB (0x00, OBOE_MAXLENH
);
437 /*Set to packet based reception */
438 config0l
|= OBOE_CONFIG0L_ENSIRF
;
439 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
440 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
446 /* Set for 16 bit CRC and enable MIR */
447 /* Preamble now handled by the chip */
449 pconfig
|= 0 << OBOE_PCONFIG_BAUDSHIFT
;
450 pconfig
|= 8 << OBOE_PCONFIG_WIDTHSHIFT
;
451 pconfig
|= 1 << OBOE_PCONFIG_PREAMBLESHIFT
;
452 config0l
= OBOE_CONFIG0L_CRC16
| OBOE_CONFIG0L_ENMIR
;
456 /* Set for 32 bit CRC and enable FIR */
457 /* Preamble handled by the chip */
459 pconfig
|= 0 << OBOE_PCONFIG_BAUDSHIFT
;
460 /* Documentation says 14, but toshiba use 15 in their drivers */
461 pconfig
|= 15 << OBOE_PCONFIG_PREAMBLESHIFT
;
462 config0l
= OBOE_CONFIG0L_ENFIR
;
466 /* Copy into new PHY config buffer */
467 OUTBP (pconfig
>> 8, OBOE_NEW_PCONFIGH
);
468 OUTB (pconfig
& 0xff, OBOE_NEW_PCONFIGL
);
469 OUTB (config0l
, OBOE_CONFIG0L
);
471 /* Now make OBOE copy from new PHY to current PHY */
472 OUTB (0x0, OBOE_ENABLEH
);
473 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
476 /* speed change executed */
478 self
->io
.speed
= self
->speed
;
481 /*Let the chip look at memory */
483 toshoboe_enablebm (struct toshoboe_cb
*self
)
485 IRDA_DEBUG (4, "%s()\n", __func__
);
486 pci_set_master (self
->pdev
);
491 toshoboe_initring (struct toshoboe_cb
*self
)
495 IRDA_DEBUG (4, "%s()\n", __func__
);
497 for (i
= 0; i
< TX_SLOTS
; ++i
)
499 self
->ring
->tx
[i
].len
= 0;
500 self
->ring
->tx
[i
].control
= 0x00;
501 self
->ring
->tx
[i
].address
= virt_to_bus (self
->tx_bufs
[i
]);
504 for (i
= 0; i
< RX_SLOTS
; ++i
)
506 self
->ring
->rx
[i
].len
= RX_LEN
;
507 self
->ring
->rx
[i
].len
= 0;
508 self
->ring
->rx
[i
].address
= virt_to_bus (self
->rx_bufs
[i
]);
509 self
->ring
->rx
[i
].control
= OBOE_CTL_RX_HW_OWNS
;
514 toshoboe_resetptrs (struct toshoboe_cb
*self
)
516 /* Can reset pointers by twidling DMA */
517 OUTB (0x0, OBOE_ENABLEH
);
518 OUTBP (CONFIG0H_DMA_OFF
, OBOE_CONFIG0H
);
519 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
521 self
->rxs
= inb_p (OBOE_RXSLOT
) & OBOE_SLOT_MASK
;
522 self
->txs
= inb_p (OBOE_TXSLOT
) & OBOE_SLOT_MASK
;
525 /* Called in locked state */
527 toshoboe_initptrs (struct toshoboe_cb
*self
)
530 /* spin_lock_irqsave(self->spinlock, flags); */
531 /* save_flags (flags); */
533 /* Can reset pointers by twidling DMA */
534 toshoboe_resetptrs (self
);
536 OUTB (0x0, OBOE_ENABLEH
);
537 OUTB (CONFIG0H_DMA_ON
, OBOE_CONFIG0H
);
538 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
542 /* spin_unlock_irqrestore(self->spinlock, flags); */
543 /* restore_flags (flags); */
546 /* Wake the chip up and get it looking at the rings */
547 /* Called in locked state */
549 toshoboe_startchip (struct toshoboe_cb
*self
)
553 IRDA_DEBUG (4, "%s()\n", __func__
);
555 toshoboe_initring (self
);
556 toshoboe_enablebm (self
);
557 OUTBP (OBOE_CONFIG1_RESET
, OBOE_CONFIG1
);
558 OUTBP (OBOE_CONFIG1_ON
, OBOE_CONFIG1
);
560 /* Stop the clocks */
561 OUTB (0, OBOE_ENABLEH
);
563 /*Set size of rings */
564 OUTB (RING_SIZE
, OBOE_RING_SIZE
);
566 /*Acknoledge any pending interrupts */
567 OUTB (0xff, OBOE_ISR
);
570 OUTB (OBOE_INT_TXDONE
| OBOE_INT_RXDONE
|
571 OBOE_INT_TXUNDER
| OBOE_INT_RXOVER
| OBOE_INT_SIP
, OBOE_IER
);
573 /*Acknoledge any pending interrupts */
574 OUTB (0xff, OBOE_ISR
);
576 /*Set the maximum packet length to 0xfff (4095) */
577 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
578 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
581 OUTB (CONFIG0H_DMA_OFF
, OBOE_CONFIG0H
);
583 /*Find out where the rings live */
584 physaddr
= virt_to_bus (self
->ring
);
586 IRDA_ASSERT ((physaddr
& 0x3ff) == 0,
587 printk (KERN_ERR DRIVER_NAME
"ring not correctly aligned\n");
590 OUTB ((physaddr
>> 10) & 0xff, OBOE_RING_BASE0
);
591 OUTB ((physaddr
>> 18) & 0xff, OBOE_RING_BASE1
);
592 OUTB ((physaddr
>> 26) & 0x3f, OBOE_RING_BASE2
);
594 /*Enable DMA controller in byte mode and RX */
595 OUTB (CONFIG0H_DMA_ON
, OBOE_CONFIG0H
);
597 /* Start up the clocks */
598 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
600 /*set to sensible speed */
602 toshoboe_setbaud (self
);
603 toshoboe_initptrs (self
);
607 toshoboe_isntstuck (struct toshoboe_cb
*self
)
612 toshoboe_checkstuck (struct toshoboe_cb
*self
)
618 spin_lock_irqsave(&self
->spinlock
, flags
);
620 /* This will reset the chip completely */
621 printk (KERN_ERR DRIVER_NAME
": Resetting chip\n");
623 toshoboe_stopchip (self
);
624 toshoboe_startchip (self
);
625 spin_unlock_irqrestore(&self
->spinlock
, flags
);
629 /*Generate packet of about mtt us long */
631 toshoboe_makemttpacket (struct toshoboe_cb
*self
, void *buf
, int mtt
)
635 xbofs
= ((int) (mtt
/100)) * (int) (self
->speed
);
636 xbofs
=xbofs
/80000; /*Eight bits per byte, and mtt is in us*/
639 IRDA_DEBUG (2, DRIVER_NAME
640 ": generated mtt of %d bytes for %d us at %d baud\n"
641 , xbofs
,mtt
,self
->speed
);
645 printk (KERN_ERR DRIVER_NAME
": wanted %d bytes MTT but TX_LEN is %d\n",
650 /*xbofs will do for SIR, MIR and FIR,SIR mode doesn't generate a checksum anyway */
651 memset (buf
, XBOF
, xbofs
);
657 /***********************************************************************/
661 toshoboe_dumptx (struct toshoboe_cb
*self
)
664 PROBE_DEBUG(KERN_WARNING
"TX:");
665 for (i
= 0; i
< RX_SLOTS
; ++i
)
666 PROBE_DEBUG(" (%d,%02x)",self
->ring
->tx
[i
].len
,self
->ring
->tx
[i
].control
);
667 PROBE_DEBUG(" [%d]\n",self
->speed
);
671 toshoboe_dumprx (struct toshoboe_cb
*self
, int score
)
674 PROBE_DEBUG(" %d\nRX:",score
);
675 for (i
= 0; i
< RX_SLOTS
; ++i
)
676 PROBE_DEBUG(" (%d,%02x)",self
->ring
->rx
[i
].len
,self
->ring
->rx
[i
].control
);
681 stuff_byte (__u8 byte
, __u8
* buf
)
685 case BOF
: /* FALLTHROUGH */
686 case EOF
: /* FALLTHROUGH */
688 /* Insert transparently coded */
689 buf
[0] = CE
; /* Send link escape */
690 buf
[1] = byte
^ IRDA_TRANS
; /* Complement bit 5 */
694 /* Non-special value, no transparency required */
702 toshoboe_probeinterrupt (int irq
, void *dev_id
)
704 struct toshoboe_cb
*self
= dev_id
;
707 irqstat
= INB (OBOE_ISR
);
710 if (!(irqstat
& OBOE_INT_MASK
))
713 /* Ack all the interrupts */
714 OUTB (irqstat
, OBOE_ISR
);
716 if (irqstat
& OBOE_INT_TXDONE
)
723 txp
= INB (OBOE_TXSLOT
) & OBOE_SLOT_MASK
;
724 if (self
->ring
->tx
[txp
].control
& OBOE_CTL_TX_HW_OWNS
)
728 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
732 if (irqstat
& OBOE_INT_RXDONE
) {
735 if (irqstat
& OBOE_INT_TXUNDER
) {
738 if (irqstat
& OBOE_INT_RXOVER
) {
741 if (irqstat
& OBOE_INT_SIP
) {
748 toshoboe_maketestpacket (unsigned char *buf
, int badcrc
, int fir
)
761 memset (buf
, 0, TT_LEN
);
765 fcs
.value
= INIT_FCS
;
767 memset (buf
, XBOF
, 10);
771 for (i
= 0; i
< TT_LEN
; ++i
)
773 len
+= stuff_byte (i
, buf
+ len
);
774 fcs
.value
= irda_fcs (fcs
.value
, i
);
777 len
+= stuff_byte (fcs
.bytes
[0] ^ badcrc
, buf
+ len
);
778 len
+= stuff_byte (fcs
.bytes
[1] ^ badcrc
, buf
+ len
);
785 toshoboe_probefail (struct toshoboe_cb
*self
, char *msg
)
787 printk (KERN_ERR DRIVER_NAME
"probe(%d) failed %s\n",self
-> speed
, msg
);
788 toshoboe_dumpregs (self
);
789 toshoboe_stopchip (self
);
790 free_irq (self
->io
.irq
, (void *) self
);
795 toshoboe_numvalidrcvs (struct toshoboe_cb
*self
)
798 for (i
= 0; i
< RX_SLOTS
; ++i
)
799 if ((self
->ring
->rx
[i
].control
& 0xe0) == 0)
806 toshoboe_numrcvs (struct toshoboe_cb
*self
)
809 for (i
= 0; i
< RX_SLOTS
; ++i
)
810 if (!(self
->ring
->rx
[i
].control
& OBOE_CTL_RX_HW_OWNS
))
817 toshoboe_probe (struct toshoboe_cb
*self
)
821 static const int bauds
[] = { 9600, 115200, 4000000, 1152000 };
823 static const int bauds
[] = { 9600, 115200, 4000000 };
827 IRDA_DEBUG (4, "%s()\n", __func__
);
829 if (request_irq (self
->io
.irq
, toshoboe_probeinterrupt
,
830 self
->io
.irqflags
, "toshoboe", (void *) self
))
832 printk (KERN_ERR DRIVER_NAME
": probe failed to allocate irq %d\n",
837 /* test 1: SIR filter and back to back */
839 for (j
= 0; j
< ARRAY_SIZE(bauds
); ++j
)
842 toshoboe_stopchip (self
);
845 spin_lock_irqsave(&self
->spinlock
, flags
);
846 /*Address is already setup */
847 toshoboe_startchip (self
);
848 self
->int_rx
= self
->int_tx
= 0;
849 self
->speed
= bauds
[j
];
850 toshoboe_setbaud (self
);
851 toshoboe_initptrs (self
);
852 spin_unlock_irqrestore(&self
->spinlock
, flags
);
854 self
->ring
->tx
[self
->txs
].control
=
855 /* (FIR only) OBOE_CTL_TX_SIP needed for switching to next slot */
856 /* MIR: all received data is stored in one slot */
857 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
858 : OBOE_CTL_TX_HW_OWNS
;
859 self
->ring
->tx
[self
->txs
].len
=
860 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
862 self
->txs
%= TX_SLOTS
;
864 self
->ring
->tx
[self
->txs
].control
=
865 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_SIP
866 : OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
867 self
->ring
->tx
[self
->txs
].len
=
868 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
870 self
->txs
%= TX_SLOTS
;
872 self
->ring
->tx
[self
->txs
].control
=
873 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
874 : OBOE_CTL_TX_HW_OWNS
;
875 self
->ring
->tx
[self
->txs
].len
=
876 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
878 self
->txs
%= TX_SLOTS
;
880 self
->ring
->tx
[self
->txs
].control
=
881 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
882 | OBOE_CTL_TX_SIP
| OBOE_CTL_TX_BAD_CRC
883 : OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
884 self
->ring
->tx
[self
->txs
].len
=
885 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
887 self
->txs
%= TX_SLOTS
;
889 toshoboe_dumptx (self
);
890 /* Turn on TX and RX and loopback */
891 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
895 while (toshoboe_numvalidrcvs (self
) != n
)
898 return toshoboe_probefail (self
, "filter test");
899 udelay ((9600*(TT_LEN
+16))/self
->speed
);
904 while ((toshoboe_numrcvs(self
) != self
->int_rx
) || (self
->int_tx
!= n
))
907 return toshoboe_probefail (self
, "interrupt test");
908 udelay ((9600*(TT_LEN
+16))/self
->speed
);
911 toshoboe_dumprx (self
,i
);
915 /* test 2: SIR in char at a time */
917 toshoboe_stopchip (self
);
918 self
->int_rx
= self
->int_tx
= 0;
920 spin_lock_irqsave(&self
->spinlock
, flags
);
921 toshoboe_startchip (self
);
922 spin_unlock_irqrestore(&self
->spinlock
, flags
);
925 self
->speed
= 115200;
926 toshoboe_setbaud (self
);
927 self
->ring
->tx
[self
->txs
].control
=
928 OBOE_CTL_TX_RTCENTX
| OBOE_CTL_TX_HW_OWNS
;
929 self
->ring
->tx
[self
->txs
].len
= 4;
931 ((unsigned char *) self
->tx_bufs
[self
->txs
])[0] = 'f';
932 ((unsigned char *) self
->tx_bufs
[self
->txs
])[1] = 'i';
933 ((unsigned char *) self
->tx_bufs
[self
->txs
])[2] = 's';
934 ((unsigned char *) self
->tx_bufs
[self
->txs
])[3] = 'h';
935 toshoboe_dumptx (self
);
936 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
939 while (toshoboe_numvalidrcvs (self
) != 4)
942 return toshoboe_probefail (self
, "Async test");
947 while ((toshoboe_numrcvs (self
) != self
->int_rx
) || (self
->int_tx
!= 1))
950 return toshoboe_probefail (self
, "Async interrupt test");
954 toshoboe_dumprx (self
,i
);
958 toshoboe_setbaud (self
);
959 toshoboe_stopchip (self
);
961 free_irq (self
->io
.irq
, (void *) self
);
963 printk (KERN_WARNING DRIVER_NAME
": Self test passed ok\n");
969 /******************************************************************/
970 /* Netdev style code */
972 /* Transmit something */
974 toshoboe_hard_xmit (struct sk_buff
*skb
, struct net_device
*dev
)
976 struct toshoboe_cb
*self
;
980 struct irda_skb_cb
*cb
= (struct irda_skb_cb
*) skb
->cb
;
982 self
= netdev_priv(dev
);
984 IRDA_ASSERT (self
!= NULL
, return NETDEV_TX_OK
; );
986 IRDA_DEBUG (1, "%s.tx:%x(%x)%x\n", __func__
987 ,skb
->len
,self
->txpending
,INB (OBOE_ENABLEH
));
989 IRDA_DEBUG (2, "%s.Not IrLAP:%x\n", __func__
, cb
->magic
);
991 _dumpbufs(skb
->data
,skb
->len
,'>');
995 /* change speed pending, wait for its execution */
997 return NETDEV_TX_BUSY
;
999 /* device stopped (apm) wait for restart */
1001 return NETDEV_TX_BUSY
;
1003 toshoboe_checkstuck (self
);
1005 /* Check if we need to change the speed */
1006 /* But not now. Wait after transmission if mtt not required */
1007 speed
=irda_get_next_speed(skb
);
1008 if ((speed
!= self
->io
.speed
) && (speed
!= -1))
1010 spin_lock_irqsave(&self
->spinlock
, flags
);
1012 if (self
->txpending
|| skb
->len
)
1014 self
->new_speed
= speed
;
1015 IRDA_DEBUG (1, "%s: Queued TxDone scheduled speed change %d\n" ,
1017 /* if no data, that's all! */
1020 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1021 dev_kfree_skb (skb
);
1022 return NETDEV_TX_OK
;
1024 /* True packet, go on, but */
1025 /* do not accept anything before change speed execution */
1026 netif_stop_queue(dev
);
1027 /* ready to process TxDone interrupt */
1028 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1032 /* idle and no data, change speed now */
1033 self
->speed
= speed
;
1034 toshoboe_setbaud (self
);
1035 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1036 dev_kfree_skb (skb
);
1037 return NETDEV_TX_OK
;
1042 if ((mtt
= irda_get_mtt(skb
)))
1044 /* This is fair since the queue should be empty anyway */
1045 spin_lock_irqsave(&self
->spinlock
, flags
);
1047 if (self
->txpending
)
1049 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1050 return NETDEV_TX_BUSY
;
1053 /* If in SIR mode we need to generate a string of XBOFs */
1054 /* In MIR and FIR we need to generate a string of data */
1055 /* which we will add a wrong checksum to */
1057 mtt
= toshoboe_makemttpacket (self
, self
->tx_bufs
[self
->txs
], mtt
);
1058 IRDA_DEBUG (1, "%s.mtt:%x(%x)%d\n", __func__
1059 ,skb
->len
,mtt
,self
->txpending
);
1062 self
->ring
->tx
[self
->txs
].len
= mtt
& 0xfff;
1064 ctl
= OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
1065 if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_FIRON
)
1067 ctl
|= OBOE_CTL_TX_BAD_CRC
| OBOE_CTL_TX_SIP
;
1070 else if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_MIRON
)
1072 ctl
|= OBOE_CTL_TX_BAD_CRC
;
1075 self
->ring
->tx
[self
->txs
].control
= ctl
;
1077 OUTB (0x0, OBOE_ENABLEH
);
1078 /* It is only a timer. Do not send mtt packet outside! */
1079 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
1084 self
->txs
%= TX_SLOTS
;
1089 printk(KERN_ERR DRIVER_NAME
": problem with mtt packet - ignored\n");
1091 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1095 dumpbufs(skb
->data
,skb
->len
,'>');
1098 spin_lock_irqsave(&self
->spinlock
, flags
);
1100 if (self
->ring
->tx
[self
->txs
].control
& OBOE_CTL_TX_HW_OWNS
)
1102 IRDA_DEBUG (0, "%s.ful:%x(%x)%x\n", __func__
1103 ,skb
->len
, self
->ring
->tx
[self
->txs
].control
, self
->txpending
);
1104 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
);
1105 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1106 return NETDEV_TX_BUSY
;
1109 if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_SIRON
)
1111 len
= async_wrap_skb (skb
, self
->tx_bufs
[self
->txs
], TX_BUF_SZ
);
1116 skb_copy_from_linear_data(skb
, self
->tx_bufs
[self
->txs
], len
);
1118 self
->ring
->tx
[self
->txs
].len
= len
& 0x0fff;
1120 /*Sometimes the HW doesn't see us assert RTCENTX in the interrupt code */
1121 /*later this plays safe, we garuntee the last packet to be transmitted */
1122 /*has RTCENTX set */
1124 ctl
= OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
1125 if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_FIRON
)
1127 ctl
|= OBOE_CTL_TX_SIP
;
1129 self
->ring
->tx
[self
->txs
].control
= ctl
;
1131 /* If transmitter is idle start in one-shot mode */
1133 if (!self
->txpending
)
1134 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
);
1139 self
->txs
%= TX_SLOTS
;
1141 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1142 dev_kfree_skb (skb
);
1144 return NETDEV_TX_OK
;
1147 /*interrupt handler */
1149 toshoboe_interrupt (int irq
, void *dev_id
)
1151 struct toshoboe_cb
*self
= dev_id
;
1153 struct sk_buff
*skb
= NULL
;
1155 irqstat
= INB (OBOE_ISR
);
1158 if (!(irqstat
& OBOE_INT_MASK
))
1161 /* Ack all the interrupts */
1162 OUTB (irqstat
, OBOE_ISR
);
1164 toshoboe_isntstuck (self
);
1167 if (irqstat
& OBOE_INT_TXDONE
)
1172 txp
= self
->txpending
;
1173 self
->txpending
= 0;
1175 for (i
= 0; i
< TX_SLOTS
; ++i
)
1177 if (self
->ring
->tx
[i
].control
& OBOE_CTL_TX_HW_OWNS
)
1180 IRDA_DEBUG (1, "%s.txd(%x)%x/%x\n", __func__
1181 ,irqstat
,txp
,self
->txpending
);
1183 txp
= INB (OBOE_TXSLOT
) & OBOE_SLOT_MASK
;
1185 /* Got anything queued ? start it together */
1186 if (self
->ring
->tx
[txp
].control
& OBOE_CTL_TX_HW_OWNS
)
1190 while (self
->ring
->tx
[txpc
].control
& OBOE_CTL_TX_HW_OWNS
)
1195 self
->netdev
->stats
.tx_packets
++;
1196 if (self
->ring
->tx
[txpc
].control
& OBOE_CTL_TX_HW_OWNS
)
1197 self
->ring
->tx
[txp
].control
&= ~OBOE_CTL_TX_RTCENTX
;
1199 self
->netdev
->stats
.tx_packets
--;
1201 self
->netdev
->stats
.tx_packets
++;
1203 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
);
1206 if ((!self
->txpending
) && (self
->new_speed
))
1208 self
->speed
= self
->new_speed
;
1209 IRDA_DEBUG (1, "%s: Executed TxDone scheduled speed change %d\n",
1210 __func__
, self
->speed
);
1211 toshoboe_setbaud (self
);
1214 /* Tell network layer that we want more frames */
1215 if (!self
->new_speed
)
1216 netif_wake_queue(self
->netdev
);
1219 if (irqstat
& OBOE_INT_RXDONE
)
1221 while (!(self
->ring
->rx
[self
->rxs
].control
& OBOE_CTL_RX_HW_OWNS
))
1223 int len
= self
->ring
->rx
[self
->rxs
].len
;
1225 IRDA_DEBUG (3, "%s.rcv:%x(%x)\n", __func__
1226 ,len
,self
->ring
->rx
[self
->rxs
].control
);
1229 dumpbufs(self
->rx_bufs
[self
->rxs
],len
,'<');
1232 if (self
->ring
->rx
[self
->rxs
].control
== 0)
1234 __u8 enable
= INB (OBOE_ENABLEH
);
1236 /* In SIR mode we need to check the CRC as this */
1237 /* hasn't been done by the hardware */
1238 if (enable
& OBOE_ENABLEH_SIRON
)
1240 if (!toshoboe_checkfcs (self
->rx_bufs
[self
->rxs
], len
))
1242 /*Trim off the CRC */
1247 IRDA_DEBUG (1, "%s.SIR:%x(%x)\n", __func__
, len
,enable
);
1251 else if (enable
& OBOE_ENABLEH_MIRON
)
1257 IRDA_DEBUG (2, "%s.MIR:%x(%x)\n", __func__
, len
,enable
);
1260 else if (enable
& OBOE_ENABLEH_FIRON
)
1263 len
-= 4; /*FIXME: check this */
1266 IRDA_DEBUG (1, "%s.FIR:%x(%x)\n", __func__
, len
,enable
);
1269 IRDA_DEBUG (0, "%s.?IR:%x(%x)\n", __func__
, len
,enable
);
1273 skb
= dev_alloc_skb (len
+ 1);
1276 skb_reserve (skb
, 1);
1279 skb_copy_to_linear_data(skb
, self
->rx_bufs
[self
->rxs
],
1281 self
->netdev
->stats
.rx_packets
++;
1282 skb
->dev
= self
->netdev
;
1283 skb_reset_mac_header(skb
);
1284 skb
->protocol
= htons (ETH_P_IRDA
);
1289 "%s(), memory squeeze, dropping frame.\n",
1296 /* TODO: =========================================== */
1297 /* if OBOE_CTL_RX_LENGTH, our buffers are too small */
1298 /* (MIR or FIR) data is lost. */
1299 /* (SIR) data is splitted in several slots. */
1300 /* we have to join all the received buffers received */
1301 /*in a large buffer before checking CRC. */
1302 IRDA_DEBUG (0, "%s.err:%x(%x)\n", __func__
1303 ,len
,self
->ring
->rx
[self
->rxs
].control
);
1306 self
->ring
->rx
[self
->rxs
].len
= 0x0;
1307 self
->ring
->rx
[self
->rxs
].control
= OBOE_CTL_RX_HW_OWNS
;
1310 self
->rxs
%= RX_SLOTS
;
1318 if (irqstat
& OBOE_INT_TXUNDER
)
1320 printk (KERN_WARNING DRIVER_NAME
": tx fifo underflow\n");
1322 if (irqstat
& OBOE_INT_RXOVER
)
1324 printk (KERN_WARNING DRIVER_NAME
": rx fifo overflow\n");
1326 /* This must be useful for something... */
1327 if (irqstat
& OBOE_INT_SIP
)
1330 IRDA_DEBUG (1, "%s.sip:%x(%x)%x\n", __func__
1331 ,self
->int_sip
,irqstat
,self
->txpending
);
1338 toshoboe_net_open (struct net_device
*dev
)
1340 struct toshoboe_cb
*self
;
1341 unsigned long flags
;
1344 IRDA_DEBUG (4, "%s()\n", __func__
);
1346 self
= netdev_priv(dev
);
1354 rc
= request_irq (self
->io
.irq
, toshoboe_interrupt
,
1355 IRQF_SHARED
| IRQF_DISABLED
, dev
->name
, self
);
1359 spin_lock_irqsave(&self
->spinlock
, flags
);
1360 toshoboe_startchip (self
);
1361 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1363 /* Ready to play! */
1364 netif_start_queue(dev
);
1367 * Open new IrLAP layer instance, now that everything should be
1368 * initialized properly
1370 self
->irlap
= irlap_open (dev
, &self
->qos
, driver_name
);
1378 toshoboe_net_close (struct net_device
*dev
)
1380 struct toshoboe_cb
*self
;
1382 IRDA_DEBUG (4, "%s()\n", __func__
);
1384 IRDA_ASSERT (dev
!= NULL
, return -1; );
1385 self
= netdev_priv(dev
);
1388 netif_stop_queue(dev
);
1390 /* Stop and remove instance of IrLAP */
1392 irlap_close (self
->irlap
);
1397 free_irq (self
->io
.irq
, (void *) self
);
1401 toshoboe_stopchip (self
);
1408 * Function toshoboe_net_ioctl (dev, rq, cmd)
1410 * Process IOCTL commands for this device
1414 toshoboe_net_ioctl (struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1416 struct if_irda_req
*irq
= (struct if_irda_req
*) rq
;
1417 struct toshoboe_cb
*self
;
1418 unsigned long flags
;
1421 IRDA_ASSERT (dev
!= NULL
, return -1; );
1423 self
= netdev_priv(dev
);
1425 IRDA_ASSERT (self
!= NULL
, return -1; );
1427 IRDA_DEBUG (5, "%s(), %s, (cmd=0x%X)\n", __func__
, dev
->name
, cmd
);
1429 /* Disable interrupts & save flags */
1430 spin_lock_irqsave(&self
->spinlock
, flags
);
1434 case SIOCSBANDWIDTH
: /* Set bandwidth */
1435 /* This function will also be used by IrLAP to change the
1436 * speed, so we still must allow for speed change within
1437 * interrupt context.
1439 IRDA_DEBUG (1, "%s(BANDWIDTH), %s, (%X/%ld\n", __func__
1440 ,dev
->name
, INB (OBOE_STATUS
), irq
->ifr_baudrate
);
1441 if (!in_interrupt () && !capable (CAP_NET_ADMIN
)) {
1446 /* self->speed=irq->ifr_baudrate; */
1447 /* toshoboe_setbaud(self); */
1448 /* Just change speed once - inserted by Paul Bristow */
1449 self
->new_speed
= irq
->ifr_baudrate
;
1451 case SIOCSMEDIABUSY
: /* Set media busy */
1452 IRDA_DEBUG (1, "%s(MEDIABUSY), %s, (%X/%x)\n", __func__
1453 ,dev
->name
, INB (OBOE_STATUS
), capable (CAP_NET_ADMIN
) );
1454 if (!capable (CAP_NET_ADMIN
)) {
1458 irda_device_set_media_busy (self
->netdev
, TRUE
);
1460 case SIOCGRECEIVING
: /* Check if we are receiving right now */
1461 irq
->ifr_receiving
= (INB (OBOE_STATUS
) & OBOE_STATUS_RXBUSY
) ? 1 : 0;
1462 IRDA_DEBUG (3, "%s(RECEIVING), %s, (%X/%x)\n", __func__
1463 ,dev
->name
, INB (OBOE_STATUS
), irq
->ifr_receiving
);
1466 IRDA_DEBUG (1, "%s(?), %s, (cmd=0x%X)\n", __func__
, dev
->name
, cmd
);
1470 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1475 MODULE_DESCRIPTION("Toshiba OBOE IrDA Device Driver");
1476 MODULE_AUTHOR("James McKenzie <james@fishsoup.dhs.org>");
1477 MODULE_LICENSE("GPL");
1479 module_param (max_baud
, int, 0);
1480 MODULE_PARM_DESC(max_baud
, "Maximum baud rate");
1483 module_param (do_probe
, bool, 0);
1484 MODULE_PARM_DESC(do_probe
, "Enable/disable chip probing and self-test");
1488 toshoboe_close (struct pci_dev
*pci_dev
)
1491 struct toshoboe_cb
*self
= (struct toshoboe_cb
*)pci_get_drvdata(pci_dev
);
1493 IRDA_DEBUG (4, "%s()\n", __func__
);
1495 IRDA_ASSERT (self
!= NULL
, return; );
1499 toshoboe_stopchip (self
);
1502 release_region (self
->io
.fir_base
, self
->io
.fir_ext
);
1504 for (i
= 0; i
< TX_SLOTS
; ++i
)
1506 kfree (self
->tx_bufs
[i
]);
1507 self
->tx_bufs
[i
] = NULL
;
1510 for (i
= 0; i
< RX_SLOTS
; ++i
)
1512 kfree (self
->rx_bufs
[i
]);
1513 self
->rx_bufs
[i
] = NULL
;
1516 unregister_netdev(self
->netdev
);
1518 kfree (self
->ringbuf
);
1519 self
->ringbuf
= NULL
;
1522 free_netdev(self
->netdev
);
1525 static const struct net_device_ops toshoboe_netdev_ops
= {
1526 .ndo_open
= toshoboe_net_open
,
1527 .ndo_stop
= toshoboe_net_close
,
1528 .ndo_start_xmit
= toshoboe_hard_xmit
,
1529 .ndo_do_ioctl
= toshoboe_net_ioctl
,
1533 toshoboe_open (struct pci_dev
*pci_dev
, const struct pci_device_id
*pdid
)
1535 struct toshoboe_cb
*self
;
1536 struct net_device
*dev
;
1541 IRDA_DEBUG (4, "%s()\n", __func__
);
1543 if ((err
=pci_enable_device(pci_dev
)))
1546 dev
= alloc_irdadev(sizeof (struct toshoboe_cb
));
1549 printk (KERN_ERR DRIVER_NAME
": can't allocate memory for "
1550 "IrDA control block\n");
1554 self
= netdev_priv(dev
);
1556 self
->pdev
= pci_dev
;
1557 self
->base
= pci_resource_start(pci_dev
,0);
1559 self
->io
.fir_base
= self
->base
;
1560 self
->io
.fir_ext
= OBOE_IO_EXTENT
;
1561 self
->io
.irq
= pci_dev
->irq
;
1562 self
->io
.irqflags
= IRQF_SHARED
| IRQF_DISABLED
;
1564 self
->speed
= self
->io
.speed
= 9600;
1567 /* Lock the port that we need */
1568 if (NULL
==request_region (self
->io
.fir_base
, self
->io
.fir_ext
, driver_name
))
1570 printk (KERN_ERR DRIVER_NAME
": can't get iobase of 0x%03x\n"
1571 ,self
->io
.fir_base
);
1576 spin_lock_init(&self
->spinlock
);
1578 irda_init_max_qos_capabilies (&self
->qos
);
1579 self
->qos
.baud_rate
.bits
= 0;
1581 if (max_baud
>= 2400)
1582 self
->qos
.baud_rate
.bits
|= IR_2400
;
1583 /*if (max_baud>=4800) idev->qos.baud_rate.bits|=IR_4800; */
1584 if (max_baud
>= 9600)
1585 self
->qos
.baud_rate
.bits
|= IR_9600
;
1586 if (max_baud
>= 19200)
1587 self
->qos
.baud_rate
.bits
|= IR_19200
;
1588 if (max_baud
>= 115200)
1589 self
->qos
.baud_rate
.bits
|= IR_115200
;
1591 if (max_baud
>= 1152000)
1593 self
->qos
.baud_rate
.bits
|= IR_1152000
;
1596 if (max_baud
>= 4000000)
1598 self
->qos
.baud_rate
.bits
|= (IR_4000000
<< 8);
1601 /*FIXME: work this out... */
1602 self
->qos
.min_turn_time
.bits
= 0xff;
1604 irda_qos_bits_to_value (&self
->qos
);
1606 /* Allocate twice the size to guarantee alignment */
1607 self
->ringbuf
= kmalloc(OBOE_RING_LEN
<< 1, GFP_KERNEL
);
1610 printk (KERN_ERR DRIVER_NAME
": can't allocate DMA buffers\n");
1615 #if (BITS_PER_LONG == 64)
1616 #error broken on 64-bit: casts pointer to 32-bit, and then back to pointer.
1619 /*We need to align the taskfile on a taskfile size boundary */
1623 addr
= (__u32
) self
->ringbuf
;
1624 addr
&= ~(OBOE_RING_LEN
- 1);
1625 addr
+= OBOE_RING_LEN
;
1626 self
->ring
= (struct OboeRing
*) addr
;
1629 memset (self
->ring
, 0, OBOE_RING_LEN
);
1630 self
->io
.mem_base
= (__u32
) self
->ring
;
1633 for (i
= 0; i
< TX_SLOTS
; ++i
)
1635 self
->tx_bufs
[i
] = kmalloc (TX_BUF_SZ
, GFP_KERNEL
);
1636 if (!self
->tx_bufs
[i
])
1640 for (i
= 0; i
< RX_SLOTS
; ++i
)
1642 self
->rx_bufs
[i
] = kmalloc (RX_BUF_SZ
, GFP_KERNEL
);
1643 if (!self
->rx_bufs
[i
])
1649 printk (KERN_ERR DRIVER_NAME
": can't allocate rx/tx buffers\n");
1657 if (!toshoboe_probe (self
))
1664 SET_NETDEV_DEV(dev
, &pci_dev
->dev
);
1665 dev
->netdev_ops
= &toshoboe_netdev_ops
;
1667 err
= register_netdev(dev
);
1670 printk (KERN_ERR DRIVER_NAME
": register_netdev() failed\n");
1674 printk (KERN_INFO
"IrDA: Registered device %s\n", dev
->name
);
1676 pci_set_drvdata(pci_dev
,self
);
1678 printk (KERN_INFO DRIVER_NAME
": Using multiple tasks\n");
1683 for (i
= 0; i
< TX_SLOTS
; ++i
)
1684 kfree (self
->tx_bufs
[i
]);
1685 for (i
= 0; i
< RX_SLOTS
; ++i
)
1686 kfree (self
->rx_bufs
[i
]);
1687 kfree(self
->ringbuf
);
1690 release_region (self
->io
.fir_base
, self
->io
.fir_ext
);
1699 toshoboe_gotosleep (struct pci_dev
*pci_dev
, pm_message_t crap
)
1701 struct toshoboe_cb
*self
= (struct toshoboe_cb
*)pci_get_drvdata(pci_dev
);
1702 unsigned long flags
;
1705 IRDA_DEBUG (4, "%s()\n", __func__
);
1707 if (!self
|| self
->stopped
)
1710 if ((!self
->irdad
) && (!self
->async
))
1713 /* Flush all packets */
1714 while ((i
--) && (self
->txpending
))
1717 spin_lock_irqsave(&self
->spinlock
, flags
);
1719 toshoboe_stopchip (self
);
1721 self
->txpending
= 0;
1723 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1728 toshoboe_wakeup (struct pci_dev
*pci_dev
)
1730 struct toshoboe_cb
*self
= (struct toshoboe_cb
*)pci_get_drvdata(pci_dev
);
1731 unsigned long flags
;
1733 IRDA_DEBUG (4, "%s()\n", __func__
);
1735 if (!self
|| !self
->stopped
)
1738 if ((!self
->irdad
) && (!self
->async
))
1741 spin_lock_irqsave(&self
->spinlock
, flags
);
1743 toshoboe_startchip (self
);
1746 netif_wake_queue(self
->netdev
);
1747 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1751 static struct pci_driver donauboe_pci_driver
= {
1753 .id_table
= toshoboe_pci_tbl
,
1754 .probe
= toshoboe_open
,
1755 .remove
= toshoboe_close
,
1756 .suspend
= toshoboe_gotosleep
,
1757 .resume
= toshoboe_wakeup
1761 donauboe_init (void)
1763 return pci_register_driver(&donauboe_pci_driver
);
1767 donauboe_cleanup (void)
1769 pci_unregister_driver(&donauboe_pci_driver
);
1772 module_init(donauboe_init
);
1773 module_exit(donauboe_cleanup
);