drivers/media/usb/dvb-usb-v2/usb_urb.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* usb-urb.c is part of the DVB USB library.
   3  *
   4  * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@posteo.de)
   5  * see dvb-usb-init.c for copyright information.
   6  *
   7  * This file keeps functions for initializing and handling the
   8  * BULK and ISOC USB data transfers in a generic way.
   9  * Can be used for DVB-only and also, that's the plan, for
  10  * Hybrid USB devices (analog and DVB).
  11  */
  12 #include "dvb_usb_common.h"
  13
  14 /* URB stuff for streaming */
  15
  16 int usb_urb_reconfig(struct usb_data_stream *stream,
  17                 struct usb_data_stream_properties *props);
  18
  19 static void usb_urb_complete(struct urb *urb)
  20 {
  21         struct usb_data_stream *stream = urb->context;
  22         int ptype = usb_pipetype(urb->pipe);
  23         int i;
  24         u8 *b;
  25
  26         dev_dbg_ratelimited(&stream->udev->dev,
  27                         "%s: %s urb completed status=%d length=%d/%d pack_num=%d errors=%d\n",
  28                         __func__, ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk",
  29                         urb->status, urb->actual_length,
  30                         urb->transfer_buffer_length,
  31                         urb->number_of_packets, urb->error_count);
  32
  33         switch (urb->status) {
  34         case 0:         /* success */
  35         case -ETIMEDOUT:    /* NAK */
  36                 break;
  37         case -ECONNRESET:   /* kill */
  38         case -ENOENT:
  39         case -ESHUTDOWN:
  40                 return;
  41         default:        /* error */
  42                 dev_dbg_ratelimited(&stream->udev->dev,
  43                                 "%s: urb completition failed=%d\n",
  44                                 __func__, urb->status);
  45                 break;
  46         }
  47
  48         b = (u8 *) urb->transfer_buffer;
  49         switch (ptype) {
  50         case PIPE_ISOCHRONOUS:
  51                 for (i = 0; i < urb->number_of_packets; i++) {
  52                         if (urb->iso_frame_desc[i].status != 0)
  53                                 dev_dbg(&stream->udev->dev,
  54                                                 "%s: iso frame descriptor has an error=%d\n",
  55                                                 __func__,
  56                                                 urb->iso_frame_desc[i].status);
  57                         else if (urb->iso_frame_desc[i].actual_length > 0)
  58                                 stream->complete(stream,
  59                                         b + urb->iso_frame_desc[i].offset,
  60                                         urb->iso_frame_desc[i].actual_length);
  61
  62                         urb->iso_frame_desc[i].status = 0;
  63                         urb->iso_frame_desc[i].actual_length = 0;
  64                 }
  65                 break;
  66         case PIPE_BULK:
  67                 if (urb->actual_length > 0)
  68                         stream->complete(stream, b, urb->actual_length);
  69                 break;
  70         default:
  71                 dev_err(&stream->udev->dev,
  72                                 "%s: unknown endpoint type in completition handler\n",
  73                                 KBUILD_MODNAME);
  74                 return;
  75         }
  76         usb_submit_urb(urb, GFP_ATOMIC);
  77 }
  78
  79 int usb_urb_killv2(struct usb_data_stream *stream)
  80 {
  81         int i;
  82         for (i = 0; i < stream->urbs_submitted; i++) {
  83                 dev_dbg(&stream->udev->dev, "%s: kill urb=%d\n", __func__, i);
  84                 /* stop the URB */
  85                 usb_kill_urb(stream->urb_list[i]);
  86         }
  87         stream->urbs_submitted = 0;
  88         return 0;
  89 }
  90
  91 int usb_urb_submitv2(struct usb_data_stream *stream,
  92                 struct usb_data_stream_properties *props)
  93 {
  94         int i, ret;
  95
  96         if (props) {
  97                 ret = usb_urb_reconfig(stream, props);
  98                 if (ret < 0)
  99                         return ret;
 100         }
 101
 102         for (i = 0; i < stream->urbs_initialized; i++) {
 103                 dev_dbg(&stream->udev->dev, "%s: submit urb=%d\n", __func__, i);
 104                 ret = usb_submit_urb(stream->urb_list[i], GFP_ATOMIC);
 105                 if (ret) {
 106                         dev_err(&stream->udev->dev,
 107                                         "%s: could not submit urb no. %d - get them all back\n",
 108                                         KBUILD_MODNAME, i);
 109                         usb_urb_killv2(stream);
 110                         return ret;
 111                 }
 112                 stream->urbs_submitted++;
 113         }
 114         return 0;
 115 }
 116
 117 static int usb_urb_free_urbs(struct usb_data_stream *stream)
 118 {
 119         int i;
 120
 121         usb_urb_killv2(stream);
 122
 123         for (i = stream->urbs_initialized - 1; i >= 0; i--) {
 124                 if (stream->urb_list[i]) {
 125                         dev_dbg(&stream->udev->dev, "%s: free urb=%d\n",
 126                                         __func__, i);
 127                         /* free the URBs */
 128                         usb_free_urb(stream->urb_list[i]);
 129                 }
 130         }
 131         stream->urbs_initialized = 0;
 132
 133         return 0;
 134 }
 135
 136 static int usb_urb_alloc_bulk_urbs(struct usb_data_stream *stream)
 137 {
 138         int i, j;
 139
 140         /* allocate the URBs */
 141         for (i = 0; i < stream->props.count; i++) {
 142                 dev_dbg(&stream->udev->dev, "%s: alloc urb=%d\n", __func__, i);
 143                 stream->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
 144                 if (!stream->urb_list[i]) {
 145                         dev_dbg(&stream->udev->dev, "%s: failed\n", __func__);
 146                         for (j = 0; j < i; j++)
 147                                 usb_free_urb(stream->urb_list[j]);
 148                         return -ENOMEM;
 149                 }
 150                 usb_fill_bulk_urb(stream->urb_list[i],
 151                                 stream->udev,
 152                                 usb_rcvbulkpipe(stream->udev,
 153                                                 stream->props.endpoint),
 154                                 stream->buf_list[i],
 155                                 stream->props.u.bulk.buffersize,
 156                                 usb_urb_complete, stream);
 157
 158                 stream->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 159                 stream->urb_list[i]->transfer_dma = stream->dma_addr[i];
 160                 stream->urbs_initialized++;
 161         }
 162         return 0;
 163 }
 164
 165 static int usb_urb_alloc_isoc_urbs(struct usb_data_stream *stream)
 166 {
 167         int i, j;
 168
 169         /* allocate the URBs */
 170         for (i = 0; i < stream->props.count; i++) {
 171                 struct urb *urb;
 172                 int frame_offset = 0;
 173                 dev_dbg(&stream->udev->dev, "%s: alloc urb=%d\n", __func__, i);
 174                 stream->urb_list[i] = usb_alloc_urb(
 175                                 stream->props.u.isoc.framesperurb, GFP_ATOMIC);
 176                 if (!stream->urb_list[i]) {
 177                         dev_dbg(&stream->udev->dev, "%s: failed\n", __func__);
 178                         for (j = 0; j < i; j++)
 179                                 usb_free_urb(stream->urb_list[j]);
 180                         return -ENOMEM;
 181                 }
 182
 183                 urb = stream->urb_list[i];
 184
 185                 urb->dev = stream->udev;
 186                 urb->context = stream;
 187                 urb->complete = usb_urb_complete;
 188                 urb->pipe = usb_rcvisocpipe(stream->udev,
 189                                 stream->props.endpoint);
 190                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 191                 urb->interval = stream->props.u.isoc.interval;
 192                 urb->number_of_packets = stream->props.u.isoc.framesperurb;
 193                 urb->transfer_buffer_length = stream->props.u.isoc.framesize *
 194                                 stream->props.u.isoc.framesperurb;
 195                 urb->transfer_buffer = stream->buf_list[i];
 196                 urb->transfer_dma = stream->dma_addr[i];
 197
 198                 for (j = 0; j < stream->props.u.isoc.framesperurb; j++) {
 199                         urb->iso_frame_desc[j].offset = frame_offset;
 200                         urb->iso_frame_desc[j].length =
 201                                         stream->props.u.isoc.framesize;
 202                         frame_offset += stream->props.u.isoc.framesize;
 203                 }
 204
 205                 stream->urbs_initialized++;
 206         }
 207         return 0;
 208 }
 209
 210 static int usb_free_stream_buffers(struct usb_data_stream *stream)
 211 {
 212         if (stream->state & USB_STATE_URB_BUF) {
 213                 while (stream->buf_num) {
 214                         stream->buf_num--;
 215                         dev_dbg(&stream->udev->dev, "%s: free buf=%d\n",
 216                                 __func__, stream->buf_num);
 217                         usb_free_coherent(stream->udev, stream->buf_size,
 218                                           stream->buf_list[stream->buf_num],
 219                                           stream->dma_addr[stream->buf_num]);
 220                 }
 221         }
 222
 223         stream->state &= ~USB_STATE_URB_BUF;
 224
 225         return 0;
 226 }
 227
 228 static int usb_alloc_stream_buffers(struct usb_data_stream *stream, int num,
 229                                     unsigned long size)
 230 {
 231         stream->buf_num = 0;
 232         stream->buf_size = size;
 233
 234         dev_dbg(&stream->udev->dev,
 235                         "%s: all in all I will use %lu bytes for streaming\n",
 236                         __func__,  num * size);
 237
 238         for (stream->buf_num = 0; stream->buf_num < num; stream->buf_num++) {
 239                 stream->buf_list[stream->buf_num] = usb_alloc_coherent(
 240                                 stream->udev, size, GFP_ATOMIC,
 241                                 &stream->dma_addr[stream->buf_num]);
 242                 if (!stream->buf_list[stream->buf_num]) {
 243                         dev_dbg(&stream->udev->dev, "%s: alloc buf=%d failed\n",
 244                                         __func__, stream->buf_num);
 245                         usb_free_stream_buffers(stream);
 246                         return -ENOMEM;
 247                 }
 248
 249                 dev_dbg(&stream->udev->dev, "%s: alloc buf=%d %p (dma %llu)\n",
 250                                 __func__, stream->buf_num,
 251                                 stream->buf_list[stream->buf_num],
 252                                 (long long)stream->dma_addr[stream->buf_num]);
 253                 memset(stream->buf_list[stream->buf_num], 0, size);
 254                 stream->state |= USB_STATE_URB_BUF;
 255         }
 256
 257         return 0;
 258 }
 259
 260 int usb_urb_reconfig(struct usb_data_stream *stream,
 261                 struct usb_data_stream_properties *props)
 262 {
 263         int buf_size;
 264
 265         if (!props)
 266                 return 0;
 267
 268         /* check allocated buffers are large enough for the request */
 269         if (props->type == USB_BULK) {
 270                 buf_size = stream->props.u.bulk.buffersize;
 271         } else if (props->type == USB_ISOC) {
 272                 buf_size = props->u.isoc.framesize * props->u.isoc.framesperurb;
 273         } else {
 274                 dev_err(&stream->udev->dev, "%s: invalid endpoint type=%d\n",
 275                                 KBUILD_MODNAME, props->type);
 276                 return -EINVAL;
 277         }
 278
 279         if (stream->buf_num < props->count || stream->buf_size < buf_size) {
 280                 dev_err(&stream->udev->dev,
 281                                 "%s: cannot reconfigure as allocated buffers are too small\n",
 282                                 KBUILD_MODNAME);
 283                 return -EINVAL;
 284         }
 285
 286         /* check if all fields are same */
 287         if (stream->props.type == props->type &&
 288                         stream->props.count == props->count &&
 289                         stream->props.endpoint == props->endpoint) {
 290                 if (props->type == USB_BULK &&
 291                                 props->u.bulk.buffersize ==
 292                                 stream->props.u.bulk.buffersize)
 293                         return 0;
 294                 else if (props->type == USB_ISOC &&
 295                                 props->u.isoc.framesperurb ==
 296                                 stream->props.u.isoc.framesperurb &&
 297                                 props->u.isoc.framesize ==
 298                                 stream->props.u.isoc.framesize &&
 299                                 props->u.isoc.interval ==
 300                                 stream->props.u.isoc.interval)
 301                         return 0;
 302         }
 303
 304         dev_dbg(&stream->udev->dev, "%s: re-alloc urbs\n", __func__);
 305
 306         usb_urb_free_urbs(stream);
 307         memcpy(&stream->props, props, sizeof(*props));
 308         if (props->type == USB_BULK)
 309                 return usb_urb_alloc_bulk_urbs(stream);
 310         else if (props->type == USB_ISOC)
 311                 return usb_urb_alloc_isoc_urbs(stream);
 312
 313         return 0;
 314 }
 315
 316 int usb_urb_initv2(struct usb_data_stream *stream,
 317                 const struct usb_data_stream_properties *props)
 318 {
 319         int ret;
 320
 321         if (!stream || !props)
 322                 return -EINVAL;
 323
 324         memcpy(&stream->props, props, sizeof(*props));
 325
 326         if (!stream->complete) {
 327                 dev_err(&stream->udev->dev,
 328                                 "%s: there is no data callback - this doesn't make sense\n",
 329                                 KBUILD_MODNAME);
 330                 return -EINVAL;
 331         }
 332
 333         switch (stream->props.type) {
 334         case USB_BULK:
 335                 ret = usb_alloc_stream_buffers(stream, stream->props.count,
 336                                 stream->props.u.bulk.buffersize);
 337                 if (ret < 0)
 338                         return ret;
 339
 340                 return usb_urb_alloc_bulk_urbs(stream);
 341         case USB_ISOC:
 342                 ret = usb_alloc_stream_buffers(stream, stream->props.count,
 343                                 stream->props.u.isoc.framesize *
 344                                 stream->props.u.isoc.framesperurb);
 345                 if (ret < 0)
 346                         return ret;
 347
 348                 return usb_urb_alloc_isoc_urbs(stream);
 349         default:
 350                 dev_err(&stream->udev->dev,
 351                                 "%s: unknown urb-type for data transfer\n",
 352                                 KBUILD_MODNAME);
 353                 return -EINVAL;
 354         }
 355 }
 356
 357 int usb_urb_exitv2(struct usb_data_stream *stream)
 358 {
 359         usb_urb_free_urbs(stream);
 360         usb_free_stream_buffers(stream);
 361
 362         return 0;
 363 }