1 /* 2 * manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices 3 * 4 * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz> 5 * Copyright 2003 Adam Belay <ambx1@neo.rr.com> 6 * Copyright (C) 2008 Hewlett-Packard Development Company, L.P. 7 * Bjorn Helgaas <bjorn.helgaas@hp.com> 8 */ 9 10 #include <linux/errno.h> 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/kernel.h> 14 #include <linux/pnp.h> 15 #include <linux/bitmap.h> 16 #include <linux/mutex.h> 17 #include "base.h" 18 19 DEFINE_MUTEX(pnp_res_mutex); 20 21 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx) 22 { 23 struct resource *res, local_res; 24 25 res = pnp_get_resource(dev, IORESOURCE_IO, idx); 26 if (res) { 27 pnp_dbg(&dev->dev, " io %d already set to %#llx-%#llx " 28 "flags %#lx\n", idx, (unsigned long long) res->start, 29 (unsigned long long) res->end, res->flags); 30 return 0; 31 } 32 33 res = &local_res; 34 res->flags = rule->flags | IORESOURCE_AUTO; 35 res->start = 0; 36 res->end = 0; 37 38 if (!rule->size) { 39 res->flags |= IORESOURCE_DISABLED; 40 pnp_dbg(&dev->dev, " io %d disabled\n", idx); 41 goto __add; 42 } 43 44 res->start = rule->min; 45 res->end = res->start + rule->size - 1; 46 47 while (!pnp_check_port(dev, res)) { 48 res->start += rule->align; 49 res->end = res->start + rule->size - 1; 50 if (res->start > rule->max || !rule->align) { 51 pnp_dbg(&dev->dev, " couldn't assign io %d " 52 "(min %#llx max %#llx)\n", idx, 53 (unsigned long long) rule->min, 54 (unsigned long long) rule->max); 55 return -EBUSY; 56 } 57 } 58 59 __add: 60 pnp_add_io_resource(dev, res->start, res->end, res->flags); 61 return 0; 62 } 63 64 static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) 65 { 66 struct resource *res, local_res; 67 68 res = pnp_get_resource(dev, IORESOURCE_MEM, idx); 69 if (res) { 70 pnp_dbg(&dev->dev, " mem %d already set to %#llx-%#llx " 71 "flags %#lx\n", idx, (unsigned long long) res->start, 72 (unsigned long long) res->end, res->flags); 73 return 0; 74 } 75 76 res = &local_res; 77 res->flags = rule->flags | IORESOURCE_AUTO; 78 res->start = 0; 79 res->end = 0; 80 81 if (!(rule->flags & IORESOURCE_MEM_WRITEABLE)) 82 res->flags |= IORESOURCE_READONLY; 83 if (rule->flags & IORESOURCE_MEM_CACHEABLE) 84 res->flags |= IORESOURCE_CACHEABLE; 85 if (rule->flags & IORESOURCE_MEM_RANGELENGTH) 86 res->flags |= IORESOURCE_RANGELENGTH; 87 if (rule->flags & IORESOURCE_MEM_SHADOWABLE) 88 res->flags |= IORESOURCE_SHADOWABLE; 89 90 if (!rule->size) { 91 res->flags |= IORESOURCE_DISABLED; 92 pnp_dbg(&dev->dev, " mem %d disabled\n", idx); 93 goto __add; 94 } 95 96 res->start = rule->min; 97 res->end = res->start + rule->size - 1; 98 99 while (!pnp_check_mem(dev, res)) { 100 res->start += rule->align; 101 res->end = res->start + rule->size - 1; 102 if (res->start > rule->max || !rule->align) { 103 pnp_dbg(&dev->dev, " couldn't assign mem %d " 104 "(min %#llx max %#llx)\n", idx, 105 (unsigned long long) rule->min, 106 (unsigned long long) rule->max); 107 return -EBUSY; 108 } 109 } 110 111 __add: 112 pnp_add_mem_resource(dev, res->start, res->end, res->flags); 113 return 0; 114 } 115 116 static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) 117 { 118 struct resource *res, local_res; 119 int i; 120 121 /* IRQ priority: this table is good for i386 */ 122 static unsigned short xtab[16] = { 123 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2 124 }; 125 126 res = pnp_get_resource(dev, IORESOURCE_IRQ, idx); 127 if (res) { 128 pnp_dbg(&dev->dev, " irq %d already set to %d flags %#lx\n", 129 idx, (int) res->start, res->flags); 130 return 0; 131 } 132 133 res = &local_res; 134 res->flags = rule->flags | IORESOURCE_AUTO; 135 res->start = -1; 136 res->end = -1; 137 138 if (bitmap_empty(rule->map.bits, PNP_IRQ_NR)) { 139 res->flags |= IORESOURCE_DISABLED; 140 pnp_dbg(&dev->dev, " irq %d disabled\n", idx); 141 goto __add; 142 } 143 144 /* TBD: need check for >16 IRQ */ 145 res->start = find_next_bit(rule->map.bits, PNP_IRQ_NR, 16); 146 if (res->start < PNP_IRQ_NR) { 147 res->end = res->start; 148 goto __add; 149 } 150 for (i = 0; i < 16; i++) { 151 if (test_bit(xtab[i], rule->map.bits)) { 152 res->start = res->end = xtab[i]; 153 if (pnp_check_irq(dev, res)) 154 goto __add; 155 } 156 } 157 158 if (rule->flags & IORESOURCE_IRQ_OPTIONAL) { 159 res->start = -1; 160 res->end = -1; 161 res->flags |= IORESOURCE_DISABLED; 162 pnp_dbg(&dev->dev, " irq %d disabled (optional)\n", idx); 163 goto __add; 164 } 165 166 pnp_dbg(&dev->dev, " couldn't assign irq %d\n", idx); 167 return -EBUSY; 168 169 __add: 170 pnp_add_irq_resource(dev, res->start, res->flags); 171 return 0; 172 } 173 174 static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx) 175 { 176 struct resource *res, local_res; 177 int i; 178 179 /* DMA priority: this table is good for i386 */ 180 static unsigned short xtab[8] = { 181 1, 3, 5, 6, 7, 0, 2, 4 182 }; 183 184 res = pnp_get_resource(dev, IORESOURCE_DMA, idx); 185 if (res) { 186 pnp_dbg(&dev->dev, " dma %d already set to %d flags %#lx\n", 187 idx, (int) res->start, res->flags); 188 return 0; 189 } 190 191 res = &local_res; 192 res->flags = rule->flags | IORESOURCE_AUTO; 193 res->start = -1; 194 res->end = -1; 195 196 for (i = 0; i < 8; i++) { 197 if (rule->map & (1 << xtab[i])) { 198 res->start = res->end = xtab[i]; 199 if (pnp_check_dma(dev, res)) 200 goto __add; 201 } 202 } 203 #ifdef MAX_DMA_CHANNELS 204 res->start = res->end = MAX_DMA_CHANNELS; 205 #endif 206 res->flags |= IORESOURCE_DISABLED; 207 pnp_dbg(&dev->dev, " disable dma %d\n", idx); 208 209 __add: 210 pnp_add_dma_resource(dev, res->start, res->flags); 211 return 0; 212 } 213 214 void pnp_init_resources(struct pnp_dev *dev) 215 { 216 pnp_free_resources(dev); 217 } 218 219 static void pnp_clean_resource_table(struct pnp_dev *dev) 220 { 221 struct pnp_resource *pnp_res, *tmp; 222 223 list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) { 224 if (pnp_res->res.flags & IORESOURCE_AUTO) 225 pnp_free_resource(pnp_res); 226 } 227 } 228 229 /** 230 * pnp_assign_resources - assigns resources to the device based on the specified dependent number 231 * @dev: pointer to the desired device 232 * @set: the dependent function number 233 */ 234 static int pnp_assign_resources(struct pnp_dev *dev, int set) 235 { 236 struct pnp_option *option; 237 int nport = 0, nmem = 0, nirq = 0, ndma = 0; 238 int ret = 0; 239 240 pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set); 241 mutex_lock(&pnp_res_mutex); 242 pnp_clean_resource_table(dev); 243 244 list_for_each_entry(option, &dev->options, list) { 245 if (pnp_option_is_dependent(option) && 246 pnp_option_set(option) != set) 247 continue; 248 249 switch (option->type) { 250 case IORESOURCE_IO: 251 ret = pnp_assign_port(dev, &option->u.port, nport++); 252 break; 253 case IORESOURCE_MEM: 254 ret = pnp_assign_mem(dev, &option->u.mem, nmem++); 255 break; 256 case IORESOURCE_IRQ: 257 ret = pnp_assign_irq(dev, &option->u.irq, nirq++); 258 break; 259 case IORESOURCE_DMA: 260 ret = pnp_assign_dma(dev, &option->u.dma, ndma++); 261 break; 262 default: 263 ret = -EINVAL; 264 break; 265 } 266 if (ret < 0) 267 break; 268 } 269 270 mutex_unlock(&pnp_res_mutex); 271 if (ret < 0) { 272 pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret); 273 pnp_clean_resource_table(dev); 274 } else 275 dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded"); 276 return ret; 277 } 278 279 /** 280 * pnp_auto_config_dev - automatically assigns resources to a device 281 * @dev: pointer to the desired device 282 */ 283 int pnp_auto_config_dev(struct pnp_dev *dev) 284 { 285 int i, ret; 286 287 if (!pnp_can_configure(dev)) { 288 pnp_dbg(&dev->dev, "configuration not supported\n"); 289 return -ENODEV; 290 } 291 292 ret = pnp_assign_resources(dev, 0); 293 if (ret == 0) 294 return 0; 295 296 for (i = 1; i < dev->num_dependent_sets; i++) { 297 ret = pnp_assign_resources(dev, i); 298 if (ret == 0) 299 return 0; 300 } 301 302 dev_err(&dev->dev, "unable to assign resources\n"); 303 return ret; 304 } 305 306 /** 307 * pnp_start_dev - low-level start of the PnP device 308 * @dev: pointer to the desired device 309 * 310 * assumes that resources have already been allocated 311 */ 312 int pnp_start_dev(struct pnp_dev *dev) 313 { 314 if (!pnp_can_write(dev)) { 315 pnp_dbg(&dev->dev, "activation not supported\n"); 316 return -EINVAL; 317 } 318 319 dbg_pnp_show_resources(dev, "pnp_start_dev"); 320 if (dev->protocol->set(dev) < 0) { 321 dev_err(&dev->dev, "activation failed\n"); 322 return -EIO; 323 } 324 325 dev_info(&dev->dev, "activated\n"); 326 return 0; 327 } 328 329 /** 330 * pnp_stop_dev - low-level disable of the PnP device 331 * @dev: pointer to the desired device 332 * 333 * does not free resources 334 */ 335 int pnp_stop_dev(struct pnp_dev *dev) 336 { 337 if (!pnp_can_disable(dev)) { 338 pnp_dbg(&dev->dev, "disabling not supported\n"); 339 return -EINVAL; 340 } 341 if (dev->protocol->disable(dev) < 0) { 342 dev_err(&dev->dev, "disable failed\n"); 343 return -EIO; 344 } 345 346 dev_info(&dev->dev, "disabled\n"); 347 return 0; 348 } 349 350 /** 351 * pnp_activate_dev - activates a PnP device for use 352 * @dev: pointer to the desired device 353 * 354 * does not validate or set resources so be careful. 355 */ 356 int pnp_activate_dev(struct pnp_dev *dev) 357 { 358 int error; 359 360 if (dev->active) 361 return 0; 362 363 /* ensure resources are allocated */ 364 if (pnp_auto_config_dev(dev)) 365 return -EBUSY; 366 367 error = pnp_start_dev(dev); 368 if (error) 369 return error; 370 371 dev->active = 1; 372 return 0; 373 } 374 375 /** 376 * pnp_disable_dev - disables device 377 * @dev: pointer to the desired device 378 * 379 * inform the correct pnp protocol so that resources can be used by other devices 380 */ 381 int pnp_disable_dev(struct pnp_dev *dev) 382 { 383 int error; 384 385 if (!dev->active) 386 return 0; 387 388 error = pnp_stop_dev(dev); 389 if (error) 390 return error; 391 392 dev->active = 0; 393 394 /* release the resources so that other devices can use them */ 395 mutex_lock(&pnp_res_mutex); 396 pnp_clean_resource_table(dev); 397 mutex_unlock(&pnp_res_mutex); 398 399 return 0; 400 } 401 402 EXPORT_SYMBOL(pnp_start_dev); 403 EXPORT_SYMBOL(pnp_stop_dev); 404 EXPORT_SYMBOL(pnp_activate_dev); 405 EXPORT_SYMBOL(pnp_disable_dev); 406