Merge git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/v4l-dvb
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 5 Jun 2008 21:30:47 +0000 (14:30 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 5 Jun 2008 21:30:47 +0000 (14:30 -0700)
* git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/v4l-dvb: (48 commits)
  V4L/DVB (8001): dib0070: fix dib0070_attach when !CONFIG_DVB_TUNER_DIB0070
  V4L/DVB (8000): tda827x: fix NULL pointer in tda827xa_lna_gain
  V4L/DVB (7990): Fix entry for PowerColor RA 330 and make it run with firmware version 2.7
  V4L/DVB (7983): tda18271_calc_rf_cal must return the return value of tda18271_lookup_map
  V4L/DVB (7978): cx18: explicitly test for XC2028 tuner
  V4L/DVB (7977): cx18: fix init order and remove duplicate open_on_first_use.
  V4L/DVB (7975): saa7134_empress
  V4L/DVB (7974): fix MEDIA_TUNER && FW_LOADER build error
  V4L/DVB (7972): or51132.c: unaligned
  V4L/DVB (7971): usb: unaligned
  V4L/DVB (7970): mix trivial endianness annotations
  V4L/DVB (7969): m920x: unaligned access
  V4L/DVB (7968): zoran: endianness annotations
  V4L/DVB (7967): bt8xx: unaligned access
  V4L/DVB (7966): cx18: direct dereferencing of iomem
  V4L/DVB (7965): annotate bcx_riscmem
  V4L/DVB (7964): cx18 iomem annotations
  V4L/DVB (7963): ivtv: trivial annotations
  V4L/DVB (7962): ttusb endianness annotations and fixes
  V4L/DVB (7961): fix endianness bug in dib0700_devices.c
  ...

65 files changed:
Documentation/video4linux/CARDLIST.cx88
Documentation/video4linux/cx18.txt
drivers/media/Makefile
drivers/media/common/tuners/Kconfig
drivers/media/common/tuners/mxl5005s.c
drivers/media/common/tuners/tda18271-common.c
drivers/media/common/tuners/tda827x.c
drivers/media/common/tuners/tea5761.c
drivers/media/common/tuners/tuner-i2c.h
drivers/media/common/tuners/tuner-simple.c
drivers/media/common/tuners/tuner-xc2028.c
drivers/media/dvb/b2c2/flexcop-usb.c
drivers/media/dvb/cinergyT2/cinergyT2.c
drivers/media/dvb/dvb-core/dvb_net.c
drivers/media/dvb/dvb-usb/Kconfig
drivers/media/dvb/dvb-usb/dib0700_devices.c
drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
drivers/media/dvb/dvb-usb/gp8psk.c
drivers/media/dvb/dvb-usb/m920x.c
drivers/media/dvb/frontends/dib0070.h
drivers/media/dvb/frontends/dib7000p.h
drivers/media/dvb/frontends/or51132.c
drivers/media/dvb/ttpci/av7110.c
drivers/media/dvb/ttpci/av7110_av.c
drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c
drivers/media/dvb/ttusb-dec/Kconfig
drivers/media/dvb/ttusb-dec/ttusb_dec.c
drivers/media/dvb/ttusb-dec/ttusbdecfe.c
drivers/media/video/au0828/Kconfig
drivers/media/video/au0828/au0828-dvb.c
drivers/media/video/bt8xx/bttv-cards.c
drivers/media/video/bt8xx/bttv-risc.c
drivers/media/video/btcx-risc.c
drivers/media/video/btcx-risc.h
drivers/media/video/cx18/cx18-av-core.c
drivers/media/video/cx18/cx18-cards.c
drivers/media/video/cx18/cx18-controls.c
drivers/media/video/cx18/cx18-driver.c
drivers/media/video/cx18/cx18-driver.h
drivers/media/video/cx18/cx18-fileops.c
drivers/media/video/cx18/cx18-gpio.c
drivers/media/video/cx18/cx18-ioctl.c
drivers/media/video/cx18/cx18-irq.c
drivers/media/video/cx18/cx18-mailbox.c
drivers/media/video/cx18/cx18-streams.c
drivers/media/video/cx23885/cx23885-core.c
drivers/media/video/cx88/cx88-cards.c
drivers/media/video/cx88/cx88-core.c
drivers/media/video/em28xx/em28xx-video.c
drivers/media/video/ivtv/ivtv-driver.h
drivers/media/video/ivtv/ivtv-fileops.c
drivers/media/video/ivtv/ivtv-irq.c
drivers/media/video/ivtv/ivtv-queue.c
drivers/media/video/ivtv/ivtv-streams.c
drivers/media/video/ivtv/ivtv-version.h
drivers/media/video/ivtv/ivtv-yuv.c
drivers/media/video/ivtv/ivtv-yuv.h
drivers/media/video/saa7134/saa7134-empress.c
drivers/media/video/tuner-core.c
drivers/media/video/usbvideo/quickcam_messenger.c
drivers/media/video/zoran.h
drivers/media/video/zoran_device.c
drivers/media/video/zoran_driver.c
include/linux/videodev2.h
include/media/v4l2-dev.h

index 5439573464693ca9c3ac29ba9d10b0dd27a2fdf9..7cf5685d36452f64216a0f304e69f7b71ed43703 100644 (file)
@@ -60,7 +60,7 @@
  59 -> DViCO FusionHDTV 5 PCI nano                         [18ac:d530]
  60 -> Pinnacle Hybrid PCTV                                [12ab:1788]
  61 -> Winfast TV2000 XP Global                            [107d:6f18]
- 62 -> PowerColor Real Angel 330                           [14f1:ea3d]
+ 62 -> PowerColor RA330                                    [14f1:ea3d]
  63 -> Geniatech X8000-MT DVBT                             [14f1:8852]
  64 -> DViCO FusionHDTV DVB-T PRO                          [18ac:db30]
  65 -> DViCO FusionHDTV 7 Gold                             [18ac:d610]
index 077d56ec3f3d6e300c2fd4545b0082b939895ac4..6842c262890f898561f537888ddf53b8bc39bda5 100644 (file)
@@ -1,7 +1,9 @@
 Some notes regarding the cx18 driver for the Conexant CX23418 MPEG
 encoder chip:
 
-1) The only hardware currently supported is the Hauppauge HVR-1600.
+1) The only hardware currently supported is the Hauppauge HVR-1600
+   card and the Compro VideoMate H900 (note that this card only
+   supports analog input, it has no digital tuner!).
 
 2) Some people have problems getting the i2c bus to work. Cause unknown.
    The symptom is that the eeprom cannot be read and the card is
index cc11c4c0e7e7afaf585e3866c0119a0601275164..09a829d8a7e71a4b7b0b5de035f7034d1748e82d 100644 (file)
@@ -2,12 +2,7 @@
 # Makefile for the kernel multimedia device drivers.
 #
 
-obj-y := common/
-
-obj-$(CONFIG_VIDEO_MEDIA) += common/
-
-# Since hybrid devices are here, should be compiled if DVB and/or V4L
-obj-$(CONFIG_VIDEO_MEDIA) += video/
+obj-y += common/ video/
 
 obj-$(CONFIG_VIDEO_DEV) += radio/
 obj-$(CONFIG_DVB_CORE)  += dvb/
index d6206540476bcad9c1f63fed08a5dbc49722dc7d..85482960d0127a66308afec8d331d36d6258112e 100644 (file)
@@ -21,6 +21,7 @@ config MEDIA_TUNER
        tristate
        default VIDEO_MEDIA && I2C
        depends on VIDEO_MEDIA && I2C
+       select FW_LOADER if !MEDIA_TUNER_CUSTOMIZE && HOTPLUG
        select MEDIA_TUNER_XC2028 if !MEDIA_TUNER_CUSTOMIZE && HOTPLUG
        select MEDIA_TUNER_XC5000 if !MEDIA_TUNER_CUSTOMIZE && HOTPLUG
        select MEDIA_TUNER_MT20XX if !MEDIA_TUNER_CUSTOMIZE
index 5d05b5390f66f48cc2e95c6f4d2f3bb7884a9156..0dc2bef9f6a3b9acd59c7c4c75439d3782ce0192 100644 (file)
@@ -101,7 +101,7 @@ enum {
        MXL_QAM,
        MXL_ANALOG_CABLE,
        MXL_ANALOG_OTA
-} tuner_modu_type;
+};
 
 /* MXL5005 Tuner Register Struct */
 struct TunerReg {
@@ -194,7 +194,7 @@ enum {
        RFSYN_DIVM,                /* 88 */
        DN_BYPASS_AGC_I2C          /* 89 */
 #endif
-} MXL5005_ControlName;
+};
 
 /*
  * The following context is source code provided by MaxLinear.
index 42b5f5d4bfe64109df3f25760be9d88ea73ba071..f1894fec32b930343d69f0665a698ed267b8e731 100644 (file)
@@ -648,11 +648,11 @@ int tda18271_calc_rf_cal(struct dvb_frontend *fe, u32 *freq)
        unsigned char *regs = priv->tda18271_regs;
        u8 val;
 
-       tda18271_lookup_map(fe, RF_CAL, freq, &val);
+       int ret = tda18271_lookup_map(fe, RF_CAL, freq, &val);
 
        regs[R_EB14] = val;
 
-       return 0;
+       return ret;
 }
 
 /*
index d30d2c9094d9b0fcdde74cd3212d9f5cbd700b95..8555d9cf9051031f7643675b4487e65461553d1b 100644 (file)
@@ -418,13 +418,13 @@ static void tda827xa_lna_gain(struct dvb_frontend *fe, int high,
        unsigned char buf[] = {0x22, 0x01};
        int arg;
        int gp_func;
-       struct i2c_msg msg = { .addr = priv->cfg->switch_addr, .flags = 0,
-                              .buf = buf, .len = sizeof(buf) };
+       struct i2c_msg msg = { .flags = 0, .buf = buf, .len = sizeof(buf) };
 
        if (NULL == priv->cfg) {
                dprintk("tda827x_config not defined, cannot set LNA gain!\n");
                return;
        }
+       msg.addr = priv->cfg->switch_addr;
        if (priv->cfg->config) {
                if (high)
                        dprintk("setting LNA to high gain\n");
index b93cdef9ac73e48b04f5a369da3767e6d46c42d7..b23dadeecd0528ad74d55405948562981b24c234 100644 (file)
@@ -295,7 +295,7 @@ struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
 {
        struct tea5761_priv *priv = NULL;
 
-       if (tea5761_autodetection(i2c_adap, i2c_addr) == EINVAL)
+       if (tea5761_autodetection(i2c_adap, i2c_addr) != 0)
                return NULL;
 
        priv = kzalloc(sizeof(struct tea5761_priv), GFP_KERNEL);
index 3ad6c8e0b04ccbd8d612ac89db2f61911b64e225..cb1c7141f0c6d9e96d76110e6ce657ae18148c15 100644 (file)
@@ -170,4 +170,12 @@ __fail:                                                                    \
        __ret;                                                          \
 })
 
+#define hybrid_tuner_report_instance_count(state)                      \
+({                                                                     \
+       int __ret = 0;                                                  \
+       if (state)                                                      \
+               __ret = state->i2c_props.count;                         \
+       __ret;                                                          \
+})
+
 #endif /* __TUNER_I2C_H__ */
index be8d903171b7dce5f3ace750c63177a86d107284..266c255cf0d89241f2332e50ea8947329d13d311 100644 (file)
@@ -1018,8 +1018,10 @@ struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
                        fe->ops.i2c_gate_ctrl(fe, 1);
 
                if (1 != i2c_transfer(i2c_adap, &msg, 1))
-                       tuner_warn("unable to probe %s, proceeding anyway.",
-                                  tuners[type].name);
+                       printk(KERN_WARNING "tuner-simple %d-%04x: "
+                              "unable to probe %s, proceeding anyway.",
+                              i2c_adapter_id(i2c_adap), i2c_addr,
+                              tuners[type].name);
 
                if (fe->ops.i2c_gate_ctrl)
                        fe->ops.i2c_gate_ctrl(fe, 0);
index 9e9003cffc7f20e8d551082b1eceea18b4dd3153..0cbde17bfbb7a7471616112dda6dd5507f21e169 100644 (file)
@@ -46,7 +46,7 @@ module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
 MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
                                "default firmware name\n");
 
-static LIST_HEAD(xc2028_list);
+static LIST_HEAD(hybrid_tuner_instance_list);
 static DEFINE_MUTEX(xc2028_list_mutex);
 
 /* struct for storing firmware table */
