redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

Input: use kzalloc() throughout the code 

Signed-off-by: Eric Sesterhenn <snakebyte@gmx.de>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
wifi-calibration
Eric Sesterhenn 2006-03-14 00:09:16 -05:00 committed by Dmitry Torokhov
parent 493a7e0d56
commit b39787a972
13 changed files with 22 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/input/evbug.c
View File

@ -49,9 +49,8 @@ static struct input_handle *evbug_connect(struct input_handler *handler, struct
{
struct input_handle *handle;
if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
if (!(handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL)))
return NULL;
memset(handle, 0, sizeof(struct input_handle));
handle->dev = dev;
handle->handler = handler;

6
drivers/input/evdev.c
View File

@ -130,9 +130,8 @@ static int evdev_open(struct inode * inode, struct file * file)
if ((accept_err = input_accept_process(&(evdev_table[i]->handle), file)))
return accept_err;
if (!(list = kmalloc(sizeof(struct evdev_list), GFP_KERNEL)))
if (!(list = kzalloc(sizeof(struct evdev_list), GFP_KERNEL)))
return -ENOMEM;
memset(list, 0, sizeof(struct evdev_list));
list->evdev = evdev_table[i];
list_add_tail(&list->node, &evdev_table[i]->list);
@ -609,9 +608,8 @@ static struct input_handle *evdev_connect(struct input_handler *handler, struct
return NULL;
}
if (!(evdev = kmalloc(sizeof(struct evdev), GFP_KERNEL)))
if (!(evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL)))
return NULL;
memset(evdev, 0, sizeof(struct evdev));
INIT_LIST_HEAD(&evdev->list);
init_waitqueue_head(&evdev->wait);

6
drivers/input/joydev.c
View File

@ -171,9 +171,8 @@ static int joydev_open(struct inode *inode, struct file *file)
if (i >= JOYDEV_MINORS || !joydev_table[i])
return -ENODEV;
if (!(list = kmalloc(sizeof(struct joydev_list), GFP_KERNEL)))
if (!(list = kzalloc(sizeof(struct joydev_list), GFP_KERNEL)))
return -ENOMEM;
memset(list, 0, sizeof(struct joydev_list));
list->joydev = joydev_table[i];
list_add_tail(&list->node, &joydev_table[i]->list);
@ -457,9 +456,8 @@ static struct input_handle *joydev_connect(struct input_handler *handler, struct
return NULL;
}
if (!(joydev = kmalloc(sizeof(struct joydev), GFP_KERNEL)))
if (!(joydev = kzalloc(sizeof(struct joydev), GFP_KERNEL)))
return NULL;
memset(joydev, 0, sizeof(struct joydev));
INIT_LIST_HEAD(&joydev->list);
init_waitqueue_head(&joydev->wait);

3
drivers/input/keyboard/hil_kbd.c
View File

@ -251,10 +251,9 @@ static int hil_kbd_connect(struct serio *serio, struct serio_driver *drv)
uint8_t did, *idd;
int i;
kbd = kmalloc(sizeof(*kbd), GFP_KERNEL);
kbd = kzalloc(sizeof(*kbd), GFP_KERNEL);
if (!kbd)
return -ENOMEM;
memset(kbd, 0, sizeof(struct hil_kbd));
if (serio_open(serio, drv)) goto bail0;

7
drivers/input/mouse/hil_ptr.c
View File

@ -245,10 +245,11 @@ static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver)
unsigned int i, naxsets, btntype;
uint8_t did, *idd;
if (!(ptr = kmalloc(sizeof(struct hil_ptr), GFP_KERNEL))) return -ENOMEM;
memset(ptr, 0, sizeof(struct hil_ptr));
if (!(ptr = kzalloc(sizeof(struct hil_ptr), GFP_KERNEL)))
return -ENOMEM;
if (serio_open(serio, driver)) goto bail0;
if (serio_open(serio, driver))
goto bail0;
serio_set_drvdata(serio, ptr);
ptr->serio = serio;

7
drivers/input/mouse/synaptics.c
View File

