remove ioremap_nocache and devm_ioremap_nocache

  devm_ioport_map()

  devm_ioport_unmap()

  devm_ioremap()

  devm_ioremap_nocache()

  devm_ioremap_uc()

  devm_ioremap_wc()

  devm_ioremap_resource() : checks resource, requests memory region, ioremaps

          return err;

  }

  chip->iobase_phys = pci_resource_start(pci, 0);

  chip->iobase_virt = ioremap_nocache(chip->iobase_phys,

  chip->iobase_virt = ioremap(chip->iobase_phys,

                                      pci_resource_len(pci, 0));

and the corresponding destructor would be:

+------------------------+----------+--------------+------------------+

| ioremap_uc             |    --    |    UC        |       UC         |

+------------------------+----------+--------------+------------------+

| ioremap_nocache        |    --    |    UC-       |       UC-        |

+------------------------+----------+--------------+------------------+

| ioremap_wc             |    --    |    --        |       WC         |

+------------------------+----------+--------------+------------------+

| ioremap_wt             |    --    |    --        |       WT         |

	return IO_CONCAT(__IO_PREFIX,ioremap) (port, size);

}

static inline void __iomem * ioremap_nocache(unsigned long offset,

					     unsigned long size)

{

	return ioremap(offset, size);

}

#define ioremap_wc ioremap_nocache

#define ioremap_uc ioremap_nocache

#define ioremap_wc ioremap

#define ioremap_uc ioremap

static inline void iounmap(volatile void __iomem *addr)

{

 *

 * Function		Memory type	Cacheability	Cache hint

 * ioremap()		Device		n/a		n/a

 * ioremap_nocache()	Device		n/a		n/a

 * ioremap_cache()	Normal		Writeback	Read allocate

 * ioremap_wc()		Normal		Non-cacheable	n/a

 * ioremap_wt()		Normal		Non-cacheable	n/a

 * - unaligned accesses are "unpredictable"

 * - writes may be delayed before they hit the endpoint device

 *

 * ioremap_nocache() is the same as ioremap() as there are too many device

 * drivers using this for device registers, and documentation which tells

 * people to use it for such for this to be any different.  This is not a

 * safe fallback for memory-like mappings, or memory regions where the

 * compiler may generate unaligned accesses - eg, via inlining its own

 * memcpy.

 *

 * All normal memory mappings have the following properties:

 * - reads can be repeated with no side effects

 * - repeated reads return the last value written