2 * pvrusb2-dvb.c - linux-dvb api interface to the pvrusb2 driver.
4 * Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/kthread.h>
22 #include <linux/freezer.h>
24 #include "pvrusb2-hdw-internal.h"
25 #include "pvrusb2-hdw.h"
26 #include "pvrusb2-io.h"
27 #include "pvrusb2-dvb.h"
29 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
31 static int pvr2_dvb_feed_func(struct pvr2_dvb_adapter
*adap
)
35 struct pvr2_buffer
*bp
;
36 struct pvr2_stream
*stream
;
38 printk(KERN_DEBUG
"dvb thread started\n");
41 stream
= adap
->channel
.stream
->stream
;
44 if (kthread_should_stop()) break;
46 /* Not sure about this... */
49 bp
= pvr2_stream_get_ready_buffer(stream
);
51 count
= pvr2_buffer_get_count(bp
);
56 pvr2_buffer_get_id(bp
)],
59 ret
= pvr2_buffer_get_status(bp
);
62 ret
= pvr2_buffer_queue(bp
);
65 /* Since we know we did something to a buffer,
66 just go back and try again. No point in
67 blocking unless we really ran out of
68 buffers to process. */
73 /* Wait until more buffers become available. */
74 ret
= wait_event_interruptible(
75 adap
->buffer_wait_data
,
76 pvr2_stream_get_ready_count(stream
) > 0);
80 /* If we get here and ret is < 0, then an error has occurred.
81 Probably would be a good idea to communicate that to DVB core... */
83 printk(KERN_DEBUG
"dvb thread stopped\n");
88 static int pvr2_dvb_feed_thread(void *data
)
90 int stat
= pvr2_dvb_feed_func(data
);
91 /* from videobuf-dvb.c: */
92 while (!kthread_should_stop()) {
93 set_current_state(TASK_INTERRUPTIBLE
);
99 static void pvr2_dvb_notify(struct pvr2_dvb_adapter
*adap
)
101 wake_up(&adap
->buffer_wait_data
);
104 static void pvr2_dvb_stream_end(struct pvr2_dvb_adapter
*adap
)
107 struct pvr2_stream
*stream
;
110 kthread_stop(adap
->thread
);
114 if (adap
->channel
.stream
) {
115 stream
= adap
->channel
.stream
->stream
;
120 pvr2_hdw_set_streaming(adap
->channel
.hdw
, 0);
121 pvr2_stream_set_callback(stream
, NULL
, NULL
);
122 pvr2_stream_kill(stream
);
123 pvr2_stream_set_buffer_count(stream
, 0);
124 pvr2_channel_claim_stream(&adap
->channel
, NULL
);
127 if (adap
->stream_run
) {
128 for (idx
= 0; idx
< PVR2_DVB_BUFFER_COUNT
; idx
++) {
129 if (!(adap
->buffer_storage
[idx
])) continue;
130 kfree(adap
->buffer_storage
[idx
]);
131 adap
->buffer_storage
[idx
] = 0;
133 adap
->stream_run
= 0;
137 static int pvr2_dvb_stream_do_start(struct pvr2_dvb_adapter
*adap
)
139 struct pvr2_context
*pvr
= adap
->channel
.mc_head
;
142 struct pvr2_buffer
*bp
;
143 struct pvr2_stream
*stream
= 0;
145 if (adap
->stream_run
) return -EIO
;
147 ret
= pvr2_channel_claim_stream(&adap
->channel
, &pvr
->video_stream
);
148 /* somebody else already has the stream */
149 if (ret
< 0) return ret
;
151 stream
= adap
->channel
.stream
->stream
;
153 for (idx
= 0; idx
< PVR2_DVB_BUFFER_COUNT
; idx
++) {
154 adap
->buffer_storage
[idx
] = kmalloc(PVR2_DVB_BUFFER_SIZE
,
156 if (!(adap
->buffer_storage
[idx
])) return -ENOMEM
;
159 pvr2_stream_set_callback(pvr
->video_stream
.stream
,
160 (pvr2_stream_callback
) pvr2_dvb_notify
, adap
);
162 ret
= pvr2_stream_set_buffer_count(stream
, PVR2_DVB_BUFFER_COUNT
);
163 if (ret
< 0) return ret
;
165 for (idx
= 0; idx
< PVR2_DVB_BUFFER_COUNT
; idx
++) {
166 bp
= pvr2_stream_get_buffer(stream
, idx
);
167 pvr2_buffer_set_buffer(bp
,
168 adap
->buffer_storage
[idx
],
169 PVR2_DVB_BUFFER_SIZE
);
172 ret
= pvr2_hdw_set_streaming(adap
->channel
.hdw
, 1);
173 if (ret
< 0) return ret
;
175 while ((bp
= pvr2_stream_get_idle_buffer(stream
)) != 0) {
176 ret
= pvr2_buffer_queue(bp
);
177 if (ret
< 0) return ret
;
180 adap
->thread
= kthread_run(pvr2_dvb_feed_thread
, adap
, "pvrusb2-dvb");
182 if (IS_ERR(adap
->thread
)) {
183 ret
= PTR_ERR(adap
->thread
);
188 adap
->stream_run
= !0;
193 static int pvr2_dvb_stream_start(struct pvr2_dvb_adapter
*adap
)
195 int ret
= pvr2_dvb_stream_do_start(adap
);
196 if (ret
< 0) pvr2_dvb_stream_end(adap
);
200 static int pvr2_dvb_ctrl_feed(struct dvb_demux_feed
*dvbdmxfeed
, int onoff
)
202 struct pvr2_dvb_adapter
*adap
= dvbdmxfeed
->demux
->priv
;
205 if (adap
== NULL
) return -ENODEV
;
207 mutex_lock(&adap
->lock
);
210 if (!adap
->feedcount
) {
211 printk(KERN_DEBUG
"start feeding\n");
212 ret
= pvr2_dvb_stream_start(adap
);
216 } else if (adap
->feedcount
> 0) {
218 if (!adap
->feedcount
) {
219 printk(KERN_DEBUG
"stop feeding\n");
220 pvr2_dvb_stream_end(adap
);
224 mutex_unlock(&adap
->lock
);
229 static int pvr2_dvb_start_feed(struct dvb_demux_feed
*dvbdmxfeed
)
231 printk(KERN_DEBUG
"start pid: 0x%04x, feedtype: %d\n",
232 dvbdmxfeed
->pid
, dvbdmxfeed
->type
);
233 return pvr2_dvb_ctrl_feed(dvbdmxfeed
, 1);
236 static int pvr2_dvb_stop_feed(struct dvb_demux_feed
*dvbdmxfeed
)
238 printk(KERN_DEBUG
"stop pid: 0x%04x, feedtype: %d\n",
239 dvbdmxfeed
->pid
, dvbdmxfeed
->type
);
240 return pvr2_dvb_ctrl_feed(dvbdmxfeed
, 0);
243 static int pvr2_dvb_bus_ctrl(struct dvb_frontend
*fe
, int acquire
)
245 /* TO DO: This function will call into the core and request for
246 * input to be set to 'dtv' if (acquire) and if it isn't set already.
248 * If (!acquire) then we should do nothing -- don't switch inputs
249 * again unless the analog side of the driver requests the bus.
254 static int pvr2_dvb_adapter_init(struct pvr2_dvb_adapter
*adap
)
258 ret
= dvb_register_adapter(&adap
->dvb_adap
, "pvrusb2-dvb",
259 THIS_MODULE
/*&hdw->usb_dev->owner*/,
260 &adap
->channel
.hdw
->usb_dev
->dev
,
263 err("dvb_register_adapter failed: error %d", ret
);
266 adap
->dvb_adap
.priv
= adap
;
268 adap
->demux
.dmx
.capabilities
= DMX_TS_FILTERING
|
269 DMX_SECTION_FILTERING
|
270 DMX_MEMORY_BASED_FILTERING
;
271 adap
->demux
.priv
= adap
;
272 adap
->demux
.filternum
= 256;
273 adap
->demux
.feednum
= 256;
274 adap
->demux
.start_feed
= pvr2_dvb_start_feed
;
275 adap
->demux
.stop_feed
= pvr2_dvb_stop_feed
;
276 adap
->demux
.write_to_decoder
= NULL
;
278 ret
= dvb_dmx_init(&adap
->demux
);
280 err("dvb_dmx_init failed: error %d", ret
);
284 adap
->dmxdev
.filternum
= adap
->demux
.filternum
;
285 adap
->dmxdev
.demux
= &adap
->demux
.dmx
;
286 adap
->dmxdev
.capabilities
= 0;
288 ret
= dvb_dmxdev_init(&adap
->dmxdev
, &adap
->dvb_adap
);
290 err("dvb_dmxdev_init failed: error %d", ret
);
294 dvb_net_init(&adap
->dvb_adap
, &adap
->dvb_net
, &adap
->demux
.dmx
);
296 adap
->digital_up
= 1;
301 dvb_dmx_release(&adap
->demux
);
303 dvb_unregister_adapter(&adap
->dvb_adap
);
308 static int pvr2_dvb_adapter_exit(struct pvr2_dvb_adapter
*adap
)
310 if (adap
->digital_up
) {
311 printk(KERN_DEBUG
"unregistering DVB devices\n");
312 dvb_net_release(&adap
->dvb_net
);
313 adap
->demux
.dmx
.close(&adap
->demux
.dmx
);
314 dvb_dmxdev_release(&adap
->dmxdev
);
315 dvb_dmx_release(&adap
->demux
);
316 dvb_unregister_adapter(&adap
->dvb_adap
);
317 adap
->digital_up
= 0;
322 static int pvr2_dvb_frontend_init(struct pvr2_dvb_adapter
*adap
)
324 struct pvr2_hdw
*hdw
= adap
->channel
.hdw
;
325 struct pvr2_dvb_props
*dvb_props
= hdw
->hdw_desc
->dvb_props
;
328 if (dvb_props
== NULL
) {
329 err("fe_props not defined!");
333 /* FIXME: This code should be moved into the core,
334 * and should only be called if we don't already have
335 * control of the bus.
337 * We can't call "pvr2_dvb_bus_ctrl(adap->fe, 1)" from here,
338 * because adap->fe isn't defined yet.
340 ret
= pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_by_id(hdw
,
342 PVR2_CVAL_INPUT_DTV
);
346 pvr2_hdw_commit_ctl(hdw
);
349 if (dvb_props
->frontend_attach
== NULL
) {
350 err("frontend_attach not defined!");
354 if ((dvb_props
->frontend_attach(adap
) == 0) && (adap
->fe
)) {
356 if (dvb_register_frontend(&adap
->dvb_adap
, adap
->fe
)) {
357 err("frontend registration failed!");
358 dvb_frontend_detach(adap
->fe
);
363 if (dvb_props
->tuner_attach
)
364 dvb_props
->tuner_attach(adap
);
366 if (adap
->fe
->ops
.analog_ops
.standby
)
367 adap
->fe
->ops
.analog_ops
.standby(adap
->fe
);
369 /* Ensure all frontends negotiate bus access */
370 adap
->fe
->ops
.ts_bus_ctrl
= pvr2_dvb_bus_ctrl
;
373 err("no frontend was attached!");
380 static int pvr2_dvb_frontend_exit(struct pvr2_dvb_adapter
*adap
)
382 if (adap
->fe
!= NULL
) {
383 dvb_unregister_frontend(adap
->fe
);
384 dvb_frontend_detach(adap
->fe
);
389 int pvr2_dvb_init(struct pvr2_context
*pvr
)
392 struct pvr2_dvb_adapter
*adap
;
393 adap
= &pvr
->hdw
->dvb
;
395 pvr2_channel_init(&adap
->channel
, pvr
);
396 init_waitqueue_head(&adap
->buffer_wait_data
);
397 mutex_init(&pvr
->hdw
->dvb
.lock
);
398 ret
= pvr2_dvb_adapter_init(&pvr
->hdw
->dvb
);
399 if (ret
< 0) goto fail
;
400 ret
= pvr2_dvb_frontend_init(&pvr
->hdw
->dvb
);
405 int pvr2_dvb_exit(struct pvr2_context
*pvr
)
407 struct pvr2_dvb_adapter
*adap
;
408 adap
= &pvr
->hdw
->dvb
;
409 if (!adap
->init
) return 0;
410 pvr2_dvb_stream_end(adap
);
411 pvr2_dvb_frontend_exit(adap
);
412 pvr2_dvb_adapter_exit(adap
);
413 pvr2_channel_done(&adap
->channel
);