[IrDA]: Irport removal - part 2 (16b4d60b) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/net/irda/act200l.c

deleted100644 → 0

+0 −297

Original line number	Diff line number	Diff line
		/*********************************************************************
		*
		* Filename: act200l.c
		* Version: 0.8
		* Description: Implementation for the ACTiSYS ACT-IR200L dongle
		* Status: Experimental.
		* Author: SHIMIZU Takuya <tshimizu@ga2.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@ga2.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@ga2.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);

drivers/net/irda/actisys.c

deleted100644 → 0

+0 −288

Original line number	Diff line number	Diff line
		/*********************************************************************
		*
		* Filename: actisys.c
		* Version: 1.0
		* Description: Implementation for the ACTiSYS IR-220L and IR-220L+
		* dongles
		* Status: Beta.
		* Authors: Dag Brattli <dagb@cs.uit.no> (initially)
		* Jean Tourrilhes <jt@hpl.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@cs.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@cs.uit.no> - Jean Tourrilhes <jt@hpl.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);

drivers/net/irda/ep7211_ir.c

deleted100644 → 0

+0 −125

Original line number	Diff line number	Diff line
		/*
		* 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@bluemug.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);

drivers/net/irda/esi.c

deleted100644 → 0

+0 −149

Original line number	Diff line number	Diff line
		/*********************************************************************
		*
		* Filename: esi.c
		* Version: 1.5
		* Description: Driver for the Extended Systems JetEye PC dongle
		* Status: Experimental.
		* Author: Dag Brattli <dagb@cs.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@cs.uit.no>
		*
		* Copyright (c) 1999 Dag Brattli, <dagb@cs.uit.no>,
		* Copyright (c) 1998 Thomas Davis, <ratbert@radiks.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@cs.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);

drivers/net/irda/girbil.c

deleted100644 → 0

+0 −250

File deleted.

Preview size limit exceeded, changes collapsed.