[media] technisat-usb2: added driver for Technisat's USB2.0 DVB-S/S2 receiver
authorPatrick Boettcher <pboettcher@kernellabs.com>
Sun, 31 Oct 2010 19:24:19 +0000 (16:24 -0300)
committerMauro Carvalho Chehab <mchehab@redhat.com>
Mon, 21 Mar 2011 23:31:33 +0000 (20:31 -0300)
This patch is adding support for Technisat's new USB2.0 DVB-S/S2 receiver
device. The development was sponsored by Technisat.

The Green led is toggle depending on the frontend-state. The Red LED is turned
on all the time.

The MAC address reading from the EEPROM along with the
LRC-method to check whether its valid.

Support for the IR-receiver of the Technisat USB2 box. The keys of
small, black remote-control are built-in, repeated key behaviour are
simulated.

The i2c-mutex of the dvb-usb-structure is used as a general mutex for
USB requests, as there are 3 threads racing for atomic requests
consisting of multiple usb-requests.

A module option is there which disables the toggling of LEDs by the
driver on certain triggers. Useful when being used in a "dark"
environment.

[mchehab@redhat.com: Fix merge conflicts with RC renaming patches]
Signed-off-by: Martin Wilks <m.wilks@technisat.com>
Signed-off-by: Patrick Boettcher <pboettcher@kernellabs.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
drivers/media/dvb/dvb-usb/Kconfig
drivers/media/dvb/dvb-usb/Makefile
drivers/media/dvb/dvb-usb/dvb-usb-ids.h
drivers/media/dvb/dvb-usb/dvb-usb-remote.c
drivers/media/dvb/dvb-usb/dvb-usb.h
drivers/media/dvb/dvb-usb/technisat-usb2.c [new file with mode: 0644]
drivers/media/rc/keymaps/Makefile
drivers/media/rc/keymaps/rc-technisat-usb2.c [new file with mode: 0644]
include/media/rc-map.h

index 3d48ba0193425b9b1971d5eb03385fcb94209d96..fe4f894183ffcf5bb65b85ab85b4ca0acc12473d 100644 (file)
@@ -358,3 +358,11 @@ config DVB_USB_LME2510
        select DVB_IX2505V if !DVB_FE_CUSTOMISE
        help
          Say Y here to support the LME DM04/QQBOX DVB-S USB2.0 .
+
+config DVB_USB_TECHNISAT_USB2
+       tristate "Technisat DVB-S/S2 USB2.0 support"
+       depends on DVB_USB
+       select DVB_STB0899 if !DVB_FE_CUSTOMISE
+       select DVB_STB6100 if !DVB_FE_CUSTOMISE
+       help
+         Say Y here to support the Technisat USB2 DVB-S/S2 device
index 5b1d12f2d59184a36138427f5e513d5722441a6c..4bac13da0c39eb55ecff23fe52b41b39be1d324c 100644 (file)
@@ -91,6 +91,9 @@ obj-$(CONFIG_DVB_USB_AZ6027) += dvb-usb-az6027.o
 dvb-usb-lmedm04-objs = lmedm04.o
 obj-$(CONFIG_DVB_USB_LME2510) += dvb-usb-lmedm04.o
 
+dvb-usb-technisat-usb2-objs = technisat-usb2.o
+obj-$(CONFIG_DVB_USB_TECHNISAT_USB2) += dvb-usb-technisat-usb2.o
+
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/
 # due to tuner-xc3028
 EXTRA_CFLAGS += -Idrivers/media/common/tuners
index 1a6310b619238030c64125eba61ec3578ed8fafe..d0bce0445cc76912a476493b4fc5fc06af94eb4c 100644 (file)
 #define USB_PID_TERRATEC_DVBS2CI_V2                    0x10ac
 #define USB_PID_TECHNISAT_USB2_HDCI_V1                 0x0001
 #define USB_PID_TECHNISAT_USB2_HDCI_V2                 0x0002
+#define USB_PID_TECHNISAT_USB2_DVB_S2                  0x0500
 #endif
index 23005b3cf30bedaea413a1afba3627fe28d0d400..f511418b144abe82599d13718c5fb09e29c61abf 100644 (file)
@@ -246,7 +246,7 @@ static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
        dev->map_name = d->props.rc.core.rc_codes;
        dev->change_protocol = d->props.rc.core.change_protocol;
        dev->allowed_protos = d->props.rc.core.allowed_protos;
-       dev->driver_type = RC_DRIVER_SCANCODE;
+       dev->driver_type = d->props.rc.core.driver_type;
        usb_to_input_id(d->udev, &dev->input_id);
        dev->input_name = "IR-receiver inside an USB DVB receiver";
        dev->input_phys = d->rc_phys;
