1/* $Id: ebus.c,v 1.1.1.1 2007/08/03 18:52:18 Exp $ 2 * ebus.c: PCI to EBus bridge device. 3 * 4 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be) 5 * Copyright (C) 1999 David S. Miller (davem@redhat.com) 6 */ 7 8#include <linux/module.h> 9#include <linux/kernel.h> 10#include <linux/types.h> 11#include <linux/init.h> 12#include <linux/slab.h> 13#include <linux/string.h> 14#include <linux/interrupt.h> 15#include <linux/delay.h> 16#include <linux/pci.h> 17 18#include <asm/system.h> 19#include <asm/page.h> 20#include <asm/ebus.h> 21#include <asm/oplib.h> 22#include <asm/prom.h> 23#include <asm/of_device.h> 24#include <asm/bpp.h> 25#include <asm/irq.h> 26#include <asm/io.h> 27 28/* EBUS dma library. */ 29 30#define EBDMA_CSR 0x00UL /* Control/Status */ 31#define EBDMA_ADDR 0x04UL /* DMA Address */ 32#define EBDMA_COUNT 0x08UL /* DMA Count */ 33 34#define EBDMA_CSR_INT_PEND 0x00000001 35#define EBDMA_CSR_ERR_PEND 0x00000002 36#define EBDMA_CSR_DRAIN 0x00000004 37#define EBDMA_CSR_INT_EN 0x00000010 38#define EBDMA_CSR_RESET 0x00000080 39#define EBDMA_CSR_WRITE 0x00000100 40#define EBDMA_CSR_EN_DMA 0x00000200 41#define EBDMA_CSR_CYC_PEND 0x00000400 42#define EBDMA_CSR_DIAG_RD_DONE 0x00000800 43#define EBDMA_CSR_DIAG_WR_DONE 0x00001000 44#define EBDMA_CSR_EN_CNT 0x00002000 45#define EBDMA_CSR_TC 0x00004000 46#define EBDMA_CSR_DIS_CSR_DRN 0x00010000 47#define EBDMA_CSR_BURST_SZ_MASK 0x000c0000 48#define EBDMA_CSR_BURST_SZ_1 0x00080000 49#define EBDMA_CSR_BURST_SZ_4 0x00000000 50#define EBDMA_CSR_BURST_SZ_8 0x00040000 51#define EBDMA_CSR_BURST_SZ_16 0x000c0000 52#define EBDMA_CSR_DIAG_EN 0x00100000 53#define EBDMA_CSR_DIS_ERR_PEND 0x00400000 54#define EBDMA_CSR_TCI_DIS 0x00800000 55#define EBDMA_CSR_EN_NEXT 0x01000000 56#define EBDMA_CSR_DMA_ON 0x02000000 57#define EBDMA_CSR_A_LOADED 0x04000000 58#define EBDMA_CSR_NA_LOADED 0x08000000 59#define EBDMA_CSR_DEV_ID_MASK 0xf0000000 60 61#define EBUS_DMA_RESET_TIMEOUT 10000 62 63static void __ebus_dma_reset(struct ebus_dma_info *p, int no_drain) 64{ 65 int i; 66 u32 val = 0; 67 68 writel(EBDMA_CSR_RESET, p->regs + EBDMA_CSR); 69 udelay(1); 70 71 if (no_drain) 72 return; 73 74 for (i = EBUS_DMA_RESET_TIMEOUT; i > 0; i--) { 75 val = readl(p->regs + EBDMA_CSR); 76 77 if (!(val & (EBDMA_CSR_DRAIN | EBDMA_CSR_CYC_PEND))) 78 break; 79 udelay(10); 80 } 81} 82 83static irqreturn_t ebus_dma_irq(int irq, void *dev_id) 84{ 85 struct ebus_dma_info *p = dev_id; 86 unsigned long flags; 87 u32 csr = 0; 88 89 spin_lock_irqsave(&p->lock, flags); 90 csr = readl(p->regs + EBDMA_CSR); 91 writel(csr, p->regs + EBDMA_CSR); 92 spin_unlock_irqrestore(&p->lock, flags); 93 94 if (csr & EBDMA_CSR_ERR_PEND) { 95 printk(KERN_CRIT "ebus_dma(%s): DMA error!\n", p->name); 96 p->callback(p, EBUS_DMA_EVENT_ERROR, p->client_cookie); 97 return IRQ_HANDLED; 98 } else if (csr & EBDMA_CSR_INT_PEND) { 99 p->callback(p, 100 (csr & EBDMA_CSR_TC) ? 101 EBUS_DMA_EVENT_DMA : EBUS_DMA_EVENT_DEVICE, 102 p->client_cookie); 103 return IRQ_HANDLED; 104 } 105 106 return IRQ_NONE; 107 108} 109 110int ebus_dma_register(struct ebus_dma_info *p) 111{ 112 u32 csr; 113 114 if (!p->regs) 115 return -EINVAL; 116 if (p->flags & ~(EBUS_DMA_FLAG_USE_EBDMA_HANDLER | 117 EBUS_DMA_FLAG_TCI_DISABLE)) 118 return -EINVAL; 119 if ((p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) && !p->callback) 120 return -EINVAL; 121 if (!strlen(p->name)) 122 return -EINVAL; 123 124 __ebus_dma_reset(p, 1); 125 126 csr = EBDMA_CSR_BURST_SZ_16 | EBDMA_CSR_EN_CNT; 127 128 if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE) 129 csr |= EBDMA_CSR_TCI_DIS; 130 131 writel(csr, p->regs + EBDMA_CSR); 132 133 return 0; 134} 135EXPORT_SYMBOL(ebus_dma_register); 136 137int ebus_dma_irq_enable(struct ebus_dma_info *p, int on) 138{ 139 unsigned long flags; 140 u32 csr; 141 142 if (on) { 143 if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) { 144 if (request_irq(p->irq, ebus_dma_irq, IRQF_SHARED, p->name, p)) 145 return -EBUSY; 146 } 147 148 spin_lock_irqsave(&p->lock, flags); 149 csr = readl(p->regs + EBDMA_CSR); 150 csr |= EBDMA_CSR_INT_EN; 151 writel(csr, p->regs + EBDMA_CSR); 152 spin_unlock_irqrestore(&p->lock, flags); 153 } else { 154 spin_lock_irqsave(&p->lock, flags); 155 csr = readl(p->regs + EBDMA_CSR); 156 csr &= ~EBDMA_CSR_INT_EN; 157 writel(csr, p->regs + EBDMA_CSR); 158 spin_unlock_irqrestore(&p->lock, flags); 159 160 if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) { 161 free_irq(p->irq, p); 162 } 163 } 164 165 return 0; 166} 167EXPORT_SYMBOL(ebus_dma_irq_enable); 168 169void ebus_dma_unregister(struct ebus_dma_info *p) 170{ 171 unsigned long flags; 172 u32 csr; 173 int irq_on = 0; 174 175 spin_lock_irqsave(&p->lock, flags); 176 csr = readl(p->regs + EBDMA_CSR); 177 if (csr & EBDMA_CSR_INT_EN) { 178 csr &= ~EBDMA_CSR_INT_EN; 179 writel(csr, p->regs + EBDMA_CSR); 180 irq_on = 1; 181 } 182 spin_unlock_irqrestore(&p->lock, flags); 183 184 if (irq_on) 185 free_irq(p->irq, p); 186} 187EXPORT_SYMBOL(ebus_dma_unregister); 188 189int ebus_dma_request(struct ebus_dma_info *p, dma_addr_t bus_addr, size_t len) 190{ 191 unsigned long flags; 192 u32 csr; 193 int err; 194 195 if (len >= (1 << 24)) 196 return -EINVAL; 197 198 spin_lock_irqsave(&p->lock, flags); 199 csr = readl(p->regs + EBDMA_CSR); 200 err = -EINVAL; 201 if (!(csr & EBDMA_CSR_EN_DMA)) 202 goto out; 203 err = -EBUSY; 204 if (csr & EBDMA_CSR_NA_LOADED) 205 goto out; 206 207 writel(len, p->regs + EBDMA_COUNT); 208 writel(bus_addr, p->regs + EBDMA_ADDR); 209 err = 0; 210 211out: 212 spin_unlock_irqrestore(&p->lock, flags); 213 214 return err; 215} 216EXPORT_SYMBOL(ebus_dma_request); 217 218void ebus_dma_prepare(struct ebus_dma_info *p, int write) 219{ 220 unsigned long flags; 221 u32 csr; 222 223 spin_lock_irqsave(&p->lock, flags); 224 __ebus_dma_reset(p, 0); 225 226 csr = (EBDMA_CSR_INT_EN | 227 EBDMA_CSR_EN_CNT | 228 EBDMA_CSR_BURST_SZ_16 | 229 EBDMA_CSR_EN_NEXT); 230 231 if (write) 232 csr |= EBDMA_CSR_WRITE; 233 if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE) 234 csr |= EBDMA_CSR_TCI_DIS; 235 236 writel(csr, p->regs + EBDMA_CSR); 237 238 spin_unlock_irqrestore(&p->lock, flags); 239} 240EXPORT_SYMBOL(ebus_dma_prepare); 241 242unsigned int ebus_dma_residue(struct ebus_dma_info *p) 243{ 244 return readl(p->regs + EBDMA_COUNT); 245} 246EXPORT_SYMBOL(ebus_dma_residue); 247 248unsigned int ebus_dma_addr(struct ebus_dma_info *p) 249{ 250 return readl(p->regs + EBDMA_ADDR); 251} 252EXPORT_SYMBOL(ebus_dma_addr); 253 254void ebus_dma_enable(struct ebus_dma_info *p, int on) 255{ 256 unsigned long flags; 257 u32 orig_csr, csr; 258 259 spin_lock_irqsave(&p->lock, flags); 260 orig_csr = csr = readl(p->regs + EBDMA_CSR); 261 if (on) 262 csr |= EBDMA_CSR_EN_DMA; 263 else 264 csr &= ~EBDMA_CSR_EN_DMA; 265 if ((orig_csr & EBDMA_CSR_EN_DMA) != 266 (csr & EBDMA_CSR_EN_DMA)) 267 writel(csr, p->regs + EBDMA_CSR); 268 spin_unlock_irqrestore(&p->lock, flags); 269} 270EXPORT_SYMBOL(ebus_dma_enable); 271 272struct linux_ebus *ebus_chain = NULL; 273 274static inline void *ebus_alloc(size_t size) 275{ 276 void *mem; 277 278 mem = kzalloc(size, GFP_ATOMIC); 279 if (!mem) 280 panic("ebus_alloc: out of memory"); 281 return mem; 282} 283 284static void __init fill_ebus_child(struct device_node *dp, 285 struct linux_ebus_child *dev, 286 int non_standard_regs) 287{ 288 struct of_device *op; 289 const int *regs; 290 int i, len; 291 292 dev->prom_node = dp; 293 printk(" (%s)", dp->name); 294 295 regs = of_get_property(dp, "reg", &len); 296 if (!regs) 297 dev->num_addrs = 0; 298 else 299 dev->num_addrs = len / sizeof(regs[0]); 300 301 if (non_standard_regs) { 302 /* This is to handle reg properties which are not 303 * in the parent relative format. One example are 304 * children of the i2c device on CompactPCI systems. 305 * 306 * So, for such devices we just record the property 307 * raw in the child resources. 308 */ 309 for (i = 0; i < dev->num_addrs; i++) 310 dev->resource[i].start = regs[i]; 311 } else { 312 for (i = 0; i < dev->num_addrs; i++) { 313 int rnum = regs[i]; 314 if (rnum >= dev->parent->num_addrs) { 315 prom_printf("UGH: property for %s was %d, need < %d\n", 316 dp->name, len, dev->parent->num_addrs); 317 prom_halt(); 318 } 319 dev->resource[i].start = dev->parent->resource[i].start; 320 dev->resource[i].end = dev->parent->resource[i].end; 321 dev->resource[i].flags = IORESOURCE_MEM; 322 dev->resource[i].name = dp->name; 323 } 324 } 325 326 op = of_find_device_by_node(dp); 327 if (!op) { 328 dev->num_irqs = 0; 329 } else { 330 dev->num_irqs = op->num_irqs; 331 for (i = 0; i < dev->num_irqs; i++) 332 dev->irqs[i] = op->irqs[i]; 333 } 334 335 if (!dev->num_irqs) { 336 /* 337 * Oh, well, some PROMs don't export interrupts 338 * property to children of EBus devices... 339 * 340 * Be smart about PS/2 keyboard and mouse. 341 */ 342 if (!strcmp(dev->parent->prom_node->name, "8042")) { 343 if (!strcmp(dev->prom_node->name, "kb_ps2")) { 344 dev->num_irqs = 1; 345 dev->irqs[0] = dev->parent->irqs[0]; 346 } else { 347 dev->num_irqs = 1; 348 dev->irqs[0] = dev->parent->irqs[1]; 349 } 350 } 351 } 352} 353 354static int __init child_regs_nonstandard(struct linux_ebus_device *dev) 355{ 356 if (!strcmp(dev->prom_node->name, "i2c") || 357 !strcmp(dev->prom_node->name, "SUNW,lombus")) 358 return 1; 359 return 0; 360} 361 362static void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev) 363{ 364 struct linux_ebus_child *child; 365 struct of_device *op; 366 int i, len; 367 368 dev->prom_node = dp; 369 370 printk(" [%s", dp->name); 371 372 op = of_find_device_by_node(dp); 373 if (!op) { 374 dev->num_addrs = 0; 375 dev->num_irqs = 0; 376 } else { 377 (void) of_get_property(dp, "reg", &len); 378 dev->num_addrs = len / sizeof(struct linux_prom_registers); 379 380 for (i = 0; i < dev->num_addrs; i++) 381 memcpy(&dev->resource[i], 382 &op->resource[i], 383 sizeof(struct resource)); 384 385 dev->num_irqs = op->num_irqs; 386 for (i = 0; i < dev->num_irqs; i++) 387 dev->irqs[i] = op->irqs[i]; 388 } 389 390 dev->ofdev.node = dp; 391 dev->ofdev.dev.parent = &dev->bus->ofdev.dev; 392 dev->ofdev.dev.bus = &ebus_bus_type; 393 sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node); 394 395 /* Register with core */ 396 if (of_device_register(&dev->ofdev) != 0) 397 printk(KERN_DEBUG "ebus: device registration error for %s!\n", 398 dp->path_component_name); 399 400 dp = dp->child; 401 if (dp) { 402 printk(" ->"); 403 dev->children = ebus_alloc(sizeof(struct linux_ebus_child)); 404 405 child = dev->children; 406 child->next = NULL; 407 child->parent = dev; 408 child->bus = dev->bus; 409 fill_ebus_child(dp, child, 410 child_regs_nonstandard(dev)); 411 412 while ((dp = dp->sibling) != NULL) { 413 child->next = ebus_alloc(sizeof(struct linux_ebus_child)); 414 415 child = child->next; 416 child->next = NULL; 417 child->parent = dev; 418 child->bus = dev->bus; 419 fill_ebus_child(dp, child, 420 child_regs_nonstandard(dev)); 421 } 422 } 423 printk("]"); 424} 425 426static struct pci_dev *find_next_ebus(struct pci_dev *start, int *is_rio_p) 427{ 428 struct pci_dev *pdev = start; 429 430 while ((pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_ANY_ID, pdev))) 431 if (pdev->device == PCI_DEVICE_ID_SUN_EBUS || 432 pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS) 433 break; 434 435 *is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS)); 436 437 return pdev; 438} 439 440void __init ebus_init(void) 441{ 442 struct linux_ebus_device *dev; 443 struct linux_ebus *ebus; 444 struct pci_dev *pdev; 445 struct device_node *dp; 446 int is_rio; 447 int num_ebus = 0; 448 449 pdev = find_next_ebus(NULL, &is_rio); 450 if (!pdev) { 451 printk("ebus: No EBus's found.\n"); 452 return; 453 } 454 455 dp = pci_device_to_OF_node(pdev); 456 457 ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus)); 458 ebus->next = NULL; 459 ebus->is_rio = is_rio; 460 461 while (dp) { 462 struct device_node *child; 463 464 /* SUNW,pci-qfe uses four empty ebuses on it. 465 I think we should not consider them here, 466 as they have half of the properties this 467 code expects and once we do PCI hot-plug, 468 we'd have to tweak with the ebus_chain 469 in the runtime after initialization. -jj */ 470 if (!dp->child) { 471 pdev = find_next_ebus(pdev, &is_rio); 472 if (!pdev) { 473 if (ebus == ebus_chain) { 474 ebus_chain = NULL; 475 printk("ebus: No EBus's found.\n"); 476 return; 477 } 478 break; 479 } 480 ebus->is_rio = is_rio; 481 dp = pci_device_to_OF_node(pdev); 482 continue; 483 } 484 printk("ebus%d:", num_ebus); 485 486 ebus->index = num_ebus; 487 ebus->prom_node = dp; 488 ebus->self = pdev; 489 490 ebus->ofdev.node = dp; 491 ebus->ofdev.dev.parent = &pdev->dev; 492 ebus->ofdev.dev.bus = &ebus_bus_type; 493 sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus); 494 495 /* Register with core */ 496 if (of_device_register(&ebus->ofdev) != 0) 497 printk(KERN_DEBUG "ebus: device registration error for %s!\n", 498 dp->path_component_name); 499 500 501 child = dp->child; 502 if (!child) 503 goto next_ebus; 504 505 ebus->devices = ebus_alloc(sizeof(struct linux_ebus_device)); 506 507 dev = ebus->devices; 508 dev->next = NULL; 509 dev->children = NULL; 510 dev->bus = ebus; 511 fill_ebus_device(child, dev); 512 513 while ((child = child->sibling) != NULL) { 514 dev->next = ebus_alloc(sizeof(struct linux_ebus_device)); 515 516 dev = dev->next; 517 dev->next = NULL; 518 dev->children = NULL; 519 dev->bus = ebus; 520 fill_ebus_device(child, dev); 521 } 522 523 next_ebus: 524 printk("\n"); 525 526 pdev = find_next_ebus(pdev, &is_rio); 527 if (!pdev) 528 break; 529 530 dp = pci_device_to_OF_node(pdev); 531 532 ebus->next = ebus_alloc(sizeof(struct linux_ebus)); 533 ebus = ebus->next; 534 ebus->next = NULL; 535 ebus->is_rio = is_rio; 536 ++num_ebus; 537 } 538 pci_dev_put(pdev); 539} 540