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 */ 7 8 #include <linux/errno.h> 9 #include <linux/module.h> 10 #include <linux/init.h> 11 #include <linux/kernel.h> 12 #include <linux/pnp.h> 13 #include <linux/slab.h> 14 #include <linux/bitmap.h> 15 #include "base.h" 16 17 DECLARE_MUTEX(pnp_res_mutex); 18 19 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx) 20 { 21 resource_size_t *start, *end; 22 unsigned long *flags; 23 24 if (idx >= PNP_MAX_PORT) { 25 dev_err(&dev->dev, "too many I/O port resources\n"); 26 /* pretend we were successful so at least the manager won't try again */ 27 return 1; 28 } 29 30 /* check if this resource has been manually set, if so skip */ 31 if (!(dev->res.port_resource[idx].flags & IORESOURCE_AUTO)) 32 return 1; 33 34 start = &dev->res.port_resource[idx].start; 35 end = &dev->res.port_resource[idx].end; 36 flags = &dev->res.port_resource[idx].flags; 37 38 /* set the initial values */ 39 *flags |= rule->flags | IORESOURCE_IO; 40 *flags &= ~IORESOURCE_UNSET; 41 42 if (!rule->size) { 43 *flags |= IORESOURCE_DISABLED; 44 return 1; /* skip disabled resource requests */ 45 } 46 47 *start = rule->min; 48 *end = *start + rule->size - 1; 49 50 /* run through until pnp_check_port is happy */ 51 while (!pnp_check_port(dev, idx)) { 52 *start += rule->align; 53 *end = *start + rule->size - 1; 54 if (*start > rule->max || !rule->align) 55 return 0; 56 } 57 return 1; 58 } 59 60 static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) 61 { 62 resource_size_t *start, *end; 63 unsigned long *flags; 64 65 if (idx >= PNP_MAX_MEM) { 66 dev_err(&dev->dev, "too many memory resources\n"); 67 /* pretend we were successful so at least the manager won't try again */ 68 return 1; 69 } 70 71 /* check if this resource has been manually set, if so skip */ 72 if (!(dev->res.mem_resource[idx].flags & IORESOURCE_AUTO)) 73 return 1; 74 75 start = &dev->res.mem_resource[idx].start; 76 end = &dev->res.mem_resource[idx].end; 77 flags = &dev->res.mem_resource[idx].flags; 78 79 /* set the initial values */ 80 *flags |= rule->flags | IORESOURCE_MEM; 81 *flags &= ~IORESOURCE_UNSET; 82 83 /* convert pnp flags to standard Linux flags */ 84 if (!(rule->flags & IORESOURCE_MEM_WRITEABLE)) 85 *flags |= IORESOURCE_READONLY; 86 if (rule->flags & IORESOURCE_MEM_CACHEABLE) 87 *flags |= IORESOURCE_CACHEABLE; 88 if (rule->flags & IORESOURCE_MEM_RANGELENGTH) 89 *flags |= IORESOURCE_RANGELENGTH; 90 if (rule->flags & IORESOURCE_MEM_SHADOWABLE) 91 *flags |= IORESOURCE_SHADOWABLE; 92 93 if (!rule->size) { 94 *flags |= IORESOURCE_DISABLED; 95 return 1; /* skip disabled resource requests */ 96 } 97 98 *start = rule->min; 99 *end = *start + rule->size - 1; 100 101 /* run through until pnp_check_mem is happy */ 102 while (!pnp_check_mem(dev, idx)) { 103 *start += rule->align; 104 *end = *start + rule->size - 1; 105 if (*start > rule->max || !rule->align) 106 return 0; 107 } 108 return 1; 109 } 110 111 static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) 112 { 113 resource_size_t *start, *end; 114 unsigned long *flags; 115 int i; 116 117 /* IRQ priority: this table is good for i386 */ 118 static unsigned short xtab[16] = { 119 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2 120 }; 121 122 if (idx >= PNP_MAX_IRQ) { 123 dev_err(&dev->dev, "too many IRQ resources\n"); 124 /* pretend we were successful so at least the manager won't try again */ 125 return 1; 126 } 127 128 /* check if this resource has been manually set, if so skip */ 129 if (!(dev->res.irq_resource[idx].flags & IORESOURCE_AUTO)) 130 return 1; 131 132 start = &dev->res.irq_resource[idx].start; 133 end = &dev->res.irq_resource[idx].end; 134 flags = &dev->res.irq_resource[idx].flags; 135 136 /* set the initial values */ 137 *flags |= rule->flags | IORESOURCE_IRQ; 138 *flags &= ~IORESOURCE_UNSET; 139 140 if (bitmap_empty(rule->map, PNP_IRQ_NR)) { 141 *flags |= IORESOURCE_DISABLED; 142 return 1; /* skip disabled resource requests */ 143 } 144 145 /* TBD: need check for >16 IRQ */ 146 *start = find_next_bit(rule->map, PNP_IRQ_NR, 16); 147 if (*start < PNP_IRQ_NR) { 148 *end = *start; 149 return 1; 150 } 151 for (i = 0; i < 16; i++) { 152 if (test_bit(xtab[i], rule->map)) { 153 *start = *end = xtab[i]; 154 if (pnp_check_irq(dev, idx)) 155 return 1; 156 } 157 } 158 return 0; 159 } 160 161 static void pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx) 162 { 163 resource_size_t *start, *end; 164 unsigned long *flags; 165 int i; 166 167 /* DMA priority: this table is good for i386 */ 168 static unsigned short xtab[8] = { 169 1, 3, 5, 6, 7, 0, 2, 4 170 }; 171 172 if (idx >= PNP_MAX_DMA) { 173 dev_err(&dev->dev, "too many DMA resources\n"); 174 return; 175 } 176 177 /* check if this resource has been manually set, if so skip */ 178 if (!(dev->res.dma_resource[idx].flags & IORESOURCE_AUTO)) 179 return; 180 181 start = &dev->res.dma_resource[idx].start; 182 end = &dev->res.dma_resource[idx].end; 183 flags = &dev->res.dma_resource[idx].flags; 184 185 /* set the initial values */ 186 *flags |= rule->flags | IORESOURCE_DMA; 187 *flags &= ~IORESOURCE_UNSET; 188 189 for (i = 0; i < 8; i++) { 190 if (rule->map & (1 << xtab[i])) { 191 *start = *end = xtab[i]; 192 if (pnp_check_dma(dev, idx)) 193 return; 194 } 195 } 196 #ifdef MAX_DMA_CHANNELS 197 *start = *end = MAX_DMA_CHANNELS; 198 #endif 199 *flags |= IORESOURCE_UNSET | IORESOURCE_DISABLED; 200 } 201 202 /** 203 * pnp_init_resources - Resets a resource table to default values. 204 * @table: pointer to the desired resource table 205 */ 206 void pnp_init_resource_table(struct pnp_resource_table *table) 207 { 208 int idx; 209 210 for (idx = 0; idx < PNP_MAX_IRQ; idx++) { 211 table->irq_resource[idx].name = NULL; 212 table->irq_resource[idx].start = -1; 213 table->irq_resource[idx].end = -1; 214 table->irq_resource[idx].flags = 215 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET; 216 } 217 for (idx = 0; idx < PNP_MAX_DMA; idx++) { 218 table->dma_resource[idx].name = NULL; 219 table->dma_resource[idx].start = -1; 220 table->dma_resource[idx].end = -1; 221 table->dma_resource[idx].flags = 222 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET; 223 } 224 for (idx = 0; idx < PNP_MAX_PORT; idx++) { 225 table->port_resource[idx].name = NULL; 226 table->port_resource[idx].start = 0; 227 table->port_resource[idx].end = 0; 228 table->port_resource[idx].flags = 229 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET; 230 } 231 for (idx = 0; idx < PNP_MAX_MEM; idx++) { 232 table->mem_resource[idx].name = NULL; 233 table->mem_resource[idx].start = 0; 234 table->mem_resource[idx].end = 0; 235 table->mem_resource[idx].flags = 236 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET; 237 } 238 } 239 240 /** 241 * pnp_clean_resources - clears resources that were not manually set 242 * @res: the resources to clean 243 */ 244 static void pnp_clean_resource_table(struct pnp_resource_table *res) 245 { 246 int idx; 247 248 for (idx = 0; idx < PNP_MAX_IRQ; idx++) { 249 if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO)) 250 continue; 251 res->irq_resource[idx].start = -1; 252 res->irq_resource[idx].end = -1; 253 res->irq_resource[idx].flags = 254 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET; 255 } 256 for (idx = 0; idx < PNP_MAX_DMA; idx++) { 257 if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO)) 258 continue; 259 res->dma_resource[idx].start = -1; 260 res->dma_resource[idx].end = -1; 261 res->dma_resource[idx].flags = 262 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET; 263 } 264 for (idx = 0; idx < PNP_MAX_PORT; idx++) { 265 if (!(res->port_resource[idx].flags & IORESOURCE_AUTO)) 266 continue; 267 res->port_resource[idx].start = 0; 268 res->port_resource[idx].end = 0; 269 res->port_resource[idx].flags = 270 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET; 271 } 272 for (idx = 0; idx < PNP_MAX_MEM; idx++) { 273 if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO)) 274 continue; 275 res->mem_resource[idx].start = 0; 276 res->mem_resource[idx].end = 0; 277 res->mem_resource[idx].flags = 278 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET; 279 } 280 } 281 282 /** 283 * pnp_assign_resources - assigns resources to the device based on the specified dependent number 284 * @dev: pointer to the desired device 285 * @depnum: the dependent function number 286 * 287 * Only set depnum to 0 if the device does not have dependent options. 288 */ 289 static int pnp_assign_resources(struct pnp_dev *dev, int depnum) 290 { 291 struct pnp_port *port; 292 struct pnp_mem *mem; 293 struct pnp_irq *irq; 294 struct pnp_dma *dma; 295 int nport = 0, nmem = 0, nirq = 0, ndma = 0; 296 297 if (!pnp_can_configure(dev)) 298 return -ENODEV; 299 300 down(&pnp_res_mutex); 301 pnp_clean_resource_table(&dev->res); /* start with a fresh slate */ 302 if (dev->independent) { 303 port = dev->independent->port; 304 mem = dev->independent->mem; 305 irq = dev->independent->irq; 306 dma = dev->independent->dma; 307 while (port) { 308 if (!pnp_assign_port(dev, port, nport)) 309 goto fail; 310 nport++; 311 port = port->next; 312 } 313 while (mem) { 314 if (!pnp_assign_mem(dev, mem, nmem)) 315 goto fail; 316 nmem++; 317 mem = mem->next; 318 } 319 while (irq) { 320 if (!pnp_assign_irq(dev, irq, nirq)) 321 goto fail; 322 nirq++; 323 irq = irq->next; 324 } 325 while (dma) { 326 pnp_assign_dma(dev, dma, ndma); 327 ndma++; 328 dma = dma->next; 329 } 330 } 331 332 if (depnum) { 333 struct pnp_option *dep; 334 int i; 335 for (i = 1, dep = dev->dependent; i < depnum; 336 i++, dep = dep->next) 337 if (!dep) 338 goto fail; 339 port = dep->port; 340 mem = dep->mem; 341 irq = dep->irq; 342 dma = dep->dma; 343 while (port) { 344 if (!pnp_assign_port(dev, port, nport)) 345 goto fail; 346 nport++; 347 port = port->next; 348 } 349 while (mem) { 350 if (!pnp_assign_mem(dev, mem, nmem)) 351 goto fail; 352 nmem++; 353 mem = mem->next; 354 } 355 while (irq) { 356 if (!pnp_assign_irq(dev, irq, nirq)) 357 goto fail; 358 nirq++; 359 irq = irq->next; 360 } 361 while (dma) { 362 pnp_assign_dma(dev, dma, ndma); 363 ndma++; 364 dma = dma->next; 365 } 366 } else if (dev->dependent) 367 goto fail; 368 369 up(&pnp_res_mutex); 370 return 1; 371 372 fail: 373 pnp_clean_resource_table(&dev->res); 374 up(&pnp_res_mutex); 375 return 0; 376 } 377 378 /** 379 * pnp_manual_config_dev - Disables Auto Config and Manually sets the resource table 380 * @dev: pointer to the desired device 381 * @res: pointer to the new resource config 382 * @mode: 0 or PNP_CONFIG_FORCE 383 * 384 * This function can be used by drivers that want to manually set thier resources. 385 */ 386 int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, 387 int mode) 388 { 389 int i; 390 struct pnp_resource_table *bak; 391 392 if (!pnp_can_configure(dev)) 393 return -ENODEV; 394 bak = pnp_alloc(sizeof(struct pnp_resource_table)); 395 if (!bak) 396 return -ENOMEM; 397 *bak = dev->res; 398 399 down(&pnp_res_mutex); 400 dev->res = *res; 401 if (!(mode & PNP_CONFIG_FORCE)) { 402 for (i = 0; i < PNP_MAX_PORT; i++) { 403 if (!pnp_check_port(dev, i)) 404 goto fail; 405 } 406 for (i = 0; i < PNP_MAX_MEM; i++) { 407 if (!pnp_check_mem(dev, i)) 408 goto fail; 409 } 410 for (i = 0; i < PNP_MAX_IRQ; i++) { 411 if (!pnp_check_irq(dev, i)) 412 goto fail; 413 } 414 for (i = 0; i < PNP_MAX_DMA; i++) { 415 if (!pnp_check_dma(dev, i)) 416 goto fail; 417 } 418 } 419 up(&pnp_res_mutex); 420 421 kfree(bak); 422 return 0; 423 424 fail: 425 dev->res = *bak; 426 up(&pnp_res_mutex); 427 kfree(bak); 428 return -EINVAL; 429 } 430 431 /** 432 * pnp_auto_config_dev - automatically assigns resources to a device 433 * @dev: pointer to the desired device 434 */ 435 int pnp_auto_config_dev(struct pnp_dev *dev) 436 { 437 struct pnp_option *dep; 438 int i = 1; 439 440 if (!pnp_can_configure(dev)) { 441 dev_dbg(&dev->dev, "configuration not supported\n"); 442 return -ENODEV; 443 } 444 445 if (!dev->dependent) { 446 if (pnp_assign_resources(dev, 0)) 447 return 0; 448 } else { 449 dep = dev->dependent; 450 do { 451 if (pnp_assign_resources(dev, i)) 452 return 0; 453 dep = dep->next; 454 i++; 455 } while (dep); 456 } 457 458 dev_err(&dev->dev, "unable to assign resources\n"); 459 return -EBUSY; 460 } 461 462 /** 463 * pnp_start_dev - low-level start of the PnP device 464 * @dev: pointer to the desired device 465 * 466 * assumes that resources have already been allocated 467 */ 468 int pnp_start_dev(struct pnp_dev *dev) 469 { 470 if (!pnp_can_write(dev)) { 471 dev_dbg(&dev->dev, "activation not supported\n"); 472 return -EINVAL; 473 } 474 475 if (dev->protocol->set(dev, &dev->res) < 0) { 476 dev_err(&dev->dev, "activation failed\n"); 477 return -EIO; 478 } 479 480 dev_info(&dev->dev, "activated\n"); 481 return 0; 482 } 483 484 /** 485 * pnp_stop_dev - low-level disable of the PnP device 486 * @dev: pointer to the desired device 487 * 488 * does not free resources 489 */ 490 int pnp_stop_dev(struct pnp_dev *dev) 491 { 492 if (!pnp_can_disable(dev)) { 493 dev_dbg(&dev->dev, "disabling not supported\n"); 494 return -EINVAL; 495 } 496 if (dev->protocol->disable(dev) < 0) { 497 dev_err(&dev->dev, "disable failed\n"); 498 return -EIO; 499 } 500 501 dev_info(&dev->dev, "disabled\n"); 502 return 0; 503 } 504 505 /** 506 * pnp_activate_dev - activates a PnP device for use 507 * @dev: pointer to the desired device 508 * 509 * does not validate or set resources so be careful. 510 */ 511 int pnp_activate_dev(struct pnp_dev *dev) 512 { 513 int error; 514 515 if (dev->active) 516 return 0; /* the device is already active */ 517 518 /* ensure resources are allocated */ 519 if (pnp_auto_config_dev(dev)) 520 return -EBUSY; 521 522 error = pnp_start_dev(dev); 523 if (error) 524 return error; 525 526 dev->active = 1; 527 return 1; 528 } 529 530 /** 531 * pnp_disable_dev - disables device 532 * @dev: pointer to the desired device 533 * 534 * inform the correct pnp protocol so that resources can be used by other devices 535 */ 536 int pnp_disable_dev(struct pnp_dev *dev) 537 { 538 int error; 539 540 if (!dev->active) 541 return 0; /* the device is already disabled */ 542 543 error = pnp_stop_dev(dev); 544 if (error) 545 return error; 546 547 dev->active = 0; 548 549 /* release the resources so that other devices can use them */ 550 down(&pnp_res_mutex); 551 pnp_clean_resource_table(&dev->res); 552 up(&pnp_res_mutex); 553 554 return 1; 555 } 556 557 /** 558 * pnp_resource_change - change one resource 559 * @resource: pointer to resource to be changed 560 * @start: start of region 561 * @size: size of region 562 */ 563 void pnp_resource_change(struct resource *resource, resource_size_t start, 564 resource_size_t size) 565 { 566 resource->flags &= ~(IORESOURCE_AUTO | IORESOURCE_UNSET); 567 resource->start = start; 568 resource->end = start + size - 1; 569 } 570 571 EXPORT_SYMBOL(pnp_manual_config_dev); 572 EXPORT_SYMBOL(pnp_start_dev); 573 EXPORT_SYMBOL(pnp_stop_dev); 574 EXPORT_SYMBOL(pnp_activate_dev); 575 EXPORT_SYMBOL(pnp_disable_dev); 576 EXPORT_SYMBOL(pnp_resource_change); 577 EXPORT_SYMBOL(pnp_init_resource_table); 578