@ -247,14 +247,12 @@ static void synaptics_pt_create(struct psmouse *psmouse)
{
struct serio *serio;
serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
if (!serio) {
printk(KERN_ERR "synaptics: not enough memory to allocate pass-through port\n");
return;
}
memset(serio, 0, sizeof(struct serio));
serio->id.type = SERIO_PS_PSTHRU;
strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
@ -623,10 +621,9 @@ int synaptics_init(struct psmouse *psmouse)
{
struct synaptics_data *priv;
psmouse->private = priv = kmalloc(sizeof(struct synaptics_data), GFP_KERNEL);
psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
if (!priv)
return -1;
memset(priv, 0, sizeof(struct synaptics_data));
if (synaptics_query_hardware(psmouse)) {
printk(KERN_ERR "Unable to query Synaptics hardware.\n");

6
drivers/input/mousedev.c
View File

@ -412,9 +412,8 @@ static int mousedev_open(struct inode * inode, struct file * file)
if (i >= MOUSEDEV_MINORS || !mousedev_table[i])
return -ENODEV;
if (!(list = kmalloc(sizeof(struct mousedev_list), GFP_KERNEL)))
if (!(list = kzalloc(sizeof(struct mousedev_list), GFP_KERNEL)))
return -ENOMEM;
memset(list, 0, sizeof(struct mousedev_list));
spin_lock_init(&list->packet_lock);
list->pos_x = xres / 2;
@ -626,9 +625,8 @@ static struct input_handle *mousedev_connect(struct input_handler *handler, stru
return NULL;
}
if (!(mousedev = kmalloc(sizeof(struct mousedev), GFP_KERNEL)))
if (!(mousedev = kzalloc(sizeof(struct mousedev), GFP_KERNEL)))
return NULL;
memset(mousedev, 0, sizeof(struct mousedev));
INIT_LIST_HEAD(&mousedev->list);
init_waitqueue_head(&mousedev->wait);

3
drivers/input/power.c
View File

@ -103,9 +103,8 @@ static struct input_handle *power_connect(struct input_handler *handler,
{
struct input_handle *handle;
if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
if (!(handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL)))
return NULL;
memset(handle, 0, sizeof(struct input_handle));
handle->dev = dev;
handle->handler = handler;

3
drivers/input/serio/hil_mlc.c
View File

@ -872,9 +872,8 @@ int hil_mlc_register(hil_mlc *mlc) {
for (i = 0; i < HIL_MLC_DEVMEM; i++) {
struct serio *mlc_serio;
hil_mlc_copy_di_scratch(mlc, i);
mlc_serio = kmalloc(sizeof(*mlc_serio), GFP_KERNEL);
mlc_serio = kzalloc(sizeof(*mlc_serio), GFP_KERNEL);
mlc->serio[i] = mlc_serio;
memset(mlc_serio, 0, sizeof(*mlc_serio));
mlc_serio->id = hil_mlc_serio_id;
mlc_serio->write = hil_mlc_serio_write;
mlc_serio->open = hil_mlc_serio_open;

3
drivers/input/serio/parkbd.c
View File

@ -171,9 +171,8 @@ static struct serio * __init parkbd_allocate_serio(void)
{
struct serio *serio;
serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
if (serio) {
memset(serio, 0, sizeof(struct serio));
serio->id.type = parkbd_mode;
serio->write = parkbd_write,
strlcpy(serio->name, "PARKBD AT/XT keyboard adapter", sizeof(serio->name));

3
drivers/input/serio/rpckbd.c
View File

@ -111,11 +111,10 @@ static int __devinit rpckbd_probe(struct platform_device *dev)
{
struct serio *serio;
serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
if (!serio)
return -ENOMEM;
memset(serio, 0, sizeof(struct serio));
serio->id.type = SERIO_8042;
serio->write = rpckbd_write;
serio->open = rpckbd_open;

6
drivers/input/serio/serio_raw.c
View File

@ -96,12 +96,11 @@ static int serio_raw_open(struct inode *inode, struct file *file)
goto out;
}
if (!(list = kmalloc(sizeof(struct serio_raw_list), GFP_KERNEL))) {
if (!(list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL))) {
retval = -ENOMEM;
goto out;
}
memset(list, 0, sizeof(struct serio_raw_list));
list->serio_raw = serio_raw;
file->private_data = list;
@ -276,14 +275,13 @@ static int serio_raw_connect(struct serio *serio, struct serio_driver *drv)
struct serio_raw *serio_raw;
int err;
if (!(serio_raw = kmalloc(sizeof(struct serio_raw), GFP_KERNEL))) {
if (!(serio_raw = kzalloc(sizeof(struct serio_raw), GFP_KERNEL))) {
printk(KERN_ERR "serio_raw.c: can't allocate memory for a device\n");
return -ENOMEM;
}
mutex_lock(&serio_raw_mutex);
memset(serio_raw, 0, sizeof(struct serio_raw));
snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++);
serio_raw->refcnt = 1;
serio_raw->serio = serio;

6
drivers/input/tsdev.c
View File

@ -157,9 +157,8 @@ static int tsdev_open(struct inode *inode, struct file *file)
if (i >= TSDEV_MINORS || !tsdev_table[i & TSDEV_MINOR_MASK])
return -ENODEV;
if (!(list = kmalloc(sizeof(struct tsdev_list), GFP_KERNEL)))
if (!(list = kzalloc(sizeof(struct tsdev_list), GFP_KERNEL)))
return -ENOMEM;
memset(list, 0, sizeof(struct tsdev_list));
list->raw = (i >= TSDEV_MINORS/2) ? 1 : 0;
@ -379,9 +378,8 @@ static struct input_handle *tsdev_connect(struct input_handler *handler,
return NULL;
}
if (!(tsdev = kmalloc(sizeof(struct tsdev), GFP_KERNEL)))
if (!(tsdev = kzalloc(sizeof(struct tsdev), GFP_KERNEL)))
return NULL;
memset(tsdev, 0, sizeof(struct tsdev));
INIT_LIST_HEAD(&tsdev->list);
init_waitqueue_head(&tsdev->wait);