smsusb.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561
  1. /*
  2. * Driver for the Siano SMS1xxx USB dongle
  3. *
  4. * author: Anatoly Greenblat
  5. *
  6. * Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation;
  11. *
  12. * Software distributed under the License is distributed on an "AS IS"
  13. * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
  14. *
  15. * See the GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21. #include <linux/kernel.h>
  22. #include <linux/init.h>
  23. #include <linux/usb.h>
  24. #include <linux/firmware.h>
  25. #include "smscoreapi.h"
  26. #include "sms-cards.h"
  27. static int sms_dbg;
  28. module_param_named(debug, sms_dbg, int, 0644);
  29. MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
  30. #define USB1_BUFFER_SIZE 0x1000
  31. #define USB2_BUFFER_SIZE 0x4000
  32. #define MAX_BUFFERS 50
  33. #define MAX_URBS 10
  34. struct smsusb_device_t;
  35. struct smsusb_urb_t {
  36. struct smscore_buffer_t *cb;
  37. struct smsusb_device_t *dev;
  38. struct urb urb;
  39. };
  40. struct smsusb_device_t {
  41. struct usb_device *udev;
  42. struct smscore_device_t *coredev;
  43. struct smsusb_urb_t surbs[MAX_URBS];
  44. int response_alignment;
  45. int buffer_size;
  46. };
  47. static int smsusb_submit_urb(struct smsusb_device_t *dev,
  48. struct smsusb_urb_t *surb);
  49. static void smsusb_onresponse(struct urb *urb)
  50. {
  51. struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context;
  52. struct smsusb_device_t *dev = surb->dev;
  53. if (urb->status < 0) {
  54. sms_err("error, urb status %d, %d bytes",
  55. urb->status, urb->actual_length);
  56. return;
  57. }
  58. if (urb->actual_length > 0) {
  59. struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) surb->cb->p;
  60. if (urb->actual_length >= phdr->msgLength) {
  61. surb->cb->size = phdr->msgLength;
  62. if (dev->response_alignment &&
  63. (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) {
  64. surb->cb->offset =
  65. dev->response_alignment +
  66. ((phdr->msgFlags >> 8) & 3);
  67. /* sanity check */
  68. if (((int) phdr->msgLength +
  69. surb->cb->offset) > urb->actual_length) {
  70. sms_err("invalid response "
  71. "msglen %d offset %d "
  72. "size %d",
  73. phdr->msgLength,
  74. surb->cb->offset,
  75. urb->actual_length);
  76. goto exit_and_resubmit;
  77. }
  78. /* move buffer pointer and
  79. * copy header to its new location */
  80. memcpy((char *) phdr + surb->cb->offset,
  81. phdr, sizeof(struct SmsMsgHdr_ST));
  82. } else
  83. surb->cb->offset = 0;
  84. smscore_onresponse(dev->coredev, surb->cb);
  85. surb->cb = NULL;
  86. } else {
  87. sms_err("invalid response "
  88. "msglen %d actual %d",
  89. phdr->msgLength, urb->actual_length);
  90. }
  91. }
  92. exit_and_resubmit:
  93. smsusb_submit_urb(dev, surb);
  94. }
  95. static int smsusb_submit_urb(struct smsusb_device_t *dev,
  96. struct smsusb_urb_t *surb)
  97. {
  98. if (!surb->cb) {
  99. surb->cb = smscore_getbuffer(dev->coredev);
  100. if (!surb->cb) {
  101. sms_err("smscore_getbuffer(...) returned NULL");
  102. return -ENOMEM;
  103. }
  104. }
  105. usb_fill_bulk_urb(
  106. &surb->urb,
  107. dev->udev,
  108. usb_rcvbulkpipe(dev->udev, 0x81),
  109. surb->cb->p,
  110. dev->buffer_size,
  111. smsusb_onresponse,
  112. surb
  113. );
  114. surb->urb.transfer_dma = surb->cb->phys;
  115. surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  116. return usb_submit_urb(&surb->urb, GFP_ATOMIC);
  117. }
  118. static void smsusb_stop_streaming(struct smsusb_device_t *dev)
  119. {
  120. int i;
  121. for (i = 0; i < MAX_URBS; i++) {
  122. usb_kill_urb(&dev->surbs[i].urb);
  123. if (dev->surbs[i].cb) {
  124. smscore_putbuffer(dev->coredev, dev->surbs[i].cb);
  125. dev->surbs[i].cb = NULL;
  126. }
  127. }
  128. }
  129. static int smsusb_start_streaming(struct smsusb_device_t *dev)
  130. {
  131. int i, rc;
  132. for (i = 0; i < MAX_URBS; i++) {
  133. rc = smsusb_submit_urb(dev, &dev->surbs[i]);
  134. if (rc < 0) {
  135. sms_err("smsusb_submit_urb(...) failed");
  136. smsusb_stop_streaming(dev);
  137. break;
  138. }
  139. }
  140. return rc;
  141. }
  142. static int smsusb_sendrequest(void *context, void *buffer, size_t size)
  143. {
  144. struct smsusb_device_t *dev = (struct smsusb_device_t *) context;
  145. int dummy;
  146. return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
  147. buffer, size, &dummy, 1000);
  148. }
  149. static char *smsusb1_fw_lkup[] = {
  150. "dvbt_stellar_usb.inp",
  151. "dvbh_stellar_usb.inp",
  152. "tdmb_stellar_usb.inp",
  153. "none",
  154. "dvbt_bda_stellar_usb.inp",
  155. };
  156. static inline char *sms_get_fw_name(int mode, int board_id)
  157. {
  158. char **fw = sms_get_board(board_id)->fw;
  159. return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode];
  160. }
  161. static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id)
  162. {
  163. const struct firmware *fw;
  164. u8 *fw_buffer;
  165. int rc, dummy;
  166. char *fw_filename;
  167. if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) {
  168. sms_err("invalid firmware id specified %d", id);
  169. return -EINVAL;
  170. }
  171. fw_filename = sms_get_fw_name(id, board_id);
  172. rc = request_firmware(&fw, fw_filename, &udev->dev);
  173. if (rc < 0) {
  174. sms_warn("failed to open \"%s\" mode %d, "
  175. "trying again with default firmware", fw_filename, id);
  176. fw_filename = smsusb1_fw_lkup[id];
  177. rc = request_firmware(&fw, fw_filename, &udev->dev);
  178. if (rc < 0) {
  179. sms_warn("failed to open \"%s\" mode %d",
  180. fw_filename, id);
  181. return rc;
  182. }
  183. }
  184. fw_buffer = kmalloc(fw->size, GFP_KERNEL);
  185. if (fw_buffer) {
  186. memcpy(fw_buffer, fw->data, fw->size);
  187. rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),
  188. fw_buffer, fw->size, &dummy, 1000);
  189. sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc);
  190. kfree(fw_buffer);
  191. } else {
  192. sms_err("failed to allocate firmware buffer");
  193. rc = -ENOMEM;
  194. }
  195. sms_info("read FW %s, size=%zd", fw_filename, fw->size);
  196. release_firmware(fw);
  197. return rc;
  198. }
  199. static void smsusb1_detectmode(void *context, int *mode)
  200. {
  201. char *product_string =
  202. ((struct smsusb_device_t *) context)->udev->product;
  203. *mode = DEVICE_MODE_NONE;
  204. if (!product_string) {
  205. product_string = "none";
  206. sms_err("product string not found");
  207. } else if (strstr(product_string, "DVBH"))
  208. *mode = 1;
  209. else if (strstr(product_string, "BDA"))
  210. *mode = 4;
  211. else if (strstr(product_string, "DVBT"))
  212. *mode = 0;
  213. else if (strstr(product_string, "TDMB"))
  214. *mode = 2;
  215. sms_info("%d \"%s\"", *mode, product_string);
  216. }
  217. static int smsusb1_setmode(void *context, int mode)
  218. {
  219. struct SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
  220. sizeof(struct SmsMsgHdr_ST), 0 };
  221. if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
  222. sms_err("invalid firmware id specified %d", mode);
  223. return -EINVAL;
  224. }
  225. return smsusb_sendrequest(context, &Msg, sizeof(Msg));
  226. }
  227. static void smsusb_term_device(struct usb_interface *intf)
  228. {
  229. struct smsusb_device_t *dev =
  230. (struct smsusb_device_t *) usb_get_intfdata(intf);
  231. if (dev) {
  232. smsusb_stop_streaming(dev);
  233. /* unregister from smscore */
  234. if (dev->coredev)
  235. smscore_unregister_device(dev->coredev);
  236. kfree(dev);
  237. sms_info("device %p destroyed", dev);
  238. }
  239. usb_set_intfdata(intf, NULL);
  240. }
  241. static int smsusb_init_device(struct usb_interface *intf, int board_id)
  242. {
  243. struct smsdevice_params_t params;
  244. struct smsusb_device_t *dev;
  245. int i, rc;
  246. /* create device object */
  247. dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);
  248. if (!dev) {
  249. sms_err("kzalloc(sizeof(struct smsusb_device_t) failed");
  250. return -ENOMEM;
  251. }
  252. memset(&params, 0, sizeof(params));
  253. usb_set_intfdata(intf, dev);
  254. dev->udev = interface_to_usbdev(intf);
  255. params.device_type = sms_get_board(board_id)->type;
  256. switch (params.device_type) {
  257. case SMS_STELLAR:
  258. dev->buffer_size = USB1_BUFFER_SIZE;
  259. params.setmode_handler = smsusb1_setmode;
  260. params.detectmode_handler = smsusb1_detectmode;
  261. break;
  262. default:
  263. sms_err("Unspecified sms device type!");
  264. /* fall-thru */
  265. case SMS_NOVA_A0:
  266. case SMS_NOVA_B0:
  267. case SMS_VEGA:
  268. dev->buffer_size = USB2_BUFFER_SIZE;
  269. dev->response_alignment =
  270. dev->udev->ep_in[1]->desc.wMaxPacketSize -
  271. sizeof(struct SmsMsgHdr_ST);
  272. params.flags |= SMS_DEVICE_FAMILY2;
  273. break;
  274. }
  275. params.device = &dev->udev->dev;
  276. params.buffer_size = dev->buffer_size;
  277. params.num_buffers = MAX_BUFFERS;
  278. params.sendrequest_handler = smsusb_sendrequest;
  279. params.context = dev;
  280. snprintf(params.devpath, sizeof(params.devpath),
  281. "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath);
  282. /* register in smscore */
  283. rc = smscore_register_device(&params, &dev->coredev);
  284. if (rc < 0) {
  285. sms_err("smscore_register_device(...) failed, rc %d", rc);
  286. smsusb_term_device(intf);
  287. return rc;
  288. }
  289. smscore_set_board_id(dev->coredev, board_id);
  290. /* initialize urbs */
  291. for (i = 0; i < MAX_URBS; i++) {
  292. dev->surbs[i].dev = dev;
  293. usb_init_urb(&dev->surbs[i].urb);
  294. }
  295. sms_info("smsusb_start_streaming(...).");
  296. rc = smsusb_start_streaming(dev);
  297. if (rc < 0) {
  298. sms_err("smsusb_start_streaming(...) failed");
  299. smsusb_term_device(intf);
  300. return rc;
  301. }
  302. rc = smscore_start_device(dev->coredev);
  303. if (rc < 0) {
  304. sms_err("smscore_start_device(...) failed");
  305. smsusb_term_device(intf);
  306. return rc;
  307. }
  308. sms_info("device %p created", dev);
  309. return rc;
  310. }
  311. static int smsusb_probe(struct usb_interface *intf,
  312. const struct usb_device_id *id)
  313. {
  314. struct usb_device *udev = interface_to_usbdev(intf);
  315. char devpath[32];
  316. int i, rc;
  317. rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81));
  318. rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02));
  319. if (intf->num_altsetting > 0) {
  320. rc = usb_set_interface(
  321. udev, intf->cur_altsetting->desc.bInterfaceNumber, 0);
  322. if (rc < 0) {
  323. sms_err("usb_set_interface failed, rc %d", rc);
  324. return rc;
  325. }
  326. }
  327. sms_info("smsusb_probe %d",
  328. intf->cur_altsetting->desc.bInterfaceNumber);
  329. for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
  330. sms_info("endpoint %d %02x %02x %d", i,
  331. intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
  332. intf->cur_altsetting->endpoint[i].desc.bmAttributes,
  333. intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
  334. if ((udev->actconfig->desc.bNumInterfaces == 2) &&
  335. (intf->cur_altsetting->desc.bInterfaceNumber == 0)) {
  336. sms_err("rom interface 0 is not used");
  337. return -ENODEV;
  338. }
  339. if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
  340. snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
  341. udev->bus->busnum, udev->devpath);
  342. sms_info("stellar device was found.");
  343. return smsusb1_load_firmware(
  344. udev, smscore_registry_getmode(devpath),
  345. id->driver_info);
  346. }
  347. rc = smsusb_init_device(intf, id->driver_info);
  348. sms_info("rc %d", rc);
  349. sms_board_load_modules(id->driver_info);
  350. return rc;
  351. }
  352. static void smsusb_disconnect(struct usb_interface *intf)
  353. {
  354. smsusb_term_device(intf);
  355. }
  356. static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)
  357. {
  358. struct smsusb_device_t *dev =
  359. (struct smsusb_device_t *)usb_get_intfdata(intf);
  360. printk(KERN_INFO "%s: Entering status %d.\n", __func__, msg.event);
  361. smsusb_stop_streaming(dev);
  362. return 0;
  363. }
  364. static int smsusb_resume(struct usb_interface *intf)
  365. {
  366. int rc, i;
  367. struct smsusb_device_t *dev =
  368. (struct smsusb_device_t *)usb_get_intfdata(intf);
  369. struct usb_device *udev = interface_to_usbdev(intf);
  370. printk(KERN_INFO "%s: Entering.\n", __func__);
  371. usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81));
  372. usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02));
  373. for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
  374. printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,
  375. intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
  376. intf->cur_altsetting->endpoint[i].desc.bmAttributes,
  377. intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
  378. if (intf->num_altsetting > 0) {
  379. rc = usb_set_interface(udev,
  380. intf->cur_altsetting->desc.
  381. bInterfaceNumber, 0);
  382. if (rc < 0) {
  383. printk(KERN_INFO "%s usb_set_interface failed, "
  384. "rc %d\n", __func__, rc);
  385. return rc;
  386. }
  387. }
  388. smsusb_start_streaming(dev);
  389. return 0;
  390. }
  391. struct usb_device_id smsusb_id_table[] = {
  392. #ifdef CONFIG_DVB_SIANO_SMS1XXX_SMS_IDS
  393. { USB_DEVICE(0x187f, 0x0010),
  394. .driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
  395. { USB_DEVICE(0x187f, 0x0100),
  396. .driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
  397. { USB_DEVICE(0x187f, 0x0200),
  398. .driver_info = SMS1XXX_BOARD_SIANO_NOVA_A },
  399. { USB_DEVICE(0x187f, 0x0201),
  400. .driver_info = SMS1XXX_BOARD_SIANO_NOVA_B },
  401. { USB_DEVICE(0x187f, 0x0300),
  402. .driver_info = SMS1XXX_BOARD_SIANO_VEGA },
  403. #endif
  404. { USB_DEVICE(0x2040, 0x1700),
  405. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT },
  406. { USB_DEVICE(0x2040, 0x1800),
  407. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A },
  408. { USB_DEVICE(0x2040, 0x1801),
  409. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B },
  410. { USB_DEVICE(0x2040, 0x2000),
  411. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
  412. { USB_DEVICE(0x2040, 0x2009),
  413. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2 },
  414. { USB_DEVICE(0x2040, 0x200a),
  415. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
  416. { USB_DEVICE(0x2040, 0x2010),
  417. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
  418. { USB_DEVICE(0x2040, 0x2011),
  419. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
  420. { USB_DEVICE(0x2040, 0x2019),
  421. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
  422. { USB_DEVICE(0x2040, 0x5500),
  423. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
  424. { USB_DEVICE(0x2040, 0x5510),
  425. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
  426. { USB_DEVICE(0x2040, 0x5520),
  427. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
  428. { USB_DEVICE(0x2040, 0x5530),
  429. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
  430. { USB_DEVICE(0x2040, 0x5580),
  431. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
  432. { USB_DEVICE(0x2040, 0x5590),
  433. .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
  434. { } /* Terminating entry */
  435. };
  436. MODULE_DEVICE_TABLE(usb, smsusb_id_table);
  437. static struct usb_driver smsusb_driver = {
  438. .name = "smsusb",
  439. .probe = smsusb_probe,
  440. .disconnect = smsusb_disconnect,
  441. .id_table = smsusb_id_table,
  442. .suspend = smsusb_suspend,
  443. .resume = smsusb_resume,
  444. };
  445. int smsusb_module_init(void)
  446. {
  447. int rc = usb_register(&smsusb_driver);
  448. if (rc)
  449. sms_err("usb_register failed. Error number %d", rc);
  450. sms_debug("");
  451. return rc;
  452. }
  453. void smsusb_module_exit(void)
  454. {
  455. sms_debug("");
  456. /* Regular USB Cleanup */
  457. usb_deregister(&smsusb_driver);
  458. }
  459. module_init(smsusb_module_init);
  460. module_exit(smsusb_module_exit);
  461. MODULE_DESCRIPTION("Driver for the Siano SMS1XXX USB dongle");
  462. MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");
  463. MODULE_LICENSE("GPL");