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