SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/em28xx/em28xx-core.c

   1 /*
   2    em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
   3
   4    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
   5                       Markus Rechberger <mrechberger@gmail.com>
   6                       Mauro Carvalho Chehab <mchehab@infradead.org>
   7                       Sascha Sommer <saschasommer@freenet.de>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/init.h>
  25 #include <linux/list.h>
  26 #include <linux/module.h>
  27 #include <linux/usb.h>
  28 #include <linux/vmalloc.h>
  29
  30 #include "em28xx.h"
  31
  32 /* #define ENABLE_DEBUG_ISOC_FRAMES */
  33
  34 static unsigned int core_debug;
  35 module_param(core_debug,int,0644);
  36 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
  37
  38 #define em28xx_coredbg(fmt, arg...) do {\
  39         if (core_debug) \
  40                 printk(KERN_INFO "%s %s :"fmt, \
  41                          dev->name, __func__ , ##arg); } while (0)
  42
  43 static unsigned int reg_debug;
  44 module_param(reg_debug,int,0644);
  45 MODULE_PARM_DESC(reg_debug,"enable debug messages [URB reg]");
  46
  47 #define em28xx_regdbg(fmt, arg...) do {\
  48         if (reg_debug) \
  49                 printk(KERN_INFO "%s %s :"fmt, \
  50                          dev->name, __func__ , ##arg); } while (0)
  51
  52 static int alt = EM28XX_PINOUT;
  53 module_param(alt, int, 0644);
  54 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
  55
  56 /* FIXME */
  57 #define em28xx_isocdbg(fmt, arg...) do {\
  58         if (core_debug) \
  59                 printk(KERN_INFO "%s %s :"fmt, \
  60                          dev->name, __func__ , ##arg); } while (0)
  61
  62 /*
  63  * em28xx_read_reg_req()
  64  * reads data from the usb device specifying bRequest
  65  */
  66 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
  67                                    char *buf, int len)
  68 {
  69         int ret;
  70         int pipe = usb_rcvctrlpipe(dev->udev, 0);
  71
  72         if (dev->state & 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 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
 137 /*
 138  * em28xx_write_regs_req()
 139  * sends data to the usb device, specifying bRequest
 140  */
 141 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
 142                                  int len)
 143 {
 144         int ret;
 145         int pipe = usb_sndctrlpipe(dev->udev, 0);
 146
 147         if (dev->state & DEV_DISCONNECTED)
 148                 return -ENODEV;
 149
 150         if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
 151                 return -EINVAL;
 152
 153         if (reg_debug) {
 154                 int byte;
 155
 156                 printk( KERN_DEBUG "(pipe 0x%08x): "
 157                         "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>",
 158                         pipe,
 159                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 160                         req, 0, 0,
 161                         reg & 0xff, reg >> 8,
 162                         len & 0xff, len >> 8);
 163
 164                 for (byte = 0; byte < len; byte++)
 165                         printk(" %02x", (unsigned char)buf[byte]);
 166                 printk("\n");
 167         }
 168
 169         mutex_lock(&dev->ctrl_urb_lock);
 170         memcpy(dev->urb_buf, buf, len);
 171         ret = usb_control_msg(dev->udev, pipe, req,
 172                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 173                               0x0000, reg, dev->urb_buf, len, HZ);
 174         mutex_unlock(&dev->ctrl_urb_lock);
 175
 176         if (dev->wait_after_write)
 177                 msleep(dev->wait_after_write);
 178
 179         return ret;
 180 }
 181
 182 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
 183 {
 184         int rc;
 185
 186         rc = em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
 187
 188         /* Stores GPO/GPIO values at the cache, if changed
 189            Only write values should be stored, since input on a GPIO
 190            register will return the input bits.
 191            Not sure what happens on reading GPO register.
 192          */
 193         if (rc >= 0) {
 194                 if (reg == dev->reg_gpo_num)
 195                         dev->reg_gpo = buf[0];
 196                 else if (reg == dev->reg_gpio_num)
 197                         dev->reg_gpio = buf[0];
 198         }
 199
 200         return rc;
 201 }
 202
 203 /* Write a single register */
 204 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
 205 {
 206         return em28xx_write_regs(dev, reg, &val, 1);
 207 }
 208
 209 /*
 210  * em28xx_write_reg_bits()
 211  * sets only some bits (specified by bitmask) of a register, by first reading
 212  * the actual value
 213  */
 214 static int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
 215                                  u8 bitmask)
 216 {
 217         int oldval;
 218         u8 newval;
 219
 220         /* Uses cache for gpo/gpio registers */
 221         if (reg == dev->reg_gpo_num)
 222                 oldval = dev->reg_gpo;
 223         else if (reg == dev->reg_gpio_num)
 224                 oldval = dev->reg_gpio;
 225         else
 226                 oldval = em28xx_read_reg(dev, reg);
 227
 228         if (oldval < 0)
 229                 return oldval;
 230
 231         newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
 232
 233         return em28xx_write_regs(dev, reg, &newval, 1);
 234 }
 235
 236 /*
 237  * em28xx_is_ac97_ready()
 238  * Checks if ac97 is ready
 239  */
 240 static int em28xx_is_ac97_ready(struct em28xx *dev)
 241 {
 242         int ret, i;
 243
 244         /* Wait up to 50 ms for AC97 command to complete */
 245         for (i = 0; i < 10; i++, msleep(5)) {
 246                 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
 247                 if (ret < 0)
 248                         return ret;
 249
 250                 if (!(ret & 0x01))
 251                         return 0;
 252         }
 253
 254         em28xx_warn("AC97 command still being executed: not handled properly!\n");
 255         return -EBUSY;
 256 }
 257
 258 /*
 259  * em28xx_read_ac97()
 260  * write a 16 bit value to the specified AC97 address (LSB first!)
 261  */
 262 static int em28xx_read_ac97(struct em28xx *dev, u8 reg)
 263 {
 264         int ret;
 265         u8 addr = (reg & 0x7f) | 0x80;
 266         u16 val;
 267
 268         ret = em28xx_is_ac97_ready(dev);
 269         if (ret < 0)
 270                 return ret;
 271
 272         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 273         if (ret < 0)
 274                 return ret;
 275
 276         ret = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R40_AC97LSB,
 277                                            (u8 *)&val, sizeof(val));
 278
 279         if (ret < 0)
 280                 return ret;
 281         return le16_to_cpu(val);
 282 }
 283
 284 /*
 285  * em28xx_write_ac97()
 286  * write a 16 bit value to the specified AC97 address (LSB first!)
 287  */
 288 static int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
 289 {
 290         int ret;
 291         u8 addr = reg & 0x7f;
 292         __le16 value;
 293
 294         value = cpu_to_le16(val);
 295
 296         ret = em28xx_is_ac97_ready(dev);
 297         if (ret < 0)
 298                 return ret;
 299
 300         ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *) &value, 2);
 301         if (ret < 0)
 302                 return ret;
 303
 304         ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
 305         if (ret < 0)
 306                 return ret;
 307
 308         return 0;
 309 }
 310
 311 struct em28xx_vol_table {
 312         enum em28xx_amux mux;
 313         u8               reg;
 314 };
 315
 316 static struct em28xx_vol_table inputs[] = {
 317         { EM28XX_AMUX_VIDEO,    AC97_VIDEO_VOL   },
 318         { EM28XX_AMUX_LINE_IN,  AC97_LINEIN_VOL  },
 319         { EM28XX_AMUX_PHONE,    AC97_PHONE_VOL   },
 320         { EM28XX_AMUX_MIC,      AC97_MIC_VOL     },
 321         { EM28XX_AMUX_CD,       AC97_CD_VOL      },
 322         { EM28XX_AMUX_AUX,      AC97_AUX_VOL     },
 323         { EM28XX_AMUX_PCM_OUT,  AC97_PCM_OUT_VOL },
 324 };
 325
 326 static int set_ac97_input(struct em28xx *dev)
 327 {
 328         int ret, i;
 329         enum em28xx_amux amux = dev->ctl_ainput;
 330
 331         /* EM28XX_AMUX_VIDEO2 is a special case used to indicate that
 332            em28xx should point to LINE IN, while AC97 should use VIDEO
 333          */
 334         if (amux == EM28XX_AMUX_VIDEO2)
 335                 amux = EM28XX_AMUX_VIDEO;
 336
 337         /* Mute all entres but the one that were selected */
 338         for (i = 0; i < ARRAY_SIZE(inputs); i++) {
 339                 if (amux == inputs[i].mux)
 340                         ret = em28xx_write_ac97(dev, inputs[i].reg, 0x0808);
 341                 else
 342                         ret = em28xx_write_ac97(dev, inputs[i].reg, 0x8000);
 343
 344                 if (ret < 0)
 345                         em28xx_warn("couldn't setup AC97 register %d\n",
 346                                      inputs[i].reg);
 347         }
 348         return 0;
 349 }
 350
 351 static int em28xx_set_audio_source(struct em28xx *dev)
 352 {
 353         int ret;
 354         u8 input;
 355
 356         if (dev->board.is_em2800) {
 357                 if (dev->ctl_ainput == EM28XX_AMUX_VIDEO)
 358                         input = EM2800_AUDIO_SRC_TUNER;
 359                 else
 360                         input = EM2800_AUDIO_SRC_LINE;
 361
 362                 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
 363                 if (ret < 0)
 364                         return ret;
 365         }
 366
 367         if (dev->board.has_msp34xx)
 368                 input = EM28XX_AUDIO_SRC_TUNER;
 369         else {
 370                 switch (dev->ctl_ainput) {
 371                 case EM28XX_AMUX_VIDEO:
 372                         input = EM28XX_AUDIO_SRC_TUNER;
 373                         break;
 374                 default:
 375                         input = EM28XX_AUDIO_SRC_LINE;
 376                         break;
 377                 }
 378         }
 379
 380         ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
 381         if (ret < 0)
 382                 return ret;
 383         msleep(5);
 384
 385         switch (dev->audio_mode.ac97) {
 386         case EM28XX_NO_AC97:
 387                 break;
 388         default:
 389                 ret = set_ac97_input(dev);
 390         }
 391
 392         return ret;
 393 }
 394
 395 struct em28xx_vol_table outputs[] = {
 396         { EM28XX_AOUT_MASTER, AC97_MASTER_VOL      },
 397         { EM28XX_AOUT_LINE,   AC97_LINE_LEVEL_VOL  },
 398         { EM28XX_AOUT_MONO,   AC97_MASTER_MONO_VOL },
 399         { EM28XX_AOUT_LFE,    AC97_LFE_MASTER_VOL  },
 400         { EM28XX_AOUT_SURR,   AC97_SURR_MASTER_VOL },
 401 };
 402
 403 int em28xx_audio_analog_set(struct em28xx *dev)
 404 {
 405         int ret, i;
 406         u8 xclk;
 407
 408         if (!dev->audio_mode.has_audio)
 409                 return 0;
 410
 411         /* It is assumed that all devices use master volume for output.
 412            It would be possible to use also line output.
 413          */
 414         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 415                 /* Mute all outputs */
 416                 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
 417                         ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
 418                         if (ret < 0)
 419                                 em28xx_warn("couldn't setup AC97 register %d\n",
 420                                      outputs[i].reg);
 421                 }
 422         }
 423
 424         xclk = dev->board.xclk & 0x7f;
 425         if (!dev->mute)
 426                 xclk |= 0x80;
 427
 428         ret = em28xx_write_reg(dev, EM28XX_R0F_XCLK, xclk);
 429         if (ret < 0)
 430                 return ret;
 431         msleep(10);
 432
 433         /* Selects the proper audio input */
 434         ret = em28xx_set_audio_source(dev);
 435
 436         /* Sets volume */
 437         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 438                 int vol;
 439
 440                 /* LSB: left channel - both channels with the same level */
 441                 vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);
 442
 443                 /* Mute device, if needed */
 444                 if (dev->mute)
 445                         vol |= 0x8000;
 446
 447                 /* Sets volume */
 448                 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
 449                         if (dev->ctl_aoutput & outputs[i].mux)
 450                                 ret = em28xx_write_ac97(dev, outputs[i].reg,
 451                                                         vol);
 452                         if (ret < 0)
 453                                 em28xx_warn("couldn't setup AC97 register %d\n",
 454                                      outputs[i].reg);
 455                 }
 456         }
 457
 458         return ret;
 459 }
 460 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
 461
 462 int em28xx_audio_setup(struct em28xx *dev)
 463 {
 464         int vid1, vid2, feat, cfg;
 465         u32 vid;
 466
 467         if (dev->chip_id == CHIP_ID_EM2874) {
 468                 /* Digital only device - don't load any alsa module */
 469                 dev->audio_mode.has_audio = 0;
 470                 dev->has_audio_class = 0;
 471                 dev->has_alsa_audio = 0;
 472                 return 0;
 473         }
 474
 475         /* If device doesn't support Usb Audio Class, use vendor class */
 476         if (!dev->has_audio_class)
 477                 dev->has_alsa_audio = 1;
 478
 479         dev->audio_mode.has_audio = 1;
 480
 481         /* See how this device is configured */
 482         cfg = em28xx_read_reg(dev, EM28XX_R00_CHIPCFG);
 483         if (cfg < 0)
 484                 cfg = EM28XX_CHIPCFG_AC97; /* Be conservative */
 485         else
 486                 em28xx_info("Config register raw data: 0x%02x\n", cfg);
 487
 488         if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
 489                     EM28XX_CHIPCFG_I2S_3_SAMPRATES) {
 490                 em28xx_info("I2S Audio (3 sample rates)\n");
 491                 dev->audio_mode.i2s_3rates = 1;
 492         }
 493         if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
 494                     EM28XX_CHIPCFG_I2S_5_SAMPRATES) {
 495                 em28xx_info("I2S Audio (5 sample rates)\n");
 496                 dev->audio_mode.i2s_5rates = 1;
 497         }
 498
 499         if (!(cfg & EM28XX_CHIPCFG_AC97)) {
 500                 dev->audio_mode.ac97 = EM28XX_NO_AC97;
 501                 goto init_audio;
 502         }
 503
 504         dev->audio_mode.ac97 = EM28XX_AC97_OTHER;
 505
 506         vid1 = em28xx_read_ac97(dev, AC97_VENDOR_ID1);
 507         if (vid1 < 0) {
 508                 /* Device likely doesn't support AC97 */
 509                 em28xx_warn("AC97 chip type couldn't be determined\n");
 510                 goto init_audio;
 511         }
 512
 513         vid2 = em28xx_read_ac97(dev, AC97_VENDOR_ID2);
 514         if (vid2 < 0)
 515                 goto init_audio;
 516
 517         vid = vid1 << 16 | vid2;
 518
 519         dev->audio_mode.ac97_vendor_id = vid;
 520         em28xx_warn("AC97 vendor ID = 0x%08x\n", vid);
 521
 522         feat = em28xx_read_ac97(dev, AC97_RESET);
 523         if (feat < 0)
 524                 goto init_audio;
 525
 526         dev->audio_mode.ac97_feat = feat;
 527         em28xx_warn("AC97 features = 0x%04x\n", feat);
 528
 529         /* Try to identify what audio processor we have */
 530         if ((vid == 0xffffffff) && (feat == 0x6a90))
 531                 dev->audio_mode.ac97 = EM28XX_AC97_EM202;
 532         else if ((vid >> 8) == 0x838476)
 533                 dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
 534
 535 init_audio:
 536         /* Reports detected AC97 processor */
 537         switch (dev->audio_mode.ac97) {
 538         case EM28XX_NO_AC97:
 539                 em28xx_info("No AC97 audio processor\n");
 540                 break;
 541         case EM28XX_AC97_EM202:
 542                 em28xx_info("Empia 202 AC97 audio processor detected\n");
 543                 break;
 544         case EM28XX_AC97_SIGMATEL:
 545                 em28xx_info("Sigmatel audio processor detected(stac 97%02x)\n",
 546                             dev->audio_mode.ac97_vendor_id & 0xff);
 547                 break;
 548         case EM28XX_AC97_OTHER:
 549                 em28xx_warn("Unknown AC97 audio processor detected!\n");
 550                 break;
 551         default:
 552                 break;
 553         }
 554
 555         return em28xx_audio_analog_set(dev);
 556 }
 557 EXPORT_SYMBOL_GPL(em28xx_audio_setup);
 558
 559 int em28xx_colorlevels_set_default(struct em28xx *dev)
 560 {
 561         em28xx_write_reg(dev, EM28XX_R20_YGAIN, 0x10);  /* contrast */
 562         em28xx_write_reg(dev, EM28XX_R21_YOFFSET, 0x00);        /* brightness */
 563         em28xx_write_reg(dev, EM28XX_R22_UVGAIN, 0x10); /* saturation */
 564         em28xx_write_reg(dev, EM28XX_R23_UOFFSET, 0x00);
 565         em28xx_write_reg(dev, EM28XX_R24_VOFFSET, 0x00);
 566         em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, 0x00);
 567
 568         em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
 569         em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
 570         em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
 571         em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
 572         em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
 573         em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
 574         return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
 575 }
 576
 577 int em28xx_capture_start(struct em28xx *dev, int start)
 578 {
 579         int rc;
 580
 581         if (dev->chip_id == CHIP_ID_EM2874) {
 582                 /* The Transport Stream Enable Register moved in em2874 */
 583                 if (!start) {
 584                         rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
 585                                                    0x00,
 586                                                    EM2874_TS1_CAPTURE_ENABLE);
 587                         return rc;
 588                 }
 589
 590                 /* Enable Transport Stream */
 591                 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
 592                                            EM2874_TS1_CAPTURE_ENABLE,
 593                                            EM2874_TS1_CAPTURE_ENABLE);
 594                 return rc;
 595         }
 596
 597
 598         /* FIXME: which is the best order? */
 599         /* video registers are sampled by VREF */
 600         rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
 601                                    start ? 0x10 : 0x00, 0x10);
 602         if (rc < 0)
 603                 return rc;
 604
 605         if (!start) {
 606                 /* disable video capture */
 607                 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
 608                 return rc;
 609         }
 610
 611         /* enable video capture */
 612         rc = em28xx_write_reg(dev, 0x48, 0x00);
 613
 614         if (dev->mode == EM28XX_ANALOG_MODE)
 615                 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
 616         else
 617                 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
 618
 619         msleep(6);
 620
 621         return rc;
 622 }
 623
 624 int em28xx_set_outfmt(struct em28xx *dev)
 625 {
 626         int ret;
 627
 628         ret = em28xx_write_reg_bits(dev, EM28XX_R27_OUTFMT,
 629                                     dev->format->reg | 0x20, 0x3f);
 630         if (ret < 0)
 631                 return ret;
 632
 633         ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, 0x10);
 634         if (ret < 0)
 635                 return ret;
 636
 637         return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, 0x11);
 638 }
 639
 640 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
 641                                   u8 ymin, u8 ymax)
 642 {
 643         em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
 644                         xmin, ymin, xmax, ymax);
 645
 646         em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
 647         em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
 648         em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
 649         return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
 650 }
 651
 652 static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
 653                                    u16 width, u16 height)
 654 {
 655         u8 cwidth = width;
 656         u8 cheight = height;
 657         u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
 658
 659         em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
 660                         (width | (overflow & 2) << 7),
 661                         (height | (overflow & 1) << 8));
 662
 663         em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
 664         em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
 665         em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
 666         em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
 667         return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
 668 }
 669
 670 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 671 {
 672         u8 mode;
 673         /* the em2800 scaler only supports scaling down to 50% */
 674         if (dev->board.is_em2800)
 675                 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
 676         else {
 677                 u8 buf[2];
 678                 buf[0] = h;
 679                 buf[1] = h >> 8;
 680                 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
 681                 buf[0] = v;
 682                 buf[1] = v >> 8;
 683                 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
 684                 /* it seems that both H and V scalers must be active
 685                    to work correctly */
 686                 mode = (h || v)? 0x30: 0x00;
 687         }
 688         return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
 689 }
 690
 691 /* FIXME: this only function read values from dev */
 692 int em28xx_resolution_set(struct em28xx *dev)
 693 {
 694         int width, height;
 695         width = norm_maxw(dev);
 696         height = norm_maxh(dev) >> 1;
 697
 698         em28xx_set_outfmt(dev);
 699         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
 700         em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
 701         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 702 }
 703
 704 int em28xx_set_alternate(struct em28xx *dev)
 705 {
 706         int errCode, prev_alt = dev->alt;
 707         int i;
 708         unsigned int min_pkt_size = dev->width * 2 + 4;
 709
 710         /* When image size is bigger than a certain value,
 711            the frame size should be increased, otherwise, only
 712            green screen will be received.
 713          */
 714         if (dev->width * 2 * dev->height > 720 * 240 * 2)
 715                 min_pkt_size *= 2;
 716
 717         for (i = 0; i < dev->num_alt; i++) {
 718                 /* stop when the selected alt setting offers enough bandwidth */
 719                 if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
 720                         dev->alt = i;
 721                         break;
 722                 /* otherwise make sure that we end up with the maximum bandwidth
 723                    because the min_pkt_size equation might be wrong...
 724                 */
 725                 } else if (dev->alt_max_pkt_size[i] >
 726                            dev->alt_max_pkt_size[dev->alt])
 727                         dev->alt = i;
 728         }
 729
 730         if (dev->alt != prev_alt) {
 731                 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
 732                                 min_pkt_size, dev->alt);
 733                 dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
 734                 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
 735                                dev->alt, dev->max_pkt_size);
 736                 errCode = usb_set_interface(dev->udev, 0, dev->alt);
 737                 if (errCode < 0) {
 738                         em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
 739                                         dev->alt, errCode);
 740                         return errCode;
 741                 }
 742         }
 743         return 0;
 744 }
 745
 746 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
 747 {
 748         int rc = 0;
 749
 750         if (!gpio)
 751                 return rc;
 752
 753         if (dev->mode != EM28XX_SUSPEND) {
 754                 em28xx_write_reg(dev, 0x48, 0x00);
 755                 if (dev->mode == EM28XX_ANALOG_MODE)
 756                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
 757                 else
 758                         em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
 759                 msleep(6);
 760         }
 761
 762         /* Send GPIO reset sequences specified at board entry */
 763         while (gpio->sleep >= 0) {
 764                 if (gpio->reg >= 0) {
 765                         rc = em28xx_write_reg_bits(dev,
 766                                                    gpio->reg,
 767                                                    gpio->val,
 768                                                    gpio->mask);
 769                         if (rc < 0)
 770                                 return rc;
 771                 }
 772                 if (gpio->sleep > 0)
 773                         msleep(gpio->sleep);
 774
 775                 gpio++;
 776         }
 777         return rc;
 778 }
 779
 780 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
 781 {
 782         if (dev->mode == set_mode)
 783                 return 0;
 784
 785         if (set_mode == EM28XX_SUSPEND) {
 786                 dev->mode = set_mode;
 787
 788                 /* FIXME: add suspend support for ac97 */
 789
 790                 return em28xx_gpio_set(dev, dev->board.suspend_gpio);
 791         }
 792
 793         dev->mode = set_mode;
 794
 795         if (dev->mode == EM28XX_DIGITAL_MODE)
 796                 return em28xx_gpio_set(dev, dev->board.dvb_gpio);
 797         else
 798                 return em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
 799 }
 800 EXPORT_SYMBOL_GPL(em28xx_set_mode);
 801
 802 /* ------------------------------------------------------------------
 803         URB control
 804    ------------------------------------------------------------------*/
 805
 806 /*
 807  * IRQ callback, called by URB callback
 808  */
 809 static void em28xx_irq_callback(struct urb *urb)
 810 {
 811         struct em28xx_dmaqueue  *dma_q = urb->context;
 812         struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
 813         int rc, i;
 814
 815         /* Copy data from URB */
 816         spin_lock(&dev->slock);
 817         rc = dev->isoc_ctl.isoc_copy(dev, urb);
 818         spin_unlock(&dev->slock);
 819
 820         /* Reset urb buffers */
 821         for (i = 0; i < urb->number_of_packets; i++) {
 822                 urb->iso_frame_desc[i].status = 0;
 823                 urb->iso_frame_desc[i].actual_length = 0;
 824         }
 825         urb->status = 0;
 826
 827         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 828         if (urb->status) {
 829                 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
 830                                urb->status);
 831         }
 832 }
 833
 834 /*
 835  * Stop and Deallocate URBs
 836  */
 837 void em28xx_uninit_isoc(struct em28xx *dev)
 838 {
 839         struct urb *urb;
 840         int i;
 841
 842         em28xx_isocdbg("em28xx: called em28xx_uninit_isoc\n");
 843
 844         dev->isoc_ctl.nfields = -1;
 845         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 846                 urb = dev->isoc_ctl.urb[i];
 847                 if (urb) {
 848                         usb_kill_urb(urb);
 849                         usb_unlink_urb(urb);
 850                         if (dev->isoc_ctl.transfer_buffer[i]) {
 851                                 usb_buffer_free(dev->udev,
 852                                         urb->transfer_buffer_length,
 853                                         dev->isoc_ctl.transfer_buffer[i],
 854                                         urb->transfer_dma);
 855                         }
 856                         usb_free_urb(urb);
 857                         dev->isoc_ctl.urb[i] = NULL;
 858                 }
 859                 dev->isoc_ctl.transfer_buffer[i] = NULL;
 860         }
 861
 862         kfree(dev->isoc_ctl.urb);
 863         kfree(dev->isoc_ctl.transfer_buffer);
 864
 865         dev->isoc_ctl.urb = NULL;
 866         dev->isoc_ctl.transfer_buffer = NULL;
 867         dev->isoc_ctl.num_bufs = 0;
 868
 869         em28xx_capture_start(dev, 0);
 870 }
 871 EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
 872
 873 /*
 874  * Allocate URBs and start IRQ
 875  */
 876 int em28xx_init_isoc(struct em28xx *dev, int max_packets,
 877                      int num_bufs, int max_pkt_size,
 878                      int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
 879 {
 880         struct em28xx_dmaqueue *dma_q = &dev->vidq;
 881         int i;
 882         int sb_size, pipe;
 883         struct urb *urb;
 884         int j, k;
 885         int rc;
 886
 887         em28xx_isocdbg("em28xx: called em28xx_prepare_isoc\n");
 888
 889         /* De-allocates all pending stuff */
 890         em28xx_uninit_isoc(dev);
 891
 892         dev->isoc_ctl.isoc_copy = isoc_copy;
 893         dev->isoc_ctl.num_bufs = num_bufs;
 894
 895         dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
 896         if (!dev->isoc_ctl.urb) {
 897                 em28xx_errdev("cannot alloc memory for usb buffers\n");
 898                 return -ENOMEM;
 899         }
 900
 901         dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
 902                                               GFP_KERNEL);
 903         if (!dev->isoc_ctl.transfer_buffer) {
 904                 em28xx_errdev("cannot allocate memory for usbtransfer\n");
 905                 kfree(dev->isoc_ctl.urb);
 906                 return -ENOMEM;
 907         }
 908
 909         dev->isoc_ctl.max_pkt_size = max_pkt_size;
 910         dev->isoc_ctl.buf = NULL;
 911
 912         sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
 913
 914         /* allocate urbs and transfer buffers */
 915         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 916                 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
 917                 if (!urb) {
 918                         em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
 919                         em28xx_uninit_isoc(dev);
 920                         return -ENOMEM;
 921                 }
 922                 dev->isoc_ctl.urb[i] = urb;
 923
 924                 dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->udev,
 925                         sb_size, GFP_KERNEL, &urb->transfer_dma);
 926                 if (!dev->isoc_ctl.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_isoc(dev);
 932                         return -ENOMEM;
 933                 }
 934                 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
 935
 936                 /* FIXME: this is a hack - should be
 937                         'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
 938                         should also be using 'desc.bInterval'
 939                  */
 940                 pipe = usb_rcvisocpipe(dev->udev,
 941                         dev->mode == EM28XX_ANALOG_MODE ? 0x82 : 0x84);
 942
 943                 usb_fill_int_urb(urb, dev->udev, pipe,
 944                                  dev->isoc_ctl.transfer_buffer[i], sb_size,
 945                                  em28xx_irq_callback, dma_q, 1);
 946
 947                 urb->number_of_packets = max_packets;
 948                 urb->transfer_flags = URB_ISO_ASAP;
 949
 950                 k = 0;
 951                 for (j = 0; j < max_packets; j++) {
 952                         urb->iso_frame_desc[j].offset = k;
 953                         urb->iso_frame_desc[j].length =
 954                                                 dev->isoc_ctl.max_pkt_size;
 955                         k += dev->isoc_ctl.max_pkt_size;
 956                 }
 957         }
 958
 959         init_waitqueue_head(&dma_q->wq);
 960
 961         em28xx_capture_start(dev, 1);
 962
 963         /* submit urbs and enables IRQ */
 964         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 965                 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
 966                 if (rc) {
 967                         em28xx_err("submit of urb %i failed (error=%i)\n", i,
 968                                    rc);
 969                         em28xx_uninit_isoc(dev);
 970                         return rc;
 971                 }
 972         }
 973
 974         return 0;
 975 }
 976 EXPORT_SYMBOL_GPL(em28xx_init_isoc);