The iounmap() function performs also input parameter validation.
Thus the test around the call is not needed.
This issue was detected by using the Coccinelle software.
Signed-off-by: Markus Elfring <elfring@users.sourceforge.net>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
        int i;
 
        i2sdev = container_of(dev, struct i2sbus_dev, sound.ofdev.dev);
-
-       if (i2sdev->intfregs) iounmap(i2sdev->intfregs);
-       if (i2sdev->out.dbdma) iounmap(i2sdev->out.dbdma);
-       if (i2sdev->in.dbdma) iounmap(i2sdev->in.dbdma);
+       iounmap(i2sdev->intfregs);
+       iounmap(i2sdev->out.dbdma);
+       iounmap(i2sdev->in.dbdma);
        for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++)
                release_and_free_resource(i2sdev->allocated_resource[i]);
        free_dbdma_descriptor_ring(i2sdev, &i2sdev->out.dbdma_ring);
                        free_irq(dev->interrupts[i], dev);
        free_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring);
        free_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring);
-       if (dev->intfregs) iounmap(dev->intfregs);
-       if (dev->out.dbdma) iounmap(dev->out.dbdma);
-       if (dev->in.dbdma) iounmap(dev->in.dbdma);
+       iounmap(dev->intfregs);
+       iounmap(dev->out.dbdma);
+       iounmap(dev->in.dbdma);
        for (i=0;i<3;i++)
                release_and_free_resource(dev->allocated_resource[i]);
        mutex_destroy(&dev->lock);
 
 static void aaci_free_card(struct snd_card *card)
 {
        struct aaci *aaci = card->private_data;
-       if (aaci->base)
-               iounmap(aaci->base);
+
+       iounmap(aaci->base);
 }
 
 static struct aaci *aaci_init_card(struct amba_device *dev)
 
        if (ml403_ac97cr->capture_irq >= 0)
                free_irq(ml403_ac97cr->capture_irq, ml403_ac97cr);
        /* give back "port" */
-       if (ml403_ac97cr->port != NULL)
-               iounmap(ml403_ac97cr->port);
+       iounmap(ml403_ac97cr->port);
        kfree(ml403_ac97cr);
        PDEBUG(INIT_INFO, "free(): (done)\n");
        return 0;
 
        return 0;
 
 err_release_region:
-       if (chip->mappedbase)
-               iounmap(chip->mappedbase);
+       iounmap(chip->mappedbase);
        release_mem_region(chip->base, BUFFSIZE);
        release_region(chip->io, DSP_NUMIO);
        free_irq(chip->irq, chip);
 
        if (h->irq >= 0)
                free_irq(h->irq, h);
 
-       if (h->iobase)
-               iounmap(h->iobase);
-
+       iounmap(h->iobase);
        kfree(h);
        return 0;
 }
 
                free_irq(chip->irq, chip);
 
 skip_hw:
-       if (chip->iobase)
-               iounmap(chip->iobase);
-
+       iounmap(chip->iobase);
        pci_release_regions(chip->pci);
        pci_disable_device(chip->pci);
-
        kfree(chip);
        return 0;
 }
 
        hpi_send_recv_ex(&hm, &hr, HOWNER_KERNEL);
 
        /* unmap PCI memory space, mapped during device init. */
-       for (idx = 0; idx < HPI_MAX_ADAPTER_MEM_SPACES; idx++) {
-               if (pci.ap_mem_base[idx])
-                       iounmap(pci.ap_mem_base[idx]);
-       }
+       for (idx = 0; idx < HPI_MAX_ADAPTER_MEM_SPACES; ++idx)
+               iounmap(pci.ap_mem_base[idx]);
 
        if (pa->irq)
                free_irq(pa->irq, pa);
 
       __hw_end:
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
-       if (chip->remap_addr)
-               iounmap(chip->remap_addr);
+       iounmap(chip->remap_addr);
        pci_release_regions(chip->pci);
        pci_disable_device(chip->pci);
        kfree(chip);
 
       __hw_end:
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
-       if (chip->remap_addr)
-               iounmap(chip->remap_addr);
+       iounmap(chip->remap_addr);
        pci_release_regions(chip->pci);
        pci_disable_device(chip->pci);
        kfree(chip);
 
        if (chip->irq >= 0)
                free_irq(chip->irq, (void *)chip);
        /* release the i/o ports & memory */
-       if (chip->iobase_virt)
-               iounmap(chip->iobase_virt);
-
+       iounmap(chip->iobase_virt);
        pci_release_regions(chip->pci);
        /* disable the PCI entry */
        pci_disable_device(chip->pci);
 
                snd_bt87x_stop(chip);
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
-       if (chip->mmio)
-               iounmap(chip->mmio);
+       iounmap(chip->mmio);
        pci_release_regions(chip->pci);
        pci_disable_device(chip->pci);
        kfree(chip);
 
 
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
-       if (chip->ba0)
-               iounmap(chip->ba0);
-       if (chip->ba1)
-               iounmap(chip->ba1);
+       iounmap(chip->ba0);
+       iounmap(chip->ba1);
        pci_release_regions(chip->pci);
        pci_disable_device(chip->pci);
 
 
 
        for (idx = 0; idx < 5; idx++) {
                struct snd_cs46xx_region *region = &chip->region.idx[idx];
-               if (region->remap_addr)
-                       iounmap(region->remap_addr);
+
+               iounmap(region->remap_addr);
                release_and_free_resource(region->resource);
        }
 
 
                free_irq(hw->irq, hw);
 
        hw->irq = -1;
