fsl_rio.c 32.0 KB
Newer Older
M
Matt Porter 已提交
1
/*
2
 * Freescale MPC85xx/MPC86xx RapidIO support
M
Matt Porter 已提交
3
 *
4 5 6
 * Copyright (C) 2007, 2008 Freescale Semiconductor, Inc.
 * Zhang Wei <wei.zhang@freescale.com>
 *
M
Matt Porter 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * Copyright 2005 MontaVista Software, Inc.
 * Matt Porter <mporter@kernel.crashing.org>
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/rio.h>
#include <linux/rio_drv.h>
23
#include <linux/of_platform.h>
24
#include <linux/delay.h>
M
Matt Porter 已提交
25 26 27

#include <asm/io.h>

28 29 30 31 32
/* RapidIO definition irq, which read from OF-tree */
#define IRQ_RIO_BELL(m)		(((struct rio_priv *)(m->priv))->bellirq)
#define IRQ_RIO_TX(m)		(((struct rio_priv *)(m->priv))->txirq)
#define IRQ_RIO_RX(m)		(((struct rio_priv *)(m->priv))->rxirq)

M
Matt Porter 已提交
33
#define RIO_ATMU_REGS_OFFSET	0x10c00
34 35 36 37 38 39
#define RIO_P_MSG_REGS_OFFSET	0x11000
#define RIO_S_MSG_REGS_OFFSET	0x13000
#define RIO_ESCSR		0x158
#define RIO_CCSR		0x15c
#define RIO_ISR_AACR		0x10120
#define RIO_ISR_AACR_AA		0x1	/* Accept All ID */
M
Matt Porter 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
#define RIO_MAINT_WIN_SIZE	0x400000
#define RIO_DBELL_WIN_SIZE	0x1000

#define RIO_MSG_OMR_MUI		0x00000002
#define RIO_MSG_OSR_TE		0x00000080
#define RIO_MSG_OSR_QOI		0x00000020
#define RIO_MSG_OSR_QFI		0x00000010
#define RIO_MSG_OSR_MUB		0x00000004
#define RIO_MSG_OSR_EOMI	0x00000002
#define RIO_MSG_OSR_QEI		0x00000001

#define RIO_MSG_IMR_MI		0x00000002
#define RIO_MSG_ISR_TE		0x00000080
#define RIO_MSG_ISR_QFI		0x00000010
#define RIO_MSG_ISR_DIQI	0x00000001

#define RIO_MSG_DESC_SIZE	32
#define RIO_MSG_BUFFER_SIZE	4096
#define RIO_MIN_TX_RING_SIZE	2
#define RIO_MAX_TX_RING_SIZE	2048
#define RIO_MIN_RX_RING_SIZE	2
#define RIO_MAX_RX_RING_SIZE	2048

#define DOORBELL_DMR_DI		0x00000002
#define DOORBELL_DSR_TE		0x00000080
#define DOORBELL_DSR_QFI	0x00000010
#define DOORBELL_DSR_DIQI	0x00000001
67 68
#define DOORBELL_TID_OFFSET	0x02
#define DOORBELL_SID_OFFSET	0x04
M
Matt Porter 已提交
69 70 71
#define DOORBELL_INFO_OFFSET	0x06

#define DOORBELL_MESSAGE_SIZE	0x08
72 73
#define DBELL_SID(x)		(*(u16 *)(x + DOORBELL_SID_OFFSET))
#define DBELL_TID(x)		(*(u16 *)(x + DOORBELL_TID_OFFSET))
M
Matt Porter 已提交
74 75 76 77
#define DBELL_INF(x)		(*(u16 *)(x + DOORBELL_INFO_OFFSET))

struct rio_atmu_regs {
	u32 rowtar;
78
	u32 rowtear;
M
Matt Porter 已提交
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
	u32 rowbar;
	u32 pad2;
	u32 rowar;
	u32 pad3[3];
};

struct rio_msg_regs {
	u32 omr;
	u32 osr;
	u32 pad1;
	u32 odqdpar;
	u32 pad2;
	u32 osar;
	u32 odpr;
	u32 odatr;
	u32 odcr;
	u32 pad3;
	u32 odqepar;
	u32 pad4[13];
	u32 imr;
	u32 isr;
	u32 pad5;
	u32 ifqdpar;
	u32 pad6;
	u32 ifqepar;
104 105 106 107 108 109 110 111 112
	u32 pad7[226];
	u32 odmr;
	u32 odsr;
	u32 res0[4];
	u32 oddpr;
	u32 oddatr;
	u32 res1[3];
	u32 odretcr;
	u32 res2[12];
M
Matt Porter 已提交
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
	u32 dmr;
	u32 dsr;
	u32 pad8;
	u32 dqdpar;
	u32 pad9;
	u32 dqepar;
	u32 pad10[26];
	u32 pwmr;
	u32 pwsr;
	u32 pad11;
	u32 pwqbar;
};

struct rio_tx_desc {
	u32 res1;
	u32 saddr;
	u32 dport;
	u32 dattr;
	u32 res2;
	u32 res3;
	u32 dwcnt;
	u32 res4;
};

137
struct rio_dbell_ring {
M
Matt Porter 已提交
138 139
	void *virt;
	dma_addr_t phys;
140
};
M
Matt Porter 已提交
141

142
struct rio_msg_tx_ring {
M
Matt Porter 已提交
143 144 145 146 147 148
	void *virt;
	dma_addr_t phys;
	void *virt_buffer[RIO_MAX_TX_RING_SIZE];
	dma_addr_t phys_buffer[RIO_MAX_TX_RING_SIZE];
	int tx_slot;
	int size;
149
	void *dev_id;
150
};
M
Matt Porter 已提交
151

152
struct rio_msg_rx_ring {
M
Matt Porter 已提交
153 154 155 156 157
	void *virt;
	dma_addr_t phys;
	void *virt_buffer[RIO_MAX_RX_RING_SIZE];
	int rx_slot;
	int size;
158
	void *dev_id;
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
};

struct rio_priv {
	void __iomem *regs_win;
	struct rio_atmu_regs __iomem *atmu_regs;
	struct rio_atmu_regs __iomem *maint_atmu_regs;
	struct rio_atmu_regs __iomem *dbell_atmu_regs;
	void __iomem *dbell_win;
	void __iomem *maint_win;
	struct rio_msg_regs __iomem *msg_regs;
	struct rio_dbell_ring dbell_ring;
	struct rio_msg_tx_ring msg_tx_ring;
	struct rio_msg_rx_ring msg_rx_ring;
	int bellirq;
	int txirq;
	int rxirq;
};
M
Matt Porter 已提交
176 177

