Blame view
drivers/parisc/eisa.c
11.5 KB
2874c5fd2
|
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4c
|
2 3 4 |
/* * eisa.c - provide support for EISA adapters in PA-RISC machines * |
1da177e4c
|
5 6 7 8 9 10 11 12 |
* Copyright (c) 2001 Matthew Wilcox for Hewlett Packard * Copyright (c) 2001 Daniel Engstrom <5116@telia.com> * * There are two distinct EISA adapters. Mongoose is found in machines * before the 712; then the Wax ASIC is used. To complicate matters, the * Wax ASIC also includes a PS/2 and RS-232 controller, but those are * dealt with elsewhere; this file is concerned only with the EISA portions * of Wax. |
99cde44ed
|
13 |
* |
1da177e4c
|
14 15 16 |
* HINT: * ----- * To allow an ISA card to work properly in the EISA slot you need to |
99cde44ed
|
17 18 |
* set an edge trigger level. This may be done on the palo command line * by adding the kernel parameter "eisa_irq_edge=n,n2,[...]]", with |
1da177e4c
|
19 |
* n and n2 as the irq levels you want to use. |
99cde44ed
|
20 21 |
* * Example: "eisa_irq_edge=10,11" allows ISA cards to operate at |
1da177e4c
|
22 23 24 25 26 27 28 29 30 |
* irq levels 10 and 11. */ #include <linux/init.h> #include <linux/ioport.h> #include <linux/interrupt.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/pci.h> |
1da177e4c
|
31 32 33 34 35 36 37 38 39 40 41 |
#include <linux/spinlock.h> #include <linux/eisa.h> #include <asm/byteorder.h> #include <asm/io.h> #include <asm/hardware.h> #include <asm/processor.h> #include <asm/parisc-device.h> #include <asm/delay.h> #include <asm/eisa_bus.h> #include <asm/eisa_eeprom.h> |
9b8eeab01
|
42 |
#include "iommu.h" |
1da177e4c
|
43 |
#if 0 |
99cde44ed
|
44 |
#define EISA_DBG(msg, arg...) printk(KERN_DEBUG "eisa: " msg, ## arg) |
1da177e4c
|
45 |
#else |
99cde44ed
|
46 |
#define EISA_DBG(msg, arg...) |
1da177e4c
|
47 48 49 50 51 52 |
#endif #define SNAKES_EEPROM_BASE_ADDR 0xF0810400 #define MIRAGE_EEPROM_BASE_ADDR 0xF00C0400 static DEFINE_SPINLOCK(eisa_irq_lock); |
8039de10a
|
53 |
void __iomem *eisa_eeprom_addr __read_mostly; |
1da177e4c
|
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
/* We can only have one EISA adapter in the system because neither * implementation can be flexed. */ static struct eisa_ba { struct pci_hba_data hba; unsigned long eeprom_addr; struct eisa_root_device root; } eisa_dev; /* Port ops */ static inline unsigned long eisa_permute(unsigned short port) { if (port & 0x300) { return 0xfc000000 | ((port & 0xfc00) >> 6) | ((port & 0x3f8) << 9) | (port & 7); } else { return 0xfc000000 | port; } } unsigned char eisa_in8(unsigned short port) { if (EISA_bus) return gsc_readb(eisa_permute(port)); return 0xff; } unsigned short eisa_in16(unsigned short port) { if (EISA_bus) return le16_to_cpu(gsc_readw(eisa_permute(port))); return 0xffff; } unsigned int eisa_in32(unsigned short port) { if (EISA_bus) return le32_to_cpu(gsc_readl(eisa_permute(port))); return 0xffffffff; } void eisa_out8(unsigned char data, unsigned short port) { if (EISA_bus) gsc_writeb(data, eisa_permute(port)); } void eisa_out16(unsigned short data, unsigned short port) { |
99cde44ed
|
105 |
if (EISA_bus) |
1da177e4c
|
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 |
gsc_writew(cpu_to_le16(data), eisa_permute(port)); } void eisa_out32(unsigned int data, unsigned short port) { if (EISA_bus) gsc_writel(cpu_to_le32(data), eisa_permute(port)); } #ifndef CONFIG_PCI /* We call these directly without PCI. See asm/io.h. */ EXPORT_SYMBOL(eisa_in8); EXPORT_SYMBOL(eisa_in16); EXPORT_SYMBOL(eisa_in32); EXPORT_SYMBOL(eisa_out8); EXPORT_SYMBOL(eisa_out16); EXPORT_SYMBOL(eisa_out32); #endif /* Interrupt handling */ /* cached interrupt mask registers */ static int master_mask; static int slave_mask; /* the trig level can be set with the |
99cde44ed
|
132 133 134 |
* eisa_irq_edge=n,n,n commandline parameter * We should really read this from the EEPROM * in the furure. |
1da177e4c
|
135 136 |
*/ /* irq 13,8,2,1,0 must be edge */ |
8039de10a
|
137 |
static unsigned int eisa_irq_level __read_mostly; /* default to edge triggered */ |
1da177e4c
|
138 139 140 |
/* called by free irq */ |
4c4231ea2
|
141 |
static void eisa_mask_irq(struct irq_data *d) |
1da177e4c
|
142 |
{ |
4c4231ea2
|
143 |
unsigned int irq = d->irq; |
1da177e4c
|
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
unsigned long flags; EISA_DBG("disable irq %d ", irq); /* just mask for now */ spin_lock_irqsave(&eisa_irq_lock, flags); if (irq & 8) { slave_mask |= (1 << (irq&7)); eisa_out8(slave_mask, 0xa1); } else { master_mask |= (1 << (irq&7)); eisa_out8(master_mask, 0x21); } spin_unlock_irqrestore(&eisa_irq_lock, flags); EISA_DBG("pic0 mask %02x ", eisa_in8(0x21)); EISA_DBG("pic1 mask %02x ", eisa_in8(0xa1)); } /* called by request irq */ |
4c4231ea2
|
165 |
static void eisa_unmask_irq(struct irq_data *d) |
1da177e4c
|
166 |
{ |
4c4231ea2
|
167 |
unsigned int irq = d->irq; |
1da177e4c
|
168 169 170 |
unsigned long flags; EISA_DBG("enable irq %d ", irq); |
99cde44ed
|
171 |
|
1da177e4c
|
172 173 174 175 176 177 178 179 180 181 182 183 184 185 |
spin_lock_irqsave(&eisa_irq_lock, flags); if (irq & 8) { slave_mask &= ~(1 << (irq&7)); eisa_out8(slave_mask, 0xa1); } else { master_mask &= ~(1 << (irq&7)); eisa_out8(master_mask, 0x21); } spin_unlock_irqrestore(&eisa_irq_lock, flags); EISA_DBG("pic0 mask %02x ", eisa_in8(0x21)); EISA_DBG("pic1 mask %02x ", eisa_in8(0xa1)); } |
dfe075650
|
186 |
static struct irq_chip eisa_interrupt_type = { |
4c4231ea2
|
187 188 189 |
.name = "EISA", .irq_unmask = eisa_unmask_irq, .irq_mask = eisa_mask_irq, |
1da177e4c
|
190 |
}; |
7d12e780e
|
191 |
static irqreturn_t eisa_irq(int wax_irq, void *intr_dev) |
1da177e4c
|
192 193 194 |
{ int irq = gsc_readb(0xfc01f000); /* EISA supports 16 irqs */ unsigned long flags; |
99cde44ed
|
195 |
|
1da177e4c
|
196 197 198 199 200 201 202 203 |
spin_lock_irqsave(&eisa_irq_lock, flags); /* read IRR command */ eisa_out8(0x0a, 0x20); eisa_out8(0x0a, 0xa0); EISA_DBG("irq IAR %02x 8259-1 irr %02x 8259-2 irr %02x ", irq, eisa_in8(0x20), eisa_in8(0xa0)); |
99cde44ed
|
204 |
|
1da177e4c
|
205 206 207 208 209 210 |
/* read ISR command */ eisa_out8(0x0a, 0x20); eisa_out8(0x0a, 0xa0); EISA_DBG("irq 8259-1 isr %02x imr %02x 8259-2 isr %02x imr %02x ", eisa_in8(0x20), eisa_in8(0x21), eisa_in8(0xa0), eisa_in8(0xa1)); |
99cde44ed
|
211 |
|
1da177e4c
|
212 |
irq &= 0xf; |
99cde44ed
|
213 |
|
1da177e4c
|
214 215 216 217 218 |
/* mask irq and write eoi */ if (irq & 8) { slave_mask |= (1 << (irq&7)); eisa_out8(slave_mask, 0xa1); eisa_out8(0x60 | (irq&7),0xa0);/* 'Specific EOI' to slave */ |
99cde44ed
|
219 |
eisa_out8(0x62, 0x20); /* 'Specific EOI' to master-IRQ2 */ |
1da177e4c
|
220 221 222 |
} else { master_mask |= (1 << (irq&7)); eisa_out8(master_mask, 0x21); |
99cde44ed
|
223 |
eisa_out8(0x60|irq, 0x20); /* 'Specific EOI' to master */ |
1da177e4c
|
224 225 |
} spin_unlock_irqrestore(&eisa_irq_lock, flags); |
ba20085c2
|
226 |
generic_handle_irq(irq); |
99cde44ed
|
227 |
|
1da177e4c
|
228 229 230 231 232 233 234 235 236 237 238 239 |
spin_lock_irqsave(&eisa_irq_lock, flags); /* unmask */ if (irq & 8) { slave_mask &= ~(1 << (irq&7)); eisa_out8(slave_mask, 0xa1); } else { master_mask &= ~(1 << (irq&7)); eisa_out8(master_mask, 0x21); } spin_unlock_irqrestore(&eisa_irq_lock, flags); return IRQ_HANDLED; } |
7d12e780e
|
240 |
static irqreturn_t dummy_irq2_handler(int _, void *dev) |
1da177e4c
|
241 242 243 244 245 |
{ printk(KERN_ALERT "eisa: uhh, irq2? "); return IRQ_HANDLED; } |
1da177e4c
|
246 247 248 |
static void init_eisa_pic(void) { unsigned long flags; |
99cde44ed
|
249 |
|
1da177e4c
|
250 251 252 253 |
spin_lock_irqsave(&eisa_irq_lock, flags); eisa_out8(0xff, 0x21); /* mask during init */ eisa_out8(0xff, 0xa1); /* mask during init */ |
99cde44ed
|
254 |
|
1da177e4c
|
255 |
/* master pic */ |
99cde44ed
|
256 257 258 259 260 |
eisa_out8(0x11, 0x20); /* ICW1 */ eisa_out8(0x00, 0x21); /* ICW2 */ eisa_out8(0x04, 0x21); /* ICW3 */ eisa_out8(0x01, 0x21); /* ICW4 */ eisa_out8(0x40, 0x20); /* OCW2 */ |
1da177e4c
|
261 |
/* slave pic */ |
99cde44ed
|
262 263 264 265 266 |
eisa_out8(0x11, 0xa0); /* ICW1 */ eisa_out8(0x08, 0xa1); /* ICW2 */ eisa_out8(0x02, 0xa1); /* ICW3 */ eisa_out8(0x01, 0xa1); /* ICW4 */ eisa_out8(0x40, 0xa0); /* OCW2 */ |
1da177e4c
|
267 |
udelay(100); |
99cde44ed
|
268 269 270 |
slave_mask = 0xff; master_mask = 0xfb; |
1da177e4c
|
271 272 |
eisa_out8(slave_mask, 0xa1); /* OCW1 */ eisa_out8(master_mask, 0x21); /* OCW1 */ |
99cde44ed
|
273 |
|
1da177e4c
|
274 275 276 |
/* setup trig level */ EISA_DBG("EISA edge/level %04x ", eisa_irq_level); |
99cde44ed
|
277 |
|
1da177e4c
|
278 |
eisa_out8(eisa_irq_level&0xff, 0x4d0); /* Set all irq's to edge */ |
99cde44ed
|
279 |
eisa_out8((eisa_irq_level >> 8) & 0xff, 0x4d1); |
1da177e4c
|
280 281 282 283 284 285 286 287 |
EISA_DBG("pic0 mask %02x ", eisa_in8(0x21)); EISA_DBG("pic1 mask %02x ", eisa_in8(0xa1)); EISA_DBG("pic0 edge/level %02x ", eisa_in8(0x4d0)); EISA_DBG("pic1 edge/level %02x ", eisa_in8(0x4d1)); |
99cde44ed
|
288 |
|
1da177e4c
|
289 290 291 292 293 294 |
spin_unlock_irqrestore(&eisa_irq_lock, flags); } /* Device initialisation */ #define is_mongoose(dev) (dev->id.sversion == 0x00076) |
6fe077fd3
|
295 |
static int __init eisa_probe(struct parisc_device *dev) |
1da177e4c
|
296 297 298 299 |
{ int i, result; char *name = is_mongoose(dev) ? "Mongoose" : "Wax"; |
99cde44ed
|
300 301 |
printk(KERN_INFO "%s EISA Adapter found at 0x%08lx ", |
c18b46089
|
302 |
name, (unsigned long)dev->hpa.start); |
1da177e4c
|
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 |
eisa_dev.hba.dev = dev; eisa_dev.hba.iommu = ccio_get_iommu(dev); eisa_dev.hba.lmmio_space.name = "EISA"; eisa_dev.hba.lmmio_space.start = F_EXTEND(0xfc000000); eisa_dev.hba.lmmio_space.end = F_EXTEND(0xffbfffff); eisa_dev.hba.lmmio_space.flags = IORESOURCE_MEM; result = ccio_request_resource(dev, &eisa_dev.hba.lmmio_space); if (result < 0) { printk(KERN_ERR "EISA: failed to claim EISA Bus address space! "); return result; } eisa_dev.hba.io_space.name = "EISA"; eisa_dev.hba.io_space.start = 0; eisa_dev.hba.io_space.end = 0xffff; eisa_dev.hba.lmmio_space.flags = IORESOURCE_IO; result = request_resource(&ioport_resource, &eisa_dev.hba.io_space); if (result < 0) { printk(KERN_ERR "EISA: failed to claim EISA Bus port space! "); return result; } pcibios_register_hba(&eisa_dev.hba); |
8c56e7214
|
328 |
result = request_irq(dev->irq, eisa_irq, IRQF_SHARED, "EISA", &eisa_dev); |
1da177e4c
|
329 330 331 |
if (result) { printk(KERN_ERR "EISA: request_irq failed! "); |
af640d17e
|
332 |
goto error_release; |
1da177e4c
|
333 |
} |
99cde44ed
|
334 |
|
1da177e4c
|
335 |
/* Reserve IRQ2 */ |
997ba6573
|
336 337 338 |
if (request_irq(2, dummy_irq2_handler, 0, "cascade", NULL)) pr_err("Failed to request irq 2 (cascade) "); |
1da177e4c
|
339 |
for (i = 0; i < 16; i++) { |
e2f571d29
|
340 |
irq_set_chip_and_handler(i, &eisa_interrupt_type, |
51890613f
|
341 |
handle_simple_irq); |
1da177e4c
|
342 |
} |
99cde44ed
|
343 |
|
1da177e4c
|
344 345 346 347 348 349 350 351 352 353 354 355 356 |
EISA_bus = 1; if (dev->num_addrs) { /* newer firmware hand out the eeprom address */ eisa_dev.eeprom_addr = dev->addr[0]; } else { /* old firmware, need to figure out the box */ if (is_mongoose(dev)) { eisa_dev.eeprom_addr = SNAKES_EEPROM_BASE_ADDR; } else { eisa_dev.eeprom_addr = MIRAGE_EEPROM_BASE_ADDR; } } |
4bdc0d676
|
357 |
eisa_eeprom_addr = ioremap(eisa_dev.eeprom_addr, HPEE_MAX_LENGTH); |
af640d17e
|
358 359 |
if (!eisa_eeprom_addr) { result = -ENOMEM; |
4bdc0d676
|
360 361 |
printk(KERN_ERR "EISA: ioremap failed! "); |
af640d17e
|
362 363 |
goto error_free_irq; } |
1da177e4c
|
364 365 366 367 368 369 370 |
result = eisa_enumerator(eisa_dev.eeprom_addr, &eisa_dev.hba.io_space, &eisa_dev.hba.lmmio_space); init_eisa_pic(); if (result >= 0) { /* FIXME : Don't enumerate the bus twice. */ eisa_dev.root.dev = &dev->dev; |
d18dbfa7a
|
371 |
dev_set_drvdata(&dev->dev, &eisa_dev.root); |
1da177e4c
|
372 373 374 375 376 377 378 |
eisa_dev.root.bus_base_addr = 0; eisa_dev.root.res = &eisa_dev.hba.io_space; eisa_dev.root.slots = result; eisa_dev.root.dma_mask = 0xffffffff; /* wild guess */ if (eisa_root_register (&eisa_dev.root)) { printk(KERN_ERR "EISA: Failed to register EISA root "); |
af640d17e
|
379 380 |
result = -ENOMEM; goto error_iounmap; |
1da177e4c
|
381 382 |
} } |
99cde44ed
|
383 |
|
1da177e4c
|
384 |
return 0; |
af640d17e
|
385 386 387 388 389 390 391 392 |
error_iounmap: iounmap(eisa_eeprom_addr); error_free_irq: free_irq(dev->irq, &eisa_dev); error_release: release_resource(&eisa_dev.hba.io_space); return result; |
1da177e4c
|
393 |
} |
cfe4fbfb2
|
394 |
static const struct parisc_device_id eisa_tbl[] __initconst = { |
1da177e4c
|
395 396 397 398 399 400 |
{ HPHW_BA, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00076 }, /* Mongoose */ { HPHW_BA, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00090 }, /* Wax EISA */ { 0, } }; MODULE_DEVICE_TABLE(parisc, eisa_tbl); |
cfe4fbfb2
|
401 |
static struct parisc_driver eisa_driver __refdata = { |
bdad1f836
|
402 |
.name = "eisa_ba", |
1da177e4c
|
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 |
.id_table = eisa_tbl, .probe = eisa_probe, }; void __init eisa_init(void) { register_parisc_driver(&eisa_driver); } static unsigned int eisa_irq_configured; void eisa_make_irq_level(int num) { if (eisa_irq_configured& (1<<num)) { printk(KERN_WARNING |
99cde44ed
|
418 419 |
"IRQ %d polarity configured twice (last to level) ", |
1da177e4c
|
420 421 422 423 424 425 426 427 428 |
num); } eisa_irq_level |= (1<<num); /* set the corresponding bit */ eisa_irq_configured |= (1<<num); /* set the corresponding bit */ } void eisa_make_irq_edge(int num) { if (eisa_irq_configured& (1<<num)) { |
99cde44ed
|
429 |
printk(KERN_WARNING |
1da177e4c
|
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 |
"IRQ %d polarity configured twice (last to edge) ", num); } eisa_irq_level &= ~(1<<num); /* clear the corresponding bit */ eisa_irq_configured |= (1<<num); /* set the corresponding bit */ } static int __init eisa_irq_setup(char *str) { char *cur = str; int val; EISA_DBG("IRQ setup "); while (cur != NULL) { char *pe; |
99cde44ed
|
447 |
|
1da177e4c
|
448 449 450 451 452 453 |
val = (int) simple_strtoul(cur, &pe, 0); if (val > 15 || val < 0) { printk(KERN_ERR "eisa: EISA irq value are 0-15 "); continue; } |
99cde44ed
|
454 |
if (val == 2) { |
1da177e4c
|
455 456 457 458 459 |
val = 9; } eisa_make_irq_edge(val); /* clear the corresponding bit */ EISA_DBG("setting IRQ %d to edge-triggered mode ", val); |
99cde44ed
|
460 |
|
1da177e4c
|
461 462 463 464 465 466 467 468 469 470 |
if ((cur = strchr(cur, ','))) { cur++; } else { break; } } return 1; } __setup("eisa_irq_edge=", eisa_irq_setup); |