xref: /linux/drivers/media/usb/pvrusb2/pvrusb2-context.c (revision e8d235d4d8fb8957bae5f6ed4521115203a00d8b)
1 /*
2  *
3  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2 of the License
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this program; if not, write to the Free Software
16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  *
18  */
19 
20 #include "pvrusb2-context.h"
21 #include "pvrusb2-io.h"
22 #include "pvrusb2-ioread.h"
23 #include "pvrusb2-hdw.h"
24 #include "pvrusb2-debug.h"
25 #include <linux/wait.h>
26 #include <linux/kthread.h>
27 #include <linux/errno.h>
28 #include <linux/string.h>
29 #include <linux/slab.h>
30 
31 static struct pvr2_context *pvr2_context_exist_first;
32 static struct pvr2_context *pvr2_context_exist_last;
33 static struct pvr2_context *pvr2_context_notify_first;
34 static struct pvr2_context *pvr2_context_notify_last;
35 static DEFINE_MUTEX(pvr2_context_mutex);
36 static DECLARE_WAIT_QUEUE_HEAD(pvr2_context_sync_data);
37 static DECLARE_WAIT_QUEUE_HEAD(pvr2_context_cleanup_data);
38 static int pvr2_context_cleanup_flag;
39 static int pvr2_context_cleaned_flag;
40 static struct task_struct *pvr2_context_thread_ptr;
41 
42 
43 static void pvr2_context_set_notify(struct pvr2_context *mp, int fl)
44 {
45 	int signal_flag = 0;
46 	mutex_lock(&pvr2_context_mutex);
47 	if (fl) {
48 		if (!mp->notify_flag) {
49 			signal_flag = (pvr2_context_notify_first == NULL);
50 			mp->notify_prev = pvr2_context_notify_last;
51 			mp->notify_next = NULL;
52 			pvr2_context_notify_last = mp;
53 			if (mp->notify_prev) {
54 				mp->notify_prev->notify_next = mp;
55 			} else {
56 				pvr2_context_notify_first = mp;
57 			}
58 			mp->notify_flag = !0;
59 		}
60 	} else {
61 		if (mp->notify_flag) {
62 			mp->notify_flag = 0;
63 			if (mp->notify_next) {
64 				mp->notify_next->notify_prev = mp->notify_prev;
65 			} else {
66 				pvr2_context_notify_last = mp->notify_prev;
67 			}
68 			if (mp->notify_prev) {
69 				mp->notify_prev->notify_next = mp->notify_next;
70 			} else {
71 				pvr2_context_notify_first = mp->notify_next;
72 			}
73 		}
74 	}
75 	mutex_unlock(&pvr2_context_mutex);
76 	if (signal_flag) wake_up(&pvr2_context_sync_data);
77 }
78 
79 
80 static void pvr2_context_destroy(struct pvr2_context *mp)
81 {
82 	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (destroy)",mp);
83 	pvr2_hdw_destroy(mp->hdw);
84 	pvr2_context_set_notify(mp, 0);
85 	mutex_lock(&pvr2_context_mutex);
86 	if (mp->exist_next) {
87 		mp->exist_next->exist_prev = mp->exist_prev;
88 	} else {
89 		pvr2_context_exist_last = mp->exist_prev;
90 	}
91 	if (mp->exist_prev) {
92 		mp->exist_prev->exist_next = mp->exist_next;
93 	} else {
94 		pvr2_context_exist_first = mp->exist_next;
95 	}
96 	if (!pvr2_context_exist_first) {
97 		/* Trigger wakeup on control thread in case it is waiting
98 		   for an exit condition. */
99 		wake_up(&pvr2_context_sync_data);
100 	}
101 	mutex_unlock(&pvr2_context_mutex);
102 	kfree(mp);
103 }
104 
105 
106 static void pvr2_context_notify(struct pvr2_context *mp)
107 {
108 	pvr2_context_set_notify(mp,!0);
109 }
110 
111 
112 static void pvr2_context_check(struct pvr2_context *mp)
113 {
114 	struct pvr2_channel *ch1, *ch2;
115 	pvr2_trace(PVR2_TRACE_CTXT,
116 		   "pvr2_context %p (notify)", mp);
117 	if (!mp->initialized_flag && !mp->disconnect_flag) {
118 		mp->initialized_flag = !0;
119 		pvr2_trace(PVR2_TRACE_CTXT,
120 			   "pvr2_context %p (initialize)", mp);
121 		/* Finish hardware initialization */
122 		if (pvr2_hdw_initialize(mp->hdw,
123 					(void (*)(void *))pvr2_context_notify,
124 					mp)) {
125 			mp->video_stream.stream =
126 				pvr2_hdw_get_video_stream(mp->hdw);
127 			/* Trigger interface initialization.  By doing this
128 			   here initialization runs in our own safe and
129 			   cozy thread context. */
130 			if (mp->setup_func) mp->setup_func(mp);
131 		} else {
132 			pvr2_trace(PVR2_TRACE_CTXT,
133 				   "pvr2_context %p (thread skipping setup)",
134 				   mp);
135 			/* Even though initialization did not succeed,
136 			   we're still going to continue anyway.  We need
137 			   to do this in order to await the expected
138 			   disconnect (which we will detect in the normal
139 			   course of operation). */
140 		}
141 	}
142 
143 	for (ch1 = mp->mc_first; ch1; ch1 = ch2) {
144 		ch2 = ch1->mc_next;
145 		if (ch1->check_func) ch1->check_func(ch1);
146 	}
147 
148 	if (mp->disconnect_flag && !mp->mc_first) {
149 		/* Go away... */
150 		pvr2_context_destroy(mp);
151 		return;
152 	}
153 }
154 
155 
156 static int pvr2_context_shutok(void)
157 {
158 	return pvr2_context_cleanup_flag && (pvr2_context_exist_first == NULL);
159 }
160 
161 
162 static int pvr2_context_thread_func(void *foo)
163 {
164 	struct pvr2_context *mp;
165 
166 	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread start");
167 
168 	do {
169 		while ((mp = pvr2_context_notify_first) != NULL) {
170 			pvr2_context_set_notify(mp, 0);
171 			pvr2_context_check(mp);
172 		}
173 		wait_event_interruptible(
174 			pvr2_context_sync_data,
175 			((pvr2_context_notify_first != NULL) ||
176 			 pvr2_context_shutok()));
177 	} while (!pvr2_context_shutok());
178 
179 	pvr2_context_cleaned_flag = !0;
180 	wake_up(&pvr2_context_cleanup_data);
181 
182 	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread cleaned up");
183 
184 	wait_event_interruptible(
185 		pvr2_context_sync_data,
186 		kthread_should_stop());
187 
188 	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context thread end");
189 
190 	return 0;
191 }
192 
193 
194 int pvr2_context_global_init(void)
195 {
196 	pvr2_context_thread_ptr = kthread_run(pvr2_context_thread_func,
197 					      NULL,
198 					      "pvrusb2-context");
199 	return (pvr2_context_thread_ptr ? 0 : -ENOMEM);
200 }
201 
202 
203 void pvr2_context_global_done(void)
204 {
205 	pvr2_context_cleanup_flag = !0;
206 	wake_up(&pvr2_context_sync_data);
207 	wait_event_interruptible(
208 		pvr2_context_cleanup_data,
209 		pvr2_context_cleaned_flag);
210 	kthread_stop(pvr2_context_thread_ptr);
211 }
212 
213 
214 struct pvr2_context *pvr2_context_create(
215 	struct usb_interface *intf,
216 	const struct usb_device_id *devid,
217 	void (*setup_func)(struct pvr2_context *))
218 {
219 	struct pvr2_context *mp = NULL;
220 	mp = kzalloc(sizeof(*mp),GFP_KERNEL);
221 	if (!mp) goto done;
222 	pvr2_trace(PVR2_TRACE_CTXT,"pvr2_context %p (create)",mp);
223 	mp->setup_func = setup_func;
224 	mutex_init(&mp->mutex);
225 	mutex_lock(&pvr2_context_mutex);
226 	mp->exist_prev = pvr2_context_exist_last;
227 	mp->exist_next = NULL;
228 	pvr2_context_exist_last = mp;
229 	if (mp->exist_prev) {
230 		mp->exist_prev->exist_next = mp;
231 	} else {
232 		pvr2_context_exist_first = mp;
233 	}
234 	mutex_unlock(&pvr2_context_mutex);
235 	mp->hdw = pvr2_hdw_create(intf,devid);
236 	if (!mp->hdw) {
237 		pvr2_context_destroy(mp);
238 		mp = NULL;
239 		goto done;
240 	}
241 	pvr2_context_set_notify(mp, !0);
242  done:
243 	return mp;
244 }
245 
246 
247 static void pvr2_context_reset_input_limits(struct pvr2_context *mp)
248 {
249 	unsigned int tmsk,mmsk;
250 	struct pvr2_channel *cp;
251 	struct pvr2_hdw *hdw = mp->hdw;
252 	mmsk = pvr2_hdw_get_input_available(hdw);
253 	tmsk = mmsk;
254 	for (cp = mp->mc_first; cp; cp = cp->mc_next) {
255 		if (!cp->input_mask) continue;
256 		tmsk &= cp->input_mask;
257 	}
258 	pvr2_hdw_set_input_allowed(hdw,mmsk,tmsk);
259 	pvr2_hdw_commit_ctl(hdw);
260 }
261 
262 
263 static void pvr2_context_enter(struct pvr2_context *mp)
264 {
265 	mutex_lock(&mp->mutex);
266 }
267 
268 
269 static void pvr2_context_exit(struct pvr2_context *mp)
270 {
271 	int destroy_flag = 0;
272 	if (!(mp->mc_first || !mp->disconnect_flag)) {
273 		destroy_flag = !0;
274 	}
275 	mutex_unlock(&mp->mutex);
276 	if (destroy_flag) pvr2_context_notify(mp);
277 }
278 
279 
280 void pvr2_context_disconnect(struct pvr2_context *mp)
281 {
282 	pvr2_hdw_disconnect(mp->hdw);
283 	mp->disconnect_flag = !0;
284 	pvr2_context_notify(mp);
285 }
286 
287 
288 void pvr2_channel_init(struct pvr2_channel *cp,struct pvr2_context *mp)
289 {
290 	pvr2_context_enter(mp);
291 	cp->hdw = mp->hdw;
292 	cp->mc_head = mp;
293 	cp->mc_next = NULL;
294 	cp->mc_prev = mp->mc_last;
295 	if (mp->mc_last) {
296 		mp->mc_last->mc_next = cp;
297 	} else {
298 		mp->mc_first = cp;
299 	}
300 	mp->mc_last = cp;
301 	pvr2_context_exit(mp);
302 }
303 
304 
305 static void pvr2_channel_disclaim_stream(struct pvr2_channel *cp)
306 {
307 	if (!cp->stream) return;
308 	pvr2_stream_kill(cp->stream->stream);
309 	cp->stream->user = NULL;
310 	cp->stream = NULL;
311 }
312 
313 
314 void pvr2_channel_done(struct pvr2_channel *cp)
315 {
316 	struct pvr2_context *mp = cp->mc_head;
317 	pvr2_context_enter(mp);
318 	cp->input_mask = 0;
319 	pvr2_channel_disclaim_stream(cp);
320 	pvr2_context_reset_input_limits(mp);
321 	if (cp->mc_next) {
322 		cp->mc_next->mc_prev = cp->mc_prev;
323 	} else {
324 		mp->mc_last = cp->mc_prev;
325 	}
326 	if (cp->mc_prev) {
327 		cp->mc_prev->mc_next = cp->mc_next;
328 	} else {
329 		mp->mc_first = cp->mc_next;
330 	}
331 	cp->hdw = NULL;
332 	pvr2_context_exit(mp);
333 }
334 
335 
336 int pvr2_channel_limit_inputs(struct pvr2_channel *cp,unsigned int cmsk)
337 {
338 	unsigned int tmsk,mmsk;
339 	int ret = 0;
340 	struct pvr2_channel *p2;
341 	struct pvr2_hdw *hdw = cp->hdw;
342 
343 	mmsk = pvr2_hdw_get_input_available(hdw);
344 	cmsk &= mmsk;
345 	if (cmsk == cp->input_mask) {
346 		/* No change; nothing to do */
347 		return 0;
348 	}
349 
350 	pvr2_context_enter(cp->mc_head);
351 	do {
352 		if (!cmsk) {
353 			cp->input_mask = 0;
354 			pvr2_context_reset_input_limits(cp->mc_head);
355 			break;
356 		}
357 		tmsk = mmsk;
358 		for (p2 = cp->mc_head->mc_first; p2; p2 = p2->mc_next) {
359 			if (p2 == cp) continue;
360 			if (!p2->input_mask) continue;
361 			tmsk &= p2->input_mask;
362 		}
363 		if (!(tmsk & cmsk)) {
364 			ret = -EPERM;
365 			break;
366 		}
367 		tmsk &= cmsk;
368 		if ((ret = pvr2_hdw_set_input_allowed(hdw,mmsk,tmsk)) != 0) {
369 			/* Internal failure changing allowed list; probably
370 			   should not happen, but react if it does. */
371 			break;
372 		}
373 		cp->input_mask = cmsk;
374 		pvr2_hdw_commit_ctl(hdw);
375 	} while (0);
376 	pvr2_context_exit(cp->mc_head);
377 	return ret;
378 }
379 
380 
381 unsigned int pvr2_channel_get_limited_inputs(struct pvr2_channel *cp)
382 {
383 	return cp->input_mask;
384 }
385 
386 
387 int pvr2_channel_claim_stream(struct pvr2_channel *cp,
388 			      struct pvr2_context_stream *sp)
389 {
390 	int code = 0;
391 	pvr2_context_enter(cp->mc_head); do {
392 		if (sp == cp->stream) break;
393 		if (sp && sp->user) {
394 			code = -EBUSY;
395 			break;
396 		}
397 		pvr2_channel_disclaim_stream(cp);
398 		if (!sp) break;
399 		sp->user = cp;
400 		cp->stream = sp;
401 	} while (0); pvr2_context_exit(cp->mc_head);
402 	return code;
403 }
404 
405 
406 // This is the marker for the real beginning of a legitimate mpeg2 stream.
407 static char stream_sync_key[] = {
408 	0x00, 0x00, 0x01, 0xba,
409 };
410 
411 struct pvr2_ioread *pvr2_channel_create_mpeg_stream(
412 	struct pvr2_context_stream *sp)
413 {
414 	struct pvr2_ioread *cp;
415 	cp = pvr2_ioread_create();
416 	if (!cp) return NULL;
417 	pvr2_ioread_setup(cp,sp->stream);
418 	pvr2_ioread_set_sync_key(cp,stream_sync_key,sizeof(stream_sync_key));
419 	return cp;
420 }
421