udc-core.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566
  1. /**
  2. * udc.c - Core UDC Framework
  3. *
  4. * Copyright (C) 2010 Texas Instruments
  5. * Author: Felipe Balbi <balbi@ti.com>
  6. *
  7. * This program is free software: you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License version 2 of
  9. * the License as published by the Free Software Foundation.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. */
  19. #include <linux/kernel.h>
  20. #include <linux/module.h>
  21. #include <linux/device.h>
  22. #include <linux/list.h>
  23. #include <linux/err.h>
  24. #include <linux/dma-mapping.h>
  25. #include <linux/usb/ch9.h>
  26. #include <linux/usb/gadget.h>
  27. /**
  28. * struct usb_udc - describes one usb device controller
  29. * @driver - the gadget driver pointer. For use by the class code
  30. * @dev - the child device to the actual controller
  31. * @gadget - the gadget. For use by the class code
  32. * @list - for use by the udc class driver
  33. *
  34. * This represents the internal data structure which is used by the UDC-class
  35. * to hold information about udc driver and gadget together.
  36. */
  37. struct usb_udc {
  38. struct usb_gadget_driver *driver;
  39. struct usb_gadget *gadget;
  40. struct device dev;
  41. struct list_head list;
  42. };
  43. static struct class *udc_class;
  44. static LIST_HEAD(udc_list);
  45. static DEFINE_MUTEX(udc_lock);
  46. /* ------------------------------------------------------------------------- */
  47. int usb_gadget_map_request(struct usb_gadget *gadget,
  48. struct usb_request *req, int is_in)
  49. {
  50. if (req->length == 0)
  51. return 0;
  52. if (req->num_sgs) {
  53. int mapped;
  54. mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
  55. is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
  56. if (mapped == 0) {
  57. dev_err(&gadget->dev, "failed to map SGs\n");
  58. return -EFAULT;
  59. }
  60. req->num_mapped_sgs = mapped;
  61. } else {
  62. req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
  63. is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
  64. if (dma_mapping_error(&gadget->dev, req->dma)) {
  65. dev_err(&gadget->dev, "failed to map buffer\n");
  66. return -EFAULT;
  67. }
  68. }
  69. return 0;
  70. }
  71. EXPORT_SYMBOL_GPL(usb_gadget_map_request);
  72. void usb_gadget_unmap_request(struct usb_gadget *gadget,
  73. struct usb_request *req, int is_in)
  74. {
  75. if (req->length == 0)
  76. return;
  77. if (req->num_mapped_sgs) {
  78. dma_unmap_sg(&gadget->dev, req->sg, req->num_mapped_sgs,
  79. is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
  80. req->num_mapped_sgs = 0;
  81. } else {
  82. dma_unmap_single(&gadget->dev, req->dma, req->length,
  83. is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
  84. }
  85. }
  86. EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
  87. /* ------------------------------------------------------------------------- */
  88. void usb_gadget_set_state(struct usb_gadget *gadget,
  89. enum usb_device_state state)
  90. {
  91. gadget->state = state;
  92. sysfs_notify(&gadget->dev.kobj, NULL, "status");
  93. }
  94. EXPORT_SYMBOL_GPL(usb_gadget_set_state);
  95. /* ------------------------------------------------------------------------- */
  96. /**
  97. * usb_gadget_udc_start - tells usb device controller to start up
  98. * @gadget: The gadget we want to get started
  99. * @driver: The driver we want to bind to @gadget
  100. *
  101. * This call is issued by the UDC Class driver when it's about
  102. * to register a gadget driver to the device controller, before
  103. * calling gadget driver's bind() method.
  104. *
  105. * It allows the controller to be powered off until strictly
  106. * necessary to have it powered on.
  107. *
  108. * Returns zero on success, else negative errno.
  109. */
  110. static inline int usb_gadget_udc_start(struct usb_gadget *gadget,
  111. struct usb_gadget_driver *driver)
  112. {
  113. return gadget->ops->udc_start(gadget, driver);
  114. }
  115. /**
  116. * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
  117. * @gadget: The device we want to stop activity
  118. * @driver: The driver to unbind from @gadget
  119. *
  120. * This call is issued by the UDC Class driver after calling
  121. * gadget driver's unbind() method.
  122. *
  123. * The details are implementation specific, but it can go as
  124. * far as powering off UDC completely and disable its data
  125. * line pullups.
  126. */
  127. static inline void usb_gadget_udc_stop(struct usb_gadget *gadget,
  128. struct usb_gadget_driver *driver)
  129. {
  130. gadget->ops->udc_stop(gadget, driver);
  131. }
  132. /**
  133. * usb_udc_release - release the usb_udc struct
  134. * @dev: the dev member within usb_udc
  135. *
  136. * This is called by driver's core in order to free memory once the last
  137. * reference is released.
  138. */
  139. static void usb_udc_release(struct device *dev)
  140. {
  141. struct usb_udc *udc;
  142. udc = container_of(dev, struct usb_udc, dev);
  143. dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
  144. kfree(udc);
  145. }
  146. static const struct attribute_group *usb_udc_attr_groups[];
  147. static void usb_udc_nop_release(struct device *dev)
  148. {
  149. dev_vdbg(dev, "%s\n", __func__);
  150. }
  151. /**
  152. * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
  153. * @parent: the parent device to this udc. Usually the controller driver's
  154. * device.
  155. * @gadget: the gadget to be added to the list.
  156. * @release: a gadget release function.
  157. *
  158. * Returns zero on success, negative errno otherwise.
  159. */
  160. int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
  161. void (*release)(struct device *dev))
  162. {
  163. struct usb_udc *udc;
  164. int ret = -ENOMEM;
  165. udc = kzalloc(sizeof(*udc), GFP_KERNEL);
  166. if (!udc)
  167. goto err1;
  168. dev_set_name(&gadget->dev, "gadget");
  169. gadget->dev.parent = parent;
  170. dma_set_coherent_mask(&gadget->dev, parent->coherent_dma_mask);
  171. gadget->dev.dma_parms = parent->dma_parms;
  172. gadget->dev.dma_mask = parent->dma_mask;
  173. if (release)
  174. gadget->dev.release = release;
  175. else
  176. gadget->dev.release = usb_udc_nop_release;
  177. ret = device_register(&gadget->dev);
  178. if (ret)
  179. goto err2;
  180. device_initialize(&udc->dev);
  181. udc->dev.release = usb_udc_release;
  182. udc->dev.class = udc_class;
  183. udc->dev.groups = usb_udc_attr_groups;
  184. udc->dev.parent = parent;
  185. ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
  186. if (ret)
  187. goto err3;
  188. udc->gadget = gadget;
  189. mutex_lock(&udc_lock);
  190. list_add_tail(&udc->list, &udc_list);
  191. ret = device_add(&udc->dev);
  192. if (ret)
  193. goto err4;
  194. usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
  195. mutex_unlock(&udc_lock);
  196. return 0;
  197. err4:
  198. list_del(&udc->list);
  199. mutex_unlock(&udc_lock);
  200. err3:
  201. put_device(&udc->dev);
  202. err2:
  203. put_device(&gadget->dev);
  204. kfree(udc);
  205. err1:
  206. return ret;
  207. }
  208. EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
  209. /**
  210. * usb_add_gadget_udc - adds a new gadget to the udc class driver list
  211. * @parent: the parent device to this udc. Usually the controller
  212. * driver's device.
  213. * @gadget: the gadget to be added to the list
  214. *
  215. * Returns zero on success, negative errno otherwise.
  216. */
  217. int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
  218. {
  219. return usb_add_gadget_udc_release(parent, gadget, NULL);
  220. }
  221. EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
  222. static void usb_gadget_remove_driver(struct usb_udc *udc)
  223. {
  224. dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
  225. udc->gadget->name);
  226. kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
  227. usb_gadget_disconnect(udc->gadget);
  228. udc->driver->disconnect(udc->gadget);
  229. udc->driver->unbind(udc->gadget);
  230. usb_gadget_udc_stop(udc->gadget, NULL);
  231. udc->driver = NULL;
  232. udc->dev.driver = NULL;
  233. udc->gadget->dev.driver = NULL;
  234. }
  235. /**
  236. * usb_del_gadget_udc - deletes @udc from udc_list
  237. * @gadget: the gadget to be removed.
  238. *
  239. * This, will call usb_gadget_unregister_driver() if
  240. * the @udc is still busy.
  241. */
  242. void usb_del_gadget_udc(struct usb_gadget *gadget)
  243. {
  244. struct usb_udc *udc = NULL;
  245. mutex_lock(&udc_lock);
  246. list_for_each_entry(udc, &udc_list, list)
  247. if (udc->gadget == gadget)
  248. goto found;
  249. dev_err(gadget->dev.parent, "gadget not registered.\n");
  250. mutex_unlock(&udc_lock);
  251. return;
  252. found:
  253. dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
  254. list_del(&udc->list);
  255. mutex_unlock(&udc_lock);
  256. if (udc->driver)
  257. usb_gadget_remove_driver(udc);
  258. kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
  259. device_unregister(&udc->dev);
  260. device_unregister(&gadget->dev);
  261. }
  262. EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
  263. /* ------------------------------------------------------------------------- */
  264. static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
  265. {
  266. int ret;
  267. dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
  268. driver->function);
  269. udc->driver = driver;
  270. udc->dev.driver = &driver->driver;
  271. udc->gadget->dev.driver = &driver->driver;
  272. ret = driver->bind(udc->gadget, driver);
  273. if (ret)
  274. goto err1;
  275. ret = usb_gadget_udc_start(udc->gadget, driver);
  276. if (ret) {
  277. driver->unbind(udc->gadget);
  278. goto err1;
  279. }
  280. usb_gadget_connect(udc->gadget);
  281. kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
  282. return 0;
  283. err1:
  284. dev_err(&udc->dev, "failed to start %s: %d\n",
  285. udc->driver->function, ret);
  286. udc->driver = NULL;
  287. udc->dev.driver = NULL;
  288. udc->gadget->dev.driver = NULL;
  289. return ret;
  290. }
  291. int udc_attach_driver(const char *name, struct usb_gadget_driver *driver)
  292. {
  293. struct usb_udc *udc = NULL;
  294. int ret = -ENODEV;
  295. mutex_lock(&udc_lock);
  296. list_for_each_entry(udc, &udc_list, list) {
  297. ret = strcmp(name, dev_name(&udc->dev));
  298. if (!ret)
  299. break;
  300. }
  301. if (ret) {
  302. ret = -ENODEV;
  303. goto out;
  304. }
  305. if (udc->driver) {
  306. ret = -EBUSY;
  307. goto out;
  308. }
  309. ret = udc_bind_to_driver(udc, driver);
  310. out:
  311. mutex_unlock(&udc_lock);
  312. return ret;
  313. }
  314. EXPORT_SYMBOL_GPL(udc_attach_driver);
  315. int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
  316. {
  317. struct usb_udc *udc = NULL;
  318. int ret;
  319. if (!driver || !driver->bind || !driver->setup)
  320. return -EINVAL;
  321. mutex_lock(&udc_lock);
  322. list_for_each_entry(udc, &udc_list, list) {
  323. /* For now we take the first one */
  324. if (!udc->driver)
  325. goto found;
  326. }
  327. pr_debug("couldn't find an available UDC\n");
  328. mutex_unlock(&udc_lock);
  329. return -ENODEV;
  330. found:
  331. ret = udc_bind_to_driver(udc, driver);
  332. mutex_unlock(&udc_lock);
  333. return ret;
  334. }
  335. EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
  336. int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
  337. {
  338. struct usb_udc *udc = NULL;
  339. int ret = -ENODEV;
  340. if (!driver || !driver->unbind)
  341. return -EINVAL;
  342. mutex_lock(&udc_lock);
  343. list_for_each_entry(udc, &udc_list, list)
  344. if (udc->driver == driver) {
  345. usb_gadget_remove_driver(udc);
  346. ret = 0;
  347. break;
  348. }
  349. mutex_unlock(&udc_lock);
  350. return ret;
  351. }
  352. EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
  353. /* ------------------------------------------------------------------------- */
  354. static ssize_t usb_udc_srp_store(struct device *dev,
  355. struct device_attribute *attr, const char *buf, size_t n)
  356. {
  357. struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
  358. if (sysfs_streq(buf, "1"))
  359. usb_gadget_wakeup(udc->gadget);
  360. return n;
  361. }
  362. static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);
  363. static ssize_t usb_udc_softconn_store(struct device *dev,
  364. struct device_attribute *attr, const char *buf, size_t n)
  365. {
  366. struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
  367. if (sysfs_streq(buf, "connect")) {
  368. usb_gadget_udc_start(udc->gadget, udc->driver);
  369. usb_gadget_connect(udc->gadget);
  370. } else if (sysfs_streq(buf, "disconnect")) {
  371. usb_gadget_disconnect(udc->gadget);
  372. usb_gadget_udc_stop(udc->gadget, udc->driver);
  373. } else {
  374. dev_err(dev, "unsupported command '%s'\n", buf);
  375. return -EINVAL;
  376. }
  377. return n;
  378. }
  379. static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);
  380. static ssize_t usb_gadget_state_show(struct device *dev,
  381. struct device_attribute *attr, char *buf)
  382. {
  383. struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
  384. struct usb_gadget *gadget = udc->gadget;
  385. return sprintf(buf, "%s\n", usb_state_string(gadget->state));
  386. }
  387. static DEVICE_ATTR(state, S_IRUGO, usb_gadget_state_show, NULL);
  388. #define USB_UDC_SPEED_ATTR(name, param) \
  389. ssize_t usb_udc_##param##_show(struct device *dev, \
  390. struct device_attribute *attr, char *buf) \
  391. { \
  392. struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
  393. return snprintf(buf, PAGE_SIZE, "%s\n", \
  394. usb_speed_string(udc->gadget->param)); \
  395. } \
  396. static DEVICE_ATTR(name, S_IRUGO, usb_udc_##param##_show, NULL)
  397. static USB_UDC_SPEED_ATTR(current_speed, speed);
  398. static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
  399. #define USB_UDC_ATTR(name) \
  400. ssize_t usb_udc_##name##_show(struct device *dev, \
  401. struct device_attribute *attr, char *buf) \
  402. { \
  403. struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
  404. struct usb_gadget *gadget = udc->gadget; \
  405. \
  406. return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
  407. } \
  408. static DEVICE_ATTR(name, S_IRUGO, usb_udc_##name##_show, NULL)
  409. static USB_UDC_ATTR(is_otg);
  410. static USB_UDC_ATTR(is_a_peripheral);
  411. static USB_UDC_ATTR(b_hnp_enable);
  412. static USB_UDC_ATTR(a_hnp_support);
  413. static USB_UDC_ATTR(a_alt_hnp_support);
  414. static struct attribute *usb_udc_attrs[] = {
  415. &dev_attr_srp.attr,
  416. &dev_attr_soft_connect.attr,
  417. &dev_attr_state.attr,
  418. &dev_attr_current_speed.attr,
  419. &dev_attr_maximum_speed.attr,
  420. &dev_attr_is_otg.attr,
  421. &dev_attr_is_a_peripheral.attr,
  422. &dev_attr_b_hnp_enable.attr,
  423. &dev_attr_a_hnp_support.attr,
  424. &dev_attr_a_alt_hnp_support.attr,
  425. NULL,
  426. };
  427. static const struct attribute_group usb_udc_attr_group = {
  428. .attrs = usb_udc_attrs,
  429. };
  430. static const struct attribute_group *usb_udc_attr_groups[] = {
  431. &usb_udc_attr_group,
  432. NULL,
  433. };
  434. static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
  435. {
  436. struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
  437. int ret;
  438. ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
  439. if (ret) {
  440. dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
  441. return ret;
  442. }
  443. if (udc->driver) {
  444. ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
  445. udc->driver->function);
  446. if (ret) {
  447. dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
  448. return ret;
  449. }
  450. }
  451. return 0;
  452. }
  453. static int __init usb_udc_init(void)
  454. {
  455. udc_class = class_create(THIS_MODULE, "udc");
  456. if (IS_ERR(udc_class)) {
  457. pr_err("failed to create udc class --> %ld\n",
  458. PTR_ERR(udc_class));
  459. return PTR_ERR(udc_class);
  460. }
  461. udc_class->dev_uevent = usb_udc_uevent;
  462. return 0;
  463. }
  464. subsys_initcall(usb_udc_init);
  465. static void __exit usb_udc_exit(void)
  466. {
  467. class_destroy(udc_class);
  468. }
  469. module_exit(usb_udc_exit);
  470. MODULE_DESCRIPTION("UDC Framework");
  471. MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
  472. MODULE_LICENSE("GPL v2");