drivers/media/usb/dvb-usb/dtt200u-fe.c

   1 /* Frontend part of the Linux driver for the WideView/ Yakumo/ Hama/
   2  * Typhoon/ Yuan DVB-T USB2.0 receiver.
   3  *
   4  * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@posteo.de>
   5  *
   6  *      This program is free software; you can redistribute it and/or modify it
   7  *      under the terms of the GNU General Public License as published by the Free
   8  *      Software Foundation, version 2.
   9  *
  10  * see Documentation/dvb/README.dvb-usb for more information
  11  */
  12 #include "dtt200u.h"
  13
  14 struct dtt200u_fe_state {
  15         struct dvb_usb_device *d;
  16
  17         enum fe_status stat;
  18
  19         struct dtv_frontend_properties fep;
  20         struct dvb_frontend frontend;
  21 };
  22
  23 static int dtt200u_fe_read_status(struct dvb_frontend *fe,
  24                                   enum fe_status *stat)
  25 {
  26         struct dtt200u_fe_state *state = fe->demodulator_priv;
  27         u8 st = GET_TUNE_STATUS, b[3];
  28
  29         dvb_usb_generic_rw(state->d,&st,1,b,3,0);
  30
  31         switch (b[0]) {
  32                 case 0x01:
  33                         *stat = FE_HAS_SIGNAL | FE_HAS_CARRIER |
  34                                 FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
  35                         break;
  36                 case 0x00: /* pending */
  37                         *stat = FE_TIMEDOUT; /* during set_frontend */
  38                         break;
  39                 default:
  40                 case 0x02: /* failed */
  41                         *stat = 0;
  42                         break;
  43         }
  44         return 0;
  45 }
  46
  47 static int dtt200u_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
  48 {
  49         struct dtt200u_fe_state *state = fe->demodulator_priv;
  50         u8 bw = GET_VIT_ERR_CNT,b[3];
  51         dvb_usb_generic_rw(state->d,&bw,1,b,3,0);
  52         *ber = (b[0] << 16) | (b[1] << 8) | b[2];
  53         return 0;
  54 }
  55
  56 static int dtt200u_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
  57 {
  58         struct dtt200u_fe_state *state = fe->demodulator_priv;
  59         u8 bw = GET_RS_UNCOR_BLK_CNT,b[2];
  60
  61         dvb_usb_generic_rw(state->d,&bw,1,b,2,0);
  62         *unc = (b[0] << 8) | b[1];
  63         return 0;
  64 }
  65
  66 static int dtt200u_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
  67 {
  68         struct dtt200u_fe_state *state = fe->demodulator_priv;
  69         u8 bw = GET_AGC, b;
  70         dvb_usb_generic_rw(state->d,&bw,1,&b,1,0);
  71         *strength = (b << 8) | b;
  72         return 0;
  73 }
  74
  75 static int dtt200u_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
  76 {
  77         struct dtt200u_fe_state *state = fe->demodulator_priv;
  78         u8 bw = GET_SNR,br;
  79         dvb_usb_generic_rw(state->d,&bw,1,&br,1,0);
  80         *snr = ~((br << 8) | br);
  81         return 0;
  82 }
  83
  84 static int dtt200u_fe_init(struct dvb_frontend* fe)
  85 {
  86         struct dtt200u_fe_state *state = fe->demodulator_priv;
  87         u8 b = SET_INIT;
  88         return dvb_usb_generic_write(state->d,&b,1);
  89 }
  90
  91 static int dtt200u_fe_sleep(struct dvb_frontend* fe)
  92 {
  93         return dtt200u_fe_init(fe);
  94 }
  95
  96 static int dtt200u_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
  97 {
  98         tune->min_delay_ms = 1500;
  99         tune->step_size = 0;
 100         tune->max_drift = 0;
 101         return 0;
 102 }
 103
 104 static int dtt200u_fe_set_frontend(struct dvb_frontend *fe)
 105 {
 106         struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
 107         struct dtt200u_fe_state *state = fe->demodulator_priv;
 108         int i;
 109         enum fe_status st;
 110         u16 freq = fep->frequency / 250000;
 111         u8 bwbuf[2] = { SET_BANDWIDTH, 0 },freqbuf[3] = { SET_RF_FREQ, 0, 0 };
 112
 113         switch (fep->bandwidth_hz) {
 114         case 8000000:
 115                 bwbuf[1] = 8;
 116                 break;
 117         case 7000000:
 118                 bwbuf[1] = 7;
 119                 break;
 120         case 6000000:
 121                 bwbuf[1] = 6;
 122                 break;
 123         default:
 124                 return -EINVAL;
 125         }
 126
 127         dvb_usb_generic_write(state->d,bwbuf,2);
 128
 129         freqbuf[1] = freq & 0xff;
 130         freqbuf[2] = (freq >> 8) & 0xff;
 131         dvb_usb_generic_write(state->d,freqbuf,3);
 132
 133         for (i = 0; i < 30; i++) {
 134                 msleep(20);
 135                 dtt200u_fe_read_status(fe, &st);
 136                 if (st & FE_TIMEDOUT)
 137                         continue;
 138         }
 139
 140         return 0;
 141 }
 142
 143 static int dtt200u_fe_get_frontend(struct dvb_frontend* fe,
 144                                    struct dtv_frontend_properties *fep)
 145 {
 146         struct dtt200u_fe_state *state = fe->demodulator_priv;
 147
 148         memcpy(fep, &state->fep, sizeof(struct dtv_frontend_properties));
 149         return 0;
 150 }
 151
 152 static void dtt200u_fe_release(struct dvb_frontend* fe)
 153 {
 154         struct dtt200u_fe_state *state = (struct dtt200u_fe_state*) fe->demodulator_priv;
 155         kfree(state);
 156 }
 157
 158 static struct dvb_frontend_ops dtt200u_fe_ops;
 159
 160 struct dvb_frontend* dtt200u_fe_attach(struct dvb_usb_device *d)
 161 {
 162         struct dtt200u_fe_state* state = NULL;
 163
 164         /* allocate memory for the internal state */
 165         state = kzalloc(sizeof(struct dtt200u_fe_state), GFP_KERNEL);
 166         if (state == NULL)
 167                 goto error;
 168
 169         deb_info("attaching frontend dtt200u\n");
 170
 171         state->d = d;
 172
 173         memcpy(&state->frontend.ops,&dtt200u_fe_ops,sizeof(struct dvb_frontend_ops));
 174         state->frontend.demodulator_priv = state;
 175
 176         return &state->frontend;
 177 error:
 178         return NULL;
 179 }
 180
 181 static struct dvb_frontend_ops dtt200u_fe_ops = {
 182         .delsys = { SYS_DVBT },
 183         .info = {
 184                 .name                   = "WideView USB DVB-T",
 185                 .frequency_min          = 44250000,
 186                 .frequency_max          = 867250000,
 187                 .frequency_stepsize     = 250000,
 188                 .caps = FE_CAN_INVERSION_AUTO |
 189                                 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 190                                 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 191                                 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 192                                 FE_CAN_TRANSMISSION_MODE_AUTO |
 193                                 FE_CAN_GUARD_INTERVAL_AUTO |
 194                                 FE_CAN_RECOVER |
 195                                 FE_CAN_HIERARCHY_AUTO,
 196         },
 197
 198         .release = dtt200u_fe_release,
 199
 200         .init = dtt200u_fe_init,
 201         .sleep = dtt200u_fe_sleep,
 202
 203         .set_frontend = dtt200u_fe_set_frontend,
 204         .get_frontend = dtt200u_fe_get_frontend,
 205         .get_tune_settings = dtt200u_fe_get_tune_settings,
 206
 207         .read_status = dtt200u_fe_read_status,
 208         .read_ber = dtt200u_fe_read_ber,
 209         .read_signal_strength = dtt200u_fe_read_signal_strength,
 210         .read_snr = dtt200u_fe_read_snr,
 211         .read_ucblocks = dtt200u_fe_read_unc_blocks,
 212 };