/**
178
 * fsl_rio_doorbell_send - Send a MPC85xx doorbell message
179
 * @mport: RapidIO master port info
M
Matt Porter 已提交
180 181 182 183 184 185 186
 * @index: ID of RapidIO interface
 * @destid: Destination ID of target device
 * @data: 16-bit info field of RapidIO doorbell message
 *
 * Sends a MPC85xx doorbell message. Returns %0 on success or
 * %-EINVAL on failure.
 */
187 188
static int fsl_rio_doorbell_send(struct rio_mport *mport,
				int index, u16 destid, u16 data)
M
Matt Porter 已提交
189
{
190
	struct rio_priv *priv = mport->priv;
191
	pr_debug("fsl_doorbell_send: index %d destid %4.4x data %4.4x\n",
M
Matt Porter 已提交
192
		 index, destid, data);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
	switch (mport->phy_type) {
	case RIO_PHY_PARALLEL:
		out_be32(&priv->dbell_atmu_regs->rowtar, destid << 22);
		out_be16(priv->dbell_win, data);
		break;
	case RIO_PHY_SERIAL:
		/* In the serial version silicons, such as MPC8548, MPC8641,
		 * below operations is must be.
		 */
		out_be32(&priv->msg_regs->odmr, 0x00000000);
		out_be32(&priv->msg_regs->odretcr, 0x00000004);
		out_be32(&priv->msg_regs->oddpr, destid << 16);
		out_be32(&priv->msg_regs->oddatr, data);
		out_be32(&priv->msg_regs->odmr, 0x00000001);
		break;
	}
M
Matt Porter 已提交
209 210 211 212 213

	return 0;
}

/**
214
 * fsl_local_config_read - Generate a MPC85xx local config space read
215
 * @mport: RapidIO master port info
M
Matt Porter 已提交
216 217 218 219 220 221 222 223
 * @index: ID of RapdiIO interface
 * @offset: Offset into configuration space
 * @len: Length (in bytes) of the maintenance transaction
 * @data: Value to be read into
 *
 * Generates a MPC85xx local configuration space read. Returns %0 on
 * success or %-EINVAL on failure.
 */
224 225
static int fsl_local_config_read(struct rio_mport *mport,
				int index, u32 offset, int len, u32 *data)
M
Matt Porter 已提交
226
{
227
	struct rio_priv *priv = mport->priv;
228
	pr_debug("fsl_local_config_read: index %d offset %8.8x\n", index,
M
Matt Porter 已提交
229
		 offset);
230
	*data = in_be32(priv->regs_win + offset);
M
Matt Porter 已提交
231 232 233 234 235

	return 0;
}

/**
236
 * fsl_local_config_write - Generate a MPC85xx local config space write
237
 * @mport: RapidIO master port info
M
Matt Porter 已提交
238 239 240 241 242 243 244 245
 * @index: ID of RapdiIO interface
 * @offset: Offset into configuration space
 * @len: Length (in bytes) of the maintenance transaction
 * @data: Value to be written
 *
 * Generates a MPC85xx local configuration space write. Returns %0 on
 * success or %-EINVAL on failure.
 */
246 247
static int fsl_local_config_write(struct rio_mport *mport,
				int index, u32 offset, int len, u32 data)
M
Matt Porter 已提交
248
{
249
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
250
	pr_debug
251
	    ("fsl_local_config_write: index %d offset %8.8x data %8.8x\n",
M
Matt Porter 已提交
252
	     index, offset, data);
253
	out_be32(priv->regs_win + offset, data);
M
Matt Porter 已提交
254 255 256 257 258

	return 0;
}

/**
259
 * fsl_rio_config_read - Generate a MPC85xx read maintenance transaction
260
 * @mport: RapidIO master port info
M
Matt Porter 已提交
261 262 263 264 265 266 267 268 269 270 271
 * @index: ID of RapdiIO interface
 * @destid: Destination ID of transaction
 * @hopcount: Number of hops to target device
 * @offset: Offset into configuration space
 * @len: Length (in bytes) of the maintenance transaction
 * @val: Location to be read into
 *
 * Generates a MPC85xx read maintenance transaction. Returns %0 on
 * success or %-EINVAL on failure.
 */
static int
272 273
fsl_rio_config_read(struct rio_mport *mport, int index, u16 destid,
			u8 hopcount, u32 offset, int len, u32 *val)
M
Matt Porter 已提交
274
{
275
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
276 277 278
	u8 *data;

	pr_debug
279
	    ("fsl_rio_config_read: index %d destid %d hopcount %d offset %8.8x len %d\n",
M
Matt Porter 已提交
280
	     index, destid, hopcount, offset, len);
281
	out_be32(&priv->maint_atmu_regs->rowtar,
M
Matt Porter 已提交
282 283
		 (destid << 22) | (hopcount << 12) | ((offset & ~0x3) >> 9));

284
	data = (u8 *) priv->maint_win + offset;
M
Matt Porter 已提交
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
	switch (len) {
	case 1:
		*val = in_8((u8 *) data);
		break;
	case 2:
		*val = in_be16((u16 *) data);
		break;
	default:
		*val = in_be32((u32 *) data);
		break;
	}

	return 0;
}

/**
301
 * fsl_rio_config_write - Generate a MPC85xx write maintenance transaction
302
 * @mport: RapidIO master port info
M
Matt Porter 已提交
303 304 305 306 307 308 309 310 311 312 313
 * @index: ID of RapdiIO interface
 * @destid: Destination ID of transaction
 * @hopcount: Number of hops to target device
 * @offset: Offset into configuration space
 * @len: Length (in bytes) of the maintenance transaction
 * @val: Value to be written
 *
 * Generates an MPC85xx write maintenance transaction. Returns %0 on
 * success or %-EINVAL on failure.
 */
static int
314 315
fsl_rio_config_write(struct rio_mport *mport, int index, u16 destid,
			u8 hopcount, u32 offset, int len, u32 val)
M
Matt Porter 已提交
316
{
317
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
318 319
	u8 *data;
	pr_debug
320
	    ("fsl_rio_config_write: index %d destid %d hopcount %d offset %8.8x len %d val %8.8x\n",
M
Matt Porter 已提交
321
	     index, destid, hopcount, offset, len, val);
322
	out_be32(&priv->maint_atmu_regs->rowtar,
M
Matt Porter 已提交
323 324
		 (destid << 22) | (hopcount << 12) | ((offset & ~0x3) >> 9));

325
	data = (u8 *) priv->maint_win + offset;
M
Matt Porter 已提交
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
	switch (len) {
	case 1:
		out_8((u8 *) data, val);
		break;
	case 2:
		out_be16((u16 *) data, val);
		break;
	default:
		out_be32((u32 *) data, val);
		break;
	}

	return 0;
}

