V4L/DVB (6517): CodingStyle fixup
authorMauro Carvalho Chehab <mchehab@infradead.org>
Thu, 1 Nov 2007 20:47:42 +0000 (17:47 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Fri, 25 Jan 2008 21:01:54 +0000 (19:01 -0200)
Used scripts/Lindent + manual check + scripts/checkpatch.pl

Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
drivers/media/video/tuner-xc2028.c
drivers/media/video/tuner-xc2028.h

index b9135b7c43378374b584de7f16e7d3d7b9b7dd9f..473fa73b1819573be96132e60e27335e0e882fe2 100644 (file)
@@ -11,7 +11,7 @@
 #include <linux/i2c.h>
 #include <asm/div64.h>
 #include <linux/firmware.h>
-#include <linux/videodev.h>
+#include <linux/videodev2.h>
 #include <linux/delay.h>
 #include <media/tuner.h>
 #include <linux/mutex.h>
@@ -65,27 +65,31 @@ struct xc2028_data {
        struct mutex lock;
 };
 
-#define i2c_send(rc, priv, buf, size)                                  \
-if (size != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size)))   \
-       tuner_info("i2c output error: rc = %d (should be %d)\n",        \
-       rc, (int)size);
-
-#define i2c_rcv(rc, priv, buf, size)                                   \
-if (size != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buf, size)))   \
-       tuner_info("i2c input error: rc = %d (should be %d)\n",         \
-       rc, (int)size);
-
-#define send_seq(priv, data...)                                                \
-{      int rc;                                                         \
+#define i2c_send(rc, priv, buf, size) do {                             \
+       rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size);          \
+       if (size != rc)                                                 \
+               tuner_info("i2c output error: rc = %d (should be %d)\n",\
+                          rc, (int)size);                              \
+} while (0)
+
+#define i2c_rcv(rc, priv, buf, size) do {                              \
+       rc = tuner_i2c_xfer_recv(&priv->i2c_props, buf, size);          \
+       if (size != rc)                                                 \
+               tuner_info("i2c input error: rc = %d (should be %d)\n", \
+                          rc, (int)size);                              \
+} while (0)
+
+#define send_seq(priv, data...)        do {                                    \
+       int rc;                                                         \
        static u8 _val[] = data;                                        \
        if (sizeof(_val) !=                                             \
-                       (rc = tuner_i2c_xfer_send (&priv->i2c_props,    \
+                       (rc = tuner_i2c_xfer_send(&priv->i2c_props,     \
                                                _val, sizeof(_val)))) { \
-               tuner_info("Error on line %d: %d\n",__LINE__,rc);       \
-               return -EINVAL;                                                 \
+               tuner_info("Error on line %d: %d\n", __LINE__, rc);     \
+               return -EINVAL;                                         \
        }                                                               \
-       msleep (10);                                                    \
-}
+       msleep(10);                                                     \
+} while (0)
 
 static int xc2028_get_reg(struct xc2028_data *priv, u16 reg)
 {
@@ -94,42 +98,42 @@ static int xc2028_get_reg(struct xc2028_data *priv, u16 reg)
 
        tuner_info("%s called\n", __FUNCTION__);
 
-       buf[0]= reg;
+       buf[0] = reg;
 
        i2c_send(rc, priv, buf, sizeof(buf));
-       if (rc<0)
+       if (rc < 0)
                return rc;
 
        i2c_rcv(rc, priv, buf, 2);
-       if (rc<0)
+       if (rc < 0)
                return rc;
 
-       return (buf[1])|(buf[0]<<8);
+       return (buf[1]) | (buf[0] << 8);
 }
 
