Quelle  gp8psk.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/* DVB USB compliant Linux driver for the
 *  - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
 *
 * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
 * Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com)
 *
 * Thanks to GENPIX for the sample code used to implement this module.
 *
 * This module is based off the vp7045 and vp702x modules
 *
 * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
 */
#include "gp8psk.h"
#include "gp8psk-fe.h"

/* debug */
static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw";
int dvb_usb_gp8psk_debug;
module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);

DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);

struct gp8psk_state {
 unsigned char data[80];
};

static int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value,
       u16 index, u8 *b, int blen)
{
 struct gp8psk_state *st = d->priv;
 int ret = 0,try = 0;

 if (blen > sizeof(st->data))
  return -EIO;

 if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
  return ret;

 while (ret >= 0 && ret != blen && try < 3) {
  ret = usb_control_msg(d->udev,
   usb_rcvctrlpipe(d->udev,0),
   req,
   USB_TYPE_VENDOR | USB_DIR_IN,
   value, index, st->data, blen,
   2000);
  deb_info("reading number %d (ret: %d)\n",try,ret);
  try++;
 }

 if (ret < 0 || ret != blen) {
  warn("usb in %d operation failed.", req);
  ret = -EIO;
 } else {
  ret = 0;
  memcpy(b, st->data, blen);
 }

 deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
 debug_dump(b,blen,deb_xfer);

 mutex_unlock(&d->usb_mutex);

 return ret;
}

static int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
        u16 index, u8 *b, int blen)
{
 struct gp8psk_state *st = d->priv;
 int ret;

 deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
 debug_dump(b,blen,deb_xfer);

 if (blen > sizeof(st->data))
  return -EIO;

 if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
  return ret;

 memcpy(st->data, b, blen);
 if (usb_control_msg(d->udev,
   usb_sndctrlpipe(d->udev,0),
   req,
   USB_TYPE_VENDOR | USB_DIR_OUT,
   value, index, st->data, blen,
   2000) != blen) {
  warn("usb out operation failed.");
  ret = -EIO;
 } else
  ret = 0;
 mutex_unlock(&d->usb_mutex);

 return ret;
}


static int gp8psk_get_fw_version(struct dvb_usb_device *d, u8 *fw_vers)
{
 return gp8psk_usb_in_op(d, GET_FW_VERS, 0, 0, fw_vers, 6);
}

static int gp8psk_get_fpga_version(struct dvb_usb_device *d, u8 *fpga_vers)
{
 return gp8psk_usb_in_op(d, GET_FPGA_VERS, 0, 0, fpga_vers, 1);
}

static void gp8psk_info(struct dvb_usb_device *d)
{
 u8 fpga_vers, fw_vers[6];

 if (!gp8psk_get_fw_version(d, fw_vers))
  info("FW Version = %i.%02i.%i (0x%x) Build %4i/%02i/%02i",
  fw_vers[2], fw_vers[1], fw_vers[0], GP8PSK_FW_VERS(fw_vers),
  2000 + fw_vers[5], fw_vers[4], fw_vers[3]);
 else
  info("failed to get FW version");

 if (!gp8psk_get_fpga_version(d, &fpga_vers))
  info("FPGA Version = %i", fpga_vers);
 else
  info("failed to get FPGA version");
}

static int gp8psk_load_bcm4500fw(struct dvb_usb_device *d)
{
 int ret;
 const struct firmware *fw = NULL;
 const u8 *ptr;
 u8 *buf;
 if ((ret = request_firmware(&fw, bcm4500_firmware,
     &d->udev->dev)) != 0) {
  err("did not find the bcm4500 firmware file '%s' (status %d). You can use /scripts/get_dvb_firmware to get the firmware",
   bcm4500_firmware,ret);
  return ret;
 }

 ret = -EINVAL;

 if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
  goto out_rel_fw;

 info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware);

 ptr = fw->data;
 buf = kmalloc(64, GFP_KERNEL);
 if (!buf) {
  ret = -ENOMEM;
  goto out_rel_fw;
 }

 while (ptr[0] != 0xff) {
  u16 buflen = ptr[0] + 4;
  if (ptr + buflen >= fw->data + fw->size) {
   err("failed to load bcm4500 firmware.");
   goto out_free;
  }
  if (buflen > 64) {
   err("firmware chunk size bigger than 64 bytes.");
   goto out_free;
  }

  memcpy(buf, ptr, buflen);
  if (dvb_usb_generic_write(d, buf, buflen)) {
   err("failed to load bcm4500 firmware.");
   goto out_free;
  }
  ptr += buflen;
 }

 ret = 0;

out_free:
 kfree(buf);
out_rel_fw:
 release_firmware(fw);

 return ret;
}

static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
{
 u8 status = 0, buf;
 int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);

 if (onoff) {
  gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
  if (! (status & bm8pskStarted)) {  /* started */
   if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
    gp8psk_usb_out_op(d, CW3K_INIT, 1, 0, NULL, 0);
   if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
    return -EINVAL;
   gp8psk_info(d);
  }

  if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
   if (! (status & bm8pskFW_Loaded)) /* BCM4500 firmware loaded */
    if(gp8psk_load_bcm4500fw(d))
     return -EINVAL;

  if (! (status & bmIntersilOn)) /* LNB Power */
   if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
     &buf, 1))
    return -EINVAL;

  /* Set DVB mode to 1 */
  if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
   if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
    return -EINVAL;
  /* Abort possible TS (if previous tune crashed) */
  if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0))
   return -EINVAL;
 } else {
  /* Turn off LNB power */
  if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
   return -EINVAL;
  /* Turn off 8psk power */
  if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
   return -EINVAL;
  if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
   gp8psk_usb_out_op(d, CW3K_INIT, 0, 0, NULL, 0);
 }
 return 0;
}