/**
 * rio_hw_add_outb_message - Add message to the MPC85xx outbound message queue
 * @mport: Master port with outbound message queue
 * @rdev: Target of outbound message
 * @mbox: Outbound mailbox
 * @buffer: Message to add to outbound queue
 * @len: Length of message
 *
 * Adds the @buffer message to the MPC85xx outbound message queue. Returns
 * %0 on success or %-EINVAL on failure.
 */
int
rio_hw_add_outb_message(struct rio_mport *mport, struct rio_dev *rdev, int mbox,
			void *buffer, size_t len)
{
356
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
357
	u32 omr;
358 359
	struct rio_tx_desc *desc = (struct rio_tx_desc *)priv->msg_tx_ring.virt
					+ priv->msg_tx_ring.tx_slot;
M
Matt Porter 已提交
360 361 362 363 364 365 366 367 368 369 370 371
	int ret = 0;

	pr_debug
	    ("RIO: rio_hw_add_outb_message(): destid %4.4x mbox %d buffer %8.8x len %8.8x\n",
	     rdev->destid, mbox, (int)buffer, len);

	if ((len < 8) || (len > RIO_MAX_MSG_SIZE)) {
		ret = -EINVAL;
		goto out;
	}

	/* Copy and clear rest of buffer */
372 373
	memcpy(priv->msg_tx_ring.virt_buffer[priv->msg_tx_ring.tx_slot], buffer,
			len);
M
Matt Porter 已提交
374
	if (len < (RIO_MAX_MSG_SIZE - 4))
375 376
		memset(priv->msg_tx_ring.virt_buffer[priv->msg_tx_ring.tx_slot]
				+ len, 0, RIO_MAX_MSG_SIZE - len);
M
Matt Porter 已提交
377

378 379 380 381
	switch (mport->phy_type) {
	case RIO_PHY_PARALLEL:
		/* Set mbox field for message */
		desc->dport = mbox & 0x3;
M
Matt Porter 已提交
382

383 384 385 386 387 388 389 390 391 392 393
		/* Enable EOMI interrupt, set priority, and set destid */
		desc->dattr = 0x28000000 | (rdev->destid << 2);
		break;
	case RIO_PHY_SERIAL:
		/* Set mbox field for message, and set destid */
		desc->dport = (rdev->destid << 16) | (mbox & 0x3);

		/* Enable EOMI interrupt and priority */
		desc->dattr = 0x28000000;
		break;
	}
M
Matt Porter 已提交
394 395 396 397 398

	/* Set transfer size aligned to next power of 2 (in double words) */
	desc->dwcnt = is_power_of_2(len) ? len : 1 << get_bitmask_order(len);

	/* Set snooping and source buffer address */
399 400
	desc->saddr = 0x00000004
		| priv->msg_tx_ring.phys_buffer[priv->msg_tx_ring.tx_slot];
M
Matt Porter 已提交
401 402

	/* Increment enqueue pointer */
403 404
	omr = in_be32(&priv->msg_regs->omr);
	out_be32(&priv->msg_regs->omr, omr | RIO_MSG_OMR_MUI);
M
Matt Porter 已提交
405 406

	/* Go to next descriptor */
407 408
	if (++priv->msg_tx_ring.tx_slot == priv->msg_tx_ring.size)
		priv->msg_tx_ring.tx_slot = 0;
M
Matt Porter 已提交
409 410 411 412 413 414 415 416

      out:
	return ret;
}

EXPORT_SYMBOL_GPL(rio_hw_add_outb_message);

/**
417
 * fsl_rio_tx_handler - MPC85xx outbound message interrupt handler
M
Matt Porter 已提交
418 419 420 421
 * @irq: Linux interrupt number
 * @dev_instance: Pointer to interrupt-specific data
 *
 * Handles outbound message interrupts. Executes a register outbound
422
 * mailbox event handler and acks the interrupt occurrence.
M
Matt Porter 已提交
423 424
 */
static irqreturn_t
425
fsl_rio_tx_handler(int irq, void *dev_instance)
M
Matt Porter 已提交
426 427 428
{
	int osr;
	struct rio_mport *port = (struct rio_mport *)dev_instance;
429
	struct rio_priv *priv = port->priv;
M
Matt Porter 已提交
430

431
	osr = in_be32(&priv->msg_regs->osr);
M
Matt Porter 已提交
432 433 434

	if (osr & RIO_MSG_OSR_TE) {
		pr_info("RIO: outbound message transmission error\n");
435
		out_be32(&priv->msg_regs->osr, RIO_MSG_OSR_TE);
M
Matt Porter 已提交
436 437 438 439 440
		goto out;
	}

	if (osr & RIO_MSG_OSR_QOI) {
		pr_info("RIO: outbound message queue overflow\n");
441
		out_be32(&priv->msg_regs->osr, RIO_MSG_OSR_QOI);
M
Matt Porter 已提交
442 443 444 445
		goto out;
	}

	if (osr & RIO_MSG_OSR_EOMI) {
446 447 448 449
		u32 dqp = in_be32(&priv->msg_regs->odqdpar);
		int slot = (dqp - priv->msg_tx_ring.phys) >> 5;
		port->outb_msg[0].mcback(port, priv->msg_tx_ring.dev_id, -1,
				slot);
M
Matt Porter 已提交
450 451

		/* Ack the end-of-message interrupt */
452
		out_be32(&priv->msg_regs->osr, RIO_MSG_OSR_EOMI);
M
Matt Porter 已提交
453 454 455 456 457 458 459 460 461
	}

      out:
	return IRQ_HANDLED;
}

/**
 * rio_open_outb_mbox - Initialize MPC85xx outbound mailbox
 * @mport: Master port implementing the outbound message unit
462
 * @dev_id: Device specific pointer to pass on event
M
Matt Porter 已提交
463 464 465 466 467 468 469
 * @mbox: Mailbox to open
 * @entries: Number of entries in the outbound mailbox ring
 *
 * Initializes buffer ring, request the outbound message interrupt,
 * and enables the outbound message unit. Returns %0 on success and
 * %-EINVAL or %-ENOMEM on failure.
 */
