![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)
851 lines
20 KiB
C
851 lines
20 KiB
C
/*
|
|
* Alchemy Semi Au1000 IrDA driver
|
|
*
|
|
* Copyright 2001 MontaVista Software Inc.
|
|
* Author: MontaVista Software, Inc.
|
|
* ppopov@mvista.com or source@mvista.com
|
|
*
|
|
* This program is free software; you can distribute it and/or modify it
|
|
* under the terms of the GNU General Public License (Version 2) as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope 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/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/pm.h>
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/irq.h>
|
|
#include <asm/io.h>
|
|
#include <asm/au1000.h>
|
|
#if defined(CONFIG_MIPS_PB1000) || defined(CONFIG_MIPS_PB1100)
|
|
#include <asm/pb1000.h>
|
|
#elif defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
|
|
#include <asm/db1x00.h>
|
|
#else
|
|
#error au1k_ir: unsupported board
|
|
#endif
|
|
|
|
#include <net/irda/irda.h>
|
|
#include <net/irda/irmod.h>
|
|
#include <net/irda/wrapper.h>
|
|
#include <net/irda/irda_device.h>
|
|
#include "au1000_ircc.h"
|
|
|
|
static int au1k_irda_net_init(struct net_device *);
|
|
static int au1k_irda_start(struct net_device *);
|
|
static int au1k_irda_stop(struct net_device *dev);
|
|
static int au1k_irda_hard_xmit(struct sk_buff *, struct net_device *);
|
|
static int au1k_irda_rx(struct net_device *);
|
|
static void au1k_irda_interrupt(int, void *);
|
|
static void au1k_tx_timeout(struct net_device *);
|
|
static struct net_device_stats *au1k_irda_stats(struct net_device *);
|
|
static int au1k_irda_ioctl(struct net_device *, struct ifreq *, int);
|
|
static int au1k_irda_set_speed(struct net_device *dev, int speed);
|
|
|
|
static void *dma_alloc(size_t, dma_addr_t *);
|
|
static void dma_free(void *, size_t);
|
|
|
|
static int qos_mtt_bits = 0x07; /* 1 ms or more */
|
|
static struct net_device *ir_devs[NUM_IR_IFF];
|
|
static char version[] __devinitdata =
|
|
"au1k_ircc:1.2 ppopov@mvista.com\n";
|
|
|
|
#define RUN_AT(x) (jiffies + (x))
|
|
|
|
#if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
|
|
static BCSR * const bcsr = (BCSR *)0xAE000000;
|
|
#endif
|
|
|
|
static DEFINE_SPINLOCK(ir_lock);
|
|
|
|
/*
|
|
* IrDA peripheral bug. You have to read the register
|
|
* twice to get the right value.
|
|
*/
|
|
u32 read_ir_reg(u32 addr)
|
|
{
|
|
readl(addr);
|
|
return readl(addr);
|
|
}
|
|
|
|
|
|
/*
|
|
* Buffer allocation/deallocation routines. The buffer descriptor returned
|
|
* has the virtual and dma address of a buffer suitable for
|
|
* both, receive and transmit operations.
|
|
*/
|
|
static db_dest_t *GetFreeDB(struct au1k_private *aup)
|
|
{
|
|
db_dest_t *pDB;
|
|
pDB = aup->pDBfree;
|
|
|
|
if (pDB) {
|
|
aup->pDBfree = pDB->pnext;
|
|
}
|
|
return pDB;
|
|
}
|
|
|
|
static void ReleaseDB(struct au1k_private *aup, db_dest_t *pDB)
|
|
{
|
|
db_dest_t *pDBfree = aup->pDBfree;
|
|
if (pDBfree)
|
|
pDBfree->pnext = pDB;
|
|
aup->pDBfree = pDB;
|
|
}
|
|
|
|
|
|
/*
|
|
DMA memory allocation, derived from pci_alloc_consistent.
|
|
However, the Au1000 data cache is coherent (when programmed
|
|
so), therefore we return KSEG0 address, not KSEG1.
|
|
*/
|
|
static void *dma_alloc(size_t size, dma_addr_t * dma_handle)
|
|
{
|
|
void *ret;
|
|
int gfp = GFP_ATOMIC | GFP_DMA;
|
|
|
|
ret = (void *) __get_free_pages(gfp, get_order(size));
|
|
|
|
if (ret != NULL) {
|
|
memset(ret, 0, size);
|
|
*dma_handle = virt_to_bus(ret);
|
|
ret = (void *)KSEG0ADDR(ret);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void dma_free(void *vaddr, size_t size)
|
|
{
|
|
vaddr = (void *)KSEG0ADDR(vaddr);
|
|
free_pages((unsigned long) vaddr, get_order(size));
|
|
}
|
|
|
|
|
|
static void
|
|
setup_hw_rings(struct au1k_private *aup, u32 rx_base, u32 tx_base)
|
|
{
|
|
int i;
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
aup->rx_ring[i] = (volatile ring_dest_t *)
|
|
(rx_base + sizeof(ring_dest_t)*i);
|
|
}
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
aup->tx_ring[i] = (volatile ring_dest_t *)
|
|
(tx_base + sizeof(ring_dest_t)*i);
|
|
}
|
|
}
|
|
|
|
static int au1k_irda_init(void)
|
|
{
|
|
static unsigned version_printed = 0;
|
|
struct au1k_private *aup;
|
|
struct net_device *dev;
|
|
int err;
|
|
|
|
if (version_printed++ == 0) printk(version);
|
|
|
|
dev = alloc_irdadev(sizeof(struct au1k_private));
|
|
if (!dev)
|
|
return -ENOMEM;
|
|
|
|
dev->irq = AU1000_IRDA_RX_INT; /* TX has its own interrupt */
|
|
err = au1k_irda_net_init(dev);
|
|
if (err)
|
|
goto out;
|
|
err = register_netdev(dev);
|
|
if (err)
|
|
goto out1;
|
|
ir_devs[0] = dev;
|
|
printk(KERN_INFO "IrDA: Registered device %s\n", dev->name);
|
|
return 0;
|
|
|
|
out1:
|
|
aup = netdev_priv(dev);
|
|
dma_free((void *)aup->db[0].vaddr,
|
|
MAX_BUF_SIZE * 2*NUM_IR_DESC);
|
|
dma_free((void *)aup->rx_ring[0],
|
|
2 * MAX_NUM_IR_DESC*(sizeof(ring_dest_t)));
|
|
kfree(aup->rx_buff.head);
|
|
out:
|
|
free_netdev(dev);
|
|
return err;
|
|
}
|
|
|
|
static int au1k_irda_init_iobuf(iobuff_t *io, int size)
|
|
{
|
|
io->head = kmalloc(size, GFP_KERNEL);
|
|
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 au1k_irda_net_init(struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
int i, retval = 0, err;
|
|
db_dest_t *pDB, *pDBfree;
|
|
dma_addr_t temp;
|
|
|
|
err = au1k_irda_init_iobuf(&aup->rx_buff, 14384);
|
|
if (err)
|
|
goto out1;
|
|
|
|
dev->open = au1k_irda_start;
|
|
dev->hard_start_xmit = au1k_irda_hard_xmit;
|
|
dev->stop = au1k_irda_stop;
|
|
dev->get_stats = au1k_irda_stats;
|
|
dev->do_ioctl = au1k_irda_ioctl;
|
|
dev->tx_timeout = au1k_tx_timeout;
|
|
|
|
irda_init_max_qos_capabilies(&aup->qos);
|
|
|
|
/* The only value we must override it the baudrate */
|
|
aup->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
|
|
IR_115200|IR_576000 |(IR_4000000 << 8);
|
|
|
|
aup->qos.min_turn_time.bits = qos_mtt_bits;
|
|
irda_qos_bits_to_value(&aup->qos);
|
|
|
|
retval = -ENOMEM;
|
|
|
|
/* Tx ring follows rx ring + 512 bytes */
|
|
/* we need a 1k aligned buffer */
|
|
aup->rx_ring[0] = (ring_dest_t *)
|
|
dma_alloc(2*MAX_NUM_IR_DESC*(sizeof(ring_dest_t)), &temp);
|
|
if (!aup->rx_ring[0])
|
|
goto out2;
|
|
|
|
/* allocate the data buffers */
|
|
aup->db[0].vaddr =
|
|
(void *)dma_alloc(MAX_BUF_SIZE * 2*NUM_IR_DESC, &temp);
|
|
if (!aup->db[0].vaddr)
|
|
goto out3;
|
|
|
|
setup_hw_rings(aup, (u32)aup->rx_ring[0], (u32)aup->rx_ring[0] + 512);
|
|
|
|
pDBfree = NULL;
|
|
pDB = aup->db;
|
|
for (i=0; i<(2*NUM_IR_DESC); i++) {
|
|
pDB->pnext = pDBfree;
|
|
pDBfree = pDB;
|
|
pDB->vaddr =
|
|
(u32 *)((unsigned)aup->db[0].vaddr + MAX_BUF_SIZE*i);
|
|
pDB->dma_addr = (dma_addr_t)virt_to_bus(pDB->vaddr);
|
|
pDB++;
|
|
}
|
|
aup->pDBfree = pDBfree;
|
|
|
|
/* attach a data buffer to each descriptor */
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
pDB = GetFreeDB(aup);
|
|
if (!pDB) goto out;
|
|
aup->rx_ring[i]->addr_0 = (u8)(pDB->dma_addr & 0xff);
|
|
aup->rx_ring[i]->addr_1 = (u8)((pDB->dma_addr>>8) & 0xff);
|
|
aup->rx_ring[i]->addr_2 = (u8)((pDB->dma_addr>>16) & 0xff);
|
|
aup->rx_ring[i]->addr_3 = (u8)((pDB->dma_addr>>24) & 0xff);
|
|
aup->rx_db_inuse[i] = pDB;
|
|
}
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
pDB = GetFreeDB(aup);
|
|
if (!pDB) goto out;
|
|
aup->tx_ring[i]->addr_0 = (u8)(pDB->dma_addr & 0xff);
|
|
aup->tx_ring[i]->addr_1 = (u8)((pDB->dma_addr>>8) & 0xff);
|
|
aup->tx_ring[i]->addr_2 = (u8)((pDB->dma_addr>>16) & 0xff);
|
|
aup->tx_ring[i]->addr_3 = (u8)((pDB->dma_addr>>24) & 0xff);
|
|
aup->tx_ring[i]->count_0 = 0;
|
|
aup->tx_ring[i]->count_1 = 0;
|
|
aup->tx_ring[i]->flags = 0;
|
|
aup->tx_db_inuse[i] = pDB;
|
|
}
|
|
|
|
#if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
|
|
/* power on */
|
|
bcsr->resets &= ~BCSR_RESETS_IRDA_MODE_MASK;
|
|
bcsr->resets |= BCSR_RESETS_IRDA_MODE_FULL;
|
|
au_sync();
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
out3:
|
|
dma_free((void *)aup->rx_ring[0],
|
|
2 * MAX_NUM_IR_DESC*(sizeof(ring_dest_t)));
|
|
out2:
|
|
kfree(aup->rx_buff.head);
|
|
out1:
|
|
printk(KERN_ERR "au1k_init_module failed. Returns %d\n", retval);
|
|
return retval;
|
|
}
|
|
|
|
|
|
static int au1k_init(struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
int i;
|
|
u32 control;
|
|
u32 ring_address;
|
|
|
|
/* bring the device out of reset */
|
|
control = 0xe; /* coherent, clock enable, one half system clock */
|
|
|
|
#ifndef CONFIG_CPU_LITTLE_ENDIAN
|
|
control |= 1;
|
|
#endif
|
|
aup->tx_head = 0;
|
|
aup->tx_tail = 0;
|
|
aup->rx_head = 0;
|
|
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
aup->rx_ring[i]->flags = AU_OWN;
|
|
}
|
|
|
|
writel(control, IR_INTERFACE_CONFIG);
|
|
au_sync_delay(10);
|
|
|
|
writel(read_ir_reg(IR_ENABLE) & ~0x8000, IR_ENABLE); /* disable PHY */
|
|
au_sync_delay(1);
|
|
|
|
writel(MAX_BUF_SIZE, IR_MAX_PKT_LEN);
|
|
|
|
ring_address = (u32)virt_to_phys((void *)aup->rx_ring[0]);
|
|
writel(ring_address >> 26, IR_RING_BASE_ADDR_H);
|
|
writel((ring_address >> 10) & 0xffff, IR_RING_BASE_ADDR_L);
|
|
|
|
writel(RING_SIZE_64<<8 | RING_SIZE_64<<12, IR_RING_SIZE);
|
|
|
|
writel(1<<2 | IR_ONE_PIN, IR_CONFIG_2); /* 48MHz */
|
|
writel(0, IR_RING_ADDR_CMPR);
|
|
|
|
au1k_irda_set_speed(dev, 9600);
|
|
return 0;
|
|
}
|
|
|
|
static int au1k_irda_start(struct net_device *dev)
|
|
{
|
|
int retval;
|
|
char hwname[32];
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
|
|
if ((retval = au1k_init(dev))) {
|
|
printk(KERN_ERR "%s: error in au1k_init\n", dev->name);
|
|
return retval;
|
|
}
|
|
|
|
if ((retval = request_irq(AU1000_IRDA_TX_INT, &au1k_irda_interrupt,
|
|
0, dev->name, dev))) {
|
|
printk(KERN_ERR "%s: unable to get IRQ %d\n",
|
|
dev->name, dev->irq);
|
|
return retval;
|
|
}
|
|
if ((retval = request_irq(AU1000_IRDA_RX_INT, &au1k_irda_interrupt,
|
|
0, dev->name, dev))) {
|
|
free_irq(AU1000_IRDA_TX_INT, dev);
|
|
printk(KERN_ERR "%s: unable to get IRQ %d\n",
|
|
dev->name, dev->irq);
|
|
return retval;
|
|
}
|
|
|
|
/* Give self a hardware name */
|
|
sprintf(hwname, "Au1000 SIR/FIR");
|
|
aup->irlap = irlap_open(dev, &aup->qos, hwname);
|
|
netif_start_queue(dev);
|
|
|
|
writel(read_ir_reg(IR_CONFIG_2) | 1<<8, IR_CONFIG_2); /* int enable */
|
|
|
|
aup->timer.expires = RUN_AT((3*HZ));
|
|
aup->timer.data = (unsigned long)dev;
|
|
return 0;
|
|
}
|
|
|
|
static int au1k_irda_stop(struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
|
|
/* disable interrupts */
|
|
writel(read_ir_reg(IR_CONFIG_2) & ~(1<<8), IR_CONFIG_2);
|
|
writel(0, IR_CONFIG_1);
|
|
writel(0, IR_INTERFACE_CONFIG); /* disable clock */
|
|
au_sync();
|
|
|
|
if (aup->irlap) {
|
|
irlap_close(aup->irlap);
|
|
aup->irlap = NULL;
|
|
}
|
|
|
|
netif_stop_queue(dev);
|
|
del_timer(&aup->timer);
|
|
|
|
/* disable the interrupt */
|
|
free_irq(AU1000_IRDA_TX_INT, dev);
|
|
free_irq(AU1000_IRDA_RX_INT, dev);
|
|
return 0;
|
|
}
|
|
|
|
static void __exit au1k_irda_exit(void)
|
|
{
|
|
struct net_device *dev = ir_devs[0];
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
|
|
unregister_netdev(dev);
|
|
|
|
dma_free((void *)aup->db[0].vaddr,
|
|
MAX_BUF_SIZE * 2*NUM_IR_DESC);
|
|
dma_free((void *)aup->rx_ring[0],
|
|
2 * MAX_NUM_IR_DESC*(sizeof(ring_dest_t)));
|
|
kfree(aup->rx_buff.head);
|
|
free_netdev(dev);
|
|
}
|
|
|
|
|
|
static inline void
|
|
update_tx_stats(struct net_device *dev, u32 status, u32 pkt_len)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
struct net_device_stats *ps = &aup->stats;
|
|
|
|
ps->tx_packets++;
|
|
ps->tx_bytes += pkt_len;
|
|
|
|
if (status & IR_TX_ERROR) {
|
|
ps->tx_errors++;
|
|
ps->tx_aborted_errors++;
|
|
}
|
|
}
|
|
|
|
|
|
static void au1k_tx_ack(struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
volatile ring_dest_t *ptxd;
|
|
|
|
ptxd = aup->tx_ring[aup->tx_tail];
|
|
while (!(ptxd->flags & AU_OWN) && (aup->tx_tail != aup->tx_head)) {
|
|
update_tx_stats(dev, ptxd->flags,
|
|
ptxd->count_1<<8 | ptxd->count_0);
|
|
ptxd->count_0 = 0;
|
|
ptxd->count_1 = 0;
|
|
au_sync();
|
|
|
|
aup->tx_tail = (aup->tx_tail + 1) & (NUM_IR_DESC - 1);
|
|
ptxd = aup->tx_ring[aup->tx_tail];
|
|
|
|
if (aup->tx_full) {
|
|
aup->tx_full = 0;
|
|
netif_wake_queue(dev);
|
|
}
|
|
}
|
|
|
|
if (aup->tx_tail == aup->tx_head) {
|
|
if (aup->newspeed) {
|
|
au1k_irda_set_speed(dev, aup->newspeed);
|
|
aup->newspeed = 0;
|
|
}
|
|
else {
|
|
writel(read_ir_reg(IR_CONFIG_1) & ~IR_TX_ENABLE,
|
|
IR_CONFIG_1);
|
|
au_sync();
|
|
writel(read_ir_reg(IR_CONFIG_1) | IR_RX_ENABLE,
|
|
IR_CONFIG_1);
|
|
writel(0, IR_RING_PROMPT);
|
|
au_sync();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Au1000 transmit routine.
|
|
*/
|
|
static int au1k_irda_hard_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
int speed = irda_get_next_speed(skb);
|
|
volatile ring_dest_t *ptxd;
|
|
u32 len;
|
|
|
|
u32 flags;
|
|
db_dest_t *pDB;
|
|
|
|
if (speed != aup->speed && speed != -1) {
|
|
aup->newspeed = speed;
|
|
}
|
|
|
|
if ((skb->len == 0) && (aup->newspeed)) {
|
|
if (aup->tx_tail == aup->tx_head) {
|
|
au1k_irda_set_speed(dev, speed);
|
|
aup->newspeed = 0;
|
|
}
|
|
dev_kfree_skb(skb);
|
|
return 0;
|
|
}
|
|
|
|
ptxd = aup->tx_ring[aup->tx_head];
|
|
flags = ptxd->flags;
|
|
|
|
if (flags & AU_OWN) {
|
|
printk(KERN_DEBUG "%s: tx_full\n", dev->name);
|
|
netif_stop_queue(dev);
|
|
aup->tx_full = 1;
|
|
return 1;
|
|
}
|
|
else if (((aup->tx_head + 1) & (NUM_IR_DESC - 1)) == aup->tx_tail) {
|
|
printk(KERN_DEBUG "%s: tx_full\n", dev->name);
|
|
netif_stop_queue(dev);
|
|
aup->tx_full = 1;
|
|
return 1;
|
|
}
|
|
|
|
pDB = aup->tx_db_inuse[aup->tx_head];
|
|
|
|
#if 0
|
|
if (read_ir_reg(IR_RX_BYTE_CNT) != 0) {
|
|
printk("tx warning: rx byte cnt %x\n",
|
|
read_ir_reg(IR_RX_BYTE_CNT));
|
|
}
|
|
#endif
|
|
|
|
if (aup->speed == 4000000) {
|
|
/* FIR */
|
|
memcpy((void *)pDB->vaddr, skb->data, skb->len);
|
|
ptxd->count_0 = skb->len & 0xff;
|
|
ptxd->count_1 = (skb->len >> 8) & 0xff;
|
|
|
|
}
|
|
else {
|
|
/* SIR */
|
|
len = async_wrap_skb(skb, (u8 *)pDB->vaddr, MAX_BUF_SIZE);
|
|
ptxd->count_0 = len & 0xff;
|
|
ptxd->count_1 = (len >> 8) & 0xff;
|
|
ptxd->flags |= IR_DIS_CRC;
|
|
au_writel(au_readl(0xae00000c) & ~(1<<13), 0xae00000c);
|
|
}
|
|
ptxd->flags |= AU_OWN;
|
|
au_sync();
|
|
|
|
writel(read_ir_reg(IR_CONFIG_1) | IR_TX_ENABLE, IR_CONFIG_1);
|
|
writel(0, IR_RING_PROMPT);
|
|
au_sync();
|
|
|
|
dev_kfree_skb(skb);
|
|
aup->tx_head = (aup->tx_head + 1) & (NUM_IR_DESC - 1);
|
|
dev->trans_start = jiffies;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static inline void
|
|
update_rx_stats(struct net_device *dev, u32 status, u32 count)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
struct net_device_stats *ps = &aup->stats;
|
|
|
|
ps->rx_packets++;
|
|
|
|
if (status & IR_RX_ERROR) {
|
|
ps->rx_errors++;
|
|
if (status & (IR_PHY_ERROR|IR_FIFO_OVER))
|
|
ps->rx_missed_errors++;
|
|
if (status & IR_MAX_LEN)
|
|
ps->rx_length_errors++;
|
|
if (status & IR_CRC_ERROR)
|
|
ps->rx_crc_errors++;
|
|
}
|
|
else
|
|
ps->rx_bytes += count;
|
|
}
|
|
|
|
/*
|
|
* Au1000 receive routine.
|
|
*/
|
|
static int au1k_irda_rx(struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
struct sk_buff *skb;
|
|
volatile ring_dest_t *prxd;
|
|
u32 flags, count;
|
|
db_dest_t *pDB;
|
|
|
|
prxd = aup->rx_ring[aup->rx_head];
|
|
flags = prxd->flags;
|
|
|
|
while (!(flags & AU_OWN)) {
|
|
pDB = aup->rx_db_inuse[aup->rx_head];
|
|
count = prxd->count_1<<8 | prxd->count_0;
|
|
if (!(flags & IR_RX_ERROR)) {
|
|
/* good frame */
|
|
update_rx_stats(dev, flags, count);
|
|
skb=alloc_skb(count+1,GFP_ATOMIC);
|
|
if (skb == NULL) {
|
|
aup->stats.rx_dropped++;
|
|
continue;
|
|
}
|
|
skb_reserve(skb, 1);
|
|
if (aup->speed == 4000000)
|
|
skb_put(skb, count);
|
|
else
|
|
skb_put(skb, count-2);
|
|
memcpy(skb->data, (void *)pDB->vaddr, count-2);
|
|
skb->dev = dev;
|
|
skb->mac.raw = skb->data;
|
|
skb->protocol = htons(ETH_P_IRDA);
|
|
netif_rx(skb);
|
|
prxd->count_0 = 0;
|
|
prxd->count_1 = 0;
|
|
}
|
|
prxd->flags |= AU_OWN;
|
|
aup->rx_head = (aup->rx_head + 1) & (NUM_IR_DESC - 1);
|
|
writel(0, IR_RING_PROMPT);
|
|
au_sync();
|
|
|
|
/* next descriptor */
|
|
prxd = aup->rx_ring[aup->rx_head];
|
|
flags = prxd->flags;
|
|
dev->last_rx = jiffies;
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void au1k_irda_interrupt(int irq, void *dev_id)
|
|
{
|
|
struct net_device *dev = (struct net_device *) dev_id;
|
|
|
|
if (dev == NULL) {
|
|
printk(KERN_ERR "%s: isr: null dev ptr\n", dev->name);
|
|
return;
|
|
}
|
|
|
|
writel(0, IR_INT_CLEAR); /* ack irda interrupts */
|
|
|
|
au1k_irda_rx(dev);
|
|
au1k_tx_ack(dev);
|
|
}
|
|
|
|
|
|
/*
|
|
* The Tx ring has been full longer than the watchdog timeout
|
|
* value. The transmitter must be hung?
|
|
*/
|
|
static void au1k_tx_timeout(struct net_device *dev)
|
|
{
|
|
u32 speed;
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
|
|
printk(KERN_ERR "%s: tx timeout\n", dev->name);
|
|
speed = aup->speed;
|
|
aup->speed = 0;
|
|
au1k_irda_set_speed(dev, speed);
|
|
aup->tx_full = 0;
|
|
netif_wake_queue(dev);
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the IrDA communications speed.
|
|
*/
|
|
static int
|
|
au1k_irda_set_speed(struct net_device *dev, int speed)
|
|
{
|
|
unsigned long flags;
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
u32 control;
|
|
int ret = 0, timeout = 10, i;
|
|
volatile ring_dest_t *ptxd;
|
|
#if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
|
|
unsigned long irda_resets;
|
|
#endif
|
|
|
|
if (speed == aup->speed)
|
|
return ret;
|
|
|
|
spin_lock_irqsave(&ir_lock, flags);
|
|
|
|
/* disable PHY first */
|
|
writel(read_ir_reg(IR_ENABLE) & ~0x8000, IR_ENABLE);
|
|
|
|
/* disable RX/TX */
|
|
writel(read_ir_reg(IR_CONFIG_1) & ~(IR_RX_ENABLE|IR_TX_ENABLE),
|
|
IR_CONFIG_1);
|
|
au_sync_delay(1);
|
|
while (read_ir_reg(IR_ENABLE) & (IR_RX_STATUS | IR_TX_STATUS)) {
|
|
mdelay(1);
|
|
if (!timeout--) {
|
|
printk(KERN_ERR "%s: rx/tx disable timeout\n",
|
|
dev->name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* disable DMA */
|
|
writel(read_ir_reg(IR_CONFIG_1) & ~IR_DMA_ENABLE, IR_CONFIG_1);
|
|
au_sync_delay(1);
|
|
|
|
/*
|
|
* After we disable tx/rx. the index pointers
|
|
* go back to zero.
|
|
*/
|
|
aup->tx_head = aup->tx_tail = aup->rx_head = 0;
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
ptxd = aup->tx_ring[i];
|
|
ptxd->flags = 0;
|
|
ptxd->count_0 = 0;
|
|
ptxd->count_1 = 0;
|
|
}
|
|
|
|
for (i=0; i<NUM_IR_DESC; i++) {
|
|
ptxd = aup->rx_ring[i];
|
|
ptxd->count_0 = 0;
|
|
ptxd->count_1 = 0;
|
|
ptxd->flags = AU_OWN;
|
|
}
|
|
|
|
if (speed == 4000000) {
|
|
#if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
|
|
bcsr->resets |= BCSR_RESETS_FIR_SEL;
|
|
#else /* Pb1000 and Pb1100 */
|
|
writel(1<<13, CPLD_AUX1);
|
|
#endif
|
|
}
|
|
else {
|
|
#if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
|
|
bcsr->resets &= ~BCSR_RESETS_FIR_SEL;
|
|
#else /* Pb1000 and Pb1100 */
|
|
writel(readl(CPLD_AUX1) & ~(1<<13), CPLD_AUX1);
|
|
#endif
|
|
}
|
|
|
|
switch (speed) {
|
|
case 9600:
|
|
writel(11<<10 | 12<<5, IR_WRITE_PHY_CONFIG);
|
|
writel(IR_SIR_MODE, IR_CONFIG_1);
|
|
break;
|
|
case 19200:
|
|
writel(5<<10 | 12<<5, IR_WRITE_PHY_CONFIG);
|
|
writel(IR_SIR_MODE, IR_CONFIG_1);
|
|
break;
|
|
case 38400:
|
|
writel(2<<10 | 12<<5, IR_WRITE_PHY_CONFIG);
|
|
writel(IR_SIR_MODE, IR_CONFIG_1);
|
|
break;
|
|
case 57600:
|
|
writel(1<<10 | 12<<5, IR_WRITE_PHY_CONFIG);
|
|
writel(IR_SIR_MODE, IR_CONFIG_1);
|
|
break;
|
|
case 115200:
|
|
writel(12<<5, IR_WRITE_PHY_CONFIG);
|
|
writel(IR_SIR_MODE, IR_CONFIG_1);
|
|
break;
|
|
case 4000000:
|
|
writel(0xF, IR_WRITE_PHY_CONFIG);
|
|
writel(IR_FIR|IR_DMA_ENABLE|IR_RX_ENABLE, IR_CONFIG_1);
|
|
break;
|
|
default:
|
|
printk(KERN_ERR "%s unsupported speed %x\n", dev->name, speed);
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
aup->speed = speed;
|
|
writel(read_ir_reg(IR_ENABLE) | 0x8000, IR_ENABLE);
|
|
au_sync();
|
|
|
|
control = read_ir_reg(IR_ENABLE);
|
|
writel(0, IR_RING_PROMPT);
|
|
au_sync();
|
|
|
|
if (control & (1<<14)) {
|
|
printk(KERN_ERR "%s: configuration error\n", dev->name);
|
|
}
|
|
else {
|
|
if (control & (1<<11))
|
|
printk(KERN_DEBUG "%s Valid SIR config\n", dev->name);
|
|
if (control & (1<<12))
|
|
printk(KERN_DEBUG "%s Valid MIR config\n", dev->name);
|
|
if (control & (1<<13))
|
|
printk(KERN_DEBUG "%s Valid FIR config\n", dev->name);
|
|
if (control & (1<<10))
|
|
printk(KERN_DEBUG "%s TX enabled\n", dev->name);
|
|
if (control & (1<<9))
|
|
printk(KERN_DEBUG "%s RX enabled\n", dev->name);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ir_lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
au1k_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
|
|
{
|
|
struct if_irda_req *rq = (struct if_irda_req *)ifreq;
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
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 (aup->open)
|
|
ret = au1k_irda_set_speed(dev,
|
|
rq->ifr_baudrate);
|
|
else {
|
|
printk(KERN_ERR "%s ioctl: !netif_running\n",
|
|
dev->name);
|
|
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 = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static struct net_device_stats *au1k_irda_stats(struct net_device *dev)
|
|
{
|
|
struct au1k_private *aup = netdev_priv(dev);
|
|
return &aup->stats;
|
|
}
|
|
|
|
MODULE_AUTHOR("Pete Popov <ppopov@mvista.com>");
|
|
MODULE_DESCRIPTION("Au1000 IrDA Device Driver");
|
|
|
|
module_init(au1k_irda_init);
|
|
module_exit(au1k_irda_exit);
|