drivers/media/video/em28xx/em28xx-core.c

   1 /*
   2    em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
   3
   4    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
   5                       Markus Rechberger <mrechberger@gmail.com>
   6                       Mauro Carvalho Chehab <mchehab@infradead.org>
   7                       Sascha Sommer <saschasommer@freenet.de>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/init.h>
  25 #include <linux/list.h>
  26 #include <linux/module.h>
  27 #include <linux/usb.h>
  28 #include <linux/vmalloc.h>
  29
  30 #include "em28xx.h"
  31
  32 /* #define ENABLE_DEBUG_ISOC_FRAMES */
  33
  34 static unsigned int core_debug;
  35 module_param(core_debug,int,0644);
  36 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
  37
  38 #define em28xx_coredbg(fmt, arg...) do {\
  39         if (core_debug) \
  40                 printk(KERN_INFO "%s %s :"fmt, \
  41                          dev->name, __func__ , ##arg); } while (0)
  42
  43 static unsigned int reg_debug;
  44 module_param(reg_debug,int,0644);
  45 MODULE_PARM_DESC(reg_debug,"enable debug messages [URB reg]");
  46
  47 #define em28xx_regdbg(fmt, arg...) do {\
  48         if (reg_debug) \
  49                 printk(KERN_INFO "%s %s :"fmt, \
  50                          dev->name, __func__ , ##arg); } while (0)
  51
  52 static int alt = EM28XX_PINOUT;
  53 module_param(alt, int, 0644);
  54 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
  55
  56 /* FIXME */
  57 #define em28xx_isocdbg(fmt, arg...) do {\
  58         if (core_debug) \
  59                 printk(KERN_INFO "%s %s :"fmt, \
  60                          dev->name, __func__ , ##arg); } while (0)
  61
  62 /*
  63  * em28xx_read_reg_req()
  64  * reads data from the usb device specifying bRequest
  65  */
  66 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
  67                                    char *buf, int len)
  68 {
  69         int ret, byte;
  70
  71         if (dev->state & DEV_DISCONNECTED)
  72                 return(-ENODEV);
  73
  74         em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
  75
  76         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
  77                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  78                               0x0000, reg, buf, len, HZ);
  79
  80         if (reg_debug) {
  81                 printk(ret < 0 ? " failed!\n" : "%02x values: ", ret);
  82                 for (byte = 0; byte < len; byte++)
  83                         printk(" %02x", (unsigned char)buf[byte]);
  84
  85                 printk("\n");
  86         }
  87
  88         return ret;
  89 }
  90
  91 /*
  92  * em28xx_read_reg_req()
  93  * reads data from the usb device specifying bRequest
  94  */
  95 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
  96 {
  97         u8 val;
  98         int ret;
  99
 100         if (dev->state & DEV_DISCONNECTED)
 101                 return(-ENODEV);
 102
 103         em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
 104
 105         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
 106                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 107                               0x0000, reg, &val, 1, HZ);
 108
 109         if (reg_debug)
 110                 printk(ret < 0 ? " failed!\n" :
 111                                  "%02x\n", (unsigned char) val);
 112
 113         if (ret < 0)
 114                 return ret;
 115
 116         return val;
 117 }
 118
 119 int em28xx_read_reg(struct em28xx *dev, u16 reg)
 120 {
 121         return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
 122 }
 123
 124 /*
 125  * em28xx_write_regs_req()
 126  * sends data to the usb device, specifying bRequest
 127  */
 128 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
 129                                  int len)
 130 {
 131         int ret;
 132
 133         /*usb_control_msg seems to expect a kmalloced buffer */
 134         unsigned char *bufs;
 135
 136         if (dev->state & DEV_DISCONNECTED)
 137                 return -ENODEV;
 138
 139         if (len < 1)
 140                 return -EINVAL;
 141
 142         bufs = kmalloc(len, GFP_KERNEL);
 143
 144         em28xx_regdbg("req=%02x reg=%02x:", req, reg);
 145
 146         if (reg_debug) {
 147                 int i;
 148                 for (i = 0; i < len; ++i)
 149                         printk(" %02x", (unsigned char)buf[i]);
 150                 printk("\n");
 151         }
 152
 153         if (!bufs)
 154                 return -ENOMEM;
 155         memcpy(bufs, buf, len);
 156         ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
 157                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 158                               0x0000, reg, bufs, len, HZ);
 159         if (dev->wait_after_write)
 160                 msleep(dev->wait_after_write);
 161
 162         kfree(bufs);
 163         return ret;
 164 }
 165
 166 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
 167 {
 168         int rc;
 169
 170         rc = em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
 171
 172         /* Stores GPO/GPIO values at the cache, if changed
 173            Only write values should be stored, since input on a GPIO
 174            register will return the input bits.
 175            Not sure what happens on reading GPO register.
 176          */
 177         if (rc >= 0) {
 178                 if (reg == EM2880_R04_GPO)
 179                         dev->reg_gpo = buf[0];
 180                 else if (reg == EM28XX_R08_GPIO)
 181                         dev->reg_gpio = buf[0];
 182         }
 183
 184         return rc;
 185 }
 186
 187 /*
 188  * em28xx_write_reg_bits()
 189  * sets only some bits (specified by bitmask) of a register, by first reading
 190  * the actual value
 191  */
 192 static int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
 193                                  u8 bitmask)
 194 {
 195         int oldval;
 196         u8 newval;
 197
 198         /* Uses cache for gpo/gpio registers */
 199         if (reg == EM2880_R04_GPO)
 200                 oldval = dev->reg_gpo;
 201         else if (reg == EM28XX_R08_GPIO)
 202                 oldval = dev->reg_gpio;
 203         else
 204                 oldval = em28xx_read_reg(dev, reg);
 205
 206         if (oldval < 0)
 207                 return oldval;
 208
 209         newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
 210
 211         return em28xx_write_regs(dev, reg, &newval, 1);
 212 }
 213
 214 /*
 215  * em28xx_write_ac97()
 216  * write a 16 bit value to the specified AC97 address (LSB first!)
 217  */
 218 static int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 *val)
 219 {
 220         int ret, i;
 221         u8 addr = reg & 0x7f;
 222
 223         ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, val, 2);
 224         if (ret < 0)
 225                 return ret;
 226
 227         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 228         if (ret < 0)
 229                 return ret;
 230
 231         /* Wait up to 50 ms for AC97 command to complete */
 232         for (i = 0; i < 10; i++) {
 233                 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
 234                 if (ret < 0)
 235                         return ret;
 236
 237                 if (!(ret & 0x01))
 238                         return 0;
 239                 msleep(5);
 240         }
 241         em28xx_warn("AC97 command still being executed: not handled properly!\n");
 242         return 0;
 243 }
 244
 245 static int em28xx_set_audio_source(struct em28xx *dev)
 246 {
 247         static char *enable  = "\x08\x08";
 248         static char *disable = "\x08\x88";
 249         char *video = enable, *line = disable;
 250         int ret;
 251         u8 input;
 252
 253         if (dev->is_em2800) {
 254                 if (dev->ctl_ainput)
 255                         input = EM2800_AUDIO_SRC_LINE;
 256                 else
 257                         input = EM2800_AUDIO_SRC_TUNER;
 258
 259                 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
 260                 if (ret < 0)
 261                         return ret;
 262         }
 263
 264         if (dev->has_msp34xx)
 265                 input = EM28XX_AUDIO_SRC_TUNER;
 266         else {
 267                 switch (dev->ctl_ainput) {
 268                 case EM28XX_AMUX_VIDEO:
 269                         input = EM28XX_AUDIO_SRC_TUNER;
 270                         break;
 271                 case EM28XX_AMUX_LINE_IN:
 272                         input = EM28XX_AUDIO_SRC_LINE;
 273                         break;
 274                 case EM28XX_AMUX_AC97_VIDEO:
 275                         input = EM28XX_AUDIO_SRC_LINE;
 276                         break;
 277                 case EM28XX_AMUX_AC97_LINE_IN:
 278                         input = EM28XX_AUDIO_SRC_LINE;
 279                         video = disable;
 280                         line  = enable;
 281                         break;
 282                 }
 283         }
 284
 285         ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
 286         if (ret < 0)
 287                 return ret;
 288         msleep(5);
 289
 290         /* Sets AC97 mixer registers
 291            This is seems to be needed, even for non-ac97 configs
 292          */
 293         ret = em28xx_write_ac97(dev, EM28XX_R14_VIDEO_AC97, video);
 294         if (ret < 0)
 295                 return ret;
 296
 297         ret = em28xx_write_ac97(dev, EM28XX_R10_LINE_IN_AC97, line);
 298
 299         return ret;
 300 }
 301
 302 int em28xx_audio_analog_set(struct em28xx *dev)
 303 {
 304         int ret;
 305         char s[2] = { 0x00, 0x00 };
 306         u8 xclk = 0x07;
 307
 308         s[0] |= 0x1f - dev->volume;
 309         s[1] |= 0x1f - dev->volume;
 310
 311         /* Mute */
 312         s[1] |= 0x80;
 313         ret = em28xx_write_ac97(dev, EM28XX_R02_MASTER_AC97, s);
 314
 315         if (ret < 0)
 316                 return ret;
 317
 318         if (dev->has_12mhz_i2s)
 319                 xclk |= 0x20;
 320
 321         if (!dev->mute)
 322                 xclk |= 0x80;
 323
 324         ret = em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, xclk, 0xa7);
 325         if (ret < 0)
 326                 return ret;
 327         msleep(10);
 328
 329         /* Selects the proper audio input */
 330         ret = em28xx_set_audio_source(dev);
 331
 332         /* Unmute device */
 333         if (!dev->mute)
 334                 s[1] &= ~0x80;
 335         ret = em28xx_write_ac97(dev, EM28XX_R02_MASTER_AC97, s);
 336
 337         return ret;
 338 }
 339 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
 340
 341 int em28xx_colorlevels_set_default(struct em28xx *dev)
 342 {
 343         em28xx_write_regs(dev, EM28XX_R20_YGAIN, "\x10", 1);    /* contrast */
 344         em28xx_write_regs(dev, EM28XX_R21_YOFFSET, "\x00", 1);  /* brightness */
 345         em28xx_write_regs(dev, EM28XX_R22_UVGAIN, "\x10", 1);   /* saturation */
 346         em28xx_write_regs(dev, EM28XX_R23_UOFFSET, "\x00", 1);
 347         em28xx_write_regs(dev, EM28XX_R24_VOFFSET, "\x00", 1);
 348         em28xx_write_regs(dev, EM28XX_R25_SHARPNESS, "\x00", 1);
 349
 350         em28xx_write_regs(dev, EM28XX_R14_GAMMA, "\x20", 1);
 351         em28xx_write_regs(dev, EM28XX_R15_RGAIN, "\x20", 1);
 352         em28xx_write_regs(dev, EM28XX_R16_GGAIN, "\x20", 1);
 353         em28xx_write_regs(dev, EM28XX_R17_BGAIN, "\x20", 1);
 354         em28xx_write_regs(dev, EM28XX_R18_ROFFSET, "\x00", 1);
 355         em28xx_write_regs(dev, EM28XX_R19_GOFFSET, "\x00", 1);
 356         return em28xx_write_regs(dev, EM28XX_R1A_BOFFSET, "\x00", 1);
 357 }
 358
 359 int em28xx_capture_start(struct em28xx *dev, int start)
 360 {
 361         int rc;
 362         /* FIXME: which is the best order? */
 363         /* video registers are sampled by VREF */
 364         rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
 365                                    start ? 0x10 : 0x00, 0x10);
 366         if (rc < 0)
 367                 return rc;
 368
 369         if (!start) {
 370                 /* disable video capture */
 371                 rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x27", 1);
 372                 return rc;
 373         }
 374
 375         /* enable video capture */
 376         rc = em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
 377
 378         if (dev->mode == EM28XX_ANALOG_MODE)
 379                 rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x67", 1);
 380         else
 381                 rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x37", 1);
 382
 383         msleep(6);
 384
 385         return rc;
 386 }
 387
 388 int em28xx_outfmt_set_yuv422(struct em28xx *dev)
 389 {
 390         em28xx_write_regs(dev, EM28XX_R27_OUTFMT, "\x34", 1);
 391         em28xx_write_regs(dev, EM28XX_R10_VINMODE, "\x10", 1);
 392         return em28xx_write_regs(dev, EM28XX_R11_VINCTRL, "\x11", 1);
 393 }
 394
 395 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
 396                                   u8 ymin, u8 ymax)
 397 {
 398         em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
 399                         xmin, ymin, xmax, ymax);
 400
 401         em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
 402         em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
 403         em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
 404         return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
 405 }
 406
 407 static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
 408                                    u16 width, u16 height)
 409 {
 410         u8 cwidth = width;
 411         u8 cheight = height;
 412         u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
 413
 414         em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
 415                         (width | (overflow & 2) << 7),
 416                         (height | (overflow & 1) << 8));
 417
 418         em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
 419         em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
 420         em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
 421         em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
 422         return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
 423 }
 424
 425 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 426 {
 427         u8 mode;
 428         /* the em2800 scaler only supports scaling down to 50% */
 429         if (dev->is_em2800)
 430                 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
 431         else {
 432                 u8 buf[2];
 433                 buf[0] = h;
 434                 buf[1] = h >> 8;
 435                 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
 436                 buf[0] = v;
 437                 buf[1] = v >> 8;
 438                 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
 439                 /* it seems that both H and V scalers must be active
 440                    to work correctly */
 441                 mode = (h || v)? 0x30: 0x00;
 442         }
 443         return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
 444 }
 445
 446 /* FIXME: this only function read values from dev */
 447 int em28xx_resolution_set(struct em28xx *dev)
 448 {
 449         int width, height;
 450         width = norm_maxw(dev);
 451         height = norm_maxh(dev) >> 1;
 452
 453         em28xx_outfmt_set_yuv422(dev);
 454         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
 455         em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
 456         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 457 }
 458
 459 int em28xx_set_alternate(struct em28xx *dev)
 460 {
 461         int errCode, prev_alt = dev->alt;
 462         int i;
 463         unsigned int min_pkt_size = dev->width * 2 + 4;
 464
 465         /* When image size is bigger than a certain value,
 466            the frame size should be increased, otherwise, only
 467            green screen will be received.
 468          */
 469         if (dev->width * 2 * dev->height > 720 * 240 * 2)
 470                 min_pkt_size *= 2;
 471
 472         for (i = 0; i < dev->num_alt; i++) {
 473                 /* stop when the selected alt setting offers enough bandwidth */
 474                 if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
 475                         dev->alt = i;
 476                         break;
 477                 /* otherwise make sure that we end up with the maximum bandwidth
 478                    because the min_pkt_size equation might be wrong...
 479                 */
 480                 } else if (dev->alt_max_pkt_size[i] >
 481                            dev->alt_max_pkt_size[dev->alt])
 482                         dev->alt = i;
 483         }
 484
 485         if (dev->alt != prev_alt) {
 486                 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
 487                                 min_pkt_size, dev->alt);
 488                 dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
 489                 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
 490                                dev->alt, dev->max_pkt_size);
 491                 errCode = usb_set_interface(dev->udev, 0, dev->alt);
 492                 if (errCode < 0) {
 493                         em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
 494                                         dev->alt, errCode);
 495                         return errCode;
 496                 }
 497         }
 498         return 0;
 499 }
 500
 501 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
 502 {
 503         int rc = 0;
 504
 505         if (!gpio)
 506                 return rc;
 507
 508         dev->em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
 509         if (dev->mode == EM28XX_ANALOG_MODE)
 510                 dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x67", 1);
 511         else
 512                 dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x37", 1);
 513         msleep(6);
 514
 515         /* Send GPIO reset sequences specified at board entry */
 516         while (gpio->sleep >= 0) {
 517                 if (gpio->reg >= 0) {
 518                         rc = em28xx_write_reg_bits(dev,
 519                                                    gpio->reg,
 520                                                    gpio->val,
 521                                                    gpio->mask);
 522                         if (rc < 0)
 523                                 return rc;
 524                 }
 525                 if (gpio->sleep > 0)
 526                         msleep(gpio->sleep);
 527
 528                 gpio++;
 529         }
 530         return rc;
 531 }
 532
 533 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
 534 {
 535         if (dev->mode == set_mode)
 536                 return 0;
 537
 538         if (set_mode == EM28XX_MODE_UNDEFINED) {
 539                 dev->mode = set_mode;
 540                 return 0;
 541         }
 542
 543         dev->mode = set_mode;
 544
 545         if (dev->mode == EM28XX_DIGITAL_MODE)
 546                 return em28xx_gpio_set(dev, dev->digital_gpio);
 547         else
 548                 return em28xx_gpio_set(dev, dev->analog_gpio);
 549 }
 550 EXPORT_SYMBOL_GPL(em28xx_set_mode);
 551
 552 /* ------------------------------------------------------------------
 553         URB control
 554    ------------------------------------------------------------------*/
 555
 556 /*
 557  * IRQ callback, called by URB callback
 558  */
 559 static void em28xx_irq_callback(struct urb *urb)
 560 {
 561         struct em28xx_dmaqueue  *dma_q = urb->context;
 562         struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
 563         int rc, i;
 564
 565         /* Copy data from URB */
 566         spin_lock(&dev->slock);
 567         rc = dev->isoc_ctl.isoc_copy(dev, urb);
 568         spin_unlock(&dev->slock);
 569
 570         /* Reset urb buffers */
 571         for (i = 0; i < urb->number_of_packets; i++) {
 572                 urb->iso_frame_desc[i].status = 0;
 573                 urb->iso_frame_desc[i].actual_length = 0;
 574         }
 575         urb->status = 0;
 576
 577         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 578         if (urb->status) {
 579                 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
 580                                urb->status);
 581         }
 582 }
 583
 584 /*
 585  * Stop and Deallocate URBs
 586  */
 587 void em28xx_uninit_isoc(struct em28xx *dev)
 588 {
 589         struct urb *urb;
 590         int i;
 591
 592         em28xx_isocdbg("em28xx: called em28xx_uninit_isoc\n");
 593
 594         dev->isoc_ctl.nfields = -1;
 595         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 596                 urb = dev->isoc_ctl.urb[i];
 597                 if (urb) {
 598                         usb_kill_urb(urb);
 599                         usb_unlink_urb(urb);
 600                         if (dev->isoc_ctl.transfer_buffer[i]) {
 601                                 usb_buffer_free(dev->udev,
 602                                         urb->transfer_buffer_length,
 603                                         dev->isoc_ctl.transfer_buffer[i],
 604                                         urb->transfer_dma);
 605                         }
 606                         usb_free_urb(urb);
 607                         dev->isoc_ctl.urb[i] = NULL;
 608                 }
 609                 dev->isoc_ctl.transfer_buffer[i] = NULL;
 610         }
 611
 612         kfree(dev->isoc_ctl.urb);
 613         kfree(dev->isoc_ctl.transfer_buffer);
 614
 615         dev->isoc_ctl.urb = NULL;
 616         dev->isoc_ctl.transfer_buffer = NULL;
 617         dev->isoc_ctl.num_bufs = 0;
 618
 619         em28xx_capture_start(dev, 0);
 620 }
 621 EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
 622
 623 /*
 624  * Allocate URBs and start IRQ
 625  */
 626 int em28xx_init_isoc(struct em28xx *dev, int max_packets,
 627                      int num_bufs, int max_pkt_size,
 628                      int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
 629 {
 630         struct em28xx_dmaqueue *dma_q = &dev->vidq;
 631         int i;
 632         int sb_size, pipe;
 633         struct urb *urb;
 634         int j, k;
 635         int rc;
 636
 637         em28xx_isocdbg("em28xx: called em28xx_prepare_isoc\n");
 638
 639         /* De-allocates all pending stuff */
 640         em28xx_uninit_isoc(dev);
 641
 642         dev->isoc_ctl.isoc_copy = isoc_copy;
 643         dev->isoc_ctl.num_bufs = num_bufs;
 644
 645         dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
 646         if (!dev->isoc_ctl.urb) {
 647                 em28xx_errdev("cannot alloc memory for usb buffers\n");
 648                 return -ENOMEM;
 649         }
 650
 651         dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
 652                                               GFP_KERNEL);
 653         if (!dev->isoc_ctl.transfer_buffer) {
 654                 em28xx_errdev("cannot allocate memory for usbtransfer\n");
 655                 kfree(dev->isoc_ctl.urb);
 656                 return -ENOMEM;
 657         }
 658
 659         dev->isoc_ctl.max_pkt_size = max_pkt_size;
 660         dev->isoc_ctl.buf = NULL;
 661
 662         sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
 663
 664         /* allocate urbs and transfer buffers */
 665         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 666                 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
 667                 if (!urb) {
 668                         em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
 669                         em28xx_uninit_isoc(dev);
 670                         return -ENOMEM;
 671                 }
 672                 dev->isoc_ctl.urb[i] = urb;
 673
 674                 dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->udev,
 675                         sb_size, GFP_KERNEL, &urb->transfer_dma);
 676                 if (!dev->isoc_ctl.transfer_buffer[i]) {
 677                         em28xx_err("unable to allocate %i bytes for transfer"
 678                                         " buffer %i%s\n",
 679                                         sb_size, i,
 680                                         in_interrupt()?" while in int":"");
 681                         em28xx_uninit_isoc(dev);
 682                         return -ENOMEM;
 683                 }
 684                 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
 685
 686                 /* FIXME: this is a hack - should be
 687                         'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
 688                         should also be using 'desc.bInterval'
 689                  */
 690                 pipe = usb_rcvisocpipe(dev->udev,
 691                         dev->mode == EM28XX_ANALOG_MODE ? 0x82 : 0x84);
 692
 693                 usb_fill_int_urb(urb, dev->udev, pipe,
 694                                  dev->isoc_ctl.transfer_buffer[i], sb_size,
 695                                  em28xx_irq_callback, dma_q, 1);
 696
 697                 urb->number_of_packets = max_packets;
 698                 urb->transfer_flags = URB_ISO_ASAP;
 699
 700                 k = 0;
 701                 for (j = 0; j < max_packets; j++) {
 702                         urb->iso_frame_desc[j].offset = k;
 703                         urb->iso_frame_desc[j].length =
 704                                                 dev->isoc_ctl.max_pkt_size;
 705                         k += dev->isoc_ctl.max_pkt_size;
 706                 }
 707         }
 708
 709         init_waitqueue_head(&dma_q->wq);
 710
 711         em28xx_capture_start(dev, 1);
 712
 713         /* submit urbs and enables IRQ */
 714         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 715                 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
 716                 if (rc) {
 717                         em28xx_err("submit of urb %i failed (error=%i)\n", i,
 718                                    rc);
 719                         em28xx_uninit_isoc(dev);
 720                         return rc;
 721                 }
 722         }
 723
 724         return 0;
 725 }
 726 EXPORT_SYMBOL_GPL(em28xx_init_isoc);