2005-04-16 15:20:36 -07:00
|
|
|
/*********************************************************************
|
|
|
|
*
|
|
|
|
* Filename: irport.c
|
|
|
|
* Version: 1.0
|
|
|
|
* Description: Half duplex serial port SIR driver for IrDA.
|
|
|
|
* Status: Experimental.
|
|
|
|
* Author: Dag Brattli <dagb@cs.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@cs.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);
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 06:55:46 -07:00
|
|
|
static irqreturn_t irport_interrupt(int irq, void *dev_id);
|
2005-04-16 15:20:36 -07:00
|
|
|
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) {
|
2006-12-13 01:35:56 -07:00
|
|
|
self->tx_buff.head = kmalloc(self->tx_buff.truesize,
|
2005-04-16 15:20:36 -07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (self->tx_buff.head == NULL) {
|
|
|
|
IRDA_ERROR("%s(), can't allocate memory for "
|
|
|
|
"transmit buffer!\n", __FUNCTION__);
|
|
|
|
goto err_out4;
|
|
|
|
}
|
|
|
|
memset(self->tx_buff.head, 0, self->tx_buff.truesize);
|
|
|
|
}
|
|
|
|
self->tx_buff.data = self->tx_buff.head;
|
|
|
|
|
|
|
|
self->netdev = dev;
|
|
|
|
/* Keep track of module usage */
|
|
|
|
SET_MODULE_OWNER(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);
|
|
|
|
|
2005-10-28 13:53:13 -07:00
|
|
|
kfree(self->tx_buff.head);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
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
|
|
|
|
*
|
|
|
|
*/
|
2006-01-09 21:54:00 -07:00
|
|
|
static int __irport_change_speed(struct irda_task *task)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
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 !
|
2006-06-26 09:35:02 -07:00
|
|
|
* This is ugly, and unsafe is the spinlock is not already acquired.
|
2005-04-16 15:20:36 -07:00
|
|
|
* 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=%d\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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 06:55:46 -07:00
|
|
|
* Function irport_interrupt (irq, dev_id)
|
2005-04-16 15:20:36 -07:00
|
|
|
*
|
|
|
|
* Interrupt handler
|
|
|
|
*/
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 06:55:46 -07:00
|
|
|
static irqreturn_t irport_interrupt(int irq, void *dev_id)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-10-06 11:56:04 -07:00
|
|
|
struct net_device *dev = dev_id;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct irport_cb *self;
|
|
|
|
int boguscount = 0;
|
|
|
|
int iobase;
|
|
|
|
int iir, lsr;
|
|
|
|
int handled = 0;
|
|
|
|
|
2006-10-06 11:56:04 -07:00
|
|
|
self = dev->priv;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2006-08-15 00:05:38 -07:00
|
|
|
for (i=0; (io[i] < 2000) && (i < ARRAY_SIZE(dev_self)); i++) {
|
2005-04-16 15:20:36 -07:00
|
|
|
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__);
|
|
|
|
|
2006-08-15 00:05:38 -07:00
|
|
|
for (i=0; i < ARRAY_SIZE(dev_self); i++) {
|
2005-04-16 15:20:36 -07:00
|
|
|
if (dev_self[i])
|
|
|
|
irport_close(dev_self[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-25 04:07:05 -07:00
|
|
|
module_param_array(io, int, NULL, 0);
|
2005-04-16 15:20:36 -07:00
|
|
|
MODULE_PARM_DESC(io, "Base I/O addresses");
|
2006-03-25 04:07:05 -07:00
|
|
|
module_param_array(irq, int, NULL, 0);
|
2005-04-16 15:20:36 -07:00
|
|
|
MODULE_PARM_DESC(irq, "IRQ lines");
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
|
|
|
|
MODULE_DESCRIPTION("Half duplex serial driver for IrDA SIR mode");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
module_init(irport_init);
|
|
|
|
module_exit(irport_cleanup);
|
|
|
|
|