arch/powerpc/platforms/ps3/interrupt.c

   1 /*
   2  *  PS3 interrupt routines.
   3  *
   4  *  Copyright (C) 2006 Sony Computer Entertainment Inc.
   5  *  Copyright 2006 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/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/irq.h>
  24
  25 #include <asm/machdep.h>
  26 #include <asm/udbg.h>
  27 #include <asm/ps3.h>
  28 #include <asm/lv1call.h>
  29
  30 #include "platform.h"
  31
  32 #if defined(DEBUG)
  33 #define DBG(fmt...) udbg_printf(fmt)
  34 #else
  35 #define DBG(fmt...) do{if(0)printk(fmt);}while(0)
  36 #endif
  37
  38 /**
  39  * struct ps3_bmp - a per cpu irq status and mask bitmap structure
  40  * @status: 256 bit status bitmap indexed by plug
  41  * @unused_1:
  42  * @mask: 256 bit mask bitmap indexed by plug
  43  * @unused_2:
  44  * @lock:
  45  * @ipi_debug_brk_mask:
  46  *
  47  * The HV mantains per SMT thread mappings of HV outlet to HV plug on
  48  * behalf of the guest.  These mappings are implemented as 256 bit guest
  49  * supplied bitmaps indexed by plug number.  The addresses of the bitmaps
  50  * are registered with the HV through lv1_configure_irq_state_bitmap().
  51  *
  52  * The HV supports 256 plugs per thread, assigned as {0..255}, for a total
  53  * of 512 plugs supported on a processor.  To simplify the logic this
  54  * implementation equates HV plug value to Linux virq value, constrains each
  55  * interrupt to have a system wide unique plug number, and limits the range
  56  * of the plug values to map into the first dword of the bitmaps.  This
  57  * gives a usable range of plug values of  {NUM_ISA_INTERRUPTS..63}.  Note
  58  * that there is no constraint on how many in this set an individual thread
  59  * can acquire.
  60  */
  61
  62 struct ps3_bmp {
  63         struct {
  64                 u64 status;
  65                 u64 unused_1[3];
  66                 u64 mask;
  67                 u64 unused_2[3];
  68         };
  69         u64 ipi_debug_brk_mask;
  70         spinlock_t lock;
  71 };
  72
  73 /**
  74  * struct ps3_private - a per cpu data structure
  75  * @bmp: ps3_bmp structure
  76  * @node: HV logical_ppe_id
  77  * @cpu: HV thread_id
  78  */
  79
  80 struct ps3_private {
  81         struct ps3_bmp bmp __attribute__ ((aligned (64)));
  82         u64 node;
  83         unsigned int cpu;
  84 };
  85
  86 static DEFINE_PER_CPU(struct ps3_private, ps3_private);
  87
  88 static int ps3_connect_irq(enum ps3_cpu_binding cpu, unsigned long outlet,
  89         unsigned int *virq)
  90 {
  91         int result;
  92         struct ps3_private *pd;
  93
  94         /* This defines the default interrupt distribution policy. */
  95
  96         if (cpu == PS3_BINDING_CPU_ANY)
  97                 cpu = 0;
  98
  99         pd = &per_cpu(ps3_private, cpu);
 100
 101         *virq = irq_create_mapping(NULL, outlet);
 102
 103         if (*virq == NO_IRQ) {
 104                 pr_debug("%s:%d: irq_create_mapping failed: outlet %lu\n",
 105                         __func__, __LINE__, outlet);
 106                 result = -ENOMEM;
 107                 goto fail_create;
 108         }
 109
 110         /* Binds outlet to cpu + virq. */
 111
 112         result = lv1_connect_irq_plug_ext(pd->node, pd->cpu, *virq, outlet, 0);
 113
 114         if (result) {
 115                 pr_info("%s:%d: lv1_connect_irq_plug_ext failed: %s\n",
 116                 __func__, __LINE__, ps3_result(result));
 117                 result = -EPERM;
 118                 goto fail_connect;
 119         }
 120
 121         pr_debug("%s:%d: outlet %lu => cpu %u, virq %u\n", __func__, __LINE__,
 122                 outlet, cpu, *virq);
 123
 124         result = set_irq_chip_data(*virq, pd);
 125
 126         if (result) {
 127                 pr_debug("%s:%d: set_irq_chip_data failed\n",
 128                         __func__, __LINE__);
 129                 goto fail_set;
 130         }
 131
 132         return result;
 133
 134 fail_set:
 135         lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, *virq);
 136 fail_connect:
 137         irq_dispose_mapping(*virq);
 138 fail_create:
 139         return result;
 140 }
 141
 142 static void ps3_disconnect_irq(unsigned int virq)
 143 {
 144         int result;
 145         const struct ps3_private *pd = get_irq_chip_data(virq);
 146
 147         pr_debug("%s:%d: node %lu, cpu %d, virq %u\n", __func__, __LINE__,
 148                 pd->node, pd->cpu, virq);
 149
 150         result = lv1_disconnect_irq_plug_ext(pd->node, pd->cpu, virq);
 151
 152         if (result)
 153                 pr_info("%s:%d: lv1_disconnect_irq_plug_ext failed: %s\n",
 154                 __func__, __LINE__, ps3_result(result));
 155
 156         set_irq_chip_data(virq, NULL);
 157         irq_dispose_mapping(virq);
 158 }
 159
 160 /**
 161  * ps3_alloc_io_irq - Assign a virq to a system bus device.
 162  * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 163  * serviced on.
 164  * @interrupt_id: The device interrupt id read from the system repository.
 165  * @virq: The assigned Linux virq.
 166  *
 167  * An io irq represents a non-virtualized device interrupt.  interrupt_id
 168  * coresponds to the interrupt number of the interrupt controller.
 169  */
 170
 171 int ps3_alloc_io_irq(enum ps3_cpu_binding cpu, unsigned int interrupt_id,
 172         unsigned int *virq)
 173 {
 174         int result;
 175         unsigned long outlet;
 176
 177         result = lv1_construct_io_irq_outlet(interrupt_id, &outlet);
 178
 179         if (result) {
 180                 pr_debug("%s:%d: lv1_construct_io_irq_outlet failed: %s\n",
 181                         __func__, __LINE__, ps3_result(result));
 182                 return result;
 183         }
 184
 185         result = ps3_connect_irq(cpu, outlet, virq);
 186         BUG_ON(result);
 187
 188         return result;
 189 }
 190
 191 int ps3_free_io_irq(unsigned int virq)
 192 {
 193         int result;
 194
 195         result = lv1_destruct_io_irq_outlet(virq_to_hw(virq));
 196
 197         if (result)
 198                 pr_debug("%s:%d: lv1_destruct_io_irq_outlet failed: %s\n",
 199                         __func__, __LINE__, ps3_result(result));
 200
 201         ps3_disconnect_irq(virq);
 202
 203         return result;
 204 }
 205
 206 /**
 207  * ps3_alloc_event_irq - Allocate a virq for use with a system event.
 208  * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 209  * serviced on.
 210  * @virq: The assigned Linux virq.
 211  *
 212  * The virq can be used with lv1_connect_interrupt_event_receive_port() to
 213  * arrange to receive events, or with ps3_send_event_locally() to signal
 214  * events.
 215  */
 216
 217 int ps3_alloc_event_irq(enum ps3_cpu_binding cpu, unsigned int *virq)
 218 {
 219         int result;
 220         unsigned long outlet;
 221
 222         result = lv1_construct_event_receive_port(&outlet);
 223
 224         if (result) {
 225                 pr_debug("%s:%d: lv1_construct_event_receive_port failed: %s\n",
 226                         __func__, __LINE__, ps3_result(result));
 227                 *virq = NO_IRQ;
 228                 return result;
 229         }
 230
 231         result = ps3_connect_irq(cpu, outlet, virq);
 232         BUG_ON(result);
 233
 234         return result;
 235 }
 236
 237 int ps3_free_event_irq(unsigned int virq)
 238 {
 239         int result;
 240
 241         pr_debug(" -> %s:%d\n", __func__, __LINE__);
 242
 243         result = lv1_destruct_event_receive_port(virq_to_hw(virq));
 244
 245         if (result)
 246                 pr_debug("%s:%d: lv1_destruct_event_receive_port failed: %s\n",
 247                         __func__, __LINE__, ps3_result(result));
 248
 249         ps3_disconnect_irq(virq);
 250
 251         pr_debug(" <- %s:%d\n", __func__, __LINE__);
 252         return result;
 253 }
 254
 255 int ps3_send_event_locally(unsigned int virq)
 256 {
 257         return lv1_send_event_locally(virq_to_hw(virq));
 258 }
 259
 260 /**
 261  * ps3_connect_event_irq - Assign a virq to a system bus device.
 262  * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 263  * serviced on.
 264  * @did: The HV device identifier read from the system repository.
 265  * @interrupt_id: The device interrupt id read from the system repository.
 266  * @virq: The assigned Linux virq.
 267  *
 268  * An event irq represents a virtual device interrupt.  The interrupt_id
 269  * coresponds to the software interrupt number.
 270  */
 271
 272 int ps3_connect_event_irq(enum ps3_cpu_binding cpu,
 273         const struct ps3_device_id *did, unsigned int interrupt_id,
 274         unsigned int *virq)
 275 {
 276         int result;
 277
 278         result = ps3_alloc_event_irq(cpu, virq);
 279
 280         if (result)
 281                 return result;
 282
 283         result = lv1_connect_interrupt_event_receive_port(did->bus_id,
 284                 did->dev_id, virq_to_hw(*virq), interrupt_id);
 285
 286         if (result) {
 287                 pr_debug("%s:%d: lv1_connect_interrupt_event_receive_port"
 288                         " failed: %s\n", __func__, __LINE__,
 289                         ps3_result(result));
 290                 ps3_free_event_irq(*virq);
 291                 *virq = NO_IRQ;
 292                 return result;
 293         }
 294
 295         pr_debug("%s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
 296                 interrupt_id, *virq);
 297
 298         return 0;
 299 }
 300
 301 int ps3_disconnect_event_irq(const struct ps3_device_id *did,
 302         unsigned int interrupt_id, unsigned int virq)
 303 {
 304         int result;
 305
 306         pr_debug(" -> %s:%d: interrupt_id %u, virq %u\n", __func__, __LINE__,
 307                 interrupt_id, virq);
 308
 309         result = lv1_disconnect_interrupt_event_receive_port(did->bus_id,
 310                 did->dev_id, virq_to_hw(virq), interrupt_id);
 311
 312         if (result)
 313                 pr_debug("%s:%d: lv1_disconnect_interrupt_event_receive_port"
 314                         " failed: %s\n", __func__, __LINE__,
 315                         ps3_result(result));
 316
 317         ps3_free_event_irq(virq);
 318
 319         pr_debug(" <- %s:%d\n", __func__, __LINE__);
 320         return result;
 321 }
 322
 323 /**
 324  * ps3_alloc_vuart_irq - Configure the system virtual uart virq.
 325  * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 326  * serviced on.
 327  * @virt_addr_bmp: The caller supplied virtual uart interrupt bitmap.
 328  * @virq: The assigned Linux virq.
 329  *
 330  * The system supports only a single virtual uart, so multiple calls without
 331  * freeing the interrupt will return a wrong state error.
 332  */
 333
 334 int ps3_alloc_vuart_irq(enum ps3_cpu_binding cpu, void* virt_addr_bmp,
 335         unsigned int *virq)
 336 {
 337         int result;
 338         unsigned long outlet;
 339         u64 lpar_addr;
 340
 341         BUG_ON(!is_kernel_addr((u64)virt_addr_bmp));
 342
 343         lpar_addr = ps3_mm_phys_to_lpar(__pa(virt_addr_bmp));
 344
 345         result = lv1_configure_virtual_uart_irq(lpar_addr, &outlet);
 346
 347         if (result) {
 348                 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
 349                         __func__, __LINE__, ps3_result(result));
 350                 return result;
 351         }
 352
 353         result = ps3_connect_irq(cpu, outlet, virq);
 354         BUG_ON(result);
 355
 356         return result;
 357 }
 358
 359 int ps3_free_vuart_irq(unsigned int virq)
 360 {
 361         int result;
 362
 363         result = lv1_deconfigure_virtual_uart_irq();
 364
 365         if (result) {
 366                 pr_debug("%s:%d: lv1_configure_virtual_uart_irq failed: %s\n",
 367                         __func__, __LINE__, ps3_result(result));
 368                 return result;
 369         }
 370
 371         ps3_disconnect_irq(virq);
 372
 373         return result;
 374 }
 375
 376 /**
 377  * ps3_alloc_spe_irq - Configure an spe virq.
 378  * @cpu: enum ps3_cpu_binding indicating the cpu the interrupt should be
 379  * serviced on.
 380  * @spe_id: The spe_id returned from lv1_construct_logical_spe().
 381  * @class: The spe interrupt class {0,1,2}.
 382  * @virq: The assigned Linux virq.
 383  *
 384  */
 385
 386 int ps3_alloc_spe_irq(enum ps3_cpu_binding cpu, unsigned long spe_id,
 387         unsigned int class, unsigned int *virq)
 388 {
 389         int result;
 390         unsigned long outlet;
 391
 392         BUG_ON(class > 2);
 393
 394         result = lv1_get_spe_irq_outlet(spe_id, class, &outlet);
 395
 396         if (result) {
 397                 pr_debug("%s:%d: lv1_get_spe_irq_outlet failed: %s\n",
 398                         __func__, __LINE__, ps3_result(result));
 399                 return result;
 400         }
 401
 402         result = ps3_connect_irq(cpu, outlet, virq);
 403         BUG_ON(result);
 404
 405         return result;
 406 }
 407
 408 int ps3_free_spe_irq(unsigned int virq)
 409 {
 410         ps3_disconnect_irq(virq);
 411         return 0;
 412 }
 413
 414 #define PS3_INVALID_OUTLET ((irq_hw_number_t)-1)
 415 #define PS3_PLUG_MAX 63
 416
 417 #if defined(DEBUG)
 418 static void _dump_64_bmp(const char *header, const u64 *p, unsigned cpu,
 419         const char* func, int line)
 420 {
 421         pr_debug("%s:%d: %s %u {%04lx_%04lx_%04lx_%04lx}\n",
 422                 func, line, header, cpu,
 423                 *p >> 48, (*p >> 32) & 0xffff, (*p >> 16) & 0xffff,
 424                 *p & 0xffff);
 425 }
 426
 427 static void __attribute__ ((unused)) _dump_256_bmp(const char *header,
 428         const u64 *p, unsigned cpu, const char* func, int line)
 429 {
 430         pr_debug("%s:%d: %s %u {%016lx:%016lx:%016lx:%016lx}\n",
 431                 func, line, header, cpu, p[0], p[1], p[2], p[3]);
 432 }
 433
 434 #define dump_bmp(_x) _dump_bmp(_x, __func__, __LINE__)
 435 static void _dump_bmp(struct ps3_private* pd, const char* func, int line)
 436 {
 437         unsigned long flags;
 438
 439         spin_lock_irqsave(&pd->bmp.lock, flags);
 440         _dump_64_bmp("stat", &pd->bmp.status, pd->cpu, func, line);
 441         _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
 442         spin_unlock_irqrestore(&pd->bmp.lock, flags);
 443 }
 444
 445 #define dump_mask(_x) _dump_mask(_x, __func__, __LINE__)
 446 static void __attribute__ ((unused)) _dump_mask(struct ps3_private* pd,
 447         const char* func, int line)
 448 {
 449         unsigned long flags;
 450
 451         spin_lock_irqsave(&pd->bmp.lock, flags);
 452         _dump_64_bmp("mask", &pd->bmp.mask, pd->cpu, func, line);
 453         spin_unlock_irqrestore(&pd->bmp.lock, flags);
 454 }
 455 #else
 456 static void dump_bmp(struct ps3_private* pd) {};
 457 #endif /* defined(DEBUG) */
 458
 459 static void ps3_chip_mask(unsigned int virq)
 460 {
 461         struct ps3_private *pd = get_irq_chip_data(virq);
 462         u64 bit = 0x8000000000000000UL >> virq;
 463         u64 *p = &pd->bmp.mask;
 464         u64 old;
 465         unsigned long flags;
 466
 467         pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
 468
 469         local_irq_save(flags);
 470         asm volatile(
 471                      "1:        ldarx %0,0,%3\n"
 472                      "andc      %0,%0,%2\n"
 473                      "stdcx.    %0,0,%3\n"
 474                      "bne-      1b"
 475                      : "=&r" (old), "+m" (*p)
 476                      : "r" (bit), "r" (p)
 477                      : "cc" );
 478
 479         lv1_did_update_interrupt_mask(pd->node, pd->cpu);
 480         local_irq_restore(flags);
 481 }
 482
 483 static void ps3_chip_unmask(unsigned int virq)
 484 {
 485         struct ps3_private *pd = get_irq_chip_data(virq);
 486         u64 bit = 0x8000000000000000UL >> virq;
 487         u64 *p = &pd->bmp.mask;
 488         u64 old;
 489         unsigned long flags;
 490
 491         pr_debug("%s:%d: cpu %u, virq %d\n", __func__, __LINE__, pd->cpu, virq);
 492
 493         local_irq_save(flags);
 494         asm volatile(
 495                      "1:        ldarx %0,0,%3\n"
 496                      "or        %0,%0,%2\n"
 497                      "stdcx.    %0,0,%3\n"
 498                      "bne-      1b"
 499                      : "=&r" (old), "+m" (*p)
 500                      : "r" (bit), "r" (p)
 501                      : "cc" );
 502
 503         lv1_did_update_interrupt_mask(pd->node, pd->cpu);
 504         local_irq_restore(flags);
 505 }
 506
 507 static void ps3_chip_eoi(unsigned int virq)
 508 {
 509         const struct ps3_private *pd = get_irq_chip_data(virq);
 510         lv1_end_of_interrupt_ext(pd->node, pd->cpu, virq);
 511 }
 512
 513 static struct irq_chip irq_chip = {
 514         .typename = "ps3",
 515         .mask = ps3_chip_mask,
 516         .unmask = ps3_chip_unmask,
 517         .eoi = ps3_chip_eoi,
 518 };
 519
 520 static void ps3_host_unmap(struct irq_host *h, unsigned int virq)
 521 {
 522         set_irq_chip_data(virq, NULL);
 523 }
 524
 525 static int ps3_host_map(struct irq_host *h, unsigned int virq,
 526         irq_hw_number_t hwirq)
 527 {
 528         pr_debug("%s:%d: hwirq %lu, virq %u\n", __func__, __LINE__, hwirq,
 529                 virq);
 530
 531         set_irq_chip_and_handler(virq, &irq_chip, handle_fasteoi_irq);
 532
 533         return 0;
 534 }
 535
 536 static struct irq_host_ops ps3_host_ops = {
 537         .map = ps3_host_map,
 538         .unmap = ps3_host_unmap,
 539 };
 540
 541 void __init ps3_register_ipi_debug_brk(unsigned int cpu, unsigned int virq)
 542 {
 543         struct ps3_private *pd = &per_cpu(ps3_private, cpu);
 544
 545         pd->bmp.ipi_debug_brk_mask = 0x8000000000000000UL >> virq;
 546
 547         pr_debug("%s:%d: cpu %u, virq %u, mask %lxh\n", __func__, __LINE__,
 548                 cpu, virq, pd->bmp.ipi_debug_brk_mask);
 549 }
 550
 551 unsigned int ps3_get_irq(void)
 552 {
 553         struct ps3_private *pd = &__get_cpu_var(ps3_private);
 554         u64 x = (pd->bmp.status & pd->bmp.mask);
 555         unsigned int plug;
 556
 557         /* check for ipi break first to stop this cpu ASAP */
 558
 559         if (x & pd->bmp.ipi_debug_brk_mask)
 560                 x &= pd->bmp.ipi_debug_brk_mask;
 561
 562         asm volatile("cntlzd %0,%1" : "=r" (plug) : "r" (x));
 563         plug &= 0x3f;
 564
 565         if (unlikely(plug) == NO_IRQ) {
 566                 pr_debug("%s:%d: no plug found: cpu %u\n", __func__, __LINE__,
 567                         pd->cpu);
 568                 dump_bmp(&per_cpu(ps3_private, 0));
 569                 dump_bmp(&per_cpu(ps3_private, 1));
 570                 return NO_IRQ;
 571         }
 572
 573 #if defined(DEBUG)
 574         if (unlikely(plug < NUM_ISA_INTERRUPTS || plug > PS3_PLUG_MAX)) {
 575                 dump_bmp(&per_cpu(ps3_private, 0));
 576                 dump_bmp(&per_cpu(ps3_private, 1));
 577                 BUG();
 578         }
 579 #endif
 580         return plug;
 581 }
 582
 583 void __init ps3_init_IRQ(void)
 584 {
 585         int result;
 586         unsigned cpu;
 587         struct irq_host *host;
 588
 589         host = irq_alloc_host(IRQ_HOST_MAP_NOMAP, 0, &ps3_host_ops,
 590                 PS3_INVALID_OUTLET);
 591         irq_set_default_host(host);
 592         irq_set_virq_count(PS3_PLUG_MAX + 1);
 593
 594         for_each_possible_cpu(cpu) {
 595                 struct ps3_private *pd = &per_cpu(ps3_private, cpu);
 596
 597                 lv1_get_logical_ppe_id(&pd->node);
 598                 pd->cpu = get_hard_smp_processor_id(cpu);
 599                 spin_lock_init(&pd->bmp.lock);
 600
 601                 pr_debug("%s:%d: node %lu, cpu %d, bmp %lxh\n", __func__,
 602                         __LINE__, pd->node, pd->cpu,
 603                         ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
 604
 605                 result = lv1_configure_irq_state_bitmap(pd->node, pd->cpu,
 606                         ps3_mm_phys_to_lpar(__pa(&pd->bmp)));
 607
 608                 if (result)
 609                         pr_debug("%s:%d: lv1_configure_irq_state_bitmap failed:"
 610                                 " %s\n", __func__, __LINE__,
 611                                 ps3_result(result));
 612         }
 613
 614         ppc_md.get_irq = ps3_get_irq;
 615 }