if (ignore || (intf->cur_altsetting->desc.bInterfaceNumber != 0))
                return -ENODEV;
 
-       data = kmalloc(sizeof(*data), GFP_KERNEL);
+       data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (!data) {
                BT_ERR("Can't allocate memory for data structure");
                return -ENOMEM;
        }
 
-       memset(data, 0, sizeof(*data));
-
        data->udev  = udev;
        data->state = BCM203X_LOAD_MINIDRV;
 
 
        }
 
        /* Initialize control structure and load firmware */
-       if (!(bfusb = kmalloc(sizeof(struct bfusb), GFP_KERNEL))) {
+       if (!(bfusb = kzalloc(sizeof(struct bfusb), GFP_KERNEL))) {
                BT_ERR("Can't allocate memory for control structure");
                goto done;
        }
 
-       memset(bfusb, 0, sizeof(struct bfusb));
-
        bfusb->udev = udev;
        bfusb->bulk_in_ep    = bulk_in_ep->desc.bEndpointAddress;
        bfusb->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;
 
        int ret;
 
        /* Create new info device */
-       info = kmalloc(sizeof(*info), GFP_KERNEL);
+       info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
                return NULL;
-       memset(info, 0, sizeof(*info));
 
        link = &info->link;
        link->priv = info;
 
        if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
                return -ENODEV;
 
-       data = kmalloc(sizeof(*data), GFP_KERNEL);
+       data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (!data) {
                BT_ERR("Can't allocate data structure");
                return -ENOMEM;
        }
 
-       memset(data, 0, sizeof(*data));
-
        data->udev = udev;
 
        rwlock_init(&data->lock);
 
        int ret;
 
        /* Create new info device */
-       info = kmalloc(sizeof(*info), GFP_KERNEL);
+       info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
                return NULL;
-       memset(info, 0, sizeof(*info));
 
        link = &info->link;
        link->priv = info;
 
        int ret;
 
        /* Create new info device */
-       info = kmalloc(sizeof(*info), GFP_KERNEL);
+       info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
                return NULL;
-       memset(info, 0, sizeof(*info));
 
        link = &info->link;
        link->priv = info;
 
        int ret;
 
        /* Create new info device */
-       info = kmalloc(sizeof(*info), GFP_KERNEL);
+       info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
                return NULL;
-       memset(info, 0, sizeof(*info));
 
        link = &info->link;
        link->priv = info;
 
 
        BT_DBG("hu %p", hu);
 
-       bcsp = kmalloc(sizeof(*bcsp), GFP_ATOMIC);
+       bcsp = kzalloc(sizeof(*bcsp), GFP_ATOMIC);
        if (!bcsp)
                return -ENOMEM;
-       memset(bcsp, 0, sizeof(*bcsp));
 
        hu->priv = bcsp;
        skb_queue_head_init(&bcsp->unack);
 
 
        BT_DBG("hu %p", hu);
 
-       h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
+       h4 = kzalloc(sizeof(*h4), GFP_ATOMIC);
        if (!h4)
                return -ENOMEM;
 
-       memset(h4, 0, sizeof(*h4));
-
        skb_queue_head_init(&h4->txq);
 
        hu->priv = h4;
 
        if (hu)
                return -EEXIST;
 
-       if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
+       if (!(hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
                BT_ERR("Can't allocate controll structure");
                return -ENFILE;
        }
 
-       memset(hu, 0, sizeof(struct hci_uart));
-
        tty->disc_data = hu;
        hu->tty = tty;
 
 
                goto done;
        }
 
-       if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
+       if (!(husb = kzalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
                BT_ERR("Can't allocate: control structure");
                goto done;
        }
 
-       memset(husb, 0, sizeof(struct hci_usb));
-
        husb->udev = udev;
        husb->bulk_out_ep = bulk_out_ep;
        husb->bulk_in_ep  = bulk_in_ep;
 
        struct vhci_data *vhci;
        struct hci_dev *hdev;
 
-       vhci = kmalloc(sizeof(struct vhci_data), GFP_KERNEL);
+       vhci = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
        if (!vhci)
                return -ENOMEM;
 
-       memset(vhci, 0, sizeof(struct vhci_data));
-
        skb_queue_head_init(&vhci->readq);
        init_waitqueue_head(&vhci->read_wait);