drivers/media/usb/pvrusb2/pvrusb2-ioread.c

   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 }