git.oblomov.eu Git - linux-2.6/blob - arch/m68k/kernel/bios32.c

   1 /*
   2  * bios32.c - PCI BIOS functions for m68k systems.
   3  *
   4  * Written by Wout Klaren.
   5  *
   6  * Based on the DEC Alpha bios32.c by Dave Rusling and David Mosberger.
   7  */
   8
   9 #include <linux/init.h>
  10 #include <linux/kernel.h>
  11
  12 #if 0
  13 # define DBG_DEVS(args)         printk args
  14 #else
  15 # define DBG_DEVS(args)
  16 #endif
  17
  18 #ifdef CONFIG_PCI
  19
  20 /*
  21  * PCI support for Linux/m68k. Currently only the Hades is supported.
  22  *
  23  * The support for PCI bridges in the DEC Alpha version has
  24  * been removed in this version.
  25  */
  26
  27 #include <linux/pci.h>
  28 #include <linux/slab.h>
  29 #include <linux/mm.h>
  30
  31 #include <asm/io.h>
  32 #include <asm/pci.h>
  33 #include <asm/uaccess.h>
  34
  35 #define KB              1024
  36 #define MB              (1024*KB)
  37 #define GB              (1024*MB)
  38
  39 #define MAJOR_REV       0
  40 #define MINOR_REV       5
  41
  42 /*
  43  * Align VAL to ALIGN, which must be a power of two.
  44  */
  45
  46 #define ALIGN(val,align)        (((val) + ((align) - 1)) & ~((align) - 1))
  47
  48 /*
  49  * Offsets relative to the I/O and memory base addresses from where resources
  50  * are allocated.
  51  */
  52
  53 #define IO_ALLOC_OFFSET         0x00004000
  54 #define MEM_ALLOC_OFFSET        0x04000000
  55
  56 /*
  57  * Declarations of hardware specific initialisation functions.
  58  */
  59
  60 extern struct pci_bus_info *init_hades_pci(void);
  61
  62 /*
  63  * Bus info structure of the PCI bus. A pointer to this structure is
  64  * put in the sysdata member of the pci_bus structure.
  65  */
  66
  67 static struct pci_bus_info *bus_info;
  68
  69 static int pci_modify = 1;              /* If set, layout the PCI bus ourself. */
  70 static int skip_vga;                    /* If set do not modify base addresses
  71                                            of vga cards.*/
  72 static int disable_pci_burst;           /* If set do not allow PCI bursts. */
  73
  74 static unsigned int io_base;
  75 static unsigned int mem_base;
  76
  77 /*
  78  * static void disable_dev(struct pci_dev *dev)
  79  *
  80  * Disable PCI device DEV so that it does not respond to I/O or memory
  81  * accesses.
  82  *
  83  * Parameters:
  84  *
  85  * dev  - device to disable.
  86  */
  87
  88 static void __init disable_dev(struct pci_dev *dev)
  89 {
  90         unsigned short cmd;
  91
  92         if (((dev->class >> 8 == PCI_CLASS_NOT_DEFINED_VGA) ||
  93              (dev->class >> 8 == PCI_CLASS_DISPLAY_VGA) ||
  94              (dev->class >> 8 == PCI_CLASS_DISPLAY_XGA)) && skip_vga)
  95                 return;
  96
  97         pci_read_config_word(dev, PCI_COMMAND, &cmd);
  98
  99         cmd &= (~PCI_COMMAND_IO & ~PCI_COMMAND_MEMORY & ~PCI_COMMAND_MASTER);
 100         pci_write_config_word(dev, PCI_COMMAND, cmd);
 101 }
 102
 103 /*
 104  * static void layout_dev(struct pci_dev *dev)
 105  *
 106  * Layout memory and I/O for a device.
 107  *
 108  * Parameters:
 109  *
 110  * device       - device to layout memory and I/O for.
 111  */
 112
 113 static void __init layout_dev(struct pci_dev *dev)
 114 {
 115         unsigned short cmd;
 116         unsigned int base, mask, size, reg;
 117         unsigned int alignto;
 118         int i;
 119
 120         /*
 121          * Skip video cards if requested.
 122          */
 123
 124         if (((dev->class >> 8 == PCI_CLASS_NOT_DEFINED_VGA) ||
 125              (dev->class >> 8 == PCI_CLASS_DISPLAY_VGA) ||
 126              (dev->class >> 8 == PCI_CLASS_DISPLAY_XGA)) && skip_vga)
 127                 return;
 128
 129         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 130
 131         for (reg = PCI_BASE_ADDRESS_0, i = 0; reg <= PCI_BASE_ADDRESS_5; reg += 4, i++)
 132         {
 133                 /*
 134                  * Figure out how much space and of what type this
 135                  * device wants.
 136                  */
 137
 138                 pci_write_config_dword(dev, reg, 0xffffffff);
 139                 pci_read_config_dword(dev, reg, &base);
 140
 141                 if (!base)
 142                 {
 143                         /* this base-address register is unused */
 144                         dev->resource[i].start = 0;
 145                         dev->resource[i].end = 0;
 146                         dev->resource[i].flags = 0;
 147                         continue;
 148                 }
 149
 150                 /*
 151                  * We've read the base address register back after
 152                  * writing all ones and so now we must decode it.
 153                  */
 154
 155                 if (base & PCI_BASE_ADDRESS_SPACE_IO)
 156                 {
 157                         /*
 158                          * I/O space base address register.
 159                          */
 160
 161                         cmd |= PCI_COMMAND_IO;
 162
 163                         base &= PCI_BASE_ADDRESS_IO_MASK;
 164                         mask = (~base << 1) | 0x1;
 165                         size = (mask & base) & 0xffffffff;
 166
 167                         /*
 168                          * Align to multiple of size of minimum base.
 169                          */
 170
 171                         alignto = max_t(unsigned int, 0x040, size);
 172                         base = ALIGN(io_base, alignto);
 173                         io_base = base + size;
 174                         pci_write_config_dword(dev, reg, base | PCI_BASE_ADDRESS_SPACE_IO);
 175
 176                         dev->resource[i].start = base;
 177                         dev->resource[i].end = dev->resource[i].start + size - 1;
 178                         dev->resource[i].flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
 179
 180                         DBG_DEVS(("layout_dev: IO address: %lX\n", base));
 181                 }
 182                 else
 183                 {
 184                         unsigned int type;
 185
 186                         /*
 187                          * Memory space base address register.
 188                          */
 189
 190                         cmd |= PCI_COMMAND_MEMORY;
 191                         type = base & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
 192                         base &= PCI_BASE_ADDRESS_MEM_MASK;
 193                         mask = (~base << 1) | 0x1;
 194                         size = (mask & base) & 0xffffffff;
 195                         switch (type)
 196                         {
 197                         case PCI_BASE_ADDRESS_MEM_TYPE_32:
 198                         case PCI_BASE_ADDRESS_MEM_TYPE_64:
 199                                 break;
 200
 201                         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
 202                                 printk("bios32 WARNING: slot %d, function %d "
 203                                        "requests memory below 1MB---don't "
 204                                        "know how to do that.\n",
 205                                        PCI_SLOT(dev->devfn),
 206                                        PCI_FUNC(dev->devfn));
 207                                 continue;
 208                         }
 209
 210                         /*
 211                          * Align to multiple of size of minimum base.
 212                          */
 213
 214                         alignto = max_t(unsigned int, 0x1000, size);
 215                         base = ALIGN(mem_base, alignto);
 216                         mem_base = base + size;
 217                         pci_write_config_dword(dev, reg, base);
 218
 219                         dev->resource[i].start = base;
 220                         dev->resource[i].end = dev->resource[i].start + size - 1;
 221                         dev->resource[i].flags = IORESOURCE_MEM;
 222
 223                         if (type == PCI_BASE_ADDRESS_MEM_TYPE_64)
 224                         {
 225                                 /*
 226                                  * 64-bit address, set the highest 32 bits
 227                                  * to zero.
 228                                  */
 229
 230                                 reg += 4;
 231                                 pci_write_config_dword(dev, reg, 0);
 232
 233                                 i++;
 234                                 dev->resource[i].start = 0;
 235                                 dev->resource[i].end = 0;
 236                                 dev->resource[i].flags = 0;
 237                         }
 238                 }
 239         }
 240
 241         /*
 242          * Enable device:
 243          */
 244
 245         if (dev->class >> 8 == PCI_CLASS_NOT_DEFINED ||
 246             dev->class >> 8 == PCI_CLASS_NOT_DEFINED_VGA ||
 247             dev->class >> 8 == PCI_CLASS_DISPLAY_VGA ||
 248             dev->class >> 8 == PCI_CLASS_DISPLAY_XGA)
 249         {
 250                 /*
 251                  * All of these (may) have I/O scattered all around
 252                  * and may not use i/o-base address registers at all.
 253                  * So we just have to always enable I/O to these
 254                  * devices.
 255                  */
 256                 cmd |= PCI_COMMAND_IO;
 257         }
 258
 259         pci_write_config_word(dev, PCI_COMMAND, cmd | PCI_COMMAND_MASTER);
 260
 261         pci_write_config_byte(dev, PCI_LATENCY_TIMER, (disable_pci_burst) ? 0 : 32);
 262
 263         if (bus_info != NULL)
 264                 bus_info->conf_device(dev);     /* Machine dependent configuration. */
 265
 266         DBG_DEVS(("layout_dev: bus %d  slot 0x%x  VID 0x%x  DID 0x%x  class 0x%x\n",
 267                   dev->bus->number, PCI_SLOT(dev->devfn), dev->vendor, dev->device, dev->class));
 268 }
 269
 270 /*
 271  * static void layout_bus(struct pci_bus *bus)
 272  *
 273  * Layout memory and I/O for all devices on the given bus.
 274  *
 275  * Parameters:
 276  *
 277  * bus  - bus.
 278  */
 279
 280 static void __init layout_bus(struct pci_bus *bus)
 281 {
 282         unsigned int bio, bmem;
 283         struct pci_dev *dev;
 284
 285         DBG_DEVS(("layout_bus: starting bus %d\n", bus->number));
 286
 287         if (!bus->devices && !bus->children)
 288                 return;
 289
 290         /*
 291          * Align the current bases on appropriate boundaries (4K for
 292          * IO and 1MB for memory).
 293          */
 294
 295         bio = io_base = ALIGN(io_base, 4*KB);
 296         bmem = mem_base = ALIGN(mem_base, 1*MB);
 297
 298         /*
 299          * PCI devices might have been setup by a PCI BIOS emulation
 300          * running under TOS. In these cases there is a
 301          * window during which two devices may have an overlapping
 302          * address range. To avoid this causing trouble, we first
 303          * turn off the I/O and memory address decoders for all PCI
 304          * devices.  They'll be re-enabled only once all address
 305          * decoders are programmed consistently.
 306          */
 307
 308         DBG_DEVS(("layout_bus: disable_dev for bus %d\n", bus->number));
 309
 310         for (dev = bus->devices; dev; dev = dev->sibling)
 311         {
 312                 if ((dev->class >> 16 != PCI_BASE_CLASS_BRIDGE) ||
 313                     (dev->class >> 8 == PCI_CLASS_BRIDGE_PCMCIA))
 314                         disable_dev(dev);
 315         }
 316
 317         /*
 318          * Allocate space to each device:
 319          */
 320
 321         DBG_DEVS(("layout_bus: starting bus %d devices\n", bus->number));
 322
 323         for (dev = bus->devices; dev; dev = dev->sibling)
 324         {
 325                 if ((dev->class >> 16 != PCI_BASE_CLASS_BRIDGE) ||
 326                     (dev->class >> 8 == PCI_CLASS_BRIDGE_PCMCIA))
 327                         layout_dev(dev);
 328         }
 329
 330         DBG_DEVS(("layout_bus: bus %d finished\n", bus->number));
 331 }
 332
 333 /*
 334  * static void pcibios_fixup(void)
 335  *
 336  * Layout memory and I/O of all devices on the PCI bus if 'pci_modify' is
 337  * true. This might be necessary because not every m68k machine with a PCI
 338  * bus has a PCI BIOS. This function should be called right after
 339  * pci_scan_bus() in pcibios_init().
 340  */
 341
 342 static void __init pcibios_fixup(void)
 343 {
 344         if (pci_modify)
 345         {
 346                 /*
 347                  * Set base addresses for allocation of I/O and memory space.
 348                  */
 349
 350                 io_base = bus_info->io_space.start + IO_ALLOC_OFFSET;
 351                 mem_base = bus_info->mem_space.start + MEM_ALLOC_OFFSET;
 352
 353                 /*
 354                  * Scan the tree, allocating PCI memory and I/O space.
 355                  */
 356
 357                 layout_bus(pci_bus_b(pci_root.next));
 358         }
 359
 360         /*
 361          * Fix interrupt assignments, etc.
 362          */
 363
 364         bus_info->fixup(pci_modify);
 365 }
 366
 367 /*
 368  * static void pcibios_claim_resources(struct pci_bus *bus)
 369  *
 370  * Claim all resources that are assigned to devices on the given bus.
 371  *
 372  * Parameters:
 373  *
 374  * bus  - bus.
 375  */
 376
 377 static void __init pcibios_claim_resources(struct pci_bus *bus)
 378 {
 379         struct pci_dev *dev;
 380         int i;
 381
 382         while (bus)
 383         {
 384                 for (dev = bus->devices; (dev != NULL); dev = dev->sibling)
 385                 {
 386                         for (i = 0; i < PCI_NUM_RESOURCES; i++)
 387                         {
 388                                 struct resource *r = &dev->resource[i];
 389                                 struct resource *pr;
 390                                 struct pci_bus_info *bus_info = (struct pci_bus_info *) dev->sysdata;
 391
 392                                 if ((r->start == 0) || (r->parent != NULL))
 393                                         continue;
 394 #if 1
 395                                 if (r->flags & IORESOURCE_IO)
 396                                         pr = &bus_info->io_space;
 397                                 else
 398                                         pr = &bus_info->mem_space;
 399 #else
 400                                 if (r->flags & IORESOURCE_IO)
 401                                         pr = &ioport_resource;
 402                                 else
 403                                         pr = &iomem_resource;
 404 #endif
 405                                 if (request_resource(pr, r) < 0)
 406                                 {
 407                                         printk(KERN_ERR "PCI: Address space collision on region %d of device %s\n", i, dev->name);
 408                                 }
 409                         }
 410                 }
 411
 412                 if (bus->children)
 413                         pcibios_claim_resources(bus->children);
 414
 415                 bus = bus->next;
 416         }
 417 }
 418
 419 /*
 420  * int pcibios_assign_resource(struct pci_dev *dev, int i)
 421  *
 422  * Assign a new address to a PCI resource.
 423  *
 424  * Parameters:
 425  *
 426  * dev  - device.
 427  * i    - resource.
 428  *
 429  * Result: 0 if successful.
 430  */
 431
 432 int __init pcibios_assign_resource(struct pci_dev *dev, int i)
 433 {
 434         struct resource *r = &dev->resource[i];
 435         struct resource *pr = pci_find_parent_resource(dev, r);
 436         unsigned long size = r->end + 1;
 437
 438         if (!pr)
 439                 return -EINVAL;
 440
 441         if (r->flags & IORESOURCE_IO)
 442         {
 443                 if (size > 0x100)
 444                         return -EFBIG;
 445
 446                 if (allocate_resource(pr, r, size, bus_info->io_space.start +
 447                                       IO_ALLOC_OFFSET,  bus_info->io_space.end, 1024))
 448                         return -EBUSY;
 449         }
 450         else
 451         {
 452                 if (allocate_resource(pr, r, size, bus_info->mem_space.start +
 453                                       MEM_ALLOC_OFFSET, bus_info->mem_space.end, size))
 454                         return -EBUSY;
 455         }
 456
 457         if (i < 6)
 458                 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, r->start);
 459
 460         return 0;
 461 }
 462
 463 void __init pcibios_fixup_bus(struct pci_bus *bus)
 464 {
 465         struct pci_dev *dev;
 466         void *sysdata;
 467
 468         sysdata = (bus->parent) ? bus->parent->sysdata : bus->sysdata;
 469
 470         for (dev = bus->devices; (dev != NULL); dev = dev->sibling)
 471                 dev->sysdata = sysdata;
 472 }
 473
 474 void __init pcibios_init(void)
 475 {
 476         printk("Linux/m68k PCI BIOS32 revision %x.%02x\n", MAJOR_REV, MINOR_REV);
 477
 478         bus_info = NULL;
 479 #ifdef CONFIG_HADES
 480         if (MACH_IS_HADES)
 481                 bus_info = init_hades_pci();
 482 #endif
 483         if (bus_info != NULL)
 484         {
 485                 printk("PCI: Probing PCI hardware\n");
 486                 pci_scan_bus(0, bus_info->m68k_pci_ops, bus_info);
 487                 pcibios_fixup();
 488                 pcibios_claim_resources(pci_root);
 489         }
 490         else
 491                 printk("PCI: No PCI bus detected\n");
 492 }
 493
 494 char * __init pcibios_setup(char *str)
 495 {
 496         if (!strcmp(str, "nomodify"))
 497         {
 498                 pci_modify = 0;
 499                 return NULL;
 500         }
 501         else if (!strcmp(str, "skipvga"))
 502         {
 503                 skip_vga = 1;
 504                 return NULL;
 505         }
 506         else if (!strcmp(str, "noburst"))
 507         {
 508                 disable_pci_burst = 1;
 509                 return NULL;
 510         }
 511
 512         return str;
 513 }
 514 #endif /* CONFIG_PCI */