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 */
54 "$Id: donauboe.c V2.18 ven jan 10 03:14:16 2003$";
56 /* See below for a description of the logic in this driver */
58 /* User servicable parts */
59 /* USE_PROBE Create the code which probes the chip and does a few tests */
60 /* do_probe module parameter Enable this code */
61 /* Probe code is very useful for understanding how the hardware works */
62 /* Use it with various combinations of TT_LEN, RX_LEN */
63 /* Strongly recomended, disable if the probe fails on your machine */
64 /* and send me <james@fishsoup.dhs.org> the output of dmesg */
68 /* Trace Transmit ring, interrupts, Receive ring or not ? */
69 #define PROBE_VERBOSE 1
71 /* Debug option, examine sent and received raw data */
72 /* Irdadump is better, but does not see all packets. enable it if you want. */
75 /* MIR mode has not been tested. Some behaviour is different */
76 /* Seems to work against an Ericsson R520 for me. -Martin */
79 /* Schedule back to back hardware transmits wherever possible, otherwise */
80 /* we need an interrupt for every frame, unset if oboe works for a bit and */
84 /* Set the number of slots in the rings */
85 /* If you get rx/tx fifo overflows at high bitrates, you can try increasing */
88 #define RING_SIZE (OBOE_RING_SIZE_RX8 | OBOE_RING_SIZE_TX8)
93 /* Less user servicable parts below here */
95 /* Test, Transmit and receive buffer sizes, adjust at your peril */
96 /* remarks: nfs usually needs 1k blocks */
97 /* remarks: in SIR mode, CRC is received, -> RX_LEN=TX_LEN+2 */
98 /* remarks: test accepts large blocks. Standard is 0x80 */
99 /* When TT_LEN > RX_LEN (SIR mode) data is stored in successive slots. */
100 /* When 3 or more slots are needed for each test packet, */
101 /* data received in the first slots is overwritten, even */
102 /* if OBOE_CTL_RX_HW_OWNS is not set, without any error! */
106 /* Real transmitted length (SIR mode) is about 14+(2%*TX_LEN) more */
107 /* long than user-defined length (see async_wrap_skb) and is less then 4K */
108 /* Real received length is (max RX_LEN) differs from user-defined */
109 /* length only b the CRC (2 or 4 bytes) */
110 #define BUF_SAFETY 0x7a
111 #define RX_BUF_SZ (RX_LEN)
112 #define TX_BUF_SZ (TX_LEN+BUF_SAFETY)
115 /* Logic of the netdev part of this driver */
117 /* The RX ring is filled with buffers, when a packet arrives */
118 /* it is DMA'd into the buffer which is marked used and RxDone called */
119 /* RxDone forms an skb (and checks the CRC if in SIR mode) and ships */
120 /* the packet off upstairs */
122 /* The transmitter on the oboe chip can work in one of two modes */
123 /* for each ring->tx[] the transmitter can either */
124 /* a) transmit the packet, leave the trasmitter enabled and proceed to */
127 /* b) transmit the packet, switch off the transmitter and issue TxDone */
129 /* All packets are entered into the ring in mode b), if the ring was */
130 /* empty the transmitter is started. */
132 /* If OPTIMIZE_TX is defined then in TxDone if the ring contains */
133 /* more than one packet, all but the last are set to mode a) [HOWEVER */
134 /* the hardware may not notice this, this is why we start in mode b) ] */
135 /* then restart the transmitter */
137 /* If OPTIMIZE_TX is not defined then we just restart the transmitter */
138 /* if the ring isn't empty */
140 /* Speed changes are delayed until the TxRing is empty */
141 /* mtt is handled by generating packets with bad CRCs, before the data */
144 /* check the mtt works ok */
145 /* finish the watchdog */
147 /* No user servicable parts below here */
149 #include <linux/module.h>
151 #include <linux/kernel.h>
152 #include <linux/types.h>
153 #include <linux/skbuff.h>
154 #include <linux/netdevice.h>
155 #include <linux/ioport.h>
156 #include <linux/delay.h>
157 #include <linux/slab.h>
158 #include <linux/init.h>
159 #include <linux/pci.h>
160 #include <linux/rtnetlink.h>
162 #include <asm/system.h>
165 #include <net/irda/wrapper.h>
166 #include <net/irda/irda.h>
167 //#include <net/irda/irmod.h>
168 //#include <net/irda/irlap_frame.h>
169 #include <net/irda/irda_device.h>
170 #include <net/irda/crc.h>
172 #include "donauboe.h"
174 #define INB(port) inb_p(port)
175 #define OUTB(val,port) outb_p(val,port)
176 #define OUTBP(val,port) outb_p(val,port)
178 #define PROMPT OUTB(OBOE_PROMPT_BIT,OBOE_PROMPT);
181 #define PROBE_DEBUG(args...) (printk (args))
183 #define PROBE_DEBUG(args...) ;
186 /* Set the DMA to be byte at a time */
187 #define CONFIG0H_DMA_OFF OBOE_CONFIG0H_RCVANY
188 #define CONFIG0H_DMA_ON_NORX CONFIG0H_DMA_OFF| OBOE_CONFIG0H_ENDMAC
189 #define CONFIG0H_DMA_ON CONFIG0H_DMA_ON_NORX | OBOE_CONFIG0H_ENRX
191 static struct pci_device_id toshoboe_pci_tbl
[] = {
192 { PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_FIR701
, PCI_ANY_ID
, PCI_ANY_ID
, },
193 { PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_FIRD01
, PCI_ANY_ID
, PCI_ANY_ID
, },
194 { } /* Terminating entry */
196 MODULE_DEVICE_TABLE(pci
, toshoboe_pci_tbl
);
198 #define DRIVER_NAME "toshoboe"
199 static char *driver_name
= DRIVER_NAME
;
201 static int max_baud
= 4000000;
203 static int do_probe
= 0;
207 /**********************************************************************/
209 toshoboe_checkfcs (unsigned char *buf
, int len
)
219 fcs
.value
= INIT_FCS
;
221 for (i
= 0; i
< len
; ++i
)
222 fcs
.value
= irda_fcs (fcs
.value
, *(buf
++));
224 return (fcs
.value
== GOOD_FCS
);
227 /***********************************************************************/
228 /* Generic chip handling code */
230 static unsigned char dump
[50];
232 _dumpbufs (unsigned char *data
, int len
, char tete
)
236 for (i
=0;i
<len
;i
+=16) {
237 for (j
=0;j
<16 && i
+j
<len
;j
++) { sprintf(&dump
[3*j
],"%02x.",data
[i
+j
]); }
239 IRDA_DEBUG (2, "%c%s\n",head
, dump
);
246 /* Dump the registers */
248 toshoboe_dumpregs (struct toshoboe_cb
*self
)
252 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
254 ringbase
= INB (OBOE_RING_BASE0
) << 10;
255 ringbase
|= INB (OBOE_RING_BASE1
) << 18;
256 ringbase
|= INB (OBOE_RING_BASE2
) << 26;
258 printk (KERN_ERR DRIVER_NAME
": Register dump:\n");
259 printk (KERN_ERR
"Interrupts: Tx:%d Rx:%d TxUnder:%d RxOver:%d Sip:%d\n",
260 self
->int_tx
, self
->int_rx
, self
->int_txunder
, self
->int_rxover
,
262 printk (KERN_ERR
"RX %02x TX %02x RingBase %08x\n",
263 INB (OBOE_RXSLOT
), INB (OBOE_TXSLOT
), ringbase
);
264 printk (KERN_ERR
"RING_SIZE %02x IER %02x ISR %02x\n",
265 INB (OBOE_RING_SIZE
), INB (OBOE_IER
), INB (OBOE_ISR
));
266 printk (KERN_ERR
"CONFIG1 %02x STATUS %02x\n",
267 INB (OBOE_CONFIG1
), INB (OBOE_STATUS
));
268 printk (KERN_ERR
"CONFIG0 %02x%02x ENABLE %02x%02x\n",
269 INB (OBOE_CONFIG0H
), INB (OBOE_CONFIG0L
),
270 INB (OBOE_ENABLEH
), INB (OBOE_ENABLEL
));
271 printk (KERN_ERR
"NEW_PCONFIG %02x%02x CURR_PCONFIG %02x%02x\n",
272 INB (OBOE_NEW_PCONFIGH
), INB (OBOE_NEW_PCONFIGL
),
273 INB (OBOE_CURR_PCONFIGH
), INB (OBOE_CURR_PCONFIGL
));
274 printk (KERN_ERR
"MAXLEN %02x%02x RXCOUNT %02x%02x\n",
275 INB (OBOE_MAXLENH
), INB (OBOE_MAXLENL
),
276 INB (OBOE_RXCOUNTL
), INB (OBOE_RXCOUNTH
));
281 ringbase
= virt_to_bus (self
->ring
);
282 printk (KERN_ERR
"Ring at %08x:\n", ringbase
);
283 printk (KERN_ERR
"RX:");
284 for (i
= 0; i
< RX_SLOTS
; ++i
)
285 printk (" (%d,%02x)",self
->ring
->rx
[i
].len
,self
->ring
->rx
[i
].control
);
287 printk (KERN_ERR
"TX:");
288 for (i
= 0; i
< RX_SLOTS
; ++i
)
289 printk (" (%d,%02x)",self
->ring
->tx
[i
].len
,self
->ring
->tx
[i
].control
);
295 /*Don't let the chip look at memory */
297 toshoboe_disablebm (struct toshoboe_cb
*self
)
300 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
302 pci_read_config_byte (self
->pdev
, PCI_COMMAND
, &command
);
303 command
&= ~PCI_COMMAND_MASTER
;
304 pci_write_config_byte (self
->pdev
, PCI_COMMAND
, command
);
308 /* Shutdown the chip and point the taskfile reg somewhere else */
310 toshoboe_stopchip (struct toshoboe_cb
*self
)
312 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
314 /*Disable interrupts */
315 OUTB (0x0, OBOE_IER
);
316 /*Disable DMA, Disable Rx, Disable Tx */
317 OUTB (CONFIG0H_DMA_OFF
, OBOE_CONFIG0H
);
318 /*Disable SIR MIR FIR, Tx and Rx */
319 OUTB (0x00, OBOE_ENABLEH
);
320 /*Point the ring somewhere safe */
321 OUTB (0x3f, OBOE_RING_BASE2
);
322 OUTB (0xff, OBOE_RING_BASE1
);
323 OUTB (0xff, OBOE_RING_BASE0
);
325 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
326 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
328 /*Acknoledge any pending interrupts */
329 OUTB (0xff, OBOE_ISR
);
332 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
335 OUTB (OBOE_CONFIG1_OFF
, OBOE_CONFIG1
);
337 toshoboe_disablebm (self
);
340 /* Transmitter initialization */
342 toshoboe_start_DMA (struct toshoboe_cb
*self
, int opts
)
344 OUTB (0x0, OBOE_ENABLEH
);
345 OUTB (CONFIG0H_DMA_ON
| opts
, OBOE_CONFIG0H
);
346 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
350 /*Set the baud rate */
352 toshoboe_setbaud (struct toshoboe_cb
*self
)
357 IRDA_DEBUG (2, "%s(%d/%d)\n", __FUNCTION__
, self
->speed
, self
->io
.speed
);
375 printk (KERN_ERR DRIVER_NAME
": switch to unsupported baudrate %d\n",
382 /* For SIR the preamble is done by adding XBOFs */
384 /* set to filtered SIR mode, filter looks for BOF and EOF */
386 pconfig
|= 47 << OBOE_PCONFIG_BAUDSHIFT
;
387 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
390 pconfig
|= 23 << OBOE_PCONFIG_BAUDSHIFT
;
391 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
394 pconfig
|= 11 << OBOE_PCONFIG_BAUDSHIFT
;
395 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
398 pconfig
|= 5 << OBOE_PCONFIG_BAUDSHIFT
;
399 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
402 pconfig
|= 2 << OBOE_PCONFIG_BAUDSHIFT
;
403 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
406 pconfig
|= 1 << OBOE_PCONFIG_BAUDSHIFT
;
407 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
410 pconfig
|= 0 << OBOE_PCONFIG_BAUDSHIFT
;
411 pconfig
|= 25 << OBOE_PCONFIG_WIDTHSHIFT
;
414 /*Set to packet based reception */
415 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
416 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
429 config0l
= OBOE_CONFIG0L_ENSIR
;
432 /*Set to character based reception */
433 /*System will lock if MAXLEN=0 */
434 /*so have to be careful */
435 OUTB (0x01, OBOE_MAXLENH
);
436 OUTB (0x01, OBOE_MAXLENL
);
437 OUTB (0x00, OBOE_MAXLENH
);
441 /*Set to packet based reception */
442 config0l
|= OBOE_CONFIG0L_ENSIRF
;
443 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
444 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
450 /* Set for 16 bit CRC and enable MIR */
451 /* Preamble now handled by the chip */
453 pconfig
|= 0 << OBOE_PCONFIG_BAUDSHIFT
;
454 pconfig
|= 8 << OBOE_PCONFIG_WIDTHSHIFT
;
455 pconfig
|= 1 << OBOE_PCONFIG_PREAMBLESHIFT
;
456 config0l
= OBOE_CONFIG0L_CRC16
| OBOE_CONFIG0L_ENMIR
;
460 /* Set for 32 bit CRC and enable FIR */
461 /* Preamble handled by the chip */
463 pconfig
|= 0 << OBOE_PCONFIG_BAUDSHIFT
;
464 /* Documentation says 14, but toshiba use 15 in their drivers */
465 pconfig
|= 15 << OBOE_PCONFIG_PREAMBLESHIFT
;
466 config0l
= OBOE_CONFIG0L_ENFIR
;
470 /* Copy into new PHY config buffer */
471 OUTBP (pconfig
>> 8, OBOE_NEW_PCONFIGH
);
472 OUTB (pconfig
& 0xff, OBOE_NEW_PCONFIGL
);
473 OUTB (config0l
, OBOE_CONFIG0L
);
475 /* Now make OBOE copy from new PHY to current PHY */
476 OUTB (0x0, OBOE_ENABLEH
);
477 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
480 /* speed change executed */
482 self
->io
.speed
= self
->speed
;
485 /*Let the chip look at memory */
487 toshoboe_enablebm (struct toshoboe_cb
*self
)
489 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
490 pci_set_master (self
->pdev
);
495 toshoboe_initring (struct toshoboe_cb
*self
)
499 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
501 for (i
= 0; i
< TX_SLOTS
; ++i
)
503 self
->ring
->tx
[i
].len
= 0;
504 self
->ring
->tx
[i
].control
= 0x00;
505 self
->ring
->tx
[i
].address
= virt_to_bus (self
->tx_bufs
[i
]);
508 for (i
= 0; i
< RX_SLOTS
; ++i
)
510 self
->ring
->rx
[i
].len
= RX_LEN
;
511 self
->ring
->rx
[i
].len
= 0;
512 self
->ring
->rx
[i
].address
= virt_to_bus (self
->rx_bufs
[i
]);
513 self
->ring
->rx
[i
].control
= OBOE_CTL_RX_HW_OWNS
;
518 toshoboe_resetptrs (struct toshoboe_cb
*self
)
520 /* Can reset pointers by twidling DMA */
521 OUTB (0x0, OBOE_ENABLEH
);
522 OUTBP (CONFIG0H_DMA_OFF
, OBOE_CONFIG0H
);
523 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
525 self
->rxs
= inb_p (OBOE_RXSLOT
) & OBOE_SLOT_MASK
;
526 self
->txs
= inb_p (OBOE_TXSLOT
) & OBOE_SLOT_MASK
;
529 /* Called in locked state */
531 toshoboe_initptrs (struct toshoboe_cb
*self
)
534 /* spin_lock_irqsave(self->spinlock, flags); */
535 /* save_flags (flags); */
537 /* Can reset pointers by twidling DMA */
538 toshoboe_resetptrs (self
);
540 OUTB (0x0, OBOE_ENABLEH
);
541 OUTB (CONFIG0H_DMA_ON
, OBOE_CONFIG0H
);
542 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
546 /* spin_unlock_irqrestore(self->spinlock, flags); */
547 /* restore_flags (flags); */
550 /* Wake the chip up and get it looking at the rings */
551 /* Called in locked state */
553 toshoboe_startchip (struct toshoboe_cb
*self
)
557 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
559 toshoboe_initring (self
);
560 toshoboe_enablebm (self
);
561 OUTBP (OBOE_CONFIG1_RESET
, OBOE_CONFIG1
);
562 OUTBP (OBOE_CONFIG1_ON
, OBOE_CONFIG1
);
564 /* Stop the clocks */
565 OUTB (0, OBOE_ENABLEH
);
567 /*Set size of rings */
568 OUTB (RING_SIZE
, OBOE_RING_SIZE
);
570 /*Acknoledge any pending interrupts */
571 OUTB (0xff, OBOE_ISR
);
574 OUTB (OBOE_INT_TXDONE
| OBOE_INT_RXDONE
|
575 OBOE_INT_TXUNDER
| OBOE_INT_RXOVER
| OBOE_INT_SIP
, OBOE_IER
);
577 /*Acknoledge any pending interrupts */
578 OUTB (0xff, OBOE_ISR
);
580 /*Set the maximum packet length to 0xfff (4095) */
581 OUTB (RX_LEN
>> 8, OBOE_MAXLENH
);
582 OUTB (RX_LEN
& 0xff, OBOE_MAXLENL
);
585 OUTB (CONFIG0H_DMA_OFF
, OBOE_CONFIG0H
);
587 /*Find out where the rings live */
588 physaddr
= virt_to_bus (self
->ring
);
590 IRDA_ASSERT ((physaddr
& 0x3ff) == 0,
591 printk (KERN_ERR DRIVER_NAME
"ring not correctly aligned\n");
594 OUTB ((physaddr
>> 10) & 0xff, OBOE_RING_BASE0
);
595 OUTB ((physaddr
>> 18) & 0xff, OBOE_RING_BASE1
);
596 OUTB ((physaddr
>> 26) & 0x3f, OBOE_RING_BASE2
);
598 /*Enable DMA controler in byte mode and RX */
599 OUTB (CONFIG0H_DMA_ON
, OBOE_CONFIG0H
);
601 /* Start up the clocks */
602 OUTB (OBOE_ENABLEH_PHYANDCLOCK
, OBOE_ENABLEH
);
604 /*set to sensible speed */
606 toshoboe_setbaud (self
);
607 toshoboe_initptrs (self
);
611 toshoboe_isntstuck (struct toshoboe_cb
*self
)
616 toshoboe_checkstuck (struct toshoboe_cb
*self
)
622 spin_lock_irqsave(&self
->spinlock
, flags
);
624 /* This will reset the chip completely */
625 printk (KERN_ERR DRIVER_NAME
": Resetting chip\n");
627 toshoboe_stopchip (self
);
628 toshoboe_startchip (self
);
629 spin_unlock_irqrestore(&self
->spinlock
, flags
);
633 /*Generate packet of about mtt us long */
635 toshoboe_makemttpacket (struct toshoboe_cb
*self
, void *buf
, int mtt
)
639 xbofs
= ((int) (mtt
/100)) * (int) (self
->speed
);
640 xbofs
=xbofs
/80000; /*Eight bits per byte, and mtt is in us*/
643 IRDA_DEBUG (2, DRIVER_NAME
644 ": generated mtt of %d bytes for %d us at %d baud\n"
645 , xbofs
,mtt
,self
->speed
);
649 printk (KERN_ERR DRIVER_NAME
": wanted %d bytes MTT but TX_LEN is %d\n",
654 /*xbofs will do for SIR, MIR and FIR,SIR mode doesn't generate a checksum anyway */
655 memset (buf
, XBOF
, xbofs
);
661 /***********************************************************************/
665 toshoboe_dumptx (struct toshoboe_cb
*self
)
668 PROBE_DEBUG(KERN_WARNING
"TX:");
669 for (i
= 0; i
< RX_SLOTS
; ++i
)
670 PROBE_DEBUG(" (%d,%02x)",self
->ring
->tx
[i
].len
,self
->ring
->tx
[i
].control
);
671 PROBE_DEBUG(" [%d]\n",self
->speed
);
675 toshoboe_dumprx (struct toshoboe_cb
*self
, int score
)
678 PROBE_DEBUG(" %d\nRX:",score
);
679 for (i
= 0; i
< RX_SLOTS
; ++i
)
680 PROBE_DEBUG(" (%d,%02x)",self
->ring
->rx
[i
].len
,self
->ring
->rx
[i
].control
);
685 stuff_byte (__u8 byte
, __u8
* buf
)
689 case BOF
: /* FALLTHROUGH */
690 case EOF
: /* FALLTHROUGH */
692 /* Insert transparently coded */
693 buf
[0] = CE
; /* Send link escape */
694 buf
[1] = byte
^ IRDA_TRANS
; /* Complement bit 5 */
698 /* Non-special value, no transparency required */
706 toshoboe_probeinterrupt (int irq
, void *dev_id
)
708 struct toshoboe_cb
*self
= dev_id
;
711 irqstat
= INB (OBOE_ISR
);
714 if (!(irqstat
& OBOE_INT_MASK
))
717 /* Ack all the interrupts */
718 OUTB (irqstat
, OBOE_ISR
);
720 if (irqstat
& OBOE_INT_TXDONE
)
727 txp
= INB (OBOE_TXSLOT
) & OBOE_SLOT_MASK
;
728 if (self
->ring
->tx
[txp
].control
& OBOE_CTL_TX_HW_OWNS
)
732 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
736 if (irqstat
& OBOE_INT_RXDONE
) {
739 if (irqstat
& OBOE_INT_TXUNDER
) {
742 if (irqstat
& OBOE_INT_RXOVER
) {
745 if (irqstat
& OBOE_INT_SIP
) {
752 toshoboe_maketestpacket (unsigned char *buf
, int badcrc
, int fir
)
765 memset (buf
, 0, TT_LEN
);
769 fcs
.value
= INIT_FCS
;
771 memset (buf
, XBOF
, 10);
775 for (i
= 0; i
< TT_LEN
; ++i
)
777 len
+= stuff_byte (i
, buf
+ len
);
778 fcs
.value
= irda_fcs (fcs
.value
, i
);
781 len
+= stuff_byte (fcs
.bytes
[0] ^ badcrc
, buf
+ len
);
782 len
+= stuff_byte (fcs
.bytes
[1] ^ badcrc
, buf
+ len
);
789 toshoboe_probefail (struct toshoboe_cb
*self
, char *msg
)
791 printk (KERN_ERR DRIVER_NAME
"probe(%d) failed %s\n",self
-> speed
, msg
);
792 toshoboe_dumpregs (self
);
793 toshoboe_stopchip (self
);
794 free_irq (self
->io
.irq
, (void *) self
);
799 toshoboe_numvalidrcvs (struct toshoboe_cb
*self
)
802 for (i
= 0; i
< RX_SLOTS
; ++i
)
803 if ((self
->ring
->rx
[i
].control
& 0xe0) == 0)
810 toshoboe_numrcvs (struct toshoboe_cb
*self
)
813 for (i
= 0; i
< RX_SLOTS
; ++i
)
814 if (!(self
->ring
->rx
[i
].control
& OBOE_CTL_RX_HW_OWNS
))
821 toshoboe_probe (struct toshoboe_cb
*self
)
825 int bauds
[] = { 9600, 115200, 4000000, 1152000 };
827 int bauds
[] = { 9600, 115200, 4000000 };
831 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
833 if (request_irq (self
->io
.irq
, toshoboe_probeinterrupt
,
834 self
->io
.irqflags
, "toshoboe", (void *) self
))
836 printk (KERN_ERR DRIVER_NAME
": probe failed to allocate irq %d\n",
841 /* test 1: SIR filter and back to back */
843 for (j
= 0; j
< (sizeof (bauds
) / sizeof (int)); ++j
)
846 toshoboe_stopchip (self
);
849 spin_lock_irqsave(&self
->spinlock
, flags
);
850 /*Address is already setup */
851 toshoboe_startchip (self
);
852 self
->int_rx
= self
->int_tx
= 0;
853 self
->speed
= bauds
[j
];
854 toshoboe_setbaud (self
);
855 toshoboe_initptrs (self
);
856 spin_unlock_irqrestore(&self
->spinlock
, flags
);
858 self
->ring
->tx
[self
->txs
].control
=
859 /* (FIR only) OBOE_CTL_TX_SIP needed for switching to next slot */
860 /* MIR: all received data is stored in one slot */
861 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
862 : OBOE_CTL_TX_HW_OWNS
;
863 self
->ring
->tx
[self
->txs
].len
=
864 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
866 self
->txs
%= TX_SLOTS
;
868 self
->ring
->tx
[self
->txs
].control
=
869 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_SIP
870 : OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
871 self
->ring
->tx
[self
->txs
].len
=
872 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
874 self
->txs
%= TX_SLOTS
;
876 self
->ring
->tx
[self
->txs
].control
=
877 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
878 : OBOE_CTL_TX_HW_OWNS
;
879 self
->ring
->tx
[self
->txs
].len
=
880 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
882 self
->txs
%= TX_SLOTS
;
884 self
->ring
->tx
[self
->txs
].control
=
885 (fir
) ? OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
886 | OBOE_CTL_TX_SIP
| OBOE_CTL_TX_BAD_CRC
887 : OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
888 self
->ring
->tx
[self
->txs
].len
=
889 toshoboe_maketestpacket (self
->tx_bufs
[self
->txs
], 0, fir
);
891 self
->txs
%= TX_SLOTS
;
893 toshoboe_dumptx (self
);
894 /* Turn on TX and RX and loopback */
895 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
899 while (toshoboe_numvalidrcvs (self
) != n
)
902 return toshoboe_probefail (self
, "filter test");
903 udelay ((9600*(TT_LEN
+16))/self
->speed
);
908 while ((toshoboe_numrcvs(self
) != self
->int_rx
) || (self
->int_tx
!= n
))
911 return toshoboe_probefail (self
, "interrupt test");
912 udelay ((9600*(TT_LEN
+16))/self
->speed
);
915 toshoboe_dumprx (self
,i
);
919 /* test 2: SIR in char at a time */
921 toshoboe_stopchip (self
);
922 self
->int_rx
= self
->int_tx
= 0;
924 spin_lock_irqsave(&self
->spinlock
, flags
);
925 toshoboe_startchip (self
);
926 spin_unlock_irqrestore(&self
->spinlock
, flags
);
929 self
->speed
= 115200;
930 toshoboe_setbaud (self
);
931 self
->ring
->tx
[self
->txs
].control
=
932 OBOE_CTL_TX_RTCENTX
| OBOE_CTL_TX_HW_OWNS
;
933 self
->ring
->tx
[self
->txs
].len
= 4;
935 ((unsigned char *) self
->tx_bufs
[self
->txs
])[0] = 'f';
936 ((unsigned char *) self
->tx_bufs
[self
->txs
])[1] = 'i';
937 ((unsigned char *) self
->tx_bufs
[self
->txs
])[2] = 's';
938 ((unsigned char *) self
->tx_bufs
[self
->txs
])[3] = 'h';
939 toshoboe_dumptx (self
);
940 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
943 while (toshoboe_numvalidrcvs (self
) != 4)
946 return toshoboe_probefail (self
, "Async test");
951 while ((toshoboe_numrcvs (self
) != self
->int_rx
) || (self
->int_tx
!= 1))
954 return toshoboe_probefail (self
, "Async interrupt test");
958 toshoboe_dumprx (self
,i
);
962 toshoboe_setbaud (self
);
963 toshoboe_stopchip (self
);
965 free_irq (self
->io
.irq
, (void *) self
);
967 printk (KERN_WARNING DRIVER_NAME
": Self test passed ok\n");
973 /******************************************************************/
974 /* Netdev style code */
976 /* Transmit something */
978 toshoboe_hard_xmit (struct sk_buff
*skb
, struct net_device
*dev
)
980 struct toshoboe_cb
*self
;
984 struct irda_skb_cb
*cb
= (struct irda_skb_cb
*) skb
->cb
;
986 self
= (struct toshoboe_cb
*) dev
->priv
;
988 IRDA_ASSERT (self
!= NULL
, return 0; );
990 IRDA_DEBUG (1, "%s.tx:%x(%x)%x\n", __FUNCTION__
991 ,skb
->len
,self
->txpending
,INB (OBOE_ENABLEH
));
993 IRDA_DEBUG (2, "%s.Not IrLAP:%x\n", __FUNCTION__
, cb
->magic
);
995 _dumpbufs(skb
->data
,skb
->len
,'>');
999 /* change speed pending, wait for its execution */
1000 if (self
->new_speed
)
1003 /* device stopped (apm) wait for restart */
1007 toshoboe_checkstuck (self
);
1009 dev
->trans_start
= jiffies
;
1011 /* Check if we need to change the speed */
1012 /* But not now. Wait after transmission if mtt not required */
1013 speed
=irda_get_next_speed(skb
);
1014 if ((speed
!= self
->io
.speed
) && (speed
!= -1))
1016 spin_lock_irqsave(&self
->spinlock
, flags
);
1018 if (self
->txpending
|| skb
->len
)
1020 self
->new_speed
= speed
;
1021 IRDA_DEBUG (1, "%s: Queued TxDone scheduled speed change %d\n" ,
1022 __FUNCTION__
, speed
);
1023 /* if no data, that's all! */
1026 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1027 dev_kfree_skb (skb
);
1030 /* True packet, go on, but */
1031 /* do not accept anything before change speed execution */
1032 netif_stop_queue(dev
);
1033 /* ready to process TxDone interrupt */
1034 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1038 /* idle and no data, change speed now */
1039 self
->speed
= speed
;
1040 toshoboe_setbaud (self
);
1041 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1042 dev_kfree_skb (skb
);
1048 if ((mtt
= irda_get_mtt(skb
)))
1050 /* This is fair since the queue should be empty anyway */
1051 spin_lock_irqsave(&self
->spinlock
, flags
);
1053 if (self
->txpending
)
1055 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1059 /* If in SIR mode we need to generate a string of XBOFs */
1060 /* In MIR and FIR we need to generate a string of data */
1061 /* which we will add a wrong checksum to */
1063 mtt
= toshoboe_makemttpacket (self
, self
->tx_bufs
[self
->txs
], mtt
);
1064 IRDA_DEBUG (1, "%s.mtt:%x(%x)%d\n", __FUNCTION__
1065 ,skb
->len
,mtt
,self
->txpending
);
1068 self
->ring
->tx
[self
->txs
].len
= mtt
& 0xfff;
1070 ctl
= OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
1071 if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_FIRON
)
1073 ctl
|= OBOE_CTL_TX_BAD_CRC
| OBOE_CTL_TX_SIP
;
1076 else if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_MIRON
)
1078 ctl
|= OBOE_CTL_TX_BAD_CRC
;
1081 self
->ring
->tx
[self
->txs
].control
= ctl
;
1083 OUTB (0x0, OBOE_ENABLEH
);
1084 /* It is only a timer. Do not send mtt packet outside! */
1085 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
| OBOE_CONFIG0H_LOOP
);
1090 self
->txs
%= TX_SLOTS
;
1095 printk(KERN_ERR DRIVER_NAME
": problem with mtt packet - ignored\n");
1097 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1101 dumpbufs(skb
->data
,skb
->len
,'>');
1104 spin_lock_irqsave(&self
->spinlock
, flags
);
1106 if (self
->ring
->tx
[self
->txs
].control
& OBOE_CTL_TX_HW_OWNS
)
1108 IRDA_DEBUG (0, "%s.ful:%x(%x)%x\n", __FUNCTION__
1109 ,skb
->len
, self
->ring
->tx
[self
->txs
].control
, self
->txpending
);
1110 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
);
1111 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1115 if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_SIRON
)
1117 len
= async_wrap_skb (skb
, self
->tx_bufs
[self
->txs
], TX_BUF_SZ
);
1122 skb_copy_from_linear_data(skb
, self
->tx_bufs
[self
->txs
], len
);
1124 self
->ring
->tx
[self
->txs
].len
= len
& 0x0fff;
1126 /*Sometimes the HW doesn't see us assert RTCENTX in the interrupt code */
1127 /*later this plays safe, we garuntee the last packet to be transmitted */
1128 /*has RTCENTX set */
1130 ctl
= OBOE_CTL_TX_HW_OWNS
| OBOE_CTL_TX_RTCENTX
;
1131 if (INB (OBOE_ENABLEH
) & OBOE_ENABLEH_FIRON
)
1133 ctl
|= OBOE_CTL_TX_SIP
;
1135 self
->ring
->tx
[self
->txs
].control
= ctl
;
1137 /* If transmitter is idle start in one-shot mode */
1139 if (!self
->txpending
)
1140 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
);
1145 self
->txs
%= TX_SLOTS
;
1147 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1148 dev_kfree_skb (skb
);
1153 /*interrupt handler */
1155 toshoboe_interrupt (int irq
, void *dev_id
)
1157 struct toshoboe_cb
*self
= dev_id
;
1159 struct sk_buff
*skb
= NULL
;
1161 irqstat
= INB (OBOE_ISR
);
1164 if (!(irqstat
& OBOE_INT_MASK
))
1167 /* Ack all the interrupts */
1168 OUTB (irqstat
, OBOE_ISR
);
1170 toshoboe_isntstuck (self
);
1173 if (irqstat
& OBOE_INT_TXDONE
)
1178 txp
= self
->txpending
;
1179 self
->txpending
= 0;
1181 for (i
= 0; i
< TX_SLOTS
; ++i
)
1183 if (self
->ring
->tx
[i
].control
& OBOE_CTL_TX_HW_OWNS
)
1186 IRDA_DEBUG (1, "%s.txd(%x)%x/%x\n", __FUNCTION__
1187 ,irqstat
,txp
,self
->txpending
);
1189 txp
= INB (OBOE_TXSLOT
) & OBOE_SLOT_MASK
;
1191 /* Got anything queued ? start it together */
1192 if (self
->ring
->tx
[txp
].control
& OBOE_CTL_TX_HW_OWNS
)
1196 while (self
->ring
->tx
[txpc
].control
& OBOE_CTL_TX_HW_OWNS
)
1201 self
->stats
.tx_packets
++;
1202 if (self
->ring
->tx
[txpc
].control
& OBOE_CTL_TX_HW_OWNS
)
1203 self
->ring
->tx
[txp
].control
&= ~OBOE_CTL_TX_RTCENTX
;
1205 self
->stats
.tx_packets
--;
1207 self
->stats
.tx_packets
++;
1209 toshoboe_start_DMA(self
, OBOE_CONFIG0H_ENTX
);
1212 if ((!self
->txpending
) && (self
->new_speed
))
1214 self
->speed
= self
->new_speed
;
1215 IRDA_DEBUG (1, "%s: Executed TxDone scheduled speed change %d\n",
1216 __FUNCTION__
, self
->speed
);
1217 toshoboe_setbaud (self
);
1220 /* Tell network layer that we want more frames */
1221 if (!self
->new_speed
)
1222 netif_wake_queue(self
->netdev
);
1225 if (irqstat
& OBOE_INT_RXDONE
)
1227 while (!(self
->ring
->rx
[self
->rxs
].control
& OBOE_CTL_RX_HW_OWNS
))
1229 int len
= self
->ring
->rx
[self
->rxs
].len
;
1231 IRDA_DEBUG (3, "%s.rcv:%x(%x)\n", __FUNCTION__
1232 ,len
,self
->ring
->rx
[self
->rxs
].control
);
1235 dumpbufs(self
->rx_bufs
[self
->rxs
],len
,'<');
1238 if (self
->ring
->rx
[self
->rxs
].control
== 0)
1240 __u8 enable
= INB (OBOE_ENABLEH
);
1242 /* In SIR mode we need to check the CRC as this */
1243 /* hasn't been done by the hardware */
1244 if (enable
& OBOE_ENABLEH_SIRON
)
1246 if (!toshoboe_checkfcs (self
->rx_bufs
[self
->rxs
], len
))
1248 /*Trim off the CRC */
1253 IRDA_DEBUG (1, "%s.SIR:%x(%x)\n", __FUNCTION__
, len
,enable
);
1257 else if (enable
& OBOE_ENABLEH_MIRON
)
1263 IRDA_DEBUG (2, "%s.MIR:%x(%x)\n", __FUNCTION__
, len
,enable
);
1266 else if (enable
& OBOE_ENABLEH_FIRON
)
1269 len
-= 4; /*FIXME: check this */
1272 IRDA_DEBUG (1, "%s.FIR:%x(%x)\n", __FUNCTION__
, len
,enable
);
1275 IRDA_DEBUG (0, "%s.?IR:%x(%x)\n", __FUNCTION__
, len
,enable
);
1279 skb
= dev_alloc_skb (len
+ 1);
1282 skb_reserve (skb
, 1);
1285 skb_copy_to_linear_data(skb
, self
->rx_bufs
[self
->rxs
],
1287 self
->stats
.rx_packets
++;
1288 skb
->dev
= self
->netdev
;
1289 skb_reset_mac_header(skb
);
1290 skb
->protocol
= htons (ETH_P_IRDA
);
1295 "%s(), memory squeeze, dropping frame.\n",
1302 /* TODO: =========================================== */
1303 /* if OBOE_CTL_RX_LENGTH, our buffers are too small */
1304 /* (MIR or FIR) data is lost. */
1305 /* (SIR) data is splitted in several slots. */
1306 /* we have to join all the received buffers received */
1307 /*in a large buffer before checking CRC. */
1308 IRDA_DEBUG (0, "%s.err:%x(%x)\n", __FUNCTION__
1309 ,len
,self
->ring
->rx
[self
->rxs
].control
);
1312 self
->ring
->rx
[self
->rxs
].len
= 0x0;
1313 self
->ring
->rx
[self
->rxs
].control
= OBOE_CTL_RX_HW_OWNS
;
1316 self
->rxs
%= RX_SLOTS
;
1324 if (irqstat
& OBOE_INT_TXUNDER
)
1326 printk (KERN_WARNING DRIVER_NAME
": tx fifo underflow\n");
1328 if (irqstat
& OBOE_INT_RXOVER
)
1330 printk (KERN_WARNING DRIVER_NAME
": rx fifo overflow\n");
1332 /* This must be useful for something... */
1333 if (irqstat
& OBOE_INT_SIP
)
1336 IRDA_DEBUG (1, "%s.sip:%x(%x)%x\n", __FUNCTION__
1337 ,self
->int_sip
,irqstat
,self
->txpending
);
1344 toshoboe_net_open (struct net_device
*dev
)
1346 struct toshoboe_cb
*self
;
1347 unsigned long flags
;
1350 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
1352 self
= netdev_priv(dev
);
1360 rc
= request_irq (self
->io
.irq
, toshoboe_interrupt
,
1361 IRQF_SHARED
| IRQF_DISABLED
, dev
->name
, self
);
1365 spin_lock_irqsave(&self
->spinlock
, flags
);
1366 toshoboe_startchip (self
);
1367 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1369 /* Ready to play! */
1370 netif_start_queue(dev
);
1373 * Open new IrLAP layer instance, now that everything should be
1374 * initialized properly
1376 self
->irlap
= irlap_open (dev
, &self
->qos
, driver_name
);
1384 toshoboe_net_close (struct net_device
*dev
)
1386 struct toshoboe_cb
*self
;
1388 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
1390 IRDA_ASSERT (dev
!= NULL
, return -1; );
1391 self
= (struct toshoboe_cb
*) dev
->priv
;
1394 netif_stop_queue(dev
);
1396 /* Stop and remove instance of IrLAP */
1398 irlap_close (self
->irlap
);
1403 free_irq (self
->io
.irq
, (void *) self
);
1407 toshoboe_stopchip (self
);
1414 * Function toshoboe_net_ioctl (dev, rq, cmd)
1416 * Process IOCTL commands for this device
1420 toshoboe_net_ioctl (struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1422 struct if_irda_req
*irq
= (struct if_irda_req
*) rq
;
1423 struct toshoboe_cb
*self
;
1424 unsigned long flags
;
1427 IRDA_ASSERT (dev
!= NULL
, return -1; );
1431 IRDA_ASSERT (self
!= NULL
, return -1; );
1433 IRDA_DEBUG (5, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__
, dev
->name
, cmd
);
1435 /* Disable interrupts & save flags */
1436 spin_lock_irqsave(&self
->spinlock
, flags
);
1440 case SIOCSBANDWIDTH
: /* Set bandwidth */
1441 /* This function will also be used by IrLAP to change the
1442 * speed, so we still must allow for speed change within
1443 * interrupt context.
1445 IRDA_DEBUG (1, "%s(BANDWIDTH), %s, (%X/%ld\n", __FUNCTION__
1446 ,dev
->name
, INB (OBOE_STATUS
), irq
->ifr_baudrate
);
1447 if (!in_interrupt () && !capable (CAP_NET_ADMIN
)) {
1452 /* self->speed=irq->ifr_baudrate; */
1453 /* toshoboe_setbaud(self); */
1454 /* Just change speed once - inserted by Paul Bristow */
1455 self
->new_speed
= irq
->ifr_baudrate
;
1457 case SIOCSMEDIABUSY
: /* Set media busy */
1458 IRDA_DEBUG (1, "%s(MEDIABUSY), %s, (%X/%x)\n", __FUNCTION__
1459 ,dev
->name
, INB (OBOE_STATUS
), capable (CAP_NET_ADMIN
) );
1460 if (!capable (CAP_NET_ADMIN
)) {
1464 irda_device_set_media_busy (self
->netdev
, TRUE
);
1466 case SIOCGRECEIVING
: /* Check if we are receiving right now */
1467 irq
->ifr_receiving
= (INB (OBOE_STATUS
) & OBOE_STATUS_RXBUSY
) ? 1 : 0;
1468 IRDA_DEBUG (3, "%s(RECEIVING), %s, (%X/%x)\n", __FUNCTION__
1469 ,dev
->name
, INB (OBOE_STATUS
), irq
->ifr_receiving
);
1472 IRDA_DEBUG (1, "%s(?), %s, (cmd=0x%X)\n", __FUNCTION__
, dev
->name
, cmd
);
1476 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1481 MODULE_DESCRIPTION("Toshiba OBOE IrDA Device Driver");
1482 MODULE_AUTHOR("James McKenzie <james@fishsoup.dhs.org>");
1483 MODULE_LICENSE("GPL");
1485 module_param (max_baud
, int, 0);
1486 MODULE_PARM_DESC(max_baud
, "Maximum baud rate");
1489 module_param (do_probe
, bool, 0);
1490 MODULE_PARM_DESC(do_probe
, "Enable/disable chip probing and self-test");
1494 toshoboe_close (struct pci_dev
*pci_dev
)
1497 struct toshoboe_cb
*self
= (struct toshoboe_cb
*)pci_get_drvdata(pci_dev
);
1499 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
1501 IRDA_ASSERT (self
!= NULL
, return; );
1505 toshoboe_stopchip (self
);
1508 release_region (self
->io
.fir_base
, self
->io
.fir_ext
);
1510 for (i
= 0; i
< TX_SLOTS
; ++i
)
1512 kfree (self
->tx_bufs
[i
]);
1513 self
->tx_bufs
[i
] = NULL
;
1516 for (i
= 0; i
< RX_SLOTS
; ++i
)
1518 kfree (self
->rx_bufs
[i
]);
1519 self
->rx_bufs
[i
] = NULL
;
1522 unregister_netdev(self
->netdev
);
1524 kfree (self
->ringbuf
);
1525 self
->ringbuf
= NULL
;
1528 free_netdev(self
->netdev
);
1532 toshoboe_open (struct pci_dev
*pci_dev
, const struct pci_device_id
*pdid
)
1534 struct toshoboe_cb
*self
;
1535 struct net_device
*dev
;
1540 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
1542 if ((err
=pci_enable_device(pci_dev
)))
1545 dev
= alloc_irdadev(sizeof (struct toshoboe_cb
));
1548 printk (KERN_ERR DRIVER_NAME
": can't allocate memory for "
1549 "IrDA control block\n");
1555 self
->pdev
= pci_dev
;
1556 self
->base
= pci_resource_start(pci_dev
,0);
1558 self
->io
.fir_base
= self
->base
;
1559 self
->io
.fir_ext
= OBOE_IO_EXTENT
;
1560 self
->io
.irq
= pci_dev
->irq
;
1561 self
->io
.irqflags
= IRQF_SHARED
| IRQF_DISABLED
;
1563 self
->speed
= self
->io
.speed
= 9600;
1566 /* Lock the port that we need */
1567 if (NULL
==request_region (self
->io
.fir_base
, self
->io
.fir_ext
, driver_name
))
1569 printk (KERN_ERR DRIVER_NAME
": can't get iobase of 0x%03x\n"
1570 ,self
->io
.fir_base
);
1575 spin_lock_init(&self
->spinlock
);
1577 irda_init_max_qos_capabilies (&self
->qos
);
1578 self
->qos
.baud_rate
.bits
= 0;
1580 if (max_baud
>= 2400)
1581 self
->qos
.baud_rate
.bits
|= IR_2400
;
1582 /*if (max_baud>=4800) idev->qos.baud_rate.bits|=IR_4800; */
1583 if (max_baud
>= 9600)
1584 self
->qos
.baud_rate
.bits
|= IR_9600
;
1585 if (max_baud
>= 19200)
1586 self
->qos
.baud_rate
.bits
|= IR_19200
;
1587 if (max_baud
>= 115200)
1588 self
->qos
.baud_rate
.bits
|= IR_115200
;
1590 if (max_baud
>= 1152000)
1592 self
->qos
.baud_rate
.bits
|= IR_1152000
;
1595 if (max_baud
>= 4000000)
1597 self
->qos
.baud_rate
.bits
|= (IR_4000000
<< 8);
1600 /*FIXME: work this out... */
1601 self
->qos
.min_turn_time
.bits
= 0xff;
1603 irda_qos_bits_to_value (&self
->qos
);
1605 /* Allocate twice the size to guarantee alignment */
1606 self
->ringbuf
= kmalloc(OBOE_RING_LEN
<< 1, GFP_KERNEL
);
1609 printk (KERN_ERR DRIVER_NAME
": can't allocate DMA buffers\n");
1614 #if (BITS_PER_LONG == 64)
1615 #error broken on 64-bit: casts pointer to 32-bit, and then back to pointer.
1618 /*We need to align the taskfile on a taskfile size boundary */
1622 addr
= (__u32
) self
->ringbuf
;
1623 addr
&= ~(OBOE_RING_LEN
- 1);
1624 addr
+= OBOE_RING_LEN
;
1625 self
->ring
= (struct OboeRing
*) addr
;
1628 memset (self
->ring
, 0, OBOE_RING_LEN
);
1629 self
->io
.mem_base
= (__u32
) self
->ring
;
1632 for (i
= 0; i
< TX_SLOTS
; ++i
)
1634 self
->tx_bufs
[i
] = kmalloc (TX_BUF_SZ
, GFP_KERNEL
);
1635 if (!self
->tx_bufs
[i
])
1639 for (i
= 0; i
< RX_SLOTS
; ++i
)
1641 self
->rx_bufs
[i
] = kmalloc (RX_BUF_SZ
, GFP_KERNEL
);
1642 if (!self
->rx_bufs
[i
])
1648 printk (KERN_ERR DRIVER_NAME
": can't allocate rx/tx buffers\n");
1656 if (!toshoboe_probe (self
))
1663 SET_MODULE_OWNER(dev
);
1664 SET_NETDEV_DEV(dev
, &pci_dev
->dev
);
1665 dev
->hard_start_xmit
= toshoboe_hard_xmit
;
1666 dev
->open
= toshoboe_net_open
;
1667 dev
->stop
= toshoboe_net_close
;
1668 dev
->do_ioctl
= toshoboe_net_ioctl
;
1670 err
= register_netdev(dev
);
1673 printk (KERN_ERR DRIVER_NAME
": register_netdev() failed\n");
1677 printk (KERN_INFO
"IrDA: Registered device %s\n", dev
->name
);
1679 pci_set_drvdata(pci_dev
,self
);
1681 printk (KERN_INFO DRIVER_NAME
": Using multiple tasks, version %s\n", rcsid
);
1686 for (i
= 0; i
< TX_SLOTS
; ++i
)
1687 kfree (self
->tx_bufs
[i
]);
1688 for (i
= 0; i
< RX_SLOTS
; ++i
)
1689 kfree (self
->rx_bufs
[i
]);
1690 kfree(self
->ringbuf
);
1693 release_region (self
->io
.fir_base
, self
->io
.fir_ext
);
1702 toshoboe_gotosleep (struct pci_dev
*pci_dev
, pm_message_t crap
)
1704 struct toshoboe_cb
*self
= (struct toshoboe_cb
*)pci_get_drvdata(pci_dev
);
1705 unsigned long flags
;
1708 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
1710 if (!self
|| self
->stopped
)
1713 if ((!self
->irdad
) && (!self
->async
))
1716 /* Flush all packets */
1717 while ((i
--) && (self
->txpending
))
1720 spin_lock_irqsave(&self
->spinlock
, flags
);
1722 toshoboe_stopchip (self
);
1724 self
->txpending
= 0;
1726 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1731 toshoboe_wakeup (struct pci_dev
*pci_dev
)
1733 struct toshoboe_cb
*self
= (struct toshoboe_cb
*)pci_get_drvdata(pci_dev
);
1734 unsigned long flags
;
1736 IRDA_DEBUG (4, "%s()\n", __FUNCTION__
);
1738 if (!self
|| !self
->stopped
)
1741 if ((!self
->irdad
) && (!self
->async
))
1744 spin_lock_irqsave(&self
->spinlock
, flags
);
1746 toshoboe_startchip (self
);
1749 netif_wake_queue(self
->netdev
);
1750 spin_unlock_irqrestore(&self
->spinlock
, flags
);
1754 static struct pci_driver donauboe_pci_driver
= {
1756 .id_table
= toshoboe_pci_tbl
,
1757 .probe
= toshoboe_open
,
1758 .remove
= toshoboe_close
,
1759 .suspend
= toshoboe_gotosleep
,
1760 .resume
= toshoboe_wakeup
1764 donauboe_init (void)
1766 return pci_register_driver(&donauboe_pci_driver
);
1770 donauboe_cleanup (void)
1772 pci_unregister_driver(&donauboe_pci_driver
);
1775 module_init(donauboe_init
);
1776 module_exit(donauboe_cleanup
);