adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-31 21:26:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

[PATCH] USB: kzalloc for hid

Browse source 
this uses kzalloc in hid.

Signed-off-by: Oliver Neukum <oliver@neukum.name>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Oliver Neukum 2006-01-06 20:54:29 +01:00 committed by Greg Kroah-Hartman
parent 887c2560b6
commit bbdb7dafb5
4 changed files with 10 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
drivers/usb/input/hid-core.c
View file

@ -66,9 +66,8 @@ static struct hid_report *hid_register_report(struct hid_device *device, unsigne
if (report_enum->report_id_hash[id]) if (report_enum->report_id_hash[id])
return report_enum->report_id_hash[id]; return report_enum->report_id_hash[id];
if (!(report = kmalloc(sizeof(struct hid_report), GFP_KERNEL))) if (!(report = kzalloc(sizeof(struct hid_report), GFP_KERNEL)))
return NULL; return NULL;
memset(report, 0, sizeof(struct hid_report));
if (id != 0) if (id != 0)
report_enum->numbered = 1; report_enum->numbered = 1;
@ -97,12 +96,9 @@ static struct hid_field *hid_register_field(struct hid_report *report, unsigned
return NULL; return NULL;
} }
if (!(field = kmalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage) if (!(field = kzalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
+ values * sizeof(unsigned), GFP_KERNEL))) return NULL; + values * sizeof(unsigned), GFP_KERNEL))) return NULL;
memset(field, 0, sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
+ values * sizeof(unsigned));
field->index = report->maxfield++; field->index = report->maxfield++;
report->field[field->index] = field; report->field[field->index] = field;
field->usage = (struct hid_usage *)(field + 1); field->usage = (struct hid_usage *)(field + 1);
@ -651,17 +647,14 @@ static struct hid_device *hid_parse_report(__u8 *start, unsigned size)
hid_parser_reserved hid_parser_reserved
}; };
if (!(device = kmalloc(sizeof(struct hid_device), GFP_KERNEL))) if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
return NULL; return NULL;
memset(device, 0, sizeof(struct hid_device));
if (!(device->collection = kmalloc(sizeof(struct hid_collection) * if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) { HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) {
kfree(device); kfree(device);
return NULL; return NULL;
} }
memset(device->collection, 0, sizeof(struct hid_collection) *
HID_DEFAULT_NUM_COLLECTIONS);
device->collection_size = HID_DEFAULT_NUM_COLLECTIONS; device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
for (i = 0; i < HID_REPORT_TYPES; i++) for (i = 0; i < HID_REPORT_TYPES; i++)
@ -675,13 +668,12 @@ static struct hid_device *hid_parse_report(__u8 *start, unsigned size)
memcpy(device->rdesc, start, size); memcpy(device->rdesc, start, size);
device->rsize = size; device->rsize = size;
if (!(parser = kmalloc(sizeof(struct hid_parser), GFP_KERNEL))) { if (!(parser = kzalloc(sizeof(struct hid_parser), GFP_KERNEL))) {
kfree(device->rdesc); kfree(device->rdesc);
kfree(device->collection); kfree(device->collection);
kfree(device); kfree(device);
return NULL; return NULL;
} }
memset(parser, 0, sizeof(struct hid_parser));
parser->device = device; parser->device = device;
end = start + size; end = start + size;

6
drivers/usb/input/hid-lgff.c
View file

@ -154,10 +154,9 @@ int hid_lgff_init(struct hid_device* hid)
return -1; return -1;
} }
private = kmalloc(sizeof(struct lgff_device), GFP_KERNEL); private = kzalloc(sizeof(struct lgff_device), GFP_KERNEL);
if (!private) if (!private)
return -1; return -1;
memset(private, 0, sizeof(struct lgff_device));
hid->ff_private = private; hid->ff_private = private;
/* Input init */ /* Input init */
@ -228,13 +227,12 @@ static struct hid_report* hid_lgff_duplicate_report(struct hid_report* report)
} }
*ret->field[0] = *report->field[0]; *ret->field[0] = *report->field[0];
ret->field[0]->value = kmalloc(sizeof(s32[8]), GFP_KERNEL); ret->field[0]->value = kzalloc(sizeof(s32[8]), GFP_KERNEL);
if (!ret->field[0]->value) { if (!ret->field[0]->value) {
kfree(ret->field[0]); kfree(ret->field[0]);
kfree(ret); kfree(ret);
return NULL; return NULL;
} }
memset(ret->field[0]->value, 0, sizeof(s32[8]));
return ret; return ret;
} }

3
drivers/usb/input/hid-tmff.c
View file

@ -113,11 +113,10 @@ int hid_tmff_init(struct hid_device *hid)
struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
struct input_dev *input_dev = hidinput->input; struct input_dev *input_dev = hidinput->input;
private = kmalloc(sizeof(struct tmff_device), GFP_KERNEL); private = kzalloc(sizeof(struct tmff_device), GFP_KERNEL);
if (!private) if (!private)
return -ENOMEM; return -ENOMEM;
memset(private, 0, sizeof(struct tmff_device));
hid->ff_private = private; hid->ff_private = private;
/* Find the report to use */ /* Find the report to use */

6
drivers/usb/input/hiddev.c
View file

@ -257,9 +257,8 @@ static int hiddev_open(struct inode * inode, struct file * file) {
if (i >= HIDDEV_MINORS || !hiddev_table[i]) if (i >= HIDDEV_MINORS || !hiddev_table[i])
return -ENODEV; return -ENODEV;
if (!(list = kmalloc(sizeof(struct hiddev_list), GFP_KERNEL))) if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
return -ENOMEM; return -ENOMEM;
memset(list, 0, sizeof(struct hiddev_list));
list->hiddev = hiddev_table[i]; list->hiddev = hiddev_table[i];
list->next = hiddev_table[i]->list; list->next = hiddev_table[i]->list;
@ -754,9 +753,8 @@ int hiddev_connect(struct hid_device *hid)
if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDDEV) == 0) if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDDEV) == 0)
return -1; return -1;
if (!(hiddev = kmalloc(sizeof(struct hiddev), GFP_KERNEL))) if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
return -1; return -1;
memset(hiddev, 0, sizeof(struct hiddev));
retval = usb_register_dev(hid->intf, &hiddev_class); retval = usb_register_dev(hid->intf, &hiddev_class);
if (retval) { if (retval) {