This is the drivers/mtd part of the big kfree cleanup patch.
Remove pointless checks for NULL prior to calling kfree() in drivers/mtd/.
Signed-off-by: Jesper Juhl <jesper.juhl@gmail.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Acked-by: Joern Engel <joern@wohnheim.fh-wedel.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
 
  setup_err:
        if(mtd) {
-               if(mtd->eraseregions)
-                       kfree(mtd->eraseregions);
+               kfree(mtd->eraseregions);
                kfree(mtd);
        }
        kfree(cfi->cmdset_priv);
 
 
  setup_err:
        if(mtd) {
-               if(mtd->eraseregions)
-                       kfree(mtd->eraseregions);
+               kfree(mtd->eraseregions);
                kfree(mtd);
        }
        kfree(cfi->cmdset_priv);
 {
        struct map_info *map = mtd->priv;
        struct cfi_private *cfi = map->fldrv_priv;
+
        kfree(cfi->cmdset_priv);
        kfree(cfi->cfiq);
        kfree(cfi);
 
 {
        DEBUG(2, "blkmtd: free_device() dev = %p\n", dev);
        if(dev) {
-               if(dev->mtd_info.eraseregions)
-                       kfree(dev->mtd_info.eraseregions);
-               if(dev->mtd_info.name)
-                       kfree(dev->mtd_info.name);
-
+               kfree(dev->mtd_info.eraseregions);
+               kfree(dev->mtd_info.name);
                if(dev->blkdev) {
                        invalidate_inode_pages(dev->blkdev->bd_inode->i_mapping);
                        close_bdev_excl(dev->blkdev);
 
        }
 
        if (add_mtd_blktrans_dev(&inftl->mbd)) {
-               if (inftl->PUtable)
-                       kfree(inftl->PUtable);
-               if (inftl->VUtable)
-                       kfree(inftl->VUtable);
+               kfree(inftl->PUtable);
+               kfree(inftl->VUtable);
                kfree(inftl);
                return;
        }
 
        del_mtd_blktrans_dev(dev);
 
-       if (inftl->PUtable)
-               kfree(inftl->PUtable);
-       if (inftl->VUtable)
-               kfree(inftl->VUtable);
+       kfree(inftl->PUtable);
+       kfree(inftl->VUtable);
        kfree(inftl);
 }
 
 
 
  out:
        /* Free any left over map structures */
-       if (map) {
-               kfree(map);
-       }
+       kfree(map);
        /* See if I have any map structures */
        if (list_empty(&window->maps)) {
                amd76xrom_cleanup(window);
 
                map_destroy(info->mtd);
        }
 
-       if (info->partitions)
-               kfree(info->partitions);
+       kfree(info->partitions);
 
        if (info->area) {
                release_resource(info->area);
 
 
 static void __exit clps_destroy_partitions(void)
 {
-       if (parsed_parts)
-               kfree(parsed_parts);
+       kfree(parsed_parts);
 }
 
 static struct mtd_info *mymtd;
 
 
  out:
        /* Free any left over map structures */
-       if (map) {
-               kfree(map);
-       }
+       kfree(map);
+
        /* See if I have any map structures */
        if (list_empty(&window->maps)) {
                ichxrom_cleanup(window);
 
                        del_mtd_partitions(info->mtd);
                        map_destroy(info->mtd);
                }
-               if (info->parts)
-                       kfree(info->parts);
+               kfree(info->parts);
 
  no_device:
                iounmap(base);
                        del_mtd_partitions(info->mtd);
                        map_destroy(info->mtd);
                }
-               if (info->parts)
-                       kfree(info->parts);
+               kfree(info->parts);
 
                iounmap(info->map.virt);
                release_resource(info->res);
 
                                if (my_sub_mtd[i])
                                        map_destroy(my_sub_mtd[i]);
                        }
-               if (parsed_parts)
-                       kfree(parsed_parts);
+               kfree(parsed_parts);
        }
 }
 
 
        if (mymtd) {
                del_mtd_partitions(mymtd);
                map_destroy(mymtd);
-               if (parsed_parts)
-                       kfree(parsed_parts);
+               kfree(parsed_parts);
        }
        if (iq80310_map.virt)
                iounmap((void *)iq80310_map.virt);
 
        if (info->map.map_priv_1)
                iounmap((void *) info->map.map_priv_1);
 
-       if (info->partitions) {
-               kfree(info->partitions); }
+       kfree(info->partitions);
 
        if (info->res) {
                release_resource(info->res);
 
        if (info->map.map_priv_1)
                iounmap((void *) info->map.map_priv_1);
 
-       if (info->partitions)
-               kfree(info->partitions);
+       kfree(info->partitions);
 
        if (info->res) {
                release_resource(info->res);
 
                if (lubbock_maps[i].cached)
                        iounmap(lubbock_maps[i].cached);
 
-               if (parsed_parts[i])
-                       kfree(parsed_parts[i]);
+               kfree(parsed_parts[i]);
        }
 }
 
 
        if (flash_mtd) {
                del_mtd_partitions(flash_mtd);
                map_destroy(flash_mtd);
-               if (parsed_parts)
-                       kfree(parsed_parts);
+               kfree(parsed_parts);
        }
 }
 
 
 #endif
        }
 
-       if (info->parts)
-               kfree(info->parts);
+       kfree(info->parts);
 
        for (i = info->num_subdev - 1; i >= 0; i--)
                sa1100_destroy_subdev(&info->subdev[i]);
 
                        iounmap(udev->map.virt);
                        udev->map.virt = NULL;
                }
-               if(0 != udev->name) {
-                       kfree(udev->name);
-               }
+               kfree(udev->name);
                kfree(udev);
        }       
 }
 
 error_mem:
        for(idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
                if(map_banks[idx] != NULL) {
-                       if(map_banks[idx]->name != NULL) {
-                               kfree(map_banks[idx]->name);
-                               map_banks[idx]->name = NULL;
-                       }
+                       kfree(map_banks[idx]->name);
+                       map_banks[idx]->name = NULL;
                        kfree(map_banks[idx]);
                        map_banks[idx] = NULL;
                }
 
        /* Deregister the device */
        del_mtd_device (mtd);
 
-       /* Free bad block table memory, if allocated */
-       if (this->bbt)
-               kfree (this->bbt);
+       /* Free bad block table memory */
+       kfree (this->bbt);
        /* Buffer allocated by nand_scan ? */
        if (this->options & NAND_OOBBUF_ALLOC)
                kfree (this->oob_buf);
 
        }
 
        if (add_mtd_blktrans_dev(&nftl->mbd)) {
-               if (nftl->ReplUnitTable)
-                       kfree(nftl->ReplUnitTable);
-               if (nftl->EUNtable)
-                       kfree(nftl->EUNtable);
+               kfree(nftl->ReplUnitTable);
+               kfree(nftl->EUNtable);
                kfree(nftl);
                return;
        }
        DEBUG(MTD_DEBUG_LEVEL1, "NFTL: remove_dev (i=%d)\n", dev->devnum);
 
        del_mtd_blktrans_dev(dev);
-       if (nftl->ReplUnitTable)
-               kfree(nftl->ReplUnitTable);
-       if (nftl->EUNtable)
-               kfree(nftl->EUNtable);
+       kfree(nftl->ReplUnitTable);
+       kfree(nftl->EUNtable);
        kfree(nftl);
 }