1 /* DVB USB compliant Linux driver for the 2 * - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module 3 * 4 * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com) 5 * Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com) 6 * 7 * Thanks to GENPIX for the sample code used to implement this module. 8 * 9 * This module is based off the vp7045 and vp702x modules 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the Free 13 * Software Foundation, version 2. 14 * 15 * see Documentation/dvb/README.dvb-usb for more information 16 */ 17 #include "gp8psk.h" 18 #include "gp8psk-fe.h" 19 20 /* debug */ 21 static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw"; 22 int dvb_usb_gp8psk_debug; 23 module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644); 24 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS); 25 26 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 27 28 struct gp8psk_state { 29 unsigned char data[80]; 30 }; 31 32 static int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, 33 u16 index, u8 *b, int blen) 34 { 35 struct gp8psk_state *st = d->priv; 36 int ret = 0,try = 0; 37 38 if (blen > sizeof(st->data)) 39 return -EIO; 40 41 if ((ret = mutex_lock_interruptible(&d->usb_mutex))) 42 return ret; 43 44 while (ret >= 0 && ret != blen && try < 3) { 45 ret = usb_control_msg(d->udev, 46 usb_rcvctrlpipe(d->udev,0), 47 req, 48 USB_TYPE_VENDOR | USB_DIR_IN, 49 value, index, st->data, blen, 50 2000); 51 deb_info("reading number %d (ret: %d)\n",try,ret); 52 try++; 53 } 54 55 if (ret < 0 || ret != blen) { 56 warn("usb in %d operation failed.", req); 57 ret = -EIO; 58 } else { 59 ret = 0; 60 memcpy(b, st->data, blen); 61 } 62 63 deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index); 64 debug_dump(b,blen,deb_xfer); 65 66 mutex_unlock(&d->usb_mutex); 67 68 return ret; 69 } 70 71 static int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, 72 u16 index, u8 *b, int blen) 73 { 74 struct gp8psk_state *st = d->priv; 75 int ret; 76 77 deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index); 78 debug_dump(b,blen,deb_xfer); 79 80 if (blen > sizeof(st->data)) 81 return -EIO; 82 83 if ((ret = mutex_lock_interruptible(&d->usb_mutex))) 84 return ret; 85 86 memcpy(st->data, b, blen); 87 if (usb_control_msg(d->udev, 88 usb_sndctrlpipe(d->udev,0), 89 req, 90 USB_TYPE_VENDOR | USB_DIR_OUT, 91 value, index, st->data, blen, 92 2000) != blen) { 93 warn("usb out operation failed."); 94 ret = -EIO; 95 } else 96 ret = 0; 97 mutex_unlock(&d->usb_mutex); 98 99 return ret; 100 } 101 102 103 static int gp8psk_get_fw_version(struct dvb_usb_device *d, u8 *fw_vers) 104 { 105 return gp8psk_usb_in_op(d, GET_FW_VERS, 0, 0, fw_vers, 6); 106 } 107 108 static int gp8psk_get_fpga_version(struct dvb_usb_device *d, u8 *fpga_vers) 109 { 110 return gp8psk_usb_in_op(d, GET_FPGA_VERS, 0, 0, fpga_vers, 1); 111 } 112 113 static void gp8psk_info(struct dvb_usb_device *d) 114 { 115 u8 fpga_vers, fw_vers[6]; 116 117 if (!gp8psk_get_fw_version(d, fw_vers)) 118 info("FW Version = %i.%02i.%i (0x%x) Build %4i/%02i/%02i", 119 fw_vers[2], fw_vers[1], fw_vers[0], GP8PSK_FW_VERS(fw_vers), 120 2000 + fw_vers[5], fw_vers[4], fw_vers[3]); 121 else 122 info("failed to get FW version"); 123 124 if (!gp8psk_get_fpga_version(d, &fpga_vers)) 125 info("FPGA Version = %i", fpga_vers); 126 else 127 info("failed to get FPGA version"); 128 } 129 130 static int gp8psk_load_bcm4500fw(struct dvb_usb_device *d) 131 { 132 int ret; 133 const struct firmware *fw = NULL; 134 const u8 *ptr; 135 u8 *buf; 136 if ((ret = request_firmware(&fw, bcm4500_firmware, 137 &d->udev->dev)) != 0) { 138 err("did not find the bcm4500 firmware file. (%s) " 139 "Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)", 140 bcm4500_firmware,ret); 141 return ret; 142 } 143 144 ret = -EINVAL; 145 146 if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0)) 147 goto out_rel_fw; 148 149 info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware); 150 151 ptr = fw->data; 152 buf = kmalloc(64, GFP_KERNEL | GFP_DMA); 153 if (!buf) { 154 ret = -ENOMEM; 155 goto out_rel_fw; 156 } 157 158 while (ptr[0] != 0xff) { 159 u16 buflen = ptr[0] + 4; 160 if (ptr + buflen >= fw->data + fw->size) { 161 err("failed to load bcm4500 firmware."); 162 goto out_free; 163 } 164 if (buflen > 64) { 165 err("firmare chunk size bigger than 64 bytes."); 166 goto out_free; 167 } 168 169 memcpy(buf, ptr, buflen); 170 if (dvb_usb_generic_write(d, buf, buflen)) { 171 err("failed to load bcm4500 firmware."); 172 goto out_free; 173 } 174 ptr += buflen; 175 } 176 177 ret = 0; 178 179 out_free: 180 kfree(buf); 181 out_rel_fw: 182 release_firmware(fw); 183 184 return ret; 185 } 186 187 static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff) 188 { 189 u8 status, buf; 190 int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct); 191 192 if (onoff) { 193 gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1); 194 if (! (status & bm8pskStarted)) { /* started */ 195 if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K) 196 gp8psk_usb_out_op(d, CW3K_INIT, 1, 0, NULL, 0); 197 if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1)) 198 return -EINVAL; 199 gp8psk_info(d); 200 } 201 202 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM) 203 if (! (status & bm8pskFW_Loaded)) /* BCM4500 firmware loaded */ 204 if(gp8psk_load_bcm4500fw(d)) 205 return -EINVAL; 206 207 if (! (status & bmIntersilOn)) /* LNB Power */ 208 if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0, 209 &buf, 1)) 210 return -EINVAL; 211 212 /* Set DVB mode to 1 */ 213 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM) 214 if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0)) 215 return -EINVAL; 216 /* Abort possible TS (if previous tune crashed) */ 217 if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0)) 218 return -EINVAL; 219 } else { 220 /* Turn off LNB power */ 221 if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1)) 222 return -EINVAL; 223 /* Turn off 8psk power */ 224 if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1)) 225 return -EINVAL; 226 if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K) 227 gp8psk_usb_out_op(d, CW3K_INIT, 0, 0, NULL, 0); 228 } 229 return 0; 230 } 231 232 static int gp8psk_bcm4500_reload(struct dvb_usb_device *d) 233 { 234 u8 buf; 235 int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct); 236 237 deb_xfer("reloading firmware\n"); 238 239 /* Turn off 8psk power */ 240 if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1)) 241 return -EINVAL; 242 /* Turn On 8psk power */ 243 if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1)) 244 return -EINVAL; 245 /* load BCM4500 firmware */ 246 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM) 247 if (gp8psk_load_bcm4500fw(d)) 248 return -EINVAL; 249 return 0; 250 } 251 252 static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 253 { 254 return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0); 255 } 256 257 /* Callbacks for gp8psk-fe.c */ 258 259 static int gp8psk_fe_in(void *priv, u8 req, u16 value, 260 u16 index, u8 *b, int blen) 261 { 262 struct dvb_usb_device *d = priv; 263 264 return gp8psk_usb_in_op(d, req, value, index, b, blen); 265 } 266 267 static int gp8psk_fe_out(void *priv, u8 req, u16 value, 268 u16 index, u8 *b, int blen) 269 { 270 struct dvb_usb_device *d = priv; 271 272 return gp8psk_usb_out_op(d, req, value, index, b, blen); 273 } 274 275 static int gp8psk_fe_reload(void *priv) 276 { 277 struct dvb_usb_device *d = priv; 278 279 return gp8psk_bcm4500_reload(d); 280 } 281 282 const struct gp8psk_fe_ops gp8psk_fe_ops = { 283 .in = gp8psk_fe_in, 284 .out = gp8psk_fe_out, 285 .reload = gp8psk_fe_reload, 286 }; 287 288 static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap) 289 { 290 struct dvb_usb_device *d = adap->dev; 291 int id = le16_to_cpu(d->udev->descriptor.idProduct); 292 int is_rev1; 293 294 is_rev1 = (id == USB_PID_GENPIX_8PSK_REV_1_WARM) ? true : false; 295 296 adap->fe_adap[0].fe = dvb_attach(gp8psk_fe_attach, 297 &gp8psk_fe_ops, d, is_rev1); 298 return 0; 299 } 300 301 static struct dvb_usb_device_properties gp8psk_properties; 302 303 static int gp8psk_usb_probe(struct usb_interface *intf, 304 const struct usb_device_id *id) 305 { 306 int ret; 307 struct usb_device *udev = interface_to_usbdev(intf); 308 ret = dvb_usb_device_init(intf, &gp8psk_properties, 309 THIS_MODULE, NULL, adapter_nr); 310 if (ret == 0) { 311 info("found Genpix USB device pID = %x (hex)", 312 le16_to_cpu(udev->descriptor.idProduct)); 313 } 314 return ret; 315 } 316 317 static struct usb_device_id gp8psk_usb_table [] = { 318 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_COLD) }, 319 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_WARM) }, 320 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_2) }, 321 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_1) }, 322 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_2) }, 323 /* { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_CW3K) }, */ 324 { 0 }, 325 }; 326 MODULE_DEVICE_TABLE(usb, gp8psk_usb_table); 327 328 static struct dvb_usb_device_properties gp8psk_properties = { 329 .usb_ctrl = CYPRESS_FX2, 330 .firmware = "dvb-usb-gp8psk-01.fw", 331 332 .size_of_priv = sizeof(struct gp8psk_state), 333 334 .num_adapters = 1, 335 .adapter = { 336 { 337 .num_frontends = 1, 338 .fe = {{ 339 .streaming_ctrl = gp8psk_streaming_ctrl, 340 .frontend_attach = gp8psk_frontend_attach, 341 /* parameter for the MPEG2-data transfer */ 342 .stream = { 343 .type = USB_BULK, 344 .count = 7, 345 .endpoint = 0x82, 346 .u = { 347 .bulk = { 348 .buffersize = 8192, 349 } 350 } 351 }, 352 }}, 353 } 354 }, 355 .power_ctrl = gp8psk_power_ctrl, 356 357 .generic_bulk_ctrl_endpoint = 0x01, 358 359 .num_device_descs = 4, 360 .devices = { 361 { .name = "Genpix 8PSK-to-USB2 Rev.1 DVB-S receiver", 362 .cold_ids = { &gp8psk_usb_table[0], NULL }, 363 .warm_ids = { &gp8psk_usb_table[1], NULL }, 364 }, 365 { .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver", 366 .cold_ids = { NULL }, 367 .warm_ids = { &gp8psk_usb_table[2], NULL }, 368 }, 369 { .name = "Genpix SkyWalker-1 DVB-S receiver", 370 .cold_ids = { NULL }, 371 .warm_ids = { &gp8psk_usb_table[3], NULL }, 372 }, 373 { .name = "Genpix SkyWalker-2 DVB-S receiver", 374 .cold_ids = { NULL }, 375 .warm_ids = { &gp8psk_usb_table[4], NULL }, 376 }, 377 { NULL }, 378 } 379 }; 380 381 /* usb specific object needed to register this driver with the usb subsystem */ 382 static struct usb_driver gp8psk_usb_driver = { 383 .name = "dvb_usb_gp8psk", 384 .probe = gp8psk_usb_probe, 385 .disconnect = dvb_usb_device_exit, 386 .id_table = gp8psk_usb_table, 387 }; 388 389 module_usb_driver(gp8psk_usb_driver); 390 391 MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>"); 392 MODULE_DESCRIPTION("Driver for Genpix DVB-S"); 393 MODULE_VERSION("1.1"); 394 MODULE_LICENSE("GPL"); 395