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