linux/arch/powerpc/platforms/ps3/device-init.c
<<
>>
Prefs
   1/*
   2 *  PS3 device registration routines.
   3 *
   4 *  Copyright (C) 2007 Sony Computer Entertainment Inc.
   5 *  Copyright 2007 Sony Corp.
   6 *
   7 *  This program is free software; you can redistribute it and/or modify
   8 *  it under the terms of the GNU General Public License as published by
   9 *  the Free Software Foundation; version 2 of the License.
  10 *
  11 *  This program is distributed in the hope that it will be useful,
  12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *  GNU General Public License for more details.
  15 *
  16 *  You should have received a copy of the GNU General Public License
  17 *  along with this program; if not, write to the Free Software
  18 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21#include <linux/delay.h>
  22#include <linux/freezer.h>
  23#include <linux/kernel.h>
  24#include <linux/kthread.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/reboot.h>
  28
  29#include <asm/firmware.h>
  30#include <asm/lv1call.h>
  31#include <asm/ps3stor.h>
  32
  33#include "platform.h"
  34
  35static int __init ps3_register_lpm_devices(void)
  36{
  37        int result;
  38        u64 tmp1;
  39        u64 tmp2;
  40        struct ps3_system_bus_device *dev;
  41
  42        pr_debug(" -> %s:%d\n", __func__, __LINE__);
  43
  44        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  45        if (!dev)
  46                return -ENOMEM;
  47
  48        dev->match_id = PS3_MATCH_ID_LPM;
  49        dev->dev_type = PS3_DEVICE_TYPE_LPM;
  50
  51        /* The current lpm driver only supports a single BE processor. */
  52
  53        result = ps3_repository_read_be_node_id(0, &dev->lpm.node_id);
  54
  55        if (result) {
  56                pr_debug("%s:%d: ps3_repository_read_be_node_id failed \n",
  57                        __func__, __LINE__);
  58                goto fail_read_repo;
  59        }
  60
  61        result = ps3_repository_read_lpm_privileges(dev->lpm.node_id, &tmp1,
  62                &dev->lpm.rights);
  63
  64        if (result) {
  65                pr_debug("%s:%d: ps3_repository_read_lpm_privileges failed\n",
  66                        __func__, __LINE__);
  67                goto fail_read_repo;
  68        }
  69
  70        lv1_get_logical_partition_id(&tmp2);
  71
  72        if (tmp1 != tmp2) {
  73                pr_debug("%s:%d: wrong lpar\n",
  74                        __func__, __LINE__);
  75                result = -ENODEV;
  76                goto fail_rights;
  77        }
  78
  79        if (!(dev->lpm.rights & PS3_LPM_RIGHTS_USE_LPM)) {
  80                pr_debug("%s:%d: don't have rights to use lpm\n",
  81                        __func__, __LINE__);
  82                result = -EPERM;
  83                goto fail_rights;
  84        }
  85
  86        pr_debug("%s:%d: pu_id %llu, rights %llu(%llxh)\n",
  87                __func__, __LINE__, dev->lpm.pu_id, dev->lpm.rights,
  88                dev->lpm.rights);
  89
  90        result = ps3_repository_read_pu_id(0, &dev->lpm.pu_id);
  91
  92        if (result) {
  93                pr_debug("%s:%d: ps3_repository_read_pu_id failed \n",
  94                        __func__, __LINE__);
  95                goto fail_read_repo;
  96        }
  97
  98        result = ps3_system_bus_device_register(dev);
  99
 100        if (result) {
 101                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 102                        __func__, __LINE__);
 103                goto fail_register;
 104        }
 105
 106        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 107        return 0;
 108
 109
 110fail_register:
 111fail_rights:
 112fail_read_repo:
 113        kfree(dev);
 114        pr_debug(" <- %s:%d: failed\n", __func__, __LINE__);
 115        return result;
 116}
 117
 118/**
 119 * ps3_setup_gelic_device - Setup and register a gelic device instance.
 120 *
 121 * Allocates memory for a struct ps3_system_bus_device instance, initialises the
 122 * structure members, and registers the device instance with the system bus.
 123 */
 124
 125static int __init ps3_setup_gelic_device(
 126        const struct ps3_repository_device *repo)
 127{
 128        int result;
 129        struct layout {
 130                struct ps3_system_bus_device dev;
 131                struct ps3_dma_region d_region;
 132        } *p;
 133
 134        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 135
 136        BUG_ON(repo->bus_type != PS3_BUS_TYPE_SB);
 137        BUG_ON(repo->dev_type != PS3_DEV_TYPE_SB_GELIC);
 138
 139        p = kzalloc(sizeof(struct layout), GFP_KERNEL);
 140
 141        if (!p) {
 142                result = -ENOMEM;
 143                goto fail_malloc;
 144        }
 145
 146        p->dev.match_id = PS3_MATCH_ID_GELIC;
 147        p->dev.dev_type = PS3_DEVICE_TYPE_SB;
 148        p->dev.bus_id = repo->bus_id;
 149        p->dev.dev_id = repo->dev_id;
 150        p->dev.d_region = &p->d_region;
 151
 152        result = ps3_repository_find_interrupt(repo,
 153                PS3_INTERRUPT_TYPE_EVENT_PORT, &p->dev.interrupt_id);
 154
 155        if (result) {
 156                pr_debug("%s:%d ps3_repository_find_interrupt failed\n",
 157                        __func__, __LINE__);
 158                goto fail_find_interrupt;
 159        }
 160
 161        BUG_ON(p->dev.interrupt_id != 0);
 162
 163        result = ps3_dma_region_init(&p->dev, p->dev.d_region, PS3_DMA_64K,
 164                PS3_DMA_OTHER, NULL, 0);
 165
 166        if (result) {
 167                pr_debug("%s:%d ps3_dma_region_init failed\n",
 168                        __func__, __LINE__);
 169                goto fail_dma_init;
 170        }
 171
 172        result = ps3_system_bus_device_register(&p->dev);
 173
 174        if (result) {
 175                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 176                        __func__, __LINE__);
 177                goto fail_device_register;
 178        }
 179
 180        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 181        return result;
 182
 183fail_device_register:
 184fail_dma_init:
 185fail_find_interrupt:
 186        kfree(p);
 187fail_malloc:
 188        pr_debug(" <- %s:%d: fail.\n", __func__, __LINE__);
 189        return result;
 190}
 191
 192static int __ref ps3_setup_uhc_device(
 193        const struct ps3_repository_device *repo, enum ps3_match_id match_id,
 194        enum ps3_interrupt_type interrupt_type, enum ps3_reg_type reg_type)
 195{
 196        int result;
 197        struct layout {
 198                struct ps3_system_bus_device dev;
 199                struct ps3_dma_region d_region;
 200                struct ps3_mmio_region m_region;
 201        } *p;
 202        u64 bus_addr;
 203        u64 len;
 204
 205        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 206
 207        BUG_ON(repo->bus_type != PS3_BUS_TYPE_SB);
 208        BUG_ON(repo->dev_type != PS3_DEV_TYPE_SB_USB);
 209
 210        p = kzalloc(sizeof(struct layout), GFP_KERNEL);
 211
 212        if (!p) {
 213                result = -ENOMEM;
 214                goto fail_malloc;
 215        }
 216
 217        p->dev.match_id = match_id;
 218        p->dev.dev_type = PS3_DEVICE_TYPE_SB;
 219        p->dev.bus_id = repo->bus_id;
 220        p->dev.dev_id = repo->dev_id;
 221        p->dev.d_region = &p->d_region;
 222        p->dev.m_region = &p->m_region;
 223
 224        result = ps3_repository_find_interrupt(repo,
 225                interrupt_type, &p->dev.interrupt_id);
 226
 227        if (result) {
 228                pr_debug("%s:%d ps3_repository_find_interrupt failed\n",
 229                        __func__, __LINE__);
 230                goto fail_find_interrupt;
 231        }
 232
 233        result = ps3_repository_find_reg(repo, reg_type,
 234                &bus_addr, &len);
 235
 236        if (result) {
 237                pr_debug("%s:%d ps3_repository_find_reg failed\n",
 238                        __func__, __LINE__);
 239                goto fail_find_reg;
 240        }
 241
 242        result = ps3_dma_region_init(&p->dev, p->dev.d_region, PS3_DMA_64K,
 243                PS3_DMA_INTERNAL, NULL, 0);
 244
 245        if (result) {
 246                pr_debug("%s:%d ps3_dma_region_init failed\n",
 247                        __func__, __LINE__);
 248                goto fail_dma_init;
 249        }
 250
 251        result = ps3_mmio_region_init(&p->dev, p->dev.m_region, bus_addr, len,
 252                PS3_MMIO_4K);
 253
 254        if (result) {
 255                pr_debug("%s:%d ps3_mmio_region_init failed\n",
 256                        __func__, __LINE__);
 257                goto fail_mmio_init;
 258        }
 259
 260        result = ps3_system_bus_device_register(&p->dev);
 261
 262        if (result) {
 263                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 264                        __func__, __LINE__);
 265                goto fail_device_register;
 266        }
 267
 268        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 269        return result;
 270
 271fail_device_register:
 272fail_mmio_init:
 273fail_dma_init:
 274fail_find_reg:
 275fail_find_interrupt:
 276        kfree(p);
 277fail_malloc:
 278        pr_debug(" <- %s:%d: fail.\n", __func__, __LINE__);
 279        return result;
 280}
 281
 282static int __init ps3_setup_ehci_device(
 283        const struct ps3_repository_device *repo)
 284{
 285        return ps3_setup_uhc_device(repo, PS3_MATCH_ID_EHCI,
 286                PS3_INTERRUPT_TYPE_SB_EHCI, PS3_REG_TYPE_SB_EHCI);
 287}
 288
 289static int __init ps3_setup_ohci_device(
 290        const struct ps3_repository_device *repo)
 291{
 292        return ps3_setup_uhc_device(repo, PS3_MATCH_ID_OHCI,
 293                PS3_INTERRUPT_TYPE_SB_OHCI, PS3_REG_TYPE_SB_OHCI);
 294}
 295
 296static int __init ps3_setup_vuart_device(enum ps3_match_id match_id,
 297        unsigned int port_number)
 298{
 299        int result;
 300        struct layout {
 301                struct ps3_system_bus_device dev;
 302        } *p;
 303
 304        pr_debug(" -> %s:%d: match_id %u, port %u\n", __func__, __LINE__,
 305                match_id, port_number);
 306
 307        p = kzalloc(sizeof(struct layout), GFP_KERNEL);
 308
 309        if (!p)
 310                return -ENOMEM;
 311
 312        p->dev.match_id = match_id;
 313        p->dev.dev_type = PS3_DEVICE_TYPE_VUART;
 314        p->dev.port_number = port_number;
 315
 316        result = ps3_system_bus_device_register(&p->dev);
 317
 318        if (result) {
 319                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 320                        __func__, __LINE__);
 321                goto fail_device_register;
 322        }
 323        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 324        return 0;
 325
 326fail_device_register:
 327        kfree(p);
 328        pr_debug(" <- %s:%d fail\n", __func__, __LINE__);
 329        return result;
 330}
 331
 332static int ps3_setup_storage_dev(const struct ps3_repository_device *repo,
 333                                 enum ps3_match_id match_id)
 334{
 335        int result;
 336        struct ps3_storage_device *p;
 337        u64 port, blk_size, num_blocks;
 338        unsigned int num_regions, i;
 339
 340        pr_debug(" -> %s:%u: match_id %u\n", __func__, __LINE__, match_id);
 341
 342        result = ps3_repository_read_stor_dev_info(repo->bus_index,
 343                                                   repo->dev_index, &port,
 344                                                   &blk_size, &num_blocks,
 345                                                   &num_regions);
 346        if (result) {
 347                printk(KERN_ERR "%s:%u: _read_stor_dev_info failed %d\n",
 348                       __func__, __LINE__, result);
 349                return -ENODEV;
 350        }
 351
 352        pr_debug("%s:%u: (%u:%u:%u): port %llu blk_size %llu num_blocks %llu "
 353                 "num_regions %u\n", __func__, __LINE__, repo->bus_index,
 354                 repo->dev_index, repo->dev_type, port, blk_size, num_blocks,
 355                 num_regions);
 356
 357        p = kzalloc(sizeof(struct ps3_storage_device) +
 358                    num_regions * sizeof(struct ps3_storage_region),
 359                    GFP_KERNEL);
 360        if (!p) {
 361                result = -ENOMEM;
 362                goto fail_malloc;
 363        }
 364
 365        p->sbd.match_id = match_id;
 366        p->sbd.dev_type = PS3_DEVICE_TYPE_SB;
 367        p->sbd.bus_id = repo->bus_id;
 368        p->sbd.dev_id = repo->dev_id;
 369        p->sbd.d_region = &p->dma_region;
 370        p->blk_size = blk_size;
 371        p->num_regions = num_regions;
 372
 373        result = ps3_repository_find_interrupt(repo,
 374                                               PS3_INTERRUPT_TYPE_EVENT_PORT,
 375                                               &p->sbd.interrupt_id);
 376        if (result) {
 377                printk(KERN_ERR "%s:%u: find_interrupt failed %d\n", __func__,
 378                       __LINE__, result);
 379                result = -ENODEV;
 380                goto fail_find_interrupt;
 381        }
 382
 383        for (i = 0; i < num_regions; i++) {
 384                unsigned int id;
 385                u64 start, size;
 386
 387                result = ps3_repository_read_stor_dev_region(repo->bus_index,
 388                                                             repo->dev_index,
 389                                                             i, &id, &start,
 390                                                             &size);
 391                if (result) {
 392                        printk(KERN_ERR
 393                               "%s:%u: read_stor_dev_region failed %d\n",
 394                               __func__, __LINE__, result);
 395                        result = -ENODEV;
 396                        goto fail_read_region;
 397                }
 398                pr_debug("%s:%u: region %u: id %u start %llu size %llu\n",
 399                         __func__, __LINE__, i, id, start, size);
 400
 401                p->regions[i].id = id;
 402                p->regions[i].start = start;
 403                p->regions[i].size = size;
 404        }
 405
 406        result = ps3_system_bus_device_register(&p->sbd);
 407        if (result) {
 408                pr_debug("%s:%u ps3_system_bus_device_register failed\n",
 409                         __func__, __LINE__);
 410                goto fail_device_register;
 411        }
 412
 413        pr_debug(" <- %s:%u\n", __func__, __LINE__);
 414        return 0;
 415
 416fail_device_register:
 417fail_read_region:
 418fail_find_interrupt:
 419        kfree(p);
 420fail_malloc:
 421        pr_debug(" <- %s:%u: fail.\n", __func__, __LINE__);
 422        return result;
 423}
 424
 425static int __init ps3_register_vuart_devices(void)
 426{
 427        int result;
 428        unsigned int port_number;
 429
 430        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 431
 432        result = ps3_repository_read_vuart_av_port(&port_number);
 433        if (result)
 434                port_number = 0; /* av default */
 435
 436        result = ps3_setup_vuart_device(PS3_MATCH_ID_AV_SETTINGS, port_number);
 437        WARN_ON(result);
 438
 439        result = ps3_repository_read_vuart_sysmgr_port(&port_number);
 440        if (result)
 441                port_number = 2; /* sysmgr default */
 442
 443        result = ps3_setup_vuart_device(PS3_MATCH_ID_SYSTEM_MANAGER,
 444                port_number);
 445        WARN_ON(result);
 446
 447        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 448        return result;
 449}
 450
 451static int __init ps3_register_sound_devices(void)
 452{
 453        int result;
 454        struct layout {
 455                struct ps3_system_bus_device dev;
 456                struct ps3_dma_region d_region;
 457                struct ps3_mmio_region m_region;
 458        } *p;
 459
 460        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 461
 462        p = kzalloc(sizeof(*p), GFP_KERNEL);
 463        if (!p)
 464                return -ENOMEM;
 465
 466        p->dev.match_id = PS3_MATCH_ID_SOUND;
 467        p->dev.dev_type = PS3_DEVICE_TYPE_IOC0;
 468        p->dev.d_region = &p->d_region;
 469        p->dev.m_region = &p->m_region;
 470
 471        result = ps3_system_bus_device_register(&p->dev);
 472
 473        if (result) {
 474                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 475                        __func__, __LINE__);
 476                goto fail_device_register;
 477        }
 478        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 479        return 0;
 480
 481fail_device_register:
 482        kfree(p);
 483        pr_debug(" <- %s:%d failed\n", __func__, __LINE__);
 484        return result;
 485}
 486
 487static int __init ps3_register_graphics_devices(void)
 488{
 489        int result;
 490        struct layout {
 491                struct ps3_system_bus_device dev;
 492        } *p;
 493
 494        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 495
 496        p = kzalloc(sizeof(struct layout), GFP_KERNEL);
 497
 498        if (!p)
 499                return -ENOMEM;
 500
 501        p->dev.match_id = PS3_MATCH_ID_GPU;
 502        p->dev.match_sub_id = PS3_MATCH_SUB_ID_GPU_FB;
 503        p->dev.dev_type = PS3_DEVICE_TYPE_IOC0;
 504
 505        result = ps3_system_bus_device_register(&p->dev);
 506
 507        if (result) {
 508                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 509                        __func__, __LINE__);
 510                goto fail_device_register;
 511        }
 512
 513        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 514        return 0;
 515
 516fail_device_register:
 517        kfree(p);
 518        pr_debug(" <- %s:%d failed\n", __func__, __LINE__);
 519        return result;
 520}
 521
 522static int __init ps3_register_ramdisk_device(void)
 523{
 524        int result;
 525        struct layout {
 526                struct ps3_system_bus_device dev;
 527        } *p;
 528
 529        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 530
 531        p = kzalloc(sizeof(struct layout), GFP_KERNEL);
 532
 533        if (!p)
 534                return -ENOMEM;
 535
 536        p->dev.match_id = PS3_MATCH_ID_GPU;
 537        p->dev.match_sub_id = PS3_MATCH_SUB_ID_GPU_RAMDISK;
 538        p->dev.dev_type = PS3_DEVICE_TYPE_IOC0;
 539
 540        result = ps3_system_bus_device_register(&p->dev);
 541
 542        if (result) {
 543                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
 544                        __func__, __LINE__);
 545                goto fail_device_register;
 546        }
 547
 548        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 549        return 0;
 550
 551fail_device_register:
 552        kfree(p);
 553        pr_debug(" <- %s:%d failed\n", __func__, __LINE__);
 554        return result;
 555}
 556
 557/**
 558 * ps3_setup_dynamic_device - Setup a dynamic device from the repository
 559 */
 560
 561static int ps3_setup_dynamic_device(const struct ps3_repository_device *repo)
 562{
 563        int result;
 564
 565        switch (repo->dev_type) {
 566        case PS3_DEV_TYPE_STOR_DISK:
 567                result = ps3_setup_storage_dev(repo, PS3_MATCH_ID_STOR_DISK);
 568
 569                /* Some devices are not accessible from the Other OS lpar. */
 570                if (result == -ENODEV) {
 571                        result = 0;
 572                        pr_debug("%s:%u: not accessible\n", __func__,
 573                                 __LINE__);
 574                }
 575
 576                if (result)
 577                        pr_debug("%s:%u ps3_setup_storage_dev failed\n",
 578                                 __func__, __LINE__);
 579                break;
 580
 581        case PS3_DEV_TYPE_STOR_ROM:
 582                result = ps3_setup_storage_dev(repo, PS3_MATCH_ID_STOR_ROM);
 583                if (result)
 584                        pr_debug("%s:%u ps3_setup_storage_dev failed\n",
 585                                 __func__, __LINE__);
 586                break;
 587
 588        case PS3_DEV_TYPE_STOR_FLASH:
 589                result = ps3_setup_storage_dev(repo, PS3_MATCH_ID_STOR_FLASH);
 590                if (result)
 591                        pr_debug("%s:%u ps3_setup_storage_dev failed\n",
 592                                 __func__, __LINE__);
 593                break;
 594
 595        default:
 596                result = 0;
 597                pr_debug("%s:%u: unsupported dev_type %u\n", __func__, __LINE__,
 598                        repo->dev_type);
 599        }
 600
 601        return result;
 602}
 603
 604/**
 605 * ps3_setup_static_device - Setup a static device from the repository
 606 */
 607
 608static int __init ps3_setup_static_device(const struct ps3_repository_device *repo)
 609{
 610        int result;
 611
 612        switch (repo->dev_type) {
 613        case PS3_DEV_TYPE_SB_GELIC:
 614                result = ps3_setup_gelic_device(repo);
 615                if (result) {
 616                        pr_debug("%s:%d ps3_setup_gelic_device failed\n",
 617                                __func__, __LINE__);
 618                }
 619                break;
 620        case PS3_DEV_TYPE_SB_USB:
 621
 622                /* Each USB device has both an EHCI and an OHCI HC */
 623
 624                result = ps3_setup_ehci_device(repo);
 625
 626                if (result) {
 627                        pr_debug("%s:%d ps3_setup_ehci_device failed\n",
 628                                __func__, __LINE__);
 629                }
 630
 631                result = ps3_setup_ohci_device(repo);
 632
 633                if (result) {
 634                        pr_debug("%s:%d ps3_setup_ohci_device failed\n",
 635                                __func__, __LINE__);
 636                }
 637                break;
 638
 639        default:
 640                return ps3_setup_dynamic_device(repo);
 641        }
 642
 643        return result;
 644}
 645
 646static void ps3_find_and_add_device(u64 bus_id, u64 dev_id)
 647{
 648        struct ps3_repository_device repo;
 649        int res;
 650        unsigned int retries;
 651        unsigned long rem;
 652
 653        /*
 654         * On some firmware versions (e.g. 1.90), the device may not show up
 655         * in the repository immediately
 656         */
 657        for (retries = 0; retries < 10; retries++) {
 658                res = ps3_repository_find_device_by_id(&repo, bus_id, dev_id);
 659                if (!res)
 660                        goto found;
 661
 662                rem = msleep_interruptible(100);
 663                if (rem)
 664                        break;
 665        }
 666        pr_warn("%s:%u: device %llu:%llu not found\n",
 667                __func__, __LINE__, bus_id, dev_id);
 668        return;
 669
 670found:
 671        if (retries)
 672                pr_debug("%s:%u: device %llu:%llu found after %u retries\n",
 673                         __func__, __LINE__, bus_id, dev_id, retries);
 674
 675        ps3_setup_dynamic_device(&repo);
 676        return;
 677}
 678
 679#define PS3_NOTIFICATION_DEV_ID         ULONG_MAX
 680#define PS3_NOTIFICATION_INTERRUPT_ID   0
 681
 682struct ps3_notification_device {
 683        struct ps3_system_bus_device sbd;
 684        spinlock_t lock;
 685        u64 tag;
 686        u64 lv1_status;
 687        struct completion done;
 688};
 689
 690enum ps3_notify_type {
 691        notify_device_ready = 0,
 692        notify_region_probe = 1,
 693        notify_region_update = 2,
 694};
 695
 696struct ps3_notify_cmd {
 697        u64 operation_code;             /* must be zero */
 698        u64 event_mask;                 /* OR of 1UL << enum ps3_notify_type */
 699};
 700
 701struct ps3_notify_event {
 702        u64 event_type;                 /* enum ps3_notify_type */
 703        u64 bus_id;
 704        u64 dev_id;
 705        u64 dev_type;
 706        u64 dev_port;
 707};
 708
 709static irqreturn_t ps3_notification_interrupt(int irq, void *data)
 710{
 711        struct ps3_notification_device *dev = data;
 712        int res;
 713        u64 tag, status;
 714
 715        spin_lock(&dev->lock);
 716        res = lv1_storage_get_async_status(PS3_NOTIFICATION_DEV_ID, &tag,
 717                                           &status);
 718        if (tag != dev->tag)
 719                pr_err("%s:%u: tag mismatch, got %llx, expected %llx\n",
 720                       __func__, __LINE__, tag, dev->tag);
 721
 722        if (res) {
 723                pr_err("%s:%u: res %d status 0x%llx\n", __func__, __LINE__, res,
 724                       status);
 725        } else {
 726                pr_debug("%s:%u: completed, status 0x%llx\n", __func__,
 727                         __LINE__, status);
 728                dev->lv1_status = status;
 729                complete(&dev->done);
 730        }
 731        spin_unlock(&dev->lock);
 732        return IRQ_HANDLED;
 733}
 734
 735static int ps3_notification_read_write(struct ps3_notification_device *dev,
 736                                       u64 lpar, int write)
 737{
 738        const char *op = write ? "write" : "read";
 739        unsigned long flags;
 740        int res;
 741
 742        init_completion(&dev->done);
 743        spin_lock_irqsave(&dev->lock, flags);
 744        res = write ? lv1_storage_write(dev->sbd.dev_id, 0, 0, 1, 0, lpar,
 745                                        &dev->tag)
 746                    : lv1_storage_read(dev->sbd.dev_id, 0, 0, 1, 0, lpar,
 747                                       &dev->tag);
 748        spin_unlock_irqrestore(&dev->lock, flags);
 749        if (res) {
 750                pr_err("%s:%u: %s failed %d\n", __func__, __LINE__, op, res);
 751                return -EPERM;
 752        }
 753        pr_debug("%s:%u: notification %s issued\n", __func__, __LINE__, op);
 754
 755        res = wait_event_interruptible(dev->done.wait,
 756                                       dev->done.done || kthread_should_stop());
 757        if (kthread_should_stop())
 758                res = -EINTR;
 759        if (res) {
 760                pr_debug("%s:%u: interrupted %s\n", __func__, __LINE__, op);
 761                return res;
 762        }
 763
 764        if (dev->lv1_status) {
 765                pr_err("%s:%u: %s not completed, status 0x%llx\n", __func__,
 766                       __LINE__, op, dev->lv1_status);
 767                return -EIO;
 768        }
 769        pr_debug("%s:%u: notification %s completed\n", __func__, __LINE__, op);
 770
 771        return 0;
 772}
 773
 774static struct task_struct *probe_task;
 775
 776/**
 777 * ps3_probe_thread - Background repository probing at system startup.
 778 *
 779 * This implementation only supports background probing on a single bus.
 780 * It uses the hypervisor's storage device notification mechanism to wait until
 781 * a storage device is ready.  The device notification mechanism uses a
 782 * pseudo device to asynchronously notify the guest when storage devices become
 783 * ready.  The notification device has a block size of 512 bytes.
 784 */
 785
 786static int ps3_probe_thread(void *data)
 787{
 788        struct ps3_notification_device dev;
 789        int res;
 790        unsigned int irq;
 791        u64 lpar;
 792        void *buf;
 793        struct ps3_notify_cmd *notify_cmd;
 794        struct ps3_notify_event *notify_event;
 795
 796        pr_debug(" -> %s:%u: kthread started\n", __func__, __LINE__);
 797
 798        buf = kzalloc(512, GFP_KERNEL);
 799        if (!buf)
 800                return -ENOMEM;
 801
 802        lpar = ps3_mm_phys_to_lpar(__pa(buf));
 803        notify_cmd = buf;
 804        notify_event = buf;
 805
 806        /* dummy system bus device */
 807        dev.sbd.bus_id = (u64)data;
 808        dev.sbd.dev_id = PS3_NOTIFICATION_DEV_ID;
 809        dev.sbd.interrupt_id = PS3_NOTIFICATION_INTERRUPT_ID;
 810
 811        res = lv1_open_device(dev.sbd.bus_id, dev.sbd.dev_id, 0);
 812        if (res) {
 813                pr_err("%s:%u: lv1_open_device failed %s\n", __func__,
 814                       __LINE__, ps3_result(res));
 815                goto fail_free;
 816        }
 817
 818        res = ps3_sb_event_receive_port_setup(&dev.sbd, PS3_BINDING_CPU_ANY,
 819                                              &irq);
 820        if (res) {
 821                pr_err("%s:%u: ps3_sb_event_receive_port_setup failed %d\n",
 822                       __func__, __LINE__, res);
 823               goto fail_close_device;
 824        }
 825
 826        spin_lock_init(&dev.lock);
 827
 828        res = request_irq(irq, ps3_notification_interrupt, 0,
 829                          "ps3_notification", &dev);
 830        if (res) {
 831                pr_err("%s:%u: request_irq failed %d\n", __func__, __LINE__,
 832                       res);
 833                goto fail_sb_event_receive_port_destroy;
 834        }
 835
 836        /* Setup and write the request for device notification. */
 837        notify_cmd->operation_code = 0; /* must be zero */
 838        notify_cmd->event_mask = 1UL << notify_region_probe;
 839
 840        res = ps3_notification_read_write(&dev, lpar, 1);
 841        if (res)
 842                goto fail_free_irq;
 843
 844        /* Loop here processing the requested notification events. */
 845        do {
 846                try_to_freeze();
 847
 848                memset(notify_event, 0, sizeof(*notify_event));
 849
 850                res = ps3_notification_read_write(&dev, lpar, 0);
 851                if (res)
 852                        break;
 853
 854                pr_debug("%s:%u: notify event type 0x%llx bus id %llu dev id %llu"
 855                         " type %llu port %llu\n", __func__, __LINE__,
 856                         notify_event->event_type, notify_event->bus_id,
 857                         notify_event->dev_id, notify_event->dev_type,
 858                         notify_event->dev_port);
 859
 860                if (notify_event->event_type != notify_region_probe ||
 861                    notify_event->bus_id != dev.sbd.bus_id) {
 862                        pr_warn("%s:%u: bad notify_event: event %llu, dev_id %llu, dev_type %llu\n",
 863                                __func__, __LINE__, notify_event->event_type,
 864                                notify_event->dev_id, notify_event->dev_type);
 865                        continue;
 866                }
 867
 868                ps3_find_and_add_device(dev.sbd.bus_id, notify_event->dev_id);
 869
 870        } while (!kthread_should_stop());
 871
 872fail_free_irq:
 873        free_irq(irq, &dev);
 874fail_sb_event_receive_port_destroy:
 875        ps3_sb_event_receive_port_destroy(&dev.sbd, irq);
 876fail_close_device:
 877        lv1_close_device(dev.sbd.bus_id, dev.sbd.dev_id);
 878fail_free:
 879        kfree(buf);
 880
 881        probe_task = NULL;
 882
 883        pr_debug(" <- %s:%u: kthread finished\n", __func__, __LINE__);
 884
 885        return 0;
 886}
 887
 888/**
 889 * ps3_stop_probe_thread - Stops the background probe thread.
 890 *
 891 */
 892
 893static int ps3_stop_probe_thread(struct notifier_block *nb, unsigned long code,
 894                                 void *data)
 895{
 896        if (probe_task)
 897                kthread_stop(probe_task);
 898        return 0;
 899}
 900
 901static struct notifier_block nb = {
 902        .notifier_call = ps3_stop_probe_thread
 903};
 904
 905/**
 906 * ps3_start_probe_thread - Starts the background probe thread.
 907 *
 908 */
 909
 910static int __init ps3_start_probe_thread(enum ps3_bus_type bus_type)
 911{
 912        int result;
 913        struct task_struct *task;
 914        struct ps3_repository_device repo;
 915
 916        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 917
 918        memset(&repo, 0, sizeof(repo));
 919
 920        repo.bus_type = bus_type;
 921
 922        result = ps3_repository_find_bus(repo.bus_type, 0, &repo.bus_index);
 923
 924        if (result) {
 925                printk(KERN_ERR "%s: Cannot find bus (%d)\n", __func__, result);
 926                return -ENODEV;
 927        }
 928
 929        result = ps3_repository_read_bus_id(repo.bus_index, &repo.bus_id);
 930
 931        if (result) {
 932                printk(KERN_ERR "%s: read_bus_id failed %d\n", __func__,
 933                        result);
 934                return -ENODEV;
 935        }
 936
 937        task = kthread_run(ps3_probe_thread, (void *)repo.bus_id,
 938                           "ps3-probe-%u", bus_type);
 939
 940        if (IS_ERR(task)) {
 941                result = PTR_ERR(task);
 942                printk(KERN_ERR "%s: kthread_run failed %d\n", __func__,
 943                       result);
 944                return result;
 945        }
 946
 947        probe_task = task;
 948        register_reboot_notifier(&nb);
 949
 950        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 951        return 0;
 952}
 953
 954/**
 955 * ps3_register_devices - Probe the system and register devices found.
 956 *
 957 * A device_initcall() routine.
 958 */
 959
 960static int __init ps3_register_devices(void)
 961{
 962        int result;
 963
 964        if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
 965                return -ENODEV;
 966
 967        pr_debug(" -> %s:%d\n", __func__, __LINE__);
 968
 969        /* ps3_repository_dump_bus_info(); */
 970
 971        result = ps3_start_probe_thread(PS3_BUS_TYPE_STORAGE);
 972
 973        ps3_register_vuart_devices();
 974
 975        ps3_register_graphics_devices();
 976
 977        ps3_repository_find_devices(PS3_BUS_TYPE_SB, ps3_setup_static_device);
 978
 979        ps3_register_sound_devices();
 980
 981        ps3_register_lpm_devices();
 982
 983        ps3_register_ramdisk_device();
 984
 985        pr_debug(" <- %s:%d\n", __func__, __LINE__);
 986        return 0;
 987}
 988
 989device_initcall(ps3_register_devices);
 990