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
19struct 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
39static 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
62static 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
73struct 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
86void 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
98void 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
126static 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
146static 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
181struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp)
182{
183	return cp->stream;
184}
185
186int 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
229int 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
246static 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
293static 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
352int 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
388int 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.",
400cp);
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