PageRenderTime 98ms CodeModel.GetById 3ms app.highlight 83ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/pcmcia/cs.c

https://bitbucket.org/evzijst/gittest
C | 1917 lines | 1383 code | 299 blank | 235 comment | 321 complexity | 5aa5a5c2978dd148a457c35a574ad6df MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * cs.c -- Kernel Card Services - core services
   3 *
   4 * This program is free software; you can redistribute it and/or modify
   5 * it under the terms of the GNU General Public License version 2 as
   6 * published by the Free Software Foundation.
   7 *
   8 * The initial developer of the original code is David A. Hinds
   9 * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  10 * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  11 *
  12 * (C) 1999		David A. Hinds
  13 */
  14
  15#include <linux/module.h>
  16#include <linux/moduleparam.h>
  17#include <linux/init.h>
  18#include <linux/kernel.h>
  19#include <linux/config.h>
  20#include <linux/string.h>
  21#include <linux/major.h>
  22#include <linux/errno.h>
  23#include <linux/slab.h>
  24#include <linux/mm.h>
  25#include <linux/interrupt.h>
  26#include <linux/timer.h>
  27#include <linux/ioport.h>
  28#include <linux/delay.h>
  29#include <linux/pm.h>
  30#include <linux/pci.h>
  31#include <linux/device.h>
  32#include <asm/system.h>
  33#include <asm/irq.h>
  34
  35#define IN_CARD_SERVICES
  36#include <pcmcia/version.h>
  37#include <pcmcia/cs_types.h>
  38#include <pcmcia/ss.h>
  39#include <pcmcia/cs.h>
  40#include <pcmcia/bulkmem.h>
  41#include <pcmcia/cistpl.h>
  42#include <pcmcia/cisreg.h>
  43#include <pcmcia/ds.h>
  44#include "cs_internal.h"
  45
  46#ifdef CONFIG_PCI
  47#define PCI_OPT " [pci]"
  48#else
  49#define PCI_OPT ""
  50#endif
  51#ifdef CONFIG_CARDBUS
  52#define CB_OPT " [cardbus]"
  53#else
  54#define CB_OPT ""
  55#endif
  56#ifdef CONFIG_PM
  57#define PM_OPT " [pm]"
  58#else
  59#define PM_OPT ""
  60#endif
  61#if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
  62#define OPTIONS " none"
  63#else
  64#define OPTIONS PCI_OPT CB_OPT PM_OPT
  65#endif
  66
  67static const char *release = "Linux Kernel Card Services";
  68static const char *options = "options: " OPTIONS;
  69
  70/*====================================================================*/
  71
  72/* Module parameters */
  73
  74MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  75MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
  76MODULE_LICENSE("GPL");
  77
  78#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
  79
  80INT_MODULE_PARM(setup_delay,	10);		/* centiseconds */
  81INT_MODULE_PARM(resume_delay,	20);		/* centiseconds */
  82INT_MODULE_PARM(shutdown_delay,	3);		/* centiseconds */
  83INT_MODULE_PARM(vcc_settle,	40);		/* centiseconds */
  84INT_MODULE_PARM(reset_time,	10);		/* usecs */
  85INT_MODULE_PARM(unreset_delay,	10);		/* centiseconds */
  86INT_MODULE_PARM(unreset_check,	10);		/* centiseconds */
  87INT_MODULE_PARM(unreset_limit,	30);		/* unreset_check's */
  88
  89/* Access speed for attribute memory windows */
  90INT_MODULE_PARM(cis_speed,	300);		/* ns */
  91
  92/* Access speed for IO windows */
  93INT_MODULE_PARM(io_speed,	0);		/* ns */
  94
  95#ifdef DEBUG
  96static int pc_debug;
  97
  98module_param(pc_debug, int, 0644);
  99
 100int cs_debug_level(int level)
 101{
 102	return pc_debug > level;
 103}
 104#endif
 105
 106/*====================================================================*/
 107
 108socket_state_t dead_socket = {
 109	.csc_mask	= SS_DETECT,
 110};
 111
 112
 113/* List of all sockets, protected by a rwsem */
 114LIST_HEAD(pcmcia_socket_list);
 115DECLARE_RWSEM(pcmcia_socket_list_rwsem);
 116EXPORT_SYMBOL(pcmcia_socket_list);
 117EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
 118
 119
 120#ifdef CONFIG_PCMCIA_PROBE
 121/* mask ofIRQs already reserved by other cards, we should avoid using them */
 122static u8 pcmcia_used_irq[NR_IRQS];
 123#endif
 124
 125/*====================================================================
 126
 127    Low-level PC Card interface drivers need to register with Card
 128    Services using these calls.
 129    
 130======================================================================*/
 131
 132/**
 133 * socket drivers are expected to use the following callbacks in their 
 134 * .drv struct:
 135 *  - pcmcia_socket_dev_suspend
 136 *  - pcmcia_socket_dev_resume
 137 * These functions check for the appropriate struct pcmcia_soket arrays,
 138 * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
 139 */
 140static int socket_resume(struct pcmcia_socket *skt);
 141static int socket_suspend(struct pcmcia_socket *skt);
 142
 143int pcmcia_socket_dev_suspend(struct device *dev, pm_message_t state)
 144{
 145	struct pcmcia_socket *socket;
 146
 147	down_read(&pcmcia_socket_list_rwsem);
 148	list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
 149		if (socket->dev.dev != dev)
 150			continue;
 151		down(&socket->skt_sem);
 152		socket_suspend(socket);
 153		up(&socket->skt_sem);
 154	}
 155	up_read(&pcmcia_socket_list_rwsem);
 156
 157	return 0;
 158}
 159EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
 160
 161int pcmcia_socket_dev_resume(struct device *dev)
 162{
 163	struct pcmcia_socket *socket;
 164
 165	down_read(&pcmcia_socket_list_rwsem);
 166	list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
 167		if (socket->dev.dev != dev)
 168			continue;
 169		down(&socket->skt_sem);
 170		socket_resume(socket);
 171		up(&socket->skt_sem);
 172	}
 173	up_read(&pcmcia_socket_list_rwsem);
 174
 175	return 0;
 176}
 177EXPORT_SYMBOL(pcmcia_socket_dev_resume);
 178
 179
 180struct pcmcia_socket * pcmcia_get_socket(struct pcmcia_socket *skt)
 181{
 182	struct class_device *cl_dev = class_device_get(&skt->dev);
 183	if (!cl_dev)
 184		return NULL;
 185	skt = class_get_devdata(cl_dev);
 186	if (!try_module_get(skt->owner)) {
 187		class_device_put(&skt->dev);
 188		return NULL;
 189	}
 190	return (skt);
 191}
 192EXPORT_SYMBOL(pcmcia_get_socket);
 193
 194
 195void pcmcia_put_socket(struct pcmcia_socket *skt)
 196{
 197	module_put(skt->owner);
 198	class_device_put(&skt->dev);
 199}
 200EXPORT_SYMBOL(pcmcia_put_socket);
 201
 202
 203static void pcmcia_release_socket(struct class_device *class_dev)
 204{
 205	struct pcmcia_socket *socket = class_get_devdata(class_dev);
 206
 207	complete(&socket->socket_released);
 208}
 209
 210static int pccardd(void *__skt);
 211
 212/**
 213 * pcmcia_register_socket - add a new pcmcia socket device
 214 */
 215int pcmcia_register_socket(struct pcmcia_socket *socket)
 216{
 217	int ret;
 218
 219	if (!socket || !socket->ops || !socket->dev.dev || !socket->resource_ops)
 220		return -EINVAL;
 221
 222	cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
 223
 224	spin_lock_init(&socket->lock);
 225
 226	if (socket->resource_ops->init) {
 227		ret = socket->resource_ops->init(socket);
 228		if (ret)
 229			return (ret);
 230	}
 231
 232	/* try to obtain a socket number [yes, it gets ugly if we
 233	 * register more than 2^sizeof(unsigned int) pcmcia 
 234	 * sockets... but the socket number is deprecated 
 235	 * anyways, so I don't care] */
 236	down_write(&pcmcia_socket_list_rwsem);
 237	if (list_empty(&pcmcia_socket_list))
 238		socket->sock = 0;
 239	else {
 240		unsigned int found, i = 1;
 241		struct pcmcia_socket *tmp;
 242		do {
 243			found = 1;
 244			list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
 245				if (tmp->sock == i)
 246					found = 0;
 247			}
 248			i++;
 249		} while (!found);
 250		socket->sock = i - 1;
 251	}
 252	list_add_tail(&socket->socket_list, &pcmcia_socket_list);
 253	up_write(&pcmcia_socket_list_rwsem);
 254
 255
 256	/* set proper values in socket->dev */
 257	socket->dev.class_data = socket;
 258	socket->dev.class = &pcmcia_socket_class;
 259	snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
 260
 261	/* base address = 0, map = 0 */
 262	socket->cis_mem.flags = 0;
 263	socket->cis_mem.speed = cis_speed;
 264
 265	INIT_LIST_HEAD(&socket->cis_cache);
 266
 267	init_completion(&socket->socket_released);
 268	init_completion(&socket->thread_done);
 269	init_waitqueue_head(&socket->thread_wait);
 270	init_MUTEX(&socket->skt_sem);
 271	spin_lock_init(&socket->thread_lock);
 272
 273	ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
 274	if (ret < 0)
 275		goto err;
 276
 277	wait_for_completion(&socket->thread_done);
 278	if(!socket->thread) {
 279		printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
 280		return -EIO;
 281	}
 282	pcmcia_parse_events(socket, SS_DETECT);
 283
 284	return 0;
 285
 286 err:
 287	down_write(&pcmcia_socket_list_rwsem);
 288	list_del(&socket->socket_list);
 289	up_write(&pcmcia_socket_list_rwsem);
 290	return ret;
 291} /* pcmcia_register_socket */
 292EXPORT_SYMBOL(pcmcia_register_socket);
 293
 294
 295/**
 296 * pcmcia_unregister_socket - remove a pcmcia socket device
 297 */
 298void pcmcia_unregister_socket(struct pcmcia_socket *socket)
 299{
 300	if (!socket)
 301		return;
 302
 303	cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
 304
 305	if (socket->thread) {
 306		init_completion(&socket->thread_done);
 307		socket->thread = NULL;
 308		wake_up(&socket->thread_wait);
 309		wait_for_completion(&socket->thread_done);
 310	}
 311	release_cis_mem(socket);
 312
 313	/* remove from our own list */
 314	down_write(&pcmcia_socket_list_rwsem);
 315	list_del(&socket->socket_list);
 316	up_write(&pcmcia_socket_list_rwsem);
 317
 318	/* wait for sysfs to drop all references */
 319	release_resource_db(socket);
 320	wait_for_completion(&socket->socket_released);
 321} /* pcmcia_unregister_socket */
 322EXPORT_SYMBOL(pcmcia_unregister_socket);
 323
 324
 325struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
 326{
 327	struct pcmcia_socket *s;
 328
 329	down_read(&pcmcia_socket_list_rwsem);
 330	list_for_each_entry(s, &pcmcia_socket_list, socket_list)
 331		if (s->sock == nr) {
 332			up_read(&pcmcia_socket_list_rwsem);
 333			return s;
 334		}
 335	up_read(&pcmcia_socket_list_rwsem);
 336
 337	return NULL;
 338
 339}
 340EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
 341
 342
 343/*======================================================================
 344
 345    socket_setup() and shutdown_socket() are called by the main event
 346    handler when card insertion and removal events are received.
 347    socket_setup() turns on socket power and resets the socket, in two stages.
 348    shutdown_socket() unconfigures a socket and turns off socket power.
 349
 350======================================================================*/
 351
 352static void shutdown_socket(struct pcmcia_socket *s)
 353{
 354    cs_dbg(s, 1, "shutdown_socket\n");
 355
 356    /* Blank out the socket state */
 357    s->socket = dead_socket;
 358    s->ops->init(s);
 359    s->ops->set_socket(s, &s->socket);
 360    s->irq.AssignedIRQ = s->irq.Config = 0;
 361    s->lock_count = 0;
 362    destroy_cis_cache(s);
 363#ifdef CONFIG_CARDBUS
 364    cb_free(s);
 365#endif
 366    s->functions = 0;
 367    if (s->config) {
 368	kfree(s->config);
 369	s->config = NULL;
 370    }
 371
 372    {
 373	int status;
 374	s->ops->get_status(s, &status);
 375	if (status & SS_POWERON) {
 376		printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
 377	}
 378    }
 379} /* shutdown_socket */
 380
 381/*======================================================================
 382
 383    The central event handler.  Send_event() sends an event to the
 384    16-bit subsystem, which then calls the relevant device drivers.
 385    Parse_events() interprets the event bits from
 386    a card status change report.  Do_shutdown() handles the high
 387    priority stuff associated with a card removal.
 388    
 389======================================================================*/
 390
 391
 392/* NOTE: send_event needs to be called with skt->sem held. */
 393
 394static int send_event(struct pcmcia_socket *s, event_t event, int priority)
 395{
 396	int ret;
 397
 398	if (s->state & SOCKET_CARDBUS)
 399		return 0;
 400
 401	cs_dbg(s, 1, "send_event(event %d, pri %d, callback 0x%p)\n",
 402	   event, priority, s->callback);
 403
 404	if (!s->callback)
 405		return 0;
 406	if (!try_module_get(s->callback->owner))
 407		return 0;
 408
 409	ret = s->callback->event(s, event, priority);
 410
 411	module_put(s->callback->owner);
 412
 413	return ret;
 414}
 415
 416static void socket_remove_drivers(struct pcmcia_socket *skt)
 417{
 418	cs_dbg(skt, 4, "remove_drivers\n");
 419
 420	send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
 421}
 422
 423static void socket_shutdown(struct pcmcia_socket *skt)
 424{
 425	cs_dbg(skt, 4, "shutdown\n");
 426
 427	socket_remove_drivers(skt);
 428	skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
 429	msleep(shutdown_delay * 10);
 430	skt->state &= SOCKET_INUSE;
 431	shutdown_socket(skt);
 432}
 433
 434static int socket_reset(struct pcmcia_socket *skt)
 435{
 436	int status, i;
 437
 438	cs_dbg(skt, 4, "reset\n");
 439
 440	skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
 441	skt->ops->set_socket(skt, &skt->socket);
 442	udelay((long)reset_time);
 443
 444	skt->socket.flags &= ~SS_RESET;
 445	skt->ops->set_socket(skt, &skt->socket);
 446
 447	msleep(unreset_delay * 10);
 448	for (i = 0; i < unreset_limit; i++) {
 449		skt->ops->get_status(skt, &status);
 450
 451		if (!(status & SS_DETECT))
 452			return CS_NO_CARD;
 453
 454		if (status & SS_READY)
 455			return CS_SUCCESS;
 456
 457		msleep(unreset_check * 10);
 458	}
 459
 460	cs_err(skt, "time out after reset.\n");
 461	return CS_GENERAL_FAILURE;
 462}
 463
 464static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
 465{
 466	int status, i;
 467
 468	cs_dbg(skt, 4, "setup\n");
 469
 470	skt->ops->get_status(skt, &status);
 471	if (!(status & SS_DETECT))
 472		return CS_NO_CARD;
 473
 474	msleep(initial_delay * 10);
 475
 476	for (i = 0; i < 100; i++) {
 477		skt->ops->get_status(skt, &status);
 478		if (!(status & SS_DETECT))
 479			return CS_NO_CARD;
 480
 481		if (!(status & SS_PENDING))
 482			break;
 483
 484		msleep(100);
 485	}
 486
 487	if (status & SS_PENDING) {
 488		cs_err(skt, "voltage interrogation timed out.\n");
 489		return CS_GENERAL_FAILURE;
 490	}
 491
 492	if (status & SS_CARDBUS) {
 493		skt->state |= SOCKET_CARDBUS;
 494#ifndef CONFIG_CARDBUS
 495		cs_err(skt, "cardbus cards are not supported.\n");
 496		return CS_BAD_TYPE;
 497#endif
 498	}
 499
 500	/*
 501	 * Decode the card voltage requirements, and apply power to the card.
 502	 */
 503	if (status & SS_3VCARD)
 504		skt->socket.Vcc = skt->socket.Vpp = 33;
 505	else if (!(status & SS_XVCARD))
 506		skt->socket.Vcc = skt->socket.Vpp = 50;
 507	else {
 508		cs_err(skt, "unsupported voltage key.\n");
 509		return CS_BAD_TYPE;
 510	}
 511	skt->socket.flags = 0;
 512	skt->ops->set_socket(skt, &skt->socket);
 513
 514	/*
 515	 * Wait "vcc_settle" for the supply to stabilise.
 516	 */
 517	msleep(vcc_settle * 10);
 518
 519	skt->ops->get_status(skt, &status);
 520	if (!(status & SS_POWERON)) {
 521		cs_err(skt, "unable to apply power.\n");
 522		return CS_BAD_TYPE;
 523	}
 524
 525	return socket_reset(skt);
 526}
 527
 528/*
 529 * Handle card insertion.  Setup the socket, reset the card,
 530 * and then tell the rest of PCMCIA that a card is present.
 531 */
 532static int socket_insert(struct pcmcia_socket *skt)
 533{
 534	int ret;
 535
 536	cs_dbg(skt, 4, "insert\n");
 537
 538	if (!cs_socket_get(skt))
 539		return CS_NO_CARD;
 540
 541	ret = socket_setup(skt, setup_delay);
 542	if (ret == CS_SUCCESS) {
 543		skt->state |= SOCKET_PRESENT;
 544#ifdef CONFIG_CARDBUS
 545		if (skt->state & SOCKET_CARDBUS) {
 546			cb_alloc(skt);
 547			skt->state |= SOCKET_CARDBUS_CONFIG;
 548		}
 549#endif
 550		cs_dbg(skt, 4, "insert done\n");
 551
 552		send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
 553	} else {
 554		socket_shutdown(skt);
 555		cs_socket_put(skt);
 556	}
 557
 558	return ret;
 559}
 560
 561static int socket_suspend(struct pcmcia_socket *skt)
 562{
 563	if (skt->state & SOCKET_SUSPEND)
 564		return CS_IN_USE;
 565
 566	send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
 567	skt->socket = dead_socket;
 568	skt->ops->set_socket(skt, &skt->socket);
 569	if (skt->ops->suspend)
 570		skt->ops->suspend(skt);
 571	skt->state |= SOCKET_SUSPEND;
 572
 573	return CS_SUCCESS;
 574}
 575
 576/*
 577 * Resume a socket.  If a card is present, verify its CIS against
 578 * our cached copy.  If they are different, the card has been
 579 * replaced, and we need to tell the drivers.
 580 */
 581static int socket_resume(struct pcmcia_socket *skt)
 582{
 583	int ret;
 584
 585	if (!(skt->state & SOCKET_SUSPEND))
 586		return CS_IN_USE;
 587
 588	skt->socket = dead_socket;
 589	skt->ops->init(skt);
 590	skt->ops->set_socket(skt, &skt->socket);
 591
 592	if (!(skt->state & SOCKET_PRESENT)) {
 593		skt->state &= ~SOCKET_SUSPEND;
 594		return socket_insert(skt);
 595	}
 596
 597	ret = socket_setup(skt, resume_delay);
 598	if (ret == CS_SUCCESS) {
 599		/*
 600		 * FIXME: need a better check here for cardbus cards.
 601		 */
 602		if (verify_cis_cache(skt) != 0) {
 603			cs_dbg(skt, 4, "cis mismatch - different card\n");
 604			socket_remove_drivers(skt);
 605			destroy_cis_cache(skt);
 606			/*
 607			 * Workaround: give DS time to schedule removal.
 608			 * Remove me once the 100ms delay is eliminated
 609			 * in ds.c
 610			 */
 611			msleep(200);
 612			send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
 613		} else {
 614			cs_dbg(skt, 4, "cis matches cache\n");
 615			send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
 616		}
 617	} else {
 618		socket_shutdown(skt);
 619		cs_socket_put(skt);
 620	}
 621
 622	skt->state &= ~SOCKET_SUSPEND;
 623
 624	return CS_SUCCESS;
 625}
 626
 627static void socket_remove(struct pcmcia_socket *skt)
 628{
 629	socket_shutdown(skt);
 630	cs_socket_put(skt);
 631}
 632
 633/*
 634 * Process a socket card detect status change.
 635 *
 636 * If we don't have a card already present, delay the detect event for
 637 * about 20ms (to be on the safe side) before reading the socket status.
 638 *
 639 * Some i82365-based systems send multiple SS_DETECT events during card
 640 * insertion, and the "card present" status bit seems to bounce.  This
 641 * will probably be true with GPIO-based card detection systems after
 642 * the product has aged.
 643 */
 644static void socket_detect_change(struct pcmcia_socket *skt)
 645{
 646	if (!(skt->state & SOCKET_SUSPEND)) {
 647		int status;
 648
 649		if (!(skt->state & SOCKET_PRESENT))
 650			msleep(20);
 651
 652		skt->ops->get_status(skt, &status);
 653		if ((skt->state & SOCKET_PRESENT) &&
 654		     !(status & SS_DETECT))
 655			socket_remove(skt);
 656		if (!(skt->state & SOCKET_PRESENT) &&
 657		    (status & SS_DETECT))
 658			socket_insert(skt);
 659	}
 660}
 661
 662static int pccardd(void *__skt)
 663{
 664	struct pcmcia_socket *skt = __skt;
 665	DECLARE_WAITQUEUE(wait, current);
 666	int ret;
 667
 668	daemonize("pccardd");
 669
 670	skt->thread = current;
 671	skt->socket = dead_socket;
 672	skt->ops->init(skt);
 673	skt->ops->set_socket(skt, &skt->socket);
 674
 675	/* register with the device core */
 676	ret = class_device_register(&skt->dev);
 677	if (ret) {
 678		printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
 679			skt);
 680		skt->thread = NULL;
 681		complete_and_exit(&skt->thread_done, 0);
 682	}
 683	complete(&skt->thread_done);
 684
 685	add_wait_queue(&skt->thread_wait, &wait);
 686	for (;;) {
 687		unsigned long flags;
 688		unsigned int events;
 689
 690		set_current_state(TASK_INTERRUPTIBLE);
 691
 692		spin_lock_irqsave(&skt->thread_lock, flags);
 693		events = skt->thread_events;
 694		skt->thread_events = 0;
 695		spin_unlock_irqrestore(&skt->thread_lock, flags);
 696
 697		if (events) {
 698			down(&skt->skt_sem);
 699			if (events & SS_DETECT)
 700				socket_detect_change(skt);
 701			if (events & SS_BATDEAD)
 702				send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
 703			if (events & SS_BATWARN)
 704				send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
 705			if (events & SS_READY)
 706				send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
 707			up(&skt->skt_sem);
 708			continue;
 709		}
 710
 711		schedule();
 712		try_to_freeze(PF_FREEZE);
 713
 714		if (!skt->thread)
 715			break;
 716	}
 717	remove_wait_queue(&skt->thread_wait, &wait);
 718
 719	/* remove from the device core */
 720	class_device_unregister(&skt->dev);
 721
 722	complete_and_exit(&skt->thread_done, 0);
 723}
 724
 725/*
 726 * Yenta (at least) probes interrupts before registering the socket and
 727 * starting the handler thread.
 728 */
 729void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
 730{
 731	cs_dbg(s, 4, "parse_events: events %08x\n", events);
 732	if (s->thread) {
 733		spin_lock(&s->thread_lock);
 734		s->thread_events |= events;
 735		spin_unlock(&s->thread_lock);
 736
 737		wake_up(&s->thread_wait);
 738	}
 739} /* pcmcia_parse_events */
 740
 741
 742/*======================================================================
 743
 744    Special stuff for managing IO windows, because they are scarce.
 745    
 746======================================================================*/
 747
 748static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
 749			  ioaddr_t num, u_int lines)
 750{
 751    int i;
 752    kio_addr_t try, align;
 753
 754    align = (*base) ? (lines ? 1<<lines : 0) : 1;
 755    if (align && (align < num)) {
 756	if (*base) {
 757	    cs_dbg(s, 0, "odd IO request: num %#x align %#lx\n",
 758		   num, align);
 759	    align = 0;
 760	} else
 761	    while (align && (align < num)) align <<= 1;
 762    }
 763    if (*base & ~(align-1)) {
 764	cs_dbg(s, 0, "odd IO request: base %#x align %#lx\n",
 765	       *base, align);
 766	align = 0;
 767    }
 768    if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
 769	*base = s->io_offset | (*base & 0x0fff);
 770	return 0;
 771    }
 772    /* Check for an already-allocated window that must conflict with
 773       what was asked for.  It is a hack because it does not catch all
 774       potential conflicts, just the most obvious ones. */
 775    for (i = 0; i < MAX_IO_WIN; i++)
 776	if ((s->io[i].NumPorts != 0) &&
 777	    ((s->io[i].BasePort & (align-1)) == *base))
 778	    return 1;
 779    for (i = 0; i < MAX_IO_WIN; i++) {
 780	if (s->io[i].NumPorts == 0) {
 781	    s->io[i].res = find_io_region(*base, num, align, s);
 782	    if (s->io[i].res) {
 783		s->io[i].Attributes = attr;
 784		s->io[i].BasePort = *base = s->io[i].res->start;
 785		s->io[i].NumPorts = s->io[i].InUse = num;
 786		break;
 787	    } else
 788		return 1;
 789	} else if (s->io[i].Attributes != attr)
 790	    continue;
 791	/* Try to extend top of window */
 792	try = s->io[i].BasePort + s->io[i].NumPorts;
 793	if ((*base == 0) || (*base == try))
 794	    if (adjust_io_region(s->io[i].res, s->io[i].res->start,
 795				 s->io[i].res->end + num, s) == 0) {
 796		*base = try;
 797		s->io[i].NumPorts += num;
 798		s->io[i].InUse += num;
 799		break;
 800	    }
 801	/* Try to extend bottom of window */
 802	try = s->io[i].BasePort - num;
 803	if ((*base == 0) || (*base == try))
 804	    if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
 805				 s->io[i].res->end, s) == 0) {
 806		s->io[i].BasePort = *base = try;
 807		s->io[i].NumPorts += num;
 808		s->io[i].InUse += num;
 809		break;
 810	    }
 811    }
 812    return (i == MAX_IO_WIN);
 813} /* alloc_io_space */
 814
 815static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
 816			     ioaddr_t num)
 817{
 818    int i;
 819
 820    for (i = 0; i < MAX_IO_WIN; i++) {
 821	if ((s->io[i].BasePort <= base) &&
 822	    (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
 823	    s->io[i].InUse -= num;
 824	    /* Free the window if no one else is using it */
 825	    if (s->io[i].InUse == 0) {
 826		s->io[i].NumPorts = 0;
 827		release_resource(s->io[i].res);
 828		kfree(s->io[i].res);
 829		s->io[i].res = NULL;
 830	    }
 831	}
 832    }
 833}
 834
 835/*======================================================================
 836
 837    Access_configuration_register() reads and writes configuration
 838    registers in attribute memory.  Memory window 0 is reserved for
 839    this and the tuple reading services.
 840    
 841======================================================================*/
 842
 843int pccard_access_configuration_register(struct pcmcia_socket *s,
 844					 unsigned int function,
 845					 conf_reg_t *reg)
 846{
 847    config_t *c;
 848    int addr;
 849    u_char val;
 850
 851    if (!s || !s->config)
 852	return CS_NO_CARD;    
 853
 854    c = &s->config[function];
 855
 856    if (c == NULL)
 857	return CS_NO_CARD;
 858
 859    if (!(c->state & CONFIG_LOCKED))
 860	return CS_CONFIGURATION_LOCKED;
 861
 862    addr = (c->ConfigBase + reg->Offset) >> 1;
 863    
 864    switch (reg->Action) {
 865    case CS_READ:
 866	read_cis_mem(s, 1, addr, 1, &val);
 867	reg->Value = val;
 868	break;
 869    case CS_WRITE:
 870	val = reg->Value;
 871	write_cis_mem(s, 1, addr, 1, &val);
 872	break;
 873    default:
 874	return CS_BAD_ARGS;
 875	break;
 876    }
 877    return CS_SUCCESS;
 878} /* access_configuration_register */
 879EXPORT_SYMBOL(pccard_access_configuration_register);
 880
 881
 882/*====================================================================*/
 883
 884int pccard_get_configuration_info(struct pcmcia_socket *s,
 885				  unsigned int function,
 886				  config_info_t *config)
 887{
 888    config_t *c;
 889    
 890    if (!(s->state & SOCKET_PRESENT))
 891	return CS_NO_CARD;
 892
 893    config->Function = function;
 894
 895#ifdef CONFIG_CARDBUS
 896    if (s->state & SOCKET_CARDBUS) {
 897	memset(config, 0, sizeof(config_info_t));
 898	config->Vcc = s->socket.Vcc;
 899	config->Vpp1 = config->Vpp2 = s->socket.Vpp;
 900	config->Option = s->cb_dev->subordinate->number;
 901	if (s->state & SOCKET_CARDBUS_CONFIG) {
 902	    config->Attributes = CONF_VALID_CLIENT;
 903	    config->IntType = INT_CARDBUS;
 904	    config->AssignedIRQ = s->irq.AssignedIRQ;
 905	    if (config->AssignedIRQ)
 906		config->Attributes |= CONF_ENABLE_IRQ;
 907	    config->BasePort1 = s->io[0].BasePort;
 908	    config->NumPorts1 = s->io[0].NumPorts;
 909	}
 910	return CS_SUCCESS;
 911    }
 912#endif
 913    
 914    c = (s->config != NULL) ? &s->config[function] : NULL;
 915    
 916    if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
 917	config->Attributes = 0;
 918	config->Vcc = s->socket.Vcc;
 919	config->Vpp1 = config->Vpp2 = s->socket.Vpp;
 920	return CS_SUCCESS;
 921    }
 922    
 923    /* !!! This is a hack !!! */
 924    memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
 925    config->Attributes |= CONF_VALID_CLIENT;
 926    config->CardValues = c->CardValues;
 927    config->IRQAttributes = c->irq.Attributes;
 928    config->AssignedIRQ = s->irq.AssignedIRQ;
 929    config->BasePort1 = c->io.BasePort1;
 930    config->NumPorts1 = c->io.NumPorts1;
 931    config->Attributes1 = c->io.Attributes1;
 932    config->BasePort2 = c->io.BasePort2;
 933    config->NumPorts2 = c->io.NumPorts2;
 934    config->Attributes2 = c->io.Attributes2;
 935    config->IOAddrLines = c->io.IOAddrLines;
 936    
 937    return CS_SUCCESS;
 938} /* get_configuration_info */
 939EXPORT_SYMBOL(pccard_get_configuration_info);
 940
 941/*======================================================================
 942
 943    Return information about this version of Card Services.
 944    
 945======================================================================*/
 946
 947int pcmcia_get_card_services_info(servinfo_t *info)
 948{
 949    unsigned int socket_count = 0;
 950    struct list_head *tmp;
 951    info->Signature[0] = 'C';
 952    info->Signature[1] = 'S';
 953    down_read(&pcmcia_socket_list_rwsem);
 954    list_for_each(tmp, &pcmcia_socket_list)
 955	    socket_count++;
 956    up_read(&pcmcia_socket_list_rwsem);
 957    info->Count = socket_count;
 958    info->Revision = CS_RELEASE_CODE;
 959    info->CSLevel = 0x0210;
 960    info->VendorString = (char *)release;
 961    return CS_SUCCESS;
 962} /* get_card_services_info */
 963
 964
 965/*====================================================================*/
 966
 967int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, int idx, win_req_t *req)
 968{
 969    window_t *win;
 970    int w;
 971
 972    if (!s || !(s->state & SOCKET_PRESENT))
 973	return CS_NO_CARD;
 974    for (w = idx; w < MAX_WIN; w++)
 975	if (s->state & SOCKET_WIN_REQ(w)) break;
 976    if (w == MAX_WIN)
 977	return CS_NO_MORE_ITEMS;
 978    win = &s->win[w];
 979    req->Base = win->ctl.res->start;
 980    req->Size = win->ctl.res->end - win->ctl.res->start + 1;
 981    req->AccessSpeed = win->ctl.speed;
 982    req->Attributes = 0;
 983    if (win->ctl.flags & MAP_ATTRIB)
 984	req->Attributes |= WIN_MEMORY_TYPE_AM;
 985    if (win->ctl.flags & MAP_ACTIVE)
 986	req->Attributes |= WIN_ENABLE;
 987    if (win->ctl.flags & MAP_16BIT)
 988	req->Attributes |= WIN_DATA_WIDTH_16;
 989    if (win->ctl.flags & MAP_USE_WAIT)
 990	req->Attributes |= WIN_USE_WAIT;
 991    *handle = win;
 992    return CS_SUCCESS;
 993} /* get_window */
 994EXPORT_SYMBOL(pcmcia_get_window);
 995
 996/*=====================================================================
 997
 998    Return the PCI device associated with a card..
 999
1000======================================================================*/
1001
1002#ifdef CONFIG_CARDBUS
1003
1004struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
1005{
1006	if (!s || !(s->state & SOCKET_CARDBUS))
1007		return NULL;
1008
1009	return s->cb_dev->subordinate;
1010}
1011
1012EXPORT_SYMBOL(pcmcia_lookup_bus);
1013
1014#endif
1015
1016/*======================================================================
1017
1018    Get the current socket state bits.  We don't support the latched
1019    SocketState yet: I haven't seen any point for it.
1020    
1021======================================================================*/
1022
1023int pccard_get_status(struct pcmcia_socket *s, unsigned int function, cs_status_t *status)
1024{
1025    config_t *c;
1026    int val;
1027    
1028    s->ops->get_status(s, &val);
1029    status->CardState = status->SocketState = 0;
1030    status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1031    status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1032    status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1033    status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1034    if (s->state & SOCKET_SUSPEND)
1035	status->CardState |= CS_EVENT_PM_SUSPEND;
1036    if (!(s->state & SOCKET_PRESENT))
1037	return CS_NO_CARD;
1038    
1039    c = (s->config != NULL) ? &s->config[function] : NULL;
1040    if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1041	(c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1042	u_char reg;
1043	if (c->Present & PRESENT_PIN_REPLACE) {
1044	    read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
1045	    status->CardState |=
1046		(reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1047	    status->CardState |=
1048		(reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1049	    status->CardState |=
1050		(reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1051	    status->CardState |=
1052		(reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1053	} else {
1054	    /* No PRR?  Then assume we're always ready */
1055	    status->CardState |= CS_EVENT_READY_CHANGE;
1056	}
1057	if (c->Present & PRESENT_EXT_STATUS) {
1058	    read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
1059	    status->CardState |=
1060		(reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1061	}
1062	return CS_SUCCESS;
1063    }
1064    status->CardState |=
1065	(val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1066    status->CardState |=
1067	(val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1068    status->CardState |=
1069	(val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1070    status->CardState |=
1071	(val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1072    return CS_SUCCESS;
1073} /* get_status */
1074EXPORT_SYMBOL(pccard_get_status);
1075
1076/*======================================================================
1077
1078    Change the card address of an already open memory window.
1079    
1080======================================================================*/
1081
1082int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1083{
1084    if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1085	return CS_BAD_HANDLE;
1086    req->Page = 0;
1087    req->CardOffset = win->ctl.card_start;
1088    return CS_SUCCESS;
1089} /* get_mem_page */
1090
1091int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1092{
1093    struct pcmcia_socket *s;
1094    if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1095	return CS_BAD_HANDLE;
1096    if (req->Page != 0)
1097	return CS_BAD_PAGE;
1098    s = win->sock;
1099    win->ctl.card_start = req->CardOffset;
1100    if (s->ops->set_mem_map(s, &win->ctl) != 0)
1101	return CS_BAD_OFFSET;
1102    return CS_SUCCESS;
1103} /* map_mem_page */
1104
1105/*======================================================================
1106
1107    Modify a locked socket configuration
1108    
1109======================================================================*/
1110
1111int pcmcia_modify_configuration(client_handle_t handle,
1112				modconf_t *mod)
1113{
1114    struct pcmcia_socket *s;
1115    config_t *c;
1116    
1117    if (CHECK_HANDLE(handle))
1118	return CS_BAD_HANDLE;
1119    s = SOCKET(handle); c = CONFIG(handle);
1120    if (!(s->state & SOCKET_PRESENT))
1121	return CS_NO_CARD;
1122    if (!(c->state & CONFIG_LOCKED))
1123	return CS_CONFIGURATION_LOCKED;
1124    
1125    if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1126	if (mod->Attributes & CONF_ENABLE_IRQ) {
1127	    c->Attributes |= CONF_ENABLE_IRQ;
1128	    s->socket.io_irq = s->irq.AssignedIRQ;
1129	} else {
1130	    c->Attributes &= ~CONF_ENABLE_IRQ;
1131	    s->socket.io_irq = 0;
1132	}
1133	s->ops->set_socket(s, &s->socket);
1134    }
1135
1136    if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1137	return CS_BAD_VCC;
1138
1139    /* We only allow changing Vpp1 and Vpp2 to the same value */
1140    if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1141	(mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1142	if (mod->Vpp1 != mod->Vpp2)
1143	    return CS_BAD_VPP;
1144	c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1145	if (s->ops->set_socket(s, &s->socket))
1146	    return CS_BAD_VPP;
1147    } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1148	       (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1149	return CS_BAD_VPP;
1150
1151    return CS_SUCCESS;
1152} /* modify_configuration */
1153
1154/* register pcmcia_callback */
1155int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
1156{
1157        int ret = 0;
1158
1159	/* s->skt_sem also protects s->callback */
1160	down(&s->skt_sem);
1161
1162	if (c) {
1163		/* registration */
1164		if (s->callback) {
1165			ret = -EBUSY;
1166			goto err;
1167		}
1168
1169		s->callback = c;
1170
1171		if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
1172			send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1173	} else
1174		s->callback = NULL;
1175 err:
1176	up(&s->skt_sem);
1177
1178	return ret;
1179}
1180EXPORT_SYMBOL(pccard_register_pcmcia);
1181
1182/*====================================================================*/
1183
1184int pcmcia_release_configuration(client_handle_t handle)
1185{
1186    pccard_io_map io = { 0, 0, 0, 0, 1 };
1187    struct pcmcia_socket *s;
1188    int i;
1189    
1190    if (CHECK_HANDLE(handle) ||
1191	!(handle->state & CLIENT_CONFIG_LOCKED))
1192	return CS_BAD_HANDLE;
1193    handle->state &= ~CLIENT_CONFIG_LOCKED;
1194    s = SOCKET(handle);
1195    
1196#ifdef CONFIG_CARDBUS
1197    if (handle->state & CLIENT_CARDBUS)
1198	return CS_SUCCESS;
1199#endif
1200    
1201    if (!(handle->state & CLIENT_STALE)) {
1202	config_t *c = CONFIG(handle);
1203	if (--(s->lock_count) == 0) {
1204	    s->socket.flags = SS_OUTPUT_ENA;   /* Is this correct? */
1205	    s->socket.Vpp = 0;
1206	    s->socket.io_irq = 0;
1207	    s->ops->set_socket(s, &s->socket);
1208	}
1209	if (c->state & CONFIG_IO_REQ)
1210	    for (i = 0; i < MAX_IO_WIN; i++) {
1211		if (s->io[i].NumPorts == 0)
1212		    continue;
1213		s->io[i].Config--;
1214		if (s->io[i].Config != 0)
1215		    continue;
1216		io.map = i;
1217		s->ops->set_io_map(s, &io);
1218	    }
1219	c->state &= ~CONFIG_LOCKED;
1220    }
1221    
1222    return CS_SUCCESS;
1223} /* release_configuration */
1224
1225/*======================================================================
1226
1227    Release_io() releases the I/O ranges allocated by a client.  This
1228    may be invoked some time after a card ejection has already dumped
1229    the actual socket configuration, so if the client is "stale", we
1230    don't bother checking the port ranges against the current socket
1231    values.
1232    
1233======================================================================*/
1234
1235int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1236{
1237    struct pcmcia_socket *s;
1238    
1239    if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1240	return CS_BAD_HANDLE;
1241    handle->state &= ~CLIENT_IO_REQ;
1242    s = SOCKET(handle);
1243    
1244#ifdef CONFIG_CARDBUS
1245    if (handle->state & CLIENT_CARDBUS)
1246	return CS_SUCCESS;
1247#endif
1248    
1249    if (!(handle->state & CLIENT_STALE)) {
1250	config_t *c = CONFIG(handle);
1251	if (c->state & CONFIG_LOCKED)
1252	    return CS_CONFIGURATION_LOCKED;
1253	if ((c->io.BasePort1 != req->BasePort1) ||
1254	    (c->io.NumPorts1 != req->NumPorts1) ||
1255	    (c->io.BasePort2 != req->BasePort2) ||
1256	    (c->io.NumPorts2 != req->NumPorts2))
1257	    return CS_BAD_ARGS;
1258	c->state &= ~CONFIG_IO_REQ;
1259    }
1260
1261    release_io_space(s, req->BasePort1, req->NumPorts1);
1262    if (req->NumPorts2)
1263	release_io_space(s, req->BasePort2, req->NumPorts2);
1264    
1265    return CS_SUCCESS;
1266} /* release_io */
1267
1268/*====================================================================*/
1269
1270int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1271{
1272    struct pcmcia_socket *s;
1273    if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1274	return CS_BAD_HANDLE;
1275    handle->state &= ~CLIENT_IRQ_REQ;
1276    s = SOCKET(handle);
1277    
1278    if (!(handle->state & CLIENT_STALE)) {
1279	config_t *c = CONFIG(handle);
1280	if (c->state & CONFIG_LOCKED)
1281	    return CS_CONFIGURATION_LOCKED;
1282	if (c->irq.Attributes != req->Attributes)
1283	    return CS_BAD_ATTRIBUTE;
1284	if (s->irq.AssignedIRQ != req->AssignedIRQ)
1285	    return CS_BAD_IRQ;
1286	if (--s->irq.Config == 0) {
1287	    c->state &= ~CONFIG_IRQ_REQ;
1288	    s->irq.AssignedIRQ = 0;
1289	}
1290    }
1291    
1292    if (req->Attributes & IRQ_HANDLE_PRESENT) {
1293	free_irq(req->AssignedIRQ, req->Instance);
1294    }
1295
1296#ifdef CONFIG_PCMCIA_PROBE
1297    pcmcia_used_irq[req->AssignedIRQ]--;
1298#endif
1299
1300    return CS_SUCCESS;
1301} /* cs_release_irq */
1302
1303/*====================================================================*/
1304
1305int pcmcia_release_window(window_handle_t win)
1306{
1307    struct pcmcia_socket *s;
1308    
1309    if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1310	return CS_BAD_HANDLE;
1311    s = win->sock;
1312    if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1313	return CS_BAD_HANDLE;
1314
1315    /* Shut down memory window */
1316    win->ctl.flags &= ~MAP_ACTIVE;
1317    s->ops->set_mem_map(s, &win->ctl);
1318    s->state &= ~SOCKET_WIN_REQ(win->index);
1319
1320    /* Release system memory */
1321    if (win->ctl.res) {
1322	release_resource(win->ctl.res);
1323	kfree(win->ctl.res);
1324	win->ctl.res = NULL;
1325    }
1326    win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1327
1328    win->magic = 0;
1329    
1330    return CS_SUCCESS;
1331} /* release_window */
1332
1333/*====================================================================*/
1334
1335int pcmcia_request_configuration(client_handle_t handle,
1336				 config_req_t *req)
1337{
1338    int i;
1339    u_int base;
1340    struct pcmcia_socket *s;
1341    config_t *c;
1342    pccard_io_map iomap;
1343    
1344    if (CHECK_HANDLE(handle))
1345	return CS_BAD_HANDLE;
1346    s = SOCKET(handle);
1347    if (!(s->state & SOCKET_PRESENT))
1348	return CS_NO_CARD;
1349    
1350#ifdef CONFIG_CARDBUS
1351    if (handle->state & CLIENT_CARDBUS)
1352	return CS_UNSUPPORTED_MODE;
1353#endif
1354    
1355    if (req->IntType & INT_CARDBUS)
1356	return CS_UNSUPPORTED_MODE;
1357    c = CONFIG(handle);
1358    if (c->state & CONFIG_LOCKED)
1359	return CS_CONFIGURATION_LOCKED;
1360
1361    /* Do power control.  We don't allow changes in Vcc. */
1362    if (s->socket.Vcc != req->Vcc)
1363	return CS_BAD_VCC;
1364    if (req->Vpp1 != req->Vpp2)
1365	return CS_BAD_VPP;
1366    s->socket.Vpp = req->Vpp1;
1367    if (s->ops->set_socket(s, &s->socket))
1368	return CS_BAD_VPP;
1369    
1370    c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1371    
1372    /* Pick memory or I/O card, DMA mode, interrupt */
1373    c->IntType = req->IntType;
1374    c->Attributes = req->Attributes;
1375    if (req->IntType & INT_MEMORY_AND_IO)
1376	s->socket.flags |= SS_IOCARD;
1377    if (req->IntType & INT_ZOOMED_VIDEO)
1378	s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1379    if (req->Attributes & CONF_ENABLE_DMA)
1380	s->socket.flags |= SS_DMA_MODE;
1381    if (req->Attributes & CONF_ENABLE_SPKR)
1382	s->socket.flags |= SS_SPKR_ENA;
1383    if (req->Attributes & CONF_ENABLE_IRQ)
1384	s->socket.io_irq = s->irq.AssignedIRQ;
1385    else
1386	s->socket.io_irq = 0;
1387    s->ops->set_socket(s, &s->socket);
1388    s->lock_count++;
1389    
1390    /* Set up CIS configuration registers */
1391    base = c->ConfigBase = req->ConfigBase;
1392    c->Present = c->CardValues = req->Present;
1393    if (req->Present & PRESENT_COPY) {
1394	c->Copy = req->Copy;
1395	write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1396    }
1397    if (req->Present & PRESENT_OPTION) {
1398	if (s->functions == 1) {
1399	    c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1400	} else {
1401	    c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1402	    c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1403	    if (req->Present & PRESENT_IOBASE_0)
1404		c->Option |= COR_ADDR_DECODE;
1405	}
1406	if (c->state & CONFIG_IRQ_REQ)
1407	    if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1408		c->Option |= COR_LEVEL_REQ;
1409	write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1410	mdelay(40);
1411    }
1412    if (req->Present & PRESENT_STATUS) {
1413	c->Status = req->Status;
1414	write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1415    }
1416    if (req->Present & PRESENT_PIN_REPLACE) {
1417	c->Pin = req->Pin;
1418	write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1419    }
1420    if (req->Present & PRESENT_EXT_STATUS) {
1421	c->ExtStatus = req->ExtStatus;
1422	write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1423    }
1424    if (req->Present & PRESENT_IOBASE_0) {
1425	u_char b = c->io.BasePort1 & 0xff;
1426	write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1427	b = (c->io.BasePort1 >> 8) & 0xff;
1428	write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1429    }
1430    if (req->Present & PRESENT_IOSIZE) {
1431	u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1432	write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1433    }
1434    
1435    /* Configure I/O windows */
1436    if (c->state & CONFIG_IO_REQ) {
1437	iomap.speed = io_speed;
1438	for (i = 0; i < MAX_IO_WIN; i++)
1439	    if (s->io[i].NumPorts != 0) {
1440		iomap.map = i;
1441		iomap.flags = MAP_ACTIVE;
1442		switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1443		case IO_DATA_PATH_WIDTH_16:
1444		    iomap.flags |= MAP_16BIT; break;
1445		case IO_DATA_PATH_WIDTH_AUTO:
1446		    iomap.flags |= MAP_AUTOSZ; break;
1447		default:
1448		    break;
1449		}
1450		iomap.start = s->io[i].BasePort;
1451		iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1452		s->ops->set_io_map(s, &iomap);
1453		s->io[i].Config++;
1454	    }
1455    }
1456    
1457    c->state |= CONFIG_LOCKED;
1458    handle->state |= CLIENT_CONFIG_LOCKED;
1459    return CS_SUCCESS;
1460} /* request_configuration */
1461
1462/*======================================================================
1463  
1464    Request_io() reserves ranges of port addresses for a socket.
1465    I have not implemented range sharing or alias addressing.
1466    
1467======================================================================*/
1468
1469int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1470{
1471    struct pcmcia_socket *s;
1472    config_t *c;
1473    
1474    if (CHECK_HANDLE(handle))
1475	return CS_BAD_HANDLE;
1476    s = SOCKET(handle);
1477    if (!(s->state & SOCKET_PRESENT))
1478	return CS_NO_CARD;
1479
1480    if (handle->state & CLIENT_CARDBUS) {
1481#ifdef CONFIG_CARDBUS
1482	handle->state |= CLIENT_IO_REQ;
1483	return CS_SUCCESS;
1484#else
1485	return CS_UNSUPPORTED_FUNCTION;
1486#endif
1487    }
1488
1489    if (!req)
1490	return CS_UNSUPPORTED_MODE;
1491    c = CONFIG(handle);
1492    if (c->state & CONFIG_LOCKED)
1493	return CS_CONFIGURATION_LOCKED;
1494    if (c->state & CONFIG_IO_REQ)
1495	return CS_IN_USE;
1496    if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1497	return CS_BAD_ATTRIBUTE;
1498    if ((req->NumPorts2 > 0) &&
1499	(req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1500	return CS_BAD_ATTRIBUTE;
1501
1502    if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1503		       req->NumPorts1, req->IOAddrLines))
1504	return CS_IN_USE;
1505
1506    if (req->NumPorts2) {
1507	if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1508			   req->NumPorts2, req->IOAddrLines)) {
1509	    release_io_space(s, req->BasePort1, req->NumPorts1);
1510	    return CS_IN_USE;
1511	}
1512    }
1513
1514    c->io = *req;
1515    c->state |= CONFIG_IO_REQ;
1516    handle->state |= CLIENT_IO_REQ;
1517    return CS_SUCCESS;
1518} /* request_io */
1519
1520/*======================================================================
1521
1522    Request_irq() reserves an irq for this client.
1523
1524    Also, since Linux only reserves irq's when they are actually
1525    hooked, we don't guarantee that an irq will still be available
1526    when the configuration is locked.  Now that I think about it,
1527    there might be a way to fix this using a dummy handler.
1528    
1529======================================================================*/
1530
1531#ifdef CONFIG_PCMCIA_PROBE
1532static irqreturn_t test_action(int cpl, void *dev_id, struct pt_regs *regs)
1533{
1534	return IRQ_NONE;
1535}
1536#endif
1537
1538int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1539{
1540	struct pcmcia_socket *s;
1541	config_t *c;
1542	int ret = CS_IN_USE, irq = 0;
1543	struct pcmcia_device *p_dev = handle_to_pdev(handle);
1544
1545	if (CHECK_HANDLE(handle))
1546		return CS_BAD_HANDLE;
1547	s = SOCKET(handle);
1548	if (!(s->state & SOCKET_PRESENT))
1549		return CS_NO_CARD;
1550	c = CONFIG(handle);
1551	if (c->state & CONFIG_LOCKED)
1552		return CS_CONFIGURATION_LOCKED;
1553	if (c->state & CONFIG_IRQ_REQ)
1554		return CS_IN_USE;
1555
1556#ifdef CONFIG_PCMCIA_PROBE
1557	if (s->irq.AssignedIRQ != 0) {
1558		/* If the interrupt is already assigned, it must be the same */
1559		irq = s->irq.AssignedIRQ;
1560	} else {
1561		int try;
1562		u32 mask = s->irq_mask;
1563		void *data = NULL;
1564
1565		for (try = 0; try < 64; try++) {
1566			irq = try % 32;
1567
1568			/* marked as available by driver, and not blocked by userspace? */
1569			if (!((mask >> irq) & 1))
1570				continue;
1571
1572			/* avoid an IRQ which is already used by a PCMCIA card */
1573			if ((try < 32) && pcmcia_used_irq[irq])
1574				continue;
1575
1576			/* register the correct driver, if possible, of check whether
1577			 * registering a dummy handle works, i.e. if the IRQ isn't
1578			 * marked as used by the kernel resource management core */
1579			ret = request_irq(irq,
1580					  (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Handler : test_action,
1581					  ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1582					   (s->functions > 1) ||
1583					   (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1584					  p_dev->dev.bus_id,
1585					  (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data);
1586			if (!ret) {
1587				if (!(req->Attributes & IRQ_HANDLE_PRESENT))
1588					free_irq(irq, data);
1589				break;
1590			}
1591		}
1592	}
1593#endif
1594	if (ret) {
1595		if (!s->pci_irq)
1596			return ret;
1597		irq = s->pci_irq;
1598	}
1599
1600	if (ret && req->Attributes & IRQ_HANDLE_PRESENT) {
1601		if (request_irq(irq, req->Handler,
1602				((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1603				 (s->functions > 1) ||
1604				 (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1605				p_dev->dev.bus_id, req->Instance))
1606			return CS_IN_USE;
1607	}
1608
1609	c->irq.Attributes = req->Attributes;
1610	s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1611	s->irq.Config++;
1612
1613	c->state |= CONFIG_IRQ_REQ;
1614	handle->state |= CLIENT_IRQ_REQ;
1615
1616#ifdef CONFIG_PCMCIA_PROBE
1617	pcmcia_used_irq[irq]++;
1618#endif
1619
1620	return CS_SUCCESS;
1621} /* pcmcia_request_irq */
1622
1623/*======================================================================
1624
1625    Request_window() establishes a mapping between card memory space
1626    and system memory space.
1627
1628======================================================================*/
1629
1630int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1631{
1632    struct pcmcia_socket *s;
1633    window_t *win;
1634    u_long align;
1635    int w;
1636    
1637    if (CHECK_HANDLE(*handle))
1638	return CS_BAD_HANDLE;
1639    s = (*handle)->Socket;
1640    if (!(s->state & SOCKET_PRESENT))
1641	return CS_NO_CARD;
1642    if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1643	return CS_BAD_ATTRIBUTE;
1644
1645    /* Window size defaults to smallest available */
1646    if (req->Size == 0)
1647	req->Size = s->map_size;
1648    align = (((s->features & SS_CAP_MEM_ALIGN) ||
1649	      (req->Attributes & WIN_STRICT_ALIGN)) ?
1650	     req->Size : s->map_size);
1651    if (req->Size & (s->map_size-1))
1652	return CS_BAD_SIZE;
1653    if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1654	(req->Base & (align-1)))
1655	return CS_BAD_BASE;
1656    if (req->Base)
1657	align = 0;
1658
1659    /* Allocate system memory window */
1660    for (w = 0; w < MAX_WIN; w++)
1661	if (!(s->state & SOCKET_WIN_REQ(w))) break;
1662    if (w == MAX_WIN)
1663	return CS_OUT_OF_RESOURCE;
1664
1665    win = &s->win[w];
1666    win->magic = WINDOW_MAGIC;
1667    win->index = w;
1668    win->handle = *handle;
1669    win->sock = s;
1670
1671    if (!(s->features & SS_CAP_STATIC_MAP)) {
1672	win->ctl.res = find_mem_region(req->Base, req->Size, align,
1673				       (req->Attributes & WIN_MAP_BELOW_1MB), s);
1674	if (!win->ctl.res)
1675	    return CS_IN_USE;
1676    }
1677    (*handle)->state |= CLIENT_WIN_REQ(w);
1678
1679    /* Configure the socket controller */
1680    win->ctl.map = w+1;
1681    win->ctl.flags = 0;
1682    win->ctl.speed = req->AccessSpeed;
1683    if (req->Attributes & WIN_MEMORY_TYPE)
1684	win->ctl.flags |= MAP_ATTRIB;
1685    if (req->Attributes & WIN_ENABLE)
1686	win->ctl.flags |= MAP_ACTIVE;
1687    if (req->Attributes & WIN_DATA_WIDTH_16)
1688	win->ctl.flags |= MAP_16BIT;
1689    if (req->Attributes & WIN_USE_WAIT)
1690	win->ctl.flags |= MAP_USE_WAIT;
1691    win->ctl.card_start = 0;
1692    if (s->ops->set_mem_map(s, &win->ctl) != 0)
1693	return CS_BAD_ARGS;
1694    s->state |= SOCKET_WIN_REQ(w);
1695
1696    /* Return window handle */
1697    if (s->features & SS_CAP_STATIC_MAP) {
1698	req->Base = win->ctl.static_start;
1699    } else {
1700	req->Base = win->ctl.res->start;
1701    }
1702    *wh = win;
1703    
1704    return CS_SUCCESS;
1705} /* request_window */
1706
1707/*======================================================================
1708
1709    I'm not sure which "reset" function this is supposed to use,
1710    but for now, it uses the low-level interface's reset, not the
1711    CIS register.
1712    
1713======================================================================*/
1714
1715int pccard_reset_card(struct pcmcia_socket *skt)
1716{
1717	int ret;
1718    
1719	cs_dbg(skt, 1, "resetting socket\n");
1720
1721	down(&skt->skt_sem);
1722	do {
1723		if (!(skt->state & SOCKET_PRESENT)) {
1724			ret = CS_NO_CARD;
1725			break;
1726		}
1727		if (skt->state & SOCKET_SUSPEND) {
1728			ret = CS_IN_USE;
1729			break;
1730		}
1731		if (skt->state & SOCKET_CARDBUS) {
1732			ret = CS_UNSUPPORTED_FUNCTION;
1733			break;
1734		}
1735
1736		ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1737		if (ret == 0) {
1738			send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1739			if (socket_reset(skt) == CS_SUCCESS)
1740				send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1741		}
1742
1743		ret = CS_SUCCESS;
1744	} while (0);
1745	up(&skt->skt_sem);
1746
1747	return ret;
1748} /* reset_card */
1749EXPORT_SYMBOL(pccard_reset_card);
1750
1751/*======================================================================
1752
1753    These shut down or wake up a socket.  They are sort of user
1754    initiated versions of the APM suspend and resume actions.
1755    
1756======================================================================*/
1757
1758int pcmcia_suspend_card(struct pcmcia_socket *skt)
1759{
1760	int ret;
1761    
1762	cs_dbg(skt, 1, "suspending socket\n");
1763
1764	down(&skt->skt_sem);
1765	do {
1766		if (!(skt->state & SOCKET_PRESENT)) {
1767			ret = CS_NO_CARD;
1768			break;
1769		}
1770		if (skt->state & SOCKET_CARDBUS) {
1771			ret = CS_UNSUPPORTED_FUNCTION;
1772			break;
1773		}
1774		ret = socket_suspend(skt);
1775	} while (0);
1776	up(&skt->skt_sem);
1777
1778	return ret;
1779} /* suspend_card */
1780
1781int pcmcia_resume_card(struct pcmcia_socket *skt)
1782{
1783	int ret;
1784    
1785	cs_dbg(skt, 1, "waking up socket\n");
1786
1787	down(&skt->skt_sem);
1788	do {
1789		if (!(skt->state & SOCKET_PRESENT)) {
1790			ret = CS_NO_CARD;
1791			break;
1792		}
1793		if (skt->state & SOCKET_CARDBUS) {
1794			ret = CS_UNSUPPORTED_FUNCTION;
1795			break;
1796		}
1797		ret = socket_resume(skt);
1798	} while (0);
1799	up(&skt->skt_sem);
1800
1801	return ret;
1802} /* resume_card */
1803
1804/*======================================================================
1805
1806    These handle user requests to eject or insert a card.
1807    
1808======================================================================*/
1809
1810int pcmcia_eject_card(struct pcmcia_socket *skt)
1811{
1812	int ret;
1813    
1814	cs_dbg(skt, 1, "user eject request\n");
1815
1816	down(&skt->skt_sem);
1817	do {
1818		if (!(skt->state & SOCKET_PRESENT)) {
1819			ret = -ENODEV;
1820			break;
1821		}
1822
1823		ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
1824		if (ret != 0) {
1825			ret = -EINVAL;
1826			break;
1827		}
1828
1829		socket_remove(skt);
1830		ret = 0;
1831	} while (0);
1832	up(&skt->skt_sem);
1833
1834	return ret;
1835} /* eject_card */
1836
1837int pcmcia_insert_card(struct pcmcia_socket *skt)
1838{
1839	int ret;
1840
1841	cs_dbg(skt, 1, "user insert request\n");
1842
1843	down(&skt->skt_sem);
1844	do {
1845		if (skt->state & SOCKET_PRESENT) {
1846			ret = -EBUSY;
1847			break;
1848		}
1849		if (socket_insert(skt) == CS_NO_CARD) {
1850			ret = -ENODEV;
1851			break;
1852		}
1853		ret = 0;
1854	} while (0);
1855	up(&skt->skt_sem);
1856
1857	return ret;
1858} /* insert_card */
1859
1860/*======================================================================
1861
1862    OS-specific module glue goes here
1863    
1864======================================================================*/
1865/* in alpha order */
1866EXPORT_SYMBOL(pcmcia_eject_card);
1867EXPORT_SYMBOL(pcmcia_get_card_services_info);
1868EXPORT_SYMBOL(pcmcia_get_mem_page);
1869EXPORT_SYMBOL(pcmcia_insert_card);
1870EXPORT_SYMBOL(pcmcia_map_mem_page);
1871EXPORT_SYMBOL(pcmcia_modify_configuration);
1872EXPORT_SYMBOL(pcmcia_release_configuration);
1873EXPORT_SYMBOL(pcmcia_release_io);
1874EXPORT_SYMBOL(pcmcia_release_irq);
1875EXPORT_SYMBOL(pcmcia_release_window);
1876EXPORT_SYMBOL(pcmcia_replace_cis);
1877EXPORT_SYMBOL(pcmcia_request_configuration);
1878EXPORT_SYMBOL(pcmcia_request_io);
1879EXPORT_SYMBOL(pcmcia_request_irq);
1880EXPORT_SYMBOL(pcmcia_request_window);
1881EXPORT_SYMBOL(pcmcia_resume_card);
1882EXPORT_SYMBOL(pcmcia_suspend_card);
1883
1884EXPORT_SYMBOL(dead_socket);
1885EXPORT_SYMBOL(pcmcia_parse_events);
1886
1887struct class pcmcia_socket_class = {
1888	.name = "pcmcia_socket",
1889	.release = pcmcia_release_socket,
1890};
1891EXPORT_SYMBOL(pcmcia_socket_class);
1892
1893
1894static int __init init_pcmcia_cs(void)
1895{
1896	int ret;
1897	printk(KERN_INFO "%s\n", release);
1898	printk(KERN_INFO "  %s\n

Large files files are truncated, but you can click here to view the full file