@@ -68,12 +68,11 @@ struct firmware_properties {
 };
 
 struct xc2028_data {
-       struct list_head        xc2028_list;
+       struct list_head        hybrid_tuner_instance_list;
        struct tuner_i2c_props  i2c_props;
        int                     (*tuner_callback) (void *dev,
                                                   int command, int arg);
        void                    *video_dev;
-       int                     count;
        __u32                   frequency;
 
        struct firmware_description *firm;
@@ -1072,20 +1071,19 @@ static int xc2028_dvb_release(struct dvb_frontend *fe)
 
        mutex_lock(&xc2028_list_mutex);
 
-       priv->count--;
-
-       if (!priv->count) {
-               list_del(&priv->xc2028_list);
-
+       /* only perform final cleanup if this is the last instance */
+       if (hybrid_tuner_report_instance_count(priv) == 1) {
                kfree(priv->ctrl.fname);
-
                free_firmware(priv);
-               kfree(priv);
-               fe->tuner_priv = NULL;
        }
 
+       if (priv)
+               hybrid_tuner_release_state(priv);
+
        mutex_unlock(&xc2028_list_mutex);
 
+       fe->tuner_priv = NULL;
+
        return 0;
 }
 
@@ -1150,7 +1148,7 @@ struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
                                   struct xc2028_config *cfg)
 {
        struct xc2028_data *priv;
-       void               *video_dev;
+       int instance;
 
        if (debug)
                printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n");
@@ -1163,48 +1161,40 @@ struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
                return NULL;
        }
 
-       video_dev = cfg->i2c_adap->algo_data;
-
-       if (debug)
-               printk(KERN_DEBUG "xc2028: video_dev =%p\n", video_dev);
-
        mutex_lock(&xc2028_list_mutex);
 
-       list_for_each_entry(priv, &xc2028_list, xc2028_list) {
-               if (&priv->i2c_props.adap->dev == &cfg->i2c_adap->dev) {
-                       video_dev = NULL;
-                       if (debug)
-                               printk(KERN_DEBUG "xc2028: reusing device\n");
-
-                       break;
-               }
-       }
-
-       if (video_dev) {
-               priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-               if (priv == NULL) {
-                       mutex_unlock(&xc2028_list_mutex);
-                       return NULL;
-               }
-
-               priv->i2c_props.addr = cfg->i2c_addr;
-               priv->i2c_props.adap = cfg->i2c_adap;
-               priv->i2c_props.name = "xc2028";
-
-               priv->video_dev = video_dev;
+       instance = hybrid_tuner_request_state(struct xc2028_data, priv,
+                                             hybrid_tuner_instance_list,
+                                             cfg->i2c_adap, cfg->i2c_addr,
+                                             "xc2028");
+       switch (instance) {
+       case 0:
+               /* memory allocation failure */
+               goto fail;
+               break;
+       case 1:
+               /* new tuner instance */
                priv->tuner_callback = cfg->callback;
                priv->ctrl.max_len = 13;
 
                mutex_init(&priv->lock);
 
-               list_add_tail(&priv->xc2028_list, &xc2028_list);
-       }
-
-       fe->tuner_priv = priv;
-       priv->count++;
+               /* analog side (tuner-core) uses i2c_adap->algo_data.
+                * digital side is not guaranteed to have algo_data defined.
+                *
+                * digital side will always have fe->dvb defined.
+                * analog side (tuner-core) doesn't (yet) define fe->dvb.
+                */
+               priv->video_dev = ((fe->dvb) && (fe->dvb->priv)) ?
+                                  fe->dvb->priv : cfg->i2c_adap->algo_data;
 
-       if (debug)
-               printk(KERN_DEBUG "xc2028: usage count is %i\n", priv->count);
+               fe->tuner_priv = priv;
+               break;
+       case 2:
+               /* existing tuner instance */
+               fe->tuner_priv = priv;
+               break;
+       }
 
        memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
               sizeof(xc2028_dvb_tuner_ops));
@@ -1217,6 +1207,11 @@ struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
        mutex_unlock(&xc2028_list_mutex);
 
        return fe;
+fail:
+       mutex_unlock(&xc2028_list_mutex);
+
+       xc2028_dvb_release(fe);
+       return NULL;
 }
 
 EXPORT_SYMBOL(xc2028_attach);
