2 * Driver for the Cirrus PD6729 PCI-PCMCIA bridge.
4 * Based on the i82092.c driver.
6 * This software may be used and distributed according to the terms of
7 * the GNU General Public License, incorporated herein by reference.
10 #include <linux/kernel.h>
11 #include <linux/config.h>
12 #include <linux/module.h>
13 #include <linux/pci.h>
14 #include <linux/init.h>
15 #include <linux/workqueue.h>
16 #include <linux/interrupt.h>
17 #include <linux/device.h>
19 #include <pcmcia/cs_types.h>
20 #include <pcmcia/ss.h>
21 #include <pcmcia/cs.h>
23 #include <asm/system.h>
30 MODULE_LICENSE("GPL");
34 /* simple helper functions */
35 /* External clock time, in nanoseconds. 120 ns = 8.33 MHz */
36 #define to_cycles(ns) ((ns)/120)
38 static spinlock_t port_lock = SPIN_LOCK_UNLOCKED;
40 /* basic value read/write functions */
42 static unsigned char indirect_read(struct pd6729_socket *socket, unsigned short reg)
48 spin_lock_irqsave(&port_lock, flags);
49 reg += socket->number * 0x40;
50 port = socket->io_base;
53 spin_unlock_irqrestore(&port_lock, flags);
58 static unsigned short indirect_read16(struct pd6729_socket *socket, unsigned short reg)
64 spin_lock_irqsave(&port_lock, flags);
65 reg = reg + socket->number * 0x40;
66 port = socket->io_base;
71 tmp = tmp | (inb(port + 1) << 8);
72 spin_unlock_irqrestore(&port_lock, flags);
77 static void indirect_write(struct pd6729_socket *socket, unsigned short reg, unsigned char value)
82 spin_lock_irqsave(&port_lock, flags);
83 reg = reg + socket->number * 0x40;
84 port = socket->io_base;
86 outb(value, port + 1);
87 spin_unlock_irqrestore(&port_lock, flags);
90 static void indirect_setbit(struct pd6729_socket *socket, unsigned short reg, unsigned char mask)
96 spin_lock_irqsave(&port_lock, flags);
97 reg = reg + socket->number * 0x40;
98 port = socket->io_base;
104 spin_unlock_irqrestore(&port_lock, flags);
107 static void indirect_resetbit(struct pd6729_socket *socket, unsigned short reg, unsigned char mask)
113 spin_lock_irqsave(&port_lock, flags);
114 reg = reg + socket->number * 0x40;
115 port = socket->io_base;
121 spin_unlock_irqrestore(&port_lock, flags);
124 static void indirect_write16(struct pd6729_socket *socket, unsigned short reg, unsigned short value)
130 spin_lock_irqsave(&port_lock, flags);
131 reg = reg + socket->number * 0x40;
132 port = socket->io_base;
143 spin_unlock_irqrestore(&port_lock, flags);
146 /* Interrupt handler functionality */
148 static irqreturn_t pd6729_interrupt(int irq, void *dev, struct pt_regs *regs)
150 struct pd6729_socket *socket = (struct pd6729_socket *)dev;
154 unsigned int events, active = 0;
158 if (loopcount > 20) {
159 printk(KERN_ERR "pd6729: infinite eventloop in interrupt\n");
165 for (i = 0; i < MAX_SOCKETS; i++) {
168 /* card status change register */
169 csc = indirect_read(&socket[i], I365_CSC);
170 if (csc == 0) /* no events on this socket */
176 if (csc & I365_CSC_DETECT) {
178 dprintk("Card detected in socket %i!\n", i);
181 if (indirect_read(&socket[i], I365_INTCTL) & I365_PC_IOCARD) {
182 /* For IO/CARDS, bit 0 means "read the card" */
183 events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0;
185 /* Check for battery/ready events */
186 events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0;
187 events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0;
188 events |= (csc & I365_CSC_READY) ? SS_READY : 0;
192 pcmcia_parse_events(&socket[i].socket, events);
197 if (active == 0) /* no more events to handle */
200 return IRQ_RETVAL(handled);
203 /* socket functions */
205 static void set_bridge_state(struct pd6729_socket *socket)
207 indirect_write(socket, I365_GBLCTL, 0x00);
208 indirect_write(socket, I365_GENCTL, 0x00);
210 indirect_setbit(socket, I365_INTCTL, 0x08);
213 static int pd6729_get_status(struct pcmcia_socket *sock, u_int *value)
215 struct pd6729_socket *socket = container_of(sock, struct pd6729_socket, socket);
218 struct pd6729_socket *t;
220 /* Interface Status Register */
221 status = indirect_read(socket, I365_STATUS);
224 if ((status & I365_CS_DETECT) == I365_CS_DETECT) {
228 /* IO cards have a different meaning of bits 0,1 */
229 /* Also notice the inverse-logic on the bits */
230 if (indirect_read(socket, I365_INTCTL) & I365_PC_IOCARD) {
232 if (!(status & I365_CS_STSCHG))
236 if (!(status & I365_CS_BVD1))
237 *value |= SS_BATDEAD;
238 if (!(status & I365_CS_BVD2))
239 *value |= SS_BATWARN;
242 if (status & I365_CS_WRPROT)
243 *value |= SS_WRPROT; /* card is write protected */
245 if (status & I365_CS_READY)
246 *value |= SS_READY; /* card is not busy */
248 if (status & I365_CS_POWERON)
249 *value |= SS_POWERON; /* power is applied to the card */
251 t = (socket->number) ? socket : socket + 1;
252 indirect_write(t, PD67_EXT_INDEX, PD67_EXTERN_DATA);
253 data = indirect_read16(t, PD67_EXT_DATA);
254 *value |= (data & PD67_EXD_VS1(socket->number)) ? 0 : SS_3VCARD;
260 static int pd6729_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
262 struct pd6729_socket *socket = container_of(sock, struct pd6729_socket, socket);
263 unsigned char reg, vcc, vpp;
271 /* First the power status of the socket */
272 /* PCTRL - Power Control Register */
273 reg = indirect_read(socket, I365_POWER);
275 if (reg & I365_PWR_AUTO)
276 state->flags |= SS_PWR_AUTO; /* Automatic Power Switch */
278 if (reg & I365_PWR_OUT)
279 state->flags |= SS_OUTPUT_ENA; /* Output signals are enabled */
281 vcc = reg & I365_VCC_MASK; vpp = reg & I365_VPP1_MASK;
283 if (reg & I365_VCC_5V) {
284 state->Vcc = (indirect_read(socket, PD67_MISC_CTL_1) &
285 PD67_MC1_VCC_3V) ? 33 : 50;
287 if (vpp == I365_VPP1_5V) {
288 if (state->Vcc == 50)
293 if (vpp == I365_VPP1_12V)
297 /* Now the IO card, RESET flags and IO interrupt */
298 /* IGENC, Interrupt and General Control */
299 reg = indirect_read(socket, I365_INTCTL);
301 if ((reg & I365_PC_RESET) == 0)
302 state->flags |= SS_RESET;
303 if (reg & I365_PC_IOCARD)
304 state->flags |= SS_IOCARD; /* This is an IO card */
306 /* Set the IRQ number */
307 state->io_irq = socket->socket.pci_irq;
309 /* Card status change */
310 /* CSCICR, Card Status Change Interrupt Configuration */
311 reg = indirect_read(socket, I365_CSCINT);
313 if (reg & I365_CSC_DETECT)
314 state->csc_mask |= SS_DETECT; /* Card detect is enabled */
316 if (state->flags & SS_IOCARD) {/* IO Cards behave different */
317 if (reg & I365_CSC_STSCHG)
318 state->csc_mask |= SS_STSCHG;
320 if (reg & I365_CSC_BVD1)
321 state->csc_mask |= SS_BATDEAD;
322 if (reg & I365_CSC_BVD2)
323 state->csc_mask |= SS_BATWARN;
324 if (reg & I365_CSC_READY)
325 state->csc_mask |= SS_READY;
331 static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
333 struct pd6729_socket *socket = container_of(sock, struct pd6729_socket, socket);
336 /* First, set the global controller options */
338 set_bridge_state(socket);
340 /* Values for the IGENC register */
343 /* The reset bit has "inverse" logic */
344 if (!(state->flags & SS_RESET))
345 reg = reg | I365_PC_RESET;
346 if (state->flags & SS_IOCARD)
347 reg = reg | I365_PC_IOCARD;
349 /* IGENC, Interrupt and General Control Register */
350 indirect_write(socket, I365_INTCTL, reg);
352 /* Power registers */
354 reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */
356 if (state->flags & SS_PWR_AUTO) {
357 dprintk("Auto power\n");
358 reg |= I365_PWR_AUTO; /* automatic power mngmnt */
360 if (state->flags & SS_OUTPUT_ENA) {
361 dprintk("Power Enabled\n");
362 reg |= I365_PWR_OUT; /* enable power */
365 switch (state->Vcc) {
369 dprintk("setting voltage to Vcc to 3.3V on socket %i\n",
372 indirect_setbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
375 dprintk("setting voltage to Vcc to 5V on socket %i\n",
378 indirect_resetbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
381 dprintk("pd6729: pd6729_set_socket called with invalid VCC power value: %i\n",
386 switch (state->Vpp) {
388 dprintk("not setting Vpp on socket %i\n", socket->number);
392 dprintk("setting Vpp to Vcc for socket %i\n", socket->number);
396 dprintk("setting Vpp to 12.0\n");
397 reg |= I365_VPP1_12V;
400 dprintk("pd6729: pd6729_set_socket called with invalid VPP power value: %i\n",
405 /* only write if changed */
406 if (reg != indirect_read(socket, I365_POWER))
407 indirect_write(socket, I365_POWER, reg);
409 /* Now, specifiy that all interrupts are to be done as PCI interrupts */
410 indirect_write(socket, PD67_EXT_INDEX, PD67_EXT_CTL_1);
411 indirect_write(socket, PD67_EXT_DATA, PD67_EC1_INV_MGMT_IRQ | PD67_EC1_INV_CARD_IRQ);
413 /* Enable specific interrupt events */
416 if (state->csc_mask & SS_DETECT) {
417 reg |= I365_CSC_DETECT;
419 if (state->flags & SS_IOCARD) {
420 if (state->csc_mask & SS_STSCHG)
421 reg |= I365_CSC_STSCHG;
423 if (state->csc_mask & SS_BATDEAD)
424 reg |= I365_CSC_BVD1;
425 if (state->csc_mask & SS_BATWARN)
426 reg |= I365_CSC_BVD2;
427 if (state->csc_mask & SS_READY)
428 reg |= I365_CSC_READY;
430 reg |= 0x30; /* management IRQ: PCI INTA# = "irq 3" */
431 indirect_write(socket, I365_CSCINT, reg);
433 reg = indirect_read(socket, I365_INTCTL);
434 reg |= 0x03; /* card IRQ: PCI INTA# = "irq 3" */
435 indirect_write(socket, I365_INTCTL, reg);
437 /* now clear the (probably bogus) pending stuff by doing a dummy read */
438 (void)indirect_read(socket, I365_CSC);
443 static int pd6729_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
445 struct pd6729_socket *socket = container_of(sock, struct pd6729_socket, socket);
446 unsigned char map, ioctl;
450 /* Check error conditions */
452 dprintk("pd6729_set_io_map with invalid map");
456 /* Turn off the window before changing anything */
457 if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_IO(map))
458 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
460 /* dprintk("set_io_map: Setting range to %x - %x\n", io->start, io->stop);*/
462 /* write the new values */
463 indirect_write16(socket, I365_IO(map)+I365_W_START, io->start);
464 indirect_write16(socket, I365_IO(map)+I365_W_STOP, io->stop);
466 ioctl = indirect_read(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
468 if (io->flags & MAP_0WS) ioctl |= I365_IOCTL_0WS(map);
469 if (io->flags & MAP_16BIT) ioctl |= I365_IOCTL_16BIT(map);
470 if (io->flags & MAP_AUTOSZ) ioctl |= I365_IOCTL_IOCS16(map);
472 indirect_write(socket, I365_IOCTL, ioctl);
474 /* Turn the window back on if needed */
475 if (io->flags & MAP_ACTIVE)
476 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
481 static int pd6729_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
483 struct pd6729_socket *socket = container_of(sock, struct pd6729_socket, socket);
484 unsigned short base, i;
489 printk("pd6729_set_mem_map: invalid map");
493 if ((mem->sys_start > mem->sys_stop) || (mem->speed > 1000)) {
494 printk("pd6729_set_mem_map: invalid address / speed");
495 /* printk("invalid mem map for socket %i : %lx to %lx with a start of %x\n",
496 sock, mem->sys_start, mem->sys_stop, mem->card_start); */
500 /* Turn off the window before changing anything */
501 if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_MEM(map))
502 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
504 /* write the start address */
505 base = I365_MEM(map);
506 i = (mem->sys_start >> 12) & 0x0fff;
507 if (mem->flags & MAP_16BIT)
509 if (mem->flags & MAP_0WS)
511 indirect_write16(socket, base + I365_W_START, i);
513 /* write the stop address */
515 i= (mem->sys_stop >> 12) & 0x0fff;
516 switch (to_cycles(mem->speed)) {
526 i |= I365_MEM_WS1 | I365_MEM_WS0;
530 indirect_write16(socket, base + I365_W_STOP, i);
532 /* Take care of high byte */
533 indirect_write(socket, PD67_EXT_INDEX, PD67_MEM_PAGE(map));
534 indirect_write(socket, PD67_EXT_DATA, mem->sys_start >> 24);
538 i = ((mem->card_start - mem->sys_start) >> 12) & 0x3fff;
539 if (mem->flags & MAP_WRPROT)
540 i |= I365_MEM_WRPROT;
541 if (mem->flags & MAP_ATTRIB) {
542 /* dprintk("requesting attribute memory for socket %i\n",
546 /* dprintk("requesting normal memory for socket %i\n",
549 indirect_write16(socket, base + I365_W_OFF, i);
551 /* Enable the window if necessary */
552 if (mem->flags & MAP_ACTIVE)
553 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
558 static int pd6729_suspend(struct pcmcia_socket *sock)
560 return pd6729_set_socket(sock, &dead_socket);
563 static int pd6729_init(struct pcmcia_socket *sock)
566 struct resource res = { .end = 0x0fff };
567 pccard_io_map io = { 0, 0, 0, 0, 1 };
568 pccard_mem_map mem = { .res = &res, .sys_stop = 0x0fff };
570 pd6729_set_socket(sock, &dead_socket);
571 for (i = 0; i < 2; i++) {
573 pd6729_set_io_map(sock, &io);
575 for (i = 0; i < 5; i++) {
577 pd6729_set_mem_map(sock, &mem);
584 /* the pccard structure and its functions */
585 static struct pccard_operations pd6729_operations = {
587 .suspend = pd6729_suspend,
588 .get_status = pd6729_get_status,
589 .get_socket = pd6729_get_socket,
590 .set_socket = pd6729_set_socket,
591 .set_io_map = pd6729_set_io_map,
592 .set_mem_map = pd6729_set_mem_map,
595 static int __devinit pd6729_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
599 struct pd6729_socket *socket;
601 socket = kmalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS, GFP_KERNEL);
605 memset(socket, 0, sizeof(struct pd6729_socket) * MAX_SOCKETS);
607 if ((ret = pci_enable_device(dev)))
608 goto err_out_free_mem;
610 printk(KERN_INFO "pd6729: Cirrus PD6729 PCI to PCMCIA Bridge at 0x%lx on irq %d\n",
611 pci_resource_start(dev, 0), dev->irq);
612 printk(KERN_INFO "pd6729: configured as a %d socket device.\n", MAX_SOCKETS);
613 /* Since we have no memory BARs some firmware we may not
614 have had PCI_COMMAND_MEM enabled, yet the device needs
616 pci_read_config_byte(dev, PCI_COMMAND, &configbyte);
617 if (!(configbyte & PCI_COMMAND_MEMORY)) {
618 printk(KERN_DEBUG "pd6729: Enabling PCI_COMMAND_MEMORY.\n");
619 configbyte |= PCI_COMMAND_MEMORY;
620 pci_write_config_byte(dev, PCI_COMMAND, configbyte);
623 ret = pci_request_regions(dev, "pd6729");
625 printk(KERN_INFO "pd6729: pci request region failed.\n");
626 goto err_out_disable;
629 for (i = 0; i < MAX_SOCKETS; i++) {
630 socket[i].io_base = pci_resource_start(dev, 0);
631 socket[i].socket.features |= SS_CAP_PCCARD;
632 socket[i].socket.map_size = 0x1000;
633 socket[i].socket.irq_mask = 0;
634 socket[i].socket.pci_irq = dev->irq;
635 socket[i].socket.owner = THIS_MODULE;
637 socket[i].number = i;
639 socket[i].socket.ops = &pd6729_operations;
640 socket[i].socket.dev.dev = &dev->dev;
641 socket[i].socket.driver_data = &socket[i];
644 pci_set_drvdata(dev, socket);
646 /* Register the interrupt handler */
647 if ((ret = request_irq(dev->irq, pd6729_interrupt, SA_SHIRQ, "pd6729", socket))) {
648 printk(KERN_ERR "pd6729: Failed to register irq %d, aborting\n", dev->irq);
649 goto err_out_free_res;
652 for (i = 0; i < MAX_SOCKETS; i++) {
653 ret = pcmcia_register_socket(&socket[i].socket);
655 printk(KERN_INFO "pd6729: pcmcia_register_socket failed.\n");
656 for (j = 0; j < i ; j++)
657 pcmcia_unregister_socket(&socket[j].socket);
658 goto err_out_free_res2;
665 free_irq(dev->irq, socket);
667 pci_release_regions(dev);
669 pci_disable_device(dev);
676 static void __devexit pd6729_pci_remove(struct pci_dev *dev)
679 struct pd6729_socket *socket = pci_get_drvdata(dev);
681 for (i = 0; i < MAX_SOCKETS; i++)
682 pcmcia_unregister_socket(&socket[i].socket);
684 free_irq(dev->irq, socket);
685 pci_release_regions(dev);
686 pci_disable_device(dev);
691 static int pd6729_socket_suspend(struct pci_dev *dev, u32 state)
693 return pcmcia_socket_dev_suspend(&dev->dev, state);
696 static int pd6729_socket_resume(struct pci_dev *dev)
698 return pcmcia_socket_dev_resume(&dev->dev);
701 static struct pci_device_id pd6729_pci_ids[] = {
703 .vendor = PCI_VENDOR_ID_CIRRUS,
704 .device = PCI_DEVICE_ID_CIRRUS_6729,
705 .subvendor = PCI_ANY_ID,
706 .subdevice = PCI_ANY_ID,
710 MODULE_DEVICE_TABLE(pci, pd6729_pci_ids);
712 static struct pci_driver pd6729_pci_drv = {
714 .id_table = pd6729_pci_ids,
715 .probe = pd6729_pci_probe,
716 .remove = __devexit_p(pd6729_pci_remove),
717 .suspend = pd6729_socket_suspend,
718 .resume = pd6729_socket_resume,
721 static int pd6729_module_init(void)
723 return pci_module_init(&pd6729_pci_drv);
726 static void pd6729_module_exit(void)
728 pci_unregister_driver(&pd6729_pci_drv);
731 module_init(pd6729_module_init);
732 module_exit(pd6729_module_exit);