470
int rio_open_outb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries)
M
Matt Porter 已提交
471 472
{
	int i, j, rc = 0;
473
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
474 475 476 477 478 479 480 481

	if ((entries < RIO_MIN_TX_RING_SIZE) ||
	    (entries > RIO_MAX_TX_RING_SIZE) || (!is_power_of_2(entries))) {
		rc = -EINVAL;
		goto out;
	}

	/* Initialize shadow copy ring */
482 483 484 485 486 487 488 489
	priv->msg_tx_ring.dev_id = dev_id;
	priv->msg_tx_ring.size = entries;

	for (i = 0; i < priv->msg_tx_ring.size; i++) {
		priv->msg_tx_ring.virt_buffer[i] =
			dma_alloc_coherent(NULL, RIO_MSG_BUFFER_SIZE,
				&priv->msg_tx_ring.phys_buffer[i], GFP_KERNEL);
		if (!priv->msg_tx_ring.virt_buffer[i]) {
M
Matt Porter 已提交
490
			rc = -ENOMEM;
491 492
			for (j = 0; j < priv->msg_tx_ring.size; j++)
				if (priv->msg_tx_ring.virt_buffer[j])
M
Matt Porter 已提交
493
					dma_free_coherent(NULL,
494 495 496 497 498
							RIO_MSG_BUFFER_SIZE,
							priv->msg_tx_ring.
							virt_buffer[j],
							priv->msg_tx_ring.
							phys_buffer[j]);
M
Matt Porter 已提交
499 500 501 502 503
			goto out;
		}
	}

	/* Initialize outbound message descriptor ring */
504 505 506 507
	priv->msg_tx_ring.virt = dma_alloc_coherent(NULL,
				priv->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
				&priv->msg_tx_ring.phys, GFP_KERNEL);
	if (!priv->msg_tx_ring.virt) {
M
Matt Porter 已提交
508 509 510
		rc = -ENOMEM;
		goto out_dma;
	}
511 512 513
	memset(priv->msg_tx_ring.virt, 0,
			priv->msg_tx_ring.size * RIO_MSG_DESC_SIZE);
	priv->msg_tx_ring.tx_slot = 0;
M
Matt Porter 已提交
514 515

	/* Point dequeue/enqueue pointers at first entry in ring */
516 517
	out_be32(&priv->msg_regs->odqdpar, priv->msg_tx_ring.phys);
	out_be32(&priv->msg_regs->odqepar, priv->msg_tx_ring.phys);
M
Matt Porter 已提交
518 519

	/* Configure for snooping */
520
	out_be32(&priv->msg_regs->osar, 0x00000004);
M
Matt Porter 已提交
521 522

	/* Clear interrupt status */
523
	out_be32(&priv->msg_regs->osr, 0x000000b3);
M
Matt Porter 已提交
524 525

	/* Hook up outbound message handler */
526 527 528
	rc = request_irq(IRQ_RIO_TX(mport), fsl_rio_tx_handler, 0,
			 "msg_tx", (void *)mport);
	if (rc < 0)
M
Matt Porter 已提交
529 530 531 532 533 534 535 536 537
		goto out_irq;

	/*
	 * Configure outbound message unit
	 *      Snooping
	 *      Interrupts (all enabled, except QEIE)
	 *      Chaining mode
	 *      Disable
	 */
538
	out_be32(&priv->msg_regs->omr, 0x00100220);
M
Matt Porter 已提交
539 540

	/* Set number of entries */
541 542
	out_be32(&priv->msg_regs->omr,
		 in_be32(&priv->msg_regs->omr) |
M
Matt Porter 已提交
543 544 545
		 ((get_bitmask_order(entries) - 2) << 12));

	/* Now enable the unit */
546
	out_be32(&priv->msg_regs->omr, in_be32(&priv->msg_regs->omr) | 0x1);
M
Matt Porter 已提交
547 548 549 550 551

      out:
	return rc;

      out_irq:
552 553
	dma_free_coherent(NULL, priv->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
			  priv->msg_tx_ring.virt, priv->msg_tx_ring.phys);
M
Matt Porter 已提交
554 555

      out_dma:
556
	for (i = 0; i < priv->msg_tx_ring.size; i++)
M
Matt Porter 已提交
557
		dma_free_coherent(NULL, RIO_MSG_BUFFER_SIZE,
558 559
				  priv->msg_tx_ring.virt_buffer[i],
				  priv->msg_tx_ring.phys_buffer[i]);
M
Matt Porter 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572 573

	return rc;
}

/**
 * rio_close_outb_mbox - Shut down MPC85xx outbound mailbox
 * @mport: Master port implementing the outbound message unit
 * @mbox: Mailbox to close
 *
 * Disables the outbound message unit, free all buffers, and
 * frees the outbound message interrupt.
 */
void rio_close_outb_mbox(struct rio_mport *mport, int mbox)
{
574
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
575
	/* Disable inbound message unit */
576
	out_be32(&priv->msg_regs->omr, 0);
M
Matt Porter 已提交
577 578

	/* Free ring */
579 580
	dma_free_coherent(NULL, priv->msg_tx_ring.size * RIO_MSG_DESC_SIZE,
			  priv->msg_tx_ring.virt, priv->msg_tx_ring.phys);
M
Matt Porter 已提交
581 582

	/* Free interrupt */
583
	free_irq(IRQ_RIO_TX(mport), (void *)mport);
M
Matt Porter 已提交
584 585 586
}

/**
587
 * fsl_rio_rx_handler - MPC85xx inbound message interrupt handler
M
Matt Porter 已提交
588 589 590 591
 * @irq: Linux interrupt number
 * @dev_instance: Pointer to interrupt-specific data
 *
 * Handles inbound message interrupts. Executes a registered inbound
592
 * mailbox event handler and acks the interrupt occurrence.
M
Matt Porter 已提交
593 594
 */
static irqreturn_t
595
fsl_rio_rx_handler(int irq, void *dev_instance)
M
Matt Porter 已提交
596 597 598
{
	int isr;
	struct rio_mport *port = (struct rio_mport *)dev_instance;
599
	struct rio_priv *priv = port->priv;
M
Matt Porter 已提交
600

601
	isr = in_be32(&priv->msg_regs->isr);
M
Matt Porter 已提交
602 603 604

	if (isr & RIO_MSG_ISR_TE) {
		pr_info("RIO: inbound message reception error\n");
605
		out_be32((void *)&priv->msg_regs->isr, RIO_MSG_ISR_TE);
M
Matt Porter 已提交
606 607 608 609 610 611 612 613 614 615 616
		goto out;
	}

	/* XXX Need to check/dispatch until queue empty */
	if (isr & RIO_MSG_ISR_DIQI) {
		/*
		 * We implement *only* mailbox 0, but can receive messages
		 * for any mailbox/letter to that mailbox destination. So,
		 * make the callback with an unknown/invalid mailbox number
		 * argument.
		 */
617
		port->inb_msg[0].mcback(port, priv->msg_rx_ring.dev_id, -1, -1);
M
Matt Porter 已提交
618 619

		/* Ack the queueing interrupt */
620
		out_be32(&priv->msg_regs->isr, RIO_MSG_ISR_DIQI);
M
Matt Porter 已提交
621 622 623 624 625 626 627 628 629
	}

      out:
	return IRQ_HANDLED;
}

