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(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 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("\n data(%d): ", cmd_hdr
->dlen
);
216 len
= min(len_org
, 14);
217 for (index
= 0; index
< len
; index
++)
219 skb
->data
[FM_CMD_MSG_HDR_SIZE
+ index
]);
220 printk("%s", (len_org
> 14) ? ".." : "");
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 "
234 "opcode:%02x type:%s dlen:%02x", 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("\n data(%d): ", evt_hdr
->dlen
);
241 len
= min(len_org
, 14);
242 for (index
= 0; index
< len
; index
++)
244 skb
->data
[FM_EVT_MSG_HDR_SIZE
+ index
]);
245 printk("%s", (len_org
> 14) ? ".." : "");
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, "
275 "at least need %zu bytes to decode\n", skb
,
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 *(u16
*)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 reg"
476 "completion signal from RX tasklet\n",
477 jiffies_to_msecs(FM_DRV_TX_TIMEOUT
) / 1000);
480 if (!fmdev
->resp_skb
) {
481 fmerr("Response SKB is missing\n");
484 spin_lock_irqsave(&fmdev
->resp_skb_lock
, flags
);
485 skb
= fmdev
->resp_skb
;
486 fmdev
->resp_skb
= NULL
;
487 spin_unlock_irqrestore(&fmdev
->resp_skb_lock
, flags
);
489 evt_hdr
= (void *)skb
->data
;
490 if (evt_hdr
->status
!= 0) {
491 fmerr("Received event pkt status(%d) is not zero\n",
496 /* Send response data to caller */
497 if (response
!= NULL
&& response_len
!= NULL
&& evt_hdr
->dlen
) {
498 /* Skip header info and copy only response data */
499 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
500 memcpy(response
, skb
->data
, evt_hdr
->dlen
);
501 *response_len
= evt_hdr
->dlen
;
502 } else if (response_len
!= NULL
&& evt_hdr
->dlen
== 0) {
510 /* --- Helper functions used in FM interrupt handlers ---*/
511 static inline int check_cmdresp_status(struct fmdev
*fmdev
,
512 struct sk_buff
**skb
)
514 struct fm_event_msg_hdr
*fm_evt_hdr
;
517 del_timer(&fmdev
->irq_info
.timer
);
519 spin_lock_irqsave(&fmdev
->resp_skb_lock
, flags
);
520 *skb
= fmdev
->resp_skb
;
521 fmdev
->resp_skb
= NULL
;
522 spin_unlock_irqrestore(&fmdev
->resp_skb_lock
, flags
);
524 fm_evt_hdr
= (void *)(*skb
)->data
;
525 if (fm_evt_hdr
->status
!= 0) {
526 fmerr("irq: opcode %x response status is not zero "
527 "Initiating irq recovery process\n",
530 mod_timer(&fmdev
->irq_info
.timer
, jiffies
+ FM_DRV_TX_TIMEOUT
);
537 static inline void fm_irq_common_cmd_resp_helper(struct fmdev
*fmdev
, u8 stage
)
541 if (!check_cmdresp_status(fmdev
, &skb
))
542 fm_irq_call_stage(fmdev
, stage
);
546 * Interrupt process timeout handler.
547 * One of the irq handler did not get proper response from the chip. So take
548 * recovery action here. FM interrupts are disabled in the beginning of
549 * interrupt process. Therefore reset stage index to re-enable default
550 * interrupts. So that next interrupt will be processed as usual.
552 static void int_timeout_handler(unsigned long data
)
555 struct fm_irq
*fmirq
;
557 fmdbg("irq: timeout,trying to re-enable fm interrupts\n");
558 fmdev
= (struct fmdev
*)data
;
559 fmirq
= &fmdev
->irq_info
;
562 if (fmirq
->retry
> FM_IRQ_TIMEOUT_RETRY_MAX
) {
563 /* Stop recovery action (interrupt reenable process) and
564 * reset stage index & retry count values */
567 fmerr("Recovery action failed during"
568 "irq processing, max retry reached\n");
571 fm_irq_call_stage(fmdev
, FM_SEND_INTMSK_CMD_IDX
);
574 /* --------- FM interrupt handlers ------------*/
575 static void fm_irq_send_flag_getcmd(struct fmdev
*fmdev
)
579 /* Send FLAG_GET command , to know the source of interrupt */
580 if (!fm_send_cmd(fmdev
, FLAG_GET
, REG_RD
, NULL
, sizeof(flag
), NULL
))
581 fm_irq_timeout_stage(fmdev
, FM_HANDLE_FLAG_GETCMD_RESP_IDX
);
584 static void fm_irq_handle_flag_getcmd_resp(struct fmdev
*fmdev
)
587 struct fm_event_msg_hdr
*fm_evt_hdr
;
589 if (check_cmdresp_status(fmdev
, &skb
))
592 fm_evt_hdr
= (void *)skb
->data
;
594 /* Skip header info and copy only response data */
595 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
596 memcpy(&fmdev
->irq_info
.flag
, skb
->data
, fm_evt_hdr
->dlen
);
598 fmdev
->irq_info
.flag
= be16_to_cpu(fmdev
->irq_info
.flag
);
599 fmdbg("irq: flag register(0x%x)\n", fmdev
->irq_info
.flag
);
601 /* Continue next function in interrupt handler table */
602 fm_irq_call_stage(fmdev
, FM_HW_MAL_FUNC_IDX
);
605 static void fm_irq_handle_hw_malfunction(struct fmdev
*fmdev
)
607 if (fmdev
->irq_info
.flag
& FM_MAL_EVENT
& fmdev
->irq_info
.mask
)
608 fmerr("irq: HW MAL int received - do nothing\n");
610 /* Continue next function in interrupt handler table */
611 fm_irq_call_stage(fmdev
, FM_RDS_START_IDX
);
614 static void fm_irq_handle_rds_start(struct fmdev
*fmdev
)
616 if (fmdev
->irq_info
.flag
& FM_RDS_EVENT
& fmdev
->irq_info
.mask
) {
617 fmdbg("irq: rds threshold reached\n");
618 fmdev
->irq_info
.stage
= FM_RDS_SEND_RDS_GETCMD_IDX
;
620 /* Continue next function in interrupt handler table */
621 fmdev
->irq_info
.stage
= FM_HW_TUNE_OP_ENDED_IDX
;
627 static void fm_irq_send_rdsdata_getcmd(struct fmdev
*fmdev
)
629 /* Send the command to read RDS data from the chip */
630 if (!fm_send_cmd(fmdev
, RDS_DATA_GET
, REG_RD
, NULL
,
631 (FM_RX_RDS_FIFO_THRESHOLD
* 3), NULL
))
632 fm_irq_timeout_stage(fmdev
, FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX
);
635 /* Keeps track of current RX channel AF (Alternate Frequency) */
636 static void fm_rx_update_af_cache(struct fmdev
*fmdev
, u8 af
)
638 struct tuned_station_info
*stat_info
= &fmdev
->rx
.stat_info
;
639 u8 reg_idx
= fmdev
->rx
.region
.fm_band
;
643 /* First AF indicates the number of AF follows. Reset the list */
644 if ((af
>= FM_RDS_1_AF_FOLLOWS
) && (af
<= FM_RDS_25_AF_FOLLOWS
)) {
645 fmdev
->rx
.stat_info
.af_list_max
= (af
- FM_RDS_1_AF_FOLLOWS
+ 1);
646 fmdev
->rx
.stat_info
.afcache_size
= 0;
647 fmdbg("No of expected AF : %d\n", fmdev
->rx
.stat_info
.af_list_max
);
651 if (af
< FM_RDS_MIN_AF
)
653 if (reg_idx
== FM_BAND_EUROPE_US
&& af
> FM_RDS_MAX_AF
)
655 if (reg_idx
== FM_BAND_JAPAN
&& af
> FM_RDS_MAX_AF_JAPAN
)
658 freq
= fmdev
->rx
.region
.bot_freq
+ (af
* 100);
659 if (freq
== fmdev
->rx
.freq
) {
660 fmdbg("Current freq(%d) is matching with received AF(%d)\n",
661 fmdev
->rx
.freq
, freq
);
664 /* Do check in AF cache */
665 for (index
= 0; index
< stat_info
->afcache_size
; index
++) {
666 if (stat_info
->af_cache
[index
] == freq
)
669 /* Reached the limit of the list - ignore the next AF */
670 if (index
== stat_info
->af_list_max
) {
671 fmdbg("AF cache is full\n");
675 * If we reached the end of the list then this AF is not
676 * in the list - add it.
678 if (index
== stat_info
->afcache_size
) {
679 fmdbg("Storing AF %d to cache index %d\n", freq
, index
);
680 stat_info
->af_cache
[index
] = freq
;
681 stat_info
->afcache_size
++;
686 * Converts RDS buffer data from big endian format
687 * to little endian format.
689 static void fm_rdsparse_swapbytes(struct fmdev
*fmdev
,
690 struct fm_rdsdata_format
*rds_format
)
697 * Since in Orca the 2 RDS Data bytes are in little endian and
698 * in Dolphin they are in big endian, the parsing of the RDS data
701 if (fmdev
->asci_id
!= 0x6350) {
702 rds_buff
= &rds_format
->data
.groupdatabuff
.buff
[0];
703 while (index
+ 1 < FM_RX_RDS_INFO_FIELD_MAX
) {
704 byte1
= rds_buff
[index
];
705 rds_buff
[index
] = rds_buff
[index
+ 1];
706 rds_buff
[index
+ 1] = byte1
;
712 static void fm_irq_handle_rdsdata_getcmd_resp(struct fmdev
*fmdev
)
715 struct fm_rdsdata_format rds_fmt
;
716 struct fm_rds
*rds
= &fmdev
->rx
.rds
;
717 unsigned long group_idx
, flags
;
718 u8
*rds_data
, meta_data
, tmpbuf
[3];
723 if (check_cmdresp_status(fmdev
, &skb
))
726 /* Skip header info */
727 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
728 rds_data
= skb
->data
;
731 /* Parse the RDS data */
732 while (rds_len
>= FM_RDS_BLK_SIZE
) {
733 meta_data
= rds_data
[2];
734 /* Get the type: 0=A, 1=B, 2=C, 3=C', 4=D, 5=E */
735 type
= (meta_data
& 0x07);
737 /* Transform the blk type into index sequence (0, 1, 2, 3, 4) */
738 blk_idx
= (type
<= FM_RDS_BLOCK_C
? type
: (type
- 1));
739 fmdbg("Block index:%d(%s)\n", blk_idx
,
740 (meta_data
& FM_RDS_STATUS_ERR_MASK
) ? "Bad" : "Ok");
742 if ((meta_data
& FM_RDS_STATUS_ERR_MASK
) != 0)
745 if (blk_idx
> FM_RDS_BLK_IDX_D
) {
746 fmdbg("Block sequence mismatch\n");
747 rds
->last_blk_idx
= -1;
751 /* Skip checkword (control) byte and copy only data byte */
752 memcpy(&rds_fmt
.data
.groupdatabuff
.
753 buff
[blk_idx
* (FM_RDS_BLK_SIZE
- 1)],
754 rds_data
, (FM_RDS_BLK_SIZE
- 1));
756 rds
->last_blk_idx
= blk_idx
;
758 /* If completed a whole group then handle it */
759 if (blk_idx
== FM_RDS_BLK_IDX_D
) {
760 fmdbg("Good block received\n");
761 fm_rdsparse_swapbytes(fmdev
, &rds_fmt
);
764 * Extract PI code and store in local cache.
765 * We need this during AF switch processing.
767 cur_picode
= be16_to_cpu(rds_fmt
.data
.groupgeneral
.pidata
);
768 if (fmdev
->rx
.stat_info
.picode
!= cur_picode
)
769 fmdev
->rx
.stat_info
.picode
= cur_picode
;
771 fmdbg("picode:%d\n", cur_picode
);
773 group_idx
= (rds_fmt
.data
.groupgeneral
.blk_b
[0] >> 3);
774 fmdbg("(fmdrv):Group:%ld%s\n", group_idx
/2,
775 (group_idx
% 2) ? "B" : "A");
777 group_idx
= 1 << (rds_fmt
.data
.groupgeneral
.blk_b
[0] >> 3);
778 if (group_idx
== FM_RDS_GROUP_TYPE_MASK_0A
) {
779 fm_rx_update_af_cache(fmdev
, rds_fmt
.data
.group0A
.af
[0]);
780 fm_rx_update_af_cache(fmdev
, rds_fmt
.data
.group0A
.af
[1]);
783 rds_len
-= FM_RDS_BLK_SIZE
;
784 rds_data
+= FM_RDS_BLK_SIZE
;
787 /* Copy raw rds data to internal rds buffer */
788 rds_data
= skb
->data
;
791 spin_lock_irqsave(&fmdev
->rds_buff_lock
, flags
);
792 while (rds_len
> 0) {
794 * Fill RDS buffer as per V4L2 specification.
797 type
= (rds_data
[2] & 0x07);
798 blk_idx
= (type
<= FM_RDS_BLOCK_C
? type
: (type
- 1));
799 tmpbuf
[2] = blk_idx
; /* Offset name */
800 tmpbuf
[2] |= blk_idx
<< 3; /* Received offset */
802 /* Store data byte */
803 tmpbuf
[0] = rds_data
[0];
804 tmpbuf
[1] = rds_data
[1];
806 memcpy(&rds
->buff
[rds
->wr_idx
], &tmpbuf
, FM_RDS_BLK_SIZE
);
807 rds
->wr_idx
= (rds
->wr_idx
+ FM_RDS_BLK_SIZE
) % rds
->buf_size
;
809 /* Check for overflow & start over */
810 if (rds
->wr_idx
== rds
->rd_idx
) {
811 fmdbg("RDS buffer overflow\n");
816 rds_len
-= FM_RDS_BLK_SIZE
;
817 rds_data
+= FM_RDS_BLK_SIZE
;
819 spin_unlock_irqrestore(&fmdev
->rds_buff_lock
, flags
);
821 /* Wakeup read queue */
822 if (rds
->wr_idx
!= rds
->rd_idx
)
823 wake_up_interruptible(&rds
->read_queue
);
825 fm_irq_call_stage(fmdev
, FM_RDS_FINISH_IDX
);
828 static void fm_irq_handle_rds_finish(struct fmdev
*fmdev
)
830 fm_irq_call_stage(fmdev
, FM_HW_TUNE_OP_ENDED_IDX
);
833 static void fm_irq_handle_tune_op_ended(struct fmdev
*fmdev
)
835 if (fmdev
->irq_info
.flag
& (FM_FR_EVENT
| FM_BL_EVENT
) & fmdev
->
837 fmdbg("irq: tune ended/bandlimit reached\n");
838 if (test_and_clear_bit(FM_AF_SWITCH_INPROGRESS
, &fmdev
->flag
)) {
839 fmdev
->irq_info
.stage
= FM_AF_JUMP_RD_FREQ_IDX
;
841 complete(&fmdev
->maintask_comp
);
842 fmdev
->irq_info
.stage
= FM_HW_POWER_ENB_IDX
;
845 fmdev
->irq_info
.stage
= FM_HW_POWER_ENB_IDX
;
850 static void fm_irq_handle_power_enb(struct fmdev
*fmdev
)
852 if (fmdev
->irq_info
.flag
& FM_POW_ENB_EVENT
) {
853 fmdbg("irq: Power Enabled/Disabled\n");
854 complete(&fmdev
->maintask_comp
);
857 fm_irq_call_stage(fmdev
, FM_LOW_RSSI_START_IDX
);
860 static void fm_irq_handle_low_rssi_start(struct fmdev
*fmdev
)
862 if ((fmdev
->rx
.af_mode
== FM_RX_RDS_AF_SWITCH_MODE_ON
) &&
863 (fmdev
->irq_info
.flag
& FM_LEV_EVENT
& fmdev
->irq_info
.mask
) &&
864 (fmdev
->rx
.freq
!= FM_UNDEFINED_FREQ
) &&
865 (fmdev
->rx
.stat_info
.afcache_size
!= 0)) {
866 fmdbg("irq: rssi level has fallen below threshold level\n");
868 /* Disable further low RSSI interrupts */
869 fmdev
->irq_info
.mask
&= ~FM_LEV_EVENT
;
871 fmdev
->rx
.afjump_idx
= 0;
872 fmdev
->rx
.freq_before_jump
= fmdev
->rx
.freq
;
873 fmdev
->irq_info
.stage
= FM_AF_JUMP_SETPI_IDX
;
875 /* Continue next function in interrupt handler table */
876 fmdev
->irq_info
.stage
= FM_SEND_INTMSK_CMD_IDX
;
882 static void fm_irq_afjump_set_pi(struct fmdev
*fmdev
)
886 /* Set PI code - must be updated if the AF list is not empty */
887 payload
= fmdev
->rx
.stat_info
.picode
;
888 if (!fm_send_cmd(fmdev
, RDS_PI_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
889 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_SETPI_RESP_IDX
);
892 static void fm_irq_handle_set_pi_resp(struct fmdev
*fmdev
)
894 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_SETPI_MASK_IDX
);
899 * 0xFFFF = Enable PI code matching
900 * 0x0000 = Disable PI code matching
902 static void fm_irq_afjump_set_pimask(struct fmdev
*fmdev
)
907 if (!fm_send_cmd(fmdev
, RDS_PI_MASK_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
908 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX
);
911 static void fm_irq_handle_set_pimask_resp(struct fmdev
*fmdev
)
913 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_SET_AF_FREQ_IDX
);
916 static void fm_irq_afjump_setfreq(struct fmdev
*fmdev
)
921 fmdbg("Swtich to %d KHz\n", fmdev
->rx
.stat_info
.af_cache
[fmdev
->rx
.afjump_idx
]);
922 frq_index
= (fmdev
->rx
.stat_info
.af_cache
[fmdev
->rx
.afjump_idx
] -
923 fmdev
->rx
.region
.bot_freq
) / FM_FREQ_MUL
;
926 if (!fm_send_cmd(fmdev
, AF_FREQ_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
927 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX
);
930 static void fm_irq_handle_setfreq_resp(struct fmdev
*fmdev
)
932 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_ENABLE_INT_IDX
);
935 static void fm_irq_afjump_enableint(struct fmdev
*fmdev
)
939 /* Enable FR (tuning operation ended) interrupt */
940 payload
= FM_FR_EVENT
;
941 if (!fm_send_cmd(fmdev
, INT_MASK_SET
, REG_WR
, &payload
, sizeof(payload
), NULL
))
942 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_ENABLE_INT_RESP_IDX
);
945 static void fm_irq_afjump_enableint_resp(struct fmdev
*fmdev
)
947 fm_irq_common_cmd_resp_helper(fmdev
, FM_AF_JUMP_START_AFJUMP_IDX
);
950 static void fm_irq_start_afjump(struct fmdev
*fmdev
)
954 payload
= FM_TUNER_AF_JUMP_MODE
;
955 if (!fm_send_cmd(fmdev
, TUNER_MODE_SET
, REG_WR
, &payload
,
956 sizeof(payload
), NULL
))
957 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX
);
960 static void fm_irq_handle_start_afjump_resp(struct fmdev
*fmdev
)
964 if (check_cmdresp_status(fmdev
, &skb
))
967 fmdev
->irq_info
.stage
= FM_SEND_FLAG_GETCMD_IDX
;
968 set_bit(FM_AF_SWITCH_INPROGRESS
, &fmdev
->flag
);
969 clear_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
);
972 static void fm_irq_afjump_rd_freq(struct fmdev
*fmdev
)
976 if (!fm_send_cmd(fmdev
, FREQ_SET
, REG_RD
, NULL
, sizeof(payload
), NULL
))
977 fm_irq_timeout_stage(fmdev
, FM_AF_JUMP_RD_FREQ_RESP_IDX
);
980 static void fm_irq_afjump_rd_freq_resp(struct fmdev
*fmdev
)
984 u32 curr_freq
, jumped_freq
;
986 if (check_cmdresp_status(fmdev
, &skb
))
989 /* Skip header info and copy only response data */
990 skb_pull(skb
, sizeof(struct fm_event_msg_hdr
));
991 memcpy(&read_freq
, skb
->data
, sizeof(read_freq
));
992 read_freq
= be16_to_cpu(read_freq
);
993 curr_freq
= fmdev
->rx
.region
.bot_freq
+ ((u32
)read_freq
* FM_FREQ_MUL
);
995 jumped_freq
= fmdev
->rx
.stat_info
.af_cache
[fmdev
->rx
.afjump_idx
];
997 /* If the frequency was changed the jump succeeded */
998 if ((curr_freq
!= fmdev
->rx
.freq_before_jump
) && (curr_freq
== jumped_freq
)) {
999 fmdbg("Successfully switched to alternate freq %d\n", curr_freq
);
1000 fmdev
->rx
.freq
= curr_freq
;
1001 fm_rx_reset_rds_cache(fmdev
);
1003 /* AF feature is on, enable low level RSSI interrupt */
1004 if (fmdev
->rx
.af_mode
== FM_RX_RDS_AF_SWITCH_MODE_ON
)
1005 fmdev
->irq_info
.mask
|= FM_LEV_EVENT
;
1007 fmdev
->irq_info
.stage
= FM_LOW_RSSI_FINISH_IDX
;
1008 } else { /* jump to the next freq in the AF list */
1009 fmdev
->rx
.afjump_idx
++;
1011 /* If we reached the end of the list - stop searching */
1012 if (fmdev
->rx
.afjump_idx
>= fmdev
->rx
.stat_info
.afcache_size
) {
1013 fmdbg("AF switch processing failed\n");
1014 fmdev
->irq_info
.stage
= FM_LOW_RSSI_FINISH_IDX
;
1015 } else { /* AF List is not over - try next one */
1017 fmdbg("Trying next freq in AF cache\n");
1018 fmdev
->irq_info
.stage
= FM_AF_JUMP_SETPI_IDX
;
1024 static void fm_irq_handle_low_rssi_finish(struct fmdev
*fmdev
)
1026 fm_irq_call_stage(fmdev
, FM_SEND_INTMSK_CMD_IDX
);
1029 static void fm_irq_send_intmsk_cmd(struct fmdev
*fmdev
)
1033 /* Re-enable FM interrupts */
1034 payload
= fmdev
->irq_info
.mask
;
1036 if (!fm_send_cmd(fmdev
, INT_MASK_SET
, REG_WR
, &payload
,
1037 sizeof(payload
), NULL
))
1038 fm_irq_timeout_stage(fmdev
, FM_HANDLE_INTMSK_CMD_RESP_IDX
);
1041 static void fm_irq_handle_intmsk_cmd_resp(struct fmdev
*fmdev
)
1043 struct sk_buff
*skb
;
1045 if (check_cmdresp_status(fmdev
, &skb
))
1048 * This is last function in interrupt table to be executed.
1049 * So, reset stage index to 0.
1051 fmdev
->irq_info
.stage
= FM_SEND_FLAG_GETCMD_IDX
;
1053 /* Start processing any pending interrupt */
1054 if (test_and_clear_bit(FM_INTTASK_SCHEDULE_PENDING
, &fmdev
->flag
))
1055 fmdev
->irq_info
.handlers
[fmdev
->irq_info
.stage
](fmdev
);
1057 clear_bit(FM_INTTASK_RUNNING
, &fmdev
->flag
);
1060 /* Returns availability of RDS data in internel buffer */
1061 int fmc_is_rds_data_available(struct fmdev
*fmdev
, struct file
*file
,
1062 struct poll_table_struct
*pts
)
1064 poll_wait(file
, &fmdev
->rx
.rds
.read_queue
, pts
);
1065 if (fmdev
->rx
.rds
.rd_idx
!= fmdev
->rx
.rds
.wr_idx
)
1071 /* Copies RDS data from internal buffer to user buffer */
1072 int fmc_transfer_rds_from_internal_buff(struct fmdev
*fmdev
, struct file
*file
,
1073 u8 __user
*buf
, size_t count
)
1076 unsigned long flags
;
1079 if (fmdev
->rx
.rds
.wr_idx
== fmdev
->rx
.rds
.rd_idx
) {
1080 if (file
->f_flags
& O_NONBLOCK
)
1081 return -EWOULDBLOCK
;
1083 ret
= wait_event_interruptible(fmdev
->rx
.rds
.read_queue
,
1084 (fmdev
->rx
.rds
.wr_idx
!= fmdev
->rx
.rds
.rd_idx
));
1089 /* Calculate block count from byte count */
1094 spin_lock_irqsave(&fmdev
->rds_buff_lock
, flags
);
1096 while (block_count
< count
) {
1097 if (fmdev
->rx
.rds
.wr_idx
== fmdev
->rx
.rds
.rd_idx
)
1100 if (copy_to_user(buf
, &fmdev
->rx
.rds
.buff
[fmdev
->rx
.rds
.rd_idx
],
1104 fmdev
->rx
.rds
.rd_idx
+= FM_RDS_BLK_SIZE
;
1105 if (fmdev
->rx
.rds
.rd_idx
>= fmdev
->rx
.rds
.buf_size
)
1106 fmdev
->rx
.rds
.rd_idx
= 0;
1109 buf
+= FM_RDS_BLK_SIZE
;
1110 ret
+= FM_RDS_BLK_SIZE
;
1112 spin_unlock_irqrestore(&fmdev
->rds_buff_lock
, flags
);
1116 int fmc_set_freq(struct fmdev
*fmdev
, u32 freq_to_set
)
1118 switch (fmdev
->curr_fmmode
) {
1120 return fm_rx_set_freq(fmdev
, freq_to_set
);
1123 return fm_tx_set_freq(fmdev
, freq_to_set
);
1130 int fmc_get_freq(struct fmdev
*fmdev
, u32
*cur_tuned_frq
)
1132 if (fmdev
->rx
.freq
== FM_UNDEFINED_FREQ
) {
1133 fmerr("RX frequency is not set\n");
1136 if (cur_tuned_frq
== NULL
) {
1137 fmerr("Invalid memory\n");
1141 switch (fmdev
->curr_fmmode
) {
1143 *cur_tuned_frq
= fmdev
->rx
.freq
;
1147 *cur_tuned_frq
= 0; /* TODO : Change this later */
1156 int fmc_set_region(struct fmdev
*fmdev
, u8 region_to_set
)
1158 switch (fmdev
->curr_fmmode
) {
1160 return fm_rx_set_region(fmdev
, region_to_set
);
1163 return fm_tx_set_region(fmdev
, region_to_set
);
1170 int fmc_set_mute_mode(struct fmdev
*fmdev
, u8 mute_mode_toset
)
1172 switch (fmdev
->curr_fmmode
) {
1174 return fm_rx_set_mute_mode(fmdev
, mute_mode_toset
);
1177 return fm_tx_set_mute_mode(fmdev
, mute_mode_toset
);
1184 int fmc_set_stereo_mono(struct fmdev
*fmdev
, u16 mode
)
1186 switch (fmdev
->curr_fmmode
) {
1188 return fm_rx_set_stereo_mono(fmdev
, mode
);
1191 return fm_tx_set_stereo_mono(fmdev
, mode
);
1198 int fmc_set_rds_mode(struct fmdev
*fmdev
, u8 rds_en_dis
)
1200 switch (fmdev
->curr_fmmode
) {
1202 return fm_rx_set_rds_mode(fmdev
, rds_en_dis
);
1205 return fm_tx_set_rds_mode(fmdev
, rds_en_dis
);
1212 /* Sends power off command to the chip */
1213 static int fm_power_down(struct fmdev
*fmdev
)
1218 if (!test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1219 fmerr("FM core is not ready\n");
1222 if (fmdev
->curr_fmmode
== FM_MODE_OFF
) {
1223 fmdbg("FM chip is already in OFF state\n");
1228 ret
= fmc_send_cmd(fmdev
, FM_POWER_MODE
, REG_WR
, &payload
,
1229 sizeof(payload
), NULL
, NULL
);
1233 return fmc_release(fmdev
);
1236 /* Reads init command from FM firmware file and loads to the chip */
1237 static int fm_download_firmware(struct fmdev
*fmdev
, const u8
*fw_name
)
1239 const struct firmware
*fw_entry
;
1240 struct bts_header
*fw_header
;
1241 struct bts_action
*action
;
1242 struct bts_action_delay
*delay
;
1244 int ret
, fw_len
, cmd_cnt
;
1247 set_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
);
1249 ret
= request_firmware(&fw_entry
, fw_name
,
1250 &fmdev
->radio_dev
->dev
);
1252 fmerr("Unable to read firmware(%s) content\n", fw_name
);
1255 fmdbg("Firmware(%s) length : %d bytes\n", fw_name
, fw_entry
->size
);
1257 fw_data
= (void *)fw_entry
->data
;
1258 fw_len
= fw_entry
->size
;
1260 fw_header
= (struct bts_header
*)fw_data
;
1261 if (fw_header
->magic
!= FM_FW_FILE_HEADER_MAGIC
) {
1262 fmerr("%s not a legal TI firmware file\n", fw_name
);
1266 fmdbg("FW(%s) magic number : 0x%x\n", fw_name
, fw_header
->magic
);
1268 /* Skip file header info , we already verified it */
1269 fw_data
+= sizeof(struct bts_header
);
1270 fw_len
-= sizeof(struct bts_header
);
1272 while (fw_data
&& fw_len
> 0) {
1273 action
= (struct bts_action
*)fw_data
;
1275 switch (action
->type
) {
1276 case ACTION_SEND_COMMAND
: /* Send */
1277 if (fmc_send_cmd(fmdev
, 0, 0, action
->data
,
1278 action
->size
, NULL
, NULL
))
1284 case ACTION_DELAY
: /* Delay */
1285 delay
= (struct bts_action_delay
*)action
->data
;
1286 mdelay(delay
->msec
);
1290 fw_data
+= (sizeof(struct bts_action
) + (action
->size
));
1291 fw_len
-= (sizeof(struct bts_action
) + (action
->size
));
1293 fmdbg("Firmware commands(%d) loaded to chip\n", cmd_cnt
);
1295 release_firmware(fw_entry
);
1296 clear_bit(FM_FW_DW_INPROGRESS
, &fmdev
->flag
);
1301 /* Loads default RX configuration to the chip */
1302 static int load_default_rx_configuration(struct fmdev
*fmdev
)
1306 ret
= fm_rx_set_volume(fmdev
, FM_DEFAULT_RX_VOLUME
);
1310 return fm_rx_set_rssi_threshold(fmdev
, FM_DEFAULT_RSSI_THRESHOLD
);
1313 /* Does FM power on sequence */
1314 static int fm_power_up(struct fmdev
*fmdev
, u8 mode
)
1316 u16 payload
, asic_id
, asic_ver
;
1320 if (mode
>= FM_MODE_ENTRY_MAX
) {
1321 fmerr("Invalid firmware download option\n");
1326 * Initialize FM common module. FM GPIO toggling is
1327 * taken care in Shared Transport driver.
1329 ret
= fmc_prepare(fmdev
);
1331 fmerr("Unable to prepare FM Common\n");
1335 payload
= FM_ENABLE
;
1336 if (fmc_send_cmd(fmdev
, FM_POWER_MODE
, REG_WR
, &payload
,
1337 sizeof(payload
), NULL
, NULL
))
1340 /* Allow the chip to settle down in Channel-8 mode */
1343 if (fmc_send_cmd(fmdev
, ASIC_ID_GET
, REG_RD
, NULL
,
1344 sizeof(asic_id
), &asic_id
, &resp_len
))
1347 if (fmc_send_cmd(fmdev
, ASIC_VER_GET
, REG_RD
, NULL
,
1348 sizeof(asic_ver
), &asic_ver
, &resp_len
))
1351 fmdbg("ASIC ID: 0x%x , ASIC Version: %d\n",
1352 be16_to_cpu(asic_id
), be16_to_cpu(asic_ver
));
1354 sprintf(fw_name
, "%s_%x.%d.bts", FM_FMC_FW_FILE_START
,
1355 be16_to_cpu(asic_id
), be16_to_cpu(asic_ver
));
1357 ret
= fm_download_firmware(fmdev
, fw_name
);
1359 fmdbg("Failed to download firmware file %s\n", fw_name
);
1362 sprintf(fw_name
, "%s_%x.%d.bts", (mode
== FM_MODE_RX
) ?
1363 FM_RX_FW_FILE_START
: FM_TX_FW_FILE_START
,
1364 be16_to_cpu(asic_id
), be16_to_cpu(asic_ver
));
1366 ret
= fm_download_firmware(fmdev
, fw_name
);
1368 fmdbg("Failed to download firmware file %s\n", fw_name
);
1373 return fmc_release(fmdev
);
1376 /* Set FM Modes(TX, RX, OFF) */
1377 int fmc_set_mode(struct fmdev
*fmdev
, u8 fm_mode
)
1381 if (fm_mode
>= FM_MODE_ENTRY_MAX
) {
1382 fmerr("Invalid FM mode\n");
1385 if (fmdev
->curr_fmmode
== fm_mode
) {
1386 fmdbg("Already fm is in mode(%d)\n", fm_mode
);
1391 case FM_MODE_OFF
: /* OFF Mode */
1392 ret
= fm_power_down(fmdev
);
1394 fmerr("Failed to set OFF mode\n");
1399 case FM_MODE_TX
: /* TX Mode */
1400 case FM_MODE_RX
: /* RX Mode */
1401 /* Power down before switching to TX or RX mode */
1402 if (fmdev
->curr_fmmode
!= FM_MODE_OFF
) {
1403 ret
= fm_power_down(fmdev
);
1405 fmerr("Failed to set OFF mode\n");
1410 ret
= fm_power_up(fmdev
, fm_mode
);
1412 fmerr("Failed to load firmware\n");
1416 fmdev
->curr_fmmode
= fm_mode
;
1418 /* Set default configuration */
1419 if (fmdev
->curr_fmmode
== FM_MODE_RX
) {
1420 fmdbg("Loading default rx configuration..\n");
1421 ret
= load_default_rx_configuration(fmdev
);
1423 fmerr("Failed to load default values\n");
1429 /* Returns current FM mode (TX, RX, OFF) */
1430 int fmc_get_mode(struct fmdev
*fmdev
, u8
*fmmode
)
1432 if (!test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1433 fmerr("FM core is not ready\n");
1436 if (fmmode
== NULL
) {
1437 fmerr("Invalid memory\n");
1441 *fmmode
= fmdev
->curr_fmmode
;
1445 /* Called by ST layer when FM packet is available */
1446 static long fm_st_receive(void *arg
, struct sk_buff
*skb
)
1448 struct fmdev
*fmdev
;
1450 fmdev
= (struct fmdev
*)arg
;
1453 fmerr("Invalid SKB received from ST\n");
1457 if (skb
->cb
[0] != FM_PKT_LOGICAL_CHAN_NUMBER
) {
1458 fmerr("Received SKB (%p) is not FM Channel 8 pkt\n", skb
);
1462 memcpy(skb_push(skb
, 1), &skb
->cb
[0], 1);
1463 skb_queue_tail(&fmdev
->rx_q
, skb
);
1464 tasklet_schedule(&fmdev
->rx_task
);
1470 * Called by ST layer to indicate protocol registration completion
1473 static void fm_st_reg_comp_cb(void *arg
, char data
)
1475 struct fmdev
*fmdev
;
1477 fmdev
= (struct fmdev
*)arg
;
1478 fmdev
->streg_cbdata
= data
;
1479 complete(&wait_for_fmdrv_reg_comp
);
1483 * This function will be called from FM V4L2 open function.
1484 * Register with ST driver and initialize driver data.
1486 int fmc_prepare(struct fmdev
*fmdev
)
1488 static struct st_proto_s fm_st_proto
;
1491 if (test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1492 fmdbg("FM Core is already up\n");
1496 memset(&fm_st_proto
, 0, sizeof(fm_st_proto
));
1497 fm_st_proto
.recv
= fm_st_receive
;
1498 fm_st_proto
.match_packet
= NULL
;
1499 fm_st_proto
.reg_complete_cb
= fm_st_reg_comp_cb
;
1500 fm_st_proto
.write
= NULL
; /* TI ST driver will fill write pointer */
1501 fm_st_proto
.priv_data
= fmdev
;
1502 fm_st_proto
.chnl_id
= 0x08;
1503 fm_st_proto
.max_frame_size
= 0xff;
1504 fm_st_proto
.hdr_len
= 1;
1505 fm_st_proto
.offset_len_in_hdr
= 0;
1506 fm_st_proto
.len_size
= 1;
1507 fm_st_proto
.reserve
= 1;
1509 ret
= st_register(&fm_st_proto
);
1510 if (ret
== -EINPROGRESS
) {
1511 init_completion(&wait_for_fmdrv_reg_comp
);
1512 fmdev
->streg_cbdata
= -EINPROGRESS
;
1513 fmdbg("%s waiting for ST reg completion signal\n", __func__
);
1515 if (!wait_for_completion_timeout(&wait_for_fmdrv_reg_comp
,
1516 FM_ST_REG_TIMEOUT
)) {
1517 fmerr("Timeout(%d sec), didn't get reg "
1518 "completion signal from ST\n",
1519 jiffies_to_msecs(FM_ST_REG_TIMEOUT
) / 1000);
1522 if (fmdev
->streg_cbdata
!= 0) {
1523 fmerr("ST reg comp CB called with error "
1524 "status %d\n", fmdev
->streg_cbdata
);
1529 } else if (ret
== -1) {
1530 fmerr("st_register failed %d\n", ret
);
1534 if (fm_st_proto
.write
!= NULL
) {
1535 g_st_write
= fm_st_proto
.write
;
1537 fmerr("Failed to get ST write func pointer\n");
1538 ret
= st_unregister(&fm_st_proto
);
1540 fmerr("st_unregister failed %d\n", ret
);
1544 spin_lock_init(&fmdev
->rds_buff_lock
);
1545 spin_lock_init(&fmdev
->resp_skb_lock
);
1547 /* Initialize TX queue and TX tasklet */
1548 skb_queue_head_init(&fmdev
->tx_q
);
1549 tasklet_init(&fmdev
->tx_task
, send_tasklet
, (unsigned long)fmdev
);
1551 /* Initialize RX Queue and RX tasklet */
1552 skb_queue_head_init(&fmdev
->rx_q
);
1553 tasklet_init(&fmdev
->rx_task
, recv_tasklet
, (unsigned long)fmdev
);
1555 fmdev
->irq_info
.stage
= 0;
1556 atomic_set(&fmdev
->tx_cnt
, 1);
1557 fmdev
->resp_comp
= NULL
;
1559 init_timer(&fmdev
->irq_info
.timer
);
1560 fmdev
->irq_info
.timer
.function
= &int_timeout_handler
;
1561 fmdev
->irq_info
.timer
.data
= (unsigned long)fmdev
;
1562 /*TODO: add FM_STIC_EVENT later */
1563 fmdev
->irq_info
.mask
= FM_MAL_EVENT
;
1566 fmdev
->rx
.region
= region_configs
[default_radio_region
];
1568 fmdev
->rx
.mute_mode
= FM_MUTE_OFF
;
1569 fmdev
->rx
.rf_depend_mute
= FM_RX_RF_DEPENDENT_MUTE_OFF
;
1570 fmdev
->rx
.rds
.flag
= FM_RDS_DISABLE
;
1571 fmdev
->rx
.freq
= FM_UNDEFINED_FREQ
;
1572 fmdev
->rx
.rds_mode
= FM_RDS_SYSTEM_RDS
;
1573 fmdev
->rx
.af_mode
= FM_RX_RDS_AF_SWITCH_MODE_OFF
;
1574 fmdev
->irq_info
.retry
= 0;
1576 fm_rx_reset_rds_cache(fmdev
);
1577 init_waitqueue_head(&fmdev
->rx
.rds
.read_queue
);
1579 fm_rx_reset_station_info(fmdev
);
1580 set_bit(FM_CORE_READY
, &fmdev
->flag
);
1586 * This function will be called from FM V4L2 release function.
1587 * Unregister from ST driver.
1589 int fmc_release(struct fmdev
*fmdev
)
1591 static struct st_proto_s fm_st_proto
;
1594 if (!test_bit(FM_CORE_READY
, &fmdev
->flag
)) {
1595 fmdbg("FM Core is already down\n");
1598 /* Service pending read */
1599 wake_up_interruptible(&fmdev
->rx
.rds
.read_queue
);
1601 tasklet_kill(&fmdev
->tx_task
);
1602 tasklet_kill(&fmdev
->rx_task
);
1604 skb_queue_purge(&fmdev
->tx_q
);
1605 skb_queue_purge(&fmdev
->rx_q
);
1607 fmdev
->resp_comp
= NULL
;
1610 memset(&fm_st_proto
, 0, sizeof(fm_st_proto
));
1611 fm_st_proto
.chnl_id
= 0x08;
1613 ret
= st_unregister(&fm_st_proto
);
1616 fmerr("Failed to de-register FM from ST %d\n", ret
);
1618 fmdbg("Successfully unregistered from ST\n");
1620 clear_bit(FM_CORE_READY
, &fmdev
->flag
);
1625 * Module init function. Ask FM V4L module to register video device.
1626 * Allocate memory for FM driver context and RX RDS buffer.
1628 static int __init
fm_drv_init(void)
1630 struct fmdev
*fmdev
= NULL
;
1633 fmdbg("FM driver version %s\n", FM_DRV_VERSION
);
1635 fmdev
= kzalloc(sizeof(struct fmdev
), GFP_KERNEL
);
1636 if (NULL
== fmdev
) {
1637 fmerr("Can't allocate operation structure memory\n");
1640 fmdev
->rx
.rds
.buf_size
= default_rds_buf
* FM_RDS_BLK_SIZE
;
1641 fmdev
->rx
.rds
.buff
= kzalloc(fmdev
->rx
.rds
.buf_size
, GFP_KERNEL
);
1642 if (NULL
== fmdev
->rx
.rds
.buff
) {
1643 fmerr("Can't allocate rds ring buffer\n");
1647 ret
= fm_v4l2_init_video_device(fmdev
, radio_nr
);
1651 fmdev
->irq_info
.handlers
= int_handler_table
;
1652 fmdev
->curr_fmmode
= FM_MODE_OFF
;
1653 fmdev
->tx_data
.pwr_lvl
= FM_PWR_LVL_DEF
;
1654 fmdev
->tx_data
.preemph
= FM_TX_PREEMPH_50US
;
1658 kfree(fmdev
->rx
.rds
.buff
);
1665 /* Module exit function. Ask FM V4L module to unregister video device */
1666 static void __exit
fm_drv_exit(void)
1668 struct fmdev
*fmdev
= NULL
;
1670 fmdev
= fm_v4l2_deinit_video_device();
1671 if (fmdev
!= NULL
) {
1672 kfree(fmdev
->rx
.rds
.buff
);
1677 module_init(fm_drv_init
);
1678 module_exit(fm_drv_exit
);
1680 /* ------------- Module Info ------------- */
1681 MODULE_AUTHOR("Manjunatha Halli <manjunatha_halli@ti.com>");
1682 MODULE_DESCRIPTION("FM Driver for TI's Connectivity chip. " FM_DRV_VERSION
);
1683 MODULE_VERSION(FM_DRV_VERSION
);
1684 MODULE_LICENSE("GPL");