xref: /openbmc/linux/arch/powerpc/sysdev/fsl_rmu.c (revision 2a2383dab097823d68accce65da043402bdeb57b)
16ec4bedbSLiu Gang /*
26ec4bedbSLiu Gang  * Freescale MPC85xx/MPC86xx RapidIO RMU support
36ec4bedbSLiu Gang  *
46ec4bedbSLiu Gang  * Copyright 2009 Sysgo AG
56ec4bedbSLiu Gang  * Thomas Moll <thomas.moll@sysgo.com>
66ec4bedbSLiu Gang  * - fixed maintenance access routines, check for aligned access
76ec4bedbSLiu Gang  *
86ec4bedbSLiu Gang  * Copyright 2009 Integrated Device Technology, Inc.
96ec4bedbSLiu Gang  * Alex Bounine <alexandre.bounine@idt.com>
106ec4bedbSLiu Gang  * - Added Port-Write message handling
116ec4bedbSLiu Gang  * - Added Machine Check exception handling
126ec4bedbSLiu Gang  *
136ec4bedbSLiu Gang  * Copyright (C) 2007, 2008, 2010, 2011 Freescale Semiconductor, Inc.
146ec4bedbSLiu Gang  * Zhang Wei <wei.zhang@freescale.com>
156ec4bedbSLiu Gang  * Lian Minghuan-B31939 <Minghuan.Lian@freescale.com>
166ec4bedbSLiu Gang  * Liu Gang <Gang.Liu@freescale.com>
176ec4bedbSLiu Gang  *
186ec4bedbSLiu Gang  * Copyright 2005 MontaVista Software, Inc.
196ec4bedbSLiu Gang  * Matt Porter <mporter@kernel.crashing.org>
206ec4bedbSLiu Gang  *
216ec4bedbSLiu Gang  * This program is free software; you can redistribute  it and/or modify it
226ec4bedbSLiu Gang  * under  the terms of  the GNU General  Public License as published by the
236ec4bedbSLiu Gang  * Free Software Foundation;  either version 2 of the  License, or (at your
246ec4bedbSLiu Gang  * option) any later version.
256ec4bedbSLiu Gang  */
266ec4bedbSLiu Gang 
276ec4bedbSLiu Gang #include <linux/types.h>
286ec4bedbSLiu Gang #include <linux/dma-mapping.h>
296ec4bedbSLiu Gang #include <linux/interrupt.h>
306ec4bedbSLiu Gang #include <linux/of_platform.h>
316ec4bedbSLiu Gang #include <linux/slab.h>
326ec4bedbSLiu Gang 
336ec4bedbSLiu Gang #include "fsl_rio.h"
346ec4bedbSLiu Gang 
356ec4bedbSLiu Gang #define GET_RMM_HANDLE(mport) \
366ec4bedbSLiu Gang 		(((struct rio_priv *)(mport->priv))->rmm_handle)
376ec4bedbSLiu Gang 
386ec4bedbSLiu Gang /* RapidIO definition irq, which read from OF-tree */
39abc3aeaeSLiu Gang #define IRQ_RIO_PW(m)		(((struct fsl_rio_pw *)(m))->pwirq)
40abc3aeaeSLiu Gang #define IRQ_RIO_BELL(m) (((struct fsl_rio_dbell *)(m))->bellirq)
416ec4bedbSLiu Gang #define IRQ_RIO_TX(m) (((struct fsl_rmu *)(GET_RMM_HANDLE(m)))->txirq)
426ec4bedbSLiu Gang #define IRQ_RIO_RX(m) (((struct fsl_rmu *)(GET_RMM_HANDLE(m)))->rxirq)
436ec4bedbSLiu Gang 
446ec4bedbSLiu Gang #define RIO_MIN_TX_RING_SIZE	2
456ec4bedbSLiu Gang #define RIO_MAX_TX_RING_SIZE	2048
466ec4bedbSLiu Gang #define RIO_MIN_RX_RING_SIZE	2
476ec4bedbSLiu Gang #define RIO_MAX_RX_RING_SIZE	2048
486ec4bedbSLiu Gang 
496ec4bedbSLiu Gang #define RIO_IPWMR_SEN		0x00100000
506ec4bedbSLiu Gang #define RIO_IPWMR_QFIE		0x00000100
516ec4bedbSLiu Gang #define RIO_IPWMR_EIE		0x00000020
526ec4bedbSLiu Gang #define RIO_IPWMR_CQ		0x00000002
536ec4bedbSLiu Gang #define RIO_IPWMR_PWE		0x00000001
546ec4bedbSLiu Gang 
556ec4bedbSLiu Gang #define RIO_IPWSR_QF		0x00100000
566ec4bedbSLiu Gang #define RIO_IPWSR_TE		0x00000080
576ec4bedbSLiu Gang #define RIO_IPWSR_QFI		0x00000010
586ec4bedbSLiu Gang #define RIO_IPWSR_PWD		0x00000008
596ec4bedbSLiu Gang #define RIO_IPWSR_PWB		0x00000004
606ec4bedbSLiu Gang 
616ec4bedbSLiu Gang #define RIO_EPWISR		0x10010
626ec4bedbSLiu Gang /* EPWISR Error match value */
636ec4bedbSLiu Gang #define RIO_EPWISR_PINT1	0x80000000
646ec4bedbSLiu Gang #define RIO_EPWISR_PINT2	0x40000000
656ec4bedbSLiu Gang #define RIO_EPWISR_MU		0x00000002
666ec4bedbSLiu Gang #define RIO_EPWISR_PW		0x00000001
676ec4bedbSLiu Gang 
686ec4bedbSLiu Gang #define IPWSR_CLEAR		0x98
696ec4bedbSLiu Gang #define OMSR_CLEAR		0x1cb3
706ec4bedbSLiu Gang #define IMSR_CLEAR		0x491
716ec4bedbSLiu Gang #define IDSR_CLEAR		0x91
726ec4bedbSLiu Gang #define ODSR_CLEAR		0x1c00
736ec4bedbSLiu Gang #define LTLEECSR_ENABLE_ALL	0xFFC000FC
746ec4bedbSLiu Gang #define RIO_LTLEECSR		0x060c
756ec4bedbSLiu Gang 
76abc3aeaeSLiu Gang #define RIO_IM0SR		0x64
77abc3aeaeSLiu Gang #define RIO_IM1SR		0x164
78abc3aeaeSLiu Gang #define RIO_OM0SR		0x4
79abc3aeaeSLiu Gang #define RIO_OM1SR		0x104
806ec4bedbSLiu Gang 
816ec4bedbSLiu Gang #define RIO_DBELL_WIN_SIZE	0x1000
826ec4bedbSLiu Gang 
836ec4bedbSLiu Gang #define RIO_MSG_OMR_MUI		0x00000002
846ec4bedbSLiu Gang #define RIO_MSG_OSR_TE		0x00000080
856ec4bedbSLiu Gang #define RIO_MSG_OSR_QOI		0x00000020
866ec4bedbSLiu Gang #define RIO_MSG_OSR_QFI		0x00000010
876ec4bedbSLiu Gang #define RIO_MSG_OSR_MUB		0x00000004
886ec4bedbSLiu Gang #define RIO_MSG_OSR_EOMI	0x00000002
896ec4bedbSLiu Gang #define RIO_MSG_OSR_QEI		0x00000001
906ec4bedbSLiu Gang 
916ec4bedbSLiu Gang #define RIO_MSG_IMR_MI		0x00000002
926ec4bedbSLiu Gang #define RIO_MSG_ISR_TE		0x00000080
936ec4bedbSLiu Gang #define RIO_MSG_ISR_QFI		0x00000010
946ec4bedbSLiu Gang #define RIO_MSG_ISR_DIQI	0x00000001
956ec4bedbSLiu Gang 
966ec4bedbSLiu Gang #define RIO_MSG_DESC_SIZE	32
976ec4bedbSLiu Gang #define RIO_MSG_BUFFER_SIZE	4096
986ec4bedbSLiu Gang 
996ec4bedbSLiu Gang #define DOORBELL_DMR_DI		0x00000002
1006ec4bedbSLiu Gang #define DOORBELL_DSR_TE		0x00000080
1016ec4bedbSLiu Gang #define DOORBELL_DSR_QFI	0x00000010
1026ec4bedbSLiu Gang #define DOORBELL_DSR_DIQI	0x00000001
1036ec4bedbSLiu Gang 
1046ec4bedbSLiu Gang #define DOORBELL_MESSAGE_SIZE	0x08
1056ec4bedbSLiu Gang 
1066ec4bedbSLiu Gang struct rio_msg_regs {
107abc3aeaeSLiu Gang 	u32 omr;
108abc3aeaeSLiu Gang 	u32 osr;
1096ec4bedbSLiu Gang 	u32 pad1;
110abc3aeaeSLiu Gang 	u32 odqdpar;
1116ec4bedbSLiu Gang 	u32 pad2;
112abc3aeaeSLiu Gang 	u32 osar;
113abc3aeaeSLiu Gang 	u32 odpr;
114abc3aeaeSLiu Gang 	u32 odatr;
115abc3aeaeSLiu Gang 	u32 odcr;
1166ec4bedbSLiu Gang 	u32 pad3;
117abc3aeaeSLiu Gang 	u32 odqepar;
1186ec4bedbSLiu Gang 	u32 pad4[13];
119abc3aeaeSLiu Gang 	u32 imr;
120abc3aeaeSLiu Gang 	u32 isr;
1216ec4bedbSLiu Gang 	u32 pad5;
122abc3aeaeSLiu Gang 	u32 ifqdpar;
1236ec4bedbSLiu Gang 	u32 pad6;
124abc3aeaeSLiu Gang 	u32 ifqepar;
1256ec4bedbSLiu Gang };
1266ec4bedbSLiu Gang 
127abc3aeaeSLiu Gang struct rio_dbell_regs {
128abc3aeaeSLiu Gang 	u32 odmr;
129abc3aeaeSLiu Gang 	u32 odsr;
130abc3aeaeSLiu Gang 	u32 pad1[4];
131abc3aeaeSLiu Gang 	u32 oddpr;
132abc3aeaeSLiu Gang 	u32 oddatr;
133abc3aeaeSLiu Gang 	u32 pad2[3];
134abc3aeaeSLiu Gang 	u32 odretcr;
135abc3aeaeSLiu Gang 	u32 pad3[12];
136abc3aeaeSLiu Gang 	u32 dmr;
137abc3aeaeSLiu Gang 	u32 dsr;
138abc3aeaeSLiu Gang 	u32 pad4;
139abc3aeaeSLiu Gang 	u32 dqdpar;
140abc3aeaeSLiu Gang 	u32 pad5;
141abc3aeaeSLiu Gang 	u32 dqepar;
142abc3aeaeSLiu Gang };
143abc3aeaeSLiu Gang 
144abc3aeaeSLiu Gang struct rio_pw_regs {
145abc3aeaeSLiu Gang 	u32 pwmr;
146abc3aeaeSLiu Gang 	u32 pwsr;
147abc3aeaeSLiu Gang 	u32 epwqbar;
148abc3aeaeSLiu Gang 	u32 pwqbar;
149abc3aeaeSLiu Gang };
150abc3aeaeSLiu Gang 
151abc3aeaeSLiu Gang 
1526ec4bedbSLiu Gang struct rio_tx_desc {
153abc3aeaeSLiu Gang 	u32 pad1;
1546ec4bedbSLiu Gang 	u32 saddr;
1556ec4bedbSLiu Gang 	u32 dport;
1566ec4bedbSLiu Gang 	u32 dattr;
157abc3aeaeSLiu Gang 	u32 pad2;
158abc3aeaeSLiu Gang 	u32 pad3;
1596ec4bedbSLiu Gang 	u32 dwcnt;
160abc3aeaeSLiu Gang 	u32 pad4;
1616ec4bedbSLiu Gang };
1626ec4bedbSLiu Gang 
1636ec4bedbSLiu Gang struct rio_msg_tx_ring {
1646ec4bedbSLiu Gang 	void *virt;
1656ec4bedbSLiu Gang 	dma_addr_t phys;
1666ec4bedbSLiu Gang 	void *virt_buffer[RIO_MAX_TX_RING_SIZE];
1676ec4bedbSLiu Gang 	dma_addr_t phys_buffer[RIO_MAX_TX_RING_SIZE];
1686ec4bedbSLiu Gang 	int tx_slot;
1696ec4bedbSLiu Gang 	int size;
1706ec4bedbSLiu Gang 	void *dev_id;
1716ec4bedbSLiu Gang };
1726ec4bedbSLiu Gang 
1736ec4bedbSLiu Gang struct rio_msg_rx_ring {
1746ec4bedbSLiu Gang 	void *virt;
1756ec4bedbSLiu Gang 	dma_addr_t phys;
1766ec4bedbSLiu Gang 	void *virt_buffer[RIO_MAX_RX_RING_SIZE];
1776ec4bedbSLiu Gang 	int rx_slot;
1786ec4bedbSLiu Gang 	int size;
1796ec4bedbSLiu Gang 	void *dev_id;
1806ec4bedbSLiu Gang };
1816ec4bedbSLiu Gang 
1826ec4bedbSLiu Gang struct fsl_rmu {
1836ec4bedbSLiu Gang 	struct rio_msg_regs __iomem *msg_regs;
1846ec4bedbSLiu Gang 	struct rio_msg_tx_ring msg_tx_ring;
1856ec4bedbSLiu Gang 	struct rio_msg_rx_ring msg_rx_ring;
1866ec4bedbSLiu Gang 	int txirq;
1876ec4bedbSLiu Gang 	int rxirq;
1886ec4bedbSLiu Gang };
1896ec4bedbSLiu Gang 
190*2a2383daSLiu Gang struct rio_dbell_msg {
191*2a2383daSLiu Gang 	u16 pad1;
192*2a2383daSLiu Gang 	u16 tid;
193*2a2383daSLiu Gang 	u16 sid;
194*2a2383daSLiu Gang 	u16 info;
195*2a2383daSLiu Gang };
196*2a2383daSLiu Gang 
1976ec4bedbSLiu Gang /**
1986ec4bedbSLiu Gang  * fsl_rio_tx_handler - MPC85xx outbound message interrupt handler
1996ec4bedbSLiu Gang  * @irq: Linux interrupt number
2006ec4bedbSLiu Gang  * @dev_instance: Pointer to interrupt-specific data
2016ec4bedbSLiu Gang  *
2026ec4bedbSLiu Gang  * Handles outbound message interrupts. Executes a register outbound
2036ec4bedbSLiu Gang  * mailbox event handler and acks the interrupt occurrence.
2046ec4bedbSLiu Gang  */
2056ec4bedbSLiu Gang static irqreturn_t
2066ec4bedbSLiu Gang fsl_rio_tx_handler(int irq, void *dev_instance)
2076ec4bedbSLiu Gang {
2086ec4bedbSLiu Gang 	int osr;
2096ec4bedbSLiu Gang 	struct rio_mport *port = (struct rio_mport *)dev_instance;
2106ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(port);
2116ec4bedbSLiu Gang 
2126ec4bedbSLiu Gang 	osr = in_be32(&rmu->msg_regs->osr);
2136ec4bedbSLiu Gang 
2146ec4bedbSLiu Gang 	if (osr & RIO_MSG_OSR_TE) {
2156ec4bedbSLiu Gang 		pr_info("RIO: outbound message transmission error\n");
2166ec4bedbSLiu Gang 		out_be32(&rmu->msg_regs->osr, RIO_MSG_OSR_TE);
2176ec4bedbSLiu Gang 		goto out;
2186ec4bedbSLiu Gang 	}
2196ec4bedbSLiu Gang 
2206ec4bedbSLiu Gang 	if (osr & RIO_MSG_OSR_QOI) {
2216ec4bedbSLiu Gang 		pr_info("RIO: outbound message queue overflow\n");
2226ec4bedbSLiu Gang 		out_be32(&rmu->msg_regs->osr, RIO_MSG_OSR_QOI);
2236ec4bedbSLiu Gang 		goto out;
2246ec4bedbSLiu Gang 	}
2256ec4bedbSLiu Gang 
2266ec4bedbSLiu Gang 	if (osr & RIO_MSG_OSR_EOMI) {
2276ec4bedbSLiu Gang 		u32 dqp = in_be32(&rmu->msg_regs->odqdpar);
2286ec4bedbSLiu Gang 		int slot = (dqp - rmu->msg_tx_ring.phys) >> 5;
229abc3aeaeSLiu Gang 		if (port->outb_msg[0].mcback != NULL) {
230abc3aeaeSLiu Gang 			port->outb_msg[0].mcback(port, rmu->msg_tx_ring.dev_id,
231abc3aeaeSLiu Gang 					-1,
2326ec4bedbSLiu Gang 					slot);
233abc3aeaeSLiu Gang 		}
2346ec4bedbSLiu Gang 		/* Ack the end-of-message interrupt */
2356ec4bedbSLiu Gang 		out_be32(&rmu->msg_regs->osr, RIO_MSG_OSR_EOMI);
2366ec4bedbSLiu Gang 	}
2376ec4bedbSLiu Gang 
2386ec4bedbSLiu Gang out:
2396ec4bedbSLiu Gang 	return IRQ_HANDLED;
2406ec4bedbSLiu Gang }
2416ec4bedbSLiu Gang 
2426ec4bedbSLiu Gang /**
2436ec4bedbSLiu Gang  * fsl_rio_rx_handler - MPC85xx inbound message interrupt handler
2446ec4bedbSLiu Gang  * @irq: Linux interrupt number
2456ec4bedbSLiu Gang  * @dev_instance: Pointer to interrupt-specific data
2466ec4bedbSLiu Gang  *
2476ec4bedbSLiu Gang  * Handles inbound message interrupts. Executes a registered inbound
2486ec4bedbSLiu Gang  * mailbox event handler and acks the interrupt occurrence.
2496ec4bedbSLiu Gang  */
2506ec4bedbSLiu Gang static irqreturn_t
2516ec4bedbSLiu Gang fsl_rio_rx_handler(int irq, void *dev_instance)
2526ec4bedbSLiu Gang {
2536ec4bedbSLiu Gang 	int isr;
2546ec4bedbSLiu Gang 	struct rio_mport *port = (struct rio_mport *)dev_instance;
2556ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(port);
2566ec4bedbSLiu Gang 
2576ec4bedbSLiu Gang 	isr = in_be32(&rmu->msg_regs->isr);
2586ec4bedbSLiu Gang 
2596ec4bedbSLiu Gang 	if (isr & RIO_MSG_ISR_TE) {
2606ec4bedbSLiu Gang 		pr_info("RIO: inbound message reception error\n");
2616ec4bedbSLiu Gang 		out_be32((void *)&rmu->msg_regs->isr, RIO_MSG_ISR_TE);
2626ec4bedbSLiu Gang 		goto out;
2636ec4bedbSLiu Gang 	}
2646ec4bedbSLiu Gang 
2656ec4bedbSLiu Gang 	/* XXX Need to check/dispatch until queue empty */
2666ec4bedbSLiu Gang 	if (isr & RIO_MSG_ISR_DIQI) {
2676ec4bedbSLiu Gang 		/*
268abc3aeaeSLiu Gang 		* Can receive messages for any mailbox/letter to that
269abc3aeaeSLiu Gang 		* mailbox destination. So, make the callback with an
270abc3aeaeSLiu Gang 		* unknown/invalid mailbox number argument.
2716ec4bedbSLiu Gang 		*/
272abc3aeaeSLiu Gang 		if (port->inb_msg[0].mcback != NULL)
273abc3aeaeSLiu Gang 			port->inb_msg[0].mcback(port, rmu->msg_rx_ring.dev_id,
274abc3aeaeSLiu Gang 				-1,
275abc3aeaeSLiu Gang 				-1);
2766ec4bedbSLiu Gang 
2776ec4bedbSLiu Gang 		/* Ack the queueing interrupt */
2786ec4bedbSLiu Gang 		out_be32(&rmu->msg_regs->isr, RIO_MSG_ISR_DIQI);
2796ec4bedbSLiu Gang 	}
2806ec4bedbSLiu Gang 
2816ec4bedbSLiu Gang out:
2826ec4bedbSLiu Gang 	return IRQ_HANDLED;
2836ec4bedbSLiu Gang }
2846ec4bedbSLiu Gang 
2856ec4bedbSLiu Gang /**
2866ec4bedbSLiu Gang  * fsl_rio_dbell_handler - MPC85xx doorbell interrupt handler
2876ec4bedbSLiu Gang  * @irq: Linux interrupt number
2886ec4bedbSLiu Gang  * @dev_instance: Pointer to interrupt-specific data
2896ec4bedbSLiu Gang  *
2906ec4bedbSLiu Gang  * Handles doorbell interrupts. Parses a list of registered
2916ec4bedbSLiu Gang  * doorbell event handlers and executes a matching event handler.
2926ec4bedbSLiu Gang  */
2936ec4bedbSLiu Gang static irqreturn_t
2946ec4bedbSLiu Gang fsl_rio_dbell_handler(int irq, void *dev_instance)
2956ec4bedbSLiu Gang {
2966ec4bedbSLiu Gang 	int dsr;
297abc3aeaeSLiu Gang 	struct fsl_rio_dbell *fsl_dbell = (struct fsl_rio_dbell *)dev_instance;
298abc3aeaeSLiu Gang 	int i;
2996ec4bedbSLiu Gang 
300abc3aeaeSLiu Gang 	dsr = in_be32(&fsl_dbell->dbell_regs->dsr);
3016ec4bedbSLiu Gang 
3026ec4bedbSLiu Gang 	if (dsr & DOORBELL_DSR_TE) {
3036ec4bedbSLiu Gang 		pr_info("RIO: doorbell reception error\n");
304abc3aeaeSLiu Gang 		out_be32(&fsl_dbell->dbell_regs->dsr, DOORBELL_DSR_TE);
3056ec4bedbSLiu Gang 		goto out;
3066ec4bedbSLiu Gang 	}
3076ec4bedbSLiu Gang 
3086ec4bedbSLiu Gang 	if (dsr & DOORBELL_DSR_QFI) {
3096ec4bedbSLiu Gang 		pr_info("RIO: doorbell queue full\n");
310abc3aeaeSLiu Gang 		out_be32(&fsl_dbell->dbell_regs->dsr, DOORBELL_DSR_QFI);
3116ec4bedbSLiu Gang 	}
3126ec4bedbSLiu Gang 
3136ec4bedbSLiu Gang 	/* XXX Need to check/dispatch until queue empty */
3146ec4bedbSLiu Gang 	if (dsr & DOORBELL_DSR_DIQI) {
315*2a2383daSLiu Gang 		struct rio_dbell_msg *dmsg =
316*2a2383daSLiu Gang 			fsl_dbell->dbell_ring.virt +
317abc3aeaeSLiu Gang 			(in_be32(&fsl_dbell->dbell_regs->dqdpar) & 0xfff);
3186ec4bedbSLiu Gang 		struct rio_dbell *dbell;
3196ec4bedbSLiu Gang 		int found = 0;
3206ec4bedbSLiu Gang 
3216ec4bedbSLiu Gang 		pr_debug
3226ec4bedbSLiu Gang 			("RIO: processing doorbell,"
3236ec4bedbSLiu Gang 			" sid %2.2x tid %2.2x info %4.4x\n",
324*2a2383daSLiu Gang 			dmsg->sid, dmsg->tid, dmsg->info);
3256ec4bedbSLiu Gang 
326abc3aeaeSLiu Gang 		for (i = 0; i < MAX_PORT_NUM; i++) {
327abc3aeaeSLiu Gang 			if (fsl_dbell->mport[i]) {
328abc3aeaeSLiu Gang 				list_for_each_entry(dbell,
329abc3aeaeSLiu Gang 					&fsl_dbell->mport[i]->dbells, node) {
330abc3aeaeSLiu Gang 					if ((dbell->res->start
331*2a2383daSLiu Gang 						<= dmsg->info)
332abc3aeaeSLiu Gang 						&& (dbell->res->end
333*2a2383daSLiu Gang 						>= dmsg->info)) {
3346ec4bedbSLiu Gang 						found = 1;
3356ec4bedbSLiu Gang 						break;
3366ec4bedbSLiu Gang 					}
3376ec4bedbSLiu Gang 				}
338abc3aeaeSLiu Gang 				if (found && dbell->dinb) {
339abc3aeaeSLiu Gang 					dbell->dinb(fsl_dbell->mport[i],
340*2a2383daSLiu Gang 						dbell->dev_id, dmsg->sid,
341*2a2383daSLiu Gang 						dmsg->tid,
342*2a2383daSLiu Gang 						dmsg->info);
343abc3aeaeSLiu Gang 					break;
344abc3aeaeSLiu Gang 				}
345abc3aeaeSLiu Gang 			}
346abc3aeaeSLiu Gang 		}
347abc3aeaeSLiu Gang 
348abc3aeaeSLiu Gang 		if (!found) {
3496ec4bedbSLiu Gang 			pr_debug
3506ec4bedbSLiu Gang 				("RIO: spurious doorbell,"
3516ec4bedbSLiu Gang 				" sid %2.2x tid %2.2x info %4.4x\n",
352*2a2383daSLiu Gang 				dmsg->sid, dmsg->tid,
353*2a2383daSLiu Gang 				dmsg->info);
3546ec4bedbSLiu Gang 		}
355abc3aeaeSLiu Gang 		setbits32(&fsl_dbell->dbell_regs->dmr, DOORBELL_DMR_DI);
356abc3aeaeSLiu Gang 		out_be32(&fsl_dbell->dbell_regs->dsr, DOORBELL_DSR_DIQI);
3576ec4bedbSLiu Gang 	}
3586ec4bedbSLiu Gang 
3596ec4bedbSLiu Gang out:
3606ec4bedbSLiu Gang 	return IRQ_HANDLED;
3616ec4bedbSLiu Gang }
3626ec4bedbSLiu Gang 
363abc3aeaeSLiu Gang void msg_unit_error_handler(void)
3646ec4bedbSLiu Gang {
3656ec4bedbSLiu Gang 
3666ec4bedbSLiu Gang 	/*XXX: Error recovery is not implemented, we just clear errors */
3676ec4bedbSLiu Gang 	out_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR), 0);
3686ec4bedbSLiu Gang 
369abc3aeaeSLiu Gang 	out_be32((u32 *)(rmu_regs_win + RIO_IM0SR), IMSR_CLEAR);
370abc3aeaeSLiu Gang 	out_be32((u32 *)(rmu_regs_win + RIO_IM1SR), IMSR_CLEAR);
371abc3aeaeSLiu Gang 	out_be32((u32 *)(rmu_regs_win + RIO_OM0SR), OMSR_CLEAR);
372abc3aeaeSLiu Gang 	out_be32((u32 *)(rmu_regs_win + RIO_OM1SR), OMSR_CLEAR);
3736ec4bedbSLiu Gang 
374abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->odsr, ODSR_CLEAR);
375abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->dsr, IDSR_CLEAR);
3766ec4bedbSLiu Gang 
377abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->pwsr, IPWSR_CLEAR);
3786ec4bedbSLiu Gang }
3796ec4bedbSLiu Gang 
3806ec4bedbSLiu Gang /**
3816ec4bedbSLiu Gang  * fsl_rio_port_write_handler - MPC85xx port write interrupt handler
3826ec4bedbSLiu Gang  * @irq: Linux interrupt number
3836ec4bedbSLiu Gang  * @dev_instance: Pointer to interrupt-specific data
3846ec4bedbSLiu Gang  *
3856ec4bedbSLiu Gang  * Handles port write interrupts. Parses a list of registered
3866ec4bedbSLiu Gang  * port write event handlers and executes a matching event handler.
3876ec4bedbSLiu Gang  */
3886ec4bedbSLiu Gang static irqreturn_t
3896ec4bedbSLiu Gang fsl_rio_port_write_handler(int irq, void *dev_instance)
3906ec4bedbSLiu Gang {
3916ec4bedbSLiu Gang 	u32 ipwmr, ipwsr;
392abc3aeaeSLiu Gang 	struct fsl_rio_pw *pw = (struct fsl_rio_pw *)dev_instance;
3936ec4bedbSLiu Gang 	u32 epwisr, tmp;
3946ec4bedbSLiu Gang 
395abc3aeaeSLiu Gang 	epwisr = in_be32(rio_regs_win + RIO_EPWISR);
3966ec4bedbSLiu Gang 	if (!(epwisr & RIO_EPWISR_PW))
3976ec4bedbSLiu Gang 		goto pw_done;
3986ec4bedbSLiu Gang 
399abc3aeaeSLiu Gang 	ipwmr = in_be32(&pw->pw_regs->pwmr);
400abc3aeaeSLiu Gang 	ipwsr = in_be32(&pw->pw_regs->pwsr);
4016ec4bedbSLiu Gang 
4026ec4bedbSLiu Gang #ifdef DEBUG_PW
4036ec4bedbSLiu Gang 	pr_debug("PW Int->IPWMR: 0x%08x IPWSR: 0x%08x (", ipwmr, ipwsr);
4046ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_QF)
4056ec4bedbSLiu Gang 		pr_debug(" QF");
4066ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_TE)
4076ec4bedbSLiu Gang 		pr_debug(" TE");
4086ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_QFI)
4096ec4bedbSLiu Gang 		pr_debug(" QFI");
4106ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_PWD)
4116ec4bedbSLiu Gang 		pr_debug(" PWD");
4126ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_PWB)
4136ec4bedbSLiu Gang 		pr_debug(" PWB");
4146ec4bedbSLiu Gang 	pr_debug(" )\n");
4156ec4bedbSLiu Gang #endif
4166ec4bedbSLiu Gang 	/* Schedule deferred processing if PW was received */
4176ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_QFI) {
4186ec4bedbSLiu Gang 		/* Save PW message (if there is room in FIFO),
4196ec4bedbSLiu Gang 		 * otherwise discard it.
4206ec4bedbSLiu Gang 		 */
421abc3aeaeSLiu Gang 		if (kfifo_avail(&pw->pw_fifo) >= RIO_PW_MSG_SIZE) {
422abc3aeaeSLiu Gang 			pw->port_write_msg.msg_count++;
423abc3aeaeSLiu Gang 			kfifo_in(&pw->pw_fifo, pw->port_write_msg.virt,
4246ec4bedbSLiu Gang 				 RIO_PW_MSG_SIZE);
4256ec4bedbSLiu Gang 		} else {
426abc3aeaeSLiu Gang 			pw->port_write_msg.discard_count++;
4276ec4bedbSLiu Gang 			pr_debug("RIO: ISR Discarded Port-Write Msg(s) (%d)\n",
428abc3aeaeSLiu Gang 				 pw->port_write_msg.discard_count);
4296ec4bedbSLiu Gang 		}
4306ec4bedbSLiu Gang 		/* Clear interrupt and issue Clear Queue command. This allows
4316ec4bedbSLiu Gang 		 * another port-write to be received.
4326ec4bedbSLiu Gang 		 */
433abc3aeaeSLiu Gang 		out_be32(&pw->pw_regs->pwsr,	RIO_IPWSR_QFI);
434abc3aeaeSLiu Gang 		out_be32(&pw->pw_regs->pwmr, ipwmr | RIO_IPWMR_CQ);
4356ec4bedbSLiu Gang 
436abc3aeaeSLiu Gang 		schedule_work(&pw->pw_work);
4376ec4bedbSLiu Gang 	}
4386ec4bedbSLiu Gang 
4396ec4bedbSLiu Gang 	if ((ipwmr & RIO_IPWMR_EIE) && (ipwsr & RIO_IPWSR_TE)) {
440abc3aeaeSLiu Gang 		pw->port_write_msg.err_count++;
4416ec4bedbSLiu Gang 		pr_debug("RIO: Port-Write Transaction Err (%d)\n",
442abc3aeaeSLiu Gang 			 pw->port_write_msg.err_count);
4436ec4bedbSLiu Gang 		/* Clear Transaction Error: port-write controller should be
4446ec4bedbSLiu Gang 		 * disabled when clearing this error
4456ec4bedbSLiu Gang 		 */
446abc3aeaeSLiu Gang 		out_be32(&pw->pw_regs->pwmr, ipwmr & ~RIO_IPWMR_PWE);
447abc3aeaeSLiu Gang 		out_be32(&pw->pw_regs->pwsr,	RIO_IPWSR_TE);
448abc3aeaeSLiu Gang 		out_be32(&pw->pw_regs->pwmr, ipwmr);
4496ec4bedbSLiu Gang 	}
4506ec4bedbSLiu Gang 
4516ec4bedbSLiu Gang 	if (ipwsr & RIO_IPWSR_PWD) {
452abc3aeaeSLiu Gang 		pw->port_write_msg.discard_count++;
4536ec4bedbSLiu Gang 		pr_debug("RIO: Port Discarded Port-Write Msg(s) (%d)\n",
454abc3aeaeSLiu Gang 			 pw->port_write_msg.discard_count);
455abc3aeaeSLiu Gang 		out_be32(&pw->pw_regs->pwsr, RIO_IPWSR_PWD);
4566ec4bedbSLiu Gang 	}
4576ec4bedbSLiu Gang 
4586ec4bedbSLiu Gang pw_done:
4596ec4bedbSLiu Gang 	if (epwisr & RIO_EPWISR_PINT1) {
460abc3aeaeSLiu Gang 		tmp = in_be32(rio_regs_win + RIO_LTLEDCSR);
4616ec4bedbSLiu Gang 		pr_debug("RIO_LTLEDCSR = 0x%x\n", tmp);
462abc3aeaeSLiu Gang 		fsl_rio_port_error_handler(0);
4636ec4bedbSLiu Gang 	}
4646ec4bedbSLiu Gang 
4656ec4bedbSLiu Gang 	if (epwisr & RIO_EPWISR_PINT2) {
466abc3aeaeSLiu Gang 		tmp = in_be32(rio_regs_win + RIO_LTLEDCSR);
4676ec4bedbSLiu Gang 		pr_debug("RIO_LTLEDCSR = 0x%x\n", tmp);
468abc3aeaeSLiu Gang 		fsl_rio_port_error_handler(1);
4696ec4bedbSLiu Gang 	}
4706ec4bedbSLiu Gang 
4716ec4bedbSLiu Gang 	if (epwisr & RIO_EPWISR_MU) {
472abc3aeaeSLiu Gang 		tmp = in_be32(rio_regs_win + RIO_LTLEDCSR);
4736ec4bedbSLiu Gang 		pr_debug("RIO_LTLEDCSR = 0x%x\n", tmp);
474abc3aeaeSLiu Gang 		msg_unit_error_handler();
4756ec4bedbSLiu Gang 	}
4766ec4bedbSLiu Gang 
4776ec4bedbSLiu Gang 	return IRQ_HANDLED;
4786ec4bedbSLiu Gang }
4796ec4bedbSLiu Gang 
4806ec4bedbSLiu Gang static void fsl_pw_dpc(struct work_struct *work)
4816ec4bedbSLiu Gang {
482abc3aeaeSLiu Gang 	struct fsl_rio_pw *pw = container_of(work, struct fsl_rio_pw, pw_work);
4836ec4bedbSLiu Gang 	u32 msg_buffer[RIO_PW_MSG_SIZE/sizeof(u32)];
4846ec4bedbSLiu Gang 
4856ec4bedbSLiu Gang 	/*
4866ec4bedbSLiu Gang 	 * Process port-write messages
4876ec4bedbSLiu Gang 	 */
488abc3aeaeSLiu Gang 	while (kfifo_out_spinlocked(&pw->pw_fifo, (unsigned char *)msg_buffer,
489abc3aeaeSLiu Gang 			 RIO_PW_MSG_SIZE, &pw->pw_fifo_lock)) {
4906ec4bedbSLiu Gang 		/* Process one message */
4916ec4bedbSLiu Gang #ifdef DEBUG_PW
4926ec4bedbSLiu Gang 		{
4936ec4bedbSLiu Gang 		u32 i;
4946ec4bedbSLiu Gang 		pr_debug("%s : Port-Write Message:", __func__);
4956ec4bedbSLiu Gang 		for (i = 0; i < RIO_PW_MSG_SIZE/sizeof(u32); i++) {
4966ec4bedbSLiu Gang 			if ((i%4) == 0)
4976ec4bedbSLiu Gang 				pr_debug("\n0x%02x: 0x%08x", i*4,
4986ec4bedbSLiu Gang 					 msg_buffer[i]);
4996ec4bedbSLiu Gang 			else
5006ec4bedbSLiu Gang 				pr_debug(" 0x%08x", msg_buffer[i]);
5016ec4bedbSLiu Gang 		}
5026ec4bedbSLiu Gang 		pr_debug("\n");
5036ec4bedbSLiu Gang 		}
5046ec4bedbSLiu Gang #endif
5056ec4bedbSLiu Gang 		/* Pass the port-write message to RIO core for processing */
5066ec4bedbSLiu Gang 		rio_inb_pwrite_handler((union rio_pw_msg *)msg_buffer);
5076ec4bedbSLiu Gang 	}
5086ec4bedbSLiu Gang }
5096ec4bedbSLiu Gang 
5106ec4bedbSLiu Gang /**
5116ec4bedbSLiu Gang  * fsl_rio_pw_enable - enable/disable port-write interface init
5126ec4bedbSLiu Gang  * @mport: Master port implementing the port write unit
5136ec4bedbSLiu Gang  * @enable:    1=enable; 0=disable port-write message handling
5146ec4bedbSLiu Gang  */
5156ec4bedbSLiu Gang int fsl_rio_pw_enable(struct rio_mport *mport, int enable)
5166ec4bedbSLiu Gang {
5176ec4bedbSLiu Gang 	u32 rval;
5186ec4bedbSLiu Gang 
519abc3aeaeSLiu Gang 	rval = in_be32(&pw->pw_regs->pwmr);
5206ec4bedbSLiu Gang 
5216ec4bedbSLiu Gang 	if (enable)
5226ec4bedbSLiu Gang 		rval |= RIO_IPWMR_PWE;
5236ec4bedbSLiu Gang 	else
5246ec4bedbSLiu Gang 		rval &= ~RIO_IPWMR_PWE;
5256ec4bedbSLiu Gang 
526abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->pwmr, rval);
5276ec4bedbSLiu Gang 
5286ec4bedbSLiu Gang 	return 0;
5296ec4bedbSLiu Gang }
5306ec4bedbSLiu Gang 
5316ec4bedbSLiu Gang /**
5326ec4bedbSLiu Gang  * fsl_rio_port_write_init - MPC85xx port write interface init
5336ec4bedbSLiu Gang  * @mport: Master port implementing the port write unit
5346ec4bedbSLiu Gang  *
5356ec4bedbSLiu Gang  * Initializes port write unit hardware and DMA buffer
5366ec4bedbSLiu Gang  * ring. Called from fsl_rio_setup(). Returns %0 on success
5376ec4bedbSLiu Gang  * or %-ENOMEM on failure.
5386ec4bedbSLiu Gang  */
5396ec4bedbSLiu Gang 
540abc3aeaeSLiu Gang int fsl_rio_port_write_init(struct fsl_rio_pw *pw)
5416ec4bedbSLiu Gang {
5426ec4bedbSLiu Gang 	int rc = 0;
5436ec4bedbSLiu Gang 
5446ec4bedbSLiu Gang 	/* Following configurations require a disabled port write controller */
545abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->pwmr,
546abc3aeaeSLiu Gang 		 in_be32(&pw->pw_regs->pwmr) & ~RIO_IPWMR_PWE);
5476ec4bedbSLiu Gang 
5486ec4bedbSLiu Gang 	/* Initialize port write */
549abc3aeaeSLiu Gang 	pw->port_write_msg.virt = dma_alloc_coherent(pw->dev,
5506ec4bedbSLiu Gang 					RIO_PW_MSG_SIZE,
551abc3aeaeSLiu Gang 					&pw->port_write_msg.phys, GFP_KERNEL);
552abc3aeaeSLiu Gang 	if (!pw->port_write_msg.virt) {
5536ec4bedbSLiu Gang 		pr_err("RIO: unable allocate port write queue\n");
5546ec4bedbSLiu Gang 		return -ENOMEM;
5556ec4bedbSLiu Gang 	}
5566ec4bedbSLiu Gang 
557abc3aeaeSLiu Gang 	pw->port_write_msg.err_count = 0;
558abc3aeaeSLiu Gang 	pw->port_write_msg.discard_count = 0;
5596ec4bedbSLiu Gang 
5606ec4bedbSLiu Gang 	/* Point dequeue/enqueue pointers at first entry */
561abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->epwqbar, 0);
562abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->pwqbar, (u32) pw->port_write_msg.phys);
5636ec4bedbSLiu Gang 
5646ec4bedbSLiu Gang 	pr_debug("EIPWQBAR: 0x%08x IPWQBAR: 0x%08x\n",
565abc3aeaeSLiu Gang 		 in_be32(&pw->pw_regs->epwqbar),
566abc3aeaeSLiu Gang 		 in_be32(&pw->pw_regs->pwqbar));
5676ec4bedbSLiu Gang 
5686ec4bedbSLiu Gang 	/* Clear interrupt status IPWSR */
569abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->pwsr,
5706ec4bedbSLiu Gang 		 (RIO_IPWSR_TE | RIO_IPWSR_QFI | RIO_IPWSR_PWD));
5716ec4bedbSLiu Gang 
5726ec4bedbSLiu Gang 	/* Configure port write contoller for snooping enable all reporting,
5736ec4bedbSLiu Gang 	   clear queue full */
574abc3aeaeSLiu Gang 	out_be32(&pw->pw_regs->pwmr,
5756ec4bedbSLiu Gang 		 RIO_IPWMR_SEN | RIO_IPWMR_QFIE | RIO_IPWMR_EIE | RIO_IPWMR_CQ);
5766ec4bedbSLiu Gang 
5776ec4bedbSLiu Gang 
5786ec4bedbSLiu Gang 	/* Hook up port-write handler */
579abc3aeaeSLiu Gang 	rc = request_irq(IRQ_RIO_PW(pw), fsl_rio_port_write_handler,
580abc3aeaeSLiu Gang 			IRQF_SHARED, "port-write", (void *)pw);
5816ec4bedbSLiu Gang 	if (rc < 0) {
5826ec4bedbSLiu Gang 		pr_err("MPC85xx RIO: unable to request inbound doorbell irq");
5836ec4bedbSLiu Gang 		goto err_out;
5846ec4bedbSLiu Gang 	}
5856ec4bedbSLiu Gang 	/* Enable Error Interrupt */
5866ec4bedbSLiu Gang 	out_be32((u32 *)(rio_regs_win + RIO_LTLEECSR), LTLEECSR_ENABLE_ALL);
5876ec4bedbSLiu Gang 
588abc3aeaeSLiu Gang 	INIT_WORK(&pw->pw_work, fsl_pw_dpc);
589abc3aeaeSLiu Gang 	spin_lock_init(&pw->pw_fifo_lock);
590abc3aeaeSLiu Gang 	if (kfifo_alloc(&pw->pw_fifo, RIO_PW_MSG_SIZE * 32, GFP_KERNEL)) {
5916ec4bedbSLiu Gang 		pr_err("FIFO allocation failed\n");
5926ec4bedbSLiu Gang 		rc = -ENOMEM;
5936ec4bedbSLiu Gang 		goto err_out_irq;
5946ec4bedbSLiu Gang 	}
5956ec4bedbSLiu Gang 
5966ec4bedbSLiu Gang 	pr_debug("IPWMR: 0x%08x IPWSR: 0x%08x\n",
597abc3aeaeSLiu Gang 		 in_be32(&pw->pw_regs->pwmr),
598abc3aeaeSLiu Gang 		 in_be32(&pw->pw_regs->pwsr));
5996ec4bedbSLiu Gang 
6006ec4bedbSLiu Gang 	return rc;
6016ec4bedbSLiu Gang 
6026ec4bedbSLiu Gang err_out_irq:
603abc3aeaeSLiu Gang 	free_irq(IRQ_RIO_PW(pw), (void *)pw);
6046ec4bedbSLiu Gang err_out:
605abc3aeaeSLiu Gang 	dma_free_coherent(pw->dev, RIO_PW_MSG_SIZE,
606abc3aeaeSLiu Gang 		pw->port_write_msg.virt,
607abc3aeaeSLiu Gang 		pw->port_write_msg.phys);
6086ec4bedbSLiu Gang 	return rc;
6096ec4bedbSLiu Gang }
6106ec4bedbSLiu Gang 
6116ec4bedbSLiu Gang /**
6126ec4bedbSLiu Gang  * fsl_rio_doorbell_send - Send a MPC85xx doorbell message
6136ec4bedbSLiu Gang  * @mport: RapidIO master port info
6146ec4bedbSLiu Gang  * @index: ID of RapidIO interface
6156ec4bedbSLiu Gang  * @destid: Destination ID of target device
6166ec4bedbSLiu Gang  * @data: 16-bit info field of RapidIO doorbell message
6176ec4bedbSLiu Gang  *
6186ec4bedbSLiu Gang  * Sends a MPC85xx doorbell message. Returns %0 on success or
6196ec4bedbSLiu Gang  * %-EINVAL on failure.
6206ec4bedbSLiu Gang  */
621abc3aeaeSLiu Gang int fsl_rio_doorbell_send(struct rio_mport *mport,
6226ec4bedbSLiu Gang 				int index, u16 destid, u16 data)
6236ec4bedbSLiu Gang {
6246ec4bedbSLiu Gang 	pr_debug("fsl_doorbell_send: index %d destid %4.4x data %4.4x\n",
6256ec4bedbSLiu Gang 		 index, destid, data);
626abc3aeaeSLiu Gang 
6276ec4bedbSLiu Gang 	/* In the serial version silicons, such as MPC8548, MPC8641,
6286ec4bedbSLiu Gang 	 * below operations is must be.
6296ec4bedbSLiu Gang 	 */
630abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->odmr, 0x00000000);
631abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->odretcr, 0x00000004);
632abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->oddpr, destid << 16);
633abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->oddatr, (index << 20) | data);
634abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->odmr, 0x00000001);
6356ec4bedbSLiu Gang 
6366ec4bedbSLiu Gang 	return 0;
6376ec4bedbSLiu Gang }
6386ec4bedbSLiu Gang 
6396ec4bedbSLiu Gang /**
6406ec4bedbSLiu Gang  * fsl_add_outb_message - Add message to the MPC85xx outbound message queue
6416ec4bedbSLiu Gang  * @mport: Master port with outbound message queue
6426ec4bedbSLiu Gang  * @rdev: Target of outbound message
6436ec4bedbSLiu Gang  * @mbox: Outbound mailbox
6446ec4bedbSLiu Gang  * @buffer: Message to add to outbound queue
6456ec4bedbSLiu Gang  * @len: Length of message
6466ec4bedbSLiu Gang  *
6476ec4bedbSLiu Gang  * Adds the @buffer message to the MPC85xx outbound message queue. Returns
6486ec4bedbSLiu Gang  * %0 on success or %-EINVAL on failure.
6496ec4bedbSLiu Gang  */
650abc3aeaeSLiu Gang int
6516ec4bedbSLiu Gang fsl_add_outb_message(struct rio_mport *mport, struct rio_dev *rdev, int mbox,
6526ec4bedbSLiu Gang 			void *buffer, size_t len)
6536ec4bedbSLiu Gang {
6546ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
6556ec4bedbSLiu Gang 	u32 omr;
6566ec4bedbSLiu Gang 	struct rio_tx_desc *desc = (struct rio_tx_desc *)rmu->msg_tx_ring.virt
6576ec4bedbSLiu Gang 					+ rmu->msg_tx_ring.tx_slot;
6586ec4bedbSLiu Gang 	int ret = 0;
6596ec4bedbSLiu Gang 
6606ec4bedbSLiu Gang 	pr_debug("RIO: fsl_add_outb_message(): destid %4.4x mbox %d buffer " \
661*2a2383daSLiu Gang 		 "%p len %8.8zx\n", rdev->destid, mbox, buffer, len);
6626ec4bedbSLiu Gang 	if ((len < 8) || (len > RIO_MAX_MSG_SIZE)) {
6636ec4bedbSLiu Gang 		ret = -EINVAL;
6646ec4bedbSLiu Gang 		goto out;
6656ec4bedbSLiu Gang 	}
6666ec4bedbSLiu Gang 
6676ec4bedbSLiu Gang 	/* Copy and clear rest of buffer */
6686ec4bedbSLiu Gang 	memcpy(rmu->msg_tx_ring.virt_buffer[rmu->msg_tx_ring.tx_slot], buffer,
6696ec4bedbSLiu Gang 			len);
6706ec4bedbSLiu Gang 	if (len < (RIO_MAX_MSG_SIZE - 4))
6716ec4bedbSLiu Gang 		memset(rmu->msg_tx_ring.virt_buffer[rmu->msg_tx_ring.tx_slot]
6726ec4bedbSLiu Gang 				+ len, 0, RIO_MAX_MSG_SIZE - len);
6736ec4bedbSLiu Gang 
6746ec4bedbSLiu Gang 	/* Set mbox field for message, and set destid */
6756ec4bedbSLiu Gang 	desc->dport = (rdev->destid << 16) | (mbox & 0x3);
6766ec4bedbSLiu Gang 
6776ec4bedbSLiu Gang 	/* Enable EOMI interrupt and priority */
678abc3aeaeSLiu Gang 	desc->dattr = 0x28000000 | ((mport->index) << 20);
6796ec4bedbSLiu Gang 
6806ec4bedbSLiu Gang 	/* Set transfer size aligned to next power of 2 (in double words) */
6816ec4bedbSLiu Gang 	desc->dwcnt = is_power_of_2(len) ? len : 1 << get_bitmask_order(len);
6826ec4bedbSLiu Gang 
6836ec4bedbSLiu Gang 	/* Set snooping and source buffer address */
6846ec4bedbSLiu Gang 	desc->saddr = 0x00000004
6856ec4bedbSLiu Gang 		| rmu->msg_tx_ring.phys_buffer[rmu->msg_tx_ring.tx_slot];
6866ec4bedbSLiu Gang 
6876ec4bedbSLiu Gang 	/* Increment enqueue pointer */
6886ec4bedbSLiu Gang 	omr = in_be32(&rmu->msg_regs->omr);
6896ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->omr, omr | RIO_MSG_OMR_MUI);
6906ec4bedbSLiu Gang 
6916ec4bedbSLiu Gang 	/* Go to next descriptor */
6926ec4bedbSLiu Gang 	if (++rmu->msg_tx_ring.tx_slot == rmu->msg_tx_ring.size)
6936ec4bedbSLiu Gang 		rmu->msg_tx_ring.tx_slot = 0;
6946ec4bedbSLiu Gang 
6956ec4bedbSLiu Gang out:
6966ec4bedbSLiu Gang 	return ret;
6976ec4bedbSLiu Gang }
6986ec4bedbSLiu Gang 
6996ec4bedbSLiu Gang /**
7006ec4bedbSLiu Gang  * fsl_open_outb_mbox - Initialize MPC85xx outbound mailbox
7016ec4bedbSLiu Gang  * @mport: Master port implementing the outbound message unit
7026ec4bedbSLiu Gang  * @dev_id: Device specific pointer to pass on event
7036ec4bedbSLiu Gang  * @mbox: Mailbox to open
7046ec4bedbSLiu Gang  * @entries: Number of entries in the outbound mailbox ring
7056ec4bedbSLiu Gang  *
7066ec4bedbSLiu Gang  * Initializes buffer ring, request the outbound message interrupt,
7076ec4bedbSLiu Gang  * and enables the outbound message unit. Returns %0 on success and
7086ec4bedbSLiu Gang  * %-EINVAL or %-ENOMEM on failure.
7096ec4bedbSLiu Gang  */
710abc3aeaeSLiu Gang int
7116ec4bedbSLiu Gang fsl_open_outb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries)
7126ec4bedbSLiu Gang {
7136ec4bedbSLiu Gang 	int i, j, rc = 0;
7146ec4bedbSLiu Gang 	struct rio_priv *priv = mport->priv;
7156ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
7166ec4bedbSLiu Gang 
7176ec4bedbSLiu Gang 	if ((entries < RIO_MIN_TX_RING_SIZE) ||
7186ec4bedbSLiu Gang 		(entries > RIO_MAX_TX_RING_SIZE) || (!is_power_of_2(entries))) {
7196ec4bedbSLiu Gang 		rc = -EINVAL;
7206ec4bedbSLiu Gang 		goto out;
7216ec4bedbSLiu Gang 	}
7226ec4bedbSLiu Gang 
7236ec4bedbSLiu Gang 	/* Initialize shadow copy ring */
7246ec4bedbSLiu Gang 	rmu->msg_tx_ring.dev_id = dev_id;
7256ec4bedbSLiu Gang 	rmu->msg_tx_ring.size = entries;
7266ec4bedbSLiu Gang 
7276ec4bedbSLiu Gang 	for (i = 0; i < rmu->msg_tx_ring.size; i++) {
7286ec4bedbSLiu Gang 		rmu->msg_tx_ring.virt_buffer[i] =
7296ec4bedbSLiu Gang 			dma_alloc_coherent(priv->dev, RIO_MSG_BUFFER_SIZE,
7306ec4bedbSLiu Gang 				&rmu->msg_tx_ring.phys_buffer[i], GFP_KERNEL);
7316ec4bedbSLiu Gang 		if (!rmu->msg_tx_ring.virt_buffer[i]) {
7326ec4bedbSLiu Gang 			rc = -ENOMEM;
7336ec4bedbSLiu Gang 			for (j = 0; j < rmu->msg_tx_ring.size; j++)
7346ec4bedbSLiu Gang 				if (rmu->msg_tx_ring.virt_buffer[j])
7356ec4bedbSLiu Gang 					dma_free_coherent(priv->dev,
7366ec4bedbSLiu Gang 							RIO_MSG_BUFFER_SIZE,
7376ec4bedbSLiu Gang 							rmu->msg_tx_ring.
7386ec4bedbSLiu Gang 							virt_buffer[j],
7396ec4bedbSLiu Gang 							rmu->msg_tx_ring.
7406ec4bedbSLiu Gang 							phys_buffer[j]);
7416ec4bedbSLiu Gang 			goto out;
7426ec4bedbSLiu Gang 		}
7436ec4bedbSLiu Gang 	}
7446ec4bedbSLiu Gang 
7456ec4bedbSLiu Gang 	/* Initialize outbound message descriptor ring */
7466ec4bedbSLiu Gang 	rmu->msg_tx_ring.virt = dma_alloc_coherent(priv->dev,
7476ec4bedbSLiu Gang 				rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
7486ec4bedbSLiu Gang 				&rmu->msg_tx_ring.phys, GFP_KERNEL);
7496ec4bedbSLiu Gang 	if (!rmu->msg_tx_ring.virt) {
7506ec4bedbSLiu Gang 		rc = -ENOMEM;
7516ec4bedbSLiu Gang 		goto out_dma;
7526ec4bedbSLiu Gang 	}
7536ec4bedbSLiu Gang 	memset(rmu->msg_tx_ring.virt, 0,
7546ec4bedbSLiu Gang 			rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE);
7556ec4bedbSLiu Gang 	rmu->msg_tx_ring.tx_slot = 0;
7566ec4bedbSLiu Gang 
7576ec4bedbSLiu Gang 	/* Point dequeue/enqueue pointers at first entry in ring */
7586ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->odqdpar, rmu->msg_tx_ring.phys);
7596ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->odqepar, rmu->msg_tx_ring.phys);
7606ec4bedbSLiu Gang 
7616ec4bedbSLiu Gang 	/* Configure for snooping */
7626ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->osar, 0x00000004);
7636ec4bedbSLiu Gang 
7646ec4bedbSLiu Gang 	/* Clear interrupt status */
7656ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->osr, 0x000000b3);
7666ec4bedbSLiu Gang 
7676ec4bedbSLiu Gang 	/* Hook up outbound message handler */
7686ec4bedbSLiu Gang 	rc = request_irq(IRQ_RIO_TX(mport), fsl_rio_tx_handler, 0,
7696ec4bedbSLiu Gang 			 "msg_tx", (void *)mport);
7706ec4bedbSLiu Gang 	if (rc < 0)
7716ec4bedbSLiu Gang 		goto out_irq;
7726ec4bedbSLiu Gang 
7736ec4bedbSLiu Gang 	/*
7746ec4bedbSLiu Gang 	 * Configure outbound message unit
7756ec4bedbSLiu Gang 	 *      Snooping
7766ec4bedbSLiu Gang 	 *      Interrupts (all enabled, except QEIE)
7776ec4bedbSLiu Gang 	 *      Chaining mode
7786ec4bedbSLiu Gang 	 *      Disable
7796ec4bedbSLiu Gang 	 */
7806ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->omr, 0x00100220);
7816ec4bedbSLiu Gang 
7826ec4bedbSLiu Gang 	/* Set number of entries */
7836ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->omr,
7846ec4bedbSLiu Gang 		 in_be32(&rmu->msg_regs->omr) |
7856ec4bedbSLiu Gang 		 ((get_bitmask_order(entries) - 2) << 12));
7866ec4bedbSLiu Gang 
7876ec4bedbSLiu Gang 	/* Now enable the unit */
7886ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->omr, in_be32(&rmu->msg_regs->omr) | 0x1);
7896ec4bedbSLiu Gang 
7906ec4bedbSLiu Gang out:
7916ec4bedbSLiu Gang 	return rc;
7926ec4bedbSLiu Gang 
7936ec4bedbSLiu Gang out_irq:
7946ec4bedbSLiu Gang 	dma_free_coherent(priv->dev,
7956ec4bedbSLiu Gang 		rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
7966ec4bedbSLiu Gang 		rmu->msg_tx_ring.virt, rmu->msg_tx_ring.phys);
7976ec4bedbSLiu Gang 
7986ec4bedbSLiu Gang out_dma:
7996ec4bedbSLiu Gang 	for (i = 0; i < rmu->msg_tx_ring.size; i++)
8006ec4bedbSLiu Gang 		dma_free_coherent(priv->dev, RIO_MSG_BUFFER_SIZE,
8016ec4bedbSLiu Gang 		rmu->msg_tx_ring.virt_buffer[i],
8026ec4bedbSLiu Gang 		rmu->msg_tx_ring.phys_buffer[i]);
8036ec4bedbSLiu Gang 
8046ec4bedbSLiu Gang 	return rc;
8056ec4bedbSLiu Gang }
8066ec4bedbSLiu Gang 
8076ec4bedbSLiu Gang /**
8086ec4bedbSLiu Gang  * fsl_close_outb_mbox - Shut down MPC85xx outbound mailbox
8096ec4bedbSLiu Gang  * @mport: Master port implementing the outbound message unit
8106ec4bedbSLiu Gang  * @mbox: Mailbox to close
8116ec4bedbSLiu Gang  *
8126ec4bedbSLiu Gang  * Disables the outbound message unit, free all buffers, and
8136ec4bedbSLiu Gang  * frees the outbound message interrupt.
8146ec4bedbSLiu Gang  */
815abc3aeaeSLiu Gang void fsl_close_outb_mbox(struct rio_mport *mport, int mbox)
8166ec4bedbSLiu Gang {
8176ec4bedbSLiu Gang 	struct rio_priv *priv = mport->priv;
8186ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
8196ec4bedbSLiu Gang 
8206ec4bedbSLiu Gang 	/* Disable inbound message unit */
8216ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->omr, 0);
8226ec4bedbSLiu Gang 
8236ec4bedbSLiu Gang 	/* Free ring */
8246ec4bedbSLiu Gang 	dma_free_coherent(priv->dev,
8256ec4bedbSLiu Gang 	rmu->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
8266ec4bedbSLiu Gang 	rmu->msg_tx_ring.virt, rmu->msg_tx_ring.phys);
8276ec4bedbSLiu Gang 
8286ec4bedbSLiu Gang 	/* Free interrupt */
8296ec4bedbSLiu Gang 	free_irq(IRQ_RIO_TX(mport), (void *)mport);
8306ec4bedbSLiu Gang }
8316ec4bedbSLiu Gang 
8326ec4bedbSLiu Gang /**
8336ec4bedbSLiu Gang  * fsl_open_inb_mbox - Initialize MPC85xx inbound mailbox
8346ec4bedbSLiu Gang  * @mport: Master port implementing the inbound message unit
8356ec4bedbSLiu Gang  * @dev_id: Device specific pointer to pass on event
8366ec4bedbSLiu Gang  * @mbox: Mailbox to open
8376ec4bedbSLiu Gang  * @entries: Number of entries in the inbound mailbox ring
8386ec4bedbSLiu Gang  *
8396ec4bedbSLiu Gang  * Initializes buffer ring, request the inbound message interrupt,
8406ec4bedbSLiu Gang  * and enables the inbound message unit. Returns %0 on success
8416ec4bedbSLiu Gang  * and %-EINVAL or %-ENOMEM on failure.
8426ec4bedbSLiu Gang  */
843abc3aeaeSLiu Gang int
8446ec4bedbSLiu Gang fsl_open_inb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries)
8456ec4bedbSLiu Gang {
8466ec4bedbSLiu Gang 	int i, rc = 0;
8476ec4bedbSLiu Gang 	struct rio_priv *priv = mport->priv;
8486ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
8496ec4bedbSLiu Gang 
8506ec4bedbSLiu Gang 	if ((entries < RIO_MIN_RX_RING_SIZE) ||
8516ec4bedbSLiu Gang 		(entries > RIO_MAX_RX_RING_SIZE) || (!is_power_of_2(entries))) {
8526ec4bedbSLiu Gang 		rc = -EINVAL;
8536ec4bedbSLiu Gang 		goto out;
8546ec4bedbSLiu Gang 	}
8556ec4bedbSLiu Gang 
8566ec4bedbSLiu Gang 	/* Initialize client buffer ring */
8576ec4bedbSLiu Gang 	rmu->msg_rx_ring.dev_id = dev_id;
8586ec4bedbSLiu Gang 	rmu->msg_rx_ring.size = entries;
8596ec4bedbSLiu Gang 	rmu->msg_rx_ring.rx_slot = 0;
8606ec4bedbSLiu Gang 	for (i = 0; i < rmu->msg_rx_ring.size; i++)
8616ec4bedbSLiu Gang 		rmu->msg_rx_ring.virt_buffer[i] = NULL;
8626ec4bedbSLiu Gang 
8636ec4bedbSLiu Gang 	/* Initialize inbound message ring */
8646ec4bedbSLiu Gang 	rmu->msg_rx_ring.virt = dma_alloc_coherent(priv->dev,
8656ec4bedbSLiu Gang 				rmu->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
8666ec4bedbSLiu Gang 				&rmu->msg_rx_ring.phys, GFP_KERNEL);
8676ec4bedbSLiu Gang 	if (!rmu->msg_rx_ring.virt) {
8686ec4bedbSLiu Gang 		rc = -ENOMEM;
8696ec4bedbSLiu Gang 		goto out;
8706ec4bedbSLiu Gang 	}
8716ec4bedbSLiu Gang 
8726ec4bedbSLiu Gang 	/* Point dequeue/enqueue pointers at first entry in ring */
8736ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->ifqdpar, (u32) rmu->msg_rx_ring.phys);
8746ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->ifqepar, (u32) rmu->msg_rx_ring.phys);
8756ec4bedbSLiu Gang 
8766ec4bedbSLiu Gang 	/* Clear interrupt status */
8776ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->isr, 0x00000091);
8786ec4bedbSLiu Gang 
8796ec4bedbSLiu Gang 	/* Hook up inbound message handler */
8806ec4bedbSLiu Gang 	rc = request_irq(IRQ_RIO_RX(mport), fsl_rio_rx_handler, 0,
8816ec4bedbSLiu Gang 			 "msg_rx", (void *)mport);
8826ec4bedbSLiu Gang 	if (rc < 0) {
8836ec4bedbSLiu Gang 		dma_free_coherent(priv->dev, RIO_MSG_BUFFER_SIZE,
8846ec4bedbSLiu Gang 			rmu->msg_tx_ring.virt_buffer[i],
8856ec4bedbSLiu Gang 			rmu->msg_tx_ring.phys_buffer[i]);
8866ec4bedbSLiu Gang 		goto out;
8876ec4bedbSLiu Gang 	}
8886ec4bedbSLiu Gang 
8896ec4bedbSLiu Gang 	/*
8906ec4bedbSLiu Gang 	 * Configure inbound message unit:
8916ec4bedbSLiu Gang 	 *      Snooping
8926ec4bedbSLiu Gang 	 *      4KB max message size
8936ec4bedbSLiu Gang 	 *      Unmask all interrupt sources
8946ec4bedbSLiu Gang 	 *      Disable
8956ec4bedbSLiu Gang 	 */
8966ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->imr, 0x001b0060);
8976ec4bedbSLiu Gang 
8986ec4bedbSLiu Gang 	/* Set number of queue entries */
8996ec4bedbSLiu Gang 	setbits32(&rmu->msg_regs->imr, (get_bitmask_order(entries) - 2) << 12);
9006ec4bedbSLiu Gang 
9016ec4bedbSLiu Gang 	/* Now enable the unit */
9026ec4bedbSLiu Gang 	setbits32(&rmu->msg_regs->imr, 0x1);
9036ec4bedbSLiu Gang 
9046ec4bedbSLiu Gang out:
9056ec4bedbSLiu Gang 	return rc;
9066ec4bedbSLiu Gang }
9076ec4bedbSLiu Gang 
9086ec4bedbSLiu Gang /**
9096ec4bedbSLiu Gang  * fsl_close_inb_mbox - Shut down MPC85xx inbound mailbox
9106ec4bedbSLiu Gang  * @mport: Master port implementing the inbound message unit
9116ec4bedbSLiu Gang  * @mbox: Mailbox to close
9126ec4bedbSLiu Gang  *
9136ec4bedbSLiu Gang  * Disables the inbound message unit, free all buffers, and
9146ec4bedbSLiu Gang  * frees the inbound message interrupt.
9156ec4bedbSLiu Gang  */
916abc3aeaeSLiu Gang void fsl_close_inb_mbox(struct rio_mport *mport, int mbox)
9176ec4bedbSLiu Gang {
9186ec4bedbSLiu Gang 	struct rio_priv *priv = mport->priv;
9196ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
9206ec4bedbSLiu Gang 
9216ec4bedbSLiu Gang 	/* Disable inbound message unit */
9226ec4bedbSLiu Gang 	out_be32(&rmu->msg_regs->imr, 0);
9236ec4bedbSLiu Gang 
9246ec4bedbSLiu Gang 	/* Free ring */
9256ec4bedbSLiu Gang 	dma_free_coherent(priv->dev, rmu->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
9266ec4bedbSLiu Gang 	rmu->msg_rx_ring.virt, rmu->msg_rx_ring.phys);
9276ec4bedbSLiu Gang 
9286ec4bedbSLiu Gang 	/* Free interrupt */
9296ec4bedbSLiu Gang 	free_irq(IRQ_RIO_RX(mport), (void *)mport);
9306ec4bedbSLiu Gang }
9316ec4bedbSLiu Gang 
9326ec4bedbSLiu Gang /**
9336ec4bedbSLiu Gang  * fsl_add_inb_buffer - Add buffer to the MPC85xx inbound message queue
9346ec4bedbSLiu Gang  * @mport: Master port implementing the inbound message unit
9356ec4bedbSLiu Gang  * @mbox: Inbound mailbox number
9366ec4bedbSLiu Gang  * @buf: Buffer to add to inbound queue
9376ec4bedbSLiu Gang  *
9386ec4bedbSLiu Gang  * Adds the @buf buffer to the MPC85xx inbound message queue. Returns
9396ec4bedbSLiu Gang  * %0 on success or %-EINVAL on failure.
9406ec4bedbSLiu Gang  */
941abc3aeaeSLiu Gang int fsl_add_inb_buffer(struct rio_mport *mport, int mbox, void *buf)
9426ec4bedbSLiu Gang {
9436ec4bedbSLiu Gang 	int rc = 0;
9446ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
9456ec4bedbSLiu Gang 
9466ec4bedbSLiu Gang 	pr_debug("RIO: fsl_add_inb_buffer(), msg_rx_ring.rx_slot %d\n",
9476ec4bedbSLiu Gang 		 rmu->msg_rx_ring.rx_slot);
9486ec4bedbSLiu Gang 
9496ec4bedbSLiu Gang 	if (rmu->msg_rx_ring.virt_buffer[rmu->msg_rx_ring.rx_slot]) {
9506ec4bedbSLiu Gang 		printk(KERN_ERR
9516ec4bedbSLiu Gang 			"RIO: error adding inbound buffer %d, buffer exists\n",
9526ec4bedbSLiu Gang 			rmu->msg_rx_ring.rx_slot);
9536ec4bedbSLiu Gang 		rc = -EINVAL;
9546ec4bedbSLiu Gang 		goto out;
9556ec4bedbSLiu Gang 	}
9566ec4bedbSLiu Gang 
9576ec4bedbSLiu Gang 	rmu->msg_rx_ring.virt_buffer[rmu->msg_rx_ring.rx_slot] = buf;
9586ec4bedbSLiu Gang 	if (++rmu->msg_rx_ring.rx_slot == rmu->msg_rx_ring.size)
9596ec4bedbSLiu Gang 		rmu->msg_rx_ring.rx_slot = 0;
9606ec4bedbSLiu Gang 
9616ec4bedbSLiu Gang out:
9626ec4bedbSLiu Gang 	return rc;
9636ec4bedbSLiu Gang }
9646ec4bedbSLiu Gang 
9656ec4bedbSLiu Gang /**
9666ec4bedbSLiu Gang  * fsl_get_inb_message - Fetch inbound message from the MPC85xx message unit
9676ec4bedbSLiu Gang  * @mport: Master port implementing the inbound message unit
9686ec4bedbSLiu Gang  * @mbox: Inbound mailbox number
9696ec4bedbSLiu Gang  *
9706ec4bedbSLiu Gang  * Gets the next available inbound message from the inbound message queue.
9716ec4bedbSLiu Gang  * A pointer to the message is returned on success or NULL on failure.
9726ec4bedbSLiu Gang  */
973abc3aeaeSLiu Gang void *fsl_get_inb_message(struct rio_mport *mport, int mbox)
9746ec4bedbSLiu Gang {
9756ec4bedbSLiu Gang 	struct fsl_rmu *rmu = GET_RMM_HANDLE(mport);
976*2a2383daSLiu Gang 	u32 phys_buf;
977*2a2383daSLiu Gang 	void *virt_buf;
9786ec4bedbSLiu Gang 	void *buf = NULL;
9796ec4bedbSLiu Gang 	int buf_idx;
9806ec4bedbSLiu Gang 
9816ec4bedbSLiu Gang 	phys_buf = in_be32(&rmu->msg_regs->ifqdpar);
9826ec4bedbSLiu Gang 
9836ec4bedbSLiu Gang 	/* If no more messages, then bail out */
9846ec4bedbSLiu Gang 	if (phys_buf == in_be32(&rmu->msg_regs->ifqepar))
9856ec4bedbSLiu Gang 		goto out2;
9866ec4bedbSLiu Gang 
987*2a2383daSLiu Gang 	virt_buf = rmu->msg_rx_ring.virt + (phys_buf
9886ec4bedbSLiu Gang 						- rmu->msg_rx_ring.phys);
9896ec4bedbSLiu Gang 	buf_idx = (phys_buf - rmu->msg_rx_ring.phys) / RIO_MAX_MSG_SIZE;
9906ec4bedbSLiu Gang 	buf = rmu->msg_rx_ring.virt_buffer[buf_idx];
9916ec4bedbSLiu Gang 
9926ec4bedbSLiu Gang 	if (!buf) {
9936ec4bedbSLiu Gang 		printk(KERN_ERR
9946ec4bedbSLiu Gang 			"RIO: inbound message copy failed, no buffers\n");
9956ec4bedbSLiu Gang 		goto out1;
9966ec4bedbSLiu Gang 	}
9976ec4bedbSLiu Gang 
9986ec4bedbSLiu Gang 	/* Copy max message size, caller is expected to allocate that big */
999*2a2383daSLiu Gang 	memcpy(buf, virt_buf, RIO_MAX_MSG_SIZE);
10006ec4bedbSLiu Gang 
10016ec4bedbSLiu Gang 	/* Clear the available buffer */
10026ec4bedbSLiu Gang 	rmu->msg_rx_ring.virt_buffer[buf_idx] = NULL;
10036ec4bedbSLiu Gang 
10046ec4bedbSLiu Gang out1:
10056ec4bedbSLiu Gang 	setbits32(&rmu->msg_regs->imr, RIO_MSG_IMR_MI);
10066ec4bedbSLiu Gang 
10076ec4bedbSLiu Gang out2:
10086ec4bedbSLiu Gang 	return buf;
10096ec4bedbSLiu Gang }
10106ec4bedbSLiu Gang 
10116ec4bedbSLiu Gang /**
10126ec4bedbSLiu Gang  * fsl_rio_doorbell_init - MPC85xx doorbell interface init
10136ec4bedbSLiu Gang  * @mport: Master port implementing the inbound doorbell unit
10146ec4bedbSLiu Gang  *
10156ec4bedbSLiu Gang  * Initializes doorbell unit hardware and inbound DMA buffer
10166ec4bedbSLiu Gang  * ring. Called from fsl_rio_setup(). Returns %0 on success
10176ec4bedbSLiu Gang  * or %-ENOMEM on failure.
10186ec4bedbSLiu Gang  */
1019abc3aeaeSLiu Gang int fsl_rio_doorbell_init(struct fsl_rio_dbell *dbell)
10206ec4bedbSLiu Gang {
10216ec4bedbSLiu Gang 	int rc = 0;
10226ec4bedbSLiu Gang 
10236ec4bedbSLiu Gang 	/* Initialize inbound doorbells */
1024abc3aeaeSLiu Gang 	dbell->dbell_ring.virt = dma_alloc_coherent(dbell->dev, 512 *
1025abc3aeaeSLiu Gang 		DOORBELL_MESSAGE_SIZE, &dbell->dbell_ring.phys, GFP_KERNEL);
1026abc3aeaeSLiu Gang 	if (!dbell->dbell_ring.virt) {
10276ec4bedbSLiu Gang 		printk(KERN_ERR "RIO: unable allocate inbound doorbell ring\n");
10286ec4bedbSLiu Gang 		rc = -ENOMEM;
10296ec4bedbSLiu Gang 		goto out;
10306ec4bedbSLiu Gang 	}
10316ec4bedbSLiu Gang 
10326ec4bedbSLiu Gang 	/* Point dequeue/enqueue pointers at first entry in ring */
1033abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->dqdpar, (u32) dbell->dbell_ring.phys);
1034abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->dqepar, (u32) dbell->dbell_ring.phys);
10356ec4bedbSLiu Gang 
10366ec4bedbSLiu Gang 	/* Clear interrupt status */
1037abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->dsr, 0x00000091);
10386ec4bedbSLiu Gang 
10396ec4bedbSLiu Gang 	/* Hook up doorbell handler */
1040abc3aeaeSLiu Gang 	rc = request_irq(IRQ_RIO_BELL(dbell), fsl_rio_dbell_handler, 0,
1041abc3aeaeSLiu Gang 			 "dbell_rx", (void *)dbell);
10426ec4bedbSLiu Gang 	if (rc < 0) {
1043abc3aeaeSLiu Gang 		dma_free_coherent(dbell->dev, 512 * DOORBELL_MESSAGE_SIZE,
1044abc3aeaeSLiu Gang 			 dbell->dbell_ring.virt, dbell->dbell_ring.phys);
10456ec4bedbSLiu Gang 		printk(KERN_ERR
10466ec4bedbSLiu Gang 			"MPC85xx RIO: unable to request inbound doorbell irq");
10476ec4bedbSLiu Gang 		goto out;
10486ec4bedbSLiu Gang 	}
10496ec4bedbSLiu Gang 
10506ec4bedbSLiu Gang 	/* Configure doorbells for snooping, 512 entries, and enable */
1051abc3aeaeSLiu Gang 	out_be32(&dbell->dbell_regs->dmr, 0x00108161);
10526ec4bedbSLiu Gang 
10536ec4bedbSLiu Gang out:
10546ec4bedbSLiu Gang 	return rc;
10556ec4bedbSLiu Gang }
10566ec4bedbSLiu Gang 
10576ec4bedbSLiu Gang int fsl_rio_setup_rmu(struct rio_mport *mport, struct device_node *node)
10586ec4bedbSLiu Gang {
10596ec4bedbSLiu Gang 	struct rio_priv *priv;
10606ec4bedbSLiu Gang 	struct fsl_rmu *rmu;
1061abc3aeaeSLiu Gang 	u64 msg_start;
1062abc3aeaeSLiu Gang 	const u32 *msg_addr;
1063abc3aeaeSLiu Gang 	int mlen;
1064abc3aeaeSLiu Gang 	int aw;
10656ec4bedbSLiu Gang 
1066abc3aeaeSLiu Gang 	if (!mport || !mport->priv)
1067abc3aeaeSLiu Gang 		return -EINVAL;
1068abc3aeaeSLiu Gang 
1069abc3aeaeSLiu Gang 	priv = mport->priv;
1070abc3aeaeSLiu Gang 
1071abc3aeaeSLiu Gang 	if (!node) {
1072abc3aeaeSLiu Gang 		dev_warn(priv->dev, "Can't get %s property 'fsl,rmu'\n",
1073abc3aeaeSLiu Gang 			priv->dev->of_node->full_name);
1074abc3aeaeSLiu Gang 		return -EINVAL;
1075abc3aeaeSLiu Gang 	}
10766ec4bedbSLiu Gang 
10776ec4bedbSLiu Gang 	rmu = kzalloc(sizeof(struct fsl_rmu), GFP_KERNEL);
10786ec4bedbSLiu Gang 	if (!rmu)
10796ec4bedbSLiu Gang 		return -ENOMEM;
10806ec4bedbSLiu Gang 
1081abc3aeaeSLiu Gang 	aw = of_n_addr_cells(node);
1082abc3aeaeSLiu Gang 	msg_addr = of_get_property(node, "reg", &mlen);
1083abc3aeaeSLiu Gang 	if (!msg_addr) {
1084abc3aeaeSLiu Gang 		pr_err("%s: unable to find 'reg' property of message-unit\n",
1085abc3aeaeSLiu Gang 			node->full_name);
1086c6ca52adSJulia Lawall 		kfree(rmu);
1087abc3aeaeSLiu Gang 		return -ENOMEM;
1088abc3aeaeSLiu Gang 	}
1089abc3aeaeSLiu Gang 	msg_start = of_read_number(msg_addr, aw);
1090abc3aeaeSLiu Gang 
1091abc3aeaeSLiu Gang 	rmu->msg_regs = (struct rio_msg_regs *)
1092abc3aeaeSLiu Gang 			(rmu_regs_win + (u32)msg_start);
1093abc3aeaeSLiu Gang 
1094abc3aeaeSLiu Gang 	rmu->txirq = irq_of_parse_and_map(node, 0);
1095abc3aeaeSLiu Gang 	rmu->rxirq = irq_of_parse_and_map(node, 1);
1096abc3aeaeSLiu Gang 	printk(KERN_INFO "%s: txirq: %d, rxirq %d\n",
1097abc3aeaeSLiu Gang 		node->full_name, rmu->txirq, rmu->rxirq);
1098abc3aeaeSLiu Gang 
10996ec4bedbSLiu Gang 	priv->rmm_handle = rmu;
11006ec4bedbSLiu Gang 
11016ec4bedbSLiu Gang 	rio_init_dbell_res(&mport->riores[RIO_DOORBELL_RESOURCE], 0, 0xffff);
11026ec4bedbSLiu Gang 	rio_init_mbox_res(&mport->riores[RIO_INB_MBOX_RESOURCE], 0, 0);
11036ec4bedbSLiu Gang 	rio_init_mbox_res(&mport->riores[RIO_OUTB_MBOX_RESOURCE], 0, 0);
11046ec4bedbSLiu Gang 
11056ec4bedbSLiu Gang 	return 0;
11066ec4bedbSLiu Gang }
1107