/**
 * rio_open_inb_mbox - Initialize MPC85xx inbound mailbox
 * @mport: Master port implementing the inbound message unit
630
 * @dev_id: Device specific pointer to pass on event
M
Matt Porter 已提交
631 632 633 634 635 636 637
 * @mbox: Mailbox to open
 * @entries: Number of entries in the inbound mailbox ring
 *
 * Initializes buffer ring, request the inbound message interrupt,
 * and enables the inbound message unit. Returns %0 on success
 * and %-EINVAL or %-ENOMEM on failure.
 */
638
int rio_open_inb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries)
M
Matt Porter 已提交
639 640
{
	int i, rc = 0;
641
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
642 643 644 645 646 647 648 649

	if ((entries < RIO_MIN_RX_RING_SIZE) ||
	    (entries > RIO_MAX_RX_RING_SIZE) || (!is_power_of_2(entries))) {
		rc = -EINVAL;
		goto out;
	}

	/* Initialize client buffer ring */
650 651 652 653 654
	priv->msg_rx_ring.dev_id = dev_id;
	priv->msg_rx_ring.size = entries;
	priv->msg_rx_ring.rx_slot = 0;
	for (i = 0; i < priv->msg_rx_ring.size; i++)
		priv->msg_rx_ring.virt_buffer[i] = NULL;
M
Matt Porter 已提交
655 656

	/* Initialize inbound message ring */
657 658 659 660
	priv->msg_rx_ring.virt = dma_alloc_coherent(NULL,
				priv->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
				&priv->msg_rx_ring.phys, GFP_KERNEL);
	if (!priv->msg_rx_ring.virt) {
M
Matt Porter 已提交
661 662 663 664 665
		rc = -ENOMEM;
		goto out;
	}

	/* Point dequeue/enqueue pointers at first entry in ring */
666 667
	out_be32(&priv->msg_regs->ifqdpar, (u32) priv->msg_rx_ring.phys);
	out_be32(&priv->msg_regs->ifqepar, (u32) priv->msg_rx_ring.phys);
M
Matt Porter 已提交
668 669

	/* Clear interrupt status */
670
	out_be32(&priv->msg_regs->isr, 0x00000091);
M
Matt Porter 已提交
671 672

	/* Hook up inbound message handler */
673 674 675
	rc = request_irq(IRQ_RIO_RX(mport), fsl_rio_rx_handler, 0,
			 "msg_rx", (void *)mport);
	if (rc < 0) {
M
Matt Porter 已提交
676
		dma_free_coherent(NULL, RIO_MSG_BUFFER_SIZE,
677 678
				  priv->msg_tx_ring.virt_buffer[i],
				  priv->msg_tx_ring.phys_buffer[i]);
M
Matt Porter 已提交
679 680 681 682 683 684 685 686 687 688
		goto out;
	}

	/*
	 * Configure inbound message unit:
	 *      Snooping
	 *      4KB max message size
	 *      Unmask all interrupt sources
	 *      Disable
	 */
689
	out_be32(&priv->msg_regs->imr, 0x001b0060);
M
Matt Porter 已提交
690 691

	/* Set number of queue entries */
692
	setbits32(&priv->msg_regs->imr, (get_bitmask_order(entries) - 2) << 12);
M
Matt Porter 已提交
693 694

	/* Now enable the unit */
695
	setbits32(&priv->msg_regs->imr, 0x1);
M
Matt Porter 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710

      out:
	return rc;
}

/**
 * rio_close_inb_mbox - Shut down MPC85xx inbound mailbox
 * @mport: Master port implementing the inbound message unit
 * @mbox: Mailbox to close
 *
 * Disables the inbound message unit, free all buffers, and
 * frees the inbound message interrupt.
 */
void rio_close_inb_mbox(struct rio_mport *mport, int mbox)
{
711
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
712
	/* Disable inbound message unit */
713
	out_be32(&priv->msg_regs->imr, 0);
M
Matt Porter 已提交
714 715

	/* Free ring */
716 717
	dma_free_coherent(NULL, priv->msg_rx_ring.size * RIO_MAX_MSG_SIZE,
			  priv->msg_rx_ring.virt, priv->msg_rx_ring.phys);
M
Matt Porter 已提交
718 719

	/* Free interrupt */
720
	free_irq(IRQ_RIO_RX(mport), (void *)mport);
M
Matt Porter 已提交
721 722 723 724 725 726 727 728 729 730 731 732 733 734
}

/**
 * rio_hw_add_inb_buffer - Add buffer to the MPC85xx inbound message queue
 * @mport: Master port implementing the inbound message unit
 * @mbox: Inbound mailbox number
 * @buf: Buffer to add to inbound queue
 *
 * Adds the @buf buffer to the MPC85xx inbound message queue. Returns
 * %0 on success or %-EINVAL on failure.
 */
int rio_hw_add_inb_buffer(struct rio_mport *mport, int mbox, void *buf)
{
	int rc = 0;
735
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
736 737

	pr_debug("RIO: rio_hw_add_inb_buffer(), msg_rx_ring.rx_slot %d\n",
738
		 priv->msg_rx_ring.rx_slot);
M
Matt Porter 已提交
739

740
	if (priv->msg_rx_ring.virt_buffer[priv->msg_rx_ring.rx_slot]) {
M
Matt Porter 已提交
741 742
		printk(KERN_ERR
		       "RIO: error adding inbound buffer %d, buffer exists\n",
743
		       priv->msg_rx_ring.rx_slot);
M
Matt Porter 已提交
744 745 746 747
		rc = -EINVAL;
		goto out;
	}

748 749 750
	priv->msg_rx_ring.virt_buffer[priv->msg_rx_ring.rx_slot] = buf;
	if (++priv->msg_rx_ring.rx_slot == priv->msg_rx_ring.size)
		priv->msg_rx_ring.rx_slot = 0;
M
Matt Porter 已提交
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767

      out:
	return rc;
}

