/drivers/media/radio/si470x/radio-si470x-usb.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 897 lines · 533 code · 169 blank · 195 comment · 69 complexity · b49044c566ef499e717b77b541f8ebdf MD5 · raw file

  1. /*
  2. * drivers/media/radio/si470x/radio-si470x-usb.c
  3. *
  4. * USB driver for radios with Silicon Labs Si470x FM Radio Receivers
  5. *
  6. * Copyright (c) 2009 Tobias Lorenz <tobias.lorenz@gmx.net>
  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 as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. */
  22. /*
  23. * ToDo:
  24. * - add firmware download/update support
  25. */
  26. /* driver definitions */
  27. #define DRIVER_AUTHOR "Tobias Lorenz <tobias.lorenz@gmx.net>"
  28. #define DRIVER_KERNEL_VERSION KERNEL_VERSION(1, 0, 10)
  29. #define DRIVER_CARD "Silicon Labs Si470x FM Radio Receiver"
  30. #define DRIVER_DESC "USB radio driver for Si470x FM Radio Receivers"
  31. #define DRIVER_VERSION "1.0.10"
  32. /* kernel includes */
  33. #include <linux/usb.h>
  34. #include <linux/hid.h>
  35. #include <linux/slab.h>
  36. #include "radio-si470x.h"
  37. /* USB Device ID List */
  38. static struct usb_device_id si470x_usb_driver_id_table[] = {
  39. /* Silicon Labs USB FM Radio Reference Design */
  40. { USB_DEVICE_AND_INTERFACE_INFO(0x10c4, 0x818a, USB_CLASS_HID, 0, 0) },
  41. /* ADS/Tech FM Radio Receiver (formerly Instant FM Music) */
  42. { USB_DEVICE_AND_INTERFACE_INFO(0x06e1, 0xa155, USB_CLASS_HID, 0, 0) },
  43. /* KWorld USB FM Radio SnapMusic Mobile 700 (FM700) */
  44. { USB_DEVICE_AND_INTERFACE_INFO(0x1b80, 0xd700, USB_CLASS_HID, 0, 0) },
  45. /* Sanei Electric, Inc. FM USB Radio (sold as DealExtreme.com PCear) */
  46. { USB_DEVICE_AND_INTERFACE_INFO(0x10c5, 0x819a, USB_CLASS_HID, 0, 0) },
  47. /* Terminating entry */
  48. { }
  49. };
  50. MODULE_DEVICE_TABLE(usb, si470x_usb_driver_id_table);
  51. /**************************************************************************
  52. * Module Parameters
  53. **************************************************************************/
  54. /* Radio Nr */
  55. static int radio_nr = -1;
  56. module_param(radio_nr, int, 0444);
  57. MODULE_PARM_DESC(radio_nr, "Radio Nr");
  58. /* USB timeout */
  59. static unsigned int usb_timeout = 500;
  60. module_param(usb_timeout, uint, 0644);
  61. MODULE_PARM_DESC(usb_timeout, "USB timeout (ms): *500*");
  62. /* RDS buffer blocks */
  63. static unsigned int rds_buf = 100;
  64. module_param(rds_buf, uint, 0444);
  65. MODULE_PARM_DESC(rds_buf, "RDS buffer entries: *100*");
  66. /* RDS maximum block errors */
  67. static unsigned short max_rds_errors = 1;
  68. /* 0 means 0 errors requiring correction */
  69. /* 1 means 1-2 errors requiring correction (used by original USBRadio.exe) */
  70. /* 2 means 3-5 errors requiring correction */
  71. /* 3 means 6+ errors or errors in checkword, correction not possible */
  72. module_param(max_rds_errors, ushort, 0644);
  73. MODULE_PARM_DESC(max_rds_errors, "RDS maximum block errors: *1*");
  74. /**************************************************************************
  75. * USB HID Reports
  76. **************************************************************************/
  77. /* Reports 1-16 give direct read/write access to the 16 Si470x registers */
  78. /* with the (REPORT_ID - 1) corresponding to the register address across USB */
  79. /* endpoint 0 using GET_REPORT and SET_REPORT */
  80. #define REGISTER_REPORT_SIZE (RADIO_REGISTER_SIZE + 1)
  81. #define REGISTER_REPORT(reg) ((reg) + 1)
  82. /* Report 17 gives direct read/write access to the entire Si470x register */
  83. /* map across endpoint 0 using GET_REPORT and SET_REPORT */
  84. #define ENTIRE_REPORT_SIZE (RADIO_REGISTER_NUM * RADIO_REGISTER_SIZE + 1)
  85. #define ENTIRE_REPORT 17
  86. /* Report 18 is used to send the lowest 6 Si470x registers up the HID */
  87. /* interrupt endpoint 1 to Windows every 20 milliseconds for status */
  88. #define RDS_REPORT_SIZE (RDS_REGISTER_NUM * RADIO_REGISTER_SIZE + 1)
  89. #define RDS_REPORT 18
  90. /* Report 19: LED state */
  91. #define LED_REPORT_SIZE 3
  92. #define LED_REPORT 19
  93. /* Report 19: stream */
  94. #define STREAM_REPORT_SIZE 3
  95. #define STREAM_REPORT 19
  96. /* Report 20: scratch */
  97. #define SCRATCH_PAGE_SIZE 63
  98. #define SCRATCH_REPORT_SIZE (SCRATCH_PAGE_SIZE + 1)
  99. #define SCRATCH_REPORT 20
  100. /* Reports 19-22: flash upgrade of the C8051F321 */
  101. #define WRITE_REPORT_SIZE 4
  102. #define WRITE_REPORT 19
  103. #define FLASH_REPORT_SIZE 64
  104. #define FLASH_REPORT 20
  105. #define CRC_REPORT_SIZE 3
  106. #define CRC_REPORT 21
  107. #define RESPONSE_REPORT_SIZE 2
  108. #define RESPONSE_REPORT 22
  109. /* Report 23: currently unused, but can accept 60 byte reports on the HID */
  110. /* interrupt out endpoint 2 every 1 millisecond */
  111. #define UNUSED_REPORT 23
  112. /**************************************************************************
  113. * Software/Hardware Versions from Scratch Page
  114. **************************************************************************/
  115. #define RADIO_SW_VERSION_NOT_BOOTLOADABLE 6
  116. #define RADIO_SW_VERSION 7
  117. #define RADIO_HW_VERSION 1
  118. /**************************************************************************
  119. * LED State Definitions
  120. **************************************************************************/
  121. #define LED_COMMAND 0x35
  122. #define NO_CHANGE_LED 0x00
  123. #define ALL_COLOR_LED 0x01 /* streaming state */
  124. #define BLINK_GREEN_LED 0x02 /* connect state */
  125. #define BLINK_RED_LED 0x04
  126. #define BLINK_ORANGE_LED 0x10 /* disconnect state */
  127. #define SOLID_GREEN_LED 0x20 /* tuning/seeking state */
  128. #define SOLID_RED_LED 0x40 /* bootload state */
  129. #define SOLID_ORANGE_LED 0x80
  130. /**************************************************************************
  131. * Stream State Definitions
  132. **************************************************************************/
  133. #define STREAM_COMMAND 0x36
  134. #define STREAM_VIDPID 0x00
  135. #define STREAM_AUDIO 0xff
  136. /**************************************************************************
  137. * Bootloader / Flash Commands
  138. **************************************************************************/
  139. /* unique id sent to bootloader and required to put into a bootload state */
  140. #define UNIQUE_BL_ID 0x34
  141. /* mask for the flash data */
  142. #define FLASH_DATA_MASK 0x55
  143. /* bootloader commands */
  144. #define GET_SW_VERSION_COMMAND 0x00
  145. #define SET_PAGE_COMMAND 0x01
  146. #define ERASE_PAGE_COMMAND 0x02
  147. #define WRITE_PAGE_COMMAND 0x03
  148. #define CRC_ON_PAGE_COMMAND 0x04
  149. #define READ_FLASH_BYTE_COMMAND 0x05
  150. #define RESET_DEVICE_COMMAND 0x06
  151. #define GET_HW_VERSION_COMMAND 0x07
  152. #define BLANK 0xff
  153. /* bootloader command responses */
  154. #define COMMAND_OK 0x01
  155. #define COMMAND_FAILED 0x02
  156. #define COMMAND_PENDING 0x03
  157. /**************************************************************************
  158. * General Driver Functions - REGISTER_REPORTs
  159. **************************************************************************/
  160. /*
  161. * si470x_get_report - receive a HID report
  162. */
  163. static int si470x_get_report(struct si470x_device *radio, void *buf, int size)
  164. {
  165. unsigned char *report = (unsigned char *) buf;
  166. int retval;
  167. retval = usb_control_msg(radio->usbdev,
  168. usb_rcvctrlpipe(radio->usbdev, 0),
  169. HID_REQ_GET_REPORT,
  170. USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
  171. report[0], 2,
  172. buf, size, usb_timeout);
  173. if (retval < 0)
  174. dev_warn(&radio->intf->dev,
  175. "si470x_get_report: usb_control_msg returned %d\n",
  176. retval);
  177. return retval;
  178. }
  179. /*
  180. * si470x_set_report - send a HID report
  181. */
  182. static int si470x_set_report(struct si470x_device *radio, void *buf, int size)
  183. {
  184. unsigned char *report = (unsigned char *) buf;
  185. int retval;
  186. retval = usb_control_msg(radio->usbdev,
  187. usb_sndctrlpipe(radio->usbdev, 0),
  188. HID_REQ_SET_REPORT,
  189. USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
  190. report[0], 2,
  191. buf, size, usb_timeout);
  192. if (retval < 0)
  193. dev_warn(&radio->intf->dev,
  194. "si470x_set_report: usb_control_msg returned %d\n",
  195. retval);
  196. return retval;
  197. }
  198. /*
  199. * si470x_get_register - read register
  200. */
  201. int si470x_get_register(struct si470x_device *radio, int regnr)
  202. {
  203. unsigned char buf[REGISTER_REPORT_SIZE];
  204. int retval;
  205. buf[0] = REGISTER_REPORT(regnr);
  206. retval = si470x_get_report(radio, (void *) &buf, sizeof(buf));
  207. if (retval >= 0)
  208. radio->registers[regnr] = get_unaligned_be16(&buf[1]);
  209. return (retval < 0) ? -EINVAL : 0;
  210. }
  211. /*
  212. * si470x_set_register - write register
  213. */
  214. int si470x_set_register(struct si470x_device *radio, int regnr)
  215. {
  216. unsigned char buf[REGISTER_REPORT_SIZE];
  217. int retval;
  218. buf[0] = REGISTER_REPORT(regnr);
  219. put_unaligned_be16(radio->registers[regnr], &buf[1]);
  220. retval = si470x_set_report(radio, (void *) &buf, sizeof(buf));
  221. return (retval < 0) ? -EINVAL : 0;
  222. }
  223. /**************************************************************************
  224. * General Driver Functions - ENTIRE_REPORT
  225. **************************************************************************/
  226. /*
  227. * si470x_get_all_registers - read entire registers
  228. */
  229. static int si470x_get_all_registers(struct si470x_device *radio)
  230. {
  231. unsigned char buf[ENTIRE_REPORT_SIZE];
  232. int retval;
  233. unsigned char regnr;
  234. buf[0] = ENTIRE_REPORT;
  235. retval = si470x_get_report(radio, (void *) &buf, sizeof(buf));
  236. if (retval >= 0)
  237. for (regnr = 0; regnr < RADIO_REGISTER_NUM; regnr++)
  238. radio->registers[regnr] = get_unaligned_be16(
  239. &buf[regnr * RADIO_REGISTER_SIZE + 1]);
  240. return (retval < 0) ? -EINVAL : 0;
  241. }
  242. /**************************************************************************
  243. * General Driver Functions - LED_REPORT
  244. **************************************************************************/
  245. /*
  246. * si470x_set_led_state - sets the led state
  247. */
  248. static int si470x_set_led_state(struct si470x_device *radio,
  249. unsigned char led_state)
  250. {
  251. unsigned char buf[LED_REPORT_SIZE];
  252. int retval;
  253. buf[0] = LED_REPORT;
  254. buf[1] = LED_COMMAND;
  255. buf[2] = led_state;
  256. retval = si470x_set_report(radio, (void *) &buf, sizeof(buf));
  257. return (retval < 0) ? -EINVAL : 0;
  258. }
  259. /**************************************************************************
  260. * General Driver Functions - SCRATCH_REPORT
  261. **************************************************************************/
  262. /*
  263. * si470x_get_scratch_versions - gets the scratch page and version infos
  264. */
  265. static int si470x_get_scratch_page_versions(struct si470x_device *radio)
  266. {
  267. unsigned char buf[SCRATCH_REPORT_SIZE];
  268. int retval;
  269. buf[0] = SCRATCH_REPORT;
  270. retval = si470x_get_report(radio, (void *) &buf, sizeof(buf));
  271. if (retval < 0)
  272. dev_warn(&radio->intf->dev, "si470x_get_scratch: "
  273. "si470x_get_report returned %d\n", retval);
  274. else {
  275. radio->software_version = buf[1];
  276. radio->hardware_version = buf[2];
  277. }
  278. return (retval < 0) ? -EINVAL : 0;
  279. }
  280. /**************************************************************************
  281. * General Driver Functions - DISCONNECT_CHECK
  282. **************************************************************************/
  283. /*
  284. * si470x_disconnect_check - check whether radio disconnects
  285. */
  286. int si470x_disconnect_check(struct si470x_device *radio)
  287. {
  288. if (radio->disconnected)
  289. return -EIO;
  290. else
  291. return 0;
  292. }
  293. /**************************************************************************
  294. * RDS Driver Functions
  295. **************************************************************************/
  296. /*
  297. * si470x_int_in_callback - rds callback and processing function
  298. *
  299. * TODO: do we need to use mutex locks in some sections?
  300. */
  301. static void si470x_int_in_callback(struct urb *urb)
  302. {
  303. struct si470x_device *radio = urb->context;
  304. unsigned char buf[RDS_REPORT_SIZE];
  305. int retval;
  306. unsigned char regnr;
  307. unsigned char blocknum;
  308. unsigned short bler; /* rds block errors */
  309. unsigned short rds;
  310. unsigned char tmpbuf[3];
  311. if (urb->status) {
  312. if (urb->status == -ENOENT ||
  313. urb->status == -ECONNRESET ||
  314. urb->status == -ESHUTDOWN) {
  315. return;
  316. } else {
  317. dev_warn(&radio->intf->dev,
  318. "non-zero urb status (%d)\n", urb->status);
  319. goto resubmit; /* Maybe we can recover. */
  320. }
  321. }
  322. /* safety checks */
  323. if (radio->disconnected)
  324. return;
  325. if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
  326. goto resubmit;
  327. if (urb->actual_length > 0) {
  328. /* Update RDS registers with URB data */
  329. buf[0] = RDS_REPORT;
  330. for (regnr = 0; regnr < RDS_REGISTER_NUM; regnr++)
  331. radio->registers[STATUSRSSI + regnr] =
  332. get_unaligned_be16(&radio->int_in_buffer[
  333. regnr * RADIO_REGISTER_SIZE + 1]);
  334. /* get rds blocks */
  335. if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSR) == 0) {
  336. /* No RDS group ready, better luck next time */
  337. goto resubmit;
  338. }
  339. if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSS) == 0) {
  340. /* RDS decoder not synchronized */
  341. goto resubmit;
  342. }
  343. for (blocknum = 0; blocknum < 4; blocknum++) {
  344. switch (blocknum) {
  345. default:
  346. bler = (radio->registers[STATUSRSSI] &
  347. STATUSRSSI_BLERA) >> 9;
  348. rds = radio->registers[RDSA];
  349. break;
  350. case 1:
  351. bler = (radio->registers[READCHAN] &
  352. READCHAN_BLERB) >> 14;
  353. rds = radio->registers[RDSB];
  354. break;
  355. case 2:
  356. bler = (radio->registers[READCHAN] &
  357. READCHAN_BLERC) >> 12;
  358. rds = radio->registers[RDSC];
  359. break;
  360. case 3:
  361. bler = (radio->registers[READCHAN] &
  362. READCHAN_BLERD) >> 10;
  363. rds = radio->registers[RDSD];
  364. break;
  365. };
  366. /* Fill the V4L2 RDS buffer */
  367. put_unaligned_le16(rds, &tmpbuf);
  368. tmpbuf[2] = blocknum; /* offset name */
  369. tmpbuf[2] |= blocknum << 3; /* received offset */
  370. if (bler > max_rds_errors)
  371. tmpbuf[2] |= 0x80; /* uncorrectable errors */
  372. else if (bler > 0)
  373. tmpbuf[2] |= 0x40; /* corrected error(s) */
  374. /* copy RDS block to internal buffer */
  375. memcpy(&radio->buffer[radio->wr_index], &tmpbuf, 3);
  376. radio->wr_index += 3;
  377. /* wrap write pointer */
  378. if (radio->wr_index >= radio->buf_size)
  379. radio->wr_index = 0;
  380. /* check for overflow */
  381. if (radio->wr_index == radio->rd_index) {
  382. /* increment and wrap read pointer */
  383. radio->rd_index += 3;
  384. if (radio->rd_index >= radio->buf_size)
  385. radio->rd_index = 0;
  386. }
  387. }
  388. if (radio->wr_index != radio->rd_index)
  389. wake_up_interruptible(&radio->read_queue);
  390. }
  391. resubmit:
  392. /* Resubmit if we're still running. */
  393. if (radio->int_in_running && radio->usbdev) {
  394. retval = usb_submit_urb(radio->int_in_urb, GFP_ATOMIC);
  395. if (retval) {
  396. dev_warn(&radio->intf->dev,
  397. "resubmitting urb failed (%d)", retval);
  398. radio->int_in_running = 0;
  399. }
  400. }
  401. }
  402. /**************************************************************************
  403. * File Operations Interface
  404. **************************************************************************/
  405. /*
  406. * si470x_fops_open - file open
  407. */
  408. int si470x_fops_open(struct file *file)
  409. {
  410. struct si470x_device *radio = video_drvdata(file);
  411. int retval;
  412. mutex_lock(&radio->lock);
  413. radio->users++;
  414. retval = usb_autopm_get_interface(radio->intf);
  415. if (retval < 0) {
  416. radio->users--;
  417. retval = -EIO;
  418. goto done;
  419. }
  420. if (radio->users == 1) {
  421. /* start radio */
  422. retval = si470x_start(radio);
  423. if (retval < 0) {
  424. usb_autopm_put_interface(radio->intf);
  425. goto done;
  426. }
  427. /* initialize interrupt urb */
  428. usb_fill_int_urb(radio->int_in_urb, radio->usbdev,
  429. usb_rcvintpipe(radio->usbdev,
  430. radio->int_in_endpoint->bEndpointAddress),
  431. radio->int_in_buffer,
  432. le16_to_cpu(radio->int_in_endpoint->wMaxPacketSize),
  433. si470x_int_in_callback,
  434. radio,
  435. radio->int_in_endpoint->bInterval);
  436. radio->int_in_running = 1;
  437. mb();
  438. retval = usb_submit_urb(radio->int_in_urb, GFP_KERNEL);
  439. if (retval) {
  440. dev_info(&radio->intf->dev,
  441. "submitting int urb failed (%d)\n", retval);
  442. radio->int_in_running = 0;
  443. usb_autopm_put_interface(radio->intf);
  444. }
  445. }
  446. done:
  447. mutex_unlock(&radio->lock);
  448. return retval;
  449. }
  450. /*
  451. * si470x_fops_release - file release
  452. */
  453. int si470x_fops_release(struct file *file)
  454. {
  455. struct si470x_device *radio = video_drvdata(file);
  456. int retval = 0;
  457. /* safety check */
  458. if (!radio) {
  459. retval = -ENODEV;
  460. goto done;
  461. }
  462. mutex_lock(&radio->lock);
  463. radio->users--;
  464. if (radio->users == 0) {
  465. /* shutdown interrupt handler */
  466. if (radio->int_in_running) {
  467. radio->int_in_running = 0;
  468. if (radio->int_in_urb)
  469. usb_kill_urb(radio->int_in_urb);
  470. }
  471. if (radio->disconnected) {
  472. video_unregister_device(radio->videodev);
  473. kfree(radio->int_in_buffer);
  474. kfree(radio->buffer);
  475. mutex_unlock(&radio->lock);
  476. kfree(radio);
  477. goto done;
  478. }
  479. /* cancel read processes */
  480. wake_up_interruptible(&radio->read_queue);
  481. /* stop radio */
  482. retval = si470x_stop(radio);
  483. usb_autopm_put_interface(radio->intf);
  484. }
  485. mutex_unlock(&radio->lock);
  486. done:
  487. return retval;
  488. }
  489. /**************************************************************************
  490. * Video4Linux Interface
  491. **************************************************************************/
  492. /*
  493. * si470x_vidioc_querycap - query device capabilities
  494. */
  495. int si470x_vidioc_querycap(struct file *file, void *priv,
  496. struct v4l2_capability *capability)
  497. {
  498. struct si470x_device *radio = video_drvdata(file);
  499. strlcpy(capability->driver, DRIVER_NAME, sizeof(capability->driver));
  500. strlcpy(capability->card, DRIVER_CARD, sizeof(capability->card));
  501. usb_make_path(radio->usbdev, capability->bus_info,
  502. sizeof(capability->bus_info));
  503. capability->version = DRIVER_KERNEL_VERSION;
  504. capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
  505. V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE;
  506. return 0;
  507. }
  508. /**************************************************************************
  509. * USB Interface
  510. **************************************************************************/
  511. /*
  512. * si470x_usb_driver_probe - probe for the device
  513. */
  514. static int si470x_usb_driver_probe(struct usb_interface *intf,
  515. const struct usb_device_id *id)
  516. {
  517. struct si470x_device *radio;
  518. struct usb_host_interface *iface_desc;
  519. struct usb_endpoint_descriptor *endpoint;
  520. int i, int_end_size, retval = 0;
  521. unsigned char version_warning = 0;
  522. /* private data allocation and initialization */
  523. radio = kzalloc(sizeof(struct si470x_device), GFP_KERNEL);
  524. if (!radio) {
  525. retval = -ENOMEM;
  526. goto err_initial;
  527. }
  528. radio->users = 0;
  529. radio->disconnected = 0;
  530. radio->usbdev = interface_to_usbdev(intf);
  531. radio->intf = intf;
  532. mutex_init(&radio->lock);
  533. iface_desc = intf->cur_altsetting;
  534. /* Set up interrupt endpoint information. */
  535. for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
  536. endpoint = &iface_desc->endpoint[i].desc;
  537. if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ==
  538. USB_DIR_IN) && ((endpoint->bmAttributes &
  539. USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT))
  540. radio->int_in_endpoint = endpoint;
  541. }
  542. if (!radio->int_in_endpoint) {
  543. dev_info(&intf->dev, "could not find interrupt in endpoint\n");
  544. retval = -EIO;
  545. goto err_radio;
  546. }
  547. int_end_size = le16_to_cpu(radio->int_in_endpoint->wMaxPacketSize);
  548. radio->int_in_buffer = kmalloc(int_end_size, GFP_KERNEL);
  549. if (!radio->int_in_buffer) {
  550. dev_info(&intf->dev, "could not allocate int_in_buffer");
  551. retval = -ENOMEM;
  552. goto err_radio;
  553. }
  554. radio->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);
  555. if (!radio->int_in_urb) {
  556. dev_info(&intf->dev, "could not allocate int_in_urb");
  557. retval = -ENOMEM;
  558. goto err_intbuffer;
  559. }
  560. /* video device allocation and initialization */
  561. radio->videodev = video_device_alloc();
  562. if (!radio->videodev) {
  563. retval = -ENOMEM;
  564. goto err_intbuffer;
  565. }
  566. memcpy(radio->videodev, &si470x_viddev_template,
  567. sizeof(si470x_viddev_template));
  568. video_set_drvdata(radio->videodev, radio);
  569. /* get device and chip versions */
  570. if (si470x_get_all_registers(radio) < 0) {
  571. retval = -EIO;
  572. goto err_video;
  573. }
  574. dev_info(&intf->dev, "DeviceID=0x%4.4hx ChipID=0x%4.4hx\n",
  575. radio->registers[DEVICEID], radio->registers[CHIPID]);
  576. if ((radio->registers[CHIPID] & CHIPID_FIRMWARE) < RADIO_FW_VERSION) {
  577. dev_warn(&intf->dev,
  578. "This driver is known to work with "
  579. "firmware version %hu,\n", RADIO_FW_VERSION);
  580. dev_warn(&intf->dev,
  581. "but the device has firmware version %hu.\n",
  582. radio->registers[CHIPID] & CHIPID_FIRMWARE);
  583. version_warning = 1;
  584. }
  585. /* get software and hardware versions */
  586. if (si470x_get_scratch_page_versions(radio) < 0) {
  587. retval = -EIO;
  588. goto err_video;
  589. }
  590. dev_info(&intf->dev, "software version %d, hardware version %d\n",
  591. radio->software_version, radio->hardware_version);
  592. if (radio->software_version < RADIO_SW_VERSION) {
  593. dev_warn(&intf->dev,
  594. "This driver is known to work with "
  595. "software version %hu,\n", RADIO_SW_VERSION);
  596. dev_warn(&intf->dev,
  597. "but the device has software version %hu.\n",
  598. radio->software_version);
  599. version_warning = 1;
  600. }
  601. if (radio->hardware_version < RADIO_HW_VERSION) {
  602. dev_warn(&intf->dev,
  603. "This driver is known to work with "
  604. "hardware version %hu,\n", RADIO_HW_VERSION);
  605. dev_warn(&intf->dev,
  606. "but the device has hardware version %hu.\n",
  607. radio->hardware_version);
  608. version_warning = 1;
  609. }
  610. /* give out version warning */
  611. if (version_warning == 1) {
  612. dev_warn(&intf->dev,
  613. "If you have some trouble using this driver,\n");
  614. dev_warn(&intf->dev,
  615. "please report to V4L ML at "
  616. "linux-media@vger.kernel.org\n");
  617. }
  618. /* set initial frequency */
  619. si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */
  620. /* set led to connect state */
  621. si470x_set_led_state(radio, BLINK_GREEN_LED);
  622. /* rds buffer allocation */
  623. radio->buf_size = rds_buf * 3;
  624. radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
  625. if (!radio->buffer) {
  626. retval = -EIO;
  627. goto err_video;
  628. }
  629. /* rds buffer configuration */
  630. radio->wr_index = 0;
  631. radio->rd_index = 0;
  632. init_waitqueue_head(&radio->read_queue);
  633. /* register video device */
  634. retval = video_register_device(radio->videodev, VFL_TYPE_RADIO,
  635. radio_nr);
  636. if (retval) {
  637. dev_warn(&intf->dev, "Could not register video device\n");
  638. goto err_all;
  639. }
  640. usb_set_intfdata(intf, radio);
  641. return 0;
  642. err_all:
  643. kfree(radio->buffer);
  644. err_video:
  645. video_device_release(radio->videodev);
  646. err_intbuffer:
  647. kfree(radio->int_in_buffer);
  648. err_radio:
  649. kfree(radio);
  650. err_initial:
  651. return retval;
  652. }
  653. /*
  654. * si470x_usb_driver_suspend - suspend the device
  655. */
  656. static int si470x_usb_driver_suspend(struct usb_interface *intf,
  657. pm_message_t message)
  658. {
  659. dev_info(&intf->dev, "suspending now...\n");
  660. return 0;
  661. }
  662. /*
  663. * si470x_usb_driver_resume - resume the device
  664. */
  665. static int si470x_usb_driver_resume(struct usb_interface *intf)
  666. {
  667. dev_info(&intf->dev, "resuming now...\n");
  668. return 0;
  669. }
  670. /*
  671. * si470x_usb_driver_disconnect - disconnect the device
  672. */
  673. static void si470x_usb_driver_disconnect(struct usb_interface *intf)
  674. {
  675. struct si470x_device *radio = usb_get_intfdata(intf);
  676. mutex_lock(&radio->lock);
  677. radio->disconnected = 1;
  678. usb_set_intfdata(intf, NULL);
  679. if (radio->users == 0) {
  680. /* set led to disconnect state */
  681. si470x_set_led_state(radio, BLINK_ORANGE_LED);
  682. /* Free data structures. */
  683. usb_free_urb(radio->int_in_urb);
  684. kfree(radio->int_in_buffer);
  685. video_unregister_device(radio->videodev);
  686. kfree(radio->buffer);
  687. mutex_unlock(&radio->lock);
  688. kfree(radio);
  689. } else {
  690. mutex_unlock(&radio->lock);
  691. }
  692. }
  693. /*
  694. * si470x_usb_driver - usb driver interface
  695. */
  696. static struct usb_driver si470x_usb_driver = {
  697. .name = DRIVER_NAME,
  698. .probe = si470x_usb_driver_probe,
  699. .disconnect = si470x_usb_driver_disconnect,
  700. .suspend = si470x_usb_driver_suspend,
  701. .resume = si470x_usb_driver_resume,
  702. .id_table = si470x_usb_driver_id_table,
  703. .supports_autosuspend = 1,
  704. };
  705. /**************************************************************************
  706. * Module Interface
  707. **************************************************************************/
  708. /*
  709. * si470x_module_init - module init
  710. */
  711. static int __init si470x_module_init(void)
  712. {
  713. printk(KERN_INFO DRIVER_DESC ", Version " DRIVER_VERSION "\n");
  714. return usb_register(&si470x_usb_driver);
  715. }
  716. /*
  717. * si470x_module_exit - module exit
  718. */
  719. static void __exit si470x_module_exit(void)
  720. {
  721. usb_deregister(&si470x_usb_driver);
  722. }
  723. module_init(si470x_module_init);
  724. module_exit(si470x_module_exit);
  725. MODULE_LICENSE("GPL");
  726. MODULE_AUTHOR(DRIVER_AUTHOR);
  727. MODULE_DESCRIPTION(DRIVER_DESC);
  728. MODULE_VERSION(DRIVER_VERSION);