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 /* FIXME */
  57 #define em28xx_isocdbg(fmt, arg...) do {\
  58         if (core_debug) \
  59                 printk(KERN_INFO "%s %s :"fmt, \
  60                          dev->name, __func__ , ##arg); } while (0)
  61
  62 /*
  63  * em28xx_read_reg_req()
  64  * reads data from the usb device specifying bRequest
  65  */
  66 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
  67                                    char *buf, int len)
  68 {
  69         int ret;
  70         int pipe = usb_rcvctrlpipe(dev->udev, 0);
  71
  72         if (dev->disconnected)
  73                 return -ENODEV;
  74
  75         if (len > URB_MAX_CTRL_SIZE)
  76                 return -EINVAL;
  77
  78         if (reg_debug) {
  79                 printk(KERN_DEBUG "(pipe 0x%08x): "
  80                         "IN:  %02x %02x %02x %02x %02x %02x %02x %02x ",
  81                         pipe,
  82                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  83                         req, 0, 0,
  84                         reg & 0xff, reg >> 8,
  85                         len & 0xff, len >> 8);
  86         }
  87
  88         mutex_lock(&dev->ctrl_urb_lock);
  89         ret = usb_control_msg(dev->udev, pipe, req,
  90                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  91                               0x0000, reg, dev->urb_buf, len, HZ);
  92         if (ret < 0) {
  93                 if (reg_debug)
  94                         printk(" failed!\n");
  95                 mutex_unlock(&dev->ctrl_urb_lock);
  96                 return usb_translate_errors(ret);
  97         }
  98
  99         if (len)
 100                 memcpy(buf, dev->urb_buf, len);
 101
 102         mutex_unlock(&dev->ctrl_urb_lock);
 103
 104         if (reg_debug) {
 105                 int byte;
 106
 107                 printk("<<<");
 108                 for (byte = 0; byte < len; byte++)
 109                         printk(" %02x", (unsigned char)buf[byte]);
 110                 printk("\n");
 111         }
 112
 113         return ret;
 114 }
 115
 116 /*
 117  * em28xx_read_reg_req()
 118  * reads data from the usb device specifying bRequest
 119  */
 120 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
 121 {
 122         int ret;
 123         u8 val;
 124
 125         ret = em28xx_read_reg_req_len(dev, req, reg, &val, 1);
 126         if (ret < 0)
 127                 return ret;
 128
 129         return val;
 130 }
 131
 132 int em28xx_read_reg(struct em28xx *dev, u16 reg)
 133 {
 134         return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
 135 }
 136 EXPORT_SYMBOL_GPL(em28xx_read_reg);
 137
 138 /*
 139  * em28xx_write_regs_req()
 140  * sends data to the usb device, specifying bRequest
 141  */
 142 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
 143                                  int len)
 144 {
 145         int ret;
 146         int pipe = usb_sndctrlpipe(dev->udev, 0);
 147
 148         if (dev->disconnected)
 149                 return -ENODEV;
 150
 151         if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
 152                 return -EINVAL;
 153
 154         if (reg_debug) {
 155                 int byte;
 156
 157                 printk(KERN_DEBUG "(pipe 0x%08x): "
 158                         "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>",
 159                         pipe,
 160                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 161                         req, 0, 0,
 162                         reg & 0xff, reg >> 8,
 163                         len & 0xff, len >> 8);
 164
 165                 for (byte = 0; byte < len; byte++)
 166                         printk(" %02x", (unsigned char)buf[byte]);
 167                 printk("\n");
 168         }
 169
 170         mutex_lock(&dev->ctrl_urb_lock);
 171         memcpy(dev->urb_buf, buf, len);
 172         ret = usb_control_msg(dev->udev, pipe, req,
 173                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 174                               0x0000, reg, dev->urb_buf, len, HZ);
 175         mutex_unlock(&dev->ctrl_urb_lock);
 176
 177         if (ret < 0)
 178                 return usb_translate_errors(ret);
 179
 180         if (dev->wait_after_write)
 181                 msleep(dev->wait_after_write);
 182
 183         return ret;
 184 }
 185
 186 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
 187 {
 188         return em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
 189 }
 190 EXPORT_SYMBOL_GPL(em28xx_write_regs);
 191
 192 /* Write a single register */
 193 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
 194 {
 195         return em28xx_write_regs(dev, reg, &val, 1);
 196 }
 197 EXPORT_SYMBOL_GPL(em28xx_write_reg);
 198
 199 /*
 200  * em28xx_write_reg_bits()
 201  * sets only some bits (specified by bitmask) of a register, by first reading
 202  * the actual value
 203  */
 204 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
 205                                  u8 bitmask)
 206 {
 207         int oldval;
 208         u8 newval;
 209
 210         oldval = em28xx_read_reg(dev, reg);
 211         if (oldval < 0)
 212                 return oldval;
 213
 214         newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
 215
 216         return em28xx_write_regs(dev, reg, &newval, 1);
 217 }
 218 EXPORT_SYMBOL_GPL(em28xx_write_reg_bits);
 219
 220 /*
 221  * em28xx_toggle_reg_bits()
 222  * toggles/inverts the bits (specified by bitmask) of a register
 223  */
 224 int em28xx_toggle_reg_bits(struct em28xx *dev, u16 reg, u8 bitmask)
 225 {
 226         int oldval;
 227         u8 newval;
 228
 229         oldval = em28xx_read_reg(dev, reg);
 230         if (oldval < 0)
 231                 return oldval;
 232
 233         newval = (~oldval & bitmask) | (oldval & ~bitmask);
 234
 235         return em28xx_write_reg(dev, reg, newval);
 236 }
 237 EXPORT_SYMBOL_GPL(em28xx_toggle_reg_bits);
 238
 239 /*
 240  * em28xx_is_ac97_ready()
 241  * Checks if ac97 is ready
 242  */
 243 static int em28xx_is_ac97_ready(struct em28xx *dev)
 244 {
 245         int ret, i;
 246
 247         /* Wait up to 50 ms for AC97 command to complete */
 248         for (i = 0; i < 10; i++, msleep(5)) {
 249                 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
 250                 if (ret < 0)
 251                         return ret;
 252
 253                 if (!(ret & 0x01))
 254                         return 0;
 255         }
 256
 257         em28xx_warn("AC97 command still being executed: not handled properly!\n");
 258         return -EBUSY;
 259 }
 260
 261 /*
 262  * em28xx_read_ac97()
 263  * write a 16 bit value to the specified AC97 address (LSB first!)
 264  */
 265 int em28xx_read_ac97(struct em28xx *dev, u8 reg)
 266 {
 267         int ret;
 268         u8 addr = (reg & 0x7f) | 0x80;
 269         u16 val;
 270
 271         ret = em28xx_is_ac97_ready(dev);
 272         if (ret < 0)
 273                 return ret;
 274
 275         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 276         if (ret < 0)
 277                 return ret;
 278
 279         ret = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R40_AC97LSB,
 280                                            (u8 *)&val, sizeof(val));
 281
 282         if (ret < 0)
 283                 return ret;
 284         return le16_to_cpu(val);
 285 }
 286 EXPORT_SYMBOL_GPL(em28xx_read_ac97);
 287
 288 /*
 289  * em28xx_write_ac97()
 290  * write a 16 bit value to the specified AC97 address (LSB first!)
 291  */
 292 int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
 293 {
 294         int ret;
 295         u8 addr = reg & 0x7f;
 296         __le16 value;
 297
 298         value = cpu_to_le16(val);
 299
 300         ret = em28xx_is_ac97_ready(dev);
 301         if (ret < 0)
 302                 return ret;
 303
 304         ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *) &value, 2);
 305         if (ret < 0)
 306                 return ret;
 307
 308         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 309         if (ret < 0)
 310                 return ret;
 311
 312         return 0;
 313 }
 314 EXPORT_SYMBOL_GPL(em28xx_write_ac97);
 315
 316 struct em28xx_vol_itable {
 317         enum em28xx_amux mux;
 318         u8               reg;
 319 };
 320
 321 static struct em28xx_vol_itable inputs[] = {
 322         { EM28XX_AMUX_VIDEO,    AC97_VIDEO      },
 323         { EM28XX_AMUX_LINE_IN,  AC97_LINE       },
 324         { EM28XX_AMUX_PHONE,    AC97_PHONE      },
 325         { EM28XX_AMUX_MIC,      AC97_MIC        },
 326         { EM28XX_AMUX_CD,       AC97_CD         },
 327         { EM28XX_AMUX_AUX,      AC97_AUX        },
 328         { EM28XX_AMUX_PCM_OUT,  AC97_PCM        },
 329 };
 330
 331 static int set_ac97_input(struct em28xx *dev)
 332 {
 333         int ret, i;
 334         enum em28xx_amux amux = dev->ctl_ainput;
 335
 336         /* EM28XX_AMUX_VIDEO2 is a special case used to indicate that
 337            em28xx should point to LINE IN, while AC97 should use VIDEO
 338          */
 339         if (amux == EM28XX_AMUX_VIDEO2)
 340                 amux = EM28XX_AMUX_VIDEO;
 341
 342         /* Mute all entres but the one that were selected */
 343         for (i = 0; i < ARRAY_SIZE(inputs); i++) {
 344                 if (amux == inputs[i].mux)
 345                         ret = em28xx_write_ac97(dev, inputs[i].reg, 0x0808);
 346                 else
 347                         ret = em28xx_write_ac97(dev, inputs[i].reg, 0x8000);
 348
 349                 if (ret < 0)
 350                         em28xx_warn("couldn't setup AC97 register %d\n",
 351                                      inputs[i].reg);
 352         }
 353         return 0;
 354 }
 355
 356 static int em28xx_set_audio_source(struct em28xx *dev)
 357 {
 358         int ret;
 359         u8 input;
 360
 361         if (dev->board.is_em2800) {
 362                 if (dev->ctl_ainput == EM28XX_AMUX_VIDEO)
 363                         input = EM2800_AUDIO_SRC_TUNER;
 364                 else
 365                         input = EM2800_AUDIO_SRC_LINE;
 366
 367                 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
 368                 if (ret < 0)
 369                         return ret;
 370         }
 371
 372         if (dev->board.has_msp34xx)
 373                 input = EM28XX_AUDIO_SRC_TUNER;
 374         else {
 375                 switch (dev->ctl_ainput) {
 376                 case EM28XX_AMUX_VIDEO:
 377                         input = EM28XX_AUDIO_SRC_TUNER;
 378                         break;
 379                 default:
 380                         input = EM28XX_AUDIO_SRC_LINE;
 381                         break;
 382                 }
 383         }
 384
 385         if (dev->board.mute_gpio && dev->mute)
 386                 em28xx_gpio_set(dev, dev->board.mute_gpio);
 387         else
 388                 em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
 389
 390         ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
 391         if (ret < 0)
 392                 return ret;
 393         msleep(5);
 394
 395         switch (dev->audio_mode.ac97) {
 396         case EM28XX_NO_AC97:
 397                 break;
 398         default:
 399                 ret = set_ac97_input(dev);
 400         }
 401
 402         return ret;
 403 }
 404
 405 struct em28xx_vol_otable {
 406         enum em28xx_aout mux;
 407         u8               reg;
 408 };
 409
 410 static const struct em28xx_vol_otable outputs[] = {
 411         { EM28XX_AOUT_MASTER, AC97_MASTER               },
 412         { EM28XX_AOUT_LINE,   AC97_HEADPHONE            },
 413         { EM28XX_AOUT_MONO,   AC97_MASTER_MONO          },
 414         { EM28XX_AOUT_LFE,    AC97_CENTER_LFE_MASTER    },
 415         { EM28XX_AOUT_SURR,   AC97_SURROUND_MASTER      },
 416 };
 417
 418 int em28xx_audio_analog_set(struct em28xx *dev)
 419 {
 420         int ret, i;
 421         u8 xclk;
 422
 423         if (!dev->audio_mode.has_audio)
 424                 return 0;
 425
 426         /* It is assumed that all devices use master volume for output.
 427            It would be possible to use also line output.
 428          */
 429         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 430                 /* Mute all outputs */
 431                 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
 432                         ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
 433                         if (ret < 0)
 434                                 em28xx_warn("couldn't setup AC97 register %d\n",
 435                                      outputs[i].reg);
 436                 }
 437         }
 438
 439         xclk = dev->board.xclk & 0x7f;
 440         if (!dev->mute)
 441                 xclk |= EM28XX_XCLK_AUDIO_UNMUTE;
 442
 443         ret = em28xx_write_reg(dev, EM28XX_R0F_XCLK, xclk);
 444         if (ret < 0)
 445                 return ret;
 446         msleep(10);
 447
 448         /* Selects the proper audio input */
 449         ret = em28xx_set_audio_source(dev);
 450
 451         /* Sets volume */
 452         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 453                 int vol;
 454
 455                 em28xx_write_ac97(dev, AC97_POWERDOWN, 0x4200);
 456                 em28xx_write_ac97(dev, AC97_EXTENDED_STATUS, 0x0031);
 457                 em28xx_write_ac97(dev, AC97_PCM_LR_ADC_RATE, 0xbb80);
 458
 459                 /* LSB: left channel - both channels with the same level */
 460                 vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);
 461
 462                 /* Mute device, if needed */
 463                 if (dev->mute)
 464                         vol |= 0x8000;
 465
 466                 /* Sets volume */
 467                 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
 468                         if (dev->ctl_aoutput & outputs[i].mux)
 469                                 ret = em28xx_write_ac97(dev, outputs[i].reg,
 470                                                         vol);
 471                         if (ret < 0)
 472                                 em28xx_warn("couldn't setup AC97 register %d\n",
 473                                      outputs[i].reg);
 474                 }
 475
 476                 if (dev->ctl_aoutput & EM28XX_AOUT_PCM_IN) {
 477                         int sel = ac97_return_record_select(dev->ctl_aoutput);
 478
 479                         /* Use the same input for both left and right
 480                            channels */
 481                         sel |= (sel << 8);
 482
 483                         em28xx_write_ac97(dev, AC97_REC_SEL, sel);
 484                 }
 485         }
 486
 487         return ret;
 488 }
 489 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
 490
 491 int em28xx_audio_setup(struct em28xx *dev)
 492 {
 493         int vid1, vid2, feat, cfg;
 494         u32 vid;
 495
 496         if (dev->chip_id == CHIP_ID_EM2870 ||
 497             dev->chip_id == CHIP_ID_EM2874 ||
 498             dev->chip_id == CHIP_ID_EM28174 ||
 499             dev->chip_id == CHIP_ID_EM28178) {
 500                 /* Digital only device - don't load any alsa module */
 501                 dev->audio_mode.has_audio = false;
 502                 dev->has_audio_class = false;
 503                 dev->has_alsa_audio = false;
 504                 return 0;
 505         }
 506
 507         dev->audio_mode.has_audio = true;
 508
 509         /* See how this device is configured */
 510         cfg = em28xx_read_reg(dev, EM28XX_R00_CHIPCFG);
 511         em28xx_info("Config register raw data: 0x%02x\n", cfg);
 512         if (cfg < 0) {
 513                 /* Register read error?  */
 514                 cfg = EM28XX_CHIPCFG_AC97; /* Be conservative */
 515         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) == 0x00) {
 516                 /* The device doesn't have vendor audio at all */
 517                 dev->has_alsa_audio = false;
 518                 dev->audio_mode.has_audio = false;
 519                 return 0;
 520         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
 521                    EM28XX_CHIPCFG_I2S_3_SAMPRATES) {
 522                 em28xx_info("I2S Audio (3 sample rates)\n");
 523                 dev->audio_mode.i2s_3rates = 1;
 524         } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
 525                    EM28XX_CHIPCFG_I2S_5_SAMPRATES) {
 526                 em28xx_info("I2S Audio (5 sample rates)\n");
 527                 dev->audio_mode.i2s_5rates = 1;
 528         }
 529
 530         if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) != EM28XX_CHIPCFG_AC97) {
 531                 /* Skip the code that does AC97 vendor detection */
 532                 dev->audio_mode.ac97 = EM28XX_NO_AC97;
 533                 goto init_audio;
 534         }
 535
 536         dev->audio_mode.ac97 = EM28XX_AC97_OTHER;
 537
 538         vid1 = em28xx_read_ac97(dev, AC97_VENDOR_ID1);
 539         if (vid1 < 0) {
 540                 /*
 541                  * Device likely doesn't support AC97
 542                  * Note: (some) em2800 devices without eeprom reports 0x91 on
 543                  *       CHIPCFG register, even not having an AC97 chip
 544                  */
 545                 em28xx_warn("AC97 chip type couldn't be determined\n");
 546                 dev->audio_mode.ac97 = EM28XX_NO_AC97;
 547                 dev->has_alsa_audio = false;
 548                 dev->audio_mode.has_audio = false;
 549                 goto init_audio;
 550         }
 551
 552         vid2 = em28xx_read_ac97(dev, AC97_VENDOR_ID2);
 553         if (vid2 < 0)
 554                 goto init_audio;
 555
 556         vid = vid1 << 16 | vid2;
 557
 558         dev->audio_mode.ac97_vendor_id = vid;
 559         em28xx_warn("AC97 vendor ID = 0x%08x\n", vid);
 560
 561         feat = em28xx_read_ac97(dev, AC97_RESET);
 562         if (feat < 0)
 563                 goto init_audio;
 564
 565         dev->audio_mode.ac97_feat = feat;
 566         em28xx_warn("AC97 features = 0x%04x\n", feat);
 567
 568         /* Try to identify what audio processor we have */
 569         if (((vid == 0xffffffff) || (vid == 0x83847650)) && (feat == 0x6a90))
 570                 dev->audio_mode.ac97 = EM28XX_AC97_EM202;
 571         else if ((vid >> 8) == 0x838476)
 572                 dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
 573
 574 init_audio:
 575         /* Reports detected AC97 processor */
 576         switch (dev->audio_mode.ac97) {
 577         case EM28XX_NO_AC97:
 578                 em28xx_info("No AC97 audio processor\n");
 579                 break;
 580         case EM28XX_AC97_EM202:
 581                 em28xx_info("Empia 202 AC97 audio processor detected\n");
 582                 break;
 583         case EM28XX_AC97_SIGMATEL:
 584                 em28xx_info("Sigmatel audio processor detected(stac 97%02x)\n",
 585                             dev->audio_mode.ac97_vendor_id & 0xff);
 586                 break;
 587         case EM28XX_AC97_OTHER:
 588                 em28xx_warn("Unknown AC97 audio processor detected!\n");
 589                 break;
 590         default:
 591                 break;
 592         }
 593
 594         return em28xx_audio_analog_set(dev);
 595 }
 596 EXPORT_SYMBOL_GPL(em28xx_audio_setup);
 597
 598 const struct em28xx_led *em28xx_find_led(struct em28xx *dev,
 599                                          enum em28xx_led_role role)
 600 {
 601         if (dev->board.leds) {
 602                 u8 k = 0;
 603                 while (dev->board.leds[k].role >= 0 &&
 604                                dev->board.leds[k].role < EM28XX_NUM_LED_ROLES) {
 605                         if (dev->board.leds[k].role == role)
 606                                 return &dev->board.leds[k];
 607                         k++;
 608                 }
 609         }
 610         return NULL;
 611 }
 612 EXPORT_SYMBOL_GPL(em28xx_find_led);
 613
 614 int em28xx_capture_start(struct em28xx *dev, int start)
 615 {
 616         int rc;
 617
 618         if (dev->chip_id == CHIP_ID_EM2874 ||
 619             dev->chip_id == CHIP_ID_EM2884 ||
 620             dev->chip_id == CHIP_ID_EM28174 ||
 621             dev->chip_id == CHIP_ID_EM28178) {
 622                 /* The Transport Stream Enable Register moved in em2874 */
 623                 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
 624                                            start ?
 625                                                EM2874_TS1_CAPTURE_ENABLE : 0x00,
 626                                            EM2874_TS1_CAPTURE_ENABLE);
 627         } else {
 628                 /* FIXME: which is the best order? */
 629                 /* video registers are sampled by VREF */
 630                 rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
 631                                            start ? 0x10 : 0x00, 0x10);
 632                 if (rc < 0)
 633                         return rc;
 634
 635                 if (start) {
 636                         if (dev->board.is_webcam)
 637                                 rc = em28xx_write_reg(dev, 0x13, 0x0c);
 638
 639                         /* Enable video capture */
 640                         rc = em28xx_write_reg(dev, 0x48, 0x00);
 641
 642                         if (dev->mode == EM28XX_ANALOG_MODE)
 643                                 rc = em28xx_write_reg(dev,
 644                                                     EM28XX_R12_VINENABLE, 0x67);
 645                         else
 646                                 rc = em28xx_write_reg(dev,
 647                                                     EM28XX_R12_VINENABLE, 0x37);
 648
 649                         msleep(6);
 650                 } else {
 651                         /* disable video capture */
 652                         rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
 653                 }
 654         }
 655
 656         if (rc < 0)
 657                 return rc;
 658
 659         /* Switch (explicitly controlled) analog capturing LED on/off */
 660         if (dev->mode == EM28XX_ANALOG_MODE) {
 661                 const struct em28xx_led *led;
 662                 led = em28xx_find_led(dev, EM28XX_LED_ANALOG_CAPTURING);
 663                 if (led)
 664                         em28xx_write_reg_bits(dev, led->gpio_reg,
 665                                               (!start ^ led->inverted) ?
 666                                               ~led->gpio_mask : led->gpio_mask,
 667                                               led->gpio_mask);
 668         }
 669
 670         return rc;
 671 }
 672
 673 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
 674 {
 675         int rc = 0;
 676
 677         if (!gpio)
 678                 return rc;
 679
 680         if (dev->mode != EM28XX_SUSPEND) {
 681                 em28xx_write_reg(dev, 0x48, 0x00);
 682                 if (dev->mode == EM28XX_ANALOG_MODE)
 683                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
 684                 else
 685                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
 686                 msleep(6);
 687         }
 688
 689         /* Send GPIO reset sequences specified at board entry */
 690         while (gpio->sleep >= 0) {
 691                 if (gpio->reg >= 0) {
 692                         rc = em28xx_write_reg_bits(dev,
 693                                                    gpio->reg,
 694                                                    gpio->val,
 695                                                    gpio->mask);
 696                         if (rc < 0)
 697                                 return rc;
 698                 }
 699                 if (gpio->sleep > 0)
 700                         msleep(gpio->sleep);
 701
 702                 gpio++;
 703         }
 704         return rc;
 705 }
 706 EXPORT_SYMBOL_GPL(em28xx_gpio_set);
 707
 708 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
 709 {
 710         if (dev->mode == set_mode)
 711                 return 0;
 712
 713         if (set_mode == EM28XX_SUSPEND) {
 714                 dev->mode = set_mode;
 715
 716                 /* FIXME: add suspend support for ac97 */
 717
 718                 return em28xx_gpio_set(dev, dev->board.suspend_gpio);
 719         }
 720
 721         dev->mode = set_mode;
 722
 723         if (dev->mode == EM28XX_DIGITAL_MODE)
 724                 return em28xx_gpio_set(dev, dev->board.dvb_gpio);
 725         else
 726                 return em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
 727 }
 728 EXPORT_SYMBOL_GPL(em28xx_set_mode);
 729
 730 /* ------------------------------------------------------------------
 731         URB control
 732    ------------------------------------------------------------------*/
 733
 734 /*
 735  * URB completion handler for isoc/bulk transfers
 736  */
 737 static void em28xx_irq_callback(struct urb *urb)
 738 {
 739         struct em28xx *dev = urb->context;
 740         int i;
 741
 742         switch (urb->status) {
 743         case 0:             /* success */
 744         case -ETIMEDOUT:    /* NAK */
 745                 break;
 746         case -ECONNRESET:   /* kill */
 747         case -ENOENT:
 748         case -ESHUTDOWN:
 749                 return;
 750         default:            /* error */
 751                 em28xx_isocdbg("urb completition error %d.\n", urb->status);
 752                 break;
 753         }
 754
 755         /* Copy data from URB */
 756         spin_lock(&dev->slock);
 757         dev->usb_ctl.urb_data_copy(dev, urb);
 758         spin_unlock(&dev->slock);
 759
 760         /* Reset urb buffers */
 761         for (i = 0; i < urb->number_of_packets; i++) {
 762                 /* isoc only (bulk: number_of_packets = 0) */
 763                 urb->iso_frame_desc[i].status = 0;
 764                 urb->iso_frame_desc[i].actual_length = 0;
 765         }
 766         urb->status = 0;
 767
 768         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 769         if (urb->status) {
 770                 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
 771                                urb->status);
 772         }
 773 }
 774
 775 /*
 776  * Stop and Deallocate URBs
 777  */
 778 void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode)
 779 {
 780         struct urb *urb;
 781         struct em28xx_usb_bufs *usb_bufs;
 782         int i;
 783
 784         em28xx_isocdbg("em28xx: called em28xx_uninit_usb_xfer in mode %d\n",
 785                        mode);
 786
 787         if (mode == EM28XX_DIGITAL_MODE)
 788                 usb_bufs = &dev->usb_ctl.digital_bufs;
 789         else
 790                 usb_bufs = &dev->usb_ctl.analog_bufs;
 791
 792         for (i = 0; i < usb_bufs->num_bufs; i++) {
 793                 urb = usb_bufs->urb[i];
 794                 if (urb) {
 795                         if (!irqs_disabled())
 796                                 usb_kill_urb(urb);
 797                         else
 798                                 usb_unlink_urb(urb);
 799
 800                         if (usb_bufs->transfer_buffer[i]) {
 801                                 usb_free_coherent(dev->udev,
 802                                         urb->transfer_buffer_length,
 803                                         usb_bufs->transfer_buffer[i],
 804                                         urb->transfer_dma);
 805                         }
 806                         usb_free_urb(urb);
 807                         usb_bufs->urb[i] = NULL;
 808                 }
 809                 usb_bufs->transfer_buffer[i] = NULL;
 810         }
 811
 812         kfree(usb_bufs->urb);
 813         kfree(usb_bufs->transfer_buffer);
 814
 815         usb_bufs->urb = NULL;
 816         usb_bufs->transfer_buffer = NULL;
 817         usb_bufs->num_bufs = 0;
 818
 819         em28xx_capture_start(dev, 0);
 820 }
 821 EXPORT_SYMBOL_GPL(em28xx_uninit_usb_xfer);
 822
 823 /*
 824  * Stop URBs
 825  */
 826 void em28xx_stop_urbs(struct em28xx *dev)
 827 {
 828         int i;
 829         struct urb *urb;
 830         struct em28xx_usb_bufs *isoc_bufs = &dev->usb_ctl.digital_bufs;
 831
 832         em28xx_isocdbg("em28xx: called em28xx_stop_urbs\n");
 833
 834         for (i = 0; i < isoc_bufs->num_bufs; i++) {
 835                 urb = isoc_bufs->urb[i];
 836                 if (urb) {
 837                         if (!irqs_disabled())
 838                                 usb_kill_urb(urb);
 839                         else
 840                                 usb_unlink_urb(urb);
 841                 }
 842         }
 843
 844         em28xx_capture_start(dev, 0);
 845 }
 846 EXPORT_SYMBOL_GPL(em28xx_stop_urbs);
 847
 848 /*
 849  * Allocate URBs
 850  */
 851 int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
 852                       int num_bufs, int max_pkt_size, int packet_multiplier)
 853 {
 854         struct em28xx_usb_bufs *usb_bufs;
 855         int i;
 856         int sb_size, pipe;
 857         struct urb *urb;
 858         int j, k;
 859
 860         em28xx_isocdbg("em28xx: called em28xx_alloc_isoc in mode %d\n", mode);
 861
 862         /* Check mode and if we have an endpoint for the selected
 863            transfer type, select buffer                          */
 864         if (mode == EM28XX_DIGITAL_MODE) {
 865                 if ((xfer_bulk && !dev->dvb_ep_bulk) ||
 866                     (!xfer_bulk && !dev->dvb_ep_isoc)) {
 867                         em28xx_errdev("no endpoint for DVB mode and transfer type %d\n",
 868                                       xfer_bulk > 0);
 869                         return -EINVAL;
 870                 }
 871                 usb_bufs = &dev->usb_ctl.digital_bufs;
 872         } else if (mode == EM28XX_ANALOG_MODE) {
 873                 if ((xfer_bulk && !dev->analog_ep_bulk) ||
 874                     (!xfer_bulk && !dev->analog_ep_isoc)) {
 875                         em28xx_errdev("no endpoint for analog mode and transfer type %d\n",
 876                                        xfer_bulk > 0);
 877                         return -EINVAL;
 878                 }
 879                 usb_bufs = &dev->usb_ctl.analog_bufs;
 880         } else {
 881                 em28xx_errdev("invalid mode selected\n");
 882                 return -EINVAL;
 883         }
 884
 885         /* De-allocates all pending stuff */
 886         em28xx_uninit_usb_xfer(dev, mode);
 887
 888         usb_bufs->num_bufs = num_bufs;
 889
 890         usb_bufs->urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
 891         if (!usb_bufs->urb) {
 892                 em28xx_errdev("cannot alloc memory for usb buffers\n");
 893                 return -ENOMEM;
 894         }
 895
 896         usb_bufs->transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
 897                                              GFP_KERNEL);
 898         if (!usb_bufs->transfer_buffer) {
 899                 em28xx_errdev("cannot allocate memory for usb transfer\n");
 900                 kfree(usb_bufs->urb);
 901                 return -ENOMEM;
 902         }
 903
 904         usb_bufs->max_pkt_size = max_pkt_size;
 905         if (xfer_bulk)
 906                 usb_bufs->num_packets = 0;
 907         else
 908                 usb_bufs->num_packets = packet_multiplier;
 909         dev->usb_ctl.vid_buf = NULL;
 910         dev->usb_ctl.vbi_buf = NULL;
 911
 912         sb_size = packet_multiplier * usb_bufs->max_pkt_size;
 913
 914         /* allocate urbs and transfer buffers */
 915         for (i = 0; i < usb_bufs->num_bufs; i++) {
 916                 urb = usb_alloc_urb(usb_bufs->num_packets, GFP_KERNEL);
 917                 if (!urb) {
 918                         em28xx_err("cannot alloc usb_ctl.urb %i\n", i);
 919                         em28xx_uninit_usb_xfer(dev, mode);
 920                         return -ENOMEM;
 921                 }
 922                 usb_bufs->urb[i] = urb;
 923
 924                 usb_bufs->transfer_buffer[i] = usb_alloc_coherent(dev->udev,
 925                         sb_size, GFP_KERNEL, &urb->transfer_dma);
 926                 if (!usb_bufs->transfer_buffer[i]) {
 927                         em28xx_err("unable to allocate %i bytes for transfer"
 928                                         " buffer %i%s\n",
 929                                         sb_size, i,
 930                                         in_interrupt() ? " while in int" : "");
 931                         em28xx_uninit_usb_xfer(dev, mode);
 932                         return -ENOMEM;
 933                 }
 934                 memset(usb_bufs->transfer_buffer[i], 0, sb_size);
 935
 936                 if (xfer_bulk) { /* bulk */
 937                         pipe = usb_rcvbulkpipe(dev->udev,
 938                                                mode == EM28XX_ANALOG_MODE ?
 939                                                dev->analog_ep_bulk :
 940                                                dev->dvb_ep_bulk);
 941                         usb_fill_bulk_urb(urb, dev->udev, pipe,
 942                                           usb_bufs->transfer_buffer[i], sb_size,
 943                                           em28xx_irq_callback, dev);
 944                         urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 945                 } else { /* isoc */
 946                         pipe = usb_rcvisocpipe(dev->udev,
 947                                                mode == EM28XX_ANALOG_MODE ?
 948                                                dev->analog_ep_isoc :
 949                                                dev->dvb_ep_isoc);
 950                         usb_fill_int_urb(urb, dev->udev, pipe,
 951                                          usb_bufs->transfer_buffer[i], sb_size,
 952                                          em28xx_irq_callback, dev, 1);
 953                         urb->transfer_flags = URB_ISO_ASAP |
 954                                               URB_NO_TRANSFER_DMA_MAP;
 955                         k = 0;
 956                         for (j = 0; j < usb_bufs->num_packets; j++) {
 957                                 urb->iso_frame_desc[j].offset = k;
 958                                 urb->iso_frame_desc[j].length =
 959                                                         usb_bufs->max_pkt_size;
 960                                 k += usb_bufs->max_pkt_size;
 961                         }
 962                 }
 963
 964                 urb->number_of_packets = usb_bufs->num_packets;
 965         }
 966
 967         return 0;
 968 }
 969 EXPORT_SYMBOL_GPL(em28xx_alloc_urbs);
 970
 971 /*
 972  * Allocate URBs and start IRQ
 973  */
 974 int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
 975                     int xfer_bulk, int num_bufs, int max_pkt_size,
 976                     int packet_multiplier,
 977                     int (*urb_data_copy) (struct em28xx *dev, struct urb *urb))
 978 {
 979         struct em28xx_dmaqueue *dma_q = &dev->vidq;
 980         struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
 981         struct em28xx_usb_bufs *usb_bufs;
 982         int i;
 983         int rc;
 984         int alloc;
 985
 986         em28xx_isocdbg("em28xx: called em28xx_init_usb_xfer in mode %d\n",
 987                        mode);
 988
 989         dev->usb_ctl.urb_data_copy = urb_data_copy;
 990
 991         if (mode == EM28XX_DIGITAL_MODE) {
 992                 usb_bufs = &dev->usb_ctl.digital_bufs;
 993                 /* no need to free/alloc usb buffers in digital mode */
 994                 alloc = 0;
 995         } else {
 996                 usb_bufs = &dev->usb_ctl.analog_bufs;
 997                 alloc = 1;
 998         }
 999
1000         if (alloc) {
1001                 rc = em28xx_alloc_urbs(dev, mode, xfer_bulk, num_bufs,
1002                                        max_pkt_size, packet_multiplier);
1003                 if (rc)
1004                         return rc;
1005         }
1006
1007         if (xfer_bulk) {
1008                 rc = usb_clear_halt(dev->udev, usb_bufs->urb[0]->pipe);
1009                 if (rc < 0) {
1010                         em28xx_err("failed to clear USB bulk endpoint stall/halt condition (error=%i)\n",
1011                                    rc);
1012                         em28xx_uninit_usb_xfer(dev, mode);
1013                         return rc;
1014                 }
1015         }
1016
1017         init_waitqueue_head(&dma_q->wq);
1018         init_waitqueue_head(&vbi_dma_q->wq);
1019
1020         em28xx_capture_start(dev, 1);
1021
1022         /* submit urbs and enables IRQ */
1023         for (i = 0; i < usb_bufs->num_bufs; i++) {
1024                 rc = usb_submit_urb(usb_bufs->urb[i], GFP_ATOMIC);
1025                 if (rc) {
1026                         em28xx_err("submit of urb %i failed (error=%i)\n", i,
1027                                    rc);
1028                         em28xx_uninit_usb_xfer(dev, mode);
1029                         return rc;
1030                 }
1031         }
1032
1033         return 0;
1034 }
1035 EXPORT_SYMBOL_GPL(em28xx_init_usb_xfer);
1036
1037 /*
1038  * Device control list
1039  */
1040
1041 static LIST_HEAD(em28xx_devlist);
1042 static DEFINE_MUTEX(em28xx_devlist_mutex);
1043
1044 /*
1045  * Extension interface
1046  */
1047
1048 static LIST_HEAD(em28xx_extension_devlist);
1049
1050 int em28xx_register_extension(struct em28xx_ops *ops)
1051 {
1052         struct em28xx *dev = NULL;
1053
1054         mutex_lock(&em28xx_devlist_mutex);
1055         list_add_tail(&ops->next, &em28xx_extension_devlist);
1056         list_for_each_entry(dev, &em28xx_devlist, devlist) {
1057                 ops->init(dev);
1058         }
1059         mutex_unlock(&em28xx_devlist_mutex);
1060         printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
1061         return 0;
1062 }
1063 EXPORT_SYMBOL(em28xx_register_extension);
1064
1065 void em28xx_unregister_extension(struct em28xx_ops *ops)
1066 {
1067         struct em28xx *dev = NULL;
1068
1069         mutex_lock(&em28xx_devlist_mutex);
1070         list_for_each_entry(dev, &em28xx_devlist, devlist) {
1071                 ops->fini(dev);
1072         }
1073         list_del(&ops->next);
1074         mutex_unlock(&em28xx_devlist_mutex);
1075         printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
1076 }
1077 EXPORT_SYMBOL(em28xx_unregister_extension);
1078
1079 void em28xx_init_extension(struct em28xx *dev)
1080 {
1081         const struct em28xx_ops *ops = NULL;
1082
1083         mutex_lock(&em28xx_devlist_mutex);
1084         list_add_tail(&dev->devlist, &em28xx_devlist);
1085         list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1086                 if (ops->init)
1087                         ops->init(dev);
1088         }
1089         mutex_unlock(&em28xx_devlist_mutex);
1090 }
1091
1092 void em28xx_close_extension(struct em28xx *dev)
1093 {
1094         const struct em28xx_ops *ops = NULL;
1095
1096         mutex_lock(&em28xx_devlist_mutex);
1097         list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1098                 if (ops->fini)
1099                         ops->fini(dev);
1100         }
1101         list_del(&dev->devlist);
1102         mutex_unlock(&em28xx_devlist_mutex);
1103 }