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