forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
9.8 KiB
390 lines
9.8 KiB
// 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 ([email protected]) |
|
* Copyright (C) 2006,2007 Genpix Electronics ([email protected]) |
|
* |
|
* 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 <kernel_dir>/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) ? true : false; |
|
|
|
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; |
|
} |
|
|
|
static struct usb_device_id gp8psk_usb_table [] = { |
|
{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_COLD) }, |
|
{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_WARM) }, |
|
{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_2) }, |
|
{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_1) }, |
|
{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_2) }, |
|
/* { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_CW3K) }, */ |
|
{ 0 }, |
|
}; |
|
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[0], NULL }, |
|
.warm_ids = { &gp8psk_usb_table[1], NULL }, |
|
}, |
|
{ .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver", |
|
.cold_ids = { NULL }, |
|
.warm_ids = { &gp8psk_usb_table[2], NULL }, |
|
}, |
|
{ .name = "Genpix SkyWalker-1 DVB-S receiver", |
|
.cold_ids = { NULL }, |
|
.warm_ids = { &gp8psk_usb_table[3], NULL }, |
|
}, |
|
{ .name = "Genpix SkyWalker-2 DVB-S receiver", |
|
.cold_ids = { NULL }, |
|
.warm_ids = { &gp8psk_usb_table[4], 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 <[email protected]>"); |
|
MODULE_DESCRIPTION("Driver for Genpix DVB-S"); |
|
MODULE_VERSION("1.1"); |
|
MODULE_LICENSE("GPL");
|
|
|