1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * ds.c -- 16-bit PCMCIA core support
   4 *
   5 * The initial developer of the original code is David A. Hinds
   6 * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
   7 * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
   8 *
   9 * (C) 1999		David A. Hinds
  10 * (C) 2003 - 2010	Dominik Brodowski
  11 */
  12
  13#include <linux/kernel.h>
  14#include <linux/module.h>
  15#include <linux/init.h>
  16#include <linux/errno.h>
  17#include <linux/list.h>
  18#include <linux/delay.h>
  19#include <linux/workqueue.h>
  20#include <linux/crc32.h>
  21#include <linux/firmware.h>
  22#include <linux/kref.h>
  23#include <linux/dma-mapping.h>
  24#include <linux/slab.h>
  25
  26#include <pcmcia/cistpl.h>
  27#include <pcmcia/ds.h>
  28#include <pcmcia/ss.h>
  29
  30#include "cs_internal.h"
  31
  32/*====================================================================*/
  33
  34/* Module parameters */
  35
  36MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  37MODULE_DESCRIPTION("PCMCIA Driver Services");
  38MODULE_LICENSE("GPL");
  39
  40
  41/*====================================================================*/
  42
  43static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
  44{
  45	const struct pcmcia_device_id *did = p_drv->id_table;
  46	unsigned int i;
  47	u32 hash;
  48
  49	if (!p_drv->probe || !p_drv->remove)
  50		printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "
  51		       "function\n", p_drv->name);
  52
  53	while (did && did->match_flags) {
  54		for (i = 0; i < 4; i++) {
  55			if (!did->prod_id[i])
  56				continue;
  57
  58			hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
  59			if (hash == did->prod_id_hash[i])
  60				continue;
  61
  62			printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
  63			       "product string \"%s\": is 0x%x, should "
  64			       "be 0x%x\n", p_drv->name, did->prod_id[i],
  65			       did->prod_id_hash[i], hash);
  66			printk(KERN_DEBUG "pcmcia: see "
  67				"Documentation/pcmcia/devicetable.rst for "
  68				"details\n");
  69		}
  70		did++;
  71	}
  72
  73	return;
  74}
  75
  76
  77/*======================================================================*/
  78
  79
  80struct pcmcia_dynid {
  81	struct list_head		node;
  82	struct pcmcia_device_id		id;
  83};
  84
  85/**
  86 * pcmcia_store_new_id - add a new PCMCIA device ID to this driver and re-probe devices
  87 * @driver: target device driver
  88 * @buf: buffer for scanning device ID data
  89 * @count: input size
  90 *
  91 * Adds a new dynamic PCMCIA device ID to this driver,
  92 * and causes the driver to probe for all devices again.
  93 */
  94static ssize_t
  95new_id_store(struct device_driver *driver, const char *buf, size_t count)
  96{
  97	struct pcmcia_dynid *dynid;
  98	struct pcmcia_driver *pdrv = to_pcmcia_drv(driver);
  99	__u16 match_flags, manf_id, card_id;
 100	__u8 func_id, function, device_no;
 101	__u32 prod_id_hash[4] = {0, 0, 0, 0};
 102	int fields = 0;
 103	int retval = 0;
 104
 105	fields = sscanf(buf, "%hx %hx %hx %hhx %hhx %hhx %x %x %x %x",
 106			&match_flags, &manf_id, &card_id, &func_id, &function, &device_no,
 107			&prod_id_hash[0], &prod_id_hash[1], &prod_id_hash[2], &prod_id_hash[3]);
 108	if (fields < 6)
 109		return -EINVAL;
 110
 111	dynid = kzalloc(sizeof(struct pcmcia_dynid), GFP_KERNEL);
 112	if (!dynid)
 113		return -ENOMEM;
 114
 115	dynid->id.match_flags = match_flags;
 116	dynid->id.manf_id = manf_id;
 117	dynid->id.card_id = card_id;
 118	dynid->id.func_id = func_id;
 119	dynid->id.function = function;
 120	dynid->id.device_no = device_no;
 121	memcpy(dynid->id.prod_id_hash, prod_id_hash, sizeof(__u32) * 4);
 122
 123	mutex_lock(&pdrv->dynids.lock);
 124	list_add_tail(&dynid->node, &pdrv->dynids.list);
 125	mutex_unlock(&pdrv->dynids.lock);
 126
 127	retval = driver_attach(&pdrv->drv);
 128
 129	if (retval)
 130		return retval;
 131	return count;
 132}
 133static DRIVER_ATTR_WO(new_id);
 134
 135static void
 136pcmcia_free_dynids(struct pcmcia_driver *drv)
 137{
 138	struct pcmcia_dynid *dynid, *n;
 139
 140	mutex_lock(&drv->dynids.lock);
 141	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
 142		list_del(&dynid->node);
 143		kfree(dynid);
 144	}
 145	mutex_unlock(&drv->dynids.lock);
 146}
 147
 148static int
 149pcmcia_create_newid_file(struct pcmcia_driver *drv)
 150{
 151	int error = 0;
 152	if (drv->probe != NULL)
 153		error = driver_create_file(&drv->drv, &driver_attr_new_id);
 154	return error;
 155}
 156
 157static void
 158pcmcia_remove_newid_file(struct pcmcia_driver *drv)
 159{
 160	driver_remove_file(&drv->drv, &driver_attr_new_id);
 161}
 162
 163/**
 164 * pcmcia_register_driver - register a PCMCIA driver with the bus core
 165 * @driver: the &driver being registered
 166 *
 167 * Registers a PCMCIA driver with the PCMCIA bus core.
 168 */
 169int pcmcia_register_driver(struct pcmcia_driver *driver)
 170{
 171	int error;
 172
 173	if (!driver)
 174		return -EINVAL;
 175
 176	pcmcia_check_driver(driver);
 177
 178	/* initialize common fields */
 179	driver->drv.bus = &pcmcia_bus_type;
 180	driver->drv.owner = driver->owner;
 181	driver->drv.name = driver->name;
 182	mutex_init(&driver->dynids.lock);
 183	INIT_LIST_HEAD(&driver->dynids.list);
 184
 185	pr_debug("registering driver %s\n", driver->name);
 186
 187	error = driver_register(&driver->drv);
 188	if (error < 0)
 189		return error;
 190
 191	error = pcmcia_create_newid_file(driver);
 192	if (error)
 193		driver_unregister(&driver->drv);
 194
 195	return error;
 196}
 197EXPORT_SYMBOL(pcmcia_register_driver);
 198
 199/**
 200 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
 201 * @driver: the &driver being unregistered
 202 */
 203void pcmcia_unregister_driver(struct pcmcia_driver *driver)
 204{
 205	pr_debug("unregistering driver %s\n", driver->name);
 206	pcmcia_remove_newid_file(driver);
 207	driver_unregister(&driver->drv);
 208	pcmcia_free_dynids(driver);
 209}
 210EXPORT_SYMBOL(pcmcia_unregister_driver);
 211
 212
 213/* pcmcia_device handling */
 214
 215static struct pcmcia_device *pcmcia_get_dev(struct pcmcia_device *p_dev)
 216{
 217	struct device *tmp_dev;
 218	tmp_dev = get_device(&p_dev->dev);
 219	if (!tmp_dev)
 220		return NULL;
 221	return to_pcmcia_dev(tmp_dev);
 222}
 223
 224static void pcmcia_put_dev(struct pcmcia_device *p_dev)
 225{
 226	if (p_dev)
 227		put_device(&p_dev->dev);
 228}
 229
 230static void pcmcia_release_function(struct kref *ref)
 231{
 232	struct config_t *c = container_of(ref, struct config_t, ref);
 233	pr_debug("releasing config_t\n");
 234	kfree(c);
 235}
 236
 237static void pcmcia_release_dev(struct device *dev)
 238{
 239	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 240	int i;
 241	dev_dbg(dev, "releasing device\n");
 242	pcmcia_put_socket(p_dev->socket);
 243	for (i = 0; i < 4; i++)
 244		kfree(p_dev->prod_id[i]);
 245	kfree(p_dev->devname);
 246	kref_put(&p_dev->function_config->ref, pcmcia_release_function);
 247	kfree(p_dev);
 248}
 249
 250
 251static int pcmcia_device_probe(struct device *dev)
 252{
 253	struct pcmcia_device *p_dev;
 254	struct pcmcia_driver *p_drv;
 255	struct pcmcia_socket *s;
 256	cistpl_config_t cis_config;
 257	int ret = 0;
 258
 259	dev = get_device(dev);
 260	if (!dev)
 261		return -ENODEV;
 262
 263	p_dev = to_pcmcia_dev(dev);
 264	p_drv = to_pcmcia_drv(dev->driver);
 265	s = p_dev->socket;
 266
 267	dev_dbg(dev, "trying to bind to %s\n", p_drv->name);
 268
 269	if ((!p_drv->probe) || (!p_dev->function_config) ||
 270	    (!try_module_get(p_drv->owner))) {
 271		ret = -EINVAL;
 272		goto put_dev;
 273	}
 274
 275	/* set up some more device information */
 276	ret = pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_CONFIG,
 277				&cis_config);
 278	if (!ret) {
 279		p_dev->config_base = cis_config.base;
 280		p_dev->config_regs = cis_config.rmask[0];
 281		dev_dbg(dev, "base %x, regs %x", p_dev->config_base,
 282			p_dev->config_regs);
 283	} else {
 284		dev_info(dev,
 285			 "pcmcia: could not parse base and rmask0 of CIS\n");
 286		p_dev->config_base = 0;
 287		p_dev->config_regs = 0;
 288	}
 289
 290	ret = p_drv->probe(p_dev);
 291	if (ret) {
 292		dev_dbg(dev, "binding to %s failed with %d\n",
 293			   p_drv->name, ret);
 294		goto put_module;
 295	}
 296	dev_dbg(dev, "%s bound: Vpp %d.%d, idx %x, IRQ %d", p_drv->name,
 297		p_dev->vpp/10, p_dev->vpp%10, p_dev->config_index, p_dev->irq);
 298	dev_dbg(dev, "resources: ioport %pR %pR iomem %pR %pR %pR",
 299		p_dev->resource[0], p_dev->resource[1], p_dev->resource[2],
 300		p_dev->resource[3], p_dev->resource[4]);
 301
 302	mutex_lock(&s->ops_mutex);
 303	if ((s->pcmcia_pfc) &&
 304	    (p_dev->socket->device_count == 1) && (p_dev->device_no == 0))
 305		pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
 306	mutex_unlock(&s->ops_mutex);
 307
 308put_module:
 309	if (ret)
 310		module_put(p_drv->owner);
 311put_dev:
 312	if (ret)
 313		put_device(dev);
 314	return ret;
 315}
 316
 317
 318/*
 319 * Removes a PCMCIA card from the device tree and socket list.
 320 */
 321static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover)
 322{
 323	struct pcmcia_device	*p_dev;
 324	struct pcmcia_device	*tmp;
 325
 326	dev_dbg(leftover ? &leftover->dev : &s->dev,
 327		   "pcmcia_card_remove(%d) %s\n", s->sock,
 328		   leftover ? leftover->devname : "");
 329
 330	mutex_lock(&s->ops_mutex);
 331	if (!leftover)
 332		s->device_count = 0;
 333	else
 334		s->device_count = 1;
 335	mutex_unlock(&s->ops_mutex);
 336
 337	/* unregister all pcmcia_devices registered with this socket, except leftover */
 338	list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) {
 339		if (p_dev == leftover)
 340			continue;
 341
 342		mutex_lock(&s->ops_mutex);
 343		list_del(&p_dev->socket_device_list);
 344		mutex_unlock(&s->ops_mutex);
 345
 346		dev_dbg(&p_dev->dev, "unregistering device\n");
 347		device_unregister(&p_dev->dev);
 348	}
 349
 350	return;
 351}
 352
 353static int pcmcia_device_remove(struct device *dev)
 354{
 355	struct pcmcia_device *p_dev;
 356	struct pcmcia_driver *p_drv;
 357	int i;
 358
 359	p_dev = to_pcmcia_dev(dev);
 360	p_drv = to_pcmcia_drv(dev->driver);
 361
 362	dev_dbg(dev, "removing device\n");
 363
 364	/* If we're removing the primary module driving a
 365	 * pseudo multi-function card, we need to unbind
 366	 * all devices
 367	 */
 368	if ((p_dev->socket->pcmcia_pfc) &&
 369	    (p_dev->socket->device_count > 0) &&
 370	    (p_dev->device_no == 0))
 371		pcmcia_card_remove(p_dev->socket, p_dev);
 372
 373	/* detach the "instance" */
 374	if (!p_drv)
 375		return 0;
 376
 377	if (p_drv->remove)
 378		p_drv->remove(p_dev);
 379
 380	/* check for proper unloading */
 381	if (p_dev->_irq || p_dev->_io || p_dev->_locked)
 382		dev_info(dev,
 383			 "pcmcia: driver %s did not release config properly\n",
 384			 p_drv->name);
 385
 386	for (i = 0; i < MAX_WIN; i++)
 387		if (p_dev->_win & CLIENT_WIN_REQ(i))
 388			dev_info(dev,
 389				 "pcmcia: driver %s did not release window properly\n",
 390				 p_drv->name);
 391
 392	/* references from pcmcia_probe_device */
 393	pcmcia_put_dev(p_dev);
 394	module_put(p_drv->owner);
 395
 396	return 0;
 397}
 398
 399
 400/*
 401 * pcmcia_device_query -- determine information about a pcmcia device
 402 */
 403static int pcmcia_device_query(struct pcmcia_device *p_dev)
 404{
 405	cistpl_manfid_t manf_id;
 406	cistpl_funcid_t func_id;
 407	cistpl_vers_1_t	*vers1;
 408	unsigned int i;
 409
 410	vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);
 411	if (!vers1)
 412		return -ENOMEM;
 413
 414	if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL,
 415			       CISTPL_MANFID, &manf_id)) {
 416		mutex_lock(&p_dev->socket->ops_mutex);
 417		p_dev->manf_id = manf_id.manf;
 418		p_dev->card_id = manf_id.card;
 419		p_dev->has_manf_id = 1;
 420		p_dev->has_card_id = 1;
 421		mutex_unlock(&p_dev->socket->ops_mutex);
 422	}
 423
 424	if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 425			       CISTPL_FUNCID, &func_id)) {
 426		mutex_lock(&p_dev->socket->ops_mutex);
 427		p_dev->func_id = func_id.func;
 428		p_dev->has_func_id = 1;
 429		mutex_unlock(&p_dev->socket->ops_mutex);
 430	} else {
 431		/* rule of thumb: cards with no FUNCID, but with
 432		 * common memory device geometry information, are
 433		 * probably memory cards (from pcmcia-cs) */
 434		cistpl_device_geo_t *devgeo;
 435
 436		devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);
 437		if (!devgeo) {
 438			kfree(vers1);
 439			return -ENOMEM;
 440		}
 441		if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 442				      CISTPL_DEVICE_GEO, devgeo)) {
 443			dev_dbg(&p_dev->dev,
 444				   "mem device geometry probably means "
 445				   "FUNCID_MEMORY\n");
 446			mutex_lock(&p_dev->socket->ops_mutex);
 447			p_dev->func_id = CISTPL_FUNCID_MEMORY;
 448			p_dev->has_func_id = 1;
 449			mutex_unlock(&p_dev->socket->ops_mutex);
 450		}
 451		kfree(devgeo);
 452	}
 453
 454	if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1,
 455			       vers1)) {
 456		mutex_lock(&p_dev->socket->ops_mutex);
 457		for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) {
 458			char *tmp;
 459			unsigned int length;
 460			char *new;
 461
 462			tmp = vers1->str + vers1->ofs[i];
 463
 464			length = strlen(tmp) + 1;
 465			if ((length < 2) || (length > 255))
 466				continue;
 467
 468			new = kstrdup(tmp, GFP_KERNEL);
 469			if (!new)
 470				continue;
 471
 472			tmp = p_dev->prod_id[i];
 473			p_dev->prod_id[i] = new;
 474			kfree(tmp);
 475		}
 476		mutex_unlock(&p_dev->socket->ops_mutex);
 477	}
 478
 479	kfree(vers1);
 480	return 0;
 481}
 482
 483
 484static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,
 485					       unsigned int function)
 486{
 487	struct pcmcia_device *p_dev, *tmp_dev;
 488	int i;
 489
 490	s = pcmcia_get_socket(s);
 491	if (!s)
 492		return NULL;
 493
 494	pr_debug("adding device to %d, function %d\n", s->sock, function);
 495
 496	p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
 497	if (!p_dev)
 498		goto err_put;
 499
 500	mutex_lock(&s->ops_mutex);
 501	p_dev->device_no = (s->device_count++);
 502	mutex_unlock(&s->ops_mutex);
 503
 504	/* max of 2 PFC devices */
 505	if ((p_dev->device_no >= 2) && (function == 0))
 506		goto err_free;
 507
 508	/* max of 4 devices overall */
 509	if (p_dev->device_no >= 4)
 510		goto err_free;
 511
 512	p_dev->socket = s;
 513	p_dev->func   = function;
 514
 515	p_dev->dev.bus = &pcmcia_bus_type;
 516	p_dev->dev.parent = s->dev.parent;
 517	p_dev->dev.release = pcmcia_release_dev;
 518	/* by default don't allow DMA */
 519	p_dev->dma_mask = DMA_MASK_NONE;
 520	p_dev->dev.dma_mask = &p_dev->dma_mask;
 521	dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);
 522	if (!dev_name(&p_dev->dev))
 523		goto err_free;
 524	p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));
 525	if (!p_dev->devname)
 526		goto err_free;
 527	dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);
 528
 529	mutex_lock(&s->ops_mutex);
 530
 531	/*
 532	 * p_dev->function_config must be the same for all card functions.
 533	 * Note that this is serialized by ops_mutex, so that only one
 534	 * such struct will be created.
 535	 */
 536	list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
 537		if (p_dev->func == tmp_dev->func) {
 538			p_dev->function_config = tmp_dev->function_config;
 539			p_dev->irq = tmp_dev->irq;
 540			kref_get(&p_dev->function_config->ref);
 541		}
 542
 543	/* Add to the list in pcmcia_bus_socket */
 544	list_add(&p_dev->socket_device_list, &s->devices_list);
 545
 546	if (pcmcia_setup_irq(p_dev))
 547		dev_warn(&p_dev->dev,
 548			"IRQ setup failed -- device might not work\n");
 549
 550	if (!p_dev->function_config) {
 551		config_t *c;
 552		dev_dbg(&p_dev->dev, "creating config_t\n");
 553		c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
 554		if (!c) {
 555			mutex_unlock(&s->ops_mutex);
 556			goto err_unreg;
 557		}
 558		p_dev->function_config = c;
 559		kref_init(&c->ref);
 560		for (i = 0; i < MAX_IO_WIN; i++) {
 561			c->io[i].name = p_dev->devname;
 562			c->io[i].flags = IORESOURCE_IO;
 563		}
 564		for (i = 0; i < MAX_WIN; i++) {
 565			c->mem[i].name = p_dev->devname;
 566			c->mem[i].flags = IORESOURCE_MEM;
 567		}
 568	}
 569	for (i = 0; i < MAX_IO_WIN; i++)
 570		p_dev->resource[i] = &p_dev->function_config->io[i];
 571	for (; i < (MAX_IO_WIN + MAX_WIN); i++)
 572		p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];
 573
 574	mutex_unlock(&s->ops_mutex);
 575
 576	dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",
 577		   p_dev->devname, p_dev->irq);
 578
 579	pcmcia_device_query(p_dev);
 580
 581	if (device_register(&p_dev->dev))
 582		goto err_unreg;
 583
 584	return p_dev;
 585
 586 err_unreg:
 587	mutex_lock(&s->ops_mutex);
 588	list_del(&p_dev->socket_device_list);
 589	mutex_unlock(&s->ops_mutex);
 590
 591 err_free:
 592	mutex_lock(&s->ops_mutex);
 593	s->device_count--;
 594	mutex_unlock(&s->ops_mutex);
 595
 596	for (i = 0; i < 4; i++)
 597		kfree(p_dev->prod_id[i]);
 598	kfree(p_dev->devname);
 599	kfree(p_dev);
 600 err_put:
 601	pcmcia_put_socket(s);
 602
 603	return NULL;
 604}
 605
 606
 607static int pcmcia_card_add(struct pcmcia_socket *s)
 608{
 609	cistpl_longlink_mfc_t mfc;
 610	unsigned int no_funcs, i, no_chains;
 611	int ret = -EAGAIN;
 612
 613	mutex_lock(&s->ops_mutex);
 614	if (!(s->resource_setup_done)) {
 615		dev_dbg(&s->dev,
 616			   "no resources available, delaying card_add\n");
 617		mutex_unlock(&s->ops_mutex);
 618		return -EAGAIN; /* try again, but later... */
 619	}
 620
 621	if (pcmcia_validate_mem(s)) {
 622		dev_dbg(&s->dev, "validating mem resources failed, "
 623		       "delaying card_add\n");
 624		mutex_unlock(&s->ops_mutex);
 625		return -EAGAIN; /* try again, but later... */
 626	}
 627	mutex_unlock(&s->ops_mutex);
 628
 629	ret = pccard_validate_cis(s, &no_chains);
 630	if (ret || !no_chains) {
 631#if defined(CONFIG_MTD_PCMCIA_ANONYMOUS)
 632		/* Set up as an anonymous card. If we don't have anonymous
 633		   memory support then just error the card as there is no
 634		   point trying to second guess.
 635
 636		   Note: some cards have just a device entry, it may be
 637		   worth extending support to cover these in future */
 638		if (ret == -EIO) {
 639			dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");
 640			pcmcia_replace_cis(s, "\xFF", 1);
 641			no_chains = 1;
 642			ret = 0;
 643		} else
 644#endif
 645		{
 646			dev_dbg(&s->dev, "invalid CIS or invalid resources\n");
 647			return -ENODEV;
 648		}
 649	}
 650
 651	if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
 652		no_funcs = mfc.nfn;
 653	else
 654		no_funcs = 1;
 655	s->functions = no_funcs;
 656
 657	for (i = 0; i < no_funcs; i++)
 658		pcmcia_device_add(s, i);
 659
 660	return ret;
 661}
 662
 663
 664static int pcmcia_requery_callback(struct device *dev, void *_data)
 665{
 666	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 667	if (!p_dev->dev.driver) {
 668		dev_dbg(dev, "update device information\n");
 669		pcmcia_device_query(p_dev);
 670	}
 671
 672	return 0;
 673}
 674
 675
 676static void pcmcia_requery(struct pcmcia_socket *s)
 677{
 678	int has_pfc;
 679
 680	if (!(s->state & SOCKET_PRESENT))
 681		return;
 682
 683	if (s->functions == 0) {
 684		pcmcia_card_add(s);
 685		return;
 686	}
 687
 688	/* some device information might have changed because of a CIS
 689	 * update or because we can finally read it correctly... so
 690	 * determine it again, overwriting old values if necessary. */
 691	bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback);
 692
 693	/* if the CIS changed, we need to check whether the number of
 694	 * functions changed. */
 695	if (s->fake_cis) {
 696		int old_funcs, new_funcs;
 697		cistpl_longlink_mfc_t mfc;
 698
 699		/* does this cis override add or remove functions? */
 700		old_funcs = s->functions;
 701
 702		if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 703					&mfc))
 704			new_funcs = mfc.nfn;
 705		else
 706			new_funcs = 1;
 707		if (old_funcs != new_funcs) {
 708			/* we need to re-start */
 709			pcmcia_card_remove(s, NULL);
 710			s->functions = 0;
 711			pcmcia_card_add(s);
 712		}
 713	}
 714
 715	/* If the PCMCIA device consists of two pseudo devices,
 716	 * call pcmcia_device_add() -- which will fail if both
 717	 * devices are already registered. */
 718	mutex_lock(&s->ops_mutex);
 719	has_pfc = s->pcmcia_pfc;
 720	mutex_unlock(&s->ops_mutex);
 721	if (has_pfc)
 722		pcmcia_device_add(s, 0);
 723
 724	/* we re-scan all devices, not just the ones connected to this
 725	 * socket. This does not matter, though. */
 726	if (bus_rescan_devices(&pcmcia_bus_type))
 727		dev_warn(&s->dev, "rescanning the bus failed\n");
 728}
 729
 730
 731#ifdef CONFIG_PCMCIA_LOAD_CIS
 732
 733/**
 734 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
 735 * @dev: the pcmcia device which needs a CIS override
 736 * @filename: requested filename in /lib/firmware/
 737 *
 738 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
 739 * the one provided by the card is broken. The firmware files reside in
 740 * /lib/firmware/ in userspace.
 741 */
 742static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)
 743{
 744	struct pcmcia_socket *s = dev->socket;
 745	const struct firmware *fw;
 746	int ret = -ENOMEM;
 747	cistpl_longlink_mfc_t mfc;
 748	int old_funcs, new_funcs = 1;
 749
 750	if (!filename)
 751		return -EINVAL;
 752
 753	dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);
 754
 755	if (request_firmware(&fw, filename, &dev->dev) == 0) {
 756		if (fw->size >= CISTPL_MAX_CIS_SIZE) {
 757			ret = -EINVAL;
 758			dev_err(&dev->dev, "pcmcia: CIS override is too big\n");
 759			goto release;
 760		}
 761
 762		if (!pcmcia_replace_cis(s, fw->data, fw->size))
 763			ret = 0;
 764		else {
 765			dev_err(&dev->dev, "pcmcia: CIS override failed\n");
 766			goto release;
 767		}
 768
 769		/* we need to re-start if the number of functions changed */
 770		old_funcs = s->functions;
 771		if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 772					&mfc))
 773			new_funcs = mfc.nfn;
 774
 775		if (old_funcs != new_funcs)
 776			ret = -EBUSY;
 777
 778		/* update information */
 779		pcmcia_device_query(dev);
 780
 781		/* requery (as number of functions might have changed) */
 782		pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
 783	}
 784 release:
 785	release_firmware(fw);
 786
 787	return ret;
 788}
 789
 790#else /* !CONFIG_PCMCIA_LOAD_CIS */
 791
 792static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
 793				       char *filename)
 794{
 795	return -ENODEV;
 796}
 797
 798#endif
 799
 800
 801static inline int pcmcia_devmatch(struct pcmcia_device *dev,
 802				  const struct pcmcia_device_id *did)
 803{
 804	if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
 805		if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
 806			return 0;
 807	}
 808
 809	if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
 810		if ((!dev->has_card_id) || (dev->card_id != did->card_id))
 811			return 0;
 812	}
 813
 814	if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
 815		if (dev->func != did->function)
 816			return 0;
 817	}
 818
 819	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
 820		if (!dev->prod_id[0])
 821			return 0;
 822		if (strcmp(did->prod_id[0], dev->prod_id[0]))
 823			return 0;
 824	}
 825
 826	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
 827		if (!dev->prod_id[1])
 828			return 0;
 829		if (strcmp(did->prod_id[1], dev->prod_id[1]))
 830			return 0;
 831	}
 832
 833	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
 834		if (!dev->prod_id[2])
 835			return 0;
 836		if (strcmp(did->prod_id[2], dev->prod_id[2]))
 837			return 0;
 838	}
 839
 840	if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
 841		if (!dev->prod_id[3])
 842			return 0;
 843		if (strcmp(did->prod_id[3], dev->prod_id[3]))
 844			return 0;
 845	}
 846
 847	if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
 848		dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");
 849		mutex_lock(&dev->socket->ops_mutex);
 850		dev->socket->pcmcia_pfc = 1;
 851		mutex_unlock(&dev->socket->ops_mutex);
 852		if (dev->device_no != did->device_no)
 853			return 0;
 854	}
 855
 856	if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
 857		int ret;
 858
 859		if ((!dev->has_func_id) || (dev->func_id != did->func_id))
 860			return 0;
 861
 862		/* if this is a pseudo-multi-function device,
 863		 * we need explicit matches */
 864		if (dev->socket->pcmcia_pfc)
 865			return 0;
 866		if (dev->device_no)
 867			return 0;
 868
 869		/* also, FUNC_ID matching needs to be activated by userspace
 870		 * after it has re-checked that there is no possible module
 871		 * with a prod_id/manf_id/card_id match.
 872		 */
 873		mutex_lock(&dev->socket->ops_mutex);
 874		ret = dev->allow_func_id_match;
 875		mutex_unlock(&dev->socket->ops_mutex);
 876
 877		if (!ret) {
 878			dev_dbg(&dev->dev,
 879				"skipping FUNC_ID match until userspace ACK\n");
 880			return 0;
 881		}
 882	}
 883
 884	if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
 885		dev_dbg(&dev->dev, "device needs a fake CIS\n");
 886		if (!dev->socket->fake_cis)
 887			if (pcmcia_load_firmware(dev, did->cisfile))
 888				return 0;
 889	}
 890
 891	if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
 892		int i;
 893		for (i = 0; i < 4; i++)
 894			if (dev->prod_id[i])
 895				return 0;
 896		if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
 897			return 0;
 898	}
 899
 900	return 1;
 901}
 902
 903
 904static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
 905{
 906	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 907	struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);
 908	const struct pcmcia_device_id *did = p_drv->id_table;
 909	struct pcmcia_dynid *dynid;
 910
 911	/* match dynamic devices first */
 912	mutex_lock(&p_drv->dynids.lock);
 913	list_for_each_entry(dynid, &p_drv->dynids.list, node) {
 914		dev_dbg(dev, "trying to match to %s\n", drv->name);
 915		if (pcmcia_devmatch(p_dev, &dynid->id)) {
 916			dev_dbg(dev, "matched to %s\n", drv->name);
 917			mutex_unlock(&p_drv->dynids.lock);
 918			return 1;
 919		}
 920	}
 921	mutex_unlock(&p_drv->dynids.lock);
 922
 923	while (did && did->match_flags) {
 924		dev_dbg(dev, "trying to match to %s\n", drv->name);
 925		if (pcmcia_devmatch(p_dev, did)) {
 926			dev_dbg(dev, "matched to %s\n", drv->name);
 927			return 1;
 928		}
 929		did++;
 930	}
 931
 932	return 0;
 933}
 934
 935static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 936{
 937	struct pcmcia_device *p_dev;
 938	int i;
 939	u32 hash[4] = { 0, 0, 0, 0};
 940
 941	if (!dev)
 942		return -ENODEV;
 943
 944	p_dev = to_pcmcia_dev(dev);
 945
 946	/* calculate hashes */
 947	for (i = 0; i < 4; i++) {
 948		if (!p_dev->prod_id[i])
 949			continue;
 950		hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
 951	}
 952
 953	if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
 954		return -ENOMEM;
 955
 956	if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
 957		return -ENOMEM;
 958
 959	if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
 960			   "pa%08Xpb%08Xpc%08Xpd%08X",
 961			   p_dev->has_manf_id ? p_dev->manf_id : 0,
 962			   p_dev->has_card_id ? p_dev->card_id : 0,
 963			   p_dev->has_func_id ? p_dev->func_id : 0,
 964			   p_dev->func,
 965			   p_dev->device_no,
 966			   hash[0],
 967			   hash[1],
 968			   hash[2],
 969			   hash[3]))
 970		return -ENOMEM;
 971
 972	return 0;
 973}
 974
 975/************************ runtime PM support ***************************/
 976
 977static int pcmcia_dev_suspend(struct device *dev);
 978static int pcmcia_dev_resume(struct device *dev);
 979
 980static int runtime_suspend(struct device *dev)
 981{
 982	int rc;
 983
 984	device_lock(dev);
 985	rc = pcmcia_dev_suspend(dev);
 986	device_unlock(dev);
 987	return rc;
 988}
 989
 990static int runtime_resume(struct device *dev)
 991{
 992	int rc;
 993
 994	device_lock(dev);
 995	rc = pcmcia_dev_resume(dev);
 996	device_unlock(dev);
 997	return rc;
 998}
 999
