drivers/mtk_wcn_combo/drv_fm/mt6626/pub/mt6626_fm_rds.c

   1 /* mt6626_rds.c
   2  *
   3  * (C) Copyright 2009
   4  * MediaTek <www.MediaTek.com>
   5  * hongcheng <hongcheng.xia@MediaTek.com>
   6  *
   7  * mt6626 FM Radio Driver
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23 #include "fm_typedef.h"
  24 #include "fm_dbg.h"
  25 #include "fm_err.h"
  26 #include "fm_interface.h"
  27 #include "fm_stdlib.h"
  28 #include "fm_rds.h"
  29
  30 #include "mt6626_fm_reg.h"
  31
  32
  33 static fm_bool bRDS_FirstIn = fm_false;
  34 static fm_u32 gBLER_CHK_INTERVAL = 5000;
  35 static fm_u16 GOOD_BLK_CNT = 0, BAD_BLK_CNT = 0;
  36 static fm_u8 BAD_BLK_RATIO = 0;
  37
  38 static struct fm_callback *fm_cb = NULL;
  39 static struct fm_basic_interface *fm_bi = NULL;
  40
  41
  42 static fm_bool mt6626_RDS_support(void);
  43 static fm_s32 mt6626_RDS_enable(void);
  44 static fm_s32 mt6626_RDS_disable(void);
  45 static fm_u16 mt6626_RDS_Get_GoodBlock_Counter(void);
  46 static fm_u16 mt6626_RDS_Get_BadBlock_Counter(void);
  47 static fm_u8 mt6626_RDS_Get_BadBlock_Ratio(void);
  48 static fm_u32 mt6626_RDS_Get_BlerCheck_Interval(void);
  49 static void mt6626_RDS_GetData(fm_u16 *data, fm_u16 datalen);
  50 static void mt6626_RDS_Init_Data(rds_t *pstRDSData);
  51
  52
  53
  54 static fm_bool mt6626_RDS_support(void)
  55 {
  56     return fm_true;
  57 }
  58
  59 static fm_s32 mt6626_RDS_enable(void)
  60 {
  61     fm_u16 dataRead;
  62
  63     WCN_DBG(FM_DBG | RDSC, "rds enable\n");
  64     fm_bi->read(FM_RDS_CFG0, &dataRead);
  65     fm_bi->write(FM_RDS_CFG0, 6); //set buf_start_th
  66     fm_bi->read(FM_MAIN_CTRL, &dataRead);
  67     fm_bi->write(FM_MAIN_CTRL, dataRead | (RDS_MASK));
  68
  69     return 0;
  70 }
  71
  72 static fm_s32 mt6626_RDS_disable(void)
  73 {
  74     fm_u16 dataRead;
  75
  76     WCN_DBG(FM_DBG | RDSC, "rds disable\n");
  77     fm_bi->read(FM_MAIN_CTRL, &dataRead);
  78     fm_bi->write(FM_MAIN_CTRL, dataRead&(~RDS_MASK));
  79
  80     return 0;
  81 }
  82
  83 static fm_u16 mt6626_RDS_Get_GoodBlock_Counter(void)
  84 {
  85     fm_u16 tmp_reg;
  86
  87     fm_bi->read(FM_RDS_GOODBK_CNT, &tmp_reg);
  88     GOOD_BLK_CNT = tmp_reg;
  89     WCN_DBG(FM_DBG | RDSC, "get good block cnt:%d\n", (fm_s32)tmp_reg);
  90
  91     return tmp_reg;
  92 }
  93
  94 static fm_u16 mt6626_RDS_Get_BadBlock_Counter(void)
  95 {
  96     fm_u16 tmp_reg;
  97
  98     fm_bi->read(FM_RDS_BADBK_CNT, &tmp_reg);
  99     BAD_BLK_CNT = tmp_reg;
 100     WCN_DBG(FM_DBG | RDSC, "get bad block cnt:%d\n", (fm_s32)tmp_reg);
 101
 102     return tmp_reg;
 103 }
 104
 105 static fm_u8 mt6626_RDS_Get_BadBlock_Ratio(void)
 106 {
 107     fm_u16 tmp_reg;
 108     fm_u16 gbc;
 109     fm_u16 bbc;
 110
 111     gbc = mt6626_RDS_Get_GoodBlock_Counter();
 112     bbc = mt6626_RDS_Get_BadBlock_Counter();
 113
 114     if ((gbc + bbc) > 0) {
 115         tmp_reg = (fm_u8)(bbc * 100 / (gbc + bbc));
 116     } else {
 117         tmp_reg = 0;
 118     }
 119
 120     BAD_BLK_RATIO = tmp_reg;
 121     WCN_DBG(FM_DBG | RDSC, "get badblock ratio:%d\n", (fm_s32)tmp_reg);
 122
 123     return tmp_reg;
 124 }
 125
 126 static fm_s32 mt6626_RDS_BlockCounter_Reset(void)
 127 {
 128     mt6626_RDS_disable();
 129     mt6626_RDS_enable();
 130
 131     return 0;
 132 }
 133
 134 static fm_u32 mt6626_RDS_Get_BlerCheck_Interval(void)
 135 {
 136     return gBLER_CHK_INTERVAL;
 137 }
 138
 139 static fm_s32 mt6626_RDS_BlerCheck(rds_t *dst)
 140 {
 141     return -1;
 142 }
 143
 144 static void RDS_Recovery_Handler(void)
 145 {
 146     fm_u16 tempData = 0;
 147
 148     do {
 149         fm_bi->read(FM_RDS_DATA_REG, &tempData);
 150         fm_bi->read(FM_RDS_POINTER, &tempData);
 151     } while (tempData & 0x3);
 152 }
 153
 154 static void mt6626_RDS_GetData(fm_u16 *data, fm_u16 datalen)
 155 {
 156 #define RDS_GROUP_DIFF_OFS          0x007C
 157 #define RDS_FIFO_DIFF               0x007F
 158 #define RDS_CRC_BLK_ADJ             0x0020
 159 #define RDS_CRC_CORR_CNT            0x001E
 160 #define RDS_CRC_INFO                0x0001
 161
 162     fm_u16 CRC = 0, i = 0, RDS_adj = 0, RDSDataCount = 0, FM_WARorrCnt = 0;
 163     fm_u16 temp = 0, OutputPofm_s32 = 0;
 164
 165     WCN_DBG(FM_DBG | RDSC, "get data\n");
 166     fm_bi->read(FM_RDS_FIFO_STATUS0, &temp);
 167     RDSDataCount = ((RDS_GROUP_DIFF_OFS & temp) << 2);
 168
 169     if ((temp & RDS_FIFO_DIFF) >= 4) {
 170         //block A data and info handling
 171         fm_bi->read(FM_RDS_INFO, &temp);
 172         RDS_adj |= (temp & RDS_CRC_BLK_ADJ) << 10;
 173         CRC |= (temp & RDS_CRC_INFO) << 3;
 174         FM_WARorrCnt |= ((temp & RDS_CRC_CORR_CNT) << 11);
 175         fm_bi->read(FM_RDS_DATA_REG, &data[0]);
 176
 177         //block B data and info handling
 178         fm_bi->read(FM_RDS_INFO, &temp);
 179         RDS_adj |= (temp & RDS_CRC_BLK_ADJ) << 9;
 180         CRC |= (temp & RDS_CRC_INFO) << 2;
 181         FM_WARorrCnt |= ((temp & RDS_CRC_CORR_CNT) << 7);
 182         fm_bi->read(FM_RDS_DATA_REG, &data[1]);
 183
 184         //block C data and info handling
 185         fm_bi->read(FM_RDS_INFO, &temp);
 186         RDS_adj |= (temp & RDS_CRC_BLK_ADJ) << 8;
 187         CRC |= (temp & RDS_CRC_INFO) << 1;
 188         FM_WARorrCnt |= ((temp & RDS_CRC_CORR_CNT) << 3);
 189         fm_bi->read(FM_RDS_DATA_REG, &data[2]);
 190
 191         //block D data and info handling
 192         fm_bi->read(FM_RDS_INFO, &temp);
 193         RDS_adj |= (temp & RDS_CRC_BLK_ADJ) << 7;
 194         CRC |= (temp & RDS_CRC_INFO);
 195         FM_WARorrCnt |= ((temp & RDS_CRC_CORR_CNT) >> 1);
 196         fm_bi->read(FM_RDS_DATA_REG, &data[3]);
 197
 198         data[4] = FM_WARorrCnt;     // CBC
 199         data[5] = (CRC | RDS_adj | RDSDataCount);   //CRC
 200
 201         fm_bi->read(FM_RDS_PWDI, &data[6]);
 202         fm_bi->read(FM_RDS_PWDQ, &data[7]);
 203
 204         fm_bi->read(FM_RDS_POINTER, &OutputPofm_s32);
 205
 206         //Go fm_s32o RDS recovery handler while RDS output pofm_s32 doesn't align to 4 in numeric
 207         if (OutputPofm_s32 & 0x3) {
 208             RDS_Recovery_Handler();
 209         }
 210
 211     } else {
 212         for (; i < 8; i++)
 213             data[i] = 0;
 214     }
 215 }
 216
 217 static void mt6626_RDS_Init_Data(rds_t *pstRDSData)
 218 {
 219     fm_memset(pstRDSData, 0, sizeof(rds_t));
 220     bRDS_FirstIn = fm_true;
 221
 222     fm_memset(pstRDSData->RT_Data.TextData, 0x20, sizeof(pstRDSData->RT_Data.TextData));
 223     fm_memset(pstRDSData->PS_Data.PS, '\0', sizeof(pstRDSData->PS_Data.PS));
 224     fm_memset(pstRDSData->PS_ON, 0x20, sizeof(pstRDSData->PS_ON));
 225 }
 226
 227 fm_bool mt6626_RDS_OnOff(rds_t *dst, fm_bool bFlag)
 228 {
 229     if (mt6626_RDS_support() == fm_false) {
 230         WCN_DBG(FM_ALT | RDSC, "mt6626_RDS_OnOff failed, RDS not support\n");
 231         return fm_false;
 232     }
 233
 234     if (bFlag) {
 235         mt6626_RDS_Init_Data(dst);
 236         mt6626_RDS_enable();
 237     } else {
 238         mt6626_RDS_disable();
 239     }
 240
 241     return fm_true;
 242 }
 243
 244 DEFINE_RDSLOG(rds_log);
 245
 246 /* mt6626_RDS_Efm_s32_Handler    -    response FM RDS interrupt
 247  * @fm - main data structure of FM driver
 248  * This function first get RDS raw data, then call RDS spec parser
 249  */
 250 static fm_s32 mt6626_rds_parser(rds_t *rds_dst, struct rds_rx_t *rds_raw, fm_s32 rds_size, fm_u16(*getfreq)(void))
 251 {
 252     struct rds_rx_t raw;
 253     fm_u16 fifo_offset;
 254
 255     do {
 256         mt6626_RDS_GetData(&raw.data[0].blkA, sizeof(rds_packet_t) + 2);
 257         fifo_offset = (raw.data[0].crc & FM_RDS_DCO_FIFO_OFST) >> 5; //FM_RDS_DATA_CRC_FFOST
 258         WCN_DBG(FM_DBG | RDSC, "RDS fifo_offset:%d\n", fifo_offset);
 259         rds_log.log_in(&rds_log, &raw, sizeof(rds_packet_t) + 2*sizeof(fm_u16));
 260         rds_parser(rds_dst, &raw, sizeof(rds_packet_t) + 2*sizeof(fm_u16), getfreq);
 261     } while (fifo_offset > 1);
 262
 263     return 0;
 264 }
 265
 266 static fm_s32 mt6626_rds_log_get(struct rds_rx_t *dst, fm_s32 *dst_len)
 267 {
 268     return rds_log.log_out(&rds_log, dst, dst_len);
 269 }
 270
 271 static fm_s32 mt6626_rds_gc_get(struct rds_group_cnt_t *dst, rds_t *rdsp)
 272 {
 273     return rds_grp_counter_get(dst, &rdsp->gc);
 274 }
 275
 276 static fm_s32 mt6626_rds_gc_reset(rds_t *rdsp)
 277 {
 278     return rds_grp_counter_reset(&rdsp->gc);
 279 }
 280
 281 fm_s32 fm_rds_ops_register(struct fm_lowlevel_ops *ops)
 282 {
 283     fm_s32 ret = 0;
 284
 285     FMR_ASSERT(ops);
 286     FMR_ASSERT(ops->bi.write);
 287     FMR_ASSERT(ops->bi.read);
 288     FMR_ASSERT(ops->bi.setbits);
 289     FMR_ASSERT(ops->bi.usdelay);
 290     fm_bi = &ops->bi;
 291
 292     FMR_ASSERT(ops->cb.cur_freq_get);
 293     FMR_ASSERT(ops->cb.cur_freq_set);
 294     fm_cb = &ops->cb;
 295
 296     ops->ri.rds_blercheck = mt6626_RDS_BlerCheck;
 297     ops->ri.rds_onoff = mt6626_RDS_OnOff;
 298     ops->ri.rds_parser = mt6626_rds_parser;
 299     ops->ri.rds_gbc_get = mt6626_RDS_Get_GoodBlock_Counter;
 300     ops->ri.rds_bbc_get = mt6626_RDS_Get_BadBlock_Counter;
 301     ops->ri.rds_bbr_get = mt6626_RDS_Get_BadBlock_Ratio;
 302     ops->ri.rds_bc_reset = mt6626_RDS_BlockCounter_Reset;
 303     ops->ri.rds_bci_get = mt6626_RDS_Get_BlerCheck_Interval;
 304     ops->ri.rds_log_get = mt6626_rds_log_get;
 305     ops->ri.rds_gc_get = mt6626_rds_gc_get;
 306     ops->ri.rds_gc_reset = mt6626_rds_gc_reset;
 307     return ret;
 308 }
 309
 310 fm_s32 fm_rds_ops_unregister(struct fm_lowlevel_ops *ops)
 311 {
 312     fm_s32 ret = 0;
 313
 314     FMR_ASSERT(ops);
 315
 316     fm_bi = NULL;
 317     fm_memset(&ops->ri, 0, sizeof(struct fm_rds_interface));
 318     return ret;
 319 }
 320