arch/powerpc/sysdev/fsl_rmu.c

   1 /*
   2  * Freescale MPC85xx/MPC86xx RapidIO RMU support
   3  *
   4  * Copyright 2009 Sysgo AG
   5  * Thomas Moll <thomas.moll@sysgo.com>
   6  * - fixed maintenance access routines, check for aligned access
   7  *
   8  * Copyright 2009 Integrated Device Technology, Inc.
   9  * Alex Bounine <alexandre.bounine@idt.com>
  10  * - Added Port-Write message handling
  11  * - Added Machine Check exception handling
  12  *
  13  * Copyright (C) 2007, 2008, 2010, 2011 Freescale Semiconductor, Inc.
  14  * Zhang Wei <wei.zhang@freescale.com>
  15  * Lian Minghuan-B31939 <Minghuan.Lian@freescale.com>
  16  * Liu Gang <Gang.Liu@freescale.com>
  17  *
  18  * Copyright 2005 MontaVista Software, Inc.
  19  * Matt Porter <mporter@kernel.crashing.org>
  20  *
  21  * This program is free software; you can redistribute  it and/or modify it
  22  * under  the terms of  the GNU General  Public License as published by the
  23  * Free Software Foundation;  either version 2 of the  License, or (at your
  24  * option) any later version.
  25  */
  26
  27 #include <linux/types.h>
  28 #include <linux/dma-mapping.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/of_irq.h>
  31 #include <linux/of_platform.h>
  32 #include <linux/slab.h>
  33
  34 #include "fsl_rio.h"
  35
  36 #define GET_RMM_HANDLE(mport) \
  37                 (((struct rio_priv *)(mport->priv))->rmm_handle)
  38
  39 /* RapidIO definition irq, which read from OF-tree */
  40 #define IRQ_RIO_PW(m)           (((struct fsl_rio_pw *)(m))->pwirq)
  41 #define IRQ_RIO_BELL(m) (((struct fsl_rio_dbell *)(m))->bellirq)
  42 #define IRQ_RIO_TX(m) (((struct fsl_rmu *)(GET_RMM_HANDLE(m)))->txirq)
  43 #define IRQ_RIO_RX(m) (((struct fsl_rmu *)(GET_RMM_HANDLE(m)))->rxirq)
  44
  45 #define RIO_MIN_TX_RING_SIZE    2
  46 #define RIO_MAX_TX_RING_SIZE    2048
  47 #define RIO_MIN_RX_RING_SIZE    2
  48 #define RIO_MAX_RX_RING_SIZE    2048
  49
  50 #define RIO_IPWMR_SEN           0x00100000
  51 #define RIO_IPWMR_QFIE          0x00000100
  52 #define RIO_IPWMR_EIE           0x00000020
  53 #define RIO_IPWMR_CQ            0x00000002
  54 #define RIO_IPWMR_PWE           0x00000001
  55
  56 #define RIO_IPWSR_QF            0x00100000
  57 #define RIO_IPWSR_TE            0x00000080
  58 #define RIO_IPWSR_QFI           0x00000010
  59 #define RIO_IPWSR_PWD           0x00000008
  60 #define RIO_IPWSR_PWB           0x00000004
  61
  62 #define RIO_EPWISR              0x10010
  63 /* EPWISR Error match value */
  64 #define RIO_EPWISR_PINT1        0x80000000
  65 #define RIO_EPWISR_PINT2        0x40000000
  66 #define RIO_EPWISR_MU           0x00000002
  67 #define RIO_EPWISR_PW           0x00000001
  68
  69 #define IPWSR_CLEAR             0x98
  70 #define OMSR_CLEAR              0x1cb3
  71 #define IMSR_CLEAR              0x491
  72 #define IDSR_CLEAR              0x91
  73 #define ODSR_CLEAR              0x1c00
  74 #define LTLEECSR_ENABLE_ALL     0xFFC000FC
  75 #define RIO_LTLEECSR            0x060c
  76
  77 #define RIO_IM0SR               0x64
  78 #define RIO_IM1SR               0x164
  79 #define RIO_OM0SR               0x4
  80 #define RIO_OM1SR               0x104
  81
  82 #define RIO_DBELL_WIN_SIZE      0x1000
  83
  84 #define RIO_MSG_OMR_MUI         0x00000002
  85 #define RIO_MSG_OSR_TE          0x00000080
  86 #define RIO_MSG_OSR_QOI         0x00000020
  87 #define RIO_MSG_OSR_QFI         0x00000010
  88 #define RIO_MSG_OSR_MUB         0x00000004
  89 #define RIO_MSG_OSR_EOMI        0x00000002
  90 #define RIO_MSG_OSR_QEI         0x00000001
  91
  92 #define RIO_MSG_IMR_MI          0x00000002
  93 #define RIO_MSG_ISR_TE          0x00000080
  94 #define RIO_MSG_ISR_QFI         0x00000010
  95 #define RIO_MSG_ISR_DIQI        0x00000001
  96
  97 #define RIO_MSG_DESC_SIZE       32
  98 #define RIO_MSG_BUFFER_SIZE     4096
  99
 100 #define DOORBELL_DMR_DI         0x00000002
 101 #define DOORBELL_DSR_TE         0x00000080
 102 #define DOORBELL_DSR_QFI        0x00000010
 103 #define DOORBELL_DSR_DIQI       0x00000001
 104
 105 #define DOORBELL_MESSAGE_SIZE   0x08
 106
 107 static DEFINE_SPINLOCK(fsl_rio_doorbell_lock);
 108
 109 struct rio_msg_regs {
 110         u32 omr;
 111         u32 osr;
 112         u32 pad1;
 113         u32 odqdpar;
 114         u32 pad2;
 115         u32 osar;
 116         u32 odpr;
 117         u32 odatr;
 118         u32 odcr;
 119         u32 pad3;
 120         u32 odqepar;
 121         u32 pad4[13];
 122         u32 imr;
 123         u32 isr;
 124         u32 pad5;
 125         u32 ifqdpar;
 126         u32 pad6;
 127         u32 ifqepar;
 128 };
 129
 130 struct rio_dbell_regs {
 131         u32 odmr;
 132         u32 odsr;
 133         u32 pad1[4];
 134         u32 oddpr;
 135         u32 oddatr;
 136         u32 pad2[3];
 137         u32 odretcr;
 138         u32 pad3[12];
 139         u32 dmr;
 140         u32 dsr;
 141         u32 pad4;
 142         u32 dqdpar;
 143         u32 pad5;
 144         u32 dqepar;
 145 };
 146
 147 struct rio_pw_regs {
 148         u32 pwmr;
 149         u32 pwsr;
 150         u32 epwqbar;
 151         u32 pwqbar;
 152 };
 153
 154
 155 struct rio_tx_desc {
 156         u32 pad1;
 157         u32 saddr;
 158         u32 dport;
 159         u32 dattr;
 160         u32 pad2;
 161         u32 pad3;
 162         u32 dwcnt;
 163         u32 pad4;
 164 };
 165
 166 struct rio_msg_tx_ring {
 167         void *virt;
 168         dma_addr_t phys;
 169         void *virt_buffer[RIO_MAX_TX_RING_SIZE];
 170         dma_addr_t phys_buffer[RIO_MAX_TX_RING_SIZE];
 171         int tx_slot;
 172         int size;
 173         void *dev_id;
 174 };
 175
 176 struct rio_msg_rx_ring {
 177         void *virt;
 178         dma_addr_t phys;
 179         void *virt_buffer[RIO_MAX_RX_RING_SIZE];
 180         int rx_slot;
 181         int size;
 182         void *dev_id;
 183 };
 184
 185 struct fsl_rmu {
 186         struct rio_msg_regs __iomem *msg_regs;
 187         struct rio_msg_tx_ring msg_tx_ring;
 188         struct rio_msg_rx_ring msg_rx_ring;
 189         int txirq;
 190         int rxirq;
 191 };
 192
 193 struct rio_dbell_msg {
 194         u16 pad1;
 195         u16 tid;
 196         u16 sid;
 197         u16 info;
 198 };
 199
 200 /**
 201  * fsl_rio_tx_handler - MPC85xx outbound message interrupt handler
 202  * @irq: Linux interrupt number
 203  * @dev_instance: Pointer to interrupt-specific data
 204  *
 205  * Handles outbound message interrupts. Executes a register outbound
 206  * mailbox event handler and acks the interrupt occurrence.
 207  */
 208 static irqreturn_t
 209 fsl_rio_tx_handler(int irq, void *dev_instance)
 210 {
 211         int osr;
 212         struct rio_mport *port = (struct rio_mport *)dev_instance;
 213         struct fsl_rmu *rmu = GET_RMM_HANDLE(port);
 214
 215         osr = in_be32(&rmu->msg_regs->osr);
 216
 217         if (osr & RIO_MSG_OSR_TE) {
 218                 pr_info("RIO: outbound message transmission error\n");
 219                 out_be32(&rmu->msg_regs->osr, RIO_MSG_OSR_TE);
 220                 goto out;
 221         }
 222
 223         if (osr & RIO_MSG_OSR_QOI) {
 224                 pr_info("RIO: outbound message queue overflow\n");
 225                 out_be32(&rmu->msg_regs->osr, RIO_MSG_OSR_QOI);
 226                 goto out;
 227         }
 228
 229         if (osr & RIO_MSG_OSR_EOMI) {
 230                 u32 dqp = in_be32(&rmu->msg_regs->odqdpar);
 231                 int slot = (dqp - rmu->msg_tx_ring.phys) >> 5;
 232                 if (port->outb_msg[0].mcback != NULL) {
 233                         port->outb_msg[0].mcback(port, rmu->msg_tx_ring.dev_id,
 234                                         -1,
 235                                         slot);
 236                 }
 237                 /* Ack the end-of-message interrupt */
 238                 out_be32(&rmu->msg_regs->osr, RIO_MSG_OSR_EOMI);
 239         }
 240
 241 out:
 242         return IRQ_HANDLED;
 243 }
 244
 245 /**
 246  * fsl_rio_rx_handler - MPC85xx inbound message interrupt handler
 247  * @irq: Linux interrupt number
 248  * @dev_instance: Pointer to interrupt-specific data
 249  *
 250  * Handles inbound message interrupts. Executes a registered inbound
 251  * mailbox event handler and acks the interrupt occurrence.
 252  */
 253 static irqreturn_t
 254 fsl_rio_rx_handler(int irq, void *dev_instance)
 255 {
 256         int isr;
 257         struct rio_mport *port = (struct rio_mport *)dev_instance;
 258         struct fsl_rmu *rmu = GET_RMM_HANDLE(port);
 259
 260         isr = in_be32(&rmu->msg_regs->isr);
 261
 262         if (isr & RIO_MSG_ISR_TE) {
 263                 pr_info("RIO: inbound message reception error\n");
 264                 out_be32((void *)&rmu->msg_regs->isr, RIO_MSG_ISR_TE);
 265                 goto out;
 266         }
 267
 268         /* XXX Need to check/dispatch until queue empty */
 269         if (isr & RIO_MSG_ISR_DIQI) {
 270                 /*
 271                 * Can receive messages for any mailbox/letter to that
 272                 * mailbox destination. So, make the callback with an
 273                 * unknown/invalid mailbox number argument.
 274                 */
 275                 if (port->inb_msg[0].mcback != NULL)
 276                         port->inb_msg[0].mcback(port, rmu->msg_rx_ring.dev_id,
 277                                 -1,
 278                                 -1);
 279
 280                 /* Ack the queueing interrupt */
 281                 out_be32(&rmu->msg_regs->isr, RIO_MSG_ISR_DIQI);
 282         }
 283
 284 out:
 285         return IRQ_HANDLED;
 286 }
 287
 288 /**
 289  * fsl_rio_dbell_handler - MPC85xx doorbell interrupt handler
 290  * @irq: Linux interrupt number
 291  * @dev_instance: Pointer to interrupt-specific data
 292  *
 293  * Handles doorbell interrupts. Parses a list of registered
 294  * doorbell event handlers and executes a matching event handler.
 295  */
 296 static irqreturn_t
 297 fsl_rio_dbell_handler(int irq, void *dev_instance)
 298 {
 299         int dsr;
 300         struct fsl_rio_dbell *fsl_dbell = (struct fsl_rio_dbell *)dev_instance;
 301         int i;
 302
 303         dsr = in_be32(&fsl_dbell->dbell_regs->dsr);
 304
 305         if (dsr & DOORBELL_DSR_TE) {
 306                 pr_info("RIO: doorbell reception error\n");
 307                 out_be32(&fsl_dbell->dbell_regs->dsr, DOORBELL_DSR_TE);
 308                 goto out;
 309         }
 310
 311         if (dsr & DOORBELL_DSR_QFI) {
 312                 pr_info("RIO: doorbell queue full\n");
 313                 out_be32(&fsl_dbell->dbell_regs->dsr, DOORBELL_DSR_QFI);
 314         }
 315
 316         /* XXX Need to check/dispatch until queue empty */
 317         if (dsr & DOORBELL_DSR_DIQI) {
 318                 struct rio_dbell_msg *dmsg =
 319                         fsl_dbell->dbell_ring.virt +
 320                         (in_be32(&fsl_dbell->dbell_regs->dqdpar) & 0xfff);
 321                 struct rio_dbell *dbell;
 322                 int found = 0;
 323
 324                 pr_debug
 325                         ("RIO: processing doorbell,"
 326                         " sid %2.2x tid %2.2x info %4.4x\n",
 327                         dmsg->sid, dmsg->tid, dmsg->info);
 328
 329                 for (i = 0; i < MAX_PORT_NUM; i++) {
 330                         if (fsl_dbell->mport[i]) {
 331                                 list_for_each_entry(dbell,
 332                                         &fsl_dbell->mport[i]->dbells, node) {
 333                                         if ((dbell->res->start
 334                                                 <= dmsg->info)
 335                                                 && (dbell->res->end
 336                                                 >= dmsg->info)) {
 337                                                 found = 1;
 338                                                 break;
 339                                         }
 340                                 }
 341                                 if (found && dbell->dinb) {
 342                                         dbell->dinb(fsl_dbell->mport[i],
 343                                                 dbell->dev_id, dmsg->sid,
 344                                                 dmsg->tid,
 345                                                 dmsg->info);
 346                                         break;
 347                                 }
 348                         }
 349                 }
 350
 351                 if (!found) {
 352                         pr_debug
 353                                 ("RIO: spurious doorbell,"
 354                                 " sid %2.2x tid %2.2x info %4.4x\n",
 355                                 dmsg->sid, dmsg->tid,
 356                                 dmsg->info);
 357                 }
 358                 setbits32(&fsl_dbell->dbell_regs->dmr, DOORBELL_DMR_DI);
 359                 out_be32(&fsl_dbell->dbell_regs->dsr, DOORBELL_DSR_DIQI);
 360         }
 361
 362 out:
 363         return IRQ_HANDLED;
 364 }
 365
 366 void msg_unit_error_handler(void)
 367 {
 368
 369         /*XXX: Error recovery is not implemented, we just clear errors */
 370         out_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR), 0);
 371
 372         out_be32((u32 *)(rmu_regs_win + RIO_IM0SR), IMSR_CLEAR);
 373         out_be32((u32 *)(rmu_regs_win + RIO_IM1SR), IMSR_CLEAR);
 374         out_be32((u32 *)(rmu_regs_win + RIO_OM0SR), OMSR_CLEAR);
 375         out_be32((u32 *)(rmu_regs_win + RIO_OM1SR), OMSR_CLEAR);
 376
 377         out_be32(&dbell->dbell_regs->odsr, ODSR_CLEAR);
 378         out_be32(&dbell->dbell_regs->dsr, IDSR_CLEAR);
 379
 380         out_be32(&pw->pw_regs->pwsr, IPWSR_CLEAR);
 381 }
 382
 383 /**
 384  * fsl_rio_port_write_handler - MPC85xx port write interrupt handler
 385  * @irq: Linux interrupt number
 386  * @dev_instance: Pointer to interrupt-specific data
 387  *
 388  * Handles port write interrupts. Parses a list of registered
 389  * port write event handlers and executes a matching event handler.
 390  */
 391 static irqreturn_t
 392 fsl_rio_port_write_handler(int irq, void *dev_instance)
 393 {
 394         u32 ipwmr, ipwsr;
 395         struct fsl_rio_pw *pw = (struct fsl_rio_pw *)dev_instance;
 396         u32 epwisr, tmp;
 397
 398         epwisr = in_be32(rio_regs_win + RIO_EPWISR);
 399         if (!(epwisr & RIO_EPWISR_PW))
 400                 goto pw_done;
 401
 402         ipwmr = in_be32(&pw->pw_regs->pwmr);
 403         ipwsr = in_be32(&pw->pw_regs->pwsr);
 404
 405 #ifdef DEBUG_PW
 406         pr_debug("PW Int->IPWMR: 0x%08x IPWSR: 0x%08x (", ipwmr, ipwsr);
 407         if (ipwsr & RIO_IPWSR_QF)
 408                 pr_debug(" QF");
 409         if (ipwsr & RIO_IPWSR_TE)
 410                 pr_debug(" TE");
 411         if (ipwsr & RIO_IPWSR_QFI)
 412                 pr_debug(" QFI");
 413         if (ipwsr & RIO_IPWSR_PWD)
 414                 pr_debug(" PWD");
 415         if (ipwsr & RIO_IPWSR_PWB)
 416                 pr_debug(" PWB");
 417         pr_debug(" )\n");
 418 #endif
 419         /* Schedule deferred processing if PW was received */
 420         if (ipwsr & RIO_IPWSR_QFI) {
 421                 /* Save PW message (if there is room in FIFO),
 422                  * otherwise discard it.
 423                  */
 424                 if (kfifo_avail(&pw->pw_fifo) >= RIO_PW_MSG_SIZE) {
 425                         pw->port_write_msg.msg_count++;
 426                         kfifo_in(&pw->pw_fifo, pw->port_write_msg.virt,
 427                                  RIO_PW_MSG_SIZE);
 428                 } else {
 429                         pw->port_write_msg.discard_count++;
 430                         pr_debug("RIO: ISR Discarded Port-Write Msg(s) (%d)\n",
 431                                  pw->port_write_msg.discard_count);
 432                 }
 433                 /* Clear interrupt and issue Clear Queue command. This allows
 434                  * another port-write to be received.
 435                  */
 436                 out_be32(&pw->pw_regs->pwsr,    RIO_IPWSR_QFI);
 437                 out_be32(&pw->pw_regs->pwmr, ipwmr | RIO_IPWMR_CQ);
 438
 439                 schedule_work(&pw->pw_work);
 440         }
 441
 442         if ((ipwmr & RIO_IPWMR_EIE) && (ipwsr & RIO_IPWSR_TE)) {
 443                 pw->port_write_msg.err_count++;
 444                 pr_debug("RIO: Port-Write Transaction Err (%d)\n",
 445                          pw->port_write_msg.err_count);
 446                 /* Clear Transaction Error: port-write controller should be
 447                  * disabled when clearing this error
 448                  */
 449                 out_be32(&pw->pw_regs->pwmr, ipwmr & ~RIO_IPWMR_PWE);
 450                 out_be32(&pw->pw_regs->pwsr,    RIO_IPWSR_TE);
 451                 out_be32(&pw->pw_regs->pwmr, ipwmr);
 452         }
 453
 454         if (ipwsr & RIO_IPWSR_PWD) {
 455                 pw->port_write_msg.discard_count++;
 456                 pr_debug("RIO: Port Discarded Port-Write Msg(s) (%d)\n",
 457                          pw->port_write_msg.discard_count);
 458                 out_be32(&pw->pw_regs->pwsr, RIO_IPWSR_PWD);
 459         }
 460
 461 pw_done:
 462         if (epwisr & RIO_EPWISR_PINT1) {
 463                 tmp = in_be32(rio_regs_win + RIO_LTLEDCSR);
 464                 pr_debug("RIO_LTLEDCSR = 0x%x\n", tmp);
 465                 fsl_rio_port_error_handler(0);
 466         }
 467
 468         if (epwisr & RIO_EPWISR_PINT2) {
 469                 tmp = in_be32(rio_regs_win + RIO_LTLEDCSR);
 470                 pr_debug("RIO_LTLEDCSR = 0x%x\n", tmp);
 471                 fsl_rio_port_error_handler(1);
 472         }
 473
 474         if (epwisr & RIO_EPWISR_MU) {
 475                 tmp = in_be32(rio_regs_win + RIO_LTLEDCSR);
 476                 pr_debug("RIO_LTLEDCSR = 0x%x\n", tmp);
 477                 msg_unit_error_handler();
 478         }
 479
 480         return IRQ_HANDLED;
 481 }
 482
 483 static void fsl_pw_dpc(struct work_struct *work)
 484 {
 485         struct fsl_rio_pw *pw = container_of(work, struct fsl_rio_pw, pw_work);
 486         union rio_pw_msg msg_buffer;
 487         int i;
 488
 489         /*
 490          * Process port-write messages
 491          */
 492         while (kfifo_out_spinlocked(&pw->pw_fifo, (unsigned char *)&msg_buffer,
 493                          RIO_PW_MSG_SIZE, &pw->pw_fifo_lock)) {
 494 #ifdef DEBUG_PW
 495                 {
 496                 u32 i;
 497                 pr_debug("%s : Port-Write Message:", __func__);
 498                 for (i = 0; i < RIO_PW_MSG_SIZE/sizeof(u32); i++) {
 499                         if ((i%4) == 0)
 500                                 pr_debug("\n0x%02x: 0x%08x", i*4,
 501                                          msg_buffer.raw[i]);
 502                         else
 503                                 pr_debug(" 0x%08x", msg_buffer.raw[i]);
 504                 }
 505                 pr_debug("\n");
 506                 }
 507 #endif
 508                 /* Pass the port-write message to RIO core for processing */
 509                 for (i = 0; i < MAX_PORT_NUM; i++) {
 510                         if (pw->mport[i])
 511                                 rio_inb_pwrite_handler(pw->mport[i],
 512                                                        &msg_buffer);
 513                 }
 514         }
 515 }
 516
 517 /**
 518  * fsl_rio_pw_enable - enable/disable port-write interface init
 519  * @mport: Master port implementing the port write unit
 520  * @enable:    1=enable; 0=disable port-write message handling
 521  */
 522 int fsl_rio_pw_enable(struct rio_mport *mport, int enable)
 523 {
 524         u32 rval;
 525
 526         rval = in_be32(&pw->pw_regs->pwmr);
 527
 528         if (enable)
 529                 rval |= RIO_IPWMR_PWE;
 530         else
 531                 rval &= ~RIO_IPWMR_PWE;
 532
 533         out_be32(&pw->pw_regs->pwmr, rval);
 534
 535         return 0;
 536 }
 537
 538 /**
 539  * fsl_rio_port_write_init - MPC85xx port write interface init
 540  * @mport: Master port implementing the port write unit
 541  *
 542  * Initializes port write unit hardware and DMA buffer
 543  * ring. Called from fsl_rio_setup(). Returns %0 on success
 544  * or %-ENOMEM on failure.
 545  */
 546
 547 int fsl_rio_port_write_init(struct fsl_rio_pw *pw)
 548 {
 549         int rc = 0;
 550
 551         /* Following configurations require a disabled port write controller */
 552         out_be32(&pw->pw_regs->pwmr,
 553                  in_be32(&pw->pw_regs->pwmr) & ~RIO_IPWMR_PWE);
 554
 555         /* Initialize port write */
 556         pw->port_write_msg.virt = dma_alloc_coherent(pw->dev,
 557                                         RIO_PW_MSG_SIZE,
 558                                         &pw->port_write_msg.phys, GFP_KERNEL);
 559         if (!pw->port_write_msg.virt) {
 560                 pr_err("RIO: unable allocate port write queue\n");
 561                 return -ENOMEM;
 562         }
 563
 564         pw->port_write_msg.err_count = 0;
 565         pw->port_write_msg.discard_count = 0;
 566
 567         /* Point dequeue/enqueue pointers at first entry */
 568         out_be32(&pw->pw_regs->epwqbar, 0);
 569         out_be32(&pw->pw_regs->pwqbar, (u32) pw->port_write_msg.phys);
 570
 571         pr_debug("EIPWQBAR: 0x%08x IPWQBAR: 0x%08x\n",
 572                  in_be32(&pw->pw_regs->epwqbar),
 573                  in_be32(&pw->pw_regs->pwqbar));
 574
 575         /* Clear interrupt status IPWSR */
 576         out_be32(&pw->pw_regs->pwsr,
 577                  (RIO_IPWSR_TE | RIO_IPWSR_QFI | RIO_IPWSR_PWD));
 578
 579         /* Configure port write controller for snooping enable all reporting,
 580            clear queue full */
 581         out_be32(&pw->pw_regs->pwmr,
 582                  RIO_IPWMR_SEN | RIO_IPWMR_QFIE | RIO_IPWMR_EIE | RIO_IPWMR_CQ);
 583
 584
 585         /* Hook up port-write handler */
 586         rc = request_irq(IRQ_RIO_PW(pw), fsl_rio_port_write_handler,
 587                         IRQF_SHARED, "port-write", (void *)pw);
 588         if (rc < 0) {
 589                 pr_err("MPC85xx RIO: unable to request inbound doorbell irq");
 590                 goto err_out;
 591         }
 592         /* Enable Error Interrupt */
 593         out_be32((u32 *)(rio_regs_win + RIO_LTLEECSR), LTLEECSR_ENABLE_ALL);
 594
 595         INIT_WORK(&pw->pw_work, fsl_pw_dpc);
 596         spin_lock_init(&pw->pw_fifo_lock);
 597         if (kfifo_alloc(&pw->pw_fifo, RIO_PW_MSG_SIZE * 32, GFP_KERNEL)) {
 598                 pr_err("FIFO allocation failed\n");
 599                 rc = -ENOMEM;
 600                 goto err_out_irq;
 601         }
 602
 603         pr_debug("IPWMR: 0x%08x IPWSR: 0x%08x\n",
 604                  in_be32(&pw->pw_regs->pwmr),
 605                  in_be32(&pw->pw_regs->pwsr));
 606
 607         return rc;
 608
 609 err_out_irq:
 610         free_irq(IRQ_RIO_PW(pw), (void *)pw);
 611 err_out:
 612         dma_free_coherent(pw->dev, RIO_PW_MSG_SIZE,
 613                 pw->port_write_msg.virt,
 614                 pw->port_write_msg.phys);
 615         return rc;
 616 }
 617
 618 /**
 619  * fsl_rio_doorbell_send - Send a MPC85xx doorbell message
 620  * @mport: RapidIO master port info
 621  * @index: ID of RapidIO interface
 622  * @destid: Destination ID of target device
 623  * @data: 16-bit info field of RapidIO doorbell message
 624  *
 625  * Sends a MPC85xx doorbell message. Returns %0 on success or
 626  * %-EINVAL on failure.
 627  */
 628 int fsl_rio_doorbell_send(struct rio_mport *mport,
 629                                 int index, u16 destid, u16 data)
 630 {
 631         unsigned long flags;
 632
 633         pr_debug("fsl_doorbell_send: index %d destid %4.4x data %4.4x\n",
 634                  index, destid, data);
 635
 636         spin_lock_irqsave(&fsl_rio_doorbell_lock, flags);
 637
 638         /* In the serial version silicons, such as MPC8548, MPC8641,
 639          * below operations is must be.
 640          */
 641         out_be32(&dbell->dbell_regs->odmr, 0x00000000);
 642         out_be32(&dbell->dbell_regs->odretcr, 0x00000004);
 643         out_be32(&dbell->dbell_regs->oddpr, destid << 16);
 644         out_be32(&dbell->dbell_regs->oddatr, (index << 20) | data);
 645         out_be32(&dbell->dbell_regs->odmr, 0x00000001);
 646
 647         spin_unlock_irqrestore(&fsl_rio_doorbell_lock, flags);
 648
 649         return 0;
 650 }
 651
 652 /**
 653  * fsl_add_outb_message - Add message to the MPC85xx outbound message queue
 654  * @mport: Master port with outbound message queue
 655  * @rdev: Target of outbound message
 656  * @mbox: Outbound mailbox
 657  * @buffer: Message to add to outbound queue
 658  * @len: Length of message
 659  *
 660  * Adds the @buffer message to the MPC85xx outbound message queue. Returns
 661  * %0 on success or %-EINVAL on failure.
 662  */
 663 int
 664 fsl_add_outb_message(struct rio_mport *mport, struct rio_dev *rdev, int mbox,
 665                         void *buffer, size_t len)
 666 {
 667         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 668         u32 omr;
 669         struct rio_tx_desc *desc = (struct rio_tx_desc *)rmu->msg_tx_ring.virt
 670                                         + rmu->msg_tx_ring.tx_slot;
 671         int ret = 0;
 672
 673         pr_debug("RIO: fsl_add_outb_message(): destid %4.4x mbox %d buffer " \
 674                  "%p len %8.8zx\n", rdev->destid, mbox, buffer, len);
 675         if ((len < 8) || (len > RIO_MAX_MSG_SIZE)) {
 676                 ret = -EINVAL;
 677                 goto out;
 678         }
 679
 680         /* Copy and clear rest of buffer */
 681         memcpy(rmu->msg_tx_ring.virt_buffer[rmu->msg_tx_ring.tx_slot], buffer,
 682                         len);
 683         if (len < (RIO_MAX_MSG_SIZE - 4))
 684                 memset(rmu->msg_tx_ring.virt_buffer[rmu->msg_tx_ring.tx_slot]
 685                                 + len, 0, RIO_MAX_MSG_SIZE - len);
 686
 687         /* Set mbox field for message, and set destid */
 688         desc->dport = (rdev->destid << 16) | (mbox & 0x3);
 689
 690         /* Enable EOMI interrupt and priority */
 691         desc->dattr = 0x28000000 | ((mport->index) << 20);
 692
 693         /* Set transfer size aligned to next power of 2 (in double words) */
 694         desc->dwcnt = is_power_of_2(len) ? len : 1 << get_bitmask_order(len);
 695
 696         /* Set snooping and source buffer address */
 697         desc->saddr = 0x00000004
 698                 | rmu->msg_tx_ring.phys_buffer[rmu->msg_tx_ring.tx_slot];
 699
 700         /* Increment enqueue pointer */
 701         omr = in_be32(&rmu->msg_regs->omr);
 702         out_be32(&rmu->msg_regs->omr, omr | RIO_MSG_OMR_MUI);
 703
 704         /* Go to next descriptor */
 705         if (++rmu->msg_tx_ring.tx_slot == rmu->msg_tx_ring.size)
 706                 rmu->msg_tx_ring.tx_slot = 0;
 707
 708 out:
 709         return ret;
 710 }
 711
 712 /**
 713  * fsl_open_outb_mbox - Initialize MPC85xx outbound mailbox
 714  * @mport: Master port implementing the outbound message unit
 715  * @dev_id: Device specific pointer to pass on event
 716  * @mbox: Mailbox to open
 717  * @entries: Number of entries in the outbound mailbox ring
 718  *
 719  * Initializes buffer ring, request the outbound message interrupt,
 720  * and enables the outbound message unit. Returns %0 on success and
 721  * %-EINVAL or %-ENOMEM on failure.
 722  */
 723 int
 724 fsl_open_outb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries)
 725 {
 726         int i, j, rc = 0;
 727         struct rio_priv *priv = mport->priv;
 728         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 729
 730         if ((entries < RIO_MIN_TX_RING_SIZE) ||
 731                 (entries > RIO_MAX_TX_RING_SIZE) || (!is_power_of_2(entries))) {
 732                 rc = -EINVAL;
 733                 goto out;
 734         }
 735
 736         /* Initialize shadow copy ring */
 737         rmu->msg_tx_ring.dev_id = dev_id;
 738         rmu->msg_tx_ring.size = entries;
 739
 740         for (i = 0; i < rmu->msg_tx_ring.size; i++) {
 741                 rmu->msg_tx_ring.virt_buffer[i] =
 742                         dma_alloc_coherent(priv->dev, RIO_MSG_BUFFER_SIZE,
 743                                 &rmu->msg_tx_ring.phys_buffer[i], GFP_KERNEL);
 744                 if (!rmu->msg_tx_ring.virt_buffer[i]) {
 745                         rc = -ENOMEM;
 746                         for (j = 0; j < rmu->msg_tx_ring.size; j++)
 747                                 if (rmu->msg_tx_ring.virt_buffer[j])
 748                                         dma_free_coherent(priv->dev,
 749                                                         RIO_MSG_BUFFER_SIZE,
 750                                                         rmu->msg_tx_ring.
 751                                                         virt_buffer[j],
 752                                                         rmu->msg_tx_ring.
 753                                                         phys_buffer[j]);
 754                         goto out;
 755                 }
 756         }
 757
 758         /* Initialize outbound message descriptor ring */
 759         rmu->msg_tx_ring.virt = dma_alloc_coherent(priv->dev,
 760                                                    rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
 761                                                    &rmu->msg_tx_ring.phys,
 762                                                    GFP_KERNEL);
 763         if (!rmu->msg_tx_ring.virt) {
 764                 rc = -ENOMEM;
 765                 goto out_dma;
 766         }
 767         rmu->msg_tx_ring.tx_slot = 0;
 768
 769         /* Point dequeue/enqueue pointers at first entry in ring */
 770         out_be32(&rmu->msg_regs->odqdpar, rmu->msg_tx_ring.phys);
 771         out_be32(&rmu->msg_regs->odqepar, rmu->msg_tx_ring.phys);
 772
 773         /* Configure for snooping */
 774         out_be32(&rmu->msg_regs->osar, 0x00000004);
 775
 776         /* Clear interrupt status */
 777         out_be32(&rmu->msg_regs->osr, 0x000000b3);
 778
 779         /* Hook up outbound message handler */
 780         rc = request_irq(IRQ_RIO_TX(mport), fsl_rio_tx_handler, 0,
 781                          "msg_tx", (void *)mport);
 782         if (rc < 0)
 783                 goto out_irq;
 784
 785         /*
 786          * Configure outbound message unit
 787          *      Snooping
 788          *      Interrupts (all enabled, except QEIE)
 789          *      Chaining mode
 790          *      Disable
 791          */
 792         out_be32(&rmu->msg_regs->omr, 0x00100220);
 793
 794         /* Set number of entries */
 795         out_be32(&rmu->msg_regs->omr,
 796                  in_be32(&rmu->msg_regs->omr) |
 797                  ((get_bitmask_order(entries) - 2) << 12));
 798
 799         /* Now enable the unit */
 800         out_be32(&rmu->msg_regs->omr, in_be32(&rmu->msg_regs->omr) | 0x1);
 801
 802 out:
 803         return rc;
 804
 805 out_irq:
 806         dma_free_coherent(priv->dev,
 807                 rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
 808                 rmu->msg_tx_ring.virt, rmu->msg_tx_ring.phys);
 809
 810 out_dma:
 811         for (i = 0; i < rmu->msg_tx_ring.size; i++)
 812                 dma_free_coherent(priv->dev, RIO_MSG_BUFFER_SIZE,
 813                 rmu->msg_tx_ring.virt_buffer[i],
 814                 rmu->msg_tx_ring.phys_buffer[i]);
 815
 816         return rc;
 817 }
 818
 819 /**
 820  * fsl_close_outb_mbox - Shut down MPC85xx outbound mailbox
 821  * @mport: Master port implementing the outbound message unit
 822  * @mbox: Mailbox to close
 823  *
 824  * Disables the outbound message unit, free all buffers, and
 825  * frees the outbound message interrupt.
 826  */
 827 void fsl_close_outb_mbox(struct rio_mport *mport, int mbox)
 828 {
 829         struct rio_priv *priv = mport->priv;
 830         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 831
 832         /* Disable inbound message unit */
 833         out_be32(&rmu->msg_regs->omr, 0);
 834
 835         /* Free ring */
 836         dma_free_coherent(priv->dev,
 837         rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
 838         rmu->msg_tx_ring.virt, rmu->msg_tx_ring.phys);
 839
 840         /* Free interrupt */
 841         free_irq(IRQ_RIO_TX(mport), (void *)mport);
 842 }
 843
 844 /**
 845  * fsl_open_inb_mbox - Initialize MPC85xx inbound mailbox
 846  * @mport: Master port implementing the inbound message unit
 847  * @dev_id: Device specific pointer to pass on event
 848  * @mbox: Mailbox to open
 849  * @entries: Number of entries in the inbound mailbox ring
 850  *
 851  * Initializes buffer ring, request the inbound message interrupt,
 852  * and enables the inbound message unit. Returns %0 on success
 853  * and %-EINVAL or %-ENOMEM on failure.
 854  */
 855 int
 856 fsl_open_inb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries)
 857 {
 858         int i, rc = 0;
 859         struct rio_priv *priv = mport->priv;
 860         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 861
 862         if ((entries < RIO_MIN_RX_RING_SIZE) ||
 863                 (entries > RIO_MAX_RX_RING_SIZE) || (!is_power_of_2(entries))) {
 864                 rc = -EINVAL;
 865                 goto out;
 866         }
 867
 868         /* Initialize client buffer ring */
 869         rmu->msg_rx_ring.dev_id = dev_id;
 870         rmu->msg_rx_ring.size = entries;
 871         rmu->msg_rx_ring.rx_slot = 0;
 872         for (i = 0; i < rmu->msg_rx_ring.size; i++)
 873                 rmu->msg_rx_ring.virt_buffer[i] = NULL;
 874
 875         /* Initialize inbound message ring */
 876         rmu->msg_rx_ring.virt = dma_alloc_coherent(priv->dev,
 877                                 rmu->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
 878                                 &rmu->msg_rx_ring.phys, GFP_KERNEL);
 879         if (!rmu->msg_rx_ring.virt) {
 880                 rc = -ENOMEM;
 881                 goto out;
 882         }
 883
 884         /* Point dequeue/enqueue pointers at first entry in ring */
 885         out_be32(&rmu->msg_regs->ifqdpar, (u32) rmu->msg_rx_ring.phys);
 886         out_be32(&rmu->msg_regs->ifqepar, (u32) rmu->msg_rx_ring.phys);
 887
 888         /* Clear interrupt status */
 889         out_be32(&rmu->msg_regs->isr, 0x00000091);
 890
 891         /* Hook up inbound message handler */
 892         rc = request_irq(IRQ_RIO_RX(mport), fsl_rio_rx_handler, 0,
 893                          "msg_rx", (void *)mport);
 894         if (rc < 0) {
 895                 dma_free_coherent(priv->dev,
 896                         rmu->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
 897                         rmu->msg_rx_ring.virt, rmu->msg_rx_ring.phys);
 898                 goto out;
 899         }
 900
 901         /*
 902          * Configure inbound message unit:
 903          *      Snooping
 904          *      4KB max message size
 905          *      Unmask all interrupt sources
 906          *      Disable
 907          */
 908         out_be32(&rmu->msg_regs->imr, 0x001b0060);
 909
 910         /* Set number of queue entries */
 911         setbits32(&rmu->msg_regs->imr, (get_bitmask_order(entries) - 2) << 12);
 912
 913         /* Now enable the unit */
 914         setbits32(&rmu->msg_regs->imr, 0x1);
 915
 916 out:
 917         return rc;
 918 }
 919
 920 /**
 921  * fsl_close_inb_mbox - Shut down MPC85xx inbound mailbox
 922  * @mport: Master port implementing the inbound message unit
 923  * @mbox: Mailbox to close
 924  *
 925  * Disables the inbound message unit, free all buffers, and
 926  * frees the inbound message interrupt.
 927  */
 928 void fsl_close_inb_mbox(struct rio_mport *mport, int mbox)
 929 {
 930         struct rio_priv *priv = mport->priv;
 931         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 932
 933         /* Disable inbound message unit */
 934         out_be32(&rmu->msg_regs->imr, 0);
 935
 936         /* Free ring */
 937         dma_free_coherent(priv->dev, rmu->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
 938         rmu->msg_rx_ring.virt, rmu->msg_rx_ring.phys);
 939
 940         /* Free interrupt */
 941         free_irq(IRQ_RIO_RX(mport), (void *)mport);
 942 }
 943
 944 /**
 945  * fsl_add_inb_buffer - Add buffer to the MPC85xx inbound message queue
 946  * @mport: Master port implementing the inbound message unit
 947  * @mbox: Inbound mailbox number
 948  * @buf: Buffer to add to inbound queue
 949  *
 950  * Adds the @buf buffer to the MPC85xx inbound message queue. Returns
 951  * %0 on success or %-EINVAL on failure.
 952  */
 953 int fsl_add_inb_buffer(struct rio_mport *mport, int mbox, void *buf)
 954 {
 955         int rc = 0;
 956         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 957
 958         pr_debug("RIO: fsl_add_inb_buffer(), msg_rx_ring.rx_slot %d\n",
 959                  rmu->msg_rx_ring.rx_slot);
 960
 961         if (rmu->msg_rx_ring.virt_buffer[rmu->msg_rx_ring.rx_slot]) {
 962                 printk(KERN_ERR
 963                         "RIO: error adding inbound buffer %d, buffer exists\n",
 964                         rmu->msg_rx_ring.rx_slot);
 965                 rc = -EINVAL;
 966                 goto out;
 967         }
 968
 969         rmu->msg_rx_ring.virt_buffer[rmu->msg_rx_ring.rx_slot] = buf;
 970         if (++rmu->msg_rx_ring.rx_slot == rmu->msg_rx_ring.size)
 971                 rmu->msg_rx_ring.rx_slot = 0;
 972
 973 out:
 974         return rc;
 975 }
 976
 977 /**
 978  * fsl_get_inb_message - Fetch inbound message from the MPC85xx message unit
 979  * @mport: Master port implementing the inbound message unit
 980  * @mbox: Inbound mailbox number
 981  *
 982  * Gets the next available inbound message from the inbound message queue.
 983  * A pointer to the message is returned on success or NULL on failure.
 984  */
 985 void *fsl_get_inb_message(struct rio_mport *mport, int mbox)
 986 {
 987         struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
 988         u32 phys_buf;
 989         void *virt_buf;
 990         void *buf = NULL;
 991         int buf_idx;
 992
 993         phys_buf = in_be32(&rmu->msg_regs->ifqdpar);
 994
 995         /* If no more messages, then bail out */
 996         if (phys_buf == in_be32(&rmu->msg_regs->ifqepar))
 997                 goto out2;
 998
 999         virt_buf = rmu->msg_rx_ring.virt + (phys_buf
1000                                                 - rmu->msg_rx_ring.phys);
1001         buf_idx = (phys_buf - rmu->msg_rx_ring.phys) / RIO_MAX_MSG_SIZE;
1002         buf = rmu->msg_rx_ring.virt_buffer[buf_idx];
1003
1004         if (!buf) {
1005                 printk(KERN_ERR
1006                         "RIO: inbound message copy failed, no buffers\n");
1007                 goto out1;
1008         }
1009
1010         /* Copy max message size, caller is expected to allocate that big */
1011         memcpy(buf, virt_buf, RIO_MAX_MSG_SIZE);
1012
1013         /* Clear the available buffer */
1014         rmu->msg_rx_ring.virt_buffer[buf_idx] = NULL;
1015
1016 out1:
1017         setbits32(&rmu->msg_regs->imr, RIO_MSG_IMR_MI);
1018
1019 out2:
1020         return buf;
1021 }
1022
1023 /**
1024  * fsl_rio_doorbell_init - MPC85xx doorbell interface init
1025  * @mport: Master port implementing the inbound doorbell unit
1026  *
1027  * Initializes doorbell unit hardware and inbound DMA buffer
1028  * ring. Called from fsl_rio_setup(). Returns %0 on success
1029  * or %-ENOMEM on failure.
1030  */
1031 int fsl_rio_doorbell_init(struct fsl_rio_dbell *dbell)
1032 {
1033         int rc = 0;
1034
1035         /* Initialize inbound doorbells */
1036         dbell->dbell_ring.virt = dma_alloc_coherent(dbell->dev, 512 *
1037                 DOORBELL_MESSAGE_SIZE, &dbell->dbell_ring.phys, GFP_KERNEL);
1038         if (!dbell->dbell_ring.virt) {
1039                 printk(KERN_ERR "RIO: unable allocate inbound doorbell ring\n");
1040                 rc = -ENOMEM;
1041                 goto out;
1042         }
1043
1044         /* Point dequeue/enqueue pointers at first entry in ring */
1045         out_be32(&dbell->dbell_regs->dqdpar, (u32) dbell->dbell_ring.phys);
1046         out_be32(&dbell->dbell_regs->dqepar, (u32) dbell->dbell_ring.phys);
1047
1048         /* Clear interrupt status */
1049         out_be32(&dbell->dbell_regs->dsr, 0x00000091);
1050
1051         /* Hook up doorbell handler */
1052         rc = request_irq(IRQ_RIO_BELL(dbell), fsl_rio_dbell_handler, 0,
1053                          "dbell_rx", (void *)dbell);
1054         if (rc < 0) {
1055                 dma_free_coherent(dbell->dev, 512 * DOORBELL_MESSAGE_SIZE,
1056                          dbell->dbell_ring.virt, dbell->dbell_ring.phys);
1057                 printk(KERN_ERR
1058                         "MPC85xx RIO: unable to request inbound doorbell irq");
1059                 goto out;
1060         }
1061
1062         /* Configure doorbells for snooping, 512 entries, and enable */
1063         out_be32(&dbell->dbell_regs->dmr, 0x00108161);
1064
1065 out:
1066         return rc;
1067 }
1068
1069 int fsl_rio_setup_rmu(struct rio_mport *mport, struct device_node *node)
1070 {
1071         struct rio_priv *priv;
1072         struct fsl_rmu *rmu;
1073         u64 msg_start;
1074         const u32 *msg_addr;
1075         int mlen;
1076         int aw;
1077
1078         if (!mport || !mport->priv)
1079                 return -EINVAL;
1080
1081         priv = mport->priv;
1082
1083         if (!node) {
1084                 dev_warn(priv->dev, "Can't get %pOF property 'fsl,rmu'\n",
1085                         priv->dev->of_node);
1086                 return -EINVAL;
1087         }
1088
1089         rmu = kzalloc(sizeof(struct fsl_rmu), GFP_KERNEL);
1090         if (!rmu)
1091                 return -ENOMEM;
1092
1093         aw = of_n_addr_cells(node);
1094         msg_addr = of_get_property(node, "reg", &mlen);
1095         if (!msg_addr) {
1096                 pr_err("%pOF: unable to find 'reg' property of message-unit\n",
1097                         node);
1098                 kfree(rmu);
1099                 return -ENOMEM;
1100         }
1101         msg_start = of_read_number(msg_addr, aw);
1102
1103         rmu->msg_regs = (struct rio_msg_regs *)
1104                         (rmu_regs_win + (u32)msg_start);
1105
1106         rmu->txirq = irq_of_parse_and_map(node, 0);
1107         rmu->rxirq = irq_of_parse_and_map(node, 1);
1108         printk(KERN_INFO "%pOF: txirq: %d, rxirq %d\n",
1109                 node, rmu->txirq, rmu->rxirq);
1110
1111         priv->rmm_handle = rmu;
1112
1113         rio_init_dbell_res(&mport->riores[RIO_DOORBELL_RESOURCE], 0, 0xffff);
1114         rio_init_mbox_res(&mport->riores[RIO_INB_MBOX_RESOURCE], 0, 0);
1115         rio_init_mbox_res(&mport->riores[RIO_OUTB_MBOX_RESOURCE], 0, 0);
1116
1117         return 0;
1118 }