Commit | Line | Data |
---|---|---|
2b0c28d7 | 1 | /* |
d02443a6 | 2 | * Freescale MPC85xx/MPC86xx RapidIO support |
2b0c28d7 | 3 | * |
bd4fb654 TM |
4 | * Copyright 2009 Sysgo AG |
5 | * Thomas Moll <thomas.moll@sysgo.com> | |
6 | * - fixed maintenance access routines, check for aligned access | |
7 | * | |
5b2074ae AB |
8 | * Copyright 2009 Integrated Device Technology, Inc. |
9 | * Alex Bounine <alexandre.bounine@idt.com> | |
10 | * - Added Port-Write message handling | |
11 | * - Added Machine Check exception handling | |
12 | * | |
6ec4bedb | 13 | * Copyright (C) 2007, 2008, 2010, 2011 Freescale Semiconductor, Inc. |
ad1e9380 ZW |
14 | * Zhang Wei <wei.zhang@freescale.com> |
15 | * | |
2b0c28d7 MP |
16 | * Copyright 2005 MontaVista Software, Inc. |
17 | * Matt Porter <mporter@kernel.crashing.org> | |
18 | * | |
19 | * This program is free software; you can redistribute it and/or modify it | |
20 | * under the terms of the GNU General Public License as published by the | |
21 | * Free Software Foundation; either version 2 of the License, or (at your | |
22 | * option) any later version. | |
23 | */ | |
24 | ||
2b0c28d7 | 25 | #include <linux/init.h> |
e0ce42e1 | 26 | #include <linux/module.h> |
2b0c28d7 MP |
27 | #include <linux/types.h> |
28 | #include <linux/dma-mapping.h> | |
29 | #include <linux/interrupt.h> | |
0dbbbf1a | 30 | #include <linux/device.h> |
26a2056e RH |
31 | #include <linux/of_address.h> |
32 | #include <linux/of_irq.h> | |
cc2bb696 | 33 | #include <linux/of_platform.h> |
61b26917 | 34 | #include <linux/delay.h> |
5a0e3ad6 | 35 | #include <linux/slab.h> |
2b0c28d7 | 36 | |
6ec4bedb LG |
37 | #include <linux/io.h> |
38 | #include <linux/uaccess.h> | |
a52c8f52 | 39 | #include <asm/machdep.h> |
2b0c28d7 | 40 | |
6ec4bedb | 41 | #include "fsl_rio.h" |
5b2074ae | 42 | |
6ec4bedb | 43 | #undef DEBUG_PW /* Port-Write debugging */ |
6ff31453 SX |
44 | |
45 | #define RIO_PORT1_EDCSR 0x0640 | |
46 | #define RIO_PORT2_EDCSR 0x0680 | |
47 | #define RIO_PORT1_IECSR 0x10130 | |
48 | #define RIO_PORT2_IECSR 0x101B0 | |
6ff31453 | 49 | |
af84ca38 | 50 | #define RIO_GCCSR 0x13c |
61b26917 | 51 | #define RIO_ESCSR 0x158 |
6ec4bedb | 52 | #define ESCSR_CLEAR 0x07120204 |
6ff31453 | 53 | #define RIO_PORT2_ESCSR 0x178 |
61b26917 | 54 | #define RIO_CCSR 0x15c |
6ff31453 SX |
55 | #define RIO_LTLEDCSR_IER 0x80000000 |
56 | #define RIO_LTLEDCSR_PRT 0x01000000 | |
6ec4bedb | 57 | #define IECSR_CLEAR 0x80000000 |
61b26917 ZW |
58 | #define RIO_ISR_AACR 0x10120 |
59 | #define RIO_ISR_AACR_AA 0x1 /* Accept All ID */ | |
2b0c28d7 | 60 | |
e6a546fd MG |
61 | #define RIWTAR_TRAD_VAL_SHIFT 12 |
62 | #define RIWTAR_TRAD_MASK 0x00FFFFFF | |
63 | #define RIWBAR_BADD_VAL_SHIFT 12 | |
64 | #define RIWBAR_BADD_MASK 0x003FFFFF | |
65 | #define RIWAR_ENABLE 0x80000000 | |
66 | #define RIWAR_TGINT_LOCAL 0x00F00000 | |
67 | #define RIWAR_RDTYP_NO_SNOOP 0x00040000 | |
68 | #define RIWAR_RDTYP_SNOOP 0x00050000 | |
69 | #define RIWAR_WRTYP_NO_SNOOP 0x00004000 | |
70 | #define RIWAR_WRTYP_SNOOP 0x00005000 | |
71 | #define RIWAR_WRTYP_ALLOC 0x00006000 | |
72 | #define RIWAR_SIZE_MASK 0x0000003F | |
73 | ||
a52c8f52 AB |
74 | #define __fsl_read_rio_config(x, addr, err, op) \ |
75 | __asm__ __volatile__( \ | |
76 | "1: "op" %1,0(%2)\n" \ | |
77 | " eieio\n" \ | |
78 | "2:\n" \ | |
79 | ".section .fixup,\"ax\"\n" \ | |
80 | "3: li %1,-1\n" \ | |
81 | " li %0,%3\n" \ | |
82 | " b 2b\n" \ | |
83 | ".section __ex_table,\"a\"\n" \ | |
b6c46dcf LG |
84 | PPC_LONG_ALIGN "\n" \ |
85 | PPC_LONG "1b,3b\n" \ | |
a52c8f52 AB |
86 | ".text" \ |
87 | : "=r" (err), "=r" (x) \ | |
88 | : "b" (addr), "i" (-EFAULT), "0" (err)) | |
89 | ||
6ec4bedb | 90 | void __iomem *rio_regs_win; |
abc3aeae LG |
91 | void __iomem *rmu_regs_win; |
92 | resource_size_t rio_law_start; | |
93 | ||
94 | struct fsl_rio_dbell *dbell; | |
95 | struct fsl_rio_pw *pw; | |
a52c8f52 | 96 | |
ff33f182 | 97 | #ifdef CONFIG_E500 |
cce1f106 | 98 | int fsl_rio_mcheck_exception(struct pt_regs *regs) |
a52c8f52 | 99 | { |
82a9a480 SW |
100 | const struct exception_table_entry *entry; |
101 | unsigned long reason; | |
a52c8f52 | 102 | |
82a9a480 SW |
103 | if (!rio_regs_win) |
104 | return 0; | |
105 | ||
106 | reason = in_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR)); | |
107 | if (reason & (RIO_LTLEDCSR_IER | RIO_LTLEDCSR_PRT)) { | |
108 | /* Check if we are prepared to handle this fault */ | |
109 | entry = search_exception_tables(regs->nip); | |
110 | if (entry) { | |
111 | pr_debug("RIO: %s - MC Exception handled\n", | |
112 | __func__); | |
113 | out_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR), | |
114 | 0); | |
115 | regs->msr |= MSR_RI; | |
116 | regs->nip = entry->fixup; | |
117 | return 1; | |
a52c8f52 AB |
118 | } |
119 | } | |
120 | ||
cce1f106 | 121 | return 0; |
a52c8f52 | 122 | } |
cce1f106 | 123 | EXPORT_SYMBOL_GPL(fsl_rio_mcheck_exception); |
ff33f182 | 124 | #endif |
a52c8f52 | 125 | |
2b0c28d7 | 126 | /** |
d02443a6 | 127 | * fsl_local_config_read - Generate a MPC85xx local config space read |
9941d945 | 128 | * @mport: RapidIO master port info |
2b0c28d7 MP |
129 | * @index: ID of RapdiIO interface |
130 | * @offset: Offset into configuration space | |
131 | * @len: Length (in bytes) of the maintenance transaction | |
132 | * @data: Value to be read into | |
133 | * | |
134 | * Generates a MPC85xx local configuration space read. Returns %0 on | |
135 | * success or %-EINVAL on failure. | |
136 | */ | |
ad1e9380 ZW |
137 | static int fsl_local_config_read(struct rio_mport *mport, |
138 | int index, u32 offset, int len, u32 *data) | |
2b0c28d7 | 139 | { |
ad1e9380 | 140 | struct rio_priv *priv = mport->priv; |
d02443a6 | 141 | pr_debug("fsl_local_config_read: index %d offset %8.8x\n", index, |
abc3aeae | 142 | offset); |
ad1e9380 | 143 | *data = in_be32(priv->regs_win + offset); |
2b0c28d7 MP |
144 | |
145 | return 0; | |
146 | } | |
147 | ||
148 | /** | |
d02443a6 | 149 | * fsl_local_config_write - Generate a MPC85xx local config space write |
9941d945 | 150 | * @mport: RapidIO master port info |
2b0c28d7 MP |
151 | * @index: ID of RapdiIO interface |
152 | * @offset: Offset into configuration space | |
153 | * @len: Length (in bytes) of the maintenance transaction | |
154 | * @data: Value to be written | |
155 | * | |
156 | * Generates a MPC85xx local configuration space write. Returns %0 on | |
157 | * success or %-EINVAL on failure. | |
158 | */ | |
ad1e9380 ZW |
159 | static int fsl_local_config_write(struct rio_mport *mport, |
160 | int index, u32 offset, int len, u32 data) | |
2b0c28d7 | 161 | { |
ad1e9380 | 162 | struct rio_priv *priv = mport->priv; |
2b0c28d7 | 163 | pr_debug |
6ec4bedb LG |
164 | ("fsl_local_config_write: index %d offset %8.8x data %8.8x\n", |
165 | index, offset, data); | |
ad1e9380 | 166 | out_be32(priv->regs_win + offset, data); |
2b0c28d7 MP |
167 | |
168 | return 0; | |
169 | } | |
170 | ||
171 | /** | |
d02443a6 | 172 | * fsl_rio_config_read - Generate a MPC85xx read maintenance transaction |
9941d945 | 173 | * @mport: RapidIO master port info |
2b0c28d7 MP |
174 | * @index: ID of RapdiIO interface |
175 | * @destid: Destination ID of transaction | |
176 | * @hopcount: Number of hops to target device | |
177 | * @offset: Offset into configuration space | |
178 | * @len: Length (in bytes) of the maintenance transaction | |
179 | * @val: Location to be read into | |
180 | * | |
181 | * Generates a MPC85xx read maintenance transaction. Returns %0 on | |
182 | * success or %-EINVAL on failure. | |
183 | */ | |
184 | static int | |
ad1e9380 ZW |
185 | fsl_rio_config_read(struct rio_mport *mport, int index, u16 destid, |
186 | u8 hopcount, u32 offset, int len, u32 *val) | |
2b0c28d7 | 187 | { |
ad1e9380 | 188 | struct rio_priv *priv = mport->priv; |
2b0c28d7 | 189 | u8 *data; |
a52c8f52 | 190 | u32 rval, err = 0; |
2b0c28d7 MP |
191 | |
192 | pr_debug | |
6ec4bedb LG |
193 | ("fsl_rio_config_read:" |
194 | " index %d destid %d hopcount %d offset %8.8x len %d\n", | |
abc3aeae | 195 | index, destid, hopcount, offset, len); |
bd4fb654 TM |
196 | |
197 | /* 16MB maintenance window possible */ | |
198 | /* allow only aligned access to maintenance registers */ | |
199 | if (offset > (0x1000000 - len) || !IS_ALIGNED(offset, len)) | |
200 | return -EINVAL; | |
201 | ||
ad1e9380 | 202 | out_be32(&priv->maint_atmu_regs->rowtar, |
bd4fb654 | 203 | (destid << 22) | (hopcount << 12) | (offset >> 12)); |
6ec4bedb | 204 | out_be32(&priv->maint_atmu_regs->rowtear, (destid >> 10)); |
2b0c28d7 | 205 | |
bd4fb654 | 206 | data = (u8 *) priv->maint_win + (offset & (RIO_MAINT_WIN_SIZE - 1)); |
2b0c28d7 MP |
207 | switch (len) { |
208 | case 1: | |
a52c8f52 | 209 | __fsl_read_rio_config(rval, data, err, "lbz"); |
2b0c28d7 MP |
210 | break; |
211 | case 2: | |
a52c8f52 | 212 | __fsl_read_rio_config(rval, data, err, "lhz"); |
2b0c28d7 | 213 | break; |
bd4fb654 | 214 | case 4: |
a52c8f52 | 215 | __fsl_read_rio_config(rval, data, err, "lwz"); |
2b0c28d7 | 216 | break; |
bd4fb654 TM |
217 | default: |
218 | return -EINVAL; | |
2b0c28d7 MP |
219 | } |
220 | ||
a52c8f52 AB |
221 | if (err) { |
222 | pr_debug("RIO: cfg_read error %d for %x:%x:%x\n", | |
223 | err, destid, hopcount, offset); | |
224 | } | |
225 | ||
226 | *val = rval; | |
227 | ||
228 | return err; | |
2b0c28d7 MP |
229 | } |
230 | ||
231 | /** | |
d02443a6 | 232 | * fsl_rio_config_write - Generate a MPC85xx write maintenance transaction |
9941d945 | 233 | * @mport: RapidIO master port info |
2b0c28d7 MP |
234 | * @index: ID of RapdiIO interface |
235 | * @destid: Destination ID of transaction | |
236 | * @hopcount: Number of hops to target device | |
237 | * @offset: Offset into configuration space | |
238 | * @len: Length (in bytes) of the maintenance transaction | |
239 | * @val: Value to be written | |
240 | * | |
241 | * Generates an MPC85xx write maintenance transaction. Returns %0 on | |
242 | * success or %-EINVAL on failure. | |
243 | */ | |
244 | static int | |
ad1e9380 ZW |
245 | fsl_rio_config_write(struct rio_mport *mport, int index, u16 destid, |
246 | u8 hopcount, u32 offset, int len, u32 val) | |
2b0c28d7 | 247 | { |
ad1e9380 | 248 | struct rio_priv *priv = mport->priv; |
2b0c28d7 MP |
249 | u8 *data; |
250 | pr_debug | |
6ec4bedb | 251 | ("fsl_rio_config_write:" |
abc3aeae LG |
252 | " index %d destid %d hopcount %d offset %8.8x len %d val %8.8x\n", |
253 | index, destid, hopcount, offset, len, val); | |
bd4fb654 TM |
254 | |
255 | /* 16MB maintenance windows possible */ | |
256 | /* allow only aligned access to maintenance registers */ | |
257 | if (offset > (0x1000000 - len) || !IS_ALIGNED(offset, len)) | |
258 | return -EINVAL; | |
259 | ||
ad1e9380 | 260 | out_be32(&priv->maint_atmu_regs->rowtar, |
bd4fb654 | 261 | (destid << 22) | (hopcount << 12) | (offset >> 12)); |
6ec4bedb | 262 | out_be32(&priv->maint_atmu_regs->rowtear, (destid >> 10)); |
2b0c28d7 | 263 | |
bd4fb654 | 264 | data = (u8 *) priv->maint_win + (offset & (RIO_MAINT_WIN_SIZE - 1)); |
2b0c28d7 MP |
265 | switch (len) { |
266 | case 1: | |
267 | out_8((u8 *) data, val); | |
268 | break; | |
269 | case 2: | |
270 | out_be16((u16 *) data, val); | |
271 | break; | |
bd4fb654 | 272 | case 4: |
2b0c28d7 MP |
273 | out_be32((u32 *) data, val); |
274 | break; | |
bd4fb654 TM |
275 | default: |
276 | return -EINVAL; | |
2b0c28d7 MP |
277 | } |
278 | ||
279 | return 0; | |
280 | } | |
281 | ||
e6a546fd MG |
282 | static void fsl_rio_inbound_mem_init(struct rio_priv *priv) |
283 | { | |
284 | int i; | |
285 | ||
286 | /* close inbound windows */ | |
287 | for (i = 0; i < RIO_INB_ATMU_COUNT; i++) | |
288 | out_be32(&priv->inb_atmu_regs[i].riwar, 0); | |
289 | } | |
290 | ||
291 | int fsl_map_inb_mem(struct rio_mport *mport, dma_addr_t lstart, | |
292 | u64 rstart, u32 size, u32 flags) | |
293 | { | |
294 | struct rio_priv *priv = mport->priv; | |
295 | u32 base_size; | |
296 | unsigned int base_size_log; | |
297 | u64 win_start, win_end; | |
298 | u32 riwar; | |
299 | int i; | |
300 | ||
301 | if ((size & (size - 1)) != 0) | |
302 | return -EINVAL; | |
303 | ||
304 | base_size_log = ilog2(size); | |
305 | base_size = 1 << base_size_log; | |
306 | ||
307 | /* check if addresses are aligned with the window size */ | |
308 | if (lstart & (base_size - 1)) | |
309 | return -EINVAL; | |
310 | if (rstart & (base_size - 1)) | |
311 | return -EINVAL; | |
312 | ||
313 | /* check for conflicting ranges */ | |
314 | for (i = 0; i < RIO_INB_ATMU_COUNT; i++) { | |
315 | riwar = in_be32(&priv->inb_atmu_regs[i].riwar); | |
316 | if ((riwar & RIWAR_ENABLE) == 0) | |
317 | continue; | |
318 | win_start = ((u64)(in_be32(&priv->inb_atmu_regs[i].riwbar) & RIWBAR_BADD_MASK)) | |
319 | << RIWBAR_BADD_VAL_SHIFT; | |
320 | win_end = win_start + ((1 << ((riwar & RIWAR_SIZE_MASK) + 1)) - 1); | |
321 | if (rstart < win_end && (rstart + size) > win_start) | |
322 | return -EINVAL; | |
323 | } | |
324 | ||
325 | /* find unused atmu */ | |
326 | for (i = 0; i < RIO_INB_ATMU_COUNT; i++) { | |
327 | riwar = in_be32(&priv->inb_atmu_regs[i].riwar); | |
328 | if ((riwar & RIWAR_ENABLE) == 0) | |
329 | break; | |
330 | } | |
331 | if (i >= RIO_INB_ATMU_COUNT) | |
332 | return -ENOMEM; | |
333 | ||
334 | out_be32(&priv->inb_atmu_regs[i].riwtar, lstart >> RIWTAR_TRAD_VAL_SHIFT); | |
335 | out_be32(&priv->inb_atmu_regs[i].riwbar, rstart >> RIWBAR_BADD_VAL_SHIFT); | |
336 | out_be32(&priv->inb_atmu_regs[i].riwar, RIWAR_ENABLE | RIWAR_TGINT_LOCAL | | |
337 | RIWAR_RDTYP_SNOOP | RIWAR_WRTYP_SNOOP | (base_size_log - 1)); | |
338 | ||
339 | return 0; | |
340 | } | |
341 | ||
342 | void fsl_unmap_inb_mem(struct rio_mport *mport, dma_addr_t lstart) | |
343 | { | |
344 | u32 win_start_shift, base_start_shift; | |
345 | struct rio_priv *priv = mport->priv; | |
346 | u32 riwar, riwtar; | |
347 | int i; | |
348 | ||
349 | /* skip default window */ | |
350 | base_start_shift = lstart >> RIWTAR_TRAD_VAL_SHIFT; | |
351 | for (i = 0; i < RIO_INB_ATMU_COUNT; i++) { | |
352 | riwar = in_be32(&priv->inb_atmu_regs[i].riwar); | |
353 | if ((riwar & RIWAR_ENABLE) == 0) | |
354 | continue; | |
355 | ||
356 | riwtar = in_be32(&priv->inb_atmu_regs[i].riwtar); | |
357 | win_start_shift = riwtar & RIWTAR_TRAD_MASK; | |
358 | if (win_start_shift == base_start_shift) { | |
359 | out_be32(&priv->inb_atmu_regs[i].riwar, riwar & ~RIWAR_ENABLE); | |
360 | return; | |
361 | } | |
362 | } | |
363 | } | |
364 | ||
abc3aeae | 365 | void fsl_rio_port_error_handler(int offset) |
6ff31453 SX |
366 | { |
367 | /*XXX: Error recovery is not implemented, we just clear errors */ | |
368 | out_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR), 0); | |
369 | ||
370 | if (offset == 0) { | |
371 | out_be32((u32 *)(rio_regs_win + RIO_PORT1_EDCSR), 0); | |
671ee7f0 | 372 | out_be32((u32 *)(rio_regs_win + RIO_PORT1_IECSR), IECSR_CLEAR); |
6ff31453 SX |
373 | out_be32((u32 *)(rio_regs_win + RIO_ESCSR), ESCSR_CLEAR); |
374 | } else { | |
375 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_EDCSR), 0); | |
671ee7f0 | 376 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_IECSR), IECSR_CLEAR); |
6ff31453 SX |
377 | out_be32((u32 *)(rio_regs_win + RIO_PORT2_ESCSR), ESCSR_CLEAR); |
378 | } | |
379 | } | |
7f620df8 ZW |
380 | static inline void fsl_rio_info(struct device *dev, u32 ccsr) |
381 | { | |
382 | const char *str; | |
383 | if (ccsr & 1) { | |
384 | /* Serial phy */ | |
385 | switch (ccsr >> 30) { | |
386 | case 0: | |
387 | str = "1"; | |
388 | break; | |
389 | case 1: | |
390 | str = "4"; | |
391 | break; | |
392 | default: | |
393 | str = "Unknown"; | |
d258e64e | 394 | break; |
7f620df8 ZW |
395 | } |
396 | dev_info(dev, "Hardware port width: %s\n", str); | |
397 | ||
398 | switch ((ccsr >> 27) & 7) { | |
399 | case 0: | |
400 | str = "Single-lane 0"; | |
401 | break; | |
402 | case 1: | |
403 | str = "Single-lane 2"; | |
404 | break; | |
405 | case 2: | |
406 | str = "Four-lane"; | |
407 | break; | |
408 | default: | |
409 | str = "Unknown"; | |
410 | break; | |
411 | } | |
412 | dev_info(dev, "Training connection status: %s\n", str); | |
413 | } else { | |
414 | /* Parallel phy */ | |
415 | if (!(ccsr & 0x80000000)) | |
416 | dev_info(dev, "Output port operating in 8-bit mode\n"); | |
417 | if (!(ccsr & 0x08000000)) | |
418 | dev_info(dev, "Input port operating in 8-bit mode\n"); | |
419 | } | |
420 | } | |
421 | ||
2b0c28d7 | 422 | /** |
9941d945 | 423 | * fsl_rio_setup - Setup Freescale PowerPC RapidIO interface |
2dc11581 | 424 | * @dev: platform_device pointer |
2b0c28d7 MP |
425 | * |
426 | * Initializes MPC85xx RapidIO hardware interface, configures | |
427 | * master port with system-specific info, and registers the | |
428 | * master port with the RapidIO subsystem. | |
429 | */ | |
a454dc50 | 430 | int fsl_rio_setup(struct platform_device *dev) |
2b0c28d7 MP |
431 | { |
432 | struct rio_ops *ops; | |
433 | struct rio_mport *port; | |
cc2bb696 ZW |
434 | struct rio_priv *priv; |
435 | int rc = 0; | |
abc3aeae LG |
436 | const u32 *dt_range, *cell, *port_index; |
437 | u32 active_ports = 0; | |
438 | struct resource regs, rmu_regs; | |
439 | struct device_node *np, *rmu_node; | |
cc2bb696 | 440 | int rlen; |
61b26917 | 441 | u32 ccsr; |
abc3aeae | 442 | u64 range_start, range_size; |
cc2bb696 | 443 | int paw, aw, sw; |
abc3aeae LG |
444 | u32 i; |
445 | static int tmp; | |
446 | struct device_node *rmu_np[MAX_MSG_UNIT_NUM] = {NULL}; | |
cc2bb696 | 447 | |
61c7a080 | 448 | if (!dev->dev.of_node) { |
cc2bb696 | 449 | dev_err(&dev->dev, "Device OF-Node is NULL"); |
abc3aeae | 450 | return -ENODEV; |
cc2bb696 ZW |
451 | } |
452 | ||
61c7a080 | 453 | rc = of_address_to_resource(dev->dev.of_node, 0, ®s); |
cc2bb696 ZW |
454 | if (rc) { |
455 | dev_err(&dev->dev, "Can't get %s property 'reg'\n", | |
61c7a080 | 456 | dev->dev.of_node->full_name); |
cc2bb696 ZW |
457 | return -EFAULT; |
458 | } | |
6ec4bedb LG |
459 | dev_info(&dev->dev, "Of-device full name %s\n", |
460 | dev->dev.of_node->full_name); | |
fc274a15 | 461 | dev_info(&dev->dev, "Regs: %pR\n", ®s); |
cc2bb696 | 462 | |
abc3aeae LG |
463 | rio_regs_win = ioremap(regs.start, resource_size(®s)); |
464 | if (!rio_regs_win) { | |
465 | dev_err(&dev->dev, "Unable to map rio register window\n"); | |
466 | rc = -ENOMEM; | |
467 | goto err_rio_regs; | |
cc2bb696 ZW |
468 | } |
469 | ||
e5cabeb3 | 470 | ops = kzalloc(sizeof(struct rio_ops), GFP_KERNEL); |
6c75933c JL |
471 | if (!ops) { |
472 | rc = -ENOMEM; | |
473 | goto err_ops; | |
474 | } | |
d02443a6 ZW |
475 | ops->lcread = fsl_local_config_read; |
476 | ops->lcwrite = fsl_local_config_write; | |
477 | ops->cread = fsl_rio_config_read; | |
478 | ops->cwrite = fsl_rio_config_write; | |
abc3aeae | 479 | ops->dsend = fsl_rio_doorbell_send; |
5b2074ae | 480 | ops->pwenable = fsl_rio_pw_enable; |
abc3aeae LG |
481 | ops->open_outb_mbox = fsl_open_outb_mbox; |
482 | ops->open_inb_mbox = fsl_open_inb_mbox; | |
483 | ops->close_outb_mbox = fsl_close_outb_mbox; | |
484 | ops->close_inb_mbox = fsl_close_inb_mbox; | |
485 | ops->add_outb_message = fsl_add_outb_message; | |
486 | ops->add_inb_buffer = fsl_add_inb_buffer; | |
487 | ops->get_inb_message = fsl_get_inb_message; | |
e6a546fd MG |
488 | ops->map_inb = fsl_map_inb_mem; |
489 | ops->unmap_inb = fsl_unmap_inb_mem; | |
abc3aeae LG |
490 | |
491 | rmu_node = of_parse_phandle(dev->dev.of_node, "fsl,srio-rmu-handle", 0); | |
a614db9a SW |
492 | if (!rmu_node) { |
493 | dev_err(&dev->dev, "No valid fsl,srio-rmu-handle property\n"); | |
abc3aeae | 494 | goto err_rmu; |
a614db9a | 495 | } |
abc3aeae LG |
496 | rc = of_address_to_resource(rmu_node, 0, &rmu_regs); |
497 | if (rc) { | |
498 | dev_err(&dev->dev, "Can't get %s property 'reg'\n", | |
499 | rmu_node->full_name); | |
500 | goto err_rmu; | |
501 | } | |
502 | rmu_regs_win = ioremap(rmu_regs.start, resource_size(&rmu_regs)); | |
503 | if (!rmu_regs_win) { | |
504 | dev_err(&dev->dev, "Unable to map rmu register window\n"); | |
6c75933c | 505 | rc = -ENOMEM; |
abc3aeae LG |
506 | goto err_rmu; |
507 | } | |
508 | for_each_compatible_node(np, NULL, "fsl,srio-msg-unit") { | |
509 | rmu_np[tmp] = np; | |
510 | tmp++; | |
6c75933c | 511 | } |
ad1e9380 | 512 | |
abc3aeae LG |
513 | /*set up doobell node*/ |
514 | np = of_find_compatible_node(NULL, NULL, "fsl,srio-dbell-unit"); | |
515 | if (!np) { | |
a614db9a | 516 | dev_err(&dev->dev, "No fsl,srio-dbell-unit node\n"); |
abc3aeae LG |
517 | rc = -ENODEV; |
518 | goto err_dbell; | |
519 | } | |
520 | dbell = kzalloc(sizeof(struct fsl_rio_dbell), GFP_KERNEL); | |
521 | if (!(dbell)) { | |
522 | dev_err(&dev->dev, "Can't alloc memory for 'fsl_rio_dbell'\n"); | |
ad1e9380 | 523 | rc = -ENOMEM; |
abc3aeae | 524 | goto err_dbell; |
ad1e9380 | 525 | } |
abc3aeae LG |
526 | dbell->dev = &dev->dev; |
527 | dbell->bellirq = irq_of_parse_and_map(np, 1); | |
528 | dev_info(&dev->dev, "bellirq: %d\n", dbell->bellirq); | |
ad1e9380 | 529 | |
abc3aeae LG |
530 | aw = of_n_addr_cells(np); |
531 | dt_range = of_get_property(np, "reg", &rlen); | |
532 | if (!dt_range) { | |
533 | pr_err("%s: unable to find 'reg' property\n", | |
534 | np->full_name); | |
535 | rc = -ENOMEM; | |
536 | goto err_pw; | |
537 | } | |
538 | range_start = of_read_number(dt_range, aw); | |
539 | dbell->dbell_regs = (struct rio_dbell_regs *)(rmu_regs_win + | |
540 | (u32)range_start); | |
541 | ||
542 | /*set up port write node*/ | |
543 | np = of_find_compatible_node(NULL, NULL, "fsl,srio-port-write-unit"); | |
544 | if (!np) { | |
a614db9a | 545 | dev_err(&dev->dev, "No fsl,srio-port-write-unit node\n"); |
abc3aeae LG |
546 | rc = -ENODEV; |
547 | goto err_pw; | |
548 | } | |
549 | pw = kzalloc(sizeof(struct fsl_rio_pw), GFP_KERNEL); | |
550 | if (!(pw)) { | |
551 | dev_err(&dev->dev, "Can't alloc memory for 'fsl_rio_pw'\n"); | |
552 | rc = -ENOMEM; | |
553 | goto err_pw; | |
554 | } | |
555 | pw->dev = &dev->dev; | |
556 | pw->pwirq = irq_of_parse_and_map(np, 0); | |
557 | dev_info(&dev->dev, "pwirq: %d\n", pw->pwirq); | |
558 | aw = of_n_addr_cells(np); | |
559 | dt_range = of_get_property(np, "reg", &rlen); | |
560 | if (!dt_range) { | |
561 | pr_err("%s: unable to find 'reg' property\n", | |
562 | np->full_name); | |
563 | rc = -ENOMEM; | |
564 | goto err; | |
c1256ebe | 565 | } |
abc3aeae LG |
566 | range_start = of_read_number(dt_range, aw); |
567 | pw->pw_regs = (struct rio_pw_regs *)(rmu_regs_win + (u32)range_start); | |
568 | ||
569 | /*set up ports node*/ | |
570 | for_each_child_of_node(dev->dev.of_node, np) { | |
571 | port_index = of_get_property(np, "cell-index", NULL); | |
572 | if (!port_index) { | |
573 | dev_err(&dev->dev, "Can't get %s property 'cell-index'\n", | |
574 | np->full_name); | |
575 | continue; | |
576 | } | |
577 | ||
578 | dt_range = of_get_property(np, "ranges", &rlen); | |
579 | if (!dt_range) { | |
580 | dev_err(&dev->dev, "Can't get %s property 'ranges'\n", | |
581 | np->full_name); | |
582 | continue; | |
583 | } | |
c1256ebe | 584 | |
abc3aeae LG |
585 | /* Get node address wide */ |
586 | cell = of_get_property(np, "#address-cells", NULL); | |
587 | if (cell) | |
588 | aw = *cell; | |
589 | else | |
590 | aw = of_n_addr_cells(np); | |
591 | /* Get node size wide */ | |
592 | cell = of_get_property(np, "#size-cells", NULL); | |
593 | if (cell) | |
594 | sw = *cell; | |
595 | else | |
596 | sw = of_n_size_cells(np); | |
597 | /* Get parent address wide wide */ | |
598 | paw = of_n_addr_cells(np); | |
599 | range_start = of_read_number(dt_range + aw, paw); | |
600 | range_size = of_read_number(dt_range + aw + paw, sw); | |
601 | ||
602 | dev_info(&dev->dev, "%s: LAW start 0x%016llx, size 0x%016llx.\n", | |
603 | np->full_name, range_start, range_size); | |
604 | ||
605 | port = kzalloc(sizeof(struct rio_mport), GFP_KERNEL); | |
606 | if (!port) | |
607 | continue; | |
608 | ||
dd64f4fe AB |
609 | rc = rio_mport_initialize(port); |
610 | if (rc) { | |
611 | kfree(port); | |
612 | continue; | |
613 | } | |
614 | ||
abc3aeae LG |
615 | i = *port_index - 1; |
616 | port->index = (unsigned char)i; | |
617 | ||
618 | priv = kzalloc(sizeof(struct rio_priv), GFP_KERNEL); | |
619 | if (!priv) { | |
620 | dev_err(&dev->dev, "Can't alloc memory for 'priv'\n"); | |
621 | kfree(port); | |
622 | continue; | |
623 | } | |
624 | ||
625 | INIT_LIST_HEAD(&port->dbells); | |
626 | port->iores.start = range_start; | |
627 | port->iores.end = port->iores.start + range_size - 1; | |
628 | port->iores.flags = IORESOURCE_MEM; | |
629 | port->iores.name = "rio_io_win"; | |
630 | ||
631 | if (request_resource(&iomem_resource, &port->iores) < 0) { | |
632 | dev_err(&dev->dev, "RIO: Error requesting master port region" | |
633 | " 0x%016llx-0x%016llx\n", | |
634 | (u64)port->iores.start, (u64)port->iores.end); | |
635 | kfree(priv); | |
636 | kfree(port); | |
637 | continue; | |
638 | } | |
639 | sprintf(port->name, "RIO mport %d", i); | |
640 | ||
641 | priv->dev = &dev->dev; | |
2aaf308b | 642 | port->dev.parent = &dev->dev; |
abc3aeae LG |
643 | port->ops = ops; |
644 | port->priv = priv; | |
645 | port->phys_efptr = 0x100; | |
646 | priv->regs_win = rio_regs_win; | |
647 | ||
648 | /* Probe the master port phy type */ | |
649 | ccsr = in_be32(priv->regs_win + RIO_CCSR + i*0x20); | |
650 | port->phy_type = (ccsr & 1) ? RIO_PHY_SERIAL : RIO_PHY_PARALLEL; | |
651 | if (port->phy_type == RIO_PHY_PARALLEL) { | |
652 | dev_err(&dev->dev, "RIO: Parallel PHY type, unsupported port type!\n"); | |
653 | release_resource(&port->iores); | |
654 | kfree(priv); | |
655 | kfree(port); | |
656 | continue; | |
657 | } | |
658 | dev_info(&dev->dev, "RapidIO PHY type: Serial\n"); | |
659 | /* Checking the port training status */ | |
660 | if (in_be32((priv->regs_win + RIO_ESCSR + i*0x20)) & 1) { | |
661 | dev_err(&dev->dev, "Port %d is not ready. " | |
662 | "Try to restart connection...\n", i); | |
7f620df8 | 663 | /* Disable ports */ |
abc3aeae LG |
664 | out_be32(priv->regs_win |
665 | + RIO_CCSR + i*0x20, 0); | |
7f620df8 | 666 | /* Set 1x lane */ |
abc3aeae LG |
667 | setbits32(priv->regs_win |
668 | + RIO_CCSR + i*0x20, 0x02000000); | |
7f620df8 | 669 | /* Enable ports */ |
abc3aeae LG |
670 | setbits32(priv->regs_win |
671 | + RIO_CCSR + i*0x20, 0x00600000); | |
672 | msleep(100); | |
673 | if (in_be32((priv->regs_win | |
674 | + RIO_ESCSR + i*0x20)) & 1) { | |
675 | dev_err(&dev->dev, | |
676 | "Port %d restart failed.\n", i); | |
677 | release_resource(&port->iores); | |
678 | kfree(priv); | |
679 | kfree(port); | |
680 | continue; | |
681 | } | |
682 | dev_info(&dev->dev, "Port %d restart success!\n", i); | |
7f620df8 | 683 | } |
abc3aeae | 684 | fsl_rio_info(&dev->dev, ccsr); |
61b26917 | 685 | |
abc3aeae | 686 | port->sys_size = (in_be32((priv->regs_win + RIO_PEF_CAR)) |
e0423236 | 687 | & RIO_PEF_CTLS) >> 4; |
abc3aeae LG |
688 | dev_info(&dev->dev, "RapidIO Common Transport System size: %d\n", |
689 | port->sys_size ? 65536 : 256); | |
690 | ||
abc3aeae LG |
691 | if (port->host_deviceid >= 0) |
692 | out_be32(priv->regs_win + RIO_GCCSR, RIO_PORT_GEN_HOST | | |
693 | RIO_PORT_GEN_MASTER | RIO_PORT_GEN_DISCOVERED); | |
694 | else | |
695 | out_be32(priv->regs_win + RIO_GCCSR, | |
696 | RIO_PORT_GEN_MASTER); | |
e0423236 | 697 | |
abc3aeae LG |
698 | priv->atmu_regs = (struct rio_atmu_regs *)(priv->regs_win |
699 | + ((i == 0) ? RIO_ATMU_REGS_PORT1_OFFSET : | |
700 | RIO_ATMU_REGS_PORT2_OFFSET)); | |
701 | ||
702 | priv->maint_atmu_regs = priv->atmu_regs + 1; | |
e6a546fd MG |
703 | priv->inb_atmu_regs = (struct rio_inb_atmu_regs __iomem *) |
704 | (priv->regs_win + | |
705 | ((i == 0) ? RIO_INB_ATMU_REGS_PORT1_OFFSET : | |
706 | RIO_INB_ATMU_REGS_PORT2_OFFSET)); | |
707 | ||
59f99965 | 708 | |
abc3aeae LG |
709 | /* Set to receive any dist ID for serial RapidIO controller. */ |
710 | if (port->phy_type == RIO_PHY_SERIAL) | |
711 | out_be32((priv->regs_win | |
712 | + RIO_ISR_AACR + i*0x80), RIO_ISR_AACR_AA); | |
af84ca38 | 713 | |
abc3aeae LG |
714 | /* Configure maintenance transaction window */ |
715 | out_be32(&priv->maint_atmu_regs->rowbar, | |
716 | port->iores.start >> 12); | |
717 | out_be32(&priv->maint_atmu_regs->rowar, | |
718 | 0x80077000 | (ilog2(RIO_MAINT_WIN_SIZE) - 1)); | |
61b26917 | 719 | |
abc3aeae LG |
720 | priv->maint_win = ioremap(port->iores.start, |
721 | RIO_MAINT_WIN_SIZE); | |
2b0c28d7 | 722 | |
abc3aeae | 723 | rio_law_start = range_start; |
2b0c28d7 | 724 | |
abc3aeae | 725 | fsl_rio_setup_rmu(port, rmu_np[i]); |
e6a546fd | 726 | fsl_rio_inbound_mem_init(priv); |
2b0c28d7 | 727 | |
abc3aeae | 728 | dbell->mport[i] = port; |
9a0b0627 | 729 | pw->mport[i] = port; |
abc3aeae | 730 | |
dd64f4fe AB |
731 | if (rio_register_mport(port)) { |
732 | release_resource(&port->iores); | |
733 | kfree(priv); | |
734 | kfree(port); | |
735 | continue; | |
736 | } | |
abc3aeae LG |
737 | active_ports++; |
738 | } | |
739 | ||
740 | if (!active_ports) { | |
741 | rc = -ENOLINK; | |
742 | goto err; | |
743 | } | |
6ec4bedb | 744 | |
abc3aeae LG |
745 | fsl_rio_doorbell_init(dbell); |
746 | fsl_rio_port_write_init(pw); | |
ad1e9380 | 747 | |
cc2bb696 | 748 | return 0; |
ad1e9380 | 749 | err: |
abc3aeae | 750 | kfree(pw); |
a614db9a | 751 | pw = NULL; |
abc3aeae LG |
752 | err_pw: |
753 | kfree(dbell); | |
a614db9a | 754 | dbell = NULL; |
abc3aeae LG |
755 | err_dbell: |
756 | iounmap(rmu_regs_win); | |
a614db9a | 757 | rmu_regs_win = NULL; |
abc3aeae | 758 | err_rmu: |
6c75933c JL |
759 | kfree(ops); |
760 | err_ops: | |
abc3aeae | 761 | iounmap(rio_regs_win); |
a614db9a | 762 | rio_regs_win = NULL; |
abc3aeae | 763 | err_rio_regs: |
cc2bb696 | 764 | return rc; |
2b0c28d7 | 765 | } |
cc2bb696 ZW |
766 | |
767 | /* The probe function for RapidIO peer-to-peer network. | |
768 | */ | |
cad5cef6 | 769 | static int fsl_of_rio_rpn_probe(struct platform_device *dev) |
cc2bb696 | 770 | { |
cc2bb696 | 771 | printk(KERN_INFO "Setting up RapidIO peer-to-peer network %s\n", |
61c7a080 | 772 | dev->dev.of_node->full_name); |
cc2bb696 | 773 | |
2f809985 | 774 | return fsl_rio_setup(dev); |
cc2bb696 ZW |
775 | }; |
776 | ||
777 | static const struct of_device_id fsl_of_rio_rpn_ids[] = { | |
778 | { | |
abc3aeae | 779 | .compatible = "fsl,srio", |
cc2bb696 ZW |
780 | }, |
781 | {}, | |
782 | }; | |
783 | ||
00006124 | 784 | static struct platform_driver fsl_of_rio_rpn_driver = { |
4018294b GL |
785 | .driver = { |
786 | .name = "fsl-of-rio", | |
4018294b GL |
787 | .of_match_table = fsl_of_rio_rpn_ids, |
788 | }, | |
cc2bb696 ZW |
789 | .probe = fsl_of_rio_rpn_probe, |
790 | }; | |
791 | ||
792 | static __init int fsl_of_rio_rpn_init(void) | |
793 | { | |
00006124 | 794 | return platform_driver_register(&fsl_of_rio_rpn_driver); |
cc2bb696 ZW |
795 | } |
796 | ||
797 | subsys_initcall(fsl_of_rio_rpn_init); |