-static void free_firmware (struct xc2028_data *priv)
+static void free_firmware(struct xc2028_data *priv)
 {
        int i;
 
        if (!priv->firm)
                return;
 
-       for (i=0;i<priv->firm_size;i++) {
-               if (priv->firm[i].ptr)
-                       kfree(priv->firm[i].ptr);
-       }
+       for (i = 0; i < priv->firm_size; i++)
+               kfree(priv->firm[i].ptr);
+
        kfree(priv->firm);
 
-       priv->firm=NULL;
+       priv->firm = NULL;
        priv->need_load_generic = 1;
 }
 
-static int load_all_firmwares (struct dvb_frontend *fe)
+static int load_all_firmwares(struct dvb_frontend *fe)
 {
        struct xc2028_data    *priv = fe->tuner_priv;
-       const struct firmware *fw=NULL;
+       const struct firmware *fw   = NULL;
        unsigned char         *p, *endp;
-       int                   rc=0, n, n_array;
+       int                   rc = 0;
+       int                   n, n_array;
        char                  name[33];
 
        tuner_info("%s called\n", __FUNCTION__);
@@ -137,7 +141,7 @@ static int load_all_firmwares (struct dvb_frontend *fe)
        tuner_info("Loading firmware %s\n", priv->ctrl.fname);
        rc = request_firmware(&fw, priv->ctrl.fname, priv->dev);
        if (rc < 0) {
-               if (rc==-ENOENT)
+               if (rc == -ENOENT)
                        tuner_info("Error: firmware %s not found.\n",
                                   priv->ctrl.fname);
                else
@@ -146,44 +150,44 @@ static int load_all_firmwares (struct dvb_frontend *fe)
 
                return rc;
        }
-       p=fw->data;
-       endp=p+fw->size;
+       p = fw->data;
+       endp = p + fw->size;
 
-       if(fw->size<sizeof(name)-1+2) {
+       if (fw->size < sizeof(name) - 1 + 2) {
                tuner_info("Error: firmware size is zero!\n");
-               rc=-EINVAL;
+               rc = -EINVAL;
                goto done;
        }
 
-       memcpy(name,p,sizeof(name)-1);
-       name[sizeof(name)-1]=0;
-       p+=sizeof(name)-1;
+       memcpy(name, p, sizeof(name) - 1);
+       name[sizeof(name) - 1] = 0;
+       p += sizeof(name) - 1;
 
-       priv->version = le16_to_cpu(*(__u16 *)p);
+       priv->version = le16_to_cpu(*(__u16 *) p);
        p += 2;
 
        tuner_info("firmware: %s, ver %d.%d\n", name,
-                                       priv->version>>8, priv->version&0xff);
+                  priv->version >> 8, priv->version & 0xff);
 
-       if (p+2>endp)
+       if (p + 2 > endp)
                goto corrupt;
 
-       n_array = le16_to_cpu(*(__u16 *)p);
+       n_array = le16_to_cpu(*(__u16 *) p);
        p += 2;
 
        tuner_info("there are %d firmwares at %s\n", n_array, priv->ctrl.fname);
 
-       priv->firm=kzalloc(sizeof(*priv->firm)*n_array,GFP_KERNEL);
+       priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
 
        if (!fw) {
                tuner_info("Not enough memory for loading firmware.\n");
-               rc=-ENOMEM;
+               rc = -ENOMEM;
                goto done;
        }
 
        priv->firm_size = n_array;
-       n=-1;
-       while (p<endp) {
+       n = -1;
+       while (p < endp) {
                __u32 type, size;
                v4l2_std_id id;
 
@@ -194,34 +198,34 @@ static int load_all_firmwares (struct dvb_frontend *fe)
                }
 
                /* Checks if there's enough bytes to read */
-               if (p+sizeof(type)+sizeof(id)+sizeof(size)>endp) {
+               if (p + sizeof(type) + sizeof(id) + sizeof(size) > endp) {
                        tuner_info("Lost firmware!\n");
                        goto corrupt;
                }
 
-               type = le32_to_cpu(*(__u32 *)p);
+               type = le32_to_cpu(*(__u32 *) p);
                p += sizeof(type);
 
-               id = le64_to_cpu(*(v4l2_std_id *)p);
+               id = le64_to_cpu(*(v4l2_std_id *) p);
                p += sizeof(id);
 
-               size = le32_to_cpu(*(v4l2_std_id *)p);
+               size = le32_to_cpu(*(v4l2_std_id *) p);
                p += sizeof(size);
 
-               if ((!size)||(size+p>endp)) {
+               if ((!size) || (size + p > endp)) {
                        tuner_info("Firmware type %x, id %lx corrupt\n",
-                                  type, (unsigned long) id);
+                                  type, (unsigned long)id);
                        goto corrupt;
                }
 
-               priv->firm[n].ptr=kzalloc(size,GFP_KERNEL);
+               priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
                if (!priv->firm[n].ptr) {
                        tuner_info("Not enough memory.\n");
-                       rc=-ENOMEM;
+                       rc = -ENOMEM;
                        goto err;
                }
                tuner_info("Loading firmware type %x, id %lx, size=%d.\n",
-                                  type, (unsigned long) id, size);
+                          type, (unsigned long)id, size);
 
                memcpy(priv->firm[n].ptr, p, size);
                priv->firm[n].type = type;
@@ -231,7 +235,7 @@ static int load_all_firmwares (struct dvb_frontend *fe)
                p += size;
        }
 
-       if (n+1 != priv->firm_size) {
+       if (n + 1 != priv->firm_size) {
                tuner_info("Firmware file is incomplete!\n");
                goto corrupt;
        }
@@ -239,7 +243,7 @@ static int load_all_firmwares (struct dvb_frontend *fe)
        goto done;
 
 corrupt:
-       rc=-EINVAL;
+       rc = -EINVAL;
        tuner_info("Error: firmware file is corrupted!\n");
 
 err:
@@ -254,46 +258,44 @@ done:
        return rc;
 }
 
-static int load_firmware (struct dvb_frontend *fe, unsigned int type,
-                         v4l2_std_id *id)
+static int load_firmware(struct dvb_frontend *fe, unsigned int type,
+                        v4l2_std_id * id)
 {
        struct xc2028_data *priv = fe->tuner_priv;
-       int i, rc;
-       unsigned char *p, *endp, buf[priv->max_len];
+       int                i, rc;
+       unsigned char      *p, *endp, buf[priv->max_len];
 
        tuner_info("%s called\n", __FUNCTION__);
 
        if (!priv->firm) {
-               printk (KERN_ERR PREFIX "Error! firmware not loaded\n");
+               printk(KERN_ERR PREFIX "Error! firmware not loaded\n");
                return -EINVAL;
        }
 
        if ((type == 0) && (*id == 0))
-               *id=V4L2_STD_PAL;
+               *id = V4L2_STD_PAL;
 
        /* Seek for exact match */
-       for (i=0;i<priv->firm_size;i++) {
-               if ( (type == priv->firm[i].type) &&
-                                               (*id == priv->firm[i].id))
+       for (i = 0; i < priv->firm_size; i++) {
+               if ((type == priv->firm[i].type) && (*id == priv->firm[i].id))
                        goto found;
        }
 
        /* Seek for generic video standard match */
-       for (i=0;i<priv->firm_size;i++) {
-               if ( (type == priv->firm[i].type) && (*id & priv->firm[i].id))
+       for (i = 0; i < priv->firm_size; i++) {
+               if ((type == priv->firm[i].type) && (*id & priv->firm[i].id))
                        goto found;
        }
 
        /*FIXME: Would make sense to seek for type "hint" match ? */
 
-       tuner_info ("Can't find firmware for type=%x, id=%lx\n", type,
-                   (long int)*id);
+       tuner_info("Can't find firmware for type=%x, id=%lx\n", type,
+                  (long int)*id);
        return -EINVAL;
 
 found:
        *id = priv->firm[i].id;
-       tuner_info ("Found firmware for type=%x, id=%lx\n", type,
-                   (long int)*id);
+       tuner_info("Found firmware for type=%x, id=%lx\n", type, (long int)*id);
 
        p = priv->firm[i].ptr;
 
@@ -301,19 +303,18 @@ found:
                printk(KERN_ERR PREFIX "Firmware pointer were freed!");
                return -EINVAL;
        }
-       endp = p+priv->firm[i].size;
+       endp = p + priv->firm[i].size;
 
-       while (p<endp) {
+       while (p < endp) {
                __u16 size;
 
                /* Checks if there's enough bytes to read */
-               if (p+sizeof(size)>endp) {
+               if (p + sizeof(size) > endp) {
                        tuner_info("missing bytes\n");
                        return -EINVAL;
                }
 
-
-               size = le16_to_cpu(*(__u16 *)p);
+               size = le16_to_cpu(*(__u16 *) p);
                p += sizeof(size);
 
                if (size == 0xffff)
@@ -322,10 +323,10 @@ found:
                if (!size) {
                        /* Special callback command received */
                        rc = priv->tuner_callback(priv->video_dev,
-                                            XC2028_TUNER_RESET, 0);
-                       if (rc<0) {
+                                                 XC2028_TUNER_RESET, 0);
+                       if (rc < 0) {
                                tuner_info("Error at RESET code %d\n",
-                                                               (*p)&0x7f);
+                                          (*p) & 0x7f);
                                return -EINVAL;
                        }
                        continue;
@@ -333,13 +334,13 @@ found:
 
                /* Checks for a sleep command */
                if (size & 0x8000) {
-                       msleep (size & 0x7fff);
+                       msleep(size & 0x7fff);
                        continue;
                }
 
                if ((size + p > endp)) {
                        tuner_info("missing bytes: need %d, have %d\n",
-                                       size, (int)(endp-p));
+                                  size, (int)(endp - p));
                        return -EINVAL;
                }
 
@@ -348,14 +349,15 @@ found:
                size--;
 
                /* Sends message chunks */
-               while (size>0) {
-                       int len = (size<priv->max_len-1)?size:priv->max_len-1;
+               while (size > 0) {
+                       int len = (size < priv->max_len - 1) ?
+                                  size : priv->max_len - 1;
 
-                       memcpy(buf+1, p, len);
+                       memcpy(buf + 1, p, len);
 
-                       i2c_send(rc, priv, buf, len+1);
-                       if (rc<0) {
-                               tuner_info("%d returned from send\n",rc);
+                       i2c_send(rc, priv, buf, len + 1);
+                       if (rc < 0) {
+                               tuner_info("%d returned from send\n", rc);
                                return -EINVAL;
                        }
 
@@ -367,13 +369,12 @@ found:
 }
 
 static int check_firmware(struct dvb_frontend *fe, enum tuner_mode new_mode,
-                                               v4l2_std_id std,
-                                               fe_bandwidth_t bandwidth)
+                         v4l2_std_id std, fe_bandwidth_t bandwidth)
 {
        struct xc2028_data      *priv = fe->tuner_priv;
        int                     rc, version;
-       v4l2_std_id             std0=0;
-       unsigned int            type0=0,type=0;
+       v4l2_std_id             std0 = 0;
+       unsigned int            type0 = 0, type = 0;
        int                     change_digital_bandwidth;
 
        tuner_info("%s called\n", __FUNCTION__);
@@ -382,58 +383,56 @@ static int check_firmware(struct dvb_frontend *fe, enum tuner_mode new_mode,
                if (!priv->ctrl.fname)
                        return -EINVAL;
 
-               rc=load_all_firmwares(fe);
-               if (rc<0)
+               rc = load_all_firmwares(fe);
+               if (rc < 0)
                        return rc;
        }
 
-       tuner_info( "I am in mode %u and I should switch to mode %i\n",
-                                                   priv->mode, new_mode);
+       tuner_info("I am in mode %u and I should switch to mode %i\n",
+                  priv->mode, new_mode);
 
        /* first of all, determine whether we have switched the mode */
-       if(new_mode != priv->mode) {
+       if (new_mode != priv->mode) {
                priv->mode = new_mode;
                priv->need_load_generic = 1;
        }
 
        change_digital_bandwidth = (priv->mode == T_DIGITAL_TV
-                                && bandwidth != priv->bandwidth) ? 1 : 0;
+                                   && bandwidth != priv->bandwidth) ? 1 : 0;
        tuner_info("old bandwidth %u, new bandwidth %u\n", priv->bandwidth,
-                   bandwidth);
+                  bandwidth);
 
        if (priv->need_load_generic) {
                /* Reset is needed before loading firmware */
                rc = priv->tuner_callback(priv->video_dev,
                                          XC2028_TUNER_RESET, 0);
-               if (rc<0)
+               if (rc < 0)
                        return rc;
 
-               type0=BASE;
+               type0 = BASE;
 
                if (priv->ctrl.type == XC2028_FIRM_MTS)
                        type0 |= MTS;
 
-               if (priv->bandwidth==8)
+               if (priv->bandwidth == 8)
                        type0 |= F8MHZ;
 
                /* FIXME: How to load FM and FM|INPUT1 firmwares? */
 
                rc = load_firmware(fe, type0, &std0);
-               if (rc<0) {
+               if (rc < 0) {
                        tuner_info("Error %d while loading generic firmware\n",
                                   rc);
                        return rc;
                }
 
-               priv->need_load_generic=0;
-               priv->firm_type=0;
-               if(priv->mode == T_DIGITAL_TV) {
-                       change_digital_bandwidth=1;
-               }
+               priv->need_load_generic = 0;
+               priv->firm_type = 0;
+               if (priv->mode == T_DIGITAL_TV)
+                       change_digital_bandwidth = 1;
        }
 
-       tuner_info("I should change bandwidth %u\n",
-                                                  change_digital_bandwidth);
+       tuner_info("I should change bandwidth %u\n", change_digital_bandwidth);
 
        if (change_digital_bandwidth) {
 
@@ -442,7 +441,7 @@ static int check_firmware(struct dvb_frontend *fe, enum tuner_mode new_mode,
 
                /* FIXME: When should select a DTV78 firmware?
                 */
-               switch(bandwidth) {
+               switch (bandwidth) {
                case BANDWIDTH_8_MHZ:
                        type |= DTV8;
                        break;
@@ -475,21 +474,21 @@ static int check_firmware(struct dvb_frontend *fe, enum tuner_mode new_mode,
        if (priv->ctrl.type == XC2028_FIRM_MTS)
                type |= MTS;
 
-       tuner_info("firmware standard to load: %08lx\n",(unsigned long) std);
+       tuner_info("firmware standard to load: %08lx\n", (unsigned long)std);
        if (priv->firm_type & std) {
                tuner_info("no need to load a std-specific firmware.\n");
                return 0;
        }
 
        rc = load_firmware(fe, type, &std);
-       if (rc<0)
+       if (rc < 0)
                return rc;
 
        version = xc2028_get_reg(priv, 0x4);
        tuner_info("Firmware version is %d.%d\n",
-                                       (version>>4)&0x0f,(version)&0x0f);
+                  (version >> 4) & 0x0f, (version) & 0x0f);
 
-       priv->firm_type=std;
+       priv->firm_type = std;
 
        return 0;
 }
@@ -497,7 +496,7 @@ static int check_firmware(struct dvb_frontend *fe, enum tuner_mode new_mode,
 static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
 {
        struct xc2028_data *priv = fe->tuner_priv;
-       int                frq_lock, signal=0;
+       int                frq_lock, signal = 0;
 
        tuner_info("%s called\n", __FUNCTION__);
 
@@ -506,16 +505,15 @@ static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
        *strength = 0;
 
        frq_lock = xc2028_get_reg(priv, 0x2);
-       if (frq_lock<=0)
+       if (frq_lock <= 0)
                goto ret;
 
        /* Frequency is locked. Return signal quality */
 
        signal = xc2028_get_reg(priv, 0x40);
 
-       if(signal<=0) {
-               signal=frq_lock;
-       }
+       if (signal <= 0)
+               signal = frq_lock;
 
 ret:
        mutex_unlock(&priv->lock);
@@ -527,15 +525,14 @@ ret:
 
 #define DIV 15625
 
-static int generic_set_tv_freq(struct dvb_frontend *fe, u32 freq /* in Hz */,
-                               enum tuner_mode new_mode,
-                               v4l2_std_id std,
-                               fe_bandwidth_t bandwidth)
+static int generic_set_tv_freq(struct dvb_frontend *fe, u32 freq /* in Hz */ ,
+                              enum tuner_mode new_mode,
+                              v4l2_std_id std, fe_bandwidth_t bandwidth)
 {
        struct xc2028_data *priv = fe->tuner_priv;
-       int           rc=-EINVAL;
-       unsigned char buf[5];
-       u32 div, offset = 0;
+       int                rc = -EINVAL;
+       unsigned char      buf[5];
+       u32                div, offset = 0;
 
        tuner_info("%s called\n", __FUNCTION__);
 
@@ -544,56 +541,56 @@ static int generic_set_tv_freq(struct dvb_frontend *fe, u32 freq /* in Hz */,
        /* HACK: It seems that specific firmware need to be reloaded
           when freq is changed */
 
-       priv->firm_type=0;
+       priv->firm_type = 0;
 
        /* Reset GPIO 1 */
        rc = priv->tuner_callback(priv->video_dev, XC2028_TUNER_RESET, 0);
-       if (rc<0)
+       if (rc < 0)
                goto ret;
 
        msleep(10);
        tuner_info("should set frequency %d kHz)\n", freq / 1000);
 
-       if (check_firmware(fe, new_mode, std, bandwidth)<0)
+       if (check_firmware(fe, new_mode, std, bandwidth) < 0)
                goto ret;
 
-       if(new_mode == T_DIGITAL_TV)
+       if (new_mode == T_DIGITAL_TV)
                offset = 2750000;
 
-       div = (freq - offset + DIV/2)/DIV;
+       div = (freq - offset + DIV / 2) / DIV;
 
        /* CMD= Set frequency */
 
-       if (priv->version<0x0202) {
+       if (priv->version < 0x0202) {
                send_seq(priv, {0x00, 0x02, 0x00, 0x00});
        } else {
                send_seq(priv, {0x80, 0x02, 0x00, 0x00});
        }
 
        rc = priv->tuner_callback(priv->video_dev, XC2028_RESET_CLK, 1);
-       if (rc<0)
+       if (rc < 0)
                goto ret;
 
        msleep(10);
 
-       buf[0]= 0xff & (div>>24);
-       buf[1]= 0xff & (div>>16);
-       buf[2]= 0xff & (div>>8);
-       buf[3]= 0xff & (div);
-       buf[4]= 0;
+       buf[0] = 0xff & (div >> 24);
+       buf[1] = 0xff & (div >> 16);
+       buf[2] = 0xff & (div >> 8);
+       buf[3] = 0xff & (div);
+       buf[4] = 0;
 
        i2c_send(rc, priv, buf, sizeof(buf));
-       if (rc<0)
+       if (rc < 0)
                goto ret;
        msleep(100);
 
-       priv->frequency=freq;
+       priv->frequency = freq;
 
        printk("divider= %02x %02x %02x %02x (freq=%d.%02d)\n",
-                buf[1],buf[2],buf[3],buf[4],
-                freq / 1000000, (freq%1000000)/10000);
+              buf[1], buf[2], buf[3], buf[4],
+              freq / 1000000, (freq % 1000000) / 10000);
 
-       rc=0;
+       rc = 0;
 
 ret:
        mutex_unlock(&priv->lock);
@@ -602,15 +599,14 @@ ret:
 }
 
 static int xc2028_set_tv_freq(struct dvb_frontend *fe,
-                       struct analog_parameters *p)
+                             struct analog_parameters *p)
 {
        struct xc2028_data *priv = fe->tuner_priv;
 
        tuner_info("%s called\n", __FUNCTION__);
 
-       return generic_set_tv_freq(fe, 62500l*p->frequency, T_ANALOG_TV,
-                                             p->std,
-                                             BANDWIDTH_8_MHZ /* NOT USED */);
+       return generic_set_tv_freq(fe, 62500l * p->frequency, T_ANALOG_TV,
+                                  p->std, BANDWIDTH_8_MHZ /* NOT USED */);
 }
 
 static int xc2028_set_params(struct dvb_frontend *fe,
@@ -622,13 +618,13 @@ static int xc2028_set_params(struct dvb_frontend *fe,
 
        /* FIXME: Only OFDM implemented */
        if (fe->ops.info.type != FE_OFDM) {
-               tuner_info ("DTV type not implemented.\n");
+               tuner_info("DTV type not implemented.\n");
                return -EINVAL;
        }
 
        return generic_set_tv_freq(fe, p->frequency, T_DIGITAL_TV,
-                                               0, /* NOT USED */
-                                               p->u.ofdm.bandwidth);
+                                  0 /* NOT USED */,
+                                  p->u.ofdm.bandwidth);
 
 }
 
@@ -643,11 +639,10 @@ static int xc2028_dvb_release(struct dvb_frontend *fe)
        if (!priv->count) {
                list_del(&priv->xc2028_list);
 
-               if (priv->ctrl.fname)
-                       kfree(priv->ctrl.fname);
+               kfree(priv->ctrl.fname);
 
                free_firmware(priv);
-               kfree (priv);
+               kfree(priv);
        }
 
        return 0;
@@ -664,7 +659,7 @@ static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency)
        return 0;
 }
 
-static int xc2028_set_config (struct dvb_frontend *fe, void *priv_cfg)
+static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
 {
        struct xc2028_data *priv = fe->tuner_priv;
        struct xc2028_ctrl *p    = priv_cfg;
@@ -674,10 +669,9 @@ static int xc2028_set_config (struct dvb_frontend *fe, void *priv_cfg)
        priv->ctrl.type = p->type;
 
        if (p->fname) {
-               if (priv->ctrl.fname)
-                       kfree(priv->ctrl.fname);
+               kfree(priv->ctrl.fname);
 
-               priv->ctrl.fname = kmalloc(strlen(p->fname)+1, GFP_KERNEL);
+               priv->ctrl.fname = kmalloc(strlen(p->fname) + 1, GFP_KERNEL);
                if (!priv->ctrl.fname)
                        return -ENOMEM;
 
@@ -685,7 +679,7 @@ static int xc2028_set_config (struct dvb_frontend *fe, void *priv_cfg)
                strcpy(priv->ctrl.fname, p->fname);
        }
 
-       if (p->max_len>0)
+       if (p->max_len > 0)
                priv->max_len = p->max_len;
 
        tuner_info("%s OK\n", __FUNCTION__);
@@ -695,11 +689,11 @@ static int xc2028_set_config (struct dvb_frontend *fe, void *priv_cfg)
 
 static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
        .info = {
-                       .name           = "Xceive XC3028",
-                       .frequency_min  =  42000000,
-                       .frequency_max  = 864000000,
-                       .frequency_step =     50000,
-               },
+                .name = "Xceive XC3028",
+                .frequency_min = 42000000,
+                .frequency_max = 864000000,
+                .frequency_step = 50000,
+                },
 
        .set_config        = xc2028_set_config,
        .set_analog_params = xc2028_set_tv_freq,
@@ -708,18 +702,15 @@ static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
        .get_rf_strength   = xc2028_signal,
        .set_params        = xc2028_set_params,
 
-//     int (*sleep)(struct dvb_frontend *fe);
-//     int (*get_bandwidth)(struct dvb_frontend *fe, u32 *bandwidth);
-//     int (*get_status)(struct dvb_frontend *fe, u32 *status);
 };
 
-int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapteri2c_adap,
+int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c_adap,
                  u8 i2c_addr, struct device *dev, void *video_dev,
-                 int (*tuner_callback) (void *dev, int command,int arg))
+                 int (*tuner_callback) (void *dev, int command, int arg))
 {
        struct xc2028_data *priv;
 
-       printk( KERN_INFO PREFIX "Xcv2028/3028 init called!\n");
+       printk(KERN_INFO PREFIX "Xcv2028/3028 init called!\n");
 
        if (NULL == dev)
                return -ENODEV;
@@ -728,14 +719,13 @@ int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapter* i2c_adap,
                return -ENODEV;
 
        if (!tuner_callback) {
-               printk( KERN_ERR PREFIX "No tuner callback!\n");
+               printk(KERN_ERR PREFIX "No tuner callback!\n");
                return -EINVAL;
        }
 
        list_for_each_entry(priv, &xc2028_list, xc2028_list) {
-               if (priv->dev == dev) {
+               if (priv->dev == dev)
                        dev = NULL;
-               }
        }
 
        if (dev) {
@@ -745,8 +735,8 @@ int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapter* i2c_adap,
 
                fe->tuner_priv = priv;
 
-               priv->bandwidth=BANDWIDTH_6_MHZ;
-               priv->need_load_generic=1;
+               priv->bandwidth = BANDWIDTH_6_MHZ;
+               priv->need_load_generic = 1;
                priv->mode = T_UNINITIALIZED;
                priv->i2c_props.addr = i2c_addr;
                priv->i2c_props.adap = i2c_adap;
@@ -758,18 +748,17 @@ int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapter* i2c_adap,
 
                mutex_init(&priv->lock);
 
-               list_add_tail(&priv->xc2028_list,&xc2028_list);
+               list_add_tail(&priv->xc2028_list, &xc2028_list);
        }
        priv->count++;
 
        memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
-                                              sizeof(xc2028_dvb_tuner_ops));
+              sizeof(xc2028_dvb_tuner_ops));
 
        tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");
 
        return 0;
 }
-
 EXPORT_SYMBOL(xc2028_attach);
 
 MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
index 4e5e4d5d1b5f9e8f81ff194c14c6a646158a2806..e04611e653e4d01991d8d97ad478782b83746780 100644 (file)
@@ -27,15 +27,17 @@ struct xc2028_ctrl {
 #define XC2028_RESET_CLK       1
 
 #if defined(CONFIG_TUNER_XC2028) || (defined(CONFIG_TUNER_XC2028_MODULE) && defined(MODULE))
-int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapteri2c_adap,
+int xc2028_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c_adap,
                  u8 i2c_addr, struct device *dev, void *video_dev,
-                 int (*tuner_callback) (void *dev, int command,int arg));
+                 int (*tuner_callback) (void *dev, int command, int arg));
 
 #else
 static inline int xc2028_attach(struct dvb_frontend *fe,
-                 struct i2c_adapter* i2c_adap,
-                 u8 i2c_addr, struct device *dev, void *video_dev,
-                 int (*tuner_callback) (void *dev, int command,int arg))
+                               struct i2c_adapter *i2c_adap,
+                               u8 i2c_addr, struct device *dev,
+                               void *video_dev,
+                               int (*tuner_callback) (void *dev, int command,
+                                                      int arg))
 {
        printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
               __FUNCTION__);