![David Howells](/assets/img/avatar_default.png)
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)
1044 lines
22 KiB
C
1044 lines
22 KiB
C
/*
|
|
* linux/drivers/net/irda/sa1100_ir.c
|
|
*
|
|
* Copyright (C) 2000-2001 Russell King
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* Infra-red driver for the StrongARM SA1100 embedded microprocessor
|
|
*
|
|
* Note that we don't have to worry about the SA1111's DMA bugs in here,
|
|
* so we use the straight forward dma_map_* functions with a null pointer.
|
|
*
|
|
* This driver takes one kernel command line parameter, sa1100ir=, with
|
|
* the following options:
|
|
* max_rate:baudrate - set the maximum baud rate
|
|
* power_leve:level - set the transmitter power level
|
|
* tx_lpm:0|1 - set transmit low power mode
|
|
*/
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/types.h>
|
|
#include <linux/init.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <net/irda/irda.h>
|
|
#include <net/irda/wrapper.h>
|
|
#include <net/irda/irda_device.h>
|
|
|
|
#include <asm/irq.h>
|
|
#include <asm/dma.h>
|
|
#include <asm/hardware.h>
|
|
#include <asm/mach/irda.h>
|
|
|
|
static int power_level = 3;
|
|
static int tx_lpm;
|
|
static int max_rate = 4000000;
|
|
|
|
struct sa1100_irda {
|
|
unsigned char hscr0;
|
|
unsigned char utcr4;
|
|
unsigned char power;
|
|
unsigned char open;
|
|
|
|
int speed;
|
|
int newspeed;
|
|
|
|
struct sk_buff *txskb;
|
|
struct sk_buff *rxskb;
|
|
dma_addr_t txbuf_dma;
|
|
dma_addr_t rxbuf_dma;
|
|
dma_regs_t *txdma;
|
|
dma_regs_t *rxdma;
|
|
|
|
struct net_device_stats stats;
|
|
struct device *dev;
|
|
struct irda_platform_data *pdata;
|
|
struct irlap_cb *irlap;
|
|
struct qos_info qos;
|
|
|
|
iobuff_t tx_buff;
|
|
iobuff_t rx_buff;
|
|
};
|
|
|
|
#define IS_FIR(si) ((si)->speed >= 4000000)
|
|
|
|
#define HPSIR_MAX_RXLEN 2047
|
|
|
|
/*
|
|
* Allocate and map the receive buffer, unless it is already allocated.
|
|
*/
|
|
static int sa1100_irda_rx_alloc(struct sa1100_irda *si)
|
|
{
|
|
if (si->rxskb)
|
|
return 0;
|
|
|
|
si->rxskb = alloc_skb(HPSIR_MAX_RXLEN + 1, GFP_ATOMIC);
|
|
|
|
if (!si->rxskb) {
|
|
printk(KERN_ERR "sa1100_ir: out of memory for RX SKB\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/*
|
|
* Align any IP headers that may be contained
|
|
* within the frame.
|
|
*/
|
|
skb_reserve(si->rxskb, 1);
|
|
|
|
si->rxbuf_dma = dma_map_single(si->dev, si->rxskb->data,
|
|
HPSIR_MAX_RXLEN,
|
|
DMA_FROM_DEVICE);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* We want to get here as soon as possible, and get the receiver setup.
|
|
* We use the existing buffer.
|
|
*/
|
|
static void sa1100_irda_rx_dma_start(struct sa1100_irda *si)
|
|
{
|
|
if (!si->rxskb) {
|
|
printk(KERN_ERR "sa1100_ir: rx buffer went missing\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* First empty receive FIFO
|
|
*/
|
|
Ser2HSCR0 = si->hscr0 | HSCR0_HSSP;
|
|
|
|
/*
|
|
* Enable the DMA, receiver and receive interrupt.
|
|
*/
|
|
sa1100_clear_dma(si->rxdma);
|
|
sa1100_start_dma(si->rxdma, si->rxbuf_dma, HPSIR_MAX_RXLEN);
|
|
Ser2HSCR0 = si->hscr0 | HSCR0_HSSP | HSCR0_RXE;
|
|
}
|
|
|
|
/*
|
|
* Set the IrDA communications speed.
|
|
*/
|
|
static int sa1100_irda_set_speed(struct sa1100_irda *si, int speed)
|
|
{
|
|
unsigned long flags;
|
|
int brd, ret = -EINVAL;
|
|
|
|
switch (speed) {
|
|
case 9600: case 19200: case 38400:
|
|
case 57600: case 115200:
|
|
brd = 3686400 / (16 * speed) - 1;
|
|
|
|
/*
|
|
* Stop the receive DMA.
|
|
*/
|
|
if (IS_FIR(si))
|
|
sa1100_stop_dma(si->rxdma);
|
|
|
|
local_irq_save(flags);
|
|
|
|
Ser2UTCR3 = 0;
|
|
Ser2HSCR0 = HSCR0_UART;
|
|
|
|
Ser2UTCR1 = brd >> 8;
|
|
Ser2UTCR2 = brd;
|
|
|
|
/*
|
|
* Clear status register
|
|
*/
|
|
Ser2UTSR0 = UTSR0_REB | UTSR0_RBB | UTSR0_RID;
|
|
Ser2UTCR3 = UTCR3_RIE | UTCR3_RXE | UTCR3_TXE;
|
|
|
|
if (si->pdata->set_speed)
|
|
si->pdata->set_speed(si->dev, speed);
|
|
|
|
si->speed = speed;
|
|
|
|
local_irq_restore(flags);
|
|
ret = 0;
|
|
break;
|
|
|
|
case 4000000:
|
|
local_irq_save(flags);
|
|
|
|
si->hscr0 = 0;
|
|
|
|
Ser2HSSR0 = 0xff;
|
|
Ser2HSCR0 = si->hscr0 | HSCR0_HSSP;
|
|
Ser2UTCR3 = 0;
|
|
|
|
si->speed = speed;
|
|
|
|
if (si->pdata->set_speed)
|
|
si->pdata->set_speed(si->dev, speed);
|
|
|
|
sa1100_irda_rx_alloc(si);
|
|
sa1100_irda_rx_dma_start(si);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Control the power state of the IrDA transmitter.
|
|
* State:
|
|
* 0 - off
|
|
* 1 - short range, lowest power
|
|
* 2 - medium range, medium power
|
|
* 3 - maximum range, high power
|
|
*
|
|
* Currently, only assabet is known to support this.
|
|
*/
|
|
static int
|
|
__sa1100_irda_set_power(struct sa1100_irda *si, unsigned int state)
|
|
{
|
|
int ret = 0;
|
|
if (si->pdata->set_power)
|
|
ret = si->pdata->set_power(si->dev, state);
|
|
return ret;
|
|
}
|
|
|
|
static inline int
|
|
sa1100_set_power(struct sa1100_irda *si, unsigned int state)
|
|
{
|
|
int ret;
|
|
|
|
ret = __sa1100_irda_set_power(si, state);
|
|
if (ret == 0)
|
|
si->power = state;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int sa1100_irda_startup(struct sa1100_irda *si)
|
|
{
|
|
int ret;
|
|
|
|
/*
|
|
* Ensure that the ports for this device are setup correctly.
|
|
*/
|
|
if (si->pdata->startup)
|
|
si->pdata->startup(si->dev);
|
|
|
|
/*
|
|
* Configure PPC for IRDA - we want to drive TXD2 low.
|
|
* We also want to drive this pin low during sleep.
|
|
*/
|
|
PPSR &= ~PPC_TXD2;
|
|
PSDR &= ~PPC_TXD2;
|
|
PPDR |= PPC_TXD2;
|
|
|
|
/*
|
|
* Enable HP-SIR modulation, and ensure that the port is disabled.
|
|
*/
|
|
Ser2UTCR3 = 0;
|
|
Ser2HSCR0 = HSCR0_UART;
|
|
Ser2UTCR4 = si->utcr4;
|
|
Ser2UTCR0 = UTCR0_8BitData;
|
|
Ser2HSCR2 = HSCR2_TrDataH | HSCR2_RcDataL;
|
|
|
|
/*
|
|
* Clear status register
|
|
*/
|
|
Ser2UTSR0 = UTSR0_REB | UTSR0_RBB | UTSR0_RID;
|
|
|
|
ret = sa1100_irda_set_speed(si, si->speed = 9600);
|
|
if (ret) {
|
|
Ser2UTCR3 = 0;
|
|
Ser2HSCR0 = 0;
|
|
|
|
if (si->pdata->shutdown)
|
|
si->pdata->shutdown(si->dev);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void sa1100_irda_shutdown(struct sa1100_irda *si)
|
|
{
|
|
/*
|
|
* Stop all DMA activity.
|
|
*/
|
|
sa1100_stop_dma(si->rxdma);
|
|
sa1100_stop_dma(si->txdma);
|
|
|
|
/* Disable the port. */
|
|
Ser2UTCR3 = 0;
|
|
Ser2HSCR0 = 0;
|
|
|
|
if (si->pdata->shutdown)
|
|
si->pdata->shutdown(si->dev);
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
/*
|
|
* Suspend the IrDA interface.
|
|
*/
|
|
static int sa1100_irda_suspend(struct platform_device *pdev, pm_message_t state)
|
|
{
|
|
struct net_device *dev = platform_get_drvdata(pdev);
|
|
struct sa1100_irda *si;
|
|
|
|
if (!dev)
|
|
return 0;
|
|
|
|
si = dev->priv;
|
|
if (si->open) {
|
|
/*
|
|
* Stop the transmit queue
|
|
*/
|
|
netif_device_detach(dev);
|
|
disable_irq(dev->irq);
|
|
sa1100_irda_shutdown(si);
|
|
__sa1100_irda_set_power(si, 0);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Resume the IrDA interface.
|
|
*/
|
|
static int sa1100_irda_resume(struct platform_device *pdev)
|
|
{
|
|
struct net_device *dev = platform_get_drvdata(pdev);
|
|
struct sa1100_irda *si;
|
|
|
|
if (!dev)
|
|
return 0;
|
|
|
|
si = dev->priv;
|
|
if (si->open) {
|
|
/*
|
|
* If we missed a speed change, initialise at the new speed
|
|
* directly. It is debatable whether this is actually
|
|
* required, but in the interests of continuing from where
|
|
* we left off it is desireable. The converse argument is
|
|
* that we should re-negotiate at 9600 baud again.
|
|
*/
|
|
if (si->newspeed) {
|
|
si->speed = si->newspeed;
|
|
si->newspeed = 0;
|
|
}
|
|
|
|
sa1100_irda_startup(si);
|
|
__sa1100_irda_set_power(si, si->power);
|
|
enable_irq(dev->irq);
|
|
|
|
/*
|
|
* This automatically wakes up the queue
|
|
*/
|
|
netif_device_attach(dev);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
#define sa1100_irda_suspend NULL
|
|
#define sa1100_irda_resume NULL
|
|
#endif
|
|
|
|
/*
|
|
* HP-SIR format interrupt service routines.
|
|
*/
|
|
static void sa1100_irda_hpsir_irq(struct net_device *dev)
|
|
{
|
|
struct sa1100_irda *si = dev->priv;
|
|
int status;
|
|
|
|
status = Ser2UTSR0;
|
|
|
|
/*
|
|
* Deal with any receive errors first. The bytes in error may be
|
|
* the only bytes in the receive FIFO, so we do this first.
|
|
*/
|
|
while (status & UTSR0_EIF) {
|
|
int stat, data;
|
|
|
|
stat = Ser2UTSR1;
|
|
data = Ser2UTDR;
|
|
|
|
if (stat & (UTSR1_FRE | UTSR1_ROR)) {
|
|
si->stats.rx_errors++;
|
|
if (stat & UTSR1_FRE)
|
|
si->stats.rx_frame_errors++;
|
|
if (stat & UTSR1_ROR)
|
|
si->stats.rx_fifo_errors++;
|
|
} else
|
|
async_unwrap_char(dev, &si->stats, &si->rx_buff, data);
|
|
|
|
status = Ser2UTSR0;
|
|
}
|
|
|
|
/*
|
|
* We must clear certain bits.
|
|
*/
|
|
Ser2UTSR0 = status & (UTSR0_RID | UTSR0_RBB | UTSR0_REB);
|
|
|
|
if (status & UTSR0_RFS) {
|
|
/*
|
|
* There are at least 4 bytes in the FIFO. Read 3 bytes
|
|
* and leave the rest to the block below.
|
|
*/
|
|
async_unwrap_char(dev, &si->stats, &si->rx_buff, Ser2UTDR);
|
|
async_unwrap_char(dev, &si->stats, &si->rx_buff, Ser2UTDR);
|
|
async_unwrap_char(dev, &si->stats, &si->rx_buff, Ser2UTDR);
|
|
}
|
|
|
|
if (status & (UTSR0_RFS | UTSR0_RID)) {
|
|
/*
|
|
* Fifo contains more than 1 character.
|
|
*/
|
|
do {
|
|
async_unwrap_char(dev, &si->stats, &si->rx_buff,
|
|
Ser2UTDR);
|
|
} while (Ser2UTSR1 & UTSR1_RNE);
|
|
|
|
dev->last_rx = jiffies;
|
|
}
|
|
|
|
if (status & UTSR0_TFS && si->tx_buff.len) {
|
|
/*
|
|
* Transmitter FIFO is not full
|
|
*/
|
|
do {
|
|
Ser2UTDR = *si->tx_buff.data++;
|
|
si->tx_buff.len -= 1;
|
|
} while (Ser2UTSR1 & UTSR1_TNF && si->tx_buff.len);
|
|
|
|
if (si->tx_buff.len == 0) {
|
|
si->stats.tx_packets++;
|
|
si->stats.tx_bytes += si->tx_buff.data -
|
|
si->tx_buff.head;
|
|
|
|
/*
|
|
* We need to ensure that the transmitter has
|
|
* finished.
|
|
*/
|
|
do
|
|
rmb();
|
|
while (Ser2UTSR1 & UTSR1_TBY);
|
|
|
|
/*
|
|
* Ok, we've finished transmitting. Now enable
|
|
* the receiver. Sometimes we get a receive IRQ
|
|
* immediately after a transmit...
|
|
*/
|
|
Ser2UTSR0 = UTSR0_REB | UTSR0_RBB | UTSR0_RID;
|
|
Ser2UTCR3 = UTCR3_RIE | UTCR3_RXE | UTCR3_TXE;
|
|
|
|
if (si->newspeed) {
|
|
sa1100_irda_set_speed(si, si->newspeed);
|
|
si->newspeed = 0;
|
|
}
|
|
|
|
/* I'm hungry! */
|
|
netif_wake_queue(dev);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void sa1100_irda_fir_error(struct sa1100_irda *si, struct net_device *dev)
|
|
{
|
|
struct sk_buff *skb = si->rxskb;
|
|
dma_addr_t dma_addr;
|
|
unsigned int len, stat, data;
|
|
|
|
if (!skb) {
|
|
printk(KERN_ERR "sa1100_ir: SKB is NULL!\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Get the current data position.
|
|
*/
|
|
dma_addr = sa1100_get_dma_pos(si->rxdma);
|
|
len = dma_addr - si->rxbuf_dma;
|
|
if (len > HPSIR_MAX_RXLEN)
|
|
len = HPSIR_MAX_RXLEN;
|
|
dma_unmap_single(si->dev, si->rxbuf_dma, len, DMA_FROM_DEVICE);
|
|
|
|
do {
|
|
/*
|
|
* Read Status, and then Data.
|
|
*/
|
|
stat = Ser2HSSR1;
|
|
rmb();
|
|
data = Ser2HSDR;
|
|
|
|
if (stat & (HSSR1_CRE | HSSR1_ROR)) {
|
|
si->stats.rx_errors++;
|
|
if (stat & HSSR1_CRE)
|
|
si->stats.rx_crc_errors++;
|
|
if (stat & HSSR1_ROR)
|
|
si->stats.rx_frame_errors++;
|
|
} else
|
|
skb->data[len++] = data;
|
|
|
|
/*
|
|
* If we hit the end of frame, there's
|
|
* no point in continuing.
|
|
*/
|
|
if (stat & HSSR1_EOF)
|
|
break;
|
|
} while (Ser2HSSR0 & HSSR0_EIF);
|
|
|
|
if (stat & HSSR1_EOF) {
|
|
si->rxskb = NULL;
|
|
|
|
skb_put(skb, len);
|
|
skb->dev = dev;
|
|
skb->mac.raw = skb->data;
|
|
skb->protocol = htons(ETH_P_IRDA);
|
|
si->stats.rx_packets++;
|
|
si->stats.rx_bytes += len;
|
|
|
|
/*
|
|
* Before we pass the buffer up, allocate a new one.
|
|
*/
|
|
sa1100_irda_rx_alloc(si);
|
|
|
|
netif_rx(skb);
|
|
dev->last_rx = jiffies;
|
|
} else {
|
|
/*
|
|
* Remap the buffer.
|
|
*/
|
|
si->rxbuf_dma = dma_map_single(si->dev, si->rxskb->data,
|
|
HPSIR_MAX_RXLEN,
|
|
DMA_FROM_DEVICE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* FIR format interrupt service routine. We only have to
|
|
* handle RX events; transmit events go via the TX DMA handler.
|
|
*
|
|
* No matter what, we disable RX, process, and the restart RX.
|
|
*/
|
|
static void sa1100_irda_fir_irq(struct net_device *dev)
|
|
{
|
|
struct sa1100_irda *si = dev->priv;
|
|
|
|
/*
|
|
* Stop RX DMA
|
|
*/
|
|
sa1100_stop_dma(si->rxdma);
|
|
|
|
/*
|
|
* Framing error - we throw away the packet completely.
|
|
* Clearing RXE flushes the error conditions and data
|
|
* from the fifo.
|
|
*/
|
|
if (Ser2HSSR0 & (HSSR0_FRE | HSSR0_RAB)) {
|
|
si->stats.rx_errors++;
|
|
|
|
if (Ser2HSSR0 & HSSR0_FRE)
|
|
si->stats.rx_frame_errors++;
|
|
|
|
/*
|
|
* Clear out the DMA...
|
|
*/
|
|
Ser2HSCR0 = si->hscr0 | HSCR0_HSSP;
|
|
|
|
/*
|
|
* Clear selected status bits now, so we
|
|
* don't miss them next time around.
|
|
*/
|
|
Ser2HSSR0 = HSSR0_FRE | HSSR0_RAB;
|
|
}
|
|
|
|
/*
|
|
* Deal with any receive errors. The any of the lowest
|
|
* 8 bytes in the FIFO may contain an error. We must read
|
|
* them one by one. The "error" could even be the end of
|
|
* packet!
|
|
*/
|
|
if (Ser2HSSR0 & HSSR0_EIF)
|
|
sa1100_irda_fir_error(si, dev);
|
|
|
|
/*
|
|
* No matter what happens, we must restart reception.
|
|
*/
|
|
sa1100_irda_rx_dma_start(si);
|
|
}
|
|
|
|
static irqreturn_t sa1100_irda_irq(int irq, void *dev_id)
|
|
{
|
|
struct net_device *dev = dev_id;
|
|
if (IS_FIR(((struct sa1100_irda *)dev->priv)))
|
|
sa1100_irda_fir_irq(dev);
|
|
else
|
|
sa1100_irda_hpsir_irq(dev);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/*
|
|
* TX DMA completion handler.
|
|
*/
|
|
static void sa1100_irda_txdma_irq(void *id)
|
|
{
|
|
struct net_device *dev = id;
|
|
struct sa1100_irda *si = dev->priv;
|
|
struct sk_buff *skb = si->txskb;
|
|
|
|
si->txskb = NULL;
|
|
|
|
/*
|
|
* Wait for the transmission to complete. Unfortunately,
|
|
* the hardware doesn't give us an interrupt to indicate
|
|
* "end of frame".
|
|
*/
|
|
do
|
|
rmb();
|
|
while (!(Ser2HSSR0 & HSSR0_TUR) || Ser2HSSR1 & HSSR1_TBY);
|
|
|
|
/*
|
|
* Clear the transmit underrun bit.
|
|
*/
|
|
Ser2HSSR0 = HSSR0_TUR;
|
|
|
|
/*
|
|
* Do we need to change speed? Note that we're lazy
|
|
* here - we don't free the old rxskb. We don't need
|
|
* to allocate a buffer either.
|
|
*/
|
|
if (si->newspeed) {
|
|
sa1100_irda_set_speed(si, si->newspeed);
|
|
si->newspeed = 0;
|
|
}
|
|
|
|
/*
|
|
* Start reception. This disables the transmitter for
|
|
* us. This will be using the existing RX buffer.
|
|
*/
|
|
sa1100_irda_rx_dma_start(si);
|
|
|
|
/*
|
|
* Account and free the packet.
|
|
*/
|
|
if (skb) {
|
|
dma_unmap_single(si->dev, si->txbuf_dma, skb->len, DMA_TO_DEVICE);
|
|
si->stats.tx_packets ++;
|
|
si->stats.tx_bytes += skb->len;
|
|
dev_kfree_skb_irq(skb);
|
|
}
|
|
|
|
/*
|
|
* Make sure that the TX queue is available for sending
|
|
* (for retries). TX has priority over RX at all times.
|
|
*/
|
|
netif_wake_queue(dev);
|
|
}
|
|
|
|
static int sa1100_irda_hard_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
{
|
|
struct sa1100_irda *si = dev->priv;
|
|
int speed = irda_get_next_speed(skb);
|
|
|
|
/*
|
|
* Does this packet contain a request to change the interface
|
|
* speed? If so, remember it until we complete the transmission
|
|
* of this frame.
|
|
*/
|
|
if (speed != si->speed && speed != -1)
|
|
si->newspeed = speed;
|
|
|
|
/*
|
|
* If this is an empty frame, we can bypass a lot.
|
|
*/
|
|
if (skb->len == 0) {
|
|
if (si->newspeed) {
|
|
si->newspeed = 0;
|
|
sa1100_irda_set_speed(si, speed);
|
|
}
|
|
dev_kfree_skb(skb);
|
|
return 0;
|
|
}
|
|
|
|
if (!IS_FIR(si)) {
|
|
netif_stop_queue(dev);
|
|
|
|
si->tx_buff.data = si->tx_buff.head;
|
|
si->tx_buff.len = async_wrap_skb(skb, si->tx_buff.data,
|
|
si->tx_buff.truesize);
|
|
|
|
/*
|
|
* Set the transmit interrupt enable. This will fire
|
|
* off an interrupt immediately. Note that we disable
|
|
* the receiver so we won't get spurious characteres
|
|
* received.
|
|
*/
|
|
Ser2UTCR3 = UTCR3_TIE | UTCR3_TXE;
|
|
|
|
dev_kfree_skb(skb);
|
|
} else {
|
|
int mtt = irda_get_mtt(skb);
|
|
|
|
/*
|
|
* We must not be transmitting...
|
|
*/
|
|
BUG_ON(si->txskb);
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
si->txskb = skb;
|
|
si->txbuf_dma = dma_map_single(si->dev, skb->data,
|
|
skb->len, DMA_TO_DEVICE);
|
|
|
|
sa1100_start_dma(si->txdma, si->txbuf_dma, skb->len);
|
|
|
|
/*
|
|
* If we have a mean turn-around time, impose the specified
|
|
* specified delay. We could shorten this by timing from
|
|
* the point we received the packet.
|
|
*/
|
|
if (mtt)
|
|
udelay(mtt);
|
|
|
|
Ser2HSCR0 = si->hscr0 | HSCR0_HSSP | HSCR0_TXE;
|
|
}
|
|
|
|
dev->trans_start = jiffies;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
sa1100_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
|
|
{
|
|
struct if_irda_req *rq = (struct if_irda_req *)ifreq;
|
|
struct sa1100_irda *si = dev->priv;
|
|
int ret = -EOPNOTSUPP;
|
|
|
|
switch (cmd) {
|
|
case SIOCSBANDWIDTH:
|
|
if (capable(CAP_NET_ADMIN)) {
|
|
/*
|
|
* We are unable to set the speed if the
|
|
* device is not running.
|
|
*/
|
|
if (si->open) {
|
|
ret = sa1100_irda_set_speed(si,
|
|
rq->ifr_baudrate);
|
|
} else {
|
|
printk("sa1100_irda_ioctl: SIOCSBANDWIDTH: !netif_running\n");
|
|
ret = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SIOCSMEDIABUSY:
|
|
ret = -EPERM;
|
|
if (capable(CAP_NET_ADMIN)) {
|
|
irda_device_set_media_busy(dev, TRUE);
|
|
ret = 0;
|
|
}
|
|
break;
|
|
|
|
case SIOCGRECEIVING:
|
|
rq->ifr_receiving = IS_FIR(si) ? 0
|
|
: si->rx_buff.state != OUTSIDE_FRAME;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct net_device_stats *sa1100_irda_stats(struct net_device *dev)
|
|
{
|
|
struct sa1100_irda *si = dev->priv;
|
|
return &si->stats;
|
|
}
|
|
|
|
static int sa1100_irda_start(struct net_device *dev)
|
|
{
|
|
struct sa1100_irda *si = dev->priv;
|
|
int err;
|
|
|
|
si->speed = 9600;
|
|
|
|
err = request_irq(dev->irq, sa1100_irda_irq, 0, dev->name, dev);
|
|
if (err)
|
|
goto err_irq;
|
|
|
|
err = sa1100_request_dma(DMA_Ser2HSSPRd, "IrDA receive",
|
|
NULL, NULL, &si->rxdma);
|
|
if (err)
|
|
goto err_rx_dma;
|
|
|
|
err = sa1100_request_dma(DMA_Ser2HSSPWr, "IrDA transmit",
|
|
sa1100_irda_txdma_irq, dev, &si->txdma);
|
|
if (err)
|
|
goto err_tx_dma;
|
|
|
|
/*
|
|
* The interrupt must remain disabled for now.
|
|
*/
|
|
disable_irq(dev->irq);
|
|
|
|
/*
|
|
* Setup the serial port for the specified speed.
|
|
*/
|
|
err = sa1100_irda_startup(si);
|
|
if (err)
|
|
goto err_startup;
|
|
|
|
/*
|
|
* Open a new IrLAP layer instance.
|
|
*/
|
|
si->irlap = irlap_open(dev, &si->qos, "sa1100");
|
|
err = -ENOMEM;
|
|
if (!si->irlap)
|
|
goto err_irlap;
|
|
|
|
/*
|
|
* Now enable the interrupt and start the queue
|
|
*/
|
|
si->open = 1;
|
|
sa1100_set_power(si, power_level); /* low power mode */
|
|
enable_irq(dev->irq);
|
|
netif_start_queue(dev);
|
|
return 0;
|
|
|
|
err_irlap:
|
|
si->open = 0;
|
|
sa1100_irda_shutdown(si);
|
|
err_startup:
|
|
sa1100_free_dma(si->txdma);
|
|
err_tx_dma:
|
|
sa1100_free_dma(si->rxdma);
|
|
err_rx_dma:
|
|
free_irq(dev->irq, dev);
|
|
err_irq:
|
|
return err;
|
|
}
|
|
|
|
static int sa1100_irda_stop(struct net_device *dev)
|
|
{
|
|
struct sa1100_irda *si = dev->priv;
|
|
|
|
disable_irq(dev->irq);
|
|
sa1100_irda_shutdown(si);
|
|
|
|
/*
|
|
* If we have been doing DMA receive, make sure we
|
|
* tidy that up cleanly.
|
|
*/
|
|
if (si->rxskb) {
|
|
dma_unmap_single(si->dev, si->rxbuf_dma, HPSIR_MAX_RXLEN,
|
|
DMA_FROM_DEVICE);
|
|
dev_kfree_skb(si->rxskb);
|
|
si->rxskb = NULL;
|
|
}
|
|
|
|
/* Stop IrLAP */
|
|
if (si->irlap) {
|
|
irlap_close(si->irlap);
|
|
si->irlap = NULL;
|
|
}
|
|
|
|
netif_stop_queue(dev);
|
|
si->open = 0;
|
|
|
|
/*
|
|
* Free resources
|
|
*/
|
|
sa1100_free_dma(si->txdma);
|
|
sa1100_free_dma(si->rxdma);
|
|
free_irq(dev->irq, dev);
|
|
|
|
sa1100_set_power(si, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sa1100_irda_init_iobuf(iobuff_t *io, int size)
|
|
{
|
|
io->head = kmalloc(size, GFP_KERNEL | GFP_DMA);
|
|
if (io->head != NULL) {
|
|
io->truesize = size;
|
|
io->in_frame = FALSE;
|
|
io->state = OUTSIDE_FRAME;
|
|
io->data = io->head;
|
|
}
|
|
return io->head ? 0 : -ENOMEM;
|
|
}
|
|
|
|
static int sa1100_irda_probe(struct platform_device *pdev)
|
|
{
|
|
struct net_device *dev;
|
|
struct sa1100_irda *si;
|
|
unsigned int baudrate_mask;
|
|
int err;
|
|
|
|
if (!pdev->dev.platform_data)
|
|
return -EINVAL;
|
|
|
|
err = request_mem_region(__PREG(Ser2UTCR0), 0x24, "IrDA") ? 0 : -EBUSY;
|
|
if (err)
|
|
goto err_mem_1;
|
|
err = request_mem_region(__PREG(Ser2HSCR0), 0x1c, "IrDA") ? 0 : -EBUSY;
|
|
if (err)
|
|
goto err_mem_2;
|
|
err = request_mem_region(__PREG(Ser2HSCR2), 0x04, "IrDA") ? 0 : -EBUSY;
|
|
if (err)
|
|
goto err_mem_3;
|
|
|
|
dev = alloc_irdadev(sizeof(struct sa1100_irda));
|
|
if (!dev)
|
|
goto err_mem_4;
|
|
|
|
si = dev->priv;
|
|
si->dev = &pdev->dev;
|
|
si->pdata = pdev->dev.platform_data;
|
|
|
|
/*
|
|
* Initialise the HP-SIR buffers
|
|
*/
|
|
err = sa1100_irda_init_iobuf(&si->rx_buff, 14384);
|
|
if (err)
|
|
goto err_mem_5;
|
|
err = sa1100_irda_init_iobuf(&si->tx_buff, 4000);
|
|
if (err)
|
|
goto err_mem_5;
|
|
|
|
dev->hard_start_xmit = sa1100_irda_hard_xmit;
|
|
dev->open = sa1100_irda_start;
|
|
dev->stop = sa1100_irda_stop;
|
|
dev->do_ioctl = sa1100_irda_ioctl;
|
|
dev->get_stats = sa1100_irda_stats;
|
|
dev->irq = IRQ_Ser2ICP;
|
|
|
|
irda_init_max_qos_capabilies(&si->qos);
|
|
|
|
/*
|
|
* We support original IRDA up to 115k2. (we don't currently
|
|
* support 4Mbps). Min Turn Time set to 1ms or greater.
|
|
*/
|
|
baudrate_mask = IR_9600;
|
|
|
|
switch (max_rate) {
|
|
case 4000000: baudrate_mask |= IR_4000000 << 8;
|
|
case 115200: baudrate_mask |= IR_115200;
|
|
case 57600: baudrate_mask |= IR_57600;
|
|
case 38400: baudrate_mask |= IR_38400;
|
|
case 19200: baudrate_mask |= IR_19200;
|
|
}
|
|
|
|
si->qos.baud_rate.bits &= baudrate_mask;
|
|
si->qos.min_turn_time.bits = 7;
|
|
|
|
irda_qos_bits_to_value(&si->qos);
|
|
|
|
si->utcr4 = UTCR4_HPSIR;
|
|
if (tx_lpm)
|
|
si->utcr4 |= UTCR4_Z1_6us;
|
|
|
|
/*
|
|
* Initially enable HP-SIR modulation, and ensure that the port
|
|
* is disabled.
|
|
*/
|
|
Ser2UTCR3 = 0;
|
|
Ser2UTCR4 = si->utcr4;
|
|
Ser2HSCR0 = HSCR0_UART;
|
|
|
|
err = register_netdev(dev);
|
|
if (err == 0)
|
|
platform_set_drvdata(pdev, dev);
|
|
|
|
if (err) {
|
|
err_mem_5:
|
|
kfree(si->tx_buff.head);
|
|
kfree(si->rx_buff.head);
|
|
free_netdev(dev);
|
|
err_mem_4:
|
|
release_mem_region(__PREG(Ser2HSCR2), 0x04);
|
|
err_mem_3:
|
|
release_mem_region(__PREG(Ser2HSCR0), 0x1c);
|
|
err_mem_2:
|
|
release_mem_region(__PREG(Ser2UTCR0), 0x24);
|
|
}
|
|
err_mem_1:
|
|
return err;
|
|
}
|
|
|
|
static int sa1100_irda_remove(struct platform_device *pdev)
|
|
{
|
|
struct net_device *dev = platform_get_drvdata(pdev);
|
|
|
|
if (dev) {
|
|
struct sa1100_irda *si = dev->priv;
|
|
unregister_netdev(dev);
|
|
kfree(si->tx_buff.head);
|
|
kfree(si->rx_buff.head);
|
|
free_netdev(dev);
|
|
}
|
|
|
|
release_mem_region(__PREG(Ser2HSCR2), 0x04);
|
|
release_mem_region(__PREG(Ser2HSCR0), 0x1c);
|
|
release_mem_region(__PREG(Ser2UTCR0), 0x24);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver sa1100ir_driver = {
|
|
.probe = sa1100_irda_probe,
|
|
.remove = sa1100_irda_remove,
|
|
.suspend = sa1100_irda_suspend,
|
|
.resume = sa1100_irda_resume,
|
|
.driver = {
|
|
.name = "sa11x0-ir",
|
|
},
|
|
};
|
|
|
|
static int __init sa1100_irda_init(void)
|
|
{
|
|
/*
|
|
* Limit power level a sensible range.
|
|
*/
|
|
if (power_level < 1)
|
|
power_level = 1;
|
|
if (power_level > 3)
|
|
power_level = 3;
|
|
|
|
return platform_driver_register(&sa1100ir_driver);
|
|
}
|
|
|
|
static void __exit sa1100_irda_exit(void)
|
|
{
|
|
platform_driver_unregister(&sa1100ir_driver);
|
|
}
|
|
|
|
module_init(sa1100_irda_init);
|
|
module_exit(sa1100_irda_exit);
|
|
module_param(power_level, int, 0);
|
|
module_param(tx_lpm, int, 0);
|
|
module_param(max_rate, int, 0);
|
|
|
|
MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
|
|
MODULE_DESCRIPTION("StrongARM SA1100 IrDA driver");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_PARM_DESC(power_level, "IrDA power level, 1 (low) to 3 (high)");
|
|
MODULE_PARM_DESC(tx_lpm, "Enable transmitter low power (1.6us) mode");
|
|
MODULE_PARM_DESC(max_rate, "Maximum baud rate (4000000, 115200, 57600, 38400, 19200, 9600)");
|