EXPORT_SYMBOL_GPL(rio_hw_add_inb_buffer);

/**
 * rio_hw_get_inb_message - Fetch inbound message from the MPC85xx message unit
 * @mport: Master port implementing the inbound message unit
 * @mbox: Inbound mailbox number
 *
 * Gets the next available inbound message from the inbound message queue.
 * A pointer to the message is returned on success or NULL on failure.
 */
void *rio_hw_get_inb_message(struct rio_mport *mport, int mbox)
{
768
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
769 770 771 772
	u32 phys_buf, virt_buf;
	void *buf = NULL;
	int buf_idx;

773
	phys_buf = in_be32(&priv->msg_regs->ifqdpar);
M
Matt Porter 已提交
774 775

	/* If no more messages, then bail out */
776
	if (phys_buf == in_be32(&priv->msg_regs->ifqepar))
M
Matt Porter 已提交
777 778
		goto out2;

779 780 781 782
	virt_buf = (u32) priv->msg_rx_ring.virt + (phys_buf
						- priv->msg_rx_ring.phys);
	buf_idx = (phys_buf - priv->msg_rx_ring.phys) / RIO_MAX_MSG_SIZE;
	buf = priv->msg_rx_ring.virt_buffer[buf_idx];
M
Matt Porter 已提交
783 784 785 786 787 788 789 790 791 792 793

	if (!buf) {
		printk(KERN_ERR
		       "RIO: inbound message copy failed, no buffers\n");
		goto out1;
	}

	/* Copy max message size, caller is expected to allocate that big */
	memcpy(buf, (void *)virt_buf, RIO_MAX_MSG_SIZE);

	/* Clear the available buffer */
794
	priv->msg_rx_ring.virt_buffer[buf_idx] = NULL;
M
Matt Porter 已提交
795 796

      out1:
797
	setbits32(&priv->msg_regs->imr, RIO_MSG_IMR_MI);
M
Matt Porter 已提交
798 799 800 801 802 803 804 805

      out2:
	return buf;
}

EXPORT_SYMBOL_GPL(rio_hw_get_inb_message);

/**
806
 * fsl_rio_dbell_handler - MPC85xx doorbell interrupt handler
M
Matt Porter 已提交
807 808 809 810 811 812 813
 * @irq: Linux interrupt number
 * @dev_instance: Pointer to interrupt-specific data
 *
 * Handles doorbell interrupts. Parses a list of registered
 * doorbell event handlers and executes a matching event handler.
 */
static irqreturn_t
814
fsl_rio_dbell_handler(int irq, void *dev_instance)
M
Matt Porter 已提交
815 816 817
{
	int dsr;
	struct rio_mport *port = (struct rio_mport *)dev_instance;
818
	struct rio_priv *priv = port->priv;
M
Matt Porter 已提交
819

820
	dsr = in_be32(&priv->msg_regs->dsr);
M
Matt Porter 已提交
821 822 823

	if (dsr & DOORBELL_DSR_TE) {
		pr_info("RIO: doorbell reception error\n");
824
		out_be32(&priv->msg_regs->dsr, DOORBELL_DSR_TE);
M
Matt Porter 已提交
825 826 827 828 829
		goto out;
	}

	if (dsr & DOORBELL_DSR_QFI) {
		pr_info("RIO: doorbell queue full\n");
830
		out_be32(&priv->msg_regs->dsr, DOORBELL_DSR_QFI);
M
Matt Porter 已提交
831 832 833 834 835 836
		goto out;
	}

	/* XXX Need to check/dispatch until queue empty */
	if (dsr & DOORBELL_DSR_DIQI) {
		u32 dmsg =
837 838
		    (u32) priv->dbell_ring.virt +
		    (in_be32(&priv->msg_regs->dqdpar) & 0xfff);
M
Matt Porter 已提交
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
		struct rio_dbell *dbell;
		int found = 0;

		pr_debug
		    ("RIO: processing doorbell, sid %2.2x tid %2.2x info %4.4x\n",
		     DBELL_SID(dmsg), DBELL_TID(dmsg), DBELL_INF(dmsg));

		list_for_each_entry(dbell, &port->dbells, node) {
			if ((dbell->res->start <= DBELL_INF(dmsg)) &&
			    (dbell->res->end >= DBELL_INF(dmsg))) {
				found = 1;
				break;
			}
		}
		if (found) {
854
			dbell->dinb(port, dbell->dev_id, DBELL_SID(dmsg), DBELL_TID(dmsg),
M
Matt Porter 已提交
855 856 857 858 859 860
				    DBELL_INF(dmsg));
		} else {
			pr_debug
			    ("RIO: spurious doorbell, sid %2.2x tid %2.2x info %4.4x\n",
			     DBELL_SID(dmsg), DBELL_TID(dmsg), DBELL_INF(dmsg));
		}
861 862
		setbits32(&priv->msg_regs->dmr, DOORBELL_DMR_DI);
		out_be32(&priv->msg_regs->dsr, DOORBELL_DSR_DIQI);
M
Matt Porter 已提交
863 864 865 866 867 868 869
	}

      out:
	return IRQ_HANDLED;
}

/**
870
 * fsl_rio_doorbell_init - MPC85xx doorbell interface init
M
Matt Porter 已提交
871 872 873
 * @mport: Master port implementing the inbound doorbell unit
 *
 * Initializes doorbell unit hardware and inbound DMA buffer
874
 * ring. Called from fsl_rio_setup(). Returns %0 on success
M
Matt Porter 已提交
875 876
 * or %-ENOMEM on failure.
 */
