1/* 2 * IBM PowerPC IBM eBus Infrastructure Support. 3 * 4 * Copyright (c) 2005 IBM Corporation 5 * Joachim Fenkes <fenkes@de.ibm.com> 6 * Heiko J Schick <schickhj@de.ibm.com> 7 * 8 * All rights reserved. 9 * 10 * This source code is distributed under a dual license of GPL v2.0 and OpenIB 11 * BSD. 12 * 13 * OpenIB BSD License 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions are met: 17 * 18 * Redistributions of source code must retain the above copyright notice, this 19 * list of conditions and the following disclaimer. 20 * 21 * Redistributions in binary form must reproduce the above copyright notice, 22 * this list of conditions and the following disclaimer in the documentation 23 * and/or other materials 24 * provided with the distribution. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 33 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 34 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39#include <linux/init.h> 40#include <linux/export.h> 41#include <linux/console.h> 42#include <linux/kobject.h> 43#include <linux/dma-mapping.h> 44#include <linux/interrupt.h> 45#include <linux/of.h> 46#include <linux/slab.h> 47#include <linux/stat.h> 48#include <linux/of_platform.h> 49#include <asm/ibmebus.h> 50 51static struct device ibmebus_bus_device = { /* fake "parent" device */ 52 .init_name = "ibmebus", 53}; 54 55struct bus_type ibmebus_bus_type; 56 57/* These devices will automatically be added to the bus during init */ 58static const struct of_device_id ibmebus_matches[] __initconst = { 59 { .compatible = "IBM,lhca" }, 60 { .compatible = "IBM,lhea" }, 61 {}, 62}; 63 64static void *ibmebus_alloc_coherent(struct device *dev, 65 size_t size, 66 dma_addr_t *dma_handle, 67 gfp_t flag, 68 struct dma_attrs *attrs) 69{ 70 void *mem; 71 72 mem = kmalloc(size, flag); 73 *dma_handle = (dma_addr_t)mem; 74 75 return mem; 76} 77 78static void ibmebus_free_coherent(struct device *dev, 79 size_t size, void *vaddr, 80 dma_addr_t dma_handle, 81 struct dma_attrs *attrs) 82{ 83 kfree(vaddr); 84} 85 86static dma_addr_t ibmebus_map_page(struct device *dev, 87 struct page *page, 88 unsigned long offset, 89 size_t size, 90 enum dma_data_direction direction, 91 struct dma_attrs *attrs) 92{ 93 return (dma_addr_t)(page_address(page) + offset); 94} 95 96static void ibmebus_unmap_page(struct device *dev, 97 dma_addr_t dma_addr, 98 size_t size, 99 enum dma_data_direction direction, 100 struct dma_attrs *attrs) 101{ 102 return; 103} 104 105static int ibmebus_map_sg(struct device *dev, 106 struct scatterlist *sgl, 107 int nents, enum dma_data_direction direction, 108 struct dma_attrs *attrs) 109{ 110 struct scatterlist *sg; 111 int i; 112 113 for_each_sg(sgl, sg, nents, i) { 114 sg->dma_address = (dma_addr_t) sg_virt(sg); 115 sg->dma_length = sg->length; 116 } 117 118 return nents; 119} 120 121static void ibmebus_unmap_sg(struct device *dev, 122 struct scatterlist *sg, 123 int nents, enum dma_data_direction direction, 124 struct dma_attrs *attrs) 125{ 126 return; 127} 128 129static int ibmebus_dma_supported(struct device *dev, u64 mask) 130{ 131 return mask == DMA_BIT_MASK(64); 132} 133 134static u64 ibmebus_dma_get_required_mask(struct device *dev) 135{ 136 return DMA_BIT_MASK(64); 137} 138 139static struct dma_map_ops ibmebus_dma_ops = { 140 .alloc = ibmebus_alloc_coherent, 141 .free = ibmebus_free_coherent, 142 .map_sg = ibmebus_map_sg, 143 .unmap_sg = ibmebus_unmap_sg, 144 .dma_supported = ibmebus_dma_supported, 145 .get_required_mask = ibmebus_dma_get_required_mask, 146 .map_page = ibmebus_map_page, 147 .unmap_page = ibmebus_unmap_page, 148}; 149 150static int ibmebus_match_path(struct device *dev, void *data) 151{ 152 struct device_node *dn = to_platform_device(dev)->dev.of_node; 153 return (dn->full_name && 154 (strcasecmp((char *)data, dn->full_name) == 0)); 155} 156 157static int ibmebus_match_node(struct device *dev, void *data) 158{ 159 return to_platform_device(dev)->dev.of_node == data; 160} 161 162static int ibmebus_create_device(struct device_node *dn) 163{ 164 struct platform_device *dev; 165 int ret; 166 167 dev = of_device_alloc(dn, NULL, &ibmebus_bus_device); 168 if (!dev) 169 return -ENOMEM; 170 171 dev->dev.bus = &ibmebus_bus_type; 172 dev->dev.archdata.dma_ops = &ibmebus_dma_ops; 173 174 ret = of_device_add(dev); 175 if (ret) 176 platform_device_put(dev); 177 return ret; 178} 179 180static int ibmebus_create_devices(const struct of_device_id *matches) 181{ 182 struct device_node *root, *child; 183 int ret = 0; 184 185 root = of_find_node_by_path("/"); 186 187 for_each_child_of_node(root, child) { 188 if (!of_match_node(matches, child)) 189 continue; 190 191 if (bus_find_device(&ibmebus_bus_type, NULL, child, 192 ibmebus_match_node)) 193 continue; 194 195 ret = ibmebus_create_device(child); 196 if (ret) { 197 printk(KERN_ERR "%s: failed to create device (%i)", 198 __func__, ret); 199 of_node_put(child); 200 break; 201 } 202 } 203 204 of_node_put(root); 205 return ret; 206} 207 208int ibmebus_register_driver(struct platform_driver *drv) 209{ 210 /* If the driver uses devices that ibmebus doesn't know, add them */ 211 ibmebus_create_devices(drv->driver.of_match_table); 212 213 drv->driver.bus = &ibmebus_bus_type; 214 return driver_register(&drv->driver); 215} 216EXPORT_SYMBOL(ibmebus_register_driver); 217 218void ibmebus_unregister_driver(struct platform_driver *drv) 219{ 220 driver_unregister(&drv->driver); 221} 222EXPORT_SYMBOL(ibmebus_unregister_driver); 223 224int ibmebus_request_irq(u32 ist, irq_handler_t handler, 225 unsigned long irq_flags, const char *devname, 226 void *dev_id) 227{ 228 unsigned int irq = irq_create_mapping(NULL, ist); 229 230 if (irq == NO_IRQ) 231 return -EINVAL; 232 233 return request_irq(irq, handler, irq_flags, devname, dev_id); 234} 235EXPORT_SYMBOL(ibmebus_request_irq); 236 237void ibmebus_free_irq(u32 ist, void *dev_id) 238{ 239 unsigned int irq = irq_find_mapping(NULL, ist); 240 241 free_irq(irq, dev_id); 242 irq_dispose_mapping(irq); 243} 244EXPORT_SYMBOL(ibmebus_free_irq); 245 246static char *ibmebus_chomp(const char *in, size_t count) 247{ 248 char *out = kmalloc(count + 1, GFP_KERNEL); 249 250 if (!out) 251 return NULL; 252 253 memcpy(out, in, count); 254 out[count] = '\0'; 255 if (out[count - 1] == '\n') 256 out[count - 1] = '\0'; 257 258 return out; 259} 260 261static ssize_t ibmebus_store_probe(struct bus_type *bus, 262 const char *buf, size_t count) 263{ 264 struct device_node *dn = NULL; 265 char *path; 266 ssize_t rc = 0; 267 268 path = ibmebus_chomp(buf, count); 269 if (!path) 270 return -ENOMEM; 271 272 if (bus_find_device(&ibmebus_bus_type, NULL, path, 273 ibmebus_match_path)) { 274 printk(KERN_WARNING "%s: %s has already been probed\n", 275 __func__, path); 276 rc = -EEXIST; 277 goto out; 278 } 279 280 if ((dn = of_find_node_by_path(path))) { 281 rc = ibmebus_create_device(dn); 282 of_node_put(dn); 283 } else { 284 printk(KERN_WARNING "%s: no such device node: %s\n", 285 __func__, path); 286 rc = -ENODEV; 287 } 288 289out: 290 kfree(path); 291 if (rc) 292 return rc; 293 return count; 294} 295static BUS_ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe); 296 297static ssize_t ibmebus_store_remove(struct bus_type *bus, 298 const char *buf, size_t count) 299{ 300 struct device *dev; 301 char *path; 302 303 path = ibmebus_chomp(buf, count); 304 if (!path) 305 return -ENOMEM; 306 307 if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path, 308 ibmebus_match_path))) { 309 of_device_unregister(to_platform_device(dev)); 310 311 kfree(path); 312 return count; 313 } else { 314 printk(KERN_WARNING "%s: %s not on the bus\n", 315 __func__, path); 316 317 kfree(path); 318 return -ENODEV; 319 } 320} 321static BUS_ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove); 322 323static struct attribute *ibmbus_bus_attrs[] = { 324 &bus_attr_probe.attr, 325 &bus_attr_remove.attr, 326 NULL, 327}; 328ATTRIBUTE_GROUPS(ibmbus_bus); 329 330static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv) 331{ 332 const struct of_device_id *matches = drv->of_match_table; 333 334 if (!matches) 335 return 0; 336 337 return of_match_device(matches, dev) != NULL; 338} 339 340static int ibmebus_bus_device_probe(struct device *dev) 341{ 342 int error = -ENODEV; 343 struct platform_driver *drv; 344 struct platform_device *of_dev; 345 346 drv = to_platform_driver(dev->driver); 347 of_dev = to_platform_device(dev); 348 349 if (!drv->probe) 350 return error; 351 352 of_dev_get(of_dev); 353 354 if (of_driver_match_device(dev, dev->driver)) 355 error = drv->probe(of_dev); 356 if (error) 357 of_dev_put(of_dev); 358 359 return error; 360} 361 362static int ibmebus_bus_device_remove(struct device *dev) 363{ 364 struct platform_device *of_dev = to_platform_device(dev); 365 struct platform_driver *drv = to_platform_driver(dev->driver); 366 367 if (dev->driver && drv->remove) 368 drv->remove(of_dev); 369 return 0; 370} 371 372static void ibmebus_bus_device_shutdown(struct device *dev) 373{ 374 struct platform_device *of_dev = to_platform_device(dev); 375 struct platform_driver *drv = to_platform_driver(dev->driver); 376 377 if (dev->driver && drv->shutdown) 378 drv->shutdown(of_dev); 379} 380 381/* 382 * ibmebus_bus_device_attrs 383 */ 384static ssize_t devspec_show(struct device *dev, 385 struct device_attribute *attr, char *buf) 386{ 387 struct platform_device *ofdev; 388 389 ofdev = to_platform_device(dev); 390 return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name); 391} 392 393static ssize_t name_show(struct device *dev, 394 struct device_attribute *attr, char *buf) 395{ 396 struct platform_device *ofdev; 397 398 ofdev = to_platform_device(dev); 399 return sprintf(buf, "%s\n", ofdev->dev.of_node->name); 400} 401 402static ssize_t modalias_show(struct device *dev, 403 struct device_attribute *attr, char *buf) 404{ 405 ssize_t len = of_device_get_modalias(dev, buf, PAGE_SIZE - 2); 406 buf[len] = '\n'; 407 buf[len+1] = 0; 408 return len+1; 409} 410 411struct device_attribute ibmebus_bus_device_attrs[] = { 412 __ATTR_RO(devspec), 413 __ATTR_RO(name), 414 __ATTR_RO(modalias), 415 __ATTR_NULL 416}; 417 418#ifdef CONFIG_PM_SLEEP 419static int ibmebus_bus_legacy_suspend(struct device *dev, pm_message_t mesg) 420{ 421 struct platform_device *of_dev = to_platform_device(dev); 422 struct platform_driver *drv = to_platform_driver(dev->driver); 423 int ret = 0; 424 425 if (dev->driver && drv->suspend) 426 ret = drv->suspend(of_dev, mesg); 427 return ret; 428} 429 430static int ibmebus_bus_legacy_resume(struct device *dev) 431{ 432 struct platform_device *of_dev = to_platform_device(dev); 433 struct platform_driver *drv = to_platform_driver(dev->driver); 434 int ret = 0; 435 436 if (dev->driver && drv->resume) 437 ret = drv->resume(of_dev); 438 return ret; 439} 440 441static int ibmebus_bus_pm_prepare(struct device *dev) 442{ 443 struct device_driver *drv = dev->driver; 444 int ret = 0; 445 446 if (drv && drv->pm && drv->pm->prepare) 447 ret = drv->pm->prepare(dev); 448 449 return ret; 450} 451 452static void ibmebus_bus_pm_complete(struct device *dev) 453{ 454 struct device_driver *drv = dev->driver; 455 456 if (drv && drv->pm && drv->pm->complete) 457 drv->pm->complete(dev); 458} 459 460#ifdef CONFIG_SUSPEND 461 462static int ibmebus_bus_pm_suspend(struct device *dev) 463{ 464 struct device_driver *drv = dev->driver; 465 int ret = 0; 466 467 if (!drv) 468 return 0; 469 470 if (drv->pm) { 471 if (drv->pm->suspend) 472 ret = drv->pm->suspend(dev); 473 } else { 474 ret = ibmebus_bus_legacy_suspend(dev, PMSG_SUSPEND); 475 } 476 477 return ret; 478} 479 480static int ibmebus_bus_pm_suspend_noirq(struct device *dev) 481{ 482 struct device_driver *drv = dev->driver; 483 int ret = 0; 484 485 if (!drv) 486 return 0; 487 488 if (drv->pm) { 489 if (drv->pm->suspend_noirq) 490 ret = drv->pm->suspend_noirq(dev); 491 } 492 493 return ret; 494} 495 496static int ibmebus_bus_pm_resume(struct device *dev) 497{ 498 struct device_driver *drv = dev->driver; 499 int ret = 0; 500 501 if (!drv) 502 return 0; 503 504 if (drv->pm) { 505 if (drv->pm->resume) 506 ret = drv->pm->resume(dev); 507 } else { 508 ret = ibmebus_bus_legacy_resume(dev); 509 } 510 511 return ret; 512} 513 514static int ibmebus_bus_pm_resume_noirq(struct device *dev) 515{ 516 struct device_driver *drv = dev->driver; 517 int ret = 0; 518 519 if (!drv) 520 return 0; 521 522 if (drv->pm) { 523 if (drv->pm->resume_noirq) 524 ret = drv->pm->resume_noirq(dev); 525 } 526 527 return ret; 528} 529 530#else /* !CONFIG_SUSPEND */ 531 532#define ibmebus_bus_pm_suspend NULL 533#define ibmebus_bus_pm_resume NULL 534#define ibmebus_bus_pm_suspend_noirq NULL 535#define ibmebus_bus_pm_resume_noirq NULL 536 537#endif /* !CONFIG_SUSPEND */ 538 539#ifdef CONFIG_HIBERNATE_CALLBACKS 540 541static int ibmebus_bus_pm_freeze(struct device *dev) 542{ 543 struct device_driver *drv = dev->driver; 544 int ret = 0; 545 546 if (!drv) 547 return 0; 548 549 if (drv->pm) { 550 if (drv->pm->freeze) 551 ret = drv->pm->freeze(dev); 552 } else { 553 ret = ibmebus_bus_legacy_suspend(dev, PMSG_FREEZE); 554 } 555 556 return ret; 557} 558 559static int ibmebus_bus_pm_freeze_noirq(struct device *dev) 560{ 561 struct device_driver *drv = dev->driver; 562 int ret = 0; 563 564 if (!drv) 565 return 0; 566 567 if (drv->pm) { 568 if (drv->pm->freeze_noirq) 569 ret = drv->pm->freeze_noirq(dev); 570 } 571 572 return ret; 573} 574 575static int ibmebus_bus_pm_thaw(struct device *dev) 576{ 577 struct device_driver *drv = dev->driver; 578 int ret = 0; 579 580 if (!drv) 581 return 0; 582 583 if (drv->pm) { 584 if (drv->pm->thaw) 585 ret = drv->pm->thaw(dev); 586 } else { 587 ret = ibmebus_bus_legacy_resume(dev); 588 } 589 590 return ret; 591} 592 593static int ibmebus_bus_pm_thaw_noirq(struct device *dev) 594{ 595 struct device_driver *drv = dev->driver; 596 int ret = 0; 597 598 if (!drv) 599 return 0; 600 601 if (drv->pm) { 602 if (drv->pm->thaw_noirq) 603 ret = drv->pm->thaw_noirq(dev); 604 } 605 606 return ret; 607} 608 609static int ibmebus_bus_pm_poweroff(struct device *dev) 610{ 611 struct device_driver *drv = dev->driver; 612 int ret = 0; 613 614 if (!drv) 615 return 0; 616 617 if (drv->pm) { 618 if (drv->pm->poweroff) 619 ret = drv->pm->poweroff(dev); 620 } else { 621 ret = ibmebus_bus_legacy_suspend(dev, PMSG_HIBERNATE); 622 } 623 624 return ret; 625} 626 627static int ibmebus_bus_pm_poweroff_noirq(struct device *dev) 628{ 629 struct device_driver *drv = dev->driver; 630 int ret = 0; 631 632 if (!drv) 633 return 0; 634 635 if (drv->pm) { 636 if (drv->pm->poweroff_noirq) 637 ret = drv->pm->poweroff_noirq(dev); 638 } 639 640 return ret; 641} 642 643static int ibmebus_bus_pm_restore(struct device *dev) 644{ 645 struct device_driver *drv = dev->driver; 646 int ret = 0; 647 648 if (!drv) 649 return 0; 650 651 if (drv->pm) { 652 if (drv->pm->restore) 653 ret = drv->pm->restore(dev); 654 } else { 655 ret = ibmebus_bus_legacy_resume(dev); 656 } 657 658 return ret; 659} 660 661static int ibmebus_bus_pm_restore_noirq(struct device *dev) 662{ 663 struct device_driver *drv = dev->driver; 664 int ret = 0; 665 666 if (!drv) 667 return 0; 668 669 if (drv->pm) { 670 if (drv->pm->restore_noirq) 671 ret = drv->pm->restore_noirq(dev); 672 } 673 674 return ret; 675} 676 677#else /* !CONFIG_HIBERNATE_CALLBACKS */ 678 679#define ibmebus_bus_pm_freeze NULL 680#define ibmebus_bus_pm_thaw NULL 681#define ibmebus_bus_pm_poweroff NULL 682#define ibmebus_bus_pm_restore NULL 683#define ibmebus_bus_pm_freeze_noirq NULL 684#define ibmebus_bus_pm_thaw_noirq NULL 685#define ibmebus_bus_pm_poweroff_noirq NULL 686#define ibmebus_bus_pm_restore_noirq NULL 687 688#endif /* !CONFIG_HIBERNATE_CALLBACKS */ 689 690static struct dev_pm_ops ibmebus_bus_dev_pm_ops = { 691 .prepare = ibmebus_bus_pm_prepare, 692 .complete = ibmebus_bus_pm_complete, 693 .suspend = ibmebus_bus_pm_suspend, 694 .resume = ibmebus_bus_pm_resume, 695 .freeze = ibmebus_bus_pm_freeze, 696 .thaw = ibmebus_bus_pm_thaw, 697 .poweroff = ibmebus_bus_pm_poweroff, 698 .restore = ibmebus_bus_pm_restore, 699 .suspend_noirq = ibmebus_bus_pm_suspend_noirq, 700 .resume_noirq = ibmebus_bus_pm_resume_noirq, 701 .freeze_noirq = ibmebus_bus_pm_freeze_noirq, 702 .thaw_noirq = ibmebus_bus_pm_thaw_noirq, 703 .poweroff_noirq = ibmebus_bus_pm_poweroff_noirq, 704 .restore_noirq = ibmebus_bus_pm_restore_noirq, 705}; 706 707#define IBMEBUS_BUS_PM_OPS_PTR (&ibmebus_bus_dev_pm_ops) 708 709#else /* !CONFIG_PM_SLEEP */ 710 711#define IBMEBUS_BUS_PM_OPS_PTR NULL 712 713#endif /* !CONFIG_PM_SLEEP */ 714 715struct bus_type ibmebus_bus_type = { 716 .name = "ibmebus", 717 .uevent = of_device_uevent_modalias, 718 .bus_groups = ibmbus_bus_groups, 719 .match = ibmebus_bus_bus_match, 720 .probe = ibmebus_bus_device_probe, 721 .remove = ibmebus_bus_device_remove, 722 .shutdown = ibmebus_bus_device_shutdown, 723 .dev_attrs = ibmebus_bus_device_attrs, 724 .pm = IBMEBUS_BUS_PM_OPS_PTR, 725}; 726EXPORT_SYMBOL(ibmebus_bus_type); 727 728static int __init ibmebus_bus_init(void) 729{ 730 int err; 731 732 printk(KERN_INFO "IBM eBus Device Driver\n"); 733 734 err = bus_register(&ibmebus_bus_type); 735 if (err) { 736 printk(KERN_ERR "%s: failed to register IBM eBus.\n", 737 __func__); 738 return err; 739 } 740 741 err = device_register(&ibmebus_bus_device); 742 if (err) { 743 printk(KERN_WARNING "%s: device_register returned %i\n", 744 __func__, err); 745 bus_unregister(&ibmebus_bus_type); 746 747 return err; 748 } 749 750 err = ibmebus_create_devices(ibmebus_matches); 751 if (err) { 752 device_unregister(&ibmebus_bus_device); 753 bus_unregister(&ibmebus_bus_type); 754 return err; 755 } 756 757 return 0; 758} 759postcore_initcall(ibmebus_bus_init); 760