| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20080118064655.GA3063@sortiz.org>
Date: Fri, 18 Jan 2008 07:46:56 +0100
From: Samuel Ortiz <samuel@...tiz.org>
To: Adrian Bunk <bunk@...nel.org>
Cc: netdev@...r.kernel.org
Subject: Re: [RFC: 2.6 patch] remove IrPORT and the old dongle drivers
Hi Adrian,
On Tue, Jan 01, 2008 at 03:48:51PM +0200, Adrian Bunk wrote:
> This patch removes IrPORT and the old dongle drivers (all off them
> have replacement drivers).
This patch looks good, yes. I'll schedule it for after 2.6.24, as I'd rather
not seeing this kind of patch to appear in a major release with users not
being warned in advance.
Thanks for the patch.
Cheers,
Samuel.
> Signed-off-by: Adrian Bunk <bunk@...nel.org>
>
> ---
>
> This patch has been sent on:
> - 24 Oct 2007
>
> drivers/net/irda/Kconfig | 141 ----
> drivers/net/irda/Makefile | 17
> drivers/net/irda/act200l.c | 297 --------
> drivers/net/irda/actisys.c | 288 --------
> drivers/net/irda/ep7211_ir.c | 125 ---
> drivers/net/irda/esi.c | 149 ----
> drivers/net/irda/girbil.c | 250 -------
> drivers/net/irda/irport.c | 1123 ---------------------------------
> drivers/net/irda/irport.h | 80 --
> drivers/net/irda/litelink.c | 179 -----
> drivers/net/irda/ma600.c | 354 ----------
> drivers/net/irda/mcp2120.c | 240 -------
> drivers/net/irda/old_belkin.c | 164 ----
> drivers/net/irda/tekram.c | 282 --------
> include/net/irda/irda_device.h | 13
> net/irda/irda_device.c | 169 ----
> 16 files changed, 3 insertions(+), 3868 deletions(-)
>
> dd727730309f6f76bafda7e69e3a3258a427e11c
> diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
> index 6580695..ce816ba 100644
> --- a/drivers/net/irda/Kconfig
> +++ b/drivers/net/irda/Kconfig
> @@ -190,147 +190,6 @@ config KS959_DONGLE
> To compile it as a module, choose M here: the module will be called
> ks959-sir.
>
> -comment "Old SIR device drivers"
> -
> -config IRPORT_SIR
> - tristate "IrPORT (IrDA serial driver)"
> - depends on IRDA && BROKEN_ON_SMP
> - ---help---
> - Say Y here if you want to build support for the IrPORT IrDA device
> - driver. To compile it as a module, choose M here: the module will be
> - called irport. IrPORT can be used instead of IrTTY and sometimes
> - this can be better. One example is if your IrDA port does not
> - have echo-canceling, which will work OK with IrPORT since this
> - driver is working in half-duplex mode only. You don't need to use
> - irattach with IrPORT, but you just insert it the same way as FIR
> - drivers (insmod irport io=0x3e8 irq=11). Notice that IrPORT is a
> - SIR device driver which means that speed is limited to 115200 bps.
> -
> - If unsure, say Y.
> -
> -comment "Old Serial dongle support"
> -
> -config DONGLE_OLD
> - bool "Old Serial dongle support"
> - depends on IRPORT_SIR && BROKEN_ON_SMP
> - help
> - Say Y here if you have an infrared device that connects to your
> - computer's serial port. These devices are called dongles. Then say Y
> - or M to the driver for your particular dongle below.
> -
> - Note that the answer to this question won't directly affect the
> - kernel: saying N will just cause the configurator to skip all
> - the questions about serial dongles.
> -
> -config ESI_DONGLE_OLD
> - tristate "ESI JetEye PC dongle"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the Extended Systems
> - JetEye PC dongle. To compile it as a module, choose M here. The ESI
> - dongle attaches to the normal 9-pin serial port connector, and can
> - currently only be used by IrTTY. To activate support for ESI
> - dongles you will have to start irattach like this:
> - "irattach -d esi".
> -
> -config ACTISYS_DONGLE_OLD
> - tristate "ACTiSYS IR-220L and IR220L+ dongle"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the ACTiSYS IR-220L and
> - IR220L+ dongles. To compile it as a module, choose M here. The
> - ACTiSYS dongles attaches to the normal 9-pin serial port connector,
> - and can currently only be used by IrTTY. To activate support for
> - ACTiSYS dongles you will have to start irattach like this:
> - "irattach -d actisys" or "irattach -d actisys+".
> -
> -config TEKRAM_DONGLE_OLD
> - tristate "Tekram IrMate 210B dongle"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the Tekram IrMate 210B
> - dongle. To compile it as a module, choose M here. The Tekram dongle
> - attaches to the normal 9-pin serial port connector, and can
> - currently only be used by IrTTY. To activate support for Tekram
> - dongles you will have to start irattach like this:
> - "irattach -d tekram".
> -
> -config GIRBIL_DONGLE_OLD
> - tristate "Greenwich GIrBIL dongle"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the Greenwich GIrBIL
> - dongle. To compile it as a module, choose M here. The Greenwich
> - dongle attaches to the normal 9-pin serial port connector, and can
> - currently only be used by IrTTY. To activate support for Greenwich
> - dongles you will have to insert "irattach -d girbil" in the
> - /etc/irda/drivers script.
> -
> -config LITELINK_DONGLE_OLD
> - tristate "Parallax LiteLink dongle"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the Parallax Litelink
> - dongle. To compile it as a module, choose M here. The Parallax
> - dongle attaches to the normal 9-pin serial port connector, and can
> - currently only be used by IrTTY. To activate support for Parallax
> - dongles you will have to start irattach like this:
> - "irattach -d litelink".
> -
> -config MCP2120_DONGLE_OLD
> - tristate "Microchip MCP2120"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the Microchip MCP2120
> - dongle. To compile it as a module, choose M here. The MCP2120 dongle
> - attaches to the normal 9-pin serial port connector, and can
> - currently only be used by IrTTY. To activate support for MCP2120
> - dongles you will have to insert "irattach -d mcp2120" in the
> - /etc/irda/drivers script.
> -
> - You must build this dongle yourself. For more information see:
> - <http://www.eyetap.org/~tangf/irda_sir_linux.html>
> -
> -config OLD_BELKIN_DONGLE_OLD
> - tristate "Old Belkin dongle"
> - depends on DONGLE_OLD && IRDA
> - help
> - Say Y here if you want to build support for the Adaptec Airport 1000
> - and 2000 dongles. To compile it as a module, choose M here: the module
> - will be called old_belkin. Some information is contained in the
> - comments at the top of <file:drivers/net/irda/old_belkin.c>.
> -
> -config ACT200L_DONGLE_OLD
> - tristate "ACTiSYS IR-200L dongle (EXPERIMENTAL)"
> - depends on DONGLE_OLD && EXPERIMENTAL && IRDA
> - help
> - Say Y here if you want to build support for the ACTiSYS IR-200L
> - dongle. To compile it as a module, choose M here. The ACTiSYS
> - IR-200L dongle attaches to the normal 9-pin serial port connector,
> - and can currently only be used by IrTTY. To activate support for
> - ACTiSYS IR-200L dongles you will have to start irattach like this:
> - "irattach -d act200l".
> -
> -config MA600_DONGLE_OLD
> - tristate "Mobile Action MA600 dongle (EXPERIMENTAL)"
> - depends on DONGLE_OLD && EXPERIMENTAL && IRDA
> - ---help---
> - Say Y here if you want to build support for the Mobile Action MA600
> - dongle. To compile it as a module, choose M here. The MA600 dongle
> - attaches to the normal 9-pin serial port connector, and can
> - currently only be tested on IrCOMM. To activate support for MA600
> - dongles you will have to insert "irattach -d ma600" in the
> - /etc/irda/drivers script. Note: irutils 0.9.15 requires no
> - modification. irutils 0.9.9 needs modification. For more
> - information, download the following tar gzip file.
> -
> - There is a pre-compiled module on
> - <http://engsvr.ust.hk/~eetwl95/ma600.html>
> -
> -config EP7211_IR
> - tristate "EP7211 I/R support"
> - depends on DONGLE_OLD && ARCH_EP7211 && IRDA
> -
> comment "FIR device drivers"
>
> config USB_IRDA
> diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile
> index fefbb59..5d20fde 100644
> --- a/drivers/net/irda/Makefile
> +++ b/drivers/net/irda/Makefile
> @@ -5,8 +5,6 @@
> # Rewritten to use lists instead of if-statements.
> #
>
> -# Old SIR drivers
> -obj-$(CONFIG_IRPORT_SIR) += irport.o
> # FIR drivers
> obj-$(CONFIG_USB_IRDA) += irda-usb.o
> obj-$(CONFIG_SIGMATEL_FIR) += stir4200.o
> @@ -20,21 +18,10 @@ obj-$(CONFIG_VLSI_FIR) += vlsi_ir.o
> obj-$(CONFIG_VIA_FIR) += via-ircc.o
> obj-$(CONFIG_PXA_FICP) += pxaficp_ir.o
> obj-$(CONFIG_MCS_FIR) += mcs7780.o
> -# Old dongle drivers for old SIR drivers
> -obj-$(CONFIG_ESI_DONGLE_OLD) += esi.o
> -obj-$(CONFIG_TEKRAM_DONGLE_OLD) += tekram.o
> -obj-$(CONFIG_ACTISYS_DONGLE_OLD) += actisys.o
> -obj-$(CONFIG_GIRBIL_DONGLE_OLD) += girbil.o
> -obj-$(CONFIG_LITELINK_DONGLE_OLD) += litelink.o
> -obj-$(CONFIG_OLD_BELKIN_DONGLE_OLD) += old_belkin.o
> -obj-$(CONFIG_MCP2120_DONGLE_OLD) += mcp2120.o
> -obj-$(CONFIG_ACT200L_DONGLE_OLD) += act200l.o
> -obj-$(CONFIG_MA600_DONGLE_OLD) += ma600.o
> -obj-$(CONFIG_EP7211_IR) += ep7211_ir.o
> obj-$(CONFIG_AU1000_FIR) += au1k_ir.o
> -# New SIR drivers
> +# SIR drivers
> obj-$(CONFIG_IRTTY_SIR) += irtty-sir.o sir-dev.o
> -# New dongles drivers for new SIR drivers
> +# dongle drivers for SIR drivers
> obj-$(CONFIG_ESI_DONGLE) += esi-sir.o
> obj-$(CONFIG_TEKRAM_DONGLE) += tekram-sir.o
> obj-$(CONFIG_ACTISYS_DONGLE) += actisys-sir.o
> diff --git a/drivers/net/irda/act200l.c b/drivers/net/irda/act200l.c
> deleted file mode 100644
> index 756cd44..0000000
> --- a/drivers/net/irda/act200l.c
> +++ /dev/null
> @@ -1,297 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: act200l.c
> - * Version: 0.8
> - * Description: Implementation for the ACTiSYS ACT-IR200L dongle
> - * Status: Experimental.
> - * Author: SHIMIZU Takuya <tshimizu@....so-net.ne.jp>
> - * Created at: Fri Aug 3 17:35:42 2001
> - * Modified at: Fri Aug 17 10:22:40 2001
> - * Modified by: SHIMIZU Takuya <tshimizu@....so-net.ne.jp>
> - *
> - * Copyright (c) 2001 SHIMIZU Takuya, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -static int act200l_reset(struct irda_task *task);
> -static void act200l_open(dongle_t *self, struct qos_info *qos);
> -static void act200l_close(dongle_t *self);
> -static int act200l_change_speed(struct irda_task *task);
> -
> -/* Regsiter 0: Control register #1 */
> -#define ACT200L_REG0 0x00
> -#define ACT200L_TXEN 0x01 /* Enable transmitter */
> -#define ACT200L_RXEN 0x02 /* Enable receiver */
> -
> -/* Register 1: Control register #2 */
> -#define ACT200L_REG1 0x10
> -#define ACT200L_LODB 0x01 /* Load new baud rate count value */
> -#define ACT200L_WIDE 0x04 /* Expand the maximum allowable pulse */
> -
> -/* Register 4: Output Power register */
> -#define ACT200L_REG4 0x40
> -#define ACT200L_OP0 0x01 /* Enable LED1C output */
> -#define ACT200L_OP1 0x02 /* Enable LED2C output */
> -#define ACT200L_BLKR 0x04
> -
> -/* Register 5: Receive Mode register */
> -#define ACT200L_REG5 0x50
> -#define ACT200L_RWIDL 0x01 /* fixed 1.6us pulse mode */
> -
> -/* Register 6: Receive Sensitivity register #1 */
> -#define ACT200L_REG6 0x60
> -#define ACT200L_RS0 0x01 /* receive threshold bit 0 */
> -#define ACT200L_RS1 0x02 /* receive threshold bit 1 */
> -
> -/* Register 7: Receive Sensitivity register #2 */
> -#define ACT200L_REG7 0x70
> -#define ACT200L_ENPOS 0x04 /* Ignore the falling edge */
> -
> -/* Register 8,9: Baud Rate Dvider register #1,#2 */
> -#define ACT200L_REG8 0x80
> -#define ACT200L_REG9 0x90
> -
> -#define ACT200L_2400 0x5f
> -#define ACT200L_9600 0x17
> -#define ACT200L_19200 0x0b
> -#define ACT200L_38400 0x05
> -#define ACT200L_57600 0x03
> -#define ACT200L_115200 0x01
> -
> -/* Register 13: Control register #3 */
> -#define ACT200L_REG13 0xd0
> -#define ACT200L_SHDW 0x01 /* Enable access to shadow registers */
> -
> -/* Register 15: Status register */
> -#define ACT200L_REG15 0xf0
> -
> -/* Register 21: Control register #4 */
> -#define ACT200L_REG21 0x50
> -#define ACT200L_EXCK 0x02 /* Disable clock output driver */
> -#define ACT200L_OSCL 0x04 /* oscillator in low power, medium accuracy mode */
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_ACT200L_DONGLE,
> - .open = act200l_open,
> - .close = act200l_close,
> - .reset = act200l_reset,
> - .change_speed = act200l_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init act200l_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit act200l_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void act200l_open(dongle_t *self, struct qos_info *qos)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - /* Power on the dongle */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Set the speeds we can accept */
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
> - qos->min_turn_time.bits = 0x03;
> -}
> -
> -static void act200l_close(dongle_t *self)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - /* Power off the dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function act200l_change_speed (dev, speed)
> - *
> - * Set the speed for the ACTiSYS ACT-IR200L type dongle.
> - *
> - */
> -static int act200l_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - __u8 control[3];
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - self->speed_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - if (irda_task_execute(self, act200l_reset, NULL, task,
> - (void *) speed))
> - {
> - /* Dongle need more time to reset */
> - irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
> -
> - /* Give reset 1 sec to finish */
> - ret = msecs_to_jiffies(1000);
> - }
> - break;
> - case IRDA_TASK_CHILD_WAIT:
> - IRDA_WARNING("%s(), resetting dongle timed out!\n",
> - __FUNCTION__);
> - ret = -1;
> - break;
> - case IRDA_TASK_CHILD_DONE:
> - /* Clear DTR and set RTS to enter command mode */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> -
> - switch (speed) {
> - case 9600:
> - default:
> - control[0] = ACT200L_REG8 | (ACT200L_9600 & 0x0f);
> - control[1] = ACT200L_REG9 | ((ACT200L_9600 >> 4) & 0x0f);
> - break;
> - case 19200:
> - control[0] = ACT200L_REG8 | (ACT200L_19200 & 0x0f);
> - control[1] = ACT200L_REG9 | ((ACT200L_19200 >> 4) & 0x0f);
> - break;
> - case 38400:
> - control[0] = ACT200L_REG8 | (ACT200L_38400 & 0x0f);
> - control[1] = ACT200L_REG9 | ((ACT200L_38400 >> 4) & 0x0f);
> - break;
> - case 57600:
> - control[0] = ACT200L_REG8 | (ACT200L_57600 & 0x0f);
> - control[1] = ACT200L_REG9 | ((ACT200L_57600 >> 4) & 0x0f);
> - break;
> - case 115200:
> - control[0] = ACT200L_REG8 | (ACT200L_115200 & 0x0f);
> - control[1] = ACT200L_REG9 | ((ACT200L_115200 >> 4) & 0x0f);
> - break;
> - }
> - control[2] = ACT200L_REG1 | ACT200L_LODB | ACT200L_WIDE;
> -
> - /* Write control bytes */
> - self->write(self->dev, control, 3);
> - irda_task_next_state(task, IRDA_TASK_WAIT);
> - ret = msecs_to_jiffies(5);
> - break;
> - case IRDA_TASK_WAIT:
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -/*
> - * Function act200l_reset (driver)
> - *
> - * Reset the ACTiSYS ACT-IR200L type dongle.
> - */
> -static int act200l_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u8 control[9] = {
> - ACT200L_REG15,
> - ACT200L_REG13 | ACT200L_SHDW,
> - ACT200L_REG21 | ACT200L_EXCK | ACT200L_OSCL,
> - ACT200L_REG13,
> - ACT200L_REG7 | ACT200L_ENPOS,
> - ACT200L_REG6 | ACT200L_RS0 | ACT200L_RS1,
> - ACT200L_REG5 | ACT200L_RWIDL,
> - ACT200L_REG4 | ACT200L_OP0 | ACT200L_OP1 | ACT200L_BLKR,
> - ACT200L_REG0 | ACT200L_TXEN | ACT200L_RXEN
> - };
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - self->reset_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - /* Power on the dongle */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT1);
> - ret = msecs_to_jiffies(50);
> - break;
> - case IRDA_TASK_WAIT1:
> - /* Reset the dongle : set RTS low for 25 ms */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT2);
> - ret = msecs_to_jiffies(50);
> - break;
> - case IRDA_TASK_WAIT2:
> - /* Clear DTR and set RTS to enter command mode */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> -
> - /* Write control bytes */
> - self->write(self->dev, control, 9);
> - irda_task_next_state(task, IRDA_TASK_WAIT3);
> - ret = msecs_to_jiffies(15);
> - break;
> - case IRDA_TASK_WAIT3:
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -MODULE_AUTHOR("SHIMIZU Takuya <tshimizu@....so-net.ne.jp>");
> -MODULE_DESCRIPTION("ACTiSYS ACT-IR200L dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-10"); /* IRDA_ACT200L_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize ACTiSYS ACT-IR200L module
> - *
> - */
> -module_init(act200l_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup ACTiSYS ACT-IR200L module
> - *
> - */
> -module_exit(act200l_cleanup);
> diff --git a/drivers/net/irda/actisys.c b/drivers/net/irda/actisys.c
> deleted file mode 100644
> index ae0b80a..0000000
> --- a/drivers/net/irda/actisys.c
> +++ /dev/null
> @@ -1,288 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: actisys.c
> - * Version: 1.0
> - * Description: Implementation for the ACTiSYS IR-220L and IR-220L+
> - * dongles
> - * Status: Beta.
> - * Authors: Dag Brattli <dagb@...uit.no> (initially)
> - * Jean Tourrilhes <jt@....hp.com> (new version)
> - * Created at: Wed Oct 21 20:02:35 1998
> - * Modified at: Fri Dec 17 09:10:43 1999
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
> - * Copyright (c) 1999 Jean Tourrilhes
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * Neither Dag Brattli nor University of Tromsø admit liability nor
> - * provide warranty for any of this software. This material is
> - * provided "AS-IS" and at no charge.
> - *
> - ********************************************************************/
> -
> -/*
> - * Changelog
> - *
> - * 0.8 -> 0.9999 - Jean
> - * o New initialisation procedure : much safer and correct
> - * o New procedure the change speed : much faster and simpler
> - * o Other cleanups & comments
> - * Thanks to Lichen Wang @ Actisys for his excellent help...
> - */
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -/*
> - * Define the timing of the pulses we send to the dongle (to reset it, and
> - * to toggle speeds). Basically, the limit here is the propagation speed of
> - * the signals through the serial port, the dongle being much faster. Any
> - * serial port support 115 kb/s, so we are sure that pulses 8.5 us wide can
> - * go through cleanly . If you are on the wild side, you can try to lower
> - * this value (Actisys recommended me 2 us, and 0 us work for me on a P233!)
> - */
> -#define MIN_DELAY 10 /* 10 us to be on the conservative side */
> -
> -static int actisys_change_speed(struct irda_task *task);
> -static int actisys_reset(struct irda_task *task);
> -static void actisys_open(dongle_t *self, struct qos_info *qos);
> -static void actisys_close(dongle_t *self);
> -
> -/* These are the baudrates supported, in the order available */
> -/* Note : the 220L doesn't support 38400, but we will fix that below */
> -static __u32 baud_rates[] = { 9600, 19200, 57600, 115200, 38400 };
> -#define MAX_SPEEDS 5
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_ACTISYS_DONGLE,
> - .open = actisys_open,
> - .close = actisys_close,
> - .reset = actisys_reset,
> - .change_speed = actisys_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static struct dongle_reg dongle_plus = {
> - .type = IRDA_ACTISYS_PLUS_DONGLE,
> - .open = actisys_open,
> - .close = actisys_close,
> - .reset = actisys_reset,
> - .change_speed = actisys_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -/*
> - * Function actisys_change_speed (task)
> - *
> - * There is two model of Actisys dongle we are dealing with,
> - * the 220L and 220L+. At this point, only irattach knows with
> - * kind the user has requested (it was an argument on irattach
> - * command line).
> - * So, we register a dongle of each sort and let irattach
> - * pick the right one...
> - */
> -static int __init actisys_init(void)
> -{
> - int ret;
> -
> - /* First, register an Actisys 220L dongle */
> - ret = irda_device_register_dongle(&dongle);
> - if (ret < 0)
> - return ret;
> - /* Now, register an Actisys 220L+ dongle */
> - ret = irda_device_register_dongle(&dongle_plus);
> - if (ret < 0) {
> - irda_device_unregister_dongle(&dongle);
> - return ret;
> - }
> - return 0;
> -}
> -
> -static void __exit actisys_cleanup(void)
> -{
> - /* We have to remove both dongles */
> - irda_device_unregister_dongle(&dongle);
> - irda_device_unregister_dongle(&dongle_plus);
> -}
> -
> -static void actisys_open(dongle_t *self, struct qos_info *qos)
> -{
> - /* Power on the dongle */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Set the speeds we can accept */
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
> -
> - /* Remove support for 38400 if this is not a 220L+ dongle */
> - if (self->issue->type == IRDA_ACTISYS_DONGLE)
> - qos->baud_rate.bits &= ~IR_38400;
> -
> - qos->min_turn_time.bits = 0x7f; /* Needs 0.01 ms */
> -}
> -
> -static void actisys_close(dongle_t *self)
> -{
> - /* Power off the dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function actisys_change_speed (task)
> - *
> - * Change speed of the ACTiSYS IR-220L and IR-220L+ type IrDA dongles.
> - * To cycle through the available baud rates, pulse RTS low for a few us.
> - *
> - * First, we reset the dongle to always start from a known state.
> - * Then, we cycle through the speeds by pulsing RTS low and then up.
> - * The dongle allow us to pulse quite fast, se we can set speed in one go,
> - * which is must faster ( < 100 us) and less complex than what is found
> - * in some other dongle drivers...
> - * Note that even if the new speed is the same as the current speed,
> - * we reassert the speed. This make sure that things are all right,
> - * and it's fast anyway...
> - * By the way, this function will work for both type of dongles,
> - * because the additional speed is at the end of the sequence...
> - */
> -static int actisys_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param; /* Target speed */
> - int ret = 0;
> - int i = 0;
> -
> - IRDA_DEBUG(4, "%s(), speed=%d (was %d)\n", __FUNCTION__, speed,
> - self->speed);
> -
> - /* Go to a known state by reseting the dongle */
> -
> - /* Reset the dongle : set DTR low for 10 us */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> - udelay(MIN_DELAY);
> -
> - /* Go back to normal mode (we are now at 9600 b/s) */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /*
> - * Now, we can set the speed requested. Send RTS pulses until we
> - * reach the target speed
> - */
> - for (i=0; i<MAX_SPEEDS; i++) {
> - if (speed == baud_rates[i]) {
> - self->speed = baud_rates[i];
> - break;
> - }
> - /* Make sure previous pulse is finished */
> - udelay(MIN_DELAY);
> -
> - /* Set RTS low for 10 us */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> - udelay(MIN_DELAY);
> -
> - /* Set RTS high for 10 us */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - }
> -
> - /* Check if life is sweet... */
> - if (i >= MAX_SPEEDS)
> - ret = -1; /* This should not happen */
> -
> - /* Basta lavoro, on se casse d'ici... */
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return ret;
> -}
> -
> -/*
> - * Function actisys_reset (task)
> - *
> - * Reset the Actisys type dongle. Warning, this function must only be
> - * called with a process context!
> - *
> - * We need to do two things in this function :
> - * o first make sure that the dongle is in a state where it can operate
> - * o second put the dongle in a know state
> - *
> - * The dongle is powered of the RTS and DTR lines. In the dongle, there
> - * is a big capacitor to accommodate the current spikes. This capacitor
> - * takes a least 50 ms to be charged. In theory, the Bios set those lines
> - * up, so by the time we arrive here we should be set. It doesn't hurt
> - * to be on the conservative side, so we will wait...
> - * Then, we set the speed to 9600 b/s to get in a known state (see in
> - * change_speed for details). It is needed because the IrDA stack
> - * has tried to set the speed immediately after our first return,
> - * so before we can be sure the dongle is up and running.
> - */
> -static int actisys_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - int ret = 0;
> -
> - IRDA_ASSERT(task != NULL, return -1;);
> -
> - self->reset_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - /* Set both DTR & RTS to power up the dongle */
> - /* In theory redundant with power up in actisys_open() */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Sleep 50 ms to make sure capacitor is charged */
> - ret = msecs_to_jiffies(50);
> - irda_task_next_state(task, IRDA_TASK_WAIT);
> - break;
> - case IRDA_TASK_WAIT:
> - /* Reset the dongle : set DTR low for 10 us */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> - udelay(MIN_DELAY);
> -
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - self->speed = 9600; /* That's the default */
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -MODULE_AUTHOR("Dag Brattli <dagb@...uit.no> - Jean Tourrilhes <jt@....hp.com>");
> -MODULE_DESCRIPTION("ACTiSYS IR-220L and IR-220L+ dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-2"); /* IRDA_ACTISYS_DONGLE */
> -MODULE_ALIAS("irda-dongle-3"); /* IRDA_ACTISYS_PLUS_DONGLE */
> -
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize Actisys module
> - *
> - */
> -module_init(actisys_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup Actisys module
> - *
> - */
> -module_exit(actisys_cleanup);
> diff --git a/drivers/net/irda/ep7211_ir.c b/drivers/net/irda/ep7211_ir.c
> deleted file mode 100644
> index 4cba38f..0000000
> --- a/drivers/net/irda/ep7211_ir.c
> +++ /dev/null
> @@ -1,125 +0,0 @@
> -/*
> - * IR port driver for the Cirrus Logic EP7211 processor.
> - *
> - * Copyright 2001, Blue Mug Inc. All rights reserved.
> - */
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -#include <linux/spinlock.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -#include <asm/io.h>
> -#include <asm/hardware.h>
> -
> -#define MIN_DELAY 25 /* 15 us, but wait a little more to be sure */
> -#define MAX_DELAY 10000 /* 1 ms */
> -
> -static void ep7211_ir_open(dongle_t *self, struct qos_info *qos);
> -static void ep7211_ir_close(dongle_t *self);
> -static int ep7211_ir_change_speed(struct irda_task *task);
> -static int ep7211_ir_reset(struct irda_task *task);
> -
> -static DEFINE_SPINLOCK(ep7211_lock);
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_EP7211_IR,
> - .open = ep7211_ir_open,
> - .close = ep7211_ir_close,
> - .reset = ep7211_ir_reset,
> - .change_speed = ep7211_ir_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static void ep7211_ir_open(dongle_t *self, struct qos_info *qos)
> -{
> - unsigned int syscon1, flags;
> -
> - spin_lock_irqsave(&ep7211_lock, flags);
> -
> - /* Turn on the SIR encoder. */
> - syscon1 = clps_readl(SYSCON1);
> - syscon1 |= SYSCON1_SIREN;
> - clps_writel(syscon1, SYSCON1);
> -
> - /* XXX: We should disable modem status interrupts on the first
> - UART (interrupt #14). */
> -
> - spin_unlock_irqrestore(&ep7211_lock, flags);
> -}
> -
> -static void ep7211_ir_close(dongle_t *self)
> -{
> - unsigned int syscon1, flags;
> -
> - spin_lock_irqsave(&ep7211_lock, flags);
> -
> - /* Turn off the SIR encoder. */
> - syscon1 = clps_readl(SYSCON1);
> - syscon1 &= ~SYSCON1_SIREN;
> - clps_writel(syscon1, SYSCON1);
> -
> - /* XXX: If we've disabled the modem status interrupts, we should
> - reset them back to their original state. */
> -
> - spin_unlock_irqrestore(&ep7211_lock, flags);
> -}
> -
> -/*
> - * Function ep7211_ir_change_speed (task)
> - *
> - * Change speed of the EP7211 I/R port. We don't really have to do anything
> - * for the EP7211 as long as the rate is being changed at the serial port
> - * level.
> - */
> -static int ep7211_ir_change_speed(struct irda_task *task)
> -{
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - return 0;
> -}
> -
> -/*
> - * Function ep7211_ir_reset (task)
> - *
> - * Reset the EP7211 I/R. We don't really have to do anything.
> - *
> - */
> -static int ep7211_ir_reset(struct irda_task *task)
> -{
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - return 0;
> -}
> -
> -/*
> - * Function ep7211_ir_init(void)
> - *
> - * Initialize EP7211 I/R module
> - *
> - */
> -static int __init ep7211_ir_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -/*
> - * Function ep7211_ir_cleanup(void)
> - *
> - * Cleanup EP7211 I/R module
> - *
> - */
> -static void __exit ep7211_ir_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -MODULE_AUTHOR("Jon McClintock <jonm@...emug.com>");
> -MODULE_DESCRIPTION("EP7211 I/R driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-8"); /* IRDA_EP7211_IR */
> -
> -module_init(ep7211_ir_init);
> -module_exit(ep7211_ir_cleanup);
> diff --git a/drivers/net/irda/esi.c b/drivers/net/irda/esi.c
> deleted file mode 100644
> index d3a61af..0000000
> --- a/drivers/net/irda/esi.c
> +++ /dev/null
> @@ -1,149 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: esi.c
> - * Version: 1.5
> - * Description: Driver for the Extended Systems JetEye PC dongle
> - * Status: Experimental.
> - * Author: Dag Brattli <dagb@...uit.no>
> - * Created at: Sat Feb 21 18:54:38 1998
> - * Modified at: Fri Dec 17 09:14:04 1999
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1999 Dag Brattli, <dagb@...uit.no>,
> - * Copyright (c) 1998 Thomas Davis, <ratbert@...iks.net>,
> - * All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> - * GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> - * MA 02111-1307 USA
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -static void esi_open(dongle_t *self, struct qos_info *qos);
> -static void esi_close(dongle_t *self);
> -static int esi_change_speed(struct irda_task *task);
> -static int esi_reset(struct irda_task *task);
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_ESI_DONGLE,
> - .open = esi_open,
> - .close = esi_close,
> - .reset = esi_reset,
> - .change_speed = esi_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init esi_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit esi_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void esi_open(dongle_t *self, struct qos_info *qos)
> -{
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_115200;
> - qos->min_turn_time.bits = 0x01; /* Needs at least 10 ms */
> -}
> -
> -static void esi_close(dongle_t *dongle)
> -{
> - /* Power off dongle */
> - dongle->set_dtr_rts(dongle->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function esi_change_speed (task)
> - *
> - * Set the speed for the Extended Systems JetEye PC ESI-9680 type dongle
> - *
> - */
> -static int esi_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - int dtr, rts;
> -
> - switch (speed) {
> - case 19200:
> - dtr = TRUE;
> - rts = FALSE;
> - break;
> - case 115200:
> - dtr = rts = TRUE;
> - break;
> - case 9600:
> - default:
> - dtr = FALSE;
> - rts = TRUE;
> - break;
> - }
> -
> - /* Change speed of dongle */
> - self->set_dtr_rts(self->dev, dtr, rts);
> - self->speed = speed;
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return 0;
> -}
> -
> -/*
> - * Function esi_reset (task)
> - *
> - * Reset dongle;
> - *
> - */
> -static int esi_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> -
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return 0;
> -}
> -
> -MODULE_AUTHOR("Dag Brattli <dagb@...uit.no>");
> -MODULE_DESCRIPTION("Extended Systems JetEye PC dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-1"); /* IRDA_ESI_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize ESI module
> - *
> - */
> -module_init(esi_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup ESI module
> - *
> - */
> -module_exit(esi_cleanup);
> -
> diff --git a/drivers/net/irda/girbil.c b/drivers/net/irda/girbil.c
> deleted file mode 100644
> index 1f57391..0000000
> --- a/drivers/net/irda/girbil.c
> +++ /dev/null
> @@ -1,250 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: girbil.c
> - * Version: 1.2
> - * Description: Implementation for the Greenwich GIrBIL dongle
> - * Status: Experimental.
> - * Author: Dag Brattli <dagb@...uit.no>
> - * Created at: Sat Feb 6 21:02:33 1999
> - * Modified at: Fri Dec 17 09:13:20 1999
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1999 Dag Brattli, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * Neither Dag Brattli nor University of Tromsø admit liability nor
> - * provide warranty for any of this software. This material is
> - * provided "AS-IS" and at no charge.
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -static int girbil_reset(struct irda_task *task);
> -static void girbil_open(dongle_t *self, struct qos_info *qos);
> -static void girbil_close(dongle_t *self);
> -static int girbil_change_speed(struct irda_task *task);
> -
> -/* Control register 1 */
> -#define GIRBIL_TXEN 0x01 /* Enable transmitter */
> -#define GIRBIL_RXEN 0x02 /* Enable receiver */
> -#define GIRBIL_ECAN 0x04 /* Cancel self emmited data */
> -#define GIRBIL_ECHO 0x08 /* Echo control characters */
> -
> -/* LED Current Register (0x2) */
> -#define GIRBIL_HIGH 0x20
> -#define GIRBIL_MEDIUM 0x21
> -#define GIRBIL_LOW 0x22
> -
> -/* Baud register (0x3) */
> -#define GIRBIL_2400 0x30
> -#define GIRBIL_4800 0x31
> -#define GIRBIL_9600 0x32
> -#define GIRBIL_19200 0x33
> -#define GIRBIL_38400 0x34
> -#define GIRBIL_57600 0x35
> -#define GIRBIL_115200 0x36
> -
> -/* Mode register (0x4) */
> -#define GIRBIL_IRDA 0x40
> -#define GIRBIL_ASK 0x41
> -
> -/* Control register 2 (0x5) */
> -#define GIRBIL_LOAD 0x51 /* Load the new baud rate value */
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_GIRBIL_DONGLE,
> - .open = girbil_open,
> - .close = girbil_close,
> - .reset = girbil_reset,
> - .change_speed = girbil_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init girbil_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit girbil_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void girbil_open(dongle_t *self, struct qos_info *qos)
> -{
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
> - qos->min_turn_time.bits = 0x03;
> -}
> -
> -static void girbil_close(dongle_t *self)
> -{
> - /* Power off dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function girbil_change_speed (dev, speed)
> - *
> - * Set the speed for the Girbil type dongle.
> - *
> - */
> -static int girbil_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - __u8 control[2];
> - int ret = 0;
> -
> - self->speed_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - /* Need to reset the dongle and go to 9600 bps before
> - programming */
> - if (irda_task_execute(self, girbil_reset, NULL, task,
> - (void *) speed))
> - {
> - /* Dongle need more time to reset */
> - irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
> -
> - /* Give reset 1 sec to finish */
> - ret = msecs_to_jiffies(1000);
> - }
> - break;
> - case IRDA_TASK_CHILD_WAIT:
> - IRDA_WARNING("%s(), resetting dongle timed out!\n",
> - __FUNCTION__);
> - ret = -1;
> - break;
> - case IRDA_TASK_CHILD_DONE:
> - /* Set DTR and Clear RTS to enter command mode */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> -
> - switch (speed) {
> - case 9600:
> - default:
> - control[0] = GIRBIL_9600;
> - break;
> - case 19200:
> - control[0] = GIRBIL_19200;
> - break;
> - case 34800:
> - control[0] = GIRBIL_38400;
> - break;
> - case 57600:
> - control[0] = GIRBIL_57600;
> - break;
> - case 115200:
> - control[0] = GIRBIL_115200;
> - break;
> - }
> - control[1] = GIRBIL_LOAD;
> -
> - /* Write control bytes */
> - self->write(self->dev, control, 2);
> - irda_task_next_state(task, IRDA_TASK_WAIT);
> - ret = msecs_to_jiffies(100);
> - break;
> - case IRDA_TASK_WAIT:
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -/*
> - * Function girbil_reset (driver)
> - *
> - * This function resets the girbil dongle.
> - *
> - * Algorithm:
> - * 0. set RTS, and wait at least 5 ms
> - * 1. clear RTS
> - */
> -static int girbil_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u8 control = GIRBIL_TXEN | GIRBIL_RXEN;
> - int ret = 0;
> -
> - self->reset_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - /* Reset dongle */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> - irda_task_next_state(task, IRDA_TASK_WAIT1);
> - /* Sleep at least 5 ms */
> - ret = msecs_to_jiffies(20);
> - break;
> - case IRDA_TASK_WAIT1:
> - /* Set DTR and clear RTS to enter command mode */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> - irda_task_next_state(task, IRDA_TASK_WAIT2);
> - ret = msecs_to_jiffies(20);
> - break;
> - case IRDA_TASK_WAIT2:
> - /* Write control byte */
> - self->write(self->dev, &control, 1);
> - irda_task_next_state(task, IRDA_TASK_WAIT3);
> - ret = msecs_to_jiffies(20);
> - break;
> - case IRDA_TASK_WAIT3:
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -MODULE_AUTHOR("Dag Brattli <dagb@...uit.no>");
> -MODULE_DESCRIPTION("Greenwich GIrBIL dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-4"); /* IRDA_GIRBIL_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize Girbil module
> - *
> - */
> -module_init(girbil_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup Girbil module
> - *
> - */
> -module_exit(girbil_cleanup);
> -
> diff --git a/drivers/net/irda/irport.c b/drivers/net/irda/irport.c
> deleted file mode 100644
> index c79caa5..0000000
> --- a/drivers/net/irda/irport.c
> +++ /dev/null
> @@ -1,1123 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: irport.c
> - * Version: 1.0
> - * Description: Half duplex serial port SIR driver for IrDA.
> - * Status: Experimental.
> - * Author: Dag Brattli <dagb@...uit.no>
> - * Created at: Sun Aug 3 13:49:59 1997
> - * Modified at: Fri Jan 28 20:22:38 2000
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - * Sources: serial.c by Linus Torvalds
> - *
> - * Copyright (c) 1997, 1998, 1999-2000 Dag Brattli, All Rights Reserved.
> - * Copyright (c) 2000-2003 Jean Tourrilhes, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> - * GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> - * MA 02111-1307 USA
> - *
> - * This driver is ment to be a small half duplex serial driver to be
> - * used for IR-chipsets that has a UART (16550) compatibility mode.
> - * Eventually it will replace irtty, because of irtty has some
> - * problems that is hard to get around when we don't have control
> - * over the serial driver. This driver may also be used by FIR
> - * drivers to handle SIR mode for them.
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -
> -#include <linux/kernel.h>
> -#include <linux/types.h>
> -#include <linux/ioport.h>
> -#include <linux/slab.h>
> -#include <linux/string.h>
> -#include <linux/skbuff.h>
> -#include <linux/serial_reg.h>
> -#include <linux/errno.h>
> -#include <linux/init.h>
> -#include <linux/spinlock.h>
> -#include <linux/delay.h>
> -#include <linux/rtnetlink.h>
> -#include <linux/bitops.h>
> -
> -#include <asm/system.h>
> -#include <asm/io.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/wrapper.h>
> -#include "irport.h"
> -
> -#define IO_EXTENT 8
> -
> -/*
> - * Currently you'll need to set these values using insmod like this:
> - * insmod irport io=0x3e8 irq=11
> - */
> -static unsigned int io[] = { ~0, ~0, ~0, ~0 };
> -static unsigned int irq[] = { 0, 0, 0, 0 };
> -
> -static unsigned int qos_mtt_bits = 0x03;
> -
> -static struct irport_cb *dev_self[] = { NULL, NULL, NULL, NULL};
> -static char *driver_name = "irport";
> -
> -static inline void irport_write_wakeup(struct irport_cb *self);
> -static inline int irport_write(int iobase, int fifo_size, __u8 *buf, int len);
> -static inline void irport_receive(struct irport_cb *self);
> -
> -static int irport_net_ioctl(struct net_device *dev, struct ifreq *rq,
> - int cmd);
> -static inline int irport_is_receiving(struct irport_cb *self);
> -static int irport_set_dtr_rts(struct net_device *dev, int dtr, int rts);
> -static int irport_raw_write(struct net_device *dev, __u8 *buf, int len);
> -static struct net_device_stats *irport_net_get_stats(struct net_device *dev);
> -static int irport_change_speed_complete(struct irda_task *task);
> -static void irport_timeout(struct net_device *dev);
> -
> -static irqreturn_t irport_interrupt(int irq, void *dev_id);
> -static int irport_hard_xmit(struct sk_buff *skb, struct net_device *dev);
> -static void irport_change_speed(void *priv, __u32 speed);
> -static int irport_net_open(struct net_device *dev);
> -static int irport_net_close(struct net_device *dev);
> -
> -static struct irport_cb *
> -irport_open(int i, unsigned int iobase, unsigned int irq)
> -{
> - struct net_device *dev;
> - struct irport_cb *self;
> -
> - IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
> -
> - /* Lock the port that we need */
> - if (!request_region(iobase, IO_EXTENT, driver_name)) {
> - IRDA_DEBUG(0, "%s(), can't get iobase of 0x%03x\n",
> - __FUNCTION__, iobase);
> - goto err_out1;
> - }
> -
> - /*
> - * Allocate new instance of the driver
> - */
> - dev = alloc_irdadev(sizeof(struct irport_cb));
> - if (!dev) {
> - IRDA_ERROR("%s(), can't allocate memory for "
> - "irda device!\n", __FUNCTION__);
> - goto err_out2;
> - }
> -
> - self = dev->priv;
> - spin_lock_init(&self->lock);
> -
> - /* Need to store self somewhere */
> - dev_self[i] = self;
> - self->priv = self;
> - self->index = i;
> -
> - /* Initialize IO */
> - self->io.sir_base = iobase;
> - self->io.sir_ext = IO_EXTENT;
> - self->io.irq = irq;
> - self->io.fifo_size = 16; /* 16550A and compatible */
> -
> - /* Initialize QoS for this device */
> - irda_init_max_qos_capabilies(&self->qos);
> -
> - self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
> - IR_115200;
> -
> - self->qos.min_turn_time.bits = qos_mtt_bits;
> - irda_qos_bits_to_value(&self->qos);
> -
> - /* Bootstrap ZeroCopy Rx */
> - self->rx_buff.truesize = IRDA_SKB_MAX_MTU;
> - self->rx_buff.skb = __dev_alloc_skb(self->rx_buff.truesize,
> - GFP_KERNEL);
> - if (self->rx_buff.skb == NULL) {
> - IRDA_ERROR("%s(), can't allocate memory for "
> - "receive buffer!\n", __FUNCTION__);
> - goto err_out3;
> - }
> - skb_reserve(self->rx_buff.skb, 1);
> - self->rx_buff.head = self->rx_buff.skb->data;
> - /* No need to memset the buffer, unless you are really pedantic */
> -
> - /* Finish setup the Rx buffer descriptor */
> - self->rx_buff.in_frame = FALSE;
> - self->rx_buff.state = OUTSIDE_FRAME;
> - self->rx_buff.data = self->rx_buff.head;
> -
> - /* Specify how much memory we want */
> - self->tx_buff.truesize = 4000;
> -
> - /* Allocate memory if needed */
> - if (self->tx_buff.truesize > 0) {
> - self->tx_buff.head = kzalloc(self->tx_buff.truesize,
> - GFP_KERNEL);
> - if (self->tx_buff.head == NULL) {
> - IRDA_ERROR("%s(), can't allocate memory for "
> - "transmit buffer!\n", __FUNCTION__);
> - goto err_out4;
> - }
> - }
> - self->tx_buff.data = self->tx_buff.head;
> -
> - self->netdev = dev;
> -
> - /* May be overridden by piggyback drivers */
> - self->interrupt = irport_interrupt;
> - self->change_speed = irport_change_speed;
> -
> - /* Override the network functions we need to use */
> - dev->hard_start_xmit = irport_hard_xmit;
> - dev->tx_timeout = irport_timeout;
> - dev->watchdog_timeo = HZ; /* Allow time enough for speed change */
> - dev->open = irport_net_open;
> - dev->stop = irport_net_close;
> - dev->get_stats = irport_net_get_stats;
> - dev->do_ioctl = irport_net_ioctl;
> -
> - /* Make ifconfig display some details */
> - dev->base_addr = iobase;
> - dev->irq = irq;
> -
> - if (register_netdev(dev)) {
> - IRDA_ERROR("%s(), register_netdev() failed!\n", __FUNCTION__);
> - goto err_out5;
> - }
> - IRDA_MESSAGE("IrDA: Registered device %s (irport io=0x%X irq=%d)\n",
> - dev->name, iobase, irq);
> -
> - return self;
> - err_out5:
> - kfree(self->tx_buff.head);
> - err_out4:
> - kfree_skb(self->rx_buff.skb);
> - err_out3:
> - free_netdev(dev);
> - dev_self[i] = NULL;
> - err_out2:
> - release_region(iobase, IO_EXTENT);
> - err_out1:
> - return NULL;
> -}
> -
> -static int irport_close(struct irport_cb *self)
> -{
> - IRDA_ASSERT(self != NULL, return -1;);
> -
> - /* We are not using any dongle anymore! */
> - if (self->dongle)
> - irda_device_dongle_cleanup(self->dongle);
> - self->dongle = NULL;
> -
> - /* Remove netdevice */
> - unregister_netdev(self->netdev);
> -
> - /* Release the IO-port that this driver is using */
> - IRDA_DEBUG(0 , "%s(), Releasing Region %03x\n",
> - __FUNCTION__, self->io.sir_base);
> - release_region(self->io.sir_base, self->io.sir_ext);
> -
> - kfree(self->tx_buff.head);
> -
> - if (self->rx_buff.skb)
> - kfree_skb(self->rx_buff.skb);
> - self->rx_buff.skb = NULL;
> -
> - /* Remove ourselves */
> - dev_self[self->index] = NULL;
> - free_netdev(self->netdev);
> -
> - return 0;
> -}
> -
> -static void irport_stop(struct irport_cb *self)
> -{
> - int iobase;
> -
> - iobase = self->io.sir_base;
> -
> - /* We can't lock, we may be called from a FIR driver - Jean II */
> -
> - /* We are not transmitting any more */
> - self->transmitting = 0;
> -
> - /* Reset UART */
> - outb(0, iobase+UART_MCR);
> -
> - /* Turn off interrupts */
> - outb(0, iobase+UART_IER);
> -}
> -
> -static void irport_start(struct irport_cb *self)
> -{
> - int iobase;
> -
> - iobase = self->io.sir_base;
> -
> - irport_stop(self);
> -
> - /* We can't lock, we may be called from a FIR driver - Jean II */
> -
> - /* Initialize UART */
> - outb(UART_LCR_WLEN8, iobase+UART_LCR); /* Reset DLAB */
> - outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase+UART_MCR);
> -
> - /* Turn on interrups */
> - outb(UART_IER_RLSI | UART_IER_RDI |UART_IER_THRI, iobase+UART_IER);
> -}
> -
> -/*
> - * Function irport_get_fcr (speed)
> - *
> - * Compute value of fcr
> - *
> - */
> -static inline unsigned int irport_get_fcr(__u32 speed)
> -{
> - unsigned int fcr; /* FIFO control reg */
> -
> - /* Enable fifos */
> - fcr = UART_FCR_ENABLE_FIFO;
> -
> - /*
> - * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
> - * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
> - * about this timeout since it will always be fast enough.
> - */
> - if (speed < 38400)
> - fcr |= UART_FCR_TRIGGER_1;
> - else
> - //fcr |= UART_FCR_TRIGGER_14;
> - fcr |= UART_FCR_TRIGGER_8;
> -
> - return(fcr);
> -}
> -
> -/*
> - * Function irport_change_speed (self, speed)
> - *
> - * Set speed of IrDA port to specified baudrate
> - *
> - * This function should be called with irq off and spin-lock.
> - */
> -static void irport_change_speed(void *priv, __u32 speed)
> -{
> - struct irport_cb *self = (struct irport_cb *) priv;
> - int iobase;
> - unsigned int fcr; /* FIFO control reg */
> - unsigned int lcr; /* Line control reg */
> - int divisor;
> -
> - IRDA_ASSERT(self != NULL, return;);
> - IRDA_ASSERT(speed != 0, return;);
> -
> - IRDA_DEBUG(1, "%s(), Setting speed to: %d - iobase=%#x\n",
> - __FUNCTION__, speed, self->io.sir_base);
> -
> - /* We can't lock, we may be called from a FIR driver - Jean II */
> -
> - iobase = self->io.sir_base;
> -
> - /* Update accounting for new speed */
> - self->io.speed = speed;
> -
> - /* Turn off interrupts */
> - outb(0, iobase+UART_IER);
> -
> - divisor = SPEED_MAX/speed;
> -
> - /* Get proper fifo configuration */
> - fcr = irport_get_fcr(speed);
> -
> - /* IrDA ports use 8N1 */
> - lcr = UART_LCR_WLEN8;
> -
> - outb(UART_LCR_DLAB | lcr, iobase+UART_LCR); /* Set DLAB */
> - outb(divisor & 0xff, iobase+UART_DLL); /* Set speed */
> - outb(divisor >> 8, iobase+UART_DLM);
> - outb(lcr, iobase+UART_LCR); /* Set 8N1 */
> - outb(fcr, iobase+UART_FCR); /* Enable FIFO's */
> -
> - /* Turn on interrups */
> - /* This will generate a fatal interrupt storm.
> - * People calling us will do that properly - Jean II */
> - //outb(/*UART_IER_RLSI|*/UART_IER_RDI/*|UART_IER_THRI*/, iobase+UART_IER);
> -}
> -
> -/*
> - * Function __irport_change_speed (instance, state, param)
> - *
> - * State machine for changing speed of the device. We do it this way since
> - * we cannot use schedule_timeout() when we are in interrupt context
> - *
> - */
> -static int __irport_change_speed(struct irda_task *task)
> -{
> - struct irport_cb *self;
> - __u32 speed = (__u32) task->param;
> - unsigned long flags = 0;
> - int wasunlocked = 0;
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies);
> -
> - self = (struct irport_cb *) task->instance;
> -
> - IRDA_ASSERT(self != NULL, return -1;);
> -
> - /* Locking notes : this function may be called from irq context with
> - * spinlock, via irport_write_wakeup(), or from non-interrupt without
> - * spinlock (from the task timer). Yuck !
> - * This is ugly, and unsafe is the spinlock is not already acquired.
> - * This will be fixed when irda-task get rewritten.
> - * Jean II */
> - if (!spin_is_locked(&self->lock)) {
> - spin_lock_irqsave(&self->lock, flags);
> - wasunlocked = 1;
> - }
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - case IRDA_TASK_WAIT:
> - /* Are we ready to change speed yet? */
> - if (self->tx_buff.len > 0) {
> - task->state = IRDA_TASK_WAIT;
> -
> - /* Try again later */
> - ret = msecs_to_jiffies(20);
> - break;
> - }
> -
> - if (self->dongle)
> - irda_task_next_state(task, IRDA_TASK_CHILD_INIT);
> - else
> - irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
> - break;
> - case IRDA_TASK_CHILD_INIT:
> - /* Go to default speed */
> - self->change_speed(self->priv, 9600);
> -
> - /* Change speed of dongle */
> - if (irda_task_execute(self->dongle,
> - self->dongle->issue->change_speed,
> - NULL, task, (void *) speed))
> - {
> - /* Dongle need more time to change its speed */
> - irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
> -
> - /* Give dongle 1 sec to finish */
> - ret = msecs_to_jiffies(1000);
> - } else
> - /* Child finished immediately */
> - irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
> - break;
> - case IRDA_TASK_CHILD_WAIT:
> - IRDA_WARNING("%s(), changing speed of dongle timed out!\n", __FUNCTION__);
> - ret = -1;
> - break;
> - case IRDA_TASK_CHILD_DONE:
> - /* Finally we are ready to change the speed */
> - self->change_speed(self->priv, speed);
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - ret = -1;
> - break;
> - }
> - /* Put stuff in the state we found them - Jean II */
> - if(wasunlocked) {
> - spin_unlock_irqrestore(&self->lock, flags);
> - }
> -
> - return ret;
> -}
> -
> -/*
> - * Function irport_change_speed_complete (task)
> - *
> - * Called when the change speed operation completes
> - *
> - */
> -static int irport_change_speed_complete(struct irda_task *task)
> -{
> - struct irport_cb *self;
> -
> - IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
> -
> - self = (struct irport_cb *) task->instance;
> -
> - IRDA_ASSERT(self != NULL, return -1;);
> - IRDA_ASSERT(self->netdev != NULL, return -1;);
> -
> - /* Finished changing speed, so we are not busy any longer */
> - /* Signal network layer so it can try to send the frame */
> -
> - netif_wake_queue(self->netdev);
> -
> - return 0;
> -}
> -
> -/*
> - * Function irport_timeout (struct net_device *dev)
> - *
> - * The networking layer thinks we timed out.
> - *
> - */
> -
> -static void irport_timeout(struct net_device *dev)
> -{
> - struct irport_cb *self;
> - int iobase;
> - int iir, lsr;
> - unsigned long flags;
> -
> - self = (struct irport_cb *) dev->priv;
> - IRDA_ASSERT(self != NULL, return;);
> - iobase = self->io.sir_base;
> -
> - IRDA_WARNING("%s: transmit timed out, jiffies = %ld, trans_start = %ld\n",
> - dev->name, jiffies, dev->trans_start);
> - spin_lock_irqsave(&self->lock, flags);
> -
> - /* Debug what's happening... */
> -
> - /* Get interrupt status */
> - lsr = inb(iobase+UART_LSR);
> - /* Read interrupt register */
> - iir = inb(iobase+UART_IIR);
> - IRDA_DEBUG(0, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n",
> - __FUNCTION__, iir, lsr, iobase);
> -
> - IRDA_DEBUG(0, "%s(), transmitting=%d, remain=%d, done=%td\n",
> - __FUNCTION__, self->transmitting, self->tx_buff.len,
> - self->tx_buff.data - self->tx_buff.head);
> -
> - /* Now, restart the port */
> - irport_start(self);
> - self->change_speed(self->priv, self->io.speed);
> - /* This will re-enable irqs */
> - outb(/*UART_IER_RLSI|*/UART_IER_RDI/*|UART_IER_THRI*/, iobase+UART_IER);
> - dev->trans_start = jiffies;
> - spin_unlock_irqrestore(&self->lock, flags);
> -
> - netif_wake_queue(dev);
> -}
> -
> -/*
> - * Function irport_wait_hw_transmitter_finish ()
> - *
> - * Wait for the real end of HW transmission
> - *
> - * The UART is a strict FIFO, and we get called only when we have finished
> - * pushing data to the FIFO, so the maximum amount of time we must wait
> - * is only for the FIFO to drain out.
> - *
> - * We use a simple calibrated loop. We may need to adjust the loop
> - * delay (udelay) to balance I/O traffic and latency. And we also need to
> - * adjust the maximum timeout.
> - * It would probably be better to wait for the proper interrupt,
> - * but it doesn't seem to be available.
> - *
> - * We can't use jiffies or kernel timers because :
> - * 1) We are called from the interrupt handler, which disable softirqs,
> - * so jiffies won't be increased
> - * 2) Jiffies granularity is usually very coarse (10ms), and we don't
> - * want to wait that long to detect stuck hardware.
> - * Jean II
> - */
> -
> -static void irport_wait_hw_transmitter_finish(struct irport_cb *self)
> -{
> - int iobase;
> - int count = 1000; /* 1 ms */
> -
> - iobase = self->io.sir_base;
> -
> - /* Calibrated busy loop */
> - while((count-- > 0) && !(inb(iobase+UART_LSR) & UART_LSR_TEMT))
> - udelay(1);
> -
> - if(count == 0)
> - IRDA_DEBUG(0, "%s(): stuck transmitter\n", __FUNCTION__);
> -}
> -
> -/*
> - * Function irport_hard_start_xmit (struct sk_buff *skb, struct net_device *dev)
> - *
> - * Transmits the current frame until FIFO is full, then
> - * waits until the next transmitt interrupt, and continues until the
> - * frame is transmitted.
> - */
> -static int irport_hard_xmit(struct sk_buff *skb, struct net_device *dev)
> -{
> - struct irport_cb *self;
> - unsigned long flags;
> - int iobase;
> - s32 speed;
> -
> - IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
> -
> - IRDA_ASSERT(dev != NULL, return 0;);
> -
> - self = (struct irport_cb *) dev->priv;
> - IRDA_ASSERT(self != NULL, return 0;);
> -
> - iobase = self->io.sir_base;
> -
> - netif_stop_queue(dev);
> -
> - /* Make sure tests & speed change are atomic */
> - spin_lock_irqsave(&self->lock, flags);
> -
> - /* Check if we need to change the speed */
> - speed = irda_get_next_speed(skb);
> - if ((speed != self->io.speed) && (speed != -1)) {
> - /* Check for empty frame */
> - if (!skb->len) {
> - /*
> - * We send frames one by one in SIR mode (no
> - * pipelining), so at this point, if we were sending
> - * a previous frame, we just received the interrupt
> - * telling us it is finished (UART_IIR_THRI).
> - * Therefore, waiting for the transmitter to really
> - * finish draining the fifo won't take too long.
> - * And the interrupt handler is not expected to run.
> - * - Jean II */
> - irport_wait_hw_transmitter_finish(self);
> - /* Better go there already locked - Jean II */
> - irda_task_execute(self, __irport_change_speed,
> - irport_change_speed_complete,
> - NULL, (void *) speed);
> - dev->trans_start = jiffies;
> - spin_unlock_irqrestore(&self->lock, flags);
> - dev_kfree_skb(skb);
> - return 0;
> - } else
> - self->new_speed = speed;
> - }
> -
> - /* Init tx buffer */
> - self->tx_buff.data = self->tx_buff.head;
> -
> - /* Copy skb to tx_buff while wrapping, stuffing and making CRC */
> - self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data,
> - self->tx_buff.truesize);
> -
> - self->stats.tx_bytes += self->tx_buff.len;
> -
> - /* We are transmitting */
> - self->transmitting = 1;
> -
> - /* Turn on transmit finished interrupt. Will fire immediately! */
> - outb(UART_IER_THRI, iobase+UART_IER);
> -
> - dev->trans_start = jiffies;
> - spin_unlock_irqrestore(&self->lock, flags);
> -
> - dev_kfree_skb(skb);
> -
> - return 0;
> -}
> -
> -/*
> - * Function irport_write (driver)
> - *
> - * Fill Tx FIFO with transmit data
> - *
> - * Called only from irport_write_wakeup()
> - */
> -static inline int irport_write(int iobase, int fifo_size, __u8 *buf, int len)
> -{
> - int actual = 0;
> -
> - /* Fill FIFO with current frame */
> - while ((actual < fifo_size) && (actual < len)) {
> - /* Transmit next byte */
> - outb(buf[actual], iobase+UART_TX);
> -
> - actual++;
> - }
> -
> - return actual;
> -}
> -
> -/*
> - * Function irport_write_wakeup (tty)
> - *
> - * Called by the driver when there's room for more data. If we have
> - * more packets to send, we send them here.
> - *
> - * Called only from irport_interrupt()
> - * Make sure this function is *not* called while we are receiving,
> - * otherwise we will reset fifo and loose data :-(
> - */
> -static inline void irport_write_wakeup(struct irport_cb *self)
> -{
> - int actual = 0;
> - int iobase;
> - unsigned int fcr;
> -
> - IRDA_ASSERT(self != NULL, return;);
> -
> - IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
> -
> - iobase = self->io.sir_base;
> -
> - /* Finished with frame? */
> - if (self->tx_buff.len > 0) {
> - /* Write data left in transmit buffer */
> - actual = irport_write(iobase, self->io.fifo_size,
> - self->tx_buff.data, self->tx_buff.len);
> - self->tx_buff.data += actual;
> - self->tx_buff.len -= actual;
> - } else {
> - /*
> - * Now serial buffer is almost free & we can start
> - * transmission of another packet. But first we must check
> - * if we need to change the speed of the hardware
> - */
> - if (self->new_speed) {
> - irport_wait_hw_transmitter_finish(self);
> - irda_task_execute(self, __irport_change_speed,
> - irport_change_speed_complete,
> - NULL, (void *) self->new_speed);
> - self->new_speed = 0;
> - } else {
> - /* Tell network layer that we want more frames */
> - netif_wake_queue(self->netdev);
> - }
> - self->stats.tx_packets++;
> -
> - /*
> - * Reset Rx FIFO to make sure that all reflected transmit data
> - * is discarded. This is needed for half duplex operation
> - */
> - fcr = irport_get_fcr(self->io.speed);
> - fcr |= UART_FCR_CLEAR_RCVR;
> - outb(fcr, iobase+UART_FCR);
> -
> - /* Finished transmitting */
> - self->transmitting = 0;
> -
> - /* Turn on receive interrupts */
> - outb(UART_IER_RDI, iobase+UART_IER);
> -
> - IRDA_DEBUG(1, "%s() : finished Tx\n", __FUNCTION__);
> - }
> -}
> -
> -/*
> - * Function irport_receive (self)
> - *
> - * Receive one frame from the infrared port
> - *
> - * Called only from irport_interrupt()
> - */
> -static inline void irport_receive(struct irport_cb *self)
> -{
> - int boguscount = 0;
> - int iobase;
> -
> - IRDA_ASSERT(self != NULL, return;);
> -
> - iobase = self->io.sir_base;
> -
> - /*
> - * Receive all characters in Rx FIFO, unwrap and unstuff them.
> - * async_unwrap_char will deliver all found frames
> - */
> - do {
> - async_unwrap_char(self->netdev, &self->stats, &self->rx_buff,
> - inb(iobase+UART_RX));
> -
> - /* Make sure we don't stay here too long */
> - if (boguscount++ > 32) {
> - IRDA_DEBUG(2,"%s(), breaking!\n", __FUNCTION__);
> - break;
> - }
> - } while (inb(iobase+UART_LSR) & UART_LSR_DR);
> -}
> -
> -/*
> - * Function irport_interrupt (irq, dev_id)
> - *
> - * Interrupt handler
> - */
> -static irqreturn_t irport_interrupt(int irq, void *dev_id)
> -{
> - struct net_device *dev = dev_id;
> - struct irport_cb *self;
> - int boguscount = 0;
> - int iobase;
> - int iir, lsr;
> - int handled = 0;
> -
> - self = dev->priv;
> -
> - spin_lock(&self->lock);
> -
> - iobase = self->io.sir_base;
> -
> - /* Cut'n'paste interrupt routine from serial.c
> - * This version try to minimise latency and I/O operations.
> - * Simplified and modified to enforce half duplex operation.
> - * - Jean II */
> -
> - /* Check status even is iir reg is cleared, more robust and
> - * eliminate a read on the I/O bus - Jean II */
> - do {
> - /* Get interrupt status ; Clear interrupt */
> - lsr = inb(iobase+UART_LSR);
> -
> - /* Are we receiving or transmitting ? */
> - if(!self->transmitting) {
> - /* Received something ? */
> - if (lsr & UART_LSR_DR)
> - irport_receive(self);
> - } else {
> - /* Room in Tx fifo ? */
> - if (lsr & (UART_LSR_THRE | UART_LSR_TEMT))
> - irport_write_wakeup(self);
> - }
> -
> - /* A bit hackish, but working as expected... Jean II */
> - if(lsr & (UART_LSR_THRE | UART_LSR_TEMT | UART_LSR_DR))
> - handled = 1;
> -
> - /* Make sure we don't stay here to long */
> - if (boguscount++ > 10) {
> - IRDA_WARNING("%s() irq handler looping : lsr=%02x\n",
> - __FUNCTION__, lsr);
> - break;
> - }
> -
> - /* Read interrupt register */
> - iir = inb(iobase+UART_IIR);
> -
> - /* Enable this debug only when no other options and at low
> - * bit rates, otherwise it may cause Rx overruns (lsr=63).
> - * - Jean II */
> - IRDA_DEBUG(6, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n",
> - __FUNCTION__, iir, lsr, iobase);
> -
> - /* As long as interrupt pending... */
> - } while ((iir & UART_IIR_NO_INT) == 0);
> -
> - spin_unlock(&self->lock);
> - return IRQ_RETVAL(handled);
> -}
> -
> -/*
> - * Function irport_net_open (dev)
> - *
> - * Network device is taken up. Usually this is done by "ifconfig irda0 up"
> - *
> - */
> -static int irport_net_open(struct net_device *dev)
> -{
> - struct irport_cb *self;
> - int iobase;
> - char hwname[16];
> - unsigned long flags;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> -
> - IRDA_ASSERT(dev != NULL, return -1;);
> - self = (struct irport_cb *) dev->priv;
> -
> - iobase = self->io.sir_base;
> -
> - if (request_irq(self->io.irq, self->interrupt, 0, dev->name,
> - (void *) dev)) {
> - IRDA_DEBUG(0, "%s(), unable to allocate irq=%d\n",
> - __FUNCTION__, self->io.irq);
> - return -EAGAIN;
> - }
> -
> - spin_lock_irqsave(&self->lock, flags);
> - /* Init uart */
> - irport_start(self);
> - /* Set 9600 bauds per default, including at the dongle */
> - irda_task_execute(self, __irport_change_speed,
> - irport_change_speed_complete,
> - NULL, (void *) 9600);
> - spin_unlock_irqrestore(&self->lock, flags);
> -
> -
> - /* Give self a hardware name */
> - sprintf(hwname, "SIR @ 0x%03x", self->io.sir_base);
> -
> - /*
> - * Open new IrLAP layer instance, now that everything should be
> - * initialized properly
> - */
> - self->irlap = irlap_open(dev, &self->qos, hwname);
> -
> - /* Ready to play! */
> -
> - netif_start_queue(dev);
> -
> - return 0;
> -}
> -
> -/*
> - * Function irport_net_close (self)
> - *
> - * Network device is taken down. Usually this is done by
> - * "ifconfig irda0 down"
> - */
> -static int irport_net_close(struct net_device *dev)
> -{
> - struct irport_cb *self;
> - int iobase;
> - unsigned long flags;
> -
> - IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
> -
> - IRDA_ASSERT(dev != NULL, return -1;);
> - self = (struct irport_cb *) dev->priv;
> -
> - IRDA_ASSERT(self != NULL, return -1;);
> -
> - iobase = self->io.sir_base;
> -
> - /* Stop device */
> - netif_stop_queue(dev);
> -
> - /* Stop and remove instance of IrLAP */
> - if (self->irlap)
> - irlap_close(self->irlap);
> - self->irlap = NULL;
> -
> - spin_lock_irqsave(&self->lock, flags);
> - irport_stop(self);
> - spin_unlock_irqrestore(&self->lock, flags);
> -
> - free_irq(self->io.irq, dev);
> -
> - return 0;
> -}
> -
> -/*
> - * Function irport_is_receiving (self)
> - *
> - * Returns true is we are currently receiving data
> - *
> - */
> -static inline int irport_is_receiving(struct irport_cb *self)
> -{
> - return (self->rx_buff.state != OUTSIDE_FRAME);
> -}
> -
> -/*
> - * Function irport_set_dtr_rts (tty, dtr, rts)
> - *
> - * This function can be used by dongles etc. to set or reset the status
> - * of the dtr and rts lines
> - */
> -static int irport_set_dtr_rts(struct net_device *dev, int dtr, int rts)
> -{
> - struct irport_cb *self = dev->priv;
> - int iobase;
> -
> - IRDA_ASSERT(self != NULL, return -1;);
> -
> - iobase = self->io.sir_base;
> -
> - if (dtr)
> - dtr = UART_MCR_DTR;
> - if (rts)
> - rts = UART_MCR_RTS;
> -
> - outb(dtr|rts|UART_MCR_OUT2, iobase+UART_MCR);
> -
> - return 0;
> -}
> -
> -static int irport_raw_write(struct net_device *dev, __u8 *buf, int len)
> -{
> - struct irport_cb *self = (struct irport_cb *) dev->priv;
> - int actual = 0;
> - int iobase;
> -
> - IRDA_ASSERT(self != NULL, return -1;);
> -
> - iobase = self->io.sir_base;
> -
> - /* Tx FIFO should be empty! */
> - if (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) {
> - IRDA_DEBUG( 0, "%s(), failed, fifo not empty!\n", __FUNCTION__);
> - return -1;
> - }
> -
> - /* Fill FIFO with current frame */
> - while (actual < len) {
> - /* Transmit next byte */
> - outb(buf[actual], iobase+UART_TX);
> - actual++;
> - }
> -
> - return actual;
> -}
> -
> -/*
> - * Function irport_net_ioctl (dev, rq, cmd)
> - *
> - * Process IOCTL commands for this device
> - *
> - */
> -static int irport_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
> -{
> - struct if_irda_req *irq = (struct if_irda_req *) rq;
> - struct irport_cb *self;
> - dongle_t *dongle;
> - unsigned long flags;
> - int ret = 0;
> -
> - IRDA_ASSERT(dev != NULL, return -1;);
> -
> - self = dev->priv;
> -
> - IRDA_ASSERT(self != NULL, return -1;);
> -
> - IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
> -
> - switch (cmd) {
> - case SIOCSBANDWIDTH: /* Set bandwidth */
> - if (!capable(CAP_NET_ADMIN))
> - ret = -EPERM;
> - else
> - irda_task_execute(self, __irport_change_speed, NULL,
> - NULL, (void *) irq->ifr_baudrate);
> - break;
> - case SIOCSDONGLE: /* Set dongle */
> - if (!capable(CAP_NET_ADMIN)) {
> - ret = -EPERM;
> - break;
> - }
> -
> - /* Locking :
> - * irda_device_dongle_init() can't be locked.
> - * irda_task_execute() doesn't need to be locked.
> - * Jean II
> - */
> -
> - /* Initialize dongle */
> - dongle = irda_device_dongle_init(dev, irq->ifr_dongle);
> - if (!dongle)
> - break;
> -
> - dongle->set_mode = NULL;
> - dongle->read = NULL;
> - dongle->write = irport_raw_write;
> - dongle->set_dtr_rts = irport_set_dtr_rts;
> -
> - /* Now initialize the dongle! */
> - dongle->issue->open(dongle, &self->qos);
> -
> - /* Reset dongle */
> - irda_task_execute(dongle, dongle->issue->reset, NULL, NULL,
> - NULL);
> -
> - /* Make dongle available to driver only now to avoid
> - * race conditions - Jean II */
> - self->dongle = dongle;
> - break;
> - case SIOCSMEDIABUSY: /* Set media busy */
> - if (!capable(CAP_NET_ADMIN)) {
> - ret = -EPERM;
> - break;
> - }
> -
> - irda_device_set_media_busy(self->netdev, TRUE);
> - break;
> - case SIOCGRECEIVING: /* Check if we are receiving right now */
> - irq->ifr_receiving = irport_is_receiving(self);
> - break;
> - case SIOCSDTRRTS:
> - if (!capable(CAP_NET_ADMIN)) {
> - ret = -EPERM;
> - break;
> - }
> -
> - /* No real need to lock... */
> - spin_lock_irqsave(&self->lock, flags);
> - irport_set_dtr_rts(dev, irq->ifr_dtr, irq->ifr_rts);
> - spin_unlock_irqrestore(&self->lock, flags);
> - break;
> - default:
> - ret = -EOPNOTSUPP;
> - }
> -
> - return ret;
> -}
> -
> -static struct net_device_stats *irport_net_get_stats(struct net_device *dev)
> -{
> - struct irport_cb *self = (struct irport_cb *) dev->priv;
> -
> - return &self->stats;
> -}
> -
> -static int __init irport_init(void)
> -{
> - int i;
> -
> - for (i=0; (io[i] < 2000) && (i < ARRAY_SIZE(dev_self)); i++) {
> - if (irport_open(i, io[i], irq[i]) != NULL)
> - return 0;
> - }
> - /*
> - * Maybe something failed, but we can still be usable for FIR drivers
> - */
> - return 0;
> -}
> -
> -/*
> - * Function irport_cleanup ()
> - *
> - * Close all configured ports
> - *
> - */
> -static void __exit irport_cleanup(void)
> -{
> - int i;
> -
> - IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
> -
> - for (i=0; i < ARRAY_SIZE(dev_self); i++) {
> - if (dev_self[i])
> - irport_close(dev_self[i]);
> - }
> -}
> -
> -module_param_array(io, int, NULL, 0);
> -MODULE_PARM_DESC(io, "Base I/O addresses");
> -module_param_array(irq, int, NULL, 0);
> -MODULE_PARM_DESC(irq, "IRQ lines");
> -
> -MODULE_AUTHOR("Dag Brattli <dagb@...uit.no>");
> -MODULE_DESCRIPTION("Half duplex serial driver for IrDA SIR mode");
> -MODULE_LICENSE("GPL");
> -
> -module_init(irport_init);
> -module_exit(irport_cleanup);
> -
> diff --git a/drivers/net/irda/irport.h b/drivers/net/irda/irport.h
> deleted file mode 100644
> index 66fc243..0000000
> --- a/drivers/net/irda/irport.h
> +++ /dev/null
> @@ -1,80 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: irport.h
> - * Version: 0.1
> - * Description: Serial driver for IrDA
> - * Status: Experimental.
> - * Author: Dag Brattli <dagb@...uit.no>
> - * Created at: Sun Aug 3 13:49:59 1997
> - * Modified at: Fri Jan 14 10:21:10 2000
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1997, 1998-2000 Dag Brattli <dagb@...uit.no>
> - * All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * Neither Dag Brattli nor University of Tromsø admit liability nor
> - * provide warranty for any of this software. This material is
> - * provided "AS-IS" and at no charge.
> - *
> - ********************************************************************/
> -
> -#ifndef IRPORT_H
> -#define IRPORT_H
> -
> -#include <linux/netdevice.h>
> -#include <linux/skbuff.h>
> -#include <linux/types.h>
> -#include <linux/spinlock.h>
> -
> -#include <net/irda/irda_device.h>
> -
> -#define SPEED_DEFAULT 9600
> -#define SPEED_MAX 115200
> -
> -/*
> - * These are the supported serial types.
> - */
> -#define PORT_UNKNOWN 0
> -#define PORT_8250 1
> -#define PORT_16450 2
> -#define PORT_16550 3
> -#define PORT_16550A 4
> -#define PORT_CIRRUS 5
> -#define PORT_16650 6
> -#define PORT_MAX 6
> -
> -#define FRAME_MAX_SIZE 2048
> -
> -struct irport_cb {
> - struct net_device *netdev; /* Yes! we are some kind of netdevice */
> - struct net_device_stats stats;
> -
> - struct irlap_cb *irlap; /* The link layer we are attached to */
> -
> - chipio_t io; /* IrDA controller information */
> - iobuff_t tx_buff; /* Transmit buffer */
> - iobuff_t rx_buff; /* Receive buffer */
> -
> - struct qos_info qos; /* QoS capabilities for this device */
> - dongle_t *dongle; /* Dongle driver */
> -
> - __u32 flags; /* Interface flags */
> - __u32 new_speed;
> - int mode;
> - int index; /* Instance index */
> - int transmitting; /* Are we transmitting ? */
> -
> - spinlock_t lock; /* For serializing operations */
> -
> - /* For piggyback drivers */
> - void *priv;
> - void (*change_speed)(void *priv, __u32 speed);
> - irqreturn_t (*interrupt)(int irq, void *dev_id);
> -};
> -
> -#endif /* IRPORT_H */
> diff --git a/drivers/net/irda/litelink.c b/drivers/net/irda/litelink.c
> deleted file mode 100644
> index 7db1143..0000000
> --- a/drivers/net/irda/litelink.c
> +++ /dev/null
> @@ -1,179 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: litelink.c
> - * Version: 1.1
> - * Description: Driver for the Parallax LiteLink dongle
> - * Status: Stable
> - * Author: Dag Brattli <dagb@...uit.no>
> - * Created at: Fri May 7 12:50:33 1999
> - * Modified at: Fri Dec 17 09:14:23 1999
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1999 Dag Brattli, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> - * GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> - * MA 02111-1307 USA
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -#define MIN_DELAY 25 /* 15 us, but wait a little more to be sure */
> -#define MAX_DELAY 10000 /* 1 ms */
> -
> -static void litelink_open(dongle_t *self, struct qos_info *qos);
> -static void litelink_close(dongle_t *self);
> -static int litelink_change_speed(struct irda_task *task);
> -static int litelink_reset(struct irda_task *task);
> -
> -/* These are the baudrates supported */
> -static __u32 baud_rates[] = { 115200, 57600, 38400, 19200, 9600 };
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_LITELINK_DONGLE,
> - .open = litelink_open,
> - .close = litelink_close,
> - .reset = litelink_reset,
> - .change_speed = litelink_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init litelink_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit litelink_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void litelink_open(dongle_t *self, struct qos_info *qos)
> -{
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
> - qos->min_turn_time.bits = 0x7f; /* Needs 0.01 ms */
> -}
> -
> -static void litelink_close(dongle_t *self)
> -{
> - /* Power off dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function litelink_change_speed (task)
> - *
> - * Change speed of the Litelink dongle. To cycle through the available
> - * baud rates, pulse RTS low for a few ms.
> - */
> -static int litelink_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - int i;
> -
> - /* Clear RTS to reset dongle */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* Cycle through avaiable baudrates until we reach the correct one */
> - for (i=0; i<5 && baud_rates[i] != speed; i++) {
> - /* Set DTR, clear RTS */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* Set DTR, Set RTS */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> - }
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return 0;
> -}
> -
> -/*
> - * Function litelink_reset (task)
> - *
> - * Reset the Litelink type dongle.
> - *
> - */
> -static int litelink_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> -
> - /* Power on dongle */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* Clear RTS to reset dongle */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* This dongles speed defaults to 115200 bps */
> - self->speed = 115200;
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return 0;
> -}
> -
> -MODULE_AUTHOR("Dag Brattli <dagb@...uit.no>");
> -MODULE_DESCRIPTION("Parallax Litelink dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-5"); /* IRDA_LITELINK_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize Litelink module
> - *
> - */
> -module_init(litelink_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup Litelink module
> - *
> - */
> -module_exit(litelink_cleanup);
> diff --git a/drivers/net/irda/ma600.c b/drivers/net/irda/ma600.c
> deleted file mode 100644
> index f5e6836..0000000
> --- a/drivers/net/irda/ma600.c
> +++ /dev/null
> @@ -1,354 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: ma600.c
> - * Version: 0.1
> - * Description: Implementation of the MA600 dongle
> - * Status: Experimental.
> - * Author: Leung <95Etwl@...mni.ee.ust.hk> http://www.engsvr.ust/~eetwl95
> - * Created at: Sat Jun 10 20:02:35 2000
> - * Modified at:
> - * Modified by:
> - *
> - * Note: very thanks to Mr. Maru Wang <maru@...ileaction.com.tw> for providing
> - * information on the MA600 dongle
> - *
> - * Copyright (c) 2000 Leung, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> - * GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> - * MA 02111-1307 USA
> - *
> - ********************************************************************/
> -
> -/* define this macro for release version */
> -//#define NDEBUG
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -#ifndef NDEBUG
> - #undef IRDA_DEBUG
> - #define IRDA_DEBUG(n, args...) (printk(KERN_DEBUG args))
> -
> - #undef ASSERT
> - #define ASSERT(expr, func) \
> - if(!(expr)) { \
> - printk( "Assertion failed! %s,%s,%s,line=%d\n",\
> - #expr,__FILE__,__FUNCTION__,__LINE__); \
> - func}
> -#endif
> -
> -/* convert hex value to ascii hex */
> -static const char hexTbl[] = "0123456789ABCDEF";
> -
> -
> -static void ma600_open(dongle_t *self, struct qos_info *qos);
> -static void ma600_close(dongle_t *self);
> -static int ma600_change_speed(struct irda_task *task);
> -static int ma600_reset(struct irda_task *task);
> -
> -/* control byte for MA600 */
> -#define MA600_9600 0x00
> -#define MA600_19200 0x01
> -#define MA600_38400 0x02
> -#define MA600_57600 0x03
> -#define MA600_115200 0x04
> -#define MA600_DEV_ID1 0x05
> -#define MA600_DEV_ID2 0x06
> -#define MA600_2400 0x08
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_MA600_DONGLE,
> - .open = ma600_open,
> - .close = ma600_close,
> - .reset = ma600_reset,
> - .change_speed = ma600_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init ma600_init(void)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit ma600_cleanup(void)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -/*
> - Power on:
> - (0) Clear RTS and DTR for 1 second
> - (1) Set RTS and DTR for 1 second
> - (2) 9600 bps now
> - Note: assume RTS, DTR are clear before
> -*/
> -static void ma600_open(dongle_t *self, struct qos_info *qos)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> -
> - qos->baud_rate.bits &= IR_2400|IR_9600|IR_19200|IR_38400
> - |IR_57600|IR_115200;
> - qos->min_turn_time.bits = 0x01; /* Needs at least 1 ms */
> - irda_qos_bits_to_value(qos);
> -
> - //self->set_dtr_rts(self->dev, FALSE, FALSE);
> - // should wait 1 second
> -
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - // should wait 1 second
> -}
> -
> -static void ma600_close(dongle_t *self)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> -
> - /* Power off dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -static __u8 get_control_byte(__u32 speed)
> -{
> - __u8 byte;
> -
> - switch (speed) {
> - default:
> - case 115200:
> - byte = MA600_115200;
> - break;
> - case 57600:
> - byte = MA600_57600;
> - break;
> - case 38400:
> - byte = MA600_38400;
> - break;
> - case 19200:
> - byte = MA600_19200;
> - break;
> - case 9600:
> - byte = MA600_9600;
> - break;
> - case 2400:
> - byte = MA600_2400;
> - break;
> - }
> -
> - return byte;
> -}
> -
> -/*
> - * Function ma600_change_speed (dev, state, speed)
> - *
> - * Set the speed for the MA600 type dongle. Warning, this
> - * function must be called with a process context!
> - *
> - * Algorithm
> - * 1. Reset
> - * 2. clear RTS, set DTR and wait for 1ms
> - * 3. send Control Byte to the MA600 through TXD to set new baud rate
> - * wait until the stop bit of Control Byte is sent (for 9600 baud rate,
> - * it takes about 10 msec)
> - * 4. set RTS, set DTR (return to NORMAL Operation)
> - * 5. wait at least 10 ms, new setting (baud rate, etc) takes effect here
> - * after
> - */
> -static int ma600_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - static __u8 byte;
> - __u8 byte_echo;
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> -
> - ASSERT(task != NULL, return -1;);
> -
> - if (self->speed_task && self->speed_task != task) {
> - IRDA_DEBUG(0, "%s(), busy!\n", __FUNCTION__);
> - return msecs_to_jiffies(10);
> - } else {
> - self->speed_task = task;
> - }
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - case IRDA_TASK_CHILD_INIT:
> - /*
> - * Need to reset the dongle and go to 9600 bps before
> - * programming
> - */
> - if (irda_task_execute(self, ma600_reset, NULL, task,
> - (void *) speed)) {
> - /* Dongle need more time to reset */
> - irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
> -
> - /* give 1 second to finish */
> - ret = msecs_to_jiffies(1000);
> - } else {
> - irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
> - }
> - break;
> -
> - case IRDA_TASK_CHILD_WAIT:
> - IRDA_WARNING("%s(), resetting dongle timed out!\n",
> - __FUNCTION__);
> - ret = -1;
> - break;
> -
> - case IRDA_TASK_CHILD_DONE:
> - /* Set DTR, Clear RTS */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> -
> - ret = msecs_to_jiffies(1); /* Sleep 1 ms */
> - irda_task_next_state(task, IRDA_TASK_WAIT);
> - break;
> -
> - case IRDA_TASK_WAIT:
> - speed = (__u32) task->param;
> - byte = get_control_byte(speed);
> -
> - /* Write control byte */
> - self->write(self->dev, &byte, sizeof(byte));
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT1);
> -
> - /* Wait at least 10 ms */
> - ret = msecs_to_jiffies(15);
> - break;
> -
> - case IRDA_TASK_WAIT1:
> - /* Read control byte echo */
> - self->read(self->dev, &byte_echo, sizeof(byte_echo));
> -
> - if(byte != byte_echo) {
> - /* if control byte != echo, I don't know what to do */
> - printk(KERN_WARNING "%s() control byte written != read!\n", __FUNCTION__);
> - printk(KERN_WARNING "control byte = 0x%c%c\n",
> - hexTbl[(byte>>4)&0x0f], hexTbl[byte&0x0f]);
> - printk(KERN_WARNING "byte echo = 0x%c%c\n",
> - hexTbl[(byte_echo>>4) & 0x0f],
> - hexTbl[byte_echo & 0x0f]);
> - #ifndef NDEBUG
> - } else {
> - IRDA_DEBUG(2, "%s() control byte write read OK\n", __FUNCTION__);
> - #endif
> - }
> -
> - /* Set DTR, Set RTS */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT2);
> -
> - /* Wait at least 10 ms */
> - ret = msecs_to_jiffies(10);
> - break;
> -
> - case IRDA_TASK_WAIT2:
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - break;
> -
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -/*
> - * Function ma600_reset (driver)
> - *
> - * This function resets the ma600 dongle. Warning, this function
> - * must be called with a process context!!
> - *
> - * Algorithm:
> - * 0. DTR=0, RTS=1 and wait 10 ms
> - * 1. DTR=1, RTS=1 and wait 10 ms
> - * 2. 9600 bps now
> - */
> -int ma600_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> -
> - ASSERT(task != NULL, return -1;);
> -
> - if (self->reset_task && self->reset_task != task) {
> - IRDA_DEBUG(0, "%s(), busy!\n", __FUNCTION__);
> - return msecs_to_jiffies(10);
> - } else
> - self->reset_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - /* Clear DTR and Set RTS */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> - irda_task_next_state(task, IRDA_TASK_WAIT1);
> - ret = msecs_to_jiffies(10); /* Sleep 10 ms */
> - break;
> - case IRDA_TASK_WAIT1:
> - /* Set DTR and RTS */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - irda_task_next_state(task, IRDA_TASK_WAIT2);
> - ret = msecs_to_jiffies(10); /* Sleep 10 ms */
> - break;
> - case IRDA_TASK_WAIT2:
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - ret = -1;
> - }
> - return ret;
> -}
> -
> -MODULE_AUTHOR("Leung <95Etwl@...mni.ee.ust.hk> http://www.engsvr.ust/~eetwl95");
> -MODULE_DESCRIPTION("MA600 dongle driver version 0.1");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-11"); /* IRDA_MA600_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize MA600 module
> - *
> - */
> -module_init(ma600_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup MA600 module
> - *
> - */
> -module_exit(ma600_cleanup);
> -
> diff --git a/drivers/net/irda/mcp2120.c b/drivers/net/irda/mcp2120.c
> deleted file mode 100644
> index 5e6199e..0000000
> --- a/drivers/net/irda/mcp2120.c
> +++ /dev/null
> @@ -1,240 +0,0 @@
> -/*********************************************************************
> - *
> - *
> - * Filename: mcp2120.c
> - * Version: 1.0
> - * Description: Implementation for the MCP2120 (Microchip)
> - * Status: Experimental.
> - * Author: Felix Tang (tangf@...tap.org)
> - * Created at: Sun Mar 31 19:32:12 EST 2002
> - * Based on code by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 2002 Felix Tang, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -static int mcp2120_reset(struct irda_task *task);
> -static void mcp2120_open(dongle_t *self, struct qos_info *qos);
> -static void mcp2120_close(dongle_t *self);
> -static int mcp2120_change_speed(struct irda_task *task);
> -
> -#define MCP2120_9600 0x87
> -#define MCP2120_19200 0x8B
> -#define MCP2120_38400 0x85
> -#define MCP2120_57600 0x83
> -#define MCP2120_115200 0x81
> -
> -#define MCP2120_COMMIT 0x11
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_MCP2120_DONGLE,
> - .open = mcp2120_open,
> - .close = mcp2120_close,
> - .reset = mcp2120_reset,
> - .change_speed = mcp2120_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init mcp2120_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit mcp2120_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void mcp2120_open(dongle_t *self, struct qos_info *qos)
> -{
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
> - qos->min_turn_time.bits = 0x01;
> -}
> -
> -static void mcp2120_close(dongle_t *self)
> -{
> - /* Power off dongle */
> - /* reset and inhibit mcp2120 */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - //self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function mcp2120_change_speed (dev, speed)
> - *
> - * Set the speed for the MCP2120.
> - *
> - */
> -static int mcp2120_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - __u8 control[2];
> - int ret = 0;
> -
> - self->speed_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - /* Need to reset the dongle and go to 9600 bps before
> - programming */
> - //printk("Dmcp2120_change_speed irda_task_init\n");
> - if (irda_task_execute(self, mcp2120_reset, NULL, task,
> - (void *) speed))
> - {
> - /* Dongle need more time to reset */
> - irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
> -
> - /* Give reset 1 sec to finish */
> - ret = msecs_to_jiffies(1000);
> - }
> - break;
> - case IRDA_TASK_CHILD_WAIT:
> - IRDA_WARNING("%s(), resetting dongle timed out!\n",
> - __FUNCTION__);
> - ret = -1;
> - break;
> - case IRDA_TASK_CHILD_DONE:
> - /* Set DTR to enter command mode */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> - udelay(500);
> -
> - switch (speed) {
> - case 9600:
> - default:
> - control[0] = MCP2120_9600;
> - //printk("mcp2120 9600\n");
> - break;
> - case 19200:
> - control[0] = MCP2120_19200;
> - //printk("mcp2120 19200\n");
> - break;
> - case 34800:
> - control[0] = MCP2120_38400;
> - //printk("mcp2120 38400\n");
> - break;
> - case 57600:
> - control[0] = MCP2120_57600;
> - //printk("mcp2120 57600\n");
> - break;
> - case 115200:
> - control[0] = MCP2120_115200;
> - //printk("mcp2120 115200\n");
> - break;
> - }
> - control[1] = MCP2120_COMMIT;
> -
> - /* Write control bytes */
> - self->write(self->dev, control, 2);
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT);
> - ret = msecs_to_jiffies(100);
> - //printk("mcp2120_change_speed irda_child_done\n");
> - break;
> - case IRDA_TASK_WAIT:
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - //printk("mcp2120_change_speed irda_task_wait\n");
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -/*
> - * Function mcp2120_reset (driver)
> - *
> - * This function resets the mcp2120 dongle.
> - *
> - * Info: -set RTS to reset mcp2120
> - * -set DTR to set mcp2120 software command mode
> - * -mcp2120 defaults to 9600 baud after reset
> - *
> - * Algorithm:
> - * 0. Set RTS to reset mcp2120.
> - * 1. Clear RTS and wait for device reset timer of 30 ms (max).
> - *
> - */
> -
> -
> -static int mcp2120_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - int ret = 0;
> -
> - self->reset_task = task;
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - //printk("mcp2120_reset irda_task_init\n");
> - /* Reset dongle by setting RTS*/
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> - irda_task_next_state(task, IRDA_TASK_WAIT1);
> - ret = msecs_to_jiffies(50);
> - break;
> - case IRDA_TASK_WAIT1:
> - //printk("mcp2120_reset irda_task_wait1\n");
> - /* clear RTS and wait for at least 30 ms. */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> - irda_task_next_state(task, IRDA_TASK_WAIT2);
> - ret = msecs_to_jiffies(50);
> - break;
> - case IRDA_TASK_WAIT2:
> - //printk("mcp2120_reset irda_task_wait2\n");
> - /* Go back to normal mode */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -MODULE_AUTHOR("Felix Tang <tangf@...tap.org>");
> -MODULE_DESCRIPTION("Microchip MCP2120");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-9"); /* IRDA_MCP2120_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize MCP2120 module
> - *
> - */
> -module_init(mcp2120_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup MCP2120 module
> - *
> - */
> -module_exit(mcp2120_cleanup);
> diff --git a/drivers/net/irda/old_belkin.c b/drivers/net/irda/old_belkin.c
> deleted file mode 100644
> index 26f81fd..0000000
> --- a/drivers/net/irda/old_belkin.c
> +++ /dev/null
> @@ -1,164 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: old_belkin.c
> - * Version: 1.1
> - * Description: Driver for the Belkin (old) SmartBeam dongle
> - * Status: Experimental...
> - * Author: Jean Tourrilhes <jt@....hp.com>
> - * Created at: 22/11/99
> - * Modified at: Fri Dec 17 09:13:32 1999
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1999 Jean Tourrilhes, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> - * GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
> - * MA 02111-1307 USA
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -/*
> - * Belkin is selling a dongle called the SmartBeam.
> - * In fact, there is two hardware version of this dongle, of course with
> - * the same name and looking the exactly same (grrr...).
> - * I guess that I've got the old one, because inside I don't have
> - * a jumper for IrDA/ASK...
> - *
> - * As far as I can make it from info on their web site, the old dongle
> - * support only 9600 b/s, which make our life much simpler as far as
> - * the driver is concerned, but you might not like it very much ;-)
> - * The new SmartBeam does 115 kb/s, and I've not tested it...
> - *
> - * Belkin claim that the correct driver for the old dongle (in Windows)
> - * is the generic Parallax 9500a driver, but the Linux LiteLink driver
> - * fails for me (probably because Linux-IrDA doesn't rate fallback),
> - * so I created this really dumb driver...
> - *
> - * In fact, this driver doesn't do much. The only thing it does is to
> - * prevent Linux-IrDA to use any other speed than 9600 b/s ;-) This
> - * driver is called "old_belkin" so that when the new SmartBeam is supported
> - * its driver can be called "belkin" instead of "new_belkin".
> - *
> - * Note : this driver was written without any info/help from Belkin,
> - * so a lot of info here might be totally wrong. Blame me ;-)
> - */
> -
> -/* Let's guess */
> -#define MIN_DELAY 25 /* 15 us, but wait a little more to be sure */
> -
> -static void old_belkin_open(dongle_t *self, struct qos_info *qos);
> -static void old_belkin_close(dongle_t *self);
> -static int old_belkin_change_speed(struct irda_task *task);
> -static int old_belkin_reset(struct irda_task *task);
> -
> -/* These are the baudrates supported */
> -/* static __u32 baud_rates[] = { 9600 }; */
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_OLD_BELKIN_DONGLE,
> - .open = old_belkin_open,
> - .close = old_belkin_close,
> - .reset = old_belkin_reset,
> - .change_speed = old_belkin_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init old_belkin_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit old_belkin_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void old_belkin_open(dongle_t *self, struct qos_info *qos)
> -{
> - /* Not too fast, please... */
> - qos->baud_rate.bits &= IR_9600;
> - /* Needs at least 10 ms (totally wild guess, can do probably better) */
> - qos->min_turn_time.bits = 0x01;
> -}
> -
> -static void old_belkin_close(dongle_t *self)
> -{
> - /* Power off dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -}
> -
> -/*
> - * Function old_belkin_change_speed (task)
> - *
> - * With only one speed available, not much to do...
> - */
> -static int old_belkin_change_speed(struct irda_task *task)
> -{
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return 0;
> -}
> -
> -/*
> - * Function old_belkin_reset (task)
> - *
> - * Reset the Old-Belkin type dongle.
> - *
> - */
> -static int old_belkin_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> -
> - /* Power on dongle */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Sleep a minimum of 15 us */
> - udelay(MIN_DELAY);
> -
> - /* This dongles speed "defaults" to 9600 bps ;-) */
> - self->speed = 9600;
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> -
> - return 0;
> -}
> -
> -MODULE_AUTHOR("Jean Tourrilhes <jt@....hp.com>");
> -MODULE_DESCRIPTION("Belkin (old) SmartBeam dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-7"); /* IRDA_OLD_BELKIN_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize Old-Belkin module
> - *
> - */
> -module_init(old_belkin_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup Old-Belkin module
> - *
> - */
> -module_exit(old_belkin_cleanup);
> diff --git a/drivers/net/irda/tekram.c b/drivers/net/irda/tekram.c
> deleted file mode 100644
> index 9bfd244..0000000
> --- a/drivers/net/irda/tekram.c
> +++ /dev/null
> @@ -1,282 +0,0 @@
> -/*********************************************************************
> - *
> - * Filename: tekram.c
> - * Version: 1.2
> - * Description: Implementation of the Tekram IrMate IR-210B dongle
> - * Status: Experimental.
> - * Author: Dag Brattli <dagb@...uit.no>
> - * Created at: Wed Oct 21 20:02:35 1998
> - * Modified at: Fri Dec 17 09:13:09 1999
> - * Modified by: Dag Brattli <dagb@...uit.no>
> - *
> - * Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
> - *
> - * Neither Dag Brattli nor University of Tromsø admit liability nor
> - * provide warranty for any of this software. This material is
> - * provided "AS-IS" and at no charge.
> - *
> - ********************************************************************/
> -
> -#include <linux/module.h>
> -#include <linux/delay.h>
> -#include <linux/tty.h>
> -#include <linux/init.h>
> -
> -#include <net/irda/irda.h>
> -#include <net/irda/irda_device.h>
> -
> -static void tekram_open(dongle_t *self, struct qos_info *qos);
> -static void tekram_close(dongle_t *self);
> -static int tekram_change_speed(struct irda_task *task);
> -static int tekram_reset(struct irda_task *task);
> -
> -#define TEKRAM_115200 0x00
> -#define TEKRAM_57600 0x01
> -#define TEKRAM_38400 0x02
> -#define TEKRAM_19200 0x03
> -#define TEKRAM_9600 0x04
> -
> -#define TEKRAM_PW 0x10 /* Pulse select bit */
> -
> -static struct dongle_reg dongle = {
> - .type = IRDA_TEKRAM_DONGLE,
> - .open = tekram_open,
> - .close = tekram_close,
> - .reset = tekram_reset,
> - .change_speed = tekram_change_speed,
> - .owner = THIS_MODULE,
> -};
> -
> -static int __init tekram_init(void)
> -{
> - return irda_device_register_dongle(&dongle);
> -}
> -
> -static void __exit tekram_cleanup(void)
> -{
> - irda_device_unregister_dongle(&dongle);
> -}
> -
> -static void tekram_open(dongle_t *self, struct qos_info *qos)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - qos->baud_rate.bits &= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
> - qos->min_turn_time.bits = 0x01; /* Needs at least 10 ms */
> - irda_qos_bits_to_value(qos);
> -}
> -
> -static void tekram_close(dongle_t *self)
> -{
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - /* Power off dongle */
> - self->set_dtr_rts(self->dev, FALSE, FALSE);
> -
> - if (self->reset_task)
> - irda_task_delete(self->reset_task);
> - if (self->speed_task)
> - irda_task_delete(self->speed_task);
> -}
> -
> -/*
> - * Function tekram_change_speed (dev, state, speed)
> - *
> - * Set the speed for the Tekram IRMate 210 type dongle. Warning, this
> - * function must be called with a process context!
> - *
> - * Algorithm
> - * 1. clear DTR
> - * 2. set RTS, and wait at least 7 us
> - * 3. send Control Byte to the IR-210 through TXD to set new baud rate
> - * wait until the stop bit of Control Byte is sent (for 9600 baud rate,
> - * it takes about 100 msec)
> - * 5. clear RTS (return to NORMAL Operation)
> - * 6. wait at least 50 us, new setting (baud rate, etc) takes effect here
> - * after
> - */
> -static int tekram_change_speed(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - __u32 speed = (__u32) task->param;
> - __u8 byte;
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - IRDA_ASSERT(task != NULL, return -1;);
> -
> - if (self->speed_task && self->speed_task != task) {
> - IRDA_DEBUG(0, "%s(), busy!\n", __FUNCTION__ );
> - return msecs_to_jiffies(10);
> - } else
> - self->speed_task = task;
> -
> - switch (speed) {
> - default:
> - case 9600:
> - byte = TEKRAM_PW|TEKRAM_9600;
> - break;
> - case 19200:
> - byte = TEKRAM_PW|TEKRAM_19200;
> - break;
> - case 38400:
> - byte = TEKRAM_PW|TEKRAM_38400;
> - break;
> - case 57600:
> - byte = TEKRAM_PW|TEKRAM_57600;
> - break;
> - case 115200:
> - byte = TEKRAM_115200;
> - break;
> - }
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - case IRDA_TASK_CHILD_INIT:
> - /*
> - * Need to reset the dongle and go to 9600 bps before
> - * programming
> - */
> - if (irda_task_execute(self, tekram_reset, NULL, task,
> - (void *) speed))
> - {
> - /* Dongle need more time to reset */
> - irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
> -
> - /* Give reset 1 sec to finish */
> - ret = msecs_to_jiffies(1000);
> - } else
> - irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
> - break;
> - case IRDA_TASK_CHILD_WAIT:
> - IRDA_WARNING("%s(), resetting dongle timed out!\n",
> - __FUNCTION__);
> - ret = -1;
> - break;
> - case IRDA_TASK_CHILD_DONE:
> - /* Set DTR, Clear RTS */
> - self->set_dtr_rts(self->dev, TRUE, FALSE);
> -
> - /* Wait at least 7us */
> - udelay(14);
> -
> - /* Write control byte */
> - self->write(self->dev, &byte, 1);
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT);
> -
> - /* Wait at least 100 ms */
> - ret = msecs_to_jiffies(150);
> - break;
> - case IRDA_TASK_WAIT:
> - /* Set DTR, Set RTS */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->speed_task = NULL;
> - ret = -1;
> - break;
> - }
> - return ret;
> -}
> -
> -/*
> - * Function tekram_reset (driver)
> - *
> - * This function resets the tekram dongle. Warning, this function
> - * must be called with a process context!!
> - *
> - * Algorithm:
> - * 0. Clear RTS and DTR, and wait 50 ms (power off the IR-210 )
> - * 1. clear RTS
> - * 2. set DTR, and wait at least 1 ms
> - * 3. clear DTR to SPACE state, wait at least 50 us for further
> - * operation
> - */
> -int tekram_reset(struct irda_task *task)
> -{
> - dongle_t *self = (dongle_t *) task->instance;
> - int ret = 0;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
> -
> - IRDA_ASSERT(task != NULL, return -1;);
> -
> - if (self->reset_task && self->reset_task != task) {
> - IRDA_DEBUG(0, "%s(), busy!\n", __FUNCTION__ );
> - return msecs_to_jiffies(10);
> - } else
> - self->reset_task = task;
> -
> - /* Power off dongle */
> - //self->set_dtr_rts(self->dev, FALSE, FALSE);
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - switch (task->state) {
> - case IRDA_TASK_INIT:
> - irda_task_next_state(task, IRDA_TASK_WAIT1);
> -
> - /* Sleep 50 ms */
> - ret = msecs_to_jiffies(50);
> - break;
> - case IRDA_TASK_WAIT1:
> - /* Clear DTR, Set RTS */
> - self->set_dtr_rts(self->dev, FALSE, TRUE);
> -
> - irda_task_next_state(task, IRDA_TASK_WAIT2);
> -
> - /* Should sleep 1 ms */
> - ret = msecs_to_jiffies(1);
> - break;
> - case IRDA_TASK_WAIT2:
> - /* Set DTR, Set RTS */
> - self->set_dtr_rts(self->dev, TRUE, TRUE);
> -
> - /* Wait at least 50 us */
> - udelay(75);
> -
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - break;
> - default:
> - IRDA_ERROR("%s(), unknown state %d\n",
> - __FUNCTION__, task->state);
> - irda_task_next_state(task, IRDA_TASK_DONE);
> - self->reset_task = NULL;
> - ret = -1;
> - }
> - return ret;
> -}
> -
> -MODULE_AUTHOR("Dag Brattli <dagb@...uit.no>");
> -MODULE_DESCRIPTION("Tekram IrMate IR-210B dongle driver");
> -MODULE_LICENSE("GPL");
> -MODULE_ALIAS("irda-dongle-0"); /* IRDA_TEKRAM_DONGLE */
> -
> -/*
> - * Function init_module (void)
> - *
> - * Initialize Tekram module
> - *
> - */
> -module_init(tekram_init);
> -
> -/*
> - * Function cleanup_module (void)
> - *
> - * Cleanup Tekram module
> - *
> - */
> -module_exit(tekram_cleanup);
> diff --git a/include/net/irda/irda_device.h b/include/net/irda/irda_device.h
> index bca19ca..f70e9b3 100644
> --- a/include/net/irda/irda_device.h
> +++ b/include/net/irda/irda_device.h
> @@ -228,21 +228,8 @@ static inline int irda_device_txqueue_empty(const struct net_device *dev)
> int irda_device_set_raw_mode(struct net_device* self, int status);
> struct net_device *alloc_irdadev(int sizeof_priv);
>
> -/* Dongle interface */
> -void irda_device_unregister_dongle(struct dongle_reg *dongle);
> -int irda_device_register_dongle(struct dongle_reg *dongle);
> -dongle_t *irda_device_dongle_init(struct net_device *dev, int type);
> -int irda_device_dongle_cleanup(dongle_t *dongle);
> -
> void irda_setup_dma(int channel, dma_addr_t buffer, int count, int mode);
>
> -void irda_task_delete(struct irda_task *task);
> -struct irda_task *irda_task_execute(void *instance,
> - IRDA_TASK_CALLBACK function,
> - IRDA_TASK_CALLBACK finished,
> - struct irda_task *parent, void *param);
> -void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state);
> -
> /*
> * Function irda_get_mtt (skb)
> *
> diff --git a/net/irda/irda_device.c b/net/irda/irda_device.c
> index 435b563..8718591 100644
> --- a/net/irda/irda_device.c
> +++ b/net/irda/irda_device.c
> @@ -57,20 +57,6 @@ static void __irda_task_delete(struct irda_task *task);
> static hashbin_t *dongles = NULL;
> static hashbin_t *tasks = NULL;
>
> -#ifdef CONFIG_IRDA_DEBUG
> -static const char *task_state[] = {
> - "IRDA_TASK_INIT",
> - "IRDA_TASK_DONE",
> - "IRDA_TASK_WAIT",
> - "IRDA_TASK_WAIT1",
> - "IRDA_TASK_WAIT2",
> - "IRDA_TASK_WAIT3",
> - "IRDA_TASK_CHILD_INIT",
> - "IRDA_TASK_CHILD_WAIT",
> - "IRDA_TASK_CHILD_DONE",
> -};
> -#endif /* CONFIG_IRDA_DEBUG */
> -
> static void irda_task_timer_expired(void *data);
>
> int __init irda_device_init( void)
> @@ -176,14 +162,6 @@ int irda_device_is_receiving(struct net_device *dev)
> return req.ifr_receiving;
> }
>
> -void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state)
> -{
> - IRDA_DEBUG(2, "%s(), state = %s\n", __FUNCTION__, task_state[state]);
> -
> - task->state = state;
> -}
> -EXPORT_SYMBOL(irda_task_next_state);
> -
> static void __irda_task_delete(struct irda_task *task)
> {
> del_timer(&task->timer);
> @@ -191,14 +169,13 @@ static void __irda_task_delete(struct irda_task *task)
> kfree(task);
> }
>
> -void irda_task_delete(struct irda_task *task)
> +static void irda_task_delete(struct irda_task *task)
> {
> /* Unregister task */
> hashbin_remove(tasks, (long) task, NULL);
>
> __irda_task_delete(task);
> }
> -EXPORT_SYMBOL(irda_task_delete);
>
> /*
> * Function irda_task_kick (task)
> @@ -272,51 +249,6 @@ static int irda_task_kick(struct irda_task *task)
> }
>
> /*
> - * Function irda_task_execute (instance, function, finished)
> - *
> - * This function registers and tries to execute tasks that may take some
> - * time to complete. We do it this hairy way since we may have been
> - * called from interrupt context, so it's not possible to use
> - * schedule_timeout()
> - * Two important notes :
> - * o Make sure you irda_task_delete(task); in case you delete the
> - * calling instance.
> - * o No real need to lock when calling this function, but you may
> - * want to lock within the task handler.
> - * Jean II
> - */
> -struct irda_task *irda_task_execute(void *instance,
> - IRDA_TASK_CALLBACK function,
> - IRDA_TASK_CALLBACK finished,
> - struct irda_task *parent, void *param)
> -{
> - struct irda_task *task;
> -
> - IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
> -
> - task = kmalloc(sizeof(struct irda_task), GFP_ATOMIC);
> - if (!task)
> - return NULL;
> -
> - task->state = IRDA_TASK_INIT;
> - task->instance = instance;
> - task->function = function;
> - task->finished = finished;
> - task->parent = parent;
> - task->param = param;
> - task->magic = IRDA_TASK_MAGIC;
> -
> - init_timer(&task->timer);
> -
> - /* Register task */
> - hashbin_insert(tasks, (irda_queue_t *) task, (long) task, NULL);
> -
> - /* No time to waste, so lets get going! */
> - return irda_task_kick(task) ? NULL : task;
> -}
> -EXPORT_SYMBOL(irda_task_execute);
> -
> -/*
> * Function irda_task_timer_expired (data)
> *
> * Task time has expired. We now try to execute task (again), and restart
> @@ -364,105 +296,6 @@ struct net_device *alloc_irdadev(int sizeof_priv)
> }
> EXPORT_SYMBOL(alloc_irdadev);
>
> -/*
> - * Function irda_device_init_dongle (self, type, qos)
> - *
> - * Initialize attached dongle.
> - *
> - * Important : request_module require us to call this function with
> - * a process context and irq enabled. - Jean II
> - */
> -dongle_t *irda_device_dongle_init(struct net_device *dev, int type)
> -{
> - struct dongle_reg *reg;
> - dongle_t *dongle = kzalloc(sizeof(dongle_t), GFP_KERNEL);
> -
> - might_sleep();
> -
> - spin_lock(&dongles->hb_spinlock);
> - reg = hashbin_find(dongles, type, NULL);
> -
> -#ifdef CONFIG_KMOD
> - /* Try to load the module needed */
> - if (!reg && capable(CAP_SYS_MODULE)) {
> - spin_unlock(&dongles->hb_spinlock);
> -
> - request_module("irda-dongle-%d", type);
> -
> - spin_lock(&dongles->hb_spinlock);
> - reg = hashbin_find(dongles, type, NULL);
> - }
> -#endif
> -
> - if (!reg || !try_module_get(reg->owner) ) {
> - IRDA_ERROR("IrDA: Unable to find requested dongle type %x\n",
> - type);
> - kfree(dongle);
> - dongle = NULL;
> - }
> - if (dongle) {
> - /* Bind the registration info to this particular instance */
> - dongle->issue = reg;
> - dongle->dev = dev;
> - }
> - spin_unlock(&dongles->hb_spinlock);
> - return dongle;
> -}
> -EXPORT_SYMBOL(irda_device_dongle_init);
> -
> -/*
> - * Function irda_device_dongle_cleanup (dongle)
> - */
> -int irda_device_dongle_cleanup(dongle_t *dongle)
> -{
> - IRDA_ASSERT(dongle != NULL, return -1;);
> -
> - dongle->issue->close(dongle);
> - module_put(dongle->issue->owner);
> - kfree(dongle);
> -
> - return 0;
> -}
> -EXPORT_SYMBOL(irda_device_dongle_cleanup);
> -
> -/*
> - * Function irda_device_register_dongle (dongle)
> - */
> -int irda_device_register_dongle(struct dongle_reg *new)
> -{
> - spin_lock(&dongles->hb_spinlock);
> - /* Check if this dongle has been registered before */
> - if (hashbin_find(dongles, new->type, NULL)) {
> - IRDA_MESSAGE("%s: Dongle type %x already registered\n",
> - __FUNCTION__, new->type);
> - } else {
> - /* Insert IrDA dongle into hashbin */
> - hashbin_insert(dongles, (irda_queue_t *) new, new->type, NULL);
> - }
> - spin_unlock(&dongles->hb_spinlock);
> -
> - return 0;
> -}
> -EXPORT_SYMBOL(irda_device_register_dongle);
> -
> -/*
> - * Function irda_device_unregister_dongle (dongle)
> - *
> - * Unregister dongle, and remove dongle from list of registered dongles
> - *
> - */
> -void irda_device_unregister_dongle(struct dongle_reg *dongle)
> -{
> - struct dongle *node;
> -
> - spin_lock(&dongles->hb_spinlock);
> - node = hashbin_remove(dongles, dongle->type, NULL);
> - if (!node)
> - IRDA_ERROR("%s: dongle not found!\n", __FUNCTION__);
> - spin_unlock(&dongles->hb_spinlock);
> -}
> -EXPORT_SYMBOL(irda_device_unregister_dongle);
> -
> #ifdef CONFIG_ISA_DMA_API
> /*
> * Function setup_dma (idev, buffer, count, mode)
>
>
--
To unsubscribe from this list: send the line "unsubscribe netdev" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Powered by blists - more mailing lists