driver.c 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250
  1. /*
  2. * driver.c - device id matching, driver model, etc.
  3. *
  4. * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
  5. *
  6. */
  7. #include <linux/string.h>
  8. #include <linux/list.h>
  9. #include <linux/module.h>
  10. #include <linux/ctype.h>
  11. #include <linux/slab.h>
  12. #include <linux/pnp.h>
  13. #include "base.h"
  14. static int compare_func(const char *ida, const char *idb)
  15. {
  16. int i;
  17. /* we only need to compare the last 4 chars */
  18. for (i=3; i<7; i++)
  19. {
  20. if (ida[i] != 'X' &&
  21. idb[i] != 'X' &&
  22. toupper(ida[i]) != toupper(idb[i]))
  23. return 0;
  24. }
  25. return 1;
  26. }
  27. int compare_pnp_id(struct pnp_id *pos, const char *id)
  28. {
  29. if (!pos || !id || (strlen(id) != 7))
  30. return 0;
  31. if (memcmp(id,"ANYDEVS",7)==0)
  32. return 1;
  33. while (pos){
  34. if (memcmp(pos->id,id,3)==0)
  35. if (compare_func(pos->id,id)==1)
  36. return 1;
  37. pos = pos->next;
  38. }
  39. return 0;
  40. }
  41. static const struct pnp_device_id * match_device(struct pnp_driver *drv, struct pnp_dev *dev)
  42. {
  43. const struct pnp_device_id *drv_id = drv->id_table;
  44. if (!drv_id)
  45. return NULL;
  46. while (*drv_id->id) {
  47. if (compare_pnp_id(dev->id, drv_id->id))
  48. return drv_id;
  49. drv_id++;
  50. }
  51. return NULL;
  52. }
  53. int pnp_device_attach(struct pnp_dev *pnp_dev)
  54. {
  55. spin_lock(&pnp_lock);
  56. if(pnp_dev->status != PNP_READY){
  57. spin_unlock(&pnp_lock);
  58. return -EBUSY;
  59. }
  60. pnp_dev->status = PNP_ATTACHED;
  61. spin_unlock(&pnp_lock);
  62. return 0;
  63. }
  64. void pnp_device_detach(struct pnp_dev *pnp_dev)
  65. {
  66. spin_lock(&pnp_lock);
  67. if (pnp_dev->status == PNP_ATTACHED)
  68. pnp_dev->status = PNP_READY;
  69. spin_unlock(&pnp_lock);
  70. pnp_disable_dev(pnp_dev);
  71. }
  72. static int pnp_device_probe(struct device *dev)
  73. {
  74. int error;
  75. struct pnp_driver *pnp_drv;
  76. struct pnp_dev *pnp_dev;
  77. const struct pnp_device_id *dev_id = NULL;
  78. pnp_dev = to_pnp_dev(dev);
  79. pnp_drv = to_pnp_driver(dev->driver);
  80. pnp_dbg("match found with the PnP device '%s' and the driver '%s'", dev->bus_id,pnp_drv->name);
  81. error = pnp_device_attach(pnp_dev);
  82. if (error < 0)
  83. return error;
  84. if (pnp_dev->active == 0) {
  85. if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) {
  86. error = pnp_activate_dev(pnp_dev);
  87. if (error < 0)
  88. return error;
  89. }
  90. } else if ((pnp_drv->flags & PNP_DRIVER_RES_DISABLE)
  91. == PNP_DRIVER_RES_DISABLE) {
  92. error = pnp_disable_dev(pnp_dev);
  93. if (error < 0)
  94. return error;
  95. }
  96. error = 0;
  97. if (pnp_drv->probe) {
  98. dev_id = match_device(pnp_drv, pnp_dev);
  99. if (dev_id != NULL)
  100. error = pnp_drv->probe(pnp_dev, dev_id);
  101. }
  102. if (error >= 0){
  103. pnp_dev->driver = pnp_drv;
  104. error = 0;
  105. } else
  106. goto fail;
  107. return error;
  108. fail:
  109. pnp_device_detach(pnp_dev);
  110. return error;
  111. }
  112. static int pnp_device_remove(struct device *dev)
  113. {
  114. struct pnp_dev * pnp_dev = to_pnp_dev(dev);
  115. struct pnp_driver * drv = pnp_dev->driver;
  116. if (drv) {
  117. if (drv->remove)
  118. drv->remove(pnp_dev);
  119. pnp_dev->driver = NULL;
  120. }
  121. pnp_device_detach(pnp_dev);
  122. return 0;
  123. }
  124. static int pnp_bus_match(struct device *dev, struct device_driver *drv)
  125. {
  126. struct pnp_dev * pnp_dev = to_pnp_dev(dev);
  127. struct pnp_driver * pnp_drv = to_pnp_driver(drv);
  128. if (match_device(pnp_drv, pnp_dev) == NULL)
  129. return 0;
  130. return 1;
  131. }
  132. static int pnp_bus_suspend(struct device *dev, pm_message_t state)
  133. {
  134. struct pnp_dev * pnp_dev = to_pnp_dev(dev);
  135. struct pnp_driver * pnp_drv = pnp_dev->driver;
  136. int error;
  137. if (!pnp_drv)
  138. return 0;
  139. if (pnp_drv->suspend) {
  140. error = pnp_drv->suspend(pnp_dev, state);
  141. if (error)
  142. return error;
  143. }
  144. if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE) &&
  145. pnp_can_disable(pnp_dev)) {
  146. error = pnp_stop_dev(pnp_dev);
  147. if (error)
  148. return error;
  149. }
  150. return 0;
  151. }
  152. static int pnp_bus_resume(struct device *dev)
  153. {
  154. struct pnp_dev * pnp_dev = to_pnp_dev(dev);
  155. struct pnp_driver * pnp_drv = pnp_dev->driver;
  156. int error;
  157. if (!pnp_drv)
  158. return 0;
  159. if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) {
  160. error = pnp_start_dev(pnp_dev);
  161. if (error)
  162. return error;
  163. }
  164. if (pnp_drv->resume)
  165. return pnp_drv->resume(pnp_dev);
  166. return 0;
  167. }
  168. struct bus_type pnp_bus_type = {
  169. .name = "pnp",
  170. .match = pnp_bus_match,
  171. .probe = pnp_device_probe,
  172. .remove = pnp_device_remove,
  173. .suspend = pnp_bus_suspend,
  174. .resume = pnp_bus_resume,
  175. };
  176. int pnp_register_driver(struct pnp_driver *drv)
  177. {
  178. pnp_dbg("the driver '%s' has been registered", drv->name);
  179. drv->driver.name = drv->name;
  180. drv->driver.bus = &pnp_bus_type;
  181. return driver_register(&drv->driver);
  182. }
  183. void pnp_unregister_driver(struct pnp_driver *drv)
  184. {
  185. driver_unregister(&drv->driver);
  186. pnp_dbg("the driver '%s' has been unregistered", drv->name);
  187. }
  188. /**
  189. * pnp_add_id - adds an EISA id to the specified device
  190. * @id: pointer to a pnp_id structure
  191. * @dev: pointer to the desired device
  192. *
  193. */
  194. int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev)
  195. {
  196. struct pnp_id *ptr;
  197. if (!id)
  198. return -EINVAL;
  199. if (!dev)
  200. return -EINVAL;
  201. id->next = NULL;
  202. ptr = dev->id;
  203. while (ptr && ptr->next)
  204. ptr = ptr->next;
  205. if (ptr)
  206. ptr->next = id;
  207. else
  208. dev->id = id;
  209. return 0;
  210. }
  211. EXPORT_SYMBOL(pnp_register_driver);
  212. EXPORT_SYMBOL(pnp_unregister_driver);
  213. #if 0
  214. EXPORT_SYMBOL(pnp_add_id);
  215. #endif
  216. EXPORT_SYMBOL(pnp_device_attach);
  217. EXPORT_SYMBOL(pnp_device_detach);