aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorAdrian Bunk <bunk@kernel.org>2008-01-19 03:00:42 -0500
committerDavid S. Miller <davem@davemloft.net>2008-01-28 18:08:10 -0500
commite9888f5498083f5e4d873cbbe16aa97d89aa1342 (patch)
tree00daae7fa1768dc413b13301acd394b06d16704f /drivers
parent5d780cd6585d242d9592a479fe75a007fd75155d (diff)
[IrDA]: Irport removal - part 1
This patch removes IrPORT and the old dongle drivers (all off them have replacement drivers). Signed-off-by: Adrian Bunk <bunk@kernel.org> Signed-off-by: Samuel Ortiz <samuel@sortiz.org> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/net/irda/Kconfig141
-rw-r--r--drivers/net/irda/Makefile17
-rw-r--r--drivers/net/irda/irport.c1123
-rw-r--r--drivers/net/irda/irport.h80
4 files changed, 2 insertions, 1359 deletions
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index 65806956728a..ce816ba9c40d 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -190,147 +190,6 @@ config KS959_DONGLE
190 To compile it as a module, choose M here: the module will be called 190 To compile it as a module, choose M here: the module will be called
191 ks959-sir. 191 ks959-sir.
192 192
193comment "Old SIR device drivers"
194
195config IRPORT_SIR
196 tristate "IrPORT (IrDA serial driver)"
197 depends on IRDA && BROKEN_ON_SMP
198 ---help---
199 Say Y here if you want to build support for the IrPORT IrDA device
200 driver. To compile it as a module, choose M here: the module will be
201 called irport. IrPORT can be used instead of IrTTY and sometimes
202 this can be better. One example is if your IrDA port does not
203 have echo-canceling, which will work OK with IrPORT since this
204 driver is working in half-duplex mode only. You don't need to use
205 irattach with IrPORT, but you just insert it the same way as FIR
206 drivers (insmod irport io=0x3e8 irq=11). Notice that IrPORT is a
207 SIR device driver which means that speed is limited to 115200 bps.
208
209 If unsure, say Y.
210
211comment "Old Serial dongle support"
212
213config DONGLE_OLD
214 bool "Old Serial dongle support"
215 depends on IRPORT_SIR && BROKEN_ON_SMP
216 help
217 Say Y here if you have an infrared device that connects to your
218 computer's serial port. These devices are called dongles. Then say Y
219 or M to the driver for your particular dongle below.
220
221 Note that the answer to this question won't directly affect the
222 kernel: saying N will just cause the configurator to skip all
223 the questions about serial dongles.
224
225config ESI_DONGLE_OLD
226 tristate "ESI JetEye PC dongle"
227 depends on DONGLE_OLD && IRDA
228 help
229 Say Y here if you want to build support for the Extended Systems
230 JetEye PC dongle. To compile it as a module, choose M here. The ESI
231 dongle attaches to the normal 9-pin serial port connector, and can
232 currently only be used by IrTTY. To activate support for ESI
233 dongles you will have to start irattach like this:
234 "irattach -d esi".
235
236config ACTISYS_DONGLE_OLD
237 tristate "ACTiSYS IR-220L and IR220L+ dongle"
238 depends on DONGLE_OLD && IRDA
239 help
240 Say Y here if you want to build support for the ACTiSYS IR-220L and
241 IR220L+ dongles. To compile it as a module, choose M here. The
242 ACTiSYS dongles attaches to the normal 9-pin serial port connector,
243 and can currently only be used by IrTTY. To activate support for
244 ACTiSYS dongles you will have to start irattach like this:
245 "irattach -d actisys" or "irattach -d actisys+".
246
247config TEKRAM_DONGLE_OLD
248 tristate "Tekram IrMate 210B dongle"
249 depends on DONGLE_OLD && IRDA
250 help
251 Say Y here if you want to build support for the Tekram IrMate 210B
252 dongle. To compile it as a module, choose M here. The Tekram dongle
253 attaches to the normal 9-pin serial port connector, and can
254 currently only be used by IrTTY. To activate support for Tekram
255 dongles you will have to start irattach like this:
256 "irattach -d tekram".
257
258config GIRBIL_DONGLE_OLD
259 tristate "Greenwich GIrBIL dongle"
260 depends on DONGLE_OLD && IRDA
261 help
262 Say Y here if you want to build support for the Greenwich GIrBIL
263 dongle. To compile it as a module, choose M here. The Greenwich
264 dongle attaches to the normal 9-pin serial port connector, and can
265 currently only be used by IrTTY. To activate support for Greenwich
266 dongles you will have to insert "irattach -d girbil" in the
267 /etc/irda/drivers script.
268
269config LITELINK_DONGLE_OLD
270 tristate "Parallax LiteLink dongle"
271 depends on DONGLE_OLD && IRDA
272 help
273 Say Y here if you want to build support for the Parallax Litelink
274 dongle. To compile it as a module, choose M here. The Parallax
275 dongle attaches to the normal 9-pin serial port connector, and can
276 currently only be used by IrTTY. To activate support for Parallax
277 dongles you will have to start irattach like this:
278 "irattach -d litelink".
279
280config MCP2120_DONGLE_OLD
281 tristate "Microchip MCP2120"
282 depends on DONGLE_OLD && IRDA
283 help
284 Say Y here if you want to build support for the Microchip MCP2120
285 dongle. To compile it as a module, choose M here. The MCP2120 dongle
286 attaches to the normal 9-pin serial port connector, and can
287 currently only be used by IrTTY. To activate support for MCP2120
288 dongles you will have to insert "irattach -d mcp2120" in the
289 /etc/irda/drivers script.
290
291 You must build this dongle yourself. For more information see:
292 <http://www.eyetap.org/~tangf/irda_sir_linux.html>
293
294config OLD_BELKIN_DONGLE_OLD
295 tristate "Old Belkin dongle"
296 depends on DONGLE_OLD && IRDA
297 help
298 Say Y here if you want to build support for the Adaptec Airport 1000
299 and 2000 dongles. To compile it as a module, choose M here: the module
300 will be called old_belkin. Some information is contained in the
301 comments at the top of <file:drivers/net/irda/old_belkin.c>.
302
303config ACT200L_DONGLE_OLD
304 tristate "ACTiSYS IR-200L dongle (EXPERIMENTAL)"
305 depends on DONGLE_OLD && EXPERIMENTAL && IRDA
306 help
307 Say Y here if you want to build support for the ACTiSYS IR-200L
308 dongle. To compile it as a module, choose M here. The ACTiSYS
309 IR-200L dongle attaches to the normal 9-pin serial port connector,
310 and can currently only be used by IrTTY. To activate support for
311 ACTiSYS IR-200L dongles you will have to start irattach like this:
312 "irattach -d act200l".
313
314config MA600_DONGLE_OLD
315 tristate "Mobile Action MA600 dongle (EXPERIMENTAL)"
316 depends on DONGLE_OLD && EXPERIMENTAL && IRDA
317 ---help---
318 Say Y here if you want to build support for the Mobile Action MA600
319 dongle. To compile it as a module, choose M here. The MA600 dongle
320 attaches to the normal 9-pin serial port connector, and can
321 currently only be tested on IrCOMM. To activate support for MA600
322 dongles you will have to insert "irattach -d ma600" in the
323 /etc/irda/drivers script. Note: irutils 0.9.15 requires no
324 modification. irutils 0.9.9 needs modification. For more
325 information, download the following tar gzip file.
326
327 There is a pre-compiled module on
328 <http://engsvr.ust.hk/~eetwl95/ma600.html>
329
330config EP7211_IR
331 tristate "EP7211 I/R support"
332 depends on DONGLE_OLD && ARCH_EP7211 && IRDA
333
334comment "FIR device drivers" 193comment "FIR device drivers"
335 194
336config USB_IRDA 195config USB_IRDA
diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile
index fefbb5909081..5d20fde32a24 100644
--- a/drivers/net/irda/Makefile
+++ b/drivers/net/irda/Makefile
@@ -5,8 +5,6 @@
5# Rewritten to use lists instead of if-statements. 5# Rewritten to use lists instead of if-statements.
6# 6#
7 7
8# Old SIR drivers
9obj-$(CONFIG_IRPORT_SIR) += irport.o
10# FIR drivers 8# FIR drivers
11obj-$(CONFIG_USB_IRDA) += irda-usb.o 9obj-$(CONFIG_USB_IRDA) += irda-usb.o
12obj-$(CONFIG_SIGMATEL_FIR) += stir4200.o 10obj-$(CONFIG_SIGMATEL_FIR) += stir4200.o
@@ -20,21 +18,10 @@ obj-$(CONFIG_VLSI_FIR) += vlsi_ir.o
20obj-$(CONFIG_VIA_FIR) += via-ircc.o 18obj-$(CONFIG_VIA_FIR) += via-ircc.o
21obj-$(CONFIG_PXA_FICP) += pxaficp_ir.o 19obj-$(CONFIG_PXA_FICP) += pxaficp_ir.o
22obj-$(CONFIG_MCS_FIR) += mcs7780.o 20obj-$(CONFIG_MCS_FIR) += mcs7780.o
23# Old dongle drivers for old SIR drivers
24obj-$(CONFIG_ESI_DONGLE_OLD) += esi.o
25obj-$(CONFIG_TEKRAM_DONGLE_OLD) += tekram.o
26obj-$(CONFIG_ACTISYS_DONGLE_OLD) += actisys.o
27obj-$(CONFIG_GIRBIL_DONGLE_OLD) += girbil.o
28obj-$(CONFIG_LITELINK_DONGLE_OLD) += litelink.o
29obj-$(CONFIG_OLD_BELKIN_DONGLE_OLD) += old_belkin.o
30obj-$(CONFIG_MCP2120_DONGLE_OLD) += mcp2120.o
31obj-$(CONFIG_ACT200L_DONGLE_OLD) += act200l.o
32obj-$(CONFIG_MA600_DONGLE_OLD) += ma600.o
33obj-$(CONFIG_EP7211_IR) += ep7211_ir.o
34obj-$(CONFIG_AU1000_FIR) += au1k_ir.o 21obj-$(CONFIG_AU1000_FIR) += au1k_ir.o
35# New SIR drivers 22# SIR drivers
36obj-$(CONFIG_IRTTY_SIR) += irtty-sir.o sir-dev.o 23obj-$(CONFIG_IRTTY_SIR) += irtty-sir.o sir-dev.o
37# New dongles drivers for new SIR drivers 24# dongle drivers for SIR drivers
38obj-$(CONFIG_ESI_DONGLE) += esi-sir.o 25obj-$(CONFIG_ESI_DONGLE) += esi-sir.o
39obj-$(CONFIG_TEKRAM_DONGLE) += tekram-sir.o 26obj-$(CONFIG_TEKRAM_DONGLE) += tekram-sir.o
40obj-$(CONFIG_ACTISYS_DONGLE) += actisys-sir.o 27obj-$(CONFIG_ACTISYS_DONGLE) += actisys-sir.o
diff --git a/drivers/net/irda/irport.c b/drivers/net/irda/irport.c
deleted file mode 100644
index c79caa5d3d71..000000000000
--- a/drivers/net/irda/irport.c
+++ /dev/null
@@ -1,1123 +0,0 @@
1/*********************************************************************
2 *
3 * Filename: irport.c
4 * Version: 1.0
5 * Description: Half duplex serial port SIR driver for IrDA.
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Aug 3 13:49:59 1997
9 * Modified at: Fri Jan 28 20:22:38 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 * Sources: serial.c by Linus Torvalds
12 *
13 * Copyright (c) 1997, 1998, 1999-2000 Dag Brattli, All Rights Reserved.
14 * Copyright (c) 2000-2003 Jean Tourrilhes, All Rights Reserved.
15 *
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation; either version 2 of
19 * the License, or (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 * MA 02111-1307 USA
30 *
31 * This driver is ment to be a small half duplex serial driver to be
32 * used for IR-chipsets that has a UART (16550) compatibility mode.
33 * Eventually it will replace irtty, because of irtty has some
34 * problems that is hard to get around when we don't have control
35 * over the serial driver. This driver may also be used by FIR
36 * drivers to handle SIR mode for them.
37 *
38 ********************************************************************/
39
40#include <linux/module.h>
41
42#include <linux/kernel.h>
43#include <linux/types.h>
44#include <linux/ioport.h>
45#include <linux/slab.h>
46#include <linux/string.h>
47#include <linux/skbuff.h>
48#include <linux/serial_reg.h>
49#include <linux/errno.h>
50#include <linux/init.h>
51#include <linux/spinlock.h>
52#include <linux/delay.h>
53#include <linux/rtnetlink.h>
54#include <linux/bitops.h>
55
56#include <asm/system.h>
57#include <asm/io.h>
58
59#include <net/irda/irda.h>
60#include <net/irda/wrapper.h>
61#include "irport.h"
62
63#define IO_EXTENT 8
64
65/*
66 * Currently you'll need to set these values using insmod like this:
67 * insmod irport io=0x3e8 irq=11
68 */
69static unsigned int io[] = { ~0, ~0, ~0, ~0 };
70static unsigned int irq[] = { 0, 0, 0, 0 };
71
72static unsigned int qos_mtt_bits = 0x03;
73
74static struct irport_cb *dev_self[] = { NULL, NULL, NULL, NULL};
75static char *driver_name = "irport";
76
77static inline void irport_write_wakeup(struct irport_cb *self);
78static inline int irport_write(int iobase, int fifo_size, __u8 *buf, int len);
79static inline void irport_receive(struct irport_cb *self);
80
81static int irport_net_ioctl(struct net_device *dev, struct ifreq *rq,
82 int cmd);
83static inline int irport_is_receiving(struct irport_cb *self);
84static int irport_set_dtr_rts(struct net_device *dev, int dtr, int rts);
85static int irport_raw_write(struct net_device *dev, __u8 *buf, int len);
86static struct net_device_stats *irport_net_get_stats(struct net_device *dev);
87static int irport_change_speed_complete(struct irda_task *task);
88static void irport_timeout(struct net_device *dev);
89
90static irqreturn_t irport_interrupt(int irq, void *dev_id);
91static int irport_hard_xmit(struct sk_buff *skb, struct net_device *dev);
92static void irport_change_speed(void *priv, __u32 speed);
93static int irport_net_open(struct net_device *dev);
94static int irport_net_close(struct net_device *dev);
95
96static struct irport_cb *
97irport_open(int i, unsigned int iobase, unsigned int irq)
98{
99 struct net_device *dev;
100 struct irport_cb *self;
101
102 IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
103
104 /* Lock the port that we need */
105 if (!request_region(iobase, IO_EXTENT, driver_name)) {
106 IRDA_DEBUG(0, "%s(), can't get iobase of 0x%03x\n",
107 __FUNCTION__, iobase);
108 goto err_out1;
109 }
110
111 /*
112 * Allocate new instance of the driver
113 */
114 dev = alloc_irdadev(sizeof(struct irport_cb));
115 if (!dev) {
116 IRDA_ERROR("%s(), can't allocate memory for "
117 "irda device!\n", __FUNCTION__);
118 goto err_out2;
119 }
120
121 self = dev->priv;
122 spin_lock_init(&self->lock);
123
124 /* Need to store self somewhere */
125 dev_self[i] = self;
126 self->priv = self;
127 self->index = i;
128
129 /* Initialize IO */
130 self->io.sir_base = iobase;
131 self->io.sir_ext = IO_EXTENT;
132 self->io.irq = irq;
133 self->io.fifo_size = 16; /* 16550A and compatible */
134
135 /* Initialize QoS for this device */
136 irda_init_max_qos_capabilies(&self->qos);
137
138 self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
139 IR_115200;
140
141 self->qos.min_turn_time.bits = qos_mtt_bits;
142 irda_qos_bits_to_value(&self->qos);
143
144 /* Bootstrap ZeroCopy Rx */
145 self->rx_buff.truesize = IRDA_SKB_MAX_MTU;
146 self->rx_buff.skb = __dev_alloc_skb(self->rx_buff.truesize,
147 GFP_KERNEL);
148 if (self->rx_buff.skb == NULL) {
149 IRDA_ERROR("%s(), can't allocate memory for "
150 "receive buffer!\n", __FUNCTION__);
151 goto err_out3;
152 }
153 skb_reserve(self->rx_buff.skb, 1);
154 self->rx_buff.head = self->rx_buff.skb->data;
155 /* No need to memset the buffer, unless you are really pedantic */
156
157 /* Finish setup the Rx buffer descriptor */
158 self->rx_buff.in_frame = FALSE;
159 self->rx_buff.state = OUTSIDE_FRAME;
160 self->rx_buff.data = self->rx_buff.head;
161
162 /* Specify how much memory we want */
163 self->tx_buff.truesize = 4000;
164
165 /* Allocate memory if needed */
166 if (self->tx_buff.truesize > 0) {
167 self->tx_buff.head = kzalloc(self->tx_buff.truesize,
168 GFP_KERNEL);
169 if (self->tx_buff.head == NULL) {
170 IRDA_ERROR("%s(), can't allocate memory for "
171 "transmit buffer!\n", __FUNCTION__);
172 goto err_out4;
173 }
174 }
175 self->tx_buff.data = self->tx_buff.head;
176
177 self->netdev = dev;
178
179 /* May be overridden by piggyback drivers */
180 self->interrupt = irport_interrupt;
181 self->change_speed = irport_change_speed;
182
183 /* Override the network functions we need to use */
184 dev->hard_start_xmit = irport_hard_xmit;
185 dev->tx_timeout = irport_timeout;
186 dev->watchdog_timeo = HZ; /* Allow time enough for speed change */
187 dev->open = irport_net_open;
188 dev->stop = irport_net_close;
189 dev->get_stats = irport_net_get_stats;
190 dev->do_ioctl = irport_net_ioctl;
191
192 /* Make ifconfig display some details */
193 dev->base_addr = iobase;
194 dev->irq = irq;
195
196 if (register_netdev(dev)) {
197 IRDA_ERROR("%s(), register_netdev() failed!\n", __FUNCTION__);
198 goto err_out5;
199 }
200 IRDA_MESSAGE("IrDA: Registered device %s (irport io=0x%X irq=%d)\n",
201 dev->name, iobase, irq);
202
203 return self;
204 err_out5:
205 kfree(self->tx_buff.head);
206 err_out4:
207 kfree_skb(self->rx_buff.skb);
208 err_out3:
209 free_netdev(dev);
210 dev_self[i] = NULL;
211 err_out2:
212 release_region(iobase, IO_EXTENT);
213 err_out1:
214 return NULL;
215}
216
217static int irport_close(struct irport_cb *self)
218{
219 IRDA_ASSERT(self != NULL, return -1;);
220
221 /* We are not using any dongle anymore! */
222 if (self->dongle)
223 irda_device_dongle_cleanup(self->dongle);
224 self->dongle = NULL;
225
226 /* Remove netdevice */
227 unregister_netdev(self->netdev);
228
229 /* Release the IO-port that this driver is using */
230 IRDA_DEBUG(0 , "%s(), Releasing Region %03x\n",
231 __FUNCTION__, self->io.sir_base);
232 release_region(self->io.sir_base, self->io.sir_ext);
233
234 kfree(self->tx_buff.head);
235
236 if (self->rx_buff.skb)
237 kfree_skb(self->rx_buff.skb);
238 self->rx_buff.skb = NULL;
239
240 /* Remove ourselves */
241 dev_self[self->index] = NULL;
242 free_netdev(self->netdev);
243
244 return 0;
245}
246
247static void irport_stop(struct irport_cb *self)
248{
249 int iobase;
250
251 iobase = self->io.sir_base;
252
253 /* We can't lock, we may be called from a FIR driver - Jean II */
254
255 /* We are not transmitting any more */
256 self->transmitting = 0;
257
258 /* Reset UART */
259 outb(0, iobase+UART_MCR);
260
261 /* Turn off interrupts */
262 outb(0, iobase+UART_IER);
263}
264
265static void irport_start(struct irport_cb *self)
266{
267 int iobase;
268
269 iobase = self->io.sir_base;
270
271 irport_stop(self);
272
273 /* We can't lock, we may be called from a FIR driver - Jean II */
274
275 /* Initialize UART */
276 outb(UART_LCR_WLEN8, iobase+UART_LCR); /* Reset DLAB */
277 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase+UART_MCR);
278
279 /* Turn on interrups */
280 outb(UART_IER_RLSI | UART_IER_RDI |UART_IER_THRI, iobase+UART_IER);
281}
282
283/*
284 * Function irport_get_fcr (speed)
285 *
286 * Compute value of fcr
287 *
288 */
289static inline unsigned int irport_get_fcr(__u32 speed)
290{
291 unsigned int fcr; /* FIFO control reg */
292
293 /* Enable fifos */
294 fcr = UART_FCR_ENABLE_FIFO;
295
296 /*
297 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
298 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
299 * about this timeout since it will always be fast enough.
300 */
301 if (speed < 38400)
302 fcr |= UART_FCR_TRIGGER_1;
303 else
304 //fcr |= UART_FCR_TRIGGER_14;
305 fcr |= UART_FCR_TRIGGER_8;
306
307 return(fcr);
308}
309
310/*
311 * Function irport_change_speed (self, speed)
312 *
313 * Set speed of IrDA port to specified baudrate
314 *
315 * This function should be called with irq off and spin-lock.
316 */
317static void irport_change_speed(void *priv, __u32 speed)
318{
319 struct irport_cb *self = (struct irport_cb *) priv;
320 int iobase;
321 unsigned int fcr; /* FIFO control reg */
322 unsigned int lcr; /* Line control reg */
323 int divisor;
324
325 IRDA_ASSERT(self != NULL, return;);
326 IRDA_ASSERT(speed != 0, return;);
327
328 IRDA_DEBUG(1, "%s(), Setting speed to: %d - iobase=%#x\n",
329 __FUNCTION__, speed, self->io.sir_base);
330
331 /* We can't lock, we may be called from a FIR driver - Jean II */
332
333 iobase = self->io.sir_base;
334
335 /* Update accounting for new speed */
336 self->io.speed = speed;
337
338 /* Turn off interrupts */
339 outb(0, iobase+UART_IER);
340
341 divisor = SPEED_MAX/speed;
342
343 /* Get proper fifo configuration */
344 fcr = irport_get_fcr(speed);
345
346 /* IrDA ports use 8N1 */
347 lcr = UART_LCR_WLEN8;
348
349 outb(UART_LCR_DLAB | lcr, iobase+UART_LCR); /* Set DLAB */
350 outb(divisor & 0xff, iobase+UART_DLL); /* Set speed */
351 outb(divisor >> 8, iobase+UART_DLM);
352 outb(lcr, iobase+UART_LCR); /* Set 8N1 */
353 outb(fcr, iobase+UART_FCR); /* Enable FIFO's */
354
355 /* Turn on interrups */
356 /* This will generate a fatal interrupt storm.
357 * People calling us will do that properly - Jean II */
358 //outb(/*UART_IER_RLSI|*/UART_IER_RDI/*|UART_IER_THRI*/, iobase+UART_IER);
359}
360
361/*
362 * Function __irport_change_speed (instance, state, param)
363 *
364 * State machine for changing speed of the device. We do it this way since
365 * we cannot use schedule_timeout() when we are in interrupt context
366 *
367 */
368static int __irport_change_speed(struct irda_task *task)
369{
370 struct irport_cb *self;
371 __u32 speed = (__u32) task->param;
372 unsigned long flags = 0;
373 int wasunlocked = 0;
374 int ret = 0;
375
376 IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies);
377
378 self = (struct irport_cb *) task->instance;
379
380 IRDA_ASSERT(self != NULL, return -1;);
381
382 /* Locking notes : this function may be called from irq context with
383 * spinlock, via irport_write_wakeup(), or from non-interrupt without
384 * spinlock (from the task timer). Yuck !
385 * This is ugly, and unsafe is the spinlock is not already acquired.
386 * This will be fixed when irda-task get rewritten.
387 * Jean II */
388 if (!spin_is_locked(&self->lock)) {
389 spin_lock_irqsave(&self->lock, flags);
390 wasunlocked = 1;
391 }
392
393 switch (task->state) {
394 case IRDA_TASK_INIT:
395 case IRDA_TASK_WAIT:
396 /* Are we ready to change speed yet? */
397 if (self->tx_buff.len > 0) {
398 task->state = IRDA_TASK_WAIT;
399
400 /* Try again later */
401 ret = msecs_to_jiffies(20);
402 break;
403 }
404
405 if (self->dongle)
406 irda_task_next_state(task, IRDA_TASK_CHILD_INIT);
407 else
408 irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
409 break;
410 case IRDA_TASK_CHILD_INIT:
411 /* Go to default speed */
412 self->change_speed(self->priv, 9600);
413
414 /* Change speed of dongle */
415 if (irda_task_execute(self->dongle,
416 self->dongle->issue->change_speed,
417 NULL, task, (void *) speed))
418 {
419 /* Dongle need more time to change its speed */
420 irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
421
422 /* Give dongle 1 sec to finish */
423 ret = msecs_to_jiffies(1000);
424 } else
425 /* Child finished immediately */
426 irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
427 break;
428 case IRDA_TASK_CHILD_WAIT:
429 IRDA_WARNING("%s(), changing speed of dongle timed out!\n", __FUNCTION__);
430 ret = -1;
431 break;
432 case IRDA_TASK_CHILD_DONE:
433 /* Finally we are ready to change the speed */
434 self->change_speed(self->priv, speed);
435
436 irda_task_next_state(task, IRDA_TASK_DONE);
437 break;
438 default:
439 IRDA_ERROR("%s(), unknown state %d\n",
440 __FUNCTION__, task->state);
441 irda_task_next_state(task, IRDA_TASK_DONE);
442 ret = -1;
443 break;
444 }
445 /* Put stuff in the state we found them - Jean II */
446 if(wasunlocked) {
447 spin_unlock_irqrestore(&self->lock, flags);
448 }
449
450 return ret;
451}
452
453/*
454 * Function irport_change_speed_complete (task)
455 *
456 * Called when the change speed operation completes
457 *
458 */
459static int irport_change_speed_complete(struct irda_task *task)
460{
461 struct irport_cb *self;
462
463 IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
464
465 self = (struct irport_cb *) task->instance;
466
467 IRDA_ASSERT(self != NULL, return -1;);
468 IRDA_ASSERT(self->netdev != NULL, return -1;);
469
470 /* Finished changing speed, so we are not busy any longer */
471 /* Signal network layer so it can try to send the frame */
472
473 netif_wake_queue(self->netdev);
474
475 return 0;
476}
477
478/*
479 * Function irport_timeout (struct net_device *dev)
480 *
481 * The networking layer thinks we timed out.
482 *
483 */
484
485static void irport_timeout(struct net_device *dev)
486{
487 struct irport_cb *self;
488 int iobase;
489 int iir, lsr;
490 unsigned long flags;
491
492 self = (struct irport_cb *) dev->priv;
493 IRDA_ASSERT(self != NULL, return;);
494 iobase = self->io.sir_base;
495
496 IRDA_WARNING("%s: transmit timed out, jiffies = %ld, trans_start = %ld\n",
497 dev->name, jiffies, dev->trans_start);
498 spin_lock_irqsave(&self->lock, flags);
499
500 /* Debug what's happening... */
501
502 /* Get interrupt status */
503 lsr = inb(iobase+UART_LSR);
504 /* Read interrupt register */
505 iir = inb(iobase+UART_IIR);
506 IRDA_DEBUG(0, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n",
507 __FUNCTION__, iir, lsr, iobase);
508
509 IRDA_DEBUG(0, "%s(), transmitting=%d, remain=%d, done=%td\n",
510 __FUNCTION__, self->transmitting, self->tx_buff.len,
511 self->tx_buff.data - self->tx_buff.head);
512
513 /* Now, restart the port */
514 irport_start(self);
515 self->change_speed(self->priv, self->io.speed);
516 /* This will re-enable irqs */
517 outb(/*UART_IER_RLSI|*/UART_IER_RDI/*|UART_IER_THRI*/, iobase+UART_IER);
518 dev->trans_start = jiffies;
519 spin_unlock_irqrestore(&self->lock, flags);
520
521 netif_wake_queue(dev);
522}
523
524/*
525 * Function irport_wait_hw_transmitter_finish ()
526 *
527 * Wait for the real end of HW transmission
528 *
529 * The UART is a strict FIFO, and we get called only when we have finished
530 * pushing data to the FIFO, so the maximum amount of time we must wait
531 * is only for the FIFO to drain out.
532 *
533 * We use a simple calibrated loop. We may need to adjust the loop
534 * delay (udelay) to balance I/O traffic and latency. And we also need to
535 * adjust the maximum timeout.
536 * It would probably be better to wait for the proper interrupt,
537 * but it doesn't seem to be available.
538 *
539 * We can't use jiffies or kernel timers because :
540 * 1) We are called from the interrupt handler, which disable softirqs,
541 * so jiffies won't be increased
542 * 2) Jiffies granularity is usually very coarse (10ms), and we don't
543 * want to wait that long to detect stuck hardware.
544 * Jean II
545 */
546
547static void irport_wait_hw_transmitter_finish(struct irport_cb *self)
548{
549 int iobase;
550 int count = 1000; /* 1 ms */
551
552 iobase = self->io.sir_base;
553
554 /* Calibrated busy loop */
555 while((count-- > 0) && !(inb(iobase+UART_LSR) & UART_LSR_TEMT))
556 udelay(1);
557
558 if(count == 0)
559 IRDA_DEBUG(0, "%s(): stuck transmitter\n", __FUNCTION__);
560}
561
562/*
563 * Function irport_hard_start_xmit (struct sk_buff *skb, struct net_device *dev)
564 *
565 * Transmits the current frame until FIFO is full, then
566 * waits until the next transmitt interrupt, and continues until the
567 * frame is transmitted.
568 */
569static int irport_hard_xmit(struct sk_buff *skb, struct net_device *dev)
570{
571 struct irport_cb *self;
572 unsigned long flags;
573 int iobase;
574 s32 speed;
575
576 IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
577
578 IRDA_ASSERT(dev != NULL, return 0;);
579
580 self = (struct irport_cb *) dev->priv;
581 IRDA_ASSERT(self != NULL, return 0;);
582
583 iobase = self->io.sir_base;
584
585 netif_stop_queue(dev);
586
587 /* Make sure tests & speed change are atomic */
588 spin_lock_irqsave(&self->lock, flags);
589
590 /* Check if we need to change the speed */
591 speed = irda_get_next_speed(skb);
592 if ((speed != self->io.speed) && (speed != -1)) {
593 /* Check for empty frame */
594 if (!skb->len) {
595 /*
596 * We send frames one by one in SIR mode (no
597 * pipelining), so at this point, if we were sending
598 * a previous frame, we just received the interrupt
599 * telling us it is finished (UART_IIR_THRI).
600 * Therefore, waiting for the transmitter to really
601 * finish draining the fifo won't take too long.
602 * And the interrupt handler is not expected to run.
603 * - Jean II */
604 irport_wait_hw_transmitter_finish(self);
605 /* Better go there already locked - Jean II */
606 irda_task_execute(self, __irport_change_speed,
607 irport_change_speed_complete,
608 NULL, (void *) speed);
609 dev->trans_start = jiffies;
610 spin_unlock_irqrestore(&self->lock, flags);
611 dev_kfree_skb(skb);
612 return 0;
613 } else
614 self->new_speed = speed;
615 }
616
617 /* Init tx buffer */
618 self->tx_buff.data = self->tx_buff.head;
619
620 /* Copy skb to tx_buff while wrapping, stuffing and making CRC */
621 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data,
622 self->tx_buff.truesize);
623
624 self->stats.tx_bytes += self->tx_buff.len;
625
626 /* We are transmitting */
627 self->transmitting = 1;
628
629 /* Turn on transmit finished interrupt. Will fire immediately! */
630 outb(UART_IER_THRI, iobase+UART_IER);
631
632 dev->trans_start = jiffies;
633 spin_unlock_irqrestore(&self->lock, flags);
634
635 dev_kfree_skb(skb);
636
637 return 0;
638}
639
640/*
641 * Function irport_write (driver)
642 *
643 * Fill Tx FIFO with transmit data
644 *
645 * Called only from irport_write_wakeup()
646 */
647static inline int irport_write(int iobase, int fifo_size, __u8 *buf, int len)
648{
649 int actual = 0;
650
651 /* Fill FIFO with current frame */
652 while ((actual < fifo_size) && (actual < len)) {
653 /* Transmit next byte */
654 outb(buf[actual], iobase+UART_TX);
655
656 actual++;
657 }
658
659 return actual;
660}
661
662/*
663 * Function irport_write_wakeup (tty)
664 *
665 * Called by the driver when there's room for more data. If we have
666 * more packets to send, we send them here.
667 *
668 * Called only from irport_interrupt()
669 * Make sure this function is *not* called while we are receiving,
670 * otherwise we will reset fifo and loose data :-(
671 */
672static inline void irport_write_wakeup(struct irport_cb *self)
673{
674 int actual = 0;
675 int iobase;
676 unsigned int fcr;
677
678 IRDA_ASSERT(self != NULL, return;);
679
680 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
681
682 iobase = self->io.sir_base;
683
684 /* Finished with frame? */
685 if (self->tx_buff.len > 0) {
686 /* Write data left in transmit buffer */
687 actual = irport_write(iobase, self->io.fifo_size,
688 self->tx_buff.data, self->tx_buff.len);
689 self->tx_buff.data += actual;
690 self->tx_buff.len -= actual;
691 } else {
692 /*
693 * Now serial buffer is almost free & we can start
694 * transmission of another packet. But first we must check
695 * if we need to change the speed of the hardware
696 */
697 if (self->new_speed) {
698 irport_wait_hw_transmitter_finish(self);
699 irda_task_execute(self, __irport_change_speed,
700 irport_change_speed_complete,
701 NULL, (void *) self->new_speed);
702 self->new_speed = 0;
703 } else {
704 /* Tell network layer that we want more frames */
705 netif_wake_queue(self->netdev);
706 }
707 self->stats.tx_packets++;
708
709 /*
710 * Reset Rx FIFO to make sure that all reflected transmit data
711 * is discarded. This is needed for half duplex operation
712 */
713 fcr = irport_get_fcr(self->io.speed);
714 fcr |= UART_FCR_CLEAR_RCVR;
715 outb(fcr, iobase+UART_FCR);
716
717 /* Finished transmitting */
718 self->transmitting = 0;
719
720 /* Turn on receive interrupts */
721 outb(UART_IER_RDI, iobase+UART_IER);
722
723 IRDA_DEBUG(1, "%s() : finished Tx\n", __FUNCTION__);
724 }
725}
726
727/*
728 * Function irport_receive (self)
729 *
730 * Receive one frame from the infrared port
731 *
732 * Called only from irport_interrupt()
733 */
734static inline void irport_receive(struct irport_cb *self)
735{
736 int boguscount = 0;
737 int iobase;
738
739 IRDA_ASSERT(self != NULL, return;);
740
741 iobase = self->io.sir_base;
742
743 /*
744 * Receive all characters in Rx FIFO, unwrap and unstuff them.
745 * async_unwrap_char will deliver all found frames
746 */
747 do {
748 async_unwrap_char(self->netdev, &self->stats, &self->rx_buff,
749 inb(iobase+UART_RX));
750
751 /* Make sure we don't stay here too long */
752 if (boguscount++ > 32) {
753 IRDA_DEBUG(2,"%s(), breaking!\n", __FUNCTION__);
754 break;
755 }
756 } while (inb(iobase+UART_LSR) & UART_LSR_DR);
757}
758
759/*
760 * Function irport_interrupt (irq, dev_id)
761 *
762 * Interrupt handler
763 */
764static irqreturn_t irport_interrupt(int irq, void *dev_id)
765{
766 struct net_device *dev = dev_id;
767 struct irport_cb *self;
768 int boguscount = 0;
769 int iobase;
770 int iir, lsr;
771 int handled = 0;
772
773 self = dev->priv;
774
775 spin_lock(&self->lock);
776
777 iobase = self->io.sir_base;
778
779 /* Cut'n'paste interrupt routine from serial.c
780 * This version try to minimise latency and I/O operations.
781 * Simplified and modified to enforce half duplex operation.
782 * - Jean II */
783
784 /* Check status even is iir reg is cleared, more robust and
785 * eliminate a read on the I/O bus - Jean II */
786 do {
787 /* Get interrupt status ; Clear interrupt */
788 lsr = inb(iobase+UART_LSR);
789
790 /* Are we receiving or transmitting ? */
791 if(!self->transmitting) {
792 /* Received something ? */
793 if (lsr & UART_LSR_DR)
794 irport_receive(self);
795 } else {
796 /* Room in Tx fifo ? */
797 if (lsr & (UART_LSR_THRE | UART_LSR_TEMT))
798 irport_write_wakeup(self);
799 }
800
801 /* A bit hackish, but working as expected... Jean II */
802 if(lsr & (UART_LSR_THRE | UART_LSR_TEMT | UART_LSR_DR))
803 handled = 1;
804
805 /* Make sure we don't stay here to long */
806 if (boguscount++ > 10) {
807 IRDA_WARNING("%s() irq handler looping : lsr=%02x\n",
808 __FUNCTION__, lsr);
809 break;
810 }
811
812 /* Read interrupt register */
813 iir = inb(iobase+UART_IIR);
814
815 /* Enable this debug only when no other options and at low
816 * bit rates, otherwise it may cause Rx overruns (lsr=63).
817 * - Jean II */
818 IRDA_DEBUG(6, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n",
819 __FUNCTION__, iir, lsr, iobase);
820
821 /* As long as interrupt pending... */
822 } while ((iir & UART_IIR_NO_INT) == 0);
823
824 spin_unlock(&self->lock);
825 return IRQ_RETVAL(handled);
826}
827
828/*
829 * Function irport_net_open (dev)
830 *
831 * Network device is taken up. Usually this is done by "ifconfig irda0 up"
832 *
833 */
834static int irport_net_open(struct net_device *dev)
835{
836 struct irport_cb *self;
837 int iobase;
838 char hwname[16];
839 unsigned long flags;
840
841 IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
842
843 IRDA_ASSERT(dev != NULL, return -1;);
844 self = (struct irport_cb *) dev->priv;
845
846 iobase = self->io.sir_base;
847
848 if (request_irq(self->io.irq, self->interrupt, 0, dev->name,
849 (void *) dev)) {
850 IRDA_DEBUG(0, "%s(), unable to allocate irq=%d\n",
851 __FUNCTION__, self->io.irq);
852 return -EAGAIN;
853 }
854
855 spin_lock_irqsave(&self->lock, flags);
856 /* Init uart */
857 irport_start(self);
858 /* Set 9600 bauds per default, including at the dongle */
859 irda_task_execute(self, __irport_change_speed,
860 irport_change_speed_complete,
861 NULL, (void *) 9600);
862 spin_unlock_irqrestore(&self->lock, flags);
863
864
865 /* Give self a hardware name */
866 sprintf(hwname, "SIR @ 0x%03x", self->io.sir_base);
867
868 /*
869 * Open new IrLAP layer instance, now that everything should be
870 * initialized properly
871 */
872 self->irlap = irlap_open(dev, &self->qos, hwname);
873
874 /* Ready to play! */
875
876 netif_start_queue(dev);
877
878 return 0;
879}
880
881/*
882 * Function irport_net_close (self)
883 *
884 * Network device is taken down. Usually this is done by
885 * "ifconfig irda0 down"
886 */
887static int irport_net_close(struct net_device *dev)
888{
889 struct irport_cb *self;
890 int iobase;
891 unsigned long flags;
892
893 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
894
895 IRDA_ASSERT(dev != NULL, return -1;);
896 self = (struct irport_cb *) dev->priv;
897
898 IRDA_ASSERT(self != NULL, return -1;);
899
900 iobase = self->io.sir_base;
901
902 /* Stop device */
903 netif_stop_queue(dev);
904
905 /* Stop and remove instance of IrLAP */
906 if (self->irlap)
907 irlap_close(self->irlap);
908 self->irlap = NULL;
909
910 spin_lock_irqsave(&self->lock, flags);
911 irport_stop(self);
912 spin_unlock_irqrestore(&self->lock, flags);
913
914 free_irq(self->io.irq, dev);
915
916 return 0;
917}
918
919/*
920 * Function irport_is_receiving (self)
921 *
922 * Returns true is we are currently receiving data
923 *
924 */
925static inline int irport_is_receiving(struct irport_cb *self)
926{
927 return (self->rx_buff.state != OUTSIDE_FRAME);
928}
929
930/*
931 * Function irport_set_dtr_rts (tty, dtr, rts)
932 *
933 * This function can be used by dongles etc. to set or reset the status
934 * of the dtr and rts lines
935 */
936static int irport_set_dtr_rts(struct net_device *dev, int dtr, int rts)
937{
938 struct irport_cb *self = dev->priv;
939 int iobase;
940
941 IRDA_ASSERT(self != NULL, return -1;);
942
943 iobase = self->io.sir_base;
944
945 if (dtr)
946 dtr = UART_MCR_DTR;
947 if (rts)
948 rts = UART_MCR_RTS;
949
950 outb(dtr|rts|UART_MCR_OUT2, iobase+UART_MCR);
951
952 return 0;
953}
954
955static int irport_raw_write(struct net_device *dev, __u8 *buf, int len)
956{
957 struct irport_cb *self = (struct irport_cb *) dev->priv;
958 int actual = 0;
959 int iobase;
960
961 IRDA_ASSERT(self != NULL, return -1;);
962
963 iobase = self->io.sir_base;
964
965 /* Tx FIFO should be empty! */
966 if (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) {
967 IRDA_DEBUG( 0, "%s(), failed, fifo not empty!\n", __FUNCTION__);
968 return -1;
969 }
970
971 /* Fill FIFO with current frame */
972 while (actual < len) {
973 /* Transmit next byte */
974 outb(buf[actual], iobase+UART_TX);
975 actual++;
976 }
977
978 return actual;
979}
980
981/*
982 * Function irport_net_ioctl (dev, rq, cmd)
983 *
984 * Process IOCTL commands for this device
985 *
986 */
987static int irport_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
988{
989 struct if_irda_req *irq = (struct if_irda_req *) rq;
990 struct irport_cb *self;
991 dongle_t *dongle;
992 unsigned long flags;
993 int ret = 0;
994
995 IRDA_ASSERT(dev != NULL, return -1;);
996
997 self = dev->priv;
998
999 IRDA_ASSERT(self != NULL, return -1;);
1000
1001 IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
1002
1003 switch (cmd) {
1004 case SIOCSBANDWIDTH: /* Set bandwidth */
1005 if (!capable(CAP_NET_ADMIN))
1006 ret = -EPERM;
1007 else
1008 irda_task_execute(self, __irport_change_speed, NULL,
1009 NULL, (void *) irq->ifr_baudrate);
1010 break;
1011 case SIOCSDONGLE: /* Set dongle */
1012 if (!capable(CAP_NET_ADMIN)) {
1013 ret = -EPERM;
1014 break;
1015 }
1016
1017 /* Locking :
1018 * irda_device_dongle_init() can't be locked.
1019 * irda_task_execute() doesn't need to be locked.
1020 * Jean II
1021 */
1022
1023 /* Initialize dongle */
1024 dongle = irda_device_dongle_init(dev, irq->ifr_dongle);
1025 if (!dongle)
1026 break;
1027
1028 dongle->set_mode = NULL;
1029 dongle->read = NULL;
1030 dongle->write = irport_raw_write;
1031 dongle->set_dtr_rts = irport_set_dtr_rts;
1032
1033 /* Now initialize the dongle! */
1034 dongle->issue->open(dongle, &self->qos);
1035
1036 /* Reset dongle */
1037 irda_task_execute(dongle, dongle->issue->reset, NULL, NULL,
1038 NULL);
1039
1040 /* Make dongle available to driver only now to avoid
1041 * race conditions - Jean II */
1042 self->dongle = dongle;
1043 break;
1044 case SIOCSMEDIABUSY: /* Set media busy */
1045 if (!capable(CAP_NET_ADMIN)) {
1046 ret = -EPERM;
1047 break;
1048 }
1049
1050 irda_device_set_media_busy(self->netdev, TRUE);
1051 break;
1052 case SIOCGRECEIVING: /* Check if we are receiving right now */
1053 irq->ifr_receiving = irport_is_receiving(self);
1054 break;
1055 case SIOCSDTRRTS:
1056 if (!capable(CAP_NET_ADMIN)) {
1057 ret = -EPERM;
1058 break;
1059 }
1060
1061 /* No real need to lock... */
1062 spin_lock_irqsave(&self->lock, flags);
1063 irport_set_dtr_rts(dev, irq->ifr_dtr, irq->ifr_rts);
1064 spin_unlock_irqrestore(&self->lock, flags);
1065 break;
1066 default:
1067 ret = -EOPNOTSUPP;
1068 }
1069
1070 return ret;
1071}
1072
1073static struct net_device_stats *irport_net_get_stats(struct net_device *dev)
1074{
1075 struct irport_cb *self = (struct irport_cb *) dev->priv;
1076
1077 return &self->stats;
1078}
1079
1080static int __init irport_init(void)
1081{
1082 int i;
1083
1084 for (i=0; (io[i] < 2000) && (i < ARRAY_SIZE(dev_self)); i++) {
1085 if (irport_open(i, io[i], irq[i]) != NULL)
1086 return 0;
1087 }
1088 /*
1089 * Maybe something failed, but we can still be usable for FIR drivers
1090 */
1091 return 0;
1092}
1093
1094/*
1095 * Function irport_cleanup ()
1096 *
1097 * Close all configured ports
1098 *
1099 */
1100static void __exit irport_cleanup(void)
1101{
1102 int i;
1103
1104 IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
1105
1106 for (i=0; i < ARRAY_SIZE(dev_self); i++) {
1107 if (dev_self[i])
1108 irport_close(dev_self[i]);
1109 }
1110}
1111
1112module_param_array(io, int, NULL, 0);
1113MODULE_PARM_DESC(io, "Base I/O addresses");
1114module_param_array(irq, int, NULL, 0);
1115MODULE_PARM_DESC(irq, "IRQ lines");
1116
1117MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1118MODULE_DESCRIPTION("Half duplex serial driver for IrDA SIR mode");
1119MODULE_LICENSE("GPL");
1120
1121module_init(irport_init);
1122module_exit(irport_cleanup);
1123
diff --git a/drivers/net/irda/irport.h b/drivers/net/irda/irport.h
deleted file mode 100644
index 39829cffba13..000000000000
--- a/drivers/net/irda/irport.h
+++ /dev/null
@@ -1,80 +0,0 @@
1/*********************************************************************
2 *
3 * Filename: irport.h
4 * Version: 0.1
5 * Description: Serial driver for IrDA
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Aug 3 13:49:59 1997
9 * Modified at: Fri Jan 14 10:21:10 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 *
12 * Copyright (c) 1997, 1998-2000 Dag Brattli <dagb@cs.uit.no>
13 * All Rights Reserved.
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of
18 * the License, or (at your option) any later version.
19 *
20 * Neither Dag Brattli nor University of Tromsø admit liability nor
21 * provide warranty for any of this software. This material is
22 * provided "AS-IS" and at no charge.
23 *
24 ********************************************************************/
25
26#ifndef IRPORT_H
27#define IRPORT_H
28
29#include <linux/netdevice.h>
30#include <linux/skbuff.h>
31#include <linux/types.h>
32#include <linux/spinlock.h>
33
34#include <net/irda/irda_device.h>
35
36#define SPEED_DEFAULT 9600
37#define SPEED_MAX 115200
38
39/*
40 * These are the supported serial types.
41 */
42#define PORT_UNKNOWN 0
43#define PORT_8250 1
44#define PORT_16450 2
45#define PORT_16550 3
46#define PORT_16550A 4
47#define PORT_CIRRUS 5
48#define PORT_16650 6
49#define PORT_MAX 6
50
51#define FRAME_MAX_SIZE 2048
52
53struct irport_cb {
54 struct net_device *netdev; /* Yes! we are some kind of netdevice */
55 struct net_device_stats stats;
56
57 struct irlap_cb *irlap; /* The link layer we are attached to */
58
59 chipio_t io; /* IrDA controller information */
60 iobuff_t tx_buff; /* Transmit buffer */
61 iobuff_t rx_buff; /* Receive buffer */
62
63 struct qos_info qos; /* QoS capabilities for this device */
64 dongle_t *dongle; /* Dongle driver */
65
66 __u32 flags; /* Interface flags */
67 __u32 new_speed;
68 int mode;
69 int index; /* Instance index */
70 int transmitting; /* Are we transmitting ? */
71
72 spinlock_t lock; /* For serializing operations */
73
74 /* For piggyback drivers */
75 void *priv;
76 void (*change_speed)(void *priv, __u32 speed);
77 irq_handler_t interrupt;
78};
79
80#endif /* IRPORT_H */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-28 00:13:19 -0500