1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr> 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/ioport.h> 12 #include <linux/timer.h> 13 #include <linux/platform_device.h> 14 #include <linux/delay.h> 15 #include <linux/pci.h> 16 #include <linux/gpio.h> 17 18 #include <bcm63xx_regs.h> 19 #include <bcm63xx_io.h> 20 #include "bcm63xx_pcmcia.h" 21 22 #define PFX "bcm63xx_pcmcia: " 23 24 #ifdef CONFIG_CARDBUS 25 /* if cardbus is used, platform device needs reference to actual pci 26 * device */ 27 static struct pci_dev *bcm63xx_cb_dev; 28 #endif 29 30 /* 31 * read/write helper for pcmcia regs 32 */ 33 static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off) 34 { 35 return bcm_readl(skt->base + off); 36 } 37 38 static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt, 39 u32 val, u32 off) 40 { 41 bcm_writel(val, skt->base + off); 42 } 43 44 /* 45 * This callback should (re-)initialise the socket, turn on status 46 * interrupts and PCMCIA bus, and wait for power to stabilise so that 47 * the card status signals report correctly. 48 * 49 * Hardware cannot do that. 50 */ 51 static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock) 52 { 53 return 0; 54 } 55 56 /* 57 * This callback should remove power on the socket, disable IRQs from 58 * the card, turn off status interrupts, and disable the PCMCIA bus. 59 * 60 * Hardware cannot do that. 61 */ 62 static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock) 63 { 64 return 0; 65 } 66 67 /* 68 * Implements the set_socket() operation for the in-kernel PCMCIA 69 * service (formerly SS_SetSocket in Card Services). We more or 70 * less punt all of this work and let the kernel handle the details 71 * of power configuration, reset, &c. We also record the value of 72 * `state' in order to regurgitate it to the PCMCIA core later. 73 */ 74 static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock, 75 socket_state_t *state) 76 { 77 struct bcm63xx_pcmcia_socket *skt; 78 unsigned long flags; 79 u32 val; 80 81 skt = sock->driver_data; 82 83 spin_lock_irqsave(&skt->lock, flags); 84 85 /* note: hardware cannot control socket power, so we will 86 * always report SS_POWERON */ 87 88 /* apply socket reset */ 89 val = pcmcia_readl(skt, PCMCIA_C1_REG); 90 if (state->flags & SS_RESET) 91 val |= PCMCIA_C1_RESET_MASK; 92 else 93 val &= ~PCMCIA_C1_RESET_MASK; 94 95 /* reverse reset logic for cardbus card */ 96 if (skt->card_detected && (skt->card_type & CARD_CARDBUS)) 97 val ^= PCMCIA_C1_RESET_MASK; 98 99 pcmcia_writel(skt, val, PCMCIA_C1_REG); 100 101 /* keep requested state for event reporting */ 102 skt->requested_state = *state; 103 104 spin_unlock_irqrestore(&skt->lock, flags); 105 106 return 0; 107 } 108 109 /* 110 * identity cardtype from VS[12] input, CD[12] input while only VS2 is 111 * floating, and CD[12] input while only VS1 is floating 112 */ 113 enum { 114 IN_VS1 = (1 << 0), 115 IN_VS2 = (1 << 1), 116 IN_CD1_VS2H = (1 << 2), 117 IN_CD2_VS2H = (1 << 3), 118 IN_CD1_VS1H = (1 << 4), 119 IN_CD2_VS1H = (1 << 5), 120 }; 121 122 static const u8 vscd_to_cardtype[] = { 123 124 /* VS1 float, VS2 float */ 125 [IN_VS1 | IN_VS2] = (CARD_PCCARD | CARD_5V), 126 127 /* VS1 grounded, VS2 float */ 128 [IN_VS2] = (CARD_PCCARD | CARD_5V | CARD_3V), 129 130 /* VS1 grounded, VS2 grounded */ 131 [0] = (CARD_PCCARD | CARD_5V | CARD_3V | CARD_XV), 132 133 /* VS1 tied to CD1, VS2 float */ 134 [IN_VS1 | IN_VS2 | IN_CD1_VS1H] = (CARD_CARDBUS | CARD_3V), 135 136 /* VS1 grounded, VS2 tied to CD2 */ 137 [IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V | CARD_XV), 138 139 /* VS1 tied to CD2, VS2 grounded */ 140 [IN_VS1 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_3V | CARD_XV | CARD_YV), 141 142 /* VS1 float, VS2 grounded */ 143 [IN_VS1] = (CARD_PCCARD | CARD_XV), 144 145 /* VS1 float, VS2 tied to CD2 */ 146 [IN_VS1 | IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V), 147 148 /* VS1 float, VS2 tied to CD1 */ 149 [IN_VS1 | IN_VS2 | IN_CD1_VS2H] = (CARD_CARDBUS | CARD_XV | CARD_YV), 150 151 /* VS1 tied to CD2, VS2 float */ 152 [IN_VS1 | IN_VS2 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_YV), 153 154 /* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */ 155 [IN_VS1 | IN_CD1_VS1H] = 0, /* ignore cardbay */ 156 }; 157 158 /* 159 * poll hardware to check card insertion status 160 */ 161 static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt) 162 { 163 unsigned int stat; 164 u32 val; 165 166 stat = 0; 167 168 /* check CD for card presence */ 169 val = pcmcia_readl(skt, PCMCIA_C1_REG); 170 171 if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK)) 172 stat |= SS_DETECT; 173 174 /* if new insertion, detect cardtype */ 175 if ((stat & SS_DETECT) && !skt->card_detected) { 176 unsigned int stat = 0; 177 178 /* float VS1, float VS2 */ 179 val |= PCMCIA_C1_VS1OE_MASK; 180 val |= PCMCIA_C1_VS2OE_MASK; 181 pcmcia_writel(skt, val, PCMCIA_C1_REG); 182 183 /* wait for output to stabilize and read VS[12] */ 184 udelay(10); 185 val = pcmcia_readl(skt, PCMCIA_C1_REG); 186 stat |= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0; 187 stat |= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0; 188 189 /* drive VS1 low, float VS2 */ 190 val &= ~PCMCIA_C1_VS1OE_MASK; 191 val |= PCMCIA_C1_VS2OE_MASK; 192 pcmcia_writel(skt, val, PCMCIA_C1_REG); 193 194 /* wait for output to stabilize and read CD[12] */ 195 udelay(10); 196 val = pcmcia_readl(skt, PCMCIA_C1_REG); 197 stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0; 198 stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0; 199 200 /* float VS1, drive VS2 low */ 201 val |= PCMCIA_C1_VS1OE_MASK; 202 val &= ~PCMCIA_C1_VS2OE_MASK; 203 pcmcia_writel(skt, val, PCMCIA_C1_REG); 204 205 /* wait for output to stabilize and read CD[12] */ 206 udelay(10); 207 val = pcmcia_readl(skt, PCMCIA_C1_REG); 208 stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0; 209 stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0; 210 211 /* guess cardtype from all this */ 212 skt->card_type = vscd_to_cardtype[stat]; 213 if (!skt->card_type) 214 dev_err(&skt->socket.dev, "unsupported card type\n"); 215 216 /* drive both VS pin to 0 again */ 217 val &= ~(PCMCIA_C1_VS1OE_MASK | PCMCIA_C1_VS2OE_MASK); 218 219 /* enable correct logic */ 220 val &= ~(PCMCIA_C1_EN_PCMCIA_MASK | PCMCIA_C1_EN_CARDBUS_MASK); 221 if (skt->card_type & CARD_PCCARD) 222 val |= PCMCIA_C1_EN_PCMCIA_MASK; 223 else 224 val |= PCMCIA_C1_EN_CARDBUS_MASK; 225 226 pcmcia_writel(skt, val, PCMCIA_C1_REG); 227 } 228 skt->card_detected = (stat & SS_DETECT) ? 1 : 0; 229 230 /* report card type/voltage */ 231 if (skt->card_type & CARD_CARDBUS) 232 stat |= SS_CARDBUS; 233 if (skt->card_type & CARD_3V) 234 stat |= SS_3VCARD; 235 if (skt->card_type & CARD_XV) 236 stat |= SS_XVCARD; 237 stat |= SS_POWERON; 238 239 if (gpio_get_value(skt->pd->ready_gpio)) 240 stat |= SS_READY; 241 242 return stat; 243 } 244 245 /* 246 * core request to get current socket status 247 */ 248 static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock, 249 unsigned int *status) 250 { 251 struct bcm63xx_pcmcia_socket *skt; 252 253 skt = sock->driver_data; 254 255 spin_lock_bh(&skt->lock); 256 *status = __get_socket_status(skt); 257 spin_unlock_bh(&skt->lock); 258 259 return 0; 260 } 261 262 /* 263 * socket polling timer callback 264 */ 265 static void bcm63xx_pcmcia_poll(unsigned long data) 266 { 267 struct bcm63xx_pcmcia_socket *skt; 268 unsigned int stat, events; 269 270 skt = (struct bcm63xx_pcmcia_socket *)data; 271 272 spin_lock_bh(&skt->lock); 273 274 stat = __get_socket_status(skt); 275 276 /* keep only changed bits, and mask with required one from the 277 * core */ 278 events = (stat ^ skt->old_status) & skt->requested_state.csc_mask; 279 skt->old_status = stat; 280 spin_unlock_bh(&skt->lock); 281 282 if (events) 283 pcmcia_parse_events(&skt->socket, events); 284 285 mod_timer(&skt->timer, 286 jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE)); 287 } 288 289 static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock, 290 struct pccard_io_map *map) 291 { 292 /* this doesn't seem to be called by pcmcia layer if static 293 * mapping is used */ 294 return 0; 295 } 296 297 static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock, 298 struct pccard_mem_map *map) 299 { 300 struct bcm63xx_pcmcia_socket *skt; 301 struct resource *res; 302 303 skt = sock->driver_data; 304 if (map->flags & MAP_ATTRIB) 305 res = skt->attr_res; 306 else 307 res = skt->common_res; 308 309 map->static_start = res->start + map->card_start; 310 return 0; 311 } 312 313 static struct pccard_operations bcm63xx_pcmcia_operations = { 314 .init = bcm63xx_pcmcia_sock_init, 315 .suspend = bcm63xx_pcmcia_suspend, 316 .get_status = bcm63xx_pcmcia_get_status, 317 .set_socket = bcm63xx_pcmcia_set_socket, 318 .set_io_map = bcm63xx_pcmcia_set_io_map, 319 .set_mem_map = bcm63xx_pcmcia_set_mem_map, 320 }; 321 322 /* 323 * register pcmcia socket to core 324 */ 325 static int __devinit bcm63xx_drv_pcmcia_probe(struct platform_device *pdev) 326 { 327 struct bcm63xx_pcmcia_socket *skt; 328 struct pcmcia_socket *sock; 329 struct resource *res, *irq_res; 330 unsigned int regmem_size = 0, iomem_size = 0; 331 u32 val; 332 int ret; 333 334 skt = kzalloc(sizeof(*skt), GFP_KERNEL); 335 if (!skt) 336 return -ENOMEM; 337 spin_lock_init(&skt->lock); 338 sock = &skt->socket; 339 sock->driver_data = skt; 340 341 /* make sure we have all resources we need */ 342 skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 343 skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2); 344 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 345 skt->pd = pdev->dev.platform_data; 346 if (!skt->common_res || !skt->attr_res || !irq_res || !skt->pd) { 347 ret = -EINVAL; 348 goto err; 349 } 350 351 /* remap pcmcia registers */ 352 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 353 regmem_size = resource_size(res); 354 if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) { 355 ret = -EINVAL; 356 goto err; 357 } 358 skt->reg_res = res; 359 360 skt->base = ioremap(res->start, regmem_size); 361 if (!skt->base) { 362 ret = -ENOMEM; 363 goto err; 364 } 365 366 /* remap io registers */ 367 res = platform_get_resource(pdev, IORESOURCE_MEM, 3); 368 iomem_size = resource_size(res); 369 skt->io_base = ioremap(res->start, iomem_size); 370 if (!skt->io_base) { 371 ret = -ENOMEM; 372 goto err; 373 } 374 375 /* resources are static */ 376 sock->resource_ops = &pccard_static_ops; 377 sock->ops = &bcm63xx_pcmcia_operations; 378 sock->owner = THIS_MODULE; 379 sock->dev.parent = &pdev->dev; 380 sock->features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD; 381 sock->io_offset = (unsigned long)skt->io_base; 382 sock->pci_irq = irq_res->start; 383 384 #ifdef CONFIG_CARDBUS 385 sock->cb_dev = bcm63xx_cb_dev; 386 if (bcm63xx_cb_dev) 387 sock->features |= SS_CAP_CARDBUS; 388 #endif 389 390 /* assume common & attribute memory have the same size */ 391 sock->map_size = resource_size(skt->common_res); 392 393 /* initialize polling timer */ 394 setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt); 395 396 /* initialize pcmcia control register, drive VS[12] to 0, 397 * leave CB IDSEL to the old value since it is set by the PCI 398 * layer */ 399 val = pcmcia_readl(skt, PCMCIA_C1_REG); 400 val &= PCMCIA_C1_CBIDSEL_MASK; 401 val |= PCMCIA_C1_EN_PCMCIA_GPIO_MASK; 402 pcmcia_writel(skt, val, PCMCIA_C1_REG); 403 404 /* 405 * Hardware has only one set of timings registers, not one for 406 * each memory access type, so we configure them for the 407 * slowest one: attribute memory. 408 */ 409 val = PCMCIA_C2_DATA16_MASK; 410 val |= 10 << PCMCIA_C2_RWCOUNT_SHIFT; 411 val |= 6 << PCMCIA_C2_INACTIVE_SHIFT; 412 val |= 3 << PCMCIA_C2_SETUP_SHIFT; 413 val |= 3 << PCMCIA_C2_HOLD_SHIFT; 414 pcmcia_writel(skt, val, PCMCIA_C2_REG); 415 416 ret = pcmcia_register_socket(sock); 417 if (ret) 418 goto err; 419 420 /* start polling socket */ 421 mod_timer(&skt->timer, 422 jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE)); 423 424 platform_set_drvdata(pdev, skt); 425 return 0; 426 427 err: 428 if (skt->io_base) 429 iounmap(skt->io_base); 430 if (skt->base) 431 iounmap(skt->base); 432 if (skt->reg_res) 433 release_mem_region(skt->reg_res->start, regmem_size); 434 kfree(skt); 435 return ret; 436 } 437 438 static int __devexit bcm63xx_drv_pcmcia_remove(struct platform_device *pdev) 439 { 440 struct bcm63xx_pcmcia_socket *skt; 441 struct resource *res; 442 443 skt = platform_get_drvdata(pdev); 444 del_timer_sync(&skt->timer); 445 iounmap(skt->base); 446 iounmap(skt->io_base); 447 res = skt->reg_res; 448 release_mem_region(res->start, resource_size(res)); 449 kfree(skt); 450 return 0; 451 } 452 453 struct platform_driver bcm63xx_pcmcia_driver = { 454 .probe = bcm63xx_drv_pcmcia_probe, 455 .remove = __devexit_p(bcm63xx_drv_pcmcia_remove), 456 .driver = { 457 .name = "bcm63xx_pcmcia", 458 .owner = THIS_MODULE, 459 }, 460 }; 461 462 #ifdef CONFIG_CARDBUS 463 static int __devinit bcm63xx_cb_probe(struct pci_dev *dev, 464 const struct pci_device_id *id) 465 { 466 /* keep pci device */ 467 bcm63xx_cb_dev = dev; 468 return platform_driver_register(&bcm63xx_pcmcia_driver); 469 } 470 471 static void __devexit bcm63xx_cb_exit(struct pci_dev *dev) 472 { 473 platform_driver_unregister(&bcm63xx_pcmcia_driver); 474 bcm63xx_cb_dev = NULL; 475 } 476 477 static struct pci_device_id bcm63xx_cb_table[] = { 478 { 479 .vendor = PCI_VENDOR_ID_BROADCOM, 480 .device = BCM6348_CPU_ID, 481 .subvendor = PCI_VENDOR_ID_BROADCOM, 482 .subdevice = PCI_ANY_ID, 483 .class = PCI_CLASS_BRIDGE_CARDBUS << 8, 484 .class_mask = ~0, 485 }, 486 487 { 488 .vendor = PCI_VENDOR_ID_BROADCOM, 489 .device = BCM6358_CPU_ID, 490 .subvendor = PCI_VENDOR_ID_BROADCOM, 491 .subdevice = PCI_ANY_ID, 492 .class = PCI_CLASS_BRIDGE_CARDBUS << 8, 493 .class_mask = ~0, 494 }, 495 496 { }, 497 }; 498 499 MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table); 500 501 static struct pci_driver bcm63xx_cardbus_driver = { 502 .name = "bcm63xx_cardbus", 503 .id_table = bcm63xx_cb_table, 504 .probe = bcm63xx_cb_probe, 505 .remove = __devexit_p(bcm63xx_cb_exit), 506 }; 507 #endif 508 509 /* 510 * if cardbus support is enabled, register our platform device after 511 * our fake cardbus bridge has been registered 512 */ 513 static int __init bcm63xx_pcmcia_init(void) 514 { 515 #ifdef CONFIG_CARDBUS 516 return pci_register_driver(&bcm63xx_cardbus_driver); 517 #else 518 return platform_driver_register(&bcm63xx_pcmcia_driver); 519 #endif 520 } 521 522 static void __exit bcm63xx_pcmcia_exit(void) 523 { 524 #ifdef CONFIG_CARDBUS 525 return pci_unregister_driver(&bcm63xx_cardbus_driver); 526 #else 527 platform_driver_unregister(&bcm63xx_pcmcia_driver); 528 #endif 529 } 530 531 module_init(bcm63xx_pcmcia_init); 532 module_exit(bcm63xx_pcmcia_exit); 533 534 MODULE_LICENSE("GPL"); 535 MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>"); 536 MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller"); 537