drivers/pnp/manager.c

   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);