struct pvr2_msp3400_handler *ctxt;
        if (cp->handler) return 0;
 
-       ctxt = kmalloc(sizeof(*ctxt),GFP_KERNEL);
+       ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
        if (!ctxt) return 0;
-       memset(ctxt,0,sizeof(*ctxt));
 
        ctxt->i2c_handler.func_data = ctxt;
        ctxt->i2c_handler.func_table = &msp3400_funcs;
 
        void (*setup_func)(struct pvr2_context *))
 {
        struct pvr2_context *mp = NULL;
-       mp = kmalloc(sizeof(*mp),GFP_KERNEL);
+       mp = kzalloc(sizeof(*mp),GFP_KERNEL);
        if (!mp) goto done;
-       memset(mp,0,sizeof(*mp));
        pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_main id=%p",mp);
        mp->setup_func = setup_func;
        mutex_init(&mp->mutex);
 
        if (cp->handler) return 0;
        if (!decoder_detect(cp)) return 0;
 
-       ctxt = kmalloc(sizeof(*ctxt),GFP_KERNEL);
+       ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
        if (!ctxt) return 0;
-       memset(ctxt,0,sizeof(*ctxt));
 
        ctxt->handler.func_data = ctxt;
        ctxt->handler.func_table = &hfuncs;
 
                return NULL;
        }
 
-       hdw = kmalloc(sizeof(*hdw),GFP_KERNEL);
+       hdw = kzalloc(sizeof(*hdw),GFP_KERNEL);
        pvr2_trace(PVR2_TRACE_INIT,"pvr2_hdw_create: hdw=%p, type \"%s\"",
                   hdw,pvr2_device_names[hdw_type]);
        if (!hdw) goto fail;
-       memset(hdw,0,sizeof(*hdw));
        hdw->tuner_signal_stale = !0;
        cx2341x_fill_defaults(&hdw->enc_ctl_state);
 
        hdw->control_cnt = CTRLDEF_COUNT;
        hdw->control_cnt += MPEGDEF_COUNT;
