1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Abilis Systems Single DVB-T Receiver 4 * Copyright (C) 2008 Pierrick Hascoet <pierrick.hascoet@abilis.com> 5 * Copyright (C) 2010 Devin Heitmueller <dheitmueller@kernellabs.com> 6 */ 7 8 #include <media/dvb_frontend.h> 9 10 #include "as102_fe.h" 11 12 struct as102_state { 13 struct dvb_frontend frontend; 14 struct as10x_demod_stats demod_stats; 15 16 const struct as102_fe_ops *ops; 17 void *priv; 18 uint8_t elna_cfg; 19 20 /* signal strength */ 21 uint16_t signal_strength; 22 /* bit error rate */ 23 uint32_t ber; 24 }; 25 26 static uint8_t as102_fe_get_code_rate(enum fe_code_rate arg) 27 { 28 uint8_t c; 29 30 switch (arg) { 31 case FEC_1_2: 32 c = CODE_RATE_1_2; 33 break; 34 case FEC_2_3: 35 c = CODE_RATE_2_3; 36 break; 37 case FEC_3_4: 38 c = CODE_RATE_3_4; 39 break; 40 case FEC_5_6: 41 c = CODE_RATE_5_6; 42 break; 43 case FEC_7_8: 44 c = CODE_RATE_7_8; 45 break; 46 default: 47 c = CODE_RATE_UNKNOWN; 48 break; 49 } 50 51 return c; 52 } 53 54 static int as102_fe_set_frontend(struct dvb_frontend *fe) 55 { 56 struct as102_state *state = fe->demodulator_priv; 57 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 58 struct as10x_tune_args tune_args = { 0 }; 59 60 /* set frequency */ 61 tune_args.freq = c->frequency / 1000; 62 63 /* fix interleaving_mode */ 64 tune_args.interleaving_mode = INTLV_NATIVE; 65 66 switch (c->bandwidth_hz) { 67 case 8000000: 68 tune_args.bandwidth = BW_8_MHZ; 69 break; 70 case 7000000: 71 tune_args.bandwidth = BW_7_MHZ; 72 break; 73 case 6000000: 74 tune_args.bandwidth = BW_6_MHZ; 75 break; 76 default: 77 tune_args.bandwidth = BW_8_MHZ; 78 } 79 80 switch (c->guard_interval) { 81 case GUARD_INTERVAL_1_32: 82 tune_args.guard_interval = GUARD_INT_1_32; 83 break; 84 case GUARD_INTERVAL_1_16: 85 tune_args.guard_interval = GUARD_INT_1_16; 86 break; 87 case GUARD_INTERVAL_1_8: 88 tune_args.guard_interval = GUARD_INT_1_8; 89 break; 90 case GUARD_INTERVAL_1_4: 91 tune_args.guard_interval = GUARD_INT_1_4; 92 break; 93 case GUARD_INTERVAL_AUTO: 94 default: 95 tune_args.guard_interval = GUARD_UNKNOWN; 96 break; 97 } 98 99 switch (c->modulation) { 100 case QPSK: 101 tune_args.modulation = CONST_QPSK; 102 break; 103 case QAM_16: 104 tune_args.modulation = CONST_QAM16; 105 break; 106 case QAM_64: 107 tune_args.modulation = CONST_QAM64; 108 break; 109 default: 110 tune_args.modulation = CONST_UNKNOWN; 111 break; 112 } 113 114 switch (c->transmission_mode) { 115 case TRANSMISSION_MODE_2K: 116 tune_args.transmission_mode = TRANS_MODE_2K; 117 break; 118 case TRANSMISSION_MODE_8K: 119 tune_args.transmission_mode = TRANS_MODE_8K; 120 break; 121 default: 122 tune_args.transmission_mode = TRANS_MODE_UNKNOWN; 123 } 124 125 switch (c->hierarchy) { 126 case HIERARCHY_NONE: 127 tune_args.hierarchy = HIER_NONE; 128 break; 129 case HIERARCHY_1: 130 tune_args.hierarchy = HIER_ALPHA_1; 131 break; 132 case HIERARCHY_2: 133 tune_args.hierarchy = HIER_ALPHA_2; 134 break; 135 case HIERARCHY_4: 136 tune_args.hierarchy = HIER_ALPHA_4; 137 break; 138 case HIERARCHY_AUTO: 139 tune_args.hierarchy = HIER_UNKNOWN; 140 break; 141 } 142 143 pr_debug("as102: tuner parameters: freq: %d bw: 0x%02x gi: 0x%02x\n", 144 c->frequency, 145 tune_args.bandwidth, 146 tune_args.guard_interval); 147 148 /* 149 * Detect a hierarchy selection 150 * if HP/LP are both set to FEC_NONE, HP will be selected. 151 */ 152 if ((tune_args.hierarchy != HIER_NONE) && 153 ((c->code_rate_LP == FEC_NONE) || 154 (c->code_rate_HP == FEC_NONE))) { 155 156 if (c->code_rate_LP == FEC_NONE) { 157 tune_args.hier_select = HIER_HIGH_PRIORITY; 158 tune_args.code_rate = 159 as102_fe_get_code_rate(c->code_rate_HP); 160 } 161 162 if (c->code_rate_HP == FEC_NONE) { 163 tune_args.hier_select = HIER_LOW_PRIORITY; 164 tune_args.code_rate = 165 as102_fe_get_code_rate(c->code_rate_LP); 166 } 167 168 pr_debug("as102: \thierarchy: 0x%02x selected: %s code_rate_%s: 0x%02x\n", 169 tune_args.hierarchy, 170 tune_args.hier_select == HIER_HIGH_PRIORITY ? 171 "HP" : "LP", 172 tune_args.hier_select == HIER_HIGH_PRIORITY ? 173 "HP" : "LP", 174 tune_args.code_rate); 175 } else { 176 tune_args.code_rate = 177 as102_fe_get_code_rate(c->code_rate_HP); 178 } 179 180 /* Set frontend arguments */ 181 return state->ops->set_tune(state->priv, &tune_args); 182 } 183 184 static int as102_fe_get_frontend(struct dvb_frontend *fe, 185 struct dtv_frontend_properties *c) 186 { 187 struct as102_state *state = fe->demodulator_priv; 188 int ret = 0; 189 struct as10x_tps tps = { 0 }; 190 191 /* send abilis command: GET_TPS */ 192 ret = state->ops->get_tps(state->priv, &tps); 193 if (ret < 0) 194 return ret; 195 196 /* extract constellation */ 197 switch (tps.modulation) { 198 case CONST_QPSK: 199 c->modulation = QPSK; 200 break; 201 case CONST_QAM16: 202 c->modulation = QAM_16; 203 break; 204 case CONST_QAM64: 205 c->modulation = QAM_64; 206 break; 207 } 208 209 /* extract hierarchy */ 210 switch (tps.hierarchy) { 211 case HIER_NONE: 212 c->hierarchy = HIERARCHY_NONE; 213 break; 214 case HIER_ALPHA_1: 215 c->hierarchy = HIERARCHY_1; 216 break; 217 case HIER_ALPHA_2: 218 c->hierarchy = HIERARCHY_2; 219 break; 220 case HIER_ALPHA_4: 221 c->hierarchy = HIERARCHY_4; 222 break; 223 } 224 225 /* extract code rate HP */ 226 switch (tps.code_rate_HP) { 227 case CODE_RATE_1_2: 228 c->code_rate_HP = FEC_1_2; 229 break; 230 case CODE_RATE_2_3: 231 c->code_rate_HP = FEC_2_3; 232 break; 233 case CODE_RATE_3_4: 234 c->code_rate_HP = FEC_3_4; 235 break; 236 case CODE_RATE_5_6: 237 c->code_rate_HP = FEC_5_6; 238 break; 239 case CODE_RATE_7_8: 240 c->code_rate_HP = FEC_7_8; 241 break; 242 } 243 244 /* extract code rate LP */ 245 switch (tps.code_rate_LP) { 246 case CODE_RATE_1_2: 247 c->code_rate_LP = FEC_1_2; 248 break; 249 case CODE_RATE_2_3: 250 c->code_rate_LP = FEC_2_3; 251 break; 252 case CODE_RATE_3_4: 253 c->code_rate_LP = FEC_3_4; 254 break; 255 case CODE_RATE_5_6: 256 c->code_rate_LP = FEC_5_6; 257 break; 258 case CODE_RATE_7_8: 259 c->code_rate_LP = FEC_7_8; 260 break; 261 } 262 263 /* extract guard interval */ 264 switch (tps.guard_interval) { 265 case GUARD_INT_1_32: 266 c->guard_interval = GUARD_INTERVAL_1_32; 267 break; 268 case GUARD_INT_1_16: 269 c->guard_interval = GUARD_INTERVAL_1_16; 270 break; 271 case GUARD_INT_1_8: 272 c->guard_interval = GUARD_INTERVAL_1_8; 273 break; 274 case GUARD_INT_1_4: 275 c->guard_interval = GUARD_INTERVAL_1_4; 276 break; 277 } 278 279 /* extract transmission mode */ 280 switch (tps.transmission_mode) { 281 case TRANS_MODE_2K: 282 c->transmission_mode = TRANSMISSION_MODE_2K; 283 break; 284 case TRANS_MODE_8K: 285 c->transmission_mode = TRANSMISSION_MODE_8K; 286 break; 287 } 288 289 return 0; 290 } 291 292 static int as102_fe_get_tune_settings(struct dvb_frontend *fe, 293 struct dvb_frontend_tune_settings *settings) 294 { 295 296 settings->min_delay_ms = 1000; 297 298 return 0; 299 } 300 301 static int as102_fe_read_status(struct dvb_frontend *fe, enum fe_status *status) 302 { 303 int ret = 0; 304 struct as102_state *state = fe->demodulator_priv; 305 struct as10x_tune_status tstate = { 0 }; 306 307 /* send abilis command: GET_TUNE_STATUS */ 308 ret = state->ops->get_status(state->priv, &tstate); 309 if (ret < 0) 310 return ret; 311 312 state->signal_strength = tstate.signal_strength; 313 state->ber = tstate.BER; 314 315 switch (tstate.tune_state) { 316 case TUNE_STATUS_SIGNAL_DVB_OK: 317 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER; 318 break; 319 case TUNE_STATUS_STREAM_DETECTED: 320 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC | 321 FE_HAS_VITERBI; 322 break; 323 case TUNE_STATUS_STREAM_TUNED: 324 *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC | 325 FE_HAS_LOCK | FE_HAS_VITERBI; 326 break; 327 default: 328 *status = TUNE_STATUS_NOT_TUNED; 329 } 330 331 pr_debug("as102: tuner status: 0x%02x, strength %d, per: %d, ber: %d\n", 332 tstate.tune_state, tstate.signal_strength, 333 tstate.PER, tstate.BER); 334 335 if (!(*status & FE_HAS_LOCK)) { 336 memset(&state->demod_stats, 0, sizeof(state->demod_stats)); 337 return 0; 338 } 339 340 ret = state->ops->get_stats(state->priv, &state->demod_stats); 341 if (ret < 0) 342 memset(&state->demod_stats, 0, sizeof(state->demod_stats)); 343 344 return ret; 345 } 346 347 /* 348 * Note: 349 * - in AS102 SNR=MER 350 * - the SNR will be returned in linear terms, i.e. not in dB 351 * - the accuracy equals ±2dB for a SNR range from 4dB to 30dB 352 * - the accuracy is >2dB for SNR values outside this range 353 */ 354 static int as102_fe_read_snr(struct dvb_frontend *fe, u16 *snr) 355 { 356 struct as102_state *state = fe->demodulator_priv; 357 358 *snr = state->demod_stats.mer; 359 360 return 0; 361 } 362 363 static int as102_fe_read_ber(struct dvb_frontend *fe, u32 *ber) 364 { 365 struct as102_state *state = fe->demodulator_priv; 366 367 *ber = state->ber; 368 369 return 0; 370 } 371 372 static int as102_fe_read_signal_strength(struct dvb_frontend *fe, 373 u16 *strength) 374 { 375 struct as102_state *state = fe->demodulator_priv; 376 377 *strength = (((0xffff * 400) * state->signal_strength + 41000) * 2); 378 379 return 0; 380 } 381 382 static int as102_fe_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 383 { 384 struct as102_state *state = fe->demodulator_priv; 385 386 if (state->demod_stats.has_started) 387 *ucblocks = state->demod_stats.bad_frame_count; 388 else 389 *ucblocks = 0; 390 391 return 0; 392 } 393 394 static int as102_fe_ts_bus_ctrl(struct dvb_frontend *fe, int acquire) 395 { 396 struct as102_state *state = fe->demodulator_priv; 397 398 return state->ops->stream_ctrl(state->priv, acquire, 399 state->elna_cfg); 400 } 401 402 static void as102_fe_release(struct dvb_frontend *fe) 403 { 404 struct as102_state *state = fe->demodulator_priv; 405 406 kfree(state); 407 } 408 409 410 static const struct dvb_frontend_ops as102_fe_ops = { 411 .delsys = { SYS_DVBT }, 412 .info = { 413 .name = "Abilis AS102 DVB-T", 414 .frequency_min_hz = 174 * MHz, 415 .frequency_max_hz = 862 * MHz, 416 .frequency_stepsize_hz = 166667, 417 .caps = FE_CAN_INVERSION_AUTO 418 | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 419 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO 420 | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QPSK 421 | FE_CAN_QAM_AUTO 422 | FE_CAN_TRANSMISSION_MODE_AUTO 423 | FE_CAN_GUARD_INTERVAL_AUTO 424 | FE_CAN_HIERARCHY_AUTO 425 | FE_CAN_RECOVER 426 | FE_CAN_MUTE_TS 427 }, 428 429 .set_frontend = as102_fe_set_frontend, 430 .get_frontend = as102_fe_get_frontend, 431 .get_tune_settings = as102_fe_get_tune_settings, 432 433 .read_status = as102_fe_read_status, 434 .read_snr = as102_fe_read_snr, 435 .read_ber = as102_fe_read_ber, 436 .read_signal_strength = as102_fe_read_signal_strength, 437 .read_ucblocks = as102_fe_read_ucblocks, 438 .ts_bus_ctrl = as102_fe_ts_bus_ctrl, 439 .release = as102_fe_release, 440 }; 441 442 struct dvb_frontend *as102_attach(const char *name, 443 const struct as102_fe_ops *ops, 444 void *priv, 445 uint8_t elna_cfg) 446 { 447 struct as102_state *state; 448 struct dvb_frontend *fe; 449 450 state = kzalloc(sizeof(*state), GFP_KERNEL); 451 if (!state) 452 return NULL; 453 454 fe = &state->frontend; 455 fe->demodulator_priv = state; 456 state->ops = ops; 457 state->priv = priv; 458 state->elna_cfg = elna_cfg; 459 460 /* init frontend callback ops */ 461 memcpy(&fe->ops, &as102_fe_ops, sizeof(struct dvb_frontend_ops)); 462 strscpy(fe->ops.info.name, name, sizeof(fe->ops.info.name)); 463 464 return fe; 465 466 } 467 EXPORT_SYMBOL_GPL(as102_attach); 468 469 MODULE_DESCRIPTION("as102-fe"); 470 MODULE_LICENSE("GPL"); 471 MODULE_AUTHOR("Pierrick Hascoet <pierrick.hascoet@abilis.com>"); 472