drivers/parisc/superio.c

   1 /*      National Semiconductor NS87560UBD Super I/O controller used in
   2  *      HP [BCJ]x000 workstations.
   3  *
   4  *      This chip is a horrid piece of engineering, and National
   5  *      denies any knowledge of its existence. Thus no datasheet is
   6  *      available off www.national.com.
   7  *
   8  *      (C) Copyright 2000 Linuxcare, Inc.
   9  *      (C) Copyright 2000 Linuxcare Canada, Inc.
  10  *      (C) Copyright 2000 Martin K. Petersen <mkp@linuxcare.com>
  11  *      (C) Copyright 2000 Alex deVries <alex@linuxcare.com>
  12  *      (C) Copyright 2001 John Marvin <jsm@fc.hp.com>
  13  *
  14  *      This program is free software; you can redistribute it and/or
  15  *      modify it under the terms of the GNU General Public License as
  16  *      published by the Free Software Foundation; either version 2 of
  17  *      the License, or (at your option) any later version.
  18  *
  19  *      The initial version of this is by Martin Peterson.  Alex deVries
  20  *      has spent a bit of time trying to coax it into working.
  21  *
  22  *      Major changes to get basic interrupt infrastructure working to
  23  *      hopefully be able to support all SuperIO devices. Currently
  24  *      works with serial. -- John Marvin <jsm@fc.hp.com>
  25  */
  26
  27
  28 /* NOTES:
  29  *
  30  * Function 0 is an IDE controller. It is identical to a PC87415 IDE
  31  * controller (and identifies itself as such).
  32  *
  33  * Function 1 is a "Legacy I/O" controller. Under this function is a
  34  * whole mess of legacy I/O peripherals. Of course, HP hasn't enabled
  35  * all the functionality in hardware, but the following is available:
  36  *
  37  *      Two 16550A compatible serial controllers
  38  *      An IEEE 1284 compatible parallel port
  39  *      A floppy disk controller
  40  *
  41  * Function 2 is a USB controller.
  42  *
  43  * We must be incredibly careful during initialization.  Since all
  44  * interrupts are routed through function 1 (which is not allowed by
  45  * the PCI spec), we need to program the PICs on the legacy I/O port
  46  * *before* we attempt to set up IDE and USB.  @#$!&
  47  *
  48  * According to HP, devices are only enabled by firmware if they have
  49  * a physical device connected.
  50  *
  51  * Configuration register bits:
  52  *     0x5A: FDC, SP1, IDE1, SP2, IDE2, PAR, Reserved, P92
  53  *     0x5B: RTC, 8259, 8254, DMA1, DMA2, KBC, P61, APM
  54  *
  55  */
  56
  57 #include <linux/errno.h>
  58 #include <linux/init.h>
  59 #include <linux/module.h>
  60 #include <linux/types.h>
  61 #include <linux/interrupt.h>
  62 #include <linux/ioport.h>
  63 #include <linux/serial.h>
  64 #include <linux/pci.h>
  65 #include <linux/ioport.h>
  66 #include <linux/parport.h>
  67 #include <linux/parport_pc.h>
  68 #include <linux/serial_reg.h>
  69 #include <asm/io.h>
  70 #include <asm/hardware.h>
  71 #include <asm/irq.h>
  72 #include <asm/superio.h>
  73
  74 static struct superio_device sio_dev = {
  75         .iosapic_irq = -1
  76 };
  77
  78
  79 #undef DEBUG_INIT
  80
  81 void
  82 superio_inform_irq(int irq)
  83 {
  84     if (sio_dev.iosapic_irq != -1) {
  85         printk(KERN_ERR "SuperIO: superio_inform_irq called twice! (more than one SuperIO?)\n");
  86         BUG();
  87         return;
  88     }
  89
  90     sio_dev.iosapic_irq = irq;
  91 }
  92
  93 static irqreturn_t
  94 superio_interrupt(int irq, void *devp, struct pt_regs *regs)
  95 {
  96         struct superio_device *sio = (struct superio_device *)devp;
  97         u8 results;
  98         u8 local_irq;
  99
 100         /* Poll the 8259 to see if there's an interrupt. */
 101         outb (OCW3_POLL,IC_PIC1+0);
 102
 103         results = inb(IC_PIC1+0);
 104
 105         if ((results & 0x80) == 0) {
 106 #ifndef CONFIG_SMP
 107                 /* HACK: need to investigate why this happens if SMP enabled */
 108                 BUG(); /* This shouldn't happen */
 109 #endif
 110                 return IRQ_HANDLED;
 111         }
 112
 113         /* Check to see which device is interrupting */
 114
 115         local_irq = results & 0x0f;
 116
 117         if (local_irq == 2 || local_irq > 7) {
 118                 printk(KERN_ERR "SuperIO: slave interrupted!\n");
 119                 BUG();
 120                 return IRQ_HANDLED;
 121         }
 122
 123         if (local_irq == 7) {
 124
 125                 /* Could be spurious. Check in service bits */
 126
 127                 outb(OCW3_ISR,IC_PIC1+0);
 128                 results = inb(IC_PIC1+0);
 129                 if ((results & 0x80) == 0) { /* if ISR7 not set: spurious */
 130                         printk(KERN_WARNING "SuperIO: spurious interrupt!\n");
 131                         return IRQ_HANDLED;
 132                 }
 133         }
 134
 135         /* Call the appropriate device's interrupt */
 136
 137         do_irq(&sio->irq_region->action[local_irq],
 138                 sio->irq_region->data.irqbase + local_irq,
 139                 regs);
 140
 141         /* set EOI */
 142
 143         outb((OCW2_SEOI|local_irq),IC_PIC1 + 0);
 144         return IRQ_HANDLED;
 145 }
 146
 147 /* Initialize Super I/O device */
 148
 149 static void __devinit
 150 superio_init(struct superio_device *sio)
 151 {
 152         struct pci_dev *pdev = sio->lio_pdev;
 153         u16 word;
 154         u8  i;
 155
 156         if (!pdev || sio->iosapic_irq == -1) {
 157                 printk(KERN_ERR "All SuperIO functions not found!\n");
 158                 BUG();
 159                 return;
 160         }
 161
 162         printk (KERN_INFO "SuperIO: Found NS87560 Legacy I/O device at %s (IRQ %i) \n",
 163                 pci_name(pdev),sio->iosapic_irq);
 164
 165         /* Find our I/O devices */
 166         pci_read_config_word (pdev, SIO_SP1BAR, &sio->sp1_base);
 167         sio->sp1_base &= ~1;
 168         printk (KERN_INFO "SuperIO: Serial port 1 at 0x%x\n", sio->sp1_base);
 169
 170         pci_read_config_word (pdev, SIO_SP2BAR, &sio->sp2_base);
 171         sio->sp2_base &= ~1;
 172         printk (KERN_INFO "SuperIO: Serial port 2 at 0x%x\n", sio->sp2_base);
 173
 174         pci_read_config_word (pdev, SIO_PPBAR, &sio->pp_base);
 175         sio->pp_base &= ~1;
 176         printk (KERN_INFO "SuperIO: Parallel port at 0x%x\n", sio->pp_base);
 177
 178         pci_read_config_word (pdev, SIO_FDCBAR, &sio->fdc_base);
 179         sio->fdc_base &= ~1;
 180         printk (KERN_INFO "SuperIO: Floppy controller at 0x%x\n", sio->fdc_base);
 181         pci_read_config_word (pdev, SIO_ACPIBAR, &sio->acpi_base);
 182         sio->acpi_base &= ~1;
 183         printk (KERN_INFO "SuperIO: ACPI at 0x%x\n", sio->acpi_base);
 184
 185         request_region (IC_PIC1, 0x1f, "pic1");
 186         request_region (IC_PIC2, 0x1f, "pic2");
 187         request_region (sio->acpi_base, 0x1f, "acpi");
 188
 189         /* Enable the legacy I/O function */
 190         pci_read_config_word (pdev, PCI_COMMAND, &word);
 191         word |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY | PCI_COMMAND_IO;
 192         pci_write_config_word (pdev, PCI_COMMAND, word);
 193         pci_set_master (pdev);
 194
 195         /* Next project is programming the onboard interrupt
 196          * controllers.  PDC hasn't done this for us, since it's using
 197          * polled I/O.
 198          */
 199
 200         /* Set PIC interrupts to edge triggered */
 201         pci_write_config_byte (pdev, TRIGGER_1, 0x0);
 202         pci_write_config_byte (pdev, TRIGGER_2, 0x0);
 203
 204         /* Disable all interrupt routing */
 205         for (i = IR_LOW ; i < IR_HIGH ; i++)
 206                 pci_write_config_byte (pdev, i, 0x0);
 207
 208         /* PIC1 Initialization Command Word register programming */
 209         outb (0x11,IC_PIC1+0);  /* ICW1: ICW4 write req | ICW1 */
 210         outb (0x00,IC_PIC1+1);  /* ICW2: N/A */
 211         outb (0x04,IC_PIC1+1);  /* ICW3: Cascade */
 212         outb (0x01,IC_PIC1+1);  /* ICW4: x86 mode */
 213
 214         /* PIC1 Program Operational Control Words */
 215         outb (0xff,IC_PIC1+1);  /* OCW1: Mask all interrupts */
 216         outb (0xc2,IC_PIC1+0);  /* OCW2: priority (3-7,0-2) */
 217
 218         /* PIC2 Initialization Command Word register programming */
 219         outb (0x11,IC_PIC2+0);  /* ICW1: ICW4 write req | ICW1 */
 220         outb (0x00,IC_PIC2+1);  /* ICW2: N/A */
 221         outb (0x02,IC_PIC2+1);  /* ICW3: Slave ID code */
 222         outb (0x01,IC_PIC2+1);  /* ICW4: x86 mode */
 223
 224         /* Program Operational Control Words */
 225         outb (0xff,IC_PIC1+1);  /* OCW1: Mask all interrupts */
 226         outb (0x68,IC_PIC1+0);  /* OCW3: OCW3 select | ESMM | SMM */
 227
 228         /* Write master mask reg */
 229
 230         outb (0xff,IC_PIC1+1);
 231
 232         /* Set up interrupt routing */
 233
 234         pci_write_config_byte (pdev, IR_USB, 0x10); /* USB on IRQ1 */
 235         pci_write_config_byte (pdev, IR_SER, 0x43); /* SP1 on IRQ3, SP2 on IRQ4 */
 236         pci_write_config_byte (pdev, IR_PFD, 0x65); /* PAR on IRQ5, FDC on IRQ6 */
 237         pci_write_config_byte (pdev, IR_IDE, 0x07); /* IDE1 on IRQ7 */
 238
 239         /* Set USB and IDE to level triggered interrupts, rest to edge */
 240         pci_write_config_byte (pdev, TRIGGER_1, 0x82); /* IRQ 1 and 7 */
 241
 242         /* Setup USB power regulation */
 243         outb(1, sio->acpi_base + USB_REG_CR);
 244         if (inb(sio->acpi_base + USB_REG_CR) & 1)
 245                 printk(KERN_INFO "SuperIO: USB regulator enabled\n");
 246         else
 247                 printk(KERN_ERR "USB regulator not initialized!\n");
 248
 249         pci_enable_device(pdev);
 250
 251         if (request_irq(sio->iosapic_irq,superio_interrupt,SA_INTERRUPT,
 252                         "SuperIO",(void *)sio)) {
 253
 254                 printk(KERN_ERR "SuperIO: could not get irq\n");
 255                 BUG();
 256                 return;
 257         }
 258
 259         sio->iosapic_irq_enabled = 1;
 260
 261 }
 262
 263 static void
 264 superio_disable_irq(void *dev, int local_irq)
 265 {
 266         u8 r8;
 267
 268         if ((local_irq < 1) || (local_irq == 2) || (local_irq > 7)) {
 269             printk(KERN_ERR "SuperIO: Illegal irq number.\n");
 270             BUG();
 271             return;
 272         }
 273
 274         /* Mask interrupt */
 275
 276         r8 = inb(IC_PIC1+1);
 277         r8 |= (1 << local_irq);
 278         outb (r8,IC_PIC1+1);
 279 }
 280
 281 static void
 282 superio_enable_irq(void *dev, int local_irq)
 283 {
 284         struct superio_device *sio = (struct superio_device *)dev;
 285         u8 r8;
 286
 287         if ((local_irq < 1) || (local_irq == 2) || (local_irq > 7)) {
 288             printk(KERN_ERR "SuperIO: Illegal irq number.\n");
 289             BUG();
 290             return;
 291         }
 292
 293         /*
 294          * It's possible that we haven't initialized the legacy IO
 295          * function yet. If not, do it now.
 296          */
 297
 298         if (!sio->iosapic_irq_enabled)
 299                 superio_init(sio);
 300
 301         /* Unmask interrupt */
 302
 303         r8 = inb(IC_PIC1+1);
 304         r8 &= ~(1 << local_irq);
 305         outb (r8,IC_PIC1+1);
 306 }
 307
 308 static void
 309 superio_mask_irq(void *dev, int local_irq)
 310 {
 311         BUG();
 312 }
 313
 314 static void
 315 superio_unmask_irq(void *dev, int local_irq)
 316 {
 317         BUG();
 318 }
 319
 320 static struct irq_region_ops superio_irq_ops = {
 321         .disable_irq =  superio_disable_irq,
 322         .enable_irq =   superio_enable_irq,
 323         .mask_irq =     superio_mask_irq,
 324         .unmask_irq =   superio_unmask_irq
 325 };
 326
 327 #ifdef DEBUG_INIT
 328 static unsigned short expected_device[3] = {
 329         PCI_DEVICE_ID_NS_87415,
 330         PCI_DEVICE_ID_NS_87560_LIO,
 331         PCI_DEVICE_ID_NS_87560_USB
 332 };
 333 #endif
 334
 335 int superio_fixup_irq(struct pci_dev *pcidev)
 336 {
 337         int local_irq;
 338
 339 #ifdef DEBUG_INIT
 340         int fn;
 341         fn = PCI_FUNC(pcidev->devfn);
 342
 343         /* Verify the function number matches the expected device id. */
 344         if (expected_device[fn] != pcidev->device) {
 345                 BUG();
 346                 return -1;
 347         }
 348         printk("superio_fixup_irq(%s) ven 0x%x dev 0x%x from %p\n",
 349                 pci_name(pcidev),
 350                 pcidev->vendor, pcidev->device,
 351                 __builtin_return_address(0));
 352 #endif
 353
 354         if (!sio_dev.irq_region) {
 355                 /* Allocate an irq region for SuperIO devices */
 356                 sio_dev.irq_region = alloc_irq_region(SUPERIO_NIRQS,
 357                                                 &superio_irq_ops,
 358                                                 "SuperIO", (void *) &sio_dev);
 359                 if (!sio_dev.irq_region) {
 360                         printk(KERN_WARNING "SuperIO: alloc_irq_region failed\n");
 361                         return -1;
 362                 }
 363         }
 364
 365         /*
 366          * We don't allocate a SuperIO irq for the legacy IO function,
 367          * since it is a "bridge". Instead, we will allocate irq's for
 368          * each legacy device as they are initialized.
 369          */
 370
 371         switch(pcidev->device) {
 372         case PCI_DEVICE_ID_NS_87415:            /* Function 0 */
 373                 local_irq = IDE_IRQ;
 374                 break;
 375         case PCI_DEVICE_ID_NS_87560_LIO:        /* Function 1 */
 376                 sio_dev.lio_pdev = pcidev; /* save for later initialization */
 377                 return -1;
 378         case PCI_DEVICE_ID_NS_87560_USB:        /* Function 2 */
 379                 local_irq = USB_IRQ;
 380                 break;
 381         default:
 382                 local_irq = -1;
 383                 BUG();
 384                 break;
 385         }
 386
 387         return(sio_dev.irq_region->data.irqbase + local_irq);
 388 }
 389
 390 void __devinit
 391 superio_serial_init(void)
 392 {
 393 #ifdef CONFIG_SERIAL_8250
 394         struct serial_struct *serial;
 395         int retval;
 396
 397         if (!sio_dev.irq_region)
 398                 return; /* superio not present */
 399
 400         if (!sio_dev.iosapic_irq_enabled)
 401                 superio_init(&sio_dev);
 402
 403         serial = kmalloc(2 * sizeof (struct serial_struct), GFP_KERNEL);
 404
 405         if (!serial) {
 406                 printk(KERN_WARNING "SuperIO: Could not get memory for serial struct.\n");
 407                 return;
 408         }
 409
 410         memset(serial, 0, 2 * sizeof (struct serial_struct));
 411
 412         serial->type = PORT_16550A;
 413         serial->line = 0;
 414         serial->port = sio_dev.sp1_base;
 415         serial->port_high = 0;
 416         serial->irq = sio_dev.irq_region->data.irqbase + SP1_IRQ;
 417         serial->io_type = SERIAL_IO_PORT;
 418         serial->flags = 0;
 419         serial->xmit_fifo_size = 16;
 420         serial->custom_divisor = 0;
 421         serial->baud_base = 115200;
 422
 423         retval = register_serial(serial);
 424         if (retval < 0) {
 425                 printk(KERN_WARNING "SuperIO: Register Serial #0 failed.\n");
 426                 kfree (serial);
 427                 return;
 428         }
 429
 430         serial++;
 431
 432         serial->type = PORT_16550A;
 433         serial->line = 1;
 434         serial->port = sio_dev.sp2_base;
 435         serial->port_high = 0;
 436         serial->irq = sio_dev.irq_region->data.irqbase + SP2_IRQ;
 437         serial->io_type = SERIAL_IO_PORT;
 438         serial->flags = 0;
 439         serial->xmit_fifo_size = 16;
 440         serial->custom_divisor = 0;
 441         serial->baud_base = 115200;
 442
 443         retval = register_serial(serial);
 444         if (retval < 0)
 445                 printk(KERN_WARNING "SuperIO: Register Serial #1 failed.\n");
 446 #endif /* CONFIG_SERIAL_8250 */
 447 }
 448
 449 EXPORT_SYMBOL(superio_serial_init);
 450
 451
 452 #ifdef CONFIG_PARPORT_PC
 453 void __devinit
 454 superio_parport_init(void)
 455 {
 456         if (!sio_dev.irq_region)
 457                 return; /* superio not present */
 458
 459         if (!sio_dev.iosapic_irq_enabled)
 460                 superio_init(&sio_dev);
 461
 462         if (!parport_pc_probe_port(sio_dev.pp_base,
 463                 0 /*base_hi*/,
 464                 sio_dev.irq_region->data.irqbase + PAR_IRQ,
 465                 PARPORT_DMA_NONE /* dma */,
 466                 NULL /*struct pci_dev* */))
 467
 468                 printk(KERN_WARNING "SuperIO: Probing parallel port failed.\n");
 469 }
 470
 471 EXPORT_SYMBOL(superio_parport_init);
 472 #endif  /* CONFIG_PARPORT_PC */
 473
 474
 475 int
 476 superio_get_ide_irq(void)
 477 {
 478         if (sio_dev.irq_region)
 479                 return sio_dev.irq_region->data.irqbase + IDE_IRQ;
 480         else
 481                 return 0;
 482 }
 483
 484 EXPORT_SYMBOL(superio_get_ide_irq);
 485
 486 static int __devinit superio_probe(struct pci_dev *dev, const struct pci_device_id *id)
 487 {
 488 #ifdef DEBUG_INIT
 489         printk("superio_probe(%s) ven 0x%x dev 0x%x sv 0x%x sd 0x%x class 0x%x\n",
 490                 pci_name(dev),
 491                 dev->vendor, dev->device,
 492                 dev->subsystem_vendor, dev->subsystem_device,
 493                 dev->class);
 494 /*
 495 ** superio_probe(00:0e.0) ven 0x100b dev 0x2 sv 0x0 sd 0x0 class 0x1018a
 496 ** superio_probe(00:0e.1) ven 0x100b dev 0xe sv 0x0 sd 0x0 class 0x68000
 497 ** superio_probe(00:0e.2) ven 0x100b dev 0x12 sv 0x0 sd 0x0 class 0xc0310
 498 */
 499 #endif
 500
 501         /* superio_fixup_irq(dev); */
 502
 503         if (dev->device == PCI_DEVICE_ID_NS_87560_LIO) {
 504 #ifdef CONFIG_PARPORT_PC
 505                 superio_parport_init();
 506 #endif
 507 #ifdef CONFIG_SERIAL_8250
 508                 superio_serial_init();
 509 #endif
 510                 /* REVISIT : superio_fdc_init() ? */
 511                 return 0;
 512         } else {
 513                 /* don't claim this device; let whatever either driver
 514                  * do it
 515                  */
 516                 return -1;
 517         }
 518 }
 519
 520 static struct pci_device_id superio_tbl[] = {
 521         { PCI_VENDOR_ID_NS, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 522         { 0, }
 523 };
 524
 525 static struct pci_driver superio_driver = {
 526         .name =         "SuperIO",
 527         .id_table =     superio_tbl,
 528         .probe =        superio_probe,
 529 };
 530
 531 static int __init superio_modinit(void)
 532 {
 533         return pci_module_init(&superio_driver);
 534 }
 535
 536 static void __exit superio_exit(void)
 537 {
 538         pci_unregister_driver(&superio_driver);
 539 }
 540
 541 /* Make late initcall to ensure the serial and tty layers are initialised
 542  * before we start superio.
 543  *
 544  * FIXME: does this break the superio console?
 545  */
 546 late_initcall(superio_modinit);
 547 module_exit(superio_exit);