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