2 * Regular cardbus driver ("yenta_socket")
4 * (C) Copyright 1999, 2000 Linus Torvalds
7 * Aug 2002: Manfred Spraul <manfred@colorfullife.com>
8 * Dynamically adjust the size of the bridge resource
10 * May 2003: Dominik Brodowski <linux@brodo.de>
11 * Merge pci_socket.c and yenta.c into one file
13 #include <linux/init.h>
14 #include <linux/pci.h>
15 #include <linux/workqueue.h>
16 #include <linux/interrupt.h>
17 #include <linux/delay.h>
18 #include <linux/module.h>
20 #include <linux/slab.h>
22 #include <pcmcia/cs_types.h>
23 #include <pcmcia/ss.h>
24 #include <pcmcia/cs.h>
26 #include "yenta_socket.h"
29 static int disable_clkrun
;
30 module_param(disable_clkrun
, bool, 0444);
31 MODULE_PARM_DESC(disable_clkrun
, "If PC card doesn't function properly, please try this option");
33 static int isa_probe
= 1;
34 module_param(isa_probe
, bool, 0444);
35 MODULE_PARM_DESC(isa_probe
, "If set ISA interrupts are probed (default). Set to N to disable probing");
37 static int pwr_irqs_off
;
38 module_param(pwr_irqs_off
, bool, 0644);
39 MODULE_PARM_DESC(pwr_irqs_off
, "Force IRQs off during power-on of slot. Use only when seeing IRQ storms!");
41 static char o2_speedup
[] = "default";
42 module_param_string(o2_speedup
, o2_speedup
, sizeof(o2_speedup
), 0444);
43 MODULE_PARM_DESC(o2_speedup
, "Use prefetch/burst for O2-bridges: 'on', 'off' "
44 "or 'default' (uses recommended behaviour for the detected bridge)");
47 * Only probe "regular" interrupts, don't
48 * touch dangerous spots like the mouse irq,
49 * because there are mice that apparently
50 * get really confused if they get fondled
53 * Default to 11, 10, 9, 7, 6, 5, 4, 3.
55 static u32 isa_interrupts
= 0x0ef8;
58 #define debug(x, s, args...) dev_dbg(&s->dev->dev, x, ##args)
61 #define to_cycles(ns) ((ns)/120)
62 #define to_ns(cycles) ((cycles)*120)
65 * yenta PCI irq probing.
66 * currently only used in the TI/EnE initialization code
68 #ifdef CONFIG_YENTA_TI
69 static int yenta_probe_cb_irq(struct yenta_socket
*socket
);
70 static unsigned int yenta_probe_irq(struct yenta_socket
*socket
,
75 static unsigned int override_bios
;
76 module_param(override_bios
, uint
, 0000);
77 MODULE_PARM_DESC(override_bios
, "yenta ignore bios resource allocation");
80 * Generate easy-to-use ways of reading a cardbus sockets
81 * regular memory space ("cb_xxx"), configuration space
82 * ("config_xxx") and compatibility space ("exca_xxxx")
84 static inline u32
cb_readl(struct yenta_socket
*socket
, unsigned reg
)
86 u32 val
= readl(socket
->base
+ reg
);
87 debug("%04x %08x\n", socket
, reg
, val
);
91 static inline void cb_writel(struct yenta_socket
*socket
, unsigned reg
, u32 val
)
93 debug("%04x %08x\n", socket
, reg
, val
);
94 writel(val
, socket
->base
+ reg
);
95 readl(socket
->base
+ reg
); /* avoid problems with PCI write posting */
98 static inline u8
config_readb(struct yenta_socket
*socket
, unsigned offset
)
101 pci_read_config_byte(socket
->dev
, offset
, &val
);
102 debug("%04x %02x\n", socket
, offset
, val
);
106 static inline u16
config_readw(struct yenta_socket
*socket
, unsigned offset
)
109 pci_read_config_word(socket
->dev
, offset
, &val
);
110 debug("%04x %04x\n", socket
, offset
, val
);
114 static inline u32
config_readl(struct yenta_socket
*socket
, unsigned offset
)
117 pci_read_config_dword(socket
->dev
, offset
, &val
);
118 debug("%04x %08x\n", socket
, offset
, val
);
122 static inline void config_writeb(struct yenta_socket
*socket
, unsigned offset
, u8 val
)
124 debug("%04x %02x\n", socket
, offset
, val
);
125 pci_write_config_byte(socket
->dev
, offset
, val
);
128 static inline void config_writew(struct yenta_socket
*socket
, unsigned offset
, u16 val
)
130 debug("%04x %04x\n", socket
, offset
, val
);
131 pci_write_config_word(socket
->dev
, offset
, val
);
134 static inline void config_writel(struct yenta_socket
*socket
, unsigned offset
, u32 val
)
136 debug("%04x %08x\n", socket
, offset
, val
);
137 pci_write_config_dword(socket
->dev
, offset
, val
);
140 static inline u8
exca_readb(struct yenta_socket
*socket
, unsigned reg
)
142 u8 val
= readb(socket
->base
+ 0x800 + reg
);
143 debug("%04x %02x\n", socket
, reg
, val
);
147 static inline u8
exca_readw(struct yenta_socket
*socket
, unsigned reg
)
150 val
= readb(socket
->base
+ 0x800 + reg
);
151 val
|= readb(socket
->base
+ 0x800 + reg
+ 1) << 8;
152 debug("%04x %04x\n", socket
, reg
, val
);
156 static inline void exca_writeb(struct yenta_socket
*socket
, unsigned reg
, u8 val
)
158 debug("%04x %02x\n", socket
, reg
, val
);
159 writeb(val
, socket
->base
+ 0x800 + reg
);
160 readb(socket
->base
+ 0x800 + reg
); /* PCI write posting... */
163 static void exca_writew(struct yenta_socket
*socket
, unsigned reg
, u16 val
)
165 debug("%04x %04x\n", socket
, reg
, val
);
166 writeb(val
, socket
->base
+ 0x800 + reg
);
167 writeb(val
>> 8, socket
->base
+ 0x800 + reg
+ 1);
169 /* PCI write posting... */
170 readb(socket
->base
+ 0x800 + reg
);
171 readb(socket
->base
+ 0x800 + reg
+ 1);
174 static ssize_t
show_yenta_registers(struct device
*yentadev
, struct device_attribute
*attr
, char *buf
)
176 struct pci_dev
*dev
= to_pci_dev(yentadev
);
177 struct yenta_socket
*socket
= pci_get_drvdata(dev
);
180 offset
= snprintf(buf
, PAGE_SIZE
, "CB registers:");
181 for (i
= 0; i
< 0x24; i
+= 4) {
184 offset
+= snprintf(buf
+ offset
, PAGE_SIZE
- offset
, "\n%02x:", i
);
185 val
= cb_readl(socket
, i
);
186 offset
+= snprintf(buf
+ offset
, PAGE_SIZE
- offset
, " %08x", val
);
189 offset
+= snprintf(buf
+ offset
, PAGE_SIZE
- offset
, "\n\nExCA registers:");
190 for (i
= 0; i
< 0x45; i
++) {
194 memcpy(buf
+ offset
, " -", 2);
197 offset
+= snprintf(buf
+ offset
, PAGE_SIZE
- offset
, "\n%02x:", i
);
199 val
= exca_readb(socket
, i
);
200 offset
+= snprintf(buf
+ offset
, PAGE_SIZE
- offset
, " %02x", val
);
202 buf
[offset
++] = '\n';
206 static DEVICE_ATTR(yenta_registers
, S_IRUSR
, show_yenta_registers
, NULL
);
209 * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend
210 * on what kind of card is inserted..
212 static int yenta_get_status(struct pcmcia_socket
*sock
, unsigned int *value
)
214 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
216 u32 state
= cb_readl(socket
, CB_SOCKET_STATE
);
218 val
= (state
& CB_3VCARD
) ? SS_3VCARD
: 0;
219 val
|= (state
& CB_XVCARD
) ? SS_XVCARD
: 0;
220 val
|= (state
& (CB_5VCARD
| CB_3VCARD
| CB_XVCARD
| CB_YVCARD
)) ? 0 : SS_PENDING
;
221 val
|= (state
& (CB_CDETECT1
| CB_CDETECT2
)) ? SS_PENDING
: 0;
224 if (state
& CB_CBCARD
) {
226 val
|= (state
& CB_CARDSTS
) ? SS_STSCHG
: 0;
227 val
|= (state
& (CB_CDETECT1
| CB_CDETECT2
)) ? 0 : SS_DETECT
;
228 val
|= (state
& CB_PWRCYCLE
) ? SS_POWERON
| SS_READY
: 0;
229 } else if (state
& CB_16BITCARD
) {
230 u8 status
= exca_readb(socket
, I365_STATUS
);
231 val
|= ((status
& I365_CS_DETECT
) == I365_CS_DETECT
) ? SS_DETECT
: 0;
232 if (exca_readb(socket
, I365_INTCTL
) & I365_PC_IOCARD
) {
233 val
|= (status
& I365_CS_STSCHG
) ? 0 : SS_STSCHG
;
235 val
|= (status
& I365_CS_BVD1
) ? 0 : SS_BATDEAD
;
236 val
|= (status
& I365_CS_BVD2
) ? 0 : SS_BATWARN
;
238 val
|= (status
& I365_CS_WRPROT
) ? SS_WRPROT
: 0;
239 val
|= (status
& I365_CS_READY
) ? SS_READY
: 0;
240 val
|= (status
& I365_CS_POWERON
) ? SS_POWERON
: 0;
247 static void yenta_set_power(struct yenta_socket
*socket
, socket_state_t
*state
)
249 /* some birdges require to use the ExCA registers to power 16bit cards */
250 if (!(cb_readl(socket
, CB_SOCKET_STATE
) & CB_CBCARD
) &&
251 (socket
->flags
& YENTA_16BIT_POWER_EXCA
)) {
253 reg
= old
= exca_readb(socket
, I365_POWER
);
254 reg
&= ~(I365_VCC_MASK
| I365_VPP1_MASK
| I365_VPP2_MASK
);
256 /* i82365SL-DF style */
257 if (socket
->flags
& YENTA_16BIT_POWER_DF
) {
258 switch (state
->Vcc
) {
269 switch (state
->Vpp
) {
275 reg
|= I365_VPP1_12V
;
279 /* i82365SL-B style */
280 switch (state
->Vcc
) {
288 switch (state
->Vpp
) {
290 reg
|= I365_VPP1_5V
| I365_VPP2_5V
;
293 reg
|= I365_VPP1_12V
| I365_VPP2_12V
;
299 exca_writeb(socket
, I365_POWER
, reg
);
301 u32 reg
= 0; /* CB_SC_STPCLK? */
302 switch (state
->Vcc
) {
313 switch (state
->Vpp
) {
321 reg
|= CB_SC_VPP_12V
;
324 if (reg
!= cb_readl(socket
, CB_SOCKET_CONTROL
))
325 cb_writel(socket
, CB_SOCKET_CONTROL
, reg
);
329 static int yenta_set_socket(struct pcmcia_socket
*sock
, socket_state_t
*state
)
331 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
334 /* if powering down: do it immediately */
336 yenta_set_power(socket
, state
);
338 socket
->io_irq
= state
->io_irq
;
339 bridge
= config_readw(socket
, CB_BRIDGE_CONTROL
) & ~(CB_BRIDGE_CRST
| CB_BRIDGE_INTR
);
340 if (cb_readl(socket
, CB_SOCKET_STATE
) & CB_CBCARD
) {
342 bridge
|= (state
->flags
& SS_RESET
) ? CB_BRIDGE_CRST
: 0;
344 /* ISA interrupt control? */
345 intr
= exca_readb(socket
, I365_INTCTL
);
346 intr
= (intr
& ~0xf);
347 if (!socket
->dev
->irq
) {
348 intr
|= socket
->cb_irq
? socket
->cb_irq
: state
->io_irq
;
349 bridge
|= CB_BRIDGE_INTR
;
351 exca_writeb(socket
, I365_INTCTL
, intr
);
355 reg
= exca_readb(socket
, I365_INTCTL
) & (I365_RING_ENA
| I365_INTR_ENA
);
356 reg
|= (state
->flags
& SS_RESET
) ? 0 : I365_PC_RESET
;
357 reg
|= (state
->flags
& SS_IOCARD
) ? I365_PC_IOCARD
: 0;
358 if (state
->io_irq
!= socket
->dev
->irq
) {
359 reg
|= state
->io_irq
;
360 bridge
|= CB_BRIDGE_INTR
;
362 exca_writeb(socket
, I365_INTCTL
, reg
);
364 reg
= exca_readb(socket
, I365_POWER
) & (I365_VCC_MASK
|I365_VPP1_MASK
);
365 reg
|= I365_PWR_NORESET
;
366 if (state
->flags
& SS_PWR_AUTO
)
367 reg
|= I365_PWR_AUTO
;
368 if (state
->flags
& SS_OUTPUT_ENA
)
370 if (exca_readb(socket
, I365_POWER
) != reg
)
371 exca_writeb(socket
, I365_POWER
, reg
);
373 /* CSC interrupt: no ISA irq for CSC */
374 reg
= exca_readb(socket
, I365_CSCINT
);
375 reg
&= I365_CSC_IRQ_MASK
;
376 reg
|= I365_CSC_DETECT
;
377 if (state
->flags
& SS_IOCARD
) {
378 if (state
->csc_mask
& SS_STSCHG
)
379 reg
|= I365_CSC_STSCHG
;
381 if (state
->csc_mask
& SS_BATDEAD
)
382 reg
|= I365_CSC_BVD1
;
383 if (state
->csc_mask
& SS_BATWARN
)
384 reg
|= I365_CSC_BVD2
;
385 if (state
->csc_mask
& SS_READY
)
386 reg
|= I365_CSC_READY
;
388 exca_writeb(socket
, I365_CSCINT
, reg
);
389 exca_readb(socket
, I365_CSC
);
390 if (sock
->zoom_video
)
391 sock
->zoom_video(sock
, state
->flags
& SS_ZVCARD
);
393 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge
);
394 /* Socket event mask: get card insert/remove events.. */
395 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
396 cb_writel(socket
, CB_SOCKET_MASK
, CB_CDMASK
);
398 /* if powering up: do it as the last step when the socket is configured */
400 yenta_set_power(socket
, state
);
404 static int yenta_set_io_map(struct pcmcia_socket
*sock
, struct pccard_io_map
*io
)
406 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
408 unsigned char ioctl
, addr
, enable
;
415 enable
= I365_ENA_IO(map
);
416 addr
= exca_readb(socket
, I365_ADDRWIN
);
418 /* Disable the window before changing it.. */
421 exca_writeb(socket
, I365_ADDRWIN
, addr
);
424 exca_writew(socket
, I365_IO(map
)+I365_W_START
, io
->start
);
425 exca_writew(socket
, I365_IO(map
)+I365_W_STOP
, io
->stop
);
427 ioctl
= exca_readb(socket
, I365_IOCTL
) & ~I365_IOCTL_MASK(map
);
428 if (io
->flags
& MAP_0WS
)
429 ioctl
|= I365_IOCTL_0WS(map
);
430 if (io
->flags
& MAP_16BIT
)
431 ioctl
|= I365_IOCTL_16BIT(map
);
432 if (io
->flags
& MAP_AUTOSZ
)
433 ioctl
|= I365_IOCTL_IOCS16(map
);
434 exca_writeb(socket
, I365_IOCTL
, ioctl
);
436 if (io
->flags
& MAP_ACTIVE
)
437 exca_writeb(socket
, I365_ADDRWIN
, addr
| enable
);
441 static int yenta_set_mem_map(struct pcmcia_socket
*sock
, struct pccard_mem_map
*mem
)
443 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
444 struct pci_bus_region region
;
446 unsigned char addr
, enable
;
447 unsigned int start
, stop
, card_start
;
450 pcibios_resource_to_bus(socket
->dev
, ®ion
, mem
->res
);
453 start
= region
.start
;
455 card_start
= mem
->card_start
;
457 if (map
> 4 || start
> stop
|| ((start
^ stop
) >> 24) ||
458 (card_start
>> 26) || mem
->speed
> 1000)
461 enable
= I365_ENA_MEM(map
);
462 addr
= exca_readb(socket
, I365_ADDRWIN
);
465 exca_writeb(socket
, I365_ADDRWIN
, addr
);
468 exca_writeb(socket
, CB_MEM_PAGE(map
), start
>> 24);
470 word
= (start
>> 12) & 0x0fff;
471 if (mem
->flags
& MAP_16BIT
)
472 word
|= I365_MEM_16BIT
;
473 if (mem
->flags
& MAP_0WS
)
474 word
|= I365_MEM_0WS
;
475 exca_writew(socket
, I365_MEM(map
) + I365_W_START
, word
);
477 word
= (stop
>> 12) & 0x0fff;
478 switch (to_cycles(mem
->speed
)) {
482 word
|= I365_MEM_WS0
;
485 word
|= I365_MEM_WS1
;
488 word
|= I365_MEM_WS1
| I365_MEM_WS0
;
491 exca_writew(socket
, I365_MEM(map
) + I365_W_STOP
, word
);
493 word
= ((card_start
- start
) >> 12) & 0x3fff;
494 if (mem
->flags
& MAP_WRPROT
)
495 word
|= I365_MEM_WRPROT
;
496 if (mem
->flags
& MAP_ATTRIB
)
497 word
|= I365_MEM_REG
;
498 exca_writew(socket
, I365_MEM(map
) + I365_W_OFF
, word
);
500 if (mem
->flags
& MAP_ACTIVE
)
501 exca_writeb(socket
, I365_ADDRWIN
, addr
| enable
);
507 static irqreturn_t
yenta_interrupt(int irq
, void *dev_id
)
510 struct yenta_socket
*socket
= (struct yenta_socket
*) dev_id
;
514 /* Clear interrupt status for the event */
515 cb_event
= cb_readl(socket
, CB_SOCKET_EVENT
);
516 cb_writel(socket
, CB_SOCKET_EVENT
, cb_event
);
518 csc
= exca_readb(socket
, I365_CSC
);
520 if (!(cb_event
|| csc
))
523 events
= (cb_event
& (CB_CD1EVENT
| CB_CD2EVENT
)) ? SS_DETECT
: 0 ;
524 events
|= (csc
& I365_CSC_DETECT
) ? SS_DETECT
: 0;
525 if (exca_readb(socket
, I365_INTCTL
) & I365_PC_IOCARD
) {
526 events
|= (csc
& I365_CSC_STSCHG
) ? SS_STSCHG
: 0;
528 events
|= (csc
& I365_CSC_BVD1
) ? SS_BATDEAD
: 0;
529 events
|= (csc
& I365_CSC_BVD2
) ? SS_BATWARN
: 0;
530 events
|= (csc
& I365_CSC_READY
) ? SS_READY
: 0;
534 pcmcia_parse_events(&socket
->socket
, events
);
539 static void yenta_interrupt_wrapper(unsigned long data
)
541 struct yenta_socket
*socket
= (struct yenta_socket
*) data
;
543 yenta_interrupt(0, (void *)socket
);
544 socket
->poll_timer
.expires
= jiffies
+ HZ
;
545 add_timer(&socket
->poll_timer
);
548 static void yenta_clear_maps(struct yenta_socket
*socket
)
551 struct resource res
= { .start
= 0, .end
= 0x0fff };
552 pccard_io_map io
= { 0, 0, 0, 0, 1 };
553 pccard_mem_map mem
= { .res
= &res
, };
555 yenta_set_socket(&socket
->socket
, &dead_socket
);
556 for (i
= 0; i
< 2; i
++) {
558 yenta_set_io_map(&socket
->socket
, &io
);
560 for (i
= 0; i
< 5; i
++) {
562 yenta_set_mem_map(&socket
->socket
, &mem
);
566 /* redoes voltage interrogation if required */
567 static void yenta_interrogate(struct yenta_socket
*socket
)
571 state
= cb_readl(socket
, CB_SOCKET_STATE
);
572 if (!(state
& (CB_5VCARD
| CB_3VCARD
| CB_XVCARD
| CB_YVCARD
)) ||
573 (state
& (CB_CDETECT1
| CB_CDETECT2
| CB_NOTACARD
| CB_BADVCCREQ
)) ||
574 ((state
& (CB_16BITCARD
| CB_CBCARD
)) == (CB_16BITCARD
| CB_CBCARD
)))
575 cb_writel(socket
, CB_SOCKET_FORCE
, CB_CVSTEST
);
578 /* Called at resume and initialization events */
579 static int yenta_sock_init(struct pcmcia_socket
*sock
)
581 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
583 exca_writeb(socket
, I365_GBLCTL
, 0x00);
584 exca_writeb(socket
, I365_GENCTL
, 0x00);
586 /* Redo card voltage interrogation */
587 yenta_interrogate(socket
);
589 yenta_clear_maps(socket
);
591 if (socket
->type
&& socket
->type
->sock_init
)
592 socket
->type
->sock_init(socket
);
594 /* Re-enable CSC interrupts */
595 cb_writel(socket
, CB_SOCKET_MASK
, CB_CDMASK
);
600 static int yenta_sock_suspend(struct pcmcia_socket
*sock
)
602 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
604 /* Disable CSC interrupts */
605 cb_writel(socket
, CB_SOCKET_MASK
, 0x0);
611 * Use an adaptive allocation for the memory resource,
612 * sometimes the memory behind pci bridges is limited:
613 * 1/8 of the size of the io window of the parent.
614 * max 4 MB, min 16 kB. We try very hard to not get below
615 * the "ACC" values, though.
617 #define BRIDGE_MEM_MAX (4*1024*1024)
618 #define BRIDGE_MEM_ACC (128*1024)
619 #define BRIDGE_MEM_MIN (16*1024)
621 #define BRIDGE_IO_MAX 512
622 #define BRIDGE_IO_ACC 256
623 #define BRIDGE_IO_MIN 32
625 #ifndef PCIBIOS_MIN_CARDBUS_IO
626 #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO
629 static int yenta_search_one_res(struct resource
*root
, struct resource
*res
,
632 u32 align
, size
, start
, end
;
634 if (res
->flags
& IORESOURCE_IO
) {
636 size
= BRIDGE_IO_MAX
;
637 start
= PCIBIOS_MIN_CARDBUS_IO
;
640 unsigned long avail
= root
->end
- root
->start
;
642 size
= BRIDGE_MEM_MAX
;
643 if (size
> avail
/8) {
645 /* round size down to next power of 2 */
647 while ((size
/= 2) != 0)
654 start
= PCIBIOS_MIN_MEM
;
659 if (allocate_resource(root
, res
, size
, start
, end
, align
,
665 } while (size
>= min
);
671 static int yenta_search_res(struct yenta_socket
*socket
, struct resource
*res
,
674 struct resource
*root
;
677 pci_bus_for_each_resource(socket
->dev
->bus
, root
, i
) {
681 if ((res
->flags
^ root
->flags
) &
682 (IORESOURCE_IO
| IORESOURCE_MEM
| IORESOURCE_PREFETCH
))
683 continue; /* Wrong type */
685 if (yenta_search_one_res(root
, res
, min
))
691 static int yenta_allocate_res(struct yenta_socket
*socket
, int nr
, unsigned type
, int addr_start
, int addr_end
)
693 struct pci_dev
*dev
= socket
->dev
;
694 struct resource
*res
;
695 struct pci_bus_region region
;
698 res
= dev
->resource
+ PCI_BRIDGE_RESOURCES
+ nr
;
699 /* Already allocated? */
703 /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */
705 if (type
& IORESOURCE_IO
)
708 res
->name
= dev
->subordinate
->name
;
711 region
.start
= config_readl(socket
, addr_start
) & mask
;
712 region
.end
= config_readl(socket
, addr_end
) | ~mask
;
713 if (region
.start
&& region
.end
> region
.start
&& !override_bios
) {
714 pcibios_bus_to_resource(dev
, res
, ®ion
);
715 if (pci_claim_resource(dev
, PCI_BRIDGE_RESOURCES
+ nr
) == 0)
717 dev_printk(KERN_INFO
, &dev
->dev
,
718 "Preassigned resource %d busy or not available, "
719 "reconfiguring...\n",
723 if (type
& IORESOURCE_IO
) {
724 if ((yenta_search_res(socket
, res
, BRIDGE_IO_MAX
)) ||
725 (yenta_search_res(socket
, res
, BRIDGE_IO_ACC
)) ||
726 (yenta_search_res(socket
, res
, BRIDGE_IO_MIN
)))
729 if (type
& IORESOURCE_PREFETCH
) {
730 if ((yenta_search_res(socket
, res
, BRIDGE_MEM_MAX
)) ||
731 (yenta_search_res(socket
, res
, BRIDGE_MEM_ACC
)) ||
732 (yenta_search_res(socket
, res
, BRIDGE_MEM_MIN
)))
734 /* Approximating prefetchable by non-prefetchable */
735 res
->flags
= IORESOURCE_MEM
;
737 if ((yenta_search_res(socket
, res
, BRIDGE_MEM_MAX
)) ||
738 (yenta_search_res(socket
, res
, BRIDGE_MEM_ACC
)) ||
739 (yenta_search_res(socket
, res
, BRIDGE_MEM_MIN
)))
743 dev_printk(KERN_INFO
, &dev
->dev
,
744 "no resource of type %x available, trying to continue...\n",
746 res
->start
= res
->end
= res
->flags
= 0;
751 * Allocate the bridge mappings for the device..
753 static void yenta_allocate_resources(struct yenta_socket
*socket
)
756 program
+= yenta_allocate_res(socket
, 0, IORESOURCE_IO
,
757 PCI_CB_IO_BASE_0
, PCI_CB_IO_LIMIT_0
);
758 program
+= yenta_allocate_res(socket
, 1, IORESOURCE_IO
,
759 PCI_CB_IO_BASE_1
, PCI_CB_IO_LIMIT_1
);
760 program
+= yenta_allocate_res(socket
, 2, IORESOURCE_MEM
|IORESOURCE_PREFETCH
,
761 PCI_CB_MEMORY_BASE_0
, PCI_CB_MEMORY_LIMIT_0
);
762 program
+= yenta_allocate_res(socket
, 3, IORESOURCE_MEM
,
763 PCI_CB_MEMORY_BASE_1
, PCI_CB_MEMORY_LIMIT_1
);
765 pci_setup_cardbus(socket
->dev
->subordinate
);
770 * Free the bridge mappings for the device..
772 static void yenta_free_resources(struct yenta_socket
*socket
)
775 for (i
= 0; i
< 4; i
++) {
776 struct resource
*res
;
777 res
= socket
->dev
->resource
+ PCI_BRIDGE_RESOURCES
+ i
;
778 if (res
->start
!= 0 && res
->end
!= 0)
779 release_resource(res
);
780 res
->start
= res
->end
= res
->flags
= 0;
786 * Close it down - release our resources and go home..
788 static void __devexit
yenta_close(struct pci_dev
*dev
)
790 struct yenta_socket
*sock
= pci_get_drvdata(dev
);
792 /* Remove the register attributes */
793 device_remove_file(&dev
->dev
, &dev_attr_yenta_registers
);
795 /* we don't want a dying socket registered */
796 pcmcia_unregister_socket(&sock
->socket
);
798 /* Disable all events so we don't die in an IRQ storm */
799 cb_writel(sock
, CB_SOCKET_MASK
, 0x0);
800 exca_writeb(sock
, I365_CSCINT
, 0);
803 free_irq(sock
->cb_irq
, sock
);
805 del_timer_sync(&sock
->poll_timer
);
809 yenta_free_resources(sock
);
811 pci_release_regions(dev
);
812 pci_disable_device(dev
);
813 pci_set_drvdata(dev
, NULL
);
817 static struct pccard_operations yenta_socket_operations
= {
818 .init
= yenta_sock_init
,
819 .suspend
= yenta_sock_suspend
,
820 .get_status
= yenta_get_status
,
821 .set_socket
= yenta_set_socket
,
822 .set_io_map
= yenta_set_io_map
,
823 .set_mem_map
= yenta_set_mem_map
,
827 #ifdef CONFIG_YENTA_TI
830 #ifdef CONFIG_YENTA_RICOH
833 #ifdef CONFIG_YENTA_TOSHIBA
836 #ifdef CONFIG_YENTA_O2
841 CARDBUS_TYPE_DEFAULT
= -1,
847 CARDBUS_TYPE_TOPIC95
,
848 CARDBUS_TYPE_TOPIC97
,
849 CARDBUS_TYPE_O2MICRO
,
854 * Different cardbus controllers have slightly different
855 * initialization sequences etc details. List them here..
857 static struct cardbus_type cardbus_type
[] = {
858 #ifdef CONFIG_YENTA_TI
859 [CARDBUS_TYPE_TI
] = {
860 .override
= ti_override
,
861 .save_state
= ti_save_state
,
862 .restore_state
= ti_restore_state
,
863 .sock_init
= ti_init
,
865 [CARDBUS_TYPE_TI113X
] = {
866 .override
= ti113x_override
,
867 .save_state
= ti_save_state
,
868 .restore_state
= ti_restore_state
,
869 .sock_init
= ti_init
,
871 [CARDBUS_TYPE_TI12XX
] = {
872 .override
= ti12xx_override
,
873 .save_state
= ti_save_state
,
874 .restore_state
= ti_restore_state
,
875 .sock_init
= ti_init
,
877 [CARDBUS_TYPE_TI1250
] = {
878 .override
= ti1250_override
,
879 .save_state
= ti_save_state
,
880 .restore_state
= ti_restore_state
,
881 .sock_init
= ti_init
,
884 #ifdef CONFIG_YENTA_RICOH
885 [CARDBUS_TYPE_RICOH
] = {
886 .override
= ricoh_override
,
887 .save_state
= ricoh_save_state
,
888 .restore_state
= ricoh_restore_state
,
891 #ifdef CONFIG_YENTA_TOSHIBA
892 [CARDBUS_TYPE_TOPIC95
] = {
893 .override
= topic95_override
,
895 [CARDBUS_TYPE_TOPIC97
] = {
896 .override
= topic97_override
,
899 #ifdef CONFIG_YENTA_O2
900 [CARDBUS_TYPE_O2MICRO
] = {
901 .override
= o2micro_override
,
902 .restore_state
= o2micro_restore_state
,
905 #ifdef CONFIG_YENTA_TI
906 [CARDBUS_TYPE_ENE
] = {
907 .override
= ene_override
,
908 .save_state
= ti_save_state
,
909 .restore_state
= ti_restore_state
,
910 .sock_init
= ti_init
,
916 static unsigned int yenta_probe_irq(struct yenta_socket
*socket
, u32 isa_irq_mask
)
924 * Probe for usable interrupts using the force
925 * register to generate bogus card status events.
927 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
928 cb_writel(socket
, CB_SOCKET_MASK
, CB_CSTSMASK
);
929 reg
= exca_readb(socket
, I365_CSCINT
);
930 exca_writeb(socket
, I365_CSCINT
, 0);
931 val
= probe_irq_on() & isa_irq_mask
;
932 for (i
= 1; i
< 16; i
++) {
933 if (!((val
>> i
) & 1))
935 exca_writeb(socket
, I365_CSCINT
, I365_CSC_STSCHG
| (i
<< 4));
936 cb_writel(socket
, CB_SOCKET_FORCE
, CB_FCARDSTS
);
938 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
940 cb_writel(socket
, CB_SOCKET_MASK
, 0);
941 exca_writeb(socket
, I365_CSCINT
, reg
);
943 mask
= probe_irq_mask(val
) & 0xffff;
950 * yenta PCI irq probing.
951 * currently only used in the TI/EnE initialization code
953 #ifdef CONFIG_YENTA_TI
955 /* interrupt handler, only used during probing */
956 static irqreturn_t
yenta_probe_handler(int irq
, void *dev_id
)
958 struct yenta_socket
*socket
= (struct yenta_socket
*) dev_id
;
962 /* Clear interrupt status for the event */
963 cb_event
= cb_readl(socket
, CB_SOCKET_EVENT
);
964 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
965 csc
= exca_readb(socket
, I365_CSC
);
967 if (cb_event
|| csc
) {
968 socket
->probe_status
= 1;
975 /* probes the PCI interrupt, use only on override functions */
976 static int yenta_probe_cb_irq(struct yenta_socket
*socket
)
983 socket
->probe_status
= 0;
985 if (request_irq(socket
->cb_irq
, yenta_probe_handler
, IRQF_SHARED
, "yenta", socket
)) {
986 dev_printk(KERN_WARNING
, &socket
->dev
->dev
,
987 "request_irq() in yenta_probe_cb_irq() failed!\n");
991 /* generate interrupt, wait */
992 if (!socket
->dev
->irq
)
993 reg
= exca_readb(socket
, I365_CSCINT
);
994 exca_writeb(socket
, I365_CSCINT
, reg
| I365_CSC_STSCHG
);
995 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
996 cb_writel(socket
, CB_SOCKET_MASK
, CB_CSTSMASK
);
997 cb_writel(socket
, CB_SOCKET_FORCE
, CB_FCARDSTS
);
1001 /* disable interrupts */
1002 cb_writel(socket
, CB_SOCKET_MASK
, 0);
1003 exca_writeb(socket
, I365_CSCINT
, reg
);
1004 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
1005 exca_readb(socket
, I365_CSC
);
1007 free_irq(socket
->cb_irq
, socket
);
1009 return (int) socket
->probe_status
;
1012 #endif /* CONFIG_YENTA_TI */
1016 * Set static data that doesn't need re-initializing..
1018 static void yenta_get_socket_capabilities(struct yenta_socket
*socket
, u32 isa_irq_mask
)
1020 socket
->socket
.pci_irq
= socket
->cb_irq
;
1022 socket
->socket
.irq_mask
= yenta_probe_irq(socket
, isa_irq_mask
);
1024 socket
->socket
.irq_mask
= 0;
1026 dev_printk(KERN_INFO
, &socket
->dev
->dev
,
1027 "ISA IRQ mask 0x%04x, PCI irq %d\n",
1028 socket
->socket
.irq_mask
, socket
->cb_irq
);
1032 * Initialize the standard cardbus registers
1034 static void yenta_config_init(struct yenta_socket
*socket
)
1037 struct pci_dev
*dev
= socket
->dev
;
1038 struct pci_bus_region region
;
1040 pcibios_resource_to_bus(socket
->dev
, ®ion
, &dev
->resource
[0]);
1042 config_writel(socket
, CB_LEGACY_MODE_BASE
, 0);
1043 config_writel(socket
, PCI_BASE_ADDRESS_0
, region
.start
);
1044 config_writew(socket
, PCI_COMMAND
,
1046 PCI_COMMAND_MEMORY
|
1047 PCI_COMMAND_MASTER
|
1050 /* MAGIC NUMBERS! Fixme */
1051 config_writeb(socket
, PCI_CACHE_LINE_SIZE
, L1_CACHE_BYTES
/ 4);
1052 config_writeb(socket
, PCI_LATENCY_TIMER
, 168);
1053 config_writel(socket
, PCI_PRIMARY_BUS
,
1054 (176 << 24) | /* sec. latency timer */
1055 (dev
->subordinate
->subordinate
<< 16) | /* subordinate bus */
1056 (dev
->subordinate
->secondary
<< 8) | /* secondary bus */
1057 dev
->subordinate
->primary
); /* primary bus */
1060 * Set up the bridging state:
1061 * - enable write posting.
1062 * - memory window 0 prefetchable, window 1 non-prefetchable
1063 * - PCI interrupts enabled if a PCI interrupt exists..
1065 bridge
= config_readw(socket
, CB_BRIDGE_CONTROL
);
1066 bridge
&= ~(CB_BRIDGE_CRST
| CB_BRIDGE_PREFETCH1
| CB_BRIDGE_ISAEN
| CB_BRIDGE_VGAEN
);
1067 bridge
|= CB_BRIDGE_PREFETCH0
| CB_BRIDGE_POSTEN
;
1068 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge
);
1072 * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge
1073 * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to
1075 * Checks if devices on the bus which the CardBus bridge bridges to would be
1076 * invisible during PCI scans because of a misconfigured subordinate number
1077 * of the parent brige - some BIOSes seem to be too lazy to set it right.
1078 * Does the fixup carefully by checking how far it can go without conflicts.
1079 * See http\://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information.
1081 static void yenta_fixup_parent_bridge(struct pci_bus
*cardbus_bridge
)
1083 struct list_head
*tmp
;
1084 unsigned char upper_limit
;
1086 * We only check and fix the parent bridge: All systems which need
1087 * this fixup that have been reviewed are laptops and the only bridge
1088 * which needed fixing was the parent bridge of the CardBus bridge:
1090 struct pci_bus
*bridge_to_fix
= cardbus_bridge
->parent
;
1092 /* Check bus numbers are already set up correctly: */
1093 if (bridge_to_fix
->subordinate
>= cardbus_bridge
->subordinate
)
1094 return; /* The subordinate number is ok, nothing to do */
1096 if (!bridge_to_fix
->parent
)
1097 return; /* Root bridges are ok */
1099 /* stay within the limits of the bus range of the parent: */
1100 upper_limit
= bridge_to_fix
->parent
->subordinate
;
1102 /* check the bus ranges of all silbling bridges to prevent overlap */
1103 list_for_each(tmp
, &bridge_to_fix
->parent
->children
) {
1104 struct pci_bus
*silbling
= pci_bus_b(tmp
);
1106 * If the silbling has a higher secondary bus number
1107 * and it's secondary is equal or smaller than our
1108 * current upper limit, set the new upper limit to
1109 * the bus number below the silbling's range:
1111 if (silbling
->secondary
> bridge_to_fix
->subordinate
1112 && silbling
->secondary
<= upper_limit
)
1113 upper_limit
= silbling
->secondary
- 1;
1116 /* Show that the wanted subordinate number is not possible: */
1117 if (cardbus_bridge
->subordinate
> upper_limit
)
1118 dev_printk(KERN_WARNING
, &cardbus_bridge
->dev
,
1119 "Upper limit for fixing this "
1120 "bridge's parent bridge: #%02x\n", upper_limit
);
1122 /* If we have room to increase the bridge's subordinate number, */
1123 if (bridge_to_fix
->subordinate
< upper_limit
) {
1125 /* use the highest number of the hidden bus, within limits */
1126 unsigned char subordinate_to_assign
=
1127 min(cardbus_bridge
->subordinate
, upper_limit
);
1129 dev_printk(KERN_INFO
, &bridge_to_fix
->dev
,
1130 "Raising subordinate bus# of parent "
1131 "bus (#%02x) from #%02x to #%02x\n",
1132 bridge_to_fix
->number
,
1133 bridge_to_fix
->subordinate
, subordinate_to_assign
);
1135 /* Save the new subordinate in the bus struct of the bridge */
1136 bridge_to_fix
->subordinate
= subordinate_to_assign
;
1138 /* and update the PCI config space with the new subordinate */
1139 pci_write_config_byte(bridge_to_fix
->self
,
1140 PCI_SUBORDINATE_BUS
, bridge_to_fix
->subordinate
);
1145 * Initialize a cardbus controller. Make sure we have a usable
1146 * interrupt, and that we can map the cardbus area. Fill in the
1147 * socket information structure..
1149 static int __devinit
yenta_probe(struct pci_dev
*dev
, const struct pci_device_id
*id
)
1151 struct yenta_socket
*socket
;
1155 * If we failed to assign proper bus numbers for this cardbus
1156 * controller during PCI probe, its subordinate pci_bus is NULL.
1159 if (!dev
->subordinate
) {
1160 dev_printk(KERN_ERR
, &dev
->dev
, "no bus associated! "
1161 "(try 'pci=assign-busses')\n");
1165 socket
= kzalloc(sizeof(struct yenta_socket
), GFP_KERNEL
);
1169 /* prepare pcmcia_socket */
1170 socket
->socket
.ops
= ¥ta_socket_operations
;
1171 socket
->socket
.resource_ops
= &pccard_nonstatic_ops
;
1172 socket
->socket
.dev
.parent
= &dev
->dev
;
1173 socket
->socket
.driver_data
= socket
;
1174 socket
->socket
.owner
= THIS_MODULE
;
1175 socket
->socket
.features
= SS_CAP_PAGE_REGS
| SS_CAP_PCCARD
;
1176 socket
->socket
.map_size
= 0x1000;
1177 socket
->socket
.cb_dev
= dev
;
1179 /* prepare struct yenta_socket */
1181 pci_set_drvdata(dev
, socket
);
1184 * Do some basic sanity checking..
1186 if (pci_enable_device(dev
)) {
1191 ret
= pci_request_regions(dev
, "yenta_socket");
1195 if (!pci_resource_start(dev
, 0)) {
1196 dev_printk(KERN_ERR
, &dev
->dev
, "No cardbus resource!\n");
1202 * Ok, start setup.. Map the cardbus registers,
1203 * and request the IRQ.
1205 socket
->base
= ioremap(pci_resource_start(dev
, 0), 0x1000);
1206 if (!socket
->base
) {
1212 * report the subsystem vendor and device for help debugging
1215 dev_printk(KERN_INFO
, &dev
->dev
, "CardBus bridge found [%04x:%04x]\n",
1216 dev
->subsystem_vendor
, dev
->subsystem_device
);
1218 yenta_config_init(socket
);
1220 /* Disable all events */
1221 cb_writel(socket
, CB_SOCKET_MASK
, 0x0);
1223 /* Set up the bridge regions.. */
1224 yenta_allocate_resources(socket
);
1226 socket
->cb_irq
= dev
->irq
;
1228 /* Do we have special options for the device? */
1229 if (id
->driver_data
!= CARDBUS_TYPE_DEFAULT
&&
1230 id
->driver_data
< ARRAY_SIZE(cardbus_type
)) {
1231 socket
->type
= &cardbus_type
[id
->driver_data
];
1233 ret
= socket
->type
->override(socket
);
1238 /* We must finish initialization here */
1240 if (!socket
->cb_irq
|| request_irq(socket
->cb_irq
, yenta_interrupt
, IRQF_SHARED
, "yenta", socket
)) {
1241 /* No IRQ or request_irq failed. Poll */
1242 socket
->cb_irq
= 0; /* But zero is a valid IRQ number. */
1243 init_timer(&socket
->poll_timer
);
1244 socket
->poll_timer
.function
= yenta_interrupt_wrapper
;
1245 socket
->poll_timer
.data
= (unsigned long)socket
;
1246 socket
->poll_timer
.expires
= jiffies
+ HZ
;
1247 add_timer(&socket
->poll_timer
);
1248 dev_printk(KERN_INFO
, &dev
->dev
,
1249 "no PCI IRQ, CardBus support disabled for this "
1251 dev_printk(KERN_INFO
, &dev
->dev
,
1252 "check your BIOS CardBus, BIOS IRQ or ACPI "
1255 socket
->socket
.features
|= SS_CAP_CARDBUS
;
1258 /* Figure out what the dang thing can do for the PCMCIA layer... */
1259 yenta_interrogate(socket
);
1260 yenta_get_socket_capabilities(socket
, isa_interrupts
);
1261 dev_printk(KERN_INFO
, &dev
->dev
,
1262 "Socket status: %08x\n", cb_readl(socket
, CB_SOCKET_STATE
));
1264 yenta_fixup_parent_bridge(dev
->subordinate
);
1266 /* Register it with the pcmcia layer.. */
1267 ret
= pcmcia_register_socket(&socket
->socket
);
1269 /* Add the yenta register attributes */
1270 ret
= device_create_file(&dev
->dev
, &dev_attr_yenta_registers
);
1275 pcmcia_unregister_socket(&socket
->socket
);
1279 iounmap(socket
->base
);
1281 pci_release_regions(dev
);
1283 pci_disable_device(dev
);
1291 static int yenta_dev_suspend_noirq(struct device
*dev
)
1293 struct pci_dev
*pdev
= to_pci_dev(dev
);
1294 struct yenta_socket
*socket
= pci_get_drvdata(pdev
);
1299 if (socket
->type
&& socket
->type
->save_state
)
1300 socket
->type
->save_state(socket
);
1302 pci_save_state(pdev
);
1303 pci_read_config_dword(pdev
, 16*4, &socket
->saved_state
[0]);
1304 pci_read_config_dword(pdev
, 17*4, &socket
->saved_state
[1]);
1305 pci_disable_device(pdev
);
1310 static int yenta_dev_resume_noirq(struct device
*dev
)
1312 struct pci_dev
*pdev
= to_pci_dev(dev
);
1313 struct yenta_socket
*socket
= pci_get_drvdata(pdev
);
1319 pci_write_config_dword(pdev
, 16*4, socket
->saved_state
[0]);
1320 pci_write_config_dword(pdev
, 17*4, socket
->saved_state
[1]);
1322 ret
= pci_enable_device(pdev
);
1326 pci_set_master(pdev
);
1328 if (socket
->type
&& socket
->type
->restore_state
)
1329 socket
->type
->restore_state(socket
);
1334 static const struct dev_pm_ops yenta_pm_ops
= {
1335 .suspend_noirq
= yenta_dev_suspend_noirq
,
1336 .resume_noirq
= yenta_dev_resume_noirq
,
1337 .freeze_noirq
= yenta_dev_suspend_noirq
,
1338 .thaw_noirq
= yenta_dev_resume_noirq
,
1339 .poweroff_noirq
= yenta_dev_suspend_noirq
,
1340 .restore_noirq
= yenta_dev_resume_noirq
,
1343 #define YENTA_PM_OPS (¥ta_pm_ops)
1345 #define YENTA_PM_OPS NULL
1348 #define CB_ID(vend, dev, type) \
1352 .subvendor = PCI_ANY_ID, \
1353 .subdevice = PCI_ANY_ID, \
1354 .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \
1356 .driver_data = CARDBUS_TYPE_##type, \
1359 static struct pci_device_id yenta_table
[] = {
1360 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1031
, TI
),
1363 * TBD: Check if these TI variants can use more
1364 * advanced overrides instead. (I can't get the
1365 * data sheets for these devices. --rmk)
1367 #ifdef CONFIG_YENTA_TI
1368 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1210
, TI
),
1370 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1130
, TI113X
),
1371 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1131
, TI113X
),
1373 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1211
, TI12XX
),
1374 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1220
, TI12XX
),
1375 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1221
, TI12XX
),
1376 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1225
, TI12XX
),
1377 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1251A
, TI12XX
),
1378 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1251B
, TI12XX
),
1379 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1420
, TI12XX
),
1380 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1450
, TI12XX
),
1381 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1451A
, TI12XX
),
1382 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1510
, TI12XX
),
1383 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1520
, TI12XX
),
1384 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1620
, TI12XX
),
1385 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4410
, TI12XX
),
1386 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4450
, TI12XX
),
1387 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4451
, TI12XX
),
1388 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4510
, TI12XX
),
1389 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4520
, TI12XX
),
1391 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1250
, TI1250
),
1392 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1410
, TI1250
),
1394 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_XX21_XX11
, TI12XX
),
1395 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_X515
, TI12XX
),
1396 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_XX12
, TI12XX
),
1397 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_X420
, TI12XX
),
1398 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_X620
, TI12XX
),
1399 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_7410
, TI12XX
),
1400 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_7510
, TI12XX
),
1401 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_7610
, TI12XX
),
1403 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_710
, ENE
),
1404 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_712
, ENE
),
1405 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_720
, ENE
),
1406 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_722
, ENE
),
1407 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1211
, ENE
),
1408 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1225
, ENE
),
1409 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1410
, ENE
),
1410 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1420
, ENE
),
1411 #endif /* CONFIG_YENTA_TI */
1413 #ifdef CONFIG_YENTA_RICOH
1414 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C465
, RICOH
),
1415 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C466
, RICOH
),
1416 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C475
, RICOH
),
1417 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C476
, RICOH
),
1418 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C478
, RICOH
),
1421 #ifdef CONFIG_YENTA_TOSHIBA
1422 CB_ID(PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_TOSHIBA_TOPIC95
, TOPIC95
),
1423 CB_ID(PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_TOSHIBA_TOPIC97
, TOPIC97
),
1424 CB_ID(PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_TOSHIBA_TOPIC100
, TOPIC97
),
1427 #ifdef CONFIG_YENTA_O2
1428 CB_ID(PCI_VENDOR_ID_O2
, PCI_ANY_ID
, O2MICRO
),
1431 /* match any cardbus bridge */
1432 CB_ID(PCI_ANY_ID
, PCI_ANY_ID
, DEFAULT
),
1433 { /* all zeroes */ }
1435 MODULE_DEVICE_TABLE(pci
, yenta_table
);
1438 static struct pci_driver yenta_cardbus_driver
= {
1439 .name
= "yenta_cardbus",
1440 .id_table
= yenta_table
,
1441 .probe
= yenta_probe
,
1442 .remove
= __devexit_p(yenta_close
),
1443 .driver
.pm
= YENTA_PM_OPS
,
1447 static int __init
yenta_socket_init(void)
1449 return pci_register_driver(¥ta_cardbus_driver
);
1453 static void __exit
yenta_socket_exit(void)
1455 pci_unregister_driver(¥ta_cardbus_driver
);
1459 module_init(yenta_socket_init
);
1460 module_exit(yenta_socket_exit
);
1462 MODULE_LICENSE("GPL");