drivers/media/radio/sc2331/fmdrv_main.c

   1 /*
   2  *  FM Driver for Connectivity chip of Broadcom Corporation.
   3  *
   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  *
  14  *  Copyright (C) 2009 Texas Instruments
  15  *  Copyright (C) 2009-2014 Broadcom Corporation
  16  *
  17  *  This program is free software; you can redistribute it and/or modify
  18  *  it under the terms of the GNU General Public License version 2 as
  19  *  published by the Free Software Foundation.
  20  *
  21  *  This program is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  *  GNU General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU General Public License
  27  *  along with this program; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29  *
  30  */
  31 /************************************************************************************
  32  *
  33  *  Filename:      fmdrv_main.c
  34  *
  35  *  Description:   Common sub-module for both FM Rx and Tx. Currently, only
  36  *                  is supported
  37  *
  38  ***********************************************************************************/
  39
  40 #include <linux/module.h>
  41 #include <linux/delay.h>
  42 #include "fmdrv.h"
  43 #include "fmdrv_v4l2.h"
  44 #include "fmdrv_main.h"
  45 #include "../../../bluetooth/hci_uart_bcm.h"
  46 #include "fmdrv_rx.h"
  47 #include <linux/fm_public.h>
  48 #define  FMDRV_REGION_CONFIGS
  49 #include "fmdrv_config.h"
  50
  51 #ifndef DEBUG
  52 #ifdef pr_info
  53 #undef pr_info
  54 #define pr_info(fmt, arg...)
  55 #endif
  56 #endif
  57
  58 /*******************************************************************************
  59 **  Static Variables
  60 *******************************************************************************/
  61
  62 /* Band selection */
  63
  64 static unsigned char default_radio_region;    /* US */
  65 module_param(default_radio_region, byte, 0);
  66 MODULE_PARM_DESC(default_radio_region, "Region: 0=US, 1=Europe, 2=Japan");
  67
  68 /* RDS buffer blocks */
  69 static unsigned int default_rds_buf = 300;
  70 module_param(default_rds_buf, uint, 0444);
  71 MODULE_PARM_DESC(rds_buf, "RDS buffer entries");
  72
  73 /* Radio Nr */
  74 static int radio_nr = -1;
  75 module_param(radio_nr, int, 0);
  76 MODULE_PARM_DESC(radio_nr, "Radio Nr");
  77 #if (defined CONFIG_BCM_BT_LPM && defined CONFIG_TIZEN_WIP)
  78 extern  struct notifier_block hci_event_nblock;
  79 #endif
  80
  81 /*******************************************************************************
  82 **  Forward function declarations
  83 *******************************************************************************/
  84
  85 long (*g_bcm_write) (struct sk_buff *skb);
  86
  87 int parse_inrpt_flags(struct fmdrv_ops *fmdev);
  88 int parse_rds_data(struct fmdrv_ops *fmdev);
  89 void send_read_intrp_cmd(struct fmdrv_ops *fmdev);
  90 int read_rds_data(struct fmdrv_ops *);
  91
  92 unsigned short global_frequency=8750;
  93 unsigned char global_cur_rssi=0x6C; //-105dBm default
  94 unsigned char global_VSE_subevent=0;
  95
  96 /*******************************************************************************
  97 **  Functions
  98 *******************************************************************************/
  99
 100 //#ifdef FM_DUMP_TXRX_PKT
 101  /* To dump outgoing FM Channel-8 packets */
 102 inline void dump_tx_skb_data(struct sk_buff *skb)
 103 {
 104     int len, len_org;
 105     char index;
 106     struct fm_cmd_msg_hdr_sprd *cmd_hdr;
 107
 108     cmd_hdr = (struct fm_cmd_msg_hdr_sprd *)skb->data;
 109     printk(KERN_INFO "<<%shdr:%02x len:%02x opcode:%02x",
 110            fm_cb(skb)->completion ? " " : "*", cmd_hdr->header,
 111            cmd_hdr->len, cmd_hdr->fm_opcode);
 112
 113     len_org = skb->len - FM_CMD_MSG_HDR_SIZE_SPRD;
 114     if (len_org > 0)
 115     {
 116         //printk("\n   data(%d): ", cmd_hdr->dlen);
 117         len = min(len_org, 14);
 118         for (index = 0; index < len; index++)
 119             printk("%x ",
 120                    skb->data[FM_CMD_MSG_HDR_SIZE_SPRD + index]);
 121         printk("%s", (len_org > 14) ? ".." : "");
 122     }
 123     printk("\n");
 124 }
 125
 126  /* To dump incoming FM Channel-8 packets */
 127 inline void dump_rx_skb_data(struct sk_buff *skb)
 128 {
 129     int len, len_org;
 130     char index;
 131     struct fm_event_msg_hdr  *evt_hdr;
 132
 133     evt_hdr = (struct fm_event_msg_hdr *)skb->data;
 134     printk(KERN_INFO ">> header:%02x event:%02x len:%02x",
 135         evt_hdr->header, evt_hdr->event_id, evt_hdr->len);
 136
 137     len_org = skb->len - FM_EVT_MSG_HDR_SIZE;
 138     if (len_org > 0)
 139     {
 140         printk("\n   data(%d): ", evt_hdr->len);
 141         len = min(len_org, 14);
 142         for (index = 0; index < len; index++)
 143             printk("%x ",
 144                    skb->data[FM_EVT_MSG_HDR_SIZE + index]);
 145         printk("%s", (len_org > 14) ? ".." : "");
 146     }
 147     printk("\n");
 148 }
 149
 150 //#endif
 151
 152 /*
 153  * Store the currently set region
 154  */
 155 void fmc_update_region_info(struct fmdrv_ops *fmdev,
 156                 unsigned char region_to_set)
 157 {
 158     fmdev->rx.curr_region = region_to_set;
 159     memcpy(&fmdev->rx.region, &region_configs[region_to_set],
 160         sizeof(struct region_info));
 161     fmdev->rx.curr_freq = fmdev->rx.region.low_bound;
 162     fm_rx_config_deemphasis( fmdev,fmdev->rx.region.deemphasis);
 163 }
 164
 165 /*
 166 * FM common sub-module will schedule this tasklet whenever it receives
 167 * FM packet from ST driver.
 168 */
 169 static void __recv_tasklet(unsigned long arg)
 170 {
 171     struct fmdrv_ops *fmdev;
 172     struct fm_event_msg_hdr *fm_evt_hdr;
 173     struct sk_buff *skb;
 174     unsigned long flags;
 175     unsigned char sub_event, *p;
 176         unsigned char rdsdata_len=0;
 177         unsigned char tmpbuf[64]={0};
 178         unsigned char ps,rds_type;
 179         unsigned char i;
 180
 181     fmdev = (struct fmdrv_ops *)arg;
 182
 183         pr_err("wsh___recv_tasklet");
 184     /* Process all packets in the RX queue */
 185     while ((skb = skb_dequeue(&fmdev->rx_q)))
 186     {
 187         if (skb->len < sizeof(struct fm_event_msg_hdr))
 188         {
 189             pr_err("(fmdrv): skb(%p) has only %d bytes"
 190                             "atleast need %lu bytes to decode\n",
 191                                         skb, skb->len,
 192                                 (unsigned long)sizeof(struct fm_event_msg_hdr));
 193             kfree_skb(skb);
 194             continue;
 195         }
 196 //#ifdef FM_DUMP_TXRX_PKT
 197         dump_rx_skb_data(skb);
 198 //#endif
 199         fm_evt_hdr = (void *)skb->data;
 200                 pr_err("\neventid=%02x ,last_sent_pkt_opcode=%02x \n",fm_evt_hdr->event_id,fmdev->last_sent_pkt_opcode);
 201
 202 if(fmdev->response_completion != NULL){
 203
 204         pr_info("response_completion have completion\n");
 205
 206 }
 207         if (fm_evt_hdr->event_id == HCI_EV_CMD_COMPLETE)
 208         {
 209             struct fm_cmd_complete_hdr_sprd *cmd_complete_hdr;
 210             cmd_complete_hdr = (struct fm_cmd_complete_hdr_sprd *) &skb->data [FM_EVT_MSG_HDR_SIZE];
 211                         pr_err("the header is : %2x \n",cmd_complete_hdr->fm_opcode);
 212             /* Anyone waiting for this with completion handler? */
 213             if (/*cmd_complete_hdr->fm_opcode == fmdev->last_sent_pkt_opcode && */
 214                                 fmdev->response_completion != NULL)
 215             {
 216                 pr_info("(fmdrv) %s() : Command complete Event\n", __func__);
 217                 if (fmdev->response_skb != NULL)
 218                     pr_err("(fmdrv) %s(): Response SKB ptr not NULL\n", __func__);
 219
 220                 if(cmd_complete_hdr->fm_opcode == FM_REG_FM_RDS_MSK)
 221                     fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 222
 223                 spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
 224                 fmdev->response_skb = skb;
 225                 spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
 226                 complete(fmdev->response_completion);
 227
 228                 fmdev->response_completion = NULL;
 229                 atomic_set(&fmdev->tx_cnt, 1);
 230             }
 231                 }
 232             /* This is the VSE interrupt handler case */
 233
 234           else if (fm_evt_hdr->event_id == 0xFF)
 235
 236             {
 237                 pr_info("(fmdrv) %s : VSE interrupt handler case\n", __func__);
 238                 if (fmdev->response_skb != NULL)
 239                     pr_err("(fmdrv) %s(): Response SKB ptr not NULL\n", __func__);
 240                p = &skb->data[FM_EVT_MSG_HDR_SIZE];
 241
 242                STREAM_TO_UINT8(sub_event, p);
 243                            //sub_event=0x30,p=0x0,p+1=0xae,p+2=0x0.p:after subevent
 244                            pr_info("sub_event=0x%x,p=0x%x,p+1=0x%x,p+2=0x%x",sub_event,p[0],p[1],p[2]);
 245
 246                                 spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
 247                             fmdev->response_skb = skb;
 248                 spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
 249
 250                                 if(sub_event==0x30)
 251                                         {
 252                     complete(&fmdev->seektask_completion);
 253
 254                        //(&fmdev->seektask_completion)= NULL;
 255
 256                         global_frequency=(p[4]<<8)+p[3];
 257                         global_VSE_subevent =sub_event;
 258                         global_cur_rssi=p[1];
 259                         /*              fmdev->rx.curr_rssi_threshold=p[1]; */
 260                         pr_info("seek freq is %d\n",global_frequency);
 261                        atomic_set(&fmdev->tx_cnt, 1);}
 262                                 else if(sub_event==0x31)
 263                                         {
 264                                           pr_info("This is AF jump event\n");
 265
 266                                         }
 267                                 else {
 268                            pr_info("This is RDS data event from controller\n");
 269                            rdsdata_len=*(p-2);
 270                            p=p-2;
 271                                                    ps=sub_event;
 272 #if 0
 273                            rds_type=sub_event;
 274                            pr_info("RDS data before memcopy,rdsdata_len=%x\n",rdsdata_len);
 275                            fmdev->rx.rds.rd_index=900; //when before read, default value
 276                            memcpy(&fmdev->rx.rds.cbuffer[0], p,rdsdata_len+1);
 277                            fmdev->rx.rds.wr_index=rdsdata_len+1;
 278                            fmdev->rx.rds.buf_size=rdsdata_len+1;
 279
 280                            if (fmdev->rx.rds.wr_index != fmdev->rx.rds.rd_index)
 281                            pr_info("after memcopy\n");
 282                            for(i=0;i<rdsdata_len+1;i++)
 283                            {
 284                            pr_info("p[%d]=%x__",i,p[i]);
 285                            }
 286                                                    pr_info("\n");
 287                            wake_up_interruptible(&fmdev->rx.rds.read_queue);
 288 #endif
 289
 290 //#if 0
 291                                           if(ps==0x07)
 292                                                 {   pr_info("ps data before memcopy,rdsdata_len=%x\n",rdsdata_len);
 293                                                 fmdev->rx.rds.rd_index=900; //when before read, default value
 294                                                     memcpy(&fmdev->rx.rds.cbuffer[0], p,rdsdata_len+1);
 295                                                         fmdev->rx.rds.wr_index=rdsdata_len+1;
 296                                                         fmdev->rx.rds.buf_size=rdsdata_len+1;
 297
 298                                                         if (fmdev->rx.rds.wr_index != fmdev->rx.rds.rd_index)
 299                                                         pr_info("after memcopy\n");
 300                                                         for(i=0;i<rdsdata_len+1;i++)
 301                                                                 {
 302                                                                         pr_info("p[%d]=%x__",i,p[i]);
 303                                                                 }
 304                             wake_up_interruptible(&fmdev->rx.rds.read_queue);
 305
 306                                                 }
 307                                           if(ps==0x09)
 308                                                 {
 309                                                         pr_info("RT data comming");
 310                                                         fmdev->rx.rds.rd_index=900; //when before read, default value
 311                                                     memcpy(&fmdev->rx.rds.cbuffer[0], p,rdsdata_len+1);
 312                                                         fmdev->rx.rds.wr_index=rdsdata_len+1;
 313                                                         fmdev->rx.rds.buf_size=rdsdata_len+1;
 314
 315                                                         if (fmdev->rx.rds.wr_index != fmdev->rx.rds.rd_index)
 316                                                         pr_info("after memcopy\n");
 317                                                         for(i=0;i<rdsdata_len+1;i++)
 318                                                                 {
 319                                                                         pr_info("p[%d]=%x__",i,p[i]);
 320                                                                 }
 321                             wake_up_interruptible(&fmdev->rx.rds.read_queue);
 322
 323
 324                                                 }
 325 //#endif
 326
 327
 328                                         }
 329         kfree_skb(skb);
 330         }
 331
 332        // else if(fm_evt_hdr->event_id == BRCM_FM_VS_EVENT) /* Vendor specific Event */
 333        else if(fm_evt_hdr->event_id ==0xFE)
 334         {
 335             p = &skb->data[FM_EVT_MSG_HDR_SIZE];
 336
 337             /* Check if this is a FM vendor specific event */
 338             STREAM_TO_UINT8(sub_event, p);
 339             if(sub_event == BRCM_VSE_SUBCODE_FM_INTERRUPT)
 340             {
 341                 pr_info("(fmdrv) %s(): VSE Interrupt event for FM received\n",
 342                                                                 __func__);
 343                 pr_info("(fmdrv) %s(): Calling fmc_send_intrp_cmd()\n",
 344                                                                 __func__);
 345                 send_read_intrp_cmd(fmdev);
 346             }
 347         }
 348         else
 349         {
 350             pr_err("(fmdrv) %s(): Unhandled packet SKB(%p),purging\n", __func__, skb);
 351         }
 352         if (!skb_queue_empty(&fmdev->tx_q))
 353                 tasklet_schedule(&fmdev->tx_task);
 354     }
 355 }
 356
 357 /*
 358 * FM send tasklet: is scheduled when
 359 * FM packet has to be sent to chip */
 360 static void __send_tasklet(unsigned long arg)
 361 {
 362     struct fmdrv_ops *fmdev;
 363     struct sk_buff *skb;
 364     int len;
 365
 366     fmdev = (struct fmdrv_ops *)arg;
 367     /* Send queued FM TX packets */
 368     if (atomic_read(&fmdev->tx_cnt))
 369     {
 370         skb = skb_dequeue(&fmdev->tx_q);
 371         if (skb)
 372         {
 373             atomic_dec(&fmdev->tx_cnt);
 374             fmdev->last_sent_pkt_opcode = fm_cb(skb)->fm_opcode;
 375
 376             if (fmdev->response_completion != NULL)
 377                     pr_err("(fmdrv) %s(): Response completion handler is not NULL\n",
 378                                                                         __func__);
 379
 380             fmdev->response_completion = fm_cb(skb)->completion;
 381             pr_info("(fmdrv): %s(): *** pkt_type 0x%x\n",
 382                                         __func__, sh_ldisc_cb(skb)->pkt_type);
 383             /* SYED : Hack to set the right packet type for FM */
 384             sh_ldisc_cb(skb)->pkt_type = FM_PKT_LOGICAL_CHAN_NUMBER;
 385             /* Write FM packet to hci shared ldisc driver */
 386             len = g_bcm_write(skb);
 387             if (len < 0)
 388             {
 389                 pr_err("(fmdrv): %s(): TX tasklet failed to send skb(0x%p)\n",
 390                                                 __func__, skb);
 391                 kfree_skb(skb);
 392                 fmdev->response_completion = NULL;
 393                 atomic_set(&fmdev->tx_cnt, 1);
 394             }
 395             else {
 396                 fmdev->last_tx_jiffies = jiffies;
 397             }
 398         }
 399     }
 400 }
 401
 402 /* Queues FM Channel-8 packet to FM TX queue and schedules FM TX tasklet for
 403  * transmission */
 404 static int __fm_send_cmd(struct fmdrv_ops *fmdev, unsigned char fmreg_index,
 405                 void *payload, int payload_len, unsigned char type,
 406                 struct completion *wait_completion)
 407 {
 408     struct sk_buff *skb;
 409     struct fm_cmd_msg_hdr_sprd *cmd_hdr;
 410     int size;
 411 #if (defined CONFIG_BCM_BT_LPM && defined CONFIG_TIZEN_WIP)
 412     hci_event_nblock.notifier_call(NULL,HCI_DEV_WRITE,NULL);
 413 #endif
 414
 415     size = FM_CMD_MSG_HDR_SIZE_SPRD + ((payload == NULL) ? 0 : payload_len);
 416
 417     skb = alloc_skb(size, GFP_ATOMIC);
 418     if (!skb)
 419     {
 420         pr_err("(fmdrv): %s(): No memory to create new SKB\n",
 421                                         __func__);
 422         return -ENOMEM;
 423     }
 424
 425     /* Fill command header info */
 426     cmd_hdr =(struct fm_cmd_msg_hdr_sprd *)skb_put(skb, FM_CMD_MSG_HDR_SIZE_SPRD);
 427
 428     /* kilsung Change for 4343S  */
 429     cmd_hdr->header = 0x01; /* FM_PKT_LOGICAL_CHAN_NUMBER;*/    /* 0x08 */
 430     /* 3 (cmd, len, fm_opcode,rd_wr) */
 431     cmd_hdr->cmd = hci_opcode_pack(HCI_GRP_VENDOR_SPECIFIC, FM_SPRD_OP_CODE);
 432
 433     cmd_hdr->len = ((payload == NULL) ? 0 : payload_len) + 1;    //need to check
 434     /* FM opcode */
 435     cmd_hdr->fm_opcode = fmreg_index;
 436     /* read/write type */
 437    // cmd_hdr->rd_wr = type;
 438
 439     fm_cb(skb)->fm_opcode = fmreg_index;
 440
 441     if (payload != NULL)
 442             memcpy(skb_put(skb, payload_len), payload, payload_len);
 443
 444     fm_cb(skb)->completion = wait_completion;
 445     skb_queue_tail(&fmdev->tx_q, skb);
 446     tasklet_schedule(&fmdev->tx_task);
 447
 448     return 0;
 449 }
 450
 451
 452 /* Sends FM Channel-8 command to the chip and waits for the reponse */
 453 int fmc_send_cmd(struct fmdrv_ops *fmdev, unsigned char fmreg_index,
 454             void *payload, int payload_len, unsigned char type,
 455             struct completion *wait_completion, void *reponse,
 456             int *reponse_len)
 457 {
 458     struct sk_buff *skb;
 459     struct fm_event_msg_hdr *fm_evt_hdr;
 460     struct fm_cmd_complete_hdr_sprd *cmd_complete_hdr;
 461     unsigned long timeleft;
 462     unsigned long flags;
 463     int ret;
 464
 465     mutex_lock(&fmdev->completionmutex);
 466     init_completion(wait_completion);
 467     ret = __fm_send_cmd(fmdev, fmreg_index, payload, payload_len, type,
 468                             wait_completion);
 469     if (ret < 0)
 470         return ret;
 471
 472     timeleft = wait_for_completion_timeout(wait_completion, FM_DRV_TX_TIMEOUT);
 473     if (!timeleft)
 474     {
 475         pr_err("(fmdrv) %s(): Timeout(%d sec),didn't get reg 0x%02X "
 476                             "completion signal from RX tasklet\n",
 477                         __func__, jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000, fmreg_index);
 478         mutex_unlock(&fmdev->completionmutex);
 479         return -ETIMEDOUT;
 480     }
 481     mutex_unlock(&fmdev->completionmutex);
 482     if (!fmdev->response_skb) {
 483         pr_err("(fmdrv) %s(): Reponse SKB is missing for 0x%02X\n", __func__, fmreg_index);
 484         return -EFAULT;
 485     }
 486     spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
 487     skb = fmdev->response_skb;
 488     fmdev->response_skb = NULL;
 489     spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
 490
 491     fm_evt_hdr = (void *)skb->data;
 492     if (fm_evt_hdr->event_id == HCI_EV_CMD_COMPLETE) /* Vendor specific command response */
 493     {
 494         cmd_complete_hdr = (struct fm_cmd_complete_hdr_sprd *) &skb->data [FM_EVT_MSG_HDR_SIZE];
 495         if (cmd_complete_hdr->status != 0)
 496         {
 497             pr_err("(fmdrv) %s(): Reponse status not success for 0x%02X\n",
 498                                                                 __func__, fmreg_index);
 499             kfree (skb);
 500             return -EFAULT;
 501         }
 502
 503         pr_info("(fmdrv) %s(): Reponse status success for 0x%02X: %d,head_len=%d\n",
 504                                 __func__, fmreg_index, cmd_complete_hdr->status,fm_evt_hdr->len);
 505         /* Send reponse data to caller */
 506         if (reponse != NULL && reponse_len != NULL && fm_evt_hdr->len) {
 507             /* Skip header info and copy only response data */
 508                         pr_info("weisonghe\n");
 509
 510             skb_pull(skb, (FM_EVT_MSG_HDR_SIZE + 4));//data after status
 511             memcpy(reponse, skb->data, (fm_evt_hdr->len-4) );
 512             *reponse_len = (fm_evt_hdr->len - 4) ;//len -4 =after status
 513 //                      debugbuf=(unsigned char *)reponse;
 514 //                      pr_info("reponse=%x\n",debugbuf[0]);
 515
 516         }
 517         else if (reponse_len != NULL && fm_evt_hdr->len == 0) {
 518             *reponse_len = 0;
 519         }
 520     }
 521     else
 522     {
 523         pr_err("(fmdrv) %s(): Unhandled event ID for 0x%02X: %d\n",
 524                                 __func__, fmreg_index, fm_evt_hdr->event_id);
 525     }
 526     kfree_skb(skb);
 527     return 0;
 528 }
 529
 530 /* Helper function to parse the interrupt bits
 531 * in FM_REG_FM_RDS_FLAG (0x12).
 532 * Called locally by fmdrv_main.c
 533 */
 534 int parse_inrpt_flags(struct fmdrv_ops *fmdev)
 535 {
 536     struct sk_buff *skb;
 537     unsigned long flags;
 538     unsigned short fm_rds_flag;
 539     unsigned char response[2];
 540
 541 #if V4L2_FM_DEBUG
 542     pr_info("(fmdrv) %s()\n", __func__);
 543 #endif
 544
 545     spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
 546     skb = fmdev->response_skb;
 547     fmdev->response_skb = NULL;
 548     spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
 549
 550     memcpy(&response, &skb->data[FM_EVT_MSG_HDR_SIZE + FM_CMD_COMPLETE_HDR_SIZE_sprd], 2);
 551     fm_rds_flag= (unsigned short)response[0] + ((unsigned short)response[1] << 8) ;
 552
 553     if (fmdev->rx.fm_rds_flag & (FM_RDS_FLAG_SCH_FRZ_BIT|FM_RDS_FLAG_CLEAN_BIT))
 554     {
 555         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_CLEAN_BIT;
 556         pr_info("(fmdrv) %s(): Clean BIT set. So no processing of the current\
 557             FM/RDS flag set\n", __func__);
 558         kfree_skb(skb);
 559         return 0;
 560     }
 561
 562     pr_info("(fmdrv) %s(): Processing the interrupt flag. Flag read is 0x%x 0x%x\n",
 563                 __func__, response[0], response[1]);
 564 #if V4L2_FM_DEBUG
 565     pr_info("(fmdrv) %s(): flag register(0x%x)\n", __func__, fm_rds_flag);
 566 #endif
 567     if(fm_rds_flag & (I2C_MASK_SRH_TUNE_CMPL_BIT|I2C_MASK_SRH_TUNE_FAIL_BIT))
 568     {
 569         /* remove sch_tune pending bit */
 570         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_BIT;
 571
 572         if(fm_rds_flag & I2C_MASK_SRH_TUNE_FAIL_BIT)
 573         {
 574             pr_err("(fmdrv) %s(): MASK BIT : Search failure\n", __func__);
 575             if(fmdev->rx.curr_search_state == FM_STATE_SEEKING)
 576             {
 577                 fmdev->rx.curr_search_state = FM_STATE_SEEK_ERR;
 578                 complete(&fmdev->seektask_completion);
 579             }
 580             else if(fmdev->rx.curr_search_state == FM_STATE_TUNING)
 581             {
 582                 fmdev->rx.curr_search_state = FM_STATE_TUNE_ERR;
 583                 complete(&fmdev->maintask_completion);
 584             }
 585         }
 586         else
 587         {
 588             pr_info("(fmdrv) %s(): MASK BIT : Search success\n", __func__);
 589             if(fmdev->rx.curr_search_state == FM_STATE_SEEKING)
 590             {
 591                 fmdev->rx.curr_search_state = FM_STATE_SEEK_CMPL;
 592                 complete(&fmdev->seektask_completion);
 593             }
 594             else if(fmdev->rx.curr_search_state == FM_STATE_TUNING)
 595             {
 596                 fmdev->rx.curr_search_state = FM_STATE_TUNE_CMPL;
 597                 complete(&fmdev->maintask_completion);
 598             }
 599         }
 600     }
 601     else if(fm_rds_flag & I2C_MASK_RDS_FIFO_WLINE_BIT)
 602     {
 603         pr_info("(fmdrv) %s(): Detected WLINE interrupt; Reading RDS.\n",
 604                                                                 __func__);
 605         read_rds_data(fmdev);
 606     }
 607     kfree_skb(skb);
 608     return 0;
 609 }
 610
 611
 612 /*
 613 read RDS data from sock buffer to fmdev cbuff
 614 called by __recv_tasklet interace
 615 */
 616 #if 0
 617 int parse_rds_data(struct fmdrv_ops *fmdev)
 618 {
 619         unsigned char *rds_data;
 620         unsigned long flags;
 621         unsigned char ps_buffer[1];
 622         unsigned char RT_buffer[64];
 623         unsigned char RDS_type;
 624         struct sk_buffer *skb;
 625         int ret, response_len, index=0;
 626 #if V4L2_RDS_DEBUG
 627     pr_info("(fm_rds) %s\n", __func__);
 628 #endif
 629         spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
 630     skb = fmdev->response_skb;
 631     fmdev->response_skb = NULL;
 632     spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
 633    // skb_pull(skb, (sizeof(struct fm_event_msg_hdr) + sizeof(struct fm_cmd_complete_hdr)));
 634     rds_data = skb->data;
 635     response_len = skb->len;
 636 #if V4L2_RDS_DEBUG
 637     pr_info("(fm_rds) RDS length : %d, RDS_data=%x\n", response_len,rds_data[0]);
 638 #endif
 639
 640
 641 }
 642
 643
 644
 645 #endif
 646
 647
 648 /* Helper function to parse the RDS data
 649 * in FM_REG_FM_RDS_DATA (0x80).
 650 * Called locally by fmdrv_main.c
 651 */
 652 int brm_parse_rds_data(struct fmdrv_ops *fmdev)
 653 {
 654     unsigned long flags;
 655     unsigned char *rds_data, tmpbuf[3];
 656     unsigned char type, block_index;
 657     tBRCM_RDS_QUALITY qlty_index;
 658     int ret, response_len, index=0;
 659     struct sk_buff *skb;
 660     //struct fm_event_msg_hdr *fm_evt_hdr;
 661     //struct fm_cmd_complete_hdr *cmd_complete_hdr;
 662
 663 #if V4L2_RDS_DEBUG
 664     pr_info("(fm_rds) %s\n", __func__);
 665 #endif
 666
 667     spin_lock_irqsave(&fmdev->resp_skb_lock, flags);
 668     skb = fmdev->response_skb;
 669     fmdev->response_skb = NULL;
 670     spin_unlock_irqrestore(&fmdev->resp_skb_lock, flags);
 671     skb_pull(skb, (sizeof(struct fm_event_msg_hdr) + sizeof(struct fm_cmd_complete_hdr)));
 672     rds_data = skb->data;
 673     response_len = skb->len;
 674 #if V4L2_RDS_DEBUG
 675     pr_info("(fm_rds) RDS length : %d\n", response_len);
 676 #endif
 677
 678     /* Read RDS data */
 679     spin_lock_irqsave(&fmdev->rds_cbuff_lock, flags);
 680     while (response_len > 0)
 681     {
 682         /* Fill RDS buffer as per V4L2 specification.
 683      * Store control byte
 684      */
 685
 686         type = (rds_data[0] & BRCM_RDS_GRP_TYPE_MASK);
 687         block_index = (type >> 4);
 688         if (block_index < V4L2_RDS_BLOCK_A|| block_index > V4L2_RDS_BLOCK_C_ALT)
 689         {
 690             pr_err("(fm_rds) Block sequence mismatch\n");
 691             block_index = V4L2_RDS_BLOCK_INVALID;
 692         }
 693
 694         qlty_index = (tBRCM_RDS_QUALITY)((rds_data[0] & BRCM_RDS_GRP_QLTY_MASK) >> 2);
 695
 696         tmpbuf[2] = (block_index & V4L2_RDS_BLOCK_MSK);    /* Offset name */
 697         tmpbuf[2] |= ((block_index & V4L2_RDS_BLOCK_MSK) << 3);  /* Reserved offset */
 698
 699         switch(qlty_index)
 700         {
 701             case BRCM_RDS_NO_ERR:
 702                 /* Set bits 7 and 8 to 0 to indicate no error / correction*/
 703 #if V4L2_RDS_DEBUG
 704                 pr_info("(fm_rds) qlty : BRCM_RDS_NO_ERR\n");
 705 #endif
 706                 //tmpbuf[2] &= ~(BRCM_RDS_BIT_6 | BRCM_RDS_BIT_7);
 707
 708                 break;
 709
 710             case BRCM_RDS_2BIT_ERR:
 711             case BRCM_RDS_3BIT_ERR:
 712 #if V4L2_RDS_DEBUG
 713                 pr_info("(fm_rds) qlty : %s\n", ((qlty_index==BRCM_RDS_2BIT_ERR)?
 714                     "BRCM_RDS_2BIT_ERR":"BRCM_RDS_3BIT_ERR"));
 715 #endif
 716                 /* Set bit 7 to 1 and bit 8 to 0 indicate no error
 717                     but correction made*/
 718                 tmpbuf[2] |= (BRCM_RDS_BIT_6);
 719                 tmpbuf[2] &= ~(BRCM_RDS_BIT_7);
 720                 break;
 721
 722             case BRCM_RDS_UNRECOVER:
 723                 pr_info("(fm_rds) qlty : BRCM_RDS_UNRECOVER for data [ 0x%x 0x%x 0x%x]\n",
 724                     rds_data[0], rds_data[1], rds_data[2]);
 725                 /* Set bit 7 to 0 and bit 8 to 1 indicate error */
 726                 tmpbuf[2] |= (BRCM_RDS_BIT_7);
 727                 tmpbuf[2] &= ~(BRCM_RDS_BIT_6);
 728                 break;
 729              default :
 730                 pr_err("(fm_rds) Unknown quality code\n");
 731                 tmpbuf[2] |= (BRCM_RDS_BIT_7);
 732                 tmpbuf[2] &= ~(BRCM_RDS_BIT_6);
 733
 734         }
 735
 736         /* Store data byte. Swap bytes*/
 737         tmpbuf[0] = rds_data[2]; /* LSB of V4L2 spec block */
 738         tmpbuf[1] = rds_data[1]; /* MSB of V4L2 spec block */
 739 #if V4L2_RDS_DEBUG
 740         pr_info("(fm_rds) Copying [ 0x%x 0x%x 0x%x] as [0x%x 0x%x 0x%x] to V4L2\n",
 741                     rds_data[0], rds_data[1], rds_data[2],
 742                     tmpbuf[0], tmpbuf[1], tmpbuf[2]);
 743 #endif
 744         memcpy(&fmdev->rx.rds.cbuffer[fmdev->rx.rds.wr_index], &tmpbuf,
 745                FM_RDS_TUPLE_LENGTH);
 746         fmdev->rx.rds.wr_index =
 747             (fmdev->rx.rds.wr_index +
 748              FM_RDS_TUPLE_LENGTH) % fmdev->rx.rds.buf_size;
 749
 750         /* Check for overflow & start over */
 751         if (fmdev->rx.rds.wr_index == fmdev->rx.rds.rd_index) {
 752             pr_err("(fm_rds) RDS buffer overflow\n");
 753             fmdev->rx.rds.wr_index = 0;
 754             fmdev->rx.rds.rd_index = 0;
 755             break;
 756         }
 757
 758         /*Check for end of RDS tuple */
 759         if ((rds_data + FM_RDS_TUPLE_LENGTH)[FM_RDS_TUPLE_BYTE1] == FM_RDS_END_TUPLE_1ST_BYTE &&
 760             (rds_data + FM_RDS_TUPLE_LENGTH)[FM_RDS_TUPLE_BYTE2] == FM_RDS_END_TUPLE_2ND_BYTE &&
 761             (rds_data + FM_RDS_TUPLE_LENGTH)[FM_RDS_TUPLE_BYTE3] == FM_RDS_END_TUPLE_3RD_BYTE )
 762         {
 763             pr_err("(fm_rds) End of RDS tuple reached @ %d index\n", index);
 764             break;
 765         }
 766         response_len -= FM_RDS_TUPLE_LENGTH;
 767         rds_data += FM_RDS_TUPLE_LENGTH;
 768         index += FM_RDS_TUPLE_LENGTH;
 769     }
 770     spin_unlock_irqrestore(&fmdev->rds_cbuff_lock, flags);
 771
 772     /* Set Tuner RDS capability bit as RDS data has been detected */
 773     fmdev->device_info.rxsubchans |= V4L2_TUNER_SUB_RDS;
 774
 775     /* Wakeup read queue */
 776     if (fmdev->rx.rds.wr_index != fmdev->rx.rds.rd_index)
 777         wake_up_interruptible(&fmdev->rx.rds.read_queue);
 778
 779 #if V4L2_RDS_DEBUG
 780     pr_info("(fm_rds) Now reset the mask\n");
 781 #endif
 782     fmdev->rx.fm_rds_mask |= I2C_MASK_RDS_FIFO_WLINE_BIT;
 783
 784     ret = __fm_send_cmd(fmdev, FM_REG_FM_RDS_MSK, &fmdev->rx.fm_rds_mask,
 785                             2, REG_WR, NULL);
 786 #if V4L2_RDS_DEBUG
 787     pr_info("(fm_rds) %s(): Write to FM_REG_FM_RDS_MSK done : %d\n",
 788                                                         __func__, ret);
 789 #endif
 790     kfree(skb);
 791     return 0;
 792 }
 793
 794 /*
 795  * Read the FM_REG_FM_RDS_FLAG by sending a read command.
 796  * Called locally by fmdrv_main.c
 797  */
 798 void send_read_intrp_cmd(struct fmdrv_ops *fmdev)
 799 {
 800     unsigned char read_length;
 801     int ret;
 802
 803     read_length = FM_READ_2_BYTE_DATA;
 804     ret = __fm_send_cmd(fmdev, FM_REG_FM_RDS_FLAG, &read_length,
 805                             sizeof(read_length), REG_RD, NULL);
 806     if(ret < 0)
 807     {
 808         pr_err("(fmdrv) %s(): Error reading FM_REG_FM_RDS_FLAG\n", __func__);
 809     }
 810     pr_info("(fmdrv) %s(): Sent read to Interrupt flag FM_REG_FM_RDS_FLAG\n",
 811                                         __func__);
 812 }
 813
 814 /* Initiate a read to RDS register. Called locally by fmdrv_main.c */
 815 int read_rds_data(struct fmdrv_ops *fmdev)
 816 {
 817     unsigned char payload;
 818     int ret;
 819
 820     payload = FM_RDS_FIFO_MAX;
 821 #if V4L2_RDS_DEBUG
 822     pr_info("(fmdrv) %s(): Going to read RDS data from FM_REG_RDS_DATA!!\n",
 823                                         __func__);
 824 #endif
 825     ret = __fm_send_cmd(fmdev, FM_SETRDSMODE_SUB_CMD, &payload, 1, REG_RD, NULL);
 826     return 0;
 827 }
 828
 829 /*
 830  * Function to copy RDS data from the FM ring buffer
 831  * to the userspace buffer.
 832  */
 833 int fmc_transfer_rds_from_cbuff(struct fmdrv_ops *fmdev, struct file *file,
 834                     char __user * buf, size_t count)
 835 {
 836     unsigned int block_count;
 837     unsigned long flags;
 838     int ret;
 839
 840     /* Block if no new data available */
 841     if (fmdev->rx.rds.wr_index == fmdev->rx.rds.rd_index) {
 842         if (file->f_flags & O_NONBLOCK)
 843             return -EWOULDBLOCK;
 844
 845         ret = wait_event_interruptible(fmdev->rx.rds.read_queue,
 846                     (fmdev->rx.rds.wr_index != fmdev->rx.rds.rd_index));
 847         if (ret) {
 848             pr_err("(fm_rds) %s(): Error : EINTR\n", __func__);
 849             return -EINTR;
 850         }
 851     }
 852     /* Calculate block count from byte count */
 853
 854     spin_lock_irqsave(&fmdev->rds_cbuff_lock, flags);
 855         copy_to_user(buf, &fmdev->rx.rds.cbuffer[0],fmdev->rx.rds.buf_size);
 856
 857         //fmdev->rx.rds.wr_index=0;
 858         fmdev->rx.rds.rd_index=fmdev->rx.rds.buf_size;
 859
 860
 861 #if 0
 862
 863     /* Copy RDS blocks from the internal buffer and to user buffer */
 864     while (block_count < count) {
 865         if (fmdev->rx.rds.wr_index == fmdev->rx.rds.rd_index)
 866             break;
 867
 868         /* Always transfer complete RDS blocks */
 869         if (copy_to_user
 870             (buf, &fmdev->rx.rds.cbuffer[fmdev->rx.rds.rd_index],
 871              fmdev->rx.rds.buf_size))
 872             break;
 873
 874         /* Increment and wrap the read pointer */
 875         fmdev->rx.rds.rd_index += FM_RDS_BLOCK_SIZE;
 876
 877         /* Wrap read pointer */
 878         if (fmdev->rx.rds.rd_index >= fmdev->rx.rds.buf_size)
 879             fmdev->rx.rds.rd_index = 0;
 880
 881         /* Increment counters */
 882         block_count++;
 883         buf += FM_RDS_BLOCK_SIZE;
 884         ret += FM_RDS_BLOCK_SIZE;
 885     }
 886
 887 #endif
 888     spin_unlock_irqrestore(&fmdev->rds_cbuff_lock, flags);
 889 #if V4L2_RDS_DEBUG
 890     pr_info("(fm_rds) %s(): Done copying %d,wr_index=%d,rd_index=%d\n", __func__, fmdev->rx.rds.buf_size,fmdev->rx.rds.wr_index,fmdev->rx.rds.rd_index);
 891 #endif
 892     return fmdev->rx.rds.buf_size;
 893 }
 894
 895 /* Sets the frequency */
 896 int fmc_set_frequency(struct fmdrv_ops *fmdev, unsigned int freq_to_set)
 897 {
 898     int ret;
 899
 900     switch (fmdev->curr_fmmode) {
 901         case FM_MODE_RX:
 902             ret = fm_rx_set_frequency(fmdev, freq_to_set);
 903             break;
 904
 905         case FM_MODE_TX:
 906             /* Currently FM TX is not supported */
 907
 908         default:
 909             ret = -EINVAL;
 910     }
 911     return ret;
 912 }
 913
 914 /* Returns the current tuned frequency */
 915 int fmc_get_frequency(struct fmdrv_ops *fmdev, unsigned int *cur_tuned_frq)
 916 {
 917     int ret = 0;
 918
 919     switch (fmdev->curr_fmmode) {
 920         case FM_MODE_RX:
 921             ret = fm_rx_get_frequency(fmdev, cur_tuned_frq);
 922             break;
 923
 924         case FM_MODE_TX:
 925         /* Currently FM TX is not supported */
 926
 927         default:
 928             ret = -EINVAL;
 929     }
 930     return ret;
 931 }
 932
 933 /* Function to initiate SEEK operation */
 934 int fmc_seek_station(struct fmdrv_ops *fmdev, unsigned char direction_upward,
 935                     unsigned char wrap_around)
 936 {
 937     return fm_rx_seek_station(fmdev, direction_upward, wrap_around);
 938 }
 939
 940 /* Returns current band index (0-Europe/US; 1-Japan) */
 941 int fmc_get_region(struct fmdrv_ops *fmdev, unsigned char *region)
 942 {
 943     *region = fmdev->rx.curr_region;
 944     return 0;
 945 }
 946
 947 /* Set the world region */
 948 int fmc_set_region(struct fmdrv_ops *fmdev, unsigned char region_to_set)
 949 {
 950     int ret;
 951
 952     switch (fmdev->curr_fmmode) {
 953         case FM_MODE_RX:
 954             if (region_to_set == fmdev->rx.curr_region)
 955             {
 956                 pr_info("(fmdrv) %s(): Already region is set(%d)\n",
 957                                         __func__, region_to_set);
 958                 return 0;
 959             }
 960             ret = fm_rx_set_region(fmdev, region_to_set);
 961             break;
 962
 963         case FM_MODE_TX:
 964         /* Currently FM TX is not supported */
 965
 966         default:
 967             ret = -EINVAL;
 968     }
 969     return ret;
 970 }
 971
 972 /* Sets the audio mode */
 973 int fmc_set_audio_mode(struct fmdrv_ops *fmdev, unsigned char audio_mode)
 974 {
 975     int ret;
 976
 977     switch (fmdev->curr_fmmode) {
 978         case FM_MODE_RX:
 979             ret = fm_rx_set_audio_mode(fmdev, audio_mode);
 980             break;
 981
 982         case FM_MODE_TX:
 983             /* Currently FM TX is not supported */
 984
 985         default:
 986             ret = -EINVAL;
 987     }
 988     return ret;
 989 }
 990
 991 /* Sets the scan step */
 992 int fmc_set_scan_step(struct fmdrv_ops *fmdev, unsigned char scan_step)
 993 {
 994     int ret;
 995
 996     switch (fmdev->curr_fmmode) {
 997         case FM_MODE_RX:
 998             ret = fm_rx_set_scan_step(fmdev, scan_step);
 999             break;
1000
1001         case FM_MODE_TX:
1002             /* Currently FM TX is not supported */
1003
1004         default:
1005             ret = -EINVAL;
1006     }
1007     return ret;
1008 }
1009
1010 /*
1011 * Resets RDS cache parameters
1012 */
1013 void fmc_reset_rds_cache(struct fmdrv_ops *fmdev)
1014 {
1015     fmdev->rx.rds.rds_flag = FM_RDS_DISABLE;
1016     fmdev->rx.rds.wr_index = 0;
1017     fmdev->rx.rds.rd_index = 0;
1018     fmdev->device_info.rxsubchans &= ~V4L2_TUNER_SUB_RDS;
1019 }
1020
1021 /*
1022  * Turn FM ON by sending FM_ENABLE_SUB_CMD commmand
1023  */
1024 int fmc_turn_fm_on (struct fmdrv_ops *fmdev, unsigned char rds_flag)
1025 {
1026     int ret;
1027     //unsigned char payload; by wsh
1028         unsigned short payload;
1029
1030     if (rds_flag != FM_RDS_ENABLE && rds_flag != FM_RDS_DISABLE) {
1031         pr_err("(fmdrv) %s(): Invalid rds option\n", __func__);
1032         return -EINVAL;
1033     }
1034
1035     if (fmdev->softmute_blend_config.start_mute == 0x1) {
1036         payload=0x160;
1037         pr_info("(fmdrv) %s(): SOFT MUTE Enabled\n", __func__);
1038     }
1039     else{
1040         payload=0x60;
1041         pr_info("(fmdrv) %s(): SOFT MUTE Disabled start_mute = %d\n", __func__,fmdev->softmute_blend_config.start_mute);
1042     }
1043 /* by wsh
1044     if (rds_flag == FM_RDS_ENABLE)
1045         payload = (FM_ON | FM_RDS_ON);
1046     else
1047         payload = FM_ON;
1048 */
1049     ret = fmc_send_cmd(fmdev, FM_ENABLE_SUB_CMD, &payload, sizeof(payload),
1050             REG_WR, &fmdev->maintask_completion, NULL, NULL);
1051     FM_CHECK_SEND_CMD_STATUS(ret);
1052 #if V4L2_FM_DEBUG
1053     pr_debug("(fmdrv) %s(): FM_ENABLE_SUB_CMD write done\n", __func__);
1054 #endif
1055     fmdev->rx.rds.rds_flag = rds_flag;
1056     return ret;
1057 }
1058
1059 /*
1060  * Turn off FM
1061  */
1062 int fmc_turn_fm_off(struct fmdrv_ops *fmdev)
1063 {
1064     int ret = -EINVAL;
1065     unsigned char payload;
1066 #if 0 /* There is no chip side mute in sc2331 for FM*/
1067     /* Mute audio */
1068     payload = FM_MUTE_ON;    /* darrel issue_02 : mute on is value 1 */
1069     ret = fm_rx_set_mute_mode(fmdev, payload);
1070
1071     FM_CHECK_SEND_CMD_STATUS(ret);
1072
1073     if(ret < 0)
1074     {
1075         pr_err ("(fmdrv) %s(): FM mute off during FM Disable operation has failed\n",
1076                                                                         __func__);
1077         return ret;
1078     }
1079 #endif
1080     /* Disable FM */
1081     payload = FM_OFF;
1082
1083     ret = fmc_send_cmd(fmdev, FM_DISABLE_SUB_CMD, &payload, sizeof(payload),
1084             REG_WR, &fmdev->maintask_completion, NULL, NULL);
1085     FM_CHECK_SEND_CMD_STATUS(ret);
1086
1087     return ret;
1088 }
1089
1090 /*
1091  * Set FM Modes(TX, RX, OFF)
1092  * TX and RX modes are exclusive
1093  */
1094 int fmc_set_mode(struct fmdrv_ops *fmdev, unsigned char fm_mode)
1095 {
1096     int ret = 0;
1097
1098     if (fm_mode >= FM_MODE_ENTRY_MAX) {
1099         pr_err("(fmdrv) %s(): Invalid FM mode : %d\n", __func__, fm_mode);
1100         ret = -EINVAL;
1101         return ret;
1102     }
1103     if (fmdev->curr_fmmode == fm_mode) {
1104         pr_info("(fmdrv) %s(): Already fm is in mode(%d)", __func__, fm_mode);
1105          return ret;
1106     }
1107     fmdev->curr_fmmode = fm_mode;
1108     return ret;
1109 }
1110
1111 /*
1112  * Turn on FM, and other initialization to enable FM
1113  */
1114 int fmc_enable (struct fmdrv_ops *fmdev, unsigned char opt)
1115 {
1116     int ret;
1117     unsigned char rds_en_dis, rdbs_en_dis;
1118     unsigned char aud_ctrl;
1119     unsigned char read_length;
1120     unsigned char resp_buf [1];
1121     int resp_len;
1122         global_frequency=8750;
1123
1124     if (!test_bit(FM_CORE_READY, &fmdev->flag))
1125     {
1126         pr_err("(fmdrv) %s(): FM core is not ready\n", __func__);
1127         return -EPERM;
1128     }
1129
1130     fmc_set_mode (fmdev, FM_MODE_RX);
1131
1132 /*android:functionalityMask: bit4:RDS  bit5:RBDS bit6:AF  bit8:softmute default:352(5,6,8 bit=1)*/
1133
1134     /* turn FM ON */
1135     rds_en_dis = (opt & (FM_RDS_BIT | FM_RBDS_BIT)) ?
1136                             FM_RDS_ENABLE : FM_RDS_DISABLE;
1137
1138     ret = fmc_turn_fm_on (fmdev, rds_en_dis);
1139
1140     if (ret < 0)
1141     {
1142         pr_err ("(fmdrv) %s(): FM turn on failed\n", __func__);
1143         return ret;
1144     }
1145     fmdev->rx.fm_func_mask = opt;
1146     /* wait for 50 ms before sending any more commands */
1147     mdelay (50);
1148
1149     /* wrire rds control */
1150     rdbs_en_dis = (opt & FM_RBDS_BIT) ?
1151             FM_RDBS_ENABLE : FM_RDBS_DISABLE;
1152     ret = fm_rx_set_rds_system (fmdev, rdbs_en_dis);
1153
1154     if (ret < 0)
1155     {
1156         pr_err ("(fmdrv) %s(): set rds mode failed\n", __func__);
1157         return ret;
1158     }
1159     ret = fm_rx_set_region( fmdev,(opt & FM_REGION_MASK));
1160
1161     if (ret < 0)
1162     {
1163         pr_err ("(fmdrv) %s(): set region has failed\n", __func__);
1164         return ret;
1165     }
1166
1167         /* fmdev->rx.curr_rssi_threshold = DEF_V4L2_FM_SIGNAL_STRENGTH;*/
1168
1169     /* Read PCM Route settings */
1170
1171 /*********************don't need, beacause marlin auto check pcm, not depend on AP CMD ***
1172
1173     read_length = FM_READ_1_BYTE_DATA;
1174     ret = fmc_send_cmd(fmdev, FM_REG_PCM_ROUTE, &read_length, sizeof(read_length), REG_RD,
1175                     &fmdev->maintask_completion, &resp_buf, &resp_len);
1176     FM_CHECK_SEND_CMD_STATUS(ret);
1177     fmdev->rx.pcm_reg = resp_buf[0];
1178     pr_debug ("(fmdrv) %s(): pcm_reg value %d\n", __func__, fmdev->rx.pcm_reg);
1179
1180     // darrel : fm enable with mute state. added FM_MANUAL_MUTE
1181
1182     aud_ctrl = (unsigned short)(FM_AUDIO_DAC_ON | \
1183                     FM_RF_MUTE | FM_Z_MUTE_LEFT_OFF | FM_Z_MUTE_RITE_OFF | \
1184                     FM_MANUAL_MUTE | \
1185                     fmdev->rx.region.deemphasis);
1186
1187     ret = fm_rx_set_audio_ctrl(fmdev, aud_ctrl);
1188
1189     fmdev->rx.curr_rssi_threshold = DEF_V4L2_FM_SIGNAL_STRENGTH;
1190
1191     // Set world region
1192     pr_debug("(fmdrv) %s(): FM Set world region option : %d\n",
1193                                 __func__, DEF_V4L2_FM_WORLD_REGION);
1194     ret = fmc_set_region(fmdev, DEF_V4L2_FM_WORLD_REGION);
1195     if (ret < 0) {
1196         pr_err("(fmdrv) %s(): Unable to set World region\n", __func__);
1197         return ret;
1198     }
1199     fmdev->rx.curr_region = DEF_V4L2_FM_WORLD_REGION;
1200
1201 *******************************************************************************************/
1202
1203     /* Set Scan Step */
1204 #if(defined(DEF_V4L2_FM_WORLD_REGION) && DEF_V4L2_FM_WORLD_REGION == FM_REGION_NA)
1205     fmdev->rx.sch_step = FM_STEP_200KHZ;
1206 #else
1207     fmdev->rx.sch_step = FM_STEP_100KHZ;
1208 #endif
1209     pr_debug("(fmdrv) %s(): FM Set Scan Step : 0x%x\n", __func__, fmdev->rx.sch_step);
1210     ret = fmc_set_scan_step(fmdev, fmdev->rx.sch_step);
1211     if (ret < 0) {
1212         pr_err("(fmdrv) %s(): Unable to set scan step\n", __func__);
1213         return ret;
1214     }
1215
1216     /* Enable RDS */
1217     fm_rx_enable_rds(fmdev);
1218
1219     return ret;
1220 }
1221
1222 /*
1223 * Returns current FM mode (TX, RX, OFF) */
1224 int fmc_get_mode(struct fmdrv_ops *fmdev, unsigned char *fmmode)
1225 {
1226     if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
1227         pr_err("(fmdrv) %s(): FM core is not ready\n", __func__);
1228         return -EPERM;
1229     }
1230     if (fmmode == NULL) {
1231         pr_err("(fmdrv) %s(): Invalid memory\n", __func__);
1232         return -ENOMEM;
1233     }
1234
1235     *fmmode = fmdev->curr_fmmode;
1236     return 0;
1237 }
1238
1239 /*
1240 * Called by LDisc layer when FM packet is available. The pointer to
1241 * this function is registered to LDisc during brcm_sh_ldisc_register() call.*/
1242 static long fm_st_receive(void *arg, struct sk_buff *skb)
1243 {
1244     struct fmdrv_ops *fmdev;
1245 #if V4L2_FM_DEBUG
1246     int len;
1247 #endif
1248     __u8 pkt_type = 0x08;
1249
1250     fmdev = (struct fmdrv_ops *)arg;
1251 #if V4L2_FM_DEBUG
1252     pr_debug("(fmdrv): %s()\n", __func__);
1253 #endif
1254     if (skb == NULL) {
1255         pr_err("(fmdrv) %s(): Invalid SKB received from LDisp\n", __func__);
1256         return -EFAULT;
1257     }
1258     if (skb->cb[0] != FM_PKT_LOGICAL_CHAN_NUMBER) {
1259         pr_err("(fmdrv) %s(): Received SKB (0x%p) is not FM Channel 8 pkt\n",
1260                                                 __func__, skb);
1261         return -EINVAL;
1262     }
1263 #if V4L2_FM_DEBUG
1264         for (len = 0; ((skb) && (len < skb->len)); len++)
1265             pr_info(">> 0x%02x ", skb->data[len]);
1266 #endif
1267
1268     memcpy(skb_push(skb, 1), &pkt_type, 1);
1269     skb_queue_tail(&fmdev->rx_q, skb);
1270     pr_info("\n(fmdrv) %s(): fm_st_receive: schedule recv tasklet\n",
1271                                                         __func__);
1272     tasklet_schedule(&fmdev->rx_task);
1273
1274     return 0;
1275 }
1276
1277 /*
1278  * This function will be called from FM V4L2 open function.
1279  * Register with shared ldisc driver and initialize driver data.
1280  */
1281 int fmc_prepare(struct fmdrv_ops *fmdev)
1282 {
1283     static struct sh_proto_s fm_st_proto;
1284     int ret = 0;
1285
1286     if (test_bit(FM_CORE_READY, &fmdev->flag)) {
1287         pr_info("(fmdrv) %s(): FM Core is already up\n", __func__);
1288         return ret;
1289     }
1290
1291     memset(&fm_st_proto, 0, sizeof(fm_st_proto));
1292     fm_st_proto.type = PROTO_SH_FM;
1293     fm_st_proto.recv = fm_st_receive;
1294     fm_st_proto.match_packet = NULL;
1295     fm_st_proto.write = NULL; /* shared ldisc driver will fill write pointer */
1296     fm_st_proto.priv_data = fmdev;
1297
1298     /* Register with the shared line discipline */
1299     ret = hci_ldisc_register(&fm_st_proto);
1300     if (ret == -1) {
1301         pr_err("(fmdrv) %s(): hci_ldisc_register failed %d\n",
1302                                                         __func__, ret);
1303         ret = -EAGAIN;
1304         return ret;
1305     }
1306
1307     if (fm_st_proto.write != NULL) {
1308         g_bcm_write = fm_st_proto.write;
1309     }
1310     else {
1311         pr_err("(fmdrv) %s(): Failed to get shared ldisc write func pointer\n", __func__);
1312         ret = hci_ldisc_unregister(PROTO_SH_FM);
1313         if (ret < 0)
1314             pr_err("(fmdrv) %s(): hci_ldisc_unregister failed %d\n", __func__, ret);
1315             ret = -EAGAIN;
1316             return ret;
1317     }
1318
1319     spin_lock_init(&fmdev->resp_skb_lock);
1320
1321     /* Initialize TX queue and TX tasklet */
1322     skb_queue_head_init(&fmdev->tx_q);
1323     tasklet_init(&fmdev->tx_task, __send_tasklet, (unsigned long)fmdev);
1324
1325     /* Initialize RX Queue and RX tasklet */
1326     skb_queue_head_init(&fmdev->rx_q);
1327     tasklet_init(&fmdev->rx_task, __recv_tasklet, (unsigned long)fmdev);
1328
1329     atomic_set(&fmdev->tx_cnt, 1);
1330     fmdev->response_completion = NULL;
1331
1332     /* Do all the broadcom FM hardware specific initialization */
1333     fmdev->rx.curr_mute_mode = FM_MUTE_OFF;
1334     fmdev->rx.rds.rds_flag = FM_RDS_DISABLE;
1335     fmdev->rx.curr_region = DEF_V4L2_FM_WORLD_REGION;
1336     memcpy(&fmdev->rx.region, &region_configs[fmdev->rx.curr_region],
1337                             sizeof(struct region_info));
1338     fmdev->rx.curr_freq = fmdev->rx.region.low_bound;
1339     fmdev->rx.rds_mode = FM_RDS_SYSTEM_NONE;
1340     fmdev->rx.curr_snr_threshold = FM_RX_SNR_MAX + 1;
1341     fmdev->rx.curr_cos_threshold = FM_RX_COS_DEFAULT;
1342     fmdev->rx.curr_sch_mode = FM_SCAN_NONE;
1343     fmdev->rx.curr_noise_floor = FM_NFE_DEFAILT;
1344     fmdev->rx.curr_volume = FM_RX_VOLUME_MAX;
1345     fmdev->rx.audio_mode = FM_AUTO_MODE;
1346     fmdev->rx.audio_path = FM_AUDIO_NONE;
1347     fmdev->rx.sch_step = FM_STEP_NONE;
1348     fmdev->device_info.capabilities = V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
1349                                 V4L2_CAP_RADIO | V4L2_CAP_MODULATOR |
1350                                 V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_RDS_CAPTURE;
1351     fmdev->device_info.type = V4L2_TUNER_RADIO;
1352     fmdev->device_info.rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1353     fmdev->device_info.tuner_capability =V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS;
1354
1355     /* RDS initialization */
1356     fmc_reset_rds_cache(fmdev);
1357     init_waitqueue_head(&fmdev->rx.rds.read_queue);
1358
1359     set_bit(FM_CORE_READY, &fmdev->flag);
1360     return ret;
1361 }
1362
1363 /* This function will be called from FM V4L2 release function.
1364  * Unregister from line discipline driver.
1365  */
1366 int fmc_release(struct fmdrv_ops *fmdev)
1367 {
1368     int ret;
1369     pr_info("(fmdrv) %s\n", __func__);
1370
1371     if (!test_bit(FM_CORE_READY, &fmdev->flag)) {
1372         pr_info("(fmdrv) %s(): FM Core is already down\n", __func__);
1373         return 0;
1374     }
1375
1376     ret = hci_ldisc_unregister(PROTO_SH_FM);
1377     if (ret < 0)
1378         pr_err("(fmdrv) %s(): Failed to de-register FM from HCI LDisc - %d\n",
1379                                                                 __func__, ret);
1380     else
1381         pr_info("(fmdrv) %s(): Successfully unregistered from  HCI LDisc\n",
1382                                                                 __func__);
1383
1384     /* Sevice pending read */
1385     wake_up_interruptible(&fmdev->rx.rds.read_queue);
1386
1387     tasklet_kill(&fmdev->tx_task);
1388     tasklet_kill(&fmdev->rx_task);
1389
1390     skb_queue_purge(&fmdev->tx_q);
1391     skb_queue_purge(&fmdev->rx_q);
1392
1393     fmdev->response_completion = NULL;
1394     fmdev->rx.curr_freq = 0;
1395
1396     clear_bit(FM_CORE_READY, &fmdev->flag);
1397     return ret;
1398 }
1399
1400 /* Module init function. Ask FM V4L module to register video device.
1401  * Allocate memory for FM driver context
1402  */
1403 static int __init fm_drv_init(void)
1404 {
1405     struct fmdrv_ops *fmdev = NULL;
1406     int ret = -ENOMEM;
1407
1408     pr_info("(fmdrv) %s(): FM driver version %s\n", __func__, FM_DRV_VERSION);
1409
1410     fmdev = kzalloc(sizeof(struct fmdrv_ops), GFP_KERNEL);
1411     if (NULL == fmdev) {
1412         pr_err("(fmdrv) %s(): Can't allocate operation structure memory\n",
1413                                                                 __func__);
1414         return ret;
1415     }
1416
1417     fmdev->rx.rds.buf_size = default_rds_buf * FM_RDS_TUPLE_LENGTH;
1418     /* Allocate memory for RDS ring buffer */
1419     fmdev->rx.rds.cbuffer = kzalloc(fmdev->rx.rds.buf_size, GFP_KERNEL);
1420     if (fmdev->rx.rds.cbuffer == NULL) {
1421         pr_err("(fmdrv) %s(): Can't allocate rds ring buffer\n", __func__);
1422         kfree(fmdev);
1423         return -ENOMEM;
1424     }
1425
1426     ret = fm_v4l2_init_video_device(fmdev, radio_nr);
1427     if (ret < 0)
1428     {
1429         kfree(fmdev);
1430         return ret;
1431     }
1432
1433     fmdev->curr_fmmode = FM_MODE_OFF;
1434     return 0;
1435 }
1436
1437 /* Module exit function. Ask FM V4L module to unregister video device */
1438 static void __exit fm_drv_exit(void)
1439 {
1440     struct fmdrv_ops *fmdev = NULL;
1441     pr_info("(fmdrv): %s\n", __func__);
1442
1443     fmdev = fm_v4l2_deinit_video_device();
1444     if (fmdev != NULL) {
1445         kfree(fmdev);
1446     }
1447 }
1448
1449 module_init(fm_drv_init);
1450 module_exit(fm_drv_exit);
1451
1452 /* ------------- Module Info ------------- */
1453 MODULE_AUTHOR("Satyajit Roy <roys@broadcom.com>, Syed Ibrahim Moosa <syedibrahim.moosa@broadcom.com>");
1454 MODULE_DESCRIPTION("FM Driver for Connectivity chip of Broadcom Corporation. "
1455            FM_DRV_VERSION);
1456 MODULE_VERSION(FM_DRV_VERSION);
1457 MODULE_LICENSE("GPL");