Pileus Git - ~andy/linux/blob - drivers/media/usb/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    Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include <linux/init.h>
  26 #include <linux/list.h>
  27 #include <linux/module.h>
  28 #include <linux/slab.h>
  29 #include <linux/usb.h>
  30 #include <linux/vmalloc.h>
  31 #include <sound/ac97_codec.h>
  32 #include <media/v4l2-common.h>
  33
  34 #include "em28xx.h"
  35
  36 /* #define ENABLE_DEBUG_ISOC_FRAMES */
  37
  38 static unsigned int core_debug;
  39 module_param(core_debug, int, 0644);
  40 MODULE_PARM_DESC(core_debug, "enable debug messages [core]");
  41
  42 #define em28xx_coredbg(fmt, arg...) do {\
  43         if (core_debug) \
  44                 printk(KERN_INFO "%s %s :"fmt, \
  45                          dev->name, __func__ , ##arg); } while (0)
  46
  47 static unsigned int reg_debug;
  48 module_param(reg_debug, int, 0644);
  49 MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
  50
  51 #define em28xx_regdbg(fmt, arg...) do {\
  52         if (reg_debug) \
  53                 printk(KERN_INFO "%s %s :"fmt, \
  54                          dev->name, __func__ , ##arg); } while (0)
  55
  56 static int alt;
  57 module_param(alt, int, 0644);
  58 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
  59
  60 static unsigned int disable_vbi;
  61 module_param(disable_vbi, int, 0644);
  62 MODULE_PARM_DESC(disable_vbi, "disable vbi support");
  63
  64 /* FIXME */
  65 #define em28xx_isocdbg(fmt, arg...) do {\
  66         if (core_debug) \
  67                 printk(KERN_INFO "%s %s :"fmt, \
  68                          dev->name, __func__ , ##arg); } while (0)
  69
  70 /*
  71  * em28xx_read_reg_req()
  72  * reads data from the usb device specifying bRequest
  73  */
  74 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
  75                                    char *buf, int len)
  76 {
  77         int ret;
  78         int pipe = usb_rcvctrlpipe(dev->udev, 0);
  79
  80         if (dev->disconnected)
  81                 return -ENODEV;
  82
  83         if (len > URB_MAX_CTRL_SIZE)
  84                 return -EINVAL;
  85
  86         if (reg_debug) {
  87                 printk(KERN_DEBUG "(pipe 0x%08x): "
  88                         "IN:  %02x %02x %02x %02x %02x %02x %02x %02x ",
  89                         pipe,
  90                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  91                         req, 0, 0,
  92                         reg & 0xff, reg >> 8,
  93                         len & 0xff, len >> 8);
  94         }
  95
  96         mutex_lock(&dev->ctrl_urb_lock);
  97         ret = usb_control_msg(dev->udev, pipe, req,
  98                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  99                               0x0000, reg, dev->urb_buf, len, HZ);
 100         if (ret < 0) {
 101                 if (reg_debug)
 102                         printk(" failed!\n");
 103                 mutex_unlock(&dev->ctrl_urb_lock);
 104                 return usb_translate_errors(ret);
 105         }
 106
 107         if (len)
 108                 memcpy(buf, dev->urb_buf, len);
 109
 110         mutex_unlock(&dev->ctrl_urb_lock);
 111
 112         if (reg_debug) {
 113                 int byte;
 114
 115                 printk("<<<");
 116                 for (byte = 0; byte < len; byte++)
 117                         printk(" %02x", (unsigned char)buf[byte]);
 118                 printk("\n");
 119         }
 120
 121         return ret;
 122 }
 123
 124 /*
 125  * em28xx_read_reg_req()
 126  * reads data from the usb device specifying bRequest
 127  */
 128 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
 129 {
 130         int ret;
 131         u8 val;
 132
 133         ret = em28xx_read_reg_req_len(dev, req, reg, &val, 1);
 134         if (ret < 0)
 135                 return ret;
 136
 137         return val;
 138 }
 139
 140 int em28xx_read_reg(struct em28xx *dev, u16 reg)
 141 {
 142         return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
 143 }
 144 EXPORT_SYMBOL_GPL(em28xx_read_reg);
 145
 146 /*
 147  * em28xx_write_regs_req()
 148  * sends data to the usb device, specifying bRequest
 149  */
 150 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
 151                                  int len)
 152 {
 153         int ret;
 154         int pipe = usb_sndctrlpipe(dev->udev, 0);
 155
 156         if (dev->disconnected)
 157                 return -ENODEV;
 158
 159         if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
 160                 return -EINVAL;
 161
 162         if (reg_debug) {
 163                 int byte;
 164
 165                 printk(KERN_DEBUG "(pipe 0x%08x): "
 166                         "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>",
 167                         pipe,
 168                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 169                         req, 0, 0,
 170                         reg & 0xff, reg >> 8,
 171                         len & 0xff, len >> 8);
 172
 173                 for (byte = 0; byte < len; byte++)
 174                         printk(" %02x", (unsigned char)buf[byte]);
 175                 printk("\n");
 176         }
 177
 178         mutex_lock(&dev->ctrl_urb_lock);
 179         memcpy(dev->urb_buf, buf, len);
 180         ret = usb_control_msg(dev->udev, pipe, req,
 181                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 182                               0x0000, reg, dev->urb_buf, len, HZ);
 183         mutex_unlock(&dev->ctrl_urb_lock);
 184
 185         if (ret < 0)
 186                 return usb_translate_errors(ret);
 187
 188         if (dev->wait_after_write)
 189                 msleep(dev->wait_after_write);
 190
 191         return ret;
 192 }
 193
 194 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
 195 {
 196         return em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
 197 }
 198 EXPORT_SYMBOL_GPL(em28xx_write_regs);
 199
 200 /* Write a single register */
 201 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
 202 {
 203         return em28xx_write_regs(dev, reg, &val, 1);
 204 }
 205 EXPORT_SYMBOL_GPL(em28xx_write_reg);
 206
 207 /*
 208  * em28xx_write_reg_bits()
 209  * sets only some bits (specified by bitmask) of a register, by first reading
 210  * the actual value
 211  */
 212 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
 213                                  u8 bitmask)
 214 {
 215         int oldval;
 216         u8 newval;
 217
 218         oldval = em28xx_read_reg(dev, reg);
 219         if (oldval < 0)
 220                 return oldval;
 221
 222         newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
 223
 224         return em28xx_write_regs(dev, reg, &newval, 1);
 225 }
 226 EXPORT_SYMBOL_GPL(em28xx_write_reg_bits);
 227
 228 /*
 229  * em28xx_is_ac97_ready()
 230  * Checks if ac97 is ready
 231  */
 232 static int em28xx_is_ac97_ready(struct em28xx *dev)
 233 {
 234         int ret, i;
 235
 236         /* Wait up to 50 ms for AC97 command to complete */
 237         for (i = 0; i < 10; i++, msleep(5)) {
 238                 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
 239                 if (ret < 0)
 240                         return ret;
 241
 242                 if (!(ret & 0x01))
 243                         return 0;
 244         }
 245
 246         em28xx_warn("AC97 command still being executed: not handled properly!\n");
 247         return -EBUSY;
 248 }
 249
 250 /*
 251  * em28xx_read_ac97()
 252  * write a 16 bit value to the specified AC97 address (LSB first!)
 253  */
 254 int em28xx_read_ac97(struct em28xx *dev, u8 reg)
 255 {
 256         int ret;
 257         u8 addr = (reg & 0x7f) | 0x80;
 258         u16 val;
 259
 260         ret = em28xx_is_ac97_ready(dev);
 261         if (ret < 0)
 262                 return ret;
 263
 264         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 265         if (ret < 0)
 266                 return ret;
 267
 268         ret = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R40_AC97LSB,
 269                                            (u8 *)&val, sizeof(val));
 270
 271         if (ret < 0)
 272                 return ret;
 273         return le16_to_cpu(val);
 274 }
 275 EXPORT_SYMBOL_GPL(em28xx_read_ac97);
 276
 277 /*
 278  * em28xx_write_ac97()
 279  * write a 16 bit value to the specified AC97 address (LSB first!)
 280  */
 281 int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
 282 {
 283         int ret;
 284         u8 addr = reg & 0x7f;
 285         __le16 value;
 286
 287         value = cpu_to_le16(val);
 288
 289         ret = em28xx_is_ac97_ready(dev);
 290         if (ret < 0)
 291                 return ret;
 292
 293         ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *) &value, 2);
 294         if (ret < 0)
 295                 return ret;
 296
 297         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 298         if (ret < 0)
 299                 return ret;
 300
 301         return 0;
 302 }
 303 EXPORT_SYMBOL_GPL(em28xx_write_ac97);
 304
 305 struct em28xx_vol_itable {
 306         enum em28xx_amux mux;
 307         u8               reg;
 308 };
 309
 310 static struct em28xx_vol_itable inputs[] = {
 311         { EM28XX_AMUX_VIDEO,    AC97_VIDEO      },
 312         { EM28XX_AMUX_LINE_IN,  AC97_LINE       },
 313         { EM28XX_AMUX_PHONE,    AC97_PHONE      },
 314         { EM28XX_AMUX_MIC,      AC97_MIC        },
 315         { EM28XX_AMUX_CD,       AC97_CD         },
 316         { EM28XX_AMUX_AUX,      AC97_AUX        },
 317         { EM28XX_AMUX_PCM_OUT,  AC97_PCM        },
 318 };
 319
 320 static int set_ac97_input(struct em28xx *dev)
 321 {
 322         int ret, i;
 323         enum em28xx_amux amux = dev->ctl_ainput;
 324
 325         /* EM28XX_AMUX_VIDEO2 is a special case used to indicate that
 326            em28xx should point to LINE IN, while AC97 should use VIDEO
 327          */
 328         if (amux == EM28XX_AMUX_VIDEO2)
 329                 amux = EM28XX_AMUX_VIDEO;
 330
 331         /* Mute all entres but the one that were selected */
 332         for (i = 0; i < ARRAY_SIZE(inputs); i++) {
 333                 if (amux == inputs[i].mux)
 334                         ret = em28xx_write_ac97(dev, inputs[i].reg, 0x0808);
 335                 else
 336                         ret = em28xx_write_ac97(dev, inputs[i].reg, 0x8000);
 337
 338                 if (ret < 0)
 339                         em28xx_warn("couldn't setup AC97 register %d\n",
 340                                      inputs[i].reg);
 341         }
 342         return 0;
 343 }
 344
 345 static int em28xx_set_audio_source(struct em28xx *dev)
 346 {
 347         int ret;
 348         u8 input;
 349
 350         if (dev->board.is_em2800) {
 351                 if (dev->ctl_ainput == EM28XX_AMUX_VIDEO)
 352                         input = EM2800_AUDIO_SRC_TUNER;
 353                 else
 354                         input = EM2800_AUDIO_SRC_LINE;
 355
 356                 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
 357                 if (ret < 0)
 358                         return ret;
 359         }
 360
 361         if (dev->board.has_msp34xx)
 362                 input = EM28XX_AUDIO_SRC_TUNER;
 363         else {
 364                 switch (dev->ctl_ainput) {
 365                 case EM28XX_AMUX_VIDEO:
 366                         input = EM28XX_AUDIO_SRC_TUNER;
 367                         break;
 368                 default:
 369                         input = EM28XX_AUDIO_SRC_LINE;
 370                         break;
 371                 }
 372         }
 373
 374         if (dev->board.mute_gpio && dev->mute)
 375                 em28xx_gpio_set(dev, dev->board.mute_gpio);
 376         else
 377                 em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
 378
 379         ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
 380         if (ret < 0)
 381                 return ret;
 382         msleep(5);
 383
 384         switch (dev->audio_mode.ac97) {
 385         case EM28XX_NO_AC97:
 386                 break;
 387         default:
 388                 ret = set_ac97_input(dev);
 389         }
 390
 391         return ret;
 392 }
 393
 394 struct em28xx_vol_otable {
 395         enum em28xx_aout mux;
 396         u8               reg;
 397 };
 398
 399 static const struct em28xx_vol_otable outputs[] = {
 400         { EM28XX_AOUT_MASTER, AC97_MASTER               },
 401         { EM28XX_AOUT_LINE,   AC97_HEADPHONE            },
 402         { EM28XX_AOUT_MONO,   AC97_MASTER_MONO          },
 403         { EM28XX_AOUT_LFE,    AC97_CENTER_LFE_MASTER    },
 404         { EM28XX_AOUT_SURR,   AC97_SURROUND_MASTER      },
 405 };
 406
 407 int em28xx_audio_analog_set(struct em28xx *dev)
 408 {
 409         int ret, i;
 410         u8 xclk;
 411
 412         if (!dev->audio_mode.has_audio)
 413                 return 0;
 414
 415         /* It is assumed that all devices use master volume for output.
 416            It would be possible to use also line output.
 417          */
 418         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 419                 /* Mute all outputs */
 420                 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
 421                         ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
 422                         if (ret < 0)
 423                                 em28xx_warn("couldn't setup AC97 register %d\n",
 424                                      outputs[i].reg);
 425                 }
 426         }
 427
 428         xclk = dev->board.xclk & 0x7f;
 429         if (!dev->mute)
 430                 xclk |= EM28XX_XCLK_AUDIO_UNMUTE;
 431
 432         ret = em28xx_write_reg(dev, EM28XX_R0F_XCLK, xclk);
 433         if (ret < 0)
 434                 return ret;
 435         msleep(10);
 436
 437         /* Selects the proper audio input */
 438         ret = em28xx_set_audio_source(dev);
 439
 440         /* Sets volume */
 441         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 442                 int vol;
 443
 444                 em28xx_write_ac97(dev, AC97_POWERDOWN, 0x4200);
 445                 em28xx_write_ac97(dev, AC97_EXTENDED_STATUS, 0x0031);
 446                 em28xx_write_ac97(dev, AC97_PCM_LR_ADC_RATE, 0xbb80);
 447
 448                 /* LSB: left channel - both channels with the same level */
 449                 vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);
 450
 451                 /* Mute device, if needed */
 452                 if (dev->mute)
 453                         vol |= 0x8000;
 454
 455                 /* Sets volume */
 456                 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
 457                         if (dev->ctl_aoutput & outputs[i].mux)
 458                                 ret = em28xx_write_ac97(dev, outputs[i].reg,
 459                                                         vol);
 460                         if (ret < 0)
 461                                 em28xx_warn("couldn't setup AC97 register %d\n",
 462                                      outputs[i].reg);
 463                 }
 464
 465                 if (dev->ctl_aoutput & EM28XX_AOUT_PCM_IN) {
 466                         int sel = ac97_return_record_select(dev->ctl_aoutput);
 467
 468                         /* Use the same input for both left and right
 469                            channels */
 470                         sel |= (sel << 8);
 471
 472                         em28xx_write_ac97(dev, AC97_REC_SEL, sel);
 473                 }
 474         }
 475
 476         return ret;
 477 }
 478 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
 479
 480 int em28xx_audio_setup(struct em28xx *dev)
 481 {
 482         int vid1, vid2, feat, cfg;
 483         u32 vid;
 484
 485         if (dev->chip_id == CHIP_ID_EM2870 || dev->chip_id == CHIP_ID_EM2874
 486                 || dev->chip_id == CHIP_ID_EM28174) {
 487                 /* Digital only device - don't load any alsa module */
 488                 dev->audio_mode.has_audio = false;
 489                 dev->has_audio_class = false;
 490                 dev->has_alsa_audio = false;
 491                 return 0;
 492         }
 493
 494         dev->audio_mode.has_audio = true;
 495
 496         /* See how this device is configured */
 497         cfg = em28xx_read_reg(dev, EM28XX_R00_CHIPCFG);
 498         em28xx_info("Config register raw data: 0x%02x\n", cfg);
 499         if (cfg < 0) {
 500                 /* Register read error?  */
 501                 cfg = EM28XX_CHIPCFG_AC97; /* Be conservative */
 502         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) == 0x00) {
 503                 /* The device doesn't have vendor audio at all */
 504                 dev->has_alsa_audio = false;
 505                 dev->audio_mode.has_audio = false;
 506                 return 0;
 507         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
 508                    EM28XX_CHIPCFG_I2S_3_SAMPRATES) {
 509                 em28xx_info("I2S Audio (3 sample rates)\n");
 510                 dev->audio_mode.i2s_3rates = 1;
 511         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
 512                    EM28XX_CHIPCFG_I2S_5_SAMPRATES) {
 513                 em28xx_info("I2S Audio (5 sample rates)\n");
 514                 dev->audio_mode.i2s_5rates = 1;
 515         }
 516
 517         if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) != EM28XX_CHIPCFG_AC97) {
 518                 /* Skip the code that does AC97 vendor detection */
 519                 dev->audio_mode.ac97 = EM28XX_NO_AC97;
 520                 goto init_audio;
 521         }
 522
 523         dev->audio_mode.ac97 = EM28XX_AC97_OTHER;
 524
 525         vid1 = em28xx_read_ac97(dev, AC97_VENDOR_ID1);
 526         if (vid1 < 0) {
 527                 /*
 528                  * Device likely doesn't support AC97
 529                  * Note: (some) em2800 devices without eeprom reports 0x91 on
 530                  *       CHIPCFG register, even not having an AC97 chip
 531                  */
 532                 em28xx_warn("AC97 chip type couldn't be determined\n");
 533                 dev->audio_mode.ac97 = EM28XX_NO_AC97;
 534                 dev->has_alsa_audio = false;
 535                 dev->audio_mode.has_audio = false;
 536                 goto init_audio;
 537         }
 538
 539         vid2 = em28xx_read_ac97(dev, AC97_VENDOR_ID2);
 540         if (vid2 < 0)
 541                 goto init_audio;
 542
 543         vid = vid1 << 16 | vid2;
 544
 545         dev->audio_mode.ac97_vendor_id = vid;
 546         em28xx_warn("AC97 vendor ID = 0x%08x\n", vid);
 547
 548         feat = em28xx_read_ac97(dev, AC97_RESET);
 549         if (feat < 0)
 550                 goto init_audio;
 551
 552         dev->audio_mode.ac97_feat = feat;
 553         em28xx_warn("AC97 features = 0x%04x\n", feat);
 554
 555         /* Try to identify what audio processor we have */
 556         if (((vid == 0xffffffff) || (vid == 0x83847650)) && (feat == 0x6a90))
 557                 dev->audio_mode.ac97 = EM28XX_AC97_EM202;
 558         else if ((vid >> 8) == 0x838476)
 559                 dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
 560
 561 init_audio:
 562         /* Reports detected AC97 processor */
 563         switch (dev->audio_mode.ac97) {
 564         case EM28XX_NO_AC97:
 565                 em28xx_info("No AC97 audio processor\n");
 566                 break;
 567         case EM28XX_AC97_EM202:
 568                 em28xx_info("Empia 202 AC97 audio processor detected\n");
 569                 break;
 570         case EM28XX_AC97_SIGMATEL:
 571                 em28xx_info("Sigmatel audio processor detected(stac 97%02x)\n",
 572                             dev->audio_mode.ac97_vendor_id & 0xff);
 573                 break;
 574         case EM28XX_AC97_OTHER:
 575                 em28xx_warn("Unknown AC97 audio processor detected!\n");
 576                 break;
 577         default:
 578                 break;
 579         }
 580
 581         return em28xx_audio_analog_set(dev);
 582 }
 583 EXPORT_SYMBOL_GPL(em28xx_audio_setup);
 584
 585 int em28xx_colorlevels_set_default(struct em28xx *dev)
 586 {
 587         em28xx_write_reg(dev, EM28XX_R20_YGAIN, CONTRAST_DEFAULT);
 588         em28xx_write_reg(dev, EM28XX_R21_YOFFSET, BRIGHTNESS_DEFAULT);
 589         em28xx_write_reg(dev, EM28XX_R22_UVGAIN, SATURATION_DEFAULT);
 590         em28xx_write_reg(dev, EM28XX_R23_UOFFSET, BLUE_BALANCE_DEFAULT);
 591         em28xx_write_reg(dev, EM28XX_R24_VOFFSET, RED_BALANCE_DEFAULT);
 592         em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, SHARPNESS_DEFAULT);
 593
 594         em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
 595         em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
 596         em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
 597         em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
 598         em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
 599         em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
 600         return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
 601 }
 602
 603 int em28xx_capture_start(struct em28xx *dev, int start)
 604 {
 605         int rc;
 606
 607         if (dev->chip_id == CHIP_ID_EM2874 ||
 608             dev->chip_id == CHIP_ID_EM2884 ||
 609             dev->chip_id == CHIP_ID_EM28174) {
 610                 /* The Transport Stream Enable Register moved in em2874 */
 611                 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
 612                                            start ?
 613                                                EM2874_TS1_CAPTURE_ENABLE : 0x00,
 614                                            EM2874_TS1_CAPTURE_ENABLE);
 615         } else {
 616                 /* FIXME: which is the best order? */
 617                 /* video registers are sampled by VREF */
 618                 rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
 619                                            start ? 0x10 : 0x00, 0x10);
 620                 if (rc < 0)
 621                         return rc;
 622
 623                 if (start) {
 624                         if (dev->board.is_webcam)
 625                                 rc = em28xx_write_reg(dev, 0x13, 0x0c);
 626
 627                         /* Enable video capture */
 628                         rc = em28xx_write_reg(dev, 0x48, 0x00);
 629
 630                         if (dev->mode == EM28XX_ANALOG_MODE)
 631                                 rc = em28xx_write_reg(dev,
 632                                                     EM28XX_R12_VINENABLE, 0x67);
 633                         else
 634                                 rc = em28xx_write_reg(dev,
 635                                                     EM28XX_R12_VINENABLE, 0x37);
 636
 637                         msleep(6);
 638                 } else {
 639                         /* disable video capture */
 640                         rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
 641                 }
 642         }
 643
 644         if (rc < 0)
 645                 return rc;
 646
 647         /* Switch (explicitly controlled) analog capturing LED on/off */
 648         if ((dev->mode == EM28XX_ANALOG_MODE)
 649             && dev->board.analog_capturing_led) {
 650                 struct em28xx_led *led = dev->board.analog_capturing_led;
 651                 em28xx_write_reg_bits(dev, led->gpio_reg,
 652                                       (!start ^ led->inverted) ?
 653                                       ~led->gpio_mask : led->gpio_mask,
 654                                       led->gpio_mask);
 655         }
 656
 657         return rc;
 658 }
 659
 660 int em28xx_vbi_supported(struct em28xx *dev)
 661 {
 662         /* Modprobe option to manually disable */
 663         if (disable_vbi == 1)
 664                 return 0;
 665
 666         if (dev->board.is_webcam)
 667                 return 0;
 668
 669         /* FIXME: check subdevices for VBI support */
 670
 671         if (dev->chip_id == CHIP_ID_EM2860 ||
 672             dev->chip_id == CHIP_ID_EM2883)
 673                 return 1;
 674
 675         /* Version of em28xx that does not support VBI */
 676         return 0;
 677 }
 678
 679 int em28xx_set_outfmt(struct em28xx *dev)
 680 {
 681         int ret;
 682         u8 fmt, vinctrl;
 683
 684         fmt = dev->format->reg;
 685         if (!dev->is_em25xx)
 686                 fmt |= 0x20;
 687         /*
 688          * NOTE: it's not clear if this is really needed !
 689          * The datasheets say bit 5 is a reserved bit and devices seem to work
 690          * fine without it. But the Windows driver sets it for em2710/50+em28xx
 691          * devices and we've always been setting it, too.
 692          *
 693          * em2765 (em25xx, em276x/7x/8x) devices do NOT work with this bit set,
 694          * it's likely used for an additional (compressed ?) format there.
 695          */
 696         ret = em28xx_write_reg(dev, EM28XX_R27_OUTFMT, fmt);
 697         if (ret < 0)
 698                 return ret;
 699
 700         ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, dev->vinmode);
 701         if (ret < 0)
 702                 return ret;
 703
 704         vinctrl = dev->vinctl;
 705         if (em28xx_vbi_supported(dev) == 1) {
 706                 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
 707                 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
 708                 em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, dev->vbi_width/4);
 709                 em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, dev->vbi_height);
 710                 if (dev->norm & V4L2_STD_525_60) {
 711                         /* NTSC */
 712                         em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
 713                 } else if (dev->norm & V4L2_STD_625_50) {
 714                         /* PAL */
 715                         em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
 716                 }
 717         }
 718
 719         return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
 720 }
 721
 722 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
 723                                   u8 ymin, u8 ymax)
 724 {
 725         em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
 726                         xmin, ymin, xmax, ymax);
 727
 728         em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
 729         em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
 730         em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
 731         return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
 732 }
 733
 734 static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
 735                                    u16 width, u16 height)
 736 {
 737         u8 cwidth = width >> 2;
 738         u8 cheight = height >> 2;
 739         u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
 740         /* NOTE: size limit: 2047x1023 = 2MPix */
 741
 742         em28xx_coredbg("capture area set to (%d,%d): %dx%d\n",
 743                        hstart, vstart,
 744                        ((overflow & 2) << 9 | cwidth << 2),
 745                        ((overflow & 1) << 10 | cheight << 2));
 746
 747         em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
 748         em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
 749         em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
 750         em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
 751         em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
 752
 753         /* FIXME: function/meaning of these registers ? */
 754         /* FIXME: align width+height to multiples of 4 ?! */
 755         if (dev->is_em25xx) {
 756                 em28xx_write_reg(dev, 0x34, width >> 4);
 757                 em28xx_write_reg(dev, 0x35, height >> 4);
 758         }
 759 }
 760
 761 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 762 {
 763         u8 mode;
 764         /* the em2800 scaler only supports scaling down to 50% */
 765
 766         if (dev->board.is_em2800) {
 767                 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
 768         } else {
 769                 u8 buf[2];
 770
 771                 buf[0] = h;
 772                 buf[1] = h >> 8;
 773                 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
 774
 775                 buf[0] = v;
 776                 buf[1] = v >> 8;
 777                 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
 778                 /* it seems that both H and V scalers must be active
 779                    to work correctly */
 780                 mode = (h || v) ? 0x30 : 0x00;
 781         }
 782         return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
 783 }
 784
 785 /* FIXME: this only function read values from dev */
 786 int em28xx_resolution_set(struct em28xx *dev)
 787 {
 788         int width, height;
 789         width = norm_maxw(dev);
 790         height = norm_maxh(dev);
 791
 792         /* Properly setup VBI */
 793         dev->vbi_width = 720;
 794         if (dev->norm & V4L2_STD_525_60)
 795                 dev->vbi_height = 12;
 796         else
 797                 dev->vbi_height = 18;
 798
 799         em28xx_set_outfmt(dev);
 800
 801         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
 802
 803         /* If we don't set the start position to 2 in VBI mode, we end up
 804            with line 20/21 being YUYV encoded instead of being in 8-bit
 805            greyscale.  The core of the issue is that line 21 (and line 23 for
 806            PAL WSS) are inside of active video region, and as a result they
 807            get the pixelformatting associated with that area.  So by cropping
 808            it out, we end up with the same format as the rest of the VBI
 809            region */
 810         if (em28xx_vbi_supported(dev) == 1)
 811                 em28xx_capture_area_set(dev, 0, 2, width, height);
 812         else
 813                 em28xx_capture_area_set(dev, 0, 0, width, height);
 814
 815         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 816 }
 817
 818 /* Set USB alternate setting for analog video */
 819 int em28xx_set_alternate(struct em28xx *dev)
 820 {
 821         int errCode;
 822         int i;
 823         unsigned int min_pkt_size = dev->width * 2 + 4;
 824
 825         /* NOTE: for isoc transfers, only alt settings > 0 are allowed
 826                  bulk transfers seem to work only with alt=0 ! */
 827         dev->alt = 0;
 828         if ((alt > 0) && (alt < dev->num_alt)) {
 829                 em28xx_coredbg("alternate forced to %d\n", dev->alt);
 830                 dev->alt = alt;
 831                 goto set_alt;
 832         }
 833         if (dev->analog_xfer_bulk)
 834                 goto set_alt;
 835
 836         /* When image size is bigger than a certain value,
 837            the frame size should be increased, otherwise, only
 838            green screen will be received.
 839          */
 840         if (dev->width * 2 * dev->height > 720 * 240 * 2)
 841                 min_pkt_size *= 2;
 842
 843         for (i = 0; i < dev->num_alt; i++) {
 844                 /* stop when the selected alt setting offers enough bandwidth */
 845                 if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
 846                         dev->alt = i;
 847                         break;
 848                 /* otherwise make sure that we end up with the maximum bandwidth
 849                    because the min_pkt_size equation might be wrong...
 850                 */
 851                 } else if (dev->alt_max_pkt_size_isoc[i] >
 852                            dev->alt_max_pkt_size_isoc[dev->alt])
 853                         dev->alt = i;
 854         }
 855
 856 set_alt:
 857         /* NOTE: for bulk transfers, we need to call usb_set_interface()
 858          * even if the previous settings were the same. Otherwise streaming
 859          * fails with all urbs having status = -EOVERFLOW ! */
 860         if (dev->analog_xfer_bulk) {
 861                 dev->max_pkt_size = 512; /* USB 2.0 spec */
 862                 dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
 863         } else { /* isoc */
 864                 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
 865                                min_pkt_size, dev->alt);
 866                 dev->max_pkt_size =
 867                                   dev->alt_max_pkt_size_isoc[dev->alt];
 868                 dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
 869         }
 870         em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
 871                        dev->alt, dev->max_pkt_size);
 872         errCode = usb_set_interface(dev->udev, 0, dev->alt);
 873         if (errCode < 0) {
 874                 em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
 875                               dev->alt, errCode);
 876                 return errCode;
 877         }
 878         return 0;
 879 }
 880
 881 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
 882 {
 883         int rc = 0;
 884
 885         if (!gpio)
 886                 return rc;
 887
 888         if (dev->mode != EM28XX_SUSPEND) {
 889                 em28xx_write_reg(dev, 0x48, 0x00);
 890                 if (dev->mode == EM28XX_ANALOG_MODE)
 891                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
 892                 else
 893                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
 894                 msleep(6);
 895         }
 896
 897         /* Send GPIO reset sequences specified at board entry */
 898         while (gpio->sleep >= 0) {
 899                 if (gpio->reg >= 0) {
 900                         rc = em28xx_write_reg_bits(dev,
 901                                                    gpio->reg,
 902                                                    gpio->val,
 903                                                    gpio->mask);
 904                         if (rc < 0)
 905                                 return rc;
 906                 }
 907                 if (gpio->sleep > 0)
 908                         msleep(gpio->sleep);
 909
 910                 gpio++;
 911         }
 912         return rc;
 913 }
 914 EXPORT_SYMBOL_GPL(em28xx_gpio_set);
 915
 916 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
 917 {
 918         if (dev->mode == set_mode)
 919                 return 0;
 920
 921         if (set_mode == EM28XX_SUSPEND) {
 922                 dev->mode = set_mode;
 923
 924                 /* FIXME: add suspend support for ac97 */
 925
 926                 return em28xx_gpio_set(dev, dev->board.suspend_gpio);
 927         }
 928
 929         dev->mode = set_mode;
 930
 931         if (dev->mode == EM28XX_DIGITAL_MODE)
 932                 return em28xx_gpio_set(dev, dev->board.dvb_gpio);
 933         else
 934                 return em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
 935 }
 936 EXPORT_SYMBOL_GPL(em28xx_set_mode);
 937
 938 /* ------------------------------------------------------------------
 939         URB control
 940    ------------------------------------------------------------------*/
 941
 942 /*
 943  * URB completion handler for isoc/bulk transfers
 944  */
 945 static void em28xx_irq_callback(struct urb *urb)
 946 {
 947         struct em28xx *dev = urb->context;
 948         int i;
 949
 950         switch (urb->status) {
 951         case 0:             /* success */
 952         case -ETIMEDOUT:    /* NAK */
 953                 break;
 954         case -ECONNRESET:   /* kill */
 955         case -ENOENT:
 956         case -ESHUTDOWN:
 957                 return;
 958         default:            /* error */
 959                 em28xx_isocdbg("urb completition error %d.\n", urb->status);
 960                 break;
 961         }
 962
 963         /* Copy data from URB */
 964         spin_lock(&dev->slock);
 965         dev->usb_ctl.urb_data_copy(dev, urb);
 966         spin_unlock(&dev->slock);
 967
 968         /* Reset urb buffers */
 969         for (i = 0; i < urb->number_of_packets; i++) {
 970                 /* isoc only (bulk: number_of_packets = 0) */
 971                 urb->iso_frame_desc[i].status = 0;
 972                 urb->iso_frame_desc[i].actual_length = 0;
 973         }
 974         urb->status = 0;
 975
 976         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 977         if (urb->status) {
 978                 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
 979                                urb->status);
 980         }
 981 }
 982
 983 /*
 984  * Stop and Deallocate URBs
 985  */
 986 void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode)
 987 {
 988         struct urb *urb;
 989         struct em28xx_usb_bufs *usb_bufs;
 990         int i;
 991
 992         em28xx_isocdbg("em28xx: called em28xx_uninit_usb_xfer in mode %d\n",
 993                        mode);
 994
 995         if (mode == EM28XX_DIGITAL_MODE)
 996                 usb_bufs = &dev->usb_ctl.digital_bufs;
 997         else
 998                 usb_bufs = &dev->usb_ctl.analog_bufs;
 999
1000         for (i = 0; i < usb_bufs->num_bufs; i++) {
1001                 urb = usb_bufs->urb[i];
1002                 if (urb) {
1003                         if (!irqs_disabled())
1004                                 usb_kill_urb(urb);
1005                         else
1006                                 usb_unlink_urb(urb);
1007
1008                         if (usb_bufs->transfer_buffer[i]) {
1009                                 usb_free_coherent(dev->udev,
1010                                         urb->transfer_buffer_length,
1011                                         usb_bufs->transfer_buffer[i],
1012                                         urb->transfer_dma);
1013                         }
1014                         usb_free_urb(urb);
1015                         usb_bufs->urb[i] = NULL;
1016                 }
1017                 usb_bufs->transfer_buffer[i] = NULL;
1018         }
1019
1020         kfree(usb_bufs->urb);
1021         kfree(usb_bufs->transfer_buffer);
1022
1023         usb_bufs->urb = NULL;
1024         usb_bufs->transfer_buffer = NULL;
1025         usb_bufs->num_bufs = 0;
1026
1027         em28xx_capture_start(dev, 0);
1028 }
1029 EXPORT_SYMBOL_GPL(em28xx_uninit_usb_xfer);
1030
1031 /*
1032  * Stop URBs
1033  */
1034 void em28xx_stop_urbs(struct em28xx *dev)
1035 {
1036         int i;
1037         struct urb *urb;
1038         struct em28xx_usb_bufs *isoc_bufs = &dev->usb_ctl.digital_bufs;
1039
1040         em28xx_isocdbg("em28xx: called em28xx_stop_urbs\n");
1041
1042         for (i = 0; i < isoc_bufs->num_bufs; i++) {
1043                 urb = isoc_bufs->urb[i];
1044                 if (urb) {
1045                         if (!irqs_disabled())
1046                                 usb_kill_urb(urb);
1047                         else
1048                                 usb_unlink_urb(urb);
1049                 }
1050         }
1051
1052         em28xx_capture_start(dev, 0);
1053 }
1054 EXPORT_SYMBOL_GPL(em28xx_stop_urbs);
1055
1056 /*
1057  * Allocate URBs
1058  */
1059 int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
1060                       int num_bufs, int max_pkt_size, int packet_multiplier)
1061 {
1062         struct em28xx_usb_bufs *usb_bufs;
1063         int i;
1064         int sb_size, pipe;
1065         struct urb *urb;
1066         int j, k;
1067
1068         em28xx_isocdbg("em28xx: called em28xx_alloc_isoc in mode %d\n", mode);
1069
1070         /* Check mode and if we have an endpoint for the selected
1071            transfer type, select buffer                          */
1072         if (mode == EM28XX_DIGITAL_MODE) {
1073                 if ((xfer_bulk && !dev->dvb_ep_bulk) ||
1074                     (!xfer_bulk && !dev->dvb_ep_isoc)) {
1075                         em28xx_errdev("no endpoint for DVB mode and transfer type %d\n",
1076                                       xfer_bulk > 0);
1077                         return -EINVAL;
1078                 }
1079                 usb_bufs = &dev->usb_ctl.digital_bufs;
1080         } else if (mode == EM28XX_ANALOG_MODE) {
1081                 if ((xfer_bulk && !dev->analog_ep_bulk) ||
1082                     (!xfer_bulk && !dev->analog_ep_isoc)) {
1083                         em28xx_errdev("no endpoint for analog mode and transfer type %d\n",
1084                                        xfer_bulk > 0);
1085                         return -EINVAL;
1086                 }
1087                 usb_bufs = &dev->usb_ctl.analog_bufs;
1088         } else {
1089                 em28xx_errdev("invalid mode selected\n");
1090                 return -EINVAL;
1091         }
1092
1093         /* De-allocates all pending stuff */
1094         em28xx_uninit_usb_xfer(dev, mode);
1095
1096         usb_bufs->num_bufs = num_bufs;
1097
1098         usb_bufs->urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
1099         if (!usb_bufs->urb) {
1100                 em28xx_errdev("cannot alloc memory for usb buffers\n");
1101                 return -ENOMEM;
1102         }
1103
1104         usb_bufs->transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
1105                                              GFP_KERNEL);
1106         if (!usb_bufs->transfer_buffer) {
1107                 em28xx_errdev("cannot allocate memory for usb transfer\n");
1108                 kfree(usb_bufs->urb);
1109                 return -ENOMEM;
1110         }
1111
1112         usb_bufs->max_pkt_size = max_pkt_size;
1113         if (xfer_bulk)
1114                 usb_bufs->num_packets = 0;
1115         else
1116                 usb_bufs->num_packets = packet_multiplier;
1117         dev->usb_ctl.vid_buf = NULL;
1118         dev->usb_ctl.vbi_buf = NULL;
1119
1120         sb_size = packet_multiplier * usb_bufs->max_pkt_size;
1121
1122         /* allocate urbs and transfer buffers */
1123         for (i = 0; i < usb_bufs->num_bufs; i++) {
1124                 urb = usb_alloc_urb(usb_bufs->num_packets, GFP_KERNEL);
1125                 if (!urb) {
1126                         em28xx_err("cannot alloc usb_ctl.urb %i\n", i);
1127                         em28xx_uninit_usb_xfer(dev, mode);
1128                         return -ENOMEM;
1129                 }
1130                 usb_bufs->urb[i] = urb;
1131
1132                 usb_bufs->transfer_buffer[i] = usb_alloc_coherent(dev->udev,
1133                         sb_size, GFP_KERNEL, &urb->transfer_dma);
1134                 if (!usb_bufs->transfer_buffer[i]) {
1135                         em28xx_err("unable to allocate %i bytes for transfer"
1136                                         " buffer %i%s\n",
1137                                         sb_size, i,
1138                                         in_interrupt() ? " while in int" : "");
1139                         em28xx_uninit_usb_xfer(dev, mode);
1140                         return -ENOMEM;
1141                 }
1142                 memset(usb_bufs->transfer_buffer[i], 0, sb_size);
1143
1144                 if (xfer_bulk) { /* bulk */
1145                         pipe = usb_rcvbulkpipe(dev->udev,
1146                                                mode == EM28XX_ANALOG_MODE ?
1147                                                dev->analog_ep_bulk :
1148                                                dev->dvb_ep_bulk);
1149                         usb_fill_bulk_urb(urb, dev->udev, pipe,
1150                                           usb_bufs->transfer_buffer[i], sb_size,
1151                                           em28xx_irq_callback, dev);
1152                         urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1153                 } else { /* isoc */
1154                         pipe = usb_rcvisocpipe(dev->udev,
1155                                                mode == EM28XX_ANALOG_MODE ?
1156                                                dev->analog_ep_isoc :
1157                                                dev->dvb_ep_isoc);
1158                         usb_fill_int_urb(urb, dev->udev, pipe,
1159                                          usb_bufs->transfer_buffer[i], sb_size,
1160                                          em28xx_irq_callback, dev, 1);
1161                         urb->transfer_flags = URB_ISO_ASAP |
1162                                               URB_NO_TRANSFER_DMA_MAP;
1163                         k = 0;
1164                         for (j = 0; j < usb_bufs->num_packets; j++) {
1165                                 urb->iso_frame_desc[j].offset = k;
1166                                 urb->iso_frame_desc[j].length =
1167                                                         usb_bufs->max_pkt_size;
1168                                 k += usb_bufs->max_pkt_size;
1169                         }
1170                 }
1171
1172                 urb->number_of_packets = usb_bufs->num_packets;
1173         }
1174
1175         return 0;
1176 }
1177 EXPORT_SYMBOL_GPL(em28xx_alloc_urbs);
1178
1179 /*
1180  * Allocate URBs and start IRQ
1181  */
1182 int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
1183                     int xfer_bulk, int num_bufs, int max_pkt_size,
1184                     int packet_multiplier,
1185                     int (*urb_data_copy) (struct em28xx *dev, struct urb *urb))
1186 {
1187         struct em28xx_dmaqueue *dma_q = &dev->vidq;
1188         struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
1189         struct em28xx_usb_bufs *usb_bufs;
1190         int i;
1191         int rc;
1192         int alloc;
1193
1194         em28xx_isocdbg("em28xx: called em28xx_init_usb_xfer in mode %d\n",
1195                        mode);
1196
1197         dev->usb_ctl.urb_data_copy = urb_data_copy;
1198
1199         if (mode == EM28XX_DIGITAL_MODE) {
1200                 usb_bufs = &dev->usb_ctl.digital_bufs;
1201                 /* no need to free/alloc usb buffers in digital mode */
1202                 alloc = 0;
1203         } else {
1204                 usb_bufs = &dev->usb_ctl.analog_bufs;
1205                 alloc = 1;
1206         }
1207
1208         if (alloc) {
1209                 rc = em28xx_alloc_urbs(dev, mode, xfer_bulk, num_bufs,
1210                                        max_pkt_size, packet_multiplier);
1211                 if (rc)
1212                         return rc;
1213         }
1214
1215         if (xfer_bulk) {
1216                 rc = usb_clear_halt(dev->udev, usb_bufs->urb[0]->pipe);
1217                 if (rc < 0) {
1218                         em28xx_err("failed to clear USB bulk endpoint stall/halt condition (error=%i)\n",
1219                                    rc);
1220                         em28xx_uninit_usb_xfer(dev, mode);
1221                         return rc;
1222                 }
1223         }
1224
1225         init_waitqueue_head(&dma_q->wq);
1226         init_waitqueue_head(&vbi_dma_q->wq);
1227
1228         em28xx_capture_start(dev, 1);
1229
1230         /* submit urbs and enables IRQ */
1231         for (i = 0; i < usb_bufs->num_bufs; i++) {
1232                 rc = usb_submit_urb(usb_bufs->urb[i], GFP_ATOMIC);
1233                 if (rc) {
1234                         em28xx_err("submit of urb %i failed (error=%i)\n", i,
1235                                    rc);
1236                         em28xx_uninit_usb_xfer(dev, mode);
1237                         return rc;
1238                 }
1239         }
1240
1241         return 0;
1242 }
1243 EXPORT_SYMBOL_GPL(em28xx_init_usb_xfer);
1244
1245 /*
1246  * em28xx_wake_i2c()
1247  * configure i2c attached devices
1248  */
1249 void em28xx_wake_i2c(struct em28xx *dev)
1250 {
1251         v4l2_device_call_all(&dev->v4l2_dev, 0, core,  reset, 0);
1252         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1253                         INPUT(dev->ctl_input)->vmux, 0, 0);
1254         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1255 }
1256
1257 /*
1258  * Device control list
1259  */
1260
1261 static LIST_HEAD(em28xx_devlist);
1262 static DEFINE_MUTEX(em28xx_devlist_mutex);
1263
1264 /*
1265  * Extension interface
1266  */
1267
1268 static LIST_HEAD(em28xx_extension_devlist);
1269
1270 int em28xx_register_extension(struct em28xx_ops *ops)
1271 {
1272         struct em28xx *dev = NULL;
1273
1274         mutex_lock(&em28xx_devlist_mutex);
1275         list_add_tail(&ops->next, &em28xx_extension_devlist);
1276         list_for_each_entry(dev, &em28xx_devlist, devlist) {
1277                 ops->init(dev);
1278         }
1279         mutex_unlock(&em28xx_devlist_mutex);
1280         printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
1281         return 0;
1282 }
1283 EXPORT_SYMBOL(em28xx_register_extension);
1284
1285 void em28xx_unregister_extension(struct em28xx_ops *ops)
1286 {
1287         struct em28xx *dev = NULL;
1288
1289         mutex_lock(&em28xx_devlist_mutex);
1290         list_for_each_entry(dev, &em28xx_devlist, devlist) {
1291                 ops->fini(dev);
1292         }
1293         list_del(&ops->next);
1294         mutex_unlock(&em28xx_devlist_mutex);
1295         printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
1296 }
1297 EXPORT_SYMBOL(em28xx_unregister_extension);
1298
1299 void em28xx_init_extension(struct em28xx *dev)
1300 {
1301         const struct em28xx_ops *ops = NULL;
1302
1303         mutex_lock(&em28xx_devlist_mutex);
1304         list_add_tail(&dev->devlist, &em28xx_devlist);
1305         list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1306                 if (ops->init)
1307                         ops->init(dev);
1308         }
1309         mutex_unlock(&em28xx_devlist_mutex);
1310 }
1311
1312 void em28xx_close_extension(struct em28xx *dev)
1313 {
1314         const struct em28xx_ops *ops = NULL;
1315
1316         mutex_lock(&em28xx_devlist_mutex);
1317         list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1318                 if (ops->fini)
1319                         ops->fini(dev);
1320         }
1321         list_del(&dev->devlist);
1322         mutex_unlock(&em28xx_devlist_mutex);
1323 }