static int gp8psk_bcm4500_reload(struct dvb_usb_device *d)
{
 u8 buf;
 int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);

 deb_xfer("reloading firmware\n");

 /* Turn off 8psk power */
 if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
  return -EINVAL;
 /* Turn On 8psk power */
 if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
  return -EINVAL;
 /* load BCM4500 firmware */
 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
  if (gp8psk_load_bcm4500fw(d))
   return -EINVAL;
 return 0;
}

static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
 return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0);
}

/* Callbacks for gp8psk-fe.c */

static int gp8psk_fe_in(void *priv, u8 req, u16 value,
       u16 index, u8 *b, int blen)
{
 struct dvb_usb_device *d = priv;

 return gp8psk_usb_in_op(d, req, value, index, b, blen);
}

static int gp8psk_fe_out(void *priv, u8 req, u16 value,
       u16 index, u8 *b, int blen)
{
 struct dvb_usb_device *d = priv;

 return gp8psk_usb_out_op(d, req, value, index, b, blen);
}

static int gp8psk_fe_reload(void *priv)
{
 struct dvb_usb_device *d = priv;

 return gp8psk_bcm4500_reload(d);
}

static const struct gp8psk_fe_ops gp8psk_fe_ops = {
 .in = gp8psk_fe_in,
 .out = gp8psk_fe_out,
 .reload = gp8psk_fe_reload,
};

static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap)
{
 struct dvb_usb_device *d = adap->dev;
 int id = le16_to_cpu(d->udev->descriptor.idProduct);
 int is_rev1;

 is_rev1 = id == USB_PID_GENPIX_8PSK_REV_1_WARM;

 adap->fe_adap[0].fe = dvb_attach(gp8psk_fe_attach,
      &gp8psk_fe_ops, d, is_rev1);
 return 0;
}

static struct dvb_usb_device_properties gp8psk_properties;

static int gp8psk_usb_probe(struct usb_interface *intf,
  const struct usb_device_id *id)
{
 int ret;
 struct usb_device *udev = interface_to_usbdev(intf);
 ret = dvb_usb_device_init(intf, &gp8psk_properties,
      THIS_MODULE, NULL, adapter_nr);
 if (ret == 0) {
  info("found Genpix USB device pID = %x (hex)",
   le16_to_cpu(udev->descriptor.idProduct));
 }
 return ret;
}

enum {
 GENPIX_8PSK_REV_1_COLD,
 GENPIX_8PSK_REV_1_WARM,
 GENPIX_8PSK_REV_2,
 GENPIX_SKYWALKER_1,
 GENPIX_SKYWALKER_2,
 GENPIX_SKYWALKER_CW3K,
};

static const struct usb_device_id gp8psk_usb_table[] = {
 DVB_USB_DEV(GENPIX, GENPIX_8PSK_REV_1_COLD),
 DVB_USB_DEV(GENPIX, GENPIX_8PSK_REV_1_WARM),
 DVB_USB_DEV(GENPIX, GENPIX_8PSK_REV_2),
 DVB_USB_DEV(GENPIX, GENPIX_SKYWALKER_1),
 DVB_USB_DEV(GENPIX, GENPIX_SKYWALKER_2),
 DVB_USB_DEV(GENPIX, GENPIX_SKYWALKER_CW3K),
 { }
};

MODULE_DEVICE_TABLE(usb, gp8psk_usb_table);

static struct dvb_usb_device_properties gp8psk_properties = {
 .usb_ctrl = CYPRESS_FX2,
 .firmware = "dvb-usb-gp8psk-01.fw",

 .size_of_priv = sizeof(struct gp8psk_state),

 .num_adapters = 1,
 .adapter = {
  {
  .num_frontends = 1,
  .fe = {{
   .streaming_ctrl   = gp8psk_streaming_ctrl,
   .frontend_attach  = gp8psk_frontend_attach,
   /* parameter for the MPEG2-data transfer */
   .stream = {
    .type = USB_BULK,
    .count = 7,
    .endpoint = 0x82,
    .u = {
     .bulk = {
      .buffersize = 8192,
     }
    }
   },
  }},
  }
 },
 .power_ctrl       = gp8psk_power_ctrl,

 .generic_bulk_ctrl_endpoint = 0x01,

 .num_device_descs = 4,
 .devices = {
  { .name = "Genpix 8PSK-to-USB2 Rev.1 DVB-S receiver",
    .cold_ids = { &gp8psk_usb_table[GENPIX_8PSK_REV_1_COLD], NULL },
    .warm_ids = { &gp8psk_usb_table[GENPIX_8PSK_REV_1_WARM], NULL },
  },
  { .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver",
    .cold_ids = { NULL },
    .warm_ids = { &gp8psk_usb_table[GENPIX_8PSK_REV_2], NULL },
  },
  { .name = "Genpix SkyWalker-1 DVB-S receiver",
    .cold_ids = { NULL },
    .warm_ids = { &gp8psk_usb_table[GENPIX_SKYWALKER_1], NULL },
  },
  { .name = "Genpix SkyWalker-2 DVB-S receiver",
    .cold_ids = { NULL },
    .warm_ids = { &gp8psk_usb_table[GENPIX_SKYWALKER_2], NULL },
  },
  { NULL },
 }
};

/* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver gp8psk_usb_driver = {
 .name  = "dvb_usb_gp8psk",
 .probe  = gp8psk_usb_probe,
 .disconnect = dvb_usb_device_exit,
 .id_table = gp8psk_usb_table,
};

module_usb_driver(gp8psk_usb_driver);

MODULE_AUTHOR("Alan Nisota ");
MODULE_DESCRIPTION("Driver for Genpix DVB-S");
MODULE_VERSION("1.1");
MODULE_LICENSE("GPL");