root/drivers/pcmcia/bcm63xx_pcmcia.c

DEFINITIONS

1. pcmcia_readl
2. pcmcia_writel
3. bcm63xx_pcmcia_sock_init
4. bcm63xx_pcmcia_suspend
5. bcm63xx_pcmcia_set_socket
6. __get_socket_status
7. bcm63xx_pcmcia_get_status
8. bcm63xx_pcmcia_poll
9. bcm63xx_pcmcia_set_io_map
10. bcm63xx_pcmcia_set_mem_map
11. bcm63xx_drv_pcmcia_probe
12. bcm63xx_drv_pcmcia_remove
13. bcm63xx_cb_probe
14. bcm63xx_cb_exit
15. bcm63xx_pcmcia_init
16. bcm63xx_pcmcia_exit

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