1/*====================================================================== 2 3 Kernel Card Services -- core services 4 5 cs.c 1.271 2000/10/02 20:27:49 6 7 The contents of this file are subject to the Mozilla Public 8 License Version 1.1 (the "License"); you may not use this file 9 except in compliance with the License. You may obtain a copy of 10 the License at http://www.mozilla.org/MPL/ 11 12 Software distributed under the License is distributed on an "AS 13 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 14 implied. See the License for the specific language governing 15 rights and limitations under the License. 16 17 The initial developer of the original code is David A. Hinds 18 <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 19 are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 20 21 Alternatively, the contents of this file may be used under the 22 terms of the GNU General Public License version 2 (the "GPL"), in which 23 case the provisions of the GPL are applicable instead of the 24 above. If you wish to allow the use of your version of this file 25 only under the terms of the GPL and not to allow others to use 26 your version of this file under the MPL, indicate your decision 27 by deleting the provisions above and replace them with the notice 28 and other provisions required by the GPL. If you do not delete 29 the provisions above, a recipient may use your version of this 30 file under either the MPL or the GPL. 31 32======================================================================*/ 33 34#include <linux/module.h> 35#include <linux/init.h> 36#include <linux/kernel.h> 37#include <linux/config.h> 38#include <linux/string.h> 39#include <linux/major.h> 40#include <linux/errno.h> 41#include <linux/slab.h> 42#include <linux/mm.h> 43#include <linux/sched.h> 44#include <linux/timer.h> 45#include <linux/ioport.h> 46#include <linux/delay.h> 47#include <linux/proc_fs.h> 48#include <linux/pm.h> 49#include <linux/pci.h> 50#include <asm/system.h> 51#include <asm/irq.h> 52 53#define IN_CARD_SERVICES 54#include <pcmcia/version.h> 55#include <pcmcia/cs_types.h> 56#include <pcmcia/ss.h> 57#include <pcmcia/cs.h> 58#include <pcmcia/bulkmem.h> 59#include <pcmcia/cistpl.h> 60#include <pcmcia/cisreg.h> 61#include <pcmcia/bus_ops.h> 62#include "cs_internal.h" 63 64#ifdef CONFIG_PCI 65#define PCI_OPT " [pci]" 66#else 67#define PCI_OPT "" 68#endif 69#ifdef CONFIG_CARDBUS 70#define CB_OPT " [cardbus]" 71#else 72#define CB_OPT "" 73#endif 74#ifdef CONFIG_PM 75#define PM_OPT " [pm]" 76#else 77#define PM_OPT "" 78#endif 79#if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM) 80#define OPTIONS " none" 81#else 82#define OPTIONS PCI_OPT CB_OPT PM_OPT 83#endif 84 85static const char *release = "Linux Kernel Card Services " CS_RELEASE; 86static const char *options = "options: " OPTIONS; 87 88/*====================================================================*/ 89 90/* Module parameters */ 91 92MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 93MODULE_DESCRIPTION("Linux Kernel Card Services " CS_RELEASE 94 "\n options:" OPTIONS); 95MODULE_LICENSE("Dual MPL/GPL"); 96 97#define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i") 98 99INT_MODULE_PARM(setup_delay, 10); /* centiseconds */ 100INT_MODULE_PARM(resume_delay, 20); /* centiseconds */ 101INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */ 102INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */ 103INT_MODULE_PARM(reset_time, 10); /* usecs */ 104INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */ 105INT_MODULE_PARM(unreset_check, 10); /* centiseconds */ 106INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */ 107 108/* Access speed for attribute memory windows */ 109INT_MODULE_PARM(cis_speed, 300); /* ns */ 110 111/* Access speed for IO windows */ 112INT_MODULE_PARM(io_speed, 0); /* ns */ 113 114/* Optional features */ 115#ifdef CONFIG_PM 116INT_MODULE_PARM(do_apm, 1); 117#else 118INT_MODULE_PARM(do_apm, 0); 119#endif 120 121#ifdef PCMCIA_DEBUG 122INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG); 123static const char *version = 124"cs.c 1.279 2001/10/13 00:08:28 (David Hinds)"; 125#endif 126 127/*====================================================================*/ 128 129socket_state_t dead_socket = { 130 0, SS_DETECT, 0, 0, 0 131}; 132 133/* Table of sockets */ 134socket_t sockets = 0; 135socket_info_t *socket_table[MAX_SOCK]; 136 137#ifdef CONFIG_PROC_FS 138struct proc_dir_entry *proc_pccard = NULL; 139#endif 140 141/*====================================================================*/ 142 143/* String tables for error messages */ 144 145typedef struct lookup_t { 146 int key; 147 char *msg; 148} lookup_t; 149 150static const lookup_t error_table[] = { 151 { CS_SUCCESS, "Operation succeeded" }, 152 { CS_BAD_ADAPTER, "Bad adapter" }, 153 { CS_BAD_ATTRIBUTE, "Bad attribute", }, 154 { CS_BAD_BASE, "Bad base address" }, 155 { CS_BAD_EDC, "Bad EDC" }, 156 { CS_BAD_IRQ, "Bad IRQ" }, 157 { CS_BAD_OFFSET, "Bad offset" }, 158 { CS_BAD_PAGE, "Bad page number" }, 159 { CS_READ_FAILURE, "Read failure" }, 160 { CS_BAD_SIZE, "Bad size" }, 161 { CS_BAD_SOCKET, "Bad socket" }, 162 { CS_BAD_TYPE, "Bad type" }, 163 { CS_BAD_VCC, "Bad Vcc" }, 164 { CS_BAD_VPP, "Bad Vpp" }, 165 { CS_BAD_WINDOW, "Bad window" }, 166 { CS_WRITE_FAILURE, "Write failure" }, 167 { CS_NO_CARD, "No card present" }, 168 { CS_UNSUPPORTED_FUNCTION, "Usupported function" }, 169 { CS_UNSUPPORTED_MODE, "Unsupported mode" }, 170 { CS_BAD_SPEED, "Bad speed" }, 171 { CS_BUSY, "Resource busy" }, 172 { CS_GENERAL_FAILURE, "General failure" }, 173 { CS_WRITE_PROTECTED, "Write protected" }, 174 { CS_BAD_ARG_LENGTH, "Bad argument length" }, 175 { CS_BAD_ARGS, "Bad arguments" }, 176 { CS_CONFIGURATION_LOCKED, "Configuration locked" }, 177 { CS_IN_USE, "Resource in use" }, 178 { CS_NO_MORE_ITEMS, "No more items" }, 179 { CS_OUT_OF_RESOURCE, "Out of resource" }, 180 { CS_BAD_HANDLE, "Bad handle" }, 181 { CS_BAD_TUPLE, "Bad CIS tuple" } 182}; 183#define ERROR_COUNT (sizeof(error_table)/sizeof(lookup_t)) 184 185static const lookup_t service_table[] = { 186 { AccessConfigurationRegister, "AccessConfigurationRegister" }, 187 { AddSocketServices, "AddSocketServices" }, 188 { AdjustResourceInfo, "AdjustResourceInfo" }, 189 { CheckEraseQueue, "CheckEraseQueue" }, 190 { CloseMemory, "CloseMemory" }, 191 { DeregisterClient, "DeregisterClient" }, 192 { DeregisterEraseQueue, "DeregisterEraseQueue" }, 193 { GetCardServicesInfo, "GetCardServicesInfo" }, 194 { GetClientInfo, "GetClientInfo" }, 195 { GetConfigurationInfo, "GetConfigurationInfo" }, 196 { GetEventMask, "GetEventMask" }, 197 { GetFirstClient, "GetFirstClient" }, 198 { GetFirstRegion, "GetFirstRegion" }, 199 { GetFirstTuple, "GetFirstTuple" }, 200 { GetNextClient, "GetNextClient" }, 201 { GetNextRegion, "GetNextRegion" }, 202 { GetNextTuple, "GetNextTuple" }, 203 { GetStatus, "GetStatus" }, 204 { GetTupleData, "GetTupleData" }, 205 { MapMemPage, "MapMemPage" }, 206 { ModifyConfiguration, "ModifyConfiguration" }, 207 { ModifyWindow, "ModifyWindow" }, 208 { OpenMemory, "OpenMemory" }, 209 { ParseTuple, "ParseTuple" }, 210 { ReadMemory, "ReadMemory" }, 211 { RegisterClient, "RegisterClient" }, 212 { RegisterEraseQueue, "RegisterEraseQueue" }, 213 { RegisterMTD, "RegisterMTD" }, 214 { ReleaseConfiguration, "ReleaseConfiguration" }, 215 { ReleaseIO, "ReleaseIO" }, 216 { ReleaseIRQ, "ReleaseIRQ" }, 217 { ReleaseWindow, "ReleaseWindow" }, 218 { RequestConfiguration, "RequestConfiguration" }, 219 { RequestIO, "RequestIO" }, 220 { RequestIRQ, "RequestIRQ" }, 221 { RequestSocketMask, "RequestSocketMask" }, 222 { RequestWindow, "RequestWindow" }, 223 { ResetCard, "ResetCard" }, 224 { SetEventMask, "SetEventMask" }, 225 { ValidateCIS, "ValidateCIS" }, 226 { WriteMemory, "WriteMemory" }, 227 { BindDevice, "BindDevice" }, 228 { BindMTD, "BindMTD" }, 229 { ReportError, "ReportError" }, 230 { SuspendCard, "SuspendCard" }, 231 { ResumeCard, "ResumeCard" }, 232 { EjectCard, "EjectCard" }, 233 { InsertCard, "InsertCard" }, 234 { ReplaceCIS, "ReplaceCIS" } 235}; 236#define SERVICE_COUNT (sizeof(service_table)/sizeof(lookup_t)) 237 238/*====================================================================== 239 240 These functions are just shorthand for the actual low-level drivers 241 242======================================================================*/ 243 244static int register_callback(socket_info_t *s, void (*handler)(void *, unsigned int), void * info) 245{ 246 return s->ss_entry->register_callback(s->sock, handler, info); 247} 248 249static int get_socket_status(socket_info_t *s, int *val) 250{ 251 return s->ss_entry->get_status(s->sock, val); 252} 253 254static int set_socket(socket_info_t *s, socket_state_t *state) 255{ 256 return s->ss_entry->set_socket(s->sock, state); 257} 258 259static int set_io_map(socket_info_t *s, struct pccard_io_map *io) 260{ 261 return s->ss_entry->set_io_map(s->sock, io); 262} 263 264static int set_mem_map(socket_info_t *s, struct pccard_mem_map *mem) 265{ 266 return s->ss_entry->set_mem_map(s->sock, mem); 267} 268 269static int suspend_socket(socket_info_t *s) 270{ 271 s->socket = dead_socket; 272 return s->ss_entry->suspend(s->sock); 273} 274 275static int init_socket(socket_info_t *s) 276{ 277 s->socket = dead_socket; 278 return s->ss_entry->init(s->sock); 279} 280 281/*====================================================================*/ 282 283#if defined(CONFIG_PROC_FS) && defined(PCMCIA_DEBUG) 284static int proc_read_clients(char *buf, char **start, off_t pos, 285 int count, int *eof, void *data) 286{ 287 socket_info_t *s = data; 288 client_handle_t c; 289 char *p = buf; 290 291 for (c = s->clients; c; c = c->next) 292 p += sprintf(p, "fn %x: '%s' [attr 0x%04x] [state 0x%04x]\n", 293 c->Function, c->dev_info, c->Attributes, c->state); 294 return (p - buf); 295} 296#endif 297 298/*====================================================================== 299 300 Low-level PC Card interface drivers need to register with Card 301 Services using these calls. 302 303======================================================================*/ 304 305static int setup_socket(socket_info_t *); 306static void shutdown_socket(socket_info_t *); 307static void reset_socket(socket_info_t *); 308static void unreset_socket(socket_info_t *); 309static void parse_events(void *info, u_int events); 310 311socket_info_t *pcmcia_register_socket (int slot, 312 struct pccard_operations * ss_entry, 313 int use_bus_pm) 314{ 315 socket_info_t *s; 316 int i; 317 318 DEBUG(0, "cs: pcmcia_register_socket(0x%p)\n", ss_entry); 319 320 s = kmalloc(sizeof(struct socket_info_t), GFP_KERNEL); 321 if (!s) 322 return NULL; 323 memset(s, 0, sizeof(socket_info_t)); 324 325 s->ss_entry = ss_entry; 326 s->sock = slot; 327 328 /* base address = 0, map = 0 */ 329 s->cis_mem.flags = 0; 330 s->cis_mem.speed = cis_speed; 331 s->use_bus_pm = use_bus_pm; 332 s->erase_busy.next = s->erase_busy.prev = &s->erase_busy; 333 spin_lock_init(&s->lock); 334 335 for (i = 0; i < sockets; i++) 336 if (socket_table[i] == NULL) break; 337 socket_table[i] = s; 338 if (i == sockets) sockets++; 339 340 init_socket(s); 341 ss_entry->inquire_socket(slot, &s->cap); 342#ifdef CONFIG_PROC_FS 343 if (proc_pccard) { 344 char name[3]; 345 sprintf(name, "%02d", i); 346 s->proc = proc_mkdir(name, proc_pccard); 347 if (s->proc) 348 ss_entry->proc_setup(slot, s->proc); 349#ifdef PCMCIA_DEBUG 350 if (s->proc) 351 create_proc_read_entry("clients", 0, s->proc, 352 proc_read_clients, s); 353#endif 354 } 355#endif 356 return s; 357} /* pcmcia_register_socket */ 358 359int register_ss_entry(int nsock, struct pccard_operations * ss_entry) 360{ 361 int ns; 362 363 DEBUG(0, "cs: register_ss_entry(%d, 0x%p)\n", nsock, ss_entry); 364 365 for (ns = 0; ns < nsock; ns++) { 366 pcmcia_register_socket (ns, ss_entry, 0); 367 } 368 369 return 0; 370} /* register_ss_entry */ 371 372/*====================================================================*/ 373 374void pcmcia_unregister_socket(socket_info_t *s) 375{ 376 int j, socket = -1; 377 client_t *client; 378 379 for (j = 0; j < MAX_SOCK; j++) 380 if (socket_table [j] == s) { 381 socket = j; 382 break; 383 } 384 if (socket < 0) 385 return; 386 387#ifdef CONFIG_PROC_FS 388 if (proc_pccard) { 389 char name[3]; 390 sprintf(name, "%02d", socket); 391#ifdef PCMCIA_DEBUG 392 remove_proc_entry("clients", s->proc); 393#endif 394 remove_proc_entry(name, proc_pccard); 395 } 396#endif 397 398 shutdown_socket(s); 399 release_cis_mem(s); 400 while (s->clients) { 401 client = s->clients; 402 s->clients = s->clients->next; 403 kfree(client); 404 } 405 s->ss_entry = NULL; 406 kfree(s); 407 408 socket_table[socket] = NULL; 409 for (j = socket; j < sockets-1; j++) 410 socket_table[j] = socket_table[j+1]; 411 sockets--; 412} /* pcmcia_unregister_socket */ 413 414void unregister_ss_entry(struct pccard_operations * ss_entry) 415{ 416 int i; 417 418 for (i = sockets-1; i >= 0; i-- ) { 419 socket_info_t *socket = socket_table[i]; 420 if (socket->ss_entry == ss_entry) 421 pcmcia_unregister_socket (socket); 422 } 423} /* unregister_ss_entry */ 424 425/*====================================================================== 426 427 Shutdown_Socket() and setup_socket() are scheduled using add_timer 428 calls by the main event handler when card insertion and removal 429 events are received. Shutdown_Socket() unconfigures a socket and 430 turns off socket power. Setup_socket() turns on socket power 431 and resets the socket, in two stages. 432 433======================================================================*/ 434 435static void free_regions(memory_handle_t *list) 436{ 437 memory_handle_t tmp; 438 while (*list != NULL) { 439 tmp = *list; 440 *list = tmp->info.next; 441 tmp->region_magic = 0; 442 kfree(tmp); 443 } 444} 445 446static int send_event(socket_info_t *s, event_t event, int priority); 447 448/* 449 * Sleep for n_cs centiseconds (1 cs = 1/100th of a second) 450 */ 451static void cs_sleep(unsigned int n_cs) 452{ 453 current->state = TASK_INTERRUPTIBLE; 454 schedule_timeout( (n_cs * HZ + 99) / 100); 455} 456 457static void shutdown_socket(socket_info_t *s) 458{ 459 client_t **c; 460 461 DEBUG(1, "cs: shutdown_socket(%p)\n", s); 462 463 /* Blank out the socket state */ 464 s->state &= SOCKET_PRESENT|SOCKET_SETUP_PENDING; 465 init_socket(s); 466 s->irq.AssignedIRQ = s->irq.Config = 0; 467 s->lock_count = 0; 468 s->cis_used = 0; 469 if (s->fake_cis) { 470 kfree(s->fake_cis); 471 s->fake_cis = NULL; 472 } 473 /* Should not the socket be forced quiet as well? e.g. turn off Vcc */ 474 /* Without these changes, the socket is left hot, even though card-services */ 475 /* realizes that no card is in place. */ 476 s->socket.flags &= ~SS_OUTPUT_ENA; 477 s->socket.Vpp = 0; 478 s->socket.Vcc = 0; 479 s->socket.io_irq = 0; 480 set_socket(s, &s->socket); 481 /* */ 482#ifdef CONFIG_CARDBUS 483 cb_release_cis_mem(s); 484 cb_free(s); 485#endif 486 s->functions = 0; 487 if (s->config) { 488 kfree(s->config); 489 s->config = NULL; 490 } 491 for (c = &s->clients; *c; ) { 492 if ((*c)->state & CLIENT_UNBOUND) { 493 client_t *d = *c; 494 *c = (*c)->next; 495 kfree(d); 496 } else { 497 c = &((*c)->next); 498 } 499 } 500 free_regions(&s->a_region); 501 free_regions(&s->c_region); 502} /* shutdown_socket */ 503 504/* 505 * Return zero if we think the card isn't actually present 506 */ 507static int setup_socket(socket_info_t *s) 508{ 509 int val, ret; 510 int setup_timeout = 100; 511 512 /* Wait for "not pending" */ 513 for (;;) { 514 get_socket_status(s, &val); 515 if (!(val & SS_PENDING)) 516 break; 517 if (--setup_timeout) { 518 cs_sleep(10); 519 continue; 520 } 521 printk(KERN_NOTICE "cs: socket %p voltage interrogation" 522 " timed out\n", s); 523 ret = 0; 524 goto out; 525 } 526 527 if (val & SS_DETECT) { 528 DEBUG(1, "cs: setup_socket(%p): applying power\n", s); 529 s->state |= SOCKET_PRESENT; 530 s->socket.flags &= SS_DEBOUNCED; 531 if (val & SS_3VCARD) 532 s->socket.Vcc = s->socket.Vpp = 33; 533 else if (!(val & SS_XVCARD)) 534 s->socket.Vcc = s->socket.Vpp = 50; 535 else { 536 printk(KERN_NOTICE "cs: socket %p: unsupported " 537 "voltage key\n", s); 538 s->socket.Vcc = 0; 539 } 540 if (val & SS_CARDBUS) { 541 s->state |= SOCKET_CARDBUS; 542#ifndef CONFIG_CARDBUS 543 printk(KERN_NOTICE "cs: unsupported card type detected!\n"); 544#endif 545 } 546 set_socket(s, &s->socket); 547 cs_sleep(vcc_settle); 548 reset_socket(s); 549 ret = 1; 550 } else { 551 DEBUG(0, "cs: setup_socket(%p): no card!\n", s); 552 ret = 0; 553 } 554out: 555 return ret; 556} /* setup_socket */ 557 558/*====================================================================== 559 560 Reset_socket() and unreset_socket() handle hard resets. Resets 561 have several causes: card insertion, a call to reset_socket, or 562 recovery from a suspend/resume cycle. Unreset_socket() sends 563 a CS event that matches the cause of the reset. 564 565======================================================================*/ 566 567static void reset_socket(socket_info_t *s) 568{ 569 DEBUG(1, "cs: resetting socket %p\n", s); 570 s->socket.flags |= SS_OUTPUT_ENA | SS_RESET; 571 set_socket(s, &s->socket); 572 udelay((long)reset_time); 573 s->socket.flags &= ~SS_RESET; 574 set_socket(s, &s->socket); 575 cs_sleep(unreset_delay); 576 unreset_socket(s); 577} /* reset_socket */ 578 579#define EVENT_MASK \ 580(SOCKET_SETUP_PENDING|SOCKET_SUSPEND|SOCKET_RESET_PENDING) 581 582static void unreset_socket(socket_info_t *s) 583{ 584 int setup_timeout = unreset_limit; 585 int val; 586 587 /* Wait for "ready" */ 588 for (;;) { 589 get_socket_status(s, &val); 590 if (val & SS_READY) 591 break; 592 DEBUG(2, "cs: socket %d not ready yet\n", s->sock); 593 if (--setup_timeout) { 594 cs_sleep(unreset_check); 595 continue; 596 } 597 printk(KERN_NOTICE "cs: socket %p timed out during" 598 " reset. Try increasing setup_delay.\n", s); 599 s->state &= ~EVENT_MASK; 600 return; 601 } 602 603 DEBUG(1, "cs: reset done on socket %p\n", s); 604 if (s->state & SOCKET_SUSPEND) { 605 s->state &= ~EVENT_MASK; 606 if (verify_cis_cache(s) != 0) 607 parse_events(s, SS_DETECT); 608 else 609 send_event(s, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW); 610 } else if (s->state & SOCKET_SETUP_PENDING) { 611#ifdef CONFIG_CARDBUS 612 if (s->state & SOCKET_CARDBUS) 613 cb_alloc(s); 614#endif 615 send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); 616 s->state &= ~SOCKET_SETUP_PENDING; 617 } else { 618 send_event(s, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW); 619 if (s->reset_handle) { 620 s->reset_handle->event_callback_args.info = NULL; 621 EVENT(s->reset_handle, CS_EVENT_RESET_COMPLETE, 622 CS_EVENT_PRI_LOW); 623 } 624 s->state &= ~EVENT_MASK; 625 } 626} /* unreset_socket */ 627 628/*====================================================================== 629 630 The central event handler. Send_event() sends an event to all 631 valid clients. Parse_events() interprets the event bits from 632 a card status change report. Do_shutdown() handles the high 633 priority stuff associated with a card removal. 634 635======================================================================*/ 636 637static int send_event(socket_info_t *s, event_t event, int priority) 638{ 639 client_t *client = s->clients; 640 int ret; 641 DEBUG(1, "cs: send_event(sock %d, event %d, pri %d)\n", 642 s->sock, event, priority); 643 ret = 0; 644 for (; client; client = client->next) { 645 if (client->state & (CLIENT_UNBOUND|CLIENT_STALE)) 646 continue; 647 if (client->EventMask & event) { 648 ret = EVENT(client, event, priority); 649 if (ret != 0) 650 return ret; 651 } 652 } 653 return ret; 654} /* send_event */ 655 656static void do_shutdown(socket_info_t *s) 657{ 658 client_t *client; 659 if (s->state & SOCKET_SHUTDOWN_PENDING) 660 return; 661 s->state |= SOCKET_SHUTDOWN_PENDING; 662 send_event(s, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH); 663 for (client = s->clients; client; client = client->next) 664 if (!(client->Attributes & INFO_MASTER_CLIENT)) 665 client->state |= CLIENT_STALE; 666 if (s->state & (SOCKET_SETUP_PENDING|SOCKET_RESET_PENDING)) { 667 DEBUG(0, "cs: flushing pending setup\n"); 668 s->state &= ~EVENT_MASK; 669 } 670 cs_sleep(shutdown_delay); 671 s->state &= ~SOCKET_PRESENT; 672 shutdown_socket(s); 673} 674 675static void parse_events(void *info, u_int events) 676{ 677 socket_info_t *s = info; 678 if (events & SS_DETECT) { 679 int status; 680 681 get_socket_status(s, &status); 682 if ((s->state & SOCKET_PRESENT) && 683 (!(s->state & SOCKET_SUSPEND) || 684 !(status & SS_DETECT))) 685 do_shutdown(s); 686 if (status & SS_DETECT) { 687 if (s->state & SOCKET_SETUP_PENDING) { 688 DEBUG(1, "cs: delaying pending setup\n"); 689 return; 690 } 691 s->state |= SOCKET_SETUP_PENDING; 692 if (s->state & SOCKET_SUSPEND) 693 cs_sleep(resume_delay); 694 else 695 cs_sleep(setup_delay); 696 s->socket.flags |= SS_DEBOUNCED; 697 if (setup_socket(s) == 0) 698 s->state &= ~SOCKET_SETUP_PENDING; 699 s->socket.flags &= ~SS_DEBOUNCED; 700 } 701 } 702 if (events & SS_BATDEAD) 703 send_event(s, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW); 704 if (events & SS_BATWARN) 705 send_event(s, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW); 706 if (events & SS_READY) { 707 if (!(s->state & SOCKET_RESET_PENDING)) 708 send_event(s, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW); 709 else DEBUG(1, "cs: ready change during reset\n"); 710 } 711} /* parse_events */ 712 713/*====================================================================== 714 715 Another event handler, for power management events. 716 717 This does not comply with the latest PC Card spec for handling 718 power management events. 719 720======================================================================*/ 721 722void pcmcia_suspend_socket (socket_info_t *s) 723{ 724 if ((s->state & SOCKET_PRESENT) && !(s->state & SOCKET_SUSPEND)) { 725 send_event(s, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW); 726 suspend_socket(s); 727 s->state |= SOCKET_SUSPEND; 728 } 729} 730 731void pcmcia_resume_socket (socket_info_t *s) 732{ 733 int stat; 734 735 /* Do this just to reinitialize the socket */ 736 init_socket(s); 737 get_socket_status(s, &stat); 738 739 /* If there was or is a card here, we need to do something 740 about it... but parse_events will sort it all out. */ 741 if ((s->state & SOCKET_PRESENT) || (stat & SS_DETECT)) 742 parse_events(s, SS_DETECT); 743} 744 745static int handle_pm_event(struct pm_dev *dev, pm_request_t rqst, void *data) 746{ 747 int i; 748 socket_info_t *s; 749 750 /* only for busses that don't suspend/resume slots directly */ 751 752 switch (rqst) { 753 case PM_SUSPEND: 754 DEBUG(1, "cs: received suspend notification\n"); 755 for (i = 0; i < sockets; i++) { 756 s = socket_table [i]; 757 if (!s->use_bus_pm) 758 pcmcia_suspend_socket (socket_table [i]); 759 } 760 break; 761 case PM_RESUME: 762 DEBUG(1, "cs: received resume notification\n"); 763 for (i = 0; i < sockets; i++) { 764 s = socket_table [i]; 765 if (!s->use_bus_pm) 766 pcmcia_resume_socket (socket_table [i]); 767 } 768 break; 769 } 770 return 0; 771} /* handle_pm_event */ 772 773/*====================================================================== 774 775 Special stuff for managing IO windows, because they are scarce. 776 777======================================================================*/ 778 779static int alloc_io_space(socket_info_t *s, u_int attr, ioaddr_t *base, 780 ioaddr_t num, u_int lines, char *name) 781{ 782 int i; 783 ioaddr_t try, align; 784 785 align = (*base) ? (lines ? 1<<lines : 0) : 1; 786 if (align && (align < num)) { 787 if (*base) { 788 DEBUG(0, "odd IO request: num %04x align %04x\n", 789 num, align); 790 align = 0; 791 } else 792 while (align && (align < num)) align <<= 1; 793 } 794 if (*base & ~(align-1)) { 795 DEBUG(0, "odd IO request: base %04x align %04x\n", 796 *base, align); 797 align = 0; 798 } 799 if ((s->cap.features & SS_CAP_STATIC_MAP) && s->cap.io_offset) { 800 *base = s->cap.io_offset | (*base & 0x0fff); 801 return 0; 802 } 803 /* Check for an already-allocated window that must conflict with 804 what was asked for. It is a hack because it does not catch all 805 potential conflicts, just the most obvious ones. */ 806 for (i = 0; i < MAX_IO_WIN; i++) 807 if ((s->io[i].NumPorts != 0) && 808 ((s->io[i].BasePort & (align-1)) == *base)) 809 return 1; 810 for (i = 0; i < MAX_IO_WIN; i++) { 811 if (s->io[i].NumPorts == 0) { 812 if (find_io_region(base, num, align, name, s) == 0) { 813 s->io[i].Attributes = attr; 814 s->io[i].BasePort = *base; 815 s->io[i].NumPorts = s->io[i].InUse = num; 816 break; 817 } else 818 return 1; 819 } else if (s->io[i].Attributes != attr) 820 continue; 821 /* Try to extend top of window */ 822 try = s->io[i].BasePort + s->io[i].NumPorts; 823 if ((*base == 0) || (*base == try)) 824 if (find_io_region(&try, num, 0, name, s) == 0) { 825 *base = try; 826 s->io[i].NumPorts += num; 827 s->io[i].InUse += num; 828 break; 829 } 830 /* Try to extend bottom of window */ 831 try = s->io[i].BasePort - num; 832 if ((*base == 0) || (*base == try)) 833 if (find_io_region(&try, num, 0, name, s) == 0) { 834 s->io[i].BasePort = *base = try; 835 s->io[i].NumPorts += num; 836 s->io[i].InUse += num; 837 break; 838 } 839 } 840 return (i == MAX_IO_WIN); 841} /* alloc_io_space */ 842 843static void release_io_space(socket_info_t *s, ioaddr_t base, 844 ioaddr_t num) 845{ 846 int i; 847 if(!(s->cap.features & SS_CAP_STATIC_MAP)) 848 release_region(base, num); 849 for (i = 0; i < MAX_IO_WIN; i++) { 850 if ((s->io[i].BasePort <= base) && 851 (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) { 852 s->io[i].InUse -= num; 853 /* Free the window if no one else is using it */ 854 if (s->io[i].InUse == 0) 855 s->io[i].NumPorts = 0; 856 } 857 } 858} 859 860/*====================================================================== 861 862 Access_configuration_register() reads and writes configuration 863 registers in attribute memory. Memory window 0 is reserved for 864 this and the tuple reading services. 865 866======================================================================*/ 867 868int pcmcia_access_configuration_register(client_handle_t handle, 869 conf_reg_t *reg) 870{ 871 socket_info_t *s; 872 config_t *c; 873 int addr; 874 u_char val; 875 876 if (CHECK_HANDLE(handle)) 877 return CS_BAD_HANDLE; 878 s = SOCKET(handle); 879 if (handle->Function == BIND_FN_ALL) { 880 if (reg->Function >= s->functions) 881 return CS_BAD_ARGS; 882 c = &s->config[reg->Function]; 883 } else 884 c = CONFIG(handle); 885 if (!(c->state & CONFIG_LOCKED)) 886 return CS_CONFIGURATION_LOCKED; 887 888 addr = (c->ConfigBase + reg->Offset) >> 1; 889 890 switch (reg->Action) { 891 case CS_READ: 892 read_cis_mem(s, 1, addr, 1, &val); 893 reg->Value = val; 894 break; 895 case CS_WRITE: 896 val = reg->Value; 897 write_cis_mem(s, 1, addr, 1, &val); 898 break; 899 default: 900 return CS_BAD_ARGS; 901 break; 902 } 903 return CS_SUCCESS; 904} /* access_configuration_register */ 905 906/*====================================================================== 907 908 Bind_device() associates a device driver with a particular socket. 909 It is normally called by Driver Services after it has identified 910 a newly inserted card. An instance of that driver will then be 911 eligible to register as a client of this socket. 912 913======================================================================*/ 914 915int pcmcia_bind_device(bind_req_t *req) 916{ 917 client_t *client; 918 socket_info_t *s; 919 920 if (CHECK_SOCKET(req->Socket)) 921 return CS_BAD_SOCKET; 922 s = SOCKET(req); 923 924 client = (client_t *)kmalloc(sizeof(client_t), GFP_KERNEL); 925 if (!client) return CS_OUT_OF_RESOURCE; 926 memset(client, '\0', sizeof(client_t)); 927 client->client_magic = CLIENT_MAGIC; 928 strncpy(client->dev_info, (char *)req->dev_info, DEV_NAME_LEN); 929 client->Socket = req->Socket; 930 client->Function = req->Function; 931 client->state = CLIENT_UNBOUND; 932 client->erase_busy.next = &client->erase_busy; 933 client->erase_busy.prev = &client->erase_busy; 934 init_waitqueue_head(&client->mtd_req); 935 client->next = s->clients; 936 s->clients = client; 937 DEBUG(1, "cs: bind_device(): client 0x%p, sock %d, dev %s\n", 938 client, client->Socket, client->dev_info); 939 return CS_SUCCESS; 940} /* bind_device */ 941 942/*====================================================================== 943 944 Bind_mtd() associates a device driver with a particular memory 945 region. It is normally called by Driver Services after it has 946 identified a memory device type. An instance of the corresponding 947 driver will then be able to register to control this region. 948 949======================================================================*/ 950 951int pcmcia_bind_mtd(mtd_bind_t *req) 952{ 953 socket_info_t *s; 954 memory_handle_t region; 955 956 if (CHECK_SOCKET(req->Socket)) 957 return CS_BAD_SOCKET; 958 s = SOCKET(req); 959 960 if (req->Attributes & REGION_TYPE_AM) 961 region = s->a_region; 962 else 963 region = s->c_region; 964 965 while (region) { 966 if (region->info.CardOffset == req->CardOffset) break; 967 region = region->info.next; 968 } 969 if (!region || (region->mtd != NULL)) 970 return CS_BAD_OFFSET; 971 strncpy(region->dev_info, (char *)req->dev_info, DEV_NAME_LEN); 972 973 DEBUG(1, "cs: bind_mtd(): attr 0x%x, offset 0x%x, dev %s\n", 974 req->Attributes, req->CardOffset, (char *)req->dev_info); 975 return CS_SUCCESS; 976} /* bind_mtd */ 977 978/*====================================================================*/ 979 980int pcmcia_deregister_client(client_handle_t handle) 981{ 982 client_t **client; 983 socket_info_t *s; 984 memory_handle_t region; 985 u_long flags; 986 int i, sn; 987 988 DEBUG(1, "cs: deregister_client(%p)\n", handle); 989 if (CHECK_HANDLE(handle)) 990 return CS_BAD_HANDLE; 991 if (handle->state & 992 (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED)) 993 return CS_IN_USE; 994 for (i = 0; i < MAX_WIN; i++) 995 if (handle->state & CLIENT_WIN_REQ(i)) 996 return CS_IN_USE; 997 998 /* Disconnect all MTD links */ 999 s = SOCKET(handle); 1000 if (handle->mtd_count) { 1001 for (region = s->a_region; region; region = region->info.next) 1002 if (region->mtd == handle) region->mtd = NULL; 1003 for (region = s->c_region; region; region = region->info.next) 1004 if (region->mtd == handle) region->mtd = NULL; 1005 } 1006 1007 sn = handle->Socket; s = socket_table[sn]; 1008 1009 if ((handle->state & CLIENT_STALE) || 1010 (handle->Attributes & INFO_MASTER_CLIENT)) { 1011 spin_lock_irqsave(&s->lock, flags); 1012 client = &s->clients; 1013 while ((*client) && ((*client) != handle)) 1014 client = &(*client)->next; 1015 if (*client == NULL) { 1016 spin_unlock_irqrestore(&s->lock, flags); 1017 return CS_BAD_HANDLE; 1018 } 1019 *client = handle->next; 1020 handle->client_magic = 0; 1021 kfree(handle); 1022 spin_unlock_irqrestore(&s->lock, flags); 1023 } else { 1024 handle->state = CLIENT_UNBOUND; 1025 handle->mtd_count = 0; 1026 handle->event_handler = NULL; 1027 } 1028 1029 if (--s->real_clients == 0) 1030 register_callback(s, NULL, NULL); 1031 1032 return CS_SUCCESS; 1033} /* deregister_client */ 1034 1035/*====================================================================*/ 1036 1037int pcmcia_get_configuration_info(client_handle_t handle, 1038 config_info_t *config) 1039{ 1040 socket_info_t *s; 1041 config_t *c; 1042 1043 if (CHECK_HANDLE(handle)) 1044 return CS_BAD_HANDLE; 1045 s = SOCKET(handle); 1046 if (!(s->state & SOCKET_PRESENT)) 1047 return CS_NO_CARD; 1048 1049 if (handle->Function == BIND_FN_ALL) { 1050 if (config->Function && (config->Function >= s->functions)) 1051 return CS_BAD_ARGS; 1052 } else 1053 config->Function = handle->Function; 1054 1055#ifdef CONFIG_CARDBUS 1056 if (s->state & SOCKET_CARDBUS) { 1057 u_char fn = config->Function; 1058 memset(config, 0, sizeof(config_info_t)); 1059 config->Function = fn; 1060 config->Vcc = s->socket.Vcc; 1061 config->Vpp1 = config->Vpp2 = s->socket.Vpp; 1062 config->Option = s->cap.cb_dev->subordinate->number; 1063 if (s->cb_config) { 1064 config->Attributes = CONF_VALID_CLIENT; 1065 config->IntType = INT_CARDBUS; 1066 config->AssignedIRQ = s->irq.AssignedIRQ; 1067 if (config->AssignedIRQ) 1068 config->Attributes |= CONF_ENABLE_IRQ; 1069 config->BasePort1 = s->io[0].BasePort; 1070 config->NumPorts1 = s->io[0].NumPorts; 1071 } 1072 return CS_SUCCESS; 1073 } 1074#endif 1075 1076 c = (s->config != NULL) ? &s->config[config->Function] : NULL; 1077 1078 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) { 1079 config->Attributes = 0; 1080 config->Vcc = s->socket.Vcc; 1081 config->Vpp1 = config->Vpp2 = s->socket.Vpp; 1082 return CS_SUCCESS; 1083 } 1084 1085 /* !!! This is a hack !!! */ 1086 memcpy(&config->Attributes, &c->Attributes, sizeof(config_t)); 1087 config->Attributes |= CONF_VALID_CLIENT; 1088 config->CardValues = c->CardValues; 1089 config->IRQAttributes = c->irq.Attributes; 1090 config->AssignedIRQ = s->irq.AssignedIRQ; 1091 config->BasePort1 = c->io.BasePort1; 1092 config->NumPorts1 = c->io.NumPorts1; 1093 config->Attributes1 = c->io.Attributes1; 1094 config->BasePort2 = c->io.BasePort2; 1095 config->NumPorts2 = c->io.NumPorts2; 1096 config->Attributes2 = c->io.Attributes2; 1097 config->IOAddrLines = c->io.IOAddrLines; 1098 1099 return CS_SUCCESS; 1100} /* get_configuration_info */ 1101 1102/*====================================================================== 1103 1104 Return information about this version of Card Services. 1105 1106======================================================================*/ 1107 1108int pcmcia_get_card_services_info(servinfo_t *info) 1109{ 1110 info->Signature[0] = 'C'; 1111 info->Signature[1] = 'S'; 1112 info->Count = sockets; 1113 info->Revision = CS_RELEASE_CODE; 1114 info->CSLevel = 0x0210; 1115 info->VendorString = (char *)release; 1116 return CS_SUCCESS; 1117} /* get_card_services_info */ 1118 1119/*====================================================================== 1120 1121 Note that get_first_client() *does* recognize the Socket field 1122 in the request structure. 1123 1124======================================================================*/ 1125 1126int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req) 1127{ 1128 socket_t s; 1129 if (req->Attributes & CLIENT_THIS_SOCKET) 1130 s = req->Socket; 1131 else 1132 s = 0; 1133 if (CHECK_SOCKET(req->Socket)) 1134 return CS_BAD_SOCKET; 1135 if (socket_table[s]->clients == NULL) 1136 return CS_NO_MORE_ITEMS; 1137 *handle = socket_table[s]->clients; 1138 return CS_SUCCESS; 1139} /* get_first_client */ 1140 1141/*====================================================================*/ 1142 1143int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req) 1144{ 1145 socket_info_t *s; 1146 if ((handle == NULL) || CHECK_HANDLE(*handle)) 1147 return CS_BAD_HANDLE; 1148 if ((*handle)->next == NULL) { 1149 if (req->Attributes & CLIENT_THIS_SOCKET) 1150 return CS_NO_MORE_ITEMS; 1151 s = SOCKET(*handle); 1152 if (s->clients == NULL) 1153 return CS_NO_MORE_ITEMS; 1154 *handle = s->clients; 1155 } else 1156 *handle = (*handle)->next; 1157 return CS_SUCCESS; 1158} /* get_next_client */ 1159 1160/*====================================================================*/ 1161 1162int pcmcia_get_window(window_handle_t *handle, int idx, win_req_t *req) 1163{ 1164 socket_info_t *s; 1165 window_t *win; 1166 int w; 1167 1168 if (idx == 0) 1169 s = SOCKET((client_handle_t)*handle); 1170 else 1171 s = (*handle)->sock; 1172 if (!(s->state & SOCKET_PRESENT)) 1173 return CS_NO_CARD; 1174 for (w = idx; w < MAX_WIN; w++) 1175 if (s->state & SOCKET_WIN_REQ(w)) break; 1176 if (w == MAX_WIN) 1177 return CS_NO_MORE_ITEMS; 1178 win = &s->win[w]; 1179 req->Base = win->ctl.sys_start; 1180 req->Size = win->ctl.sys_stop - win->ctl.sys_start + 1; 1181 req->AccessSpeed = win->ctl.speed; 1182 req->Attributes = 0; 1183 if (win->ctl.flags & MAP_ATTRIB) 1184 req->Attributes |= WIN_MEMORY_TYPE_AM; 1185 if (win->ctl.flags & MAP_ACTIVE) 1186 req->Attributes |= WIN_ENABLE; 1187 if (win->ctl.flags & MAP_16BIT) 1188 req->Attributes |= WIN_DATA_WIDTH_16; 1189 if (win->ctl.flags & MAP_USE_WAIT) 1190 req->Attributes |= WIN_USE_WAIT; 1191 *handle = win; 1192 return CS_SUCCESS; 1193} /* get_window */ 1194 1195int pcmcia_get_first_window(window_handle_t *win, win_req_t *req) 1196{ 1197 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC)) 1198 return CS_BAD_HANDLE; 1199 return pcmcia_get_window(win, 0, req); 1200} 1201 1202int pcmcia_get_next_window(window_handle_t *win, win_req_t *req) 1203{ 1204 if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC)) 1205 return CS_BAD_HANDLE; 1206 return pcmcia_get_window(win, (*win)->index+1, req); 1207} 1208 1209/*===================================================================== 1210 1211 Return the PCI device associated with a card.. 1212 1213======================================================================*/ 1214 1215#ifdef CONFIG_CARDBUS 1216 1217struct pci_bus *pcmcia_lookup_bus(client_handle_t handle) 1218{ 1219 socket_info_t *s; 1220 1221 if (CHECK_HANDLE(handle)) 1222 return NULL; 1223 s = SOCKET(handle); 1224 if (!(s->state & SOCKET_CARDBUS)) 1225 return NULL; 1226 1227 return s->cap.cb_dev->subordinate; 1228} 1229 1230EXPORT_SYMBOL(pcmcia_lookup_bus); 1231 1232#endif 1233 1234/*====================================================================== 1235 1236 Get the current socket state bits. We don't support the latched 1237 SocketState yet: I haven't seen any point for it. 1238 1239======================================================================*/ 1240 1241int pcmcia_get_status(client_handle_t handle, cs_status_t *status) 1242{ 1243 socket_info_t *s; 1244 config_t *c; 1245 int val; 1246 1247 if (CHECK_HANDLE(handle)) 1248 return CS_BAD_HANDLE; 1249 s = SOCKET(handle); 1250 get_socket_status(s, &val); 1251 status->CardState = status->SocketState = 0; 1252 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0; 1253 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0; 1254 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0; 1255 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0; 1256 if (s->state & SOCKET_SUSPEND) 1257 status->CardState |= CS_EVENT_PM_SUSPEND; 1258 if (!(s->state & SOCKET_PRESENT)) 1259 return CS_NO_CARD; 1260 if (s->state & SOCKET_SETUP_PENDING) 1261 status->CardState |= CS_EVENT_CARD_INSERTION; 1262 1263 /* Get info from the PRR, if necessary */ 1264 if (handle->Function == BIND_FN_ALL) { 1265 if (status->Function && (status->Function >= s->functions)) 1266 return CS_BAD_ARGS; 1267 c = (s->config != NULL) ? &s->config[status->Function] : NULL; 1268 } else 1269 c = CONFIG(handle); 1270 if ((c != NULL) && (c->state & CONFIG_LOCKED) && 1271 (c->IntType & (INT_MEMORY_AND_IO|INT_ZOOMED_VIDEO))) { 1272 u_char reg; 1273 if (c->Present & PRESENT_PIN_REPLACE) { 1274 read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®); 1275 status->CardState |= 1276 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0; 1277 status->CardState |= 1278 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0; 1279 status->CardState |= 1280 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0; 1281 status->CardState |= 1282 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0; 1283 } else { 1284 /* No PRR? Then assume we're always ready */ 1285 status->CardState |= CS_EVENT_READY_CHANGE; 1286 } 1287 if (c->Present & PRESENT_EXT_STATUS) { 1288 read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®); 1289 status->CardState |= 1290 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0; 1291 } 1292 return CS_SUCCESS; 1293 } 1294 status->CardState |= 1295 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0; 1296 status->CardState |= 1297 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0; 1298 status->CardState |= 1299 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0; 1300 status->CardState |= 1301 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0; 1302 return CS_SUCCESS; 1303} /* get_status */ 1304 1305/*====================================================================== 1306 1307 Change the card address of an already open memory window. 1308 1309======================================================================*/ 1310 1311int pcmcia_get_mem_page(window_handle_t win, memreq_t *req) 1312{ 1313 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 1314 return CS_BAD_HANDLE; 1315 req->Page = 0; 1316 req->CardOffset = win->ctl.card_start; 1317 return CS_SUCCESS; 1318} /* get_mem_page */ 1319 1320int pcmcia_map_mem_page(window_handle_t win, memreq_t *req) 1321{ 1322 socket_info_t *s; 1323 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 1324 return CS_BAD_HANDLE; 1325 if (req->Page != 0) 1326 return CS_BAD_PAGE; 1327 s = win->sock; 1328 win->ctl.card_start = req->CardOffset; 1329 if (set_mem_map(s, &win->ctl) != 0) 1330 return CS_BAD_OFFSET; 1331 return CS_SUCCESS; 1332} /* map_mem_page */ 1333 1334/*====================================================================== 1335 1336 Modify a locked socket configuration 1337 1338======================================================================*/ 1339 1340int pcmcia_modify_configuration(client_handle_t handle, 1341 modconf_t *mod) 1342{ 1343 socket_info_t *s; 1344 config_t *c; 1345 1346 if (CHECK_HANDLE(handle)) 1347 return CS_BAD_HANDLE; 1348 s = SOCKET(handle); c = CONFIG(handle); 1349 if (!(s->state & SOCKET_PRESENT)) 1350 return CS_NO_CARD; 1351 if (!(c->state & CONFIG_LOCKED)) 1352 return CS_CONFIGURATION_LOCKED; 1353 1354 if (mod->Attributes & CONF_IRQ_CHANGE_VALID) { 1355 if (mod->Attributes & CONF_ENABLE_IRQ) { 1356 c->Attributes |= CONF_ENABLE_IRQ; 1357 s->socket.io_irq = s->irq.AssignedIRQ; 1358 } else { 1359 c->Attributes &= ~CONF_ENABLE_IRQ; 1360 s->socket.io_irq = 0; 1361 } 1362 set_socket(s, &s->socket); 1363 } 1364 1365 if (mod->Attributes & CONF_VCC_CHANGE_VALID) 1366 return CS_BAD_VCC; 1367 1368 /* We only allow changing Vpp1 and Vpp2 to the same value */ 1369 if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) && 1370 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) { 1371 if (mod->Vpp1 != mod->Vpp2) 1372 return CS_BAD_VPP; 1373 c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1; 1374 if (set_socket(s, &s->socket)) 1375 return CS_BAD_VPP; 1376 } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) || 1377 (mod->Attributes & CONF_VPP2_CHANGE_VALID)) 1378 return CS_BAD_VPP; 1379 1380 return CS_SUCCESS; 1381} /* modify_configuration */ 1382 1383/*====================================================================== 1384 1385 Modify the attributes of a window returned by RequestWindow. 1386 1387======================================================================*/ 1388 1389int pcmcia_modify_window(window_handle_t win, modwin_t *req) 1390{ 1391 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 1392 return CS_BAD_HANDLE; 1393 1394 win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE); 1395 if (req->Attributes & WIN_MEMORY_TYPE) 1396 win->ctl.flags |= MAP_ATTRIB; 1397 if (req->Attributes & WIN_ENABLE) 1398 win->ctl.flags |= MAP_ACTIVE; 1399 if (req->Attributes & WIN_DATA_WIDTH_16) 1400 win->ctl.flags |= MAP_16BIT; 1401 if (req->Attributes & WIN_USE_WAIT) 1402 win->ctl.flags |= MAP_USE_WAIT; 1403 win->ctl.speed = req->AccessSpeed; 1404 set_mem_map(win->sock, &win->ctl); 1405 1406 return CS_SUCCESS; 1407} /* modify_window */ 1408 1409/*====================================================================== 1410 1411 Register_client() uses the dev_info_t handle to match the 1412 caller with a socket. The driver must have already been bound 1413 to a socket with bind_device() -- in fact, bind_device() 1414 allocates the client structure that will be used. 1415 1416======================================================================*/ 1417 1418int pcmcia_register_client(client_handle_t *handle, client_reg_t *req) 1419{ 1420 client_t *client; 1421 socket_info_t *s; 1422 socket_t ns; 1423 1424 /* Look for unbound client with matching dev_info */ 1425 client = NULL; 1426 for (ns = 0; ns < sockets; ns++) { 1427 client = socket_table[ns]->clients; 1428 while (client != NULL) { 1429 if ((strcmp(client->dev_info, (char *)req->dev_info) == 0) 1430 && (client->state & CLIENT_UNBOUND)) break; 1431 client = client->next; 1432 } 1433 if (client != NULL) break; 1434 } 1435 if (client == NULL) 1436 return CS_OUT_OF_RESOURCE; 1437 1438 s = socket_table[ns]; 1439 if (++s->real_clients == 1) { 1440 int status; 1441 register_callback(s, &parse_events, s); 1442 get_socket_status(s, &status); 1443 if ((status & SS_DETECT) && 1444 !(s->state & SOCKET_SETUP_PENDING)) { 1445 s->state |= SOCKET_SETUP_PENDING; 1446 if (setup_socket(s) == 0) 1447 s->state &= ~SOCKET_SETUP_PENDING; 1448 } 1449 } 1450 1451 *handle = client; 1452 client->state &= ~CLIENT_UNBOUND; 1453 client->Socket = ns; 1454 client->Attributes = req->Attributes; 1455 client->EventMask = req->EventMask; 1456 client->event_handler = req->event_handler; 1457 client->event_callback_args = req->event_callback_args; 1458 client->event_callback_args.client_handle = client; 1459 client->event_callback_args.bus = s->cap.bus; 1460 1461 if (s->state & SOCKET_CARDBUS) 1462 client->state |= CLIENT_CARDBUS; 1463 1464 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) && 1465 (client->Function != BIND_FN_ALL)) { 1466 cistpl_longlink_mfc_t mfc; 1467 if (read_tuple(client, CISTPL_LONGLINK_MFC, &mfc) 1468 == CS_SUCCESS) 1469 s->functions = mfc.nfn; 1470 else 1471 s->functions = 1; 1472 s->config = kmalloc(sizeof(config_t) * s->functions, 1473 GFP_KERNEL); 1474 if (!s->config) 1475 return CS_OUT_OF_RESOURCE; 1476 memset(s->config, 0, sizeof(config_t) * s->functions); 1477 } 1478 1479 DEBUG(1, "cs: register_client(): client 0x%p, sock %d, dev %s\n", 1480 client, client->Socket, client->dev_info); 1481 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE) 1482 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW); 1483 if ((socket_table[ns]->state & SOCKET_PRESENT) && 1484 !(socket_table[ns]->state & SOCKET_SETUP_PENDING)) { 1485 if (client->EventMask & CS_EVENT_CARD_INSERTION) 1486 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); 1487 else 1488 client->PendingEvents |= CS_EVENT_CARD_INSERTION; 1489 } 1490 return CS_SUCCESS; 1491} /* register_client */ 1492 1493/*====================================================================*/ 1494 1495int pcmcia_release_configuration(client_handle_t handle) 1496{ 1497 pccard_io_map io = { 0, 0, 0, 0, 1 }; 1498 socket_info_t *s; 1499 int i; 1500 1501 if (CHECK_HANDLE(handle) || 1502 !(handle->state & CLIENT_CONFIG_LOCKED)) 1503 return CS_BAD_HANDLE; 1504 handle->state &= ~CLIENT_CONFIG_LOCKED; 1505 s = SOCKET(handle); 1506 1507#ifdef CONFIG_CARDBUS 1508 if (handle->state & CLIENT_CARDBUS) { 1509 cb_disable(s); 1510 s->lock_count = 0; 1511 return CS_SUCCESS; 1512 } 1513#endif 1514 1515 if (!(handle->state & CLIENT_STALE)) { 1516 config_t *c = CONFIG(handle); 1517 if (--(s->lock_count) == 0) { 1518 s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */ 1519 s->socket.Vpp = 0; 1520 s->socket.io_irq = 0; 1521 set_socket(s, &s->socket); 1522 } 1523 if (c->state & CONFIG_IO_REQ) 1524 for (i = 0; i < MAX_IO_WIN; i++) { 1525 if (s->io[i].NumPorts == 0) 1526 continue; 1527 s->io[i].Config--; 1528 if (s->io[i].Config != 0) 1529 continue; 1530 io.map = i; 1531 set_io_map(s, &io); 1532 } 1533 c->state &= ~CONFIG_LOCKED; 1534 } 1535 1536 return CS_SUCCESS; 1537} /* release_configuration */ 1538 1539/*====================================================================== 1540 1541 Release_io() releases the I/O ranges allocated by a client. This 1542 may be invoked some time after a card ejection has already dumped 1543 the actual socket configuration, so if the client is "stale", we 1544 don't bother checking the port ranges against the current socket 1545 values. 1546 1547======================================================================*/ 1548 1549int pcmcia_release_io(client_handle_t handle, io_req_t *req) 1550{ 1551 socket_info_t *s; 1552 1553 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ)) 1554 return CS_BAD_HANDLE; 1555 handle->state &= ~CLIENT_IO_REQ; 1556 s = SOCKET(handle); 1557 1558#ifdef CONFIG_CARDBUS 1559 if (handle->state & CLIENT_CARDBUS) { 1560 cb_release(s); 1561 return CS_SUCCESS; 1562 } 1563#endif 1564 1565 if (!(handle->state & CLIENT_STALE)) { 1566 config_t *c = CONFIG(handle); 1567 if (c->state & CONFIG_LOCKED) 1568 return CS_CONFIGURATION_LOCKED; 1569 if ((c->io.BasePort1 != req->BasePort1) || 1570 (c->io.NumPorts1 != req->NumPorts1) || 1571 (c->io.BasePort2 != req->BasePort2) || 1572 (c->io.NumPorts2 != req->NumPorts2)) 1573 return CS_BAD_ARGS; 1574 c->state &= ~CONFIG_IO_REQ; 1575 } 1576 1577 release_io_space(s, req->BasePort1, req->NumPorts1); 1578 if (req->NumPorts2) 1579 release_io_space(s, req->BasePort2, req->NumPorts2); 1580 1581 return CS_SUCCESS; 1582} /* release_io */ 1583 1584/*====================================================================*/ 1585 1586int pcmcia_release_irq(client_handle_t handle, irq_req_t *req) 1587{ 1588 socket_info_t *s; 1589 if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ)) 1590 return CS_BAD_HANDLE; 1591 handle->state &= ~CLIENT_IRQ_REQ; 1592 s = SOCKET(handle); 1593 1594 if (!(handle->state & CLIENT_STALE)) { 1595 config_t *c = CONFIG(handle); 1596 if (c->state & CONFIG_LOCKED) 1597 return CS_CONFIGURATION_LOCKED; 1598 if (c->irq.Attributes != req->Attributes) 1599 return CS_BAD_ATTRIBUTE; 1600 if (s->irq.AssignedIRQ != req->AssignedIRQ) 1601 return CS_BAD_IRQ; 1602 if (--s->irq.Config == 0) { 1603 c->state &= ~CONFIG_IRQ_REQ; 1604 s->irq.AssignedIRQ = 0; 1605 } 1606 } 1607 1608 if (req->Attributes & IRQ_HANDLE_PRESENT) { 1609 bus_free_irq(s->cap.bus, req->AssignedIRQ, req->Instance); 1610 } 1611 1612#ifdef CONFIG_ISA 1613 if (req->AssignedIRQ != s->cap.pci_irq) 1614 undo_irq(req->Attributes, req->AssignedIRQ); 1615#endif 1616 1617 return CS_SUCCESS; 1618} /* cs_release_irq */ 1619 1620/*====================================================================*/ 1621 1622int pcmcia_release_window(window_handle_t win) 1623{ 1624 socket_info_t *s; 1625 1626 if ((win == NULL) || (win->magic != WINDOW_MAGIC)) 1627 return CS_BAD_HANDLE; 1628 s = win->sock; 1629 if (!(win->handle->state & CLIENT_WIN_REQ(win->index))) 1630 return CS_BAD_HANDLE; 1631 1632 /* Shut down memory window */ 1633 win->ctl.flags &= ~MAP_ACTIVE; 1634 set_mem_map(s, &win->ctl); 1635 s->state &= ~SOCKET_WIN_REQ(win->index); 1636 1637 /* Release system memory */ 1638 if(!(s->cap.features & SS_CAP_STATIC_MAP)) 1639 release_mem_region(win->base, win->size); 1640 win->handle->state &= ~CLIENT_WIN_REQ(win->index); 1641 1642 win->magic = 0; 1643 1644 return CS_SUCCESS; 1645} /* release_window */ 1646 1647/*====================================================================*/ 1648 1649int pcmcia_request_configuration(client_handle_t handle, 1650 config_req_t *req) 1651{ 1652 int i; 1653 u_int base; 1654 socket_info_t *s; 1655 config_t *c; 1656 pccard_io_map iomap; 1657 1658 if (CHECK_HANDLE(handle)) 1659 return CS_BAD_HANDLE; 1660 i = handle->Socket; s = socket_table[i]; 1661 if (!(s->state & SOCKET_PRESENT)) 1662 return CS_NO_CARD; 1663 1664#ifdef CONFIG_CARDBUS 1665 if (handle->state & CLIENT_CARDBUS) { 1666 if (!(req->IntType & INT_CARDBUS)) 1667 return CS_UNSUPPORTED_MODE; 1668 if (s->lock_count != 0) 1669 return CS_CONFIGURATION_LOCKED; 1670 cb_enable(s); 1671 handle->state |= CLIENT_CONFIG_LOCKED; 1672 s->lock_count++; 1673 return CS_SUCCESS; 1674 } 1675#endif 1676 1677 if (req->IntType & INT_CARDBUS) 1678 return CS_UNSUPPORTED_MODE; 1679 c = CONFIG(handle); 1680 if (c->state & CONFIG_LOCKED) 1681 return CS_CONFIGURATION_LOCKED; 1682 1683 /* Do power control. We don't allow changes in Vcc. */ 1684 if (s->socket.Vcc != req->Vcc) 1685 return CS_BAD_VCC; 1686 if (req->Vpp1 != req->Vpp2) 1687 return CS_BAD_VPP; 1688 s->socket.Vpp = req->Vpp1; 1689 if (set_socket(s, &s->socket)) 1690 return CS_BAD_VPP; 1691 1692 c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1; 1693 1694 /* Pick memory or I/O card, DMA mode, interrupt */ 1695 c->IntType = req->IntType; 1696 c->Attributes = req->Attributes; 1697 if (req->IntType & INT_MEMORY_AND_IO) 1698 s->socket.flags |= SS_IOCARD; 1699 if (req->IntType & INT_ZOOMED_VIDEO) 1700 s->socket.flags |= SS_ZVCARD|SS_IOCARD; 1701 if (req->Attributes & CONF_ENABLE_DMA) 1702 s->socket.flags |= SS_DMA_MODE; 1703 if (req->Attributes & CONF_ENABLE_SPKR) 1704 s->socket.flags |= SS_SPKR_ENA; 1705 if (req->Attributes & CONF_ENABLE_IRQ) 1706 s->socket.io_irq = s->irq.AssignedIRQ; 1707 else 1708 s->socket.io_irq = 0; 1709 set_socket(s, &s->socket); 1710 s->lock_count++; 1711 1712 /* Set up CIS configuration registers */ 1713 base = c->ConfigBase = req->ConfigBase; 1714 c->Present = c->CardValues = req->Present; 1715 if (req->Present & PRESENT_COPY) { 1716 c->Copy = req->Copy; 1717 write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy); 1718 } 1719 if (req->Present & PRESENT_OPTION) { 1720 if (s->functions == 1) { 1721 c->Option = req->ConfigIndex & COR_CONFIG_MASK; 1722 } else { 1723 c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK; 1724 c->Option |= COR_FUNC_ENA|COR_IREQ_ENA; 1725 if (req->Present & PRESENT_IOBASE_0) 1726 c->Option |= COR_ADDR_DECODE; 1727 } 1728 if (c->state & CONFIG_IRQ_REQ) 1729 if (!(c->irq.Attributes & IRQ_FORCED_PULSE)) 1730 c->Option |= COR_LEVEL_REQ; 1731 write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option); 1732 mdelay(40); 1733 } 1734 if (req->Present & PRESENT_STATUS) { 1735 c->Status = req->Status; 1736 write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status); 1737 } 1738 if (req->Present & PRESENT_PIN_REPLACE) { 1739 c->Pin = req->Pin; 1740 write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin); 1741 } 1742 if (req->Present & PRESENT_EXT_STATUS) { 1743 c->ExtStatus = req->ExtStatus; 1744 write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus); 1745 } 1746 if (req->Present & PRESENT_IOBASE_0) { 1747 u_char b = c->io.BasePort1 & 0xff; 1748 write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b); 1749 b = (c->io.BasePort1 >> 8) & 0xff; 1750 write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b); 1751 } 1752 if (req->Present & PRESENT_IOSIZE) { 1753 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1; 1754 write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b); 1755 } 1756 1757 /* Configure I/O windows */ 1758 if (c->state & CONFIG_IO_REQ) { 1759 iomap.speed = io_speed; 1760 for (i = 0; i < MAX_IO_WIN; i++) 1761 if (s->io[i].NumPorts != 0) { 1762 iomap.map = i; 1763 iomap.flags = MAP_ACTIVE; 1764 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) { 1765 case IO_DATA_PATH_WIDTH_16: 1766 iomap.flags |= MAP_16BIT; break; 1767 case IO_DATA_PATH_WIDTH_AUTO: 1768 iomap.flags |= MAP_AUTOSZ; break; 1769 default: 1770 break; 1771 } 1772 iomap.start = s->io[i].BasePort; 1773 iomap.stop = iomap.start + s->io[i].NumPorts - 1; 1774 set_io_map(s, &iomap); 1775 s->io[i].Config++; 1776 } 1777 } 1778 1779 c->state |= CONFIG_LOCKED; 1780 handle->state |= CLIENT_CONFIG_LOCKED; 1781 return CS_SUCCESS; 1782} /* request_configuration */ 1783 1784/*====================================================================== 1785 1786 Request_io() reserves ranges of port addresses for a socket. 1787 I have not implemented range sharing or alias addressing. 1788 1789======================================================================*/ 1790 1791int pcmcia_request_io(client_handle_t handle, io_req_t *req) 1792{ 1793 socket_info_t *s; 1794 config_t *c; 1795 1796 if (CHECK_HANDLE(handle)) 1797 return CS_BAD_HANDLE; 1798 s = SOCKET(handle); 1799 if (!(s->state & SOCKET_PRESENT)) 1800 return CS_NO_CARD; 1801 1802 if (handle->state & CLIENT_CARDBUS) { 1803#ifdef CONFIG_CARDBUS 1804 int ret = cb_config(s); 1805 if (ret == CS_SUCCESS) 1806 handle->state |= CLIENT_IO_REQ; 1807 return ret; 1808#else 1809 return CS_UNSUPPORTED_FUNCTION; 1810#endif 1811 } 1812 1813 if (!req) 1814 return CS_UNSUPPORTED_MODE; 1815 c = CONFIG(handle); 1816 if (c->state & CONFIG_LOCKED) 1817 return CS_CONFIGURATION_LOCKED; 1818 if (c->state & CONFIG_IO_REQ) 1819 return CS_IN_USE; 1820 if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)) 1821 return CS_BAD_ATTRIBUTE; 1822 if ((req->NumPorts2 > 0) && 1823 (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))) 1824 return CS_BAD_ATTRIBUTE; 1825 1826 if (alloc_io_space(s, req->Attributes1, &req->BasePort1, 1827 req->NumPorts1, req->IOAddrLines, 1828 handle->dev_info)) 1829 return CS_IN_USE; 1830 1831 if (req->NumPorts2) { 1832 if (alloc_io_space(s, req->Attributes2, &req->BasePort2, 1833 req->NumPorts2, req->IOAddrLines, 1834 handle->dev_info)) { 1835 release_io_space(s, req->BasePort1, req->NumPorts1); 1836 return CS_IN_USE; 1837 } 1838 } 1839 1840 c->io = *req; 1841 c->state |= CONFIG_IO_REQ; 1842 handle->state |= CLIENT_IO_REQ; 1843 return CS_SUCCESS; 1844} /* request_io */ 1845 1846/*====================================================================== 1847 1848 Request_irq() reserves an irq for this client. 1849 1850 Also, since Linux only reserves irq's when they are actually 1851 hooked, we don't guarantee that an irq will still be available 1852 when the configuration is locked. Now that I think about it, 1853 there might be a way to fix this using a dummy handler. 1854 1855======================================================================*/ 1856 1857int pcmcia_request_irq(client_handle_t handle, irq_req_t *req) 1858{ 1859 socket_info_t *s; 1860 config_t *c; 1861 int ret = 0, irq = 0; 1862 1863 if (CHECK_HANDLE(handle)) 1864 return CS_BAD_HANDLE; 1865 s = SOCKET(handle); 1866 if (!(s->state & SOCKET_PRESENT)) 1867 return CS_NO_CARD; 1868 c = CONFIG(handle); 1869 if (c->state & CONFIG_LOCKED) 1870 return CS_CONFIGURATION_LOCKED; 1871 if (c->state & CONFIG_IRQ_REQ) 1872 return CS_IN_USE; 1873 1874 /* Short cut: if there are no ISA interrupts, then it is PCI */ 1875 if (!s->cap.irq_mask) { 1876 irq = s->cap.pci_irq; 1877 ret = (irq) ? 0 : CS_IN_USE; 1878#ifdef CONFIG_ISA 1879 } else if (s->irq.AssignedIRQ != 0) { 1880 /* If the interrupt is already assigned, it must match */ 1881 irq = s->irq.AssignedIRQ; 1882 if (req->IRQInfo1 & IRQ_INFO2_VALID) { 1883 u_int mask = req->IRQInfo2 & s->cap.irq_mask; 1884 ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS; 1885 } else 1886 ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS; 1887 } else { 1888 ret = CS_IN_USE; 1889 if (req->IRQInfo1 & IRQ_INFO2_VALID) { 1890 u_int try, mask = req->IRQInfo2 & s->cap.irq_mask; 1891 for (try = 0; try < 2; try++) { 1892 for (irq = 0; irq < 32; irq++) 1893 if ((mask >> irq) & 1) { 1894 ret = try_irq(req->Attributes, irq, try); 1895 if (ret == 0) break; 1896 } 1897 if (ret == 0) break; 1898 } 1899 } else { 1900 irq = req->IRQInfo1 & IRQ_MASK; 1901 ret = try_irq(req->Attributes, irq, 1); 1902 } 1903#endif 1904 } 1905 if (ret != 0) return ret; 1906 1907 if (req->Attributes & IRQ_HANDLE_PRESENT) { 1908 if (bus_request_irq(s->cap.bus, irq, req->Handler, 1909 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) || 1910 (s->functions > 1) || 1911 (irq == s->cap.pci_irq)) ? SA_SHIRQ : 0, 1912 handle->dev_info, req->Instance)) 1913 return CS_IN_USE; 1914 } 1915 1916 c->irq.Attributes = req->Attributes; 1917 s->irq.AssignedIRQ = req->AssignedIRQ = irq; 1918 s->irq.Config++; 1919 1920 c->state |= CONFIG_IRQ_REQ; 1921 handle->state |= CLIENT_IRQ_REQ; 1922 return CS_SUCCESS; 1923} /* pcmcia_request_irq */ 1924 1925/*====================================================================== 1926 1927 Request_window() establishes a mapping between card memory space 1928 and system memory space. 1929 1930======================================================================*/ 1931 1932int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh) 1933{ 1934 socket_info_t *s; 1935 window_t *win; 1936 u_long align; 1937 int w; 1938 1939 if (CHECK_HANDLE(*handle)) 1940 return CS_BAD_HANDLE; 1941 s = SOCKET(*handle); 1942 if (!(s->state & SOCKET_PRESENT)) 1943 return CS_NO_CARD; 1944 if (req->Attributes & (WIN_PAGED | WIN_SHARED)) 1945 return CS_BAD_ATTRIBUTE; 1946 1947 /* Window size defaults to smallest available */ 1948 if (req->Size == 0) 1949 req->Size = s->cap.map_size; 1950 align = (((s->cap.features & SS_CAP_MEM_ALIGN) || 1951 (req->Attributes & WIN_STRICT_ALIGN)) ? 1952 req->Size : s->cap.map_size); 1953 if (req->Size & (s->cap.map_size-1)) 1954 return CS_BAD_SIZE; 1955 if ((req->Base && (s->cap.features & SS_CAP_STATIC_MAP)) || 1956 (req->Base & (align-1))) 1957 return CS_BAD_BASE; 1958 if (req->Base) 1959 align = 0; 1960 1961 /* Allocate system memory window */ 1962 for (w = 0; w < MAX_WIN; w++) 1963 if (!(s->state & SOCKET_WIN_REQ(w))) break; 1964 if (w == MAX_WIN) 1965 return CS_OUT_OF_RESOURCE; 1966 1967 win = &s->win[w]; 1968 win->magic = WINDOW_MAGIC; 1969 win->index = w; 1970 win->handle = *handle; 1971 win->sock = s; 1972 win->base = req->Base; 1973 win->size = req->Size; 1974 1975 if (!(s->cap.features & SS_CAP_STATIC_MAP) && 1976 find_mem_region(&win->base, win->size, align, 1977 (req->Attributes & WIN_MAP_BELOW_1MB) || 1978 !(s->cap.features & SS_CAP_PAGE_REGS), 1979 (*handle)->dev_info, s)) 1980 return CS_IN_USE; 1981 (*handle)->state |= CLIENT_WIN_REQ(w); 1982 1983 /* Configure the socket controller */ 1984 win->ctl.map = w+1; 1985 win->ctl.flags = 0; 1986 win->ctl.speed = req->AccessSpeed; 1987 if (req->Attributes & WIN_MEMORY_TYPE) 1988 win->ctl.flags |= MAP_ATTRIB; 1989 if (req->Attributes & WIN_ENABLE) 1990 win->ctl.flags |= MAP_ACTIVE; 1991 if (req->Attributes & WIN_DATA_WIDTH_16) 1992 win->ctl.flags |= MAP_16BIT; 1993 if (req->Attributes & WIN_USE_WAIT) 1994 win->ctl.flags |= MAP_USE_WAIT; 1995 win->ctl.sys_start = win->base; 1996 win->ctl.sys_stop = win->base + win->size-1; 1997 win->ctl.card_start = 0; 1998 if (set_mem_map(s, &win->ctl) != 0) 1999 return CS_BAD_ARGS; 2000 s->state |= SOCKET_WIN_REQ(w); 2001 2002 /* Return window handle */ 2003 req->Base = win->ctl.sys_start; 2004 *wh = win; 2005 2006 return CS_SUCCESS; 2007} /* request_window */ 2008 2009/*====================================================================== 2010 2011 I'm not sure which "reset" function this is supposed to use, 2012 but for now, it uses the low-level interface's reset, not the 2013 CIS register. 2014 2015======================================================================*/ 2016 2017int pcmcia_reset_card(client_handle_t handle, client_req_t *req) 2018{ 2019 int i, ret; 2020 socket_info_t *s; 2021 2022 if (CHECK_HANDLE(handle)) 2023 return CS_BAD_HANDLE; 2024 i = handle->Socket; s = socket_table[i]; 2025 if (!(s->state & SOCKET_PRESENT)) 2026 return CS_NO_CARD; 2027 if (s->state & SOCKET_RESET_PENDING) 2028 return CS_IN_USE; 2029 s->state |= SOCKET_RESET_PENDING; 2030 2031 ret = send_event(s, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW); 2032 if (ret != 0) { 2033 s->state &= ~SOCKET_RESET_PENDING; 2034 handle->event_callback_args.info = (void *)(u_long)ret; 2035 EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW); 2036 } else { 2037 DEBUG(1, "cs: resetting socket %d\n", i); 2038 send_event(s, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW); 2039 s->reset_handle = handle; 2040 reset_socket(s); 2041 } 2042 return CS_SUCCESS; 2043} /* reset_card */ 2044 2045/*====================================================================== 2046 2047 These shut down or wake up a socket. They are sort of user 2048 initiated versions of the APM suspend and resume actions. 2049 2050======================================================================*/ 2051 2052int pcmcia_suspend_card(client_handle_t handle, client_req_t *req) 2053{ 2054 int i; 2055 socket_info_t *s; 2056 2057 if (CHECK_HANDLE(handle)) 2058 return CS_BAD_HANDLE; 2059 i = handle->Socket; s = socket_table[i]; 2060 if (!(s->state & SOCKET_PRESENT)) 2061 return CS_NO_CARD; 2062 if (s->state & SOCKET_SUSPEND) 2063 return CS_IN_USE; 2064 2065 DEBUG(1, "cs: suspending socket %d\n", i); 2066 send_event(s, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW); 2067 suspend_socket(s); 2068 s->state |= SOCKET_SUSPEND; 2069 2070 return CS_SUCCESS; 2071} /* suspend_card */ 2072 2073int pcmcia_resume_card(client_handle_t handle, client_req_t *req) 2074{ 2075 int i; 2076 socket_info_t *s; 2077 2078 if (CHECK_HANDLE(handle)) 2079 return CS_BAD_HANDLE; 2080 i = handle->Socket; s = socket_table[i]; 2081 if (!(s->state & SOCKET_PRESENT)) 2082 return CS_NO_CARD; 2083 if (!(s->state & SOCKET_SUSPEND)) 2084 return CS_IN_USE; 2085 2086 DEBUG(1, "cs: waking up socket %d\n", i); 2087 setup_socket(s); 2088 2089 return CS_SUCCESS; 2090} /* resume_card */ 2091 2092/*====================================================================== 2093 2094 These handle user requests to eject or insert a card. 2095 2096======================================================================*/ 2097 2098int pcmcia_eject_card(client_handle_t handle, client_req_t *req) 2099{ 2100 int i, ret; 2101 socket_info_t *s; 2102 u_long flags; 2103 2104 if (CHECK_HANDLE(handle)) 2105 return CS_BAD_HANDLE; 2106 i = handle->Socket; s = socket_table[i]; 2107 if (!(s->state & SOCKET_PRESENT)) 2108 return CS_NO_CARD; 2109 2110 DEBUG(1, "cs: user eject request on socket %d\n", i); 2111 2112 ret = send_event(s, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW); 2113 if (ret != 0) 2114 return ret; 2115 2116 spin_lock_irqsave(&s->lock, flags); 2117 do_shutdown(s); 2118 spin_unlock_irqrestore(&s->lock, flags); 2119 2120 return CS_SUCCESS; 2121 2122} /* eject_card */ 2123 2124int pcmcia_insert_card(client_handle_t handle, client_req_t *req) 2125{ 2126 int i, status; 2127 socket_info_t *s; 2128 u_long flags; 2129 2130 if (CHECK_HANDLE(handle)) 2131 return CS_BAD_HANDLE; 2132 i = handle->Socket; s = socket_table[i]; 2133 if (s->state & SOCKET_PRESENT) 2134 return CS_IN_USE; 2135 2136 DEBUG(1, "cs: user insert request on socket %d\n", i); 2137 2138 spin_lock_irqsave(&s->lock, flags); 2139 if (!(s->state & SOCKET_SETUP_PENDING)) { 2140 s->state |= SOCKET_SETUP_PENDING; 2141 spin_unlock_irqrestore(&s->lock, flags); 2142 get_socket_status(s, &status); 2143 if ((status & SS_DETECT) == 0 || (setup_socket(s) == 0)) { 2144 s->state &= ~SOCKET_SETUP_PENDING; 2145 return CS_NO_CARD; 2146 } 2147 } else 2148 spin_unlock_irqrestore(&s->lock, flags); 2149 2150 return CS_SUCCESS; 2151} /* insert_card */ 2152 2153/*====================================================================== 2154 2155 Maybe this should send a CS_EVENT_CARD_INSERTION event if we 2156 haven't sent one to this client yet? 2157 2158======================================================================*/ 2159 2160int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask) 2161{ 2162 u_int events, bit; 2163 if (CHECK_HANDLE(handle)) 2164 return CS_BAD_HANDLE; 2165 if (handle->Attributes & CONF_EVENT_MASK_VALID) 2166 return CS_BAD_SOCKET; 2167 handle->EventMask = mask->EventMask; 2168 events = handle->PendingEvents & handle->EventMask; 2169 handle->PendingEvents -= events; 2170 while (events != 0) { 2171 bit = ((events ^ (events-1)) + 1) >> 1; 2172 EVENT(handle, bit, CS_EVENT_PRI_LOW); 2173 events -= bit; 2174 } 2175 return CS_SUCCESS; 2176} /* set_event_mask */ 2177 2178/*====================================================================*/ 2179 2180int pcmcia_report_error(client_handle_t handle, error_info_t *err) 2181{ 2182 int i; 2183 char *serv; 2184 2185 if (CHECK_HANDLE(handle)) 2186 printk(KERN_NOTICE); 2187 else 2188 printk(KERN_NOTICE "%s: ", handle->dev_info); 2189 2190 for (i = 0; i < SERVICE_COUNT; i++) 2191 if (service_table[i].key == err->func) break; 2192 if (i < SERVICE_COUNT) 2193 serv = service_table[i].msg; 2194 else 2195 serv = "Unknown service number"; 2196 2197 for (i = 0; i < ERROR_COUNT; i++) 2198 if (error_table[i].key == err->retcode) break; 2199 if (i < ERROR_COUNT) 2200 printk("%s: %s\n", serv, error_table[i].msg); 2201 else 2202 printk("%s: Unknown error code %#x\n", serv, err->retcode); 2203 2204 return CS_SUCCESS; 2205} /* report_error */ 2206 2207/*====================================================================*/ 2208 2209int CardServices(int func, void *a1, void *a2, void *a3) 2210{ 2211 2212#ifdef PCMCIA_DEBUG 2213 if (pc_debug > 2) { 2214 int i; 2215 for (i = 0; i < SERVICE_COUNT; i++) 2216 if (service_table[i].key == func) break; 2217 if (i < SERVICE_COUNT) 2218 printk(KERN_DEBUG "cs: CardServices(%s, 0x%p, 0x%p)\n", 2219 service_table[i].msg, a1, a2); 2220 else 2221 printk(KERN_DEBUG "cs: CardServices(Unknown func %d, " 2222 "0x%p, 0x%p)\n", func, a1, a2); 2223 } 2224#endif 2225 switch (func) { 2226 case AccessConfigurationRegister: 2227 return pcmcia_access_configuration_register(a1, a2); break; 2228 case AdjustResourceInfo: 2229 return pcmcia_adjust_resource_info(a1, a2); break; 2230 case CheckEraseQueue: 2231 return pcmcia_check_erase_queue(a1); break; 2232 case CloseMemory: 2233 return pcmcia_close_memory(a1); break; 2234 case CopyMemory: 2235 return pcmcia_copy_memory(a1, a2); break; 2236 case DeregisterClient: 2237 return pcmcia_deregister_client(a1); break; 2238 case DeregisterEraseQueue: 2239 return pcmcia_deregister_erase_queue(a1); break; 2240 case GetFirstClient: 2241 return pcmcia_get_first_client(a1, a2); break; 2242 case GetCardServicesInfo: 2243 return pcmcia_get_card_services_info(a1); break; 2244 case GetConfigurationInfo: 2245 return pcmcia_get_configuration_info(a1, a2); break; 2246 case GetNextClient: 2247 return pcmcia_get_next_client(a1, a2); break; 2248 case GetFirstRegion: 2249 return pcmcia_get_first_region(a1, a2); break; 2250 case GetFirstTuple: 2251 return pcmcia_get_first_tuple(a1, a2); break; 2252 case GetNextRegion: 2253 return pcmcia_get_next_region(a1, a2); break; 2254 case GetNextTuple: 2255 return pcmcia_get_next_tuple(a1, a2); break; 2256 case GetStatus: 2257 return pcmcia_get_status(a1, a2); break; 2258 case GetTupleData: 2259 return pcmcia_get_tuple_data(a1, a2); break; 2260 case MapMemPage: 2261 return pcmcia_map_mem_page(a1, a2); break; 2262 case ModifyConfiguration: 2263 return pcmcia_modify_configuration(a1, a2); break; 2264 case ModifyWindow: 2265 return pcmcia_modify_window(a1, a2); break; 2266 case OpenMemory: 2267/* return pcmcia_open_memory(a1, a2); */ 2268 { 2269 memory_handle_t m; 2270 int ret = pcmcia_open_memory(a1, a2, &m); 2271 *(memory_handle_t *)a1 = m; 2272 return ret; 2273 } 2274 break; 2275 case ParseTuple: 2276 return pcmcia_parse_tuple(a1, a2, a3); break; 2277 case ReadMemory: 2278 return pcmcia_read_memory(a1, a2, a3); break; 2279 case RegisterClient: 2280 return pcmcia_register_client(a1, a2); break; 2281 case RegisterEraseQueue: 2282 { 2283 eraseq_handle_t w; 2284 int ret = pcmcia_register_erase_queue(a1, a2, &w); 2285 *(eraseq_handle_t *)a1 = w; 2286 return ret; 2287 } 2288 break; 2289/* return pcmcia_register_erase_queue(a1, a2); break; */ 2290 2291 return pcmcia_register_mtd(a1, a2); break; 2292 case ReleaseConfiguration: 2293 return pcmcia_release_configuration(a1); break; 2294 case ReleaseIO: 2295 return pcmcia_release_io(a1, a2); break; 2296 case ReleaseIRQ: 2297 return pcmcia_release_irq(a1, a2); break; 2298 case ReleaseWindow: 2299 return pcmcia_release_window(a1); break; 2300 case RequestConfiguration: 2301 return pcmcia_request_configuration(a1, a2); break; 2302 case RequestIO: 2303 return pcmcia_request_io(a1, a2); break; 2304 case RequestIRQ: 2305 return pcmcia_request_irq(a1, a2); break; 2306 case RequestWindow: 2307 { 2308 window_handle_t w; 2309 int ret = pcmcia_request_window(a1, a2, &w); 2310 *(window_handle_t *)a1 = w; 2311 return ret; 2312 } 2313 break; 2314 case ResetCard: 2315 return pcmcia_reset_card(a1, a2); break; 2316 case SetEventMask: 2317 return pcmcia_set_event_mask(a1, a2); break; 2318 case ValidateCIS: 2319 return pcmcia_validate_cis(a1, a2); break; 2320 case WriteMemory: 2321 return pcmcia_write_memory(a1, a2, a3); break; 2322 case BindDevice: 2323 return pcmcia_bind_device(a1); break; 2324 case BindMTD: 2325 return pcmcia_bind_mtd(a1); break; 2326 case ReportError: 2327 return pcmcia_report_error(a1, a2); break; 2328 case SuspendCard: 2329 return pcmcia_suspend_card(a1, a2); break; 2330 case ResumeCard: 2331 return pcmcia_resume_card(a1, a2); break; 2332 case EjectCard: 2333 return pcmcia_eject_card(a1, a2); break; 2334 case InsertCard: 2335 return pcmcia_insert_card(a1, a2); break; 2336 case ReplaceCIS: 2337 return pcmcia_replace_cis(a1, a2); break; 2338 case GetFirstWindow: 2339 return pcmcia_get_first_window(a1, a2); break; 2340 case GetNextWindow: 2341 return pcmcia_get_next_window(a1, a2); break; 2342 case GetMemPage: 2343 return pcmcia_get_mem_page(a1, a2); break; 2344 default: 2345 return CS_UNSUPPORTED_FUNCTION; break; 2346 } 2347 2348} /* CardServices */ 2349 2350/*====================================================================== 2351 2352 OS-specific module glue goes here 2353 2354======================================================================*/ 2355/* in alpha order */ 2356EXPORT_SYMBOL(pcmcia_access_configuration_register); 2357EXPORT_SYMBOL(pcmcia_adjust_resource_info); 2358EXPORT_SYMBOL(pcmcia_bind_device); 2359EXPORT_SYMBOL(pcmcia_bind_mtd); 2360EXPORT_SYMBOL(pcmcia_check_erase_queue); 2361EXPORT_SYMBOL(pcmcia_close_memory); 2362EXPORT_SYMBOL(pcmcia_copy_memory); 2363EXPORT_SYMBOL(pcmcia_deregister_client); 2364EXPORT_SYMBOL(pcmcia_deregister_erase_queue); 2365EXPORT_SYMBOL(pcmcia_eject_card); 2366EXPORT_SYMBOL(pcmcia_get_first_client); 2367EXPORT_SYMBOL(pcmcia_get_card_services_info); 2368EXPORT_SYMBOL(pcmcia_get_configuration_info); 2369EXPORT_SYMBOL(pcmcia_get_mem_page); 2370EXPORT_SYMBOL(pcmcia_get_next_client); 2371EXPORT_SYMBOL(pcmcia_get_first_region); 2372EXPORT_SYMBOL(pcmcia_get_first_tuple); 2373EXPORT_SYMBOL(pcmcia_get_first_window); 2374EXPORT_SYMBOL(pcmcia_get_next_region); 2375EXPORT_SYMBOL(pcmcia_get_next_tuple); 2376EXPORT_SYMBOL(pcmcia_get_next_window); 2377EXPORT_SYMBOL(pcmcia_get_status); 2378EXPORT_SYMBOL(pcmcia_get_tuple_data); 2379EXPORT_SYMBOL(pcmcia_insert_card); 2380EXPORT_SYMBOL(pcmcia_map_mem_page); 2381EXPORT_SYMBOL(pcmcia_modify_configuration); 2382EXPORT_SYMBOL(pcmcia_modify_window); 2383EXPORT_SYMBOL(pcmcia_open_memory); 2384EXPORT_SYMBOL(pcmcia_parse_tuple); 2385EXPORT_SYMBOL(pcmcia_read_memory); 2386EXPORT_SYMBOL(pcmcia_register_client); 2387EXPORT_SYMBOL(pcmcia_register_erase_queue); 2388EXPORT_SYMBOL(pcmcia_register_mtd); 2389EXPORT_SYMBOL(pcmcia_release_configuration); 2390EXPORT_SYMBOL(pcmcia_release_io); 2391EXPORT_SYMBOL(pcmcia_release_irq); 2392EXPORT_SYMBOL(pcmcia_release_window); 2393EXPORT_SYMBOL(pcmcia_replace_cis); 2394EXPORT_SYMBOL(pcmcia_report_error); 2395EXPORT_SYMBOL(pcmcia_request_configuration); 2396EXPORT_SYMBOL(pcmcia_request_io); 2397EXPORT_SYMBOL(pcmcia_request_irq); 2398EXPORT_SYMBOL(pcmcia_request_window); 2399EXPORT_SYMBOL(pcmcia_reset_card); 2400EXPORT_SYMBOL(pcmcia_resume_card); 2401EXPORT_SYMBOL(pcmcia_set_event_mask); 2402EXPORT_SYMBOL(pcmcia_suspend_card); 2403EXPORT_SYMBOL(pcmcia_validate_cis); 2404EXPORT_SYMBOL(pcmcia_write_memory); 2405 2406EXPORT_SYMBOL(dead_socket); 2407EXPORT_SYMBOL(register_ss_entry); 2408EXPORT_SYMBOL(unregister_ss_entry); 2409EXPORT_SYMBOL(CardServices); 2410EXPORT_SYMBOL(MTDHelperEntry); 2411#ifdef CONFIG_PROC_FS 2412EXPORT_SYMBOL(proc_pccard); 2413#endif 2414 2415EXPORT_SYMBOL(pcmcia_register_socket); 2416EXPORT_SYMBOL(pcmcia_unregister_socket); 2417EXPORT_SYMBOL(pcmcia_suspend_socket); 2418EXPORT_SYMBOL(pcmcia_resume_socket); 2419 2420static int __init init_pcmcia_cs(void) 2421{ 2422 printk(KERN_INFO "%s\n", release); 2423 printk(KERN_INFO " %s\n", options); 2424 DEBUG(0, "%s\n", version); 2425 if (do_apm) 2426 pm_register(PM_SYS_DEV, PM_SYS_PCMCIA, handle_pm_event); 2427#ifdef CONFIG_PROC_FS 2428 proc_pccard = proc_mkdir("pccard", proc_bus); 2429#endif 2430 return 0; 2431} 2432 2433static void __exit exit_pcmcia_cs(void) 2434{ 2435 printk(KERN_INFO "unloading Kernel Card Services\n"); 2436#ifdef CONFIG_PROC_FS 2437 if (proc_pccard) { 2438 remove_proc_entry("pccard", proc_bus); 2439 } 2440#endif 2441 if (do_apm) 2442 pm_unregister_all(handle_pm_event); 2443 release_resource_db(); 2444} 2445 2446module_init(init_pcmcia_cs); 2447module_exit(exit_pcmcia_cs); 2448 2449/*====================================================================*/ 2450 2451