877
static int fsl_rio_doorbell_init(struct rio_mport *mport)
M
Matt Porter 已提交
878
{
879
	struct rio_priv *priv = mport->priv;
M
Matt Porter 已提交
880 881 882
	int rc = 0;

	/* Map outbound doorbell window immediately after maintenance window */
883 884 885
	priv->dbell_win = ioremap(mport->iores.start + RIO_MAINT_WIN_SIZE,
			    RIO_DBELL_WIN_SIZE);
	if (!priv->dbell_win) {
M
Matt Porter 已提交
886 887 888 889 890 891 892
		printk(KERN_ERR
		       "RIO: unable to map outbound doorbell window\n");
		rc = -ENOMEM;
		goto out;
	}

	/* Initialize inbound doorbells */
893 894 895
	priv->dbell_ring.virt = dma_alloc_coherent(NULL, 512 *
		    DOORBELL_MESSAGE_SIZE, &priv->dbell_ring.phys, GFP_KERNEL);
	if (!priv->dbell_ring.virt) {
M
Matt Porter 已提交
896 897
		printk(KERN_ERR "RIO: unable allocate inbound doorbell ring\n");
		rc = -ENOMEM;
898
		iounmap(priv->dbell_win);
M
Matt Porter 已提交
899 900 901 902
		goto out;
	}

	/* Point dequeue/enqueue pointers at first entry in ring */
903 904
	out_be32(&priv->msg_regs->dqdpar, (u32) priv->dbell_ring.phys);
	out_be32(&priv->msg_regs->dqepar, (u32) priv->dbell_ring.phys);
M
Matt Porter 已提交
905 906

	/* Clear interrupt status */
907
	out_be32(&priv->msg_regs->dsr, 0x00000091);
M
Matt Porter 已提交
908 909

	/* Hook up doorbell handler */
910 911 912 913
	rc = request_irq(IRQ_RIO_BELL(mport), fsl_rio_dbell_handler, 0,
			 "dbell_rx", (void *)mport);
	if (rc < 0) {
		iounmap(priv->dbell_win);
M
Matt Porter 已提交
914
		dma_free_coherent(NULL, 512 * DOORBELL_MESSAGE_SIZE,
915
				  priv->dbell_ring.virt, priv->dbell_ring.phys);
M
Matt Porter 已提交
916 917 918 919 920 921
		printk(KERN_ERR
		       "MPC85xx RIO: unable to request inbound doorbell irq");
		goto out;
	}

	/* Configure doorbells for snooping, 512 entries, and enable */
922
	out_be32(&priv->msg_regs->dmr, 0x00108161);
M
Matt Porter 已提交
923 924 925 926 927 928 929

      out:
	return rc;
}

static char *cmdline = NULL;

930
static int fsl_rio_get_hdid(int index)
M
Matt Porter 已提交
931 932 933 934 935 936 937 938
{
	/* XXX Need to parse multiple entries in some format */
	if (!cmdline)
		return -1;

	return simple_strtol(cmdline, NULL, 0);
}

939
static int fsl_rio_get_cmdline(char *s)
M
Matt Porter 已提交
940 941 942 943 944 945 946 947
{
	if (!s)
		return 0;

	cmdline = s;
	return 1;
}

948
__setup("riohdid=", fsl_rio_get_cmdline);
M
Matt Porter 已提交
949

950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
static inline void fsl_rio_info(struct device *dev, u32 ccsr)
{
	const char *str;
	if (ccsr & 1) {
		/* Serial phy */
		switch (ccsr >> 30) {
		case 0:
			str = "1";
			break;
		case 1:
			str = "4";
			break;
		default:
			str = "Unknown";
			break;;
		}
		dev_info(dev, "Hardware port width: %s\n", str);

		switch ((ccsr >> 27) & 7) {
		case 0:
			str = "Single-lane 0";
			break;
		case 1:
			str = "Single-lane 2";
			break;
		case 2:
			str = "Four-lane";
			break;
		default:
			str = "Unknown";
			break;
		}
		dev_info(dev, "Training connection status: %s\n", str);
	} else {
		/* Parallel phy */
		if (!(ccsr & 0x80000000))
			dev_info(dev, "Output port operating in 8-bit mode\n");
		if (!(ccsr & 0x08000000))
			dev_info(dev, "Input port operating in 8-bit mode\n");
	}
}

M
Matt Porter 已提交
992
/**
993 994
 * fsl_rio_setup - Setup Freescale PowerPC RapidIO interface
 * @dev: of_device pointer
M
Matt Porter 已提交
995 996 997 998 999
 *
 * Initializes MPC85xx RapidIO hardware interface, configures
 * master port with system-specific info, and registers the
 * master port with the RapidIO subsystem.
 */
