1 /*********************************************************************
3 * vlsi_ir.c: VLSI82C147 PCI IrDA controller driver for Linux
5 * Copyright (c) 2001-2003 Martin Diehl
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of
10 * the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
22 ********************************************************************/
24 #include <linux/module.h>
26 #define DRIVER_NAME "vlsi_ir"
27 #define DRIVER_VERSION "v0.5"
28 #define DRIVER_DESCRIPTION "IrDA SIR/MIR/FIR driver for VLSI 82C147"
29 #define DRIVER_AUTHOR "Martin Diehl <info@mdiehl.de>"
31 MODULE_DESCRIPTION(DRIVER_DESCRIPTION
);
32 MODULE_AUTHOR(DRIVER_AUTHOR
);
33 MODULE_LICENSE("GPL");
35 /********************************************************/
37 #include <linux/kernel.h>
38 #include <linux/init.h>
39 #include <linux/pci.h>
40 #include <linux/slab.h>
41 #include <linux/netdevice.h>
42 #include <linux/skbuff.h>
43 #include <linux/delay.h>
44 #include <linux/time.h>
45 #include <linux/proc_fs.h>
46 #include <linux/seq_file.h>
47 #include <asm/uaccess.h>
48 #include <asm/byteorder.h>
50 #include <net/irda/irda.h>
51 #include <net/irda/irda_device.h>
52 #include <net/irda/wrapper.h>
53 #include <net/irda/crc.h>
57 /********************************************************/
59 static /* const */ char drivername
[] = DRIVER_NAME
;
61 static struct pci_device_id vlsi_irda_table
[] = {
63 .class = PCI_CLASS_WIRELESS_IRDA
<< 8,
64 .class_mask
= PCI_CLASS_SUBCLASS_MASK
<< 8,
65 .vendor
= PCI_VENDOR_ID_VLSI
,
66 .device
= PCI_DEVICE_ID_VLSI_82C147
,
67 .subvendor
= PCI_ANY_ID
,
68 .subdevice
= PCI_ANY_ID
,
73 MODULE_DEVICE_TABLE(pci
, vlsi_irda_table
);
75 /********************************************************/
77 /* clksrc: which clock source to be used
78 * 0: auto - try PLL, fallback to 40MHz XCLK
79 * 1: on-chip 48MHz PLL
80 * 2: external 48MHz XCLK
81 * 3: external 40MHz XCLK (HP OB-800)
84 static int clksrc
= 0; /* default is 0(auto) */
85 module_param(clksrc
, int, 0);
86 MODULE_PARM_DESC(clksrc
, "clock input source selection");
88 /* ringsize: size of the tx and rx descriptor rings
89 * independent for tx and rx
90 * specify as ringsize=tx[,rx]
91 * allowed values: 4, 8, 16, 32, 64
92 * Due to the IrDA 1.x max. allowed window size=7,
93 * there should be no gain when using rings larger than 8
96 static int ringsize
[] = {8,8}; /* default is tx=8 / rx=8 */
97 module_param_array(ringsize
, int, NULL
, 0);
98 MODULE_PARM_DESC(ringsize
, "TX, RX ring descriptor size");
100 /* sirpulse: tuning of the SIR pulse width within IrPHY 1.3 limits
101 * 0: very short, 1.5us (exception: 6us at 2.4 kbaud)
102 * 1: nominal 3/16 bittime width
103 * note: IrDA compliant peer devices should be happy regardless
104 * which one is used. Primary goal is to save some power
105 * on the sender's side - at 9.6kbaud for example the short
106 * pulse width saves more than 90% of the transmitted IR power.
109 static int sirpulse
= 1; /* default is 3/16 bittime */
110 module_param(sirpulse
, int, 0);
111 MODULE_PARM_DESC(sirpulse
, "SIR pulse width tuning");
113 /* qos_mtt_bits: encoded min-turn-time value we require the peer device
114 * to use before transmitting to us. "Type 1" (per-station)
115 * bitfield according to IrLAP definition (section 6.6.8)
116 * Don't know which transceiver is used by my OB800 - the
117 * pretty common HP HDLS-1100 requires 1 msec - so lets use this.
120 static int qos_mtt_bits
= 0x07; /* default is 1 ms or more */
121 module_param(qos_mtt_bits
, int, 0);
122 MODULE_PARM_DESC(qos_mtt_bits
, "IrLAP bitfield representing min-turn-time");
124 /********************************************************/
126 static void vlsi_reg_debug(unsigned iobase
, const char *s
)
130 printk(KERN_DEBUG
"%s: ", s
);
131 for (i
= 0; i
< 0x20; i
++)
132 printk("%02x", (unsigned)inb((iobase
+i
)));
136 static void vlsi_ring_debug(struct vlsi_ring
*r
)
138 struct ring_descr
*rd
;
141 printk(KERN_DEBUG
"%s - ring %p / size %u / mask 0x%04x / len %u / dir %d / hw %p\n",
142 __FUNCTION__
, r
, r
->size
, r
->mask
, r
->len
, r
->dir
, r
->rd
[0].hw
);
143 printk(KERN_DEBUG
"%s - head = %d / tail = %d\n", __FUNCTION__
,
144 atomic_read(&r
->head
) & r
->mask
, atomic_read(&r
->tail
) & r
->mask
);
145 for (i
= 0; i
< r
->size
; i
++) {
147 printk(KERN_DEBUG
"%s - ring descr %u: ", __FUNCTION__
, i
);
148 printk("skb=%p data=%p hw=%p\n", rd
->skb
, rd
->buf
, rd
->hw
);
149 printk(KERN_DEBUG
"%s - hw: status=%02x count=%u addr=0x%08x\n",
150 __FUNCTION__
, (unsigned) rd_get_status(rd
),
151 (unsigned) rd_get_count(rd
), (unsigned) rd_get_addr(rd
));
155 /********************************************************/
157 /* needed regardless of CONFIG_PROC_FS */
158 static struct proc_dir_entry
*vlsi_proc_root
= NULL
;
160 #ifdef CONFIG_PROC_FS
162 static void vlsi_proc_pdev(struct seq_file
*seq
, struct pci_dev
*pdev
)
164 unsigned iobase
= pci_resource_start(pdev
, 0);
167 seq_printf(seq
, "\n%s (vid/did: %04x/%04x)\n",
168 pci_name(pdev
), (int)pdev
->vendor
, (int)pdev
->device
);
169 seq_printf(seq
, "pci-power-state: %u\n", (unsigned) pdev
->current_state
);
170 seq_printf(seq
, "resources: irq=%u / io=0x%04x / dma_mask=0x%016Lx\n",
171 pdev
->irq
, (unsigned)pci_resource_start(pdev
, 0), (unsigned long long)pdev
->dma_mask
);
172 seq_printf(seq
, "hw registers: ");
173 for (i
= 0; i
< 0x20; i
++)
174 seq_printf(seq
, "%02x", (unsigned)inb((iobase
+i
)));
175 seq_printf(seq
, "\n");
178 static void vlsi_proc_ndev(struct seq_file
*seq
, struct net_device
*ndev
)
180 vlsi_irda_dev_t
*idev
= ndev
->priv
;
183 unsigned delta1
, delta2
;
185 unsigned iobase
= ndev
->base_addr
;
187 seq_printf(seq
, "\n%s link state: %s / %s / %s / %s\n", ndev
->name
,
188 netif_device_present(ndev
) ? "attached" : "detached",
189 netif_running(ndev
) ? "running" : "not running",
190 netif_carrier_ok(ndev
) ? "carrier ok" : "no carrier",
191 netif_queue_stopped(ndev
) ? "queue stopped" : "queue running");
193 if (!netif_running(ndev
))
196 seq_printf(seq
, "\nhw-state:\n");
197 pci_read_config_byte(idev
->pdev
, VLSI_PCI_IRMISC
, &byte
);
198 seq_printf(seq
, "IRMISC:%s%s%s uart%s",
199 (byte
&IRMISC_IRRAIL
) ? " irrail" : "",
200 (byte
&IRMISC_IRPD
) ? " irpd" : "",
201 (byte
&IRMISC_UARTTST
) ? " uarttest" : "",
202 (byte
&IRMISC_UARTEN
) ? "@" : " disabled\n");
203 if (byte
&IRMISC_UARTEN
) {
204 seq_printf(seq
, "0x%s\n",
205 (byte
&2) ? ((byte
&1) ? "3e8" : "2e8")
206 : ((byte
&1) ? "3f8" : "2f8"));
208 pci_read_config_byte(idev
->pdev
, VLSI_PCI_CLKCTL
, &byte
);
209 seq_printf(seq
, "CLKCTL: PLL %s%s%s / clock %s / wakeup %s\n",
210 (byte
&CLKCTL_PD_INV
) ? "powered" : "down",
211 (byte
&CLKCTL_LOCK
) ? " locked" : "",
212 (byte
&CLKCTL_EXTCLK
) ? ((byte
&CLKCTL_XCKSEL
)?" / 40 MHz XCLK":" / 48 MHz XCLK") : "",
213 (byte
&CLKCTL_CLKSTP
) ? "stopped" : "running",
214 (byte
&CLKCTL_WAKE
) ? "enabled" : "disabled");
215 pci_read_config_byte(idev
->pdev
, VLSI_PCI_MSTRPAGE
, &byte
);
216 seq_printf(seq
, "MSTRPAGE: 0x%02x\n", (unsigned)byte
);
218 byte
= inb(iobase
+VLSI_PIO_IRINTR
);
219 seq_printf(seq
, "IRINTR:%s%s%s%s%s%s%s%s\n",
220 (byte
&IRINTR_ACTEN
) ? " ACTEN" : "",
221 (byte
&IRINTR_RPKTEN
) ? " RPKTEN" : "",
222 (byte
&IRINTR_TPKTEN
) ? " TPKTEN" : "",
223 (byte
&IRINTR_OE_EN
) ? " OE_EN" : "",
224 (byte
&IRINTR_ACTIVITY
) ? " ACTIVITY" : "",
225 (byte
&IRINTR_RPKTINT
) ? " RPKTINT" : "",
226 (byte
&IRINTR_TPKTINT
) ? " TPKTINT" : "",
227 (byte
&IRINTR_OE_INT
) ? " OE_INT" : "");
228 word
= inw(iobase
+VLSI_PIO_RINGPTR
);
229 seq_printf(seq
, "RINGPTR: rx=%u / tx=%u\n", RINGPTR_GET_RX(word
), RINGPTR_GET_TX(word
));
230 word
= inw(iobase
+VLSI_PIO_RINGBASE
);
231 seq_printf(seq
, "RINGBASE: busmap=0x%08x\n",
232 ((unsigned)word
<< 10)|(MSTRPAGE_VALUE
<<24));
233 word
= inw(iobase
+VLSI_PIO_RINGSIZE
);
234 seq_printf(seq
, "RINGSIZE: rx=%u / tx=%u\n", RINGSIZE_TO_RXSIZE(word
),
235 RINGSIZE_TO_TXSIZE(word
));
237 word
= inw(iobase
+VLSI_PIO_IRCFG
);
238 seq_printf(seq
, "IRCFG:%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
239 (word
&IRCFG_LOOP
) ? " LOOP" : "",
240 (word
&IRCFG_ENTX
) ? " ENTX" : "",
241 (word
&IRCFG_ENRX
) ? " ENRX" : "",
242 (word
&IRCFG_MSTR
) ? " MSTR" : "",
243 (word
&IRCFG_RXANY
) ? " RXANY" : "",
244 (word
&IRCFG_CRC16
) ? " CRC16" : "",
245 (word
&IRCFG_FIR
) ? " FIR" : "",
246 (word
&IRCFG_MIR
) ? " MIR" : "",
247 (word
&IRCFG_SIR
) ? " SIR" : "",
248 (word
&IRCFG_SIRFILT
) ? " SIRFILT" : "",
249 (word
&IRCFG_SIRTEST
) ? " SIRTEST" : "",
250 (word
&IRCFG_TXPOL
) ? " TXPOL" : "",
251 (word
&IRCFG_RXPOL
) ? " RXPOL" : "");
252 word
= inw(iobase
+VLSI_PIO_IRENABLE
);
253 seq_printf(seq
, "IRENABLE:%s%s%s%s%s%s%s%s\n",
254 (word
&IRENABLE_PHYANDCLOCK
) ? " PHYANDCLOCK" : "",
255 (word
&IRENABLE_CFGER
) ? " CFGERR" : "",
256 (word
&IRENABLE_FIR_ON
) ? " FIR_ON" : "",
257 (word
&IRENABLE_MIR_ON
) ? " MIR_ON" : "",
258 (word
&IRENABLE_SIR_ON
) ? " SIR_ON" : "",
259 (word
&IRENABLE_ENTXST
) ? " ENTXST" : "",
260 (word
&IRENABLE_ENRXST
) ? " ENRXST" : "",
261 (word
&IRENABLE_CRC16_ON
) ? " CRC16_ON" : "");
262 word
= inw(iobase
+VLSI_PIO_PHYCTL
);
263 seq_printf(seq
, "PHYCTL: baud-divisor=%u / pulsewidth=%u / preamble=%u\n",
264 (unsigned)PHYCTL_TO_BAUD(word
),
265 (unsigned)PHYCTL_TO_PLSWID(word
),
266 (unsigned)PHYCTL_TO_PREAMB(word
));
267 word
= inw(iobase
+VLSI_PIO_NPHYCTL
);
268 seq_printf(seq
, "NPHYCTL: baud-divisor=%u / pulsewidth=%u / preamble=%u\n",
269 (unsigned)PHYCTL_TO_BAUD(word
),
270 (unsigned)PHYCTL_TO_PLSWID(word
),
271 (unsigned)PHYCTL_TO_PREAMB(word
));
272 word
= inw(iobase
+VLSI_PIO_MAXPKT
);
273 seq_printf(seq
, "MAXPKT: max. rx packet size = %u\n", word
);
274 word
= inw(iobase
+VLSI_PIO_RCVBCNT
) & RCVBCNT_MASK
;
275 seq_printf(seq
, "RCVBCNT: rx-fifo filling level = %u\n", word
);
277 seq_printf(seq
, "\nsw-state:\n");
278 seq_printf(seq
, "IrPHY setup: %d baud - %s encoding\n", idev
->baud
,
279 (idev
->mode
==IFF_SIR
)?"SIR":((idev
->mode
==IFF_MIR
)?"MIR":"FIR"));
280 do_gettimeofday(&now
);
281 if (now
.tv_usec
>= idev
->last_rx
.tv_usec
) {
282 delta2
= now
.tv_usec
- idev
->last_rx
.tv_usec
;
286 delta2
= 1000000 + now
.tv_usec
- idev
->last_rx
.tv_usec
;
289 seq_printf(seq
, "last rx: %lu.%06u sec\n",
290 now
.tv_sec
- idev
->last_rx
.tv_sec
- delta1
, delta2
);
292 seq_printf(seq
, "RX: packets=%lu / bytes=%lu / errors=%lu / dropped=%lu",
293 idev
->stats
.rx_packets
, idev
->stats
.rx_bytes
, idev
->stats
.rx_errors
,
294 idev
->stats
.rx_dropped
);
295 seq_printf(seq
, " / overrun=%lu / length=%lu / frame=%lu / crc=%lu\n",
296 idev
->stats
.rx_over_errors
, idev
->stats
.rx_length_errors
,
297 idev
->stats
.rx_frame_errors
, idev
->stats
.rx_crc_errors
);
298 seq_printf(seq
, "TX: packets=%lu / bytes=%lu / errors=%lu / dropped=%lu / fifo=%lu\n",
299 idev
->stats
.tx_packets
, idev
->stats
.tx_bytes
, idev
->stats
.tx_errors
,
300 idev
->stats
.tx_dropped
, idev
->stats
.tx_fifo_errors
);
304 static void vlsi_proc_ring(struct seq_file
*seq
, struct vlsi_ring
*r
)
306 struct ring_descr
*rd
;
310 seq_printf(seq
, "size %u / mask 0x%04x / len %u / dir %d / hw %p\n",
311 r
->size
, r
->mask
, r
->len
, r
->dir
, r
->rd
[0].hw
);
312 h
= atomic_read(&r
->head
) & r
->mask
;
313 t
= atomic_read(&r
->tail
) & r
->mask
;
314 seq_printf(seq
, "head = %d / tail = %d ", h
, t
);
316 seq_printf(seq
, "(empty)\n");
318 if (((t
+1)&r
->mask
) == h
)
319 seq_printf(seq
, "(full)\n");
321 seq_printf(seq
, "(level = %d)\n", ((unsigned)(t
-h
) & r
->mask
));
323 j
= (unsigned) rd_get_count(rd
);
324 seq_printf(seq
, "current: rd = %d / status = %02x / len = %u\n",
325 h
, (unsigned)rd_get_status(rd
), j
);
327 seq_printf(seq
, " data:");
330 for (i
= 0; i
< j
; i
++)
331 seq_printf(seq
, " %02x", (unsigned)((unsigned char *)rd
->buf
)[i
]);
332 seq_printf(seq
, "\n");
335 for (i
= 0; i
< r
->size
; i
++) {
337 seq_printf(seq
, "> ring descr %u: ", i
);
338 seq_printf(seq
, "skb=%p data=%p hw=%p\n", rd
->skb
, rd
->buf
, rd
->hw
);
339 seq_printf(seq
, " hw: status=%02x count=%u busaddr=0x%08x\n",
340 (unsigned) rd_get_status(rd
),
341 (unsigned) rd_get_count(rd
), (unsigned) rd_get_addr(rd
));
345 static int vlsi_seq_show(struct seq_file
*seq
, void *v
)
347 struct net_device
*ndev
= seq
->private;
348 vlsi_irda_dev_t
*idev
= ndev
->priv
;
351 seq_printf(seq
, "\n%s %s\n\n", DRIVER_NAME
, DRIVER_VERSION
);
352 seq_printf(seq
, "clksrc: %s\n",
353 (clksrc
>=2) ? ((clksrc
==3)?"40MHz XCLK":"48MHz XCLK")
354 : ((clksrc
==1)?"48MHz PLL":"autodetect"));
355 seq_printf(seq
, "ringsize: tx=%d / rx=%d\n",
356 ringsize
[0], ringsize
[1]);
357 seq_printf(seq
, "sirpulse: %s\n", (sirpulse
)?"3/16 bittime":"short");
358 seq_printf(seq
, "qos_mtt_bits: 0x%02x\n", (unsigned)qos_mtt_bits
);
360 spin_lock_irqsave(&idev
->lock
, flags
);
361 if (idev
->pdev
!= NULL
) {
362 vlsi_proc_pdev(seq
, idev
->pdev
);
364 if (idev
->pdev
->current_state
== 0)
365 vlsi_proc_ndev(seq
, ndev
);
367 seq_printf(seq
, "\nPCI controller down - resume_ok = %d\n",
369 if (netif_running(ndev
) && idev
->rx_ring
&& idev
->tx_ring
) {
370 seq_printf(seq
, "\n--------- RX ring -----------\n\n");
371 vlsi_proc_ring(seq
, idev
->rx_ring
);
372 seq_printf(seq
, "\n--------- TX ring -----------\n\n");
373 vlsi_proc_ring(seq
, idev
->tx_ring
);
376 seq_printf(seq
, "\n");
377 spin_unlock_irqrestore(&idev
->lock
, flags
);
382 static int vlsi_seq_open(struct inode
*inode
, struct file
*file
)
384 return single_open(file
, vlsi_seq_show
, PDE(inode
)->data
);
387 static const struct file_operations vlsi_proc_fops
= {
388 .owner
= THIS_MODULE
,
389 .open
= vlsi_seq_open
,
392 .release
= single_release
,
395 #define VLSI_PROC_FOPS (&vlsi_proc_fops)
397 #else /* CONFIG_PROC_FS */
398 #define VLSI_PROC_FOPS NULL
401 /********************************************************/
403 static struct vlsi_ring
*vlsi_alloc_ring(struct pci_dev
*pdev
, struct ring_descr_hw
*hwmap
,
404 unsigned size
, unsigned len
, int dir
)
407 struct ring_descr
*rd
;
411 if (!size
|| ((size
-1)&size
)!=0) /* must be >0 and power of 2 */
414 r
= kmalloc(sizeof(*r
) + size
* sizeof(struct ring_descr
), GFP_KERNEL
);
417 memset(r
, 0, sizeof(*r
));
422 r
->rd
= (struct ring_descr
*)(r
+1);
425 atomic_set(&r
->head
, 0);
426 atomic_set(&r
->tail
, 0);
428 for (i
= 0; i
< size
; i
++) {
430 memset(rd
, 0, sizeof(*rd
));
432 rd
->buf
= kmalloc(len
, GFP_KERNEL
|GFP_DMA
);
434 || !(busaddr
= pci_map_single(pdev
, rd
->buf
, len
, dir
))) {
436 IRDA_ERROR("%s: failed to create PCI-MAP for %p",
437 __FUNCTION__
, rd
->buf
);
441 for (j
= 0; j
< i
; j
++) {
443 busaddr
= rd_get_addr(rd
);
444 rd_set_addr_status(rd
, 0, 0);
446 pci_unmap_single(pdev
, busaddr
, len
, dir
);
453 rd_set_addr_status(rd
, busaddr
, 0);
454 /* initially, the dma buffer is owned by the CPU */
460 static int vlsi_free_ring(struct vlsi_ring
*r
)
462 struct ring_descr
*rd
;
466 for (i
= 0; i
< r
->size
; i
++) {
469 dev_kfree_skb_any(rd
->skb
);
470 busaddr
= rd_get_addr(rd
);
471 rd_set_addr_status(rd
, 0, 0);
473 pci_unmap_single(r
->pdev
, busaddr
, r
->len
, r
->dir
);
480 static int vlsi_create_hwif(vlsi_irda_dev_t
*idev
)
483 struct ring_descr_hw
*hwmap
;
485 idev
->virtaddr
= NULL
;
488 ringarea
= pci_alloc_consistent(idev
->pdev
, HW_RING_AREA_SIZE
, &idev
->busaddr
);
490 IRDA_ERROR("%s: insufficient memory for descriptor rings\n",
494 memset(ringarea
, 0, HW_RING_AREA_SIZE
);
496 hwmap
= (struct ring_descr_hw
*)ringarea
;
497 idev
->rx_ring
= vlsi_alloc_ring(idev
->pdev
, hwmap
, ringsize
[1],
498 XFER_BUF_SIZE
, PCI_DMA_FROMDEVICE
);
499 if (idev
->rx_ring
== NULL
)
502 hwmap
+= MAX_RING_DESCR
;
503 idev
->tx_ring
= vlsi_alloc_ring(idev
->pdev
, hwmap
, ringsize
[0],
504 XFER_BUF_SIZE
, PCI_DMA_TODEVICE
);
505 if (idev
->tx_ring
== NULL
)
508 idev
->virtaddr
= ringarea
;
512 vlsi_free_ring(idev
->rx_ring
);
514 idev
->rx_ring
= idev
->tx_ring
= NULL
;
515 pci_free_consistent(idev
->pdev
, HW_RING_AREA_SIZE
, ringarea
, idev
->busaddr
);
521 static int vlsi_destroy_hwif(vlsi_irda_dev_t
*idev
)
523 vlsi_free_ring(idev
->rx_ring
);
524 vlsi_free_ring(idev
->tx_ring
);
525 idev
->rx_ring
= idev
->tx_ring
= NULL
;
528 pci_free_consistent(idev
->pdev
,HW_RING_AREA_SIZE
,idev
->virtaddr
,idev
->busaddr
);
530 idev
->virtaddr
= NULL
;
536 /********************************************************/
538 static int vlsi_process_rx(struct vlsi_ring
*r
, struct ring_descr
*rd
)
544 struct net_device
*ndev
= (struct net_device
*)pci_get_drvdata(r
->pdev
);
545 vlsi_irda_dev_t
*idev
= ndev
->priv
;
547 pci_dma_sync_single_for_cpu(r
->pdev
, rd_get_addr(rd
), r
->len
, r
->dir
);
548 /* dma buffer now owned by the CPU */
549 status
= rd_get_status(rd
);
550 if (status
& RD_RX_ERROR
) {
551 if (status
& RD_RX_OVER
)
553 if (status
& RD_RX_LENGTH
)
554 ret
|= VLSI_RX_LENGTH
;
555 if (status
& RD_RX_PHYERR
)
556 ret
|= VLSI_RX_FRAME
;
557 if (status
& RD_RX_CRCERR
)
562 len
= rd_get_count(rd
);
563 crclen
= (idev
->mode
==IFF_FIR
) ? sizeof(u32
) : sizeof(u16
);
564 len
-= crclen
; /* remove trailing CRC */
566 IRDA_DEBUG(0, "%s: strange frame (len=%d)\n", __FUNCTION__
, len
);
571 if (idev
->mode
== IFF_SIR
) { /* hw checks CRC in MIR, FIR mode */
573 /* rd->buf is a streaming PCI_DMA_FROMDEVICE map. Doing the
574 * endian-adjustment there just in place will dirty a cache line
575 * which belongs to the map and thus we must be sure it will
576 * get flushed before giving the buffer back to hardware.
577 * vlsi_fill_rx() will do this anyway - but here we rely on.
579 le16_to_cpus(rd
->buf
+len
);
580 if (irda_calc_crc16(INIT_FCS
,rd
->buf
,len
+crclen
) != GOOD_FCS
) {
581 IRDA_DEBUG(0, "%s: crc error\n", __FUNCTION__
);
588 IRDA_WARNING("%s: rx packet lost\n", __FUNCTION__
);
596 memcpy(skb_put(skb
,len
), rd
->buf
, len
);
597 skb_reset_mac_header(skb
);
602 ndev
->last_rx
= jiffies
;
605 rd_set_status(rd
, 0);
607 /* buffer still owned by CPU */
609 return (ret
) ? -ret
: len
;
612 static void vlsi_fill_rx(struct vlsi_ring
*r
)
614 struct ring_descr
*rd
;
616 for (rd
= ring_last(r
); rd
!= NULL
; rd
= ring_put(r
)) {
617 if (rd_is_active(rd
)) {
618 IRDA_WARNING("%s: driver bug: rx descr race with hw\n",
624 rd
->skb
= dev_alloc_skb(IRLAP_SKB_ALLOCSIZE
);
626 skb_reserve(rd
->skb
,1);
627 rd
->skb
->protocol
= htons(ETH_P_IRDA
);
630 break; /* probably not worth logging? */
632 /* give dma buffer back to busmaster */
633 pci_dma_sync_single_for_device(r
->pdev
, rd_get_addr(rd
), r
->len
, r
->dir
);
638 static void vlsi_rx_interrupt(struct net_device
*ndev
)
640 vlsi_irda_dev_t
*idev
= ndev
->priv
;
641 struct vlsi_ring
*r
= idev
->rx_ring
;
642 struct ring_descr
*rd
;
645 for (rd
= ring_first(r
); rd
!= NULL
; rd
= ring_get(r
)) {
647 if (rd_is_active(rd
))
650 ret
= vlsi_process_rx(r
, rd
);
654 idev
->stats
.rx_errors
++;
655 if (ret
& VLSI_RX_DROP
)
656 idev
->stats
.rx_dropped
++;
657 if (ret
& VLSI_RX_OVER
)
658 idev
->stats
.rx_over_errors
++;
659 if (ret
& VLSI_RX_LENGTH
)
660 idev
->stats
.rx_length_errors
++;
661 if (ret
& VLSI_RX_FRAME
)
662 idev
->stats
.rx_frame_errors
++;
663 if (ret
& VLSI_RX_CRC
)
664 idev
->stats
.rx_crc_errors
++;
667 idev
->stats
.rx_packets
++;
668 idev
->stats
.rx_bytes
+= ret
;
672 do_gettimeofday(&idev
->last_rx
); /* remember "now" for later mtt delay */
676 if (ring_first(r
) == NULL
) {
677 /* we are in big trouble, if this should ever happen */
678 IRDA_ERROR("%s: rx ring exhausted!\n", __FUNCTION__
);
682 outw(0, ndev
->base_addr
+VLSI_PIO_PROMPT
);
685 /* caller must have stopped the controller from busmastering */
687 static void vlsi_unarm_rx(vlsi_irda_dev_t
*idev
)
689 struct vlsi_ring
*r
= idev
->rx_ring
;
690 struct ring_descr
*rd
;
693 for (rd
= ring_first(r
); rd
!= NULL
; rd
= ring_get(r
)) {
696 if (rd_is_active(rd
)) {
697 rd_set_status(rd
, 0);
698 if (rd_get_count(rd
)) {
699 IRDA_DEBUG(0, "%s - dropping rx packet\n", __FUNCTION__
);
703 pci_dma_sync_single_for_cpu(r
->pdev
, rd_get_addr(rd
), r
->len
, r
->dir
);
705 dev_kfree_skb_any(rd
->skb
);
710 ret
= vlsi_process_rx(r
, rd
);
714 idev
->stats
.rx_errors
++;
715 if (ret
& VLSI_RX_DROP
)
716 idev
->stats
.rx_dropped
++;
717 if (ret
& VLSI_RX_OVER
)
718 idev
->stats
.rx_over_errors
++;
719 if (ret
& VLSI_RX_LENGTH
)
720 idev
->stats
.rx_length_errors
++;
721 if (ret
& VLSI_RX_FRAME
)
722 idev
->stats
.rx_frame_errors
++;
723 if (ret
& VLSI_RX_CRC
)
724 idev
->stats
.rx_crc_errors
++;
727 idev
->stats
.rx_packets
++;
728 idev
->stats
.rx_bytes
+= ret
;
733 /********************************************************/
735 static int vlsi_process_tx(struct vlsi_ring
*r
, struct ring_descr
*rd
)
741 pci_dma_sync_single_for_cpu(r
->pdev
, rd_get_addr(rd
), r
->len
, r
->dir
);
742 /* dma buffer now owned by the CPU */
743 status
= rd_get_status(rd
);
744 if (status
& RD_TX_UNDRN
)
748 rd_set_status(rd
, 0);
752 dev_kfree_skb_any(rd
->skb
);
755 else /* tx-skb already freed? - should never happen */
756 len
= rd_get_count(rd
); /* incorrect for SIR! (due to wrapping) */
759 /* dma buffer still owned by the CPU */
761 return (ret
) ? -ret
: len
;
764 static int vlsi_set_baud(vlsi_irda_dev_t
*idev
, unsigned iobase
)
773 baudrate
= idev
->new_baud
;
774 IRDA_DEBUG(2, "%s: %d -> %d\n", __FUNCTION__
, idev
->baud
, idev
->new_baud
);
775 if (baudrate
== 4000000) {
778 nphyctl
= PHYCTL_FIR
;
780 else if (baudrate
== 1152000) {
782 config
= IRCFG_MIR
| IRCFG_CRC16
;
783 nphyctl
= PHYCTL_MIR(clksrc
==3);
787 config
= IRCFG_SIR
| IRCFG_SIRFILT
| IRCFG_RXANY
;
790 IRDA_WARNING("%s: undefined baudrate %d - fallback to 9600!\n",
791 __FUNCTION__
, baudrate
);
800 nphyctl
= PHYCTL_SIR(baudrate
,sirpulse
,clksrc
==3);
804 config
|= IRCFG_MSTR
| IRCFG_ENRX
;
806 fifocnt
= inw(iobase
+VLSI_PIO_RCVBCNT
) & RCVBCNT_MASK
;
808 IRDA_DEBUG(0, "%s: rx fifo not empty(%d)\n", __FUNCTION__
, fifocnt
);
811 outw(0, iobase
+VLSI_PIO_IRENABLE
);
812 outw(config
, iobase
+VLSI_PIO_IRCFG
);
813 outw(nphyctl
, iobase
+VLSI_PIO_NPHYCTL
);
815 outw(IRENABLE_PHYANDCLOCK
, iobase
+VLSI_PIO_IRENABLE
);
818 udelay(1); /* chip applies IRCFG on next rising edge of its 8MHz clock */
820 /* read back settings for validation */
822 config
= inw(iobase
+VLSI_PIO_IRENABLE
) & IRENABLE_MASK
;
825 config
^= IRENABLE_FIR_ON
;
826 else if (mode
== IFF_MIR
)
827 config
^= (IRENABLE_MIR_ON
|IRENABLE_CRC16_ON
);
829 config
^= IRENABLE_SIR_ON
;
831 if (config
!= (IRENABLE_PHYANDCLOCK
|IRENABLE_ENRXST
)) {
832 IRDA_WARNING("%s: failed to set %s mode!\n", __FUNCTION__
,
833 (mode
==IFF_SIR
)?"SIR":((mode
==IFF_MIR
)?"MIR":"FIR"));
837 if (inw(iobase
+VLSI_PIO_PHYCTL
) != nphyctl
) {
838 IRDA_WARNING("%s: failed to apply baudrate %d\n",
839 __FUNCTION__
, baudrate
);
844 idev
->baud
= baudrate
;
851 vlsi_reg_debug(iobase
,__FUNCTION__
);
856 static int vlsi_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
858 vlsi_irda_dev_t
*idev
= ndev
->priv
;
859 struct vlsi_ring
*r
= idev
->tx_ring
;
860 struct ring_descr
*rd
;
862 unsigned iobase
= ndev
->base_addr
;
867 struct timeval now
, ready
;
870 speed
= irda_get_next_speed(skb
);
871 spin_lock_irqsave(&idev
->lock
, flags
);
872 if (speed
!= -1 && speed
!= idev
->baud
) {
873 netif_stop_queue(ndev
);
874 idev
->new_baud
= speed
;
875 status
= RD_TX_CLRENTX
; /* stop tx-ring after this frame */
881 /* handle zero packets - should be speed change */
883 msg
= "bogus zero-length packet";
887 /* due to the completely asynch tx operation we might have
888 * IrLAP racing with the hardware here, f.e. if the controller
889 * is just sending the last packet with current speed while
890 * the LAP is already switching the speed using synchronous
891 * len=0 packet. Immediate execution would lead to hw lockup
892 * requiring a powercycle to reset. Good candidate to trigger
893 * this is the final UA:RSP packet after receiving a DISC:CMD
894 * when getting the LAP down.
895 * Note that we are not protected by the queue_stop approach
896 * because the final UA:RSP arrives _without_ request to apply
897 * new-speed-after-this-packet - hence the driver doesn't know
898 * this was the last packet and doesn't stop the queue. So the
899 * forced switch to default speed from LAP gets through as fast
900 * as only some 10 usec later while the UA:RSP is still processed
901 * by the hardware and we would get screwed.
904 if (ring_first(idev
->tx_ring
) == NULL
) {
905 /* no race - tx-ring already empty */
906 vlsi_set_baud(idev
, iobase
);
907 netif_wake_queue(ndev
);
911 /* keep the speed change pending like it would
912 * for any len>0 packet. tx completion interrupt
913 * will apply it when the tx ring becomes empty.
915 spin_unlock_irqrestore(&idev
->lock
, flags
);
916 dev_kfree_skb_any(skb
);
920 /* sanity checks - simply drop the packet */
924 msg
= "ring full, but queue wasn't stopped";
928 if (rd_is_active(rd
)) {
929 msg
= "entry still owned by hw";
934 msg
= "tx ring entry without pci buffer";
939 msg
= "ring entry with old skb still attached";
943 /* no need for serialization or interrupt disable during mtt */
944 spin_unlock_irqrestore(&idev
->lock
, flags
);
946 if ((mtt
= irda_get_mtt(skb
)) > 0) {
948 ready
.tv_usec
= idev
->last_rx
.tv_usec
+ mtt
;
949 ready
.tv_sec
= idev
->last_rx
.tv_sec
;
950 if (ready
.tv_usec
>= 1000000) {
951 ready
.tv_usec
-= 1000000;
952 ready
.tv_sec
++; /* IrLAP 1.1: mtt always < 1 sec */
955 do_gettimeofday(&now
);
956 if (now
.tv_sec
> ready
.tv_sec
957 || (now
.tv_sec
==ready
.tv_sec
&& now
.tv_usec
>=ready
.tv_usec
))
960 /* must not sleep here - called under netif_tx_lock! */
964 /* tx buffer already owned by CPU due to pci_dma_sync_single_for_cpu()
965 * after subsequent tx-completion
968 if (idev
->mode
== IFF_SIR
) {
969 status
|= RD_TX_DISCRC
; /* no hw-crc creation */
970 len
= async_wrap_skb(skb
, rd
->buf
, r
->len
);
972 /* Some rare worst case situation in SIR mode might lead to
973 * potential buffer overflow. The wrapper detects this, returns
974 * with a shortened frame (without FCS/EOF) but doesn't provide
975 * any error indication about the invalid packet which we are
977 * Therefore we log if the buffer got filled to the point, where the
978 * wrapper would abort, i.e. when there are less than 5 bytes left to
979 * allow appending the FCS/EOF.
983 IRDA_WARNING("%s: possible buffer overflow with SIR wrapping!\n",
987 /* hw deals with MIR/FIR mode wrapping */
988 status
|= RD_TX_PULSE
; /* send 2 us highspeed indication pulse */
991 msg
= "frame exceeds tx buffer length";
995 skb_copy_from_linear_data(skb
, rd
->buf
, len
);
998 rd
->skb
= skb
; /* remember skb for tx-complete stats */
1000 rd_set_count(rd
, len
);
1001 rd_set_status(rd
, status
); /* not yet active! */
1003 /* give dma buffer back to busmaster-hw (flush caches to make
1004 * CPU-driven changes visible from the pci bus).
1007 pci_dma_sync_single_for_device(r
->pdev
, rd_get_addr(rd
), r
->len
, r
->dir
);
1009 /* Switching to TX mode here races with the controller
1010 * which may stop TX at any time when fetching an inactive descriptor
1011 * or one with CLR_ENTX set. So we switch on TX only, if TX was not running
1012 * _after_ the new descriptor was activated on the ring. This ensures
1013 * we will either find TX already stopped or we can be sure, there
1014 * will be a TX-complete interrupt even if the chip stopped doing
1015 * TX just after we found it still running. The ISR will then find
1016 * the non-empty ring and restart TX processing. The enclosing
1017 * spinlock provides the correct serialization to prevent race with isr.
1020 spin_lock_irqsave(&idev
->lock
,flags
);
1024 if (!(inw(iobase
+VLSI_PIO_IRENABLE
) & IRENABLE_ENTXST
)) {
1027 fifocnt
= inw(ndev
->base_addr
+VLSI_PIO_RCVBCNT
) & RCVBCNT_MASK
;
1029 IRDA_DEBUG(0, "%s: rx fifo not empty(%d)\n", __FUNCTION__
, fifocnt
);
1032 config
= inw(iobase
+VLSI_PIO_IRCFG
);
1034 outw(config
| IRCFG_ENTX
, iobase
+VLSI_PIO_IRCFG
);
1036 outw(0, iobase
+VLSI_PIO_PROMPT
);
1038 ndev
->trans_start
= jiffies
;
1040 if (ring_put(r
) == NULL
) {
1041 netif_stop_queue(ndev
);
1042 IRDA_DEBUG(3, "%s: tx ring full - queue stopped\n", __FUNCTION__
);
1044 spin_unlock_irqrestore(&idev
->lock
, flags
);
1049 spin_unlock_irqrestore(&idev
->lock
, flags
);
1051 IRDA_WARNING("%s: dropping packet - %s\n", __FUNCTION__
, msg
);
1052 dev_kfree_skb_any(skb
);
1053 idev
->stats
.tx_errors
++;
1054 idev
->stats
.tx_dropped
++;
1055 /* Don't even think about returning NET_XMIT_DROP (=1) here!
1056 * In fact any retval!=0 causes the packet scheduler to requeue the
1057 * packet for later retry of transmission - which isn't exactly
1058 * what we want after we've just called dev_kfree_skb_any ;-)
1063 static void vlsi_tx_interrupt(struct net_device
*ndev
)
1065 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1066 struct vlsi_ring
*r
= idev
->tx_ring
;
1067 struct ring_descr
*rd
;
1072 for (rd
= ring_first(r
); rd
!= NULL
; rd
= ring_get(r
)) {
1074 if (rd_is_active(rd
))
1077 ret
= vlsi_process_tx(r
, rd
);
1081 idev
->stats
.tx_errors
++;
1082 if (ret
& VLSI_TX_DROP
)
1083 idev
->stats
.tx_dropped
++;
1084 if (ret
& VLSI_TX_FIFO
)
1085 idev
->stats
.tx_fifo_errors
++;
1088 idev
->stats
.tx_packets
++;
1089 idev
->stats
.tx_bytes
+= ret
;
1093 iobase
= ndev
->base_addr
;
1095 if (idev
->new_baud
&& rd
== NULL
) /* tx ring empty and speed change pending */
1096 vlsi_set_baud(idev
, iobase
);
1098 config
= inw(iobase
+VLSI_PIO_IRCFG
);
1099 if (rd
== NULL
) /* tx ring empty: re-enable rx */
1100 outw((config
& ~IRCFG_ENTX
) | IRCFG_ENRX
, iobase
+VLSI_PIO_IRCFG
);
1102 else if (!(inw(iobase
+VLSI_PIO_IRENABLE
) & IRENABLE_ENTXST
)) {
1105 fifocnt
= inw(iobase
+VLSI_PIO_RCVBCNT
) & RCVBCNT_MASK
;
1107 IRDA_DEBUG(0, "%s: rx fifo not empty(%d)\n",
1108 __FUNCTION__
, fifocnt
);
1110 outw(config
| IRCFG_ENTX
, iobase
+VLSI_PIO_IRCFG
);
1113 outw(0, iobase
+VLSI_PIO_PROMPT
);
1115 if (netif_queue_stopped(ndev
) && !idev
->new_baud
) {
1116 netif_wake_queue(ndev
);
1117 IRDA_DEBUG(3, "%s: queue awoken\n", __FUNCTION__
);
1121 /* caller must have stopped the controller from busmastering */
1123 static void vlsi_unarm_tx(vlsi_irda_dev_t
*idev
)
1125 struct vlsi_ring
*r
= idev
->tx_ring
;
1126 struct ring_descr
*rd
;
1129 for (rd
= ring_first(r
); rd
!= NULL
; rd
= ring_get(r
)) {
1132 if (rd_is_active(rd
)) {
1133 rd_set_status(rd
, 0);
1134 rd_set_count(rd
, 0);
1135 pci_dma_sync_single_for_cpu(r
->pdev
, rd_get_addr(rd
), r
->len
, r
->dir
);
1137 dev_kfree_skb_any(rd
->skb
);
1140 IRDA_DEBUG(0, "%s - dropping tx packet\n", __FUNCTION__
);
1141 ret
= -VLSI_TX_DROP
;
1144 ret
= vlsi_process_tx(r
, rd
);
1148 idev
->stats
.tx_errors
++;
1149 if (ret
& VLSI_TX_DROP
)
1150 idev
->stats
.tx_dropped
++;
1151 if (ret
& VLSI_TX_FIFO
)
1152 idev
->stats
.tx_fifo_errors
++;
1155 idev
->stats
.tx_packets
++;
1156 idev
->stats
.tx_bytes
+= ret
;
1162 /********************************************************/
1164 static int vlsi_start_clock(struct pci_dev
*pdev
)
1169 if (clksrc
< 2) { /* auto or PLL: try PLL */
1170 clkctl
= CLKCTL_PD_INV
| CLKCTL_CLKSTP
;
1171 pci_write_config_byte(pdev
, VLSI_PCI_CLKCTL
, clkctl
);
1173 /* procedure to detect PLL lock synchronisation:
1174 * after 0.5 msec initial delay we expect to find 3 PLL lock
1175 * indications within 10 msec for successful PLL detection.
1179 for (i
= 500; i
<= 10000; i
+= 50) { /* max 10 msec */
1180 pci_read_config_byte(pdev
, VLSI_PCI_CLKCTL
, &lock
);
1181 if (lock
&CLKCTL_LOCK
) {
1188 if (clksrc
== 1) { /* explicitly asked for PLL hence bail out */
1189 IRDA_ERROR("%s: no PLL or failed to lock!\n",
1191 clkctl
= CLKCTL_CLKSTP
;
1192 pci_write_config_byte(pdev
, VLSI_PCI_CLKCTL
, clkctl
);
1195 else /* was: clksrc=0(auto) */
1196 clksrc
= 3; /* fallback to 40MHz XCLK (OB800) */
1198 IRDA_DEBUG(0, "%s: PLL not locked, fallback to clksrc=%d\n",
1199 __FUNCTION__
, clksrc
);
1202 clksrc
= 1; /* got successful PLL lock */
1206 /* we get here if either no PLL detected in auto-mode or
1207 an external clock source was explicitly specified */
1209 clkctl
= CLKCTL_EXTCLK
| CLKCTL_CLKSTP
;
1211 clkctl
|= CLKCTL_XCKSEL
;
1212 pci_write_config_byte(pdev
, VLSI_PCI_CLKCTL
, clkctl
);
1214 /* no way to test for working XCLK */
1217 pci_read_config_byte(pdev
, VLSI_PCI_CLKCTL
, &clkctl
);
1219 /* ok, now going to connect the chip with the clock source */
1221 clkctl
&= ~CLKCTL_CLKSTP
;
1222 pci_write_config_byte(pdev
, VLSI_PCI_CLKCTL
, clkctl
);
1227 static void vlsi_stop_clock(struct pci_dev
*pdev
)
1231 /* disconnect chip from clock source */
1232 pci_read_config_byte(pdev
, VLSI_PCI_CLKCTL
, &clkctl
);
1233 clkctl
|= CLKCTL_CLKSTP
;
1234 pci_write_config_byte(pdev
, VLSI_PCI_CLKCTL
, clkctl
);
1236 /* disable all clock sources */
1237 clkctl
&= ~(CLKCTL_EXTCLK
| CLKCTL_PD_INV
);
1238 pci_write_config_byte(pdev
, VLSI_PCI_CLKCTL
, clkctl
);
1241 /********************************************************/
1243 /* writing all-zero to the VLSI PCI IO register area seems to prevent
1244 * some occasional situations where the hardware fails (symptoms are
1245 * what appears as stalled tx/rx state machines, i.e. everything ok for
1246 * receive or transmit but hw makes no progress or is unable to access
1247 * the bus memory locations).
1248 * Best place to call this is immediately after/before the internal clock
1249 * gets started/stopped.
1252 static inline void vlsi_clear_regs(unsigned iobase
)
1255 const unsigned chip_io_extent
= 32;
1257 for (i
= 0; i
< chip_io_extent
; i
+= sizeof(u16
))
1258 outw(0, iobase
+ i
);
1261 static int vlsi_init_chip(struct pci_dev
*pdev
)
1263 struct net_device
*ndev
= pci_get_drvdata(pdev
);
1264 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1268 /* start the clock and clean the registers */
1270 if (vlsi_start_clock(pdev
)) {
1271 IRDA_ERROR("%s: no valid clock source\n", __FUNCTION__
);
1274 iobase
= ndev
->base_addr
;
1275 vlsi_clear_regs(iobase
);
1277 outb(IRINTR_INT_MASK
, iobase
+VLSI_PIO_IRINTR
); /* w/c pending IRQ, disable all INT */
1279 outw(0, iobase
+VLSI_PIO_IRENABLE
); /* disable IrPHY-interface */
1281 /* disable everything, particularly IRCFG_MSTR - (also resetting the RING_PTR) */
1283 outw(0, iobase
+VLSI_PIO_IRCFG
);
1286 outw(MAX_PACKET_LENGTH
, iobase
+VLSI_PIO_MAXPKT
); /* max possible value=0x0fff */
1288 outw(BUS_TO_RINGBASE(idev
->busaddr
), iobase
+VLSI_PIO_RINGBASE
);
1290 outw(TX_RX_TO_RINGSIZE(idev
->tx_ring
->size
, idev
->rx_ring
->size
),
1291 iobase
+VLSI_PIO_RINGSIZE
);
1293 ptr
= inw(iobase
+VLSI_PIO_RINGPTR
);
1294 atomic_set(&idev
->rx_ring
->head
, RINGPTR_GET_RX(ptr
));
1295 atomic_set(&idev
->rx_ring
->tail
, RINGPTR_GET_RX(ptr
));
1296 atomic_set(&idev
->tx_ring
->head
, RINGPTR_GET_TX(ptr
));
1297 atomic_set(&idev
->tx_ring
->tail
, RINGPTR_GET_TX(ptr
));
1299 vlsi_set_baud(idev
, iobase
); /* idev->new_baud used as provided by caller */
1301 outb(IRINTR_INT_MASK
, iobase
+VLSI_PIO_IRINTR
); /* just in case - w/c pending IRQ's */
1304 /* DO NOT BLINDLY ENABLE IRINTR_ACTEN!
1305 * basically every received pulse fires an ACTIVITY-INT
1306 * leading to >>1000 INT's per second instead of few 10
1309 outb(IRINTR_RPKTEN
|IRINTR_TPKTEN
, iobase
+VLSI_PIO_IRINTR
);
1314 static int vlsi_start_hw(vlsi_irda_dev_t
*idev
)
1316 struct pci_dev
*pdev
= idev
->pdev
;
1317 struct net_device
*ndev
= pci_get_drvdata(pdev
);
1318 unsigned iobase
= ndev
->base_addr
;
1321 /* we don't use the legacy UART, disable its address decoding */
1323 pci_read_config_byte(pdev
, VLSI_PCI_IRMISC
, &byte
);
1324 byte
&= ~(IRMISC_UARTEN
| IRMISC_UARTTST
);
1325 pci_write_config_byte(pdev
, VLSI_PCI_IRMISC
, byte
);
1327 /* enable PCI busmaster access to our 16MB page */
1329 pci_write_config_byte(pdev
, VLSI_PCI_MSTRPAGE
, MSTRPAGE_VALUE
);
1330 pci_set_master(pdev
);
1332 if (vlsi_init_chip(pdev
) < 0) {
1333 pci_disable_device(pdev
);
1337 vlsi_fill_rx(idev
->rx_ring
);
1339 do_gettimeofday(&idev
->last_rx
); /* first mtt may start from now on */
1341 outw(0, iobase
+VLSI_PIO_PROMPT
); /* kick hw state machine */
1346 static int vlsi_stop_hw(vlsi_irda_dev_t
*idev
)
1348 struct pci_dev
*pdev
= idev
->pdev
;
1349 struct net_device
*ndev
= pci_get_drvdata(pdev
);
1350 unsigned iobase
= ndev
->base_addr
;
1351 unsigned long flags
;
1353 spin_lock_irqsave(&idev
->lock
,flags
);
1354 outw(0, iobase
+VLSI_PIO_IRENABLE
);
1355 outw(0, iobase
+VLSI_PIO_IRCFG
); /* disable everything */
1357 /* disable and w/c irqs */
1358 outb(0, iobase
+VLSI_PIO_IRINTR
);
1360 outb(IRINTR_INT_MASK
, iobase
+VLSI_PIO_IRINTR
);
1361 spin_unlock_irqrestore(&idev
->lock
,flags
);
1363 vlsi_unarm_tx(idev
);
1364 vlsi_unarm_rx(idev
);
1366 vlsi_clear_regs(iobase
);
1367 vlsi_stop_clock(pdev
);
1369 pci_disable_device(pdev
);
1374 /**************************************************************/
1376 static struct net_device_stats
* vlsi_get_stats(struct net_device
*ndev
)
1378 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1380 return &idev
->stats
;
1383 static void vlsi_tx_timeout(struct net_device
*ndev
)
1385 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1388 vlsi_reg_debug(ndev
->base_addr
, __FUNCTION__
);
1389 vlsi_ring_debug(idev
->tx_ring
);
1391 if (netif_running(ndev
))
1392 netif_stop_queue(ndev
);
1396 /* now simply restart the whole thing */
1398 if (!idev
->new_baud
)
1399 idev
->new_baud
= idev
->baud
; /* keep current baudrate */
1401 if (vlsi_start_hw(idev
))
1402 IRDA_ERROR("%s: failed to restart hw - %s(%s) unusable!\n",
1403 __FUNCTION__
, pci_name(idev
->pdev
), ndev
->name
);
1405 netif_start_queue(ndev
);
1408 static int vlsi_ioctl(struct net_device
*ndev
, struct ifreq
*rq
, int cmd
)
1410 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1411 struct if_irda_req
*irq
= (struct if_irda_req
*) rq
;
1412 unsigned long flags
;
1417 case SIOCSBANDWIDTH
:
1418 if (!capable(CAP_NET_ADMIN
)) {
1422 spin_lock_irqsave(&idev
->lock
, flags
);
1423 idev
->new_baud
= irq
->ifr_baudrate
;
1424 /* when called from userland there might be a minor race window here
1425 * if the stack tries to change speed concurrently - which would be
1426 * pretty strange anyway with the userland having full control...
1428 vlsi_set_baud(idev
, ndev
->base_addr
);
1429 spin_unlock_irqrestore(&idev
->lock
, flags
);
1431 case SIOCSMEDIABUSY
:
1432 if (!capable(CAP_NET_ADMIN
)) {
1436 irda_device_set_media_busy(ndev
, TRUE
);
1438 case SIOCGRECEIVING
:
1439 /* the best we can do: check whether there are any bytes in rx fifo.
1440 * The trustable window (in case some data arrives just afterwards)
1441 * may be as short as 1usec or so at 4Mbps.
1443 fifocnt
= inw(ndev
->base_addr
+VLSI_PIO_RCVBCNT
) & RCVBCNT_MASK
;
1444 irq
->ifr_receiving
= (fifocnt
!=0) ? 1 : 0;
1447 IRDA_WARNING("%s: notsupp - cmd=%04x\n",
1455 /********************************************************/
1457 static irqreturn_t
vlsi_interrupt(int irq
, void *dev_instance
)
1459 struct net_device
*ndev
= dev_instance
;
1460 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1464 unsigned long flags
;
1467 iobase
= ndev
->base_addr
;
1468 spin_lock_irqsave(&idev
->lock
,flags
);
1470 irintr
= inb(iobase
+VLSI_PIO_IRINTR
);
1472 outb(irintr
, iobase
+VLSI_PIO_IRINTR
); /* acknowledge asap */
1474 if (!(irintr
&=IRINTR_INT_MASK
)) /* not our INT - probably shared */
1479 if (unlikely(!(irintr
& ~IRINTR_ACTIVITY
)))
1480 break; /* nothing todo if only activity */
1482 if (irintr
&IRINTR_RPKTINT
)
1483 vlsi_rx_interrupt(ndev
);
1485 if (irintr
&IRINTR_TPKTINT
)
1486 vlsi_tx_interrupt(ndev
);
1488 } while (--boguscount
> 0);
1489 spin_unlock_irqrestore(&idev
->lock
,flags
);
1491 if (boguscount
<= 0)
1492 IRDA_MESSAGE("%s: too much work in interrupt!\n",
1494 return IRQ_RETVAL(handled
);
1497 /********************************************************/
1499 static int vlsi_open(struct net_device
*ndev
)
1501 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1505 if (pci_request_regions(idev
->pdev
, drivername
)) {
1506 IRDA_WARNING("%s: io resource busy\n", __FUNCTION__
);
1509 ndev
->base_addr
= pci_resource_start(idev
->pdev
,0);
1510 ndev
->irq
= idev
->pdev
->irq
;
1512 /* under some rare occasions the chip apparently comes up with
1513 * IRQ's pending. We better w/c pending IRQ and disable them all
1516 outb(IRINTR_INT_MASK
, ndev
->base_addr
+VLSI_PIO_IRINTR
);
1518 if (request_irq(ndev
->irq
, vlsi_interrupt
, IRQF_SHARED
,
1519 drivername
, ndev
)) {
1520 IRDA_WARNING("%s: couldn't get IRQ: %d\n",
1521 __FUNCTION__
, ndev
->irq
);
1525 if ((err
= vlsi_create_hwif(idev
)) != 0)
1528 sprintf(hwname
, "VLSI-FIR @ 0x%04x", (unsigned)ndev
->base_addr
);
1529 idev
->irlap
= irlap_open(ndev
,&idev
->qos
,hwname
);
1531 goto errout_free_ring
;
1533 do_gettimeofday(&idev
->last_rx
); /* first mtt may start from now on */
1535 idev
->new_baud
= 9600; /* start with IrPHY using 9600(SIR) mode */
1537 if ((err
= vlsi_start_hw(idev
)) != 0)
1538 goto errout_close_irlap
;
1540 netif_start_queue(ndev
);
1542 IRDA_MESSAGE("%s: device %s operational\n", __FUNCTION__
, ndev
->name
);
1547 irlap_close(idev
->irlap
);
1549 vlsi_destroy_hwif(idev
);
1551 free_irq(ndev
->irq
,ndev
);
1553 pci_release_regions(idev
->pdev
);
1558 static int vlsi_close(struct net_device
*ndev
)
1560 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1562 netif_stop_queue(ndev
);
1565 irlap_close(idev
->irlap
);
1570 vlsi_destroy_hwif(idev
);
1572 free_irq(ndev
->irq
,ndev
);
1574 pci_release_regions(idev
->pdev
);
1576 IRDA_MESSAGE("%s: device %s stopped\n", __FUNCTION__
, ndev
->name
);
1581 static int vlsi_irda_init(struct net_device
*ndev
)
1583 vlsi_irda_dev_t
*idev
= ndev
->priv
;
1584 struct pci_dev
*pdev
= idev
->pdev
;
1586 SET_MODULE_OWNER(ndev
);
1588 ndev
->irq
= pdev
->irq
;
1589 ndev
->base_addr
= pci_resource_start(pdev
,0);
1592 * see include file for details why we need these 2 masks, in this order!
1595 if (pci_set_dma_mask(pdev
,DMA_MASK_USED_BY_HW
)
1596 || pci_set_dma_mask(pdev
,DMA_MASK_MSTRPAGE
)) {
1597 IRDA_ERROR("%s: aborting due to PCI BM-DMA address limitations\n", __FUNCTION__
);
1601 irda_init_max_qos_capabilies(&idev
->qos
);
1603 /* the VLSI82C147 does not support 576000! */
1605 idev
->qos
.baud_rate
.bits
= IR_2400
| IR_9600
1606 | IR_19200
| IR_38400
| IR_57600
| IR_115200
1607 | IR_1152000
| (IR_4000000
<< 8);
1609 idev
->qos
.min_turn_time
.bits
= qos_mtt_bits
;
1611 irda_qos_bits_to_value(&idev
->qos
);
1613 /* currently no public media definitions for IrDA */
1615 ndev
->flags
|= IFF_PORTSEL
| IFF_AUTOMEDIA
;
1616 ndev
->if_port
= IF_PORT_UNKNOWN
;
1618 ndev
->open
= vlsi_open
;
1619 ndev
->stop
= vlsi_close
;
1620 ndev
->get_stats
= vlsi_get_stats
;
1621 ndev
->hard_start_xmit
= vlsi_hard_start_xmit
;
1622 ndev
->do_ioctl
= vlsi_ioctl
;
1623 ndev
->tx_timeout
= vlsi_tx_timeout
;
1624 ndev
->watchdog_timeo
= 500*HZ
/1000; /* max. allowed turn time for IrLAP */
1626 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
1631 /**************************************************************/
1633 static int __devinit
1634 vlsi_irda_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
1636 struct net_device
*ndev
;
1637 vlsi_irda_dev_t
*idev
;
1639 if (pci_enable_device(pdev
))
1642 pdev
->current_state
= 0; /* hw must be running now */
1644 IRDA_MESSAGE("%s: IrDA PCI controller %s detected\n",
1645 drivername
, pci_name(pdev
));
1647 if ( !pci_resource_start(pdev
,0)
1648 || !(pci_resource_flags(pdev
,0) & IORESOURCE_IO
) ) {
1649 IRDA_ERROR("%s: bar 0 invalid", __FUNCTION__
);
1653 ndev
= alloc_irdadev(sizeof(*idev
));
1655 IRDA_ERROR("%s: Unable to allocate device memory.\n",
1662 spin_lock_init(&idev
->lock
);
1663 init_MUTEX(&idev
->sem
);
1667 if (vlsi_irda_init(ndev
) < 0)
1670 if (register_netdev(ndev
) < 0) {
1671 IRDA_ERROR("%s: register_netdev failed\n", __FUNCTION__
);
1675 if (vlsi_proc_root
!= NULL
) {
1676 struct proc_dir_entry
*ent
;
1678 ent
= create_proc_entry(ndev
->name
, S_IFREG
|S_IRUGO
, vlsi_proc_root
);
1680 IRDA_WARNING("%s: failed to create proc entry\n",
1684 ent
->proc_fops
= VLSI_PROC_FOPS
;
1687 idev
->proc_entry
= ent
;
1689 IRDA_MESSAGE("%s: registered device %s\n", drivername
, ndev
->name
);
1691 pci_set_drvdata(pdev
, ndev
);
1700 pci_disable_device(pdev
);
1702 pci_set_drvdata(pdev
, NULL
);
1706 static void __devexit
vlsi_irda_remove(struct pci_dev
*pdev
)
1708 struct net_device
*ndev
= pci_get_drvdata(pdev
);
1709 vlsi_irda_dev_t
*idev
;
1712 IRDA_ERROR("%s: lost netdevice?\n", drivername
);
1716 unregister_netdev(ndev
);
1720 if (idev
->proc_entry
) {
1721 remove_proc_entry(ndev
->name
, vlsi_proc_root
);
1722 idev
->proc_entry
= NULL
;
1728 pci_set_drvdata(pdev
, NULL
);
1730 IRDA_MESSAGE("%s: %s removed\n", drivername
, pci_name(pdev
));
1735 /* The Controller doesn't provide PCI PM capabilities as defined by PCI specs.
1736 * Some of the Linux PCI-PM code however depends on this, for example in
1737 * pci_set_power_state(). So we have to take care to perform the required
1738 * operations on our own (particularly reflecting the pdev->current_state)
1739 * otherwise we might get cheated by pci-pm.
1743 static int vlsi_irda_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1745 struct net_device
*ndev
= pci_get_drvdata(pdev
);
1746 vlsi_irda_dev_t
*idev
;
1749 IRDA_ERROR("%s - %s: no netdevice \n",
1750 __FUNCTION__
, pci_name(pdev
));
1755 if (pdev
->current_state
!= 0) { /* already suspended */
1756 if (state
.event
> pdev
->current_state
) { /* simply go deeper */
1757 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
1758 pdev
->current_state
= state
.event
;
1761 IRDA_ERROR("%s - %s: invalid suspend request %u -> %u\n", __FUNCTION__
, pci_name(pdev
), pdev
->current_state
, state
.event
);
1766 if (netif_running(ndev
)) {
1767 netif_device_detach(ndev
);
1769 pci_save_state(pdev
);
1770 if (!idev
->new_baud
)
1771 /* remember speed settings to restore on resume */
1772 idev
->new_baud
= idev
->baud
;
1775 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
1776 pdev
->current_state
= state
.event
;
1777 idev
->resume_ok
= 1;
1782 static int vlsi_irda_resume(struct pci_dev
*pdev
)
1784 struct net_device
*ndev
= pci_get_drvdata(pdev
);
1785 vlsi_irda_dev_t
*idev
;
1788 IRDA_ERROR("%s - %s: no netdevice \n",
1789 __FUNCTION__
, pci_name(pdev
));
1794 if (pdev
->current_state
== 0) {
1796 IRDA_WARNING("%s - %s: already resumed\n",
1797 __FUNCTION__
, pci_name(pdev
));
1801 pci_set_power_state(pdev
, PCI_D0
);
1802 pdev
->current_state
= PM_EVENT_ON
;
1804 if (!idev
->resume_ok
) {
1805 /* should be obsolete now - but used to happen due to:
1806 * - pci layer initially setting pdev->current_state = 4 (unknown)
1807 * - pci layer did not walk the save_state-tree (might be APM problem)
1808 * so we could not refuse to suspend from undefined state
1809 * - vlsi_irda_suspend detected invalid state and refused to save
1810 * configuration for resume - but was too late to stop suspending
1811 * - vlsi_irda_resume got screwed when trying to resume from garbage
1813 * now we explicitly set pdev->current_state = 0 after enabling the
1814 * device and independently resume_ok should catch any garbage config.
1816 IRDA_WARNING("%s - hm, nothing to resume?\n", __FUNCTION__
);
1821 if (netif_running(ndev
)) {
1822 pci_restore_state(pdev
);
1823 vlsi_start_hw(idev
);
1824 netif_device_attach(ndev
);
1826 idev
->resume_ok
= 0;
1831 #endif /* CONFIG_PM */
1833 /*********************************************************/
1835 static struct pci_driver vlsi_irda_driver
= {
1837 .id_table
= vlsi_irda_table
,
1838 .probe
= vlsi_irda_probe
,
1839 .remove
= __devexit_p(vlsi_irda_remove
),
1841 .suspend
= vlsi_irda_suspend
,
1842 .resume
= vlsi_irda_resume
,
1846 #define PROC_DIR ("driver/" DRIVER_NAME)
1848 static int __init
vlsi_mod_init(void)
1852 if (clksrc
< 0 || clksrc
> 3) {
1853 IRDA_ERROR("%s: invalid clksrc=%d\n", drivername
, clksrc
);
1857 for (i
= 0; i
< 2; i
++) {
1858 switch(ringsize
[i
]) {
1866 IRDA_WARNING("%s: invalid %s ringsize %d, using default=8", drivername
, (i
)?"rx":"tx", ringsize
[i
]);
1872 sirpulse
= !!sirpulse
;
1874 /* proc_mkdir returns NULL if !CONFIG_PROC_FS.
1875 * Failure to create the procfs entry is handled like running
1876 * without procfs - it's not required for the driver to work.
1878 vlsi_proc_root
= proc_mkdir(PROC_DIR
, NULL
);
1879 if (vlsi_proc_root
) {
1880 /* protect registered procdir against module removal.
1881 * Because we are in the module init path there's no race
1882 * window after create_proc_entry (and no barrier needed).
1884 vlsi_proc_root
->owner
= THIS_MODULE
;
1887 ret
= pci_register_driver(&vlsi_irda_driver
);
1889 if (ret
&& vlsi_proc_root
)
1890 remove_proc_entry(PROC_DIR
, NULL
);
1895 static void __exit
vlsi_mod_exit(void)
1897 pci_unregister_driver(&vlsi_irda_driver
);
1899 remove_proc_entry(PROC_DIR
, NULL
);
1902 module_init(vlsi_mod_init
);
1903 module_exit(vlsi_mod_exit
);