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