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 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 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 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 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 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 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 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 181 struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp) 182 { 183 return cp->stream; 184 } 185 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 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 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 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 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 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