1000/************************ per-device sysfs output ***************************/
1001
1002#define pcmcia_device_attr(field, test, format)				\
1003static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf)		\
1004{									\
1005	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);		\
1006	return p_dev->test ? sprintf(buf, format, p_dev->field) : -ENODEV; \
1007}									\
1008static DEVICE_ATTR_RO(field);
1009
1010#define pcmcia_device_stringattr(name, field)					\
1011static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf)		\
1012{									\
1013	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);		\
1014	return p_dev->field ? sprintf(buf, "%s\n", p_dev->field) : -ENODEV; \
1015}									\
1016static DEVICE_ATTR_RO(name);
1017
1018pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
1019pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
1020pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
1021pcmcia_device_stringattr(prod_id1, prod_id[0]);
1022pcmcia_device_stringattr(prod_id2, prod_id[1]);
1023pcmcia_device_stringattr(prod_id3, prod_id[2]);
1024pcmcia_device_stringattr(prod_id4, prod_id[3]);
1025
1026static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1027			     char *buf)
1028{
1029	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1030	return p_dev->socket ? sprintf(buf, "0x%02x\n", p_dev->func) : -ENODEV;
1031}
1032static DEVICE_ATTR_RO(function);
1033
1034static ssize_t resources_show(struct device *dev,
1035			      struct device_attribute *attr, char *buf)
1036{
1037	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1038	char *str = buf;
1039	int i;
1040
1041	for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
1042		str += sprintf(str, "%pr\n", p_dev->resource[i]);
1043
1044	return str - buf;
1045}
1046static DEVICE_ATTR_RO(resources);
1047
1048static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1049{
1050	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1051
1052	if (p_dev->suspended)
1053		return sprintf(buf, "off\n");
1054	else
1055		return sprintf(buf, "on\n");
1056}
1057
1058static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,
1059			      const char *buf, size_t count)
1060{
1061	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1062	int ret = 0;
1063
1064	if (!count)
1065		return -EINVAL;
1066
1067	if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
1068		ret = runtime_suspend(dev);
1069	else if (p_dev->suspended && !strncmp(buf, "on", 2))
1070		ret = runtime_resume(dev);
1071
1072	return ret ? ret : count;
1073}
1074static DEVICE_ATTR_RW(pm_state);
1075
1076static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
1077{
1078	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1079	int i;
1080	u32 hash[4] = { 0, 0, 0, 0};
1081
1082	/* calculate hashes */
1083	for (i = 0; i < 4; i++) {
1084		if (!p_dev->prod_id[i])
1085			continue;
1086		hash[i] = crc32(0, p_dev->prod_id[i],
1087				strlen(p_dev->prod_id[i]));
1088	}
1089	return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
1090				"pa%08Xpb%08Xpc%08Xpd%08X\n",
1091				p_dev->has_manf_id ? p_dev->manf_id : 0,
1092				p_dev->has_card_id ? p_dev->card_id : 0,
1093				p_dev->has_func_id ? p_dev->func_id : 0,
1094				p_dev->func, p_dev->device_no,
1095				hash[0], hash[1], hash[2], hash[3]);
1096}
1097static DEVICE_ATTR_RO(modalias);
1098
1099static ssize_t allow_func_id_match_store(struct device *dev,
1100		struct device_attribute *attr, const char *buf, size_t count)
1101{
1102	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1103
1104	if (!count)
1105		return -EINVAL;
1106
1107	mutex_lock(&p_dev->socket->ops_mutex);
1108	p_dev->allow_func_id_match = 1;
1109	mutex_unlock(&p_dev->socket->ops_mutex);
1110	pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY);
1111
1112	return count;
1113}
1114static DEVICE_ATTR_WO(allow_func_id_match);
1115
1116static struct attribute *pcmcia_dev_attrs[] = {
1117	&dev_attr_resources.attr,
1118	&dev_attr_pm_state.attr,
1119	&dev_attr_function.attr,
1120	&dev_attr_func_id.attr,
1121	&dev_attr_manf_id.attr,
1122	&dev_attr_card_id.attr,
1123	&dev_attr_prod_id1.attr,
1124	&dev_attr_prod_id2.attr,
1125	&dev_attr_prod_id3.attr,
1126	&dev_attr_prod_id4.attr,
1127	&dev_attr_modalias.attr,
1128	&dev_attr_allow_func_id_match.attr,
1129	NULL,
1130};
1131ATTRIBUTE_GROUPS(pcmcia_dev);
1132
1133/* PM support, also needed for reset */
1134
1135static int pcmcia_dev_suspend(struct device *dev)
1136{
1137	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1138	struct pcmcia_driver *p_drv = NULL;
1139	int ret = 0;
1140
1141	mutex_lock(&p_dev->socket->ops_mutex);
1142	if (p_dev->suspended) {
1143		mutex_unlock(&p_dev->socket->ops_mutex);
1144		return 0;
1145	}
1146	p_dev->suspended = 1;
1147	mutex_unlock(&p_dev->socket->ops_mutex);
1148
1149	dev_dbg(dev, "suspending\n");
1150
1151	if (dev->driver)
1152		p_drv = to_pcmcia_drv(dev->driver);
1153
1154	if (!p_drv)
1155		goto out;
1156
1157	if (p_drv->suspend) {
1158		ret = p_drv->suspend(p_dev);
1159		if (ret) {
1160			dev_err(dev,
1161				"pcmcia: device %s (driver %s) did not want to go to sleep (%d)\n",
1162				p_dev->devname, p_drv->name, ret);
1163			mutex_lock(&p_dev->socket->ops_mutex);
1164			p_dev->suspended = 0;
1165			mutex_unlock(&p_dev->socket->ops_mutex);
1166			goto out;
1167		}
1168	}
1169
1170	if (p_dev->device_no == p_dev->func) {
1171		dev_dbg(dev, "releasing configuration\n");
1172		pcmcia_release_configuration(p_dev);
1173	}
1174
1175 out:
1176	return ret;
1177}
1178
1179
1180static int pcmcia_dev_resume(struct device *dev)
1181{
1182	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1183	struct pcmcia_driver *p_drv = NULL;
1184	int ret = 0;
1185
1186	mutex_lock(&p_dev->socket->ops_mutex);
1187	if (!p_dev->suspended) {
1188		mutex_unlock(&p_dev->socket->ops_mutex);
1189		return 0;
1190	}
1191	p_dev->suspended = 0;
1192	mutex_unlock(&p_dev->socket->ops_mutex);
1193
1194	dev_dbg(dev, "resuming\n");
1195
1196	if (dev->driver)
1197		p_drv = to_pcmcia_drv(dev->driver);
1198
1199	if (!p_drv)
1200		goto out;
1201
1202	if (p_dev->device_no == p_dev->func) {
1203		dev_dbg(dev, "requesting configuration\n");
1204		ret = pcmcia_enable_device(p_dev);
1205		if (ret)
1206			goto out;
1207	}
1208
1209	if (p_drv->resume)
1210		ret = p_drv->resume(p_dev);
1211
1212 out:
1213	return ret;
1214}
1215
1216
1217static int pcmcia_bus_suspend_callback(struct device *dev, void *_data)
1218{
1219	struct pcmcia_socket *skt = _data;
1220	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1221
1222	if (p_dev->socket != skt || p_dev->suspended)
1223		return 0;
1224
1225	return runtime_suspend(dev);
1226}
1227
1228static int pcmcia_bus_resume_callback(struct device *dev, void *_data)
1229{
1230	struct pcmcia_socket *skt = _data;
1231	struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1232
1233	if (p_dev->socket != skt || !p_dev->suspended)
1234		return 0;
1235
1236	runtime_resume(dev);
1237
1238	return 0;
1239}
1240
1241static int pcmcia_bus_resume(struct pcmcia_socket *skt)
1242{
1243	dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock);
1244	bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback);
1245	return 0;
1246}
1247
1248static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
1249{
1250	dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock);
1251	if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt,
1252			     pcmcia_bus_suspend_callback)) {
1253		pcmcia_bus_resume(skt);
1254		return -EIO;
1255	}
1256	return 0;
1257}
1258
1259static int pcmcia_bus_remove(struct pcmcia_socket *skt)
1260{
1261	atomic_set(&skt->present, 0);
1262	pcmcia_card_remove(skt, NULL);
1263
1264	mutex_lock(&skt->ops_mutex);
1265	destroy_cis_cache(skt);
1266	pcmcia_cleanup_irq(skt);
1267	mutex_unlock(&skt->ops_mutex);
1268
1269	return 0;
1270}
1271
1272static int pcmcia_bus_add(struct pcmcia_socket *skt)
1273{
1274	atomic_set(&skt->present, 1);
1275
1276	mutex_lock(&skt->ops_mutex);
1277	skt->pcmcia_pfc = 0;
1278	destroy_cis_cache(skt); /* to be on the safe side... */
1279	mutex_unlock(&skt->ops_mutex);
1280
1281	pcmcia_card_add(skt);
1282
1283	return 0;
1284}
1285
1286static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)
1287{
1288	if (!verify_cis_cache(skt))
1289		return 0;
1290
1291	dev_dbg(&skt->dev, "cis mismatch - different card\n");
1292
1293	/* first, remove the card */
1294	pcmcia_bus_remove(skt);
1295
1296	mutex_lock(&skt->ops_mutex);
1297	destroy_cis_cache(skt);
1298	kfree(skt->fake_cis);
1299	skt->fake_cis = NULL;
1300	skt->functions = 0;
1301	mutex_unlock(&skt->ops_mutex);
1302
1303	/* now, add the new card */
1304	pcmcia_bus_add(skt);
1305	return 0;
1306}
1307
1308
1309/*
1310 * NOTE: This is racy. There's no guarantee the card will still be
1311 * physically present, even if the call to this function returns
1312 * non-NULL. Furthermore, the device driver most likely is unbound
1313 * almost immediately, so the timeframe where pcmcia_dev_present
1314 * returns NULL is probably really really small.
1315 */
1316struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev)
1317{
1318	struct pcmcia_device *p_dev;
1319	struct pcmcia_device *ret = NULL;
1320
1321	p_dev = pcmcia_get_dev(_p_dev);
1322	if (!p_dev)
1323		return NULL;
1324
1325	if (atomic_read(&p_dev->socket->present) != 0)
1326		ret = p_dev;
1327
1328	pcmcia_put_dev(p_dev);
1329	return ret;
1330}
1331EXPORT_SYMBOL(pcmcia_dev_present);
1332
1333
1334static struct pcmcia_callback pcmcia_bus_callback = {
1335	.owner = THIS_MODULE,
1336	.add = pcmcia_bus_add,
1337	.remove = pcmcia_bus_remove,
1338	.requery = pcmcia_requery,
1339	.validate = pccard_validate_cis,
1340	.suspend = pcmcia_bus_suspend,
1341	.early_resume = pcmcia_bus_early_resume,
1342	.resume = pcmcia_bus_resume,
1343};
1344
1345static int pcmcia_bus_add_socket(struct device *dev,
1346					   struct class_interface *class_intf)
1347{
1348	struct pcmcia_socket *socket = dev_get_drvdata(dev);
1349	int ret;
1350
1351	socket = pcmcia_get_socket(socket);
1352	if (!socket) {
1353		dev_err(dev, "PCMCIA obtaining reference to socket failed\n");
1354		return -ENODEV;
1355	}
1356
1357	ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
1358	if (ret) {
1359		dev_err(dev, "PCMCIA registration failed\n");
1360		pcmcia_put_socket(socket);
1361		return ret;
1362	}
1363
1364	INIT_LIST_HEAD(&socket->devices_list);
1365	socket->pcmcia_pfc = 0;
1366	socket->device_count = 0;
1367	atomic_set(&socket->present, 0);
1368
1369	ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1370	if (ret) {
1371		dev_err(dev, "PCMCIA registration failed\n");
1372		pcmcia_put_socket(socket);
1373		return ret;
1374	}
1375
1376	return 0;
1377}
1378
1379static void pcmcia_bus_remove_socket(struct device *dev,
1380				     struct class_interface *class_intf)
1381{
1382	struct pcmcia_socket *socket = dev_get_drvdata(dev);
1383
1384	if (!socket)
1385		return;
1386
1387	pccard_register_pcmcia(socket, NULL);
1388
1389	/* unregister any unbound devices */
1390	mutex_lock(&socket->skt_mutex);
1391	pcmcia_card_remove(socket, NULL);
1392	release_cis_mem(socket);
1393	mutex_unlock(&socket->skt_mutex);
1394
1395	sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);
1396
1397	pcmcia_put_socket(socket);
1398
1399	return;
1400}
1401
1402
1403/* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1404static struct class_interface pcmcia_bus_interface __refdata = {
1405	.class = &pcmcia_socket_class,
1406	.add_dev = &pcmcia_bus_add_socket,
1407	.remove_dev = &pcmcia_bus_remove_socket,
1408};
1409
1410static const struct dev_pm_ops pcmcia_bus_pm_ops = {
1411	SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume)
1412};
1413
1414struct bus_type pcmcia_bus_type = {
1415	.name = "pcmcia",
1416	.uevent = pcmcia_bus_uevent,
1417	.match = pcmcia_bus_match,
1418	.dev_groups = pcmcia_dev_groups,
1419	.probe = pcmcia_device_probe,
1420	.remove = pcmcia_device_remove,
1421	.pm = &pcmcia_bus_pm_ops,
1422};
1423
1424
1425static int __init init_pcmcia_bus(void)
1426{
1427	int ret;
1428
1429	ret = bus_register(&pcmcia_bus_type);
1430	if (ret < 0) {
1431		printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret);
1432		return ret;
1433	}
1434	ret = class_interface_register(&pcmcia_bus_interface);
1435	if (ret < 0) {
1436		printk(KERN_WARNING
1437			"pcmcia: class_interface_register error: %d\n", ret);
1438		bus_unregister(&pcmcia_bus_type);
1439		return ret;
1440	}
1441
1442	return 0;
1443}
1444fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1445			       * pcmcia_socket_class is already registered */
1446
1447
1448static void __exit exit_pcmcia_bus(void)
1449{
1450	class_interface_unregister(&pcmcia_bus_interface);
1451
1452	bus_unregister(&pcmcia_bus_type);
1453}
1454module_exit(exit_pcmcia_bus);
1455
1456
1457MODULE_ALIAS("ds");