-
-       if (hw->mem_base)
-               iounmap(hw->mem_base);
-
+       iounmap(hw->mem_base);
        hw->mem_base = NULL;
 
        if (hw->io_base)
 
                free_irq(hw->irq, hw);
 
        hw->irq = -1;
-
-       if (hw->mem_base)
-               iounmap(hw->mem_base);
-
+       iounmap(hw->mem_base);
        hw->mem_base = NULL;
 
        if (hw->io_base)
 
        if (chip->comm_page)
                snd_dma_free_pages(&chip->commpage_dma_buf);
 
-       if (chip->dsp_registers)
-               iounmap(chip->dsp_registers);
-
+       iounmap(chip->dsp_registers);
        release_and_free_resource(chip->iores);
-
-
        pci_disable_device(chip->pci);
 
        /* release chip data */
 
                free_irq(chip->irq, (void*)chip);
        if (chip->msi)
                pci_disable_msi(chip->pci);
-       if (chip->remap_addr)
-               iounmap(chip->remap_addr);
+       iounmap(chip->remap_addr);
 
        azx_free_stream_pages(chip);
        if (chip->region_requested)
 
        lola_free_mixer(chip);
        if (chip->irq >= 0)
                free_irq(chip->irq, (void *)chip);
-       if (chip->bar[0].remap_addr)
-               iounmap(chip->bar[0].remap_addr);
-       if (chip->bar[1].remap_addr)
-               iounmap(chip->bar[1].remap_addr);
+       iounmap(chip->bar[0].remap_addr);
+       iounmap(chip->bar[1].remap_addr);
        if (chip->rb.area)
                snd_dma_free_pages(&chip->rb);
        pci_release_regions(chip->pci);
 
        }
 
        /* release the i/o ports */
-       for (i = 0; i < 2; i++) {
-               if (mgr->mem[i].virt)
-                       iounmap(mgr->mem[i].virt);
-       }
+       for (i = 0; i < 2; ++i)
+               iounmap(mgr->mem[i].virt);
+
        pci_release_regions(mgr->pci);
 
        /* free flowarray */
 
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
 
-       if (chip->cport)
-               iounmap(chip->cport);
-       if (chip->buffer)
-               iounmap(chip->buffer);
+       iounmap(chip->cport);
+       iounmap(chip->buffer);
        release_and_free_resource(chip->res_cport);
        release_and_free_resource(chip->res_buffer);
 
 
 
        release_firmware(hdsp->firmware);
        vfree(hdsp->fw_uploaded);
-
-       if (hdsp->iobase)
-               iounmap(hdsp->iobase);
+       iounmap(hdsp->iobase);
 
        if (hdsp->port)
                pci_release_regions(hdsp->pci);
 
                free_irq(hdspm->irq, (void *) hdspm);
 
        kfree(hdspm->mixer);
-
-       if (hdspm->iobase)
-               iounmap(hdspm->iobase);
+       iounmap(hdspm->iobase);
 
        if (hdspm->port)
                pci_release_regions(hdspm->pci);
 
 
        if (rme9652->irq >= 0)
                free_irq(rme9652->irq, (void *)rme9652);
-       if (rme9652->iobase)
-               iounmap(rme9652->iobase);
+       iounmap(rme9652->iobase);
        if (rme9652->port)
                pci_release_regions(rme9652->pci);
 
 
        if (sis->irq >= 0)
                free_irq(sis->irq, sis);
 
-       if (sis->ioaddr)
-               iounmap(sis->ioaddr);
-
+       iounmap(sis->ioaddr);
        pci_release_regions(sis->pci);
        pci_disable_device(sis->pci);
-
        sis_free_suspend(sis);
        return 0;
 }
 
        release_and_free_resource(chip->mpu_res);
        release_and_free_resource(chip->fm_res);
        snd_ymfpci_free_gameport(chip);
-       if (chip->reg_area_virt)
-               iounmap(chip->reg_area_virt);
+       iounmap(chip->reg_area_virt);
        if (chip->work_ptr.area)
                snd_dma_free_pages(&chip->work_ptr);
        
 
        snd_pmac_dbdma_free(chip, &chip->capture.cmd);
        snd_pmac_dbdma_free(chip, &chip->extra_dma);
        snd_pmac_dbdma_free(chip, &emergency_dbdma);
-       if (chip->macio_base)
-               iounmap(chip->macio_base);
-       if (chip->latch_base)
-               iounmap(chip->latch_base);
-       if (chip->awacs)
-               iounmap(chip->awacs);
-       if (chip->playback.dma)
-               iounmap(chip->playback.dma);
-       if (chip->capture.dma)
-               iounmap(chip->capture.dma);
+       iounmap(chip->macio_base);
+       iounmap(chip->latch_base);
+       iounmap(chip->awacs);
+       iounmap(chip->playback.dma);
+       iounmap(chip->capture.dma);
 
        if (chip->node) {
                int i;