radio-si470x-i2c.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574
  1. /*
  2. * drivers/media/radio/si470x/radio-si470x-i2c.c
  3. *
  4. * I2C driver for radios with Silicon Labs Si470x FM Radio Receivers
  5. *
  6. * Copyright (c) 2009 Samsung Electronics Co.Ltd
  7. * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22. */
  23. /* driver definitions */
  24. #define DRIVER_AUTHOR "Joonyoung Shim <jy0922.shim@samsung.com>";
  25. #define DRIVER_KERNEL_VERSION KERNEL_VERSION(1, 0, 1)
  26. #define DRIVER_CARD "Silicon Labs Si470x FM Radio Receiver"
  27. #define DRIVER_DESC "I2C radio driver for Si470x FM Radio Receivers"
  28. #define DRIVER_VERSION "1.0.1"
  29. /* kernel includes */
  30. #include <linux/i2c.h>
  31. #include <linux/delay.h>
  32. #include <linux/interrupt.h>
  33. #include "radio-si470x.h"
  34. /* I2C Device ID List */
  35. static const struct i2c_device_id si470x_i2c_id[] = {
  36. /* Generic Entry */
  37. { "si470x", 0 },
  38. /* Terminating entry */
  39. { }
  40. };
  41. MODULE_DEVICE_TABLE(i2c, si470x_i2c_id);
  42. /**************************************************************************
  43. * Module Parameters
  44. **************************************************************************/
  45. /* Radio Nr */
  46. static int radio_nr = -1;
  47. module_param(radio_nr, int, 0444);
  48. MODULE_PARM_DESC(radio_nr, "Radio Nr");
  49. /* RDS buffer blocks */
  50. static unsigned int rds_buf = 100;
  51. module_param(rds_buf, uint, 0444);
  52. MODULE_PARM_DESC(rds_buf, "RDS buffer entries: *100*");
  53. /* RDS maximum block errors */
  54. static unsigned short max_rds_errors = 1;
  55. /* 0 means 0 errors requiring correction */
  56. /* 1 means 1-2 errors requiring correction (used by original USBRadio.exe) */
  57. /* 2 means 3-5 errors requiring correction */
  58. /* 3 means 6+ errors or errors in checkword, correction not possible */
  59. module_param(max_rds_errors, ushort, 0644);
  60. MODULE_PARM_DESC(max_rds_errors, "RDS maximum block errors: *1*");
  61. /**************************************************************************
  62. * I2C Definitions
  63. **************************************************************************/
  64. /* Write starts with the upper byte of register 0x02 */
  65. #define WRITE_REG_NUM 8
  66. #define WRITE_INDEX(i) (i + 0x02)
  67. /* Read starts with the upper byte of register 0x0a */
  68. #define READ_REG_NUM RADIO_REGISTER_NUM
  69. #define READ_INDEX(i) ((i + RADIO_REGISTER_NUM - 0x0a) % READ_REG_NUM)
  70. /**************************************************************************
  71. * General Driver Functions - REGISTERs
  72. **************************************************************************/
  73. /*
  74. * si470x_get_register - read register
  75. */
  76. int si470x_get_register(struct si470x_device *radio, int regnr)
  77. {
  78. u16 buf[READ_REG_NUM];
  79. struct i2c_msg msgs[1] = {
  80. { radio->client->addr, I2C_M_RD, sizeof(u16) * READ_REG_NUM,
  81. (void *)buf },
  82. };
  83. if (i2c_transfer(radio->client->adapter, msgs, 1) != 1)
  84. return -EIO;
  85. radio->registers[regnr] = __be16_to_cpu(buf[READ_INDEX(regnr)]);
  86. return 0;
  87. }
  88. /*
  89. * si470x_set_register - write register
  90. */
  91. int si470x_set_register(struct si470x_device *radio, int regnr)
  92. {
  93. int i;
  94. u16 buf[WRITE_REG_NUM];
  95. struct i2c_msg msgs[1] = {
  96. { radio->client->addr, 0, sizeof(u16) * WRITE_REG_NUM,
  97. (void *)buf },
  98. };
  99. for (i = 0; i < WRITE_REG_NUM; i++)
  100. buf[i] = __cpu_to_be16(radio->registers[WRITE_INDEX(i)]);
  101. if (i2c_transfer(radio->client->adapter, msgs, 1) != 1)
  102. return -EIO;
  103. return 0;
  104. }
  105. /**************************************************************************
  106. * General Driver Functions - ENTIRE REGISTERS
  107. **************************************************************************/
  108. /*
  109. * si470x_get_all_registers - read entire registers
  110. */
  111. static int si470x_get_all_registers(struct si470x_device *radio)
  112. {
  113. int i;
  114. u16 buf[READ_REG_NUM];
  115. struct i2c_msg msgs[1] = {
  116. { radio->client->addr, I2C_M_RD, sizeof(u16) * READ_REG_NUM,
  117. (void *)buf },
  118. };
  119. if (i2c_transfer(radio->client->adapter, msgs, 1) != 1)
  120. return -EIO;
  121. for (i = 0; i < READ_REG_NUM; i++)
  122. radio->registers[i] = __be16_to_cpu(buf[READ_INDEX(i)]);
  123. return 0;
  124. }
  125. /**************************************************************************
  126. * General Driver Functions - DISCONNECT_CHECK
  127. **************************************************************************/
  128. /*
  129. * si470x_disconnect_check - check whether radio disconnects
  130. */
  131. int si470x_disconnect_check(struct si470x_device *radio)
  132. {
  133. return 0;
  134. }
  135. /**************************************************************************
  136. * File Operations Interface
  137. **************************************************************************/
  138. /*
  139. * si470x_fops_open - file open
  140. */
  141. int si470x_fops_open(struct file *file)
  142. {
  143. struct si470x_device *radio = video_drvdata(file);
  144. int retval = 0;
  145. mutex_lock(&radio->lock);
  146. radio->users++;
  147. if (radio->users == 1) {
  148. /* start radio */
  149. retval = si470x_start(radio);
  150. if (retval < 0)
  151. goto done;
  152. /* enable RDS interrupt */
  153. radio->registers[SYSCONFIG1] |= SYSCONFIG1_RDSIEN;
  154. radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_GPIO2;
  155. radio->registers[SYSCONFIG1] |= 0x1 << 2;
  156. retval = si470x_set_register(radio, SYSCONFIG1);
  157. }
  158. done:
  159. mutex_unlock(&radio->lock);
  160. return retval;
  161. }
  162. /*
  163. * si470x_fops_release - file release
  164. */
  165. int si470x_fops_release(struct file *file)
  166. {
  167. struct si470x_device *radio = video_drvdata(file);
  168. int retval = 0;
  169. /* safety check */
  170. if (!radio)
  171. return -ENODEV;
  172. mutex_lock(&radio->lock);
  173. radio->users--;
  174. if (radio->users == 0)
  175. /* stop radio */
  176. retval = si470x_stop(radio);
  177. mutex_unlock(&radio->lock);
  178. return retval;
  179. }
  180. /**************************************************************************
  181. * Video4Linux Interface
  182. **************************************************************************/
  183. /*
  184. * si470x_vidioc_querycap - query device capabilities
  185. */
  186. int si470x_vidioc_querycap(struct file *file, void *priv,
  187. struct v4l2_capability *capability)
  188. {
  189. strlcpy(capability->driver, DRIVER_NAME, sizeof(capability->driver));
  190. strlcpy(capability->card, DRIVER_CARD, sizeof(capability->card));
  191. capability->version = DRIVER_KERNEL_VERSION;
  192. capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
  193. V4L2_CAP_TUNER | V4L2_CAP_RADIO;
  194. return 0;
  195. }
  196. /**************************************************************************
  197. * I2C Interface
  198. **************************************************************************/
  199. /*
  200. * si470x_i2c_interrupt_work - rds processing function
  201. */
  202. static void si470x_i2c_interrupt_work(struct work_struct *work)
  203. {
  204. struct si470x_device *radio = container_of(work,
  205. struct si470x_device, radio_work);
  206. unsigned char regnr;
  207. unsigned char blocknum;
  208. unsigned short bler; /* rds block errors */
  209. unsigned short rds;
  210. unsigned char tmpbuf[3];
  211. int retval = 0;
  212. /* safety checks */
  213. if ((radio->registers[SYSCONFIG1] & SYSCONFIG1_RDS) == 0)
  214. return;
  215. /* Update RDS registers */
  216. for (regnr = 0; regnr < RDS_REGISTER_NUM; regnr++) {
  217. retval = si470x_get_register(radio, STATUSRSSI + regnr);
  218. if (retval < 0)
  219. return;
  220. }
  221. /* get rds blocks */
  222. if ((radio->registers[STATUSRSSI] & STATUSRSSI_RDSR) == 0)
  223. /* No RDS group ready, better luck next time */
  224. return;
  225. for (blocknum = 0; blocknum < 4; blocknum++) {
  226. switch (blocknum) {
  227. default:
  228. bler = (radio->registers[STATUSRSSI] &
  229. STATUSRSSI_BLERA) >> 9;
  230. rds = radio->registers[RDSA];
  231. break;
  232. case 1:
  233. bler = (radio->registers[READCHAN] &
  234. READCHAN_BLERB) >> 14;
  235. rds = radio->registers[RDSB];
  236. break;
  237. case 2:
  238. bler = (radio->registers[READCHAN] &
  239. READCHAN_BLERC) >> 12;
  240. rds = radio->registers[RDSC];
  241. break;
  242. case 3:
  243. bler = (radio->registers[READCHAN] &
  244. READCHAN_BLERD) >> 10;
  245. rds = radio->registers[RDSD];
  246. break;
  247. };
  248. /* Fill the V4L2 RDS buffer */
  249. put_unaligned_le16(rds, &tmpbuf);
  250. tmpbuf[2] = blocknum; /* offset name */
  251. tmpbuf[2] |= blocknum << 3; /* received offset */
  252. if (bler > max_rds_errors)
  253. tmpbuf[2] |= 0x80; /* uncorrectable errors */
  254. else if (bler > 0)
  255. tmpbuf[2] |= 0x40; /* corrected error(s) */
  256. /* copy RDS block to internal buffer */
  257. memcpy(&radio->buffer[radio->wr_index], &tmpbuf, 3);
  258. radio->wr_index += 3;
  259. /* wrap write pointer */
  260. if (radio->wr_index >= radio->buf_size)
  261. radio->wr_index = 0;
  262. /* check for overflow */
  263. if (radio->wr_index == radio->rd_index) {
  264. /* increment and wrap read pointer */
  265. radio->rd_index += 3;
  266. if (radio->rd_index >= radio->buf_size)
  267. radio->rd_index = 0;
  268. }
  269. }
  270. if (radio->wr_index != radio->rd_index)
  271. wake_up_interruptible(&radio->read_queue);
  272. }
  273. /*
  274. * si470x_i2c_interrupt - interrupt handler
  275. */
  276. static irqreturn_t si470x_i2c_interrupt(int irq, void *dev_id)
  277. {
  278. struct si470x_device *radio = dev_id;
  279. if (!work_pending(&radio->radio_work))
  280. schedule_work(&radio->radio_work);
  281. return IRQ_HANDLED;
  282. }
  283. /*
  284. * si470x_i2c_probe - probe for the device
  285. */
  286. static int __devinit si470x_i2c_probe(struct i2c_client *client,
  287. const struct i2c_device_id *id)
  288. {
  289. struct si470x_device *radio;
  290. int retval = 0;
  291. unsigned char version_warning = 0;
  292. /* private data allocation and initialization */
  293. radio = kzalloc(sizeof(struct si470x_device), GFP_KERNEL);
  294. if (!radio) {
  295. retval = -ENOMEM;
  296. goto err_initial;
  297. }
  298. INIT_WORK(&radio->radio_work, si470x_i2c_interrupt_work);
  299. radio->users = 0;
  300. radio->client = client;
  301. mutex_init(&radio->lock);
  302. /* video device allocation and initialization */
  303. radio->videodev = video_device_alloc();
  304. if (!radio->videodev) {
  305. retval = -ENOMEM;
  306. goto err_radio;
  307. }
  308. memcpy(radio->videodev, &si470x_viddev_template,
  309. sizeof(si470x_viddev_template));
  310. video_set_drvdata(radio->videodev, radio);
  311. /* power up : need 110ms */
  312. radio->registers[POWERCFG] = POWERCFG_ENABLE;
  313. if (si470x_set_register(radio, POWERCFG) < 0) {
  314. retval = -EIO;
  315. goto err_all;
  316. }
  317. msleep(110);
  318. /* get device and chip versions */
  319. if (si470x_get_all_registers(radio) < 0) {
  320. retval = -EIO;
  321. goto err_video;
  322. }
  323. dev_info(&client->dev, "DeviceID=0x%4.4hx ChipID=0x%4.4hx\n",
  324. radio->registers[DEVICEID], radio->registers[CHIPID]);
  325. if ((radio->registers[CHIPID] & CHIPID_FIRMWARE) < RADIO_FW_VERSION) {
  326. dev_warn(&client->dev,
  327. "This driver is known to work with "
  328. "firmware version %hu,\n", RADIO_FW_VERSION);
  329. dev_warn(&client->dev,
  330. "but the device has firmware version %hu.\n",
  331. radio->registers[CHIPID] & CHIPID_FIRMWARE);
  332. version_warning = 1;
  333. }
  334. /* give out version warning */
  335. if (version_warning == 1) {
  336. dev_warn(&client->dev,
  337. "If you have some trouble using this driver,\n");
  338. dev_warn(&client->dev,
  339. "please report to V4L ML at "
  340. "linux-media@vger.kernel.org\n");
  341. }
  342. /* set initial frequency */
  343. si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */
  344. /* rds buffer allocation */
  345. radio->buf_size = rds_buf * 3;
  346. radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
  347. if (!radio->buffer) {
  348. retval = -EIO;
  349. goto err_video;
  350. }
  351. /* rds buffer configuration */
  352. radio->wr_index = 0;
  353. radio->rd_index = 0;
  354. init_waitqueue_head(&radio->read_queue);
  355. retval = request_irq(client->irq, si470x_i2c_interrupt,
  356. IRQF_TRIGGER_FALLING, DRIVER_NAME, radio);
  357. if (retval) {
  358. dev_err(&client->dev, "Failed to register interrupt\n");
  359. goto err_rds;
  360. }
  361. /* register video device */
  362. retval = video_register_device(radio->videodev, VFL_TYPE_RADIO,
  363. radio_nr);
  364. if (retval) {
  365. dev_warn(&client->dev, "Could not register video device\n");
  366. goto err_all;
  367. }
  368. i2c_set_clientdata(client, radio);
  369. return 0;
  370. err_all:
  371. free_irq(client->irq, radio);
  372. err_rds:
  373. kfree(radio->buffer);
  374. err_video:
  375. video_device_release(radio->videodev);
  376. err_radio:
  377. kfree(radio);
  378. err_initial:
  379. return retval;
  380. }
  381. /*
  382. * si470x_i2c_remove - remove the device
  383. */
  384. static __devexit int si470x_i2c_remove(struct i2c_client *client)
  385. {
  386. struct si470x_device *radio = i2c_get_clientdata(client);
  387. free_irq(client->irq, radio);
  388. cancel_work_sync(&radio->radio_work);
  389. video_unregister_device(radio->videodev);
  390. kfree(radio);
  391. i2c_set_clientdata(client, NULL);
  392. return 0;
  393. }
  394. #ifdef CONFIG_PM
  395. /*
  396. * si470x_i2c_suspend - suspend the device
  397. */
  398. static int si470x_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
  399. {
  400. struct si470x_device *radio = i2c_get_clientdata(client);
  401. /* power down */
  402. radio->registers[POWERCFG] |= POWERCFG_DISABLE;
  403. if (si470x_set_register(radio, POWERCFG) < 0)
  404. return -EIO;
  405. return 0;
  406. }
  407. /*
  408. * si470x_i2c_resume - resume the device
  409. */
  410. static int si470x_i2c_resume(struct i2c_client *client)
  411. {
  412. struct si470x_device *radio = i2c_get_clientdata(client);
  413. /* power up : need 110ms */
  414. radio->registers[POWERCFG] |= POWERCFG_ENABLE;
  415. if (si470x_set_register(radio, POWERCFG) < 0)
  416. return -EIO;
  417. msleep(110);
  418. return 0;
  419. }
  420. #else
  421. #define si470x_i2c_suspend NULL
  422. #define si470x_i2c_resume NULL
  423. #endif
  424. /*
  425. * si470x_i2c_driver - i2c driver interface
  426. */
  427. static struct i2c_driver si470x_i2c_driver = {
  428. .driver = {
  429. .name = "si470x",
  430. .owner = THIS_MODULE,
  431. },
  432. .probe = si470x_i2c_probe,
  433. .remove = __devexit_p(si470x_i2c_remove),
  434. .suspend = si470x_i2c_suspend,
  435. .resume = si470x_i2c_resume,
  436. .id_table = si470x_i2c_id,
  437. };
  438. /**************************************************************************
  439. * Module Interface
  440. **************************************************************************/
  441. /*
  442. * si470x_i2c_init - module init
  443. */
  444. static int __init si470x_i2c_init(void)
  445. {
  446. printk(KERN_INFO DRIVER_DESC ", Version " DRIVER_VERSION "\n");
  447. return i2c_add_driver(&si470x_i2c_driver);
  448. }
  449. /*
  450. * si470x_i2c_exit - module exit
  451. */
  452. static void __exit si470x_i2c_exit(void)
  453. {
  454. i2c_del_driver(&si470x_i2c_driver);
  455. }
  456. module_init(si470x_i2c_init);
  457. module_exit(si470x_i2c_exit);
  458. MODULE_LICENSE("GPL");
  459. MODULE_AUTHOR(DRIVER_AUTHOR);
  460. MODULE_DESCRIPTION(DRIVER_DESC);
  461. MODULE_VERSION(DRIVER_VERSION);