1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 *
4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
5 */
6
7 #include "pvrusb2-ioread.h"
8 #include "pvrusb2-debug.h"
9 #include <linux/errno.h>
10 #include <linux/string.h>
11 #include <linux/mm.h>
12 #include <linux/slab.h>
13 #include <linux/mutex.h>
14 #include <linux/uaccess.h>
15
16 #define BUFFER_COUNT 32
17 #define BUFFER_SIZE PAGE_ALIGN(0x4000)
18
19 struct pvr2_ioread {
20 struct pvr2_stream *stream;
21 char *buffer_storage[BUFFER_COUNT];
22 char *sync_key_ptr;
23 unsigned int sync_key_len;
24 unsigned int sync_buf_offs;
25 unsigned int sync_state;
26 unsigned int sync_trashed_count;
27 int enabled; // Streaming is on
28 int spigot_open; // OK to pass data to client
29 int stream_running; // Passing data to client now
30
31 /* State relevant to current buffer being read */
32 struct pvr2_buffer *c_buf;
33 char *c_data_ptr;
34 unsigned int c_data_len;
35 unsigned int c_data_offs;
36 struct mutex mutex;
37 };
38
pvr2_ioread_init(struct pvr2_ioread * cp)39 static int pvr2_ioread_init(struct pvr2_ioread *cp)
40 {
41 unsigned int idx;
42
43 cp->stream = NULL;
44 mutex_init(&cp->mutex);
45
46 for (idx = 0; idx < BUFFER_COUNT; idx++) {
47 cp->buffer_storage[idx] = kmalloc(BUFFER_SIZE,GFP_KERNEL);
48 if (!(cp->buffer_storage[idx])) break;
49 }
50
51 if (idx < BUFFER_COUNT) {
52 // An allocation appears to have failed
53 for (idx = 0; idx < BUFFER_COUNT; idx++) {
54 if (!(cp->buffer_storage[idx])) continue;
55 kfree(cp->buffer_storage[idx]);
56 }
57 return -ENOMEM;
58 }
59 return 0;
60 }
61
pvr2_ioread_done(struct pvr2_ioread * cp)62 static void pvr2_ioread_done(struct pvr2_ioread *cp)
63 {
64 unsigned int idx;
65
66 pvr2_ioread_setup(cp,NULL);
67 for (idx = 0; idx < BUFFER_COUNT; idx++) {
68 if (!(cp->buffer_storage[idx])) continue;
69 kfree(cp->buffer_storage[idx]);
70 }
71 }
72
pvr2_ioread_create(void)73 struct pvr2_ioread *pvr2_ioread_create(void)
74 {
75 struct pvr2_ioread *cp;
76 cp = kzalloc(sizeof(*cp),GFP_KERNEL);
77 if (!cp) return NULL;
78 pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp);
79 if (pvr2_ioread_init(cp) < 0) {
80 kfree(cp);
81 return NULL;
82 }
83 return cp;
84 }
85
pvr2_ioread_destroy(struct pvr2_ioread * cp)86 void pvr2_ioread_destroy(struct pvr2_ioread *cp)
87 {
88 if (!cp) return;
89 pvr2_ioread_done(cp);
90 pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_destroy id=%p",cp);
91 if (cp->sync_key_ptr) {
92 kfree(cp->sync_key_ptr);
93 cp->sync_key_ptr = NULL;
94 }
95 kfree(cp);
96 }
97
pvr2_ioread_set_sync_key(struct pvr2_ioread * cp,const char * sync_key_ptr,unsigned int sync_key_len)98 void pvr2_ioread_set_sync_key(struct pvr2_ioread *cp,
99 const char *sync_key_ptr,
100 unsigned int sync_key_len)
101 {
102 if (!cp) return;
103
104 if (!sync_key_ptr) sync_key_len = 0;
105 if ((sync_key_len == cp->sync_key_len) &&
106 ((!sync_key_len) ||
107 (!memcmp(sync_key_ptr,cp->sync_key_ptr,sync_key_len)))) return;
108
109 if (sync_key_len != cp->sync_key_len) {
110 if (cp->sync_key_ptr) {
111 kfree(cp->sync_key_ptr);
112 cp->sync_key_ptr = NULL;
113 }
114 cp->sync_key_len = 0;
115 if (sync_key_len) {
116 cp->sync_key_ptr = kmalloc(sync_key_len,GFP_KERNEL);
117 if (cp->sync_key_ptr) {
118 cp->sync_key_len = sync_key_len;
119 }
120 }
121 }
122 if (!cp->sync_key_len) return;
123 memcpy(cp->sync_key_ptr,sync_key_ptr,cp->sync_key_len);
124 }
125
pvr2_ioread_stop(struct pvr2_ioread * cp)126 static void pvr2_ioread_stop(struct pvr2_ioread *cp)
127 {
128 if (!(cp->enabled)) return;
129 pvr2_trace(PVR2_TRACE_START_STOP,
130 "/*---TRACE_READ---*/ pvr2_ioread_stop id=%p",cp);
131 pvr2_stream_kill(cp->stream);
132 cp->c_buf = NULL;
133 cp->c_data_ptr = NULL;
134 cp->c_data_len = 0;
135 cp->c_data_offs = 0;
136 cp->enabled = 0;
137 cp->stream_running = 0;
138 cp->spigot_open = 0;
139 if (cp->sync_state) {
140 pvr2_trace(PVR2_TRACE_DATA_FLOW,
141 "/*---TRACE_READ---*/ sync_state <== 0");
142 cp->sync_state = 0;
143 }
144 }
145
pvr2_ioread_start(struct pvr2_ioread * cp)146 static int pvr2_ioread_start(struct pvr2_ioread *cp)
147 {
148 int stat;
149 struct pvr2_buffer *bp;
150 if (cp->enabled) return 0;
151 if (!(cp->stream)) return 0;
152 pvr2_trace(PVR2_TRACE_START_STOP,
153 "/*---TRACE_READ---*/ pvr2_ioread_start id=%p",cp);
154 while ((bp = pvr2_stream_get_idle_buffer(cp->stream)) != NULL) {
155 stat = pvr2_buffer_queue(bp);
156 if (stat < 0) {
157 pvr2_trace(PVR2_TRACE_DATA_FLOW,
158 "/*---TRACE_READ---*/ pvr2_ioread_start id=%p error=%d",
159 cp,stat);
160 pvr2_ioread_stop(cp);
161 return stat;
162 }
163 }
164 cp->enabled = !0;
165 cp->c_buf = NULL;
166 cp->c_data_ptr = NULL;
167 cp->c_data_len = 0;
168 cp->c_data_offs = 0;
169 cp->stream_running = 0;
170 if (cp->sync_key_len) {
171 pvr2_trace(PVR2_TRACE_DATA_FLOW,
172 "/*---TRACE_READ---*/ sync_state <== 1");
173 cp->sync_state = 1;
174 cp->sync_trashed_count = 0;
175 cp->sync_buf_offs = 0;
176 }
177 cp->spigot_open = 0;
178 return 0;
179 }
180
pvr2_ioread_get_stream(struct pvr2_ioread * cp)181 struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp)
182 {
183 return cp->stream;
184 }
185
pvr2_ioread_setup(struct pvr2_ioread * cp,struct pvr2_stream * sp)186 int pvr2_ioread_setup(struct pvr2_ioread *cp,struct pvr2_stream *sp)
187 {
188 int ret;
189 unsigned int idx;
190 struct pvr2_buffer *bp;
191
192 mutex_lock(&cp->mutex);
193 do {
194 if (cp->stream) {
195 pvr2_trace(PVR2_TRACE_START_STOP,
196 "/*---TRACE_READ---*/ pvr2_ioread_setup (tear-down) id=%p",
197 cp);
198 pvr2_ioread_stop(cp);
199 pvr2_stream_kill(cp->stream);
200 if (pvr2_stream_get_buffer_count(cp->stream)) {
201 pvr2_stream_set_buffer_count(cp->stream,0);
202 }
203 cp->stream = NULL;
204 }
205 if (sp) {
206 pvr2_trace(PVR2_TRACE_START_STOP,
207 "/*---TRACE_READ---*/ pvr2_ioread_setup (setup) id=%p",
208 cp);
209 pvr2_stream_kill(sp);
210 ret = pvr2_stream_set_buffer_count(sp,BUFFER_COUNT);
211 if (ret < 0) {
212 mutex_unlock(&cp->mutex);
213 return ret;
214 }
215 for (idx = 0; idx < BUFFER_COUNT; idx++) {
216 bp = pvr2_stream_get_buffer(sp,idx);
217 pvr2_buffer_set_buffer(bp,
218 cp->buffer_storage[idx],
219 BUFFER_SIZE);
220 }
221 cp->stream = sp;
222 }
223 } while (0);
224 mutex_unlock(&cp->mutex);
225
226 return 0;
227 }
228
pvr2_ioread_set_enabled(struct pvr2_ioread * cp,int fl)229 int pvr2_ioread_set_enabled(struct pvr2_ioread *cp,int fl)
230 {
231 int ret = 0;
232 if ((!fl) == (!(cp->enabled))) return ret;
233
234 mutex_lock(&cp->mutex);
235 do {
236 if (fl) {
237 ret = pvr2_ioread_start(cp);
238 } else {
239 pvr2_ioread_stop(cp);
240 }
241 } while (0);
242 mutex_unlock(&cp->mutex);
243 return ret;
244 }
245
pvr2_ioread_get_buffer(struct pvr2_ioread * cp)246 static int pvr2_ioread_get_buffer(struct pvr2_ioread *cp)
247 {
248 int stat;
249
250 while (cp->c_data_len <= cp->c_data_offs) {
251 if (cp->c_buf) {
252 // Flush out current buffer first.
253 stat = pvr2_buffer_queue(cp->c_buf);
254 if (stat < 0) {
255 // Streaming error...
256 pvr2_trace(PVR2_TRACE_DATA_FLOW,
257 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p queue_error=%d",
258 cp,stat);
259 pvr2_ioread_stop(cp);
260 return 0;
261 }
262 cp->c_buf = NULL;
263 cp->c_data_ptr = NULL;
264 cp->c_data_len = 0;
265 cp->c_data_offs = 0;
266 }
267 // Now get a freshly filled buffer.
268 cp->c_buf = pvr2_stream_get_ready_buffer(cp->stream);
269 if (!cp->c_buf) break; // Nothing ready; done.
270 cp->c_data_len = pvr2_buffer_get_count(cp->c_buf);
271 if (!cp->c_data_len) {
272 // Nothing transferred. Was there an error?
273 stat = pvr2_buffer_get_status(cp->c_buf);
274 if (stat < 0) {
275 // Streaming error...
276 pvr2_trace(PVR2_TRACE_DATA_FLOW,
277 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p buffer_error=%d",
278 cp,stat);
279 pvr2_ioread_stop(cp);
280 // Give up.
281 return 0;
282 }
283 // Start over...
284 continue;
285 }
286 cp->c_data_offs = 0;
287 cp->c_data_ptr = cp->buffer_storage[
288 pvr2_buffer_get_id(cp->c_buf)];
289 }
290 return !0;
291 }
292
pvr2_ioread_filter(struct pvr2_ioread * cp)293 static void pvr2_ioread_filter(struct pvr2_ioread *cp)
294 {
295 unsigned int idx;
296 if (!cp->enabled) return;
297 if (cp->sync_state != 1) return;
298
299 // Search the stream for our synchronization key. This is made
300 // complicated by the fact that in order to be honest with
301 // ourselves here we must search across buffer boundaries...
302 mutex_lock(&cp->mutex);
303 while (1) {
304 // Ensure we have a buffer
305 if (!pvr2_ioread_get_buffer(cp)) break;
306 if (!cp->c_data_len) break;
307
308 // Now walk the buffer contents until we match the key or
309 // run out of buffer data.
310 for (idx = cp->c_data_offs; idx < cp->c_data_len; idx++) {
311 if (cp->sync_buf_offs >= cp->sync_key_len) break;
312 if (cp->c_data_ptr[idx] ==
313 cp->sync_key_ptr[cp->sync_buf_offs]) {
314 // Found the next key byte
315 (cp->sync_buf_offs)++;
316 } else {
317 // Whoops, mismatched. Start key over...
318 cp->sync_buf_offs = 0;
319 }
320 }
321
322 // Consume what we've walked through
323 cp->c_data_offs += idx;
324 cp->sync_trashed_count += idx;
325
326 // If we've found the key, then update state and get out.
327 if (cp->sync_buf_offs >= cp->sync_key_len) {
328 cp->sync_trashed_count -= cp->sync_key_len;
329 pvr2_trace(PVR2_TRACE_DATA_FLOW,
330 "/*---TRACE_READ---*/ sync_state <== 2 (skipped %u bytes)",
331 cp->sync_trashed_count);
332 cp->sync_state = 2;
333 cp->sync_buf_offs = 0;
334 break;
335 }
336
337 if (cp->c_data_offs < cp->c_data_len) {
338 // Sanity check - should NEVER get here
339 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
340 "ERROR: pvr2_ioread filter sync problem len=%u offs=%u",
341 cp->c_data_len,cp->c_data_offs);
342 // Get out so we don't get stuck in an infinite
343 // loop.
344 break;
345 }
346
347 continue; // (for clarity)
348 }
349 mutex_unlock(&cp->mutex);
350 }
351
pvr2_ioread_avail(struct pvr2_ioread * cp)352 int pvr2_ioread_avail(struct pvr2_ioread *cp)
353 {
354 int ret;
355 if (!(cp->enabled)) {
356 // Stream is not enabled; so this is an I/O error
357 return -EIO;
358 }
359
360 if (cp->sync_state == 1) {
361 pvr2_ioread_filter(cp);
362 if (cp->sync_state == 1) return -EAGAIN;
363 }
364
365 ret = 0;
366 if (cp->stream_running) {
367 if (!pvr2_stream_get_ready_count(cp->stream)) {
368 // No data available at all right now.
369 ret = -EAGAIN;
370 }
371 } else {
372 if (pvr2_stream_get_ready_count(cp->stream) < BUFFER_COUNT/2) {
373 // Haven't buffered up enough yet; try again later
374 ret = -EAGAIN;
375 }
376 }
377
378 if ((!(cp->spigot_open)) != (!(ret == 0))) {
379 cp->spigot_open = (ret == 0);
380 pvr2_trace(PVR2_TRACE_DATA_FLOW,
381 "/*---TRACE_READ---*/ data is %s",
382 cp->spigot_open ? "available" : "pending");
383 }
384
385 return ret;
386 }
387
pvr2_ioread_read(struct pvr2_ioread * cp,void __user * buf,unsigned int cnt)388 int pvr2_ioread_read(struct pvr2_ioread *cp,void __user *buf,unsigned int cnt)
389 {
390 unsigned int copied_cnt;
391 unsigned int bcnt;
392 const char *src;
393 int stat;
394 int ret = 0;
395 unsigned int req_cnt = cnt;
396
397 if (!cnt) {
398 pvr2_trace(PVR2_TRACE_TRAP,
399 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p ZERO Request? Returning zero.",
400 cp);
401 return 0;
402 }
403
404 stat = pvr2_ioread_avail(cp);
405 if (stat < 0) return stat;
406
407 cp->stream_running = !0;
408
409 mutex_lock(&cp->mutex);
410 do {
411
412 // Suck data out of the buffers and copy to the user
413 copied_cnt = 0;
414 if (!buf) cnt = 0;
415 while (1) {
416 if (!pvr2_ioread_get_buffer(cp)) {
417 ret = -EIO;
418 break;
419 }
420
421 if (!cnt) break;
422
423 if (cp->sync_state == 2) {
424 // We're repeating the sync key data into
425 // the stream.
426 src = cp->sync_key_ptr + cp->sync_buf_offs;
427 bcnt = cp->sync_key_len - cp->sync_buf_offs;
428 } else {
429 // Normal buffer copy
430 src = cp->c_data_ptr + cp->c_data_offs;
431 bcnt = cp->c_data_len - cp->c_data_offs;
432 }
433
434 if (!bcnt) break;
435
436 // Don't run past user's buffer
437 if (bcnt > cnt) bcnt = cnt;
438
439 if (copy_to_user(buf,src,bcnt)) {
440 // User supplied a bad pointer?
441 // Give up - this *will* cause data
442 // to be lost.
443 ret = -EFAULT;
444 break;
445 }
446 cnt -= bcnt;
447 buf += bcnt;
448 copied_cnt += bcnt;
449
450 if (cp->sync_state == 2) {
451 // Update offset inside sync key that we're
452 // repeating back out.
453 cp->sync_buf_offs += bcnt;
454 if (cp->sync_buf_offs >= cp->sync_key_len) {
455 // Consumed entire key; switch mode
456 // to normal.
457 pvr2_trace(PVR2_TRACE_DATA_FLOW,
458 "/*---TRACE_READ---*/ sync_state <== 0");
459 cp->sync_state = 0;
460 }
461 } else {
462 // Update buffer offset.
463 cp->c_data_offs += bcnt;
464 }
465 }
466
467 } while (0);
468 mutex_unlock(&cp->mutex);
469
470 if (!ret) {
471 if (copied_cnt) {
472 // If anything was copied, return that count
473 ret = copied_cnt;
474 } else {
475 // Nothing copied; suggest to caller that another
476 // attempt should be tried again later
477 ret = -EAGAIN;
478 }
479 }
480
481 pvr2_trace(PVR2_TRACE_DATA_FLOW,
482 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p request=%d result=%d",
483 cp,req_cnt,ret);
484 return ret;
485 }
486