Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Thierry Reding | f4a1831 | 2013-01-22 22:24:46 +0100 | [diff] [blame] | 2 | #include <linux/err.h> |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 3 | #include <linux/pci.h> |
| 4 | #include <linux/io.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 5 | #include <linux/gfp.h> |
Paul Gortmaker | 8bc3bcc | 2011-11-16 21:29:17 -0500 | [diff] [blame] | 6 | #include <linux/export.h> |
Benjamin Herrenschmidt | d5e8382 | 2018-06-05 13:21:26 +1000 | [diff] [blame] | 7 | #include <linux/of_address.h> |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 8 | |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 9 | enum devm_ioremap_type { |
| 10 | DEVM_IOREMAP = 0, |
Tuowen Zhao | e537654b | 2019-10-16 15:06:28 -0600 | [diff] [blame] | 11 | DEVM_IOREMAP_UC, |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 12 | DEVM_IOREMAP_WC, |
Hector Martin | 7c566bb5e | 2021-02-11 21:35:46 +0900 | [diff] [blame] | 13 | DEVM_IOREMAP_NP, |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 14 | }; |
| 15 | |
Emil Medve | b41e5ff | 2008-05-03 06:34:04 +1000 | [diff] [blame] | 16 | void devm_ioremap_release(struct device *dev, void *res) |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 17 | { |
| 18 | iounmap(*(void __iomem **)res); |
| 19 | } |
| 20 | |
| 21 | static int devm_ioremap_match(struct device *dev, void *res, void *match_data) |
| 22 | { |
| 23 | return *(void **)res == match_data; |
| 24 | } |
| 25 | |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 26 | static void __iomem *__devm_ioremap(struct device *dev, resource_size_t offset, |
| 27 | resource_size_t size, |
| 28 | enum devm_ioremap_type type) |
| 29 | { |
| 30 | void __iomem **ptr, *addr = NULL; |
| 31 | |
| 32 | ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL); |
| 33 | if (!ptr) |
| 34 | return NULL; |
| 35 | |
| 36 | switch (type) { |
| 37 | case DEVM_IOREMAP: |
| 38 | addr = ioremap(offset, size); |
| 39 | break; |
Tuowen Zhao | e537654b | 2019-10-16 15:06:28 -0600 | [diff] [blame] | 40 | case DEVM_IOREMAP_UC: |
| 41 | addr = ioremap_uc(offset, size); |
| 42 | break; |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 43 | case DEVM_IOREMAP_WC: |
| 44 | addr = ioremap_wc(offset, size); |
| 45 | break; |
Hector Martin | 7c566bb5e | 2021-02-11 21:35:46 +0900 | [diff] [blame] | 46 | case DEVM_IOREMAP_NP: |
| 47 | addr = ioremap_np(offset, size); |
| 48 | break; |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 49 | } |
| 50 | |
| 51 | if (addr) { |
| 52 | *ptr = addr; |
| 53 | devres_add(dev, ptr); |
| 54 | } else |
| 55 | devres_free(ptr); |
| 56 | |
| 57 | return addr; |
| 58 | } |
| 59 | |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 60 | /** |
| 61 | * devm_ioremap - Managed ioremap() |
| 62 | * @dev: Generic device to remap IO address for |
Lorenzo Pieralisi | 6524754 | 2017-04-19 17:48:54 +0100 | [diff] [blame] | 63 | * @offset: Resource address to map |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 64 | * @size: Size of map |
| 65 | * |
| 66 | * Managed ioremap(). Map is automatically unmapped on driver detach. |
| 67 | */ |
Kumar Gala | 4f452e8 | 2008-04-29 10:25:48 -0500 | [diff] [blame] | 68 | void __iomem *devm_ioremap(struct device *dev, resource_size_t offset, |
Cristian Stoica | 5559b7b | 2014-10-07 18:25:43 +0300 | [diff] [blame] | 69 | resource_size_t size) |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 70 | { |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 71 | return __devm_ioremap(dev, offset, size, DEVM_IOREMAP); |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 72 | } |
| 73 | EXPORT_SYMBOL(devm_ioremap); |
| 74 | |
| 75 | /** |
Tuowen Zhao | e537654b | 2019-10-16 15:06:28 -0600 | [diff] [blame] | 76 | * devm_ioremap_uc - Managed ioremap_uc() |
| 77 | * @dev: Generic device to remap IO address for |
| 78 | * @offset: Resource address to map |
| 79 | * @size: Size of map |
| 80 | * |
| 81 | * Managed ioremap_uc(). Map is automatically unmapped on driver detach. |
| 82 | */ |
| 83 | void __iomem *devm_ioremap_uc(struct device *dev, resource_size_t offset, |
| 84 | resource_size_t size) |
| 85 | { |
| 86 | return __devm_ioremap(dev, offset, size, DEVM_IOREMAP_UC); |
| 87 | } |
| 88 | EXPORT_SYMBOL_GPL(devm_ioremap_uc); |
| 89 | |
| 90 | /** |
Abhilash Kesavan | 3464452 | 2015-02-06 19:15:27 +0530 | [diff] [blame] | 91 | * devm_ioremap_wc - Managed ioremap_wc() |
| 92 | * @dev: Generic device to remap IO address for |
Lorenzo Pieralisi | 6524754 | 2017-04-19 17:48:54 +0100 | [diff] [blame] | 93 | * @offset: Resource address to map |
Abhilash Kesavan | 3464452 | 2015-02-06 19:15:27 +0530 | [diff] [blame] | 94 | * @size: Size of map |
| 95 | * |
| 96 | * Managed ioremap_wc(). Map is automatically unmapped on driver detach. |
| 97 | */ |
| 98 | void __iomem *devm_ioremap_wc(struct device *dev, resource_size_t offset, |
| 99 | resource_size_t size) |
| 100 | { |
Yisheng Xie | 1b72341 | 2018-01-29 19:48:16 +0800 | [diff] [blame] | 101 | return __devm_ioremap(dev, offset, size, DEVM_IOREMAP_WC); |
Abhilash Kesavan | 3464452 | 2015-02-06 19:15:27 +0530 | [diff] [blame] | 102 | } |
| 103 | EXPORT_SYMBOL(devm_ioremap_wc); |
| 104 | |
| 105 | /** |
Hector Martin | 7c566bb5e | 2021-02-11 21:35:46 +0900 | [diff] [blame] | 106 | * devm_ioremap_np - Managed ioremap_np() |
| 107 | * @dev: Generic device to remap IO address for |
| 108 | * @offset: Resource address to map |
| 109 | * @size: Size of map |
| 110 | * |
| 111 | * Managed ioremap_np(). Map is automatically unmapped on driver detach. |
| 112 | */ |
| 113 | void __iomem *devm_ioremap_np(struct device *dev, resource_size_t offset, |
| 114 | resource_size_t size) |
| 115 | { |
| 116 | return __devm_ioremap(dev, offset, size, DEVM_IOREMAP_NP); |
| 117 | } |
| 118 | EXPORT_SYMBOL(devm_ioremap_np); |
| 119 | |
| 120 | /** |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 121 | * devm_iounmap - Managed iounmap() |
| 122 | * @dev: Generic device to unmap for |
| 123 | * @addr: Address to unmap |
| 124 | * |
| 125 | * Managed iounmap(). @addr must have been mapped using devm_ioremap*(). |
| 126 | */ |
| 127 | void devm_iounmap(struct device *dev, void __iomem *addr) |
| 128 | { |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 129 | WARN_ON(devres_destroy(dev, devm_ioremap_release, devm_ioremap_match, |
Steven Rostedt | b104d6a | 2014-04-03 14:49:07 -0700 | [diff] [blame] | 130 | (__force void *)addr)); |
Maxin B John | ae891a1 | 2011-07-25 17:12:59 -0700 | [diff] [blame] | 131 | iounmap(addr); |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 132 | } |
| 133 | EXPORT_SYMBOL(devm_iounmap); |
| 134 | |
Bartosz Golaszewski | 6e92482 | 2019-10-22 10:43:12 +0200 | [diff] [blame] | 135 | static void __iomem * |
| 136 | __devm_ioremap_resource(struct device *dev, const struct resource *res, |
| 137 | enum devm_ioremap_type type) |
| 138 | { |
| 139 | resource_size_t size; |
| 140 | void __iomem *dest_ptr; |
Vladimir Oltean | 35bd8c0 | 2020-06-01 12:58:26 +0300 | [diff] [blame] | 141 | char *pretty_name; |
Bartosz Golaszewski | 6e92482 | 2019-10-22 10:43:12 +0200 | [diff] [blame] | 142 | |
| 143 | BUG_ON(!dev); |
| 144 | |
| 145 | if (!res || resource_type(res) != IORESOURCE_MEM) { |
| 146 | dev_err(dev, "invalid resource\n"); |
| 147 | return IOMEM_ERR_PTR(-EINVAL); |
| 148 | } |
| 149 | |
Hector Martin | 7c566bb5e | 2021-02-11 21:35:46 +0900 | [diff] [blame] | 150 | if (type == DEVM_IOREMAP && res->flags & IORESOURCE_MEM_NONPOSTED) |
| 151 | type = DEVM_IOREMAP_NP; |
| 152 | |
Bartosz Golaszewski | 6e92482 | 2019-10-22 10:43:12 +0200 | [diff] [blame] | 153 | size = resource_size(res); |
| 154 | |
Vladimir Oltean | 35bd8c0 | 2020-06-01 12:58:26 +0300 | [diff] [blame] | 155 | if (res->name) |
| 156 | pretty_name = devm_kasprintf(dev, GFP_KERNEL, "%s %s", |
| 157 | dev_name(dev), res->name); |
| 158 | else |
| 159 | pretty_name = devm_kstrdup(dev, dev_name(dev), GFP_KERNEL); |
Zhen Lei | 5c3e241 | 2021-04-28 14:32:03 +0800 | [diff] [blame] | 160 | if (!pretty_name) { |
| 161 | dev_err(dev, "can't generate pretty name for resource %pR\n", res); |
Vladimir Oltean | 35bd8c0 | 2020-06-01 12:58:26 +0300 | [diff] [blame] | 162 | return IOMEM_ERR_PTR(-ENOMEM); |
Zhen Lei | 5c3e241 | 2021-04-28 14:32:03 +0800 | [diff] [blame] | 163 | } |
Vladimir Oltean | 35bd8c0 | 2020-06-01 12:58:26 +0300 | [diff] [blame] | 164 | |
| 165 | if (!devm_request_mem_region(dev, res->start, size, pretty_name)) { |
Bartosz Golaszewski | 6e92482 | 2019-10-22 10:43:12 +0200 | [diff] [blame] | 166 | dev_err(dev, "can't request region for resource %pR\n", res); |
| 167 | return IOMEM_ERR_PTR(-EBUSY); |
| 168 | } |
| 169 | |
| 170 | dest_ptr = __devm_ioremap(dev, res->start, size, type); |
| 171 | if (!dest_ptr) { |
| 172 | dev_err(dev, "ioremap failed for resource %pR\n", res); |
| 173 | devm_release_mem_region(dev, res->start, size); |
| 174 | dest_ptr = IOMEM_ERR_PTR(-ENOMEM); |
| 175 | } |
| 176 | |
| 177 | return dest_ptr; |
| 178 | } |
| 179 | |
Wolfram Sang | 72f8c0b | 2011-10-25 15:16:47 +0200 | [diff] [blame] | 180 | /** |
Thierry Reding | 7509657 | 2013-01-21 11:08:54 +0100 | [diff] [blame] | 181 | * devm_ioremap_resource() - check, request region, and ioremap resource |
| 182 | * @dev: generic device to handle the resource for |
| 183 | * @res: resource to be handled |
| 184 | * |
Dan Williams | 92b19ff | 2015-08-10 23:07:06 -0400 | [diff] [blame] | 185 | * Checks that a resource is a valid memory region, requests the memory |
| 186 | * region and ioremaps it. All operations are managed and will be undone |
| 187 | * on driver detach. |
Thierry Reding | 7509657 | 2013-01-21 11:08:54 +0100 | [diff] [blame] | 188 | * |
Stephen Boyd | 0c7a6b9 | 2020-09-09 23:04:40 -0700 | [diff] [blame] | 189 | * Usage example: |
Thierry Reding | 7509657 | 2013-01-21 11:08:54 +0100 | [diff] [blame] | 190 | * |
| 191 | * res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 192 | * base = devm_ioremap_resource(&pdev->dev, res); |
| 193 | * if (IS_ERR(base)) |
| 194 | * return PTR_ERR(base); |
Stephen Boyd | 0c7a6b9 | 2020-09-09 23:04:40 -0700 | [diff] [blame] | 195 | * |
| 196 | * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code |
| 197 | * on failure. |
Thierry Reding | 7509657 | 2013-01-21 11:08:54 +0100 | [diff] [blame] | 198 | */ |
Arnd Bergmann | eef778c | 2019-07-04 15:14:45 -0700 | [diff] [blame] | 199 | void __iomem *devm_ioremap_resource(struct device *dev, |
| 200 | const struct resource *res) |
Thierry Reding | 7509657 | 2013-01-21 11:08:54 +0100 | [diff] [blame] | 201 | { |
Bartosz Golaszewski | 6e92482 | 2019-10-22 10:43:12 +0200 | [diff] [blame] | 202 | return __devm_ioremap_resource(dev, res, DEVM_IOREMAP); |
Thierry Reding | 7509657 | 2013-01-21 11:08:54 +0100 | [diff] [blame] | 203 | } |
| 204 | EXPORT_SYMBOL(devm_ioremap_resource); |
| 205 | |
Bartosz Golaszewski | b873af6 | 2019-10-22 10:43:13 +0200 | [diff] [blame] | 206 | /** |
| 207 | * devm_ioremap_resource_wc() - write-combined variant of |
| 208 | * devm_ioremap_resource() |
| 209 | * @dev: generic device to handle the resource for |
| 210 | * @res: resource to be handled |
| 211 | * |
Stephen Boyd | 0c7a6b9 | 2020-09-09 23:04:40 -0700 | [diff] [blame] | 212 | * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code |
| 213 | * on failure. |
Bartosz Golaszewski | b873af6 | 2019-10-22 10:43:13 +0200 | [diff] [blame] | 214 | */ |
| 215 | void __iomem *devm_ioremap_resource_wc(struct device *dev, |
| 216 | const struct resource *res) |
| 217 | { |
| 218 | return __devm_ioremap_resource(dev, res, DEVM_IOREMAP_WC); |
| 219 | } |
| 220 | |
Benjamin Herrenschmidt | d5e8382 | 2018-06-05 13:21:26 +1000 | [diff] [blame] | 221 | /* |
| 222 | * devm_of_iomap - Requests a resource and maps the memory mapped IO |
| 223 | * for a given device_node managed by a given device |
| 224 | * |
| 225 | * Checks that a resource is a valid memory region, requests the memory |
| 226 | * region and ioremaps it. All operations are managed and will be undone |
| 227 | * on driver detach of the device. |
| 228 | * |
| 229 | * This is to be used when a device requests/maps resources described |
| 230 | * by other device tree nodes (children or otherwise). |
| 231 | * |
| 232 | * @dev: The device "managing" the resource |
| 233 | * @node: The device-tree node where the resource resides |
| 234 | * @index: index of the MMIO range in the "reg" property |
| 235 | * @size: Returns the size of the resource (pass NULL if not needed) |
Stephen Boyd | 0c7a6b9 | 2020-09-09 23:04:40 -0700 | [diff] [blame] | 236 | * |
| 237 | * Usage example: |
Benjamin Herrenschmidt | d5e8382 | 2018-06-05 13:21:26 +1000 | [diff] [blame] | 238 | * |
| 239 | * base = devm_of_iomap(&pdev->dev, node, 0, NULL); |
| 240 | * if (IS_ERR(base)) |
| 241 | * return PTR_ERR(base); |
Dan Carpenter | 7ae731a | 2020-06-09 13:46:42 +0300 | [diff] [blame] | 242 | * |
| 243 | * Please Note: This is not a one-to-one replacement for of_iomap() because the |
| 244 | * of_iomap() function does not track whether the region is already mapped. If |
| 245 | * two drivers try to map the same memory, the of_iomap() function will succeed |
Randy Dunlap | 28d9fdf | 2020-08-22 21:04:43 -0700 | [diff] [blame] | 246 | * but the devm_of_iomap() function will return -EBUSY. |
Dan Carpenter | 7ae731a | 2020-06-09 13:46:42 +0300 | [diff] [blame] | 247 | * |
Stephen Boyd | 0c7a6b9 | 2020-09-09 23:04:40 -0700 | [diff] [blame] | 248 | * Return: a pointer to the requested and mapped memory or an ERR_PTR() encoded |
| 249 | * error code on failure. |
Benjamin Herrenschmidt | d5e8382 | 2018-06-05 13:21:26 +1000 | [diff] [blame] | 250 | */ |
| 251 | void __iomem *devm_of_iomap(struct device *dev, struct device_node *node, int index, |
| 252 | resource_size_t *size) |
| 253 | { |
| 254 | struct resource res; |
| 255 | |
| 256 | if (of_address_to_resource(node, index, &res)) |
| 257 | return IOMEM_ERR_PTR(-EINVAL); |
| 258 | if (size) |
| 259 | *size = resource_size(&res); |
| 260 | return devm_ioremap_resource(dev, &res); |
| 261 | } |
| 262 | EXPORT_SYMBOL(devm_of_iomap); |
| 263 | |
Uwe Kleine-König | ce816fa | 2014-04-07 15:39:19 -0700 | [diff] [blame] | 264 | #ifdef CONFIG_HAS_IOPORT_MAP |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 265 | /* |
| 266 | * Generic iomap devres |
| 267 | */ |
| 268 | static void devm_ioport_map_release(struct device *dev, void *res) |
| 269 | { |
| 270 | ioport_unmap(*(void __iomem **)res); |
| 271 | } |
| 272 | |
| 273 | static int devm_ioport_map_match(struct device *dev, void *res, |
| 274 | void *match_data) |
| 275 | { |
| 276 | return *(void **)res == match_data; |
| 277 | } |
| 278 | |
| 279 | /** |
| 280 | * devm_ioport_map - Managed ioport_map() |
| 281 | * @dev: Generic device to map ioport for |
| 282 | * @port: Port to map |
| 283 | * @nr: Number of ports to map |
| 284 | * |
| 285 | * Managed ioport_map(). Map is automatically unmapped on driver |
| 286 | * detach. |
Stephen Boyd | 0c7a6b9 | 2020-09-09 23:04:40 -0700 | [diff] [blame] | 287 | * |
| 288 | * Return: a pointer to the remapped memory or NULL on failure. |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 289 | */ |
Fabian Frederick | 5cbb00c | 2014-05-23 22:30:50 +0200 | [diff] [blame] | 290 | void __iomem *devm_ioport_map(struct device *dev, unsigned long port, |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 291 | unsigned int nr) |
| 292 | { |
| 293 | void __iomem **ptr, *addr; |
| 294 | |
| 295 | ptr = devres_alloc(devm_ioport_map_release, sizeof(*ptr), GFP_KERNEL); |
| 296 | if (!ptr) |
| 297 | return NULL; |
| 298 | |
| 299 | addr = ioport_map(port, nr); |
| 300 | if (addr) { |
| 301 | *ptr = addr; |
| 302 | devres_add(dev, ptr); |
| 303 | } else |
| 304 | devres_free(ptr); |
| 305 | |
| 306 | return addr; |
| 307 | } |
| 308 | EXPORT_SYMBOL(devm_ioport_map); |
| 309 | |
| 310 | /** |
| 311 | * devm_ioport_unmap - Managed ioport_unmap() |
| 312 | * @dev: Generic device to unmap for |
| 313 | * @addr: Address to unmap |
| 314 | * |
| 315 | * Managed ioport_unmap(). @addr must have been mapped using |
| 316 | * devm_ioport_map(). |
| 317 | */ |
| 318 | void devm_ioport_unmap(struct device *dev, void __iomem *addr) |
| 319 | { |
| 320 | ioport_unmap(addr); |
| 321 | WARN_ON(devres_destroy(dev, devm_ioport_map_release, |
Steven Rostedt | b104d6a | 2014-04-03 14:49:07 -0700 | [diff] [blame] | 322 | devm_ioport_map_match, (__force void *)addr)); |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 323 | } |
| 324 | EXPORT_SYMBOL(devm_ioport_unmap); |
Uwe Kleine-König | ce816fa | 2014-04-07 15:39:19 -0700 | [diff] [blame] | 325 | #endif /* CONFIG_HAS_IOPORT_MAP */ |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 326 | |
| 327 | #ifdef CONFIG_PCI |
| 328 | /* |
| 329 | * PCI iomap devres |
| 330 | */ |
Denis Efremov | c9c13ba | 2019-09-28 02:43:08 +0300 | [diff] [blame] | 331 | #define PCIM_IOMAP_MAX PCI_STD_NUM_BARS |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 332 | |
| 333 | struct pcim_iomap_devres { |
| 334 | void __iomem *table[PCIM_IOMAP_MAX]; |
| 335 | }; |
| 336 | |
| 337 | static void pcim_iomap_release(struct device *gendev, void *res) |
| 338 | { |
Geliang Tang | 20af74e | 2015-12-27 18:46:05 +0800 | [diff] [blame] | 339 | struct pci_dev *dev = to_pci_dev(gendev); |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 340 | struct pcim_iomap_devres *this = res; |
| 341 | int i; |
| 342 | |
| 343 | for (i = 0; i < PCIM_IOMAP_MAX; i++) |
| 344 | if (this->table[i]) |
| 345 | pci_iounmap(dev, this->table[i]); |
| 346 | } |
| 347 | |
| 348 | /** |
| 349 | * pcim_iomap_table - access iomap allocation table |
| 350 | * @pdev: PCI device to access iomap table for |
| 351 | * |
| 352 | * Access iomap allocation table for @dev. If iomap table doesn't |
| 353 | * exist and @pdev is managed, it will be allocated. All iomaps |
| 354 | * recorded in the iomap table are automatically unmapped on driver |
| 355 | * detach. |
| 356 | * |
| 357 | * This function might sleep when the table is first allocated but can |
Zhen Lei | 9dbbc3b | 2021-07-07 18:07:31 -0700 | [diff] [blame] | 358 | * be safely called without context and guaranteed to succeed once |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 359 | * allocated. |
| 360 | */ |
Fabian Frederick | 5cbb00c | 2014-05-23 22:30:50 +0200 | [diff] [blame] | 361 | void __iomem * const *pcim_iomap_table(struct pci_dev *pdev) |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 362 | { |
| 363 | struct pcim_iomap_devres *dr, *new_dr; |
| 364 | |
| 365 | dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL); |
| 366 | if (dr) |
| 367 | return dr->table; |
| 368 | |
| 369 | new_dr = devres_alloc(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL); |
| 370 | if (!new_dr) |
| 371 | return NULL; |
| 372 | dr = devres_get(&pdev->dev, new_dr, NULL, NULL); |
| 373 | return dr->table; |
| 374 | } |
| 375 | EXPORT_SYMBOL(pcim_iomap_table); |
| 376 | |
| 377 | /** |
| 378 | * pcim_iomap - Managed pcim_iomap() |
| 379 | * @pdev: PCI device to iomap for |
| 380 | * @bar: BAR to iomap |
| 381 | * @maxlen: Maximum length of iomap |
| 382 | * |
| 383 | * Managed pci_iomap(). Map is automatically unmapped on driver |
| 384 | * detach. |
| 385 | */ |
Fabian Frederick | 5cbb00c | 2014-05-23 22:30:50 +0200 | [diff] [blame] | 386 | void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen) |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 387 | { |
| 388 | void __iomem **tbl; |
| 389 | |
| 390 | BUG_ON(bar >= PCIM_IOMAP_MAX); |
| 391 | |
| 392 | tbl = (void __iomem **)pcim_iomap_table(pdev); |
| 393 | if (!tbl || tbl[bar]) /* duplicate mappings not allowed */ |
| 394 | return NULL; |
| 395 | |
| 396 | tbl[bar] = pci_iomap(pdev, bar, maxlen); |
| 397 | return tbl[bar]; |
| 398 | } |
| 399 | EXPORT_SYMBOL(pcim_iomap); |
| 400 | |
| 401 | /** |
| 402 | * pcim_iounmap - Managed pci_iounmap() |
| 403 | * @pdev: PCI device to iounmap for |
| 404 | * @addr: Address to unmap |
| 405 | * |
| 406 | * Managed pci_iounmap(). @addr must have been mapped using pcim_iomap(). |
| 407 | */ |
| 408 | void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr) |
| 409 | { |
| 410 | void __iomem **tbl; |
| 411 | int i; |
| 412 | |
| 413 | pci_iounmap(pdev, addr); |
| 414 | |
| 415 | tbl = (void __iomem **)pcim_iomap_table(pdev); |
| 416 | BUG_ON(!tbl); |
| 417 | |
| 418 | for (i = 0; i < PCIM_IOMAP_MAX; i++) |
| 419 | if (tbl[i] == addr) { |
| 420 | tbl[i] = NULL; |
| 421 | return; |
| 422 | } |
| 423 | WARN_ON(1); |
| 424 | } |
| 425 | EXPORT_SYMBOL(pcim_iounmap); |
| 426 | |
| 427 | /** |
| 428 | * pcim_iomap_regions - Request and iomap PCI BARs |
| 429 | * @pdev: PCI device to map IO resources for |
| 430 | * @mask: Mask of BARs to request and iomap |
| 431 | * @name: Name used when requesting regions |
| 432 | * |
| 433 | * Request and iomap regions specified by @mask. |
| 434 | */ |
Yinghai Lu | fb7ebfe | 2012-01-04 15:50:02 -0800 | [diff] [blame] | 435 | int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name) |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 436 | { |
| 437 | void __iomem * const *iomap; |
| 438 | int i, rc; |
| 439 | |
| 440 | iomap = pcim_iomap_table(pdev); |
| 441 | if (!iomap) |
| 442 | return -ENOMEM; |
| 443 | |
| 444 | for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { |
| 445 | unsigned long len; |
| 446 | |
| 447 | if (!(mask & (1 << i))) |
| 448 | continue; |
| 449 | |
| 450 | rc = -EINVAL; |
| 451 | len = pci_resource_len(pdev, i); |
| 452 | if (!len) |
| 453 | goto err_inval; |
| 454 | |
| 455 | rc = pci_request_region(pdev, i, name); |
| 456 | if (rc) |
Frederik Deweerdt | fb4d64e | 2007-02-16 01:27:15 -0800 | [diff] [blame] | 457 | goto err_inval; |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 458 | |
| 459 | rc = -ENOMEM; |
| 460 | if (!pcim_iomap(pdev, i, 0)) |
Frederik Deweerdt | fb4d64e | 2007-02-16 01:27:15 -0800 | [diff] [blame] | 461 | goto err_region; |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 462 | } |
| 463 | |
| 464 | return 0; |
| 465 | |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 466 | err_region: |
| 467 | pci_release_region(pdev, i); |
| 468 | err_inval: |
| 469 | while (--i >= 0) { |
Frederik Deweerdt | fb4d64e | 2007-02-16 01:27:15 -0800 | [diff] [blame] | 470 | if (!(mask & (1 << i))) |
| 471 | continue; |
Al Viro | 5ea8176 | 2007-02-11 15:41:31 +0000 | [diff] [blame] | 472 | pcim_iounmap(pdev, iomap[i]); |
| 473 | pci_release_region(pdev, i); |
| 474 | } |
| 475 | |
| 476 | return rc; |
| 477 | } |
| 478 | EXPORT_SYMBOL(pcim_iomap_regions); |
Tejun Heo | ec04b07 | 2007-03-09 19:45:58 +0900 | [diff] [blame] | 479 | |
| 480 | /** |
Tejun Heo | 916fbfb | 2008-03-12 15:26:34 +0900 | [diff] [blame] | 481 | * pcim_iomap_regions_request_all - Request all BARs and iomap specified ones |
| 482 | * @pdev: PCI device to map IO resources for |
| 483 | * @mask: Mask of BARs to iomap |
| 484 | * @name: Name used when requesting regions |
| 485 | * |
| 486 | * Request all PCI BARs and iomap regions specified by @mask. |
| 487 | */ |
Yinghai Lu | fb7ebfe | 2012-01-04 15:50:02 -0800 | [diff] [blame] | 488 | int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask, |
Tejun Heo | 916fbfb | 2008-03-12 15:26:34 +0900 | [diff] [blame] | 489 | const char *name) |
| 490 | { |
| 491 | int request_mask = ((1 << 6) - 1) & ~mask; |
| 492 | int rc; |
| 493 | |
| 494 | rc = pci_request_selected_regions(pdev, request_mask, name); |
| 495 | if (rc) |
| 496 | return rc; |
| 497 | |
| 498 | rc = pcim_iomap_regions(pdev, mask, name); |
| 499 | if (rc) |
| 500 | pci_release_selected_regions(pdev, request_mask); |
| 501 | return rc; |
| 502 | } |
| 503 | EXPORT_SYMBOL(pcim_iomap_regions_request_all); |
| 504 | |
| 505 | /** |
Tejun Heo | ec04b07 | 2007-03-09 19:45:58 +0900 | [diff] [blame] | 506 | * pcim_iounmap_regions - Unmap and release PCI BARs |
| 507 | * @pdev: PCI device to map IO resources for |
| 508 | * @mask: Mask of BARs to unmap and release |
| 509 | * |
Kulikov Vasiliy | 4d45ada | 2010-07-10 14:07:41 +0400 | [diff] [blame] | 510 | * Unmap and release regions specified by @mask. |
Tejun Heo | ec04b07 | 2007-03-09 19:45:58 +0900 | [diff] [blame] | 511 | */ |
Yinghai Lu | fb7ebfe | 2012-01-04 15:50:02 -0800 | [diff] [blame] | 512 | void pcim_iounmap_regions(struct pci_dev *pdev, int mask) |
Tejun Heo | ec04b07 | 2007-03-09 19:45:58 +0900 | [diff] [blame] | 513 | { |
| 514 | void __iomem * const *iomap; |
| 515 | int i; |
| 516 | |
| 517 | iomap = pcim_iomap_table(pdev); |
| 518 | if (!iomap) |
| 519 | return; |
| 520 | |
Dan Carpenter | 1f35d04 | 2015-09-21 19:21:51 +0300 | [diff] [blame] | 521 | for (i = 0; i < PCIM_IOMAP_MAX; i++) { |
Tejun Heo | ec04b07 | 2007-03-09 19:45:58 +0900 | [diff] [blame] | 522 | if (!(mask & (1 << i))) |
| 523 | continue; |
| 524 | |
| 525 | pcim_iounmap(pdev, iomap[i]); |
| 526 | pci_release_region(pdev, i); |
| 527 | } |
| 528 | } |
| 529 | EXPORT_SYMBOL(pcim_iounmap_regions); |
Wolfram Sang | 571806a | 2011-10-25 15:03:42 +0200 | [diff] [blame] | 530 | #endif /* CONFIG_PCI */ |