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/sched.h>
16 #include <linux/workqueue.h>
17 #include <linux/interrupt.h>
18 #include <linux/delay.h>
19 #include <linux/module.h>
21 #include <pcmcia/version.h>
22 #include <pcmcia/cs_types.h>
23 #include <pcmcia/ss.h>
24 #include <pcmcia/cs.h>
28 #include "yenta_socket.h"
33 #define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
35 #define debug(x,args...)
39 #define to_cycles(ns) ((ns)/120)
40 #define to_ns(cycles) ((cycles)*120)
42 static int yenta_probe_cb_irq(struct yenta_socket
*socket
);
46 * Generate easy-to-use ways of reading a cardbus sockets
47 * regular memory space ("cb_xxx"), configuration space
48 * ("config_xxx") and compatibility space ("exca_xxxx")
50 static inline u32
cb_readl(struct yenta_socket
*socket
, unsigned reg
)
52 u32 val
= readl(socket
->base
+ reg
);
53 debug("%p %04x %08x\n", socket
, reg
, val
);
57 static inline void cb_writel(struct yenta_socket
*socket
, unsigned reg
, u32 val
)
59 debug("%p %04x %08x\n", socket
, reg
, val
);
60 writel(val
, socket
->base
+ reg
);
63 static inline u8
config_readb(struct yenta_socket
*socket
, unsigned offset
)
66 pci_read_config_byte(socket
->dev
, offset
, &val
);
67 debug("%p %04x %02x\n", socket
, offset
, val
);
71 static inline u16
config_readw(struct yenta_socket
*socket
, unsigned offset
)
74 pci_read_config_word(socket
->dev
, offset
, &val
);
75 debug("%p %04x %04x\n", socket
, offset
, val
);
79 static inline u32
config_readl(struct yenta_socket
*socket
, unsigned offset
)
82 pci_read_config_dword(socket
->dev
, offset
, &val
);
83 debug("%p %04x %08x\n", socket
, offset
, val
);
87 static inline void config_writeb(struct yenta_socket
*socket
, unsigned offset
, u8 val
)
89 debug("%p %04x %02x\n", socket
, offset
, val
);
90 pci_write_config_byte(socket
->dev
, offset
, val
);
93 static inline void config_writew(struct yenta_socket
*socket
, unsigned offset
, u16 val
)
95 debug("%p %04x %04x\n", socket
, offset
, val
);
96 pci_write_config_word(socket
->dev
, offset
, val
);
99 static inline void config_writel(struct yenta_socket
*socket
, unsigned offset
, u32 val
)
101 debug("%p %04x %08x\n", socket
, offset
, val
);
102 pci_write_config_dword(socket
->dev
, offset
, val
);
105 static inline u8
exca_readb(struct yenta_socket
*socket
, unsigned reg
)
107 u8 val
= readb(socket
->base
+ 0x800 + reg
);
108 debug("%p %04x %02x\n", socket
, reg
, val
);
112 static inline u8
exca_readw(struct yenta_socket
*socket
, unsigned reg
)
115 val
= readb(socket
->base
+ 0x800 + reg
);
116 val
|= readb(socket
->base
+ 0x800 + reg
+ 1) << 8;
117 debug("%p %04x %04x\n", socket
, reg
, val
);
121 static inline void exca_writeb(struct yenta_socket
*socket
, unsigned reg
, u8 val
)
123 debug("%p %04x %02x\n", socket
, reg
, val
);
124 writeb(val
, socket
->base
+ 0x800 + reg
);
127 static void exca_writew(struct yenta_socket
*socket
, unsigned reg
, u16 val
)
129 debug("%p %04x %04x\n", socket
, reg
, val
);
130 writeb(val
, socket
->base
+ 0x800 + reg
);
131 writeb(val
>> 8, socket
->base
+ 0x800 + reg
+ 1);
135 * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend
136 * on what kind of card is inserted..
138 static int yenta_get_status(struct pcmcia_socket
*sock
, unsigned int *value
)
140 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
142 u32 state
= cb_readl(socket
, CB_SOCKET_STATE
);
144 val
= (state
& CB_3VCARD
) ? SS_3VCARD
: 0;
145 val
|= (state
& CB_XVCARD
) ? SS_XVCARD
: 0;
146 val
|= (state
& (CB_CDETECT1
| CB_CDETECT2
| CB_5VCARD
| CB_3VCARD
147 | CB_XVCARD
| CB_YVCARD
)) ? 0 : SS_PENDING
;
149 if (state
& CB_CBCARD
) {
151 val
|= (state
& CB_CARDSTS
) ? SS_STSCHG
: 0;
152 val
|= (state
& (CB_CDETECT1
| CB_CDETECT2
)) ? 0 : SS_DETECT
;
153 val
|= (state
& CB_PWRCYCLE
) ? SS_POWERON
| SS_READY
: 0;
155 u8 status
= exca_readb(socket
, I365_STATUS
);
156 val
|= ((status
& I365_CS_DETECT
) == I365_CS_DETECT
) ? SS_DETECT
: 0;
157 if (exca_readb(socket
, I365_INTCTL
) & I365_PC_IOCARD
) {
158 val
|= (status
& I365_CS_STSCHG
) ? 0 : SS_STSCHG
;
160 val
|= (status
& I365_CS_BVD1
) ? 0 : SS_BATDEAD
;
161 val
|= (status
& I365_CS_BVD2
) ? 0 : SS_BATWARN
;
163 val
|= (status
& I365_CS_WRPROT
) ? SS_WRPROT
: 0;
164 val
|= (status
& I365_CS_READY
) ? SS_READY
: 0;
165 val
|= (status
& I365_CS_POWERON
) ? SS_POWERON
: 0;
172 static int yenta_Vcc_power(u32 control
)
174 switch (control
& CB_SC_VCC_MASK
) {
175 case CB_SC_VCC_5V
: return 50;
176 case CB_SC_VCC_3V
: return 33;
181 static int yenta_Vpp_power(u32 control
)
183 switch (control
& CB_SC_VPP_MASK
) {
184 case CB_SC_VPP_12V
: return 120;
185 case CB_SC_VPP_5V
: return 50;
186 case CB_SC_VPP_3V
: return 33;
191 static int yenta_get_socket(struct pcmcia_socket
*sock
, socket_state_t
*state
)
193 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
197 control
= cb_readl(socket
, CB_SOCKET_CONTROL
);
199 state
->Vcc
= yenta_Vcc_power(control
);
200 state
->Vpp
= yenta_Vpp_power(control
);
201 state
->io_irq
= socket
->io_irq
;
203 if (cb_readl(socket
, CB_SOCKET_STATE
) & CB_CBCARD
) {
204 u16 bridge
= config_readw(socket
, CB_BRIDGE_CONTROL
);
205 if (bridge
& CB_BRIDGE_CRST
)
206 state
->flags
|= SS_RESET
;
210 /* 16-bit card state.. */
211 reg
= exca_readb(socket
, I365_POWER
);
212 state
->flags
= (reg
& I365_PWR_AUTO
) ? SS_PWR_AUTO
: 0;
213 state
->flags
|= (reg
& I365_PWR_OUT
) ? SS_OUTPUT_ENA
: 0;
215 reg
= exca_readb(socket
, I365_INTCTL
);
216 state
->flags
|= (reg
& I365_PC_RESET
) ? 0 : SS_RESET
;
217 state
->flags
|= (reg
& I365_PC_IOCARD
) ? SS_IOCARD
: 0;
219 reg
= exca_readb(socket
, I365_CSCINT
);
220 state
->csc_mask
= (reg
& I365_CSC_DETECT
) ? SS_DETECT
: 0;
221 if (state
->flags
& SS_IOCARD
) {
222 state
->csc_mask
|= (reg
& I365_CSC_STSCHG
) ? SS_STSCHG
: 0;
224 state
->csc_mask
|= (reg
& I365_CSC_BVD1
) ? SS_BATDEAD
: 0;
225 state
->csc_mask
|= (reg
& I365_CSC_BVD2
) ? SS_BATWARN
: 0;
226 state
->csc_mask
|= (reg
& I365_CSC_READY
) ? SS_READY
: 0;
232 static void yenta_set_power(struct yenta_socket
*socket
, socket_state_t
*state
)
234 u32 reg
= 0; /* CB_SC_STPCLK? */
235 switch (state
->Vcc
) {
236 case 33: reg
= CB_SC_VCC_3V
; break;
237 case 50: reg
= CB_SC_VCC_5V
; break;
238 default: reg
= 0; break;
240 switch (state
->Vpp
) {
241 case 33: reg
|= CB_SC_VPP_3V
; break;
242 case 50: reg
|= CB_SC_VPP_5V
; break;
243 case 120: reg
|= CB_SC_VPP_12V
; break;
245 if (reg
!= cb_readl(socket
, CB_SOCKET_CONTROL
))
246 cb_writel(socket
, CB_SOCKET_CONTROL
, reg
);
249 static int yenta_set_socket(struct pcmcia_socket
*sock
, socket_state_t
*state
)
251 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
254 yenta_set_power(socket
, state
);
255 socket
->io_irq
= state
->io_irq
;
256 bridge
= config_readw(socket
, CB_BRIDGE_CONTROL
) & ~(CB_BRIDGE_CRST
| CB_BRIDGE_INTR
);
257 if (cb_readl(socket
, CB_SOCKET_STATE
) & CB_CBCARD
) {
259 bridge
|= (state
->flags
& SS_RESET
) ? CB_BRIDGE_CRST
: 0;
261 /* ISA interrupt control? */
262 intr
= exca_readb(socket
, I365_INTCTL
);
263 intr
= (intr
& ~0xf);
264 if (!socket
->cb_irq
) {
265 intr
|= state
->io_irq
;
266 bridge
|= CB_BRIDGE_INTR
;
268 exca_writeb(socket
, I365_INTCTL
, intr
);
272 reg
= exca_readb(socket
, I365_INTCTL
) & (I365_RING_ENA
| I365_INTR_ENA
);
273 reg
|= (state
->flags
& SS_RESET
) ? 0 : I365_PC_RESET
;
274 reg
|= (state
->flags
& SS_IOCARD
) ? I365_PC_IOCARD
: 0;
275 if (state
->io_irq
!= socket
->cb_irq
) {
276 reg
|= state
->io_irq
;
277 bridge
|= CB_BRIDGE_INTR
;
279 exca_writeb(socket
, I365_INTCTL
, reg
);
281 reg
= exca_readb(socket
, I365_POWER
) & (I365_VCC_MASK
|I365_VPP1_MASK
);
282 reg
|= I365_PWR_NORESET
;
283 if (state
->flags
& SS_PWR_AUTO
) reg
|= I365_PWR_AUTO
;
284 if (state
->flags
& SS_OUTPUT_ENA
) reg
|= I365_PWR_OUT
;
285 if (exca_readb(socket
, I365_POWER
) != reg
)
286 exca_writeb(socket
, I365_POWER
, reg
);
288 /* CSC interrupt: no ISA irq for CSC */
289 reg
= I365_CSC_DETECT
;
290 if (state
->flags
& SS_IOCARD
) {
291 if (state
->csc_mask
& SS_STSCHG
) reg
|= I365_CSC_STSCHG
;
293 if (state
->csc_mask
& SS_BATDEAD
) reg
|= I365_CSC_BVD1
;
294 if (state
->csc_mask
& SS_BATWARN
) reg
|= I365_CSC_BVD2
;
295 if (state
->csc_mask
& SS_READY
) reg
|= I365_CSC_READY
;
297 exca_writeb(socket
, I365_CSCINT
, reg
);
298 exca_readb(socket
, I365_CSC
);
300 sock
->zoom_video(sock
, state
->flags
& SS_ZVCARD
);
302 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge
);
303 /* Socket event mask: get card insert/remove events.. */
304 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
305 cb_writel(socket
, CB_SOCKET_MASK
, CB_CDMASK
);
309 static int yenta_set_io_map(struct pcmcia_socket
*sock
, struct pccard_io_map
*io
)
311 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
313 unsigned char ioctl
, addr
, enable
;
320 enable
= I365_ENA_IO(map
);
321 addr
= exca_readb(socket
, I365_ADDRWIN
);
323 /* Disable the window before changing it.. */
326 exca_writeb(socket
, I365_ADDRWIN
, addr
);
329 exca_writew(socket
, I365_IO(map
)+I365_W_START
, io
->start
);
330 exca_writew(socket
, I365_IO(map
)+I365_W_STOP
, io
->stop
);
332 ioctl
= exca_readb(socket
, I365_IOCTL
) & ~I365_IOCTL_MASK(map
);
333 if (io
->flags
& MAP_0WS
) ioctl
|= I365_IOCTL_0WS(map
);
334 if (io
->flags
& MAP_16BIT
) ioctl
|= I365_IOCTL_16BIT(map
);
335 if (io
->flags
& MAP_AUTOSZ
) ioctl
|= I365_IOCTL_IOCS16(map
);
336 exca_writeb(socket
, I365_IOCTL
, ioctl
);
338 if (io
->flags
& MAP_ACTIVE
)
339 exca_writeb(socket
, I365_ADDRWIN
, addr
| enable
);
343 static int yenta_set_mem_map(struct pcmcia_socket
*sock
, struct pccard_mem_map
*mem
)
345 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
346 struct pci_bus_region region
;
348 unsigned char addr
, enable
;
349 unsigned int start
, stop
, card_start
;
352 pcibios_resource_to_bus(socket
->dev
, ®ion
, mem
->res
);
355 start
= region
.start
;
357 card_start
= mem
->card_start
;
359 if (map
> 4 || start
> stop
|| ((start
^ stop
) >> 24) ||
360 (card_start
>> 26) || mem
->speed
> 1000)
363 enable
= I365_ENA_MEM(map
);
364 addr
= exca_readb(socket
, I365_ADDRWIN
);
367 exca_writeb(socket
, I365_ADDRWIN
, addr
);
370 exca_writeb(socket
, CB_MEM_PAGE(map
), start
>> 24);
372 word
= (start
>> 12) & 0x0fff;
373 if (mem
->flags
& MAP_16BIT
)
374 word
|= I365_MEM_16BIT
;
375 if (mem
->flags
& MAP_0WS
)
376 word
|= I365_MEM_0WS
;
377 exca_writew(socket
, I365_MEM(map
) + I365_W_START
, word
);
379 word
= (stop
>> 12) & 0x0fff;
380 switch (to_cycles(mem
->speed
)) {
382 case 1: word
|= I365_MEM_WS0
; break;
383 case 2: word
|= I365_MEM_WS1
; break;
384 default: word
|= I365_MEM_WS1
| I365_MEM_WS0
; break;
386 exca_writew(socket
, I365_MEM(map
) + I365_W_STOP
, word
);
388 word
= ((card_start
- start
) >> 12) & 0x3fff;
389 if (mem
->flags
& MAP_WRPROT
)
390 word
|= I365_MEM_WRPROT
;
391 if (mem
->flags
& MAP_ATTRIB
)
392 word
|= I365_MEM_REG
;
393 exca_writew(socket
, I365_MEM(map
) + I365_W_OFF
, word
);
395 if (mem
->flags
& MAP_ACTIVE
)
396 exca_writeb(socket
, I365_ADDRWIN
, addr
| enable
);
401 static unsigned int yenta_events(struct yenta_socket
*socket
)
407 /* Clear interrupt status for the event */
408 cb_event
= cb_readl(socket
, CB_SOCKET_EVENT
);
409 cb_writel(socket
, CB_SOCKET_EVENT
, cb_event
);
411 csc
= exca_readb(socket
, I365_CSC
);
413 events
= (cb_event
& (CB_CD1EVENT
| CB_CD2EVENT
)) ? SS_DETECT
: 0 ;
414 events
|= (csc
& I365_CSC_DETECT
) ? SS_DETECT
: 0;
415 if (exca_readb(socket
, I365_INTCTL
) & I365_PC_IOCARD
) {
416 events
|= (csc
& I365_CSC_STSCHG
) ? SS_STSCHG
: 0;
418 events
|= (csc
& I365_CSC_BVD1
) ? SS_BATDEAD
: 0;
419 events
|= (csc
& I365_CSC_BVD2
) ? SS_BATWARN
: 0;
420 events
|= (csc
& I365_CSC_READY
) ? SS_READY
: 0;
426 static irqreturn_t
yenta_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
429 struct yenta_socket
*socket
= (struct yenta_socket
*) dev_id
;
431 events
= yenta_events(socket
);
433 pcmcia_parse_events(&socket
->socket
, events
);
439 static void yenta_interrupt_wrapper(unsigned long data
)
441 struct yenta_socket
*socket
= (struct yenta_socket
*) data
;
443 yenta_interrupt(0, (void *)socket
, NULL
);
444 socket
->poll_timer
.expires
= jiffies
+ HZ
;
445 add_timer(&socket
->poll_timer
);
448 static void yenta_clear_maps(struct yenta_socket
*socket
)
451 struct resource res
= { .start
= 0, .end
= 0x0fff };
452 pccard_io_map io
= { 0, 0, 0, 0, 1 };
453 pccard_mem_map mem
= { .res
= &res
, };
455 yenta_set_socket(&socket
->socket
, &dead_socket
);
456 for (i
= 0; i
< 2; i
++) {
458 yenta_set_io_map(&socket
->socket
, &io
);
460 for (i
= 0; i
< 5; i
++) {
462 yenta_set_mem_map(&socket
->socket
, &mem
);
466 /* Called at resume and initialization events */
467 static int yenta_sock_init(struct pcmcia_socket
*sock
)
469 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
473 bridge
= config_readw(socket
, CB_BRIDGE_CONTROL
) & ~CB_BRIDGE_INTR
;
475 bridge
|= CB_BRIDGE_INTR
;
476 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge
);
478 exca_writeb(socket
, I365_GBLCTL
, 0x00);
479 exca_writeb(socket
, I365_GENCTL
, 0x00);
481 /* Redo card voltage interrogation */
482 state
= cb_readl(socket
, CB_SOCKET_STATE
);
483 if (!(state
& (CB_CDETECT1
| CB_CDETECT2
| CB_5VCARD
|
484 CB_3VCARD
| CB_XVCARD
| CB_YVCARD
)))
485 cb_writel(socket
, CB_SOCKET_FORCE
, CB_CVSTEST
);
487 yenta_clear_maps(socket
);
489 if (socket
->type
&& socket
->type
->sock_init
)
490 socket
->type
->sock_init(socket
);
492 /* Re-enable CSC interrupts */
493 cb_writel(socket
, CB_SOCKET_MASK
, CB_CDMASK
);
498 static int yenta_sock_suspend(struct pcmcia_socket
*sock
)
500 struct yenta_socket
*socket
= container_of(sock
, struct yenta_socket
, socket
);
502 yenta_set_socket(sock
, &dead_socket
);
504 /* Disable CSC interrupts */
505 cb_writel(socket
, CB_SOCKET_MASK
, 0x0);
511 * Use an adaptive allocation for the memory resource,
512 * sometimes the memory behind pci bridges is limited:
513 * 1/8 of the size of the io window of the parent.
514 * max 4 MB, min 16 kB.
516 #define BRIDGE_MEM_MAX 4*1024*1024
517 #define BRIDGE_MEM_MIN 16*1024
519 #define BRIDGE_IO_MAX 256
520 #define BRIDGE_IO_MIN 32
522 #ifndef PCIBIOS_MIN_CARDBUS_IO
523 #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO
526 static void yenta_allocate_res(struct yenta_socket
*socket
, int nr
, unsigned type
)
529 struct resource
*root
, *res
;
531 u32 align
, size
, min
;
535 /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */
537 if (type
& IORESOURCE_IO
)
540 offset
= 0x1c + 8*nr
;
541 bus
= socket
->dev
->subordinate
;
542 res
= socket
->dev
->resource
+ PCI_BRIDGE_RESOURCES
+ nr
;
543 res
->name
= bus
->name
;
547 root
= pci_find_parent_resource(socket
->dev
, res
);
552 start
= config_readl(socket
, offset
) & mask
;
553 end
= config_readl(socket
, offset
+4) | ~mask
;
554 if (start
&& end
> start
) {
557 if (request_resource(root
, res
) == 0)
559 printk(KERN_INFO
"yenta %s: Preassigned resource %d busy, reconfiguring...\n",
560 pci_name(socket
->dev
), nr
);
561 res
->start
= res
->end
= 0;
564 if (type
& IORESOURCE_IO
) {
566 size
= BRIDGE_IO_MAX
;
568 start
= PCIBIOS_MIN_CARDBUS_IO
;
571 unsigned long avail
= root
->end
- root
->start
;
573 size
= BRIDGE_MEM_MAX
;
574 if (size
> avail
/8) {
576 /* round size down to next power of 2 */
578 while ((size
/= 2) != 0)
582 if (size
< BRIDGE_MEM_MIN
)
583 size
= BRIDGE_MEM_MIN
;
584 min
= BRIDGE_MEM_MIN
;
586 start
= PCIBIOS_MIN_MEM
;
591 if (allocate_resource(root
, res
, size
, start
, end
, align
, NULL
, NULL
)==0) {
592 config_writel(socket
, offset
, res
->start
);
593 config_writel(socket
, offset
+4, res
->end
);
598 } while (size
>= min
);
599 printk(KERN_INFO
"yenta %s: no resource of type %x available, trying to continue...\n",
600 pci_name(socket
->dev
), type
);
601 res
->start
= res
->end
= 0;
605 * Allocate the bridge mappings for the device..
607 static void yenta_allocate_resources(struct yenta_socket
*socket
)
609 yenta_allocate_res(socket
, 0, IORESOURCE_MEM
|IORESOURCE_PREFETCH
);
610 yenta_allocate_res(socket
, 1, IORESOURCE_MEM
);
611 yenta_allocate_res(socket
, 2, IORESOURCE_IO
);
612 yenta_allocate_res(socket
, 3, IORESOURCE_IO
); /* PCI isn't clever enough to use this one yet */
617 * Free the bridge mappings for the device..
619 static void yenta_free_resources(struct yenta_socket
*socket
)
623 struct resource
*res
;
624 res
= socket
->dev
->resource
+ PCI_BRIDGE_RESOURCES
+ i
;
625 if (res
->start
!= 0 && res
->end
!= 0)
626 release_resource(res
);
627 res
->start
= res
->end
= 0;
633 * Close it down - release our resources and go home..
635 static void yenta_close(struct pci_dev
*dev
)
637 struct yenta_socket
*sock
= pci_get_drvdata(dev
);
639 /* we don't want a dying socket registered */
640 pcmcia_unregister_socket(&sock
->socket
);
642 /* Disable all events so we don't die in an IRQ storm */
643 cb_writel(sock
, CB_SOCKET_MASK
, 0x0);
644 exca_writeb(sock
, I365_CSCINT
, 0);
647 free_irq(sock
->cb_irq
, sock
);
649 del_timer_sync(&sock
->poll_timer
);
653 yenta_free_resources(sock
);
655 pci_release_regions(dev
);
656 pci_set_drvdata(dev
, NULL
);
660 static struct pccard_operations yenta_socket_operations
= {
661 .init
= yenta_sock_init
,
662 .suspend
= yenta_sock_suspend
,
663 .get_status
= yenta_get_status
,
664 .get_socket
= yenta_get_socket
,
665 .set_socket
= yenta_set_socket
,
666 .set_io_map
= yenta_set_io_map
,
667 .set_mem_map
= yenta_set_mem_map
,
677 CARDBUS_TYPE_DEFAULT
= -1,
683 CARDBUS_TYPE_TOPIC97
,
684 CARDBUS_TYPE_O2MICRO
,
688 * Different cardbus controllers have slightly different
689 * initialization sequences etc details. List them here..
691 struct cardbus_type cardbus_type
[] = {
692 [CARDBUS_TYPE_TI
] = {
693 .override
= ti_override
,
694 .save_state
= ti_save_state
,
695 .restore_state
= ti_restore_state
,
696 .sock_init
= ti_init
,
698 [CARDBUS_TYPE_TI113X
] = {
699 .override
= ti113x_override
,
700 .save_state
= ti_save_state
,
701 .restore_state
= ti_restore_state
,
702 .sock_init
= ti_init
,
704 [CARDBUS_TYPE_TI12XX
] = {
705 .override
= ti12xx_override
,
706 .save_state
= ti_save_state
,
707 .restore_state
= ti_restore_state
,
708 .sock_init
= ti_init
,
710 [CARDBUS_TYPE_TI1250
] = {
711 .override
= ti1250_override
,
712 .save_state
= ti_save_state
,
713 .restore_state
= ti_restore_state
,
714 .sock_init
= ti_init
,
716 [CARDBUS_TYPE_RICOH
] = {
717 .override
= ricoh_override
,
718 .save_state
= ricoh_save_state
,
719 .restore_state
= ricoh_restore_state
,
721 [CARDBUS_TYPE_TOPIC97
] = {
722 .override
= topic97_override
,
724 [CARDBUS_TYPE_O2MICRO
] = {
725 .override
= o2micro_override
,
726 .restore_state
= o2micro_restore_state
,
732 * Only probe "regular" interrupts, don't
733 * touch dangerous spots like the mouse irq,
734 * because there are mice that apparently
735 * get really confused if they get fondled
738 * Default to 11, 10, 9, 7, 6, 5, 4, 3.
740 static u32 isa_interrupts
= 0x0ef8;
742 static unsigned int yenta_probe_irq(struct yenta_socket
*socket
, u32 isa_irq_mask
)
749 /* Set up ISA irq routing to probe the ISA irqs.. */
750 bridge_ctrl
= config_readw(socket
, CB_BRIDGE_CONTROL
);
751 if (!(bridge_ctrl
& CB_BRIDGE_INTR
)) {
752 bridge_ctrl
|= CB_BRIDGE_INTR
;
753 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge_ctrl
);
757 * Probe for usable interrupts using the force
758 * register to generate bogus card status events.
760 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
761 cb_writel(socket
, CB_SOCKET_MASK
, CB_CSTSMASK
);
762 exca_writeb(socket
, I365_CSCINT
, 0);
763 val
= probe_irq_on() & isa_irq_mask
;
764 for (i
= 1; i
< 16; i
++) {
765 if (!((val
>> i
) & 1))
767 exca_writeb(socket
, I365_CSCINT
, I365_CSC_STSCHG
| (i
<< 4));
768 cb_writel(socket
, CB_SOCKET_FORCE
, CB_FCARDSTS
);
770 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
772 cb_writel(socket
, CB_SOCKET_MASK
, 0);
773 exca_writeb(socket
, I365_CSCINT
, 0);
775 mask
= probe_irq_mask(val
) & 0xffff;
777 bridge_ctrl
&= ~CB_BRIDGE_INTR
;
778 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge_ctrl
);
784 /* interrupt handler, only used during probing */
785 static irqreturn_t
yenta_probe_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
787 struct yenta_socket
*socket
= (struct yenta_socket
*) dev_id
;
791 /* Clear interrupt status for the event */
792 cb_event
= cb_readl(socket
, CB_SOCKET_EVENT
);
793 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
794 csc
= exca_readb(socket
, I365_CSC
);
796 if (cb_event
|| csc
) {
797 socket
->probe_status
= 1;
804 /* probes the PCI interrupt, use only on override functions */
805 static int yenta_probe_cb_irq(struct yenta_socket
*socket
)
812 socket
->probe_status
= 0;
814 /* disable ISA interrupts */
815 bridge_ctrl
= config_readw(socket
, CB_BRIDGE_CONTROL
);
816 bridge_ctrl
&= ~CB_BRIDGE_INTR
;
817 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge_ctrl
);
819 if (request_irq(socket
->cb_irq
, yenta_probe_handler
, SA_SHIRQ
, "yenta", socket
)) {
820 printk(KERN_WARNING
"Yenta: request_irq() in yenta_probe_cb_irq() failed!\n");
824 /* generate interrupt, wait */
825 exca_writeb(socket
, I365_CSCINT
, I365_CSC_STSCHG
);
826 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
827 cb_writel(socket
, CB_SOCKET_MASK
, CB_CSTSMASK
);
828 cb_writel(socket
, CB_SOCKET_FORCE
, CB_FCARDSTS
);
830 set_current_state(TASK_UNINTERRUPTIBLE
);
831 schedule_timeout(HZ
/10);
833 /* disable interrupts */
834 cb_writel(socket
, CB_SOCKET_MASK
, 0);
835 exca_writeb(socket
, I365_CSCINT
, 0);
836 cb_writel(socket
, CB_SOCKET_EVENT
, -1);
837 exca_readb(socket
, I365_CSC
);
839 free_irq(socket
->cb_irq
, socket
);
841 return (int) socket
->probe_status
;
847 * Set static data that doesn't need re-initializing..
849 static void yenta_get_socket_capabilities(struct yenta_socket
*socket
, u32 isa_irq_mask
)
851 socket
->socket
.features
|= SS_CAP_PAGE_REGS
| SS_CAP_PCCARD
| SS_CAP_CARDBUS
;
852 socket
->socket
.map_size
= 0x1000;
853 socket
->socket
.pci_irq
= socket
->cb_irq
;
854 socket
->socket
.irq_mask
= yenta_probe_irq(socket
, isa_irq_mask
);
855 socket
->socket
.cb_dev
= socket
->dev
;
857 printk(KERN_INFO
"Yenta: ISA IRQ mask 0x%04x, PCI irq %d\n",
858 socket
->socket
.irq_mask
, socket
->cb_irq
);
862 * Initialize the standard cardbus registers
864 static void yenta_config_init(struct yenta_socket
*socket
)
867 struct pci_dev
*dev
= socket
->dev
;
869 pci_set_power_state(socket
->dev
, 0);
871 config_writel(socket
, CB_LEGACY_MODE_BASE
, 0);
872 config_writel(socket
, PCI_BASE_ADDRESS_0
, dev
->resource
[0].start
);
873 config_writew(socket
, PCI_COMMAND
,
879 /* MAGIC NUMBERS! Fixme */
880 config_writeb(socket
, PCI_CACHE_LINE_SIZE
, L1_CACHE_BYTES
/ 4);
881 config_writeb(socket
, PCI_LATENCY_TIMER
, 168);
882 config_writel(socket
, PCI_PRIMARY_BUS
,
883 (176 << 24) | /* sec. latency timer */
884 (dev
->subordinate
->subordinate
<< 16) | /* subordinate bus */
885 (dev
->subordinate
->secondary
<< 8) | /* secondary bus */
886 dev
->subordinate
->primary
); /* primary bus */
889 * Set up the bridging state:
890 * - enable write posting.
891 * - memory window 0 prefetchable, window 1 non-prefetchable
892 * - PCI interrupts enabled if a PCI interrupt exists..
894 bridge
= config_readw(socket
, CB_BRIDGE_CONTROL
);
895 bridge
&= ~(CB_BRIDGE_CRST
| CB_BRIDGE_PREFETCH1
| CB_BRIDGE_INTR
| CB_BRIDGE_ISAEN
| CB_BRIDGE_VGAEN
);
896 bridge
|= CB_BRIDGE_PREFETCH0
| CB_BRIDGE_POSTEN
| CB_BRIDGE_INTR
;
897 config_writew(socket
, CB_BRIDGE_CONTROL
, bridge
);
901 * Initialize a cardbus controller. Make sure we have a usable
902 * interrupt, and that we can map the cardbus area. Fill in the
903 * socket information structure..
905 static int __devinit
yenta_probe (struct pci_dev
*dev
, const struct pci_device_id
*id
)
907 struct yenta_socket
*socket
;
910 socket
= kmalloc(sizeof(struct yenta_socket
), GFP_KERNEL
);
913 memset(socket
, 0, sizeof(*socket
));
915 /* prepare pcmcia_socket */
916 socket
->socket
.ops
= ¥ta_socket_operations
;
917 socket
->socket
.dev
.dev
= &dev
->dev
;
918 socket
->socket
.driver_data
= socket
;
919 socket
->socket
.owner
= THIS_MODULE
;
921 /* prepare struct yenta_socket */
923 pci_set_drvdata(dev
, socket
);
926 * Do some basic sanity checking..
928 if (pci_enable_device(dev
)) {
933 ret
= pci_request_regions(dev
, "yenta_socket");
937 if (!pci_resource_start(dev
, 0)) {
938 printk(KERN_ERR
"No cardbus resource!\n");
944 * Ok, start setup.. Map the cardbus registers,
945 * and request the IRQ.
947 socket
->base
= ioremap(pci_resource_start(dev
, 0), 0x1000);
954 * report the subsystem vendor and device for help debugging
957 printk(KERN_INFO
"Yenta: CardBus bridge found at %s [%04x:%04x]\n",
958 dev
->slot_name
, dev
->subsystem_vendor
, dev
->subsystem_device
);
960 yenta_config_init(socket
);
962 /* Disable all events */
963 cb_writel(socket
, CB_SOCKET_MASK
, 0x0);
965 /* Set up the bridge regions.. */
966 yenta_allocate_resources(socket
);
968 socket
->cb_irq
= dev
->irq
;
970 /* Do we have special options for the device? */
971 if (id
->driver_data
!= CARDBUS_TYPE_DEFAULT
&&
972 id
->driver_data
< ARRAY_SIZE(cardbus_type
)) {
973 socket
->type
= &cardbus_type
[id
->driver_data
];
975 ret
= socket
->type
->override(socket
);
980 /* We must finish initialization here */
982 if (!socket
->cb_irq
|| request_irq(socket
->cb_irq
, yenta_interrupt
, SA_SHIRQ
, "yenta", socket
)) {
983 /* No IRQ or request_irq failed. Poll */
984 socket
->cb_irq
= 0; /* But zero is a valid IRQ number. */
985 init_timer(&socket
->poll_timer
);
986 socket
->poll_timer
.function
= yenta_interrupt_wrapper
;
987 socket
->poll_timer
.data
= (unsigned long)socket
;
988 socket
->poll_timer
.expires
= jiffies
+ HZ
;
989 add_timer(&socket
->poll_timer
);
992 /* Figure out what the dang thing can do for the PCMCIA layer... */
993 yenta_get_socket_capabilities(socket
, isa_interrupts
);
994 printk(KERN_INFO
"Socket status: %08x\n", cb_readl(socket
, CB_SOCKET_STATE
));
996 /* Register it with the pcmcia layer.. */
997 ret
= pcmcia_register_socket(&socket
->socket
);
1002 iounmap(socket
->base
);
1004 pci_release_regions(dev
);
1006 pci_disable_device(dev
);
1014 static int yenta_dev_suspend (struct pci_dev
*dev
, u32 state
)
1016 struct yenta_socket
*socket
= pci_get_drvdata(dev
);
1019 ret
= pcmcia_socket_dev_suspend(&dev
->dev
, state
);
1022 if (socket
->type
&& socket
->type
->save_state
)
1023 socket
->type
->save_state(socket
);
1025 /* FIXME: pci_save_state needs to have a better interface */
1026 pci_save_state(dev
, socket
->saved_state
);
1027 pci_read_config_dword(dev
, 16*4, &socket
->saved_state
[16]);
1028 pci_read_config_dword(dev
, 17*4, &socket
->saved_state
[17]);
1029 pci_set_power_state(dev
, 3);
1036 static int yenta_dev_resume (struct pci_dev
*dev
)
1038 struct yenta_socket
*socket
= pci_get_drvdata(dev
);
1041 pci_set_power_state(dev
, 0);
1042 /* FIXME: pci_restore_state needs to have a better interface */
1043 pci_restore_state(dev
, socket
->saved_state
);
1044 pci_write_config_dword(dev
, 16*4, socket
->saved_state
[16]);
1045 pci_write_config_dword(dev
, 17*4, socket
->saved_state
[17]);
1047 if (socket
->type
&& socket
->type
->restore_state
)
1048 socket
->type
->restore_state(socket
);
1051 return pcmcia_socket_dev_resume(&dev
->dev
);
1055 #define CB_ID(vend,dev,type) \
1059 .subvendor = PCI_ANY_ID, \
1060 .subdevice = PCI_ANY_ID, \
1061 .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \
1063 .driver_data = CARDBUS_TYPE_##type, \
1066 static struct pci_device_id yenta_table
[] = {
1067 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1031
, TI
),
1070 * TBD: Check if these TI variants can use more
1071 * advanced overrides instead. (I can't get the
1072 * data sheets for these devices. --rmk)
1074 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1210
, TI
),
1076 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1130
, TI113X
),
1077 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1131
, TI113X
),
1079 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1211
, TI12XX
),
1080 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1220
, TI12XX
),
1081 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1221
, TI12XX
),
1082 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1225
, TI12XX
),
1083 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1251A
, TI12XX
),
1084 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1251B
, TI12XX
),
1085 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1420
, TI12XX
),
1086 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1450
, TI12XX
),
1087 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1451A
, TI12XX
),
1088 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1510
, TI12XX
),
1089 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1520
, TI12XX
),
1090 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1620
, TI12XX
),
1091 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4410
, TI12XX
),
1092 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4450
, TI12XX
),
1093 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4451
, TI12XX
),
1094 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_4520
, TI12XX
),
1096 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1250
, TI1250
),
1097 CB_ID(PCI_VENDOR_ID_TI
, PCI_DEVICE_ID_TI_1410
, TI1250
),
1099 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1211
, TI12XX
),
1100 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1225
, TI12XX
),
1101 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1410
, TI1250
),
1102 CB_ID(PCI_VENDOR_ID_ENE
, PCI_DEVICE_ID_ENE_1420
, TI12XX
),
1104 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C465
, RICOH
),
1105 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C466
, RICOH
),
1106 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C475
, RICOH
),
1107 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C476
, RICOH
),
1108 CB_ID(PCI_VENDOR_ID_RICOH
, PCI_DEVICE_ID_RICOH_RL5C478
, RICOH
),
1110 CB_ID(PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_TOSHIBA_TOPIC97
, TOPIC97
),
1111 CB_ID(PCI_VENDOR_ID_TOSHIBA
, PCI_DEVICE_ID_TOSHIBA_TOPIC100
, TOPIC97
),
1113 CB_ID(PCI_VENDOR_ID_O2
, PCI_ANY_ID
, O2MICRO
),
1115 /* match any cardbus bridge */
1116 CB_ID(PCI_ANY_ID
, PCI_ANY_ID
, DEFAULT
),
1117 { /* all zeroes */ }
1119 MODULE_DEVICE_TABLE(pci
, yenta_table
);
1122 static struct pci_driver yenta_cardbus_driver
= {
1123 .name
= "yenta_cardbus",
1124 .id_table
= yenta_table
,
1125 .probe
= yenta_probe
,
1126 .remove
= __devexit_p(yenta_close
),
1127 .suspend
= yenta_dev_suspend
,
1128 .resume
= yenta_dev_resume
,
1132 static int __init
yenta_socket_init(void)
1134 return pci_register_driver (¥ta_cardbus_driver
);
1138 static void __exit
yenta_socket_exit (void)
1140 pci_unregister_driver (¥ta_cardbus_driver
);
1144 module_init(yenta_socket_init
);
1145 module_exit(yenta_socket_exit
);
1147 MODULE_LICENSE("GPL");