2 * FM Driver for Connectivity chip of Texas Instruments.
4 * This sub-module of FM driver is common for FM RX and TX
5 * functionality. This module is responsible for:
6 * 1) Forming group of Channel-8 commands to perform particular
7 * functionality (eg., frequency set require more than
8 * one Channel-8 command to be sent to the chip).
9 * 2) Sending each Channel-8 command to the chip and reading
10 * response back over Shared Transport.
11 * 3) Managing TX and RX Queues and Tasklets.
12 * 4) Handling FM Interrupt packet and taking appropriate action.
13 * 5) Loading FM firmware to the chip (common, FM TX, and FM RX
14 * firmware files based on mode selection)
16 * Copyright (C) 2011 Texas Instruments
17 * Author: Raja Mani <raja_mani@ti.com>
18 * Author: Manjunatha Halli <manjunatha_halli@ti.com>
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License version 2 as
22 * published by the Free Software Foundation.
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
35 #include <linux/module.h>
36 #include <linux/firmware.h>
37 #include <linux/delay.h>
39 #include "fmdrv_v4l2.h"
40 #include "fmdrv_common.h"
41 #include <linux/ti_wilink_st.h>
46 static struct region_info region_configs
[] = {
49 .chanl_space
= FM_CHANNEL_SPACING_200KHZ
* FM_FREQ_MUL
,
50 .bot_freq
= 87500, /* 87.5 MHz */
51 .top_freq
= 108000, /* 108 MHz */
56 .chanl_space
= FM_CHANNEL_SPACING_200KHZ
* FM_FREQ_MUL
,
57 .bot_freq
= 76000, /* 76 MHz */
58 .top_freq
= 90000, /* 90 MHz */
64 static u8 default_radio_region
; /* Europe/US */
65 module_param(default_radio_region
, byte
, 0);
66 MODULE_PARM_DESC(default_radio_region
, "Region: 0=Europe/US, 1=Japan");
68 /* RDS buffer blocks */
69 static u32 default_rds_buf
= 300;
70 module_param(default_rds_buf
, uint
, 0444);
71 MODULE_PARM_DESC(default_rds_buf
, "RDS buffer entries");
74 static u32 radio_nr
= -1;
75 module_param(radio_nr
, int, 0444);
76 MODULE_PARM_DESC(radio_nr
, "Radio Nr");
78 /* FM irq handlers forward declaration */
79 static void fm_irq_send_flag_getcmd(struct fmdev
*);
80 static void fm_irq_handle_flag_getcmd_resp(struct fmdev
*);
81 static void fm_irq_handle_hw_malfunction(struct fmdev
*);
82 static void fm_irq_handle_rds_start(struct fmdev
*);
83 static void fm_irq_send_rdsdata_getcmd(struct fmdev
*);
84 static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev
*);
85 static void fm_irq_handle_rds_finish(struct fmdev
*);
86 static void fm_irq_handle_tune_op_ended(struct fmdev
*);
87 static void fm_irq_handle_power_enb(struct fmdev
*);
88 static void fm_irq_handle_low_rssi_start(struct fmdev
*);
89 static void fm_irq_afjump_set_pi(struct fmdev
*);
90 static void fm_irq_handle_set_pi_resp(struct fmdev
*);
91 static void fm_irq_afjump_set_pimask(struct fmdev
*);
92 static void fm_irq_handle_set_pimask_resp(struct fmdev
*);
93 static void fm_irq_afjump_setfreq(struct fmdev
*);
94 static void fm_irq_handle_setfreq_resp(struct fmdev
*);
95 static void fm_irq_afjump_enableint(struct fmdev
*);
96 static void fm_irq_afjump_enableint_resp(struct fmdev
*);
97 static void fm_irq_start_afjump(struct fmdev
*);
98 static void fm_irq_handle_start_afjump_resp(struct fmdev
*);
99 static void fm_irq_afjump_rd_freq(struct fmdev
*);
100 static void fm_irq_afjump_rd_freq_resp(struct fmdev
*);
101 static void fm_irq_handle_low_rssi_finish(struct fmdev
*);
102 static void fm_irq_send_intmsk_cmd(struct fmdev
*);
103 static void fm_irq_handle_intmsk_cmd_resp(struct fmdev
*);
106 * When FM common module receives interrupt packet, following handlers
107 * will be executed one after another to service the interrupt(s)
109 enum fmc_irq_handler_index
{
110 FM_SEND_FLAG_GETCMD_IDX
,
111 FM_HANDLE_FLAG_GETCMD_RESP_IDX
,
113 /* HW malfunction irq handler */
116 /* RDS threshold reached irq handler */
118 FM_RDS_SEND_RDS_GETCMD_IDX
,
119 FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX
,
122 /* Tune operation ended irq handler */
123 FM_HW_TUNE_OP_ENDED_IDX
,
125 /* TX power enable irq handler */
128 /* Low RSSI irq handler */
129 FM_LOW_RSSI_START_IDX
,
130 FM_AF_JUMP_SETPI_IDX
,
131 FM_AF_JUMP_HANDLE_SETPI_RESP_IDX
,
132 FM_AF_JUMP_SETPI_MASK_IDX
,
133 FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX
,
134 FM_AF_JUMP_SET_AF_FREQ_IDX
,
135 FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX
,
136 FM_AF_JUMP_ENABLE_INT_IDX
,
137 FM_AF_JUMP_ENABLE_INT_RESP_IDX
,
138 FM_AF_JUMP_START_AFJUMP_IDX
,
139 FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX
,
140 FM_AF_JUMP_RD_FREQ_IDX
,
141 FM_AF_JUMP_RD_FREQ_RESP_IDX
,
142 FM_LOW_RSSI_FINISH_IDX
,
144 /* Interrupt process post action */
145 FM_SEND_INTMSK_CMD_IDX
,
146 FM_HANDLE_INTMSK_CMD_RESP_IDX
,
149 /* FM interrupt handler table */
150 static int_handler_prototype int_handler_table
[] = {
151 fm_irq_send_flag_getcmd
,
152 fm_irq_handle_flag_getcmd_resp
,
153 fm_irq_handle_hw_malfunction
,
154 fm_irq_handle_rds_start
, /* RDS threshold reached irq handler */
155 fm_irq_send_rdsdata_getcmd
,
156 fm_irq_handle_rdsdata_getcmd_resp
,
157 fm_irq_handle_rds_finish
,
158 fm_irq_handle_tune_op_ended
,
159 fm_irq_handle_power_enb
, /* TX power enable irq handler */
160 fm_irq_handle_low_rssi_start
,
161 fm_irq_afjump_set_pi
,
162 fm_irq_handle_set_pi_resp
,
163 fm_irq_afjump_set_pimask
,
164 fm_irq_handle_set_pimask_resp
,
165 fm_irq_afjump_setfreq
,
166 fm_irq_handle_setfreq_resp
,
167 fm_irq_afjump_enableint
,
168 fm_irq_afjump_enableint_resp
,
170 fm_irq_handle_start_afjump_resp
,
171 fm_irq_afjump_rd_freq
,
172 fm_irq_afjump_rd_freq_resp
,
173 fm_irq_handle_low_rssi_finish
,
174 fm_irq_send_intmsk_cmd
, /* Interrupt process post action */
175 fm_irq_handle_intmsk_cmd_resp
178 static long (*g_st_write
) (struct sk_buff
*skb
);
179 static struct completion wait_for_fmdrv_reg_comp
;
181 static inline void fm_irq_call(struct fmdev
*fmdev
)
183 fmdev
->irq_info
.handlers
[fmdev
->irq_info
.stage
](fmdev
);
186 /* Continue next function in interrupt handler table */
187 static inline void fm_irq_call_stage(struct fmdev
*fmdev
, u8 stage
)
189 fmdev
->irq_info
.stage
= stage
;
193 static inline void fm_irq_timeout_stage(struct fmdev
*fmdev
, u8 stage
)
195 fmdev
->irq_info
.stage
= stage
;
196 mod_timer(&fmdev
->irq_info
.timer
, jiffies
+ FM_DRV_TX_TIMEOUT
);
199 #ifdef FM_DUMP_TXRX_PKT
200 /* To dump outgoing FM Channel-8 packets */
201 inline void dump_tx_skb_data(struct sk_buff
*skb
)
205 struct fm_cmd_msg_hdr
*cmd_hdr
;
207 cmd_hdr
= (struct fm_cmd_msg_hdr
*)skb
->data
;
208 printk(KERN_INFO
"<<%shdr:%02x len:%02x opcode:%02x type:%s dlen:%02x",
209 fm_cb(skb
)->completion
? " " : "*", cmd_hdr
->hdr
,
210 cmd_hdr
->len
, cmd_hdr
->op
,
211 cmd_hdr
->rd_wr
? "RD" : "WR", cmd_hdr
->dlen
);
213 len_org
= skb
->len
- FM_CMD_MSG_HDR_SIZE
;
215 printk(KERN_CONT
"\n data(%d): ", cmd_hdr
->dlen
);
216 len
= min(len_org
, 14);
217 for (index
= 0; index
< len
; index
++)
218 printk(KERN_CONT
"%x ",
219 skb
->data
[FM_CMD_MSG_HDR_SIZE
+ index
]);
220 printk(KERN_CONT
"%s", (len_org
> 14) ? ".." : "");
222 printk(KERN_CONT
"\n");
225 /* To dump incoming FM Channel-8 packets */
226 inline void dump_rx_skb_data(struct sk_buff
*skb
)
230 struct fm_event_msg_hdr
*evt_hdr
;
232 evt_hdr
= (struct fm_event_msg_hdr
*)skb
->data
;
233 printk(KERN_INFO
">> hdr:%02x len:%02x sts:%02x numhci:%02x opcode:%02x type:%s dlen:%02x",
234 evt_hdr
->hdr
, evt_hdr
->len
,
235 evt_hdr
->status
, evt_hdr
->num_fm_hci_cmds
, evt_hdr
->op
,
236 (evt_hdr
->rd_wr
) ? "RD" : "WR", evt_hdr
->dlen
);
238 len_org
= skb
->len
- FM_EVT_MSG_HDR_SIZE
;
240 printk(KERN_CONT
"\n data(%d): ", evt_hdr
->dlen
);
241 len
= min(len_org
, 14);
242 for (index
= 0; index
< len
; index
++)
243 printk(KERN_CONT
"%x ",
244 skb
->data
[FM_EVT_MSG_HDR_SIZE
+ index
]);
245 printk(KERN_CONT
"%s", (len_org
> 14) ? ".." : "");
247 printk(KERN_CONT
"\n");
251 void fmc_update_region_info(struct fmdev
*fmdev
, u8 region_to_set
)
253 fmdev
->rx
.region
= region_configs
[region_to_set
];
257 * FM common sub-module will schedule this tasklet whenever it receives
258 * FM packet from ST driver.
260 static void recv_tasklet(unsigned long arg
)
263 struct fm_irq
*irq_info
;
264 struct fm_event_msg_hdr
*evt_hdr
;
269 fmdev
= (struct fmdev
*)arg
;
270 irq_info
= &fmdev
->irq_info
;
271 /* Process all packets in the RX queue */
272 while ((skb
= skb_dequeue(&fmdev
->rx_q
))) {
273 if (skb
->len
< sizeof(struct fm_event_msg_hdr
)) {
274 fmerr("skb(%p) has only %d bytes, at least need %zu bytes to decode\n",
276 skb
->len
, sizeof(struct fm_event_msg_hdr
));
281 evt_hdr
= (void *)skb
->data
;
282 num_fm_hci_cmds
= evt_hdr
->num_fm_hci_cmds
;
284 /* FM interrupt packet? */
285 if (evt_hdr
->op
== FM_INTERRUPT
) {
286 /* FM interrupt handler started already? */
287 if (!test_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
)) {
288 set_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
);
289 if (irq_info
->stage
!= 0) {
290 fmerr("Inval stage resetting to zero\n");
295 * Execute first function in interrupt handler
298 irq_info
->handlers
[irq_info
->stage
](fmdev
);
300 set_bit(FM_INTTASK_SCHEDULE_PENDING
, &fmdev
->flag
);
304 /* Anyone waiting for this with completion handler? */
305 else if (evt_hdr
->op
== fmdev
->pre_op
&& fmdev
->resp_comp
!= NULL
) {
307 spin_lock_irqsave(&fmdev
->resp_skb_lock
, flags
);
308 fmdev
->resp_skb
= skb
;
309 spin_unlock_irqrestore(&fmdev
->resp_skb_lock
, flags
);
310 complete(fmdev
->resp_comp
);
312 fmdev
->resp_comp
= NULL
;
313 atomic_set(&fmdev
->tx_cnt
, 1);
315 /* Is this for interrupt handler? */
316 else if (evt_hdr
->op
== fmdev
->pre_op
&& fmdev
->resp_comp
== NULL
) {
317 if (fmdev
->resp_skb
!= NULL
)
318 fmerr("Response SKB ptr not NULL\n");
320 spin_lock_irqsave(&fmdev
->resp_skb_lock
, flags
);
321 fmdev
->resp_skb
= skb
;
322 spin_unlock_irqrestore(&fmdev
->resp_skb_lock
, flags
);
324 /* Execute interrupt handler where state index points */
325 irq_info
->handlers
[irq_info
->stage
](fmdev
);
328 atomic_set(&fmdev
->tx_cnt
, 1);
330 fmerr("Nobody claimed SKB(%p),purging\n", skb
);
334 * Check flow control field. If Num_FM_HCI_Commands field is
335 * not zero, schedule FM TX tasklet.
337 if (num_fm_hci_cmds
&& atomic_read(&fmdev
->tx_cnt
))
338 if (!skb_queue_empty(&fmdev
->tx_q
))
339 tasklet_schedule(&fmdev
->tx_task
);
343 /* FM send tasklet: is scheduled when FM packet has to be sent to chip */
344 static void send_tasklet(unsigned long arg
)
350 fmdev
= (struct fmdev
*)arg
;
352 if (!atomic_read(&fmdev
->tx_cnt
))
355 /* Check, is there any timeout happened to last transmitted packet */
356 if ((jiffies
- fmdev
->last_tx_jiffies
) > FM_DRV_TX_TIMEOUT
) {
357 fmerr("TX timeout occurred\n");
358 atomic_set(&fmdev
->tx_cnt
, 1);
361 /* Send queued FM TX packets */
362 skb
= skb_dequeue(&fmdev
->tx_q
);
366 atomic_dec(&fmdev
->tx_cnt
);
367 fmdev
->pre_op
= fm_cb(skb
)->fm_op
;
369 if (fmdev
->resp_comp
!= NULL
)
370 fmerr("Response completion handler is not NULL\n");
372 fmdev
->resp_comp
= fm_cb(skb
)->completion
;
374 /* Write FM packet to ST driver */
375 len
= g_st_write(skb
);
378 fmdev
->resp_comp
= NULL
;
379 fmerr("TX tasklet failed to send skb(%p)\n", skb
);
380 atomic_set(&fmdev
->tx_cnt
, 1);
382 fmdev
->last_tx_jiffies
= jiffies
;
387 * Queues FM Channel-8 packet to FM TX queue and schedules FM TX tasklet for
390 static int fm_send_cmd(struct fmdev
*fmdev
, u8 fm_op
, u16 type
, void *payload
,
391 int payload_len
, struct completion
*wait_completion
)
394 struct fm_cmd_msg_hdr
*hdr
;
397 if (fm_op
>= FM_INTERRUPT
) {
398 fmerr("Invalid fm opcode - %d\n", fm_op
);
401 if (test_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
) && payload
== NULL
) {
402 fmerr("Payload data is NULL during fw download\n");
405 if (!test_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
))
407 FM_CMD_MSG_HDR_SIZE
+ ((payload
== NULL
) ? 0 : payload_len
);
411 skb
= alloc_skb(size
, GFP_ATOMIC
);
413 fmerr("No memory to create new SKB\n");
417 * Don't fill FM header info for the commands which come from
420 if (!test_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
) ||
421 test_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
)) {
422 /* Fill command header info */
423 hdr
= (struct fm_cmd_msg_hdr
*)skb_put(skb
, FM_CMD_MSG_HDR_SIZE
);
424 hdr
->hdr
= FM_PKT_LOGICAL_CHAN_NUMBER
; /* 0x08 */
426 /* 3 (fm_opcode,rd_wr,dlen) + payload len) */
427 hdr
->len
= ((payload
== NULL
) ? 0 : payload_len
) + 3;
432 /* read/write type */
434 hdr
->dlen
= payload_len
;
435 fm_cb(skb
)->fm_op
= fm_op
;
438 * If firmware download has finished and the command is
439 * not a read command then payload is != NULL - a write
440 * command with u16 payload - convert to be16
443 *(__be16
*)payload
= cpu_to_be16(*(u16
*)payload
);
445 } else if (payload
!= NULL
) {
446 fm_cb(skb
)->fm_op
= *((u8
*)payload
+ 2);
449 memcpy(skb_put(skb
, payload_len
), payload
, payload_len
);
451 fm_cb(skb
)->completion
= wait_completion
;
452 skb_queue_tail(&fmdev
->tx_q
, skb
);
453 tasklet_schedule(&fmdev
->tx_task
);
458 /* Sends FM Channel-8 command to the chip and waits for the response */
459 int fmc_send_cmd(struct fmdev
*fmdev
, u8 fm_op
, u16 type
, void *payload
,
460 unsigned int payload_len
, void *response
, int *response_len
)
463 struct fm_event_msg_hdr
*evt_hdr
;
467 init_completion(&fmdev
->maintask_comp
);
468 ret
= fm_send_cmd(fmdev
, fm_op
, type
, payload
, payload_len
,
469 &fmdev
->maintask_comp
);
473 if (!wait_for_completion_timeout(&fmdev
->maintask_comp
,
474 FM_DRV_TX_TIMEOUT
)) {
475 fmerr("Timeout(%d sec),didn't get regcompletion signal from RX tasklet\n",
476 jiffies_to_msecs(FM_DRV_TX_TIMEOUT
) / 1000);
479 if (!fmdev
->resp_skb
) {
480 fmerr("Response SKB is missing\n");
483 spin_lock_irqsave(&fmdev
->resp_skb_lock
, flags
);
484 skb
= fmdev
->resp_skb
;
485 fmdev
->resp_skb
= NULL
;
486 spin_unlock_irqrestore(&fmdev
->resp_skb_lock
, flags
);
488 evt_hdr
= (void *)skb
->data
;
489 if (evt_hdr
->status
!= 0) {
490 fmerr("Received event pkt status(%d) is not zero\n",
495 /* Send response data to caller */
496 if (response
!= NULL
&& response_len
!= NULL
&& evt_hdr
->dlen
) {
497 /* Skip header info and copy only response data */
498 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
499 memcpy(response
, skb
->data
, evt_hdr
->dlen
);
500 *response_len
= evt_hdr
->dlen
;
501 } else if (response_len
!= NULL
&& evt_hdr
->dlen
== 0) {
509 /* --- Helper functions used in FM interrupt handlers ---*/
510 static inline int check_cmdresp_status(struct fmdev
*fmdev
,
511 struct sk_buff
**skb
)
513 struct fm_event_msg_hdr
*fm_evt_hdr
;
516 del_timer(&fmdev
->irq_info
.timer
);
518 spin_lock_irqsave(&fmdev
->resp_skb_lock
, flags
);
519 *skb
= fmdev
->resp_skb
;
520 fmdev
->resp_skb
= NULL
;
521 spin_unlock_irqrestore(&fmdev
->resp_skb_lock
, flags
);
523 fm_evt_hdr
= (void *)(*skb
)->data
;
524 if (fm_evt_hdr
->status
!= 0) {
525 fmerr("irq: opcode %x response status is not zero Initiating irq recovery process\n",
528 mod_timer(&fmdev
->irq_info
.timer
, jiffies
+ FM_DRV_TX_TIMEOUT
);
535 static inline void fm_irq_common_cmd_resp_helper(struct fmdev
*fmdev
, u8 stage
)
539 if (!check_cmdresp_status(fmdev
, &skb
))
540 fm_irq_call_stage(fmdev
, stage
);
544 * Interrupt process timeout handler.
545 * One of the irq handler did not get proper response from the chip. So take
546 * recovery action here. FM interrupts are disabled in the beginning of
547 * interrupt process. Therefore reset stage index to re-enable default
548 * interrupts. So that next interrupt will be processed as usual.
550 static void int_timeout_handler(unsigned long data
)
553 struct fm_irq
*fmirq
;
555 fmdbg("irq: timeout,trying to re-enable fm interrupts\n");
556 fmdev
= (struct fmdev
*)data
;
557 fmirq
= &fmdev
->irq_info
;
560 if (fmirq
->retry
> FM_IRQ_TIMEOUT_RETRY_MAX
) {
561 /* Stop recovery action (interrupt reenable process) and
562 * reset stage index & retry count values */
565 fmerr("Recovery action failed duringirq processing, max retry reached\n");
568 fm_irq_call_stage(fmdev
, FM_SEND_INTMSK_CMD_IDX
);
571 /* --------- FM interrupt handlers ------------*/
572 static void fm_irq_send_flag_getcmd(struct fmdev
*fmdev
)
576 /* Send FLAG_GET command , to know the source of interrupt */
577 if (!fm_send_cmd(fmdev
, FLAG_GET
, REG_RD
, NULL
, sizeof(flag
), NULL
))
578 fm_irq_timeout_stage(fmdev
, FM_HANDLE_FLAG_GETCMD_RESP_IDX
);
581 static void fm_irq_handle_flag_getcmd_resp(struct fmdev
*fmdev
)
584 struct fm_event_msg_hdr
*fm_evt_hdr
;
586 if (check_cmdresp_status(fmdev
, &skb
))
589 fm_evt_hdr
= (void *)skb
->data
;
591 /* Skip header info and copy only response data */
592 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
593 memcpy(&fmdev
->irq_info
.flag
, skb
->data
, fm_evt_hdr
->dlen
);
595 fmdev
->irq_info
.flag
= be16_to_cpu((__force __be16
)fmdev
->irq_info
.flag
);
596 fmdbg("irq: flag register(0x%x)\n", fmdev
->irq_info
.flag
);
598 /* Continue next function in interrupt handler table */
599 fm_irq_call_stage(fmdev
, FM_HW_MAL_FUNC_IDX
);
602 static void fm_irq_handle_hw_malfunction(struct fmdev
*fmdev
)
604 if (fmdev
->irq_info
.flag
& FM_MAL_EVENT
& fmdev
->irq_info
.mask
)
605 fmerr("irq: HW MAL int received - do nothing\n");
607 /* Continue next function in interrupt handler table */
608 fm_irq_call_stage(fmdev
, FM_RDS_START_IDX
);
611 static void fm_irq_handle_rds_start(struct fmdev
*fmdev
)
613 if (fmdev
->irq_info
.flag
& FM_RDS_EVENT
& fmdev
->irq_info
.mask
) {
614 fmdbg("irq: rds threshold reached\n");
615 fmdev
->irq_info
.stage
= FM_RDS_SEND_RDS_GETCMD_IDX
;
617 /* Continue next function in interrupt handler table */
618 fmdev
->irq_info
.stage
= FM_HW_TUNE_OP_ENDED_IDX
;
624 static void fm_irq_send_rdsdata_getcmd(struct fmdev
*fmdev
)
626 /* Send the command to read RDS data from the chip */
627 if (!fm_send_cmd(fmdev
, RDS_DATA_GET
, REG_RD
, NULL
,
628 (FM_RX_RDS_FIFO_THRESHOLD
* 3), NULL
))
629 fm_irq_timeout_stage(fmdev
, FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX
);
632 /* Keeps track of current RX channel AF (Alternate Frequency) */
633 static void fm_rx_update_af_cache(struct fmdev
*fmdev
, u8 af
)
635 struct tuned_station_info
*stat_info
= &fmdev
->rx
.stat_info
;
636 u8 reg_idx
= fmdev
->rx
.region
.fm_band
;
640 /* First AF indicates the number of AF follows. Reset the list */
641 if ((af
>= FM_RDS_1_AF_FOLLOWS
) && (af
<= FM_RDS_25_AF_FOLLOWS
)) {
642 fmdev
->rx
.stat_info
.af_list_max
= (af
- FM_RDS_1_AF_FOLLOWS
+ 1);
643 fmdev
->rx
.stat_info
.afcache_size
= 0;
644 fmdbg("No of expected AF : %d\n", fmdev
->rx
.stat_info
.af_list_max
);
648 if (af
< FM_RDS_MIN_AF
)
650 if (reg_idx
== FM_BAND_EUROPE_US
&& af
> FM_RDS_MAX_AF
)
652 if (reg_idx
== FM_BAND_JAPAN
&& af
> FM_RDS_MAX_AF_JAPAN
)
655 freq
= fmdev
->rx
.region
.bot_freq
+ (af
* 100);
656 if (freq
== fmdev
->rx
.freq
) {
657 fmdbg("Current freq(%d) is matching with received AF(%d)\n",
658 fmdev
->rx
.freq
, freq
);
661 /* Do check in AF cache */
662 for (index
= 0; index
< stat_info
->afcache_size
; index
++) {
663 if (stat_info
->af_cache
[index
] == freq
)
666 /* Reached the limit of the list - ignore the next AF */
667 if (index
== stat_info
->af_list_max
) {
668 fmdbg("AF cache is full\n");
672 * If we reached the end of the list then this AF is not
673 * in the list - add it.
675 if (index
== stat_info
->afcache_size
) {
676 fmdbg("Storing AF %d to cache index %d\n", freq
, index
);
677 stat_info
->af_cache
[index
] = freq
;
678 stat_info
->afcache_size
++;
683 * Converts RDS buffer data from big endian format
684 * to little endian format.
686 static void fm_rdsparse_swapbytes(struct fmdev
*fmdev
,
687 struct fm_rdsdata_format
*rds_format
)
693 * Since in Orca the 2 RDS Data bytes are in little endian and
694 * in Dolphin they are in big endian, the parsing of the RDS data
697 if (fmdev
->asci_id
!= 0x6350) {
698 rds_buff
= &rds_format
->data
.groupdatabuff
.buff
[0];
699 while (index
+ 1 < FM_RX_RDS_INFO_FIELD_MAX
) {
700 swap(rds_buff
[index
], rds_buff
[index
+ 1]);
706 static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev
*fmdev
)
709 struct fm_rdsdata_format rds_fmt
;
710 struct fm_rds
*rds
= &fmdev
->rx
.rds
;
711 unsigned long group_idx
, flags
;
712 u8
*rds_data
, meta_data
, tmpbuf
[FM_RDS_BLK_SIZE
];
717 if (check_cmdresp_status(fmdev
, &skb
))
720 /* Skip header info */
721 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
722 rds_data
= skb
->data
;
725 /* Parse the RDS data */
726 while (rds_len
>= FM_RDS_BLK_SIZE
) {
727 meta_data
= rds_data
[2];
728 /* Get the type: 0=A, 1=B, 2=C, 3=C', 4=D, 5=E */
729 type
= (meta_data
& 0x07);
731 /* Transform the blk type into index sequence (0, 1, 2, 3, 4) */
732 blk_idx
= (type
<= FM_RDS_BLOCK_C
? type
: (type
- 1));
733 fmdbg("Block index:%d(%s)\n", blk_idx
,
734 (meta_data
& FM_RDS_STATUS_ERR_MASK
) ? "Bad" : "Ok");
736 if ((meta_data
& FM_RDS_STATUS_ERR_MASK
) != 0)
739 if (blk_idx
> FM_RDS_BLK_IDX_D
) {
740 fmdbg("Block sequence mismatch\n");
741 rds
->last_blk_idx
= -1;
745 /* Skip checkword (control) byte and copy only data byte */
746 memcpy(&rds_fmt
.data
.groupdatabuff
.
747 buff
[blk_idx
* (FM_RDS_BLK_SIZE
- 1)],
748 rds_data
, (FM_RDS_BLK_SIZE
- 1));
750 rds
->last_blk_idx
= blk_idx
;
752 /* If completed a whole group then handle it */
753 if (blk_idx
== FM_RDS_BLK_IDX_D
) {
754 fmdbg("Good block received\n");
755 fm_rdsparse_swapbytes(fmdev
, &rds_fmt
);
758 * Extract PI code and store in local cache.
759 * We need this during AF switch processing.
761 cur_picode
= be16_to_cpu((__force __be16
)rds_fmt
.data
.groupgeneral
.pidata
);
762 if (fmdev
->rx
.stat_info
.picode
!= cur_picode
)
763 fmdev
->rx
.stat_info
.picode
= cur_picode
;
765 fmdbg("picode:%d\n", cur_picode
);
767 group_idx
= (rds_fmt
.data
.groupgeneral
.blk_b
[0] >> 3);
768 fmdbg("(fmdrv):Group:%ld%s\n", group_idx
/2,
769 (group_idx
% 2) ? "B" : "A");
771 group_idx
= 1 << (rds_fmt
.data
.groupgeneral
.blk_b
[0] >> 3);
772 if (group_idx
== FM_RDS_GROUP_TYPE_MASK_0A
) {
773 fm_rx_update_af_cache(fmdev
, rds_fmt
.data
.group0A
.af
[0]);
774 fm_rx_update_af_cache(fmdev
, rds_fmt
.data
.group0A
.af
[1]);
777 rds_len
-= FM_RDS_BLK_SIZE
;
778 rds_data
+= FM_RDS_BLK_SIZE
;
781 /* Copy raw rds data to internal rds buffer */
782 rds_data
= skb
->data
;
785 spin_lock_irqsave(&fmdev
->rds_buff_lock
, flags
);
786 while (rds_len
> 0) {
788 * Fill RDS buffer as per V4L2 specification.
791 type
= (rds_data
[2] & 0x07);
792 blk_idx
= (type
<= FM_RDS_BLOCK_C
? type
: (type
- 1));
793 tmpbuf
[2] = blk_idx
; /* Offset name */
794 tmpbuf
[2] |= blk_idx
<< 3; /* Received offset */
796 /* Store data byte */
797 tmpbuf
[0] = rds_data
[0];
798 tmpbuf
[1] = rds_data
[1];
800 memcpy(&rds
->buff
[rds
->wr_idx
], &tmpbuf
, FM_RDS_BLK_SIZE
);
801 rds
->wr_idx
= (rds
->wr_idx
+ FM_RDS_BLK_SIZE
) % rds
->buf_size
;
803 /* Check for overflow & start over */
804 if (rds
->wr_idx
== rds
->rd_idx
) {
805 fmdbg("RDS buffer overflow\n");
810 rds_len
-= FM_RDS_BLK_SIZE
;
811 rds_data
+= FM_RDS_BLK_SIZE
;
813 spin_unlock_irqrestore(&fmdev
->rds_buff_lock
, flags
);
815 /* Wakeup read queue */
816 if (rds
->wr_idx
!= rds
->rd_idx
)
817 wake_up_interruptible(&rds
->read_queue
);
819 fm_irq_call_stage(fmdev
, FM_RDS_FINISH_IDX
);
822 static void fm_irq_handle_rds_finish(struct fmdev
*fmdev
)
824 fm_irq_call_stage(fmdev
, FM_HW_TUNE_OP_ENDED_IDX
);
827 static void fm_irq_handle_tune_op_ended(struct fmdev
*fmdev
)
829 if (fmdev
->irq_info
.flag
& (FM_FR_EVENT
| FM_BL_EVENT
) & fmdev
->
831 fmdbg("irq: tune ended/bandlimit reached\n");
832 if (test_and_clear_bit(FM_AF_SWITCH_INPROGRESS
, &fmdev
->flag
)) {
833 fmdev
->irq_info
.stage
= FM_AF_JUMP_RD_FREQ_IDX
;
835 complete(&fmdev
->maintask_comp
);
836 fmdev
->irq_info
.stage
= FM_HW_POWER_ENB_IDX
;
839 fmdev
->irq_info
.stage
= FM_HW_POWER_ENB_IDX
;
844 static void fm_irq_handle_power_enb(struct fmdev
*fmdev
)
846 if (fmdev
->irq_info
.flag
& FM_POW_ENB_EVENT
) {
847 fmdbg("irq: Power Enabled/Disabled\n");
848 complete(&fmdev
->maintask_comp
);
851 fm_irq_call_stage(fmdev
, FM_LOW_RSSI_START_IDX
);
854 static void fm_irq_handle_low_rssi_start(struct fmdev
*fmdev
)
856 if ((fmdev
->rx
.af_mode
== FM_RX_RDS_AF_SWITCH_MODE_ON
) &&
857 (fmdev
->irq_info
.flag
& FM_LEV_EVENT
& fmdev
->irq_info
.mask
) &&
858 (fmdev
->rx
.freq
!= FM_UNDEFINED_FREQ
) &&
859 (fmdev
->rx
.stat_info
.afcache_size
!= 0)) {
860 fmdbg("irq: rssi level has fallen below threshold level\n");
862 /* Disable further low RSSI interrupts */
863 fmdev
->irq_info
.mask
&= ~FM_LEV_EVENT
;
865 fmdev
->rx
.afjump_idx
= 0;
866 fmdev
->rx
.freq_before_jump
= fmdev
->rx
.freq
;
867 fmdev
->irq_info
.stage
= FM_AF_JUMP_SETPI_IDX
;
869 /* Continue next function in interrupt handler table */
870 fmdev
->irq_info
.stage
= FM_SEND_INTMSK_CMD_IDX
;
876 static void fm_irq_afjump_set_pi(struct fmdev
*fmdev
)
880 /* Set PI code - must be updated if the AF list is not empty */
881 payload
= fmdev
->rx
.stat_info
.picode
;
882 if (!fm_send_cmd(fmdev
, RDS_PI_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
883 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_SETPI_RESP_IDX
);
886 static void fm_irq_handle_set_pi_resp(struct fmdev
*fmdev
)
888 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_SETPI_MASK_IDX
);
893 * 0xFFFF = Enable PI code matching
894 * 0x0000 = Disable PI code matching
896 static void fm_irq_afjump_set_pimask(struct fmdev
*fmdev
)
901 if (!fm_send_cmd(fmdev
, RDS_PI_MASK_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
902 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX
);
905 static void fm_irq_handle_set_pimask_resp(struct fmdev
*fmdev
)
907 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_SET_AF_FREQ_IDX
);
910 static void fm_irq_afjump_setfreq(struct fmdev
*fmdev
)
915 fmdbg("Swtich to %d KHz\n", fmdev
->rx
.stat_info
.af_cache
[fmdev
->rx
.afjump_idx
]);
916 frq_index
= (fmdev
->rx
.stat_info
.af_cache
[fmdev
->rx
.afjump_idx
] -
917 fmdev
->rx
.region
.bot_freq
) / FM_FREQ_MUL
;
920 if (!fm_send_cmd(fmdev
, AF_FREQ_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
921 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX
);
924 static void fm_irq_handle_setfreq_resp(struct fmdev
*fmdev
)
926 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_ENABLE_INT_IDX
);
929 static void fm_irq_afjump_enableint(struct fmdev
*fmdev
)
933 /* Enable FR (tuning operation ended) interrupt */
934 payload
= FM_FR_EVENT
;
935 if (!fm_send_cmd(fmdev
, INT_MASK_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
936 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_ENABLE_INT_RESP_IDX
);
939 static void fm_irq_afjump_enableint_resp(struct fmdev
*fmdev
)
941 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_START_AFJUMP_IDX
);
944 static void fm_irq_start_afjump(struct fmdev
*fmdev
)
948 payload
= FM_TUNER_AF_JUMP_MODE
;
949 if (!fm_send_cmd(fmdev
, TUNER_MODE_SET
, REG_WR
, &payload
,
950 sizeof(payload
), NULL
))
951 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX
);
954 static void fm_irq_handle_start_afjump_resp(struct fmdev
*fmdev
)
958 if (check_cmdresp_status(fmdev
, &skb
))
961 fmdev
->irq_info
.stage
= FM_SEND_FLAG_GETCMD_IDX
;
962 set_bit(FM_AF_SWITCH_INPROGRESS
, &fmdev
->flag
);
963 clear_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
);
966 static void fm_irq_afjump_rd_freq(struct fmdev
*fmdev
)
970 if (!fm_send_cmd(fmdev
, FREQ_SET
, REG_RD
, NULL
, sizeof(payload
), NULL
))
971 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_RD_FREQ_RESP_IDX
);
974 static void fm_irq_afjump_rd_freq_resp(struct fmdev
*fmdev
)
978 u32 curr_freq
, jumped_freq
;
980 if (check_cmdresp_status(fmdev
, &skb
))
983 /* Skip header info and copy only response data */
984 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
985 memcpy(&read_freq
, skb
->data
, sizeof(read_freq
));
986 read_freq
= be16_to_cpu((__force __be16
)read_freq
);
987 curr_freq
= fmdev
->rx
.region
.bot_freq
+ ((u32
)read_freq
* FM_FREQ_MUL
);
989 jumped_freq
= fmdev
->rx
.stat_info
.af_cache
[fmdev
->rx
.afjump_idx
];
991 /* If the frequency was changed the jump succeeded */
992 if ((curr_freq
!= fmdev
->rx
.freq_before_jump
) && (curr_freq
== jumped_freq
)) {
993 fmdbg("Successfully switched to alternate freq %d\n", curr_freq
);
994 fmdev
->rx
.freq
= curr_freq
;
995 fm_rx_reset_rds_cache(fmdev
);
997 /* AF feature is on, enable low level RSSI interrupt */
998 if (fmdev
->rx
.af_mode
== FM_RX_RDS_AF_SWITCH_MODE_ON
)
999 fmdev
->irq_info
.mask
|= FM_LEV_EVENT
;
1001 fmdev
->irq_info
.stage
= FM_LOW_RSSI_FINISH_IDX
;
1002 } else { /* jump to the next freq in the AF list */
1003 fmdev
->rx
.afjump_idx
++;
1005 /* If we reached the end of the list - stop searching */
1006 if (fmdev
->rx
.afjump_idx
>= fmdev
->rx
.stat_info
.afcache_size
) {
1007 fmdbg("AF switch processing failed\n");
1008 fmdev
->irq_info
.stage
= FM_LOW_RSSI_FINISH_IDX
;
1009 } else { /* AF List is not over - try next one */
1011 fmdbg("Trying next freq in AF cache\n");
1012 fmdev
->irq_info
.stage
= FM_AF_JUMP_SETPI_IDX
;
1018 static void fm_irq_handle_low_rssi_finish(struct fmdev
*fmdev
)
1020 fm_irq_call_stage(fmdev
, FM_SEND_INTMSK_CMD_IDX
);
1023 static void fm_irq_send_intmsk_cmd(struct fmdev
*fmdev
)
1027 /* Re-enable FM interrupts */
1028 payload
= fmdev
->irq_info
.mask
;
1030 if (!fm_send_cmd(fmdev
, INT_MASK_SET
, REG_WR
, &payload
,
1031 sizeof(payload
), NULL
))
1032 fm_irq_timeout_stage(fmdev
, FM_HANDLE_INTMSK_CMD_RESP_IDX
);
1035 static void fm_irq_handle_intmsk_cmd_resp(struct fmdev
*fmdev
)
1037 struct sk_buff
*skb
;
1039 if (check_cmdresp_status(fmdev
, &skb
))
1042 * This is last function in interrupt table to be executed.
1043 * So, reset stage index to 0.
1045 fmdev
->irq_info
.stage
= FM_SEND_FLAG_GETCMD_IDX
;
1047 /* Start processing any pending interrupt */
1048 if (test_and_clear_bit(FM_INTTASK_SCHEDULE_PENDING
, &fmdev
->flag
))
1049 fmdev
->irq_info
.handlers
[fmdev
->irq_info
.stage
](fmdev
);
1051 clear_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
);
1054 /* Returns availability of RDS data in internel buffer */
1055 int fmc_is_rds_data_available(struct fmdev
*fmdev
, struct file
*file
,
1056 struct poll_table_struct
*pts
)
1058 poll_wait(file
, &fmdev
->rx
.rds
.read_queue
, pts
);
1059 if (fmdev
->rx
.rds
.rd_idx
!= fmdev
->rx
.rds
.wr_idx
)
1065 /* Copies RDS data from internal buffer to user buffer */
1066 int fmc_transfer_rds_from_internal_buff(struct fmdev
*fmdev
, struct file
*file
,
1067 u8 __user
*buf
, size_t count
)
1070 u8 tmpbuf
[FM_RDS_BLK_SIZE
];
1071 unsigned long flags
;
1074 if (fmdev
->rx
.rds
.wr_idx
== fmdev
->rx
.rds
.rd_idx
) {
1075 if (file
->f_flags
& O_NONBLOCK
)
1076 return -EWOULDBLOCK
;
1078 ret
= wait_event_interruptible(fmdev
->rx
.rds
.read_queue
,
1079 (fmdev
->rx
.rds
.wr_idx
!= fmdev
->rx
.rds
.rd_idx
));
1084 /* Calculate block count from byte count */
1085 count
/= FM_RDS_BLK_SIZE
;
1089 while (block_count
< count
) {
1090 spin_lock_irqsave(&fmdev
->rds_buff_lock
, flags
);
1092 if (fmdev
->rx
.rds
.wr_idx
== fmdev
->rx
.rds
.rd_idx
) {
1093 spin_unlock_irqrestore(&fmdev
->rds_buff_lock
, flags
);
1096 memcpy(tmpbuf
, &fmdev
->rx
.rds
.buff
[fmdev
->rx
.rds
.rd_idx
],
1098 fmdev
->rx
.rds
.rd_idx
+= FM_RDS_BLK_SIZE
;
1099 if (fmdev
->rx
.rds
.rd_idx
>= fmdev
->rx
.rds
.buf_size
)
1100 fmdev
->rx
.rds
.rd_idx
= 0;
1102 spin_unlock_irqrestore(&fmdev
->rds_buff_lock
, flags
);
1104 if (copy_to_user(buf
, tmpbuf
, FM_RDS_BLK_SIZE
))
1108 buf
+= FM_RDS_BLK_SIZE
;
1109 ret
+= FM_RDS_BLK_SIZE
;
1114 int fmc_set_freq(struct fmdev
*fmdev
, u32 freq_to_set
)
1116 switch (fmdev
->curr_fmmode
) {
1118 return fm_rx_set_freq(fmdev
, freq_to_set
);
1121 return fm_tx_set_freq(fmdev
, freq_to_set
);
1128 int fmc_get_freq(struct fmdev
*fmdev
, u32
*cur_tuned_frq
)
1130 if (fmdev
->rx
.freq
== FM_UNDEFINED_FREQ
) {
1131 fmerr("RX frequency is not set\n");
1134 if (cur_tuned_frq
== NULL
) {
1135 fmerr("Invalid memory\n");
1139 switch (fmdev
->curr_fmmode
) {
1141 *cur_tuned_frq
= fmdev
->rx
.freq
;
1145 *cur_tuned_frq
= 0; /* TODO : Change this later */
1154 int fmc_set_region(struct fmdev
*fmdev
, u8 region_to_set
)
1156 switch (fmdev
->curr_fmmode
) {
1158 return fm_rx_set_region(fmdev
, region_to_set
);
1161 return fm_tx_set_region(fmdev
, region_to_set
);
1168 int fmc_set_mute_mode(struct fmdev
*fmdev
, u8 mute_mode_toset
)
1170 switch (fmdev
->curr_fmmode
) {
1172 return fm_rx_set_mute_mode(fmdev
, mute_mode_toset
);
1175 return fm_tx_set_mute_mode(fmdev
, mute_mode_toset
);
1182 int fmc_set_stereo_mono(struct fmdev
*fmdev
, u16 mode
)
1184 switch (fmdev
->curr_fmmode
) {
1186 return fm_rx_set_stereo_mono(fmdev
, mode
);
1189 return fm_tx_set_stereo_mono(fmdev
, mode
);
1196 int fmc_set_rds_mode(struct fmdev
*fmdev
, u8 rds_en_dis
)
1198 switch (fmdev
->curr_fmmode
) {
1200 return fm_rx_set_rds_mode(fmdev
, rds_en_dis
);
1203 return fm_tx_set_rds_mode(fmdev
, rds_en_dis
);
1210 /* Sends power off command to the chip */
1211 static int fm_power_down(struct fmdev
*fmdev
)
1216 if (!test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1217 fmerr("FM core is not ready\n");
1220 if (fmdev
->curr_fmmode
== FM_MODE_OFF
) {
1221 fmdbg("FM chip is already in OFF state\n");
1226 ret
= fmc_send_cmd(fmdev
, FM_POWER_MODE
, REG_WR
, &payload
,
1227 sizeof(payload
), NULL
, NULL
);
1231 return fmc_release(fmdev
);
1234 /* Reads init command from FM firmware file and loads to the chip */
1235 static int fm_download_firmware(struct fmdev
*fmdev
, const u8
*fw_name
)
1237 const struct firmware
*fw_entry
;
1238 struct bts_header
*fw_header
;
1239 struct bts_action
*action
;
1240 struct bts_action_delay
*delay
;
1242 int ret
, fw_len
, cmd_cnt
;
1245 set_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
);
1247 ret
= request_firmware(&fw_entry
, fw_name
,
1248 &fmdev
->radio_dev
->dev
);
1250 fmerr("Unable to read firmware(%s) content\n", fw_name
);
1253 fmdbg("Firmware(%s) length : %zu bytes\n", fw_name
, fw_entry
->size
);
1255 fw_data
= (void *)fw_entry
->data
;
1256 fw_len
= fw_entry
->size
;
1258 fw_header
= (struct bts_header
*)fw_data
;
1259 if (fw_header
->magic
!= FM_FW_FILE_HEADER_MAGIC
) {
1260 fmerr("%s not a legal TI firmware file\n", fw_name
);
1264 fmdbg("FW(%s) magic number : 0x%x\n", fw_name
, fw_header
->magic
);
1266 /* Skip file header info , we already verified it */
1267 fw_data
+= sizeof(struct bts_header
);
1268 fw_len
-= sizeof(struct bts_header
);
1270 while (fw_data
&& fw_len
> 0) {
1271 action
= (struct bts_action
*)fw_data
;
1273 switch (action
->type
) {
1274 case ACTION_SEND_COMMAND
: /* Send */
1275 if (fmc_send_cmd(fmdev
, 0, 0, action
->data
,
1276 action
->size
, NULL
, NULL
))
1282 case ACTION_DELAY
: /* Delay */
1283 delay
= (struct bts_action_delay
*)action
->data
;
1284 mdelay(delay
->msec
);
1288 fw_data
+= (sizeof(struct bts_action
) + (action
->size
));
1289 fw_len
-= (sizeof(struct bts_action
) + (action
->size
));
1291 fmdbg("Firmware commands(%d) loaded to chip\n", cmd_cnt
);
1293 release_firmware(fw_entry
);
1294 clear_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
);
1299 /* Loads default RX configuration to the chip */
1300 static int load_default_rx_configuration(struct fmdev
*fmdev
)
1304 ret
= fm_rx_set_volume(fmdev
, FM_DEFAULT_RX_VOLUME
);
1308 return fm_rx_set_rssi_threshold(fmdev
, FM_DEFAULT_RSSI_THRESHOLD
);
1311 /* Does FM power on sequence */
1312 static int fm_power_up(struct fmdev
*fmdev
, u8 mode
)
1315 __be16 asic_id
, asic_ver
;
1319 if (mode
>= FM_MODE_ENTRY_MAX
) {
1320 fmerr("Invalid firmware download option\n");
1325 * Initialize FM common module. FM GPIO toggling is
1326 * taken care in Shared Transport driver.
1328 ret
= fmc_prepare(fmdev
);
1330 fmerr("Unable to prepare FM Common\n");
1334 payload
= FM_ENABLE
;
1335 if (fmc_send_cmd(fmdev
, FM_POWER_MODE
, REG_WR
, &payload
,
1336 sizeof(payload
), NULL
, NULL
))
1339 /* Allow the chip to settle down in Channel-8 mode */
1342 if (fmc_send_cmd(fmdev
, ASIC_ID_GET
, REG_RD
, NULL
,
1343 sizeof(asic_id
), &asic_id
, &resp_len
))
1346 if (fmc_send_cmd(fmdev
, ASIC_VER_GET
, REG_RD
, NULL
,
1347 sizeof(asic_ver
), &asic_ver
, &resp_len
))
1350 fmdbg("ASIC ID: 0x%x , ASIC Version: %d\n",
1351 be16_to_cpu(asic_id
), be16_to_cpu(asic_ver
));
1353 sprintf(fw_name
, "%s_%x.%d.bts", FM_FMC_FW_FILE_START
,
1354 be16_to_cpu(asic_id
), be16_to_cpu(asic_ver
));
1356 ret
= fm_download_firmware(fmdev
, fw_name
);
1358 fmdbg("Failed to download firmware file %s\n", fw_name
);
1361 sprintf(fw_name
, "%s_%x.%d.bts", (mode
== FM_MODE_RX
) ?
1362 FM_RX_FW_FILE_START
: FM_TX_FW_FILE_START
,
1363 be16_to_cpu(asic_id
), be16_to_cpu(asic_ver
));
1365 ret
= fm_download_firmware(fmdev
, fw_name
);
1367 fmdbg("Failed to download firmware file %s\n", fw_name
);
1372 return fmc_release(fmdev
);
1375 /* Set FM Modes(TX, RX, OFF) */
1376 int fmc_set_mode(struct fmdev
*fmdev
, u8 fm_mode
)
1380 if (fm_mode
>= FM_MODE_ENTRY_MAX
) {
1381 fmerr("Invalid FM mode\n");
1384 if (fmdev
->curr_fmmode
== fm_mode
) {
1385 fmdbg("Already fm is in mode(%d)\n", fm_mode
);
1390 case FM_MODE_OFF
: /* OFF Mode */
1391 ret
= fm_power_down(fmdev
);
1393 fmerr("Failed to set OFF mode\n");
1398 case FM_MODE_TX
: /* TX Mode */
1399 case FM_MODE_RX
: /* RX Mode */
1400 /* Power down before switching to TX or RX mode */
1401 if (fmdev
->curr_fmmode
!= FM_MODE_OFF
) {
1402 ret
= fm_power_down(fmdev
);
1404 fmerr("Failed to set OFF mode\n");
1409 ret
= fm_power_up(fmdev
, fm_mode
);
1411 fmerr("Failed to load firmware\n");
1415 fmdev
->curr_fmmode
= fm_mode
;
1417 /* Set default configuration */
1418 if (fmdev
->curr_fmmode
== FM_MODE_RX
) {
1419 fmdbg("Loading default rx configuration..\n");
1420 ret
= load_default_rx_configuration(fmdev
);
1422 fmerr("Failed to load default values\n");
1428 /* Returns current FM mode (TX, RX, OFF) */
1429 int fmc_get_mode(struct fmdev
*fmdev
, u8
*fmmode
)
1431 if (!test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1432 fmerr("FM core is not ready\n");
1435 if (fmmode
== NULL
) {
1436 fmerr("Invalid memory\n");
1440 *fmmode
= fmdev
->curr_fmmode
;
1444 /* Called by ST layer when FM packet is available */
1445 static long fm_st_receive(void *arg
, struct sk_buff
*skb
)
1447 struct fmdev
*fmdev
;
1449 fmdev
= (struct fmdev
*)arg
;
1452 fmerr("Invalid SKB received from ST\n");
1456 if (skb
->cb
[0] != FM_PKT_LOGICAL_CHAN_NUMBER
) {
1457 fmerr("Received SKB (%p) is not FM Channel 8 pkt\n", skb
);
1461 memcpy(skb_push(skb
, 1), &skb
->cb
[0], 1);
1462 skb_queue_tail(&fmdev
->rx_q
, skb
);
1463 tasklet_schedule(&fmdev
->rx_task
);
1469 * Called by ST layer to indicate protocol registration completion
1472 static void fm_st_reg_comp_cb(void *arg
, int data
)
1474 struct fmdev
*fmdev
;
1476 fmdev
= (struct fmdev
*)arg
;
1477 fmdev
->streg_cbdata
= data
;
1478 complete(&wait_for_fmdrv_reg_comp
);
1482 * This function will be called from FM V4L2 open function.
1483 * Register with ST driver and initialize driver data.
1485 int fmc_prepare(struct fmdev
*fmdev
)
1487 static struct st_proto_s fm_st_proto
;
1490 if (test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1491 fmdbg("FM Core is already up\n");
1495 memset(&fm_st_proto
, 0, sizeof(fm_st_proto
));
1496 fm_st_proto
.recv
= fm_st_receive
;
1497 fm_st_proto
.match_packet
= NULL
;
1498 fm_st_proto
.reg_complete_cb
= fm_st_reg_comp_cb
;
1499 fm_st_proto
.write
= NULL
; /* TI ST driver will fill write pointer */
1500 fm_st_proto
.priv_data
= fmdev
;
1501 fm_st_proto
.chnl_id
= 0x08;
1502 fm_st_proto
.max_frame_size
= 0xff;
1503 fm_st_proto
.hdr_len
= 1;
1504 fm_st_proto
.offset_len_in_hdr
= 0;
1505 fm_st_proto
.len_size
= 1;
1506 fm_st_proto
.reserve
= 1;
1508 ret
= st_register(&fm_st_proto
);
1509 if (ret
== -EINPROGRESS
) {
1510 init_completion(&wait_for_fmdrv_reg_comp
);
1511 fmdev
->streg_cbdata
= -EINPROGRESS
;
1512 fmdbg("%s waiting for ST reg completion signal\n", __func__
);
1514 if (!wait_for_completion_timeout(&wait_for_fmdrv_reg_comp
,
1515 FM_ST_REG_TIMEOUT
)) {
1516 fmerr("Timeout(%d sec), didn't get reg completion signal from ST\n",
1517 jiffies_to_msecs(FM_ST_REG_TIMEOUT
) / 1000);
1520 if (fmdev
->streg_cbdata
!= 0) {
1521 fmerr("ST reg comp CB called with error status %d\n",
1522 fmdev
->streg_cbdata
);
1527 } else if (ret
== -1) {
1528 fmerr("st_register failed %d\n", ret
);
1532 if (fm_st_proto
.write
!= NULL
) {
1533 g_st_write
= fm_st_proto
.write
;
1535 fmerr("Failed to get ST write func pointer\n");
1536 ret
= st_unregister(&fm_st_proto
);
1538 fmerr("st_unregister failed %d\n", ret
);
1542 spin_lock_init(&fmdev
->rds_buff_lock
);
1543 spin_lock_init(&fmdev
->resp_skb_lock
);
1545 /* Initialize TX queue and TX tasklet */
1546 skb_queue_head_init(&fmdev
->tx_q
);
1547 tasklet_init(&fmdev
->tx_task
, send_tasklet
, (unsigned long)fmdev
);
1549 /* Initialize RX Queue and RX tasklet */
1550 skb_queue_head_init(&fmdev
->rx_q
);
1551 tasklet_init(&fmdev
->rx_task
, recv_tasklet
, (unsigned long)fmdev
);
1553 fmdev
->irq_info
.stage
= 0;
1554 atomic_set(&fmdev
->tx_cnt
, 1);
1555 fmdev
->resp_comp
= NULL
;
1557 init_timer(&fmdev
->irq_info
.timer
);
1558 fmdev
->irq_info
.timer
.function
= &int_timeout_handler
;
1559 fmdev
->irq_info
.timer
.data
= (unsigned long)fmdev
;
1560 /*TODO: add FM_STIC_EVENT later */
1561 fmdev
->irq_info
.mask
= FM_MAL_EVENT
;
1564 fmdev
->rx
.region
= region_configs
[default_radio_region
];
1566 fmdev
->rx
.mute_mode
= FM_MUTE_OFF
;
1567 fmdev
->rx
.rf_depend_mute
= FM_RX_RF_DEPENDENT_MUTE_OFF
;
1568 fmdev
->rx
.rds
.flag
= FM_RDS_DISABLE
;
1569 fmdev
->rx
.freq
= FM_UNDEFINED_FREQ
;
1570 fmdev
->rx
.rds_mode
= FM_RDS_SYSTEM_RDS
;
1571 fmdev
->rx
.af_mode
= FM_RX_RDS_AF_SWITCH_MODE_OFF
;
1572 fmdev
->irq_info
.retry
= 0;
1574 fm_rx_reset_rds_cache(fmdev
);
1575 init_waitqueue_head(&fmdev
->rx
.rds
.read_queue
);
1577 fm_rx_reset_station_info(fmdev
);
1578 set_bit(FM_CORE_READY
, &fmdev
->flag
);
1584 * This function will be called from FM V4L2 release function.
1585 * Unregister from ST driver.
1587 int fmc_release(struct fmdev
*fmdev
)
1589 static struct st_proto_s fm_st_proto
;
1592 if (!test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1593 fmdbg("FM Core is already down\n");
1596 /* Service pending read */
1597 wake_up_interruptible(&fmdev
->rx
.rds
.read_queue
);
1599 tasklet_kill(&fmdev
->tx_task
);
1600 tasklet_kill(&fmdev
->rx_task
);
1602 skb_queue_purge(&fmdev
->tx_q
);
1603 skb_queue_purge(&fmdev
->rx_q
);
1605 fmdev
->resp_comp
= NULL
;
1608 memset(&fm_st_proto
, 0, sizeof(fm_st_proto
));
1609 fm_st_proto
.chnl_id
= 0x08;
1611 ret
= st_unregister(&fm_st_proto
);
1614 fmerr("Failed to de-register FM from ST %d\n", ret
);
1616 fmdbg("Successfully unregistered from ST\n");
1618 clear_bit(FM_CORE_READY
, &fmdev
->flag
);
1623 * Module init function. Ask FM V4L module to register video device.
1624 * Allocate memory for FM driver context and RX RDS buffer.
1626 static int __init
fm_drv_init(void)
1628 struct fmdev
*fmdev
= NULL
;
1631 fmdbg("FM driver version %s\n", FM_DRV_VERSION
);
1633 fmdev
= kzalloc(sizeof(struct fmdev
), GFP_KERNEL
);
1634 if (NULL
== fmdev
) {
1635 fmerr("Can't allocate operation structure memory\n");
1638 fmdev
->rx
.rds
.buf_size
= default_rds_buf
* FM_RDS_BLK_SIZE
;
1639 fmdev
->rx
.rds
.buff
= kzalloc(fmdev
->rx
.rds
.buf_size
, GFP_KERNEL
);
1640 if (NULL
== fmdev
->rx
.rds
.buff
) {
1641 fmerr("Can't allocate rds ring buffer\n");
1645 ret
= fm_v4l2_init_video_device(fmdev
, radio_nr
);
1649 fmdev
->irq_info
.handlers
= int_handler_table
;
1650 fmdev
->curr_fmmode
= FM_MODE_OFF
;
1651 fmdev
->tx_data
.pwr_lvl
= FM_PWR_LVL_DEF
;
1652 fmdev
->tx_data
.preemph
= FM_TX_PREEMPH_50US
;
1656 kfree(fmdev
->rx
.rds
.buff
);
1663 /* Module exit function. Ask FM V4L module to unregister video device */
1664 static void __exit
fm_drv_exit(void)
1666 struct fmdev
*fmdev
= NULL
;
1668 fmdev
= fm_v4l2_deinit_video_device();
1669 if (fmdev
!= NULL
) {
1670 kfree(fmdev
->rx
.rds
.buff
);
1675 module_init(fm_drv_init
);
1676 module_exit(fm_drv_exit
);
1678 /* ------------- Module Info ------------- */
1679 MODULE_AUTHOR("Manjunatha Halli <manjunatha_halli@ti.com>");
1680 MODULE_DESCRIPTION("FM Driver for TI's Connectivity chip. " FM_DRV_VERSION
);
1681 MODULE_VERSION(FM_DRV_VERSION
);
1682 MODULE_LICENSE("GPL");