Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
0004 //
0005 // Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
0006 //            Markus Rechberger <mrechberger@gmail.com>
0007 //            Mauro Carvalho Chehab <mchehab@kernel.org>
0008 //            Sascha Sommer <saschasommer@freenet.de>
0009 // Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
0010 
0011 #include "em28xx.h"
0012 
0013 #include <linux/init.h>
0014 #include <linux/jiffies.h>
0015 #include <linux/list.h>
0016 #include <linux/module.h>
0017 #include <linux/slab.h>
0018 #include <linux/usb.h>
0019 #include <linux/vmalloc.h>
0020 #include <sound/ac97_codec.h>
0021 #include <media/v4l2-common.h>
0022 
0023 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
0024               "Markus Rechberger <mrechberger@gmail.com>, " \
0025               "Mauro Carvalho Chehab <mchehab@kernel.org>, " \
0026               "Sascha Sommer <saschasommer@freenet.de>"
0027 
0028 MODULE_AUTHOR(DRIVER_AUTHOR);
0029 MODULE_DESCRIPTION(DRIVER_DESC);
0030 MODULE_LICENSE("GPL v2");
0031 MODULE_VERSION(EM28XX_VERSION);
0032 
0033 /* #define ENABLE_DEBUG_ISOC_FRAMES */
0034 
0035 static unsigned int core_debug;
0036 module_param(core_debug, int, 0644);
0037 MODULE_PARM_DESC(core_debug, "enable debug messages [core and isoc]");
0038 
0039 #define em28xx_coredbg(fmt, arg...) do {                \
0040     if (core_debug)                         \
0041         dev_printk(KERN_DEBUG, &dev->intf->dev,         \
0042                "core: %s: " fmt, __func__, ## arg);     \
0043 } while (0)
0044 
0045 static unsigned int reg_debug;
0046 module_param(reg_debug, int, 0644);
0047 MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
0048 
0049 #define em28xx_regdbg(fmt, arg...) do {             \
0050     if (reg_debug)                          \
0051         dev_printk(KERN_DEBUG, &dev->intf->dev,         \
0052                "reg: %s: " fmt, __func__, ## arg);      \
0053 } while (0)
0054 
0055 /* FIXME: don't abuse core_debug */
0056 #define em28xx_isocdbg(fmt, arg...) do {                \
0057     if (core_debug)                         \
0058         dev_printk(KERN_DEBUG, &dev->intf->dev,         \
0059                "core: %s: " fmt, __func__, ## arg);     \
0060 } while (0)
0061 
0062 /*
0063  * em28xx_read_reg_req()
0064  * reads data from the usb device specifying bRequest
0065  */
0066 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
0067                 char *buf, int len)
0068 {
0069     int ret;
0070     struct usb_device *udev = interface_to_usbdev(dev->intf);
0071     int pipe = usb_rcvctrlpipe(udev, 0);
0072 
0073     if (dev->disconnected)
0074         return -ENODEV;
0075 
0076     if (len > URB_MAX_CTRL_SIZE)
0077         return -EINVAL;
0078 
0079     mutex_lock(&dev->ctrl_urb_lock);
0080     ret = usb_control_msg(udev, pipe, req,
0081                   USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0082                   0x0000, reg, dev->urb_buf, len, 1000);
0083     if (ret < 0) {
0084         em28xx_regdbg("(pipe 0x%08x): IN:  %02x %02x %02x %02x %02x %02x %02x %02x  failed with error %i\n",
0085                   pipe,
0086                   USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0087                   req, 0, 0,
0088                   reg & 0xff, reg >> 8,
0089                   len & 0xff, len >> 8, ret);
0090         mutex_unlock(&dev->ctrl_urb_lock);
0091         return usb_translate_errors(ret);
0092     }
0093 
0094     if (len)
0095         memcpy(buf, dev->urb_buf, len);
0096 
0097     mutex_unlock(&dev->ctrl_urb_lock);
0098 
0099     em28xx_regdbg("(pipe 0x%08x): IN:  %02x %02x %02x %02x %02x %02x %02x %02x <<< %*ph\n",
0100               pipe, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0101               req, 0, 0,
0102               reg & 0xff, reg >> 8,
0103               len & 0xff, len >> 8, len, buf);
0104 
0105     return ret;
0106 }
0107 
0108 /*
0109  * em28xx_read_reg_req()
0110  * reads data from the usb device specifying bRequest
0111  */
0112 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
0113 {
0114     int ret;
0115     u8 val;
0116 
0117     ret = em28xx_read_reg_req_len(dev, req, reg, &val, 1);
0118     if (ret < 0)
0119         return ret;
0120 
0121     return val;
0122 }
0123 
0124 int em28xx_read_reg(struct em28xx *dev, u16 reg)
0125 {
0126     return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
0127 }
0128 EXPORT_SYMBOL_GPL(em28xx_read_reg);
0129 
0130 /*
0131  * em28xx_write_regs_req()
0132  * sends data to the usb device, specifying bRequest
0133  */
0134 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
0135               int len)
0136 {
0137     int ret;
0138     struct usb_device *udev = interface_to_usbdev(dev->intf);
0139     int pipe = usb_sndctrlpipe(udev, 0);
0140 
0141     if (dev->disconnected)
0142         return -ENODEV;
0143 
0144     if (len < 1 || len > URB_MAX_CTRL_SIZE)
0145         return -EINVAL;
0146 
0147     mutex_lock(&dev->ctrl_urb_lock);
0148     memcpy(dev->urb_buf, buf, len);
0149     ret = usb_control_msg(udev, pipe, req,
0150                   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0151                   0x0000, reg, dev->urb_buf, len, 1000);
0152     mutex_unlock(&dev->ctrl_urb_lock);
0153 
0154     if (ret < 0) {
0155         em28xx_regdbg("(pipe 0x%08x): OUT:  %02x %02x %02x %02x %02x %02x %02x %02x >>> %*ph  failed with error %i\n",
0156                   pipe,
0157                   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0158                   req, 0, 0,
0159                   reg & 0xff, reg >> 8,
0160                   len & 0xff, len >> 8, len, buf, ret);
0161         return usb_translate_errors(ret);
0162     }
0163 
0164     em28xx_regdbg("(pipe 0x%08x): OUT:  %02x %02x %02x %02x %02x %02x %02x %02x >>> %*ph\n",
0165               pipe,
0166               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0167               req, 0, 0,
0168               reg & 0xff, reg >> 8,
0169               len & 0xff, len >> 8, len, buf);
0170 
0171     if (dev->wait_after_write)
0172         msleep(dev->wait_after_write);
0173 
0174     return ret;
0175 }
0176 
0177 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
0178 {
0179     return em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
0180 }
0181 EXPORT_SYMBOL_GPL(em28xx_write_regs);
0182 
0183 /* Write a single register */
0184 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
0185 {
0186     return em28xx_write_regs(dev, reg, &val, 1);
0187 }
0188 EXPORT_SYMBOL_GPL(em28xx_write_reg);
0189 
0190 /*
0191  * em28xx_write_reg_bits()
0192  * sets only some bits (specified by bitmask) of a register, by first reading
0193  * the actual value
0194  */
0195 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
0196               u8 bitmask)
0197 {
0198     int oldval;
0199     u8 newval;
0200 
0201     oldval = em28xx_read_reg(dev, reg);
0202     if (oldval < 0)
0203         return oldval;
0204 
0205     newval = (((u8)oldval) & ~bitmask) | (val & bitmask);
0206 
0207     return em28xx_write_regs(dev, reg, &newval, 1);
0208 }
0209 EXPORT_SYMBOL_GPL(em28xx_write_reg_bits);
0210 
0211 /*
0212  * em28xx_toggle_reg_bits()
0213  * toggles/inverts the bits (specified by bitmask) of a register
0214  */
0215 int em28xx_toggle_reg_bits(struct em28xx *dev, u16 reg, u8 bitmask)
0216 {
0217     int oldval;
0218     u8 newval;
0219 
0220     oldval = em28xx_read_reg(dev, reg);
0221     if (oldval < 0)
0222         return oldval;
0223 
0224     newval = (~oldval & bitmask) | (oldval & ~bitmask);
0225 
0226     return em28xx_write_reg(dev, reg, newval);
0227 }
0228 EXPORT_SYMBOL_GPL(em28xx_toggle_reg_bits);
0229 
0230 /*
0231  * em28xx_is_ac97_ready()
0232  * Checks if ac97 is ready
0233  */
0234 static int em28xx_is_ac97_ready(struct em28xx *dev)
0235 {
0236     unsigned long timeout = jiffies + msecs_to_jiffies(EM28XX_AC97_XFER_TIMEOUT);
0237     int ret;
0238 
0239     /* Wait up to 50 ms for AC97 command to complete */
0240     while (time_is_after_jiffies(timeout)) {
0241         ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
0242         if (ret < 0)
0243             return ret;
0244 
0245         if (!(ret & 0x01))
0246             return 0;
0247         msleep(5);
0248     }
0249 
0250     dev_warn(&dev->intf->dev,
0251          "AC97 command still being executed: not handled properly!\n");
0252     return -EBUSY;
0253 }
0254 
0255 /*
0256  * em28xx_read_ac97()
0257  * write a 16 bit value to the specified AC97 address (LSB first!)
0258  */
0259 int em28xx_read_ac97(struct em28xx *dev, u8 reg)
0260 {
0261     int ret;
0262     u8 addr = (reg & 0x7f) | 0x80;
0263     __le16 val;
0264 
0265     ret = em28xx_is_ac97_ready(dev);
0266     if (ret < 0)
0267         return ret;
0268 
0269     ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
0270     if (ret < 0)
0271         return ret;
0272 
0273     ret = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R40_AC97LSB,
0274                        (u8 *)&val, sizeof(val));
0275 
0276     if (ret < 0)
0277         return ret;
0278     return le16_to_cpu(val);
0279 }
0280 EXPORT_SYMBOL_GPL(em28xx_read_ac97);
0281 
0282 /*
0283  * em28xx_write_ac97()
0284  * write a 16 bit value to the specified AC97 address (LSB first!)
0285  */
0286 int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
0287 {
0288     int ret;
0289     u8 addr = reg & 0x7f;
0290     __le16 value;
0291 
0292     value = cpu_to_le16(val);
0293 
0294     ret = em28xx_is_ac97_ready(dev);
0295     if (ret < 0)
0296         return ret;
0297 
0298     ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *)&value, 2);
0299     if (ret < 0)
0300         return ret;
0301 
0302     ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
0303     if (ret < 0)
0304         return ret;
0305 
0306     return 0;
0307 }
0308 EXPORT_SYMBOL_GPL(em28xx_write_ac97);
0309 
0310 struct em28xx_vol_itable {
0311     enum em28xx_amux mux;
0312     u8       reg;
0313 };
0314 
0315 static struct em28xx_vol_itable inputs[] = {
0316     { EM28XX_AMUX_VIDEO,    AC97_VIDEO  },
0317     { EM28XX_AMUX_LINE_IN,  AC97_LINE   },
0318     { EM28XX_AMUX_PHONE,    AC97_PHONE  },
0319     { EM28XX_AMUX_MIC,  AC97_MIC    },
0320     { EM28XX_AMUX_CD,   AC97_CD     },
0321     { EM28XX_AMUX_AUX,  AC97_AUX    },
0322     { EM28XX_AMUX_PCM_OUT,  AC97_PCM    },
0323 };
0324 
0325 static int set_ac97_input(struct em28xx *dev)
0326 {
0327     int ret, i;
0328     enum em28xx_amux amux = dev->ctl_ainput;
0329 
0330     /*
0331      * EM28XX_AMUX_VIDEO2 is a special case used to indicate that
0332      * em28xx should point to LINE IN, while AC97 should use VIDEO
0333      */
0334     if (amux == EM28XX_AMUX_VIDEO2)
0335         amux = EM28XX_AMUX_VIDEO;
0336 
0337     /* Mute all entres but the one that were selected */
0338     for (i = 0; i < ARRAY_SIZE(inputs); i++) {
0339         if (amux == inputs[i].mux)
0340             ret = em28xx_write_ac97(dev, inputs[i].reg, 0x0808);
0341         else
0342             ret = em28xx_write_ac97(dev, inputs[i].reg, 0x8000);
0343 
0344         if (ret < 0)
0345             dev_warn(&dev->intf->dev,
0346                  "couldn't setup AC97 register %d\n",
0347                  inputs[i].reg);
0348     }
0349     return 0;
0350 }
0351 
0352 static int em28xx_set_audio_source(struct em28xx *dev)
0353 {
0354     int ret;
0355     u8 input;
0356 
0357     if (dev->board.is_em2800) {
0358         if (dev->ctl_ainput == EM28XX_AMUX_VIDEO)
0359             input = EM2800_AUDIO_SRC_TUNER;
0360         else
0361             input = EM2800_AUDIO_SRC_LINE;
0362 
0363         ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
0364         if (ret < 0)
0365             return ret;
0366     }
0367 
0368     if (dev->has_msp34xx) {
0369         input = EM28XX_AUDIO_SRC_TUNER;
0370     } else {
0371         switch (dev->ctl_ainput) {
0372         case EM28XX_AMUX_VIDEO:
0373             input = EM28XX_AUDIO_SRC_TUNER;
0374             break;
0375         default:
0376             input = EM28XX_AUDIO_SRC_LINE;
0377             break;
0378         }
0379     }
0380 
0381     if (dev->board.mute_gpio && dev->mute)
0382         em28xx_gpio_set(dev, dev->board.mute_gpio);
0383     else
0384         em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
0385 
0386     ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
0387     if (ret < 0)
0388         return ret;
0389     usleep_range(10000, 11000);
0390 
0391     switch (dev->audio_mode.ac97) {
0392     case EM28XX_NO_AC97:
0393         break;
0394     default:
0395         ret = set_ac97_input(dev);
0396     }
0397 
0398     return ret;
0399 }
0400 
0401 struct em28xx_vol_otable {
0402     enum em28xx_aout mux;
0403     u8       reg;
0404 };
0405 
0406 static const struct em28xx_vol_otable outputs[] = {
0407     { EM28XX_AOUT_MASTER, AC97_MASTER       },
0408     { EM28XX_AOUT_LINE,   AC97_HEADPHONE        },
0409     { EM28XX_AOUT_MONO,   AC97_MASTER_MONO      },
0410     { EM28XX_AOUT_LFE,    AC97_CENTER_LFE_MASTER    },
0411     { EM28XX_AOUT_SURR,   AC97_SURROUND_MASTER  },
0412 };
0413 
0414 int em28xx_audio_analog_set(struct em28xx *dev)
0415 {
0416     int ret, i;
0417     u8 xclk;
0418 
0419     if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE)
0420         return 0;
0421 
0422     /*
0423      * It is assumed that all devices use master volume for output.
0424      * It would be possible to use also line output.
0425      */
0426     if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
0427         /* Mute all outputs */
0428         for (i = 0; i < ARRAY_SIZE(outputs); i++) {
0429             ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
0430             if (ret < 0)
0431                 dev_warn(&dev->intf->dev,
0432                      "couldn't setup AC97 register %d\n",
0433                      outputs[i].reg);
0434         }
0435     }
0436 
0437     xclk = dev->board.xclk & 0x7f;
0438     if (!dev->mute)
0439         xclk |= EM28XX_XCLK_AUDIO_UNMUTE;
0440 
0441     ret = em28xx_write_reg(dev, EM28XX_R0F_XCLK, xclk);
0442     if (ret < 0)
0443         return ret;
0444     usleep_range(10000, 11000);
0445 
0446     /* Selects the proper audio input */
0447     ret = em28xx_set_audio_source(dev);
0448 
0449     /* Sets volume */
0450     if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
0451         int vol;
0452 
0453         em28xx_write_ac97(dev, AC97_POWERDOWN, 0x4200);
0454         em28xx_write_ac97(dev, AC97_EXTENDED_STATUS, 0x0031);
0455         em28xx_write_ac97(dev, AC97_PCM_LR_ADC_RATE, 0xbb80);
0456 
0457         /* LSB: left channel - both channels with the same level */
0458         vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);
0459 
0460         /* Mute device, if needed */
0461         if (dev->mute)
0462             vol |= 0x8000;
0463 
0464         /* Sets volume */
0465         for (i = 0; i < ARRAY_SIZE(outputs); i++) {
0466             if (dev->ctl_aoutput & outputs[i].mux)
0467                 ret = em28xx_write_ac97(dev, outputs[i].reg,
0468                             vol);
0469             if (ret < 0)
0470                 dev_warn(&dev->intf->dev,
0471                      "couldn't setup AC97 register %d\n",
0472                      outputs[i].reg);
0473         }
0474 
0475         if (dev->ctl_aoutput & EM28XX_AOUT_PCM_IN) {
0476             int sel = ac97_return_record_select(dev->ctl_aoutput);
0477 
0478             /*
0479              * Use the same input for both left and right
0480              * channels
0481              */
0482             sel |= (sel << 8);
0483 
0484             em28xx_write_ac97(dev, AC97_REC_SEL, sel);
0485         }
0486     }
0487 
0488     return ret;
0489 }
0490 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
0491 
0492 int em28xx_audio_setup(struct em28xx *dev)
0493 {
0494     int vid1, vid2, feat, cfg;
0495     u32 vid = 0;
0496     u8 i2s_samplerates;
0497 
0498     if (dev->chip_id == CHIP_ID_EM2870 ||
0499         dev->chip_id == CHIP_ID_EM2874 ||
0500         dev->chip_id == CHIP_ID_EM28174 ||
0501         dev->chip_id == CHIP_ID_EM28178) {
0502         /* Digital only device - don't load any alsa module */
0503         dev->int_audio_type = EM28XX_INT_AUDIO_NONE;
0504         dev->usb_audio_type = EM28XX_USB_AUDIO_NONE;
0505         return 0;
0506     }
0507 
0508     /* See how this device is configured */
0509     cfg = em28xx_read_reg(dev, EM28XX_R00_CHIPCFG);
0510     dev_info(&dev->intf->dev, "Config register raw data: 0x%02x\n", cfg);
0511     if (cfg < 0) { /* Register read error */
0512         /* Be conservative */
0513         dev->int_audio_type = EM28XX_INT_AUDIO_AC97;
0514     } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) == 0x00) {
0515         /* The device doesn't have vendor audio at all */
0516         dev->int_audio_type = EM28XX_INT_AUDIO_NONE;
0517         dev->usb_audio_type = EM28XX_USB_AUDIO_NONE;
0518         return 0;
0519     } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) != EM28XX_CHIPCFG_AC97) {
0520         dev->int_audio_type = EM28XX_INT_AUDIO_I2S;
0521         if (dev->chip_id < CHIP_ID_EM2860 &&
0522             (cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
0523             EM2820_CHIPCFG_I2S_1_SAMPRATE)
0524             i2s_samplerates = 1;
0525         else if (dev->chip_id >= CHIP_ID_EM2860 &&
0526              (cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
0527              EM2860_CHIPCFG_I2S_5_SAMPRATES)
0528             i2s_samplerates = 5;
0529         else
0530             i2s_samplerates = 3;
0531         dev_info(&dev->intf->dev, "I2S Audio (%d sample rate(s))\n",
0532              i2s_samplerates);
0533         /* Skip the code that does AC97 vendor detection */
0534         dev->audio_mode.ac97 = EM28XX_NO_AC97;
0535         goto init_audio;
0536     } else {
0537         dev->int_audio_type = EM28XX_INT_AUDIO_AC97;
0538     }
0539 
0540     dev->audio_mode.ac97 = EM28XX_AC97_OTHER;
0541 
0542     vid1 = em28xx_read_ac97(dev, AC97_VENDOR_ID1);
0543     if (vid1 < 0) {
0544         /*
0545          * Device likely doesn't support AC97
0546          * Note: (some) em2800 devices without eeprom reports 0x91 on
0547          *   CHIPCFG register, even not having an AC97 chip
0548          */
0549         dev_warn(&dev->intf->dev,
0550              "AC97 chip type couldn't be determined\n");
0551         dev->audio_mode.ac97 = EM28XX_NO_AC97;
0552         if (dev->usb_audio_type == EM28XX_USB_AUDIO_VENDOR)
0553             dev->usb_audio_type = EM28XX_USB_AUDIO_NONE;
0554         dev->int_audio_type = EM28XX_INT_AUDIO_NONE;
0555         goto init_audio;
0556     }
0557 
0558     vid2 = em28xx_read_ac97(dev, AC97_VENDOR_ID2);
0559     if (vid2 < 0)
0560         goto init_audio;
0561 
0562     vid = vid1 << 16 | vid2;
0563     dev_warn(&dev->intf->dev, "AC97 vendor ID = 0x%08x\n", vid);
0564 
0565     feat = em28xx_read_ac97(dev, AC97_RESET);
0566     if (feat < 0)
0567         goto init_audio;
0568 
0569     dev_warn(&dev->intf->dev, "AC97 features = 0x%04x\n", feat);
0570 
0571     /* Try to identify what audio processor we have */
0572     if ((vid == 0xffffffff || vid == 0x83847650) && feat == 0x6a90)
0573         dev->audio_mode.ac97 = EM28XX_AC97_EM202;
0574     else if ((vid >> 8) == 0x838476)
0575         dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
0576 
0577 init_audio:
0578     /* Reports detected AC97 processor */
0579     switch (dev->audio_mode.ac97) {
0580     case EM28XX_NO_AC97:
0581         dev_info(&dev->intf->dev, "No AC97 audio processor\n");
0582         break;
0583     case EM28XX_AC97_EM202:
0584         dev_info(&dev->intf->dev,
0585              "Empia 202 AC97 audio processor detected\n");
0586         break;
0587     case EM28XX_AC97_SIGMATEL:
0588         dev_info(&dev->intf->dev,
0589              "Sigmatel audio processor detected (stac 97%02x)\n",
0590              vid & 0xff);
0591         break;
0592     case EM28XX_AC97_OTHER:
0593         dev_warn(&dev->intf->dev,
0594              "Unknown AC97 audio processor detected!\n");
0595         break;
0596     default:
0597         break;
0598     }
0599 
0600     return em28xx_audio_analog_set(dev);
0601 }
0602 EXPORT_SYMBOL_GPL(em28xx_audio_setup);
0603 
0604 const struct em28xx_led *em28xx_find_led(struct em28xx *dev,
0605                      enum em28xx_led_role role)
0606 {
0607     if (dev->board.leds) {
0608         u8 k = 0;
0609 
0610         while (dev->board.leds[k].role >= 0 &&
0611                dev->board.leds[k].role < EM28XX_NUM_LED_ROLES) {
0612             if (dev->board.leds[k].role == role)
0613                 return &dev->board.leds[k];
0614             k++;
0615         }
0616     }
0617     return NULL;
0618 }
0619 EXPORT_SYMBOL_GPL(em28xx_find_led);
0620 
0621 int em28xx_capture_start(struct em28xx *dev, int start)
0622 {
0623     int rc;
0624     const struct em28xx_led *led = NULL;
0625 
0626     if (dev->chip_id == CHIP_ID_EM2874 ||
0627         dev->chip_id == CHIP_ID_EM2884 ||
0628         dev->chip_id == CHIP_ID_EM28174 ||
0629         dev->chip_id == CHIP_ID_EM28178) {
0630         /* The Transport Stream Enable Register moved in em2874 */
0631         if (dev->dvb_xfer_bulk) {
0632             /* Max Tx Size = 188 * 256 = 48128 - LCM(188,512) * 2 */
0633             em28xx_write_reg(dev, (dev->ts == PRIMARY_TS) ?
0634                      EM2874_R5D_TS1_PKT_SIZE :
0635                      EM2874_R5E_TS2_PKT_SIZE,
0636                      0xff);
0637         } else {
0638             /* ISOC Maximum Transfer Size = 188 * 5 */
0639             em28xx_write_reg(dev, (dev->ts == PRIMARY_TS) ?
0640                      EM2874_R5D_TS1_PKT_SIZE :
0641                      EM2874_R5E_TS2_PKT_SIZE,
0642                      dev->dvb_max_pkt_size_isoc / 188);
0643         }
0644         if (dev->ts == PRIMARY_TS)
0645             rc = em28xx_write_reg_bits(dev,
0646                            EM2874_R5F_TS_ENABLE,
0647                            start ? EM2874_TS1_CAPTURE_ENABLE : 0x00,
0648                            EM2874_TS1_CAPTURE_ENABLE | EM2874_TS1_FILTER_ENABLE | EM2874_TS1_NULL_DISCARD);
0649         else
0650             rc = em28xx_write_reg_bits(dev,
0651                            EM2874_R5F_TS_ENABLE,
0652                            start ? EM2874_TS2_CAPTURE_ENABLE : 0x00,
0653                            EM2874_TS2_CAPTURE_ENABLE | EM2874_TS2_FILTER_ENABLE | EM2874_TS2_NULL_DISCARD);
0654     } else {
0655         /* FIXME: which is the best order? */
0656         /* video registers are sampled by VREF */
0657         rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
0658                        start ? 0x10 : 0x00, 0x10);
0659         if (rc < 0)
0660             return rc;
0661 
0662         if (start) {
0663             if (dev->is_webcam)
0664                 rc = em28xx_write_reg(dev, 0x13, 0x0c);
0665 
0666             /* Enable video capture */
0667             rc = em28xx_write_reg(dev, 0x48, 0x00);
0668             if (rc < 0)
0669                 return rc;
0670 
0671             if (dev->mode == EM28XX_ANALOG_MODE)
0672                 rc = em28xx_write_reg(dev,
0673                               EM28XX_R12_VINENABLE,
0674                               0x67);
0675             else
0676                 rc = em28xx_write_reg(dev,
0677                               EM28XX_R12_VINENABLE,
0678                               0x37);
0679             if (rc < 0)
0680                 return rc;
0681 
0682             usleep_range(10000, 11000);
0683         } else {
0684             /* disable video capture */
0685             rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
0686         }
0687     }
0688 
0689     if (dev->mode == EM28XX_ANALOG_MODE)
0690         led = em28xx_find_led(dev, EM28XX_LED_ANALOG_CAPTURING);
0691     else if (dev->ts == PRIMARY_TS)
0692         led = em28xx_find_led(dev, EM28XX_LED_DIGITAL_CAPTURING);
0693     else
0694         led = em28xx_find_led(dev, EM28XX_LED_DIGITAL_CAPTURING_TS2);
0695 
0696     if (led)
0697         em28xx_write_reg_bits(dev, led->gpio_reg,
0698                       (!start ^ led->inverted) ?
0699                       ~led->gpio_mask : led->gpio_mask,
0700                       led->gpio_mask);
0701 
0702     return rc;
0703 }
0704 
0705 int em28xx_gpio_set(struct em28xx *dev, const struct em28xx_reg_seq *gpio)
0706 {
0707     int rc = 0;
0708 
0709     if (!gpio)
0710         return rc;
0711 
0712     if (dev->mode != EM28XX_SUSPEND) {
0713         em28xx_write_reg(dev, 0x48, 0x00);
0714         if (dev->mode == EM28XX_ANALOG_MODE)
0715             em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
0716         else
0717             em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
0718         usleep_range(10000, 11000);
0719     }
0720 
0721     /* Send GPIO reset sequences specified at board entry */
0722     while (gpio->sleep >= 0) {
0723         if (gpio->reg >= 0) {
0724             rc = em28xx_write_reg_bits(dev,
0725                            gpio->reg,
0726                            gpio->val,
0727                            gpio->mask);
0728             if (rc < 0)
0729                 return rc;
0730         }
0731         if (gpio->sleep > 0)
0732             msleep(gpio->sleep);
0733 
0734         gpio++;
0735     }
0736     return rc;
0737 }
0738 EXPORT_SYMBOL_GPL(em28xx_gpio_set);
0739 
0740 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
0741 {
0742     if (dev->mode == set_mode)
0743         return 0;
0744 
0745     if (set_mode == EM28XX_SUSPEND) {
0746         dev->mode = set_mode;
0747 
0748         /* FIXME: add suspend support for ac97 */
0749 
0750         return em28xx_gpio_set(dev, dev->board.suspend_gpio);
0751     }
0752 
0753     dev->mode = set_mode;
0754 
0755     if (dev->mode == EM28XX_DIGITAL_MODE)
0756         return em28xx_gpio_set(dev, dev->board.dvb_gpio);
0757     else
0758         return em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
0759 }
0760 EXPORT_SYMBOL_GPL(em28xx_set_mode);
0761 
0762 /*
0763  *URB control
0764  */
0765 
0766 /*
0767  * URB completion handler for isoc/bulk transfers
0768  */
0769 static void em28xx_irq_callback(struct urb *urb)
0770 {
0771     struct em28xx *dev = urb->context;
0772     unsigned long flags;
0773     int i;
0774 
0775     switch (urb->status) {
0776     case 0:             /* success */
0777     case -ETIMEDOUT:    /* NAK */
0778         break;
0779     case -ECONNRESET:   /* kill */
0780     case -ENOENT:
0781     case -ESHUTDOWN:
0782         return;
0783     default:            /* error */
0784         em28xx_isocdbg("urb completion error %d.\n", urb->status);
0785         break;
0786     }
0787 
0788     /* Copy data from URB */
0789     spin_lock_irqsave(&dev->slock, flags);
0790     dev->usb_ctl.urb_data_copy(dev, urb);
0791     spin_unlock_irqrestore(&dev->slock, flags);
0792 
0793     /* Reset urb buffers */
0794     for (i = 0; i < urb->number_of_packets; i++) {
0795         /* isoc only (bulk: number_of_packets = 0) */
0796         urb->iso_frame_desc[i].status = 0;
0797         urb->iso_frame_desc[i].actual_length = 0;
0798     }
0799     urb->status = 0;
0800 
0801     urb->status = usb_submit_urb(urb, GFP_ATOMIC);
0802     if (urb->status) {
0803         em28xx_isocdbg("urb resubmit failed (error=%i)\n",
0804                    urb->status);
0805     }
0806 }
0807 
0808 /*
0809  * Stop and Deallocate URBs
0810  */
0811 void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode)
0812 {
0813     struct urb *urb;
0814     struct em28xx_usb_bufs *usb_bufs;
0815     int i;
0816 
0817     em28xx_isocdbg("called %s in mode %d\n", __func__, mode);
0818 
0819     if (mode == EM28XX_DIGITAL_MODE)
0820         usb_bufs = &dev->usb_ctl.digital_bufs;
0821     else
0822         usb_bufs = &dev->usb_ctl.analog_bufs;
0823 
0824     for (i = 0; i < usb_bufs->num_bufs; i++) {
0825         urb = usb_bufs->urb[i];
0826         if (urb) {
0827             if (!irqs_disabled())
0828                 usb_kill_urb(urb);
0829             else
0830                 usb_unlink_urb(urb);
0831 
0832             usb_free_urb(urb);
0833             usb_bufs->urb[i] = NULL;
0834         }
0835     }
0836 
0837     kfree(usb_bufs->urb);
0838     kfree(usb_bufs->buf);
0839 
0840     usb_bufs->urb = NULL;
0841     usb_bufs->buf = NULL;
0842     usb_bufs->num_bufs = 0;
0843 
0844     em28xx_capture_start(dev, 0);
0845 }
0846 EXPORT_SYMBOL_GPL(em28xx_uninit_usb_xfer);
0847 
0848 /*
0849  * Stop URBs
0850  */
0851 void em28xx_stop_urbs(struct em28xx *dev)
0852 {
0853     int i;
0854     struct urb *urb;
0855     struct em28xx_usb_bufs *isoc_bufs = &dev->usb_ctl.digital_bufs;
0856 
0857     em28xx_isocdbg("called %s\n", __func__);
0858 
0859     for (i = 0; i < isoc_bufs->num_bufs; i++) {
0860         urb = isoc_bufs->urb[i];
0861         if (urb) {
0862             if (!irqs_disabled())
0863                 usb_kill_urb(urb);
0864             else
0865                 usb_unlink_urb(urb);
0866         }
0867     }
0868 
0869     em28xx_capture_start(dev, 0);
0870 }
0871 EXPORT_SYMBOL_GPL(em28xx_stop_urbs);
0872 
0873 /*
0874  * Allocate URBs
0875  */
0876 int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
0877               int num_bufs, int max_pkt_size, int packet_multiplier)
0878 {
0879     struct em28xx_usb_bufs *usb_bufs;
0880     struct urb *urb;
0881     struct usb_device *udev = interface_to_usbdev(dev->intf);
0882     int i;
0883     int sb_size, pipe;
0884     int j, k;
0885 
0886     em28xx_isocdbg("em28xx: called %s in mode %d\n", __func__, mode);
0887 
0888     /*
0889      * Check mode and if we have an endpoint for the selected
0890      * transfer type, select buffer
0891      */
0892     if (mode == EM28XX_DIGITAL_MODE) {
0893         if ((xfer_bulk && !dev->dvb_ep_bulk) ||
0894             (!xfer_bulk && !dev->dvb_ep_isoc)) {
0895             dev_err(&dev->intf->dev,
0896                 "no endpoint for DVB mode and transfer type %d\n",
0897                 xfer_bulk > 0);
0898             return -EINVAL;
0899         }
0900         usb_bufs = &dev->usb_ctl.digital_bufs;
0901     } else if (mode == EM28XX_ANALOG_MODE) {
0902         if ((xfer_bulk && !dev->analog_ep_bulk) ||
0903             (!xfer_bulk && !dev->analog_ep_isoc)) {
0904             dev_err(&dev->intf->dev,
0905                 "no endpoint for analog mode and transfer type %d\n",
0906                 xfer_bulk > 0);
0907             return -EINVAL;
0908         }
0909         usb_bufs = &dev->usb_ctl.analog_bufs;
0910     } else {
0911         dev_err(&dev->intf->dev, "invalid mode selected\n");
0912         return -EINVAL;
0913     }
0914 
0915     /* De-allocates all pending stuff */
0916     em28xx_uninit_usb_xfer(dev, mode);
0917 
0918     usb_bufs->num_bufs = num_bufs;
0919 
0920     usb_bufs->urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL);
0921     if (!usb_bufs->urb)
0922         return -ENOMEM;
0923 
0924     usb_bufs->buf = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL);
0925     if (!usb_bufs->buf) {
0926         kfree(usb_bufs->urb);
0927         return -ENOMEM;
0928     }
0929 
0930     usb_bufs->max_pkt_size = max_pkt_size;
0931     if (xfer_bulk)
0932         usb_bufs->num_packets = 0;
0933     else
0934         usb_bufs->num_packets = packet_multiplier;
0935     dev->usb_ctl.vid_buf = NULL;
0936     dev->usb_ctl.vbi_buf = NULL;
0937 
0938     sb_size = packet_multiplier * usb_bufs->max_pkt_size;
0939 
0940     /* allocate urbs and transfer buffers */
0941     for (i = 0; i < usb_bufs->num_bufs; i++) {
0942         urb = usb_alloc_urb(usb_bufs->num_packets, GFP_KERNEL);
0943         if (!urb) {
0944             em28xx_uninit_usb_xfer(dev, mode);
0945             return -ENOMEM;
0946         }
0947         usb_bufs->urb[i] = urb;
0948 
0949         usb_bufs->buf[i] = kzalloc(sb_size, GFP_KERNEL);
0950         if (!usb_bufs->buf[i]) {
0951             for (i--; i >= 0; i--)
0952                 kfree(usb_bufs->buf[i]);
0953 
0954             em28xx_uninit_usb_xfer(dev, mode);
0955             return -ENOMEM;
0956         }
0957 
0958         urb->transfer_flags = URB_FREE_BUFFER;
0959 
0960         if (xfer_bulk) { /* bulk */
0961             pipe = usb_rcvbulkpipe(udev,
0962                            mode == EM28XX_ANALOG_MODE ?
0963                            dev->analog_ep_bulk :
0964                            dev->dvb_ep_bulk);
0965             usb_fill_bulk_urb(urb, udev, pipe, usb_bufs->buf[i],
0966                       sb_size, em28xx_irq_callback, dev);
0967         } else { /* isoc */
0968             pipe = usb_rcvisocpipe(udev,
0969                            mode == EM28XX_ANALOG_MODE ?
0970                            dev->analog_ep_isoc :
0971                            dev->dvb_ep_isoc);
0972             usb_fill_int_urb(urb, udev, pipe, usb_bufs->buf[i],
0973                      sb_size, em28xx_irq_callback, dev, 1);
0974             urb->transfer_flags |= URB_ISO_ASAP;
0975             k = 0;
0976             for (j = 0; j < usb_bufs->num_packets; j++) {
0977                 urb->iso_frame_desc[j].offset = k;
0978                 urb->iso_frame_desc[j].length =
0979                             usb_bufs->max_pkt_size;
0980                 k += usb_bufs->max_pkt_size;
0981             }
0982         }
0983 
0984         urb->number_of_packets = usb_bufs->num_packets;
0985     }
0986 
0987     return 0;
0988 }
0989 EXPORT_SYMBOL_GPL(em28xx_alloc_urbs);
0990 
0991 /*
0992  * Allocate URBs and start IRQ
0993  */
0994 int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
0995              int xfer_bulk, int num_bufs, int max_pkt_size,
0996             int packet_multiplier,
0997             int (*urb_data_copy)(struct em28xx *dev, struct urb *urb))
0998 {
0999     struct em28xx_dmaqueue *dma_q = &dev->vidq;
1000     struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
1001     struct em28xx_usb_bufs *usb_bufs;
1002     struct usb_device *udev = interface_to_usbdev(dev->intf);
1003     int i;
1004     int rc;
1005     int alloc;
1006 
1007     em28xx_isocdbg("em28xx: called %s in mode %d\n", __func__, mode);
1008 
1009     dev->usb_ctl.urb_data_copy = urb_data_copy;
1010 
1011     if (mode == EM28XX_DIGITAL_MODE) {
1012         usb_bufs = &dev->usb_ctl.digital_bufs;
1013         /* no need to free/alloc usb buffers in digital mode */
1014         alloc = 0;
1015     } else {
1016         usb_bufs = &dev->usb_ctl.analog_bufs;
1017         alloc = 1;
1018     }
1019 
1020     if (alloc) {
1021         rc = em28xx_alloc_urbs(dev, mode, xfer_bulk, num_bufs,
1022                        max_pkt_size, packet_multiplier);
1023         if (rc)
1024             return rc;
1025     }
1026 
1027     if (xfer_bulk) {
1028         rc = usb_clear_halt(udev, usb_bufs->urb[0]->pipe);
1029         if (rc < 0) {
1030             dev_err(&dev->intf->dev,
1031                 "failed to clear USB bulk endpoint stall/halt condition (error=%i)\n",
1032                    rc);
1033             em28xx_uninit_usb_xfer(dev, mode);
1034             return rc;
1035         }
1036     }
1037 
1038     init_waitqueue_head(&dma_q->wq);
1039     init_waitqueue_head(&vbi_dma_q->wq);
1040 
1041     em28xx_capture_start(dev, 1);
1042 
1043     /* submit urbs and enables IRQ */
1044     for (i = 0; i < usb_bufs->num_bufs; i++) {
1045         rc = usb_submit_urb(usb_bufs->urb[i], GFP_KERNEL);
1046         if (rc) {
1047             dev_err(&dev->intf->dev,
1048                 "submit of urb %i failed (error=%i)\n", i, rc);
1049             em28xx_uninit_usb_xfer(dev, mode);
1050             return rc;
1051         }
1052     }
1053 
1054     return 0;
1055 }
1056 EXPORT_SYMBOL_GPL(em28xx_init_usb_xfer);
1057 
1058 /*
1059  * Device control list
1060  */
1061 
1062 static LIST_HEAD(em28xx_devlist);
1063 static DEFINE_MUTEX(em28xx_devlist_mutex);
1064 
1065 /*
1066  * Extension interface
1067  */
1068 
1069 static LIST_HEAD(em28xx_extension_devlist);
1070 
1071 int em28xx_register_extension(struct em28xx_ops *ops)
1072 {
1073     struct em28xx *dev = NULL;
1074 
1075     mutex_lock(&em28xx_devlist_mutex);
1076     list_add_tail(&ops->next, &em28xx_extension_devlist);
1077     list_for_each_entry(dev, &em28xx_devlist, devlist) {
1078         if (ops->init) {
1079             ops->init(dev);
1080             if (dev->dev_next)
1081                 ops->init(dev->dev_next);
1082         }
1083     }
1084     mutex_unlock(&em28xx_devlist_mutex);
1085     pr_info("em28xx: Registered (%s) extension\n", ops->name);
1086     return 0;
1087 }
1088 EXPORT_SYMBOL(em28xx_register_extension);
1089 
1090 void em28xx_unregister_extension(struct em28xx_ops *ops)
1091 {
1092     struct em28xx *dev = NULL;
1093 
1094     mutex_lock(&em28xx_devlist_mutex);
1095     list_for_each_entry(dev, &em28xx_devlist, devlist) {
1096         if (ops->fini) {
1097             if (dev->dev_next)
1098                 ops->fini(dev->dev_next);
1099             ops->fini(dev);
1100         }
1101     }
1102     list_del(&ops->next);
1103     mutex_unlock(&em28xx_devlist_mutex);
1104     pr_info("em28xx: Removed (%s) extension\n", ops->name);
1105 }
1106 EXPORT_SYMBOL(em28xx_unregister_extension);
1107 
1108 void em28xx_init_extension(struct em28xx *dev)
1109 {
1110     const struct em28xx_ops *ops = NULL;
1111 
1112     mutex_lock(&em28xx_devlist_mutex);
1113     list_add_tail(&dev->devlist, &em28xx_devlist);
1114     list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1115         if (ops->init) {
1116             ops->init(dev);
1117             if (dev->dev_next)
1118                 ops->init(dev->dev_next);
1119         }
1120     }
1121     mutex_unlock(&em28xx_devlist_mutex);
1122 }
1123 
1124 void em28xx_close_extension(struct em28xx *dev)
1125 {
1126     const struct em28xx_ops *ops = NULL;
1127 
1128     mutex_lock(&em28xx_devlist_mutex);
1129     list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1130         if (ops->fini) {
1131             if (dev->dev_next)
1132                 ops->fini(dev->dev_next);
1133             ops->fini(dev);
1134         }
1135     }
1136     list_del(&dev->devlist);
1137     mutex_unlock(&em28xx_devlist_mutex);
1138 }
1139 
1140 int em28xx_suspend_extension(struct em28xx *dev)
1141 {
1142     const struct em28xx_ops *ops = NULL;
1143 
1144     dev_info(&dev->intf->dev, "Suspending extensions\n");
1145     mutex_lock(&em28xx_devlist_mutex);
1146     list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1147         if (!ops->suspend)
1148             continue;
1149         ops->suspend(dev);
1150         if (dev->dev_next)
1151             ops->suspend(dev->dev_next);
1152     }
1153     mutex_unlock(&em28xx_devlist_mutex);
1154     return 0;
1155 }
1156 
1157 int em28xx_resume_extension(struct em28xx *dev)
1158 {
1159     const struct em28xx_ops *ops = NULL;
1160 
1161     dev_info(&dev->intf->dev, "Resuming extensions\n");
1162     mutex_lock(&em28xx_devlist_mutex);
1163     list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1164         if (!ops->resume)
1165             continue;
1166         ops->resume(dev);
1167         if (dev->dev_next)
1168             ops->resume(dev->dev_next);
1169     }
1170     mutex_unlock(&em28xx_devlist_mutex);
1171     return 0;
1172 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!