1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* DVB USB compliant linux driver for Nebula Electronics uDigiTV DVB-T USB2.0 |
3 | * receiver |
4 | * |
5 | * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@posteo.de) |
6 | * |
7 | * partly based on the SDK published by Nebula Electronics |
8 | * |
9 | * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information |
10 | */ |
11 | #include "digitv.h" |
12 | |
13 | #include "mt352.h" |
14 | #include "nxt6000.h" |
15 | |
16 | /* debug */ |
17 | static int dvb_usb_digitv_debug; |
18 | module_param_named(debug,dvb_usb_digitv_debug, int, 0644); |
19 | MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS); |
20 | |
21 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
22 | |
23 | #define deb_rc(args...) dprintk(dvb_usb_digitv_debug,0x01,args) |
24 | |
25 | static int digitv_ctrl_msg(struct dvb_usb_device *d, |
26 | u8 cmd, u8 vv, u8 *wbuf, int wlen, u8 *rbuf, int rlen) |
27 | { |
28 | struct digitv_state *st = d->priv; |
29 | int ret, wo; |
30 | |
31 | wo = (rbuf == NULL || rlen == 0); /* write-only */ |
32 | |
33 | if (wlen > 4 || rlen > 4) |
34 | return -EIO; |
35 | |
36 | memset(st->sndbuf, 0, 7); |
37 | memset(st->rcvbuf, 0, 7); |
38 | |
39 | st->sndbuf[0] = cmd; |
40 | st->sndbuf[1] = vv; |
41 | st->sndbuf[2] = wo ? wlen : rlen; |
42 | |
43 | if (wo) { |
44 | memcpy(&st->sndbuf[3], wbuf, wlen); |
45 | ret = dvb_usb_generic_write(d, st->sndbuf, 7); |
46 | } else { |
47 | ret = dvb_usb_generic_rw(d, st->sndbuf, 7, st->rcvbuf, 7, 10); |
48 | memcpy(rbuf, &st->rcvbuf[3], rlen); |
49 | } |
50 | return ret; |
51 | } |
52 | |
53 | /* I2C */ |
54 | static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num) |
55 | { |
56 | struct dvb_usb_device *d = i2c_get_adapdata(adap); |
57 | int i; |
58 | |
59 | if (mutex_lock_interruptible(&d->i2c_mutex) < 0) |
60 | return -EAGAIN; |
61 | |
62 | if (num > 2) |
63 | warn("more than 2 i2c messages at a time is not handled yet. TODO." ); |
64 | |
65 | for (i = 0; i < num; i++) { |
66 | if (msg[i].len < 1) { |
67 | i = -EOPNOTSUPP; |
68 | break; |
69 | } |
70 | /* write/read request */ |
71 | if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) { |
72 | if (digitv_ctrl_msg(d, USB_READ_COFDM, vv: msg[i].buf[0], NULL, wlen: 0, |
73 | rbuf: msg[i+1].buf,rlen: msg[i+1].len) < 0) |
74 | break; |
75 | i++; |
76 | } else |
77 | if (digitv_ctrl_msg(d,USB_WRITE_COFDM, vv: msg[i].buf[0], |
78 | wbuf: &msg[i].buf[1],wlen: msg[i].len-1,NULL,rlen: 0) < 0) |
79 | break; |
80 | } |
81 | |
82 | mutex_unlock(lock: &d->i2c_mutex); |
83 | return i; |
84 | } |
85 | |
86 | static u32 digitv_i2c_func(struct i2c_adapter *adapter) |
87 | { |
88 | return I2C_FUNC_I2C; |
89 | } |
90 | |
91 | static struct i2c_algorithm digitv_i2c_algo = { |
92 | .master_xfer = digitv_i2c_xfer, |
93 | .functionality = digitv_i2c_func, |
94 | }; |
95 | |
96 | /* Callbacks for DVB USB */ |
97 | static int digitv_identify_state(struct usb_device *udev, |
98 | const struct dvb_usb_device_properties *props, |
99 | const struct dvb_usb_device_description **desc, |
100 | int *cold) |
101 | { |
102 | *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0; |
103 | return 0; |
104 | } |
105 | |
106 | static int digitv_mt352_demod_init(struct dvb_frontend *fe) |
107 | { |
108 | static u8 reset_buf[] = { 0x89, 0x38, 0x8a, 0x2d, 0x50, 0x80 }; |
109 | static u8 init_buf[] = { 0x68, 0xa0, 0x8e, 0x40, 0x53, 0x50, |
110 | 0x67, 0x20, 0x7d, 0x01, 0x7c, 0x00, 0x7a, 0x00, |
111 | 0x79, 0x20, 0x57, 0x05, 0x56, 0x31, 0x88, 0x0f, |
112 | 0x75, 0x32 }; |
113 | int i; |
114 | |
115 | for (i = 0; i < ARRAY_SIZE(reset_buf); i += 2) |
116 | mt352_write(fe, buf: &reset_buf[i], len: 2); |
117 | |
118 | msleep(msecs: 1); |
119 | |
120 | for (i = 0; i < ARRAY_SIZE(init_buf); i += 2) |
121 | mt352_write(fe, buf: &init_buf[i], len: 2); |
122 | |
123 | return 0; |
124 | } |
125 | |
126 | static struct mt352_config digitv_mt352_config = { |
127 | .demod_init = digitv_mt352_demod_init, |
128 | }; |
129 | |
130 | static int digitv_nxt6000_tuner_set_params(struct dvb_frontend *fe) |
131 | { |
132 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
133 | u8 b[5]; |
134 | |
135 | fe->ops.tuner_ops.calc_regs(fe, b, sizeof(b)); |
136 | if (fe->ops.i2c_gate_ctrl) |
137 | fe->ops.i2c_gate_ctrl(fe, 1); |
138 | return digitv_ctrl_msg(d: adap->dev, USB_WRITE_TUNER, vv: 0, wbuf: &b[1], wlen: 4, NULL, rlen: 0); |
139 | } |
140 | |
141 | static struct nxt6000_config digitv_nxt6000_config = { |
142 | .clock_inversion = 1, |
143 | }; |
144 | |
145 | static int digitv_frontend_attach(struct dvb_usb_adapter *adap) |
146 | { |
147 | struct digitv_state *st = adap->dev->priv; |
148 | |
149 | adap->fe_adap[0].fe = dvb_attach(mt352_attach, &digitv_mt352_config, |
150 | &adap->dev->i2c_adap); |
151 | if ((adap->fe_adap[0].fe) != NULL) { |
152 | st->is_nxt6000 = 0; |
153 | return 0; |
154 | } |
155 | adap->fe_adap[0].fe = dvb_attach(nxt6000_attach, |
156 | &digitv_nxt6000_config, |
157 | &adap->dev->i2c_adap); |
158 | if ((adap->fe_adap[0].fe) != NULL) { |
159 | st->is_nxt6000 = 1; |
160 | return 0; |
161 | } |
162 | return -EIO; |
163 | } |
164 | |
165 | static int digitv_tuner_attach(struct dvb_usb_adapter *adap) |
166 | { |
167 | struct digitv_state *st = adap->dev->priv; |
168 | |
169 | if (!dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, NULL, DVB_PLL_TDED4)) |
170 | return -ENODEV; |
171 | |
172 | if (st->is_nxt6000) |
173 | adap->fe_adap[0].fe->ops.tuner_ops.set_params = digitv_nxt6000_tuner_set_params; |
174 | |
175 | return 0; |
176 | } |
177 | |
178 | static struct rc_map_table rc_map_digitv_table[] = { |
179 | { 0x5f55, KEY_0 }, |
180 | { 0x6f55, KEY_1 }, |
181 | { 0x9f55, KEY_2 }, |
182 | { 0xaf55, KEY_3 }, |
183 | { 0x5f56, KEY_4 }, |
184 | { 0x6f56, KEY_5 }, |
185 | { 0x9f56, KEY_6 }, |
186 | { 0xaf56, KEY_7 }, |
187 | { 0x5f59, KEY_8 }, |
188 | { 0x6f59, KEY_9 }, |
189 | { 0x9f59, KEY_TV }, |
190 | { 0xaf59, KEY_AUX }, |
191 | { 0x5f5a, KEY_DVD }, |
192 | { 0x6f5a, KEY_POWER }, |
193 | { 0x9f5a, KEY_CAMERA }, /* labelled 'Picture' */ |
194 | { 0xaf5a, KEY_AUDIO }, |
195 | { 0x5f65, KEY_INFO }, |
196 | { 0x6f65, KEY_F13 }, /* 16:9 */ |
197 | { 0x9f65, KEY_F14 }, /* 14:9 */ |
198 | { 0xaf65, KEY_EPG }, |
199 | { 0x5f66, KEY_EXIT }, |
200 | { 0x6f66, KEY_MENU }, |
201 | { 0x9f66, KEY_UP }, |
202 | { 0xaf66, KEY_DOWN }, |
203 | { 0x5f69, KEY_LEFT }, |
204 | { 0x6f69, KEY_RIGHT }, |
205 | { 0x9f69, KEY_ENTER }, |
206 | { 0xaf69, KEY_CHANNELUP }, |
207 | { 0x5f6a, KEY_CHANNELDOWN }, |
208 | { 0x6f6a, KEY_VOLUMEUP }, |
209 | { 0x9f6a, KEY_VOLUMEDOWN }, |
210 | { 0xaf6a, KEY_RED }, |
211 | { 0x5f95, KEY_GREEN }, |
212 | { 0x6f95, KEY_YELLOW }, |
213 | { 0x9f95, KEY_BLUE }, |
214 | { 0xaf95, KEY_SUBTITLE }, |
215 | { 0x5f96, KEY_F15 }, /* AD */ |
216 | { 0x6f96, KEY_TEXT }, |
217 | { 0x9f96, KEY_MUTE }, |
218 | { 0xaf96, KEY_REWIND }, |
219 | { 0x5f99, KEY_STOP }, |
220 | { 0x6f99, KEY_PLAY }, |
221 | { 0x9f99, KEY_FASTFORWARD }, |
222 | { 0xaf99, KEY_F16 }, /* chapter */ |
223 | { 0x5f9a, KEY_PAUSE }, |
224 | { 0x6f9a, KEY_PLAY }, |
225 | { 0x9f9a, KEY_RECORD }, |
226 | { 0xaf9a, KEY_F17 }, /* picture in picture */ |
227 | { 0x5fa5, KEY_KPPLUS }, /* zoom in */ |
228 | { 0x6fa5, KEY_KPMINUS }, /* zoom out */ |
229 | { 0x9fa5, KEY_F18 }, /* capture */ |
230 | { 0xafa5, KEY_F19 }, /* web */ |
231 | { 0x5fa6, KEY_EMAIL }, |
232 | { 0x6fa6, KEY_PHONE }, |
233 | { 0x9fa6, KEY_PC }, |
234 | }; |
235 | |
236 | static int digitv_rc_query(struct dvb_usb_device *d, u32 *event, int *state) |
237 | { |
238 | struct rc_map_table *entry; |
239 | int ret, i; |
240 | u8 key[4]; |
241 | u8 b[4] = { 0 }; |
242 | |
243 | *event = 0; |
244 | *state = REMOTE_NO_KEY_PRESSED; |
245 | |
246 | ret = digitv_ctrl_msg(d, USB_READ_REMOTE, vv: 0, NULL, wlen: 0, rbuf: key, rlen: 4); |
247 | if (ret) |
248 | return ret; |
249 | |
250 | /* Tell the device we've read the remote. Not sure how necessary |
251 | this is, but the Nebula SDK does it. */ |
252 | ret = digitv_ctrl_msg(d, USB_WRITE_REMOTE, vv: 0, wbuf: b, wlen: 4, NULL, rlen: 0); |
253 | if (ret) |
254 | return ret; |
255 | |
256 | /* if something is inside the buffer, simulate key press */ |
257 | if (key[0] != 0) { |
258 | for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) { |
259 | entry = &d->props.rc.legacy.rc_map_table[i]; |
260 | |
261 | if (rc5_custom(key: entry) == key[0] && |
262 | rc5_data(key: entry) == key[1]) { |
263 | *event = entry->keycode; |
264 | *state = REMOTE_KEY_PRESSED; |
265 | return 0; |
266 | } |
267 | } |
268 | |
269 | deb_rc("key: %*ph\n" , 4, key); |
270 | } |
271 | |
272 | return 0; |
273 | } |
274 | |
275 | /* DVB USB Driver stuff */ |
276 | static struct dvb_usb_device_properties digitv_properties; |
277 | |
278 | static int digitv_probe(struct usb_interface *intf, |
279 | const struct usb_device_id *id) |
280 | { |
281 | struct dvb_usb_device *d; |
282 | int ret = dvb_usb_device_init(intf, &digitv_properties, THIS_MODULE, &d, |
283 | adapter_nums: adapter_nr); |
284 | if (ret == 0) { |
285 | u8 b[4] = { 0 }; |
286 | |
287 | if (d != NULL) { /* do that only when the firmware is loaded */ |
288 | b[0] = 1; |
289 | digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,vv: 0,wbuf: b,wlen: 4,NULL,rlen: 0); |
290 | |
291 | b[0] = 0; |
292 | digitv_ctrl_msg(d,USB_WRITE_REMOTE,vv: 0,wbuf: b,wlen: 4,NULL,rlen: 0); |
293 | } |
294 | } |
295 | return ret; |
296 | } |
297 | |
298 | enum { |
299 | ANCHOR_NEBULA_DIGITV, |
300 | }; |
301 | |
302 | static struct usb_device_id digitv_table[] = { |
303 | DVB_USB_DEV(ANCHOR, ANCHOR_NEBULA_DIGITV), |
304 | { } |
305 | }; |
306 | |
307 | MODULE_DEVICE_TABLE (usb, digitv_table); |
308 | |
309 | static struct dvb_usb_device_properties digitv_properties = { |
310 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
311 | |
312 | .usb_ctrl = CYPRESS_FX2, |
313 | .firmware = "dvb-usb-digitv-02.fw" , |
314 | |
315 | .size_of_priv = sizeof(struct digitv_state), |
316 | |
317 | .num_adapters = 1, |
318 | .adapter = { |
319 | { |
320 | .num_frontends = 1, |
321 | .fe = {{ |
322 | .frontend_attach = digitv_frontend_attach, |
323 | .tuner_attach = digitv_tuner_attach, |
324 | |
325 | /* parameter for the MPEG2-data transfer */ |
326 | .stream = { |
327 | .type = USB_BULK, |
328 | .count = 7, |
329 | .endpoint = 0x02, |
330 | .u = { |
331 | .bulk = { |
332 | .buffersize = 4096, |
333 | } |
334 | } |
335 | }, |
336 | }}, |
337 | } |
338 | }, |
339 | .identify_state = digitv_identify_state, |
340 | |
341 | .rc.legacy = { |
342 | .rc_interval = 1000, |
343 | .rc_map_table = rc_map_digitv_table, |
344 | .rc_map_size = ARRAY_SIZE(rc_map_digitv_table), |
345 | .rc_query = digitv_rc_query, |
346 | }, |
347 | |
348 | .i2c_algo = &digitv_i2c_algo, |
349 | |
350 | .generic_bulk_ctrl_endpoint = 0x01, |
351 | |
352 | .num_device_descs = 1, |
353 | .devices = { |
354 | { "Nebula Electronics uDigiTV DVB-T USB2.0)" , |
355 | { &digitv_table[ANCHOR_NEBULA_DIGITV], NULL }, |
356 | { NULL }, |
357 | }, |
358 | { NULL }, |
359 | } |
360 | }; |
361 | |
362 | static struct usb_driver digitv_driver = { |
363 | .name = "dvb_usb_digitv" , |
364 | .probe = digitv_probe, |
365 | .disconnect = dvb_usb_device_exit, |
366 | .id_table = digitv_table, |
367 | }; |
368 | |
369 | module_usb_driver(digitv_driver); |
370 | |
371 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>" ); |
372 | MODULE_DESCRIPTION("Driver for Nebula Electronics uDigiTV DVB-T USB2.0" ); |
373 | MODULE_VERSION("1.0-alpha" ); |
374 | MODULE_LICENSE("GPL" ); |
375 | |