1000
int fsl_rio_setup(struct of_device *dev)
M
Matt Porter 已提交
1001 1002 1003
{
	struct rio_ops *ops;
	struct rio_mport *port;
1004 1005 1006 1007 1008
	struct rio_priv *priv;
	int rc = 0;
	const u32 *dt_range, *cell;
	struct resource regs;
	int rlen;
1009
	u32 ccsr;
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
	u64 law_start, law_size;
	int paw, aw, sw;

	if (!dev->node) {
		dev_err(&dev->dev, "Device OF-Node is NULL");
		return -EFAULT;
	}

	rc = of_address_to_resource(dev->node, 0, &regs);
	if (rc) {
		dev_err(&dev->dev, "Can't get %s property 'reg'\n",
				dev->node->full_name);
		return -EFAULT;
	}
	dev_info(&dev->dev, "Of-device full name %s\n", dev->node->full_name);
	dev_info(&dev->dev, "Regs start 0x%08x size 0x%08x\n",	regs.start,
						regs.end - regs.start + 1);

	dt_range = of_get_property(dev->node, "ranges", &rlen);
	if (!dt_range) {
		dev_err(&dev->dev, "Can't get %s property 'ranges'\n",
				dev->node->full_name);
		return -EFAULT;
	}

	/* Get node address wide */
	cell = of_get_property(dev->node, "#address-cells", NULL);
	if (cell)
		aw = *cell;
	else
		aw = of_n_addr_cells(dev->node);
	/* Get node size wide */
	cell = of_get_property(dev->node, "#size-cells", NULL);
	if (cell)
		sw = *cell;
	else
		sw = of_n_size_cells(dev->node);
	/* Get parent address wide wide */
	paw = of_n_addr_cells(dev->node);

	law_start = of_read_number(dt_range + aw, paw);
	law_size = of_read_number(dt_range + aw + paw, sw);

	dev_info(&dev->dev, "LAW start 0x%016llx, size 0x%016llx.\n",
			law_start, law_size);
M
Matt Porter 已提交
1055 1056

	ops = kmalloc(sizeof(struct rio_ops), GFP_KERNEL);
1057 1058 1059 1060 1061
	ops->lcread = fsl_local_config_read;
	ops->lcwrite = fsl_local_config_write;
	ops->cread = fsl_rio_config_read;
	ops->cwrite = fsl_rio_config_write;
	ops->dsend = fsl_rio_doorbell_send;
M
Matt Porter 已提交
1062

1063
	port = kzalloc(sizeof(struct rio_mport), GFP_KERNEL);
M
Matt Porter 已提交
1064 1065
	port->id = 0;
	port->index = 0;
1066 1067 1068 1069 1070 1071 1072 1073

	priv = kzalloc(sizeof(struct rio_priv), GFP_KERNEL);
	if (!priv) {
		printk(KERN_ERR "Can't alloc memory for 'priv'\n");
		rc = -ENOMEM;
		goto err;
	}

M
Matt Porter 已提交
1074 1075 1076 1077 1078
	INIT_LIST_HEAD(&port->dbells);
	port->iores.start = law_start;
	port->iores.end = law_start + law_size;
	port->iores.flags = IORESOURCE_MEM;

1079 1080 1081 1082 1083 1084
	priv->bellirq = irq_of_parse_and_map(dev->node, 2);
	priv->txirq = irq_of_parse_and_map(dev->node, 3);
	priv->rxirq = irq_of_parse_and_map(dev->node, 4);
	dev_info(&dev->dev, "bellirq: %d, txirq: %d, rxirq %d\n", priv->bellirq,
				priv->txirq, priv->rxirq);

M
Matt Porter 已提交
1085 1086 1087 1088 1089 1090
	rio_init_dbell_res(&port->riores[RIO_DOORBELL_RESOURCE], 0, 0xffff);
	rio_init_mbox_res(&port->riores[RIO_INB_MBOX_RESOURCE], 0, 0);
	rio_init_mbox_res(&port->riores[RIO_OUTB_MBOX_RESOURCE], 0, 0);
	strcpy(port->name, "RIO0 mport");

	port->ops = ops;
1091
	port->host_deviceid = fsl_rio_get_hdid(port->id);
M
Matt Porter 已提交
1092

1093
	port->priv = priv;
M
Matt Porter 已提交
1094 1095
	rio_register_mport(port);

1096
	priv->regs_win = ioremap(regs.start, regs.end - regs.start + 1);
1097

1098 1099 1100 1101 1102 1103 1104
	/* Probe the master port phy type */
	ccsr = in_be32(priv->regs_win + RIO_CCSR);
	port->phy_type = (ccsr & 1) ? RIO_PHY_SERIAL : RIO_PHY_PARALLEL;
	dev_info(&dev->dev, "RapidIO PHY type: %s\n",
			(port->phy_type == RIO_PHY_PARALLEL) ? "parallel" :
			((port->phy_type == RIO_PHY_SERIAL) ? "serial" :
			 "unknown"));
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	/* Checking the port training status */
	if (in_be32((priv->regs_win + RIO_ESCSR)) & 1) {
		dev_err(&dev->dev, "Port is not ready. "
				   "Try to restart connection...\n");
		switch (port->phy_type) {
		case RIO_PHY_SERIAL:
			/* Disable ports */
			out_be32(priv->regs_win + RIO_CCSR, 0);
			/* Set 1x lane */
			setbits32(priv->regs_win + RIO_CCSR, 0x02000000);
			/* Enable ports */
			setbits32(priv->regs_win + RIO_CCSR, 0x00600000);
			break;
		case RIO_PHY_PARALLEL:
			/* Disable ports */
			out_be32(priv->regs_win + RIO_CCSR, 0x22000000);
			/* Enable ports */
			out_be32(priv->regs_win + RIO_CCSR, 0x44000000);
			break;
		}
		msleep(100);
		if (in_be32((priv->regs_win + RIO_ESCSR)) & 1) {
			dev_err(&dev->dev, "Port restart failed.\n");
			rc = -ENOLINK;
			goto err;
		}
		dev_info(&dev->dev, "Port restart success!\n");
	}
	fsl_rio_info(&dev->dev, ccsr);
1134

1135 1136 1137 1138 1139
	port->sys_size = (in_be32((priv->regs_win + RIO_PEF_CAR))
					& RIO_PEF_CTLS) >> 4;
	dev_info(&dev->dev, "RapidIO Common Transport System size: %d\n",
			port->sys_size ? 65536 : 256);

1140 1141 1142 1143
	priv->atmu_regs = (struct rio_atmu_regs *)(priv->regs_win
					+ RIO_ATMU_REGS_OFFSET);
	priv->maint_atmu_regs = priv->atmu_regs + 1;
	priv->dbell_atmu_regs = priv->atmu_regs + 2;
1144 1145 1146 1147 1148 1149 1150
	priv->msg_regs = (struct rio_msg_regs *)(priv->regs_win +
				((port->phy_type == RIO_PHY_SERIAL) ?
				RIO_S_MSG_REGS_OFFSET : RIO_P_MSG_REGS_OFFSET));

	/* Set to receive any dist ID for serial RapidIO controller. */
	if (port->phy_type == RIO_PHY_SERIAL)
		out_be32((priv->regs_win + RIO_ISR_AACR), RIO_ISR_AACR_AA);
M
Matt Porter 已提交
1151 1152

	/* Configure maintenance transaction window */
1153 1154
	out_be32(&priv->maint_atmu_regs->rowbar, 0x000c0000);
	out_be32(&priv->maint_atmu_regs->rowar, 0x80077015);
M
Matt Porter 已提交
1155

1156
	priv->maint_win = ioremap(law_start, RIO_MAINT_WIN_SIZE);
M
Matt Porter 已提交
1157 1158

	/* Configure outbound doorbell window */
1159 1160
	out_be32(&priv->dbell_atmu_regs->rowbar, 0x000c0400);
	out_be32(&priv->dbell_atmu_regs->rowar, 0x8004200b);
1161
	fsl_rio_doorbell_init(port);
1162

1163
	return 0;
1164 1165 1166
err:
	if (priv)
		iounmap(priv->regs_win);
1167
	kfree(ops);
1168 1169
	kfree(priv);
	kfree(port);
1170
	return rc;
M
Matt Porter 已提交
1171
}
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210

/* The probe function for RapidIO peer-to-peer network.
 */
static int __devinit fsl_of_rio_rpn_probe(struct of_device *dev,
				     const struct of_device_id *match)
{
	int rc;
	printk(KERN_INFO "Setting up RapidIO peer-to-peer network %s\n",
			dev->node->full_name);

	rc = fsl_rio_setup(dev);
	if (rc)
		goto out;

	/* Enumerate all registered ports */
	rc = rio_init_mports();
out:
	return rc;
};

static const struct of_device_id fsl_of_rio_rpn_ids[] = {
	{
		.compatible = "fsl,rapidio-delta",
	},
	{},
};

static struct of_platform_driver fsl_of_rio_rpn_driver = {
	.name = "fsl-of-rio",
	.match_table = fsl_of_rio_rpn_ids,
	.probe = fsl_of_rio_rpn_probe,
};

static __init int fsl_of_rio_rpn_init(void)
{
	return of_register_platform_driver(&fsl_of_rio_rpn_driver);
}

subsys_initcall(fsl_of_rio_rpn_init);