[PATCH] hwmon: kzalloc conversion

Use kzalloc instead of kmalloc+memset in all hardware monitoring
drivers.

Signed-off-by: Deepak Saxena <dsaxena@plexity.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/hwmon/adm1021.c b/drivers/hwmon/adm1021.c
index 58aee3a00caaa087468c3f97a420e9623ae517e0..8102876c7c3f2cf69e9145ca3b1f3241ff487678 100644 (file)
--- a/drivers/hwmon/adm1021.c
+++ b/drivers/hwmon/adm1021.c
@@ -204,11 +204,10 @@ static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access adm1021_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct adm1021_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct adm1021_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto error0;
        }
-       memset(data, 0, sizeof(struct adm1021_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/adm1025.c b/drivers/hwmon/adm1025.c
index 526b7ff179ebb83c0bc1197a978e85344424a6c8..3ec12421694f591df0de7c1e43ea924c331af1c1 100644 (file)
--- a/drivers/hwmon/adm1025.c
+++ b/drivers/hwmon/adm1025.c
@@ -331,11 +331,10 @@ static int adm1025_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct adm1025_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct adm1025_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct adm1025_data));
 
        /* The common I2C client data is placed right before the
           ADM1025-specific data. */

diff --git a/drivers/hwmon/adm1026.c b/drivers/hwmon/adm1026.c
index 625158110fd4ff74294debbc2a67a550012f90c9..3b5814183738d68aa0a291fe084f4816168dbc1c 100644 (file)
--- a/drivers/hwmon/adm1026.c
+++ b/drivers/hwmon/adm1026.c
@@ -1470,13 +1470,11 @@ int adm1026_detect(struct i2c_adapter *adapter, int address,
           client structure, even though we cannot fill it completely yet.
           But it allows us to access adm1026_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct adm1026_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct adm1026_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
 
-       memset(data, 0, sizeof(struct adm1026_data));
-
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);
        new_client->addr = address;

diff --git a/drivers/hwmon/adm1031.c b/drivers/hwmon/adm1031.c
index 58338ed7c8a1c676095e3c9672fa08e453455a7b..7c545d5eee4570f0cbe9c4e175db925db36344bd 100644 (file)
--- a/drivers/hwmon/adm1031.c
+++ b/drivers/hwmon/adm1031.c
@@ -740,11 +740,10 @@ static int adm1031_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct adm1031_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct adm1031_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/asb100.c b/drivers/hwmon/asb100.c
index 8e34855a627406200510db53dd9e374d87ce7db9..52c469722a6584ea622618dbd99c6c53ff43b329 100644 (file)
--- a/drivers/hwmon/asb100.c
+++ b/drivers/hwmon/asb100.c
@@ -629,19 +629,17 @@ static int asb100_detect_subclients(struct i2c_adapter *adapter, int address,
        int i, id, err;
        struct asb100_data *data = i2c_get_clientdata(new_client);
 
-       data->lm75[0] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (!(data->lm75[0])) {
                err = -ENOMEM;
                goto ERROR_SC_0;
        }
-       memset(data->lm75[0], 0x00, sizeof(struct i2c_client));
 
-       data->lm75[1] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (!(data->lm75[1])) {
                err = -ENOMEM;
                goto ERROR_SC_1;
        }
-       memset(data->lm75[1], 0x00, sizeof(struct i2c_client));
 
        id = i2c_adapter_id(adapter);
 
@@ -724,12 +722,11 @@ static int asb100_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access asb100_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct asb100_data), GFP_KERNEL))) {
-               pr_debug("asb100.o: detect failed, kmalloc failed!\n");
+       if (!(data = kzalloc(sizeof(struct asb100_data), GFP_KERNEL))) {
+               pr_debug("asb100.o: detect failed, kzalloc failed!\n");
                err = -ENOMEM;
                goto ERROR0;
        }
-       memset(data, 0, sizeof(struct asb100_data));
 
        new_client = &data->client;
        init_MUTEX(&data->lock);

diff --git a/drivers/hwmon/atxp1.c b/drivers/hwmon/atxp1.c
index 441324fc6b8bf7c1b27404df8f68f6405d76223b..53324f56404e2c38979e8b7401e6b4b254028783 100644 (file)
--- a/drivers/hwmon/atxp1.c
+++ b/drivers/hwmon/atxp1.c
@@ -268,12 +268,11 @@ static int atxp1_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct atxp1_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct atxp1_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
 
-       memset(data, 0, sizeof(struct atxp1_data));
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);
 

