PageRenderTime 6357ms CodeModel.GetById 55ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/media/radio/radio-wl1273.c

https://bitbucket.org/wisechild/galaxy-nexus
C | 2177 lines | 1636 code | 428 blank | 113 comment | 397 complexity | 4026bb3910fa59395bc4d966f0cbeb2b MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  * Driver for the Texas Instruments WL1273 FM radio.
    3. 

  3.  *
    4. 

  4.  * Copyright (C) 2011 Nokia Corporation
    5. 

  5.  * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com>
    6. 

  6.  *
    7. 

  7.  * This program is free software; you can redistribute it and/or
    8. 

  8.  * modify it under the terms of the GNU General Public License
    9. 

  9.  * version 2 as published by the Free Software Foundation.
    10. 

  10.  *
    11. 

  11.  * This program is distributed in the hope that it will be useful,
    12. 

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
    14. 

  14.  * GNU General Public License for more details.
    15. 

  15.  *
    16. 

  16.  * You should have received a copy of the GNU General Public License
    17. 

  17.  * along with this program; if not, write to the Free Software
    18. 

  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    19. 

  19.  */
    20. 

  20. 

  21. #include <linux/delay.h>
    22. 

  22. #include <linux/firmware.h>
    23. 

  23. #include <linux/interrupt.h>
    24. 

  24. #include <linux/mfd/wl1273-core.h>
    25. 

  25. #include <linux/slab.h>
    26. 

  26. #include <media/v4l2-common.h>
    27. 

  27. #include <media/v4l2-ctrls.h>
    28. 

  28. #include <media/v4l2-device.h>
    29. 

  29. #include <media/v4l2-ioctl.h>
    30. 

  30. 

  31. #define DRIVER_DESC "Wl1273 FM Radio"
    32. 

  32. 

  33. #define WL1273_POWER_SET_OFF		0
    34. 

  34. #define WL1273_POWER_SET_FM		BIT(0)
    35. 

  35. #define WL1273_POWER_SET_RDS		BIT(1)
    36. 

  36. #define WL1273_POWER_SET_RETENTION	BIT(4)
    37. 

  37. 

  38. #define WL1273_PUPD_SET_OFF		0x00
    39. 

  39. #define WL1273_PUPD_SET_ON		0x01
    40. 

  40. #define WL1273_PUPD_SET_RETENTION	0x10
    41. 

  41. 

  42. #define WL1273_FREQ(x)		(x * 10000 / 625)
    43. 

  43. #define WL1273_INV_FREQ(x)	(x * 625 / 10000)
    44. 

  44. 

  45. /*
    46. 

  46.  * static int radio_nr - The number of the radio device
    47. 

  47.  *
    48. 

  48.  * The default is 0.
    49. 

  49.  */
    50. 

  50. static int radio_nr;
    51. 

  51. module_param(radio_nr, int, 0);
    52. 

  52. MODULE_PARM_DESC(radio_nr, "The number of the radio device. Default = 0");
    53. 

  53. 

  54. struct wl1273_device {
    55. 

  55. 	char *bus_type;
    56. 

  56. 

  57. 	u8 forbidden;
    58. 

  58. 	unsigned int preemphasis;
    59. 

  59. 	unsigned int spacing;
    60. 

  60. 	unsigned int tx_power;
    61. 

  61. 	unsigned int rx_frequency;
    62. 

  62. 	unsigned int tx_frequency;
    63. 

  63. 	unsigned int rangelow;
    64. 

  64. 	unsigned int rangehigh;
    65. 

  65. 	unsigned int band;
    66. 

  66. 	bool stereo;
    67. 

  67. 

  68. 	/* RDS */
    69. 

  69. 	unsigned int rds_on;
    70. 

  70. 

  71. 	wait_queue_head_t read_queue;
    72. 

  72. 	struct mutex lock; /* for serializing fm radio operations */
    73. 

  73. 	struct completion busy;
    74. 

  74. 

  75. 	unsigned char *buffer;
    76. 

  76. 	unsigned int buf_size;
    77. 

  77. 	unsigned int rd_index;
    78. 

  78. 	unsigned int wr_index;
    79. 

  79. 

  80. 	/* Selected interrupts */
    81. 

  81. 	u16 irq_flags;
    82. 

  82. 	u16 irq_received;
    83. 

  83. 

  84. 	struct v4l2_ctrl_handler ctrl_handler;
    85. 

  85. 	struct v4l2_device v4l2dev;
    86. 

  86. 	struct video_device videodev;
    87. 

  87. 	struct device *dev;
    88. 

  88. 	struct wl1273_core *core;
    89. 

  89. 	struct file *owner;
    90. 

  90. 	char *write_buf;
    91. 

  91. 	unsigned int rds_users;
    92. 

  92. };
    93. 

  93. 

  94. #define WL1273_IRQ_MASK	 (WL1273_FR_EVENT		|	\
    95. 

  95. 			  WL1273_POW_ENB_EVENT)
    96. 

  96. 

  97. /*
    98. 

  98.  * static unsigned int rds_buf - the number of RDS buffer blocks used.
    99. 

  99.  *
    100. 

  100.  * The default number is 100.
    101. 

  101.  */
    102. 

  102. static unsigned int rds_buf = 100;
    103. 

  103. module_param(rds_buf, uint, 0);
    104. 

  104. MODULE_PARM_DESC(rds_buf, "Number of RDS buffer entries. Default = 100");
    105. 

  105. 

  106. static int wl1273_fm_write_fw(struct wl1273_core *core,
    107. 

  107. 			      __u8 *fw, int len)
    108. 

  108. {
    109. 

  109. 	struct i2c_client *client = core->client;
    110. 

  110. 	struct i2c_msg msg;
    111. 

  111. 	int i, r = 0;
    112. 

  112. 

  113. 	msg.addr = client->addr;
    114. 

  114. 	msg.flags = 0;
    115. 

  115. 

  116. 	for (i = 0; i <= len; i++) {
    117. 

  117. 		msg.len = fw[0];
    118. 

  118. 		msg.buf = fw + 1;
    119. 

  119. 

  120. 		fw += msg.len + 1;
    121. 

  121. 		dev_dbg(&client->dev, "%s:len[%d]: %d\n", __func__, i, msg.len);
    122. 

  122. 

  123. 		r = i2c_transfer(client->adapter, &msg, 1);
    124. 

  124. 		if (r < 0 && i < len + 1)
    125. 

  125. 			break;
    126. 

  126. 	}
    127. 

  127. 

  128. 	dev_dbg(&client->dev, "%s: i: %d\n", __func__, i);
    129. 

  129. 	dev_dbg(&client->dev, "%s: len + 1: %d\n", __func__, len + 1);
    130. 

  130. 

  131. 	/* Last transfer always fails. */
    132. 

  132. 	if (i == len || r == 1)
    133. 

  133. 		r = 0;
    134. 

  134. 

  135. 	return r;
    136. 

  136. }
    137. 

  137. 

  138. #define WL1273_FIFO_HAS_DATA(status)	(1 << 5 & status)
    139. 

  139. #define WL1273_RDS_CORRECTABLE_ERROR	(1 << 3)
    140. 

  140. #define WL1273_RDS_UNCORRECTABLE_ERROR	(1 << 4)
    141. 

  141. 

  142. static int wl1273_fm_rds(struct wl1273_device *radio)
    143. 

  143. {
    144. 

  144. 	struct wl1273_core *core = radio->core;
    145. 

  145. 	struct i2c_client *client = core->client;
    146. 

  146. 	u16 val;
    147. 

  147. 	u8 b0 = WL1273_RDS_DATA_GET, status;
    148. 

  148. 	struct v4l2_rds_data rds = { 0, 0, 0 };
    149. 

  149. 	struct i2c_msg msg[] = {
    150. 

  150. 		{
    151. 

  151. 			.addr = client->addr,
    152. 

  152. 			.flags = 0,
    153. 

  153. 			.buf = &b0,
    154. 

  154. 			.len = 1,
    155. 

  155. 		},
    156. 

  156. 		{
    157. 

  157. 			.addr = client->addr,
    158. 

  158. 			.flags = I2C_M_RD,
    159. 

  159. 			.buf = (u8 *) &rds,
    160. 

  160. 			.len = sizeof(rds),
    161. 

  161. 		}
    162. 

  162. 	};
    163. 

  163. 	int r;
    164. 

  164. 

  165. 	if (core->mode != WL1273_MODE_RX)
    166. 

  166. 		return 0;
    167. 

  167. 

  168. 	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
    169. 

  169. 	if (r)
    170. 

  170. 		return r;
    171. 

  171. 

  172. 	if ((val & 0x01) == 0) {
    173. 

  173. 		/* RDS decoder not synchronized */
    174. 

  174. 		return -EAGAIN;
    175. 

  175. 	}
    176. 

  176. 

  177. 	/* copy all four RDS blocks to internal buffer */
    178. 

  178. 	do {
    179. 

  179. 		r = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
    180. 

  180. 		if (r != ARRAY_SIZE(msg)) {
    181. 

  181. 			dev_err(radio->dev, WL1273_FM_DRIVER_NAME
    182. 

  182. 				": %s: read_rds error r == %i)\n",
    183. 

  183. 				__func__, r);
    184. 

  184. 		}
    185. 

  185. 

  186. 		status = rds.block;
    187. 

  187. 

  188. 		if (!WL1273_FIFO_HAS_DATA(status))
    189. 

  189. 			break;
    190. 

  190. 

  191. 		/* copy bits 0-2 (the block ID) to bits 3-5 */
    192. 

  192. 		rds.block = V4L2_RDS_BLOCK_MSK & status;
    193. 

  193. 		rds.block |= rds.block << 3;
    194. 

  194. 

  195. 		/* copy the error bits to standard positions */
    196. 

  196. 		if (WL1273_RDS_UNCORRECTABLE_ERROR & status) {
    197. 

  197. 			rds.block |= V4L2_RDS_BLOCK_ERROR;
    198. 

  198. 			rds.block &= ~V4L2_RDS_BLOCK_CORRECTED;
    199. 

  199. 		} else if  (WL1273_RDS_CORRECTABLE_ERROR & status) {
    200. 

  200. 			rds.block &= ~V4L2_RDS_BLOCK_ERROR;
    201. 

  201. 			rds.block |= V4L2_RDS_BLOCK_CORRECTED;
    202. 

  202. 		}
    203. 

  203. 

  204. 		/* copy RDS block to internal buffer */
    205. 

  205. 		memcpy(&radio->buffer[radio->wr_index], &rds, RDS_BLOCK_SIZE);
    206. 

  206. 		radio->wr_index += 3;
    207. 

  207. 

  208. 		/* wrap write pointer */
    209. 

  209. 		if (radio->wr_index >= radio->buf_size)
    210. 

  210. 			radio->wr_index = 0;
    211. 

  211. 

  212. 		/* check for overflow & start over */
    213. 

  213. 		if (radio->wr_index == radio->rd_index) {
    214. 

  214. 			dev_dbg(radio->dev, "RDS OVERFLOW");
    215. 

  215. 

  216. 			radio->rd_index = 0;
    217. 

  217. 			radio->wr_index = 0;
    218. 

  218. 			break;
    219. 

  219. 		}
    220. 

  220. 	} while (WL1273_FIFO_HAS_DATA(status));
    221. 

  221. 

  222. 	/* wake up read queue */
    223. 

  223. 	if (radio->wr_index != radio->rd_index)
    224. 

  224. 		wake_up_interruptible(&radio->read_queue);
    225. 

  225. 

  226. 	return 0;
    227. 

  227. }
    228. 

  228. 

  229. static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id)
    230. 

  230. {
    231. 

  231. 	struct wl1273_device *radio = dev_id;
    232. 

  232. 	struct wl1273_core *core = radio->core;
    233. 

  233. 	u16 flags;
    234. 

  234. 	int r;
    235. 

  235. 

  236. 	r = core->read(core, WL1273_FLAG_GET, &flags);
    237. 

  237. 	if (r)
    238. 

  238. 		goto out;
    239. 

  239. 

  240. 	if (flags & WL1273_BL_EVENT) {
    241. 

  241. 		radio->irq_received = flags;
    242. 

  242. 		dev_dbg(radio->dev, "IRQ: BL\n");
    243. 

  243. 	}
    244. 

  244. 

  245. 	if (flags & WL1273_RDS_EVENT) {
    246. 

  246. 		msleep(200);
    247. 

  247. 

  248. 		wl1273_fm_rds(radio);
    249. 

  249. 	}
    250. 

  250. 

  251. 	if (flags & WL1273_BBLK_EVENT)
    252. 

  252. 		dev_dbg(radio->dev, "IRQ: BBLK\n");
    253. 

  253. 

  254. 	if (flags & WL1273_LSYNC_EVENT)
    255. 

  255. 		dev_dbg(radio->dev, "IRQ: LSYNC\n");
    256. 

  256. 

  257. 	if (flags & WL1273_LEV_EVENT) {
    258. 

  258. 		u16 level;
    259. 

  259. 

  260. 		r = core->read(core, WL1273_RSSI_LVL_GET, &level);
    261. 

  261. 		if (r)
    262. 

  262. 			goto out;
    263. 

  263. 

  264. 		if (level > 14)
    265. 

  265. 			dev_dbg(radio->dev, "IRQ: LEV: 0x%x04\n", level);
    266. 

  266. 	}
    267. 

  267. 

  268. 	if (flags & WL1273_IFFR_EVENT)
    269. 

  269. 		dev_dbg(radio->dev, "IRQ: IFFR\n");
    270. 

  270. 

  271. 	if (flags & WL1273_PI_EVENT)
    272. 

  272. 		dev_dbg(radio->dev, "IRQ: PI\n");
    273. 

  273. 

  274. 	if (flags & WL1273_PD_EVENT)
    275. 

  275. 		dev_dbg(radio->dev, "IRQ: PD\n");
    276. 

  276. 

  277. 	if (flags & WL1273_STIC_EVENT)
    278. 

  278. 		dev_dbg(radio->dev, "IRQ: STIC\n");
    279. 

  279. 

  280. 	if (flags & WL1273_MAL_EVENT)
    281. 

  281. 		dev_dbg(radio->dev, "IRQ: MAL\n");
    282. 

  282. 

  283. 	if (flags & WL1273_POW_ENB_EVENT) {
    284. 

  284. 		complete(&radio->busy);
    285. 

  285. 		dev_dbg(radio->dev, "NOT BUSY\n");
    286. 

  286. 		dev_dbg(radio->dev, "IRQ: POW_ENB\n");
    287. 

  287. 	}
    288. 

  288. 

  289. 	if (flags & WL1273_SCAN_OVER_EVENT)
    290. 

  290. 		dev_dbg(radio->dev, "IRQ: SCAN_OVER\n");
    291. 

  291. 

  292. 	if (flags & WL1273_ERROR_EVENT)
    293. 

  293. 		dev_dbg(radio->dev, "IRQ: ERROR\n");
    294. 

  294. 

  295. 	if (flags & WL1273_FR_EVENT) {
    296. 

  296. 		u16 freq;
    297. 

  297. 

  298. 		dev_dbg(radio->dev, "IRQ: FR:\n");
    299. 

  299. 

  300. 		if (core->mode == WL1273_MODE_RX) {
    301. 

  301. 			r = core->write(core, WL1273_TUNER_MODE_SET,
    302. 

  302. 					TUNER_MODE_STOP_SEARCH);
    303. 

  303. 			if (r) {
    304. 

  304. 				dev_err(radio->dev,
    305. 

  305. 					"%s: TUNER_MODE_SET fails: %d\n",
    306. 

  306. 					__func__, r);
    307. 

  307. 				goto out;
    308. 

  308. 			}
    309. 

  309. 

  310. 			r = core->read(core, WL1273_FREQ_SET, &freq);
    311. 

  311. 			if (r)
    312. 

  312. 				goto out;
    313. 

  313. 

  314. 			if (radio->band == WL1273_BAND_JAPAN)
    315. 

  315. 				radio->rx_frequency = WL1273_BAND_JAPAN_LOW +
    316. 

  316. 					freq * 50;
    317. 

  317. 			else
    318. 

  318. 				radio->rx_frequency = WL1273_BAND_OTHER_LOW +
    319. 

  319. 					freq * 50;
    320. 

  320. 			/*
    321. 

  321. 			 *  The driver works better with this msleep,
    322. 

  322. 			 *  the documentation doesn't mention it.
    323. 

  323. 			 */
    324. 

  324. 			usleep_range(10000, 15000);
    325. 

  325. 

  326. 			dev_dbg(radio->dev, "%dkHz\n", radio->rx_frequency);
    327. 

  327. 

  328. 		} else {
    329. 

  329. 			r = core->read(core, WL1273_CHANL_SET, &freq);
    330. 

  330. 			if (r)
    331. 

  331. 				goto out;
    332. 

  332. 

  333. 			dev_dbg(radio->dev, "%dkHz\n", freq);
    334. 

  334. 		}
    335. 

  335. 		dev_dbg(radio->dev, "%s: NOT BUSY\n", __func__);
    336. 

  336. 	}
    337. 

  337. 

  338. out:
    339. 

  339. 	core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
    340. 

  340. 	complete(&radio->busy);
    341. 

  341. 

  342. 	return IRQ_HANDLED;
    343. 

  343. }
    344. 

  344. 

  345. static int wl1273_fm_set_tx_freq(struct wl1273_device *radio, unsigned int freq)
    346. 

  346. {
    347. 

  347. 	struct wl1273_core *core = radio->core;
    348. 

  348. 	int r = 0;
    349. 

  349. 

  350. 	if (freq < WL1273_BAND_TX_LOW) {
    351. 

  351. 		dev_err(radio->dev,
    352. 

  352. 			"Frequency out of range: %d < %d\n", freq,
    353. 

  353. 			WL1273_BAND_TX_LOW);
    354. 

  354. 		return -ERANGE;
    355. 

  355. 	}
    356. 

  356. 

  357. 	if (freq > WL1273_BAND_TX_HIGH) {
    358. 

  358. 		dev_err(radio->dev,
    359. 

  359. 			"Frequency out of range: %d > %d\n", freq,
    360. 

  360. 			WL1273_BAND_TX_HIGH);
    361. 

  361. 		return -ERANGE;
    362. 

  362. 	}
    363. 

  363. 

  364. 	/*
    365. 

  365. 	 *  The driver works better with this sleep,
    366. 

  366. 	 *  the documentation doesn't mention it.
    367. 

  367. 	 */
    368. 

  368. 	usleep_range(5000, 10000);
    369. 

  369. 

  370. 	dev_dbg(radio->dev, "%s: freq: %d kHz\n", __func__, freq);
    371. 

  371. 

  372. 	/* Set the current tx channel */
    373. 

  373. 	r = core->write(core, WL1273_CHANL_SET, freq / 10);
    374. 

  374. 	if (r)
    375. 

  375. 		return r;
    376. 

  376. 

  377. 	INIT_COMPLETION(radio->busy);
    378. 

  378. 

  379. 	/* wait for the FR IRQ */
    380. 

  380. 	r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000));
    381. 

  381. 	if (!r)
    382. 

  382. 		return -ETIMEDOUT;
    383. 

  383. 

  384. 	dev_dbg(radio->dev, "WL1273_CHANL_SET: %d\n", r);
    385. 

  385. 

  386. 	/* Enable the output power */
    387. 

  387. 	r = core->write(core, WL1273_POWER_ENB_SET, 1);
    388. 

  388. 	if (r)
    389. 

  389. 		return r;
    390. 

  390. 

  391. 	INIT_COMPLETION(radio->busy);
    392. 

  392. 

  393. 	/* wait for the POWER_ENB IRQ */
    394. 

  394. 	r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
    395. 

  395. 	if (!r)
    396. 

  396. 		return -ETIMEDOUT;
    397. 

  397. 

  398. 	radio->tx_frequency = freq;
    399. 

  399. 	dev_dbg(radio->dev, "WL1273_POWER_ENB_SET: %d\n", r);
    400. 

  400. 

  401. 	return	0;
    402. 

  402. }
    403. 

  403. 

  404. static int wl1273_fm_set_rx_freq(struct wl1273_device *radio, unsigned int freq)
    405. 

  405. {
    406. 

  406. 	struct wl1273_core *core = radio->core;
    407. 

  407. 	int r, f;
    408. 

  408. 

  409. 	if (freq < radio->rangelow) {
    410. 

  410. 		dev_err(radio->dev,
    411. 

  411. 			"Frequency out of range: %d < %d\n", freq,
    412. 

  412. 			radio->rangelow);
    413. 

  413. 		r = -ERANGE;
    414. 

  414. 		goto err;
    415. 

  415. 	}
    416. 

  416. 

  417. 	if (freq > radio->rangehigh) {
    418. 

  418. 		dev_err(radio->dev,
    419. 

  419. 			"Frequency out of range: %d > %d\n", freq,
    420. 

  420. 			radio->rangehigh);
    421. 

  421. 		r = -ERANGE;
    422. 

  422. 		goto err;
    423. 

  423. 	}
    424. 

  424. 

  425. 	dev_dbg(radio->dev, "%s: %dkHz\n", __func__, freq);
    426. 

  426. 

  427. 	core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
    428. 

  428. 

  429. 	if (radio->band == WL1273_BAND_JAPAN)
    430. 

  430. 		f = (freq - WL1273_BAND_JAPAN_LOW) / 50;
    431. 

  431. 	else
    432. 

  432. 		f = (freq - WL1273_BAND_OTHER_LOW) / 50;
    433. 

  433. 

  434. 	r = core->write(core, WL1273_FREQ_SET, f);
    435. 

  435. 	if (r) {
    436. 

  436. 		dev_err(radio->dev, "FREQ_SET fails\n");
    437. 

  437. 		goto err;
    438. 

  438. 	}
    439. 

  439. 

  440. 	r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET);
    441. 

  441. 	if (r) {
    442. 

  442. 		dev_err(radio->dev, "TUNER_MODE_SET fails\n");
    443. 

  443. 		goto err;
    444. 

  444. 	}
    445. 

  445. 

  446. 	INIT_COMPLETION(radio->busy);
    447. 

  447. 

  448. 	r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000));
    449. 

  449. 	if (!r) {
    450. 

  450. 		dev_err(radio->dev, "%s: TIMEOUT\n", __func__);
    451. 

  451. 		return -ETIMEDOUT;
    452. 

  452. 	}
    453. 

  453. 

  454. 	radio->rd_index = 0;
    455. 

  455. 	radio->wr_index = 0;
    456. 

  456. 	radio->rx_frequency = freq;
    457. 

  457. 	return 0;
    458. 

  458. err:
    459. 

  459. 	return r;
    460. 

  460. }
    461. 

  461. 

  462. static int wl1273_fm_get_freq(struct wl1273_device *radio)
    463. 

  463. {
    464. 

  464. 	struct wl1273_core *core = radio->core;
    465. 

  465. 	unsigned int freq;
    466. 

  466. 	u16 f;
    467. 

  467. 	int r;
    468. 

  468. 

  469. 	if (core->mode == WL1273_MODE_RX) {
    470. 

  470. 		r = core->read(core, WL1273_FREQ_SET, &f);
    471. 

  471. 		if (r)
    472. 

  472. 			return r;
    473. 

  473. 

  474. 		dev_dbg(radio->dev, "Freq get: 0x%04x\n", f);
    475. 

  475. 		if (radio->band == WL1273_BAND_JAPAN)
    476. 

  476. 			freq = WL1273_BAND_JAPAN_LOW + 50 * f;
    477. 

  477. 		else
    478. 

  478. 			freq = WL1273_BAND_OTHER_LOW + 50 * f;
    479. 

  479. 	} else {
    480. 

  480. 		r = core->read(core, WL1273_CHANL_SET, &f);
    481. 

  481. 		if (r)
    482. 

  482. 			return r;
    483. 

  483. 

  484. 		freq = f * 10;
    485. 

  485. 	}
    486. 

  486. 

  487. 	return freq;
    488. 

  488. }
    489. 

  489. 

  490. /**
    491. 

  491.  * wl1273_fm_upload_firmware_patch() -	Upload the firmware.
    492. 

  492.  * @radio:				A pointer to the device struct.
    493. 

  493.  *
    494. 

  494.  * The firmware file consists of arrays of bytes where the first byte
    495. 

  495.  * gives the array length. The first byte in the file gives the
    496. 

  496.  * number of these arrays.
    497. 

  497.  */
    498. 

  498. static int wl1273_fm_upload_firmware_patch(struct wl1273_device *radio)
    499. 

  499. {
    500. 

  500. 	struct wl1273_core *core = radio->core;
    501. 

  501. 	unsigned int packet_num;
    502. 

  502. 	const struct firmware *fw_p;
    503. 

  503. 	const char *fw_name = "radio-wl1273-fw.bin";
    504. 

  504. 	struct device *dev = radio->dev;
    505. 

  505. 	__u8 *ptr;
    506. 

  506. 	int r;
    507. 

  507. 

  508. 	dev_dbg(dev, "%s:\n", __func__);
    509. 

  509. 

  510. 	/*
    511. 

  511. 	 * Uploading the firmware patch is not always necessary,
    512. 

  512. 	 * so we only print an info message.
    513. 

  513. 	 */
    514. 

  514. 	if (request_firmware(&fw_p, fw_name, dev)) {
    515. 

  515. 		dev_info(dev, "%s - %s not found\n", __func__, fw_name);
    516. 

  516. 

  517. 		return 0;
    518. 

  518. 	}
    519. 

  519. 

  520. 	ptr = (__u8 *) fw_p->data;
    521. 

  521. 	packet_num = ptr[0];
    522. 

  522. 	dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num);
    523. 

  523. 

  524. 	r = wl1273_fm_write_fw(core, ptr + 1, packet_num);
    525. 

  525. 	if (r) {
    526. 

  526. 		dev_err(dev, "FW upload error: %d\n", r);
    527. 

  527. 		goto out;
    528. 

  528. 	}
    529. 

  529. 

  530. 	/* ignore possible error here */
    531. 

  531. 	core->write(core, WL1273_RESET, 0);
    532. 

  532. 

  533. 	dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r);
    534. 

  534. out:
    535. 

  535. 	release_firmware(fw_p);
    536. 

  536. 	return r;
    537. 

  537. }
    538. 

  538. 

  539. static int wl1273_fm_stop(struct wl1273_device *radio)
    540. 

  540. {
    541. 

  541. 	struct wl1273_core *core = radio->core;
    542. 

  542. 

  543. 	if (core->mode == WL1273_MODE_RX) {
    544. 

  544. 		int r = core->write(core, WL1273_POWER_SET,
    545. 

  545. 				    WL1273_POWER_SET_OFF);
    546. 

  546. 		if (r)
    547. 

  547. 			dev_err(radio->dev, "%s: POWER_SET fails: %d\n",
    548. 

  548. 				__func__, r);
    549. 

  549. 	} else if (core->mode == WL1273_MODE_TX) {
    550. 

  550. 		int r = core->write(core, WL1273_PUPD_SET,
    551. 

  551. 				    WL1273_PUPD_SET_OFF);
    552. 

  552. 		if (r)
    553. 

  553. 			dev_err(radio->dev,
    554. 

  554. 				"%s: PUPD_SET fails: %d\n", __func__, r);
    555. 

  555. 	}
    556. 

  556. 

  557. 	if (core->pdata->disable) {
    558. 

  558. 		core->pdata->disable();
    559. 

  559. 		dev_dbg(radio->dev, "Back to reset\n");
    560. 

  560. 	}
    561. 

  561. 

  562. 	return 0;
    563. 

  563. }
    564. 

  564. 

  565. static int wl1273_fm_start(struct wl1273_device *radio, int new_mode)
    566. 

  566. {
    567. 

  567. 	struct wl1273_core *core = radio->core;
    568. 

  568. 	struct wl1273_fm_platform_data *pdata = core->pdata;
    569. 

  569. 	struct device *dev = radio->dev;
    570. 

  570. 	int r = -EINVAL;
    571. 

  571. 

  572. 	if (pdata->enable && core->mode == WL1273_MODE_OFF) {
    573. 

  573. 		dev_dbg(radio->dev, "Out of reset\n");
    574. 

  574. 

  575. 		pdata->enable();
    576. 

  576. 		msleep(250);
    577. 

  577. 	}
    578. 

  578. 

  579. 	if (new_mode == WL1273_MODE_RX) {
    580. 

  580. 		u16 val = WL1273_POWER_SET_FM;
    581. 

  581. 

  582. 		if (radio->rds_on)
    583. 

  583. 			val |= WL1273_POWER_SET_RDS;
    584. 

  584. 

  585. 		/* If this fails try again */
    586. 

  586. 		r = core->write(core, WL1273_POWER_SET, val);
    587. 

  587. 		if (r) {
    588. 

  588. 			msleep(100);
    589. 

  589. 

  590. 			r = core->write(core, WL1273_POWER_SET, val);
    591. 

  591. 			if (r) {
    592. 

  592. 				dev_err(dev, "%s: POWER_SET fails\n", __func__);
    593. 

  593. 				goto fail;
    594. 

  594. 			}
    595. 

  595. 		}
    596. 

  596. 

  597. 		/* rds buffer configuration */
    598. 

  598. 		radio->wr_index = 0;
    599. 

  599. 		radio->rd_index = 0;
    600. 

  600. 

  601. 	} else if (new_mode == WL1273_MODE_TX) {
    602. 

  602. 		/* If this fails try again once */
    603. 

  603. 		r = core->write(core, WL1273_PUPD_SET, WL1273_PUPD_SET_ON);
    604. 

  604. 		if (r) {
    605. 

  605. 			msleep(100);
    606. 

  606. 			r = core->write(core, WL1273_PUPD_SET,
    607. 

  607. 					WL1273_PUPD_SET_ON);
    608. 

  608. 			if (r) {
    609. 

  609. 				dev_err(dev, "%s: PUPD_SET fails\n", __func__);
    610. 

  610. 				goto fail;
    611. 

  611. 			}
    612. 

  612. 		}
    613. 

  613. 

  614. 		if (radio->rds_on)
    615. 

  615. 			r = core->write(core, WL1273_RDS_DATA_ENB, 1);
    616. 

  616. 		else
    617. 

  617. 			r = core->write(core, WL1273_RDS_DATA_ENB, 0);
    618. 

  618. 	} else {
    619. 

  619. 		dev_warn(dev, "%s: Illegal mode.\n", __func__);
    620. 

  620. 	}
    621. 

  621. 

  622. 	if (core->mode == WL1273_MODE_OFF) {
    623. 

  623. 		r = wl1273_fm_upload_firmware_patch(radio);
    624. 

  624. 		if (r)
    625. 

  625. 			dev_warn(dev, "Firmware upload failed.\n");
    626. 

  626. 

  627. 		/*
    628. 

  628. 		 * Sometimes the chip is in a wrong power state at this point.
    629. 

  629. 		 * So we set the power once again.
    630. 

  630. 		 */
    631. 

  631. 		if (new_mode == WL1273_MODE_RX) {
    632. 

  632. 			u16 val = WL1273_POWER_SET_FM;
    633. 

  633. 

  634. 			if (radio->rds_on)
    635. 

  635. 				val |= WL1273_POWER_SET_RDS;
    636. 

  636. 

  637. 			r = core->write(core, WL1273_POWER_SET, val);
    638. 

  638. 			if (r) {
    639. 

  639. 				dev_err(dev, "%s: POWER_SET fails\n", __func__);
    640. 

  640. 				goto fail;
    641. 

  641. 			}
    642. 

  642. 		} else if (new_mode == WL1273_MODE_TX) {
    643. 

  643. 			r = core->write(core, WL1273_PUPD_SET,
    644. 

  644. 					WL1273_PUPD_SET_ON);
    645. 

  645. 			if (r) {
    646. 

  646. 				dev_err(dev, "%s: PUPD_SET fails\n", __func__);
    647. 

  647. 				goto fail;
    648. 

  648. 			}
    649. 

  649. 		}
    650. 

  650. 	}
    651. 

  651. 

  652. 	return 0;
    653. 

  653. fail:
    654. 

  654. 	if (pdata->disable)
    655. 

  655. 		pdata->disable();
    656. 

  656. 

  657. 	dev_dbg(dev, "%s: return: %d\n", __func__, r);
    658. 

  658. 	return r;
    659. 

  659. }
    660. 

  660. 

  661. static int wl1273_fm_suspend(struct wl1273_device *radio)
    662. 

  662. {
    663. 

  663. 	struct wl1273_core *core = radio->core;
    664. 

  664. 	int r = 0;
    665. 

  665. 

  666. 	/* Cannot go from OFF to SUSPENDED */
    667. 

  667. 	if (core->mode == WL1273_MODE_RX)
    668. 

  668. 		r = core->write(core, WL1273_POWER_SET,
    669. 

  669. 				WL1273_POWER_SET_RETENTION);
    670. 

  670. 	else if (core->mode == WL1273_MODE_TX)
    671. 

  671. 		r = core->write(core, WL1273_PUPD_SET,
    672. 

  672. 				WL1273_PUPD_SET_RETENTION);
    673. 

  673. 	else
    674. 

  674. 		r = -EINVAL;
    675. 

  675. 

  676. 	if (r) {
    677. 

  677. 		dev_err(radio->dev, "%s: POWER_SET fails: %d\n", __func__, r);
    678. 

  678. 		goto out;
    679. 

  679. 	}
    680. 

  680. 

  681. out:
    682. 

  682. 	return r;
    683. 

  683. }
    684. 

  684. 

  685. static int wl1273_fm_set_mode(struct wl1273_device *radio, int mode)
    686. 

  686. {
    687. 

  687. 	struct wl1273_core *core = radio->core;
    688. 

  688. 	struct device *dev = radio->dev;
    689. 

  689. 	int old_mode;
    690. 

  690. 	int r;
    691. 

  691. 

  692. 	dev_dbg(dev, "%s\n", __func__);
    693. 

  693. 	dev_dbg(dev, "Forbidden modes: 0x%02x\n", radio->forbidden);
    694. 

  694. 

  695. 	old_mode = core->mode;
    696. 

  696. 	if (mode & radio->forbidden) {
    697. 

  697. 		r = -EPERM;
    698. 

  698. 		goto out;
    699. 

  699. 	}
    700. 

  700. 

  701. 	switch (mode) {
    702. 

  702. 	case WL1273_MODE_RX:
    703. 

  703. 	case WL1273_MODE_TX:
    704. 

  704. 		r = wl1273_fm_start(radio, mode);
    705. 

  705. 		if (r) {
    706. 

  706. 			dev_err(dev, "%s: Cannot start.\n", __func__);
    707. 

  707. 			wl1273_fm_stop(radio);
    708. 

  708. 			goto out;
    709. 

  709. 		}
    710. 

  710. 

  711. 		core->mode = mode;
    712. 

  712. 		r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
    713. 

  713. 		if (r) {
    714. 

  714. 			dev_err(dev, "INT_MASK_SET fails.\n");
    715. 

  715. 			goto out;
    716. 

  716. 		}
    717. 

  717. 

  718. 		/* remember previous settings */
    719. 

  719. 		if (mode == WL1273_MODE_RX) {
    720. 

  720. 			r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
    721. 

  721. 			if (r) {
    722. 

  722. 				dev_err(dev, "set freq fails: %d.\n", r);
    723. 

  723. 				goto out;
    724. 

  724. 			}
    725. 

  725. 

  726. 			r = core->set_volume(core, core->volume);
    727. 

  727. 			if (r) {
    728. 

  728. 				dev_err(dev, "set volume fails: %d.\n", r);
    729. 

  729. 				goto out;
    730. 

  730. 			}
    731. 

  731. 

  732. 			dev_dbg(dev, "%s: Set vol: %d.\n", __func__,
    733. 

  733. 				core->volume);
    734. 

  734. 		} else {
    735. 

  735. 			r = wl1273_fm_set_tx_freq(radio, radio->tx_frequency);
    736. 

  736. 			if (r) {
    737. 

  737. 				dev_err(dev, "set freq fails: %d.\n", r);
    738. 

  738. 				goto out;
    739. 

  739. 			}
    740. 

  740. 		}
    741. 

  741. 

  742. 		dev_dbg(radio->dev, "%s: Set audio mode.\n", __func__);
    743. 

  743. 

  744. 		r = core->set_audio(core, core->audio_mode);
    745. 

  745. 		if (r)
    746. 

  746. 			dev_err(dev, "Cannot set audio mode.\n");
    747. 

  747. 		break;
    748. 

  748. 

  749. 	case WL1273_MODE_OFF:
    750. 

  750. 		r = wl1273_fm_stop(radio);
    751. 

  751. 		if (r)
    752. 

  752. 			dev_err(dev, "%s: Off fails: %d\n", __func__, r);
    753. 

  753. 		else
    754. 

  754. 			core->mode = WL1273_MODE_OFF;
    755. 

  755. 

  756. 		break;
    757. 

  757. 

  758. 	case WL1273_MODE_SUSPENDED:
    759. 

  759. 		r = wl1273_fm_suspend(radio);
    760. 

  760. 		if (r)
    761. 

  761. 			dev_err(dev, "%s: Suspend fails: %d\n", __func__, r);
    762. 

  762. 		else
    763. 

  763. 			core->mode = WL1273_MODE_SUSPENDED;
    764. 

  764. 

  765. 		break;
    766. 

  766. 

  767. 	default:
    768. 

  768. 		dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode);
    769. 

  769. 		r = -EINVAL;
    770. 

  770. 		break;
    771. 

  771. 	}
    772. 

  772. out:
    773. 

  773. 	if (r)
    774. 

  774. 		core->mode = old_mode;
    775. 

  775. 

  776. 	return r;
    777. 

  777. }
    778. 

  778. 

  779. static int wl1273_fm_set_seek(struct wl1273_device *radio,
    780. 

  780. 			      unsigned int wrap_around,
    781. 

  781. 			      unsigned int seek_upward,
    782. 

  782. 			      int level)
    783. 

  783. {
    784. 

  784. 	struct wl1273_core *core = radio->core;
    785. 

  785. 	int r = 0;
    786. 

  786. 	unsigned int dir = (seek_upward == 0) ? 0 : 1;
    787. 

  787. 	unsigned int f;
    788. 

  788. 

  789. 	f = radio->rx_frequency;
    790. 

  790. 	dev_dbg(radio->dev, "rx_frequency: %d\n", f);
    791. 

  791. 

  792. 	if (dir && f + radio->spacing <= radio->rangehigh)
    793. 

  793. 		r = wl1273_fm_set_rx_freq(radio, f + radio->spacing);
    794. 

  794. 	else if (dir && wrap_around)
    795. 

  795. 		r = wl1273_fm_set_rx_freq(radio, radio->rangelow);
    796. 

  796. 	else if (f - radio->spacing >= radio->rangelow)
    797. 

  797. 		r = wl1273_fm_set_rx_freq(radio, f - radio->spacing);
    798. 

  798. 	else if (wrap_around)
    799. 

  799. 		r = wl1273_fm_set_rx_freq(radio, radio->rangehigh);
    800. 

  800. 

  801. 	if (r)
    802. 

  802. 		goto out;
    803. 

  803. 

  804. 	if (level < SCHAR_MIN || level > SCHAR_MAX)
    805. 

  805. 		return -EINVAL;
    806. 

  806. 

  807. 	INIT_COMPLETION(radio->busy);
    808. 

  808. 	dev_dbg(radio->dev, "%s: BUSY\n", __func__);
    809. 

  809. 

  810. 	r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
    811. 

  811. 	if (r)
    812. 

  812. 		goto out;
    813. 

  813. 

  814. 	dev_dbg(radio->dev, "%s\n", __func__);
    815. 

  815. 

  816. 	r = core->write(core, WL1273_SEARCH_LVL_SET, level);
    817. 

  817. 	if (r)
    818. 

  818. 		goto out;
    819. 

  819. 

  820. 	r = core->write(core, WL1273_SEARCH_DIR_SET, dir);
    821. 

  821. 	if (r)
    822. 

  822. 		goto out;
    823. 

  823. 

  824. 	r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK);
    825. 

  825. 	if (r)
    826. 

  826. 		goto out;
    827. 

  827. 

  828. 	wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
    829. 

  829. 	if (!(radio->irq_received & WL1273_BL_EVENT))
    830. 

  830. 		goto out;
    831. 

  831. 

  832. 	radio->irq_received &= ~WL1273_BL_EVENT;
    833. 

  833. 

  834. 	if (!wrap_around)
    835. 

  835. 		goto out;
    836. 

  836. 

  837. 	/* Wrap around */
    838. 

  838. 	dev_dbg(radio->dev, "Wrap around in HW seek.\n");
    839. 

  839. 

  840. 	if (seek_upward)
    841. 

  841. 		f = radio->rangelow;
    842. 

  842. 	else
    843. 

  843. 		f = radio->rangehigh;
    844. 

  844. 

  845. 	r = wl1273_fm_set_rx_freq(radio, f);
    846. 

  846. 	if (r)
    847. 

  847. 		goto out;
    848. 

  848. 

  849. 	INIT_COMPLETION(radio->busy);
    850. 

  850. 	dev_dbg(radio->dev, "%s: BUSY\n", __func__);
    851. 

  851. 

  852. 	r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK);
    853. 

  853. 	if (r)
    854. 

  854. 		goto out;
    855. 

  855. 

  856. 	wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
    857. 

  857. out:
    858. 

  858. 	dev_dbg(radio->dev, "%s: Err: %d\n", __func__, r);
    859. 

  859. 	return r;
    860. 

  860. }
    861. 

  861. 

  862. /**
    863. 

  863.  * wl1273_fm_get_tx_ctune() -	Get the TX tuning capacitor value.
    864. 

  864.  * @radio:			A pointer to the device struct.
    865. 

  865.  */
    866. 

  866. static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device *radio)
    867. 

  867. {
    868. 

  868. 	struct wl1273_core *core = radio->core;
    869. 

  869. 	struct device *dev = radio->dev;
    870. 

  870. 	u16 val;
    871. 

  871. 	int r;
    872. 

  872. 

  873. 	if (core->mode == WL1273_MODE_OFF ||
    874. 

  874. 	    core->mode == WL1273_MODE_SUSPENDED)
    875. 

  875. 		return -EPERM;
    876. 

  876. 

  877. 	r = core->read(core, WL1273_READ_FMANT_TUNE_VALUE, &val);
    878. 

  878. 	if (r) {
    879. 

  879. 		dev_err(dev, "%s: read error: %d\n", __func__, r);
    880. 

  880. 		goto out;
    881. 

  881. 	}
    882. 

  882. 

  883. out:
    884. 

  884. 	return val;
    885. 

  885. }
    886. 

  886. 

  887. /**
    888. 

  888.  * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value.
    889. 

  889.  * @radio:			 A pointer to the device struct.
    890. 

  890.  * @preemphasis:		 The new pre-amphasis value.
    891. 

  891.  *
    892. 

  892.  * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED,
    893. 

  893.  * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS.
    894. 

  894.  */
    895. 

  895. static int wl1273_fm_set_preemphasis(struct wl1273_device *radio,
    896. 

  896. 				     unsigned int preemphasis)
    897. 

  897. {
    898. 

  898. 	struct wl1273_core *core = radio->core;
    899. 

  899. 	int r;
    900. 

  900. 	u16 em;
    901. 

  901. 

  902. 	if (core->mode == WL1273_MODE_OFF ||
    903. 

  903. 	    core->mode == WL1273_MODE_SUSPENDED)
    904. 

  904. 		return -EPERM;
    905. 

  905. 

  906. 	mutex_lock(&core->lock);
    907. 

  907. 

  908. 	switch (preemphasis) {
    909. 

  909. 	case V4L2_PREEMPHASIS_DISABLED:
    910. 

  910. 		em = 1;
    911. 

  911. 		break;
    912. 

  912. 	case V4L2_PREEMPHASIS_50_uS:
    913. 

  913. 		em = 0;
    914. 

  914. 		break;
    915. 

  915. 	case V4L2_PREEMPHASIS_75_uS:
    916. 

  916. 		em = 2;
    917. 

  917. 		break;
    918. 

  918. 	default:
    919. 

  919. 		r = -EINVAL;
    920. 

  920. 		goto out;
    921. 

  921. 	}
    922. 

  922. 

  923. 	r = core->write(core, WL1273_PREMPH_SET, em);
    924. 

  924. 	if (r)
    925. 

  925. 		goto out;
    926. 

  926. 

  927. 	radio->preemphasis = preemphasis;
    928. 

  928. 

  929. out:
    930. 

  930. 	mutex_unlock(&core->lock);
    931. 

  931. 	return r;
    932. 

  932. }
    933. 

  933. 

  934. static int wl1273_fm_rds_on(struct wl1273_device *radio)
    935. 

  935. {
    936. 

  936. 	struct wl1273_core *core = radio->core;
    937. 

  937. 	int r;
    938. 

  938. 

  939. 	dev_dbg(radio->dev, "%s\n", __func__);
    940. 

  940. 	if (radio->rds_on)
    941. 

  941. 		return 0;
    942. 

  942. 

  943. 	r = core->write(core, WL1273_POWER_SET,
    944. 

  944. 			WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS);
    945. 

  945. 	if (r)
    946. 

  946. 		goto out;
    947. 

  947. 

  948. 	r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
    949. 

  949. 	if (r)
    950. 

  950. 		dev_err(radio->dev, "set freq fails: %d.\n", r);
    951. 

  951. out:
    952. 

  952. 	return r;
    953. 

  953. }
    954. 

  954. 

  955. static int wl1273_fm_rds_off(struct wl1273_device *radio)
    956. 

  956. {
    957. 

  957. 	struct wl1273_core *core = radio->core;
    958. 

  958. 	int r;
    959. 

  959. 

  960. 	if (!radio->rds_on)
    961. 

  961. 		return 0;
    962. 

  962. 

  963. 	radio->irq_flags &= ~WL1273_RDS_EVENT;
    964. 

  964. 

  965. 	r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
    966. 

  966. 	if (r)
    967. 

  967. 		goto out;
    968. 

  968. 

  969. 	/* Service pending read */
    970. 

  970. 	wake_up_interruptible(&radio->read_queue);
    971. 

  971. 

  972. 	dev_dbg(radio->dev, "%s\n", __func__);
    973. 

  973. 

  974. 	r = core->write(core, WL1273_POWER_SET, WL1273_POWER_SET_FM);
    975. 

  975. 	if (r)
    976. 

  976. 		goto out;
    977. 

  977. 

  978. 	r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
    979. 

  979. 	if (r)
    980. 

  980. 		dev_err(radio->dev, "set freq fails: %d.\n", r);
    981. 

  981. out:
    982. 

  982. 	dev_dbg(radio->dev, "%s: exiting...\n", __func__);
    983. 

  983. 

  984. 	return r;
    985. 

  985. }
    986. 

  986. 

  987. static int wl1273_fm_set_rds(struct wl1273_device *radio, unsigned int new_mode)
    988. 

  988. {
    989. 

  989. 	int r = 0;
    990. 

  990. 	struct wl1273_core *core = radio->core;
    991. 

  991. 

  992. 	if (core->mode == WL1273_MODE_OFF ||
    993. 

  993. 	    core->mode == WL1273_MODE_SUSPENDED)
    994. 

  994. 		return -EPERM;
    995. 

  995. 

  996. 	if (new_mode == WL1273_RDS_RESET) {
    997. 

  997. 		r = core->write(core, WL1273_RDS_CNTRL_SET, 1);
    998. 

  998. 		return r;
    999. 

  999. 	}
    1000. 

  1000. 

  1001. 	if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) {
    1002. 

  1002. 		r = core->write(core, WL1273_RDS_DATA_ENB, 0);
    1003. 

  1003. 	} else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) {
    1004. 

  1004. 		r = core->write(core, WL1273_RDS_DATA_ENB, 1);
    1005. 

  1005. 	} else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) {
    1006. 

  1006. 		r = wl1273_fm_rds_off(radio);
    1007. 

  1007. 	} else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) {
    1008. 

  1008. 		r = wl1273_fm_rds_on(radio);
    1009. 

  1009. 	} else {
    1010. 

  1010. 		dev_err(radio->dev, "%s: Unknown mode: %d\n",
    1011. 

  1011. 			__func__, new_mode);
    1012. 

  1012. 		r = -EINVAL;
    1013. 

  1013. 	}
    1014. 

  1014. 

  1015. 	if (!r)
    1016. 

  1016. 		radio->rds_on = (new_mode == WL1273_RDS_ON) ? true : false;
    1017. 

  1017. 

  1018. 	return r;
    1019. 

  1019. }
    1020. 

  1020. 

  1021. static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf,
    1022. 

  1022. 				    size_t count, loff_t *ppos)
    1023. 

  1023. {
    1024. 

  1024. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1025. 

  1025. 	struct wl1273_core *core = radio->core;
    1026. 

  1026. 	u16 val;
    1027. 

  1027. 	int r;
    1028. 

  1028. 

  1029. 	dev_dbg(radio->dev, "%s\n", __func__);
    1030. 

  1030. 

  1031. 	if (core->mode != WL1273_MODE_TX)
    1032. 

  1032. 		return count;
    1033. 

  1033. 

  1034. 	if (radio->rds_users == 0) {
    1035. 

  1035. 		dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
    1036. 

  1036. 		return 0;
    1037. 

  1037. 	}
    1038. 

  1038. 

  1039. 	if (mutex_lock_interruptible(&core->lock))
    1040. 

  1040. 		return -EINTR;
    1041. 

  1041. 	/*
    1042. 

  1042. 	 * Multiple processes can open the device, but only
    1043. 

  1043. 	 * one gets to write to it.
    1044. 

  1044. 	 */
    1045. 

  1045. 	if (radio->owner && radio->owner != file) {
    1046. 

  1046. 		r = -EBUSY;
    1047. 

  1047. 		goto out;
    1048. 

  1048. 	}
    1049. 

  1049. 	radio->owner = file;
    1050. 

  1050. 

  1051. 	/* Manual Mode */
    1052. 

  1052. 	if (count > 255)
    1053. 

  1053. 		val = 255;
    1054. 

  1054. 	else
    1055. 

  1055. 		val = count;
    1056. 

  1056. 

  1057. 	core->write(core, WL1273_RDS_CONFIG_DATA_SET, val);
    1058. 

  1058. 

  1059. 	if (copy_from_user(radio->write_buf + 1, buf, val)) {
    1060. 

  1060. 		r = -EFAULT;
    1061. 

  1061. 		goto out;
    1062. 

  1062. 	}
    1063. 

  1063. 

  1064. 	dev_dbg(radio->dev, "Count: %d\n", val);
    1065. 

  1065. 	dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf);
    1066. 

  1066. 

  1067. 	radio->write_buf[0] = WL1273_RDS_DATA_SET;
    1068. 

  1068. 	core->write_data(core, radio->write_buf, val + 1);
    1069. 

  1069. 

  1070. 	r = val;
    1071. 

  1071. out:
    1072. 

  1072. 	mutex_unlock(&core->lock);
    1073. 

  1073. 

  1074. 	return r;
    1075. 

  1075. }
    1076. 

  1076. 

  1077. static unsigned int wl1273_fm_fops_poll(struct file *file,
    1078. 

  1078. 					struct poll_table_struct *pts)
    1079. 

  1079. {
    1080. 

  1080. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1081. 

  1081. 	struct wl1273_core *core = radio->core;
    1082. 

  1082. 

  1083. 	if (radio->owner && radio->owner != file)
    1084. 

  1084. 		return -EBUSY;
    1085. 

  1085. 

  1086. 	radio->owner = file;
    1087. 

  1087. 

  1088. 	if (core->mode == WL1273_MODE_RX) {
    1089. 

  1089. 		poll_wait(file, &radio->read_queue, pts);
    1090. 

  1090. 

  1091. 		if (radio->rd_index != radio->wr_index)
    1092. 

  1092. 			return POLLIN | POLLRDNORM;
    1093. 

  1093. 

  1094. 	} else if (core->mode == WL1273_MODE_TX) {
    1095. 

  1095. 		return POLLOUT | POLLWRNORM;
    1096. 

  1096. 	}
    1097. 

  1097. 

  1098. 	return 0;
    1099. 

  1099. }
    1100. 

  1100. 

  1101. static int wl1273_fm_fops_open(struct file *file)
    1102. 

  1102. {
    1103. 

  1103. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1104. 

  1104. 	struct wl1273_core *core = radio->core;
    1105. 

  1105. 	int r = 0;
    1106. 

  1106. 

  1107. 	dev_dbg(radio->dev, "%s\n", __func__);
    1108. 

  1108. 

  1109. 	if (core->mode == WL1273_MODE_RX && radio->rds_on &&
    1110. 

  1110. 	    !radio->rds_users) {
    1111. 

  1111. 		dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode);
    1112. 

  1112. 

  1113. 		if (mutex_lock_interruptible(&core->lock))
    1114. 

  1114. 			return -EINTR;
    1115. 

  1115. 

  1116. 		radio->irq_flags |= WL1273_RDS_EVENT;
    1117. 

  1117. 

  1118. 		r = core->write(core, WL1273_INT_MASK_SET,
    1119. 

  1119. 				radio->irq_flags);
    1120. 

  1120. 		if (r) {
    1121. 

  1121. 			mutex_unlock(&core->lock);
    1122. 

  1122. 			goto out;
    1123. 

  1123. 		}
    1124. 

  1124. 

  1125. 		radio->rds_users++;
    1126. 

  1126. 

  1127. 		mutex_unlock(&core->lock);
    1128. 

  1128. 	}
    1129. 

  1129. out:
    1130. 

  1130. 	return r;
    1131. 

  1131. }
    1132. 

  1132. 

  1133. static int wl1273_fm_fops_release(struct file *file)
    1134. 

  1134. {
    1135. 

  1135. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1136. 

  1136. 	struct wl1273_core *core = radio->core;
    1137. 

  1137. 	int r = 0;
    1138. 

  1138. 

  1139. 	dev_dbg(radio->dev, "%s\n", __func__);
    1140. 

  1140. 

  1141. 	if (radio->rds_users > 0) {
    1142. 

  1142. 		radio->rds_users--;
    1143. 

  1143. 		if (radio->rds_users == 0) {
    1144. 

  1144. 			if (mutex_lock_interruptible(&core->lock))
    1145. 

  1145. 				return -EINTR;
    1146. 

  1146. 

  1147. 			radio->irq_flags &= ~WL1273_RDS_EVENT;
    1148. 

  1148. 

  1149. 			if (core->mode == WL1273_MODE_RX) {
    1150. 

  1150. 				r = core->write(core,
    1151. 

  1151. 						WL1273_INT_MASK_SET,
    1152. 

  1152. 						radio->irq_flags);
    1153. 

  1153. 				if (r) {
    1154. 

  1154. 					mutex_unlock(&core->lock);
    1155. 

  1155. 					goto out;
    1156. 

  1156. 				}
    1157. 

  1157. 			}
    1158. 

  1158. 			mutex_unlock(&core->lock);
    1159. 

  1159. 		}
    1160. 

  1160. 	}
    1161. 

  1161. 

  1162. 	if (file == radio->owner)
    1163. 

  1163. 		radio->owner = NULL;
    1164. 

  1164. out:
    1165. 

  1165. 	return r;
    1166. 

  1166. }
    1167. 

  1167. 

  1168. static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf,
    1169. 

  1169. 				   size_t count, loff_t *ppos)
    1170. 

  1170. {
    1171. 

  1171. 	int r = 0;
    1172. 

  1172. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1173. 

  1173. 	struct wl1273_core *core = radio->core;
    1174. 

  1174. 	unsigned int block_count = 0;
    1175. 

  1175. 	u16 val;
    1176. 

  1176. 

  1177. 	dev_dbg(radio->dev, "%s\n", __func__);
    1178. 

  1178. 

  1179. 	if (core->mode != WL1273_MODE_RX)
    1180. 

  1180. 		return 0;
    1181. 

  1181. 

  1182. 	if (radio->rds_users == 0) {
    1183. 

  1183. 		dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
    1184. 

  1184. 		return 0;
    1185. 

  1185. 	}
    1186. 

  1186. 

  1187. 	if (mutex_lock_interruptible(&core->lock))
    1188. 

  1188. 		return -EINTR;
    1189. 

  1189. 

  1190. 	/*
    1191. 

  1191. 	 * Multiple processes can open the device, but only
    1192. 

  1192. 	 * one at a time gets read access.
    1193. 

  1193. 	 */
    1194. 

  1194. 	if (radio->owner && radio->owner != file) {
    1195. 

  1195. 		r = -EBUSY;
    1196. 

  1196. 		goto out;
    1197. 

  1197. 	}
    1198. 

  1198. 	radio->owner = file;
    1199. 

  1199. 

  1200. 	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
    1201. 

  1201. 	if (r) {
    1202. 

  1202. 		dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__);
    1203. 

  1203. 		goto out;
    1204. 

  1204. 	} else if (val == 0) {
    1205. 

  1205. 		dev_info(radio->dev, "RDS_SYNC: Not synchronized\n");
    1206. 

  1206. 		r = -ENODATA;
    1207. 

  1207. 		goto out;
    1208. 

  1208. 	}
    1209. 

  1209. 

  1210. 	/* block if no new data available */
    1211. 

  1211. 	while (radio->wr_index == radio->rd_index) {
    1212. 

  1212. 		if (file->f_flags & O_NONBLOCK) {
    1213. 

  1213. 			r = -EWOULDBLOCK;
    1214. 

  1214. 			goto out;
    1215. 

  1215. 		}
    1216. 

  1216. 

  1217. 		dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__);
    1218. 

  1218. 		if (wait_event_interruptible(radio->read_queue,
    1219. 

  1219. 					     radio->wr_index !=
    1220. 

  1220. 					     radio->rd_index) < 0) {
    1221. 

  1221. 			r = -EINTR;
    1222. 

  1222. 			goto out;
    1223. 

  1223. 		}
    1224. 

  1224. 	}
    1225. 

  1225. 

  1226. 	/* calculate block count from byte count */
    1227. 

  1227. 	count /= RDS_BLOCK_SIZE;
    1228. 

  1228. 

  1229. 	/* copy RDS blocks from the internal buffer and to user buffer */
    1230. 

  1230. 	while (block_count < count) {
    1231. 

  1231. 		if (radio->rd_index == radio->wr_index)
    1232. 

  1232. 			break;
    1233. 

  1233. 

  1234. 		/* always transfer complete RDS blocks */
    1235. 

  1235. 		if (copy_to_user(buf, &radio->buffer[radio->rd_index],
    1236. 

  1236. 				 RDS_BLOCK_SIZE))
    1237. 

  1237. 			break;
    1238. 

  1238. 

  1239. 		/* increment and wrap the read pointer */
    1240. 

  1240. 		radio->rd_index += RDS_BLOCK_SIZE;
    1241. 

  1241. 		if (radio->rd_index >= radio->buf_size)
    1242. 

  1242. 			radio->rd_index = 0;
    1243. 

  1243. 

  1244. 		/* increment counters */
    1245. 

  1245. 		block_count++;
    1246. 

  1246. 		buf += RDS_BLOCK_SIZE;
    1247. 

  1247. 		r += RDS_BLOCK_SIZE;
    1248. 

  1248. 	}
    1249. 

  1249. 

  1250. out:
    1251. 

  1251. 	dev_dbg(radio->dev, "%s: exit\n", __func__);
    1252. 

  1252. 	mutex_unlock(&core->lock);
    1253. 

  1253. 

  1254. 	return r;
    1255. 

  1255. }
    1256. 

  1256. 

  1257. static const struct v4l2_file_operations wl1273_fops = {
    1258. 

  1258. 	.owner		= THIS_MODULE,
    1259. 

  1259. 	.read		= wl1273_fm_fops_read,
    1260. 

  1260. 	.write		= wl1273_fm_fops_write,
    1261. 

  1261. 	.poll		= wl1273_fm_fops_poll,
    1262. 

  1262. 	.unlocked_ioctl	= video_ioctl2,
    1263. 

  1263. 	.open		= wl1273_fm_fops_open,
    1264. 

  1264. 	.release	= wl1273_fm_fops_release,
    1265. 

  1265. };
    1266. 

  1266. 

  1267. static int wl1273_fm_vidioc_querycap(struct file *file, void *priv,
    1268. 

  1268. 				     struct v4l2_capability *capability)
    1269. 

  1269. {
    1270. 

  1270. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1271. 

  1271. 

  1272. 	dev_dbg(radio->dev, "%s\n", __func__);
    1273. 

  1273. 

  1274. 	strlcpy(capability->driver, WL1273_FM_DRIVER_NAME,
    1275. 

  1275. 		sizeof(capability->driver));
    1276. 

  1276. 	strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio",
    1277. 

  1277. 		sizeof(capability->card));
    1278. 

  1278. 	strlcpy(capability->bus_info, radio->bus_type,
    1279. 

  1279. 		sizeof(capability->bus_info));
    1280. 

  1280. 

  1281. 	capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
    1282. 

  1282. 		V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO |
    1283. 

  1283. 		V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR |
    1284. 

  1284. 		V4L2_CAP_RDS_OUTPUT;
    1285. 

  1285. 

  1286. 	return 0;
    1287. 

  1287. }
    1288. 

  1288. 

  1289. static int wl1273_fm_vidioc_g_input(struct file *file, void *priv,
    1290. 

  1290. 				    unsigned int *i)
    1291. 

  1291. {
    1292. 

  1292. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1293. 

  1293. 

  1294. 	dev_dbg(radio->dev, "%s\n", __func__);
    1295. 

  1295. 

  1296. 	*i = 0;
    1297. 

  1297. 

  1298. 	return 0;
    1299. 

  1299. }
    1300. 

  1300. 

  1301. static int wl1273_fm_vidioc_s_input(struct file *file, void *priv,
    1302. 

  1302. 				    unsigned int i)
    1303. 

  1303. {
    1304. 

  1304. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1305. 

  1305. 

  1306. 	dev_dbg(radio->dev, "%s\n", __func__);
    1307. 

  1307. 

  1308. 	if (i != 0)
    1309. 

  1309. 		return -EINVAL;
    1310. 

  1310. 

  1311. 	return 0;
    1312. 

  1312. }
    1313. 

  1313. 

  1314. /**
    1315. 

  1315.  * wl1273_fm_set_tx_power() -	Set the transmission power value.
    1316. 

  1316.  * @core:			A pointer to the device struct.
    1317. 

  1317.  * @power:			The new power value.
    1318. 

  1318.  */
    1319. 

  1319. static int wl1273_fm_set_tx_power(struct wl1273_device *radio, u16 power)
    1320. 

  1320. {
    1321. 

  1321. 	struct wl1273_core *core = radio->core;
    1322. 

  1322. 	int r;
    1323. 

  1323. 

  1324. 	if (core->mode == WL1273_MODE_OFF ||
    1325. 

  1325. 	    core->mode == WL1273_MODE_SUSPENDED)
    1326. 

  1326. 		return -EPERM;
    1327. 

  1327. 

  1328. 	mutex_lock(&core->lock);
    1329. 

  1329. 

  1330. 	/* Convert the dBuV value to chip presentation */
    1331. 

  1331. 	r = core->write(core, WL1273_POWER_LEV_SET, 122 - power);
    1332. 

  1332. 	if (r)
    1333. 

  1333. 		goto out;
    1334. 

  1334. 

  1335. 	radio->tx_power = power;
    1336. 

  1336. 

  1337. out:
    1338. 

  1338. 	mutex_unlock(&core->lock);
    1339. 

  1339. 	return r;
    1340. 

  1340. }
    1341. 

  1341. 

  1342. #define WL1273_SPACING_50kHz	1
    1343. 

  1343. #define WL1273_SPACING_100kHz	2
    1344. 

  1344. #define WL1273_SPACING_200kHz	4
    1345. 

  1345. 

  1346. static int wl1273_fm_tx_set_spacing(struct wl1273_device *radio,
    1347. 

  1347. 				    unsigned int spacing)
    1348. 

  1348. {
    1349. 

  1349. 	struct wl1273_core *core = radio->core;
    1350. 

  1350. 	int r;
    1351. 

  1351. 

  1352. 	if (spacing == 0) {
    1353. 

  1353. 		r = core->write(core, WL1273_SCAN_SPACING_SET,
    1354. 

  1354. 				WL1273_SPACING_100kHz);
    1355. 

  1355. 		radio->spacing = 100;
    1356. 

  1356. 	} else if (spacing - 50000 < 25000) {
    1357. 

  1357. 		r = core->write(core, WL1273_SCAN_SPACING_SET,
    1358. 

  1358. 				WL1273_SPACING_50kHz);
    1359. 

  1359. 		radio->spacing = 50;
    1360. 

  1360. 	} else if (spacing - 100000 < 50000) {
    1361. 

  1361. 		r = core->write(core, WL1273_SCAN_SPACING_SET,
    1362. 

  1362. 				WL1273_SPACING_100kHz);
    1363. 

  1363. 		radio->spacing = 100;
    1364. 

  1364. 	} else {
    1365. 

  1365. 		r = core->write(core, WL1273_SCAN_SPACING_SET,
    1366. 

  1366. 				WL1273_SPACING_200kHz);
    1367. 

  1367. 		radio->spacing = 200;
    1368. 

  1368. 	}
    1369. 

  1369. 

  1370. 	return r;
    1371. 

  1371. }
    1372. 

  1372. 

  1373. static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
    1374. 

  1374. {
    1375. 

  1375. 	struct wl1273_device *radio = ctrl->priv;
    1376. 

  1376. 	struct wl1273_core *core = radio->core;
    1377. 

  1377. 

  1378. 	dev_dbg(radio->dev, "%s\n", __func__);
    1379. 

  1379. 

  1380. 	if (mutex_lock_interruptible(&core->lock))
    1381. 

  1381. 		return -EINTR;
    1382. 

  1382. 

  1383. 	switch (ctrl->id) {
    1384. 

  1384. 	case  V4L2_CID_TUNE_ANTENNA_CAPACITOR:
    1385. 

  1385. 		ctrl->cur.val = wl1273_fm_get_tx_ctune(radio);
    1386. 

  1386. 		break;
    1387. 

  1387. 

  1388. 	default:
    1389. 

  1389. 		dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
    1390. 

  1390. 			 __func__, ctrl->id);
    1391. 

  1391. 		break;
    1392. 

  1392. 	}
    1393. 

  1393. 

  1394. 	mutex_unlock(&core->lock);
    1395. 

  1395. 

  1396. 	return 0;
    1397. 

  1397. }
    1398. 

  1398. 

  1399. #define WL1273_MUTE_SOFT_ENABLE    (1 << 0)
    1400. 

  1400. #define WL1273_MUTE_AC             (1 << 1)
    1401. 

  1401. #define WL1273_MUTE_HARD_LEFT      (1 << 2)
    1402. 

  1402. #define WL1273_MUTE_HARD_RIGHT     (1 << 3)
    1403. 

  1403. #define WL1273_MUTE_SOFT_FORCE     (1 << 4)
    1404. 

  1404. 

  1405. static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl)
    1406. 

  1406. {
    1407. 

  1407. 	return container_of(ctrl->handler, struct wl1273_device, ctrl_handler);
    1408. 

  1408. }
    1409. 

  1409. 

  1410. static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl)
    1411. 

  1411. {
    1412. 

  1412. 	struct wl1273_device *radio = to_radio(ctrl);
    1413. 

  1413. 	struct wl1273_core *core = radio->core;
    1414. 

  1414. 	int r = 0;
    1415. 

  1415. 

  1416. 	dev_dbg(radio->dev, "%s\n", __func__);
    1417. 

  1417. 

  1418. 	switch (ctrl->id) {
    1419. 

  1419. 	case V4L2_CID_AUDIO_MUTE:
    1420. 

  1420. 		if (mutex_lock_interruptible(&core->lock))
    1421. 

  1421. 			return -EINTR;
    1422. 

  1422. 

  1423. 		if (core->mode == WL1273_MODE_RX && ctrl->val)
    1424. 

  1424. 			r = core->write(core,
    1425. 

  1425. 					WL1273_MUTE_STATUS_SET,
    1426. 

  1426. 					WL1273_MUTE_HARD_LEFT |
    1427. 

  1427. 					WL1273_MUTE_HARD_RIGHT);
    1428. 

  1428. 		else if (core->mode == WL1273_MODE_RX)
    1429. 

  1429. 			r = core->write(core,
    1430. 

  1430. 					WL1273_MUTE_STATUS_SET, 0x0);
    1431. 

  1431. 		else if (core->mode == WL1273_MODE_TX && ctrl->val)
    1432. 

  1432. 			r = core->write(core, WL1273_MUTE, 1);
    1433. 

  1433. 		else if (core->mode == WL1273_MODE_TX)
    1434. 

  1434. 			r = core->write(core, WL1273_MUTE, 0);
    1435. 

  1435. 

  1436. 		mutex_unlock(&core->lock);
    1437. 

  1437. 		break;
    1438. 

  1438. 

  1439. 	case V4L2_CID_AUDIO_VOLUME:
    1440. 

  1440. 		if (ctrl->val == 0)
    1441. 

  1441. 			r = wl1273_fm_set_mode(radio, WL1273_MODE_OFF);
    1442. 

  1442. 		else
    1443. 

  1443. 			r =  core->set_volume(core, core->volume);
    1444. 

  1444. 		break;
    1445. 

  1445. 

  1446. 	case V4L2_CID_TUNE_PREEMPHASIS:
    1447. 

  1447. 		r = wl1273_fm_set_preemphasis(radio, ctrl->val);
    1448. 

  1448. 		break;
    1449. 

  1449. 

  1450. 	case V4L2_CID_TUNE_POWER_LEVEL:
    1451. 

  1451. 		r = wl1273_fm_set_tx_power(radio, ctrl->val);
    1452. 

  1452. 		break;
    1453. 

  1453. 

  1454. 	default:
    1455. 

  1455. 		dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
    1456. 

  1456. 			 __func__, ctrl->id);
    1457. 

  1457. 		break;
    1458. 

  1458. 	}
    1459. 

  1459. 

  1460. 	dev_dbg(radio->dev, "%s\n", __func__);
    1461. 

  1461. 	return r;
    1462. 

  1462. }
    1463. 

  1463. 

  1464. static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv,
    1465. 

  1465. 				    struct v4l2_audio *audio)
    1466. 

  1466. {
    1467. 

  1467. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1468. 

  1468. 

  1469. 	dev_dbg(radio->dev, "%s\n", __func__);
    1470. 

  1470. 

  1471. 	if (audio->index > 1)
    1472. 

  1472. 		return -EINVAL;
    1473. 

  1473. 

  1474. 	strlcpy(audio->name, "Radio", sizeof(audio->name));
    1475. 

  1475. 	audio->capability = V4L2_AUDCAP_STEREO;
    1476. 

  1476. 

  1477. 	return 0;
    1478. 

  1478. }
    1479. 

  1479. 

  1480. static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv,
    1481. 

  1481. 				    struct v4l2_audio *audio)
    1482. 

  1482. {
    1483. 

  1483. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1484. 

  1484. 

  1485. 	dev_dbg(radio->dev, "%s\n", __func__);
    1486. 

  1486. 

  1487. 	if (audio->index != 0)
    1488. 

  1488. 		return -EINVAL;
    1489. 

  1489. 

  1490. 	return 0;
    1491. 

  1491. }
    1492. 

  1492. 

  1493. #define WL1273_RDS_NOT_SYNCHRONIZED 0
    1494. 

  1494. #define WL1273_RDS_SYNCHRONIZED 1
    1495. 

  1495. 

  1496. static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv,
    1497. 

  1497. 				    struct v4l2_tuner *tuner)
    1498. 

  1498. {
    1499. 

  1499. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1500. 

  1500. 	struct wl1273_core *core = radio->core;
    1501. 

  1501. 	u16 val;
    1502. 

  1502. 	int r;
    1503. 

  1503. 

  1504. 	dev_dbg(radio->dev, "%s\n", __func__);
    1505. 

  1505. 

  1506. 	if (tuner->index > 0)
    1507. 

  1507. 		return -EINVAL;
    1508. 

  1508. 

  1509. 	strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name));
    1510. 

  1510. 	tuner->type = V4L2_TUNER_RADIO;
    1511. 

  1511. 

  1512. 	tuner->rangelow	= WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
    1513. 

  1513. 	tuner->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
    1514. 

  1514. 

  1515. 	tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
    1516. 

  1516. 		V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
    1517. 

  1517. 

  1518. 	if (radio->stereo)
    1519. 

  1519. 		tuner->audmode = V4L2_TUNER_MODE_STEREO;
    1520. 

  1520. 	else
    1521. 

  1521. 		tuner->audmode = V4L2_TUNER_MODE_MONO;
    1522. 

  1522. 

  1523. 	if (core->mode != WL1273_MODE_RX)
    1524. 

  1524. 		return 0;
    1525. 

  1525. 

  1526. 	if (mutex_lock_interruptible(&core->lock))
    1527. 

  1527. 		return -EINTR;
    1528. 

  1528. 

  1529. 	r = core->read(core, WL1273_STEREO_GET, &val);
    1530. 

  1530. 	if (r)
    1531. 

  1531. 		goto out;
    1532. 

  1532. 

  1533. 	if (val == 1)
    1534. 

  1534. 		tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
    1535. 

  1535. 	else
    1536. 

  1536. 		tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
    1537. 

  1537. 

  1538. 	r = core->read(core, WL1273_RSSI_LVL_GET, &val);
    1539. 

  1539. 	if (r)
    1540. 

  1540. 		goto out;
    1541. 

  1541. 

  1542. 	tuner->signal = (s16) val;
    1543. 

  1543. 	dev_dbg(radio->dev, "Signal: %d\n", tuner->signal);
    1544. 

  1544. 

  1545. 	tuner->afc = 0;
    1546. 

  1546. 

  1547. 	r = core->read(core, WL1273_RDS_SYNC_GET, &val);
    1548. 

  1548. 	if (r)
    1549. 

  1549. 		goto out;
    1550. 

  1550. 

  1551. 	if (val == WL1273_RDS_SYNCHRONIZED)
    1552. 

  1552. 		tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
    1553. 

  1553. out:
    1554. 

  1554. 	mutex_unlock(&core->lock);
    1555. 

  1555. 

  1556. 	return r;
    1557. 

  1557. }
    1558. 

  1558. 

  1559. static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv,
    1560. 

  1560. 				    struct v4l2_tuner *tuner)
    1561. 

  1561. {
    1562. 

  1562. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1563. 

  1563. 	struct wl1273_core *core = radio->core;
    1564. 

  1564. 	int r = 0;
    1565. 

  1565. 

  1566. 	dev_dbg(radio->dev, "%s\n", __func__);
    1567. 

  1567. 	dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index);
    1568. 

  1568. 	dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name);
    1569. 

  1569. 	dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability);
    1570. 

  1570. 	dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans);
    1571. 

  1571. 	dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow);
    1572. 

  1572. 	dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh);
    1573. 

  1573. 

  1574. 	if (tuner->index > 0)
    1575. 

  1575. 		return -EINVAL;
    1576. 

  1576. 

  1577. 	if (mutex_lock_interruptible(&core->lock))
    1578. 

  1578. 		return -EINTR;
    1579. 

  1579. 

  1580. 	r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
    1581. 

  1581. 	if (r)
    1582. 

  1582. 		goto out;
    1583. 

  1583. 

  1584. 	if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS)
    1585. 

  1585. 		r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
    1586. 

  1586. 	else
    1587. 

  1587. 		r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
    1588. 

  1588. 

  1589. 	if (r)
    1590. 

  1590. 		dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r);
    1591. 

  1591. 

  1592. 	if (tuner->audmode == V4L2_TUNER_MODE_MONO) {
    1593. 

  1593. 		r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_MONO);
    1594. 

  1594. 		if (r < 0) {
    1595. 

  1595. 			dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
    1596. 

  1596. 				 __func__, r);
    1597. 

  1597. 			goto out;
    1598. 

  1598. 		}
    1599. 

  1599. 		radio->stereo = false;
    1600. 

  1600. 	} else if (tuner->audmode == V4L2_TUNER_MODE_STEREO) {
    1601. 

  1601. 		r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_STEREO);
    1602. 

  1602. 		if (r < 0) {
    1603. 

  1603. 			dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
    1604. 

  1604. 				 __func__, r);
    1605. 

  1605. 			goto out;
    1606. 

  1606. 		}
    1607. 

  1607. 		radio->stereo = true;
    1608. 

  1608. 	} else {
    1609. 

  1609. 		dev_err(radio->dev, "%s: tuner->audmode: %d\n",
    1610. 

  1610. 			 __func__, tuner->audmode);
    1611. 

  1611. 		r = -EINVAL;
    1612. 

  1612. 		goto out;
    1613. 

  1613. 	}
    1614. 

  1614. 

  1615. out:
    1616. 

  1616. 	mutex_unlock(&core->lock);
    1617. 

  1617. 

  1618. 	return r;
    1619. 

  1619. }
    1620. 

  1620. 

  1621. static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv,
    1622. 

  1622. 					struct v4l2_frequency *freq)
    1623. 

  1623. {
    1624. 

  1624. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1625. 

  1625. 	struct wl1273_core *core = radio->core;
    1626. 

  1626. 

  1627. 	dev_dbg(radio->dev, "%s\n", __func__);
    1628. 

  1628. 

  1629. 	if (mutex_lock_interruptible(&core->lock))
    1630. 

  1630. 		return -EINTR;
    1631. 

  1631. 

  1632. 	freq->type = V4L2_TUNER_RADIO;
    1633. 

  1633. 	freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(radio));
    1634. 

  1634. 

  1635. 	mutex_unlock(&core->lock);
    1636. 

  1636. 

  1637. 	return 0;
    1638. 

  1638. }
    1639. 

  1639. 

  1640. static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv,
    1641. 

  1641. 					struct v4l2_frequency *freq)
    1642. 

  1642. {
    1643. 

  1643. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1644. 

  1644. 	struct wl1273_core *core = radio->core;
    1645. 

  1645. 	int r;
    1646. 

  1646. 

  1647. 	dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency);
    1648. 

  1648. 

  1649. 	if (freq->type != V4L2_TUNER_RADIO) {
    1650. 

  1650. 		dev_dbg(radio->dev,
    1651. 

  1651. 			"freq->type != V4L2_TUNER_RADIO: %d\n", freq->type);
    1652. 

  1652. 		return -EINVAL;
    1653. 

  1653. 	}
    1654. 

  1654. 

  1655. 	if (mutex_lock_interruptible(&core->lock))
    1656. 

  1656. 		return -EINTR;
    1657. 

  1657. 

  1658. 	if (core->mode == WL1273_MODE_RX) {
    1659. 

  1659. 		dev_dbg(radio->dev, "freq: %d\n", freq->frequency);
    1660. 

  1660. 

  1661. 		r = wl1273_fm_set_rx_freq(radio,
    1662. 

  1662. 					  WL1273_INV_FREQ(freq->frequency));
    1663. 

  1663. 		if (r)
    1664. 

  1664. 			dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
    1665. 

  1665. 				 ": set frequency failed with %d\n", r);
    1666. 

  1666. 	} else {
    1667. 

  1667. 		r = wl1273_fm_set_tx_freq(radio,
    1668. 

  1668. 					  WL1273_INV_FREQ(freq->frequency));
    1669. 

  1669. 		if (r)
    1670. 

  1670. 			dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
    1671. 

  1671. 				 ": set frequency failed with %d\n", r);
    1672. 

  1672. 	}
    1673. 

  1673. 

  1674. 	mutex_unlock(&core->lock);
    1675. 

  1675. 

  1676. 	dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n");
    1677. 

  1677. 	return r;
    1678. 

  1678. }
    1679. 

  1679. 

  1680. #define WL1273_DEFAULT_SEEK_LEVEL	7
    1681. 

  1681. 

  1682. static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv,
    1683. 

  1683. 					   struct v4l2_hw_freq_seek *seek)
    1684. 

  1684. {
    1685. 

  1685. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1686. 

  1686. 	struct wl1273_core *core = radio->core;
    1687. 

  1687. 	int r;
    1688. 

  1688. 

  1689. 	dev_dbg(radio->dev, "%s\n", __func__);
    1690. 

  1690. 

  1691. 	if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO)
    1692. 

  1692. 		return -EINVAL;
    1693. 

  1693. 

  1694. 	if (mutex_lock_interruptible(&core->lock))
    1695. 

  1695. 		return -EINTR;
    1696. 

  1696. 

  1697. 	r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
    1698. 

  1698. 	if (r)
    1699. 

  1699. 		goto out;
    1700. 

  1700. 

  1701. 	r = wl1273_fm_tx_set_spacing(radio, seek->spacing);
    1702. 

  1702. 	if (r)
    1703. 

  1703. 		dev_warn(radio->dev, "HW seek failed: %d\n", r);
    1704. 

  1704. 

  1705. 	r = wl1273_fm_set_seek(radio, seek->wrap_around, seek->seek_upward,
    1706. 

  1706. 			       WL1273_DEFAULT_SEEK_LEVEL);
    1707. 

  1707. 	if (r)
    1708. 

  1708. 		dev_warn(radio->dev, "HW seek failed: %d\n", r);
    1709. 

  1709. 

  1710. out:
    1711. 

  1711. 	mutex_unlock(&core->lock);
    1712. 

  1712. 	return r;
    1713. 

  1713. }
    1714. 

  1714. 

  1715. static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv,
    1716. 

  1716. 					struct v4l2_modulator *modulator)
    1717. 

  1717. {
    1718. 

  1718. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1719. 

  1719. 	struct wl1273_core *core = radio->core;
    1720. 

  1720. 	int r = 0;
    1721. 

  1721. 

  1722. 	dev_dbg(radio->dev, "%s\n", __func__);
    1723. 

  1723. 

  1724. 	if (modulator->index > 0)
    1725. 

  1725. 		return -EINVAL;
    1726. 

  1726. 

  1727. 	if (mutex_lock_interruptible(&core->lock))
    1728. 

  1728. 		return -EINTR;
    1729. 

  1729. 

  1730. 	r = wl1273_fm_set_mode(radio, WL1273_MODE_TX);
    1731. 

  1731. 	if (r)
    1732. 

  1732. 		goto out;
    1733. 

  1733. 

  1734. 	if (modulator->txsubchans & V4L2_TUNER_SUB_RDS)
    1735. 

  1735. 		r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
    1736. 

  1736. 	else
    1737. 

  1737. 		r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
    1738. 

  1738. 

  1739. 	if (modulator->txsubchans & V4L2_TUNER_SUB_MONO)
    1740. 

  1740. 		r = core->write(core, WL1273_MONO_SET, WL1273_TX_MONO);
    1741. 

  1741. 	else
    1742. 

  1742. 		r = core->write(core, WL1273_MONO_SET,
    1743. 

  1743. 				WL1273_RX_STEREO);
    1744. 

  1744. 	if (r < 0)
    1745. 

  1745. 		dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
    1746. 

  1746. 			 "MONO_SET fails: %d\n", r);
    1747. 

  1747. out:
    1748. 

  1748. 	mutex_unlock(&core->lock);
    1749. 

  1749. 

  1750. 	return r;
    1751. 

  1751. }
    1752. 

  1752. 

  1753. static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv,
    1754. 

  1754. 					struct v4l2_modulator *modulator)
    1755. 

  1755. {
    1756. 

  1756. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1757. 

  1757. 	struct wl1273_core *core = radio->core;
    1758. 

  1758. 	u16 val;
    1759. 

  1759. 	int r;
    1760. 

  1760. 

  1761. 	dev_dbg(radio->dev, "%s\n", __func__);
    1762. 

  1762. 

  1763. 	strlcpy(modulator->name, WL1273_FM_DRIVER_NAME,
    1764. 

  1764. 		sizeof(modulator->name));
    1765. 

  1765. 

  1766. 	modulator->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
    1767. 

  1767. 	modulator->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
    1768. 

  1768. 

  1769. 	modulator->capability =  V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
    1770. 

  1770. 		V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
    1771. 

  1771. 

  1772. 	if (core->mode != WL1273_MODE_TX)
    1773. 

  1773. 		return 0;
    1774. 

  1774. 

  1775. 	if (mutex_lock_interruptible(&core->lock))
    1776. 

  1776. 		return -EINTR;
    1777. 

  1777. 

  1778. 	r = core->read(core, WL1273_MONO_SET, &val);
    1779. 

  1779. 	if (r)
    1780. 

  1780. 		goto out;
    1781. 

  1781. 

  1782. 	if (val == WL1273_TX_STEREO)
    1783. 

  1783. 		modulator->txsubchans = V4L2_TUNER_SUB_STEREO;
    1784. 

  1784. 	else
    1785. 

  1785. 		modulator->txsubchans = V4L2_TUNER_SUB_MONO;
    1786. 

  1786. 

  1787. 	if (radio->rds_on)
    1788. 

  1788. 		modulator->txsubchans |= V4L2_TUNER_SUB_RDS;
    1789. 

  1789. out:
    1790. 

  1790. 	mutex_unlock(&core->lock);
    1791. 

  1791. 

  1792. 	return 0;
    1793. 

  1793. }
    1794. 

  1794. 

  1795. static int wl1273_fm_vidioc_log_status(struct file *file, void *priv)
    1796. 

  1796. {
    1797. 

  1797. 	struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
    1798. 

  1798. 	struct wl1273_core *core = radio->core;
    1799. 

  1799. 	struct device *dev = radio->dev;
    1800. 

  1800. 	u16 val;
    1801. 

  1801. 	int r;
    1802. 

  1802. 

  1803. 	dev_info(dev, DRIVER_DESC);
    1804. 

  1804. 

  1805. 	if (core->mode == WL1273_MODE_OFF) {
    1806. 

  1806. 		dev_info(dev, "Mode: Off\n");
    1807. 

  1807. 		return 0;
    1808. 

  1808. 	}
    1809. 

  1809. 

  1810. 	if (core->mode == WL1273_MODE_SUSPENDED) {
    1811. 

  1811. 		dev_info(dev, "Mode: Suspended\n");
    1812. 

  1812. 		return 0;
    1813. 

  1813. 	}
    1814. 

  1814. 

  1815. 	r = core->read(core, WL1273_ASIC_ID_GET, &val);
    1816. 

  1816. 	if (r)
    1817. 

  1817. 		dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__);
    1818. 

  1818. 	else
    1819. 

  1819. 		dev_info(dev, "ASIC_ID: 0x%04x\n", val);
    1820. 

  1820. 

  1821. 	r = core->read(core, WL1273_ASIC_VER_GET, &val);
    1822. 

  1822. 	if (r)
    1823. 

  1823. 		dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__);
    1824. 

  1824. 	else
    1825. 

  1825. 		dev_info(dev, "ASIC Version: 0x%04x\n", val);
    1826. 

  1826. 

  1827. 	r = core->read(core, WL1273_FIRM_VER_GET, &val);
    1828. 

  1828. 	if (r)
    1829. 

  1829. 		dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__);
    1830. 

  1830. 	else
    1831. 

  1831. 		dev_info(dev, "FW version: %d(0x%04x)\n", val, val);
    1832. 

  1832. 

  1833. 	r = core->read(core, WL1273_BAND_SET, &val);
    1834. 

  1834. 	if (r)
    1835. 

  1835. 		dev_err(dev, "%s: Get BAND fails.\n", __func__);
    1836. 

  1836. 	else
    1837. 

  1837. 		dev_info(dev, "BAND: %d\n", val);
    1838. 

  1838. 

  1839. 	if (core->mode == WL1273_MODE_TX) {
    1840. 

  1840. 		r = core->read(core, WL1273_PUPD_SET, &val);
    1841. 

  1841. 		if (r)
    1842. 

  1842. 			dev_err(dev, "%s: Get PUPD fails.\n", __func__);
    1843. 

  1843. 		else
    1844. 

  1844. 			dev_info(dev, "PUPD: 0x%04x\n", val);
    1845. 

  1845. 

  1846. 		r = core->read(core, WL1273_CHANL_SET, &val);
    1847. 

  1847. 		if (r)
    1848. 

  1848. 			dev_err(dev, "%s: Get CHANL fails.\n", __func__);
    1849. 

  1849. 		else
    1850. 

  1850. 			dev_info(dev, "Tx frequency: %dkHz\n", val*10);
    1851. 

  1851. 	} else if (core->mode == WL1273_MODE_RX) {
    1852. 

  1852. 		int bf = radio->rangelow;
    1853. 

  1853. 

  1854. 		r = core->read(core, WL1273_FREQ_SET, &val);
    1855. 

  1855. 		if (r)
    1856. 

  1856. 			dev_err(dev, "%s: Get FREQ fails.\n", __func__);
    1857. 

  1857. 		else
    1858. 

  1858. 			dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50);
    1859. 

  1859. 

  1860. 		r = core->read(core, WL1273_MOST_MODE_SET, &val);
    1861. 

  1861. 		if (r)
    1862. 

  1862. 			dev_err(dev, "%s: Get MOST_MODE fails.\n",
    1863. 

  1863. 				__func__);
    1864. 

  1864. 		else if (val == 0)
    1865. 

  1865. 			dev_info(dev, "MOST_MODE: Stereo according to blend\n");
    1866. 

  1866. 		else if (val == 1)
    1867. 

  1867. 			dev_info(dev, "MOST_MODE: Force mono output\n");
    1868. 

  1868. 		else
    1869. 

  1869. 			dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val);
    1870. 

  1870. 

  1871. 		r = core->read(core, WL1273_MOST_BLEND_SET, &val);
    1872. 

  1872. 		if (r)
    1873. 

  1873. 			dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__);
    1874. 

  1874. 		else if (val == 0)
    1875. 

  1875. 			dev_info(dev,
    1876. 

  1876. 				 "MOST_BLEND: Switched blend & hysteresis.\n");
    1877. 

  1877. 		else if (val == 1)
    1878. 

  1878. 			dev_info(dev, "MOST_BLEND: Soft blend.\n");
    1879. 

  1879. 		else
    1880. 

  1880. 			dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val);
    1881. 

  1881. 

  1882. 		r = core->read(core, WL1273_STEREO_GET, &val);
    1883. 

  1883. 		if (r)
    1884. 

  1884. 			dev_err(dev, "%s: Get STEREO fails.\n", __func__);
    1885. 

  1885. 		else if (val == 0)
    1886. 

  1886. 			dev_info(dev, "STEREO: Not detected\n");
    1887. 

  1887. 		else if (val == 1)
    1888. 

  1888. 			dev_info(dev, "STEREO: Detected\n");
    1889. 

  1889. 		else
    1890. 

  1890. 			dev_info(dev, "STEREO: Unexpected value: %d\n", val);
    1891. 

  1891. 

  1892. 		r = core->read(core, WL1273_RSSI_LVL_GET, &val);
    1893. 

  1893. 		if (r)
    1894. 

  1894. 			dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__);
    1895. 

  1895. 		else
    1896. 

  1896. 			dev_info(dev, "RX signal strength: %d\n", (s16) val);
    1897. 

  1897. 

  1898. 		r = core->read(core, WL1273_POWER_SET, &val);
    1899. 

  1899. 		if (r)
    1900. 

  1900. 			dev_err(dev, "%s: Get POWER fails.\n", __func__);
    1901. 

  1901. 		else
    1902. 

  1902. 			dev_info(dev, "POWER: 0x%04x\n", val);
    1903. 

  1903. 

  1904. 		r = core->read(core, WL1273_INT_MASK_SET, &val);
    1905. 

  1905. 		if (r)
    1906. 

  1906. 			dev_err(dev, "%s: Get INT_MASK fails.\n", __func__);
    1907. 

  1907. 		else
    1908. 

  1908. 			dev_info(dev, "INT_MASK: 0x%04x\n", val);
    1909. 

  1909. 

  1910. 		r = core->read(core, WL1273_RDS_SYNC_GET, &val);
    1911. 

  1911. 		if (r)
    1912. 

  1912. 			dev_err(dev, "%s: Get RDS_SYNC fails.\n",
    1913. 

  1913. 				__func__);
    1914. 

  1914. 		else if (val == 0)
    1915. 

  1915. 			dev_info(dev, "RDS_SYNC: Not synchronized\n");
    1916. 

  1916. 

  1917. 		else if (val == 1)
    1918. 

  1918. 			dev_info(dev, "RDS_SYNC: Synchronized\n");
    1919. 

  1919. 		else
    1920. 

  1920. 			dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val);
    1921. 

  1921. 

  1922. 		r = core->read(core, WL1273_I2S_MODE_CONFIG_SET, &val);
    1923. 

  1923. 		if (r)
    1924. 

  1924. 			dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n",
    1925. 

  1925. 				__func__);
    1926. 

  1926. 		else
    1927. 

  1927. 			dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val);
    1928. 

  1928. 

  1929. 		r = core->read(core, WL1273_VOLUME_SET, &val);
    1930. 

  1930. 		if (r)
    1931. 

  1931. 			dev_err(dev, "%s: Get VOLUME fails.\n", __func__);
    1932. 

  1932. 		else
    1933. 

  1933. 			dev_info(dev, "VOLUME: 0x%04x\n", val);
    1934. 

  1934. 	}
    1935. 

  1935. 

  1936. 	return 0;
    1937. 

  1937. }
    1938. 

  1938. 

  1939. static void wl1273_vdev_release(struct video_device *dev)
    1940. 

  1940. {
    1941. 

  1941. }
    1942. 

  1942. 

  1943. static const struct v4l2_ctrl_ops wl1273_ctrl_ops = {
    1944. 

  1944. 	.s_ctrl = wl1273_fm_vidioc_s_ctrl,
    1945. 

  1945. 	.g_volatile_ctrl = wl1273_fm_g_volatile_ctrl,
    1946. 

  1946. };
    1947. 

  1947. 

  1948. static const struct v4l2_ioctl_ops wl1273_ioctl_ops = {
    1949. 

  1949. 	.vidioc_querycap	= wl1273_fm_vidioc_querycap,
    1950. 

  1950. 	.vidioc_g_input		= wl1273_fm_vidioc_g_input,
    1951. 

  1951. 	.vidioc_s_input		= wl1273_fm_vidioc_s_input,
    1952. 

  1952. 	.vidioc_g_audio		= wl1273_fm_vidioc_g_audio,
    1953. 

  1953. 	.vidioc_s_audio		= wl1273_fm_vidioc_s_audio,
    1954. 

  1954. 	.vidioc_g_tuner		= wl1273_fm_vidioc_g_tuner,
    1955. 

  1955. 	.vidioc_s_tuner		= wl1273_fm_vidioc_s_tuner,
    1956. 

  1956. 	.vidioc_g_frequency	= wl1273_fm_vidioc_g_frequency,
    1957. 

  1957. 	.vidioc_s_frequency	= wl1273_fm_vidioc_s_frequency,
    1958. 

  1958. 	.vidioc_s_hw_freq_seek	= wl1273_fm_vidioc_s_hw_freq_seek,
    1959. 

  1959. 	.vidioc_g_modulator	= wl1273_fm_vidioc_g_modulator,
    1960. 

  1960. 	.vidioc_s_modulator	= wl1273_fm_vidioc_s_modulator,
    1961. 

  1961. 	.vidioc_log_status      = wl1273_fm_vidioc_log_status,
    1962. 

  1962. };
    1963. 

  1963. 

  1964. static struct video_device wl1273_viddev_template = {
    1965. 

  1965. 	.fops			= &wl1273_fops,
    1966. 

  1966. 	.ioctl_ops		= &wl1273_ioctl_ops,
    1967. 

  1967. 	.name			= WL1273_FM_DRIVER_NAME,
    1968. 

  1968. 	.release		= wl1273_vdev_release,
    1969. 

  1969. };
    1970. 

  1970. 

  1971. static int wl1273_fm_radio_remove(struct platform_device *pdev)
    1972. 

  1972. {
    1973. 

  1973. 	struct wl1273_device *radio = platform_get_drvdata(pdev);
    1974. 

  1974. 	struct wl1273_core *core = radio->core;
    1975. 

  1975. 

  1976. 	dev_info(&pdev->dev, "%s.\n", __func__);
    1977. 

  1977. 

  1978. 	free_irq(core->client->irq, radio);
    1979. 

  1979. 	core->pdata->free_resources();
    1980. 

  1980. 

  1981. 	v4l2_ctrl_handler_free(&radio->ctrl_handler);
    1982. 

  1982. 	video_unregister_device(&radio->videodev);
    1983. 

  1983. 	v4l2_device_unregister(&radio->v4l2dev);
    1984. 

  1984. 	kfree(radio->buffer);
    1985. 

  1985. 	kfree(radio->write_buf);
    1986. 

  1986. 	kfree(radio);
    1987. 

  1987. 

  1988. 	return 0;
    1989. 

  1989. }
    1990. 

  1990. 

  1991. static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev)
    1992. 

  1992. {
    1993. 

  1993. 	struct wl1273_core **core = pdev->dev.platform_data;
    1994. 

  1994. 	struct wl1273_device *radio;
    1995. 

  1995. 	struct v4l2_ctrl *ctrl;
    1996. 

  1996. 	int r = 0;
    1997. 

  1997. 

  1998. 	pr_debug("%s\n", __func__);
    1999. 

  1999. 

  2000. 	if (!core) {
    2001. 

  2001. 		dev_err(&pdev->dev, "No platform data.\n");
    2002. 

  2002. 		r = -EINVAL;
    2003. 

  2003. 		goto pdata_err;
    2004. 

  2004. 	}
    2005. 

  2005. 

  2006. 	radio = kzalloc(sizeof(*radio), GFP_KERNEL);
    2007. 

  2007. 	if (!radio) {
    2008. 

  2008. 		r = -ENOMEM;
    2009. 

  2009. 		goto pdata_err;
    2010. 

  2010. 	}
    2011. 

  2011. 

  2012. 	/* RDS buffer allocation */
    2013. 

  2013. 	radio->buf_size = rds_buf * RDS_BLOCK_SIZE;
    2014. 

  2014. 	radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
    2015. 

  2015. 	if (!radio->buffer) {
    2016. 

  2016. 		pr_err("Cannot allocate memory for RDS buffer.\n");
    2017. 

  2017. 		r = -ENOMEM;
    2018. 

  2018. 		goto err_kmalloc;
    2019. 

  2019. 	}
    2020. 

  2020. 

  2021. 	radio->core = *core;
    2022. 

  2022. 	radio->irq_flags = WL1273_IRQ_MASK;
    2023. 

  2023. 	radio->dev = &radio->core->client->dev;
    2024. 

  2024. 	radio->rds_on = false;
    2025. 

  2025. 	radio->core->mode = WL1273_MODE_OFF;
    2026. 

  2026. 	radio->tx_power = 118;
    2027. 

  2027. 	radio->core->audio_mode = WL1273_AUDIO_ANALOG;
    2028. 

  2028. 	radio->band = WL1273_BAND_OTHER;
    2029. 

  2029. 	radio->core->i2s_mode = WL1273_I2S_DEF_MODE;
    2030. 

  2030. 	radio->core->channel_number = 2;
    2031. 

  2031. 	radio->core->volume = WL1273_DEFAULT_VOLUME;
    2032. 

  2032. 	radio->rx_frequency = WL1273_BAND_OTHER_LOW;
    2033. 

  2033. 	radio->tx_frequency = WL1273_BAND_OTHER_HIGH;
    2034. 

  2034. 	radio->rangelow = WL1273_BAND_OTHER_LOW;
    2035. 

  2035. 	radio->rangehigh = WL1273_BAND_OTHER_HIGH;
    2036. 

  2036. 	radio->stereo = true;
    2037. 

  2037. 	radio->bus_type = "I2C";
    2038. 

  2038. 

  2039. 	if (radio->core->pdata->request_resources) {
    2040. 

  2040. 		r = radio->core->pdata->request_resources(radio->core->client);
    2041. 

  2041. 		if (r) {
    2042. 

  2042. 			dev_err(radio->dev, WL1273_FM_DRIVER_NAME
    2043. 

  2043. 				": Cannot get platform data\n");
    2044. 

  2044. 			goto err_resources;
    2045. 

  2045. 		}
    2046. 

  2046. 

  2047. 		dev_dbg(radio->dev, "irq: %d\n", radio->core->client->irq);
    2048. 

  2048. 

  2049. 		r = request_threaded_irq(radio->core->client->irq, NULL,
    2050. 

  2050. 					 wl1273_fm_irq_thread_handler,
    2051. 

  2051. 					 IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
    2052. 

  2052. 					 "wl1273-fm", radio);
    2053. 

  2053. 		if (r < 0) {
    2054. 

  2054. 			dev_err(radio->dev, WL1273_FM_DRIVER_NAME
    2055. 

  2055. 				": Unable to register IRQ handler: %d\n", r);
    2056. 

  2056. 			goto err_request_irq;
    2057. 

  2057. 		}
    2058. 

  2058. 	} else {
    2059. 

  2059. 		dev_err(radio->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ"
    2060. 

  2060. 			" not configured");
    2061. 

  2061. 		r = -EINVAL;
    2062. 

  2062. 		goto err_resources;
    2063. 

  2063. 	}
    2064. 

  2064. 

  2065. 	init_completion(&radio->busy);
    2066. 

  2066. 	init_waitqueue_head(&radio->read_queue);
    2067. 

  2067. 

  2068. 	radio->write_buf = kmalloc(256, GFP_KERNEL);
    2069. 

  2069. 	if (!radio->write_buf) {
    2070. 

  2070. 		r = -ENOMEM;
    2071. 

  2071. 		goto write_buf_err;
    2072. 

  2072. 	}
    2073. 

  2073. 

  2074. 	radio->dev = &pdev->dev;
    2075. 

  2075. 	radio->v4l2dev.ctrl_handler = &radio->ctrl_handler;
    2076. 

  2076. 	radio->rds_users = 0;
    2077. 

  2077. 

  2078. 	r = v4l2_device_register(&pdev->dev, &radio->v4l2dev);
    2079. 

  2079. 	if (r) {
    2080. 

  2080. 		dev_err(&pdev->dev, "Cannot register v4l2_device.\n");
    2081. 

  2081. 		goto device_register_err;
    2082. 

  2082. 	}
    2083. 

  2083. 

  2084. 	/* V4L2 configuration */
    2085. 

  2085. 	memcpy(&radio->videodev, &wl1273_viddev_template,
    2086. 

  2086. 	       sizeof(wl1273_viddev_template));
    2087. 

  2087. 

  2088. 	radio->videodev.v4l2_dev = &radio->v4l2dev;
    2089. 

  2089. 

  2090. 	v4l2_ctrl_handler_init(&radio->ctrl_handler, 6);
    2091. 

  2091. 

  2092. 	/* add in ascending ID order */
    2093. 

  2093. 	v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
    2094. 

  2094. 			  V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1,
    2095. 

  2095. 			  WL1273_DEFAULT_VOLUME);
    2096. 

  2096. 

  2097. 	v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
    2098. 

  2098. 			  V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
    2099. 

  2099. 

  2100. 	v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops,
    2101. 

  2101. 			       V4L2_CID_TUNE_PREEMPHASIS,
    2102. 

  2102. 			       V4L2_PREEMPHASIS_75_uS, 0x03,
    2103. 

  2103. 			       V4L2_PREEMPHASIS_50_uS);
    2104. 

  2104. 

  2105. 	v4l2_ctrl_new_std(&ra…
    2106.

Large files files are truncated, but you can click here to view the full file