[PATCH] yenta: irq-routing for TI bridges...again
Pavel Roskin
proski at gnu.org
Mon Mar 15 02:43:35 GMT 2004
On Sun, 14 Mar 2004, Daniel Ritz wrote:
> > > > 3) Do we want to try to enable ISA interrupts if PCI interrupts are
> > > > working and ISA interrupts are not?
> > >
> > > don't know...why not?
> >
> > I suspect probing them may be hazardous - sure it can be tried, but I
> > think it should be treated as a separate problem to the present one.
> > I think it'll need a lot more testing on more hardware.
> >
>
> ok, so my current patch has the ISA part disabled. if ISA is not working
> fall back to PCI directly...
>
> my current patch:
> http://ritz.dnsalias.org/linux/pcmcia-ti-routing-7.patch
The patch is quite unreadable. I reverted unrelated parts to make it
readable. We can remove commented out code later. It's more important
that we don't miss any bugs. The improved patch is attached.
I don't understand why we need to probe ISA interrupts in
ti12xx_irqroute_func0(). I think we have agreed that we need PCI
interrupts for CSC events even if ISA interrupts are working.
Even if we ruins ISA interrupts completely (not likely) but fix PCI
interrupts we are still better off.
The patch is working fine with TI PCI1221. This is what I get on startup:
Yenta: CardBus bridge found at 0000:00:08.0 [133f:1233]
Yenta: Enabling burst memory read transactions
Yenta: Using CSCINT to route CSC interrupts to PCI
Yenta: Routing CardBus interrupts to PCI
Yenta TI: socket 0000:00:08.0, mfunc 0x0cc07d92, devctl 0x60
Yenta: ISA IRQ mask 0x0000, PCI irq 12
Socket status: 30000010
Yenta: CardBus bridge found at 0000:00:08.1 [133f:1233]
Yenta: Using CSCINT to route CSC interrupts to PCI
Yenta: Routing CardBus interrupts to PCI
Yenta TI: socket 0000:00:08.1, mfunc 0x0cc07d92, devctl 0x60
Yenta: ISA IRQ mask 0x0000, PCI irq 12
Socket status: 30000010
Then I added this code to the beginning of ti12xx_override():
if (PCI_FUNC(socket->dev->devfn) == 0) {
ti_irqmux(socket) = 0;
config_writel(socket, TI122X_MFUNC, ti_irqmux(socket));
ti_devctl(socket) = 0x66;
config_writeb(socket, TI113X_DEVICE_CONTROL, ti_devctl(socket));
}
When I loaded yenta_socket, I got this:
Yenta: CardBus bridge found at 0000:00:08.0 [133f:1233]
Yenta: Using CSCINT to route CSC interrupts to PCI
Yenta: Routing CardBus interrupts to PCI
Yenta TI: socket 0000:00:08.0, mfunc 0x00000000, devctl 0x66
Yenta TI: socket 0000:00:08.0 probing PCI interrupt failed, trying to fix
Yenta TI: socket 0000:00:08.0 falling back to parallel PCI interrupts
Yenta TI: socket 0000:00:08.0 parallel PCI interrupts ok
Yenta TI: socket 0000:00:08.0 routing card interrupts to PCI
Yenta: ISA IRQ mask 0x0000, PCI irq 12
Socket status: 30000010
Yenta: CardBus bridge found at 0000:00:08.1 [133f:1233]
Yenta: Using CSCINT to route CSC interrupts to PCI
Yenta: Routing CardBus interrupts to PCI
Yenta TI: socket 0000:00:08.1, mfunc 0x00000002, devctl 0x60
Yenta: ISA IRQ mask 0x0000, PCI irq 12
Socket status: 30000010
I put two cards into the sockets. Both were detected immediately and both
worked. Thank you!
--
Regards,
Pavel Roskin
-------------- next part --------------
--- linux.orig/drivers/pcmcia/ti113x.h
+++ linux/drivers/pcmcia/ti113x.h
@@ -76,7 +76,23 @@
#define TI1250_GPIO1_CONTROL 0x0089 /* 8 bit */
#define TI1250_GPIO2_CONTROL 0x008a /* 8 bit */
#define TI1250_GPIO3_CONTROL 0x008b /* 8 bit */
-#define TI122X_IRQMUX 0x008c /* 32 bit */
+#define TI1250_GPIO_MODE_MASK 0xc0
+
+/* IRQMUX/MFUNC Register */
+#define TI122X_MFUNC 0x008c /* 32 bit */
+#define TI122X_MFUNC0_MASK 0x0000000f
+#define TI122X_MFUNC1_MASK 0x000000f0
+#define TI122X_MFUNC2_MASK 0x00000f00
+#define TI122X_MFUNC3_MASK 0x0000f000
+#define TI122X_MFUNC4_MASK 0x000f0000
+#define TI122X_MFUNC5_MASK 0x00f00000
+#define TI122X_MFUNC6_MASK 0x0f000000
+
+#define TI122X_MFUNC0_INTA 0x00000002
+#define TI125X_MFUNC0_INTB 0x00000001
+#define TI122X_MFUNC1_INTB 0x00000020
+#define TI122X_MFUNC3_IRQSER 0x00001000
+
/* Retry Status Register */
#define TI113X_RETRY_STATUS 0x0090 /* 8 bit */
@@ -151,7 +167,7 @@
static void ti_save_state(struct yenta_socket *socket)
{
ti_sysctl(socket) = config_readl(socket, TI113X_SYSTEM_CONTROL);
- ti_irqmux(socket) = config_readl(socket, TI122X_IRQMUX);
+ ti_irqmux(socket) = config_readl(socket, TI122X_MFUNC);
ti_cardctl(socket) = config_readb(socket, TI113X_CARD_CONTROL);
ti_devctl(socket) = config_readb(socket, TI113X_DEVICE_CONTROL);
ti_diag(socket) = config_readb(socket, TI1250_DIAGNOSTIC);
@@ -160,7 +176,7 @@
static void ti_restore_state(struct yenta_socket *socket)
{
config_writel(socket, TI113X_SYSTEM_CONTROL, ti_sysctl(socket));
- config_writel(socket, TI122X_IRQMUX, ti_irqmux(socket));
+ config_writel(socket, TI122X_MFUNC, ti_irqmux(socket));
config_writeb(socket, TI113X_CARD_CONTROL, ti_cardctl(socket));
config_writeb(socket, TI113X_DEVICE_CONTROL, ti_devctl(socket));
config_writeb(socket, TI1250_DIAGNOSTIC, ti_diag(socket));
@@ -252,7 +268,7 @@
* INTCTL register that sets the PCI CSC interrupt.
* Make sure we set it correctly at open and init
* time
- * - open: disable the PCI CSC interrupt. This makes
+ * - override: disable the PCI CSC interrupt. This makes
* it possible to use the CSC interrupt to probe the
* ISA interrupts.
* - init: set the interrupt to match our PCI state.
@@ -325,9 +341,318 @@
}
+/* irqrouting for func0, probes PCI interrupt and ISA interrupts */
+static int ti12xx_irqroute_func0(struct yenta_socket *socket)
+{
+ u32 mfunc, mfunc_old, devctl;
+ u8 gpio3, gpio3_old;
+ unsigned probe_mask;
+ int ret, pci_irq_status;
+
+ mfunc = mfunc_old = config_readl(socket, TI122X_MFUNC);
+ devctl = config_readb(socket, TI113X_DEVICE_CONTROL);
+ printk(KERN_INFO "Yenta TI: socket %s, mfunc 0x%08x, devctl 0x%02x\n",
+ pci_name(socket->dev), mfunc, devctl);
+
+ /* make sure PCI interrupts are enabled before probing */
+ ti_init(socket);
+
+ /* test PCI interrupts first. only try fixing if return value is 0! */
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status)
+ goto probe_isa;
+
+ /*
+ * We're here which means PCI interrupts are _not_ delivered. try to
+ * find the right setting (all serial or parallel)
+ */
+ printk(KERN_INFO "Yenta TI: socket %s probing PCI interrupt failed, trying to fix\n",
+ pci_name(socket->dev));
+
+ /* for serial PCI make sure MFUNC3 is set to IRQSER */
+ if ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) {
+ switch (socket->dev->device) {
+ case PCI_DEVICE_ID_TI_1250:
+ case PCI_DEVICE_ID_TI_1251A:
+ case PCI_DEVICE_ID_TI_1251B:
+ case PCI_DEVICE_ID_TI_1450:
+ case PCI_DEVICE_ID_TI_1451A:
+ case PCI_DEVICE_ID_TI_4450:
+ case PCI_DEVICE_ID_TI_4451:
+ /* these chips have no IRQSER setting in MFUNC3 */
+ break;
+
+ default:
+ mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER;
+
+ /* write down if changed, probe */
+ if (mfunc != mfunc_old) {
+ config_writel(socket, TI122X_MFUNC, mfunc);
+
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status == 1) {
+ printk(KERN_INFO "Yenta TI: socket %s all-serial interrupts ok\n",
+ pci_name(socket->dev));
+ mfunc_old = mfunc;
+ goto probe_isa;
+ }
+
+ /* not working, back to old value */
+ mfunc = mfunc_old;
+ config_writel(socket, TI122X_MFUNC, mfunc);
+
+ if (pci_irq_status == -1)
+ goto probe_isa;
+ }
+ }
+
+ /* serial PCI interrupts not working fall back to parallel */
+ printk(KERN_INFO "Yenta TI: socket %s falling back to parallel PCI interrupts\n",
+ pci_name(socket->dev));
+ devctl &= ~TI113X_DCR_IMODE_MASK;
+ devctl |= TI113X_DCR_IMODE_SERIAL; /* serial ISA could be right */
+ config_writeb(socket, TI113X_DEVICE_CONTROL, devctl);
+ }
+
+ /* parallel PCI interrupts: route INTA */
+ switch (socket->dev->device) {
+ case PCI_DEVICE_ID_TI_1250:
+ case PCI_DEVICE_ID_TI_1251A:
+ case PCI_DEVICE_ID_TI_1251B:
+ case PCI_DEVICE_ID_TI_1450:
+ /* make sure GPIO3 is set to INTA */
+ gpio3 = gpio3_old = config_readb(socket, TI1250_GPIO3_CONTROL);
+ gpio3 &= ~TI1250_GPIO_MODE_MASK;
+ if (gpio3 != gpio3_old)
+ config_writeb(socket, TI1250_GPIO3_CONTROL, gpio3);
+ break;
+
+ default:
+ gpio3 = gpio3_old = 0;
+
+ mfunc = (mfunc & ~TI122X_MFUNC0_MASK) | TI122X_MFUNC0_INTA;
+ if (mfunc != mfunc_old)
+ config_writel(socket, TI122X_MFUNC, mfunc);
+ }
+
+ /* time to probe again */
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status == 1) {
+ mfunc_old = mfunc;
+ printk(KERN_INFO "Yenta TI: socket %s parallel PCI interrupts ok\n",
+ pci_name(socket->dev));
+ } else {
+ /* not working, back to old value */
+ mfunc = mfunc_old;
+ config_writel(socket, TI122X_MFUNC, mfunc);
+ if (gpio3 != gpio3_old)
+ config_writeb(socket, TI1250_GPIO3_CONTROL, gpio3_old);
+ }
+
+probe_isa:
+ if (pci_irq_status < 1) {
+ socket->cb_irq = 0;
+ printk(KERN_INFO "Yenta TI: socket %s no PCI interrupts. Fish. Please report.\n",
+ pci_name(socket->dev));
+ }
+
+ /* need to call ti_override() before testing ISA interrupts */
+ ret = ti_override(socket);
+ if (ret)
+ goto out;
+
+ /*
+ * if all serial: setting is right (PCI interrutps are delivered)
+ * if parallel PCI only: probing would fail anyway
+ */
+ if (((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) ||
+ ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_PCI_ONLY))
+ goto out;
+
+ /* probe interrupts before any 'fixup' */
+ probe_mask = yenta_probe_irq(socket, isa_interrupts);
+ if (probe_mask)
+ goto out;
+
+
+ /*
+ * we're here which means ISA interrupts are not delivered. try to fix it
+ */
+
+#if 0
+ printk(KERN_INFO "Yenta TI: socket %s probing ISA interrupts failed, trying to fix\n",
+ pci_name(socket->dev));
+
+ /* serialized interrupts: MFUNC3 should be IRQSER */
+ if (devctl & TI113X_DCR_IMODE_SERIAL) {
+ switch (socket->dev->device) {
+ case PCI_DEVICE_ID_TI_1250:
+ case PCI_DEVICE_ID_TI_1251A:
+ case PCI_DEVICE_ID_TI_1251B:
+ case PCI_DEVICE_ID_TI_1450:
+ case PCI_DEVICE_ID_TI_1451A:
+ case PCI_DEVICE_ID_TI_4450:
+ case PCI_DEVICE_ID_TI_4451:
+ /* these chips have no IRQSER setting in MFUNC3 */
+ break;
+
+ default:
+ mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER;
+
+ /* write down if changed, probe */
+ if (mfunc != mfunc_old) {
+ config_writel(socket, TI122X_MFUNC, mfunc);
+
+ probe_mask = yenta_probe_irq(socket, isa_interrupts);
+ if (probe_mask) {
+ printk(KERN_INFO "Yenta TI: socket %s serial ISA interrupts ok\n",
+ pci_name(socket->dev));
+ goto out;
+ }
+
+ /* not working, back to old value */
+ mfunc = mfunc_old;
+ config_writel(socket, TI122X_MFUNC, mfunc);
+ }
+ }
+ }
+#endif
+
+ /* serial ISA not working: fall back to PCI */
+ printk(KERN_INFO "Yenta TI: socket %s routing card interrupts to PCI\n",
+ pci_name(socket->dev));
+ devctl &= ~TI113X_DCR_IMODE_MASK;
+ config_writeb(socket, TI113X_DEVICE_CONTROL, devctl);
+
+out:
+ return ret;
+}
+
+
+/*
+ * irqrouting for func1, plays with INTB routing
+ * only touches MFUNC for INTB routing. all other bits are taken
+ * care of in func0 already.
+ */
+static int ti12xx_irqroute_func1(struct yenta_socket *socket)
+{
+ u32 mfunc, mfunc_old, devctl;
+ int pci_irq_status;
+
+ mfunc = mfunc_old = config_readl(socket, TI122X_MFUNC);
+ devctl = config_readb(socket, TI113X_DEVICE_CONTROL);
+ printk(KERN_INFO "Yenta TI: socket %s, mfunc 0x%08x, devctl 0x%02x\n",
+ pci_name(socket->dev), mfunc, devctl);
+
+ /* make sure PCI interrupts are enabled before probing */
+ ti_init(socket);
+
+ /* test PCI interrupts first. only try fixing if return value is 0! */
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status)
+ goto out;
+
+ /*
+ * We're here which means PCI interrupts are _not_ delivered. try to
+ * find the right setting
+ */
+ printk(KERN_INFO "Yenta TI: socket %s probing PCI interrupt failed, trying to fix\n",
+ pci_name(socket->dev));
+
+
+ /* if all serial: set INTRTIE, probe again */
+ if ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) {
+ u32 sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
+
+ if ((sysctl & TI122X_SCR_INTRTIE) == 0) {
+ sysctl |= TI122X_SCR_INTRTIE;
+ config_writel(socket, TI113X_SYSTEM_CONTROL, sysctl);
+
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status == 1) {
+ printk(KERN_INFO "Yenta TI: socket %s all-serial interrupts, tied ok\n",
+ pci_name(socket->dev));
+ goto out;
+ }
+
+ sysctl &= ~TI122X_SCR_INTRTIE;
+ config_writel(socket, TI113X_SYSTEM_CONTROL, sysctl);
+ }
+ }
+ /* parallel PCI: route INTB, probe again */
+ else {
+ u32 sysctl;
+
+ switch (socket->dev->device) {
+ case PCI_DEVICE_ID_TI_1250:
+ /* the 1250 has one pin for IRQSER/INTB depending on devctl */
+ break;
+
+ case PCI_DEVICE_ID_TI_1251A:
+ case PCI_DEVICE_ID_TI_1251B:
+ case PCI_DEVICE_ID_TI_1450:
+ /*
+ * those have a pin for IRQSER/INTB plus INTB in MFUNC0
+ * we alread probed the shared pin, now go for MFUNC0
+ */
+ mfunc = (mfunc & ~TI122X_MFUNC0_MASK) | TI125X_MFUNC0_INTB;
+ break;
+
+ default:
+ mfunc = (mfunc & ~TI122X_MFUNC1_MASK) | TI122X_MFUNC1_INTB;
+ break;
+ }
+
+ /* write, probe */
+ if (mfunc != mfunc_old) {
+ config_writel(socket, TI122X_MFUNC, mfunc);
+
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status == 1) {
+ printk(KERN_INFO "Yenta TI: socket %s parallel PCI interrupts ok\n",
+ pci_name(socket->dev));
+ goto out;
+ }
+
+ mfunc = mfunc_old;
+ config_writel(socket, TI122X_MFUNC, mfunc);
+
+ if (pci_irq_status == -1)
+ goto out;
+ }
+
+ /* still nothing: set INTRTIE */
+ sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
+ if ((sysctl & TI122X_SCR_INTRTIE) == 0) {
+ sysctl |= TI122X_SCR_INTRTIE;
+ config_writel(socket, TI113X_SYSTEM_CONTROL, sysctl);
+
+ pci_irq_status = yenta_probe_cb_irq(socket);
+ if (pci_irq_status == 1) {
+ printk(KERN_INFO "Yenta TI: socket %s parallel PCI interrupts, tied ok\n",
+ pci_name(socket->dev));
+ goto out;
+ }
+
+ sysctl &= ~TI122X_SCR_INTRTIE;
+ config_writel(socket, TI113X_SYSTEM_CONTROL, sysctl);
+ }
+ }
+
+out:
+ if (pci_irq_status < 1) {
+ socket->cb_irq = 0;
+ printk(KERN_INFO "Yenta TI: socket %s no PCI interrupts. Fish. Please report.\n",
+ pci_name(socket->dev));
+ }
+
+ return ti_override(socket);
+}
+
static int ti12xx_override(struct yenta_socket *socket)
{
u32 val;
+ int ret;
/* make sure that memory burst is active */
val = config_readl(socket, TI113X_SYSTEM_CONTROL);
@@ -347,7 +672,13 @@
printk(KERN_INFO "Yenta: Routing CardBus interrupts to %s\n",
(val & TI1250_DIAG_PCI_IREQ) ? "PCI" : "ISA");
- return ti_override(socket);
+ /* do irqrouting, depending on function */
+ if (PCI_FUNC(socket->dev->devfn) == 0)
+ ret = ti12xx_irqroute_func0(socket);
+ else
+ ret = ti12xx_irqroute_func1(socket);
+
+ return ret;
}
--- linux.orig/drivers/pcmcia/yenta_socket.c
+++ linux/drivers/pcmcia/yenta_socket.c
@@ -39,6 +39,10 @@
#define to_cycles(ns) ((ns)/120)
#define to_ns(cycles) ((cycles)*120)
+static u32 isa_interrupts;
+static int yenta_probe_cb_irq(struct yenta_socket *socket);
+static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask);
+
/*
* Generate easy-to-use ways of reading a cardbus sockets
* regular memory space ("cb_xxx"), configuration space
@@ -768,6 +772,68 @@ static unsigned int yenta_probe_irq(stru
return mask;
}
+
+/* interrupt handler, only used during probing */
+static irqreturn_t yenta_probe_handler(int irq, void *dev_id, struct pt_regs *regs)
+{
+ struct yenta_socket *socket = (struct yenta_socket *) dev_id;
+ u8 csc;
+ u32 cb_event;
+
+ /* Clear interrupt status for the event */
+ cb_event = cb_readl(socket, CB_SOCKET_EVENT);
+ cb_writel(socket, CB_SOCKET_EVENT, -1);
+ csc = exca_readb(socket, I365_CSC);
+
+ if (cb_event || csc) {
+ socket->probe_status = 1;
+ return IRQ_HANDLED;
+ }
+
+ return IRQ_NONE;
+}
+
+/* probes the PCI interrupt, use only on override functions */
+static int yenta_probe_cb_irq(struct yenta_socket *socket)
+{
+ u16 bridge_ctrl;
+
+ if (!socket->cb_irq)
+ return -1;
+
+ socket->probe_status = 0;
+
+ /* disable ISA interrupts */
+ bridge_ctrl = config_readw(socket, CB_BRIDGE_CONTROL);
+ bridge_ctrl &= ~CB_BRIDGE_INTR;
+ config_writew(socket, CB_BRIDGE_CONTROL, bridge_ctrl);
+
+ if (request_irq(socket->cb_irq, yenta_probe_handler, SA_SHIRQ, "yenta", socket)) {
+ printk(KERN_WARNING "Yenta: request_irq() in yenta_probe_cb_irq() failed!\n");
+ return -1;
+ }
+
+ /* generate interrupt, wait */
+ exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG);
+ cb_writel(socket, CB_SOCKET_EVENT, -1);
+ cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK);
+ cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS);
+
+ set_current_state(TASK_UNINTERRUPTIBLE);
+ schedule_timeout(HZ/10);
+
+ /* disable interrupts */
+ cb_writel(socket, CB_SOCKET_MASK, 0);
+ exca_writeb(socket, I365_CSCINT, 0);
+ cb_writel(socket, CB_SOCKET_EVENT, -1);
+ exca_readb(socket, I365_CSC);
+
+ free_irq(socket->cb_irq, socket);
+
+ return (int) socket->probe_status;
+}
+
+
/*
* Set static data that doesn't need re-initializing..
*/
@@ -997,7 +1063,6 @@ static struct pci_device_id yenta_table
* data sheets for these devices. --rmk)
*/
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI),
- CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X),
@@ -1007,11 +1072,14 @@ static struct pci_device_id yenta_table
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX),
+ CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX),
+ CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX),
+ CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX),
-// CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX),
+ CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX),
CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250),
--- linux.orig/drivers/pcmcia/yenta_socket.h
+++ linux/drivers/pcmcia/yenta_socket.h
@@ -113,6 +113,9 @@
struct pcmcia_socket socket;
struct cardbus_type *type;
+ /* for PCI interrupt probing */
+ unsigned int probe_status;
+
/* A few words of private data for special stuff of overrides... */
unsigned int private[8];
--- linux.orig/include/linux/pci_ids.h
+++ linux/include/linux/pci_ids.h
@@ -704,6 +704,7 @@
#define PCI_VENDOR_ID_TI 0x104c
#define PCI_DEVICE_ID_TI_TVP4010 0x3d04
#define PCI_DEVICE_ID_TI_TVP4020 0x3d07
+#define PCI_DEVICE_ID_TI_4450 0x8011
#define PCI_DEVICE_ID_TI_1130 0xac12
#define PCI_DEVICE_ID_TI_1031 0xac13
#define PCI_DEVICE_ID_TI_1131 0xac15
@@ -720,6 +721,7 @@
#define PCI_DEVICE_ID_TI_4451 0xac42
#define PCI_DEVICE_ID_TI_1410 0xac50
#define PCI_DEVICE_ID_TI_1420 0xac51
+#define PCI_DEVICE_ID_TI_1451A 0xac52
#define PCI_DEVICE_ID_TI_1520 0xac55
#define PCI_DEVICE_ID_TI_1510 0xac56
More information about the linux-pcmcia
mailing list