| /* |
| * |
| * |
| * Copyright (C) 2005 Mike Isely <isely@pobox.com> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| |
| #include "pvrusb2-ioread.h" |
| #include "pvrusb2-debug.h" |
| #include <linux/errno.h> |
| #include <linux/string.h> |
| #include <linux/mm.h> |
| #include <linux/slab.h> |
| #include <linux/mutex.h> |
| #include <asm/uaccess.h> |
| |
| #define BUFFER_COUNT 32 |
| #define BUFFER_SIZE PAGE_ALIGN(0x4000) |
| |
| struct pvr2_ioread { |
| struct pvr2_stream *stream; |
| char *buffer_storage[BUFFER_COUNT]; |
| char *sync_key_ptr; |
| unsigned int sync_key_len; |
| unsigned int sync_buf_offs; |
| unsigned int sync_state; |
| unsigned int sync_trashed_count; |
| int enabled; // Streaming is on |
| int spigot_open; // OK to pass data to client |
| int stream_running; // Passing data to client now |
| |
| /* State relevant to current buffer being read */ |
| struct pvr2_buffer *c_buf; |
| char *c_data_ptr; |
| unsigned int c_data_len; |
| unsigned int c_data_offs; |
| struct mutex mutex; |
| }; |
| |
| static int pvr2_ioread_init(struct pvr2_ioread *cp) |
| { |
| unsigned int idx; |
| |
| cp->stream = NULL; |
| mutex_init(&cp->mutex); |
| |
| for (idx = 0; idx < BUFFER_COUNT; idx++) { |
| cp->buffer_storage[idx] = kmalloc(BUFFER_SIZE,GFP_KERNEL); |
| if (!(cp->buffer_storage[idx])) break; |
| } |
| |
| if (idx < BUFFER_COUNT) { |
| // An allocation appears to have failed |
| for (idx = 0; idx < BUFFER_COUNT; idx++) { |
| if (!(cp->buffer_storage[idx])) continue; |
| kfree(cp->buffer_storage[idx]); |
| } |
| return -ENOMEM; |
| } |
| return 0; |
| } |
| |
| static void pvr2_ioread_done(struct pvr2_ioread *cp) |
| { |
| unsigned int idx; |
| |
| pvr2_ioread_setup(cp,NULL); |
| for (idx = 0; idx < BUFFER_COUNT; idx++) { |
| if (!(cp->buffer_storage[idx])) continue; |
| kfree(cp->buffer_storage[idx]); |
| } |
| } |
| |
| struct pvr2_ioread *pvr2_ioread_create(void) |
| { |
| struct pvr2_ioread *cp; |
| cp = kzalloc(sizeof(*cp),GFP_KERNEL); |
| if (!cp) return NULL; |
| pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp); |
| if (pvr2_ioread_init(cp) < 0) { |
| kfree(cp); |
| return NULL; |
| } |
| return cp; |
| } |
| |
| void pvr2_ioread_destroy(struct pvr2_ioread *cp) |
| { |
| if (!cp) return; |
| pvr2_ioread_done(cp); |
| pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_destroy id=%p",cp); |
| if (cp->sync_key_ptr) { |
| kfree(cp->sync_key_ptr); |
| cp->sync_key_ptr = NULL; |
| } |
| kfree(cp); |
| } |
| |
| void pvr2_ioread_set_sync_key(struct pvr2_ioread *cp, |
| const char *sync_key_ptr, |
| unsigned int sync_key_len) |
| { |
| if (!cp) return; |
| |
| if (!sync_key_ptr) sync_key_len = 0; |
| if ((sync_key_len == cp->sync_key_len) && |
| ((!sync_key_len) || |
| (!memcmp(sync_key_ptr,cp->sync_key_ptr,sync_key_len)))) return; |
| |
| if (sync_key_len != cp->sync_key_len) { |
| if (cp->sync_key_ptr) { |
| kfree(cp->sync_key_ptr); |
| cp->sync_key_ptr = NULL; |
| } |
| cp->sync_key_len = 0; |
| if (sync_key_len) { |
| cp->sync_key_ptr = kmalloc(sync_key_len,GFP_KERNEL); |
| if (cp->sync_key_ptr) { |
| cp->sync_key_len = sync_key_len; |
| } |
| } |
| } |
| if (!cp->sync_key_len) return; |
| memcpy(cp->sync_key_ptr,sync_key_ptr,cp->sync_key_len); |
| } |
| |
| static void pvr2_ioread_stop(struct pvr2_ioread *cp) |
| { |
| if (!(cp->enabled)) return; |
| pvr2_trace(PVR2_TRACE_START_STOP, |
| "/*---TRACE_READ---*/ pvr2_ioread_stop id=%p",cp); |
| pvr2_stream_kill(cp->stream); |
| cp->c_buf = NULL; |
| cp->c_data_ptr = NULL; |
| cp->c_data_len = 0; |
| cp->c_data_offs = 0; |
| cp->enabled = 0; |
| cp->stream_running = 0; |
| cp->spigot_open = 0; |
| if (cp->sync_state) { |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ sync_state <== 0"); |
| cp->sync_state = 0; |
| } |
| } |
| |
| static int pvr2_ioread_start(struct pvr2_ioread *cp) |
| { |
| int stat; |
| struct pvr2_buffer *bp; |
| if (cp->enabled) return 0; |
| if (!(cp->stream)) return 0; |
| pvr2_trace(PVR2_TRACE_START_STOP, |
| "/*---TRACE_READ---*/ pvr2_ioread_start id=%p",cp); |
| while ((bp = pvr2_stream_get_idle_buffer(cp->stream)) != NULL) { |
| stat = pvr2_buffer_queue(bp); |
| if (stat < 0) { |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ pvr2_ioread_start id=%p error=%d", |
| cp,stat); |
| pvr2_ioread_stop(cp); |
| return stat; |
| } |
| } |
| cp->enabled = !0; |
| cp->c_buf = NULL; |
| cp->c_data_ptr = NULL; |
| cp->c_data_len = 0; |
| cp->c_data_offs = 0; |
| cp->stream_running = 0; |
| if (cp->sync_key_len) { |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ sync_state <== 1"); |
| cp->sync_state = 1; |
| cp->sync_trashed_count = 0; |
| cp->sync_buf_offs = 0; |
| } |
| cp->spigot_open = 0; |
| return 0; |
| } |
| |
| struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp) |
| { |
| return cp->stream; |
| } |
| |
| int pvr2_ioread_setup(struct pvr2_ioread *cp,struct pvr2_stream *sp) |
| { |
| int ret; |
| unsigned int idx; |
| struct pvr2_buffer *bp; |
| |
| mutex_lock(&cp->mutex); |
| do { |
| if (cp->stream) { |
| pvr2_trace(PVR2_TRACE_START_STOP, |
| "/*---TRACE_READ---*/ pvr2_ioread_setup (tear-down) id=%p", |
| cp); |
| pvr2_ioread_stop(cp); |
| pvr2_stream_kill(cp->stream); |
| if (pvr2_stream_get_buffer_count(cp->stream)) { |
| pvr2_stream_set_buffer_count(cp->stream,0); |
| } |
| cp->stream = NULL; |
| } |
| if (sp) { |
| pvr2_trace(PVR2_TRACE_START_STOP, |
| "/*---TRACE_READ---*/ pvr2_ioread_setup (setup) id=%p", |
| cp); |
| pvr2_stream_kill(sp); |
| ret = pvr2_stream_set_buffer_count(sp,BUFFER_COUNT); |
| if (ret < 0) { |
| mutex_unlock(&cp->mutex); |
| return ret; |
| } |
| for (idx = 0; idx < BUFFER_COUNT; idx++) { |
| bp = pvr2_stream_get_buffer(sp,idx); |
| pvr2_buffer_set_buffer(bp, |
| cp->buffer_storage[idx], |
| BUFFER_SIZE); |
| } |
| cp->stream = sp; |
| } |
| } while (0); |
| mutex_unlock(&cp->mutex); |
| |
| return 0; |
| } |
| |
| int pvr2_ioread_set_enabled(struct pvr2_ioread *cp,int fl) |
| { |
| int ret = 0; |
| if ((!fl) == (!(cp->enabled))) return ret; |
| |
| mutex_lock(&cp->mutex); |
| do { |
| if (fl) { |
| ret = pvr2_ioread_start(cp); |
| } else { |
| pvr2_ioread_stop(cp); |
| } |
| } while (0); |
| mutex_unlock(&cp->mutex); |
| return ret; |
| } |
| |
| static int pvr2_ioread_get_buffer(struct pvr2_ioread *cp) |
| { |
| int stat; |
| |
| while (cp->c_data_len <= cp->c_data_offs) { |
| if (cp->c_buf) { |
| // Flush out current buffer first. |
| stat = pvr2_buffer_queue(cp->c_buf); |
| if (stat < 0) { |
| // Streaming error... |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ pvr2_ioread_read id=%p queue_error=%d", |
| cp,stat); |
| pvr2_ioread_stop(cp); |
| return 0; |
| } |
| cp->c_buf = NULL; |
| cp->c_data_ptr = NULL; |
| cp->c_data_len = 0; |
| cp->c_data_offs = 0; |
| } |
| // Now get a freshly filled buffer. |
| cp->c_buf = pvr2_stream_get_ready_buffer(cp->stream); |
| if (!cp->c_buf) break; // Nothing ready; done. |
| cp->c_data_len = pvr2_buffer_get_count(cp->c_buf); |
| if (!cp->c_data_len) { |
| // Nothing transferred. Was there an error? |
| stat = pvr2_buffer_get_status(cp->c_buf); |
| if (stat < 0) { |
| // Streaming error... |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ pvr2_ioread_read id=%p buffer_error=%d", |
| cp,stat); |
| pvr2_ioread_stop(cp); |
| // Give up. |
| return 0; |
| } |
| // Start over... |
| continue; |
| } |
| cp->c_data_offs = 0; |
| cp->c_data_ptr = cp->buffer_storage[ |
| pvr2_buffer_get_id(cp->c_buf)]; |
| } |
| return !0; |
| } |
| |
| static void pvr2_ioread_filter(struct pvr2_ioread *cp) |
| { |
| unsigned int idx; |
| if (!cp->enabled) return; |
| if (cp->sync_state != 1) return; |
| |
| // Search the stream for our synchronization key. This is made |
| // complicated by the fact that in order to be honest with |
| // ourselves here we must search across buffer boundaries... |
| mutex_lock(&cp->mutex); |
| while (1) { |
| // Ensure we have a buffer |
| if (!pvr2_ioread_get_buffer(cp)) break; |
| if (!cp->c_data_len) break; |
| |
| // Now walk the buffer contents until we match the key or |
| // run out of buffer data. |
| for (idx = cp->c_data_offs; idx < cp->c_data_len; idx++) { |
| if (cp->sync_buf_offs >= cp->sync_key_len) break; |
| if (cp->c_data_ptr[idx] == |
| cp->sync_key_ptr[cp->sync_buf_offs]) { |
| // Found the next key byte |
| (cp->sync_buf_offs)++; |
| } else { |
| // Whoops, mismatched. Start key over... |
| cp->sync_buf_offs = 0; |
| } |
| } |
| |
| // Consume what we've walked through |
| cp->c_data_offs += idx; |
| cp->sync_trashed_count += idx; |
| |
| // If we've found the key, then update state and get out. |
| if (cp->sync_buf_offs >= cp->sync_key_len) { |
| cp->sync_trashed_count -= cp->sync_key_len; |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ sync_state <== 2 (skipped %u bytes)", |
| cp->sync_trashed_count); |
| cp->sync_state = 2; |
| cp->sync_buf_offs = 0; |
| break; |
| } |
| |
| if (cp->c_data_offs < cp->c_data_len) { |
| // Sanity check - should NEVER get here |
| pvr2_trace(PVR2_TRACE_ERROR_LEGS, |
| "ERROR: pvr2_ioread filter sync problem len=%u offs=%u", |
| cp->c_data_len,cp->c_data_offs); |
| // Get out so we don't get stuck in an infinite |
| // loop. |
| break; |
| } |
| |
| continue; // (for clarity) |
| } |
| mutex_unlock(&cp->mutex); |
| } |
| |
| int pvr2_ioread_avail(struct pvr2_ioread *cp) |
| { |
| int ret; |
| if (!(cp->enabled)) { |
| // Stream is not enabled; so this is an I/O error |
| return -EIO; |
| } |
| |
| if (cp->sync_state == 1) { |
| pvr2_ioread_filter(cp); |
| if (cp->sync_state == 1) return -EAGAIN; |
| } |
| |
| ret = 0; |
| if (cp->stream_running) { |
| if (!pvr2_stream_get_ready_count(cp->stream)) { |
| // No data available at all right now. |
| ret = -EAGAIN; |
| } |
| } else { |
| if (pvr2_stream_get_ready_count(cp->stream) < BUFFER_COUNT/2) { |
| // Haven't buffered up enough yet; try again later |
| ret = -EAGAIN; |
| } |
| } |
| |
| if ((!(cp->spigot_open)) != (!(ret == 0))) { |
| cp->spigot_open = (ret == 0); |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ data is %s", |
| cp->spigot_open ? "available" : "pending"); |
| } |
| |
| return ret; |
| } |
| |
| int pvr2_ioread_read(struct pvr2_ioread *cp,void __user *buf,unsigned int cnt) |
| { |
| unsigned int copied_cnt; |
| unsigned int bcnt; |
| const char *src; |
| int stat; |
| int ret = 0; |
| unsigned int req_cnt = cnt; |
| |
| if (!cnt) { |
| pvr2_trace(PVR2_TRACE_TRAP, |
| "/*---TRACE_READ---*/ pvr2_ioread_read id=%p ZERO Request? Returning zero.", |
| cp); |
| return 0; |
| } |
| |
| stat = pvr2_ioread_avail(cp); |
| if (stat < 0) return stat; |
| |
| cp->stream_running = !0; |
| |
| mutex_lock(&cp->mutex); |
| do { |
| |
| // Suck data out of the buffers and copy to the user |
| copied_cnt = 0; |
| if (!buf) cnt = 0; |
| while (1) { |
| if (!pvr2_ioread_get_buffer(cp)) { |
| ret = -EIO; |
| break; |
| } |
| |
| if (!cnt) break; |
| |
| if (cp->sync_state == 2) { |
| // We're repeating the sync key data into |
| // the stream. |
| src = cp->sync_key_ptr + cp->sync_buf_offs; |
| bcnt = cp->sync_key_len - cp->sync_buf_offs; |
| } else { |
| // Normal buffer copy |
| src = cp->c_data_ptr + cp->c_data_offs; |
| bcnt = cp->c_data_len - cp->c_data_offs; |
| } |
| |
| if (!bcnt) break; |
| |
| // Don't run past user's buffer |
| if (bcnt > cnt) bcnt = cnt; |
| |
| if (copy_to_user(buf,src,bcnt)) { |
| // User supplied a bad pointer? |
| // Give up - this *will* cause data |
| // to be lost. |
| ret = -EFAULT; |
| break; |
| } |
| cnt -= bcnt; |
| buf += bcnt; |
| copied_cnt += bcnt; |
| |
| if (cp->sync_state == 2) { |
| // Update offset inside sync key that we're |
| // repeating back out. |
| cp->sync_buf_offs += bcnt; |
| if (cp->sync_buf_offs >= cp->sync_key_len) { |
| // Consumed entire key; switch mode |
| // to normal. |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ sync_state <== 0"); |
| cp->sync_state = 0; |
| } |
| } else { |
| // Update buffer offset. |
| cp->c_data_offs += bcnt; |
| } |
| } |
| |
| } while (0); |
| mutex_unlock(&cp->mutex); |
| |
| if (!ret) { |
| if (copied_cnt) { |
| // If anything was copied, return that count |
| ret = copied_cnt; |
| } else { |
| // Nothing copied; suggest to caller that another |
| // attempt should be tried again later |
| ret = -EAGAIN; |
| } |
| } |
| |
| pvr2_trace(PVR2_TRACE_DATA_FLOW, |
| "/*---TRACE_READ---*/ pvr2_ioread_read id=%p request=%d result=%d", |
| cp,req_cnt,ret); |
| return ret; |
| } |