davidlt/kernel-ark
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
4796b71fbb
kernel-ark/drivers/isdn/hisax/hisax_fcpcipnp.c
David Howells 7d12e780e0 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 15:10:12 +01:00

1022 lines
25 KiB
C
Raw Blame History

/*
* Driver for AVM Fritz!PCI, Fritz!PCI v2, Fritz!PnP ISDN cards
*
* Author Kai Germaschewski
* Copyright 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
* 2001 by Karsten Keil <keil@isdn4linux.de>
*
* based upon Karsten Keil's original avm_pci.c driver
*
* This software may be used and distributed according to the terms
* of the GNU General Public License, incorporated herein by reference.
*
* Thanks to Wizard Computersysteme GmbH, Bremervoerde and
* SoHaNet Technology GmbH, Berlin
* for supporting the development of this driver
*/
/* TODO:
*
* o POWER PC
* o clean up debugging
* o tx_skb at PH_DEACTIVATE time
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/isapnp.h>
#include <linux/kmod.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/delay.h>
#include <asm/io.h>
#include "hisax_fcpcipnp.h"
// debugging cruft
#define __debug_variable debug
#include "hisax_debug.h"
#ifdef CONFIG_HISAX_DEBUG
static int debug = 0;
/* static int hdlcfifosize = 32; */
module_param(debug, int, 0);
/* module_param(hdlcfifosize, int, 0); */
#endif
MODULE_AUTHOR("Kai Germaschewski <kai.germaschewski@gmx.de>/Karsten Keil <kkeil@suse.de>");
MODULE_DESCRIPTION("AVM Fritz!PCI/PnP ISDN driver");
static struct pci_device_id fcpci_ids[] = {
{ .vendor = PCI_VENDOR_ID_AVM,
.device = PCI_DEVICE_ID_AVM_A1,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = (unsigned long) "Fritz!Card PCI",
},
{ .vendor = PCI_VENDOR_ID_AVM,
.device = PCI_DEVICE_ID_AVM_A1_V2,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = (unsigned long) "Fritz!Card PCI v2" },
{}
};
MODULE_DEVICE_TABLE(pci, fcpci_ids);
#ifdef __ISAPNP__
static struct pnp_device_id fcpnp_ids[] __devinitdata = {
{
.id = "AVM0900",
.driver_data = (unsigned long) "Fritz!Card PnP",
},
};
MODULE_DEVICE_TABLE(isapnp, fcpnp_ids);
#endif
static int protocol = 2; /* EURO-ISDN Default */
module_param(protocol, int, 0);
MODULE_LICENSE("GPL");
// ----------------------------------------------------------------------
#define AVM_INDEX 0x04
#define AVM_DATA 0x10
#define AVM_IDX_HDLC_1 0x00
#define AVM_IDX_HDLC_2 0x01
#define AVM_IDX_ISAC_FIFO 0x02
#define AVM_IDX_ISAC_REG_LOW 0x04
#define AVM_IDX_ISAC_REG_HIGH 0x06
#define AVM_STATUS0 0x02
#define AVM_STATUS0_IRQ_ISAC 0x01
#define AVM_STATUS0_IRQ_HDLC 0x02
#define AVM_STATUS0_IRQ_TIMER 0x04
#define AVM_STATUS0_IRQ_MASK 0x07
#define AVM_STATUS0_RESET 0x01
#define AVM_STATUS0_DIS_TIMER 0x02
#define AVM_STATUS0_RES_TIMER 0x04
#define AVM_STATUS0_ENA_IRQ 0x08
#define AVM_STATUS0_TESTBIT 0x10
#define AVM_STATUS1 0x03
#define AVM_STATUS1_ENA_IOM 0x80
#define HDLC_FIFO 0x0
#define HDLC_STATUS 0x4
#define HDLC_CTRL 0x4
#define HDLC_MODE_ITF_FLG 0x01
#define HDLC_MODE_TRANS 0x02
#define HDLC_MODE_CCR_7 0x04
#define HDLC_MODE_CCR_16 0x08
#define HDLC_MODE_TESTLOOP 0x80
#define HDLC_INT_XPR 0x80
#define HDLC_INT_XDU 0x40
#define HDLC_INT_RPR 0x20
#define HDLC_INT_MASK 0xE0
#define HDLC_STAT_RME 0x01
#define HDLC_STAT_RDO 0x10
#define HDLC_STAT_CRCVFRRAB 0x0E
#define HDLC_STAT_CRCVFR 0x06
#define HDLC_STAT_RML_MASK 0xff00
#define HDLC_CMD_XRS 0x80
#define HDLC_CMD_XME 0x01
#define HDLC_CMD_RRS 0x20
#define HDLC_CMD_XML_MASK 0xff00
#define AVM_HDLC_FIFO_1 0x10
#define AVM_HDLC_FIFO_2 0x18
#define AVM_HDLC_STATUS_1 0x14
#define AVM_HDLC_STATUS_2 0x1c
#define AVM_ISACSX_INDEX 0x04
#define AVM_ISACSX_DATA 0x08
// ----------------------------------------------------------------------
// Fritz!PCI
static unsigned char fcpci_read_isac(struct isac *isac, unsigned char offset)
{
struct fritz_adapter *adapter = isac->priv;
unsigned char idx = (offset > 0x2f) ?
AVM_IDX_ISAC_REG_HIGH : AVM_IDX_ISAC_REG_LOW;
unsigned char val;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outb(idx, adapter->io + AVM_INDEX);
val = inb(adapter->io + AVM_DATA + (offset & 0xf));
spin_unlock_irqrestore(&adapter->hw_lock, flags);
DBG(0x1000, " port %#x, value %#x",
offset, val);
return val;
}
static void fcpci_write_isac(struct isac *isac, unsigned char offset,
unsigned char value)
{
struct fritz_adapter *adapter = isac->priv;
unsigned char idx = (offset > 0x2f) ?
AVM_IDX_ISAC_REG_HIGH : AVM_IDX_ISAC_REG_LOW;
unsigned long flags;
DBG(0x1000, " port %#x, value %#x",
offset, value);
spin_lock_irqsave(&adapter->hw_lock, flags);
outb(idx, adapter->io + AVM_INDEX);
outb(value, adapter->io + AVM_DATA + (offset & 0xf));
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
static void fcpci_read_isac_fifo(struct isac *isac, unsigned char * data,
int size)
{
struct fritz_adapter *adapter = isac->priv;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outb(AVM_IDX_ISAC_FIFO, adapter->io + AVM_INDEX);
insb(adapter->io + AVM_DATA, data, size);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
static void fcpci_write_isac_fifo(struct isac *isac, unsigned char * data,
int size)
{
struct fritz_adapter *adapter = isac->priv;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outb(AVM_IDX_ISAC_FIFO, adapter->io + AVM_INDEX);
outsb(adapter->io + AVM_DATA, data, size);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
static u32 fcpci_read_hdlc_status(struct fritz_adapter *adapter, int nr)
{
u32 val;
int idx = nr ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outl(idx, adapter->io + AVM_INDEX);
val = inl(adapter->io + AVM_DATA + HDLC_STATUS);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
return val;
}
static void __fcpci_write_ctrl(struct fritz_bcs *bcs, int which)
{
struct fritz_adapter *adapter = bcs->adapter;
int idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
DBG(0x40, "hdlc %c wr%x ctrl %x",
'A' + bcs->channel, which, bcs->ctrl.ctrl);
outl(idx, adapter->io + AVM_INDEX);
outl(bcs->ctrl.ctrl, adapter->io + AVM_DATA + HDLC_CTRL);
}
static void fcpci_write_ctrl(struct fritz_bcs *bcs, int which)
{
struct fritz_adapter *adapter = bcs->adapter;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
__fcpci_write_ctrl(bcs, which);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
// ----------------------------------------------------------------------
// Fritz!PCI v2
static unsigned char fcpci2_read_isac(struct isac *isac, unsigned char offset)
{
struct fritz_adapter *adapter = isac->priv;
unsigned char val;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outl(offset, adapter->io + AVM_ISACSX_INDEX);
val = inl(adapter->io + AVM_ISACSX_DATA);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
DBG(0x1000, " port %#x, value %#x",
offset, val);
return val;
}
static void fcpci2_write_isac(struct isac *isac, unsigned char offset,
unsigned char value)
{
struct fritz_adapter *adapter = isac->priv;
unsigned long flags;
DBG(0x1000, " port %#x, value %#x",
offset, value);
spin_lock_irqsave(&adapter->hw_lock, flags);
outl(offset, adapter->io + AVM_ISACSX_INDEX);
outl(value, adapter->io + AVM_ISACSX_DATA);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
static void fcpci2_read_isac_fifo(struct isac *isac, unsigned char * data,
int size)
{
struct fritz_adapter *adapter = isac->priv;
int i;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outl(0, adapter->io + AVM_ISACSX_INDEX);
for (i = 0; i < size; i++)
data[i] = inl(adapter->io + AVM_ISACSX_DATA);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
static void fcpci2_write_isac_fifo(struct isac *isac, unsigned char * data,
int size)
{
struct fritz_adapter *adapter = isac->priv;
int i;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outl(0, adapter->io + AVM_ISACSX_INDEX);
for (i = 0; i < size; i++)
outl(data[i], adapter->io + AVM_ISACSX_DATA);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
static u32 fcpci2_read_hdlc_status(struct fritz_adapter *adapter, int nr)
{
int offset = nr ? AVM_HDLC_STATUS_2 : AVM_HDLC_STATUS_1;
return inl(adapter->io + offset);
}
static void fcpci2_write_ctrl(struct fritz_bcs *bcs, int which)
{
struct fritz_adapter *adapter = bcs->adapter;
int offset = bcs->channel ? AVM_HDLC_STATUS_2 : AVM_HDLC_STATUS_1;
DBG(0x40, "hdlc %c wr%x ctrl %x",
'A' + bcs->channel, which, bcs->ctrl.ctrl);
outl(bcs->ctrl.ctrl, adapter->io + offset);
}
// ----------------------------------------------------------------------
// Fritz!PnP (ISAC access as for Fritz!PCI)
static u32 fcpnp_read_hdlc_status(struct fritz_adapter *adapter, int nr)
{
unsigned char idx = nr ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
u32 val;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
outb(idx, adapter->io + AVM_INDEX);
val = inb(adapter->io + AVM_DATA + HDLC_STATUS);
if (val & HDLC_INT_RPR)
val |= inb(adapter->io + AVM_DATA + HDLC_STATUS + 1) << 8;
spin_unlock_irqrestore(&adapter->hw_lock, flags);
return val;
}
static void __fcpnp_write_ctrl(struct fritz_bcs *bcs, int which)
{
struct fritz_adapter *adapter = bcs->adapter;
unsigned char idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
DBG(0x40, "hdlc %c wr%x ctrl %x",
'A' + bcs->channel, which, bcs->ctrl.ctrl);
outb(idx, adapter->io + AVM_INDEX);
if (which & 4)
outb(bcs->ctrl.sr.mode,
adapter->io + AVM_DATA + HDLC_STATUS + 2);
if (which & 2)
outb(bcs->ctrl.sr.xml,
adapter->io + AVM_DATA + HDLC_STATUS + 1);
if (which & 1)
outb(bcs->ctrl.sr.cmd,
adapter->io + AVM_DATA + HDLC_STATUS + 0);
}
static void fcpnp_write_ctrl(struct fritz_bcs *bcs, int which)
{
struct fritz_adapter *adapter = bcs->adapter;
unsigned long flags;
spin_lock_irqsave(&adapter->hw_lock, flags);
__fcpnp_write_ctrl(bcs, which);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
}
// ----------------------------------------------------------------------
static inline void B_L1L2(struct fritz_bcs *bcs, int pr, void *arg)
{
struct hisax_if *ifc = (struct hisax_if *) &bcs->b_if;
DBG(2, "pr %#x", pr);
ifc->l1l2(ifc, pr, arg);
}
static void hdlc_fill_fifo(struct fritz_bcs *bcs)
{
struct fritz_adapter *adapter = bcs->adapter;
struct sk_buff *skb = bcs->tx_skb;
int count;
unsigned long flags;
unsigned char *p;
DBG(0x40, "hdlc_fill_fifo");
BUG_ON(skb->len == 0);
bcs->ctrl.sr.cmd &= ~HDLC_CMD_XME;
if (bcs->tx_skb->len > bcs->fifo_size) {
count = bcs->fifo_size;
} else {
count = bcs->tx_skb->len;
if (bcs->mode != L1_MODE_TRANS)
bcs->ctrl.sr.cmd |= HDLC_CMD_XME;
}
DBG(0x40, "hdlc_fill_fifo %d/%d", count, bcs->tx_skb->len);
p = bcs->tx_skb->data;
skb_pull(bcs->tx_skb, count);
bcs->tx_cnt += count;
bcs->ctrl.sr.xml = ((count == bcs->fifo_size) ? 0 : count);
switch (adapter->type) {
case AVM_FRITZ_PCI:
spin_lock_irqsave(&adapter->hw_lock, flags);
// sets the correct AVM_INDEX, too
__fcpci_write_ctrl(bcs, 3);
outsl(adapter->io + AVM_DATA + HDLC_FIFO,
p, (count + 3) / 4);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
break;
case AVM_FRITZ_PCIV2:
fcpci2_write_ctrl(bcs, 3);
outsl(adapter->io +
(bcs->channel ? AVM_HDLC_FIFO_2 : AVM_HDLC_FIFO_1),
p, (count + 3) / 4);
break;
case AVM_FRITZ_PNP:
spin_lock_irqsave(&adapter->hw_lock, flags);
// sets the correct AVM_INDEX, too
__fcpnp_write_ctrl(bcs, 3);
outsb(adapter->io + AVM_DATA, p, count);
spin_unlock_irqrestore(&adapter->hw_lock, flags);
break;
}
}
static inline void hdlc_empty_fifo(struct fritz_bcs *bcs, int count)
{
struct fritz_adapter *adapter = bcs->adapter;
unsigned char *p;
unsigned char idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
DBG(0x10, "hdlc_empty_fifo %d", count);
if (bcs->rcvidx + count > HSCX_BUFMAX) {
DBG(0x10, "hdlc_empty_fifo: incoming packet too large");
return;
}
p = bcs->rcvbuf + bcs->rcvidx;
bcs->rcvidx += count;
switch (adapter->type) {
case AVM_FRITZ_PCI:
spin_lock(&adapter->hw_lock);
outl(idx, adapter->io + AVM_INDEX);
insl(adapter->io + AVM_DATA + HDLC_FIFO,
p, (count + 3) / 4);
spin_unlock(&adapter->hw_lock);
break;
case AVM_FRITZ_PCIV2:
insl(adapter->io +
(bcs->channel ? AVM_HDLC_FIFO_2 : AVM_HDLC_FIFO_1),
p, (count + 3) / 4);
break;
case AVM_FRITZ_PNP:
spin_lock(&adapter->hw_lock);
outb(idx, adapter->io + AVM_INDEX);
insb(adapter->io + AVM_DATA, p, count);
spin_unlock(&adapter->hw_lock);
break;
}
}
static inline void hdlc_rpr_irq(struct fritz_bcs *bcs, u32 stat)
{
struct fritz_adapter *adapter = bcs->adapter;
struct sk_buff *skb;
int len;
if (stat & HDLC_STAT_RDO) {
DBG(0x10, "RDO");
bcs->ctrl.sr.xml = 0;
bcs->ctrl.sr.cmd |= HDLC_CMD_RRS;
adapter->write_ctrl(bcs, 1);
bcs->ctrl.sr.cmd &= ~HDLC_CMD_RRS;
adapter->write_ctrl(bcs, 1);
bcs->rcvidx = 0;
return;
}
len = (stat & HDLC_STAT_RML_MASK) >> 8;
if (len == 0)
len = bcs->fifo_size;
hdlc_empty_fifo(bcs, len);
if ((stat & HDLC_STAT_RME) || (bcs->mode == L1_MODE_TRANS)) {
if (((stat & HDLC_STAT_CRCVFRRAB)== HDLC_STAT_CRCVFR) ||
(bcs->mode == L1_MODE_TRANS)) {
skb = dev_alloc_skb(bcs->rcvidx);
if (!skb) {
printk(KERN_WARNING "HDLC: receive out of memory\n");
} else {
memcpy(skb_put(skb, bcs->rcvidx), bcs->rcvbuf,
bcs->rcvidx);
DBG_SKB(1, skb);
B_L1L2(bcs, PH_DATA | INDICATION, skb);
}
bcs->rcvidx = 0;
} else {
DBG(0x10, "ch%d invalid frame %#x",
bcs->channel, stat);
bcs->rcvidx = 0;
}
}
}
static inline void hdlc_xdu_irq(struct fritz_bcs *bcs)
{
struct fritz_adapter *adapter = bcs->adapter;
/* Here we lost an TX interrupt, so
* restart transmitting the whole frame.
*/
bcs->ctrl.sr.xml = 0;
bcs->ctrl.sr.cmd |= HDLC_CMD_XRS;
adapter->write_ctrl(bcs, 1);
bcs->ctrl.sr.cmd &= ~HDLC_CMD_XRS;
if (!bcs->tx_skb) {
DBG(0x10, "XDU without skb");
adapter->write_ctrl(bcs, 1);
return;
}
/* only hdlc restarts the frame, transparent mode must continue */
if (bcs->mode == L1_MODE_HDLC) {
skb_push(bcs->tx_skb, bcs->tx_cnt);
bcs->tx_cnt = 0;
}
}
static inline void hdlc_xpr_irq(struct fritz_bcs *bcs)
{
struct sk_buff *skb;
skb = bcs->tx_skb;
if (!skb)
return;
if (skb->len) {
hdlc_fill_fifo(bcs);
return;
}
bcs->tx_cnt = 0;
bcs->tx_skb = NULL;
B_L1L2(bcs, PH_DATA | CONFIRM, (void *)(unsigned long)skb->truesize);
dev_kfree_skb_irq(skb);
}
static void hdlc_irq_one(struct fritz_bcs *bcs, u32 stat)
{
DBG(0x10, "ch%d stat %#x", bcs->channel, stat);
if (stat & HDLC_INT_RPR) {
DBG(0x10, "RPR");
hdlc_rpr_irq(bcs, stat);
}
if (stat & HDLC_INT_XDU) {
DBG(0x10, "XDU");
hdlc_xdu_irq(bcs);
hdlc_xpr_irq(bcs);
return;
}
if (stat & HDLC_INT_XPR) {
DBG(0x10, "XPR");
hdlc_xpr_irq(bcs);
}
}
static inline void hdlc_irq(struct fritz_adapter *adapter)
{
int nr;
u32 stat;
for (nr = 0; nr < 2; nr++) {
stat = adapter->read_hdlc_status(adapter, nr);
DBG(0x10, "HDLC %c stat %#x", 'A' + nr, stat);
if (stat & HDLC_INT_MASK)
hdlc_irq_one(&adapter->bcs[nr], stat);
}
}
static void modehdlc(struct fritz_bcs *bcs, int mode)
{
struct fritz_adapter *adapter = bcs->adapter;
DBG(0x40, "hdlc %c mode %d --> %d",
'A' + bcs->channel, bcs->mode, mode);
if (bcs->mode == mode)
return;
bcs->fifo_size = 32;
bcs->ctrl.ctrl = 0;
bcs->ctrl.sr.cmd = HDLC_CMD_XRS | HDLC_CMD_RRS;
switch (mode) {
case L1_MODE_NULL:
bcs->ctrl.sr.mode = HDLC_MODE_TRANS;
adapter->write_ctrl(bcs, 5);
break;
case L1_MODE_TRANS:
case L1_MODE_HDLC:
bcs->rcvidx = 0;
bcs->tx_cnt = 0;
bcs->tx_skb = NULL;
if (mode == L1_MODE_TRANS) {
bcs->ctrl.sr.mode = HDLC_MODE_TRANS;
} else {
bcs->ctrl.sr.mode = HDLC_MODE_ITF_FLG;
}
adapter->write_ctrl(bcs, 5);
bcs->ctrl.sr.cmd = HDLC_CMD_XRS;
adapter->write_ctrl(bcs, 1);
bcs->ctrl.sr.cmd = 0;
break;
}
bcs->mode = mode;
}
static void fritz_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
{
struct fritz_bcs *bcs = ifc->priv;
struct sk_buff *skb = arg;
int mode;
DBG(0x10, "pr %#x", pr);
switch (pr) {
case PH_DATA | REQUEST:
BUG_ON(bcs->tx_skb);
bcs->tx_skb = skb;
DBG_SKB(1, skb);
hdlc_fill_fifo(bcs);
break;
case PH_ACTIVATE | REQUEST:
mode = (long) arg;
DBG(4,"B%d,PH_ACTIVATE_REQUEST %d", bcs->channel + 1, mode);
modehdlc(bcs, mode);
B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
break;
case PH_DEACTIVATE | REQUEST:
DBG(4,"B%d,PH_DEACTIVATE_REQUEST", bcs->channel + 1);
modehdlc(bcs, L1_MODE_NULL);
B_L1L2(bcs, PH_DEACTIVATE | INDICATION, NULL);
break;
}
}
// ----------------------------------------------------------------------
static irqreturn_t
fcpci2_irq(int intno, void *dev)
{
struct fritz_adapter *adapter = dev;
unsigned char val;
val = inb(adapter->io + AVM_STATUS0);
if (!(val & AVM_STATUS0_IRQ_MASK))
/* hopefully a shared IRQ reqest */
return IRQ_NONE;
DBG(2, "STATUS0 %#x", val);
if (val & AVM_STATUS0_IRQ_ISAC)
isacsx_irq(&adapter->isac);
if (val & AVM_STATUS0_IRQ_HDLC)
hdlc_irq(adapter);
if (val & AVM_STATUS0_IRQ_ISAC)
isacsx_irq(&adapter->isac);
return IRQ_HANDLED;
}
static irqreturn_t
fcpci_irq(int intno, void *dev)
{
struct fritz_adapter *adapter = dev;
unsigned char sval;
sval = inb(adapter->io + 2);
if ((sval & AVM_STATUS0_IRQ_MASK) == AVM_STATUS0_IRQ_MASK)
/* possibly a shared IRQ reqest */
return IRQ_NONE;
DBG(2, "sval %#x", sval);
if (!(sval & AVM_STATUS0_IRQ_ISAC))
isac_irq(&adapter->isac);
if (!(sval & AVM_STATUS0_IRQ_HDLC))
hdlc_irq(adapter);
return IRQ_HANDLED;
}
// ----------------------------------------------------------------------
static inline void fcpci2_init(struct fritz_adapter *adapter)
{
outb(AVM_STATUS0_RES_TIMER, adapter->io + AVM_STATUS0);
outb(AVM_STATUS0_ENA_IRQ, adapter->io + AVM_STATUS0);
}
static inline void fcpci_init(struct fritz_adapter *adapter)
{
outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER |
AVM_STATUS0_ENA_IRQ, adapter->io + AVM_STATUS0);
outb(AVM_STATUS1_ENA_IOM | adapter->irq,
adapter->io + AVM_STATUS1);
mdelay(10);
}
// ----------------------------------------------------------------------
static int __devinit fcpcipnp_setup(struct fritz_adapter *adapter)
{
u32 val = 0;
int retval;
DBG(1,"");
isac_init(&adapter->isac); // FIXME is this okay now
retval = -EBUSY;
if (!request_region(adapter->io, 32, "fcpcipnp"))
goto err;
switch (adapter->type) {
case AVM_FRITZ_PCIV2:
retval = request_irq(adapter->irq, fcpci2_irq, IRQF_SHARED,
"fcpcipnp", adapter);
break;
case AVM_FRITZ_PCI:
retval = request_irq(adapter->irq, fcpci_irq, IRQF_SHARED,
"fcpcipnp", adapter);
break;
case AVM_FRITZ_PNP:
retval = request_irq(adapter->irq, fcpci_irq, 0,
"fcpcipnp", adapter);
break;
}
if (retval)
goto err_region;
switch (adapter->type) {
case AVM_FRITZ_PCIV2:
case AVM_FRITZ_PCI:
val = inl(adapter->io);
break;
case AVM_FRITZ_PNP:
val = inb(adapter->io);
val |= inb(adapter->io + 1) << 8;
break;
}
DBG(1, "stat %#x Class %X Rev %d",
val, val & 0xff, (val>>8) & 0xff);
spin_lock_init(&adapter->hw_lock);
adapter->isac.priv = adapter;
switch (adapter->type) {
case AVM_FRITZ_PCIV2:
adapter->isac.read_isac = &fcpci2_read_isac;
adapter->isac.write_isac = &fcpci2_write_isac;
adapter->isac.read_isac_fifo = &fcpci2_read_isac_fifo;
adapter->isac.write_isac_fifo = &fcpci2_write_isac_fifo;
adapter->read_hdlc_status = &fcpci2_read_hdlc_status;
adapter->write_ctrl = &fcpci2_write_ctrl;
break;
case AVM_FRITZ_PCI:
adapter->isac.read_isac = &fcpci_read_isac;
adapter->isac.write_isac = &fcpci_write_isac;
adapter->isac.read_isac_fifo = &fcpci_read_isac_fifo;
adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;
adapter->read_hdlc_status = &fcpci_read_hdlc_status;
adapter->write_ctrl = &fcpci_write_ctrl;
break;
case AVM_FRITZ_PNP:
adapter->isac.read_isac = &fcpci_read_isac;
adapter->isac.write_isac = &fcpci_write_isac;
adapter->isac.read_isac_fifo = &fcpci_read_isac_fifo;
adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;
adapter->read_hdlc_status = &fcpnp_read_hdlc_status;
adapter->write_ctrl = &fcpnp_write_ctrl;
break;
}
// Reset
outb(0, adapter->io + AVM_STATUS0);
mdelay(10);
outb(AVM_STATUS0_RESET, adapter->io + AVM_STATUS0);
mdelay(10);
outb(0, adapter->io + AVM_STATUS0);
mdelay(10);
switch (adapter->type) {
case AVM_FRITZ_PCIV2:
fcpci2_init(adapter);
isacsx_setup(&adapter->isac);
break;
case AVM_FRITZ_PCI:
case AVM_FRITZ_PNP:
fcpci_init(adapter);
isac_setup(&adapter->isac);
break;
}
val = adapter->read_hdlc_status(adapter, 0);
DBG(0x20, "HDLC A STA %x", val);
val = adapter->read_hdlc_status(adapter, 1);
DBG(0x20, "HDLC B STA %x", val);
adapter->bcs[0].mode = -1;
adapter->bcs[1].mode = -1;
modehdlc(&adapter->bcs[0], L1_MODE_NULL);
modehdlc(&adapter->bcs[1], L1_MODE_NULL);
return 0;
err_region:
release_region(adapter->io, 32);
err:
return retval;
}
static void __devexit fcpcipnp_release(struct fritz_adapter *adapter)
{
DBG(1,"");
outb(0, adapter->io + AVM_STATUS0);
free_irq(adapter->irq, adapter);
release_region(adapter->io, 32);
}
// ----------------------------------------------------------------------
static struct fritz_adapter * __devinit
new_adapter(void)
{
struct fritz_adapter *adapter;
struct hisax_b_if *b_if[2];
int i;
adapter = kmalloc(sizeof(struct fritz_adapter), GFP_KERNEL);
if (!adapter)
return NULL;
memset(adapter, 0, sizeof(struct fritz_adapter));
adapter->isac.hisax_d_if.owner = THIS_MODULE;
adapter->isac.hisax_d_if.ifc.priv = &adapter->isac;
adapter->isac.hisax_d_if.ifc.l2l1 = isac_d_l2l1;
for (i = 0; i < 2; i++) {
adapter->bcs[i].adapter = adapter;
adapter->bcs[i].channel = i;
adapter->bcs[i].b_if.ifc.priv = &adapter->bcs[i];
adapter->bcs[i].b_if.ifc.l2l1 = fritz_b_l2l1;
}
for (i = 0; i < 2; i++)
b_if[i] = &adapter->bcs[i].b_if;
hisax_register(&adapter->isac.hisax_d_if, b_if, "fcpcipnp", protocol);
return adapter;
}
static void delete_adapter(struct fritz_adapter *adapter)
{
hisax_unregister(&adapter->isac.hisax_d_if);
kfree(adapter);
}
static int __devinit fcpci_probe(struct pci_dev *pdev,
const struct pci_device_id *ent)
{
struct fritz_adapter *adapter;
int retval;
retval = -ENOMEM;
adapter = new_adapter();
if (!adapter)
goto err;
pci_set_drvdata(pdev, adapter);
if (pdev->device == PCI_DEVICE_ID_AVM_A1_V2)
adapter->type = AVM_FRITZ_PCIV2;
else
adapter->type = AVM_FRITZ_PCI;
retval = pci_enable_device(pdev);
if (retval)
goto err_free;
adapter->io = pci_resource_start(pdev, 1);
adapter->irq = pdev->irq;
printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at %s\n",
(char *) ent->driver_data, pci_name(pdev));
retval = fcpcipnp_setup(adapter);
if (retval)
goto err_free;
return 0;
err_free:
delete_adapter(adapter);
err:
return retval;
}
#ifdef __ISAPNP__
static int __devinit fcpnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
{
struct fritz_adapter *adapter;
int retval;
if (!pdev)
return(-ENODEV);
retval = -ENOMEM;
adapter = new_adapter();
if (!adapter)
goto err;
pnp_set_drvdata(pdev, adapter);
adapter->type = AVM_FRITZ_PNP;
pnp_disable_dev(pdev);
retval = pnp_activate_dev(pdev);
if (retval < 0) {
printk(KERN_WARNING "%s: pnp_activate_dev(%s) ret(%d)\n", __FUNCTION__,
(char *)dev_id->driver_data, retval);
goto err_free;
}
adapter->io = pnp_port_start(pdev, 0);
adapter->irq = pnp_irq(pdev, 0);
printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at IO %#x irq %d\n",
(char *) dev_id->driver_data, adapter->io, adapter->irq);
retval = fcpcipnp_setup(adapter);
if (retval)
goto err_free;
return 0;
err_free:
delete_adapter(adapter);
err:
return retval;
}
static void __devexit fcpnp_remove(struct pnp_dev *pdev)
{
struct fritz_adapter *adapter = pnp_get_drvdata(pdev);
if (adapter) {
fcpcipnp_release(adapter);
delete_adapter(adapter);
}
pnp_disable_dev(pdev);
}
static struct pnp_driver fcpnp_driver = {
.name = "fcpnp",
.probe = fcpnp_probe,
.remove = __devexit_p(fcpnp_remove),
.id_table = fcpnp_ids,
};
#endif
static void __devexit fcpci_remove(struct pci_dev *pdev)
{
struct fritz_adapter *adapter = pci_get_drvdata(pdev);
fcpcipnp_release(adapter);
pci_disable_device(pdev);
delete_adapter(adapter);
}
static struct pci_driver fcpci_driver = {
.name = "fcpci",
.probe = fcpci_probe,
.remove = __devexit_p(fcpci_remove),
.id_table = fcpci_ids,
};
static int __init hisax_fcpcipnp_init(void)
{
int retval;
printk(KERN_INFO "hisax_fcpcipnp: Fritz!Card PCI/PCIv2/PnP ISDN driver v0.0.1\n");
retval = pci_register_driver(&fcpci_driver);
if (retval)
return retval;
#ifdef __ISAPNP__
retval = pnp_register_driver(&fcpnp_driver);
if (retval < 0) {
pci_unregister_driver(&fcpci_driver);
return retval;
}
#endif
return 0;
}
static void __exit hisax_fcpcipnp_exit(void)
{
#ifdef __ISAPNP__
pnp_unregister_driver(&fcpnp_driver);
#endif
pci_unregister_driver(&fcpci_driver);
}
module_init(hisax_fcpcipnp_init);
module_exit(hisax_fcpcipnp_exit);
Reference in New Issue View Git Blame Copy Permalink