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                 if (!start) {
 612                         rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
 613                                                    0x00,
 614                                                    EM2874_TS1_CAPTURE_ENABLE);
 615                         return rc;
 616                 }
 617
 618                 /* Enable Transport Stream */
 619                 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
 620                                            EM2874_TS1_CAPTURE_ENABLE,
 621                                            EM2874_TS1_CAPTURE_ENABLE);
 622                 return rc;
 623         }
 624
 625
 626         /* FIXME: which is the best order? */
 627         /* video registers are sampled by VREF */
 628         rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
 629                                    start ? 0x10 : 0x00, 0x10);
 630         if (rc < 0)
 631                 return rc;
 632
 633         if (!start) {
 634                 /* disable video capture */
 635                 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
 636                 return rc;
 637         }
 638
 639         if (dev->board.is_webcam)
 640                 rc = em28xx_write_reg(dev, 0x13, 0x0c);
 641
 642         /* enable video capture */
 643         rc = em28xx_write_reg(dev, 0x48, 0x00);
 644
 645         if (dev->mode == EM28XX_ANALOG_MODE)
 646                 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
 647         else
 648                 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
 649
 650         msleep(6);
 651
 652         return rc;
 653 }
 654
 655 int em28xx_vbi_supported(struct em28xx *dev)
 656 {
 657         /* Modprobe option to manually disable */
 658         if (disable_vbi == 1)
 659                 return 0;
 660
 661         if (dev->board.is_webcam)
 662                 return 0;
 663
 664         /* FIXME: check subdevices for VBI support */
 665
 666         if (dev->chip_id == CHIP_ID_EM2860 ||
 667             dev->chip_id == CHIP_ID_EM2883)
 668                 return 1;
 669
 670         /* Version of em28xx that does not support VBI */
 671         return 0;
 672 }
 673
 674 int em28xx_set_outfmt(struct em28xx *dev)
 675 {
 676         int ret;
 677         u8 fmt, vinctrl;
 678
 679         fmt = dev->format->reg;
 680         if (!dev->is_em25xx)
 681                 fmt |= 0x20;
 682         /*
 683          * NOTE: it's not clear if this is really needed !
 684          * The datasheets say bit 5 is a reserved bit and devices seem to work
 685          * fine without it. But the Windows driver sets it for em2710/50+em28xx
 686          * devices and we've always been setting it, too.
 687          *
 688          * em2765 (em25xx, em276x/7x/8x) devices do NOT work with this bit set,
 689          * it's likely used for an additional (compressed ?) format there.
 690          */
 691         ret = em28xx_write_reg(dev, EM28XX_R27_OUTFMT, fmt);
 692         if (ret < 0)
 693                 return ret;
 694
 695         ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, dev->vinmode);
 696         if (ret < 0)
 697                 return ret;
 698
 699         vinctrl = dev->vinctl;
 700         if (em28xx_vbi_supported(dev) == 1) {
 701                 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
 702                 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
 703                 em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, dev->vbi_width/4);
 704                 em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, dev->vbi_height);
 705                 if (dev->norm & V4L2_STD_525_60) {
 706                         /* NTSC */
 707                         em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
 708                 } else if (dev->norm & V4L2_STD_625_50) {
 709                         /* PAL */
 710                         em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
 711                 }
 712         }
 713
 714         return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
 715 }
 716
 717 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
 718                                   u8 ymin, u8 ymax)
 719 {
 720         em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
 721                         xmin, ymin, xmax, ymax);
 722
 723         em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
 724         em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
 725         em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
 726         return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
 727 }
 728
 729 static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
 730                                    u16 width, u16 height)
 731 {
 732         u8 cwidth = width >> 2;
 733         u8 cheight = height >> 2;
 734         u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
 735         /* NOTE: size limit: 2047x1023 = 2MPix */
 736
 737         em28xx_coredbg("capture area set to (%d,%d): %dx%d\n",
 738                        hstart, vstart,
 739                        ((overflow & 2) << 9 | cwidth << 2),
 740                        ((overflow & 1) << 10 | cheight << 2));
 741
 742         em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
 743         em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
 744         em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
 745         em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
 746         em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
 747
 748         /* FIXME: function/meaning of these registers ? */
 749         /* FIXME: align width+height to multiples of 4 ?! */
 750         if (dev->is_em25xx) {
 751                 em28xx_write_reg(dev, 0x34, width >> 4);
 752                 em28xx_write_reg(dev, 0x35, height >> 4);
 753         }
 754 }
 755
 756 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 757 {
 758         u8 mode;
 759         /* the em2800 scaler only supports scaling down to 50% */
 760
 761         if (dev->board.is_em2800) {
 762                 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
 763         } else {
 764                 u8 buf[2];
 765
 766                 buf[0] = h;
 767                 buf[1] = h >> 8;
 768                 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
 769
 770                 buf[0] = v;
 771                 buf[1] = v >> 8;
 772                 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
 773                 /* it seems that both H and V scalers must be active
 774                    to work correctly */
 775                 mode = (h || v) ? 0x30 : 0x00;
 776         }
 777         return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
 778 }
 779
 780 /* FIXME: this only function read values from dev */
 781 int em28xx_resolution_set(struct em28xx *dev)
 782 {
 783         int width, height;
 784         width = norm_maxw(dev);
 785         height = norm_maxh(dev);
 786
 787         /* Properly setup VBI */
 788         dev->vbi_width = 720;
 789         if (dev->norm & V4L2_STD_525_60)
 790                 dev->vbi_height = 12;
 791         else
 792                 dev->vbi_height = 18;
 793
 794         em28xx_set_outfmt(dev);
 795
 796         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
 797
 798         /* If we don't set the start position to 2 in VBI mode, we end up
 799            with line 20/21 being YUYV encoded instead of being in 8-bit
 800            greyscale.  The core of the issue is that line 21 (and line 23 for
 801            PAL WSS) are inside of active video region, and as a result they
 802            get the pixelformatting associated with that area.  So by cropping
 803            it out, we end up with the same format as the rest of the VBI
 804            region */
 805         if (em28xx_vbi_supported(dev) == 1)
 806                 em28xx_capture_area_set(dev, 0, 2, width, height);
 807         else
 808                 em28xx_capture_area_set(dev, 0, 0, width, height);
 809
 810         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 811 }
 812
 813 /* Set USB alternate setting for analog video */
 814 int em28xx_set_alternate(struct em28xx *dev)
 815 {
 816         int errCode;
 817         int i;
 818         unsigned int min_pkt_size = dev->width * 2 + 4;
 819
 820         /* NOTE: for isoc transfers, only alt settings > 0 are allowed
 821                  bulk transfers seem to work only with alt=0 ! */
 822         dev->alt = 0;
 823         if ((alt > 0) && (alt < dev->num_alt)) {
 824                 em28xx_coredbg("alternate forced to %d\n", dev->alt);
 825                 dev->alt = alt;
 826                 goto set_alt;
 827         }
 828         if (dev->analog_xfer_bulk)
 829                 goto set_alt;
 830
 831         /* When image size is bigger than a certain value,
 832            the frame size should be increased, otherwise, only
 833            green screen will be received.
 834          */
 835         if (dev->width * 2 * dev->height > 720 * 240 * 2)
 836                 min_pkt_size *= 2;
 837
 838         for (i = 0; i < dev->num_alt; i++) {
 839                 /* stop when the selected alt setting offers enough bandwidth */
 840                 if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
 841                         dev->alt = i;
 842                         break;
 843                 /* otherwise make sure that we end up with the maximum bandwidth
 844                    because the min_pkt_size equation might be wrong...
 845                 */
 846                 } else if (dev->alt_max_pkt_size_isoc[i] >
 847                            dev->alt_max_pkt_size_isoc[dev->alt])
 848                         dev->alt = i;
 849         }
 850
 851 set_alt:
 852         /* NOTE: for bulk transfers, we need to call usb_set_interface()
 853          * even if the previous settings were the same. Otherwise streaming
 854          * fails with all urbs having status = -EOVERFLOW ! */
 855         if (dev->analog_xfer_bulk) {
 856                 dev->max_pkt_size = 512; /* USB 2.0 spec */
 857                 dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
 858         } else { /* isoc */
 859                 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
 860                                min_pkt_size, dev->alt);
 861                 dev->max_pkt_size =
 862                                   dev->alt_max_pkt_size_isoc[dev->alt];
 863                 dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
 864         }
 865         em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
 866                        dev->alt, dev->max_pkt_size);
 867         errCode = usb_set_interface(dev->udev, 0, dev->alt);
 868         if (errCode < 0) {
 869                 em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
 870                               dev->alt, errCode);
 871                 return errCode;
 872         }
 873         return 0;
 874 }
 875
 876 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
 877 {
 878         int rc = 0;
 879
 880         if (!gpio)
 881                 return rc;
 882
 883         if (dev->mode != EM28XX_SUSPEND) {
 884                 em28xx_write_reg(dev, 0x48, 0x00);
 885                 if (dev->mode == EM28XX_ANALOG_MODE)
 886                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
 887                 else
 888                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
 889                 msleep(6);
 890         }
 891
 892         /* Send GPIO reset sequences specified at board entry */
 893         while (gpio->sleep >= 0) {
 894                 if (gpio->reg >= 0) {
 895                         rc = em28xx_write_reg_bits(dev,
 896                                                    gpio->reg,
 897                                                    gpio->val,
 898                                                    gpio->mask);
 899                         if (rc < 0)
 900                                 return rc;
 901                 }
 902                 if (gpio->sleep > 0)
 903                         msleep(gpio->sleep);
 904
 905                 gpio++;
 906         }
 907         return rc;
 908 }
 909 EXPORT_SYMBOL_GPL(em28xx_gpio_set);
 910
 911 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
 912 {
 913         if (dev->mode == set_mode)
 914                 return 0;
 915
 916         if (set_mode == EM28XX_SUSPEND) {
 917                 dev->mode = set_mode;
 918
 919                 /* FIXME: add suspend support for ac97 */
 920
 921                 return em28xx_gpio_set(dev, dev->board.suspend_gpio);
 922         }
 923
 924         dev->mode = set_mode;
 925
 926         if (dev->mode == EM28XX_DIGITAL_MODE)
 927                 return em28xx_gpio_set(dev, dev->board.dvb_gpio);
 928         else
 929                 return em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
 930 }
 931 EXPORT_SYMBOL_GPL(em28xx_set_mode);
 932
 933 /* ------------------------------------------------------------------
 934         URB control
 935    ------------------------------------------------------------------*/
 936
 937 /*
 938  * URB completion handler for isoc/bulk transfers
 939  */
 940 static void em28xx_irq_callback(struct urb *urb)
 941 {
 942         struct em28xx *dev = urb->context;
 943         int i;
 944
 945         switch (urb->status) {
 946         case 0:             /* success */
 947         case -ETIMEDOUT:    /* NAK */
 948                 break;
 949         case -ECONNRESET:   /* kill */
 950         case -ENOENT:
 951         case -ESHUTDOWN:
 952                 return;
 953         default:            /* error */
 954                 em28xx_isocdbg("urb completition error %d.\n", urb->status);
 955                 break;
 956         }
 957
 958         /* Copy data from URB */
 959         spin_lock(&dev->slock);
 960         dev->usb_ctl.urb_data_copy(dev, urb);
 961         spin_unlock(&dev->slock);
 962
 963         /* Reset urb buffers */
 964         for (i = 0; i < urb->number_of_packets; i++) {
 965                 /* isoc only (bulk: number_of_packets = 0) */
 966                 urb->iso_frame_desc[i].status = 0;
 967                 urb->iso_frame_desc[i].actual_length = 0;
 968         }
 969         urb->status = 0;
 970
 971         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 972         if (urb->status) {
 973                 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
 974                                urb->status);
 975         }
 976 }
 977
 978 /*
 979  * Stop and Deallocate URBs
 980  */
 981 void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode)
 982 {
 983         struct urb *urb;
 984         struct em28xx_usb_bufs *usb_bufs;
 985         int i;
 986
 987         em28xx_isocdbg("em28xx: called em28xx_uninit_usb_xfer in mode %d\n",
 988                        mode);
 989
 990         if (mode == EM28XX_DIGITAL_MODE)
 991                 usb_bufs = &dev->usb_ctl.digital_bufs;
 992         else
 993                 usb_bufs = &dev->usb_ctl.analog_bufs;
 994
 995         for (i = 0; i < usb_bufs->num_bufs; i++) {
 996                 urb = usb_bufs->urb[i];
 997                 if (urb) {
 998                         if (!irqs_disabled())
 999                                 usb_kill_urb(urb);
1000                         else
1001                                 usb_unlink_urb(urb);
1002
1003                         if (usb_bufs->transfer_buffer[i]) {
1004                                 usb_free_coherent(dev->udev,
1005                                         urb->transfer_buffer_length,
1006                                         usb_bufs->transfer_buffer[i],
1007                                         urb->transfer_dma);
1008                         }
1009                         usb_free_urb(urb);
1010                         usb_bufs->urb[i] = NULL;
1011                 }
1012                 usb_bufs->transfer_buffer[i] = NULL;
1013         }
1014
1015         kfree(usb_bufs->urb);
1016         kfree(usb_bufs->transfer_buffer);
1017
1018         usb_bufs->urb = NULL;
1019         usb_bufs->transfer_buffer = NULL;
1020         usb_bufs->num_bufs = 0;
1021
1022         em28xx_capture_start(dev, 0);
1023 }
1024 EXPORT_SYMBOL_GPL(em28xx_uninit_usb_xfer);
1025
1026 /*
1027  * Stop URBs
1028  */
1029 void em28xx_stop_urbs(struct em28xx *dev)
1030 {
1031         int i;
1032         struct urb *urb;
1033         struct em28xx_usb_bufs *isoc_bufs = &dev->usb_ctl.digital_bufs;
1034
1035         em28xx_isocdbg("em28xx: called em28xx_stop_urbs\n");
1036
1037         for (i = 0; i < isoc_bufs->num_bufs; i++) {
1038                 urb = isoc_bufs->urb[i];
1039                 if (urb) {
1040                         if (!irqs_disabled())
1041                                 usb_kill_urb(urb);
1042                         else
1043                                 usb_unlink_urb(urb);
1044                 }
1045         }
1046
1047         em28xx_capture_start(dev, 0);
1048 }
1049 EXPORT_SYMBOL_GPL(em28xx_stop_urbs);
1050
1051 /*
1052  * Allocate URBs
1053  */
1054 int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
1055                       int num_bufs, int max_pkt_size, int packet_multiplier)
1056 {
1057         struct em28xx_usb_bufs *usb_bufs;
1058         int i;
1059         int sb_size, pipe;
1060         struct urb *urb;
1061         int j, k;
1062
1063         em28xx_isocdbg("em28xx: called em28xx_alloc_isoc in mode %d\n", mode);
1064
1065         /* Check mode and if we have an endpoint for the selected
1066            transfer type, select buffer                          */
1067         if (mode == EM28XX_DIGITAL_MODE) {
1068                 if ((xfer_bulk && !dev->dvb_ep_bulk) ||
1069                     (!xfer_bulk && !dev->dvb_ep_isoc)) {
1070                         em28xx_errdev("no endpoint for DVB mode and transfer type %d\n",
1071                                       xfer_bulk > 0);
1072                         return -EINVAL;
1073                 }
1074                 usb_bufs = &dev->usb_ctl.digital_bufs;
1075         } else if (mode == EM28XX_ANALOG_MODE) {
1076                 if ((xfer_bulk && !dev->analog_ep_bulk) ||
1077                     (!xfer_bulk && !dev->analog_ep_isoc)) {
1078                         em28xx_errdev("no endpoint for analog mode and transfer type %d\n",
1079                                        xfer_bulk > 0);
1080                         return -EINVAL;
1081                 }
1082                 usb_bufs = &dev->usb_ctl.analog_bufs;
1083         } else {
1084                 em28xx_errdev("invalid mode selected\n");
1085                 return -EINVAL;
1086         }
1087
1088         /* De-allocates all pending stuff */
1089         em28xx_uninit_usb_xfer(dev, mode);
1090
1091         usb_bufs->num_bufs = num_bufs;
1092
1093         usb_bufs->urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
1094         if (!usb_bufs->urb) {
1095                 em28xx_errdev("cannot alloc memory for usb buffers\n");
1096                 return -ENOMEM;
1097         }
1098
1099         usb_bufs->transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
1100                                              GFP_KERNEL);
1101         if (!usb_bufs->transfer_buffer) {
1102                 em28xx_errdev("cannot allocate memory for usb transfer\n");
1103                 kfree(usb_bufs->urb);
1104                 return -ENOMEM;
1105         }
1106
1107         usb_bufs->max_pkt_size = max_pkt_size;
1108         if (xfer_bulk)
1109                 usb_bufs->num_packets = 0;
1110         else
1111                 usb_bufs->num_packets = packet_multiplier;
1112         dev->usb_ctl.vid_buf = NULL;
1113         dev->usb_ctl.vbi_buf = NULL;
1114
1115         sb_size = packet_multiplier * usb_bufs->max_pkt_size;
1116
1117         /* allocate urbs and transfer buffers */
1118         for (i = 0; i < usb_bufs->num_bufs; i++) {
1119                 urb = usb_alloc_urb(usb_bufs->num_packets, GFP_KERNEL);
1120                 if (!urb) {
1121                         em28xx_err("cannot alloc usb_ctl.urb %i\n", i);
1122                         em28xx_uninit_usb_xfer(dev, mode);
1123                         return -ENOMEM;
1124                 }
1125                 usb_bufs->urb[i] = urb;
1126
1127                 usb_bufs->transfer_buffer[i] = usb_alloc_coherent(dev->udev,
1128                         sb_size, GFP_KERNEL, &urb->transfer_dma);
1129                 if (!usb_bufs->transfer_buffer[i]) {
1130                         em28xx_err("unable to allocate %i bytes for transfer"
1131                                         " buffer %i%s\n",
1132                                         sb_size, i,
1133                                         in_interrupt() ? " while in int" : "");
1134                         em28xx_uninit_usb_xfer(dev, mode);
1135                         return -ENOMEM;
1136                 }
1137                 memset(usb_bufs->transfer_buffer[i], 0, sb_size);
1138
1139                 if (xfer_bulk) { /* bulk */
1140                         pipe = usb_rcvbulkpipe(dev->udev,
1141                                                mode == EM28XX_ANALOG_MODE ?
1142                                                dev->analog_ep_bulk :
1143                                                dev->dvb_ep_bulk);
1144                         usb_fill_bulk_urb(urb, dev->udev, pipe,
1145                                           usb_bufs->transfer_buffer[i], sb_size,
1146                                           em28xx_irq_callback, dev);
1147                         urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1148                 } else { /* isoc */
1149                         pipe = usb_rcvisocpipe(dev->udev,
1150                                                mode == EM28XX_ANALOG_MODE ?
1151                                                dev->analog_ep_isoc :
1152                                                dev->dvb_ep_isoc);
1153                         usb_fill_int_urb(urb, dev->udev, pipe,
1154                                          usb_bufs->transfer_buffer[i], sb_size,
1155                                          em28xx_irq_callback, dev, 1);
1156                         urb->transfer_flags = URB_ISO_ASAP |
1157                                               URB_NO_TRANSFER_DMA_MAP;
1158                         k = 0;
1159                         for (j = 0; j < usb_bufs->num_packets; j++) {
1160                                 urb->iso_frame_desc[j].offset = k;
1161                                 urb->iso_frame_desc[j].length =
1162                                                         usb_bufs->max_pkt_size;
1163                                 k += usb_bufs->max_pkt_size;
1164                         }
1165                 }
1166
1167                 urb->number_of_packets = usb_bufs->num_packets;
1168         }
1169
1170         return 0;
1171 }
1172 EXPORT_SYMBOL_GPL(em28xx_alloc_urbs);
1173
1174 /*
1175  * Allocate URBs and start IRQ
1176  */
1177 int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
1178                     int xfer_bulk, int num_bufs, int max_pkt_size,
1179                     int packet_multiplier,
1180                     int (*urb_data_copy) (struct em28xx *dev, struct urb *urb))
1181 {
1182         struct em28xx_dmaqueue *dma_q = &dev->vidq;
1183         struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
1184         struct em28xx_usb_bufs *usb_bufs;
1185         int i;
1186         int rc;
1187         int alloc;
1188
1189         em28xx_isocdbg("em28xx: called em28xx_init_usb_xfer in mode %d\n",
1190                        mode);
1191
1192         dev->usb_ctl.urb_data_copy = urb_data_copy;
1193
1194         if (mode == EM28XX_DIGITAL_MODE) {
1195                 usb_bufs = &dev->usb_ctl.digital_bufs;
1196                 /* no need to free/alloc usb buffers in digital mode */
1197                 alloc = 0;
1198         } else {
1199                 usb_bufs = &dev->usb_ctl.analog_bufs;
1200                 alloc = 1;
1201         }
1202
1203         if (alloc) {
1204                 rc = em28xx_alloc_urbs(dev, mode, xfer_bulk, num_bufs,
1205                                        max_pkt_size, packet_multiplier);
1206                 if (rc)
1207                         return rc;
1208         }
1209
1210         if (xfer_bulk) {
1211                 rc = usb_clear_halt(dev->udev, usb_bufs->urb[0]->pipe);
1212                 if (rc < 0) {
1213                         em28xx_err("failed to clear USB bulk endpoint stall/halt condition (error=%i)\n",
1214                                    rc);
1215                         em28xx_uninit_usb_xfer(dev, mode);
1216                         return rc;
1217                 }
1218         }
1219
1220         init_waitqueue_head(&dma_q->wq);
1221         init_waitqueue_head(&vbi_dma_q->wq);
1222
1223         em28xx_capture_start(dev, 1);
1224
1225         /* submit urbs and enables IRQ */
1226         for (i = 0; i < usb_bufs->num_bufs; i++) {
1227                 rc = usb_submit_urb(usb_bufs->urb[i], GFP_ATOMIC);
1228                 if (rc) {
1229                         em28xx_err("submit of urb %i failed (error=%i)\n", i,
1230                                    rc);
1231                         em28xx_uninit_usb_xfer(dev, mode);
1232                         return rc;
1233                 }
1234         }
1235
1236         return 0;
1237 }
1238 EXPORT_SYMBOL_GPL(em28xx_init_usb_xfer);
1239
1240 /*
1241  * em28xx_wake_i2c()
1242  * configure i2c attached devices
1243  */
1244 void em28xx_wake_i2c(struct em28xx *dev)
1245 {
1246         v4l2_device_call_all(&dev->v4l2_dev, 0, core,  reset, 0);
1247         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1248                         INPUT(dev->ctl_input)->vmux, 0, 0);
1249         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1250 }
1251
1252 /*
1253  * Device control list
1254  */
1255
1256 static LIST_HEAD(em28xx_devlist);
1257 static DEFINE_MUTEX(em28xx_devlist_mutex);
1258
1259 /*
1260  * Extension interface
1261  */
1262
1263 static LIST_HEAD(em28xx_extension_devlist);
1264
1265 int em28xx_register_extension(struct em28xx_ops *ops)
1266 {
1267         struct em28xx *dev = NULL;
1268
1269         mutex_lock(&em28xx_devlist_mutex);
1270         list_add_tail(&ops->next, &em28xx_extension_devlist);
1271         list_for_each_entry(dev, &em28xx_devlist, devlist) {
1272                 ops->init(dev);
1273         }
1274         mutex_unlock(&em28xx_devlist_mutex);
1275         printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
1276         return 0;
1277 }
1278 EXPORT_SYMBOL(em28xx_register_extension);
1279
1280 void em28xx_unregister_extension(struct em28xx_ops *ops)
1281 {
1282         struct em28xx *dev = NULL;
1283
1284         mutex_lock(&em28xx_devlist_mutex);
1285         list_for_each_entry(dev, &em28xx_devlist, devlist) {
1286                 ops->fini(dev);
1287         }
1288         list_del(&ops->next);
1289         mutex_unlock(&em28xx_devlist_mutex);
1290         printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
1291 }
1292 EXPORT_SYMBOL(em28xx_unregister_extension);
1293
1294 void em28xx_init_extension(struct em28xx *dev)
1295 {
1296         const struct em28xx_ops *ops = NULL;
1297
1298         mutex_lock(&em28xx_devlist_mutex);
1299         list_add_tail(&dev->devlist, &em28xx_devlist);
1300         list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1301                 if (ops->init)
1302                         ops->init(dev);
1303         }
1304         mutex_unlock(&em28xx_devlist_mutex);
1305 }
1306
1307 void em28xx_close_extension(struct em28xx *dev)
1308 {
1309         const struct em28xx_ops *ops = NULL;
1310
1311         mutex_lock(&em28xx_devlist_mutex);
1312         list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1313                 if (ops->fini)
1314                         ops->fini(dev);
1315         }
1316         list_del(&dev->devlist);
1317         mutex_unlock(&em28xx_devlist_mutex);
1318 }