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