diff --git a/drivers/hwmon/ds1621.c b/drivers/hwmon/ds1621.c
index e1ff22cf984afc86e5afec89f83efeff43d111f5..c5afa00583089a1aaf3f9d7f4a6db60f6be2524c 100644 (file)
--- a/drivers/hwmon/ds1621.c
+++ b/drivers/hwmon/ds1621.c
@@ -202,11 +202,10 @@ int ds1621_detect(struct i2c_adapter *adapter, int address,
        /* OK. For now, we presume we have a valid client. We now create the
           client structure, even though we cannot fill it completely yet.
           But it allows us to access ds1621_{read,write}_value. */
-       if (!(data = kmalloc(sizeof(struct ds1621_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct ds1621_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct ds1621_data));
        
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/fscher.c b/drivers/hwmon/fscher.c
index eef6061d786b4e3c397b6bf9445a2d835be2b427..a02e1c34c757db66aaf5048d3544146c057fe8d6 100644 (file)
--- a/drivers/hwmon/fscher.c
+++ b/drivers/hwmon/fscher.c
@@ -303,11 +303,10 @@ static int fscher_detect(struct i2c_adapter *adapter, int address, int kind)
        /* OK. For now, we presume we have a valid client. We now create the
         * client structure, even though we cannot fill it completely yet.
         * But it allows us to access i2c_smbus_read_byte_data. */
-       if (!(data = kmalloc(sizeof(struct fscher_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct fscher_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct fscher_data));
 
        /* The common I2C client data is placed right before the
         * Hermes-specific data. */

diff --git a/drivers/hwmon/fscpos.c b/drivers/hwmon/fscpos.c
index 5fc77a5fed07b4b25d8fc21d27e22cc55a6a71a9..a378e4f5c93bd91a2e8ebb07eba6b61c2f042db3 100644 (file)
--- a/drivers/hwmon/fscpos.c
+++ b/drivers/hwmon/fscpos.c
@@ -453,11 +453,10 @@ int fscpos_detect(struct i2c_adapter *adapter, int address, int kind)
         * But it allows us to access fscpos_{read,write}_value.
         */
 
-       if (!(data = kmalloc(sizeof(struct fscpos_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct fscpos_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct fscpos_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/gl518sm.c b/drivers/hwmon/gl518sm.c
index 256b9323c84b1e83f087cf51a3b34bb9190548fb..2f178dbe3d87f5d624d467782c9237625ddada15 100644 (file)
--- a/drivers/hwmon/gl518sm.c
+++ b/drivers/hwmon/gl518sm.c
@@ -365,11 +365,10 @@ static int gl518_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access gl518_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct gl518_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct gl518_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct gl518_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/gl520sm.c b/drivers/hwmon/gl520sm.c
index 12fd757066fc9cad503b32a5c1df1e056909fbb5..c39ba12394260faebe9c1088e86e5e42a1b7b3ca 100644 (file)
--- a/drivers/hwmon/gl520sm.c
+++ b/drivers/hwmon/gl520sm.c
@@ -536,11 +536,10 @@ static int gl520_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access gl520_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct gl520_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct gl520_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct gl520_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 55e1c835a046f0fa200328f72509625656a8211f..9a5b8b268397108ac0f044a05e4228d5df3d20a6 100644 (file)
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -761,11 +761,10 @@ int it87_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access it87_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct it87_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR1;
        }
-       memset(data, 0, sizeof(struct it87_data));
 
        new_client = &data->client;
        if (is_isa)

diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index be5c7095ecbb2648bf86a05583373b0e9a30a157..954ec249724974107a14964ec00c2e3e25eb261f 100644 (file)
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -375,11 +375,10 @@ static int lm63_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct lm63_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm63_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm63_data));
 
        /* The common I2C client data is placed right before the
           LM63-specific data. */

diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index 9a3ebdf583f403ec80f4c066aa64459bfb4ccfac..d70f4c8fc1e6834f11443ef98a9a8750e1d21c25 100644 (file)
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -127,11 +127,10 @@ static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
        /* OK. For now, we presume we have a valid client. We now create the
           client structure, even though we cannot fill it completely yet.
           But it allows us to access lm75_{read,write}_value. */
-       if (!(data = kmalloc(sizeof(struct lm75_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm75_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/lm77.c b/drivers/hwmon/lm77.c
index 866eab96a6f6f6594374037bda6eeb08c5a39c1a..9380fda7dcd129015af886f1360b650f216aad78 100644 (file)
--- a/drivers/hwmon/lm77.c
+++ b/drivers/hwmon/lm77.c
@@ -226,11 +226,10 @@ static int lm77_detect(struct i2c_adapter *adapter, int address, int kind)
        /* OK. For now, we presume we have a valid client. We now create the
           client structure, even though we cannot fill it completely yet.
           But it allows us to access lm77_{read,write}_value. */
-       if (!(data = kmalloc(sizeof(struct lm77_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm77_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm77_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/lm78.c b/drivers/hwmon/lm78.c
index d697a554286f2189fc5aeb081560dcc0dec68f89..92446236274367f6223b34296c9aabfbd4314dfc 100644 (file)
--- a/drivers/hwmon/lm78.c
+++ b/drivers/hwmon/lm78.c
@@ -540,11 +540,10 @@ int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access lm78_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR1;
        }
-       memset(data, 0, sizeof(struct lm78_data));
 
        new_client = &data->client;
        if (is_isa)

diff --git a/drivers/hwmon/lm80.c b/drivers/hwmon/lm80.c
index 83af8b3a0cac02ba04ef70f1ec4b8f118de210b5..b4cd6c661f114e7375f37c67d5574c18fb1f5458 100644 (file)
--- a/drivers/hwmon/lm80.c
+++ b/drivers/hwmon/lm80.c
@@ -407,11 +407,10 @@ int lm80_detect(struct i2c_adapter *adapter, int address, int kind)
        /* OK. For now, we presume we have a valid client. We now create the
           client structure, even though we cannot fill it completely yet.
           But it allows us to access lm80_{read,write}_value. */
-       if (!(data = kmalloc(sizeof(struct lm80_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm80_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm80_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/lm83.c b/drivers/hwmon/lm83.c
index d74b2c20c719376eea2c8231938f66be28a5f9d8..9a70611a9f69ed5028af1d2b60ab0f11f5726312 100644 (file)
--- a/drivers/hwmon/lm83.c
+++ b/drivers/hwmon/lm83.c
@@ -230,11 +230,10 @@ static int lm83_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct lm83_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm83_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm83_data));
 
        /* The common I2C client data is placed right after the
         * LM83-specific data. */

diff --git a/drivers/hwmon/lm85.c b/drivers/hwmon/lm85.c
index ab214df9624bc423376bef632b4a87d0d1f2cf96..d5537a5377f7c6acadcc7b7a6e7b30a7d0ec9004 100644 (file)
--- a/drivers/hwmon/lm85.c
+++ b/drivers/hwmon/lm85.c
@@ -1033,11 +1033,10 @@ int lm85_detect(struct i2c_adapter *adapter, int address,
           client structure, even though we cannot fill it completely yet.
           But it allows us to access lm85_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct lm85_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm85_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR0;
        }
-       memset(data, 0, sizeof(struct lm85_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/lm87.c b/drivers/hwmon/lm87.c
index dca996de4c331e5eae87c3a868fb47c46ca9b3e6..eeec18177861ca67074189f03ce74df0019fa476 100644 (file)
--- a/drivers/hwmon/lm87.c
+++ b/drivers/hwmon/lm87.c
@@ -554,11 +554,10 @@ static int lm87_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct lm87_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm87_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm87_data));
 
        /* The common I2C client data is placed right before the
           LM87-specific data. */

diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 14de05fcd431e76c87c4a7ffc2e65c4d1e1252a4..dad0f1074956cfa2c851cbabb019e71d73d5175e 100644 (file)
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -370,11 +370,10 @@ static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm90_data));
 
        /* The common I2C client data is placed right before the
           LM90-specific data. */

diff --git a/drivers/hwmon/lm92.c b/drivers/hwmon/lm92.c
index 647b7c7cd575df129ed9ed7bbb7535e2d1422232..7a4b3701ed1a5c0fec354a9739f9a92954059bc4 100644 (file)
--- a/drivers/hwmon/lm92.c
+++ b/drivers/hwmon/lm92.c
@@ -300,11 +300,10 @@ static int lm92_detect(struct i2c_adapter *adapter, int address, int kind)
                                            | I2C_FUNC_SMBUS_WORD_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct lm92_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct lm92_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct lm92_data));
 
        /* Fill in enough client fields so that we can read from the chip,
           which is required for identication */

diff --git a/drivers/hwmon/max1619.c b/drivers/hwmon/max1619.c
index 16bf71f3a04d941f92391e64f8a6980b2e903315..6a82ffae1bfd6af15ce3fb89c92cae3c62edaab7 100644 (file)
--- a/drivers/hwmon/max1619.c
+++ b/drivers/hwmon/max1619.c
@@ -197,11 +197,10 @@ static int max1619_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct max1619_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct max1619_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct max1619_data));
 
        /* The common I2C client data is placed right before the
           MAX1619-specific data. */

diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index cf2a35799c7ce5939744ba91adf5b23a24a9289e..17f745a23d049898ba55dc51dc7499d64fcee606 100644 (file)
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -754,9 +754,8 @@ static int pc87360_detect(struct i2c_adapter *adapter)
        const char *name = "pc87360";
        int use_thermistors = 0;
 
-       if (!(data = kmalloc(sizeof(struct pc87360_data), GFP_KERNEL)))
+       if (!(data = kzalloc(sizeof(struct pc87360_data), GFP_KERNEL)))
                return -ENOMEM;
-       memset(data, 0x00, sizeof(struct pc87360_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/sis5595.c b/drivers/hwmon/sis5595.c
index 21aa9a41f62cbc5e7432a73e93318de9be0cf666..9c6cadec1087131d17d2a5a256c9959f503a56a2 100644 (file)
--- a/drivers/hwmon/sis5595.c
+++ b/drivers/hwmon/sis5595.c
@@ -518,11 +518,10 @@ static int sis5595_detect(struct i2c_adapter *adapter)
                        goto exit_release;
        }
 
-       if (!(data = kmalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit_release;
        }
-       memset(data, 0, sizeof(struct sis5595_data));
 
        new_client = &data->client;
        new_client->addr = address;

diff --git a/drivers/hwmon/smsc47b397.c b/drivers/hwmon/smsc47b397.c
index 37ed8b33f01aa69931a0dc05656871df86f0a16b..2a3e21b5b6b4443a11bc47387a9ea66ebcbb12c3 100644 (file)
--- a/drivers/hwmon/smsc47b397.c
+++ b/drivers/hwmon/smsc47b397.c
@@ -244,11 +244,10 @@ static int smsc47b397_detect(struct i2c_adapter *adapter)
                return -EBUSY;
        }
 
-       if (!(data = kmalloc(sizeof(struct smsc47b397_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct smsc47b397_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto error_release;
        }
-       memset(data, 0x00, sizeof(struct smsc47b397_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/smsc47m1.c b/drivers/hwmon/smsc47m1.c
index c9cc683eba4a9f85d7cda47ef9c1a3023402221f..bbe93a0688ec2ca0520a4e6c6f078adf1b3043b2 100644 (file)
--- a/drivers/hwmon/smsc47m1.c
+++ b/drivers/hwmon/smsc47m1.c
@@ -396,11 +396,10 @@ static int smsc47m1_detect(struct i2c_adapter *adapter)
                return -EBUSY;
        }
 
-       if (!(data = kmalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto error_release;
        }
-       memset(data, 0x00, sizeof(struct smsc47m1_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/via686a.c b/drivers/hwmon/via686a.c
index c6e64f4abdeadbbd60257ba769dcc2aac18f9c42..6f696f897176b678b05a11228a775d3abc603c05 100644 (file)
--- a/drivers/hwmon/via686a.c
+++ b/drivers/hwmon/via686a.c
@@ -621,11 +621,10 @@ static int via686a_detect(struct i2c_adapter *adapter)
                return -ENODEV;
        }
 
-       if (!(data = kmalloc(sizeof(struct via686a_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct via686a_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit_release;
        }
-       memset(data, 0, sizeof(struct via686a_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/w83627ehf.c b/drivers/hwmon/w83627ehf.c
index 685eeb76680959434e439d9dadc678b3e5ea4f8f..eee22a57e929dbf8d09a07693fc28ce8fb96fc8f 100644 (file)
--- a/drivers/hwmon/w83627ehf.c
+++ b/drivers/hwmon/w83627ehf.c
@@ -681,11 +681,10 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
                goto exit;
        }
 
-       if (!(data = kmalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit_release;
        }
-       memset(data, 0, sizeof(struct w83627ehf_data));
 
        client = &data->client;
        i2c_set_clientdata(client, data);

diff --git a/drivers/hwmon/w83627hf.c b/drivers/hwmon/w83627hf.c
index 48270819ff992ee361f1ce670485cda061a5fb83..70ef926c3bd8341a8cb304455a6ec2e24cfd087f 100644 (file)
--- a/drivers/hwmon/w83627hf.c
+++ b/drivers/hwmon/w83627hf.c
@@ -1045,11 +1045,10 @@ static int w83627hf_detect(struct i2c_adapter *adapter)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access w83627hf_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR1;
        }
-       memset(data, 0, sizeof(struct w83627hf_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/w83781d.c b/drivers/hwmon/w83781d.c
index 26b1fac7c61924001647e90d01ccab86ab02b40a..9265f32122fa4b59d072b98134c18bf383fb57d0 100644 (file)
--- a/drivers/hwmon/w83781d.c
+++ b/drivers/hwmon/w83781d.c
@@ -889,12 +889,11 @@ w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
        const char *client_name = "";
        struct w83781d_data *data = i2c_get_clientdata(new_client);
 
-       data->lm75[0] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (!(data->lm75[0])) {
                err = -ENOMEM;
                goto ERROR_SC_0;
        }
-       memset(data->lm75[0], 0x00, sizeof (struct i2c_client));
 
        id = i2c_adapter_id(adapter);
 
@@ -919,13 +918,11 @@ w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
        }
 
        if (kind != w83783s) {
-
-               data->lm75[1] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+               data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
                if (!(data->lm75[1])) {
                        err = -ENOMEM;
                        goto ERROR_SC_1;
                }
-               memset(data->lm75[1], 0x0, sizeof(struct i2c_client));
 
                if (force_subclients[0] == id &&
                    force_subclients[1] == address) {
@@ -1064,11 +1061,10 @@ w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access w83781d_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR1;
        }
-       memset(data, 0, sizeof(struct w83781d_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index 7bbd1888ce94a432260a1dfa012690763fa6a3f7..4be59dbb78c472467c507587e9cb47279a557572 100644 (file)
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -1086,11 +1086,10 @@ w83792d_create_subclient(struct i2c_adapter *adapter,
        int err;
        struct i2c_client *sub_client;
 
-       (*sub_cli) = sub_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       (*sub_cli) = sub_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (!(sub_client)) {
                return -ENOMEM;
        }
-       memset(sub_client, 0x00, sizeof(struct i2c_client));
        sub_client->addr = 0x48 + addr;
        i2c_set_clientdata(sub_client, NULL);
        sub_client->adapter = adapter;
@@ -1184,11 +1183,10 @@ w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
           client structure, even though we cannot fill it completely yet.
           But it allows us to access w83792d_{read,write}_value. */
 
-       if (!(data = kmalloc(sizeof(struct w83792d_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct w83792d_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR0;
        }
-       memset(data, 0, sizeof(struct w83792d_data));
 
        new_client = &data->client;
        i2c_set_clientdata(new_client, data);

diff --git a/drivers/hwmon/w83l785ts.c b/drivers/hwmon/w83l785ts.c
index db12a620b331daca37e07b42338d6db11cc7973f..f495b63786685ba72f77079bcdd361dde7bd18bf 100644 (file)
--- a/drivers/hwmon/w83l785ts.c
+++ b/drivers/hwmon/w83l785ts.c
@@ -156,12 +156,10 @@ static int w83l785ts_detect(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                goto exit;
 
-       if (!(data = kmalloc(sizeof(struct w83l785ts_data), GFP_KERNEL))) {
+       if (!(data = kzalloc(sizeof(struct w83l785ts_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto exit;
        }
-       memset(data, 0, sizeof(struct w83l785ts_data));
-
 
        /* The common I2C client data is placed right before the
         * W83L785TS-specific data. */