index 65fa9268e7f710801d75ca231da7dfcba6adbf46..76a80968482a602033cfead87ddd029301a832d2 100644 (file)
@@ -181,6 +181,7 @@ struct dvb_rc_legacy {
  * @rc_codes: name of rc codes table
  * @protocol: type of protocol(s) currently used by the driver
  * @allowed_protos: protocol(s) supported by the driver
+ * @driver_type: Used to point if a device supports raw mode
  * @change_protocol: callback to change protocol
  * @rc_query: called to query an event event.
  * @rc_interval: time in ms between two queries.
@@ -190,6 +191,7 @@ struct dvb_rc {
        char *rc_codes;
        u64 protocol;
        u64 allowed_protos;
+       enum rc_driver_type driver_type;
        int (*change_protocol)(struct rc_dev *dev, u64 rc_type);
        char *module_name;
        int (*rc_query) (struct dvb_usb_device *d);
diff --git a/drivers/media/dvb/dvb-usb/technisat-usb2.c b/drivers/media/dvb/dvb-usb/technisat-usb2.c
new file mode 100644 (file)
index 0000000..406602a
--- /dev/null
@@ -0,0 +1,808 @@
+/*
+ * Linux driver for Technisat DVB-S/S2 USB 2.0 device
+ *
+ * Copyright (C) 2010 Patrick Boettcher,
+ *                    Kernel Labs Inc. PO Box 745, St James, NY 11780
+ *
+ * Development was sponsored by Technisat Digital UK Limited, whose
+ * registered office is Witan Gate House 500 - 600 Witan Gate West,
+ * Milton Keynes, MK9 1SH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * THIS PROGRAM IS PROVIDED "AS IS" AND BOTH THE COPYRIGHT HOLDER AND
+ * TECHNISAT DIGITAL UK LTD DISCLAIM ALL WARRANTIES WITH REGARD TO
+ * THIS PROGRAM INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  NEITHER THE COPYRIGHT HOLDER
+ * NOR TECHNISAT DIGITAL UK LIMITED SHALL BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+ * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS PROGRAM. See the
+ * GNU General Public License for more details.
+ */
+
+#define DVB_USB_LOG_PREFIX "technisat-usb2"
+#include "dvb-usb.h"
+
+#include "stv6110x.h"
+#include "stv090x.h"
+
+/* module parameters */
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug,
+               "set debugging level (bit-mask: 1=info,2=eeprom,4=i2c,8=rc)." \
+               DVB_USB_DEBUG_STATUS);
+
+/* disables all LED control command and
+ * also does not start the signal polling thread */
+static int disable_led_control;
+module_param(disable_led_control, int, 0444);
+MODULE_PARM_DESC(disable_led_control,
+               "disable LED control of the device "
+               "(default: 0 - LED control is active).");
+
+/* device private data */
+struct technisat_usb2_state {
+       struct dvb_usb_device *dev;
+       struct delayed_work green_led_work;
+       u8 power_state;
+
+       u16 last_scan_code;
+};
+
+/* debug print helpers */
+#define deb_info(args...)    dprintk(debug, 0x01, args)
+#define deb_eeprom(args...)  dprintk(debug, 0x02, args)
+#define deb_i2c(args...)     dprintk(debug, 0x04, args)
+#define deb_rc(args...)      dprintk(debug, 0x08, args)
+
+/* vendor requests */
+#define SET_IFCLK_TO_EXTERNAL_TSCLK_VENDOR_REQUEST 0xB3
+#define SET_FRONT_END_RESET_VENDOR_REQUEST         0xB4
+#define GET_VERSION_INFO_VENDOR_REQUEST            0xB5
+#define SET_GREEN_LED_VENDOR_REQUEST               0xB6
+#define SET_RED_LED_VENDOR_REQUEST                 0xB7
+#define GET_IR_DATA_VENDOR_REQUEST                 0xB8
+#define SET_LED_TIMER_DIVIDER_VENDOR_REQUEST       0xB9
+#define SET_USB_REENUMERATION                      0xBA
+
+/* i2c-access methods */
+#define I2C_SPEED_100KHZ_BIT 0x40
+
+#define I2C_STATUS_NAK 7
+#define I2C_STATUS_OK 8
+
+static int technisat_usb2_i2c_access(struct usb_device *udev,
+               u8 device_addr, u8 *tx, u8 txlen, u8 *rx, u8 rxlen)
+{
+       u8 b[64];
+       int ret, actual_length;
+
+       deb_i2c("i2c-access: %02x, tx: ", device_addr);
+       debug_dump(tx, txlen, deb_i2c);
+       deb_i2c(" ");
+
+       if (txlen > 62) {
+               err("i2c TX buffer can't exceed 62 bytes (dev 0x%02x)",
+                               device_addr);
+               txlen = 62;
+       }
+       if (rxlen > 62) {
+               err("i2c RX buffer can't exceed 62 bytes (dev 0x%02x)",
+                               device_addr);
+               txlen = 62;
+       }
+
+       b[0] = I2C_SPEED_100KHZ_BIT;
+       b[1] = device_addr << 1;
+
+       if (rx != NULL) {
+               b[0] |= rxlen;
+               b[1] |= 1;
+       }
+
+       memcpy(&b[2], tx, txlen);
+       ret = usb_bulk_msg(udev,
+                       usb_sndbulkpipe(udev, 0x01),
+                       b, 2 + txlen,
+                       NULL, 1000);
+
+       if (ret < 0) {
+               err("i2c-error: out failed %02x = %d", device_addr, ret);
+               return -ENODEV;
+       }
+
+       ret = usb_bulk_msg(udev,
+                       usb_rcvbulkpipe(udev, 0x01),
+                       b, 64, &actual_length, 1000);
+       if (ret < 0) {
+               err("i2c-error: in failed %02x = %d", device_addr, ret);
+               return -ENODEV;
+       }
+
+       if (b[0] != I2C_STATUS_OK) {
+               err("i2c-error: %02x = %d", device_addr, b[0]);
+               /* handle tuner-i2c-nak */
+               if (!(b[0] == I2C_STATUS_NAK &&
+                               device_addr == 0x60
+                               /* && device_is_technisat_usb2 */))
+                       return -ENODEV;
+       }
+
+       deb_i2c("status: %d, ", b[0]);
+
+       if (rx != NULL) {
+               memcpy(rx, &b[2], rxlen);
+
+               deb_i2c("rx (%d): ", rxlen);
+               debug_dump(rx, rxlen, deb_i2c);
+       }
+
+       deb_i2c("\n");
+
+       return 0;
+}
+
+static int technisat_usb2_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
+                               int num)
+{
+       int ret = 0, i;
+       struct dvb_usb_device *d = i2c_get_adapdata(adap);
+
+       /* Ensure nobody else hits the i2c bus while we're sending our
+          sequence of messages, (such as the remote control thread) */
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+               return -EAGAIN;
+
+       for (i = 0; i < num; i++) {
+               if (i+1 < num && msg[i+1].flags & I2C_M_RD) {
+                       ret = technisat_usb2_i2c_access(d->udev, msg[i+1].addr,
+                                               msg[i].buf, msg[i].len,
+                                               msg[i+1].buf, msg[i+1].len);
+                       if (ret != 0)
+                               break;
+                       i++;
+               } else {
+                       ret = technisat_usb2_i2c_access(d->udev, msg[i].addr,
+                                               msg[i].buf, msg[i].len,
+                                               NULL, 0);
+                       if (ret != 0)
+                               break;
+               }
+       }
+
+       if (ret == 0)
+               ret = i;
+
+       mutex_unlock(&d->i2c_mutex);
+
+       return ret;
+}
+
+static u32 technisat_usb2_i2c_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm technisat_usb2_i2c_algo = {
+       .master_xfer   = technisat_usb2_i2c_xfer,
+       .functionality = technisat_usb2_i2c_func,
+};
+
+#if 0
+static void technisat_usb2_frontend_reset(struct usb_device *udev)
+{
+       usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                       SET_FRONT_END_RESET_VENDOR_REQUEST,
+                       USB_TYPE_VENDOR | USB_DIR_OUT,
+                       10, 0,
+                       NULL, 0, 500);
+}
+#endif
+
+/* LED control */
+enum technisat_usb2_led_state {
+       LED_OFF,
+       LED_BLINK,
+       LED_ON,
+       LED_UNDEFINED
+};
+
+static int technisat_usb2_set_led(struct dvb_usb_device *d, int red, enum technisat_usb2_led_state state)
+{
+       int ret;
+
+       u8 led[8] = {
+               red ? SET_RED_LED_VENDOR_REQUEST : SET_GREEN_LED_VENDOR_REQUEST,
+               0
+       };
+
+       if (disable_led_control && state != LED_OFF)
+               return 0;
+
+       switch (state) {
+       case LED_ON:
+               led[1] = 0x82;
+               break;
+       case LED_BLINK:
+               led[1] = 0x82;
+               if (red) {
+                       led[2] = 0x02;
+                       led[3] = 10;
+                       led[4] = 10;
+               } else {
+                       led[2] = 0xff;
+                       led[3] = 50;
+                       led[4] = 50;
+               }
+               led[5] = 1;
+               break;
+
+       default:
+       case LED_OFF:
+               led[1] = 0x80;
+               break;
+       }
+
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+               return -EAGAIN;
+
+       ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+               red ? SET_RED_LED_VENDOR_REQUEST : SET_GREEN_LED_VENDOR_REQUEST,
+               USB_TYPE_VENDOR | USB_DIR_OUT,
+               0, 0,
+               led, sizeof(led), 500);
+
+       mutex_unlock(&d->i2c_mutex);
+       return ret;
+}
+
+static int technisat_usb2_set_led_timer(struct dvb_usb_device *d, u8 red, u8 green)
+{
+       int ret;
+       u8 b = 0;
+
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+               return -EAGAIN;
+
+       ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+               SET_LED_TIMER_DIVIDER_VENDOR_REQUEST,
+               USB_TYPE_VENDOR | USB_DIR_OUT,
+               (red << 8) | green, 0,
+               &b, 1, 500);
+
+       mutex_unlock(&d->i2c_mutex);
+
+       return ret;
+}
+
+static void technisat_usb2_green_led_control(struct work_struct *work)
+{
+       struct technisat_usb2_state *state =
+               container_of(work, struct technisat_usb2_state, green_led_work.work);
+       struct dvb_frontend *fe = state->dev->adapter[0].fe;
+
+       if (state->power_state == 0)
+               goto schedule;
+
+       if (fe != NULL) {
+               enum fe_status status;
+
+               if (fe->ops.read_status(fe, &status) != 0)
+                       goto schedule;
+
+               if (status & FE_HAS_LOCK) {
+                       u32 ber;
+
+                       if (fe->ops.read_ber(fe, &ber) != 0)
+                               goto schedule;
+
+                       if (ber > 1000)
+                               technisat_usb2_set_led(state->dev, 0, LED_BLINK);
+                       else
+                               technisat_usb2_set_led(state->dev, 0, LED_ON);
+               } else
+                       technisat_usb2_set_led(state->dev, 0, LED_OFF);
+       }
+
+schedule:
+       schedule_delayed_work(&state->green_led_work,
+                       msecs_to_jiffies(500));
+}
+
+/* method to find out whether the firmware has to be downloaded or not */
+static int technisat_usb2_identify_state(struct usb_device *udev,
+               struct dvb_usb_device_properties *props,
+               struct dvb_usb_device_description **desc, int *cold)
+{
+       int ret;
+       u8 version[3];
+
+       /* first select the interface */
+       if (usb_set_interface(udev, 0, 1) != 0) {
+               err("could not set alternate setting to 0");
+       } else {
+               info("set alternate setting");
+       }
+
+       *cold = 0; /* by default do not download a firmware - just in case something is wrong */
+
+       ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+               GET_VERSION_INFO_VENDOR_REQUEST,
+               USB_TYPE_VENDOR | USB_DIR_IN,
+               0, 0,
+               version, sizeof(version), 500);
+
+       if (ret < 0)
+               *cold = 1;
+       else {
+               info("firmware version: %d.%d", version[1], version[2]);
+               *cold = 0;
+       }
+
+       return 0;
+}
+
+/* power control */
+static int technisat_usb2_power_ctrl(struct dvb_usb_device *d, int level)
+{
+       struct technisat_usb2_state *state = d->priv;
+
+       state->power_state = level;
+
+       if (disable_led_control)
+               return 0;
+
+       /* green led is turned off in any case - will be turned on when tuning */
+       technisat_usb2_set_led(d, 0, LED_OFF);
+       /* red led is turned on all the time */
+       technisat_usb2_set_led(d, 1, LED_ON);
+       return 0;
+}
+
+/* mac address reading - from the eeprom */
+#if 0
+static void technisat_usb2_eeprom_dump(struct dvb_usb_device *d)
+{
+       u8 reg;
+       u8 b[16];
+       int i,j;
+
+       /* full EEPROM dump */
+       for (j = 0; j < 256 * 4; j += 16) {
+               reg = j;
+               if (technisat_usb2_i2c_access(d->udev, 0x50 + j / 256, &reg, 1, b, 16) != 0)
+                       break;
+
+               deb_eeprom("EEPROM: %01x%02x: ", j / 256, reg);
+               for (i = 0; i < 16; i++)
+                       deb_eeprom("%02x ", b[i]);
+               deb_eeprom("\n");
+       }
+}
+#endif
+
+static u8 technisat_usb2_calc_lrc(const u8 *b, u16 length)
+{
+       u8 lrc = 0;
+       while (--length)
+               lrc ^= *b++;
+       return lrc;
+}
+
+static int technisat_usb2_eeprom_lrc_read(struct dvb_usb_device *d,
+       u16 offset, u8 *b, u16 length, u8 tries)
+{
+       u8 bo = offset & 0xff;
+       struct i2c_msg msg[] = {
+               {
+                       .addr = 0x50 | ((offset >> 8) & 0x3),
+                       .buf = &bo,
+                       .len = 1
+               }, {
+                       .addr = 0x50 | ((offset >> 8) & 0x3),
+                       .flags  = I2C_M_RD,
+                       .buf = b,
+                       .len = length
+               }
+       };
+
+       while (tries--) {
+               int status;
+
+               if (i2c_transfer(&d->i2c_adap, msg, 2) != 2)
+                       break;
+
+               status =
+                       technisat_usb2_calc_lrc(b, length - 1) == b[length - 1];
+
+               if (status)
+                       return 0;
+       }
+
+       return -EREMOTEIO;
+}
+
+#define EEPROM_MAC_START 0x3f8
+#define EEPROM_MAC_TOTAL 8
+static int technisat_usb2_read_mac_address(struct dvb_usb_device *d,
+               u8 mac[])
+{
+       u8 buf[EEPROM_MAC_TOTAL];
+
+       if (technisat_usb2_eeprom_lrc_read(d, EEPROM_MAC_START,
+                               buf, EEPROM_MAC_TOTAL, 4) != 0)
+               return -ENODEV;
+
+       memcpy(mac, buf, 6);
+       return 0;
+}
+
+/* frontend attach */
+static int technisat_usb2_set_voltage(struct dvb_frontend *fe,
+               fe_sec_voltage_t voltage)
+{
+       int i;
+       u8 gpio[3] = { 0 }; /* 0 = 2, 1 = 3, 2 = 4 */
+
+       gpio[2] = 1; /* high - voltage ? */
+
+       switch (voltage) {
+       case SEC_VOLTAGE_13:
+               gpio[0] = 1;
+               break;
+       case SEC_VOLTAGE_18:
+               gpio[0] = 1;
+               gpio[1] = 1;
+               break;
+       default:
+       case SEC_VOLTAGE_OFF:
+               break;
+       }
+
+       for (i = 0; i < 3; i++)
+               if (stv090x_set_gpio(fe, i+2, 0, gpio[i], 0) != 0)
+                       return -EREMOTEIO;
+       return 0;
+}
+
+static struct stv090x_config technisat_usb2_stv090x_config = {
+       .device         = STV0903,
+       .demod_mode     = STV090x_SINGLE,
+       .clk_mode       = STV090x_CLK_EXT,
+
+       .xtal           = 8000000,
+       .address        = 0x68,
+
+       .ts1_mode       = STV090x_TSMODE_DVBCI,
+       .ts1_clk        = 13400000,
+       .ts1_tei        = 1,
+
+       .repeater_level = STV090x_RPTLEVEL_64,
+
+       .tuner_bbgain   = 6,
+};
+
+static struct stv6110x_config technisat_usb2_stv6110x_config = {
+    .addr           = 0x60,
+    .refclk         = 16000000,
+    .clk_div        = 2,
+};
+
+static int technisat_usb2_frontend_attach(struct dvb_usb_adapter *a)
+{
+       struct usb_device *udev = a->dev->udev;
+       int ret;
+
+       a->fe = dvb_attach(stv090x_attach, &technisat_usb2_stv090x_config,
+                       &a->dev->i2c_adap, STV090x_DEMODULATOR_0);
+
+       if (a->fe) {
+               struct stv6110x_devctl *ctl;
+
+               ctl = dvb_attach(stv6110x_attach,
+                               a->fe,
+                               &technisat_usb2_stv6110x_config,
+                               &a->dev->i2c_adap);
+
+               if (ctl) {
+                       technisat_usb2_stv090x_config.tuner_init          = ctl->tuner_init;
+                       technisat_usb2_stv090x_config.tuner_sleep         = ctl->tuner_sleep;
+                       technisat_usb2_stv090x_config.tuner_set_mode      = ctl->tuner_set_mode;
+                       technisat_usb2_stv090x_config.tuner_set_frequency = ctl->tuner_set_frequency;
+                       technisat_usb2_stv090x_config.tuner_get_frequency = ctl->tuner_get_frequency;
+                       technisat_usb2_stv090x_config.tuner_set_bandwidth = ctl->tuner_set_bandwidth;
+                       technisat_usb2_stv090x_config.tuner_get_bandwidth = ctl->tuner_get_bandwidth;
+                       technisat_usb2_stv090x_config.tuner_set_bbgain    = ctl->tuner_set_bbgain;
+                       technisat_usb2_stv090x_config.tuner_get_bbgain    = ctl->tuner_get_bbgain;
+                       technisat_usb2_stv090x_config.tuner_set_refclk    = ctl->tuner_set_refclk;
+                       technisat_usb2_stv090x_config.tuner_get_status    = ctl->tuner_get_status;
+
+                       /* call the init function once to initialize
+                          tuner's clock output divider and demod's
+                          master clock */
+                       if (a->fe->ops.init)
+                               a->fe->ops.init(a->fe);
+
+                       if (mutex_lock_interruptible(&a->dev->i2c_mutex) < 0)
+                               return -EAGAIN;
+
+                       ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                       SET_IFCLK_TO_EXTERNAL_TSCLK_VENDOR_REQUEST,
+                                       USB_TYPE_VENDOR | USB_DIR_OUT,
+                                       0, 0,
+                                       NULL, 0, 500);
+                       mutex_unlock(&a->dev->i2c_mutex);
+
+                       if (ret != 0)
+                               err("could not set IF_CLK to external");
+
+                       a->fe->ops.set_voltage = technisat_usb2_set_voltage;
+
+                       /* if everything was successful assign a nice name to the frontend */
+                       strlcpy(a->fe->ops.info.name, a->dev->desc->name,
+                                       sizeof(a->fe->ops.info.name));
+               } else {
+                       dvb_frontend_detach(a->fe);
+                       a->fe = NULL;
+               }
+       }
+
+       technisat_usb2_set_led_timer(a->dev, 1, 1);
+
+       return a->fe == NULL ? -ENODEV : 0;
+}
+
+/* Remote control */
+
+/* the device is giving providing raw IR-signals to the host mapping
+ * it only to one remote control is just the default implementation
+ */
+#define NOMINAL_IR_BIT_TRANSITION_TIME_US 889
+#define NOMINAL_IR_BIT_TIME_US (2 * NOMINAL_IR_BIT_TRANSITION_TIME_US)
+
+#define FIRMWARE_CLOCK_TICK 83333
+#define FIRMWARE_CLOCK_DIVISOR 256
+
+#define IR_PERCENT_TOLERANCE 15
+
+#define NOMINAL_IR_BIT_TRANSITION_TICKS ((NOMINAL_IR_BIT_TRANSITION_TIME_US * 1000 * 1000) / FIRMWARE_CLOCK_TICK)
+#define NOMINAL_IR_BIT_TRANSITION_TICK_COUNT (NOMINAL_IR_BIT_TRANSITION_TICKS / FIRMWARE_CLOCK_DIVISOR)
+
+#define NOMINAL_IR_BIT_TIME_TICKS ((NOMINAL_IR_BIT_TIME_US * 1000 * 1000) / FIRMWARE_CLOCK_TICK)
+#define NOMINAL_IR_BIT_TIME_TICK_COUNT (NOMINAL_IR_BIT_TIME_TICKS / FIRMWARE_CLOCK_DIVISOR)
+
+#define MINIMUM_IR_BIT_TRANSITION_TICK_COUNT (NOMINAL_IR_BIT_TRANSITION_TICK_COUNT - ((NOMINAL_IR_BIT_TRANSITION_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+#define MAXIMUM_IR_BIT_TRANSITION_TICK_COUNT (NOMINAL_IR_BIT_TRANSITION_TICK_COUNT + ((NOMINAL_IR_BIT_TRANSITION_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+
+#define MINIMUM_IR_BIT_TIME_TICK_COUNT (NOMINAL_IR_BIT_TIME_TICK_COUNT - ((NOMINAL_IR_BIT_TIME_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+#define MAXIMUM_IR_BIT_TIME_TICK_COUNT (NOMINAL_IR_BIT_TIME_TICK_COUNT + ((NOMINAL_IR_BIT_TIME_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+
+static int technisat_usb2_get_ir(struct dvb_usb_device *d)
+{
+       u8 buf[62], *b;
+       int ret;
+       struct ir_raw_event ev;
+
+       buf[0] = GET_IR_DATA_VENDOR_REQUEST;
+       buf[1] = 0x08;
+       buf[2] = 0x8f;
+       buf[3] = MINIMUM_IR_BIT_TRANSITION_TICK_COUNT;
+       buf[4] = MAXIMUM_IR_BIT_TIME_TICK_COUNT;
+
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+               return -EAGAIN;
+       ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                       GET_IR_DATA_VENDOR_REQUEST,
+                       USB_TYPE_VENDOR | USB_DIR_OUT,
+                       0, 0,
+                       buf, 5, 500);
+       if (ret < 0)
+               goto unlock;
+
+       buf[1] = 0;
+       buf[2] = 0;
+       ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
+                       GET_IR_DATA_VENDOR_REQUEST,
+                       USB_TYPE_VENDOR | USB_DIR_IN,
+                       0x8080, 0,
+                       buf, sizeof(buf), 500);
+
+unlock:
+       mutex_unlock(&d->i2c_mutex);
+
+       if (ret < 0)
+               return ret;
+
+       if (ret == 1)
+               return 0; /* no key pressed */
+
+       /* decoding */
+       b = buf+1;
+
+#if 0
+       deb_rc("RC: %d ", ret);
+       debug_dump(b, ret, deb_rc);
+#endif
+
+       ev.pulse = 0;
+       while (1) {
+               ev.pulse = !ev.pulse;
+               ev.duration = (*b * FIRMWARE_CLOCK_DIVISOR * FIRMWARE_CLOCK_TICK) / 1000;
+               ir_raw_event_store(d->rc_dev, &ev);
+
+               b++;
+               if (*b == 0xff) {
+                       ev.pulse = 0;
+                       ev.duration = 888888*2;
+                       ir_raw_event_store(d->rc_dev, &ev);
+                       break;
+               }
+       }
+
+       ir_raw_event_handle(d->rc_dev);
+
+       return 1;
+}
+
+static int technisat_usb2_rc_query(struct dvb_usb_device *d)
+{
+       int ret = technisat_usb2_get_ir(d);
+
+       if (ret < 0)
+               return ret;
+
+       if (ret == 0)
+               return 0;
+
+       if (!disable_led_control)
+               technisat_usb2_set_led(d, 1, LED_BLINK);
+
+       return 0;
+}
+
+/* DVB-USB and USB stuff follows */
+static struct usb_device_id technisat_usb2_id_table[] = {
+       { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_USB2_DVB_S2) },
+       { 0 }           /* Terminating entry */
+};
+
+/* device description */
+static struct dvb_usb_device_properties technisat_usb2_devices = {
+       .caps              = DVB_USB_IS_AN_I2C_ADAPTER,
+
+       .usb_ctrl          = CYPRESS_FX2,
+
+       .identify_state    = technisat_usb2_identify_state,
+       .firmware          = "dvb-usb-SkyStar_USB_HD_FW_v17_63.HEX.fw",
+
+       .size_of_priv      = sizeof(struct technisat_usb2_state),
+
+       .i2c_algo          = &technisat_usb2_i2c_algo,
+
+       .power_ctrl        = technisat_usb2_power_ctrl,
+       .read_mac_address  = technisat_usb2_read_mac_address,
+
+       .num_adapters = 1,
+       .adapter = {
+               {
+                       .frontend_attach  = technisat_usb2_frontend_attach,
+
+                       .stream = {
+                               .type = USB_ISOC,
+                               .count = 8,
+                               .endpoint = 0x2,
+                               .u = {
+                                       .isoc = {
+                                               .framesperurb = 32,
+                                               .framesize = 2048,
+                                               .interval = 3,
+                                       }
+                               }
+                       },
+
+                       .size_of_priv = 0,
+               },
+       },
+
+       .num_device_descs = 1,
+       .devices = {
+               {   "Technisat SkyStar USB HD (DVB-S/S2)",
+                       { &technisat_usb2_id_table[0], NULL },
+                       { NULL },
+               },
+       },
+
+       .rc.core = {
+               .rc_interval = 100,
+               .rc_codes    = RC_MAP_TECHNISAT_USB2,
+               .module_name = "technisat-usb2",
+               .rc_query    = technisat_usb2_rc_query,
+               .allowed_protos = RC_TYPE_ALL,
+               .driver_type    = RC_DRIVER_IR_RAW,
+       }
+};
+
+static int technisat_usb2_probe(struct usb_interface *intf,
+               const struct usb_device_id *id)
+{
+       struct dvb_usb_device *dev;
+
+       if (dvb_usb_device_init(intf, &technisat_usb2_devices, THIS_MODULE,
+                               &dev, adapter_nr) != 0)
+               return -ENODEV;
+
+       if (dev) {
+               struct technisat_usb2_state *state = dev->priv;
+               state->dev = dev;
+
+               if (!disable_led_control) {
+                       INIT_DELAYED_WORK(&state->green_led_work,
+                                       technisat_usb2_green_led_control);
+                       schedule_delayed_work(&state->green_led_work,
+                                       msecs_to_jiffies(500));
+               }
+       }
+
+       return 0;
+}
+
+static void technisat_usb2_disconnect(struct usb_interface *intf)
+{
+       struct dvb_usb_device *dev = usb_get_intfdata(intf);
+
+       /* work and stuff was only created when the device is is hot-state */
+       if (dev != NULL) {
+               struct technisat_usb2_state *state = dev->priv;
+               if (state != NULL) {
+                       cancel_rearming_delayed_work(&state->green_led_work);
+                       flush_scheduled_work();
+               }
+       }
+
+       dvb_usb_device_exit(intf);
+}
+
+static struct usb_driver technisat_usb2_driver = {
+       .name       = "dvb_usb_technisat_usb2",
+       .probe      = technisat_usb2_probe,
+       .disconnect = technisat_usb2_disconnect,
+       .id_table   = technisat_usb2_id_table,
+};
+
+/* module stuff */
+static int __init technisat_usb2_module_init(void)
+{
+       int result = usb_register(&technisat_usb2_driver);
+       if (result) {
+               err("usb_register failed. Code %d", result);
+               return result;
+       }
+
+       return 0;
+}
+
+static void __exit technisat_usb2_module_exit(void)
+{
+       usb_deregister(&technisat_usb2_driver);
+}
+
+module_init(technisat_usb2_module_init);
+module_exit(technisat_usb2_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <pboettcher@kernellabs.com>");
+MODULE_DESCRIPTION("Driver for Technisat DVB-S/S2 USB 2.0 device");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
index 0659e9f501445a97925c56b7c518f4a61b1e501c..f0c80559b3035361b46982c45dc049220f5ebc5c 100644 (file)
@@ -74,6 +74,7 @@ obj-$(CONFIG_RC_MAP) += rc-adstech-dvb-t-pci.o \
                        rc-real-audio-220-32-keys.o \
                        rc-streamzap.o \
                        rc-tbs-nec.o \
+                       rc-technisat-usb2.o \
                        rc-terratec-cinergy-xs.o \
                        rc-terratec-slim.o \
                        rc-tevii-nec.o \
diff --git a/drivers/media/rc/keymaps/rc-technisat-usb2.c b/drivers/media/rc/keymaps/rc-technisat-usb2.c
new file mode 100644 (file)
index 0000000..4afe577
--- /dev/null
@@ -0,0 +1,93 @@
+/* rc-technisat-usb2.c - Keytable for SkyStar HD USB
+ *
+ * Copyright (C) 2010 Patrick Boettcher,
+ *                    Kernel Labs Inc. PO Box 745, St James, NY 11780
+ *
+ * Development was sponsored by Technisat Digital UK Limited, whose
+ * registered office is Witan Gate House 500 - 600 Witan Gate West,
+ * Milton Keynes, MK9 1SH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * THIS PROGRAM IS PROVIDED "AS IS" AND BOTH THE COPYRIGHT HOLDER AND
+ * TECHNISAT DIGITAL UK LTD DISCLAIM ALL WARRANTIES WITH REGARD TO
+ * THIS PROGRAM INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  NEITHER THE COPYRIGHT HOLDER
+ * NOR TECHNISAT DIGITAL UK LIMITED SHALL BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+ * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS PROGRAM. See the
+ * GNU General Public License for more details.
+ */
+
+#include <media/rc-map.h>
+
+static struct rc_map_table technisat_usb2[] = {
+       {0x0a0c, KEY_POWER},
+       {0x0a01, KEY_1},
+       {0x0a02, KEY_2},
+       {0x0a03, KEY_3},
+       {0x0a0d, KEY_MUTE},
+       {0x0a04, KEY_4},
+       {0x0a05, KEY_5},
+       {0x0a06, KEY_6},
+       {0x0a38, KEY_VIDEO}, /* EXT */
+       {0x0a07, KEY_7},
+       {0x0a08, KEY_8},
+       {0x0a09, KEY_9},
+       {0x0a00, KEY_0},
+       {0x0a4f, KEY_INFO},
+       {0x0a20, KEY_CHANNELUP},
+       {0x0a52, KEY_MENU},
+       {0x0a11, KEY_VOLUMEUP},
+       {0x0a57, KEY_OK},
+       {0x0a10, KEY_VOLUMEDOWN},
+       {0x0a2f, KEY_EPG},
+       {0x0a21, KEY_CHANNELDOWN},
+       {0x0a22, KEY_REFRESH},
+       {0x0a3c, KEY_TEXT},
+       {0x0a76, KEY_ENTER}, /* HOOK */
+       {0x0a0f, KEY_HELP},
+       {0x0a6b, KEY_RED},
+       {0x0a6c, KEY_GREEN},
+       {0x0a6d, KEY_YELLOW},
+       {0x0a6e, KEY_BLUE},
+       {0x0a29, KEY_STOP},
+       {0x0a23, KEY_LANGUAGE},
+       {0x0a53, KEY_TV},
+       {0x0a0a, KEY_PROGRAM},
+};
+
+static struct rc_map_list technisat_usb2_map = {
+       .map = {
+               .scan    = technisat_usb2,
+               .size    = ARRAY_SIZE(technisat_usb2),
+               .rc_type = RC_TYPE_RC5,
+               .name    = RC_MAP_TECHNISAT_USB2,
+       }
+};
+
+static int __init init_rc_map(void)
+{
+       return rc_map_register(&technisat_usb2_map);
+}
+
+static void __exit exit_rc_map(void)
+{
+       rc_map_unregister(&technisat_usb2_map);
+}
+
+module_init(init_rc_map)
+module_exit(exit_rc_map)
+
+MODULE_AUTHOR("Patrick Boettcher <pboettcher@kernellabs.com>");
+MODULE_LICENSE("GPL");
index ee9e2f747c76a5f12f8ff21f718417478e9bd92b..461711741d6751006b049d3458188c93ad2939fc 100644 (file)
@@ -131,6 +131,7 @@ void rc_map_init(void);
 #define RC_MAP_REAL_AUDIO_220_32_KEYS    "rc-real-audio-220-32-keys"
 #define RC_MAP_STREAMZAP                 "rc-streamzap"
 #define RC_MAP_TBS_NEC                   "rc-tbs-nec"
+#define RC_MAP_TECHNISAT_USB2            "rc-technisat-usb2"
 #define RC_MAP_TERRATEC_CINERGY_XS       "rc-terratec-cinergy-xs"
 #define RC_MAP_TERRATEC_SLIM             "rc-terratec-slim"
 #define RC_MAP_TEVII_NEC                 "rc-tevii-nec"