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