1 /*====================================================================== 2 3 Common support code for the PCMCIA control functionality of 4 integrated SOCs like the SA-11x0 and PXA2xx microprocessors. 5 6 The contents of this file are subject to the Mozilla Public 7 License Version 1.1 (the "License"); you may not use this file 8 except in compliance with the License. You may obtain a copy of 9 the License at http://www.mozilla.org/MPL/ 10 11 Software distributed under the License is distributed on an "AS 12 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 13 implied. See the License for the specific language governing 14 rights and limitations under the License. 15 16 The initial developer of the original code is John G. Dorsey 17 <john+@cs.cmu.edu>. Portions created by John G. Dorsey are 18 Copyright (C) 1999 John G. Dorsey. All Rights Reserved. 19 20 Alternatively, the contents of this file may be used under the 21 terms of the GNU Public License version 2 (the "GPL"), in which 22 case the provisions of the GPL are applicable instead of the 23 above. If you wish to allow the use of your version of this file 24 only under the terms of the GPL and not to allow others to use 25 your version of this file under the MPL, indicate your decision 26 by deleting the provisions above and replace them with the notice 27 and other provisions required by the GPL. If you do not delete 28 the provisions above, a recipient may use your version of this 29 file under either the MPL or the GPL. 30 31 ======================================================================*/ 32 33 34 #include <linux/cpufreq.h> 35 #include <linux/gpio.h> 36 #include <linux/gpio/consumer.h> 37 #include <linux/init.h> 38 #include <linux/interrupt.h> 39 #include <linux/io.h> 40 #include <linux/irq.h> 41 #include <linux/kernel.h> 42 #include <linux/mm.h> 43 #include <linux/module.h> 44 #include <linux/moduleparam.h> 45 #include <linux/mutex.h> 46 #include <linux/regulator/consumer.h> 47 #include <linux/spinlock.h> 48 #include <linux/timer.h> 49 50 #include <mach/hardware.h> 51 52 #include "soc_common.h" 53 54 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev); 55 56 #ifdef CONFIG_PCMCIA_DEBUG 57 58 static int pc_debug; 59 module_param(pc_debug, int, 0644); 60 61 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func, 62 int lvl, const char *fmt, ...) 63 { 64 struct va_format vaf; 65 va_list args; 66 if (pc_debug > lvl) { 67 va_start(args, fmt); 68 69 vaf.fmt = fmt; 70 vaf.va = &args; 71 72 printk(KERN_DEBUG "skt%u: %s: %pV", skt->nr, func, &vaf); 73 74 va_end(args); 75 } 76 } 77 EXPORT_SYMBOL(soc_pcmcia_debug); 78 79 #endif 80 81 #define to_soc_pcmcia_socket(x) \ 82 container_of(x, struct soc_pcmcia_socket, socket) 83 84 int soc_pcmcia_regulator_set(struct soc_pcmcia_socket *skt, 85 struct soc_pcmcia_regulator *r, int v) 86 { 87 bool on; 88 int ret; 89 90 if (!r->reg) 91 return 0; 92 93 on = v != 0; 94 if (r->on == on) 95 return 0; 96 97 if (on) { 98 ret = regulator_set_voltage(r->reg, v * 100000, v * 100000); 99 if (ret) { 100 int vout = regulator_get_voltage(r->reg) / 100000; 101 102 dev_warn(&skt->socket.dev, 103 "CS requested %s=%u.%uV, applying %u.%uV\n", 104 r == &skt->vcc ? "Vcc" : "Vpp", 105 v / 10, v % 10, vout / 10, vout % 10); 106 } 107 108 ret = regulator_enable(r->reg); 109 } else { 110 ret = regulator_disable(r->reg); 111 } 112 if (ret == 0) 113 r->on = on; 114 115 return ret; 116 } 117 EXPORT_SYMBOL_GPL(soc_pcmcia_regulator_set); 118 119 static unsigned short 120 calc_speed(unsigned short *spds, int num, unsigned short dflt) 121 { 122 unsigned short speed = 0; 123 int i; 124 125 for (i = 0; i < num; i++) 126 if (speed < spds[i]) 127 speed = spds[i]; 128 if (speed == 0) 129 speed = dflt; 130 131 return speed; 132 } 133 134 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, 135 struct soc_pcmcia_timing *timing) 136 { 137 timing->io = 138 calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS); 139 timing->mem = 140 calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS); 141 timing->attr = 142 calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS); 143 } 144 EXPORT_SYMBOL(soc_common_pcmcia_get_timing); 145 146 static void __soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt, 147 unsigned int nr) 148 { 149 unsigned int i; 150 151 for (i = 0; i < nr; i++) 152 if (skt->stat[i].irq) 153 free_irq(skt->stat[i].irq, skt); 154 155 if (skt->ops->hw_shutdown) 156 skt->ops->hw_shutdown(skt); 157 158 clk_disable_unprepare(skt->clk); 159 } 160 161 static void soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt) 162 { 163 __soc_pcmcia_hw_shutdown(skt, ARRAY_SIZE(skt->stat)); 164 } 165 166 int soc_pcmcia_request_gpiods(struct soc_pcmcia_socket *skt) 167 { 168 struct device *dev = skt->socket.dev.parent; 169 struct gpio_desc *desc; 170 int i; 171 172 for (i = 0; i < ARRAY_SIZE(skt->stat); i++) { 173 if (!skt->stat[i].name) 174 continue; 175 176 desc = devm_gpiod_get(dev, skt->stat[i].name, GPIOD_IN); 177 if (IS_ERR(desc)) { 178 dev_err(dev, "Failed to get GPIO for %s: %ld\n", 179 skt->stat[i].name, PTR_ERR(desc)); 180 return PTR_ERR(desc); 181 } 182 183 skt->stat[i].desc = desc; 184 } 185 186 return 0; 187 } 188 EXPORT_SYMBOL_GPL(soc_pcmcia_request_gpiods); 189 190 static int soc_pcmcia_hw_init(struct soc_pcmcia_socket *skt) 191 { 192 int ret = 0, i; 193 194 clk_prepare_enable(skt->clk); 195 196 if (skt->ops->hw_init) { 197 ret = skt->ops->hw_init(skt); 198 if (ret) 199 return ret; 200 } 201 202 for (i = 0; i < ARRAY_SIZE(skt->stat); i++) { 203 if (gpio_is_valid(skt->stat[i].gpio)) { 204 unsigned long flags = GPIOF_IN; 205 206 /* CD is active low by default */ 207 if (i == SOC_STAT_CD) 208 flags |= GPIOF_ACTIVE_LOW; 209 210 ret = devm_gpio_request_one(skt->socket.dev.parent, 211 skt->stat[i].gpio, flags, 212 skt->stat[i].name); 213 if (ret) { 214 __soc_pcmcia_hw_shutdown(skt, i); 215 return ret; 216 } 217 218 skt->stat[i].desc = gpio_to_desc(skt->stat[i].gpio); 219 } 220 221 if (i < SOC_STAT_VS1 && skt->stat[i].desc) { 222 int irq = gpiod_to_irq(skt->stat[i].desc); 223 224 if (irq > 0) { 225 if (i == SOC_STAT_RDY) 226 skt->socket.pci_irq = irq; 227 else 228 skt->stat[i].irq = irq; 229 } 230 } 231 232 if (skt->stat[i].irq) { 233 ret = request_irq(skt->stat[i].irq, 234 soc_common_pcmcia_interrupt, 235 IRQF_TRIGGER_NONE, 236 skt->stat[i].name, skt); 237 if (ret) { 238 __soc_pcmcia_hw_shutdown(skt, i); 239 return ret; 240 } 241 } 242 } 243 244 return ret; 245 } 246 247 static void soc_pcmcia_hw_enable(struct soc_pcmcia_socket *skt) 248 { 249 int i; 250 251 for (i = 0; i < ARRAY_SIZE(skt->stat); i++) 252 if (skt->stat[i].irq) { 253 irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_RISING); 254 irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_BOTH); 255 } 256 } 257 258 static void soc_pcmcia_hw_disable(struct soc_pcmcia_socket *skt) 259 { 260 int i; 261 262 for (i = 0; i < ARRAY_SIZE(skt->stat); i++) 263 if (skt->stat[i].irq) 264 irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_NONE); 265 } 266 267 /* 268 * The CF 3.0 specification says that cards tie VS1 to ground and leave 269 * VS2 open. Many implementations do not wire up the VS signals, so we 270 * provide hard-coded values as per the CF 3.0 spec. 271 */ 272 void soc_common_cf_socket_state(struct soc_pcmcia_socket *skt, 273 struct pcmcia_state *state) 274 { 275 state->vs_3v = 1; 276 } 277 EXPORT_SYMBOL_GPL(soc_common_cf_socket_state); 278 279 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt) 280 { 281 struct pcmcia_state state; 282 unsigned int stat; 283 284 memset(&state, 0, sizeof(struct pcmcia_state)); 285 286 /* Make battery voltage state report 'good' */ 287 state.bvd1 = 1; 288 state.bvd2 = 1; 289 290 if (skt->stat[SOC_STAT_CD].desc) 291 state.detect = !!gpiod_get_value(skt->stat[SOC_STAT_CD].desc); 292 if (skt->stat[SOC_STAT_RDY].desc) 293 state.ready = !!gpiod_get_value(skt->stat[SOC_STAT_RDY].desc); 294 if (skt->stat[SOC_STAT_BVD1].desc) 295 state.bvd1 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD1].desc); 296 if (skt->stat[SOC_STAT_BVD2].desc) 297 state.bvd2 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD2].desc); 298 if (skt->stat[SOC_STAT_VS1].desc) 299 state.vs_3v = !!gpiod_get_value(skt->stat[SOC_STAT_VS1].desc); 300 if (skt->stat[SOC_STAT_VS2].desc) 301 state.vs_Xv = !!gpiod_get_value(skt->stat[SOC_STAT_VS2].desc); 302 303 skt->ops->socket_state(skt, &state); 304 305 stat = state.detect ? SS_DETECT : 0; 306 stat |= state.ready ? SS_READY : 0; 307 stat |= state.wrprot ? SS_WRPROT : 0; 308 stat |= state.vs_3v ? SS_3VCARD : 0; 309 stat |= state.vs_Xv ? SS_XVCARD : 0; 310 311 /* The power status of individual sockets is not available 312 * explicitly from the hardware, so we just remember the state 313 * and regurgitate it upon request: 314 */ 315 stat |= skt->cs_state.Vcc ? SS_POWERON : 0; 316 317 if (skt->cs_state.flags & SS_IOCARD) 318 stat |= state.bvd1 ? 0 : SS_STSCHG; 319 else { 320 if (state.bvd1 == 0) 321 stat |= SS_BATDEAD; 322 else if (state.bvd2 == 0) 323 stat |= SS_BATWARN; 324 } 325 return stat; 326 } 327 328 /* 329 * soc_common_pcmcia_config_skt 330 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 331 * 332 * Convert PCMCIA socket state to our socket configure structure. 333 */ 334 static int soc_common_pcmcia_config_skt( 335 struct soc_pcmcia_socket *skt, socket_state_t *state) 336 { 337 int ret; 338 339 ret = skt->ops->configure_socket(skt, state); 340 if (ret < 0) { 341 pr_err("soc_common_pcmcia: unable to configure socket %d\n", 342 skt->nr); 343 /* restore the previous state */ 344 WARN_ON(skt->ops->configure_socket(skt, &skt->cs_state)); 345 return ret; 346 } 347 348 if (ret == 0) { 349 struct gpio_desc *descs[2]; 350 int values[2], n = 0; 351 352 if (skt->gpio_reset) { 353 descs[n] = skt->gpio_reset; 354 values[n++] = !!(state->flags & SS_RESET); 355 } 356 if (skt->gpio_bus_enable) { 357 descs[n] = skt->gpio_bus_enable; 358 values[n++] = !!(state->flags & SS_OUTPUT_ENA); 359 } 360 361 if (n) 362 gpiod_set_array_value_cansleep(n, descs, values); 363 364 /* 365 * This really needs a better solution. The IRQ 366 * may or may not be claimed by the driver. 367 */ 368 if (skt->irq_state != 1 && state->io_irq) { 369 skt->irq_state = 1; 370 irq_set_irq_type(skt->socket.pci_irq, 371 IRQ_TYPE_EDGE_FALLING); 372 } else if (skt->irq_state == 1 && state->io_irq == 0) { 373 skt->irq_state = 0; 374 irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE); 375 } 376 377 skt->cs_state = *state; 378 } 379 380 return ret; 381 } 382 383 /* soc_common_pcmcia_sock_init() 384 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 385 * 386 * (Re-)Initialise the socket, turning on status interrupts 387 * and PCMCIA bus. This must wait for power to stabilise 388 * so that the card status signals report correctly. 389 * 390 * Returns: 0 391 */ 392 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock) 393 { 394 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 395 396 debug(skt, 2, "initializing socket\n"); 397 if (skt->ops->socket_init) 398 skt->ops->socket_init(skt); 399 soc_pcmcia_hw_enable(skt); 400 return 0; 401 } 402 403 404 /* 405 * soc_common_pcmcia_suspend() 406 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 407 * 408 * Remove power on the socket, disable IRQs from the card. 409 * Turn off status interrupts, and disable the PCMCIA bus. 410 * 411 * Returns: 0 412 */ 413 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock) 414 { 415 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 416 417 debug(skt, 2, "suspending socket\n"); 418 419 soc_pcmcia_hw_disable(skt); 420 if (skt->ops->socket_suspend) 421 skt->ops->socket_suspend(skt); 422 423 return 0; 424 } 425 426 static DEFINE_SPINLOCK(status_lock); 427 428 static void soc_common_check_status(struct soc_pcmcia_socket *skt) 429 { 430 unsigned int events; 431 432 debug(skt, 4, "entering PCMCIA monitoring thread\n"); 433 434 do { 435 unsigned int status; 436 unsigned long flags; 437 438 status = soc_common_pcmcia_skt_state(skt); 439 440 spin_lock_irqsave(&status_lock, flags); 441 events = (status ^ skt->status) & skt->cs_state.csc_mask; 442 skt->status = status; 443 spin_unlock_irqrestore(&status_lock, flags); 444 445 debug(skt, 4, "events: %s%s%s%s%s%s\n", 446 events == 0 ? "<NONE>" : "", 447 events & SS_DETECT ? "DETECT " : "", 448 events & SS_READY ? "READY " : "", 449 events & SS_BATDEAD ? "BATDEAD " : "", 450 events & SS_BATWARN ? "BATWARN " : "", 451 events & SS_STSCHG ? "STSCHG " : ""); 452 453 if (events) 454 pcmcia_parse_events(&skt->socket, events); 455 } while (events); 456 } 457 458 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */ 459 static void soc_common_pcmcia_poll_event(struct timer_list *t) 460 { 461 struct soc_pcmcia_socket *skt = from_timer(skt, t, poll_timer); 462 debug(skt, 4, "polling for events\n"); 463 464 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD); 465 466 soc_common_check_status(skt); 467 } 468 469 470 /* 471 * Service routine for socket driver interrupts (requested by the 472 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()). 473 * The actual interrupt-servicing work is performed by 474 * soc_common_pcmcia_thread(), largely because the Card Services event- 475 * handling code performs scheduling operations which cannot be 476 * executed from within an interrupt context. 477 */ 478 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev) 479 { 480 struct soc_pcmcia_socket *skt = dev; 481 482 debug(skt, 3, "servicing IRQ %d\n", irq); 483 484 soc_common_check_status(skt); 485 486 return IRQ_HANDLED; 487 } 488 489 490 /* 491 * Implements the get_status() operation for the in-kernel PCMCIA 492 * service (formerly SS_GetStatus in Card Services). Essentially just 493 * fills in bits in `status' according to internal driver state or 494 * the value of the voltage detect chipselect register. 495 * 496 * As a debugging note, during card startup, the PCMCIA core issues 497 * three set_socket() commands in a row the first with RESET deasserted, 498 * the second with RESET asserted, and the last with RESET deasserted 499 * again. Following the third set_socket(), a get_status() command will 500 * be issued. The kernel is looking for the SS_READY flag (see 501 * setup_socket(), reset_socket(), and unreset_socket() in cs.c). 502 * 503 * Returns: 0 504 */ 505 static int 506 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status) 507 { 508 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 509 510 skt->status = soc_common_pcmcia_skt_state(skt); 511 *status = skt->status; 512 513 return 0; 514 } 515 516 517 /* 518 * Implements the set_socket() operation for the in-kernel PCMCIA 519 * service (formerly SS_SetSocket in Card Services). We more or 520 * less punt all of this work and let the kernel handle the details 521 * of power configuration, reset, &c. We also record the value of 522 * `state' in order to regurgitate it to the PCMCIA core later. 523 */ 524 static int soc_common_pcmcia_set_socket( 525 struct pcmcia_socket *sock, socket_state_t *state) 526 { 527 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 528 529 debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n", 530 (state->csc_mask == 0) ? "<NONE> " : "", 531 (state->csc_mask & SS_DETECT) ? "DETECT " : "", 532 (state->csc_mask & SS_READY) ? "READY " : "", 533 (state->csc_mask & SS_BATDEAD) ? "BATDEAD " : "", 534 (state->csc_mask & SS_BATWARN) ? "BATWARN " : "", 535 (state->csc_mask & SS_STSCHG) ? "STSCHG " : "", 536 (state->flags == 0) ? "<NONE> " : "", 537 (state->flags & SS_PWR_AUTO) ? "PWR_AUTO " : "", 538 (state->flags & SS_IOCARD) ? "IOCARD " : "", 539 (state->flags & SS_RESET) ? "RESET " : "", 540 (state->flags & SS_SPKR_ENA) ? "SPKR_ENA " : "", 541 (state->flags & SS_OUTPUT_ENA) ? "OUTPUT_ENA " : "", 542 state->Vcc, state->Vpp, state->io_irq); 543 544 return soc_common_pcmcia_config_skt(skt, state); 545 } 546 547 548 /* 549 * Implements the set_io_map() operation for the in-kernel PCMCIA 550 * service (formerly SS_SetIOMap in Card Services). We configure 551 * the map speed as requested, but override the address ranges 552 * supplied by Card Services. 553 * 554 * Returns: 0 on success, -1 on error 555 */ 556 static int soc_common_pcmcia_set_io_map( 557 struct pcmcia_socket *sock, struct pccard_io_map *map) 558 { 559 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 560 unsigned short speed = map->speed; 561 562 debug(skt, 2, "map %u speed %u start 0x%08llx stop 0x%08llx\n", 563 map->map, map->speed, (unsigned long long)map->start, 564 (unsigned long long)map->stop); 565 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n", 566 (map->flags == 0) ? "<NONE>" : "", 567 (map->flags & MAP_ACTIVE) ? "ACTIVE " : "", 568 (map->flags & MAP_16BIT) ? "16BIT " : "", 569 (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "", 570 (map->flags & MAP_0WS) ? "0WS " : "", 571 (map->flags & MAP_WRPROT) ? "WRPROT " : "", 572 (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "", 573 (map->flags & MAP_PREFETCH) ? "PREFETCH " : ""); 574 575 if (map->map >= MAX_IO_WIN) { 576 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__, 577 map->map); 578 return -1; 579 } 580 581 if (map->flags & MAP_ACTIVE) { 582 if (speed == 0) 583 speed = SOC_PCMCIA_IO_ACCESS; 584 } else { 585 speed = 0; 586 } 587 588 skt->spd_io[map->map] = speed; 589 skt->ops->set_timing(skt); 590 591 if (map->stop == 1) 592 map->stop = PAGE_SIZE-1; 593 594 map->stop -= map->start; 595 map->stop += skt->socket.io_offset; 596 map->start = skt->socket.io_offset; 597 598 return 0; 599 } 600 601 602 /* 603 * Implements the set_mem_map() operation for the in-kernel PCMCIA 604 * service (formerly SS_SetMemMap in Card Services). We configure 605 * the map speed as requested, but override the address ranges 606 * supplied by Card Services. 607 * 608 * Returns: 0 on success, -ERRNO on error 609 */ 610 static int soc_common_pcmcia_set_mem_map( 611 struct pcmcia_socket *sock, struct pccard_mem_map *map) 612 { 613 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 614 struct resource *res; 615 unsigned short speed = map->speed; 616 617 debug(skt, 2, "map %u speed %u card_start %08x\n", 618 map->map, map->speed, map->card_start); 619 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n", 620 (map->flags == 0) ? "<NONE>" : "", 621 (map->flags & MAP_ACTIVE) ? "ACTIVE " : "", 622 (map->flags & MAP_16BIT) ? "16BIT " : "", 623 (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "", 624 (map->flags & MAP_0WS) ? "0WS " : "", 625 (map->flags & MAP_WRPROT) ? "WRPROT " : "", 626 (map->flags & MAP_ATTRIB) ? "ATTRIB " : "", 627 (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : ""); 628 629 if (map->map >= MAX_WIN) 630 return -EINVAL; 631 632 if (map->flags & MAP_ACTIVE) { 633 if (speed == 0) 634 speed = 300; 635 } else { 636 speed = 0; 637 } 638 639 if (map->flags & MAP_ATTRIB) { 640 res = &skt->res_attr; 641 skt->spd_attr[map->map] = speed; 642 skt->spd_mem[map->map] = 0; 643 } else { 644 res = &skt->res_mem; 645 skt->spd_attr[map->map] = 0; 646 skt->spd_mem[map->map] = speed; 647 } 648 649 skt->ops->set_timing(skt); 650 651 map->static_start = res->start + map->card_start; 652 653 return 0; 654 } 655 656 struct bittbl { 657 unsigned int mask; 658 const char *name; 659 }; 660 661 static struct bittbl status_bits[] = { 662 { SS_WRPROT, "SS_WRPROT" }, 663 { SS_BATDEAD, "SS_BATDEAD" }, 664 { SS_BATWARN, "SS_BATWARN" }, 665 { SS_READY, "SS_READY" }, 666 { SS_DETECT, "SS_DETECT" }, 667 { SS_POWERON, "SS_POWERON" }, 668 { SS_STSCHG, "SS_STSCHG" }, 669 { SS_3VCARD, "SS_3VCARD" }, 670 { SS_XVCARD, "SS_XVCARD" }, 671 }; 672 673 static struct bittbl conf_bits[] = { 674 { SS_PWR_AUTO, "SS_PWR_AUTO" }, 675 { SS_IOCARD, "SS_IOCARD" }, 676 { SS_RESET, "SS_RESET" }, 677 { SS_DMA_MODE, "SS_DMA_MODE" }, 678 { SS_SPKR_ENA, "SS_SPKR_ENA" }, 679 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" }, 680 }; 681 682 static void dump_bits(char **p, const char *prefix, 683 unsigned int val, struct bittbl *bits, int sz) 684 { 685 char *b = *p; 686 int i; 687 688 b += sprintf(b, "%-9s:", prefix); 689 for (i = 0; i < sz; i++) 690 if (val & bits[i].mask) 691 b += sprintf(b, " %s", bits[i].name); 692 *b++ = '\n'; 693 *p = b; 694 } 695 696 /* 697 * Implements the /sys/class/pcmcia_socket/??/status file. 698 * 699 * Returns: the number of characters added to the buffer 700 */ 701 static ssize_t show_status( 702 struct device *dev, struct device_attribute *attr, char *buf) 703 { 704 struct soc_pcmcia_socket *skt = 705 container_of(dev, struct soc_pcmcia_socket, socket.dev); 706 char *p = buf; 707 708 p += sprintf(p, "slot : %d\n", skt->nr); 709 710 dump_bits(&p, "status", skt->status, 711 status_bits, ARRAY_SIZE(status_bits)); 712 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask, 713 status_bits, ARRAY_SIZE(status_bits)); 714 dump_bits(&p, "cs_flags", skt->cs_state.flags, 715 conf_bits, ARRAY_SIZE(conf_bits)); 716 717 p += sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc); 718 p += sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp); 719 p += sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, 720 skt->socket.pci_irq); 721 if (skt->ops->show_timing) 722 p += skt->ops->show_timing(skt, p); 723 724 return p-buf; 725 } 726 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 727 728 729 static struct pccard_operations soc_common_pcmcia_operations = { 730 .init = soc_common_pcmcia_sock_init, 731 .suspend = soc_common_pcmcia_suspend, 732 .get_status = soc_common_pcmcia_get_status, 733 .set_socket = soc_common_pcmcia_set_socket, 734 .set_io_map = soc_common_pcmcia_set_io_map, 735 .set_mem_map = soc_common_pcmcia_set_mem_map, 736 }; 737 738 739 #ifdef CONFIG_CPU_FREQ 740 static int soc_common_pcmcia_cpufreq_nb(struct notifier_block *nb, 741 unsigned long val, void *data) 742 { 743 struct soc_pcmcia_socket *skt = container_of(nb, struct soc_pcmcia_socket, cpufreq_nb); 744 struct cpufreq_freqs *freqs = data; 745 746 return skt->ops->frequency_change(skt, val, freqs); 747 } 748 #endif 749 750 void soc_pcmcia_init_one(struct soc_pcmcia_socket *skt, 751 const struct pcmcia_low_level *ops, struct device *dev) 752 { 753 int i; 754 755 skt->ops = ops; 756 skt->socket.owner = ops->owner; 757 skt->socket.dev.parent = dev; 758 skt->socket.pci_irq = NO_IRQ; 759 760 for (i = 0; i < ARRAY_SIZE(skt->stat); i++) 761 skt->stat[i].gpio = -EINVAL; 762 } 763 EXPORT_SYMBOL(soc_pcmcia_init_one); 764 765 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt) 766 { 767 del_timer_sync(&skt->poll_timer); 768 769 pcmcia_unregister_socket(&skt->socket); 770 771 #ifdef CONFIG_CPU_FREQ 772 if (skt->ops->frequency_change) 773 cpufreq_unregister_notifier(&skt->cpufreq_nb, 774 CPUFREQ_TRANSITION_NOTIFIER); 775 #endif 776 777 soc_pcmcia_hw_shutdown(skt); 778 779 /* should not be required; violates some lowlevel drivers */ 780 soc_common_pcmcia_config_skt(skt, &dead_socket); 781 782 iounmap(skt->virt_io); 783 skt->virt_io = NULL; 784 release_resource(&skt->res_attr); 785 release_resource(&skt->res_mem); 786 release_resource(&skt->res_io); 787 release_resource(&skt->res_skt); 788 } 789 EXPORT_SYMBOL(soc_pcmcia_remove_one); 790 791 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt) 792 { 793 int ret; 794 795 skt->cs_state = dead_socket; 796 797 timer_setup(&skt->poll_timer, soc_common_pcmcia_poll_event, 0); 798 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD; 799 800 ret = request_resource(&iomem_resource, &skt->res_skt); 801 if (ret) 802 goto out_err_1; 803 804 ret = request_resource(&skt->res_skt, &skt->res_io); 805 if (ret) 806 goto out_err_2; 807 808 ret = request_resource(&skt->res_skt, &skt->res_mem); 809 if (ret) 810 goto out_err_3; 811 812 ret = request_resource(&skt->res_skt, &skt->res_attr); 813 if (ret) 814 goto out_err_4; 815 816 skt->virt_io = ioremap(skt->res_io.start, 0x10000); 817 if (skt->virt_io == NULL) { 818 ret = -ENOMEM; 819 goto out_err_5; 820 } 821 822 /* 823 * We initialize default socket timing here, because 824 * we are not guaranteed to see a SetIOMap operation at 825 * runtime. 826 */ 827 skt->ops->set_timing(skt); 828 829 ret = soc_pcmcia_hw_init(skt); 830 if (ret) 831 goto out_err_6; 832 833 skt->socket.ops = &soc_common_pcmcia_operations; 834 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD; 835 skt->socket.resource_ops = &pccard_static_ops; 836 skt->socket.irq_mask = 0; 837 skt->socket.map_size = PAGE_SIZE; 838 skt->socket.io_offset = (unsigned long)skt->virt_io; 839 840 skt->status = soc_common_pcmcia_skt_state(skt); 841 842 #ifdef CONFIG_CPU_FREQ 843 if (skt->ops->frequency_change) { 844 skt->cpufreq_nb.notifier_call = soc_common_pcmcia_cpufreq_nb; 845 846 ret = cpufreq_register_notifier(&skt->cpufreq_nb, 847 CPUFREQ_TRANSITION_NOTIFIER); 848 if (ret < 0) 849 dev_err(skt->socket.dev.parent, 850 "unable to register CPU frequency change notifier for PCMCIA (%d)\n", 851 ret); 852 } 853 #endif 854 855 ret = pcmcia_register_socket(&skt->socket); 856 if (ret) 857 goto out_err_7; 858 859 ret = device_create_file(&skt->socket.dev, &dev_attr_status); 860 if (ret) 861 goto out_err_8; 862 863 return ret; 864 865 out_err_8: 866 del_timer_sync(&skt->poll_timer); 867 pcmcia_unregister_socket(&skt->socket); 868 869 out_err_7: 870 soc_pcmcia_hw_shutdown(skt); 871 out_err_6: 872 iounmap(skt->virt_io); 873 out_err_5: 874 release_resource(&skt->res_attr); 875 out_err_4: 876 release_resource(&skt->res_mem); 877 out_err_3: 878 release_resource(&skt->res_io); 879 out_err_2: 880 release_resource(&skt->res_skt); 881 out_err_1: 882 883 return ret; 884 } 885 EXPORT_SYMBOL(soc_pcmcia_add_one); 886 887 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>"); 888 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support"); 889 MODULE_LICENSE("Dual MPL/GPL"); 890