1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * pvrusb2-dvb.c - linux-dvb api interface to the pvrusb2 driver. |
4 | * |
5 | * Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org> |
6 | */ |
7 | |
8 | #include <linux/kthread.h> |
9 | #include <linux/freezer.h> |
10 | #include <linux/slab.h> |
11 | #include <linux/mm.h> |
12 | #include <media/dvbdev.h> |
13 | #include "pvrusb2-debug.h" |
14 | #include "pvrusb2-hdw-internal.h" |
15 | #include "pvrusb2-hdw.h" |
16 | #include "pvrusb2-io.h" |
17 | #include "pvrusb2-dvb.h" |
18 | |
19 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
20 | |
21 | static int pvr2_dvb_feed_func(struct pvr2_dvb_adapter *adap) |
22 | { |
23 | int ret; |
24 | unsigned int count; |
25 | struct pvr2_buffer *bp; |
26 | struct pvr2_stream *stream; |
27 | |
28 | pvr2_trace(PVR2_TRACE_DVB_FEED, "dvb feed thread started" ); |
29 | set_freezable(); |
30 | |
31 | stream = adap->channel.stream->stream; |
32 | |
33 | for (;;) { |
34 | if (kthread_should_stop()) break; |
35 | |
36 | bp = pvr2_stream_get_ready_buffer(stream); |
37 | if (bp != NULL) { |
38 | count = pvr2_buffer_get_count(bp); |
39 | if (count) { |
40 | dvb_dmx_swfilter( |
41 | demux: &adap->demux, |
42 | buf: adap->buffer_storage[ |
43 | pvr2_buffer_get_id(bp)], |
44 | count); |
45 | } else { |
46 | ret = pvr2_buffer_get_status(bp); |
47 | if (ret < 0) break; |
48 | } |
49 | ret = pvr2_buffer_queue(bp); |
50 | if (ret < 0) break; |
51 | |
52 | /* Since we know we did something to a buffer, |
53 | just go back and try again. No point in |
54 | blocking unless we really ran out of |
55 | buffers to process. */ |
56 | continue; |
57 | } |
58 | |
59 | |
60 | /* Wait until more buffers become available or we're |
61 | told not to wait any longer. */ |
62 | ret = wait_event_freezable(adap->buffer_wait_data, |
63 | (pvr2_stream_get_ready_count(stream) > 0) || |
64 | kthread_should_stop()); |
65 | if (ret < 0) break; |
66 | } |
67 | |
68 | /* If we get here and ret is < 0, then an error has occurred. |
69 | Probably would be a good idea to communicate that to DVB core... */ |
70 | |
71 | pvr2_trace(PVR2_TRACE_DVB_FEED, "dvb feed thread stopped" ); |
72 | |
73 | return 0; |
74 | } |
75 | |
76 | static int pvr2_dvb_feed_thread(void *data) |
77 | { |
78 | int stat = pvr2_dvb_feed_func(adap: data); |
79 | |
80 | while (!kthread_should_stop()) { |
81 | set_current_state(TASK_INTERRUPTIBLE); |
82 | schedule(); |
83 | } |
84 | return stat; |
85 | } |
86 | |
87 | static void pvr2_dvb_notify(void *ptr) |
88 | { |
89 | struct pvr2_dvb_adapter *adap = ptr; |
90 | |
91 | wake_up(&adap->buffer_wait_data); |
92 | } |
93 | |
94 | static void pvr2_dvb_stream_end(struct pvr2_dvb_adapter *adap) |
95 | { |
96 | unsigned int idx; |
97 | struct pvr2_stream *stream; |
98 | |
99 | if (adap->thread) { |
100 | kthread_stop(k: adap->thread); |
101 | adap->thread = NULL; |
102 | } |
103 | |
104 | if (adap->channel.stream) { |
105 | stream = adap->channel.stream->stream; |
106 | } else { |
107 | stream = NULL; |
108 | } |
109 | if (stream) { |
110 | pvr2_hdw_set_streaming(adap->channel.hdw, 0); |
111 | pvr2_stream_set_callback(stream, NULL, NULL); |
112 | pvr2_stream_kill(stream); |
113 | pvr2_stream_set_buffer_count(stream, 0); |
114 | pvr2_channel_claim_stream(&adap->channel, NULL); |
115 | } |
116 | |
117 | if (adap->stream_run) { |
118 | for (idx = 0; idx < PVR2_DVB_BUFFER_COUNT; idx++) { |
119 | if (!(adap->buffer_storage[idx])) continue; |
120 | kfree(objp: adap->buffer_storage[idx]); |
121 | adap->buffer_storage[idx] = NULL; |
122 | } |
123 | adap->stream_run = 0; |
124 | } |
125 | } |
126 | |
127 | static int pvr2_dvb_stream_do_start(struct pvr2_dvb_adapter *adap) |
128 | { |
129 | struct pvr2_context *pvr = adap->channel.mc_head; |
130 | unsigned int idx; |
131 | int ret; |
132 | struct pvr2_buffer *bp; |
133 | struct pvr2_stream *stream = NULL; |
134 | |
135 | if (adap->stream_run) return -EIO; |
136 | |
137 | ret = pvr2_channel_claim_stream(&adap->channel, &pvr->video_stream); |
138 | /* somebody else already has the stream */ |
139 | if (ret < 0) return ret; |
140 | |
141 | stream = adap->channel.stream->stream; |
142 | |
143 | for (idx = 0; idx < PVR2_DVB_BUFFER_COUNT; idx++) { |
144 | adap->buffer_storage[idx] = kmalloc(PVR2_DVB_BUFFER_SIZE, |
145 | GFP_KERNEL); |
146 | if (!(adap->buffer_storage[idx])) return -ENOMEM; |
147 | } |
148 | |
149 | pvr2_stream_set_callback(pvr->video_stream.stream, |
150 | func: pvr2_dvb_notify, data: adap); |
151 | |
152 | ret = pvr2_stream_set_buffer_count(stream, PVR2_DVB_BUFFER_COUNT); |
153 | if (ret < 0) return ret; |
154 | |
155 | for (idx = 0; idx < PVR2_DVB_BUFFER_COUNT; idx++) { |
156 | bp = pvr2_stream_get_buffer(sp: stream, id: idx); |
157 | pvr2_buffer_set_buffer(bp, |
158 | ptr: adap->buffer_storage[idx], |
159 | PVR2_DVB_BUFFER_SIZE); |
160 | } |
161 | |
162 | ret = pvr2_hdw_set_streaming(adap->channel.hdw, 1); |
163 | if (ret < 0) return ret; |
164 | |
165 | while ((bp = pvr2_stream_get_idle_buffer(stream)) != NULL) { |
166 | ret = pvr2_buffer_queue(bp); |
167 | if (ret < 0) return ret; |
168 | } |
169 | |
170 | adap->thread = kthread_run(pvr2_dvb_feed_thread, adap, "pvrusb2-dvb" ); |
171 | |
172 | if (IS_ERR(ptr: adap->thread)) { |
173 | ret = PTR_ERR(ptr: adap->thread); |
174 | adap->thread = NULL; |
175 | return ret; |
176 | } |
177 | |
178 | adap->stream_run = !0; |
179 | |
180 | return 0; |
181 | } |
182 | |
183 | static int pvr2_dvb_stream_start(struct pvr2_dvb_adapter *adap) |
184 | { |
185 | int ret = pvr2_dvb_stream_do_start(adap); |
186 | if (ret < 0) pvr2_dvb_stream_end(adap); |
187 | return ret; |
188 | } |
189 | |
190 | static int pvr2_dvb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff) |
191 | { |
192 | struct pvr2_dvb_adapter *adap = dvbdmxfeed->demux->priv; |
193 | int ret = 0; |
194 | |
195 | if (adap == NULL) return -ENODEV; |
196 | |
197 | mutex_lock(&adap->lock); |
198 | do { |
199 | if (onoff) { |
200 | if (!adap->feedcount) { |
201 | pvr2_trace(PVR2_TRACE_DVB_FEED, |
202 | "start feeding demux" ); |
203 | ret = pvr2_dvb_stream_start(adap); |
204 | if (ret < 0) break; |
205 | } |
206 | (adap->feedcount)++; |
207 | } else if (adap->feedcount > 0) { |
208 | (adap->feedcount)--; |
209 | if (!adap->feedcount) { |
210 | pvr2_trace(PVR2_TRACE_DVB_FEED, |
211 | "stop feeding demux" ); |
212 | pvr2_dvb_stream_end(adap); |
213 | } |
214 | } |
215 | } while (0); |
216 | mutex_unlock(lock: &adap->lock); |
217 | |
218 | return ret; |
219 | } |
220 | |
221 | static int pvr2_dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed) |
222 | { |
223 | pvr2_trace(PVR2_TRACE_DVB_FEED, "start pid: 0x%04x" , dvbdmxfeed->pid); |
224 | return pvr2_dvb_ctrl_feed(dvbdmxfeed, onoff: 1); |
225 | } |
226 | |
227 | static int pvr2_dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed) |
228 | { |
229 | pvr2_trace(PVR2_TRACE_DVB_FEED, "stop pid: 0x%04x" , dvbdmxfeed->pid); |
230 | return pvr2_dvb_ctrl_feed(dvbdmxfeed, onoff: 0); |
231 | } |
232 | |
233 | static int pvr2_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire) |
234 | { |
235 | struct pvr2_dvb_adapter *adap = fe->dvb->priv; |
236 | return pvr2_channel_limit_inputs( |
237 | &adap->channel, |
238 | (acquire ? (1 << PVR2_CVAL_INPUT_DTV) : 0)); |
239 | } |
240 | |
241 | static int pvr2_dvb_adapter_init(struct pvr2_dvb_adapter *adap) |
242 | { |
243 | int ret; |
244 | |
245 | ret = dvb_register_adapter(adap: &adap->dvb_adap, name: "pvrusb2-dvb" , |
246 | THIS_MODULE/*&hdw->usb_dev->owner*/, |
247 | device: &adap->channel.hdw->usb_dev->dev, |
248 | adapter_nums: adapter_nr); |
249 | if (ret < 0) { |
250 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
251 | "dvb_register_adapter failed: error %d" , ret); |
252 | goto err; |
253 | } |
254 | adap->dvb_adap.priv = adap; |
255 | |
256 | adap->demux.dmx.capabilities = DMX_TS_FILTERING | |
257 | DMX_SECTION_FILTERING | |
258 | DMX_MEMORY_BASED_FILTERING; |
259 | adap->demux.priv = adap; |
260 | adap->demux.filternum = 256; |
261 | adap->demux.feednum = 256; |
262 | adap->demux.start_feed = pvr2_dvb_start_feed; |
263 | adap->demux.stop_feed = pvr2_dvb_stop_feed; |
264 | adap->demux.write_to_decoder = NULL; |
265 | |
266 | ret = dvb_dmx_init(demux: &adap->demux); |
267 | if (ret < 0) { |
268 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
269 | "dvb_dmx_init failed: error %d" , ret); |
270 | goto err_dmx; |
271 | } |
272 | |
273 | adap->dmxdev.filternum = adap->demux.filternum; |
274 | adap->dmxdev.demux = &adap->demux.dmx; |
275 | adap->dmxdev.capabilities = 0; |
276 | |
277 | ret = dvb_dmxdev_init(dmxdev: &adap->dmxdev, adap: &adap->dvb_adap); |
278 | if (ret < 0) { |
279 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
280 | "dvb_dmxdev_init failed: error %d" , ret); |
281 | goto err_dmx_dev; |
282 | } |
283 | |
284 | dvb_net_init(adap: &adap->dvb_adap, dvbnet: &adap->dvb_net, dmxdemux: &adap->demux.dmx); |
285 | |
286 | return 0; |
287 | |
288 | err_dmx_dev: |
289 | dvb_dmx_release(demux: &adap->demux); |
290 | err_dmx: |
291 | dvb_unregister_adapter(adap: &adap->dvb_adap); |
292 | err: |
293 | return ret; |
294 | } |
295 | |
296 | static int pvr2_dvb_adapter_exit(struct pvr2_dvb_adapter *adap) |
297 | { |
298 | pvr2_trace(PVR2_TRACE_INFO, "unregistering DVB devices" ); |
299 | dvb_net_release(dvbnet: &adap->dvb_net); |
300 | adap->demux.dmx.close(&adap->demux.dmx); |
301 | dvb_dmxdev_release(dmxdev: &adap->dmxdev); |
302 | dvb_dmx_release(demux: &adap->demux); |
303 | dvb_unregister_adapter(adap: &adap->dvb_adap); |
304 | return 0; |
305 | } |
306 | |
307 | static int pvr2_dvb_frontend_init(struct pvr2_dvb_adapter *adap) |
308 | { |
309 | struct pvr2_hdw *hdw = adap->channel.hdw; |
310 | const struct pvr2_dvb_props *dvb_props = hdw->hdw_desc->dvb_props; |
311 | int ret = 0; |
312 | |
313 | if (dvb_props == NULL) { |
314 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, "fe_props not defined!" ); |
315 | return -EINVAL; |
316 | } |
317 | |
318 | ret = pvr2_channel_limit_inputs( |
319 | &adap->channel, |
320 | (1 << PVR2_CVAL_INPUT_DTV)); |
321 | if (ret) { |
322 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
323 | "failed to grab control of dtv input (code=%d)" , |
324 | ret); |
325 | return ret; |
326 | } |
327 | |
328 | if (dvb_props->frontend_attach == NULL) { |
329 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
330 | "frontend_attach not defined!" ); |
331 | ret = -EINVAL; |
332 | goto done; |
333 | } |
334 | |
335 | if (dvb_props->frontend_attach(adap) == 0 && adap->fe[0]) { |
336 | if (dvb_register_frontend(dvb: &adap->dvb_adap, fe: adap->fe[0])) { |
337 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
338 | "frontend registration failed!" ); |
339 | ret = -ENODEV; |
340 | goto fail_frontend0; |
341 | } |
342 | if (adap->fe[0]->ops.analog_ops.standby) |
343 | adap->fe[0]->ops.analog_ops.standby(adap->fe[0]); |
344 | |
345 | pvr2_trace(PVR2_TRACE_INFO, "transferring fe[%d] ts_bus_ctrl() to pvr2_dvb_bus_ctrl()" , |
346 | adap->fe[0]->id); |
347 | adap->fe[0]->ops.ts_bus_ctrl = pvr2_dvb_bus_ctrl; |
348 | } else { |
349 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
350 | "no frontend was attached!" ); |
351 | ret = -ENODEV; |
352 | return ret; |
353 | } |
354 | |
355 | if (dvb_props->tuner_attach && dvb_props->tuner_attach(adap)) { |
356 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, "tuner attach failed" ); |
357 | ret = -ENODEV; |
358 | goto fail_tuner; |
359 | } |
360 | |
361 | if (adap->fe[1]) { |
362 | adap->fe[1]->id = 1; |
363 | adap->fe[1]->tuner_priv = adap->fe[0]->tuner_priv; |
364 | memcpy(&adap->fe[1]->ops.tuner_ops, |
365 | &adap->fe[0]->ops.tuner_ops, |
366 | sizeof(struct dvb_tuner_ops)); |
367 | |
368 | if (dvb_register_frontend(dvb: &adap->dvb_adap, fe: adap->fe[1])) { |
369 | pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
370 | "frontend registration failed!" ); |
371 | ret = -ENODEV; |
372 | goto fail_frontend1; |
373 | } |
374 | /* MFE lock */ |
375 | adap->dvb_adap.mfe_shared = 1; |
376 | |
377 | if (adap->fe[1]->ops.analog_ops.standby) |
378 | adap->fe[1]->ops.analog_ops.standby(adap->fe[1]); |
379 | |
380 | pvr2_trace(PVR2_TRACE_INFO, "transferring fe[%d] ts_bus_ctrl() to pvr2_dvb_bus_ctrl()" , |
381 | adap->fe[1]->id); |
382 | adap->fe[1]->ops.ts_bus_ctrl = pvr2_dvb_bus_ctrl; |
383 | } |
384 | done: |
385 | pvr2_channel_limit_inputs(&adap->channel, 0); |
386 | return ret; |
387 | |
388 | fail_frontend1: |
389 | dvb_frontend_detach(fe: adap->fe[1]); |
390 | adap->fe[1] = NULL; |
391 | fail_tuner: |
392 | dvb_unregister_frontend(fe: adap->fe[0]); |
393 | fail_frontend0: |
394 | dvb_frontend_detach(fe: adap->fe[0]); |
395 | adap->fe[0] = NULL; |
396 | dvb_module_release(client: adap->i2c_client_tuner); |
397 | dvb_module_release(client: adap->i2c_client_demod[1]); |
398 | dvb_module_release(client: adap->i2c_client_demod[0]); |
399 | |
400 | return ret; |
401 | } |
402 | |
403 | static int pvr2_dvb_frontend_exit(struct pvr2_dvb_adapter *adap) |
404 | { |
405 | if (adap->fe[1]) { |
406 | dvb_unregister_frontend(fe: adap->fe[1]); |
407 | dvb_frontend_detach(fe: adap->fe[1]); |
408 | adap->fe[1] = NULL; |
409 | } |
410 | if (adap->fe[0]) { |
411 | dvb_unregister_frontend(fe: adap->fe[0]); |
412 | dvb_frontend_detach(fe: adap->fe[0]); |
413 | adap->fe[0] = NULL; |
414 | } |
415 | |
416 | dvb_module_release(client: adap->i2c_client_tuner); |
417 | adap->i2c_client_tuner = NULL; |
418 | dvb_module_release(client: adap->i2c_client_demod[1]); |
419 | adap->i2c_client_demod[1] = NULL; |
420 | dvb_module_release(client: adap->i2c_client_demod[0]); |
421 | adap->i2c_client_demod[0] = NULL; |
422 | |
423 | return 0; |
424 | } |
425 | |
426 | static void pvr2_dvb_destroy(struct pvr2_dvb_adapter *adap) |
427 | { |
428 | pvr2_dvb_stream_end(adap); |
429 | pvr2_dvb_frontend_exit(adap); |
430 | pvr2_dvb_adapter_exit(adap); |
431 | pvr2_channel_done(&adap->channel); |
432 | kfree(objp: adap); |
433 | } |
434 | |
435 | static void pvr2_dvb_internal_check(struct pvr2_channel *chp) |
436 | { |
437 | struct pvr2_dvb_adapter *adap; |
438 | adap = container_of(chp, struct pvr2_dvb_adapter, channel); |
439 | if (!adap->channel.mc_head->disconnect_flag) return; |
440 | pvr2_dvb_destroy(adap); |
441 | } |
442 | |
443 | struct pvr2_dvb_adapter *pvr2_dvb_create(struct pvr2_context *pvr) |
444 | { |
445 | int ret = 0; |
446 | struct pvr2_dvb_adapter *adap; |
447 | if (!pvr->hdw->hdw_desc->dvb_props) { |
448 | /* Device lacks a digital interface so don't set up |
449 | the DVB side of the driver either. For now. */ |
450 | return NULL; |
451 | } |
452 | adap = kzalloc(size: sizeof(*adap), GFP_KERNEL); |
453 | if (!adap) return adap; |
454 | pvr2_channel_init(&adap->channel, pvr); |
455 | adap->channel.check_func = pvr2_dvb_internal_check; |
456 | init_waitqueue_head(&adap->buffer_wait_data); |
457 | mutex_init(&adap->lock); |
458 | ret = pvr2_dvb_adapter_init(adap); |
459 | if (ret < 0) goto fail1; |
460 | ret = pvr2_dvb_frontend_init(adap); |
461 | if (ret < 0) goto fail2; |
462 | return adap; |
463 | |
464 | fail2: |
465 | pvr2_dvb_adapter_exit(adap); |
466 | fail1: |
467 | pvr2_channel_done(&adap->channel); |
468 | return NULL; |
469 | } |
470 | |
471 | |