diff options
Diffstat (limited to 'extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch')
-rw-r--r-- | extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch | 2114 |
1 files changed, 2114 insertions, 0 deletions
diff --git a/extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch b/extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch new file mode 100644 index 00000000..61dc164b --- /dev/null +++ b/extras/recipes-kernel/linux/linux-omap/wl1271/0009-drivers-media-radio-wl128x-FM-Driver-Common-sources.patch | |||
@@ -0,0 +1,2114 @@ | |||
1 | From 1c32040233847f9c7998e7c557fa80dfd953e236 Mon Sep 17 00:00:00 2001 | ||
2 | From: Manjunatha Halli <manjunatha_halli@ti.com> | ||
3 | Date: Tue, 11 Jan 2011 11:31:23 +0000 | ||
4 | Subject: [PATCH 09/15] drivers:media:radio: wl128x: FM Driver Common sources | ||
5 | |||
6 | These are the sources for the common interfaces required by the | ||
7 | FM V4L2 driver for TI WL127x and WL128x chips. | ||
8 | |||
9 | These implement the FM channel-8 protocol communication with the | ||
10 | chip. This makes use of the Shared Transport as its transport. | ||
11 | |||
12 | Signed-off-by: Manjunatha Halli <manjunatha_halli@ti.com> | ||
13 | Reviewed-by: Hans Verkuil <hverkuil@xs4all.nl> | ||
14 | --- | ||
15 | drivers/media/radio/wl128x/fmdrv_common.c | 1677 +++++++++++++++++++++++++++++ | ||
16 | drivers/media/radio/wl128x/fmdrv_common.h | 402 +++++++ | ||
17 | 2 files changed, 2079 insertions(+), 0 deletions(-) | ||
18 | create mode 100644 drivers/media/radio/wl128x/fmdrv_common.c | ||
19 | create mode 100644 drivers/media/radio/wl128x/fmdrv_common.h | ||
20 | |||
21 | diff --git a/drivers/media/radio/wl128x/fmdrv_common.c b/drivers/media/radio/wl128x/fmdrv_common.c | ||
22 | new file mode 100644 | ||
23 | index 0000000..12f4c65 | ||
24 | --- /dev/null | ||
25 | +++ b/drivers/media/radio/wl128x/fmdrv_common.c | ||
26 | @@ -0,0 +1,1677 @@ | ||
27 | +/* | ||
28 | + * FM Driver for Connectivity chip of Texas Instruments. | ||
29 | + * | ||
30 | + * This sub-module of FM driver is common for FM RX and TX | ||
31 | + * functionality. This module is responsible for: | ||
32 | + * 1) Forming group of Channel-8 commands to perform particular | ||
33 | + * functionality (eg., frequency set require more than | ||
34 | + * one Channel-8 command to be sent to the chip). | ||
35 | + * 2) Sending each Channel-8 command to the chip and reading | ||
36 | + * response back over Shared Transport. | ||
37 | + * 3) Managing TX and RX Queues and Tasklets. | ||
38 | + * 4) Handling FM Interrupt packet and taking appropriate action. | ||
39 | + * 5) Loading FM firmware to the chip (common, FM TX, and FM RX | ||
40 | + * firmware files based on mode selection) | ||
41 | + * | ||
42 | + * Copyright (C) 2011 Texas Instruments | ||
43 | + * Author: Raja Mani <raja_mani@ti.com> | ||
44 | + * Author: Manjunatha Halli <manjunatha_halli@ti.com> | ||
45 | + * | ||
46 | + * This program is free software; you can redistribute it and/or modify | ||
47 | + * it under the terms of the GNU General Public License version 2 as | ||
48 | + * published by the Free Software Foundation. | ||
49 | + * | ||
50 | + * This program is distributed in the hope that it will be useful, | ||
51 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
52 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
53 | + * GNU General Public License for more details. | ||
54 | + * | ||
55 | + * You should have received a copy of the GNU General Public License | ||
56 | + * along with this program; if not, write to the Free Software | ||
57 | + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
58 | + * | ||
59 | + */ | ||
60 | + | ||
61 | +#include <linux/module.h> | ||
62 | +#include <linux/firmware.h> | ||
63 | +#include <linux/delay.h> | ||
64 | +#include "fmdrv.h" | ||
65 | +#include "fmdrv_v4l2.h" | ||
66 | +#include "fmdrv_common.h" | ||
67 | +#include <linux/ti_wilink_st.h> | ||
68 | +#include "fmdrv_rx.h" | ||
69 | +#include "fmdrv_tx.h" | ||
70 | + | ||
71 | +/* Region info */ | ||
72 | +static struct region_info region_configs[] = { | ||
73 | + /* Europe/US */ | ||
74 | + { | ||
75 | + .chanl_space = FM_CHANNEL_SPACING_200KHZ * FM_FREQ_MUL, | ||
76 | + .bot_freq = 87500, /* 87.5 MHz */ | ||
77 | + .top_freq = 108000, /* 108 MHz */ | ||
78 | + .fm_band = 0, | ||
79 | + }, | ||
80 | + /* Japan */ | ||
81 | + { | ||
82 | + .chanl_space = FM_CHANNEL_SPACING_200KHZ * FM_FREQ_MUL, | ||
83 | + .bot_freq = 76000, /* 76 MHz */ | ||
84 | + .top_freq = 90000, /* 90 MHz */ | ||
85 | + .fm_band = 1, | ||
86 | + }, | ||
87 | +}; | ||
88 | + | ||
89 | +/* Band selection */ | ||
90 | +static u8 default_radio_region; /* Europe/US */ | ||
91 | +module_param(default_radio_region, byte, 0); | ||
92 | +MODULE_PARM_DESC(default_radio_region, "Region: 0=Europe/US, 1=Japan"); | ||
93 | + | ||
94 | +/* RDS buffer blocks */ | ||
95 | +static u32 default_rds_buf = 300; | ||
96 | +module_param(default_rds_buf, uint, 0444); | ||
97 | +MODULE_PARM_DESC(rds_buf, "RDS buffer entries"); | ||
98 | + | ||
99 | +/* Radio Nr */ | ||
100 | +static u32 radio_nr = -1; | ||
101 | +module_param(radio_nr, int, 0444); | ||
102 | +MODULE_PARM_DESC(radio_nr, "Radio Nr"); | ||
103 | + | ||
104 | +/* FM irq handlers forward declaration */ | ||
105 | +static void fm_irq_send_flag_getcmd(struct fmdev *); | ||
106 | +static void fm_irq_handle_flag_getcmd_resp(struct fmdev *); | ||
107 | +static void fm_irq_handle_hw_malfunction(struct fmdev *); | ||
108 | +static void fm_irq_handle_rds_start(struct fmdev *); | ||
109 | +static void fm_irq_send_rdsdata_getcmd(struct fmdev *); | ||
110 | +static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev *); | ||
111 | +static void fm_irq_handle_rds_finish(struct fmdev *); | ||
112 | +static void fm_irq_handle_tune_op_ended(struct fmdev *); | ||
113 | +static void fm_irq_handle_power_enb(struct fmdev *); | ||
114 | +static void fm_irq_handle_low_rssi_start(struct fmdev *); | ||
115 | +static void fm_irq_afjump_set_pi(struct fmdev *); | ||
116 | +static void fm_irq_handle_set_pi_resp(struct fmdev *); | ||
117 | +static void fm_irq_afjump_set_pimask(struct fmdev *); | ||
118 | +static void fm_irq_handle_set_pimask_resp(struct fmdev *); | ||
119 | +static void fm_irq_afjump_setfreq(struct fmdev *); | ||
120 | +static void fm_irq_handle_setfreq_resp(struct fmdev *); | ||
121 | +static void fm_irq_afjump_enableint(struct fmdev *); | ||
122 | +static void fm_irq_afjump_enableint_resp(struct fmdev *); | ||
123 | +static void fm_irq_start_afjump(struct fmdev *); | ||
124 | +static void fm_irq_handle_start_afjump_resp(struct fmdev *); | ||
125 | +static void fm_irq_afjump_rd_freq(struct fmdev *); | ||
126 | +static void fm_irq_afjump_rd_freq_resp(struct fmdev *); | ||
127 | +static void fm_irq_handle_low_rssi_finish(struct fmdev *); | ||
128 | +static void fm_irq_send_intmsk_cmd(struct fmdev *); | ||
129 | +static void fm_irq_handle_intmsk_cmd_resp(struct fmdev *); | ||
130 | + | ||
131 | +/* | ||
132 | + * When FM common module receives interrupt packet, following handlers | ||
133 | + * will be executed one after another to service the interrupt(s) | ||
134 | + */ | ||
135 | +enum fmc_irq_handler_index { | ||
136 | + FM_SEND_FLAG_GETCMD_IDX, | ||
137 | + FM_HANDLE_FLAG_GETCMD_RESP_IDX, | ||
138 | + | ||
139 | + /* HW malfunction irq handler */ | ||
140 | + FM_HW_MAL_FUNC_IDX, | ||
141 | + | ||
142 | + /* RDS threshold reached irq handler */ | ||
143 | + FM_RDS_START_IDX, | ||
144 | + FM_RDS_SEND_RDS_GETCMD_IDX, | ||
145 | + FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX, | ||
146 | + FM_RDS_FINISH_IDX, | ||
147 | + | ||
148 | + /* Tune operation ended irq handler */ | ||
149 | + FM_HW_TUNE_OP_ENDED_IDX, | ||
150 | + | ||
151 | + /* TX power enable irq handler */ | ||
152 | + FM_HW_POWER_ENB_IDX, | ||
153 | + | ||
154 | + /* Low RSSI irq handler */ | ||
155 | + FM_LOW_RSSI_START_IDX, | ||
156 | + FM_AF_JUMP_SETPI_IDX, | ||
157 | + FM_AF_JUMP_HANDLE_SETPI_RESP_IDX, | ||
158 | + FM_AF_JUMP_SETPI_MASK_IDX, | ||
159 | + FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX, | ||
160 | + FM_AF_JUMP_SET_AF_FREQ_IDX, | ||
161 | + FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX, | ||
162 | + FM_AF_JUMP_ENABLE_INT_IDX, | ||
163 | + FM_AF_JUMP_ENABLE_INT_RESP_IDX, | ||
164 | + FM_AF_JUMP_START_AFJUMP_IDX, | ||
165 | + FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX, | ||
166 | + FM_AF_JUMP_RD_FREQ_IDX, | ||
167 | + FM_AF_JUMP_RD_FREQ_RESP_IDX, | ||
168 | + FM_LOW_RSSI_FINISH_IDX, | ||
169 | + | ||
170 | + /* Interrupt process post action */ | ||
171 | + FM_SEND_INTMSK_CMD_IDX, | ||
172 | + FM_HANDLE_INTMSK_CMD_RESP_IDX, | ||
173 | +}; | ||
174 | + | ||
175 | +/* FM interrupt handler table */ | ||
176 | +static int_handler_prototype int_handler_table[] = { | ||
177 | + fm_irq_send_flag_getcmd, | ||
178 | + fm_irq_handle_flag_getcmd_resp, | ||
179 | + fm_irq_handle_hw_malfunction, | ||
180 | + fm_irq_handle_rds_start, /* RDS threshold reached irq handler */ | ||
181 | + fm_irq_send_rdsdata_getcmd, | ||
182 | + fm_irq_handle_rdsdata_getcmd_resp, | ||
183 | + fm_irq_handle_rds_finish, | ||
184 | + fm_irq_handle_tune_op_ended, | ||
185 | + fm_irq_handle_power_enb, /* TX power enable irq handler */ | ||
186 | + fm_irq_handle_low_rssi_start, | ||
187 | + fm_irq_afjump_set_pi, | ||
188 | + fm_irq_handle_set_pi_resp, | ||
189 | + fm_irq_afjump_set_pimask, | ||
190 | + fm_irq_handle_set_pimask_resp, | ||
191 | + fm_irq_afjump_setfreq, | ||
192 | + fm_irq_handle_setfreq_resp, | ||
193 | + fm_irq_afjump_enableint, | ||
194 | + fm_irq_afjump_enableint_resp, | ||
195 | + fm_irq_start_afjump, | ||
196 | + fm_irq_handle_start_afjump_resp, | ||
197 | + fm_irq_afjump_rd_freq, | ||
198 | + fm_irq_afjump_rd_freq_resp, | ||
199 | + fm_irq_handle_low_rssi_finish, | ||
200 | + fm_irq_send_intmsk_cmd, /* Interrupt process post action */ | ||
201 | + fm_irq_handle_intmsk_cmd_resp | ||
202 | +}; | ||
203 | + | ||
204 | +long (*g_st_write) (struct sk_buff *skb); | ||
205 | +static struct completion wait_for_fmdrv_reg_comp; | ||
206 | + | ||
207 | +static inline void fm_irq_call(struct fmdev *fmdev) | ||
208 | +{ | ||
209 | + fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev); | ||
210 | +} | ||
211 | + | ||
212 | +/* Continue next function in interrupt handler table */ | ||
213 | +static inline void fm_irq_call_stage(struct fmdev *fmdev, u8 stage) | ||
214 | +{ | ||
215 | + fmdev->irq_info.stage = stage; | ||
216 | + fm_irq_call(fmdev); | ||
217 | +} | ||
218 | + | ||
219 | +static inline void fm_irq_timeout_stage(struct fmdev *fmdev, u8 stage) | ||
220 | +{ | ||
221 | + fmdev->irq_info.stage = stage; | ||
222 | + mod_timer(&fmdev->irq_info.timer, jiffies + FM_DRV_TX_TIMEOUT); | ||
223 | +} | ||
224 | + | ||
225 | +#ifdef FM_DUMP_TXRX_PKT | ||
226 | + /* To dump outgoing FM Channel-8 packets */ | ||
227 | +inline void dump_tx_skb_data(struct sk_buff *skb) | ||
228 | +{ | ||
229 | + int len, len_org; | ||
230 | + u8 index; | ||
231 | + struct fm_cmd_msg_hdr *cmd_hdr; | ||
232 | + | ||
233 | + cmd_hdr = (struct fm_cmd_msg_hdr *)skb->data; | ||
234 | + printk(KERN_INFO "<<%shdr:%02x len:%02x opcode:%02x type:%s dlen:%02x", | ||
235 | + fm_cb(skb)->completion ? " " : "*", cmd_hdr->hdr, | ||
236 | + cmd_hdr->len, cmd_hdr->op, | ||
237 | + cmd_hdr->rd_wr ? "RD" : "WR", cmd_hdr->dlen); | ||
238 | + | ||
239 | + len_org = skb->len - FM_CMD_MSG_HDR_SIZE; | ||
240 | + if (len_org > 0) { | ||
241 | + printk("\n data(%d): ", cmd_hdr->dlen); | ||
242 | + len = min(len_org, 14); | ||
243 | + for (index = 0; index < len; index++) | ||
244 | + printk("%x ", | ||
245 | + skb->data[FM_CMD_MSG_HDR_SIZE + index]); | ||
246 | + printk("%s", (len_org > 14) ? ".." : ""); | ||
247 | + } | ||
248 | + printk("\n"); | ||
249 | +} | ||
250 | + | ||
251 | + /* To dump incoming FM Channel-8 packets */ | ||
252 | +inline void dump_rx_skb_data(struct sk_buff *skb) | ||
253 | +{ | ||
254 | + int len, len_org; | ||
255 | + u8 index; | ||
256 | + struct fm_event_msg_hdr *evt_hdr; | ||
257 | + | ||
258 | + evt_hdr = (struct fm_event_msg_hdr *)skb->data; | ||
259 | + printk(KERN_INFO ">> hdr:%02x len:%02x sts:%02x numhci:%02x " | ||
260 | + "opcode:%02x type:%s dlen:%02x", evt_hdr->hdr, evt_hdr->len, | ||
261 | + evt_hdr->status, evt_hdr->num_fm_hci_cmds, evt_hdr->op, | ||
262 | + (evt_hdr->rd_wr) ? "RD" : "WR", evt_hdr->dlen); | ||
263 | + | ||
264 | + len_org = skb->len - FM_EVT_MSG_HDR_SIZE; | ||
265 | + if (len_org > 0) { | ||
266 | + printk("\n data(%d): ", evt_hdr->dlen); | ||
267 | + len = min(len_org, 14); | ||
268 | + for (index = 0; index < len; index++) | ||
269 | + printk("%x ", | ||
270 | + skb->data[FM_EVT_MSG_HDR_SIZE + index]); | ||
271 | + printk("%s", (len_org > 14) ? ".." : ""); | ||
272 | + } | ||
273 | + printk("\n"); | ||
274 | +} | ||
275 | +#endif | ||
276 | + | ||
277 | +void fmc_update_region_info(struct fmdev *fmdev, u8 region_to_set) | ||
278 | +{ | ||
279 | + fmdev->rx.region = region_configs[region_to_set]; | ||
280 | +} | ||
281 | + | ||
282 | +/* | ||
283 | + * FM common sub-module will schedule this tasklet whenever it receives | ||
284 | + * FM packet from ST driver. | ||
285 | + */ | ||
286 | +static void recv_tasklet(unsigned long arg) | ||
287 | +{ | ||
288 | + struct fmdev *fmdev; | ||
289 | + struct fm_irq *irq_info; | ||
290 | + struct fm_event_msg_hdr *evt_hdr; | ||
291 | + struct sk_buff *skb; | ||
292 | + u8 num_fm_hci_cmds; | ||
293 | + unsigned long flags; | ||
294 | + | ||
295 | + fmdev = (struct fmdev *)arg; | ||
296 | + irq_info = &fmdev->irq_info; | ||
297 | + /* Process all packets in the RX queue */ | ||
298 | + while ((skb = skb_dequeue(&fmdev->rx_q))) { | ||
299 | + if (skb->len < sizeof(struct fm_event_msg_hdr)) { | ||
300 | + fmerr("skb(%p) has only %d bytes" | ||
301 | + "atleast need %d bytes to decode\n", skb, | ||
302 | + skb->len, sizeof(struct fm_event_msg_hdr)); | ||
303 | + kfree_skb(skb); | ||
304 | + continue; | ||
305 | + } | ||
306 | + | ||
307 | + evt_hdr = (void *)skb->data; | ||
308 | + num_fm_hci_cmds = evt_hdr->num_fm_hci_cmds; | ||
309 | + | ||
310 | + /* FM interrupt packet? */ | ||
311 | + if (evt_hdr->op == FM_INTERRUPT) { | ||
312 | + /* FM interrupt handler started already? */ | ||
313 | + if (!test_bit(FM_INTTASK_RUNNING, &fmdev->flag)) { | ||
314 | + set_bit(FM_INTTASK_RUNNING, &fmdev->flag); | ||
315 | + if (irq_info->stage != 0) { | ||
316 | + fmerr("Inval stage resetting to zero\n"); | ||
317 | + irq_info->stage = 0; | ||
318 | + } | ||
319 | + | ||
320 | + /* | ||
321 | + * Execute first function in interrupt handler | ||
322 | + * table. | ||
323 | + */ | ||
324 | + irq_info->handlers[irq_info->stage](fmdev); | ||
325 | + } else { | ||
326 | + set_bit(FM_INTTASK_SCHEDULE_PENDING, &fmdev->flag); | ||
327 | + } | ||
328 | + kfree_skb(skb); | ||
329 | + } | ||
330 | + /* Anyone waiting for this with completion handler? */ | ||
331 | + else if (evt_hdr->op == fmdev->pre_op && fmdev->resp_comp != NULL) { | ||
332 | + | ||
333 | + spin_lock_irqsave(&fmdev->resp_skb_lock, flags); | ||
334 | + fmdev->resp_skb = skb; | ||
335 | + spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags); | ||
336 | + complete(fmdev->resp_comp); | ||
337 | + | ||
338 | + fmdev->resp_comp = NULL; | ||
339 | + atomic_set(&fmdev->tx_cnt, 1); | ||
340 | + } | ||
341 | + /* Is this for interrupt handler? */ | ||
342 | + else if (evt_hdr->op == fmdev->pre_op && fmdev->resp_comp == NULL) { | ||
343 | + if (fmdev->resp_skb != NULL) | ||
344 | + fmerr("Response SKB ptr not NULL\n"); | ||
345 | + | ||
346 | + spin_lock_irqsave(&fmdev->resp_skb_lock, flags); | ||
347 | + fmdev->resp_skb = skb; | ||
348 | + spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags); | ||
349 | + | ||
350 | + /* Execute interrupt handler where state index points */ | ||
351 | + irq_info->handlers[irq_info->stage](fmdev); | ||
352 | + | ||
353 | + kfree_skb(skb); | ||
354 | + atomic_set(&fmdev->tx_cnt, 1); | ||
355 | + } else { | ||
356 | + fmerr("Nobody claimed SKB(%p),purging\n", skb); | ||
357 | + } | ||
358 | + | ||
359 | + /* | ||
360 | + * Check flow control field. If Num_FM_HCI_Commands field is | ||
361 | + * not zero, schedule FM TX tasklet. | ||
362 | + */ | ||
363 | + if (num_fm_hci_cmds && atomic_read(&fmdev->tx_cnt)) | ||
364 | + if (!skb_queue_empty(&fmdev->tx_q)) | ||
365 | + tasklet_schedule(&fmdev->tx_task); | ||
366 | + } | ||
367 | +} | ||
368 | + | ||
369 | +/* FM send tasklet: is scheduled when FM packet has to be sent to chip */ | ||
370 | +static void send_tasklet(unsigned long arg) | ||
371 | +{ | ||
372 | + struct fmdev *fmdev; | ||
373 | + struct sk_buff *skb; | ||
374 | + int len; | ||
375 | + | ||
376 | + fmdev = (struct fmdev *)arg; | ||
377 | + | ||
378 | + if (!atomic_read(&fmdev->tx_cnt)) | ||
379 | + return; | ||
380 | + | ||
381 | + /* Check, is there any timeout happenned to last transmitted packet */ | ||
382 | + if ((jiffies - fmdev->last_tx_jiffies) > FM_DRV_TX_TIMEOUT) { | ||
383 | + fmerr("TX timeout occurred\n"); | ||
384 | + atomic_set(&fmdev->tx_cnt, 1); | ||
385 | + } | ||
386 | + | ||
387 | + /* Send queued FM TX packets */ | ||
388 | + skb = skb_dequeue(&fmdev->tx_q); | ||
389 | + if (!skb) | ||
390 | + return; | ||
391 | + | ||
392 | + atomic_dec(&fmdev->tx_cnt); | ||
393 | + fmdev->pre_op = fm_cb(skb)->fm_op; | ||
394 | + | ||
395 | + if (fmdev->resp_comp != NULL) | ||
396 | + fmerr("Response completion handler is not NULL\n"); | ||
397 | + | ||
398 | + fmdev->resp_comp = fm_cb(skb)->completion; | ||
399 | + | ||
400 | + /* Write FM packet to ST driver */ | ||
401 | + len = g_st_write(skb); | ||
402 | + if (len < 0) { | ||
403 | + kfree_skb(skb); | ||
404 | + fmdev->resp_comp = NULL; | ||
405 | + fmerr("TX tasklet failed to send skb(%p)\n", skb); | ||
406 | + atomic_set(&fmdev->tx_cnt, 1); | ||
407 | + } else { | ||
408 | + fmdev->last_tx_jiffies = jiffies; | ||
409 | + } | ||
410 | +} | ||
411 | + | ||
412 | +/* | ||
413 | + * Queues FM Channel-8 packet to FM TX queue and schedules FM TX tasklet for | ||
414 | + * transmission | ||
415 | + */ | ||
416 | +static u32 fm_send_cmd(struct fmdev *fmdev, u8 fm_op, u16 type, void *payload, | ||
417 | + int payload_len, struct completion *wait_completion) | ||
418 | +{ | ||
419 | + struct sk_buff *skb; | ||
420 | + struct fm_cmd_msg_hdr *hdr; | ||
421 | + int size; | ||
422 | + | ||
423 | + if (fm_op >= FM_INTERRUPT) { | ||
424 | + fmerr("Invalid fm opcode - %d\n", fm_op); | ||
425 | + return -EINVAL; | ||
426 | + } | ||
427 | + if (test_bit(FM_FW_DW_INPROGRESS, &fmdev->flag) && payload == NULL) { | ||
428 | + fmerr("Payload data is NULL during fw download\n"); | ||
429 | + return -EINVAL; | ||
430 | + } | ||
431 | + if (!test_bit(FM_FW_DW_INPROGRESS, &fmdev->flag)) | ||
432 | + size = | ||
433 | + FM_CMD_MSG_HDR_SIZE + ((payload == NULL) ? 0 : payload_len); | ||
434 | + else | ||
435 | + size = payload_len; | ||
436 | + | ||
437 | + skb = alloc_skb(size, GFP_ATOMIC); | ||
438 | + if (!skb) { | ||
439 | + fmerr("No memory to create new SKB\n"); | ||
440 | + return -ENOMEM; | ||
441 | + } | ||
442 | + /* | ||
443 | + * Don't fill FM header info for the commands which come from | ||
444 | + * FM firmware file. | ||
445 | + */ | ||
446 | + if (!test_bit(FM_FW_DW_INPROGRESS, &fmdev->flag) || | ||
447 | + test_bit(FM_INTTASK_RUNNING, &fmdev->flag)) { | ||
448 | + /* Fill command header info */ | ||
449 | + hdr = (struct fm_cmd_msg_hdr *)skb_put(skb, FM_CMD_MSG_HDR_SIZE); | ||
450 | + hdr->hdr = FM_PKT_LOGICAL_CHAN_NUMBER; /* 0x08 */ | ||
451 | + | ||
452 | + /* 3 (fm_opcode,rd_wr,dlen) + payload len) */ | ||
453 | + hdr->len = ((payload == NULL) ? 0 : payload_len) + 3; | ||
454 | + | ||
455 | + /* FM opcode */ | ||
456 | + hdr->op = fm_op; | ||
457 | + | ||
458 | + /* read/write type */ | ||
459 | + hdr->rd_wr = type; | ||
460 | + hdr->dlen = payload_len; | ||
461 | + fm_cb(skb)->fm_op = fm_op; | ||
462 | + | ||
463 | + /* | ||
464 | + * If firmware download has finished and the command is | ||
465 | + * not a read command then payload is != NULL - a write | ||
466 | + * command with u16 payload - convert to be16 | ||
467 | + */ | ||
468 | + if (payload != NULL) | ||
469 | + *(u16 *)payload = cpu_to_be16(*(u16 *)payload); | ||
470 | + | ||
471 | + } else if (payload != NULL) { | ||
472 | + fm_cb(skb)->fm_op = *((u8 *)payload + 2); | ||
473 | + } | ||
474 | + if (payload != NULL) | ||
475 | + memcpy(skb_put(skb, payload_len), payload, payload_len); | ||
476 | + | ||
477 | + fm_cb(skb)->completion = wait_completion; | ||
478 | + skb_queue_tail(&fmdev->tx_q, skb); | ||
479 | + tasklet_schedule(&fmdev->tx_task); | ||
480 | + | ||
481 | + return 0; | ||
482 | +} | ||
483 | + | ||
484 | +/* Sends FM Channel-8 command to the chip and waits for the response */ | ||
485 | +u32 fmc_send_cmd(struct fmdev *fmdev, u8 fm_op, u16 type, void *payload, | ||
486 | + unsigned int payload_len, void *response, int *response_len) | ||
487 | +{ | ||
488 | + struct sk_buff *skb; | ||
489 | + struct fm_event_msg_hdr *evt_hdr; | ||
490 | + unsigned long flags; | ||
491 | + u32 ret; | ||
492 | + | ||
493 | + init_completion(&fmdev->maintask_comp); | ||
494 | + ret = fm_send_cmd(fmdev, fm_op, type, payload, payload_len, | ||
495 | + &fmdev->maintask_comp); | ||
496 | + if (ret) | ||
497 | + return ret; | ||
498 | + | ||
499 | + ret = wait_for_completion_timeout(&fmdev->maintask_comp, FM_DRV_TX_TIMEOUT); | ||
500 | + if (!ret) { | ||
501 | + fmerr("Timeout(%d sec),didn't get reg" | ||
502 | + "completion signal from RX tasklet\n", | ||
503 | + jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000); | ||
504 | + return -ETIMEDOUT; | ||
505 | + } | ||
506 | + if (!fmdev->resp_skb) { | ||
507 | + fmerr("Reponse SKB is missing\n"); | ||
508 | + return -EFAULT; | ||
509 | + } | ||
510 | + spin_lock_irqsave(&fmdev->resp_skb_lock, flags); | ||
511 | + skb = fmdev->resp_skb; | ||
512 | + fmdev->resp_skb = NULL; | ||
513 | + spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags); | ||
514 | + | ||
515 | + evt_hdr = (void *)skb->data; | ||
516 | + if (evt_hdr->status != 0) { | ||
517 | + fmerr("Received event pkt status(%d) is not zero\n", | ||
518 | + evt_hdr->status); | ||
519 | + kfree_skb(skb); | ||
520 | + return -EIO; | ||
521 | + } | ||
522 | + /* Send response data to caller */ | ||
523 | + if (response != NULL && response_len != NULL && evt_hdr->dlen) { | ||
524 | + /* Skip header info and copy only response data */ | ||
525 | + skb_pull(skb, sizeof(struct fm_event_msg_hdr)); | ||
526 | + memcpy(response, skb->data, evt_hdr->dlen); | ||
527 | + *response_len = evt_hdr->dlen; | ||
528 | + } else if (response_len != NULL && evt_hdr->dlen == 0) { | ||
529 | + *response_len = 0; | ||
530 | + } | ||
531 | + kfree_skb(skb); | ||
532 | + | ||
533 | + return 0; | ||
534 | +} | ||
535 | + | ||
536 | +/* --- Helper functions used in FM interrupt handlers ---*/ | ||
537 | +static inline u32 check_cmdresp_status(struct fmdev *fmdev, | ||
538 | + struct sk_buff **skb) | ||
539 | +{ | ||
540 | + struct fm_event_msg_hdr *fm_evt_hdr; | ||
541 | + unsigned long flags; | ||
542 | + | ||
543 | + del_timer(&fmdev->irq_info.timer); | ||
544 | + | ||
545 | + spin_lock_irqsave(&fmdev->resp_skb_lock, flags); | ||
546 | + *skb = fmdev->resp_skb; | ||
547 | + fmdev->resp_skb = NULL; | ||
548 | + spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags); | ||
549 | + | ||
550 | + fm_evt_hdr = (void *)(*skb)->data; | ||
551 | + if (fm_evt_hdr->status != 0) { | ||
552 | + fmerr("irq: opcode %x response status is not zero " | ||
553 | + "Initiating irq recovery process\n", | ||
554 | + fm_evt_hdr->op); | ||
555 | + | ||
556 | + mod_timer(&fmdev->irq_info.timer, jiffies + FM_DRV_TX_TIMEOUT); | ||
557 | + return -1; | ||
558 | + } | ||
559 | + | ||
560 | + return 0; | ||
561 | +} | ||
562 | + | ||
563 | +static inline void fm_irq_common_cmd_resp_helper(struct fmdev *fmdev, u8 stage) | ||
564 | +{ | ||
565 | + struct sk_buff *skb; | ||
566 | + | ||
567 | + if (!check_cmdresp_status(fmdev, &skb)) | ||
568 | + fm_irq_call_stage(fmdev, stage); | ||
569 | +} | ||
570 | + | ||
571 | +/* | ||
572 | + * Interrupt process timeout handler. | ||
573 | + * One of the irq handler did not get proper response from the chip. So take | ||
574 | + * recovery action here. FM interrupts are disabled in the beginning of | ||
575 | + * interrupt process. Therefore reset stage index to re-enable default | ||
576 | + * interrupts. So that next interrupt will be processed as usual. | ||
577 | + */ | ||
578 | +static void int_timeout_handler(unsigned long data) | ||
579 | +{ | ||
580 | + struct fmdev *fmdev; | ||
581 | + struct fm_irq *fmirq; | ||
582 | + | ||
583 | + fmdbg("irq: timeout,trying to re-enable fm interrupts\n"); | ||
584 | + fmdev = (struct fmdev *)data; | ||
585 | + fmirq = &fmdev->irq_info; | ||
586 | + fmirq->retry++; | ||
587 | + | ||
588 | + if (fmirq->retry > FM_IRQ_TIMEOUT_RETRY_MAX) { | ||
589 | + /* Stop recovery action (interrupt reenable process) and | ||
590 | + * reset stage index & retry count values */ | ||
591 | + fmirq->stage = 0; | ||
592 | + fmirq->retry = 0; | ||
593 | + fmerr("Recovery action failed during" | ||
594 | + "irq processing, max retry reached\n"); | ||
595 | + return; | ||
596 | + } | ||
597 | + fm_irq_call_stage(fmdev, FM_SEND_INTMSK_CMD_IDX); | ||
598 | +} | ||
599 | + | ||
600 | +/* --------- FM interrupt handlers ------------*/ | ||
601 | +static void fm_irq_send_flag_getcmd(struct fmdev *fmdev) | ||
602 | +{ | ||
603 | + u16 flag; | ||
604 | + | ||
605 | + /* Send FLAG_GET command , to know the source of interrupt */ | ||
606 | + if (!fm_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, sizeof(flag), NULL)) | ||
607 | + fm_irq_timeout_stage(fmdev, FM_HANDLE_FLAG_GETCMD_RESP_IDX); | ||
608 | +} | ||
609 | + | ||
610 | +static void fm_irq_handle_flag_getcmd_resp(struct fmdev *fmdev) | ||
611 | +{ | ||
612 | + struct sk_buff *skb; | ||
613 | + struct fm_event_msg_hdr *fm_evt_hdr; | ||
614 | + | ||
615 | + if (check_cmdresp_status(fmdev, &skb)) | ||
616 | + return; | ||
617 | + | ||
618 | + fm_evt_hdr = (void *)skb->data; | ||
619 | + | ||
620 | + /* Skip header info and copy only response data */ | ||
621 | + skb_pull(skb, sizeof(struct fm_event_msg_hdr)); | ||
622 | + memcpy(&fmdev->irq_info.flag, skb->data, fm_evt_hdr->dlen); | ||
623 | + | ||
624 | + fmdev->irq_info.flag = be16_to_cpu(fmdev->irq_info.flag); | ||
625 | + fmdbg("irq: flag register(0x%x)\n", fmdev->irq_info.flag); | ||
626 | + | ||
627 | + /* Continue next function in interrupt handler table */ | ||
628 | + fm_irq_call_stage(fmdev, FM_HW_MAL_FUNC_IDX); | ||
629 | +} | ||
630 | + | ||
631 | +static void fm_irq_handle_hw_malfunction(struct fmdev *fmdev) | ||
632 | +{ | ||
633 | + if (fmdev->irq_info.flag & FM_MAL_EVENT & fmdev->irq_info.mask) | ||
634 | + fmerr("irq: HW MAL int received - do nothing\n"); | ||
635 | + | ||
636 | + /* Continue next function in interrupt handler table */ | ||
637 | + fm_irq_call_stage(fmdev, FM_RDS_START_IDX); | ||
638 | +} | ||
639 | + | ||
640 | +static void fm_irq_handle_rds_start(struct fmdev *fmdev) | ||
641 | +{ | ||
642 | + if (fmdev->irq_info.flag & FM_RDS_EVENT & fmdev->irq_info.mask) { | ||
643 | + fmdbg("irq: rds threshold reached\n"); | ||
644 | + fmdev->irq_info.stage = FM_RDS_SEND_RDS_GETCMD_IDX; | ||
645 | + } else { | ||
646 | + /* Continue next function in interrupt handler table */ | ||
647 | + fmdev->irq_info.stage = FM_HW_TUNE_OP_ENDED_IDX; | ||
648 | + } | ||
649 | + | ||
650 | + fm_irq_call(fmdev); | ||
651 | +} | ||
652 | + | ||
653 | +static void fm_irq_send_rdsdata_getcmd(struct fmdev *fmdev) | ||
654 | +{ | ||
655 | + /* Send the command to read RDS data from the chip */ | ||
656 | + if (!fm_send_cmd(fmdev, RDS_DATA_GET, REG_RD, NULL, | ||
657 | + (FM_RX_RDS_FIFO_THRESHOLD * 3), NULL)) | ||
658 | + fm_irq_timeout_stage(fmdev, FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX); | ||
659 | +} | ||
660 | + | ||
661 | +/* Keeps track of current RX channel AF (Alternate Frequency) */ | ||
662 | +static void fm_rx_update_af_cache(struct fmdev *fmdev, u8 af) | ||
663 | +{ | ||
664 | + struct tuned_station_info *stat_info = &fmdev->rx.stat_info; | ||
665 | + u8 reg_idx = fmdev->rx.region.fm_band; | ||
666 | + u8 index; | ||
667 | + u32 freq; | ||
668 | + | ||
669 | + /* First AF indicates the number of AF follows. Reset the list */ | ||
670 | + if ((af >= FM_RDS_1_AF_FOLLOWS) && (af <= FM_RDS_25_AF_FOLLOWS)) { | ||
671 | + fmdev->rx.stat_info.af_list_max = (af - FM_RDS_1_AF_FOLLOWS + 1); | ||
672 | + fmdev->rx.stat_info.afcache_size = 0; | ||
673 | + fmdbg("No of expected AF : %d\n", fmdev->rx.stat_info.af_list_max); | ||
674 | + return; | ||
675 | + } | ||
676 | + | ||
677 | + if (af < FM_RDS_MIN_AF) | ||
678 | + return; | ||
679 | + if (reg_idx == FM_BAND_EUROPE_US && af > FM_RDS_MAX_AF) | ||
680 | + return; | ||
681 | + if (reg_idx == FM_BAND_JAPAN && af > FM_RDS_MAX_AF_JAPAN) | ||
682 | + return; | ||
683 | + | ||
684 | + freq = fmdev->rx.region.bot_freq + (af * 100); | ||
685 | + if (freq == fmdev->rx.freq) { | ||
686 | + fmdbg("Current freq(%d) is matching with received AF(%d)\n", | ||
687 | + fmdev->rx.freq, freq); | ||
688 | + return; | ||
689 | + } | ||
690 | + /* Do check in AF cache */ | ||
691 | + for (index = 0; index < stat_info->afcache_size; index++) { | ||
692 | + if (stat_info->af_cache[index] == freq) | ||
693 | + break; | ||
694 | + } | ||
695 | + /* Reached the limit of the list - ignore the next AF */ | ||
696 | + if (index == stat_info->af_list_max) { | ||
697 | + fmdbg("AF cache is full\n"); | ||
698 | + return; | ||
699 | + } | ||
700 | + /* | ||
701 | + * If we reached the end of the list then this AF is not | ||
702 | + * in the list - add it. | ||
703 | + */ | ||
704 | + if (index == stat_info->afcache_size) { | ||
705 | + fmdbg("Storing AF %d to cache index %d\n", freq, index); | ||
706 | + stat_info->af_cache[index] = freq; | ||
707 | + stat_info->afcache_size++; | ||
708 | + } | ||
709 | +} | ||
710 | + | ||
711 | +/* | ||
712 | + * Converts RDS buffer data from big endian format | ||
713 | + * to little endian format. | ||
714 | + */ | ||
715 | +static void fm_rdsparse_swapbytes(struct fmdev *fmdev, | ||
716 | + struct fm_rdsdata_format *rds_format) | ||
717 | +{ | ||
718 | + u8 byte1; | ||
719 | + u8 index = 0; | ||
720 | + u8 *rds_buff; | ||
721 | + | ||
722 | + /* | ||
723 | + * Since in Orca the 2 RDS Data bytes are in little endian and | ||
724 | + * in Dolphin they are in big endian, the parsing of the RDS data | ||
725 | + * is chip dependent | ||
726 | + */ | ||
727 | + if (fmdev->asci_id != 0x6350) { | ||
728 | + rds_buff = &rds_format->data.groupdatabuff.buff[0]; | ||
729 | + while (index + 1 < FM_RX_RDS_INFO_FIELD_MAX) { | ||
730 | + byte1 = rds_buff[index]; | ||
731 | + rds_buff[index] = rds_buff[index + 1]; | ||
732 | + rds_buff[index + 1] = byte1; | ||
733 | + index += 2; | ||
734 | + } | ||
735 | + } | ||
736 | +} | ||
737 | + | ||
738 | +static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev *fmdev) | ||
739 | +{ | ||
740 | + struct sk_buff *skb; | ||
741 | + struct fm_rdsdata_format rds_fmt; | ||
742 | + struct fm_rds *rds = &fmdev->rx.rds; | ||
743 | + unsigned long group_idx, flags; | ||
744 | + u8 *rds_data, meta_data, tmpbuf[3]; | ||
745 | + u8 type, blk_idx; | ||
746 | + u16 cur_picode; | ||
747 | + u32 rds_len; | ||
748 | + | ||
749 | + if (check_cmdresp_status(fmdev, &skb)) | ||
750 | + return; | ||
751 | + | ||
752 | + /* Skip header info */ | ||
753 | + skb_pull(skb, sizeof(struct fm_event_msg_hdr)); | ||
754 | + rds_data = skb->data; | ||
755 | + rds_len = skb->len; | ||
756 | + | ||
757 | + /* Parse the RDS data */ | ||
758 | + while (rds_len >= FM_RDS_BLK_SIZE) { | ||
759 | + meta_data = rds_data[2]; | ||
760 | + /* Get the type: 0=A, 1=B, 2=C, 3=C', 4=D, 5=E */ | ||
761 | + type = (meta_data & 0x07); | ||
762 | + | ||
763 | + /* Transform the blk type into index sequence (0, 1, 2, 3, 4) */ | ||
764 | + blk_idx = (type <= FM_RDS_BLOCK_C ? type : (type - 1)); | ||
765 | + fmdbg("Block index:%d(%s)\n", blk_idx, | ||
766 | + (meta_data & FM_RDS_STATUS_ERR_MASK) ? "Bad" : "Ok"); | ||
767 | + | ||
768 | + if ((meta_data & FM_RDS_STATUS_ERR_MASK) != 0) | ||
769 | + break; | ||
770 | + | ||
771 | + if (blk_idx < FM_RDS_BLK_IDX_A || blk_idx > FM_RDS_BLK_IDX_D) { | ||
772 | + fmdbg("Block sequence mismatch\n"); | ||
773 | + rds->last_blk_idx = -1; | ||
774 | + break; | ||
775 | + } | ||
776 | + | ||
777 | + /* Skip checkword (control) byte and copy only data byte */ | ||
778 | + memcpy(&rds_fmt.data.groupdatabuff. | ||
779 | + buff[blk_idx * (FM_RDS_BLK_SIZE - 1)], | ||
780 | + rds_data, (FM_RDS_BLK_SIZE - 1)); | ||
781 | + | ||
782 | + rds->last_blk_idx = blk_idx; | ||
783 | + | ||
784 | + /* If completed a whole group then handle it */ | ||
785 | + if (blk_idx == FM_RDS_BLK_IDX_D) { | ||
786 | + fmdbg("Good block received\n"); | ||
787 | + fm_rdsparse_swapbytes(fmdev, &rds_fmt); | ||
788 | + | ||
789 | + /* | ||
790 | + * Extract PI code and store in local cache. | ||
791 | + * We need this during AF switch processing. | ||
792 | + */ | ||
793 | + cur_picode = be16_to_cpu(rds_fmt.data.groupgeneral.pidata); | ||
794 | + if (fmdev->rx.stat_info.picode != cur_picode) | ||
795 | + fmdev->rx.stat_info.picode = cur_picode; | ||
796 | + | ||
797 | + fmdbg("picode:%d\n", cur_picode); | ||
798 | + | ||
799 | + group_idx = (rds_fmt.data.groupgeneral.blk_b[0] >> 3); | ||
800 | + fmdbg("(fmdrv):Group:%ld%s\n", group_idx/2, | ||
801 | + (group_idx % 2) ? "B" : "A"); | ||
802 | + | ||
803 | + group_idx = 1 << (rds_fmt.data.groupgeneral.blk_b[0] >> 3); | ||
804 | + if (group_idx == FM_RDS_GROUP_TYPE_MASK_0A) { | ||
805 | + fm_rx_update_af_cache(fmdev, rds_fmt.data.group0A.af[0]); | ||
806 | + fm_rx_update_af_cache(fmdev, rds_fmt.data.group0A.af[1]); | ||
807 | + } | ||
808 | + } | ||
809 | + rds_len -= FM_RDS_BLK_SIZE; | ||
810 | + rds_data += FM_RDS_BLK_SIZE; | ||
811 | + } | ||
812 | + | ||
813 | + /* Copy raw rds data to internal rds buffer */ | ||
814 | + rds_data = skb->data; | ||
815 | + rds_len = skb->len; | ||
816 | + | ||
817 | + spin_lock_irqsave(&fmdev->rds_buff_lock, flags); | ||
818 | + while (rds_len > 0) { | ||
819 | + /* | ||
820 | + * Fill RDS buffer as per V4L2 specification. | ||
821 | + * Store control byte | ||
822 | + */ | ||
823 | + type = (rds_data[2] & 0x07); | ||
824 | + blk_idx = (type <= FM_RDS_BLOCK_C ? type : (type - 1)); | ||
825 | + tmpbuf[2] = blk_idx; /* Offset name */ | ||
826 | + tmpbuf[2] |= blk_idx << 3; /* Received offset */ | ||
827 | + | ||
828 | + /* Store data byte */ | ||
829 | + tmpbuf[0] = rds_data[0]; | ||
830 | + tmpbuf[1] = rds_data[1]; | ||
831 | + | ||
832 | + memcpy(&rds->buff[rds->wr_idx], &tmpbuf, FM_RDS_BLK_SIZE); | ||
833 | + rds->wr_idx = (rds->wr_idx + FM_RDS_BLK_SIZE) % rds->buf_size; | ||
834 | + | ||
835 | + /* Check for overflow & start over */ | ||
836 | + if (rds->wr_idx == rds->rd_idx) { | ||
837 | + fmdbg("RDS buffer overflow\n"); | ||
838 | + rds->wr_idx = 0; | ||
839 | + rds->rd_idx = 0; | ||
840 | + break; | ||
841 | + } | ||
842 | + rds_len -= FM_RDS_BLK_SIZE; | ||
843 | + rds_data += FM_RDS_BLK_SIZE; | ||
844 | + } | ||
845 | + spin_unlock_irqrestore(&fmdev->rds_buff_lock, flags); | ||
846 | + | ||
847 | + /* Wakeup read queue */ | ||
848 | + if (rds->wr_idx != rds->rd_idx) | ||
849 | + wake_up_interruptible(&rds->read_queue); | ||
850 | + | ||
851 | + fm_irq_call_stage(fmdev, FM_RDS_FINISH_IDX); | ||
852 | +} | ||
853 | + | ||
854 | +static void fm_irq_handle_rds_finish(struct fmdev *fmdev) | ||
855 | +{ | ||
856 | + fm_irq_call_stage(fmdev, FM_HW_TUNE_OP_ENDED_IDX); | ||
857 | +} | ||
858 | + | ||
859 | +static void fm_irq_handle_tune_op_ended(struct fmdev *fmdev) | ||
860 | +{ | ||
861 | + if (fmdev->irq_info.flag & (FM_FR_EVENT | FM_BL_EVENT) & fmdev-> | ||
862 | + irq_info.mask) { | ||
863 | + fmdbg("irq: tune ended/bandlimit reached\n"); | ||
864 | + if (test_and_clear_bit(FM_AF_SWITCH_INPROGRESS, &fmdev->flag)) { | ||
865 | + fmdev->irq_info.stage = FM_AF_JUMP_RD_FREQ_IDX; | ||
866 | + } else { | ||
867 | + complete(&fmdev->maintask_comp); | ||
868 | + fmdev->irq_info.stage = FM_HW_POWER_ENB_IDX; | ||
869 | + } | ||
870 | + } else | ||
871 | + fmdev->irq_info.stage = FM_HW_POWER_ENB_IDX; | ||
872 | + | ||
873 | + fm_irq_call(fmdev); | ||
874 | +} | ||
875 | + | ||
876 | +static void fm_irq_handle_power_enb(struct fmdev *fmdev) | ||
877 | +{ | ||
878 | + if (fmdev->irq_info.flag & FM_POW_ENB_EVENT) { | ||
879 | + fmdbg("irq: Power Enabled/Disabled\n"); | ||
880 | + complete(&fmdev->maintask_comp); | ||
881 | + } | ||
882 | + | ||
883 | + fm_irq_call_stage(fmdev, FM_LOW_RSSI_START_IDX); | ||
884 | +} | ||
885 | + | ||
886 | +static void fm_irq_handle_low_rssi_start(struct fmdev *fmdev) | ||
887 | +{ | ||
888 | + if ((fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON) && | ||
889 | + (fmdev->irq_info.flag & FM_LEV_EVENT & fmdev->irq_info.mask) && | ||
890 | + (fmdev->rx.freq != FM_UNDEFINED_FREQ) && | ||
891 | + (fmdev->rx.stat_info.afcache_size != 0)) { | ||
892 | + fmdbg("irq: rssi level has fallen below threshold level\n"); | ||
893 | + | ||
894 | + /* Disable further low RSSI interrupts */ | ||
895 | + fmdev->irq_info.mask &= ~FM_LEV_EVENT; | ||
896 | + | ||
897 | + fmdev->rx.afjump_idx = 0; | ||
898 | + fmdev->rx.freq_before_jump = fmdev->rx.freq; | ||
899 | + fmdev->irq_info.stage = FM_AF_JUMP_SETPI_IDX; | ||
900 | + } else { | ||
901 | + /* Continue next function in interrupt handler table */ | ||
902 | + fmdev->irq_info.stage = FM_SEND_INTMSK_CMD_IDX; | ||
903 | + } | ||
904 | + | ||
905 | + fm_irq_call(fmdev); | ||
906 | +} | ||
907 | + | ||
908 | +static void fm_irq_afjump_set_pi(struct fmdev *fmdev) | ||
909 | +{ | ||
910 | + u16 payload; | ||
911 | + | ||
912 | + /* Set PI code - must be updated if the AF list is not empty */ | ||
913 | + payload = fmdev->rx.stat_info.picode; | ||
914 | + if (!fm_send_cmd(fmdev, RDS_PI_SET, REG_WR, &payload, sizeof(payload), NULL)) | ||
915 | + fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_SETPI_RESP_IDX); | ||
916 | +} | ||
917 | + | ||
918 | +static void fm_irq_handle_set_pi_resp(struct fmdev *fmdev) | ||
919 | +{ | ||
920 | + fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_SETPI_MASK_IDX); | ||
921 | +} | ||
922 | + | ||
923 | +/* | ||
924 | + * Set PI mask. | ||
925 | + * 0xFFFF = Enable PI code matching | ||
926 | + * 0x0000 = Disable PI code matching | ||
927 | + */ | ||
928 | +static void fm_irq_afjump_set_pimask(struct fmdev *fmdev) | ||
929 | +{ | ||
930 | + u16 payload; | ||
931 | + | ||
932 | + payload = 0x0000; | ||
933 | + if (!fm_send_cmd(fmdev, RDS_PI_MASK_SET, REG_WR, &payload, sizeof(payload), NULL)) | ||
934 | + fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX); | ||
935 | +} | ||
936 | + | ||
937 | +static void fm_irq_handle_set_pimask_resp(struct fmdev *fmdev) | ||
938 | +{ | ||
939 | + fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_SET_AF_FREQ_IDX); | ||
940 | +} | ||
941 | + | ||
942 | +static void fm_irq_afjump_setfreq(struct fmdev *fmdev) | ||
943 | +{ | ||
944 | + u16 frq_index; | ||
945 | + u16 payload; | ||
946 | + | ||
947 | + fmdbg("Swtich to %d KHz\n", fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx]); | ||
948 | + frq_index = (fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx] - | ||
949 | + fmdev->rx.region.bot_freq) / FM_FREQ_MUL; | ||
950 | + | ||
951 | + payload = frq_index; | ||
952 | + if (!fm_send_cmd(fmdev, AF_FREQ_SET, REG_WR, &payload, sizeof(payload), NULL)) | ||
953 | + fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX); | ||
954 | +} | ||
955 | + | ||
956 | +static void fm_irq_handle_setfreq_resp(struct fmdev *fmdev) | ||
957 | +{ | ||
958 | + fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_ENABLE_INT_IDX); | ||
959 | +} | ||
960 | + | ||
961 | +static void fm_irq_afjump_enableint(struct fmdev *fmdev) | ||
962 | +{ | ||
963 | + u16 payload; | ||
964 | + | ||
965 | + /* Enable FR (tuning operation ended) interrupt */ | ||
966 | + payload = FM_FR_EVENT; | ||
967 | + if (!fm_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload, sizeof(payload), NULL)) | ||
968 | + fm_irq_timeout_stage(fmdev, FM_AF_JUMP_ENABLE_INT_RESP_IDX); | ||
969 | +} | ||
970 | + | ||
971 | +static void fm_irq_afjump_enableint_resp(struct fmdev *fmdev) | ||
972 | +{ | ||
973 | + fm_irq_common_cmd_resp_helper(fmdev, FM_AF_JUMP_START_AFJUMP_IDX); | ||
974 | +} | ||
975 | + | ||
976 | +static void fm_irq_start_afjump(struct fmdev *fmdev) | ||
977 | +{ | ||
978 | + u16 payload; | ||
979 | + | ||
980 | + payload = FM_TUNER_AF_JUMP_MODE; | ||
981 | + if (!fm_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload, | ||
982 | + sizeof(payload), NULL)) | ||
983 | + fm_irq_timeout_stage(fmdev, FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX); | ||
984 | +} | ||
985 | + | ||
986 | +static void fm_irq_handle_start_afjump_resp(struct fmdev *fmdev) | ||
987 | +{ | ||
988 | + struct sk_buff *skb; | ||
989 | + | ||
990 | + if (check_cmdresp_status(fmdev, &skb)) | ||
991 | + return; | ||
992 | + | ||
993 | + fmdev->irq_info.stage = FM_SEND_FLAG_GETCMD_IDX; | ||
994 | + set_bit(FM_AF_SWITCH_INPROGRESS, &fmdev->flag); | ||
995 | + clear_bit(FM_INTTASK_RUNNING, &fmdev->flag); | ||
996 | +} | ||
997 | + | ||
998 | +static void fm_irq_afjump_rd_freq(struct fmdev *fmdev) | ||
999 | +{ | ||
1000 | + u16 payload; | ||
1001 | + | ||
1002 | + if (!fm_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, sizeof(payload), NULL)) | ||
1003 | + fm_irq_timeout_stage(fmdev, FM_AF_JUMP_RD_FREQ_RESP_IDX); | ||
1004 | +} | ||
1005 | + | ||
1006 | +static void fm_irq_afjump_rd_freq_resp(struct fmdev *fmdev) | ||
1007 | +{ | ||
1008 | + struct sk_buff *skb; | ||
1009 | + u16 read_freq; | ||
1010 | + u32 curr_freq, jumped_freq; | ||
1011 | + | ||
1012 | + if (check_cmdresp_status(fmdev, &skb)) | ||
1013 | + return; | ||
1014 | + | ||
1015 | + /* Skip header info and copy only response data */ | ||
1016 | + skb_pull(skb, sizeof(struct fm_event_msg_hdr)); | ||
1017 | + memcpy(&read_freq, skb->data, sizeof(read_freq)); | ||
1018 | + read_freq = be16_to_cpu(read_freq); | ||
1019 | + curr_freq = fmdev->rx.region.bot_freq + ((u32)read_freq * FM_FREQ_MUL); | ||
1020 | + | ||
1021 | + jumped_freq = fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx]; | ||
1022 | + | ||
1023 | + /* If the frequency was changed the jump succeeded */ | ||
1024 | + if ((curr_freq != fmdev->rx.freq_before_jump) && (curr_freq == jumped_freq)) { | ||
1025 | + fmdbg("Successfully switched to alternate freq %d\n", curr_freq); | ||
1026 | + fmdev->rx.freq = curr_freq; | ||
1027 | + fm_rx_reset_rds_cache(fmdev); | ||
1028 | + | ||
1029 | + /* AF feature is on, enable low level RSSI interrupt */ | ||
1030 | + if (fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON) | ||
1031 | + fmdev->irq_info.mask |= FM_LEV_EVENT; | ||
1032 | + | ||
1033 | + fmdev->irq_info.stage = FM_LOW_RSSI_FINISH_IDX; | ||
1034 | + } else { /* jump to the next freq in the AF list */ | ||
1035 | + fmdev->rx.afjump_idx++; | ||
1036 | + | ||
1037 | + /* If we reached the end of the list - stop searching */ | ||
1038 | + if (fmdev->rx.afjump_idx >= fmdev->rx.stat_info.afcache_size) { | ||
1039 | + fmdbg("AF switch processing failed\n"); | ||
1040 | + fmdev->irq_info.stage = FM_LOW_RSSI_FINISH_IDX; | ||
1041 | + } else { /* AF List is not over - try next one */ | ||
1042 | + | ||
1043 | + fmdbg("Trying next freq in AF cache\n"); | ||
1044 | + fmdev->irq_info.stage = FM_AF_JUMP_SETPI_IDX; | ||
1045 | + } | ||
1046 | + } | ||
1047 | + fm_irq_call(fmdev); | ||
1048 | +} | ||
1049 | + | ||
1050 | +static void fm_irq_handle_low_rssi_finish(struct fmdev *fmdev) | ||
1051 | +{ | ||
1052 | + fm_irq_call_stage(fmdev, FM_SEND_INTMSK_CMD_IDX); | ||
1053 | +} | ||
1054 | + | ||
1055 | +static void fm_irq_send_intmsk_cmd(struct fmdev *fmdev) | ||
1056 | +{ | ||
1057 | + u16 payload; | ||
1058 | + | ||
1059 | + /* Re-enable FM interrupts */ | ||
1060 | + payload = fmdev->irq_info.mask; | ||
1061 | + | ||
1062 | + if (!fm_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload, | ||
1063 | + sizeof(payload), NULL)) | ||
1064 | + fm_irq_timeout_stage(fmdev, FM_HANDLE_INTMSK_CMD_RESP_IDX); | ||
1065 | +} | ||
1066 | + | ||
1067 | +static void fm_irq_handle_intmsk_cmd_resp(struct fmdev *fmdev) | ||
1068 | +{ | ||
1069 | + struct sk_buff *skb; | ||
1070 | + | ||
1071 | + if (check_cmdresp_status(fmdev, &skb)) | ||
1072 | + return; | ||
1073 | + /* | ||
1074 | + * This is last function in interrupt table to be executed. | ||
1075 | + * So, reset stage index to 0. | ||
1076 | + */ | ||
1077 | + fmdev->irq_info.stage = FM_SEND_FLAG_GETCMD_IDX; | ||
1078 | + | ||
1079 | + /* Start processing any pending interrupt */ | ||
1080 | + if (test_and_clear_bit(FM_INTTASK_SCHEDULE_PENDING, &fmdev->flag)) | ||
1081 | + fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev); | ||
1082 | + else | ||
1083 | + clear_bit(FM_INTTASK_RUNNING, &fmdev->flag); | ||
1084 | +} | ||
1085 | + | ||
1086 | +/* Returns availability of RDS data in internel buffer */ | ||
1087 | +u32 fmc_is_rds_data_available(struct fmdev *fmdev, struct file *file, | ||
1088 | + struct poll_table_struct *pts) | ||
1089 | +{ | ||
1090 | + poll_wait(file, &fmdev->rx.rds.read_queue, pts); | ||
1091 | + if (fmdev->rx.rds.rd_idx != fmdev->rx.rds.wr_idx) | ||
1092 | + return 0; | ||
1093 | + | ||
1094 | + return -EAGAIN; | ||
1095 | +} | ||
1096 | + | ||
1097 | +/* Copies RDS data from internal buffer to user buffer */ | ||
1098 | +u32 fmc_transfer_rds_from_internal_buff(struct fmdev *fmdev, struct file *file, | ||
1099 | + u8 __user *buf, size_t count) | ||
1100 | +{ | ||
1101 | + u32 block_count; | ||
1102 | + unsigned long flags; | ||
1103 | + int ret; | ||
1104 | + | ||
1105 | + if (fmdev->rx.rds.wr_idx == fmdev->rx.rds.rd_idx) { | ||
1106 | + if (file->f_flags & O_NONBLOCK) | ||
1107 | + return -EWOULDBLOCK; | ||
1108 | + | ||
1109 | + ret = wait_event_interruptible(fmdev->rx.rds.read_queue, | ||
1110 | + (fmdev->rx.rds.wr_idx != fmdev->rx.rds.rd_idx)); | ||
1111 | + if (ret) | ||
1112 | + return -EINTR; | ||
1113 | + } | ||
1114 | + | ||
1115 | + /* Calculate block count from byte count */ | ||
1116 | + count /= 3; | ||
1117 | + block_count = 0; | ||
1118 | + ret = 0; | ||
1119 | + | ||
1120 | + spin_lock_irqsave(&fmdev->rds_buff_lock, flags); | ||
1121 | + | ||
1122 | + while (block_count < count) { | ||
1123 | + if (fmdev->rx.rds.wr_idx == fmdev->rx.rds.rd_idx) | ||
1124 | + break; | ||
1125 | + | ||
1126 | + if (copy_to_user(buf, &fmdev->rx.rds.buff[fmdev->rx.rds.rd_idx], | ||
1127 | + FM_RDS_BLK_SIZE)) | ||
1128 | + break; | ||
1129 | + | ||
1130 | + fmdev->rx.rds.rd_idx += FM_RDS_BLK_SIZE; | ||
1131 | + if (fmdev->rx.rds.rd_idx >= fmdev->rx.rds.buf_size) | ||
1132 | + fmdev->rx.rds.rd_idx = 0; | ||
1133 | + | ||
1134 | + block_count++; | ||
1135 | + buf += FM_RDS_BLK_SIZE; | ||
1136 | + ret += FM_RDS_BLK_SIZE; | ||
1137 | + } | ||
1138 | + spin_unlock_irqrestore(&fmdev->rds_buff_lock, flags); | ||
1139 | + return ret; | ||
1140 | +} | ||
1141 | + | ||
1142 | +u32 fmc_set_freq(struct fmdev *fmdev, u32 freq_to_set) | ||
1143 | +{ | ||
1144 | + switch (fmdev->curr_fmmode) { | ||
1145 | + case FM_MODE_RX: | ||
1146 | + return fm_rx_set_freq(fmdev, freq_to_set); | ||
1147 | + | ||
1148 | + case FM_MODE_TX: | ||
1149 | + return fm_tx_set_freq(fmdev, freq_to_set); | ||
1150 | + | ||
1151 | + default: | ||
1152 | + return -EINVAL; | ||
1153 | + } | ||
1154 | +} | ||
1155 | + | ||
1156 | +u32 fmc_get_freq(struct fmdev *fmdev, u32 *cur_tuned_frq) | ||
1157 | +{ | ||
1158 | + if (fmdev->rx.freq == FM_UNDEFINED_FREQ) { | ||
1159 | + fmerr("RX frequency is not set\n"); | ||
1160 | + return -EPERM; | ||
1161 | + } | ||
1162 | + if (cur_tuned_frq == NULL) { | ||
1163 | + fmerr("Invalid memory\n"); | ||
1164 | + return -ENOMEM; | ||
1165 | + } | ||
1166 | + | ||
1167 | + switch (fmdev->curr_fmmode) { | ||
1168 | + case FM_MODE_RX: | ||
1169 | + *cur_tuned_frq = fmdev->rx.freq; | ||
1170 | + return 0; | ||
1171 | + | ||
1172 | + case FM_MODE_TX: | ||
1173 | + *cur_tuned_frq = 0; /* TODO : Change this later */ | ||
1174 | + return 0; | ||
1175 | + | ||
1176 | + default: | ||
1177 | + return -EINVAL; | ||
1178 | + } | ||
1179 | + | ||
1180 | +} | ||
1181 | + | ||
1182 | +u32 fmc_set_region(struct fmdev *fmdev, u8 region_to_set) | ||
1183 | +{ | ||
1184 | + switch (fmdev->curr_fmmode) { | ||
1185 | + case FM_MODE_RX: | ||
1186 | + return fm_rx_set_region(fmdev, region_to_set); | ||
1187 | + | ||
1188 | + case FM_MODE_TX: | ||
1189 | + return fm_tx_set_region(fmdev, region_to_set); | ||
1190 | + | ||
1191 | + default: | ||
1192 | + return -EINVAL; | ||
1193 | + } | ||
1194 | +} | ||
1195 | + | ||
1196 | +u32 fmc_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset) | ||
1197 | +{ | ||
1198 | + switch (fmdev->curr_fmmode) { | ||
1199 | + case FM_MODE_RX: | ||
1200 | + return fm_rx_set_mute_mode(fmdev, mute_mode_toset); | ||
1201 | + | ||
1202 | + case FM_MODE_TX: | ||
1203 | + return fm_tx_set_mute_mode(fmdev, mute_mode_toset); | ||
1204 | + | ||
1205 | + default: | ||
1206 | + return -EINVAL; | ||
1207 | + } | ||
1208 | +} | ||
1209 | + | ||
1210 | +u32 fmc_set_stereo_mono(struct fmdev *fmdev, u16 mode) | ||
1211 | +{ | ||
1212 | + switch (fmdev->curr_fmmode) { | ||
1213 | + case FM_MODE_RX: | ||
1214 | + return fm_rx_set_stereo_mono(fmdev, mode); | ||
1215 | + | ||
1216 | + case FM_MODE_TX: | ||
1217 | + return fm_tx_set_stereo_mono(fmdev, mode); | ||
1218 | + | ||
1219 | + default: | ||
1220 | + return -EINVAL; | ||
1221 | + } | ||
1222 | +} | ||
1223 | + | ||
1224 | +u32 fmc_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis) | ||
1225 | +{ | ||
1226 | + switch (fmdev->curr_fmmode) { | ||
1227 | + case FM_MODE_RX: | ||
1228 | + return fm_rx_set_rds_mode(fmdev, rds_en_dis); | ||
1229 | + | ||
1230 | + case FM_MODE_TX: | ||
1231 | + return fm_tx_set_rds_mode(fmdev, rds_en_dis); | ||
1232 | + | ||
1233 | + default: | ||
1234 | + return -EINVAL; | ||
1235 | + } | ||
1236 | +} | ||
1237 | + | ||
1238 | +/* Sends power off command to the chip */ | ||
1239 | +static u32 fm_power_down(struct fmdev *fmdev) | ||
1240 | +{ | ||
1241 | + u16 payload; | ||
1242 | + u32 ret; | ||
1243 | + | ||
1244 | + if (!test_bit(FM_CORE_READY, &fmdev->flag)) { | ||
1245 | + fmerr("FM core is not ready\n"); | ||
1246 | + return -EPERM; | ||
1247 | + } | ||
1248 | + if (fmdev->curr_fmmode == FM_MODE_OFF) { | ||
1249 | + fmdbg("FM chip is already in OFF state\n"); | ||
1250 | + return 0; | ||
1251 | + } | ||
1252 | + | ||
1253 | + payload = 0x0; | ||
1254 | + ret = fmc_send_cmd(fmdev, FM_POWER_MODE, REG_WR, &payload, | ||
1255 | + sizeof(payload), NULL, NULL); | ||
1256 | + if (ret < 0) | ||
1257 | + return ret; | ||
1258 | + | ||
1259 | + return fmc_release(fmdev); | ||
1260 | +} | ||
1261 | + | ||
1262 | +/* Reads init command from FM firmware file and loads to the chip */ | ||
1263 | +static u32 fm_download_firmware(struct fmdev *fmdev, const u8 *fw_name) | ||
1264 | +{ | ||
1265 | + const struct firmware *fw_entry; | ||
1266 | + struct bts_header *fw_header; | ||
1267 | + struct bts_action *action; | ||
1268 | + struct bts_action_delay *delay; | ||
1269 | + u8 *fw_data; | ||
1270 | + int ret, fw_len, cmd_cnt; | ||
1271 | + | ||
1272 | + cmd_cnt = 0; | ||
1273 | + set_bit(FM_FW_DW_INPROGRESS, &fmdev->flag); | ||
1274 | + | ||
1275 | + ret = request_firmware(&fw_entry, fw_name, | ||
1276 | + &fmdev->radio_dev->dev); | ||
1277 | + if (ret < 0) { | ||
1278 | + fmerr("Unable to read firmware(%s) content\n", fw_name); | ||
1279 | + return ret; | ||
1280 | + } | ||
1281 | + fmdbg("Firmware(%s) length : %d bytes\n", fw_name, fw_entry->size); | ||
1282 | + | ||
1283 | + fw_data = (void *)fw_entry->data; | ||
1284 | + fw_len = fw_entry->size; | ||
1285 | + | ||
1286 | + fw_header = (struct bts_header *)fw_data; | ||
1287 | + if (fw_header->magic != FM_FW_FILE_HEADER_MAGIC) { | ||
1288 | + fmerr("%s not a legal TI firmware file\n", fw_name); | ||
1289 | + ret = -EINVAL; | ||
1290 | + goto rel_fw; | ||
1291 | + } | ||
1292 | + fmdbg("FW(%s) magic number : 0x%x\n", fw_name, fw_header->magic); | ||
1293 | + | ||
1294 | + /* Skip file header info , we already verified it */ | ||
1295 | + fw_data += sizeof(struct bts_header); | ||
1296 | + fw_len -= sizeof(struct bts_header); | ||
1297 | + | ||
1298 | + while (fw_data && fw_len > 0) { | ||
1299 | + action = (struct bts_action *)fw_data; | ||
1300 | + | ||
1301 | + switch (action->type) { | ||
1302 | + case ACTION_SEND_COMMAND: /* Send */ | ||
1303 | + if (fmc_send_cmd(fmdev, 0, 0, action->data, | ||
1304 | + action->size, NULL, NULL)) | ||
1305 | + goto rel_fw; | ||
1306 | + | ||
1307 | + cmd_cnt++; | ||
1308 | + break; | ||
1309 | + | ||
1310 | + case ACTION_DELAY: /* Delay */ | ||
1311 | + delay = (struct bts_action_delay *)action->data; | ||
1312 | + mdelay(delay->msec); | ||
1313 | + break; | ||
1314 | + } | ||
1315 | + | ||
1316 | + fw_data += (sizeof(struct bts_action) + (action->size)); | ||
1317 | + fw_len -= (sizeof(struct bts_action) + (action->size)); | ||
1318 | + } | ||
1319 | + fmdbg("Firmware commands(%d) loaded to chip\n", cmd_cnt); | ||
1320 | +rel_fw: | ||
1321 | + release_firmware(fw_entry); | ||
1322 | + clear_bit(FM_FW_DW_INPROGRESS, &fmdev->flag); | ||
1323 | + | ||
1324 | + return ret; | ||
1325 | +} | ||
1326 | + | ||
1327 | +/* Loads default RX configuration to the chip */ | ||
1328 | +static u32 load_default_rx_configuration(struct fmdev *fmdev) | ||
1329 | +{ | ||
1330 | + int ret; | ||
1331 | + | ||
1332 | + ret = fm_rx_set_volume(fmdev, FM_DEFAULT_RX_VOLUME); | ||
1333 | + if (ret < 0) | ||
1334 | + return ret; | ||
1335 | + | ||
1336 | + return fm_rx_set_rssi_threshold(fmdev, FM_DEFAULT_RSSI_THRESHOLD); | ||
1337 | +} | ||
1338 | + | ||
1339 | +/* Does FM power on sequence */ | ||
1340 | +static u32 fm_power_up(struct fmdev *fmdev, u8 mode) | ||
1341 | +{ | ||
1342 | + u16 payload, asic_id, asic_ver; | ||
1343 | + int resp_len, ret; | ||
1344 | + u8 fw_name[50]; | ||
1345 | + | ||
1346 | + if (mode >= FM_MODE_ENTRY_MAX) { | ||
1347 | + fmerr("Invalid firmware download option\n"); | ||
1348 | + return -EINVAL; | ||
1349 | + } | ||
1350 | + | ||
1351 | + /* | ||
1352 | + * Initialize FM common module. FM GPIO toggling is | ||
1353 | + * taken care in Shared Transport driver. | ||
1354 | + */ | ||
1355 | + ret = fmc_prepare(fmdev); | ||
1356 | + if (ret < 0) { | ||
1357 | + fmerr("Unable to prepare FM Common\n"); | ||
1358 | + return ret; | ||
1359 | + } | ||
1360 | + | ||
1361 | + payload = FM_ENABLE; | ||
1362 | + if (fmc_send_cmd(fmdev, FM_POWER_MODE, REG_WR, &payload, | ||
1363 | + sizeof(payload), NULL, NULL)) | ||
1364 | + goto rel; | ||
1365 | + | ||
1366 | + /* Allow the chip to settle down in Channel-8 mode */ | ||
1367 | + msleep(20); | ||
1368 | + | ||
1369 | + if (fmc_send_cmd(fmdev, ASIC_ID_GET, REG_RD, NULL, | ||
1370 | + sizeof(asic_id), &asic_id, &resp_len)) | ||
1371 | + goto rel; | ||
1372 | + | ||
1373 | + if (fmc_send_cmd(fmdev, ASIC_VER_GET, REG_RD, NULL, | ||
1374 | + sizeof(asic_ver), &asic_ver, &resp_len)) | ||
1375 | + goto rel; | ||
1376 | + | ||
1377 | + fmdbg("ASIC ID: 0x%x , ASIC Version: %d\n", | ||
1378 | + be16_to_cpu(asic_id), be16_to_cpu(asic_ver)); | ||
1379 | + | ||
1380 | + sprintf(fw_name, "%s_%x.%d.bts", FM_FMC_FW_FILE_START, | ||
1381 | + be16_to_cpu(asic_id), be16_to_cpu(asic_ver)); | ||
1382 | + | ||
1383 | + ret = fm_download_firmware(fmdev, fw_name); | ||
1384 | + if (ret < 0) { | ||
1385 | + fmdbg("Failed to download firmware file %s\n", fw_name); | ||
1386 | + goto rel; | ||
1387 | + } | ||
1388 | + sprintf(fw_name, "%s_%x.%d.bts", (mode == FM_MODE_RX) ? | ||
1389 | + FM_RX_FW_FILE_START : FM_TX_FW_FILE_START, | ||
1390 | + be16_to_cpu(asic_id), be16_to_cpu(asic_ver)); | ||
1391 | + | ||
1392 | + ret = fm_download_firmware(fmdev, fw_name); | ||
1393 | + if (ret < 0) { | ||
1394 | + fmdbg("Failed to download firmware file %s\n", fw_name); | ||
1395 | + goto rel; | ||
1396 | + } else | ||
1397 | + return ret; | ||
1398 | +rel: | ||
1399 | + return fmc_release(fmdev); | ||
1400 | +} | ||
1401 | + | ||
1402 | +/* Set FM Modes(TX, RX, OFF) */ | ||
1403 | +u32 fmc_set_mode(struct fmdev *fmdev, u8 fm_mode) | ||
1404 | +{ | ||
1405 | + int ret = 0; | ||
1406 | + | ||
1407 | + if (fm_mode >= FM_MODE_ENTRY_MAX) { | ||
1408 | + fmerr("Invalid FM mode\n"); | ||
1409 | + return -EINVAL; | ||
1410 | + } | ||
1411 | + if (fmdev->curr_fmmode == fm_mode) { | ||
1412 | + fmdbg("Already fm is in mode(%d)\n", fm_mode); | ||
1413 | + return ret; | ||
1414 | + } | ||
1415 | + | ||
1416 | + switch (fm_mode) { | ||
1417 | + case FM_MODE_OFF: /* OFF Mode */ | ||
1418 | + ret = fm_power_down(fmdev); | ||
1419 | + if (ret < 0) { | ||
1420 | + fmerr("Failed to set OFF mode\n"); | ||
1421 | + return ret; | ||
1422 | + } | ||
1423 | + break; | ||
1424 | + | ||
1425 | + case FM_MODE_TX: /* TX Mode */ | ||
1426 | + case FM_MODE_RX: /* RX Mode */ | ||
1427 | + /* Power down before switching to TX or RX mode */ | ||
1428 | + if (fmdev->curr_fmmode != FM_MODE_OFF) { | ||
1429 | + ret = fm_power_down(fmdev); | ||
1430 | + if (ret < 0) { | ||
1431 | + fmerr("Failed to set OFF mode\n"); | ||
1432 | + return ret; | ||
1433 | + } | ||
1434 | + msleep(30); | ||
1435 | + } | ||
1436 | + ret = fm_power_up(fmdev, fm_mode); | ||
1437 | + if (ret < 0) { | ||
1438 | + fmerr("Failed to load firmware\n"); | ||
1439 | + return ret; | ||
1440 | + } | ||
1441 | + } | ||
1442 | + fmdev->curr_fmmode = fm_mode; | ||
1443 | + | ||
1444 | + /* Set default configuration */ | ||
1445 | + if (fmdev->curr_fmmode == FM_MODE_RX) { | ||
1446 | + fmdbg("Loading default rx configuration..\n"); | ||
1447 | + ret = load_default_rx_configuration(fmdev); | ||
1448 | + if (ret < 0) | ||
1449 | + fmerr("Failed to load default values\n"); | ||
1450 | + } | ||
1451 | + | ||
1452 | + return ret; | ||
1453 | +} | ||
1454 | + | ||
1455 | +/* Returns current FM mode (TX, RX, OFF) */ | ||
1456 | +u32 fmc_get_mode(struct fmdev *fmdev, u8 *fmmode) | ||
1457 | +{ | ||
1458 | + if (!test_bit(FM_CORE_READY, &fmdev->flag)) { | ||
1459 | + fmerr("FM core is not ready\n"); | ||
1460 | + return -EPERM; | ||
1461 | + } | ||
1462 | + if (fmmode == NULL) { | ||
1463 | + fmerr("Invalid memory\n"); | ||
1464 | + return -ENOMEM; | ||
1465 | + } | ||
1466 | + | ||
1467 | + *fmmode = fmdev->curr_fmmode; | ||
1468 | + return 0; | ||
1469 | +} | ||
1470 | + | ||
1471 | +/* Called by ST layer when FM packet is available */ | ||
1472 | +static long fm_st_receive(void *arg, struct sk_buff *skb) | ||
1473 | +{ | ||
1474 | + struct fmdev *fmdev; | ||
1475 | + | ||
1476 | + fmdev = (struct fmdev *)arg; | ||
1477 | + | ||
1478 | + if (skb == NULL) { | ||
1479 | + fmerr("Invalid SKB received from ST\n"); | ||
1480 | + return -EFAULT; | ||
1481 | + } | ||
1482 | + | ||
1483 | + if (skb->cb[0] != FM_PKT_LOGICAL_CHAN_NUMBER) { | ||
1484 | + fmerr("Received SKB (%p) is not FM Channel 8 pkt\n", skb); | ||
1485 | + return -EINVAL; | ||
1486 | + } | ||
1487 | + | ||
1488 | + memcpy(skb_push(skb, 1), &skb->cb[0], 1); | ||
1489 | + skb_queue_tail(&fmdev->rx_q, skb); | ||
1490 | + tasklet_schedule(&fmdev->rx_task); | ||
1491 | + | ||
1492 | + return 0; | ||
1493 | +} | ||
1494 | + | ||
1495 | +/* | ||
1496 | + * Called by ST layer to indicate protocol registration completion | ||
1497 | + * status. | ||
1498 | + */ | ||
1499 | +static void fm_st_reg_comp_cb(void *arg, char data) | ||
1500 | +{ | ||
1501 | + struct fmdev *fmdev; | ||
1502 | + | ||
1503 | + fmdev = (struct fmdev *)arg; | ||
1504 | + fmdev->streg_cbdata = data; | ||
1505 | + complete(&wait_for_fmdrv_reg_comp); | ||
1506 | +} | ||
1507 | + | ||
1508 | +/* | ||
1509 | + * This function will be called from FM V4L2 open function. | ||
1510 | + * Register with ST driver and initialize driver data. | ||
1511 | + */ | ||
1512 | +u32 fmc_prepare(struct fmdev *fmdev) | ||
1513 | +{ | ||
1514 | + static struct st_proto_s fm_st_proto; | ||
1515 | + u32 ret; | ||
1516 | + | ||
1517 | + if (test_bit(FM_CORE_READY, &fmdev->flag)) { | ||
1518 | + fmdbg("FM Core is already up\n"); | ||
1519 | + return 0; | ||
1520 | + } | ||
1521 | + | ||
1522 | + memset(&fm_st_proto, 0, sizeof(fm_st_proto)); | ||
1523 | + fm_st_proto.type = ST_FM; | ||
1524 | + fm_st_proto.recv = fm_st_receive; | ||
1525 | + fm_st_proto.match_packet = NULL; | ||
1526 | + fm_st_proto.reg_complete_cb = fm_st_reg_comp_cb; | ||
1527 | + fm_st_proto.write = NULL; /* TI ST driver will fill write pointer */ | ||
1528 | + fm_st_proto.priv_data = fmdev; | ||
1529 | + | ||
1530 | + ret = st_register(&fm_st_proto); | ||
1531 | + if (ret == -EINPROGRESS) { | ||
1532 | + init_completion(&wait_for_fmdrv_reg_comp); | ||
1533 | + fmdev->streg_cbdata = -EINPROGRESS; | ||
1534 | + fmdbg("%s waiting for ST reg completion signal\n", __func__); | ||
1535 | + | ||
1536 | + ret = wait_for_completion_timeout(&wait_for_fmdrv_reg_comp, | ||
1537 | + FM_ST_REG_TIMEOUT); | ||
1538 | + | ||
1539 | + if (!ret) { | ||
1540 | + fmerr("Timeout(%d sec), didn't get reg " | ||
1541 | + "completion signal from ST\n", | ||
1542 | + jiffies_to_msecs(FM_ST_REG_TIMEOUT) / 1000); | ||
1543 | + return -ETIMEDOUT; | ||
1544 | + } | ||
1545 | + if (fmdev->streg_cbdata != 0) { | ||
1546 | + fmerr("ST reg comp CB called with error " | ||
1547 | + "status %d\n", fmdev->streg_cbdata); | ||
1548 | + return -EAGAIN; | ||
1549 | + } | ||
1550 | + | ||
1551 | + ret = 0; | ||
1552 | + } else if (ret == -1) { | ||
1553 | + fmerr("st_register failed %d\n", ret); | ||
1554 | + return -EAGAIN; | ||
1555 | + } | ||
1556 | + | ||
1557 | + if (fm_st_proto.write != NULL) { | ||
1558 | + g_st_write = fm_st_proto.write; | ||
1559 | + } else { | ||
1560 | + fmerr("Failed to get ST write func pointer\n"); | ||
1561 | + ret = st_unregister(ST_FM); | ||
1562 | + if (ret < 0) | ||
1563 | + fmerr("st_unregister failed %d\n", ret); | ||
1564 | + return -EAGAIN; | ||
1565 | + } | ||
1566 | + | ||
1567 | + spin_lock_init(&fmdev->rds_buff_lock); | ||
1568 | + spin_lock_init(&fmdev->resp_skb_lock); | ||
1569 | + | ||
1570 | + /* Initialize TX queue and TX tasklet */ | ||
1571 | + skb_queue_head_init(&fmdev->tx_q); | ||
1572 | + tasklet_init(&fmdev->tx_task, send_tasklet, (unsigned long)fmdev); | ||
1573 | + | ||
1574 | + /* Initialize RX Queue and RX tasklet */ | ||
1575 | + skb_queue_head_init(&fmdev->rx_q); | ||
1576 | + tasklet_init(&fmdev->rx_task, recv_tasklet, (unsigned long)fmdev); | ||
1577 | + | ||
1578 | + fmdev->irq_info.stage = 0; | ||
1579 | + atomic_set(&fmdev->tx_cnt, 1); | ||
1580 | + fmdev->resp_comp = NULL; | ||
1581 | + | ||
1582 | + init_timer(&fmdev->irq_info.timer); | ||
1583 | + fmdev->irq_info.timer.function = &int_timeout_handler; | ||
1584 | + fmdev->irq_info.timer.data = (unsigned long)fmdev; | ||
1585 | + /*TODO: add FM_STIC_EVENT later */ | ||
1586 | + fmdev->irq_info.mask = FM_MAL_EVENT; | ||
1587 | + | ||
1588 | + /* Region info */ | ||
1589 | + memcpy(&fmdev->rx.region, ®ion_configs[default_radio_region], | ||
1590 | + sizeof(struct region_info)); | ||
1591 | + | ||
1592 | + fmdev->rx.mute_mode = FM_MUTE_OFF; | ||
1593 | + fmdev->rx.rf_depend_mute = FM_RX_RF_DEPENDENT_MUTE_OFF; | ||
1594 | + fmdev->rx.rds.flag = FM_RDS_DISABLE; | ||
1595 | + fmdev->rx.freq = FM_UNDEFINED_FREQ; | ||
1596 | + fmdev->rx.rds_mode = FM_RDS_SYSTEM_RDS; | ||
1597 | + fmdev->rx.af_mode = FM_RX_RDS_AF_SWITCH_MODE_OFF; | ||
1598 | + fmdev->irq_info.retry = 0; | ||
1599 | + | ||
1600 | + fm_rx_reset_rds_cache(fmdev); | ||
1601 | + init_waitqueue_head(&fmdev->rx.rds.read_queue); | ||
1602 | + | ||
1603 | + fm_rx_reset_station_info(fmdev); | ||
1604 | + set_bit(FM_CORE_READY, &fmdev->flag); | ||
1605 | + | ||
1606 | + return ret; | ||
1607 | +} | ||
1608 | + | ||
1609 | +/* | ||
1610 | + * This function will be called from FM V4L2 release function. | ||
1611 | + * Unregister from ST driver. | ||
1612 | + */ | ||
1613 | +u32 fmc_release(struct fmdev *fmdev) | ||
1614 | +{ | ||
1615 | + u32 ret; | ||
1616 | + | ||
1617 | + if (!test_bit(FM_CORE_READY, &fmdev->flag)) { | ||
1618 | + fmdbg("FM Core is already down\n"); | ||
1619 | + return 0; | ||
1620 | + } | ||
1621 | + /* Sevice pending read */ | ||
1622 | + wake_up_interruptible(&fmdev->rx.rds.read_queue); | ||
1623 | + | ||
1624 | + tasklet_kill(&fmdev->tx_task); | ||
1625 | + tasklet_kill(&fmdev->rx_task); | ||
1626 | + | ||
1627 | + skb_queue_purge(&fmdev->tx_q); | ||
1628 | + skb_queue_purge(&fmdev->rx_q); | ||
1629 | + | ||
1630 | + fmdev->resp_comp = NULL; | ||
1631 | + fmdev->rx.freq = 0; | ||
1632 | + | ||
1633 | + ret = st_unregister(ST_FM); | ||
1634 | + if (ret < 0) | ||
1635 | + fmerr("Failed to de-register FM from ST %d\n", ret); | ||
1636 | + else | ||
1637 | + fmdbg("Successfully unregistered from ST\n"); | ||
1638 | + | ||
1639 | + clear_bit(FM_CORE_READY, &fmdev->flag); | ||
1640 | + return ret; | ||
1641 | +} | ||
1642 | + | ||
1643 | +/* | ||
1644 | + * Module init function. Ask FM V4L module to register video device. | ||
1645 | + * Allocate memory for FM driver context and RX RDS buffer. | ||
1646 | + */ | ||
1647 | +static int __init fm_drv_init(void) | ||
1648 | +{ | ||
1649 | + struct fmdev *fmdev = NULL; | ||
1650 | + u32 ret = -ENOMEM; | ||
1651 | + | ||
1652 | + fmdbg("FM driver version %s\n", FM_DRV_VERSION); | ||
1653 | + | ||
1654 | + fmdev = kzalloc(sizeof(struct fmdev), GFP_KERNEL); | ||
1655 | + if (NULL == fmdev) { | ||
1656 | + fmerr("Can't allocate operation structure memory\n"); | ||
1657 | + return ret; | ||
1658 | + } | ||
1659 | + fmdev->rx.rds.buf_size = default_rds_buf * FM_RDS_BLK_SIZE; | ||
1660 | + fmdev->rx.rds.buff = kzalloc(fmdev->rx.rds.buf_size, GFP_KERNEL); | ||
1661 | + if (NULL == fmdev->rx.rds.buff) { | ||
1662 | + fmerr("Can't allocate rds ring buffer\n"); | ||
1663 | + goto rel_dev; | ||
1664 | + } | ||
1665 | + | ||
1666 | + ret = fm_v4l2_init_video_device(fmdev, radio_nr); | ||
1667 | + if (ret < 0) | ||
1668 | + goto rel_rdsbuf; | ||
1669 | + | ||
1670 | + fmdev->irq_info.handlers = int_handler_table; | ||
1671 | + fmdev->curr_fmmode = FM_MODE_OFF; | ||
1672 | + fmdev->tx_data.pwr_lvl = FM_PWR_LVL_DEF; | ||
1673 | + fmdev->tx_data.preemph = FM_TX_PREEMPH_50US; | ||
1674 | + return ret; | ||
1675 | + | ||
1676 | +rel_rdsbuf: | ||
1677 | + kfree(fmdev->rx.rds.buff); | ||
1678 | +rel_dev: | ||
1679 | + kfree(fmdev); | ||
1680 | + | ||
1681 | + return ret; | ||
1682 | +} | ||
1683 | + | ||
1684 | +/* Module exit function. Ask FM V4L module to unregister video device */ | ||
1685 | +static void __exit fm_drv_exit(void) | ||
1686 | +{ | ||
1687 | + struct fmdev *fmdev = NULL; | ||
1688 | + | ||
1689 | + fmdev = fm_v4l2_deinit_video_device(); | ||
1690 | + if (fmdev != NULL) { | ||
1691 | + kfree(fmdev->rx.rds.buff); | ||
1692 | + kfree(fmdev); | ||
1693 | + } | ||
1694 | +} | ||
1695 | + | ||
1696 | +module_init(fm_drv_init); | ||
1697 | +module_exit(fm_drv_exit); | ||
1698 | + | ||
1699 | +/* ------------- Module Info ------------- */ | ||
1700 | +MODULE_AUTHOR("Manjunatha Halli <manjunatha_halli@ti.com>"); | ||
1701 | +MODULE_DESCRIPTION("FM Driver for TI's Connectivity chip. " FM_DRV_VERSION); | ||
1702 | +MODULE_VERSION(FM_DRV_VERSION); | ||
1703 | +MODULE_LICENSE("GPL"); | ||
1704 | diff --git a/drivers/media/radio/wl128x/fmdrv_common.h b/drivers/media/radio/wl128x/fmdrv_common.h | ||
1705 | new file mode 100644 | ||
1706 | index 0000000..e5091f4 | ||
1707 | --- /dev/null | ||
1708 | +++ b/drivers/media/radio/wl128x/fmdrv_common.h | ||
1709 | @@ -0,0 +1,402 @@ | ||
1710 | +/* | ||
1711 | + * FM Driver for Connectivity chip of Texas Instruments. | ||
1712 | + * FM Common module header file | ||
1713 | + * | ||
1714 | + * Copyright (C) 2011 Texas Instruments | ||
1715 | + * | ||
1716 | + * This program is free software; you can redistribute it and/or modify | ||
1717 | + * it under the terms of the GNU General Public License version 2 as | ||
1718 | + * published by the Free Software Foundation. | ||
1719 | + * | ||
1720 | + * This program is distributed in the hope that it will be useful, | ||
1721 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
1722 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
1723 | + * GNU General Public License for more details. | ||
1724 | + * | ||
1725 | + * You should have received a copy of the GNU General Public License | ||
1726 | + * along with this program; if not, write to the Free Software | ||
1727 | + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
1728 | + * | ||
1729 | + */ | ||
1730 | + | ||
1731 | +#ifndef _FMDRV_COMMON_H | ||
1732 | +#define _FMDRV_COMMON_H | ||
1733 | + | ||
1734 | +#define FM_ST_REG_TIMEOUT msecs_to_jiffies(6000) /* 6 sec */ | ||
1735 | +#define FM_PKT_LOGICAL_CHAN_NUMBER 0x08 /* Logical channel 8 */ | ||
1736 | + | ||
1737 | +#define REG_RD 0x1 | ||
1738 | +#define REG_WR 0x0 | ||
1739 | + | ||
1740 | +struct fm_reg_table { | ||
1741 | + u8 opcode; | ||
1742 | + u8 type; | ||
1743 | + u8 *name; | ||
1744 | +}; | ||
1745 | + | ||
1746 | +#define STEREO_GET 0 | ||
1747 | +#define RSSI_LVL_GET 1 | ||
1748 | +#define IF_COUNT_GET 2 | ||
1749 | +#define FLAG_GET 3 | ||
1750 | +#define RDS_SYNC_GET 4 | ||
1751 | +#define RDS_DATA_GET 5 | ||
1752 | +#define FREQ_SET 10 | ||
1753 | +#define AF_FREQ_SET 11 | ||
1754 | +#define MOST_MODE_SET 12 | ||
1755 | +#define MOST_BLEND_SET 13 | ||
1756 | +#define DEMPH_MODE_SET 14 | ||
1757 | +#define SEARCH_LVL_SET 15 | ||
1758 | +#define BAND_SET 16 | ||
1759 | +#define MUTE_STATUS_SET 17 | ||
1760 | +#define RDS_PAUSE_LVL_SET 18 | ||
1761 | +#define RDS_PAUSE_DUR_SET 19 | ||
1762 | +#define RDS_MEM_SET 20 | ||
1763 | +#define RDS_BLK_B_SET 21 | ||
1764 | +#define RDS_MSK_B_SET 22 | ||
1765 | +#define RDS_PI_MASK_SET 23 | ||
1766 | +#define RDS_PI_SET 24 | ||
1767 | +#define RDS_SYSTEM_SET 25 | ||
1768 | +#define INT_MASK_SET 26 | ||
1769 | +#define SEARCH_DIR_SET 27 | ||
1770 | +#define VOLUME_SET 28 | ||
1771 | +#define AUDIO_ENABLE_SET 29 | ||
1772 | +#define PCM_MODE_SET 30 | ||
1773 | +#define I2S_MODE_CONFIG_SET 31 | ||
1774 | +#define POWER_SET 32 | ||
1775 | +#define INTX_CONFIG_SET 33 | ||
1776 | +#define PULL_EN_SET 34 | ||
1777 | +#define HILO_SET 35 | ||
1778 | +#define SWITCH2FREF 36 | ||
1779 | +#define FREQ_DRIFT_REPORT 37 | ||
1780 | + | ||
1781 | +#define PCE_GET 40 | ||
1782 | +#define FIRM_VER_GET 41 | ||
1783 | +#define ASIC_VER_GET 42 | ||
1784 | +#define ASIC_ID_GET 43 | ||
1785 | +#define MAN_ID_GET 44 | ||
1786 | +#define TUNER_MODE_SET 45 | ||
1787 | +#define STOP_SEARCH 46 | ||
1788 | +#define RDS_CNTRL_SET 47 | ||
1789 | + | ||
1790 | +#define WRITE_HARDWARE_REG 100 | ||
1791 | +#define CODE_DOWNLOAD 101 | ||
1792 | +#define RESET 102 | ||
1793 | + | ||
1794 | +#define FM_POWER_MODE 254 | ||
1795 | +#define FM_INTERRUPT 255 | ||
1796 | + | ||
1797 | +/* Transmitter API */ | ||
1798 | + | ||
1799 | +#define CHANL_SET 55 | ||
1800 | +#define CHANL_BW_SET 56 | ||
1801 | +#define REF_SET 57 | ||
1802 | +#define POWER_ENB_SET 90 | ||
1803 | +#define POWER_ATT_SET 58 | ||
1804 | +#define POWER_LEV_SET 59 | ||
1805 | +#define AUDIO_DEV_SET 60 | ||
1806 | +#define PILOT_DEV_SET 61 | ||
1807 | +#define RDS_DEV_SET 62 | ||
1808 | +#define TX_BAND_SET 65 | ||
1809 | +#define PUPD_SET 91 | ||
1810 | +#define AUDIO_IO_SET 63 | ||
1811 | +#define PREMPH_SET 64 | ||
1812 | +#define MONO_SET 66 | ||
1813 | +#define MUTE 92 | ||
1814 | +#define MPX_LMT_ENABLE 67 | ||
1815 | +#define PI_SET 93 | ||
1816 | +#define ECC_SET 69 | ||
1817 | +#define PTY 70 | ||
1818 | +#define AF 71 | ||
1819 | +#define DISPLAY_MODE 74 | ||
1820 | +#define RDS_REP_SET 77 | ||
1821 | +#define RDS_CONFIG_DATA_SET 98 | ||
1822 | +#define RDS_DATA_SET 99 | ||
1823 | +#define RDS_DATA_ENB 94 | ||
1824 | +#define TA_SET 78 | ||
1825 | +#define TP_SET 79 | ||
1826 | +#define DI_SET 80 | ||
1827 | +#define MS_SET 81 | ||
1828 | +#define PS_SCROLL_SPEED 82 | ||
1829 | +#define TX_AUDIO_LEVEL_TEST 96 | ||
1830 | +#define TX_AUDIO_LEVEL_TEST_THRESHOLD 73 | ||
1831 | +#define TX_AUDIO_INPUT_LEVEL_RANGE_SET 54 | ||
1832 | +#define RX_ANTENNA_SELECT 87 | ||
1833 | +#define I2C_DEV_ADDR_SET 86 | ||
1834 | +#define REF_ERR_CALIB_PARAM_SET 88 | ||
1835 | +#define REF_ERR_CALIB_PERIODICITY_SET 89 | ||
1836 | +#define SOC_INT_TRIGGER 52 | ||
1837 | +#define SOC_AUDIO_PATH_SET 83 | ||
1838 | +#define SOC_PCMI_OVERRIDE 84 | ||
1839 | +#define SOC_I2S_OVERRIDE 85 | ||
1840 | +#define RSSI_BLOCK_SCAN_FREQ_SET 95 | ||
1841 | +#define RSSI_BLOCK_SCAN_START 97 | ||
1842 | +#define RSSI_BLOCK_SCAN_DATA_GET 5 | ||
1843 | +#define READ_FMANT_TUNE_VALUE 104 | ||
1844 | + | ||
1845 | +/* SKB helpers */ | ||
1846 | +struct fm_skb_cb { | ||
1847 | + __u8 fm_op; | ||
1848 | + struct completion *completion; | ||
1849 | +}; | ||
1850 | + | ||
1851 | +#define fm_cb(skb) ((struct fm_skb_cb *)(skb->cb)) | ||
1852 | + | ||
1853 | +/* FM Channel-8 command message format */ | ||
1854 | +struct fm_cmd_msg_hdr { | ||
1855 | + __u8 hdr; /* Logical Channel-8 */ | ||
1856 | + __u8 len; /* Number of bytes follows */ | ||
1857 | + __u8 op; /* FM Opcode */ | ||
1858 | + __u8 rd_wr; /* Read/Write command */ | ||
1859 | + __u8 dlen; /* Length of payload */ | ||
1860 | +} __attribute__ ((packed)); | ||
1861 | + | ||
1862 | +#define FM_CMD_MSG_HDR_SIZE 5 /* sizeof(struct fm_cmd_msg_hdr) */ | ||
1863 | + | ||
1864 | +/* FM Channel-8 event messgage format */ | ||
1865 | +struct fm_event_msg_hdr { | ||
1866 | + __u8 header; /* Logical Channel-8 */ | ||
1867 | + __u8 len; /* Number of bytes follows */ | ||
1868 | + __u8 status; /* Event status */ | ||
1869 | + __u8 num_fm_hci_cmds; /* Number of pkts the host allowed to send */ | ||
1870 | + __u8 op; /* FM Opcode */ | ||
1871 | + __u8 rd_wr; /* Read/Write command */ | ||
1872 | + __u8 dlen; /* Length of payload */ | ||
1873 | +} __attribute__ ((packed)); | ||
1874 | + | ||
1875 | +#define FM_EVT_MSG_HDR_SIZE 7 /* sizeof(struct fm_event_msg_hdr) */ | ||
1876 | + | ||
1877 | +/* TI's magic number in firmware file */ | ||
1878 | +#define FM_FW_FILE_HEADER_MAGIC 0x42535442 | ||
1879 | + | ||
1880 | +#define FM_ENABLE 1 | ||
1881 | +#define FM_DISABLE 0 | ||
1882 | + | ||
1883 | +/* FLAG_GET register bits */ | ||
1884 | +#define FM_FR_EVENT (1 << 0) | ||
1885 | +#define FM_BL_EVENT (1 << 1) | ||
1886 | +#define FM_RDS_EVENT (1 << 2) | ||
1887 | +#define FM_BBLK_EVENT (1 << 3) | ||
1888 | +#define FM_LSYNC_EVENT (1 << 4) | ||
1889 | +#define FM_LEV_EVENT (1 << 5) | ||
1890 | +#define FM_IFFR_EVENT (1 << 6) | ||
1891 | +#define FM_PI_EVENT (1 << 7) | ||
1892 | +#define FM_PD_EVENT (1 << 8) | ||
1893 | +#define FM_STIC_EVENT (1 << 9) | ||
1894 | +#define FM_MAL_EVENT (1 << 10) | ||
1895 | +#define FM_POW_ENB_EVENT (1 << 11) | ||
1896 | + | ||
1897 | +/* | ||
1898 | + * Firmware files of FM. ASIC ID and ASIC version will be appened to this, | ||
1899 | + * later. | ||
1900 | + */ | ||
1901 | +#define FM_FMC_FW_FILE_START ("fmc_ch8") | ||
1902 | +#define FM_RX_FW_FILE_START ("fm_rx_ch8") | ||
1903 | +#define FM_TX_FW_FILE_START ("fm_tx_ch8") | ||
1904 | + | ||
1905 | +#define FM_UNDEFINED_FREQ 0xFFFFFFFF | ||
1906 | + | ||
1907 | +/* Band types */ | ||
1908 | +#define FM_BAND_EUROPE_US 0 | ||
1909 | +#define FM_BAND_JAPAN 1 | ||
1910 | + | ||
1911 | +/* Seek directions */ | ||
1912 | +#define FM_SEARCH_DIRECTION_DOWN 0 | ||
1913 | +#define FM_SEARCH_DIRECTION_UP 1 | ||
1914 | + | ||
1915 | +/* Tunner modes */ | ||
1916 | +#define FM_TUNER_STOP_SEARCH_MODE 0 | ||
1917 | +#define FM_TUNER_PRESET_MODE 1 | ||
1918 | +#define FM_TUNER_AUTONOMOUS_SEARCH_MODE 2 | ||
1919 | +#define FM_TUNER_AF_JUMP_MODE 3 | ||
1920 | + | ||
1921 | +/* Min and Max volume */ | ||
1922 | +#define FM_RX_VOLUME_MIN 0 | ||
1923 | +#define FM_RX_VOLUME_MAX 70 | ||
1924 | + | ||
1925 | +/* Volume gain step */ | ||
1926 | +#define FM_RX_VOLUME_GAIN_STEP 0x370 | ||
1927 | + | ||
1928 | +/* Mute modes */ | ||
1929 | +#define FM_MUTE_OFF 0 | ||
1930 | +#define FM_MUTE_ON 1 | ||
1931 | +#define FM_MUTE_ATTENUATE 2 | ||
1932 | + | ||
1933 | +#define FM_RX_UNMUTE_MODE 0x00 | ||
1934 | +#define FM_RX_RF_DEP_MODE 0x01 | ||
1935 | +#define FM_RX_AC_MUTE_MODE 0x02 | ||
1936 | +#define FM_RX_HARD_MUTE_LEFT_MODE 0x04 | ||
1937 | +#define FM_RX_HARD_MUTE_RIGHT_MODE 0x08 | ||
1938 | +#define FM_RX_SOFT_MUTE_FORCE_MODE 0x10 | ||
1939 | + | ||
1940 | +/* RF dependent mute mode */ | ||
1941 | +#define FM_RX_RF_DEPENDENT_MUTE_ON 1 | ||
1942 | +#define FM_RX_RF_DEPENDENT_MUTE_OFF 0 | ||
1943 | + | ||
1944 | +/* RSSI threshold min and max */ | ||
1945 | +#define FM_RX_RSSI_THRESHOLD_MIN -128 | ||
1946 | +#define FM_RX_RSSI_THRESHOLD_MAX 127 | ||
1947 | + | ||
1948 | +/* Stereo/Mono mode */ | ||
1949 | +#define FM_STEREO_MODE 0 | ||
1950 | +#define FM_MONO_MODE 1 | ||
1951 | +#define FM_STEREO_SOFT_BLEND 1 | ||
1952 | + | ||
1953 | +/* FM RX De-emphasis filter modes */ | ||
1954 | +#define FM_RX_EMPHASIS_FILTER_50_USEC 0 | ||
1955 | +#define FM_RX_EMPHASIS_FILTER_75_USEC 1 | ||
1956 | + | ||
1957 | +/* FM RDS modes */ | ||
1958 | +#define FM_RDS_DISABLE 0 | ||
1959 | +#define FM_RDS_ENABLE 1 | ||
1960 | + | ||
1961 | +#define FM_NO_PI_CODE 0 | ||
1962 | + | ||
1963 | +/* FM and RX RDS block enable/disable */ | ||
1964 | +#define FM_RX_PWR_SET_FM_ON_RDS_OFF 0x1 | ||
1965 | +#define FM_RX_PWR_SET_FM_AND_RDS_BLK_ON 0x3 | ||
1966 | +#define FM_RX_PWR_SET_FM_AND_RDS_BLK_OFF 0x0 | ||
1967 | + | ||
1968 | +/* RX RDS */ | ||
1969 | +#define FM_RX_RDS_FLUSH_FIFO 0x1 | ||
1970 | +#define FM_RX_RDS_FIFO_THRESHOLD 64 /* tuples */ | ||
1971 | +#define FM_RDS_BLK_SIZE 3 /* 3 bytes */ | ||
1972 | + | ||
1973 | +/* RDS block types */ | ||
1974 | +#define FM_RDS_BLOCK_A 0 | ||
1975 | +#define FM_RDS_BLOCK_B 1 | ||
1976 | +#define FM_RDS_BLOCK_C 2 | ||
1977 | +#define FM_RDS_BLOCK_Ctag 3 | ||
1978 | +#define FM_RDS_BLOCK_D 4 | ||
1979 | +#define FM_RDS_BLOCK_E 5 | ||
1980 | + | ||
1981 | +#define FM_RDS_BLK_IDX_A 0 | ||
1982 | +#define FM_RDS_BLK_IDX_B 1 | ||
1983 | +#define FM_RDS_BLK_IDX_C 2 | ||
1984 | +#define FM_RDS_BLK_IDX_D 3 | ||
1985 | +#define FM_RDS_BLK_IDX_UNKNOWN 0xF0 | ||
1986 | + | ||
1987 | +#define FM_RDS_STATUS_ERR_MASK 0x18 | ||
1988 | + | ||
1989 | +/* | ||
1990 | + * Represents an RDS group type & version. | ||
1991 | + * There are 15 groups, each group has 2 versions: A and B. | ||
1992 | + */ | ||
1993 | +#define FM_RDS_GROUP_TYPE_MASK_0A ((unsigned long)1<<0) | ||
1994 | +#define FM_RDS_GROUP_TYPE_MASK_0B ((unsigned long)1<<1) | ||
1995 | +#define FM_RDS_GROUP_TYPE_MASK_1A ((unsigned long)1<<2) | ||
1996 | +#define FM_RDS_GROUP_TYPE_MASK_1B ((unsigned long)1<<3) | ||
1997 | +#define FM_RDS_GROUP_TYPE_MASK_2A ((unsigned long)1<<4) | ||
1998 | +#define FM_RDS_GROUP_TYPE_MASK_2B ((unsigned long)1<<5) | ||
1999 | +#define FM_RDS_GROUP_TYPE_MASK_3A ((unsigned long)1<<6) | ||
2000 | +#define FM_RDS_GROUP_TYPE_MASK_3B ((unsigned long)1<<7) | ||
2001 | +#define FM_RDS_GROUP_TYPE_MASK_4A ((unsigned long)1<<8) | ||
2002 | +#define FM_RDS_GROUP_TYPE_MASK_4B ((unsigned long)1<<9) | ||
2003 | +#define FM_RDS_GROUP_TYPE_MASK_5A ((unsigned long)1<<10) | ||
2004 | +#define FM_RDS_GROUP_TYPE_MASK_5B ((unsigned long)1<<11) | ||
2005 | +#define FM_RDS_GROUP_TYPE_MASK_6A ((unsigned long)1<<12) | ||
2006 | +#define FM_RDS_GROUP_TYPE_MASK_6B ((unsigned long)1<<13) | ||
2007 | +#define FM_RDS_GROUP_TYPE_MASK_7A ((unsigned long)1<<14) | ||
2008 | +#define FM_RDS_GROUP_TYPE_MASK_7B ((unsigned long)1<<15) | ||
2009 | +#define FM_RDS_GROUP_TYPE_MASK_8A ((unsigned long)1<<16) | ||
2010 | +#define FM_RDS_GROUP_TYPE_MASK_8B ((unsigned long)1<<17) | ||
2011 | +#define FM_RDS_GROUP_TYPE_MASK_9A ((unsigned long)1<<18) | ||
2012 | +#define FM_RDS_GROUP_TYPE_MASK_9B ((unsigned long)1<<19) | ||
2013 | +#define FM_RDS_GROUP_TYPE_MASK_10A ((unsigned long)1<<20) | ||
2014 | +#define FM_RDS_GROUP_TYPE_MASK_10B ((unsigned long)1<<21) | ||
2015 | +#define FM_RDS_GROUP_TYPE_MASK_11A ((unsigned long)1<<22) | ||
2016 | +#define FM_RDS_GROUP_TYPE_MASK_11B ((unsigned long)1<<23) | ||
2017 | +#define FM_RDS_GROUP_TYPE_MASK_12A ((unsigned long)1<<24) | ||
2018 | +#define FM_RDS_GROUP_TYPE_MASK_12B ((unsigned long)1<<25) | ||
2019 | +#define FM_RDS_GROUP_TYPE_MASK_13A ((unsigned long)1<<26) | ||
2020 | +#define FM_RDS_GROUP_TYPE_MASK_13B ((unsigned long)1<<27) | ||
2021 | +#define FM_RDS_GROUP_TYPE_MASK_14A ((unsigned long)1<<28) | ||
2022 | +#define FM_RDS_GROUP_TYPE_MASK_14B ((unsigned long)1<<29) | ||
2023 | +#define FM_RDS_GROUP_TYPE_MASK_15A ((unsigned long)1<<30) | ||
2024 | +#define FM_RDS_GROUP_TYPE_MASK_15B ((unsigned long)1<<31) | ||
2025 | + | ||
2026 | +/* RX Alternate Frequency info */ | ||
2027 | +#define FM_RDS_MIN_AF 1 | ||
2028 | +#define FM_RDS_MAX_AF 204 | ||
2029 | +#define FM_RDS_MAX_AF_JAPAN 140 | ||
2030 | +#define FM_RDS_1_AF_FOLLOWS 225 | ||
2031 | +#define FM_RDS_25_AF_FOLLOWS 249 | ||
2032 | + | ||
2033 | +/* RDS system type (RDS/RBDS) */ | ||
2034 | +#define FM_RDS_SYSTEM_RDS 0 | ||
2035 | +#define FM_RDS_SYSTEM_RBDS 1 | ||
2036 | + | ||
2037 | +/* AF on/off */ | ||
2038 | +#define FM_RX_RDS_AF_SWITCH_MODE_ON 1 | ||
2039 | +#define FM_RX_RDS_AF_SWITCH_MODE_OFF 0 | ||
2040 | + | ||
2041 | +/* Retry count when interrupt process goes wrong */ | ||
2042 | +#define FM_IRQ_TIMEOUT_RETRY_MAX 5 /* 5 times */ | ||
2043 | + | ||
2044 | +/* Audio IO set values */ | ||
2045 | +#define FM_RX_AUDIO_ENABLE_I2S 0x01 | ||
2046 | +#define FM_RX_AUDIO_ENABLE_ANALOG 0x02 | ||
2047 | +#define FM_RX_AUDIO_ENABLE_I2S_AND_ANALOG 0x03 | ||
2048 | +#define FM_RX_AUDIO_ENABLE_DISABLE 0x00 | ||
2049 | + | ||
2050 | +/* HI/LO set values */ | ||
2051 | +#define FM_RX_IFFREQ_TO_HI_SIDE 0x0 | ||
2052 | +#define FM_RX_IFFREQ_TO_LO_SIDE 0x1 | ||
2053 | +#define FM_RX_IFFREQ_HILO_AUTOMATIC 0x2 | ||
2054 | + | ||
2055 | +/* | ||
2056 | + * Default RX mode configuration. Chip will be configured | ||
2057 | + * with this default values after loading RX firmware. | ||
2058 | + */ | ||
2059 | +#define FM_DEFAULT_RX_VOLUME 10 | ||
2060 | +#define FM_DEFAULT_RSSI_THRESHOLD 3 | ||
2061 | + | ||
2062 | +/* Range for TX power level in units for dB/uV */ | ||
2063 | +#define FM_PWR_LVL_LOW 91 | ||
2064 | +#define FM_PWR_LVL_HIGH 122 | ||
2065 | + | ||
2066 | +/* Chip specific default TX power level value */ | ||
2067 | +#define FM_PWR_LVL_DEF 4 | ||
2068 | + | ||
2069 | +/* FM TX Pre-emphasis filter values */ | ||
2070 | +#define FM_TX_PREEMPH_OFF 1 | ||
2071 | +#define FM_TX_PREEMPH_50US 0 | ||
2072 | +#define FM_TX_PREEMPH_75US 2 | ||
2073 | + | ||
2074 | +/* FM TX antenna impedence values */ | ||
2075 | +#define FM_TX_ANT_IMP_50 0 | ||
2076 | +#define FM_TX_ANT_IMP_200 1 | ||
2077 | +#define FM_TX_ANT_IMP_500 2 | ||
2078 | + | ||
2079 | +/* Functions exported by FM common sub-module */ | ||
2080 | +u32 fmc_prepare(struct fmdev *); | ||
2081 | +u32 fmc_release(struct fmdev *); | ||
2082 | + | ||
2083 | +void fmc_update_region_info(struct fmdev *, u8); | ||
2084 | +u32 fmc_send_cmd(struct fmdev *, u8, u16, | ||
2085 | + void *, unsigned int, void *, int *); | ||
2086 | +u32 fmc_is_rds_data_available(struct fmdev *, struct file *, | ||
2087 | + struct poll_table_struct *); | ||
2088 | +u32 fmc_transfer_rds_from_internal_buff(struct fmdev *, struct file *, | ||
2089 | + u8 __user *, size_t); | ||
2090 | + | ||
2091 | +u32 fmc_set_freq(struct fmdev *, u32); | ||
2092 | +u32 fmc_set_mode(struct fmdev *, u8); | ||
2093 | +u32 fmc_set_region(struct fmdev *, u8); | ||
2094 | +u32 fmc_set_mute_mode(struct fmdev *, u8); | ||
2095 | +u32 fmc_set_stereo_mono(struct fmdev *, u16); | ||
2096 | +u32 fmc_set_rds_mode(struct fmdev *, u8); | ||
2097 | + | ||
2098 | +u32 fmc_get_freq(struct fmdev *, u32 *); | ||
2099 | +u32 fmc_get_region(struct fmdev *, u8 *); | ||
2100 | +u32 fmc_get_mode(struct fmdev *, u8 *); | ||
2101 | + | ||
2102 | +/* | ||
2103 | + * channel spacing | ||
2104 | + */ | ||
2105 | +#define FM_CHANNEL_SPACING_50KHZ 1 | ||
2106 | +#define FM_CHANNEL_SPACING_100KHZ 2 | ||
2107 | +#define FM_CHANNEL_SPACING_200KHZ 4 | ||
2108 | +#define FM_FREQ_MUL 50 | ||
2109 | + | ||
2110 | +#endif | ||
2111 | + | ||
2112 | -- | ||
2113 | 1.6.6.1 | ||
2114 | |||