git.oblomov.eu Git - linux-2.6/blob - drivers/media/dvb/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@desy.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         fe_status_t stat;
  18
  19         struct dvb_frontend_parameters fep;
  20         struct dvb_frontend frontend;
  21         struct dvb_frontend_ops ops;
  22 };
  23
  24 static int dtt200u_fe_read_status(struct dvb_frontend* fe, fe_status_t *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                                   struct dvb_frontend_parameters *fep)
 106 {
 107         struct dtt200u_fe_state *state = fe->demodulator_priv;
 108         int i;
 109         fe_status_t 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->u.ofdm.bandwidth) {
 114                 case BANDWIDTH_8_MHZ: bwbuf[1] = 8; break;
 115                 case BANDWIDTH_7_MHZ: bwbuf[1] = 7; break;
 116                 case BANDWIDTH_6_MHZ: bwbuf[1] = 6; break;
 117                 case BANDWIDTH_AUTO: return -EOPNOTSUPP;
 118                 default:
 119                         return -EINVAL;
 120         }
 121
 122         dvb_usb_generic_write(state->d,bwbuf,2);
 123
 124         freqbuf[1] = freq & 0xff;
 125         freqbuf[2] = (freq >> 8) & 0xff;
 126         dvb_usb_generic_write(state->d,freqbuf,3);
 127
 128         for (i = 0; i < 30; i++) {
 129                 msleep(20);
 130                 dtt200u_fe_read_status(fe, &st);
 131                 if (st & FE_TIMEDOUT)
 132                         continue;
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int dtt200u_fe_get_frontend(struct dvb_frontend* fe,
 139                                   struct dvb_frontend_parameters *fep)
 140 {
 141         struct dtt200u_fe_state *state = fe->demodulator_priv;
 142         memcpy(fep,&state->fep,sizeof(struct dvb_frontend_parameters));
 143         return 0;
 144 }
 145
 146 static void dtt200u_fe_release(struct dvb_frontend* fe)
 147 {
 148         struct dtt200u_fe_state *state = (struct dtt200u_fe_state*) fe->demodulator_priv;
 149         kfree(state);
 150 }
 151
 152 static struct dvb_frontend_ops dtt200u_fe_ops;
 153
 154 struct dvb_frontend* dtt200u_fe_attach(struct dvb_usb_device *d)
 155 {
 156         struct dtt200u_fe_state* state = NULL;
 157
 158         /* allocate memory for the internal state */
 159         state = (struct dtt200u_fe_state*) kmalloc(sizeof(struct dtt200u_fe_state), GFP_KERNEL);
 160         if (state == NULL)
 161                 goto error;
 162         memset(state,0,sizeof(struct dtt200u_fe_state));
 163
 164         deb_info("attaching frontend dtt200u\n");
 165
 166         state->d = d;
 167         memcpy(&state->ops,&dtt200u_fe_ops,sizeof(struct dvb_frontend_ops));
 168
 169         state->frontend.ops = &state->ops;
 170         state->frontend.demodulator_priv = state;
 171
 172         goto success;
 173 error:
 174         return NULL;
 175 success:
 176         return &state->frontend;
 177 }
 178
 179 static struct dvb_frontend_ops dtt200u_fe_ops = {
 180         .info = {
 181                 .name                   = "WideView USB DVB-T",
 182                 .type                   = FE_OFDM,
 183                 .frequency_min          = 44250000,
 184                 .frequency_max          = 867250000,
 185                 .frequency_stepsize     = 250000,
 186                 .caps = FE_CAN_INVERSION_AUTO |
 187                                 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 188                                 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 189                                 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 190                                 FE_CAN_TRANSMISSION_MODE_AUTO |
 191                                 FE_CAN_GUARD_INTERVAL_AUTO |
 192                                 FE_CAN_RECOVER |
 193                                 FE_CAN_HIERARCHY_AUTO,
 194         },
 195
 196         .release = dtt200u_fe_release,
 197
 198         .init = dtt200u_fe_init,
 199         .sleep = dtt200u_fe_sleep,
 200
 201         .set_frontend = dtt200u_fe_set_frontend,
 202         .get_frontend = dtt200u_fe_get_frontend,
 203         .get_tune_settings = dtt200u_fe_get_tune_settings,
 204
 205         .read_status = dtt200u_fe_read_status,
 206         .read_ber = dtt200u_fe_read_ber,
 207         .read_signal_strength = dtt200u_fe_read_signal_strength,
 208         .read_snr = dtt200u_fe_read_snr,
 209         .read_ucblocks = dtt200u_fe_read_unc_blocks,
 210 };