-       hdw->controls = kmalloc(sizeof(struct pvr2_ctrl) * hdw->control_cnt,
+       hdw->controls = kzalloc(sizeof(struct pvr2_ctrl) * hdw->control_cnt,
                                GFP_KERNEL);
        if (!hdw->controls) goto fail;
-       memset(hdw->controls,0,sizeof(struct pvr2_ctrl) * hdw->control_cnt);
        hdw->hdw_type = hdw_type;
        for (idx = 0; idx < hdw->control_cnt; idx++) {
                cptr = hdw->controls + idx;
                cptr->info = control_defs+idx;
        }
        /* Define and configure additional controls from cx2341x module. */
-       hdw->mpeg_ctrl_info = kmalloc(
+       hdw->mpeg_ctrl_info = kzalloc(
                sizeof(*(hdw->mpeg_ctrl_info)) * MPEGDEF_COUNT, GFP_KERNEL);
        if (!hdw->mpeg_ctrl_info) goto fail;
-       memset(hdw->mpeg_ctrl_info,0,
-              sizeof(*(hdw->mpeg_ctrl_info)) * MPEGDEF_COUNT);
        for (idx = 0; idx < MPEGDEF_COUNT; idx++) {
                cptr = hdw->controls + idx + CTRLDEF_COUNT;
                ciptr = &(hdw->mpeg_ctrl_info[idx].info);
                pvr2_trace(PVR2_TRACE_FIRMWARE,
                           "Preparing to suck out CPU firmware");
                hdw->fw_size = 0x2000;
-               hdw->fw_buffer = kmalloc(hdw->fw_size,GFP_KERNEL);
+               hdw->fw_buffer = kzalloc(hdw->fw_size,GFP_KERNEL);
                if (!hdw->fw_buffer) {
                        hdw->fw_size = 0;
                        break;
                }
 
-               memset(hdw->fw_buffer,0,hdw->fw_size);
-
                /* We have to hold the CPU during firmware upload. */
                pvr2_hdw_cpureset_assert(hdw,1);
 
 
        struct pvr2_hdw *hdw = (struct pvr2_hdw *)(client->adapter->algo_data);
        struct pvr2_i2c_client *cp;
        int fl = !(hdw->i2c_pend_types & PVR2_I2C_PEND_ALL);
-       cp = kmalloc(sizeof(*cp),GFP_KERNEL);
+       cp = kzalloc(sizeof(*cp),GFP_KERNEL);
        trace_i2c("i2c_attach [client=%s @ 0x%x ctxt=%p]",
                  client->name,
                  client->addr,cp);
        if (!cp) return -ENOMEM;
-       memset(cp,0,sizeof(*cp));
        cp->hdw = hdw;
        INIT_LIST_HEAD(&cp->list);
        cp->client = client;
 
 struct pvr2_stream *pvr2_stream_create(void)
 {
        struct pvr2_stream *sp;
-       sp = kmalloc(sizeof(*sp),GFP_KERNEL);
+       sp = kzalloc(sizeof(*sp),GFP_KERNEL);
        if (!sp) return sp;
-       memset(sp,0,sizeof(*sp));
        pvr2_trace(PVR2_TRACE_INIT,"pvr2_stream_create: sp=%p",sp);
        pvr2_stream_init(sp);
        return sp;
 
 struct pvr2_ioread *pvr2_ioread_create(void)
 {
        struct pvr2_ioread *cp;
-       cp = kmalloc(sizeof(*cp),GFP_KERNEL);
+       cp = kzalloc(sizeof(*cp),GFP_KERNEL);
        if (!cp) return NULL;
        pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp);
-       memset(cp,0,sizeof(*cp));
        if (pvr2_ioread_init(cp) < 0) {
                kfree(cp);
                return NULL;
 
                   std_cnt);
        if (!std_cnt) return NULL; // paranoia
 
-       stddefs = kmalloc(sizeof(struct v4l2_standard) * std_cnt,
+       stddefs = kzalloc(sizeof(struct v4l2_standard) * std_cnt,
                          GFP_KERNEL);
-       memset(stddefs,0,sizeof(struct v4l2_standard) * std_cnt);
        for (idx = 0; idx < std_cnt; idx++) stddefs[idx].index = idx;
 
        idx = 0;
 
        cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,ctl_id);
        if (!cptr) return;
 
-       cip = kmalloc(sizeof(*cip),GFP_KERNEL);
+       cip = kzalloc(sizeof(*cip),GFP_KERNEL);
        if (!cip) return;
-       memset(cip,0,sizeof(*cip));
        pvr2_sysfs_trace("Creating pvr2_sysfs_ctl_item id=%p",cip);
 
        cip->cptr = cptr;
        struct pvr2_sysfs_debugifc *dip;
        int ret;
 
-       dip = kmalloc(sizeof(*dip),GFP_KERNEL);
+       dip = kzalloc(sizeof(*dip),GFP_KERNEL);
        if (!dip) return;
-       memset(dip,0,sizeof(*dip));
        dip->attr_debugcmd.attr.owner = THIS_MODULE;
        dip->attr_debugcmd.attr.name = "debugcmd";
        dip->attr_debugcmd.attr.mode = S_IRUGO|S_IWUSR|S_IWGRP;
 
        usb_dev = pvr2_hdw_get_dev(sfp->channel.hdw);
        if (!usb_dev) return;
-       class_dev = kmalloc(sizeof(*class_dev),GFP_KERNEL);
+       class_dev = kzalloc(sizeof(*class_dev),GFP_KERNEL);
        if (!class_dev) return;
-       memset(class_dev,0,sizeof(*class_dev));
 
        pvr2_sysfs_trace("Creating class_dev id=%p",class_dev);
 
                                     struct pvr2_sysfs_class *class_ptr)
 {
        struct pvr2_sysfs *sfp;
-       sfp = kmalloc(sizeof(*sfp),GFP_KERNEL);
+       sfp = kzalloc(sizeof(*sfp),GFP_KERNEL);
        if (!sfp) return sfp;
-       memset(sfp,0,sizeof(*sfp));
        pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_sysfs id=%p",sfp);
        pvr2_channel_init(&sfp->channel,mp);
        sfp->channel.check_func = pvr2_sysfs_internal_check;
 struct pvr2_sysfs_class *pvr2_sysfs_class_create(void)
 {
        struct pvr2_sysfs_class *clp;
-       clp = kmalloc(sizeof(*clp),GFP_KERNEL);
+       clp = kzalloc(sizeof(*clp),GFP_KERNEL);
        if (!clp) return clp;
-       memset(clp,0,sizeof(*clp));
        pvr2_sysfs_trace("Creating pvr2_sysfs_class id=%p",clp);
        clp->class.name = "pvrusb2";
        clp->class.class_release = pvr2_sysfs_class_release;
 
        struct pvr2_tuner_handler *ctxt;
        if (cp->handler) return 0;
 
-       ctxt = kmalloc(sizeof(*ctxt),GFP_KERNEL);
+       ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
        if (!ctxt) return 0;
-       memset(ctxt,0,sizeof(*ctxt));
 
        ctxt->i2c_handler.func_data = ctxt;
        ctxt->i2c_handler.func_table = &tuner_funcs;
 
        if (cp->handler) return 0;
        if (!decoder_detect(cp)) return 0;
 
-       ctxt = kmalloc(sizeof(*ctxt),GFP_KERNEL);
+       ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
        if (!ctxt) return 0;
-       memset(ctxt,0,sizeof(*ctxt));
 
        ctxt->handler.func_data = ctxt;
        ctxt->handler.func_table = &hfuncs;
 
 
        if (cp->handler) return 0;
 
-       ctxt = kmalloc(sizeof(*ctxt),GFP_KERNEL);
+       ctxt = kzalloc(sizeof(*ctxt),GFP_KERNEL);
        if (!ctxt) return 0;
-       memset(ctxt,0,sizeof(*ctxt));
 
        ctxt->handler.func_data = ctxt;
        ctxt->handler.func_table = &hfuncs;