1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include "gp8psk.h"
18#include "gp8psk-fe.h"
19
20
21static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw";
22int dvb_usb_gp8psk_debug;
23module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
24MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
25
26DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
27
28struct gp8psk_state {
29 unsigned char data[80];
30};
31
32static 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
71static 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
103static 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
108static 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
113static 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
130static 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' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware",
139 bcm4500_firmware,ret);
140 return ret;
141 }
142
143 ret = -EINVAL;
144
145 if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
146 goto out_rel_fw;
147
148 info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware);
149
150 ptr = fw->data;
151 buf = kmalloc(64, GFP_KERNEL);
152 if (!buf) {
153 ret = -ENOMEM;
154 goto out_rel_fw;
155 }
156
157 while (ptr[0] != 0xff) {
158 u16 buflen = ptr[0] + 4;
159 if (ptr + buflen >= fw->data + fw->size) {
160 err("failed to load bcm4500 firmware.");
161 goto out_free;
162 }
163 if (buflen > 64) {
164 err("firmware chunk size bigger than 64 bytes.");
165 goto out_free;
166 }
167
168 memcpy(buf, ptr, buflen);
169 if (dvb_usb_generic_write(d, buf, buflen)) {
170 err("failed to load bcm4500 firmware.");
171 goto out_free;
172 }
173 ptr += buflen;
174 }
175
176 ret = 0;
177
178out_free:
179 kfree(buf);
180out_rel_fw:
181 release_firmware(fw);
182
183 return ret;
184}
185
186static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
187{
188 u8 status, buf;
189 int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
190
191 if (onoff) {
192 gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
193 if (! (status & bm8pskStarted)) {
194 if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
195 gp8psk_usb_out_op(d, CW3K_INIT, 1, 0, NULL, 0);
196 if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
197 return -EINVAL;
198 gp8psk_info(d);
199 }
200
201 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
202 if (! (status & bm8pskFW_Loaded))
203 if(gp8psk_load_bcm4500fw(d))
204 return -EINVAL;
205
206 if (! (status & bmIntersilOn))
207 if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
208 &buf, 1))
209 return -EINVAL;
210
211
212 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
213 if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
214 return -EINVAL;
215
216 if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0))
217 return -EINVAL;
218 } else {
219
220 if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
221 return -EINVAL;
222
223 if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
224 return -EINVAL;
225 if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
226 gp8psk_usb_out_op(d, CW3K_INIT, 0, 0, NULL, 0);
227 }
228 return 0;
229}
230
231static int gp8psk_bcm4500_reload(struct dvb_usb_device *d)
232{
233 u8 buf;
234 int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
235
236 deb_xfer("reloading firmware\n");
237
238
239 if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
240 return -EINVAL;
241
242 if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
243 return -EINVAL;
244
245 if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
246 if (gp8psk_load_bcm4500fw(d))
247 return -EINVAL;
248 return 0;
249}
250
251static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
252{
253 return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0);
254}
255
256
257
258static int gp8psk_fe_in(void *priv, u8 req, u16 value,
259 u16 index, u8 *b, int blen)
260{
261 struct dvb_usb_device *d = priv;
262
263 return gp8psk_usb_in_op(d, req, value, index, b, blen);
264}
265
266static int gp8psk_fe_out(void *priv, u8 req, u16 value,
267 u16 index, u8 *b, int blen)
268{
269 struct dvb_usb_device *d = priv;
270
271 return gp8psk_usb_out_op(d, req, value, index, b, blen);
272}
273
274static int gp8psk_fe_reload(void *priv)
275{
276 struct dvb_usb_device *d = priv;
277
278 return gp8psk_bcm4500_reload(d);
279}
280
281static const struct gp8psk_fe_ops gp8psk_fe_ops = {
282 .in = gp8psk_fe_in,
283 .out = gp8psk_fe_out,
284 .reload = gp8psk_fe_reload,
285};
286
287static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap)
288{
289 struct dvb_usb_device *d = adap->dev;
290 int id = le16_to_cpu(d->udev->descriptor.idProduct);
291 int is_rev1;
292
293 is_rev1 = (id == USB_PID_GENPIX_8PSK_REV_1_WARM) ? true : false;
294
295 adap->fe_adap[0].fe = dvb_attach(gp8psk_fe_attach,
296 &gp8psk_fe_ops, d, is_rev1);
297 return 0;
298}
299
300static struct dvb_usb_device_properties gp8psk_properties;
301
302static int gp8psk_usb_probe(struct usb_interface *intf,
303 const struct usb_device_id *id)
304{
305 int ret;
306 struct usb_device *udev = interface_to_usbdev(intf);
307 ret = dvb_usb_device_init(intf, &gp8psk_properties,
308 THIS_MODULE, NULL, adapter_nr);
309 if (ret == 0) {
310 info("found Genpix USB device pID = %x (hex)",
311 le16_to_cpu(udev->descriptor.idProduct));
312 }
313 return ret;
314}
315
316static struct usb_device_id gp8psk_usb_table [] = {
317 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_COLD) },
318 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_WARM) },
319 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_2) },
320 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_1) },
321 { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_2) },
322
323 { 0 },
324};
325MODULE_DEVICE_TABLE(usb, gp8psk_usb_table);
326
327static struct dvb_usb_device_properties gp8psk_properties = {
328 .usb_ctrl = CYPRESS_FX2,
329 .firmware = "dvb-usb-gp8psk-01.fw",
330
331 .size_of_priv = sizeof(struct gp8psk_state),
332
333 .num_adapters = 1,
334 .adapter = {
335 {
336 .num_frontends = 1,
337 .fe = {{
338 .streaming_ctrl = gp8psk_streaming_ctrl,
339 .frontend_attach = gp8psk_frontend_attach,
340
341 .stream = {
342 .type = USB_BULK,
343 .count = 7,
344 .endpoint = 0x82,
345 .u = {
346 .bulk = {
347 .buffersize = 8192,
348 }
349 }
350 },
351 }},
352 }
353 },
354 .power_ctrl = gp8psk_power_ctrl,
355
356 .generic_bulk_ctrl_endpoint = 0x01,
357
358 .num_device_descs = 4,
359 .devices = {
360 { .name = "Genpix 8PSK-to-USB2 Rev.1 DVB-S receiver",
361 .cold_ids = { &gp8psk_usb_table[0], NULL },
362 .warm_ids = { &gp8psk_usb_table[1], NULL },
363 },
364 { .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver",
365 .cold_ids = { NULL },
366 .warm_ids = { &gp8psk_usb_table[2], NULL },
367 },
368 { .name = "Genpix SkyWalker-1 DVB-S receiver",
369 .cold_ids = { NULL },
370 .warm_ids = { &gp8psk_usb_table[3], NULL },
371 },
372 { .name = "Genpix SkyWalker-2 DVB-S receiver",
373 .cold_ids = { NULL },
374 .warm_ids = { &gp8psk_usb_table[4], NULL },
375 },
376 { NULL },
377 }
378};
379
380
381static struct usb_driver gp8psk_usb_driver = {
382 .name = "dvb_usb_gp8psk",
383 .probe = gp8psk_usb_probe,
384 .disconnect = dvb_usb_device_exit,
385 .id_table = gp8psk_usb_table,
386};
387
388module_usb_driver(gp8psk_usb_driver);
389
390MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>");
391MODULE_DESCRIPTION("Driver for Genpix DVB-S");
392MODULE_VERSION("1.1");
393MODULE_LICENSE("GPL");
394
