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