index 449fb5c3d0b1ed31f078ff9b8eb2c244ae4c10bf..ae0d76a5d51d34dd284db2ff450fa70b5d6ea691 100644 (file)
@@ -379,7 +379,7 @@ static void flexcop_usb_transfer_exit(struct flexcop_usb *fc_usb)
 
 static int flexcop_usb_transfer_init(struct flexcop_usb *fc_usb)
 {
-       u16 frame_size = fc_usb->uintf->cur_altsetting->endpoint[0].desc.wMaxPacketSize;
+       u16 frame_size = le16_to_cpu(fc_usb->uintf->cur_altsetting->endpoint[0].desc.wMaxPacketSize);
        int bufsize = B2C2_USB_NUM_ISO_URB * B2C2_USB_FRAMES_PER_ISO * frame_size,i,j,ret;
        int buffer_offset = 0;
 
index f5010e8671b8476109b44df80e90a47079305302..a824f3719f8146536f73c9cf709400a53f7ff1b9 100644 (file)
@@ -82,22 +82,22 @@ enum cinergyt2_ep1_cmd {
 
 struct dvbt_set_parameters_msg {
        uint8_t cmd;
-       uint32_t freq;
+       __le32 freq;
        uint8_t bandwidth;
-       uint16_t tps;
+       __le16 tps;
        uint8_t flags;
 } __attribute__((packed));
 
 struct dvbt_get_status_msg {
-       uint32_t freq;
+       __le32 freq;
        uint8_t bandwidth;
-       uint16_t tps;
+       __le16 tps;
        uint8_t flags;
-       uint16_t gain;
+       __le16 gain;
        uint8_t snr;
-       uint32_t viterbi_error_rate;
-       uint32_t rs_error_rate;
-       uint32_t uncorrected_block_count;
+       __le32 viterbi_error_rate;
+       __le32 rs_error_rate;
+       __le32 uncorrected_block_count;
        uint8_t lock_bits;
        uint8_t prev_lock_bits;
 } __attribute__((packed));
@@ -136,6 +136,7 @@ struct cinergyt2 {
        wait_queue_head_t poll_wq;
        int pending_fe_events;
        int disconnect_pending;
+       unsigned int uncorrected_block_count;
        atomic_t inuse;
 
        void *streambuf;
@@ -147,7 +148,7 @@ struct cinergyt2 {
        char phys[64];
        struct delayed_work rc_query_work;
        int rc_input_event;
-       u32 rc_last_code;
+       __le32 rc_last_code;
        unsigned long last_event_jiffies;
 #endif
 };
@@ -160,7 +161,7 @@ enum {
 
 struct cinergyt2_rc_event {
        char type;
-       uint32_t value;
+       __le32 value;
 } __attribute__((packed));
 
 static const uint32_t rc_keys[] = {
@@ -619,8 +620,11 @@ static int cinergyt2_ioctl (struct inode *inode, struct file *file,
        {
                uint32_t unc_count;
 
-               unc_count = stat->uncorrected_block_count;
-               stat->uncorrected_block_count = 0;
+               if (mutex_lock_interruptible(&cinergyt2->sem))
+                       return -ERESTARTSYS;
+               unc_count = cinergyt2->uncorrected_block_count;
+               cinergyt2->uncorrected_block_count = 0;
+               mutex_unlock(&cinergyt2->sem);
 
                /* UNC are already converted to host byte order... */
                return put_user(unc_count,(__u32 __user *) arg);
@@ -769,7 +773,7 @@ static void cinergyt2_query_rc (struct work_struct *work)
                                input_sync(cinergyt2->rc_input_dev);
                                cinergyt2->rc_input_event = KEY_MAX;
                        }
-                       cinergyt2->rc_last_code = ~0;
+                       cinergyt2->rc_last_code = cpu_to_le32(~0);
                }
                goto out;
        }
@@ -780,7 +784,7 @@ static void cinergyt2_query_rc (struct work_struct *work)
                        n, le32_to_cpu(rc_events[n].value), rc_events[n].type);
 
                if (rc_events[n].type == CINERGYT2_RC_EVENT_TYPE_NEC &&
-                   rc_events[n].value == ~0) {
+                   rc_events[n].value == cpu_to_le32(~0)) {
                        /* keyrepeat bit -> just repeat last rc_input_event */
                } else {
                        cinergyt2->rc_input_event = KEY_MAX;
@@ -795,7 +799,7 @@ static void cinergyt2_query_rc (struct work_struct *work)
 
                if (cinergyt2->rc_input_event != KEY_MAX) {
                        if (rc_events[n].value == cinergyt2->rc_last_code &&
-                           cinergyt2->rc_last_code != ~0) {
+                           cinergyt2->rc_last_code != cpu_to_le32(~0)) {
                                /* emit a key-up so the double event is recognized */
                                dprintk(1, "rc_input_event=%d UP\n", cinergyt2->rc_input_event);
                                input_report_key(cinergyt2->rc_input_dev,
@@ -829,7 +833,7 @@ static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2)
        usb_make_path(cinergyt2->udev, cinergyt2->phys, sizeof(cinergyt2->phys));
        strlcat(cinergyt2->phys, "/input0", sizeof(cinergyt2->phys));
        cinergyt2->rc_input_event = KEY_MAX;
-       cinergyt2->rc_last_code = ~0;
+       cinergyt2->rc_last_code = cpu_to_le32(~0);
        INIT_DELAYED_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc);
 
        input_dev->name = DRIVER_NAME " remote control";
@@ -840,8 +844,8 @@ static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2)
        input_dev->keycodesize = 0;
        input_dev->keycodemax = 0;
        input_dev->id.bustype = BUS_USB;
-       input_dev->id.vendor = cinergyt2->udev->descriptor.idVendor;
-       input_dev->id.product = cinergyt2->udev->descriptor.idProduct;
+       input_dev->id.vendor = le16_to_cpu(cinergyt2->udev->descriptor.idVendor);
+       input_dev->id.product = le16_to_cpu(cinergyt2->udev->descriptor.idProduct);
        input_dev->id.version = 1;
        input_dev->dev.parent = &cinergyt2->udev->dev;
 
@@ -889,18 +893,16 @@ static void cinergyt2_query (struct work_struct *work)
        char cmd [] = { CINERGYT2_EP1_GET_TUNER_STATUS };
        struct dvbt_get_status_msg *s = &cinergyt2->status;
        uint8_t lock_bits;
-       uint32_t unc;
 
        if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return;
 
-       unc = s->uncorrected_block_count;
        lock_bits = s->lock_bits;
 
        cinergyt2_command(cinergyt2, cmd, sizeof(cmd), (char *) s, sizeof(*s));
 
-       unc += le32_to_cpu(s->uncorrected_block_count);
-       s->uncorrected_block_count = unc;
+       cinergyt2->uncorrected_block_count +=
+               le32_to_cpu(s->uncorrected_block_count);
 
        if (lock_bits != s->lock_bits) {
                wake_up_interruptible(&cinergyt2->poll_wq);
index 56d871cfd7fc23bf6406fca9f3f0482830c6b881..c2334aef4143f318813681587f2638870daf35a7 100644 (file)
@@ -168,7 +168,7 @@ struct dvb_net_priv {
  *  stolen from eth.c out of the linux kernel, hacked for dvb-device
  *  by Michael Holzt <kju@debian.org>
  */
-static unsigned short dvb_net_eth_type_trans(struct sk_buff *skb,
+static __be16 dvb_net_eth_type_trans(struct sk_buff *skb,
                                      struct net_device *dev)
 {
        struct ethhdr *eth;
@@ -277,10 +277,10 @@ static int handle_one_ule_extension( struct dvb_net_priv *p )
                        if(ext_len >= 0) {
                                p->ule_next_hdr += ext_len;
                                if (!p->ule_bridged) {
-                                       p->ule_sndu_type = ntohs(*(unsigned short *)p->ule_next_hdr);
+                                       p->ule_sndu_type = ntohs(*(__be16 *)p->ule_next_hdr);
                                        p->ule_next_hdr += 2;
                                } else {
-                                       p->ule_sndu_type = ntohs(*(unsigned short *)(p->ule_next_hdr + ((p->ule_dbit ? 2 : 3) * ETH_ALEN)));
+                                       p->ule_sndu_type = ntohs(*(__be16 *)(p->ule_next_hdr + ((p->ule_dbit ? 2 : 3) * ETH_ALEN)));
                                        /* This assures the extension handling loop will terminate. */
                                }
                        }
@@ -294,7 +294,7 @@ static int handle_one_ule_extension( struct dvb_net_priv *p )
                if (ule_optional_ext_handlers[htype])
                        (void)ule_optional_ext_handlers[htype]( p );
                p->ule_next_hdr += ext_len;
-               p->ule_sndu_type = ntohs( *(unsigned short *)(p->ule_next_hdr-2) );
+               p->ule_sndu_type = ntohs( *(__be16 *)(p->ule_next_hdr-2) );
                /*
                 * note: the length of the next header type is included in the
                 * length of THIS optional extension header
@@ -594,8 +594,8 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
                /* Check for complete payload. */
                if (priv->ule_sndu_remain <= 0) {
                        /* Check CRC32, we've got it in our skb already. */
-                       unsigned short ulen = htons(priv->ule_sndu_len);
-                       unsigned short utype = htons(priv->ule_sndu_type);
+                       __be16 ulen = htons(priv->ule_sndu_len);
+                       __be16 utype = htons(priv->ule_sndu_type);
                        const u8 *tail;
                        struct kvec iov[3] = {
                                { &ulen, sizeof ulen },
index cf4584e48b6d66c70d40572650e791873ce37862..f00a0eb40420942284e53e2c78c26b402d4991b1 100644 (file)
@@ -1,6 +1,6 @@
 config DVB_USB
        tristate "Support for various USB DVB devices"
-       depends on DVB_CORE && USB && I2C
+       depends on DVB_CORE && USB && I2C && INPUT
        depends on HOTPLUG      # due to FW_LOADER
        select FW_LOADER
        help
index 346223856f597e218828aacb233ed18ec3634568..c4d40fe01d579f09d57489a86b90a206538f5ed0 100644 (file)
@@ -111,8 +111,8 @@ static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
        struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
        s8 a;
        int if1=1220;
-       if (adap->dev->udev->descriptor.idVendor  == USB_VID_HAUPPAUGE &&
-               adap->dev->udev->descriptor.idProduct == USB_PID_HAUPPAUGE_NOVA_T_500_2) {
+       if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
+               adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
                if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
        }
        return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
@@ -402,8 +402,8 @@ static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
 {
        struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
 
-       if (desc->idVendor  == USB_VID_PINNACLE &&
-           desc->idProduct == USB_PID_PINNACLE_EXPRESSCARD_320CX)
+       if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
+           desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
        else
        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
@@ -845,8 +845,8 @@ static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
        struct i2c_adapter *tun_i2c;
        s8 a;
        int if1=1220;
-       if (adap->dev->udev->descriptor.idVendor  == USB_VID_HAUPPAUGE &&
-               adap->dev->udev->descriptor.idProduct == USB_PID_HAUPPAUGE_NOVA_T_STICK) {
+       if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
+               adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
                if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
        }
        if (st->is_dib7000pc)
@@ -990,11 +990,12 @@ static struct dib7000p_config dib7070p_dib7000p_config = {
 /* STK7070P */
 static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
 {
-       if (adap->dev->udev->descriptor.idVendor  == USB_VID_PINNACLE &&
-       adap->dev->udev->descriptor.idProduct == USB_PID_PINNACLE_PCTV72E)
-       dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+       struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
+       if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
+           p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
+               dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
        else
-       dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+               dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
        msleep(10);
        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
index e1112e39fb638e4d9731510afd7a22667ba434ea..733a7ff7b207819bcd05f2a816388fa21e9f69b5 100644 (file)
@@ -127,7 +127,7 @@ int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx,
        if ((*pos + hx->len + 4) >= fw->size)
                return -EINVAL;
 
-       hx->addr = le16_to_cpu( *((u16 *) &b[1]) );
+       hx->addr = b[1] | (b[2] << 8);
        hx->type = b[3];
 
        if (hx->type == 0x04) {
index 9a942afaf0af8d1a3c16cf9e5681656d3c1eca72..2653120673b77763e647e1d4a888bad14a5e221a 100644 (file)
@@ -146,24 +146,24 @@ static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
                if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
                        if (! (status & bm8pskFW_Loaded)) /* BCM4500 firmware loaded */
                                if(gp8psk_load_bcm4500fw(d))
-                                       return EINVAL;
+                                       return -EINVAL;
 
                if (! (status & bmIntersilOn)) /* LNB Power */
                        if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
                                        &buf, 1))
-                               return EINVAL;
+                               return -EINVAL;
 
                /* Set DVB mode to 1 */
                if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
                        if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
-                               return EINVAL;
+                               return -EINVAL;
                /* Abort possible TS (if previous tune crashed) */
                if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0))
-                       return EINVAL;
+                       return -EINVAL;
        } else {
                /* Turn off LNB power */
                if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
-                       return EINVAL;
+                       return -EINVAL;
                /* Turn off 8psk power */
                if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
                        return -EINVAL;
index a12e6f784fdae92aade0f2b08040f93948206155..54626a0dbf68da45274c92fd3f78a18ff48b6857 100644 (file)
@@ -16,6 +16,7 @@
 #include "qt1010.h"
 #include "tda1004x.h"
 #include "tda827x.h"
+#include <asm/unaligned.h>
 
 /* debug */
 static int dvb_usb_m920x_debug;
@@ -347,13 +348,13 @@ static int m920x_firmware_download(struct usb_device *udev, const struct firmwar
 
        for (pass = 0; pass < 2; pass++) {
                for (i = 0; i + (sizeof(u16) * 3) < fw->size;) {
-                       value = le16_to_cpu(*(u16 *)(fw->data + i));
+                       value = get_unaligned_le16(fw->data + i);
                        i += sizeof(u16);
 
-                       index = le16_to_cpu(*(u16 *)(fw->data + i));
+                       index = get_unaligned_le16(fw->data + i);
                        i += sizeof(u16);
 
-                       size = le16_to_cpu(*(u16 *)(fw->data + i));
+                       size = get_unaligned_le16(fw->data + i);
                        i += sizeof(u16);
 
                        if (pass == 1) {
index 786e37d33889d753c37121daa42cd2d5d82bc269..3eedfdf505bc5d49f6551268dc966544bc17fa83 100644 (file)
@@ -37,7 +37,20 @@ struct dib0070_config {
        u8 flip_chip;
 };
 
-extern struct dvb_frontend * dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg);
+#if defined(CONFIG_DVB_TUNER_DIB0070) || (defined(CONFIG_DVB_TUNER_DIB0070_MODULE) && defined(MODULE))
+extern struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe,
+                                          struct i2c_adapter *i2c,
+                                          struct dib0070_config *cfg);
+#else
+static inline struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe,
+                                                 struct i2c_adapter *i2c,
+                                                 struct dib0070_config *cfg)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
 extern void dib0070_ctrl_agc_filter(struct dvb_frontend *, uint8_t open);
 extern u16 dib0070_wbd_offset(struct dvb_frontend *);
 
index 081bd81f3da2ec5a2b61b797df57ca63b68d8ffe..07c4d12ed5b7846bf3e9589cd2236fe49668fa9f 100644 (file)
@@ -37,7 +37,20 @@ struct dib7000p_config {
 
 #define DEFAULT_DIB7000P_I2C_ADDRESS 18
 
-extern struct dvb_frontend * dib7000p_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib7000p_config *cfg);
+#if defined(CONFIG_DVB_DIB7000P) || (defined(CONFIG_DVB_DIB7000P_MODULE) && defined(MODULE))
+extern struct dvb_frontend *dib7000p_attach(struct i2c_adapter *i2c_adap,
+                                           u8 i2c_addr,
+                                           struct dib7000p_config *cfg);
+#else
+static inline struct dvb_frontend *dib7000p_attach(struct i2c_adapter *i2c_adap,
+                                                  u8 i2c_addr,
+                                                  struct dib7000p_config *cfg)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
 extern int dib7000p_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib7000p_config cfg[]);
 
 extern struct i2c_adapter * dib7000p_get_i2c_master(struct dvb_frontend *, enum dibx000_i2c_interface, int);
index c7b5785f81f263321c83d54e93a26d51348ad333..5ed32544de3964798a38f6683109acd92b693971 100644 (file)
@@ -126,7 +126,7 @@ static int or51132_readreg(struct or51132_state *state, u8 reg)
                       reg, err);
                return -EREMOTEIO;
        }
-       return le16_to_cpup((u16*)buf);
+       return buf[0] | (buf[1] << 8);
 }
 
 static int or51132_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
@@ -140,9 +140,9 @@ static int or51132_load_firmware (struct dvb_frontend* fe, const struct firmware
        dprintk("Firmware is %Zd bytes\n",fw->size);
 
        /* Get size of firmware A and B */
-       firmwareAsize = le32_to_cpu(*((u32*)fw->data));
+       firmwareAsize = le32_to_cpu(*((__le32*)fw->data));
        dprintk("FirmwareA is %i bytes\n",firmwareAsize);
-       firmwareBsize = le32_to_cpu(*((u32*)(fw->data+4)));
+       firmwareBsize = le32_to_cpu(*((__le32*)(fw->data+4)));
        dprintk("FirmwareB is %i bytes\n",firmwareBsize);
 
        /* Upload firmware */
index 747e7f1a6267be0a9d3d9cf4eb1d4766c97691b5..f05d43d8b5cf25cfef2bdc0e866c97080ffca257 100644 (file)
@@ -51,6 +51,7 @@
 #include <linux/crc32.h>
 #include <linux/i2c.h>
 #include <linux/kthread.h>
+#include <asm/unaligned.h>
 
 #include <asm/system.h>
 
@@ -1461,9 +1462,9 @@ static int check_firmware(struct av7110* av7110)
        ptr += 4;
 
        /* check dpram file */
-       crc = ntohl(*(u32*) ptr);
+       crc = get_unaligned_be32(ptr);
        ptr += 4;
-       len = ntohl(*(u32*) ptr);
+       len = get_unaligned_be32(ptr);
        ptr += 4;
        if (len >= 512) {
                printk("dvb-ttpci: dpram file is way too big.\n");
@@ -1478,9 +1479,9 @@ static int check_firmware(struct av7110* av7110)
        ptr += len;
 
        /* check root file */
-       crc = ntohl(*(u32*) ptr);
+       crc = get_unaligned_be32(ptr);
        ptr += 4;
-       len = ntohl(*(u32*) ptr);
+       len = get_unaligned_be32(ptr);
        ptr += 4;
 
        if (len <= 200000 || len >= 300000 ||
index 3e6b650fbb81d71ee6c9adf05f7a0113ae3d8052..ec55a968f204cf1195dbb219883055a149b46267 100644 (file)
@@ -965,8 +965,9 @@ static u8 iframe_header[] = { 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x00, 0x
 
 static int play_iframe(struct av7110 *av7110, char __user *buf, unsigned int len, int nonblock)
 {
-       int i, n;
+       unsigned i, n;
        int progressive = 0;
+       int match = 0;
 
        dprintk(2, "av7110:%p, \n", av7110);
 
@@ -975,12 +976,31 @@ static int play_iframe(struct av7110 *av7110, char __user *buf, unsigned int len
                        return -EBUSY;
        }
 
-       for (i = 0; i < len - 5; i++) {
-               /* get progressive flag from picture extension */
-               if (buf[i] == 0x00 && buf[i+1] == 0x00 &&
-                   buf[i+2] == 0x01 && (unsigned char)buf[i+3] == 0xb5 &&
-                   (buf[i+4] & 0xf0) == 0x10)
-                       progressive = buf[i+5] & 0x08;
+       /* search in buf for instances of 00 00 01 b5 1? */
+       for (i = 0; i < len; i++) {
+               unsigned char c;
+               if (get_user(c, buf + i))
+                       return -EFAULT;
+               if (match == 5) {
+                       progressive = c & 0x08;
+                       match = 0;
+               }
+               if (c == 0x00) {
+                       match = (match == 1 || match == 2) ? 2 : 1;
+                       continue;
+               }
+               switch (match++) {
+               case 2: if (c == 0x01)
+                               continue;
+                       break;
+               case 3: if (c == 0xb5)
+                               continue;
+                       break;
+               case 4: if ((c & 0xf0) == 0x10)
+                               continue;
+                       break;
+               }
+               match = 0;
        }
 
        /* setting n always > 1, fixes problems when playing stillframes
index 732ce4de512eaa392e12151150adb7c7940a19cf..5d2d81ab23710a32bf8a9f4fd47b58724dc164e3 100644 (file)
@@ -552,7 +552,7 @@ static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
        u16 csum = 0, cc;
        int i;
        for (i = 0; i < len; i += 2)
-               csum ^= le16_to_cpup((u16 *) (muxpack + i));
+               csum ^= le16_to_cpup((__le16 *) (muxpack + i));
        if (csum) {
                printk("%s: muxpack with incorrect checksum, ignoring\n",
                       __func__);
index 0712899e39a44dea8d7f1ce516313dd9cd408311..a23cc0aa17d30519c99ddb737989777d394145dc 100644 (file)
@@ -1,6 +1,6 @@
 config DVB_TTUSB_DEC
        tristate "Technotrend/Hauppauge USB DEC devices"
-       depends on DVB_CORE && USB
+       depends on DVB_CORE && USB && INPUT
        depends on HOTPLUG      # due to FW_LOADER
        select FW_LOADER
        select CRC32
index 42eee04daa5da4407c4d383982aeffbf51c1f15c..fefdc05e84ac787f2d08d1f44d4a415605c95241 100644 (file)
@@ -343,7 +343,7 @@ static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
        u8 c[COMMAND_PACKET_SIZE];
        int c_length;
        int result;
-       unsigned int tmp;
+       __be32 tmp;
 
        dprintk("%s\n", __func__);
 
@@ -398,9 +398,9 @@ static void ttusb_dec_set_pids(struct ttusb_dec *dec)
                   0x00, 0x00, 0xff, 0xff,
                   0xff, 0xff, 0xff, 0xff };
 
-       u16 pcr = htons(dec->pid[DMX_PES_PCR]);
-       u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
-       u16 video = htons(dec->pid[DMX_PES_VIDEO]);
+       __be16 pcr = htons(dec->pid[DMX_PES_PCR]);
+       __be16 audio = htons(dec->pid[DMX_PES_AUDIO]);
+       __be16 video = htons(dec->pid[DMX_PES_VIDEO]);
 
        dprintk("%s\n", __func__);
 
@@ -435,7 +435,7 @@ static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
        case 0x01: {            /* VideoStream */
                int prebytes = pva[5] & 0x03;
                int postbytes = (pva[5] & 0x0c) >> 2;
-               u16 v_pes_payload_length;
+               __be16 v_pes_payload_length;
 
                if (output_pva) {
                        dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
@@ -1006,7 +1006,7 @@ static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
                    0x00, 0x00, 0x00, 0x00,
                    0x00, 0x00, 0x00, 0x00,
                    0x00 };
-       u16 pid;
+       __be16 pid;
        u8 c[COMMAND_PACKET_SIZE];
        int c_length;
        int result;
@@ -1278,9 +1278,10 @@ static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
        u8 *firmware = NULL;
        size_t firmware_size = 0;
        u16 firmware_csum = 0;
-       u16 firmware_csum_ns;
-       u32 firmware_size_nl;
-       u32 crc32_csum, crc32_check, tmp;
+       __be16 firmware_csum_ns;
+       __be32 firmware_size_nl;
+       u32 crc32_csum, crc32_check;
+       __be32 tmp;
        const struct firmware *fw_entry = NULL;
 
        dprintk("%s\n", __func__);
@@ -1306,7 +1307,7 @@ static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
           valid. */
        crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
        memcpy(&tmp, &firmware[56], 4);
-       crc32_check = htonl(tmp);
+       crc32_check = ntohl(tmp);
        if (crc32_csum != crc32_check) {
                printk("%s: crc32 check of DSP code failed (calculated "
                       "0x%08x != 0x%08x in file), file invalid.\n",
@@ -1627,7 +1628,7 @@ static int ttusb_dec_probe(struct usb_interface *intf,
 
        usb_set_intfdata(intf, (void *)dec);
 
-       switch (le16_to_cpu(id->idProduct)) {
+       switch (id->idProduct) {
        case 0x1006:
                ttusb_dec_set_model(dec, TTUSB_DEC3000S);
                break;
@@ -1652,7 +1653,7 @@ static int ttusb_dec_probe(struct usb_interface *intf,
        ttusb_dec_init_dvb(dec);
 
        dec->adapter.priv = dec;
-       switch (le16_to_cpu(id->idProduct)) {
+       switch (id->idProduct) {
        case 0x1006:
                dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
                break;
index eb5eaeccd7c4db2dc16e8ee948f08802d7851cb3..443af24097f34118fe51c66aa7bb80aa12d17c1f 100644 (file)
@@ -86,7 +86,7 @@ static int ttusbdecfe_dvbt_set_frontend(struct dvb_frontend* fe, struct dvb_fron
                   0x00, 0x00, 0x00, 0xff,
                   0x00, 0x00, 0x00, 0xff };
 
-       u32 freq = htonl(p->frequency / 1000);
+       __be32 freq = htonl(p->frequency / 1000);
        memcpy(&b[4], &freq, sizeof (u32));
        state->config->send_command(fe, 0x71, sizeof(b), b, NULL, NULL);
 
@@ -117,10 +117,10 @@ static int ttusbdecfe_dvbs_set_frontend(struct dvb_frontend* fe, struct dvb_fron
                   0x00, 0x00, 0x00, 0x00,
                   0x00, 0x00, 0x00, 0x00,
                   0x00, 0x00, 0x00, 0x00 };
-       u32 freq;
-       u32 sym_rate;
-       u32 band;
-       u32 lnb_voltage;
+       __be32 freq;
+       __be32 sym_rate;
+       __be32 band;
+       __be32 lnb_voltage;
 
        freq = htonl(p->frequency +
               (state->hi_band ? LOF_HI : LOF_LO));
index def10d08637303f1c71559ef264496a04ed33437..52b2491581a835784790d7bec436693fe2854160 100644 (file)
@@ -1,7 +1,7 @@
 
 config VIDEO_AU0828
        tristate "Auvitek AU0828 support"
-       depends on VIDEO_DEV && I2C && INPUT && DVB_CORE && USB
+       depends on I2C && INPUT && DVB_CORE && USB
        select I2C_ALGOBIT
        select VIDEO_TVEEPROM
        select DVB_AU8522 if !DVB_FE_CUSTOMIZE
index c86a5f17eca81d6b7ff46b583c3121737f6c56d4..c6d47059038029f6d039b071512a3f343d633043 100644 (file)
@@ -353,12 +353,6 @@ int au0828_dvb_register(struct au0828_dev *dev)
                return -1;
        }
 
-       /* Put the analog decoder in standby to keep it quiet */
-       au0828_call_i2c_clients(dev, TUNER_SET_STANDBY, NULL);
-
-       if (dvb->frontend->ops.analog_ops.standby)
-               dvb->frontend->ops.analog_ops.standby(dvb->frontend);
-
        /* register everything */
        ret = dvb_register(dev);
        if (ret < 0) {
index f20a01cfc73e442dea087f4962c09cad5f603a12..8ef0424c26c4dc405eed8097ee3c2662309bfe21 100644 (file)
@@ -34,6 +34,7 @@
 #include <linux/firmware.h>
 #include <net/checksum.h>
 
+#include <asm/unaligned.h>
 #include <asm/io.h>
 
 #include "bttvp.h"
@@ -3858,7 +3859,7 @@ static void __devinit osprey_eeprom(struct bttv *btv, const u8 ee[256])
                ee += i;
 
                /* found a valid descriptor */
-               type = be16_to_cpup((u16*)(ee+4));
+               type = get_unaligned_be16((__be16 *)(ee+4));
 
                switch(type) {
                /* 848 based */
@@ -3918,7 +3919,7 @@ static void __devinit osprey_eeprom(struct bttv *btv, const u8 ee[256])
                               btv->c.nr, type);
                        break;
                }
-               serial = be32_to_cpup((u32*)(ee+6));
+               serial = get_unaligned_be32((__be32 *)(ee+6));
        }
 
        printk(KERN_INFO "bttv%d: osprey eeprom: card=%d '%s' serial=%u\n",
index e5979f77504c7329c2603905066735f636ae65ac..0af586876e72f6f7f01295cb99381f159feec47e 100644 (file)
@@ -48,7 +48,7 @@ bttv_risc_packed(struct bttv *btv, struct btcx_riscmem *risc,
 {
        u32 instructions,line,todo;
        struct scatterlist *sg;
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        /* estimate risc mem: worst case is one write per page border +
@@ -128,7 +128,8 @@ bttv_risc_planar(struct bttv *btv, struct btcx_riscmem *risc,
                 unsigned int cpadding)
 {
        unsigned int instructions,line,todo,ylen,chroma;
-       u32 *rp,ri;
+       __le32 *rp;
+       u32 ri;
        struct scatterlist *ysg;
        struct scatterlist *usg;
        struct scatterlist *vsg;
@@ -244,7 +245,8 @@ bttv_risc_overlay(struct bttv *btv, struct btcx_riscmem *risc,
 {
        int dwords,rc,line,maxy,start,end,skip,nskips;
        struct btcx_skiplist *skips;
-       u32 *rp,ri,ra;
+       __le32 *rp;
+       u32 ri,ra;
        u32 addr;
 
        /* skip list for window clipping */
index ce0840ccd594e42332767d7d0b87bc4e4cbdc4d5..f42701f82e7fe72009bd8391672bbb40d80d306b 100644 (file)
@@ -63,7 +63,7 @@ int btcx_riscmem_alloc(struct pci_dev *pci,
                       struct btcx_riscmem *risc,
                       unsigned int size)
 {
-       u32 *cpu;
+       __le32 *cpu;
        dma_addr_t dma;
 
        if (NULL != risc->cpu && risc->size < size)
index 503e6c6d7b6917d5e46a7059245242ed1f66286f..861bc8112824959298bf40c422b3782984f2deee 100644 (file)
@@ -2,8 +2,8 @@
  */
 struct btcx_riscmem {
        unsigned int   size;
-       u32            *cpu;
-       u32            *jmp;
+       __le32         *cpu;
+       __le32         *jmp;
        dma_addr_t     dma;
 };
 
index 66864904c99b903d054c3cbec285f38e33b608e2..9a26751615c618d6dcf1d5d42e36d02ecda29ef5 100644 (file)
@@ -182,14 +182,16 @@ static void input_change(struct cx18 *cx)
                if (std == V4L2_STD_NTSC_M_JP) {
                        /* Japan uses EIAJ audio standard */
                        cx18_av_write(cx, 0x808, 0xf7);
+                       cx18_av_write(cx, 0x80b, 0x02);
                } else if (std == V4L2_STD_NTSC_M_KR) {
                        /* South Korea uses A2 audio standard */
                        cx18_av_write(cx, 0x808, 0xf8);
+                       cx18_av_write(cx, 0x80b, 0x03);
                } else {
                        /* Others use the BTSC audio standard */
                        cx18_av_write(cx, 0x808, 0xf6);
+                       cx18_av_write(cx, 0x80b, 0x01);
                }
-               cx18_av_write(cx, 0x80b, 0x00);
        } else if (std & V4L2_STD_PAL) {
                /* Follow tuner change procedure for PAL */
                cx18_av_write(cx, 0x808, 0xff);
@@ -741,8 +743,8 @@ static void log_audio_status(struct cx18 *cx)
 {
        struct cx18_av_state *state = &cx->av_state;
        u8 download_ctl = cx18_av_read(cx, 0x803);
-       u8 mod_det_stat0 = cx18_av_read(cx, 0x805);
-       u8 mod_det_stat1 = cx18_av_read(cx, 0x804);
+       u8 mod_det_stat0 = cx18_av_read(cx, 0x804);
+       u8 mod_det_stat1 = cx18_av_read(cx, 0x805);
        u8 audio_config = cx18_av_read(cx, 0x808);
        u8 pref_mode = cx18_av_read(cx, 0x809);
        u8 afc0 = cx18_av_read(cx, 0x80b);
@@ -760,12 +762,12 @@ static void log_audio_status(struct cx18 *cx)
        case 0x12: p = "dual with SAP"; break;
        case 0x14: p = "tri with SAP"; break;
        case 0xfe: p = "forced mode"; break;
-       default: p = "not defined";
+       default: p = "not defined"; break;
        }
        CX18_INFO("Detected audio mode:       %s\n", p);
 
        switch (mod_det_stat1) {
-       case 0x00: p = "BTSC"; break;
+       case 0x00: p = "not defined"; break;
        case 0x01: p = "EIAJ"; break;
        case 0x02: p = "A2-M"; break;
        case 0x03: p = "A2-BG"; break;
@@ -779,8 +781,13 @@ static void log_audio_status(struct cx18 *cx)
        case 0x0b: p = "NICAM-I"; break;
        case 0x0c: p = "NICAM-L"; break;
        case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
+       case 0x0e: p = "IF FM Radio"; break;
+       case 0x0f: p = "BTSC"; break;
+       case 0x10: p = "detected chrominance"; break;
+       case 0xfd: p = "unknown audio standard"; break;
+       case 0xfe: p = "forced audio standard"; break;
        case 0xff: p = "no detected audio standard"; break;
-       default: p = "not defined";
+       default: p = "not defined"; break;
        }
        CX18_INFO("Detected audio standard:   %s\n", p);
        CX18_INFO("Audio muted:               %s\n",
@@ -789,22 +796,23 @@ static void log_audio_status(struct cx18 *cx)
                    (download_ctl & 0x10) ? "running" : "stopped");
 
        switch (audio_config >> 4) {
-       case 0x00: p = "BTSC"; break;
-       case 0x01: p = "EIAJ"; break;
-       case 0x02: p = "A2-M"; break;
-       case 0x03: p = "A2-BG"; break;
-       case 0x04: p = "A2-DK1"; break;
-       case 0x05: p = "A2-DK2"; break;
-       case 0x06: p = "A2-DK3"; break;
-       case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
-       case 0x08: p = "AM-L"; break;
-       case 0x09: p = "NICAM-BG"; break;
-       case 0x0a: p = "NICAM-DK"; break;
-       case 0x0b: p = "NICAM-I"; break;
-       case 0x0c: p = "NICAM-L"; break;
-       case 0x0d: p = "FM radio"; break;
+       case 0x00: p = "undefined"; break;
+       case 0x01: p = "BTSC"; break;
+       case 0x02: p = "EIAJ"; break;
+       case 0x03: p = "A2-M"; break;
+       case 0x04: p = "A2-BG"; break;
+       case 0x05: p = "A2-DK1"; break;
+       case 0x06: p = "A2-DK2"; break;
+       case 0x07: p = "A2-DK3"; break;
+       case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
+       case 0x09: p = "AM-L"; break;
+       case 0x0a: p = "NICAM-BG"; break;
+       case 0x0b: p = "NICAM-DK"; break;
+       case 0x0c: p = "NICAM-I"; break;
+       case 0x0d: p = "NICAM-L"; break;
+       case 0x0e: p = "FM radio"; break;
        case 0x0f: p = "automatic detection"; break;
-       default: p = "undefined";
+       default: p = "undefined"; break;
        }
        CX18_INFO("Configured audio standard: %s\n", p);
 
@@ -815,12 +823,9 @@ static void log_audio_status(struct cx18 *cx)
                case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
                case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
                case 0x04: p = "STEREO"; break;
-               case 0x05: p = "DUAL1 (AB)"; break;
-               case 0x06: p = "DUAL2 (AC) (FM)"; break;
-               case 0x07: p = "DUAL3 (BC) (FM)"; break;
-               case 0x08: p = "DUAL4 (AC) (AM)"; break;
-               case 0x09: p = "DUAL5 (BC) (AM)"; break;
-               case 0x0a: p = "SAP"; break;
+               case 0x05: p = "DUAL1 (AC)"; break;
+               case 0x06: p = "DUAL2 (BC)"; break;
+               case 0x07: p = "DUAL3 (AB)"; break;
                default: p = "undefined";
                }
                CX18_INFO("Configured audio mode:     %s\n", p);
@@ -835,9 +840,11 @@ static void log_audio_status(struct cx18 *cx)
                case 0x06: p = "BTSC"; break;
                case 0x07: p = "EIAJ"; break;
                case 0x08: p = "A2-M"; break;
-               case 0x09: p = "FM Radio"; break;
+               case 0x09: p = "FM Radio (4.5 MHz)"; break;
+               case 0x0a: p = "FM Radio (5.5 MHz)"; break;
+               case 0x0b: p = "S-Video"; break;
                case 0x0f: p = "automatic standard and mode detection"; break;
-               default: p = "undefined";
+               default: p = "undefined"; break;
                }
                CX18_INFO("Configured audio system:   %s\n", p);
        }
@@ -857,22 +864,24 @@ static void log_audio_status(struct cx18 *cx)
        case 5: p = "language AC"; break;
        case 6: p = "language BC"; break;
        case 7: p = "language AB"; break;
-       default: p = "undefined";
+       default: p = "undefined"; break;
        }
        CX18_INFO("Preferred audio mode:      %s\n", p);
 
        if ((audio_config & 0xf) == 0xf) {
-               switch ((afc0 >> 2) & 0x1) {
+               switch ((afc0 >> 3) & 0x1) {
                case 0: p = "system DK"; break;
                case 1: p = "system L"; break;
                }
                CX18_INFO("Selected 65 MHz format:    %s\n", p);
 
-               switch (afc0 & 0x3) {
-               case 0: p = "BTSC"; break;
-               case 1: p = "EIAJ"; break;
-               case 2: p = "A2-M"; break;
-               default: p = "undefined";
+               switch (afc0 & 0x7) {
+               case 0: p = "Chroma"; break;
+               case 1: p = "BTSC"; break;
+               case 2: p = "EIAJ"; break;
+               case 3: p = "A2-M"; break;
+               case 4: p = "autodetect"; break;
+               default: p = "undefined"; break;
                }
                CX18_INFO("Selected 45 MHz format:    %s\n", p);
        }
index 553adbf2cd44eab938109121e1c388aa93a97f69..baccd079243d9682efbe949ee11a6a69bfc419bb 100644 (file)
@@ -126,7 +126,7 @@ static const struct cx18_card cx18_card_hvr1600_samsung = {
 
 /* ------------------------------------------------------------------------- */
 
-/* Compro VideoMate H900: not working at the moment! */
+/* Compro VideoMate H900: note that this card is analog only! */
 
 static const struct cx18_card_pci_info cx18_pci_h900[] = {
        { PCI_DEVICE_ID_CX23418, CX18_PCI_ID_COMPRO, 0xe100 },
@@ -136,7 +136,7 @@ static const struct cx18_card_pci_info cx18_pci_h900[] = {
 static const struct cx18_card cx18_card_h900 = {
        .type = CX18_CARD_COMPRO_H900,
        .name = "Compro VideoMate H900",
-       .comment = "DVB & VBI are not yet supported\n",
+       .comment = "VBI is not yet supported\n",
        .v4l2_capabilities = CX18_CAP_ENCODER,
        .hw_audio_ctrl = CX18_HW_CX23418,
        .hw_all = CX18_HW_TUNER,
index 2bdac5ebbb0d884710769c0193ad8089aa58b0d2..87cf41021665fdf2d4a862b79ce8853becdf0d7d 100644 (file)
@@ -159,7 +159,7 @@ static int cx18_setup_vbi_fmt(struct cx18 *cx, enum v4l2_mpeg_stream_vbi_fmt fmt
 {
        if (!(cx->v4l2_cap & V4L2_CAP_SLICED_VBI_CAPTURE))
                return -EINVAL;
-       if (atomic_read(&cx->capturing) > 0)
+       if (atomic_read(&cx->ana_capturing) > 0)
                return -EBUSY;
 
        /* First try to allocate sliced VBI buffers if needed. */
@@ -235,7 +235,7 @@ int cx18_control_ioctls(struct cx18 *cx, unsigned int cmd, void *arg)
                CX18_DEBUG_IOCTL("VIDIOC_S_EXT_CTRLS\n");
                if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
                        struct cx2341x_mpeg_params p = cx->params;
-                       int err = cx2341x_ext_ctrls(&p, atomic_read(&cx->capturing), arg, cmd);
+                       int err = cx2341x_ext_ctrls(&p, atomic_read(&cx->ana_capturing), arg, cmd);
 
                        if (err)
                                return err;
@@ -295,7 +295,7 @@ int cx18_control_ioctls(struct cx18 *cx, unsigned int cmd, void *arg)
                CX18_DEBUG_IOCTL("VIDIOC_TRY_EXT_CTRLS\n");
                if (c->ctrl_class == V4L2_CTRL_CLASS_MPEG)
                        return cx2341x_ext_ctrls(&cx->params,
-                                       atomic_read(&cx->capturing), arg, cmd);
+                                       atomic_read(&cx->ana_capturing), arg, cmd);
                return -EINVAL;
        }
 
index 0dd4e05299706f83171de37a47ea801fbf8939b9..2b810bb2a4c70f8d37fc40b6ed5646d1ce5e308f 100644 (file)
@@ -670,7 +670,7 @@ static int __devinit cx18_probe(struct pci_dev *dev,
        cx18_init_power(cx, 1);
        cx18_init_memory(cx);
 
-       cx->scb = (struct cx18_scb *)(cx->enc_mem + SCB_OFFSET);
+       cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
        cx18_init_scb(cx);
 
        cx18_gpio_init(cx);
@@ -751,17 +751,6 @@ static int __devinit cx18_probe(struct pci_dev *dev,
        if (cx->options.radio > 0)
                cx->v4l2_cap |= V4L2_CAP_RADIO;
 
-       retval = cx18_streams_setup(cx);
-       if (retval) {
-               CX18_ERR("Error %d setting up streams\n", retval);
-               goto free_irq;
-       }
-       retval = cx18_streams_register(cx);
-       if (retval) {
-               CX18_ERR("Error %d registering devices\n", retval);
-               goto free_streams;
-       }
-
        if (cx->options.tuner > -1) {
                struct tuner_setup setup;
 
@@ -788,7 +777,16 @@ static int __devinit cx18_probe(struct pci_dev *dev,
           are not. */
        cx->tuner_std = cx->std;
 
-       cx18_init_on_first_open(cx);
+       retval = cx18_streams_setup(cx);
+       if (retval) {
+               CX18_ERR("Error %d setting up streams\n", retval);
+               goto free_irq;
+       }
+       retval = cx18_streams_register(cx);
+       if (retval) {
+               CX18_ERR("Error %d registering devices\n", retval);
+               goto free_streams;
+       }
 
        CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
 
@@ -889,7 +887,7 @@ static void cx18_remove(struct pci_dev *pci_dev)
 
        /* Stop all captures */
        CX18_DEBUG_INFO("Stopping all streams\n");
-       if (atomic_read(&cx->capturing) > 0)
+       if (atomic_read(&cx->tot_capturing) > 0)
                cx18_stop_all_captures(cx);
 
        /* Interrupts */
index a2a6c58d12fe55ffcb3b1d7be1aebb85603d62b1..de14ab59a206b6c84e88f07e53b0124a5b5a7281 100644 (file)
@@ -358,7 +358,7 @@ struct cx18 {
        u32 v4l2_cap;           /* V4L2 capabilities of card */
        u32 hw_flags;           /* Hardware description of the board */
        unsigned mdl_offset;
-       struct cx18_scb *scb;   /* pointer to SCB */
+       struct cx18_scb __iomem *scb;   /* pointer to SCB */
 
        struct cx18_av_state av_state;
 
@@ -380,7 +380,8 @@ struct cx18 {
        int stream_buf_size[CX18_MAX_STREAMS]; /* Stream buffer size */
        struct cx18_stream streams[CX18_MAX_STREAMS];   /* Stream data */
        unsigned long i_flags;  /* global cx18 flags */
-       atomic_t capturing;     /* count number of active capture streams */
+       atomic_t ana_capturing; /* count number of active analog capture streams */
+       atomic_t tot_capturing; /* total count number of active capture streams */
        spinlock_t lock;        /* lock access to this struct */
        int search_pack_header;
 
@@ -423,6 +424,10 @@ struct cx18 {
        struct mutex i2c_bus_lock[2];
        struct i2c_client *i2c_clients[I2C_CLIENTS_MAX];
 
+       /* gpio */
+       u32 gpio_dir;
+       u32 gpio_val;
+
        /* v4l2 and User settings */
 
        /* codec settings */
index 0b3141db174bbf4473b158d81882af7c2e8415b0..1e537fe04a2372196254aa35e6846131f136c02e 100644 (file)
@@ -318,7 +318,7 @@ static ssize_t cx18_read(struct cx18_stream *s, char __user *ubuf,
        size_t tot_written = 0;
        int single_frame = 0;
 
-       if (atomic_read(&cx->capturing) == 0 && s->id == -1) {
+       if (atomic_read(&cx->ana_capturing) == 0 && s->id == -1) {
                /* shouldn't happen */
                CX18_DEBUG_WARN("Stream %s not initialized before read\n",
                                s->name);
@@ -361,7 +361,8 @@ static ssize_t cx18_read(struct cx18_stream *s, char __user *ubuf,
                                cx18_enqueue(s, buf, &s->q_free);
                                cx18_vapi(cx, CX18_CPU_DE_SET_MDL, 5,
                                        s->handle,
-                                       (void *)&cx->scb->cpu_mdl[buf->id] - cx->enc_mem,
+                                       (void __iomem *)&cx->scb->cpu_mdl[buf->id] -
+                                         cx->enc_mem,
                                        1, buf->id, s->buf_size);
                        } else
                                cx18_enqueue(s, buf, &s->q_io);
@@ -581,7 +582,7 @@ int cx18_v4l2_close(struct inode *inode, struct file *filp)
                cx18_call_i2c_clients(cx, VIDIOC_S_STD, &cx->std);
                /* Select correct audio input (i.e. TV tuner or Line in) */
                cx18_audio_set_io(cx);
-               if (atomic_read(&cx->capturing) > 0) {
+               if (atomic_read(&cx->ana_capturing) > 0) {
                        /* Undo video mute */
                        cx18_vapi(cx, CX18_CPU_SET_VIDEO_MUTE, 2, s->handle,
                                cx->params.video_mute |
@@ -627,7 +628,7 @@ static int cx18_serialized_open(struct cx18_stream *s, struct file *filp)
                }
 
                if (!test_bit(CX18_F_I_RADIO_USER, &cx->i_flags)) {
-                       if (atomic_read(&cx->capturing) > 0) {
+                       if (atomic_read(&cx->ana_capturing) > 0) {
                                /* switching to radio while capture is
                                   in progress is not polite */
                                cx18_release_stream(s);
@@ -694,7 +695,7 @@ int cx18_v4l2_open(struct inode *inode, struct file *filp)
 
 void cx18_mute(struct cx18 *cx)
 {
-       if (atomic_read(&cx->capturing))
+       if (atomic_read(&cx->ana_capturing))
                cx18_vapi(cx, CX18_CPU_SET_AUDIO_MUTE, 2,
                                cx18_find_handle(cx), 1);
        CX18_DEBUG_INFO("Mute\n");
@@ -702,7 +703,7 @@ void cx18_mute(struct cx18 *cx)
 
 void cx18_unmute(struct cx18 *cx)
 {
-       if (atomic_read(&cx->capturing)) {
+       if (atomic_read(&cx->ana_capturing)) {
                cx18_msleep_timeout(100, 0);
                cx18_vapi(cx, CX18_CPU_SET_MISC_PARAMETERS, 2,
                                cx18_find_handle(cx), 12);
index bb8bc86086d0925c3a693bdce698524a48245265..ceb63653c926f71e6b8dae4ce39e00e4e03314ea 100644 (file)
@@ -35,9 +35,6 @@
 #define CX18_REG_GPIO_OUT2   0xc78104
 #define CX18_REG_GPIO_DIR2   0xc7810c
 
-static u32 gpio_dir;
-static u32 gpio_val;
-
 /*
  * HVR-1600 GPIO pins, courtesy of Hauppauge:
  *
@@ -49,24 +46,29 @@ static u32 gpio_val;
 
 static void gpio_write(struct cx18 *cx)
 {
-       write_reg((gpio_dir & 0xffff) << 16, CX18_REG_GPIO_DIR1);
-       write_reg(((gpio_dir & 0xffff) << 16) | (gpio_val & 0xffff),
+       u32 dir = cx->gpio_dir;
+       u32 val = cx->gpio_val;
+
+       write_reg((dir & 0xffff) << 16, CX18_REG_GPIO_DIR1);
+       write_reg(((dir & 0xffff) << 16) | (val & 0xffff),
                        CX18_REG_GPIO_OUT1);
-       write_reg(gpio_dir & 0xffff0000, CX18_REG_GPIO_DIR2);
-       write_reg((gpio_dir & 0xffff0000) | ((gpio_val & 0xffff0000) >> 16),
+       write_reg(dir & 0xffff0000, CX18_REG_GPIO_DIR2);
+       write_reg((dir & 0xffff0000) | ((val & 0xffff0000) >> 16),
                        CX18_REG_GPIO_OUT2);
 }
 
 void cx18_gpio_init(struct cx18 *cx)
 {
-       gpio_dir = cx->card->gpio_init.direction;
-       gpio_val = cx->card->gpio_init.initial_value;
+       cx->gpio_dir = cx->card->gpio_init.direction;
+       cx->gpio_val = cx->card->gpio_init.initial_value;
 
-       if (gpio_dir == 0)
-               return;
+       if (cx->card->tuners[0].tuner == TUNER_XC2028) {
+               cx->gpio_dir |= 1 << cx->card->xceive_pin;
+               cx->gpio_val |= 1 << cx->card->xceive_pin;
+       }
 
-       gpio_dir |= 1 << cx->card->xceive_pin;
-       gpio_val |= 1 << cx->card->xceive_pin;
+       if (cx->gpio_dir == 0)
+               return;
 
        CX18_DEBUG_INFO("GPIO initial dir: %08x/%08x out: %08x/%08x\n",
                   read_reg(CX18_REG_GPIO_DIR1), read_reg(CX18_REG_GPIO_DIR2),
@@ -86,13 +88,12 @@ int cx18_reset_tuner_gpio(void *dev, int cmd, int value)
                return 0;
        CX18_DEBUG_INFO("Resetting tuner\n");
 
-       gpio_dir |= 1 << cx->card->xceive_pin;
-       gpio_val &= ~(1 << cx->card->xceive_pin);
+       cx->gpio_val &= ~(1 << cx->card->xceive_pin);
 
        gpio_write(cx);
        schedule_timeout_interruptible(msecs_to_jiffies(1));
 
-       gpio_val |= 1 << cx->card->xceive_pin;
+       cx->gpio_val |= 1 << cx->card->xceive_pin;
        gpio_write(cx);
        schedule_timeout_interruptible(msecs_to_jiffies(1));
        return 0;
index dbdcb86ec5aac219659a6e5c784804a1b118f141..4151f1e5493febdf9825440be9e0650cb0d4c09f 100644 (file)
@@ -247,7 +247,7 @@ static int cx18_try_or_set_fmt(struct cx18 *cx, int streamtype,
 
                if (!set_fmt || (cx->params.width == w && cx->params.height == h))
                        return 0;
-               if (atomic_read(&cx->capturing) > 0)
+               if (atomic_read(&cx->ana_capturing) > 0)
                        return -EBUSY;
 
                cx->params.width = w;
@@ -264,7 +264,7 @@ static int cx18_try_or_set_fmt(struct cx18 *cx, int streamtype,
        if (fmt->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
                if (set_fmt && streamtype == CX18_ENC_STREAM_TYPE_VBI &&
                    cx->vbi.sliced_in->service_set &&
-                   atomic_read(&cx->capturing) > 0)
+                   atomic_read(&cx->ana_capturing) > 0)
                        return -EBUSY;
                if (set_fmt) {
                        cx->vbi.sliced_in->service_set = 0;
@@ -293,7 +293,7 @@ static int cx18_try_or_set_fmt(struct cx18 *cx, int streamtype,
                return 0;
        if (set == 0)
                return -EINVAL;
-       if (atomic_read(&cx->capturing) > 0 && cx->vbi.sliced_in->service_set == 0)
+       if (atomic_read(&cx->ana_capturing) > 0 && cx->vbi.sliced_in->service_set == 0)
                return -EBUSY;
        cx18_av_cmd(cx, VIDIOC_S_FMT, fmt);
        memcpy(cx->vbi.sliced_in, vbifmt, sizeof(*cx->vbi.sliced_in));
@@ -581,7 +581,7 @@ int cx18_v4l2_ioctls(struct cx18 *cx, struct file *filp, unsigned cmd, void *arg
                        break;
 
                if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ||
-                   atomic_read(&cx->capturing) > 0) {
+                   atomic_read(&cx->ana_capturing) > 0) {
                        /* Switching standard would turn off the radio or mess
                           with already running streams, prevent that by
                           returning EBUSY. */
@@ -677,7 +677,7 @@ int cx18_v4l2_ioctls(struct cx18 *cx, struct file *filp, unsigned cmd, void *arg
                        enc->flags = 0;
                        if (try)
                                return 0;
-                       if (!atomic_read(&cx->capturing))
+                       if (!atomic_read(&cx->ana_capturing))
                                return -EPERM;
                        if (test_and_set_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
                                return 0;
@@ -689,7 +689,7 @@ int cx18_v4l2_ioctls(struct cx18 *cx, struct file *filp, unsigned cmd, void *arg
                        enc->flags = 0;
                        if (try)
                                return 0;
-                       if (!atomic_read(&cx->capturing))
+                       if (!atomic_read(&cx->ana_capturing))
                                return -EPERM;
                        if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
                                return 0;
index 6e14f8bda5597c45c4c7b19add274271abb8a6d5..25114a5cbd57d0f58c19c7461b269421717a61c5 100644 (file)
@@ -75,7 +75,7 @@ static void epu_dma_done(struct cx18 *cx, struct cx18_mailbox *mb)
 
                        cx18_buf_sync_for_device(s, buf);
                        cx18_vapi(cx, CX18_CPU_DE_SET_MDL, 5, s->handle,
-                           (void *)&cx->scb->cpu_mdl[buf->id] - cx->enc_mem,
+                           (void __iomem *)&cx->scb->cpu_mdl[buf->id] - cx->enc_mem,
                            1, buf->id, s->buf_size);
                } else
                        set_bit(CX18_F_B_NEED_BUF_SWAP, &buf->b_flags);
@@ -161,13 +161,15 @@ irqreturn_t cx18_irq_handler(int irq, void *dev_id)
        */
 
        if (sw2) {
-               if (sw2 & (cx->scb->cpu2hpu_irq_ack | cx->scb->cpu2epu_irq_ack))
+               if (sw2 & (readl(&cx->scb->cpu2hpu_irq_ack) |
+                          readl(&cx->scb->cpu2epu_irq_ack)))
                        wake_up(&cx->mb_cpu_waitq);
-               if (sw2 & (cx->scb->apu2hpu_irq_ack | cx->scb->apu2epu_irq_ack))
+               if (sw2 & (readl(&cx->scb->apu2hpu_irq_ack) |
+                          readl(&cx->scb->apu2epu_irq_ack)))
                        wake_up(&cx->mb_apu_waitq);
-               if (sw2 & cx->scb->epu2hpu_irq_ack)
+               if (sw2 & readl(&cx->scb->epu2hpu_irq_ack))
                        wake_up(&cx->mb_epu_waitq);
-               if (sw2 & cx->scb->hpu2epu_irq_ack)
+               if (sw2 & readl(&cx->scb->hpu2epu_irq_ack))
                        wake_up(&cx->mb_hpu_waitq);
        }
 
index 0c5f328bca5434ae931cf7c0c038eab9678b18f8..2a5ccef9185b4d04a87576afd6005e44db967c20 100644 (file)
@@ -94,10 +94,10 @@ static const struct cx18_api_info *find_api_info(u32 cmd)
        return NULL;
 }
 
-static struct cx18_mailbox *cx18_mb_is_complete(struct cx18 *cx, int rpu,
+static struct cx18_mailbox __iomem *cx18_mb_is_complete(struct cx18 *cx, int rpu,
                u32 *state, u32 *irq, u32 *req)
 {
-       struct cx18_mailbox *mb = NULL;
+       struct cx18_mailbox __iomem *mb = NULL;
        int wait_count = 0;
        u32 ack;
 
@@ -142,7 +142,7 @@ static struct cx18_mailbox *cx18_mb_is_complete(struct cx18 *cx, int rpu,
 long cx18_mb_ack(struct cx18 *cx, const struct cx18_mailbox *mb)
 {
        const struct cx18_api_info *info = find_api_info(mb->cmd);
-       struct cx18_mailbox *ack_mb;
+       struct cx18_mailbox __iomem *ack_mb;
        u32 ack_irq;
        u8 rpu = CPU;
 
@@ -182,7 +182,7 @@ static int cx18_api_call(struct cx18 *cx, u32 cmd, int args, u32 data[])
 {
        const struct cx18_api_info *info = find_api_info(cmd);
        u32 state = 0, irq = 0, req, oldreq, err;
-       struct cx18_mailbox *mb;
+       struct cx18_mailbox __iomem *mb;
        wait_queue_head_t *waitq;
        int timeout = 100;
        int cnt = 0;
index 4ca9d847f1b1863703f8421212aae1ce8f493070..1b921a33609226afb08a569caefc230d8cfe5df9 100644 (file)
 #define CX18_DSP0_INTERRUPT_MASK       0xd0004C
 
 static struct file_operations cx18_v4l2_enc_fops = {
-      .owner = THIS_MODULE,
-      .read = cx18_v4l2_read,
-      .open = cx18_v4l2_open,
-      .ioctl = cx18_v4l2_ioctl,
-      .release = cx18_v4l2_close,
-      .poll = cx18_v4l2_enc_poll,
+       .owner = THIS_MODULE,
+       .read = cx18_v4l2_read,
+       .open = cx18_v4l2_open,
+       .ioctl = cx18_v4l2_ioctl,
+       .compat_ioctl = v4l_compat_ioctl32,
+       .release = cx18_v4l2_close,
+       .poll = cx18_v4l2_enc_poll,
 };
 
 /* offset from 0 to register ts v4l2 minors on */
@@ -443,7 +444,7 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
        s->handle = data[0];
        cx18_vapi(cx, CX18_CPU_SET_CHANNEL_TYPE, 2, s->handle, captype);
 
-       if (atomic_read(&cx->capturing) == 0 && !ts) {
+       if (atomic_read(&cx->ana_capturing) == 0 && !ts) {
                /* Stuff from Windows, we don't know what it is */
                cx18_vapi(cx, CX18_CPU_SET_VER_CROP_LINE, 2, s->handle, 0);
                cx18_vapi(cx, CX18_CPU_SET_MISC_PARAMETERS, 3, s->handle, 3, 1);
@@ -466,14 +467,14 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
                cx2341x_update(cx, cx18_api_func, NULL, &cx->params);
        }
 
-       if (atomic_read(&cx->capturing) == 0) {
+       if (atomic_read(&cx->tot_capturing) == 0) {
                clear_bit(CX18_F_I_EOS, &cx->i_flags);
                write_reg(7, CX18_DSP0_INTERRUPT_MASK);
        }
 
        cx18_vapi(cx, CX18_CPU_DE_SET_MDL_ACK, 3, s->handle,
-               (void *)&cx->scb->cpu_mdl_ack[s->type][0] - cx->enc_mem,
-               (void *)&cx->scb->cpu_mdl_ack[s->type][1] - cx->enc_mem);
+               (void __iomem *)&cx->scb->cpu_mdl_ack[s->type][0] - cx->enc_mem,
+               (void __iomem *)&cx->scb->cpu_mdl_ack[s->type][1] - cx->enc_mem);
 
        list_for_each(p, &s->q_free.list) {
                struct cx18_buffer *buf = list_entry(p, struct cx18_buffer, list);
@@ -481,8 +482,8 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
                writel(buf->dma_handle, &cx->scb->cpu_mdl[buf->id].paddr);
                writel(s->buf_size, &cx->scb->cpu_mdl[buf->id].length);
                cx18_vapi(cx, CX18_CPU_DE_SET_MDL, 5, s->handle,
-                       (void *)&cx->scb->cpu_mdl[buf->id] - cx->enc_mem, 1,
-                       buf->id, s->buf_size);
+                       (void __iomem *)&cx->scb->cpu_mdl[buf->id] - cx->enc_mem,
+                       1, buf->id, s->buf_size);
        }
        /* begin_capture */
        if (cx18_vapi(cx, CX18_CPU_CAPTURE_START, 1, s->handle)) {
@@ -492,7 +493,9 @@ int cx18_start_v4l2_encode_stream(struct cx18_stream *s)
        }
 
        /* you're live! sit back and await interrupts :) */
-       atomic_inc(&cx->capturing);
+       if (!ts)
+               atomic_inc(&cx->ana_capturing);
+       atomic_inc(&cx->tot_capturing);
        return 0;
 }
 
@@ -523,7 +526,7 @@ int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end)
 
        CX18_DEBUG_INFO("Stop Capture\n");
 
-       if (atomic_read(&cx->capturing) == 0)
+       if (atomic_read(&cx->tot_capturing) == 0)
                return 0;
 
        if (s->type == CX18_ENC_STREAM_TYPE_MPG)
@@ -537,7 +540,9 @@ int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end)
                CX18_INFO("ignoring gop_end: not (yet?) supported by the firmware\n");
        }
 
-       atomic_dec(&cx->capturing);
+       if (s->type != CX18_ENC_STREAM_TYPE_TS)
+               atomic_dec(&cx->ana_capturing);
+       atomic_dec(&cx->tot_capturing);
 
        /* Clear capture and no-read bits */
        clear_bit(CX18_F_S_STREAMING, &s->s_flags);
@@ -545,7 +550,7 @@ int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end)
        cx18_vapi(cx, CX18_DESTROY_TASK, 1, s->handle);
        s->handle = 0xffffffff;
 
-       if (atomic_read(&cx->capturing) > 0)
+       if (atomic_read(&cx->tot_capturing) > 0)
                return 0;
 
        write_reg(5, CX18_DSP0_INTERRUPT_MASK);
index f24abcd06dea0eb1027630be34ca934daa87d6e8..c4cc2f3b887643dc5facfc9ce3e1d9f5d7210c38 100644 (file)
@@ -823,7 +823,7 @@ static void cx23885_dev_unregister(struct cx23885_dev *dev)
        iounmap(dev->lmmio);
 }
 
-static u32* cx23885_risc_field(u32 *rp, struct scatterlist *sglist,
+static __le32* cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
                               unsigned int offset, u32 sync_line,
                               unsigned int bpl, unsigned int padding,
                               unsigned int lines)
@@ -883,7 +883,7 @@ int cx23885_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
                        unsigned int padding, unsigned int lines)
 {
        u32 instructions, fields;
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        fields = 0;
@@ -924,7 +924,7 @@ static int cx23885_risc_databuffer(struct pci_dev *pci,
                                   unsigned int lines)
 {
        u32 instructions;
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        /* estimate risc mem: worst case is one write per page border +
@@ -951,7 +951,7 @@ static int cx23885_risc_databuffer(struct pci_dev *pci,
 int cx23885_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
                                u32 reg, u32 mask, u32 value)
 {
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        if ((rc = btcx_riscmem_alloc(pci, risc, 4*16)) < 0)
index aeba26dc0a37ce69a8da26cd7fff176b139da54a..fa6d398e97b9f44015527027e43771ad2de1ac79 100644 (file)
@@ -1493,10 +1493,16 @@ static const struct cx88_board cx88_boards[] = {
                },
        },
        [CX88_BOARD_POWERCOLOR_REAL_ANGEL] = {
-               .name           = "PowerColor Real Angel 330",
+               .name           = "PowerColor RA330",   /* Long names may confuse LIRC. */
                .tuner_type     = TUNER_XC2028,
                .tuner_addr     = 0x61,
                .input          = { {
+                       .type   = CX88_VMUX_DEBUG,
+                       .vmux   = 3,            /* Due to the way the cx88 driver is written,   */
+                       .gpio0 = 0x00ff,        /* there is no way to deactivate audio pass-    */
+                       .gpio1 = 0xf39d,        /* through without this entry. Furthermore, if  */
+                       .gpio3 = 0x0000,        /* the TV mux entry is first, you get audio     */
+               }, {                            /* from the tuner on boot for a little while.   */
                        .type   = CX88_VMUX_TELEVISION,
                        .vmux   = 0,
                        .gpio0 = 0x00ff,
@@ -2424,8 +2430,9 @@ void cx88_setup_xc3028(struct cx88_core *core, struct xc2028_ctrl *ctl)
 
        switch (core->boardnr) {
        case CX88_BOARD_POWERCOLOR_REAL_ANGEL:
-               /* Doesn't work with firmware version 2.7 */
-               ctl->fname = "xc3028-v25.fw";
+               /* Now works with firmware version 2.7 */
+               if (core->i2c_algo.udelay < 16)
+                       core->i2c_algo.udelay = 16;
                break;
        case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PRO:
                ctl->scode_table = XC3028_FE_ZARLINK456;
index c4d1aff1fdb4911f186344f59594110a70604c2e..60eeda3057e9e8552bf0bb5361987e6f8d7b04d7 100644 (file)
@@ -70,7 +70,7 @@ static DEFINE_MUTEX(devlist);
 
 /* @lpi: lines per IRQ, or 0 to not generate irqs. Note: IRQ to be
         generated _after_ lpi lines are transferred. */
-static u32* cx88_risc_field(u32 *rp, struct scatterlist *sglist,
+static __le32* cx88_risc_field(__le32 *rp, struct scatterlist *sglist,
                            unsigned int offset, u32 sync_line,
                            unsigned int bpl, unsigned int padding,
                            unsigned int lines, unsigned int lpi)
@@ -130,7 +130,7 @@ int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
                     unsigned int bpl, unsigned int padding, unsigned int lines)
 {
        u32 instructions,fields;
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        fields = 0;
@@ -168,7 +168,7 @@ int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
                         unsigned int lines, unsigned int lpi)
 {
        u32 instructions;
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        /* estimate risc mem: worst case is one write per page border +
@@ -193,7 +193,7 @@ int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
 int cx88_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
                      u32 reg, u32 mask, u32 value)
 {
-       u32 *rp;
+       __le32 *rp;
        int rc;
 
        if ((rc = btcx_riscmem_alloc(pci, risc, 4*16)) < 0)
index 8996175cc95075bca9c42c89501a2adc51bd12fc..fb163ecd921684a4014b69e4de056512fa22904e 100644 (file)
@@ -1166,13 +1166,13 @@ static int vidioc_g_register(struct file *file, void *priv,
 
                reg->val = ret;
        } else {
-               u64 val = 0;
+               __le64 val = 0;
                ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
                                                   reg->reg, (char *)&val, 2);
                if (ret < 0)
                        return ret;
 
-               reg->val = cpu_to_le64((__u64)val);
+               reg->val = le64_to_cpu(val);
        }
 
        return 0;
@@ -1183,9 +1183,9 @@ static int vidioc_s_register(struct file *file, void *priv,
 {
        struct em28xx_fh      *fh  = priv;
        struct em28xx         *dev = fh->dev;
-       u64 buf;
+       __le64 buf;
 
-       buf = le64_to_cpu((__u64)reg->val);
+       buf = cpu_to_le64(reg->val);
 
        return em28xx_write_regs(dev, reg->reg, (char *)&buf,
                                 em28xx_reg_len(reg->reg));
index ba06e813c58c3d789222aca798e5bc6811c6caa4..9d23b1efd36d9c93a1e43db7f378147cddfa136f 100644 (file)
@@ -259,6 +259,12 @@ struct ivtv_mailbox_data {
 
 /* Scatter-Gather array element, used in DMA transfers */
 struct ivtv_sg_element {
+       __le32 src;
+       __le32 dst;
+       __le32 size;
+};
+
+struct ivtv_sg_host_element {
        u32 src;
        u32 dst;
        u32 size;
@@ -349,8 +355,8 @@ struct ivtv_stream {
        u16 dma_xfer_cnt;
 
        /* Base Dev SG Array for cx23415/6 */
-       struct ivtv_sg_element *sg_pending;
-       struct ivtv_sg_element *sg_processing;
+       struct ivtv_sg_host_element *sg_pending;
+       struct ivtv_sg_host_element *sg_processing;
        struct ivtv_sg_element *sg_dma;
        dma_addr_t sg_handle;
        int sg_pending_size;
index f2fa434b677b88673ef4e7335b10f2f92f02d095..db813e071ce682b36a4dc390c874fbb07ba3989e 100644 (file)
@@ -587,7 +587,7 @@ retry:
        since we may get here before the stream has been fully set-up */
        if (mode == OUT_YUV && s->q_full.length == 0 && itv->dma_data_req_size) {
                while (count >= itv->dma_data_req_size) {
-                       if (!ivtv_yuv_udma_stream_frame (itv, (void *)user_buf)) {
+                       if (!ivtv_yuv_udma_stream_frame (itv, (void __user *)user_buf)) {
                                bytes_written += itv->dma_data_req_size;
                                user_buf += itv->dma_data_req_size;
                                count -= itv->dma_data_req_size;
index d8ba3a4a8761fb0c66993ae5a2ae998aa068c58f..fba150a6cd2306caa7b877cd8ec053230aa3270a 100644 (file)
@@ -231,14 +231,14 @@ static void dma_post(struct ivtv_stream *s)
        struct ivtv_buffer *buf = NULL;
        struct list_head *p;
        u32 offset;
-       u32 *u32buf;
+       __le32 *u32buf;
        int x = 0;
 
        IVTV_DEBUG_HI_DMA("%s %s completed (%x)\n", ivtv_use_pio(s) ? "PIO" : "DMA",
                        s->name, s->dma_offset);
        list_for_each(p, &s->q_dma.list) {
                buf = list_entry(p, struct ivtv_buffer, list);
-               u32buf = (u32 *)buf->buf;
+               u32buf = (__le32 *)buf->buf;
 
                /* Sync Buffer */
                ivtv_buf_sync_for_cpu(s, buf);
@@ -444,7 +444,7 @@ static void ivtv_dma_enc_start(struct ivtv_stream *s)
        }
 
        s->dma_xfer_cnt++;
-       memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_element) * s->sg_pending_size);
+       memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_host_element) * s->sg_pending_size);
        s->sg_processing_size = s->sg_pending_size;
        s->sg_pending_size = 0;
        s->sg_processed = 0;
@@ -473,7 +473,7 @@ static void ivtv_dma_dec_start(struct ivtv_stream *s)
        if (s->q_predma.bytesused)
                ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
        s->dma_xfer_cnt++;
-       memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_element) * s->sg_pending_size);
+       memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_host_element) * s->sg_pending_size);
        s->sg_processing_size = s->sg_pending_size;
        s->sg_pending_size = 0;
        s->sg_processed = 0;
index fc8b1eaa333b38ac0b03d0458aed478e4a71343d..71bd13e22e2ee20a5f6d27c2a4bceda494fd6d61 100644 (file)
@@ -193,7 +193,7 @@ void ivtv_flush_queues(struct ivtv_stream *s)
 int ivtv_stream_alloc(struct ivtv_stream *s)
 {
        struct ivtv *itv = s->itv;
-       int SGsize = sizeof(struct ivtv_sg_element) * s->buffers;
+       int SGsize = sizeof(struct ivtv_sg_host_element) * s->buffers;
        int i;
 
        if (s->buffers == 0)
index c47c2b9451474c1dffa24c1757fe1e9d0d69994d..c854285a4371c91510e71ba39df8449762001ece 100644 (file)
 #include "ivtv-streams.h"
 
 static const struct file_operations ivtv_v4l2_enc_fops = {
-      .owner = THIS_MODULE,
-      .read = ivtv_v4l2_read,
-      .write = ivtv_v4l2_write,
-      .open = ivtv_v4l2_open,
-      .ioctl = ivtv_v4l2_ioctl,
-      .release = ivtv_v4l2_close,
-      .poll = ivtv_v4l2_enc_poll,
+       .owner = THIS_MODULE,
+       .read = ivtv_v4l2_read,
+       .write = ivtv_v4l2_write,
+       .open = ivtv_v4l2_open,
+       .ioctl = ivtv_v4l2_ioctl,
+       .compat_ioctl = v4l_compat_ioctl32,
+       .release = ivtv_v4l2_close,
+       .poll = ivtv_v4l2_enc_poll,
 };
 
 static const struct file_operations ivtv_v4l2_dec_fops = {
-      .owner = THIS_MODULE,
-      .read = ivtv_v4l2_read,
-      .write = ivtv_v4l2_write,
-      .open = ivtv_v4l2_open,
-      .ioctl = ivtv_v4l2_ioctl,
-      .release = ivtv_v4l2_close,
-      .poll = ivtv_v4l2_dec_poll,
+       .owner = THIS_MODULE,
+       .read = ivtv_v4l2_read,
+       .write = ivtv_v4l2_write,
+       .open = ivtv_v4l2_open,
+       .ioctl = ivtv_v4l2_ioctl,
+       .compat_ioctl = v4l_compat_ioctl32,
+       .release = ivtv_v4l2_close,
+       .poll = ivtv_v4l2_dec_poll,
 };
 
 #define IVTV_V4L2_DEC_MPG_OFFSET  16   /* offset from 0 to register decoder mpg v4l2 minors on */
index 02c5ab071d1b3518eec07500f78af9df25f0ea0f..442f43f11b7387dfbf8fbc05e497feef1d0ed2a3 100644 (file)
@@ -22,8 +22,8 @@
 
 #define IVTV_DRIVER_NAME "ivtv"
 #define IVTV_DRIVER_VERSION_MAJOR 1
-#define IVTV_DRIVER_VERSION_MINOR 2
-#define IVTV_DRIVER_VERSION_PATCHLEVEL 1
+#define IVTV_DRIVER_VERSION_MINOR 3
+#define IVTV_DRIVER_VERSION_PATCHLEVEL 0
 
 #define IVTV_VERSION __stringify(IVTV_DRIVER_VERSION_MAJOR) "." __stringify(IVTV_DRIVER_VERSION_MINOR) "." __stringify(IVTV_DRIVER_VERSION_PATCHLEVEL)
 #define IVTV_DRIVER_VERSION KERNEL_VERSION(IVTV_DRIVER_VERSION_MAJOR,IVTV_DRIVER_VERSION_MINOR,IVTV_DRIVER_VERSION_PATCHLEVEL)
index a9417f6e40870d8837411a109f9ddf240c1ffb13..3092ff1d00a066a24a4d04b3de06f1999159a299 100644 (file)
@@ -1116,7 +1116,7 @@ void ivtv_yuv_setup_stream_frame(struct ivtv *itv)
 }
 
 /* Attempt to dma a frame from a user buffer */
-int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void *src)
+int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void __user *src)
 {
        struct yuv_playback_info *yi = &itv->yuv_info;
        struct ivtv_dma_frame dma_args;
index 2fe5f1250762821741679be463580641ce77b951..ca5173fbf006f16e9933e2d79e5e11a3135fef62 100644 (file)
@@ -35,7 +35,7 @@ extern const u32 yuv_offset[IVTV_YUV_BUFFERS];
 
 int ivtv_yuv_filter_check(struct ivtv *itv);
 void ivtv_yuv_setup_stream_frame(struct ivtv *itv);
-int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void *src);
+int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void __user *src);
 void ivtv_yuv_frame_complete(struct ivtv *itv);
 int ivtv_yuv_prep_frame(struct ivtv *itv, struct ivtv_dma_frame *args);
 void ivtv_yuv_close(struct ivtv *itv);
index 1314522a8130784432147a5f8ad8e3ef35743a6f..81431ee418426894f5c285fdfef6f4609f2294a5 100644 (file)
@@ -163,8 +163,7 @@ ts_mmap(struct file *file, struct vm_area_struct * vma)
 static int empress_querycap(struct file *file, void  *priv,
                                        struct v4l2_capability *cap)
 {
-       struct saa7134_fh *fh = priv;
-       struct saa7134_dev *dev = fh->dev;
+       struct saa7134_dev *dev = file->private_data;
 
        strcpy(cap->driver, "saa7134");
        strlcpy(cap->card, saa7134_boards[dev->board].name,
index a0f7bc1edaa25da81d8e71d1fdb2b99881eb8bd3..0d12ace616658ce8f619d04a1e7815bfaf050a78 100644 (file)
@@ -536,7 +536,7 @@ static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 static inline int check_mode(struct tuner *t, char *cmd)
 {
        if ((1 << t->mode & t->mode_mask) == 0) {
-               return EINVAL;
+               return -EINVAL;
        }
 
        switch (t->mode) {
@@ -730,11 +730,11 @@ static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode,
 
        t->mode = mode;
 
-       if (check_mode(t, cmd) == EINVAL) {
+       if (check_mode(t, cmd) == -EINVAL) {
                t->mode = T_STANDBY;
                if (analog_ops->standby)
                        analog_ops->standby(&t->fe);
-               return EINVAL;
+               return -EINVAL;
        }
        return 0;
 }
@@ -776,13 +776,13 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                break;
        case AUDC_SET_RADIO:
                if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
-                               == EINVAL)
+                               == -EINVAL)
                        return 0;
                if (t->radio_freq)
                        set_freq(client, t->radio_freq);
                break;
        case TUNER_SET_STANDBY:
-               if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
+               if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
                        return 0;
                t->mode = T_STANDBY;
                if (analog_ops->standby)
@@ -790,9 +790,9 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                break;
 #ifdef CONFIG_VIDEO_ALLOW_V4L1
        case VIDIOCSAUDIO:
-               if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
+               if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
                        return 0;
-               if (check_v4l2(t) == EINVAL)
+               if (check_v4l2(t) == -EINVAL)
                        return 0;
 
                /* Should be implemented, since bttv calls it */
@@ -810,10 +810,10 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                        };
                        struct video_channel *vc = arg;
 
-                       if (check_v4l2(t) == EINVAL)
+                       if (check_v4l2(t) == -EINVAL)
                                return 0;
 
-                       if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
+                       if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
                                return 0;
 
                        if (vc->norm < ARRAY_SIZE(map))
@@ -827,9 +827,9 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                {
                        unsigned long *v = arg;
 
-                       if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
+                       if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
                                return 0;
-                       if (check_v4l2(t) == EINVAL)
+                       if (check_v4l2(t) == -EINVAL)
                                return 0;
 
                        set_freq(client, *v);
@@ -839,9 +839,9 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                {
                        struct video_tuner *vt = arg;
 
-                       if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
+                       if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
                                return 0;
-                       if (check_v4l2(t) == EINVAL)
+                       if (check_v4l2(t) == -EINVAL)
                                return 0;
 
                        if (V4L2_TUNER_RADIO == t->mode) {
@@ -883,9 +883,9 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                {
                        struct video_audio *va = arg;
 
-                       if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
+                       if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
                                return 0;
-                       if (check_v4l2(t) == EINVAL)
+                       if (check_v4l2(t) == -EINVAL)
                                return 0;
 
                        if (V4L2_TUNER_RADIO == t->mode) {
@@ -925,7 +925,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                        v4l2_std_id *id = arg;
 
                        if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
-                                       == EINVAL)
+                                       == -EINVAL)
                                return 0;
 
                        switch_v4l2();
@@ -941,7 +941,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                        struct v4l2_frequency *f = arg;
 
                        if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
-                                       == EINVAL)
+                                       == -EINVAL)
                                return 0;
                        switch_v4l2();
                        set_freq(client,f->frequency);
@@ -952,7 +952,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                {
                        struct v4l2_frequency *f = arg;
 
-                       if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
+                       if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
                                return 0;
                        switch_v4l2();
                        f->type = t->mode;
@@ -973,7 +973,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                {
                        struct v4l2_tuner *tuner = arg;
 
-                       if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
+                       if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
                                return 0;
                        switch_v4l2();
 
@@ -1020,7 +1020,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                {
                        struct v4l2_tuner *tuner = arg;
 
-                       if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
+                       if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
                                return 0;
 
                        switch_v4l2();
index 32e536edf09d6cc594d4debb6c3f78c2082a1e42..3d26a30abe1ef99b1c9de8873816efa00f1dc7ee 100644 (file)
@@ -210,7 +210,7 @@ static int qcm_stv_setb(struct usb_device *dev, u16 reg, u8 val)
        return ret;
 }
 
-static int qcm_stv_setw(struct usb_device *dev, u16 reg, u16 val)
+static int qcm_stv_setw(struct usb_device *dev, u16 reg, __le16 val)
 {
        int ret;
 
index 81cc3b00a07912bbf0d512055151c0bfbce6c509..46b7ad477ceb5caece92b5e0cab3d601895bf2ce 100644 (file)
@@ -285,7 +285,7 @@ struct zoran_mapping {
 
 struct zoran_jpg_buffer {
        struct zoran_mapping *map;
-       u32 *frag_tab;          /* addresses of frag table */
+       __le32 *frag_tab;               /* addresses of frag table */
        u32 frag_tab_bus;       /* same value cached to save time in ISR */
        enum zoran_buffer_state state;  /* non-zero if corresponding buffer is in use in grab queue */
        struct zoran_sync bs;   /* DONE: info to return to application */
@@ -450,7 +450,7 @@ struct zoran {
        unsigned long jpg_queued_num;   /* count of frames queued since grab/play started */
 
        /* zr36057's code buffer table */
-       u32 *stat_com;          /* stat_com[i] is indexed by dma_head/tail & BUZ_MASK_STAT_COM */
+       __le32 *stat_com;               /* stat_com[i] is indexed by dma_head/tail & BUZ_MASK_STAT_COM */
 
        /* (value & BUZ_MASK_FRAME) corresponds to index in pend[] queue */
        int jpg_pend[BUZ_MAX_FRAME];
index 37629ffd34c360f245de350137f00760130a025e..88d369708e4c82b6b52f9451d17067acd042f577 100644 (file)
@@ -1320,7 +1320,7 @@ error_handler (struct zoran *zr,
                        if (i) {
                                /* Rotate stat_comm entries to make current entry first */
                                int j;
-                               u32 bus_addr[BUZ_NUM_STAT_COM];
+                               __le32 bus_addr[BUZ_NUM_STAT_COM];
 
                                /* Here we are copying the stat_com array, which
                                 * is already in little endian format, so
index 345c77e4683769bf7ba84cdf69e056749096315c..5394d7a5cfee686b34457f6289378193e648908a 100644 (file)
@@ -495,7 +495,7 @@ jpg_fbuffer_alloc (struct file *file)
                        jpg_fbuffer_free(file);
                        return -ENOBUFS;
                }
-               fh->jpg_buffers.buffer[i].frag_tab = (u32 *) mem;
+               fh->jpg_buffers.buffer[i].frag_tab = (__le32 *) mem;
                fh->jpg_buffers.buffer[i].frag_tab_bus =
                    virt_to_bus((void *) mem);
 
@@ -1167,7 +1167,7 @@ zoran_close_end_session (struct file *file)
 
        /* v4l capture */
        if (fh->v4l_buffers.active != ZORAN_FREE) {
-               long flags;
+               unsigned long flags;
 
                spin_lock_irqsave(&zr->spinlock, flags);
                zr36057_set_memgrab(zr, 0);
@@ -3436,7 +3436,7 @@ zoran_do_ioctl (struct inode *inode,
 
                        /* unload capture */
                        if (zr->v4l_memgrab_active) {
-                               long flags;
+                               unsigned long flags;
 
                                spin_lock_irqsave(&zr->spinlock, flags);
                                zr36057_set_memgrab(zr, 0);
@@ -4375,7 +4375,7 @@ zoran_vm_close (struct vm_area_struct *vma)
                                mutex_lock(&zr->resource_lock);
 
                                if (fh->v4l_buffers.active != ZORAN_FREE) {
-                                       long flags;
+                                       unsigned long flags;
 
                                        spin_lock_irqsave(&zr->spinlock, flags);
                                        zr36057_set_memgrab(zr, 0);
@@ -4506,7 +4506,7 @@ zoran_mmap (struct file           *file,
                                if (todo > fraglen)
                                        todo = fraglen;
                                pos =
-                                   le32_to_cpu((unsigned long) fh->jpg_buffers.
+                                   le32_to_cpu(fh->jpg_buffers.
                                    buffer[i].frag_tab[2 * j]);
                                /* should just be pos on i386 */
                                page = virt_to_phys(bus_to_virt(pos))
index c1411189ba6c5983f3396a60f801f21ee2688789..4a535ea1e1235eddd26f1865398006c9938037b8 100644 (file)
@@ -865,9 +865,9 @@ struct v4l2_querymenu
 #define V4L2_CID_HFLIP                 (V4L2_CID_BASE+20)
 #define V4L2_CID_VFLIP                 (V4L2_CID_BASE+21)
 
-/* Deprecated, use V4L2_CID_PAN_RESET and V4L2_CID_TILT_RESET */
-#define V4L2_CID_HCENTER_DEPRECATED    (V4L2_CID_BASE+22)
-#define V4L2_CID_VCENTER_DEPRECATED    (V4L2_CID_BASE+23)
+/* Deprecated; use V4L2_CID_PAN_RESET and V4L2_CID_TILT_RESET */
+#define V4L2_CID_HCENTER               (V4L2_CID_BASE+22)
+#define V4L2_CID_VCENTER               (V4L2_CID_BASE+23)
 
 #define V4L2_CID_POWER_LINE_FREQUENCY  (V4L2_CID_BASE+24)
 enum v4l2_power_line_frequency {
index a807d2f86ee849a5201ebfffc3ea54ff5c66e32e..33f01ae08f767da78c532c257332391bfb48b88c 100644 (file)
@@ -40,7 +40,6 @@
 #define VFL_TYPE_VTX           3
 
 /*  Video standard functions  */
-extern unsigned int v4l2_video_std_fps(struct v4l2_standard *vs);
 extern char *v4l2_norm_to_name(v4l2_std_id id);
 extern int v4l2_video_std_construct(struct v4l2_standard *vs,
                                    int id, char *name);
This page took 0.077917 seconds and 5 git commands to generate.