Print this page
XXXX introduce drv_sectohz
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/sun4u/io/px/px_hlib.c
+++ new/usr/src/uts/sun4u/io/px/px_hlib.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 */
25 25
26 26 #include <sys/types.h>
27 27 #include <sys/cmn_err.h>
28 28 #include <sys/vmsystm.h>
29 29 #include <sys/vmem.h>
30 30 #include <sys/machsystm.h> /* lddphys() */
31 31 #include <sys/iommutsb.h>
32 32 #include <px_obj.h>
33 33 #include <sys/hotplug/pci/pcie_hp.h>
34 34 #include "px_regs.h"
35 35 #include "oberon_regs.h"
36 36 #include "px_csr.h"
37 37 #include "px_lib4u.h"
38 38 #include "px_err.h"
39 39
40 40 /*
41 41 * Registers that need to be saved and restored during suspend/resume.
42 42 */
43 43
44 44 /*
45 45 * Registers in the PEC Module.
46 46 * LPU_RESET should be set to 0ull during resume
47 47 *
48 48 * This array is in reg,chip form. PX_CHIP_UNIDENTIFIED is for all chips
49 49 * or PX_CHIP_FIRE for Fire only, or PX_CHIP_OBERON for Oberon only.
50 50 */
51 51 static struct px_pec_regs {
52 52 uint64_t reg;
53 53 uint64_t chip;
54 54 } pec_config_state_regs[] = {
55 55 {PEC_CORE_AND_BLOCK_INTERRUPT_ENABLE, PX_CHIP_UNIDENTIFIED},
56 56 {ILU_ERROR_LOG_ENABLE, PX_CHIP_UNIDENTIFIED},
57 57 {ILU_INTERRUPT_ENABLE, PX_CHIP_UNIDENTIFIED},
58 58 {TLU_CONTROL, PX_CHIP_UNIDENTIFIED},
59 59 {TLU_OTHER_EVENT_LOG_ENABLE, PX_CHIP_UNIDENTIFIED},
60 60 {TLU_OTHER_EVENT_INTERRUPT_ENABLE, PX_CHIP_UNIDENTIFIED},
61 61 {TLU_DEVICE_CONTROL, PX_CHIP_UNIDENTIFIED},
62 62 {TLU_LINK_CONTROL, PX_CHIP_UNIDENTIFIED},
63 63 {TLU_UNCORRECTABLE_ERROR_LOG_ENABLE, PX_CHIP_UNIDENTIFIED},
64 64 {TLU_UNCORRECTABLE_ERROR_INTERRUPT_ENABLE, PX_CHIP_UNIDENTIFIED},
65 65 {TLU_CORRECTABLE_ERROR_LOG_ENABLE, PX_CHIP_UNIDENTIFIED},
66 66 {TLU_CORRECTABLE_ERROR_INTERRUPT_ENABLE, PX_CHIP_UNIDENTIFIED},
67 67 {DLU_LINK_LAYER_CONFIG, PX_CHIP_OBERON},
68 68 {DLU_FLOW_CONTROL_UPDATE_CONTROL, PX_CHIP_OBERON},
69 69 {DLU_TXLINK_REPLAY_TIMER_THRESHOLD, PX_CHIP_OBERON},
70 70 {LPU_LINK_LAYER_INTERRUPT_MASK, PX_CHIP_FIRE},
71 71 {LPU_PHY_INTERRUPT_MASK, PX_CHIP_FIRE},
72 72 {LPU_RECEIVE_PHY_INTERRUPT_MASK, PX_CHIP_FIRE},
73 73 {LPU_TRANSMIT_PHY_INTERRUPT_MASK, PX_CHIP_FIRE},
74 74 {LPU_GIGABLAZE_GLUE_INTERRUPT_MASK, PX_CHIP_FIRE},
75 75 {LPU_LTSSM_INTERRUPT_MASK, PX_CHIP_FIRE},
76 76 {LPU_RESET, PX_CHIP_FIRE},
77 77 {LPU_DEBUG_CONFIG, PX_CHIP_FIRE},
78 78 {LPU_INTERRUPT_MASK, PX_CHIP_FIRE},
79 79 {LPU_LINK_LAYER_CONFIG, PX_CHIP_FIRE},
80 80 {LPU_FLOW_CONTROL_UPDATE_CONTROL, PX_CHIP_FIRE},
81 81 {LPU_TXLINK_FREQUENT_NAK_LATENCY_TIMER_THRESHOLD, PX_CHIP_FIRE},
82 82 {LPU_TXLINK_REPLAY_TIMER_THRESHOLD, PX_CHIP_FIRE},
83 83 {LPU_REPLAY_BUFFER_MAX_ADDRESS, PX_CHIP_FIRE},
84 84 {LPU_TXLINK_RETRY_FIFO_POINTER, PX_CHIP_FIRE},
85 85 {LPU_LTSSM_CONFIG2, PX_CHIP_FIRE},
86 86 {LPU_LTSSM_CONFIG3, PX_CHIP_FIRE},
87 87 {LPU_LTSSM_CONFIG4, PX_CHIP_FIRE},
88 88 {LPU_LTSSM_CONFIG5, PX_CHIP_FIRE},
89 89 {DMC_CORE_AND_BLOCK_INTERRUPT_ENABLE, PX_CHIP_UNIDENTIFIED},
90 90 {DMC_DEBUG_SELECT_FOR_PORT_A, PX_CHIP_UNIDENTIFIED},
91 91 {DMC_DEBUG_SELECT_FOR_PORT_B, PX_CHIP_UNIDENTIFIED}
92 92 };
93 93
94 94 #define PEC_KEYS \
95 95 ((sizeof (pec_config_state_regs))/sizeof (struct px_pec_regs))
96 96
97 97 #define PEC_SIZE (PEC_KEYS * sizeof (uint64_t))
98 98
99 99 /*
100 100 * Registers for the MMU module.
101 101 * MMU_TTE_CACHE_INVALIDATE needs to be cleared. (-1ull)
102 102 */
103 103 static uint64_t mmu_config_state_regs[] = {
104 104 MMU_TSB_CONTROL,
105 105 MMU_CONTROL_AND_STATUS,
106 106 MMU_ERROR_LOG_ENABLE,
107 107 MMU_INTERRUPT_ENABLE
108 108 };
109 109 #define MMU_SIZE (sizeof (mmu_config_state_regs))
110 110 #define MMU_KEYS (MMU_SIZE / sizeof (uint64_t))
111 111
112 112 /*
113 113 * Registers for the IB Module
114 114 */
115 115 static uint64_t ib_config_state_regs[] = {
116 116 IMU_ERROR_LOG_ENABLE,
117 117 IMU_INTERRUPT_ENABLE
118 118 };
119 119 #define IB_SIZE (sizeof (ib_config_state_regs))
120 120 #define IB_KEYS (IB_SIZE / sizeof (uint64_t))
121 121 #define IB_MAP_SIZE (INTERRUPT_MAPPING_ENTRIES * sizeof (uint64_t))
122 122
123 123 /*
124 124 * Registers for the JBC module.
125 125 * JBC_ERROR_STATUS_CLEAR needs to be cleared. (-1ull)
126 126 */
127 127 static uint64_t jbc_config_state_regs[] = {
128 128 JBUS_PARITY_CONTROL,
129 129 JBC_FATAL_RESET_ENABLE,
130 130 JBC_CORE_AND_BLOCK_INTERRUPT_ENABLE,
131 131 JBC_ERROR_LOG_ENABLE,
132 132 JBC_INTERRUPT_ENABLE
133 133 };
134 134 #define JBC_SIZE (sizeof (jbc_config_state_regs))
135 135 #define JBC_KEYS (JBC_SIZE / sizeof (uint64_t))
136 136
137 137 /*
138 138 * Registers for the UBC module.
139 139 * UBC_ERROR_STATUS_CLEAR needs to be cleared. (-1ull)
140 140 */
141 141 static uint64_t ubc_config_state_regs[] = {
142 142 UBC_ERROR_LOG_ENABLE,
143 143 UBC_INTERRUPT_ENABLE
144 144 };
145 145 #define UBC_SIZE (sizeof (ubc_config_state_regs))
146 146 #define UBC_KEYS (UBC_SIZE / sizeof (uint64_t))
147 147
148 148 static uint64_t msiq_config_other_regs[] = {
149 149 ERR_COR_MAPPING,
150 150 ERR_NONFATAL_MAPPING,
151 151 ERR_FATAL_MAPPING,
152 152 PM_PME_MAPPING,
153 153 PME_TO_ACK_MAPPING,
154 154 MSI_32_BIT_ADDRESS,
155 155 MSI_64_BIT_ADDRESS
156 156 };
157 157 #define MSIQ_OTHER_SIZE (sizeof (msiq_config_other_regs))
158 158 #define MSIQ_OTHER_KEYS (MSIQ_OTHER_SIZE / sizeof (uint64_t))
159 159
160 160 #define MSIQ_STATE_SIZE (EVENT_QUEUE_STATE_ENTRIES * sizeof (uint64_t))
161 161 #define MSIQ_MAPPING_SIZE (MSI_MAPPING_ENTRIES * sizeof (uint64_t))
162 162
163 163 /* OPL tuning variables for link unstable issue */
164 164 int wait_perst = 5000000; /* step 9, default: 5s */
165 165 int wait_enable_port = 30000; /* step 11, default: 30ms */
166 166 int link_retry_count = 2; /* step 11, default: 2 */
167 167 int link_status_check = 400000; /* step 11, default: 400ms */
168 168
169 169 static uint64_t msiq_suspend(devhandle_t dev_hdl, pxu_t *pxu_p);
170 170 static void msiq_resume(devhandle_t dev_hdl, pxu_t *pxu_p);
171 171 static void jbc_init(caddr_t xbc_csr_base, pxu_t *pxu_p);
172 172 static void ubc_init(caddr_t xbc_csr_base, pxu_t *pxu_p);
173 173
174 174 extern int px_acknak_timer_table[LINK_MAX_PKT_ARR_SIZE][LINK_WIDTH_ARR_SIZE];
175 175 extern int px_replay_timer_table[LINK_MAX_PKT_ARR_SIZE][LINK_WIDTH_ARR_SIZE];
176 176
177 177 /*
178 178 * Initialize the bus, but do not enable interrupts.
179 179 */
180 180 /* ARGSUSED */
181 181 void
182 182 hvio_cb_init(caddr_t xbc_csr_base, pxu_t *pxu_p)
183 183 {
184 184 switch (PX_CHIP_TYPE(pxu_p)) {
185 185 case PX_CHIP_OBERON:
186 186 ubc_init(xbc_csr_base, pxu_p);
187 187 break;
188 188 case PX_CHIP_FIRE:
189 189 jbc_init(xbc_csr_base, pxu_p);
190 190 break;
191 191 default:
192 192 DBG(DBG_CB, NULL, "hvio_cb_init - unknown chip type: 0x%x\n",
193 193 PX_CHIP_TYPE(pxu_p));
194 194 break;
195 195 }
196 196 }
197 197
198 198 /*
199 199 * Initialize the JBC module, but do not enable interrupts.
200 200 */
201 201 /* ARGSUSED */
202 202 static void
203 203 jbc_init(caddr_t xbc_csr_base, pxu_t *pxu_p)
204 204 {
205 205 uint64_t val;
206 206
207 207 /* Check if we need to enable inverted parity */
208 208 val = (1ULL << JBUS_PARITY_CONTROL_P_EN);
209 209 CSR_XS(xbc_csr_base, JBUS_PARITY_CONTROL, val);
210 210 DBG(DBG_CB, NULL, "jbc_init, JBUS_PARITY_CONTROL: 0x%llx\n",
211 211 CSR_XR(xbc_csr_base, JBUS_PARITY_CONTROL));
212 212
213 213 val = (1 << JBC_FATAL_RESET_ENABLE_SPARE_P_INT_EN) |
214 214 (1 << JBC_FATAL_RESET_ENABLE_MB_PEA_P_INT_EN) |
215 215 (1 << JBC_FATAL_RESET_ENABLE_CPE_P_INT_EN) |
216 216 (1 << JBC_FATAL_RESET_ENABLE_APE_P_INT_EN) |
217 217 (1 << JBC_FATAL_RESET_ENABLE_PIO_CPE_INT_EN) |
218 218 (1 << JBC_FATAL_RESET_ENABLE_JTCEEW_P_INT_EN) |
219 219 (1 << JBC_FATAL_RESET_ENABLE_JTCEEI_P_INT_EN) |
220 220 (1 << JBC_FATAL_RESET_ENABLE_JTCEER_P_INT_EN);
221 221 CSR_XS(xbc_csr_base, JBC_FATAL_RESET_ENABLE, val);
222 222 DBG(DBG_CB, NULL, "jbc_init, JBC_FATAL_RESET_ENABLE: 0x%llx\n",
223 223 CSR_XR(xbc_csr_base, JBC_FATAL_RESET_ENABLE));
224 224
225 225 /*
226 226 * Enable merge, jbc and dmc interrupts.
227 227 */
228 228 CSR_XS(xbc_csr_base, JBC_CORE_AND_BLOCK_INTERRUPT_ENABLE, -1ull);
229 229 DBG(DBG_CB, NULL,
230 230 "jbc_init, JBC_CORE_AND_BLOCK_INTERRUPT_ENABLE: 0x%llx\n",
231 231 CSR_XR(xbc_csr_base, JBC_CORE_AND_BLOCK_INTERRUPT_ENABLE));
232 232
233 233 /*
234 234 * CSR_V JBC's interrupt regs (log, enable, status, clear)
235 235 */
236 236 DBG(DBG_CB, NULL, "jbc_init, JBC_ERROR_LOG_ENABLE: 0x%llx\n",
237 237 CSR_XR(xbc_csr_base, JBC_ERROR_LOG_ENABLE));
238 238
239 239 DBG(DBG_CB, NULL, "jbc_init, JBC_INTERRUPT_ENABLE: 0x%llx\n",
240 240 CSR_XR(xbc_csr_base, JBC_INTERRUPT_ENABLE));
241 241
242 242 DBG(DBG_CB, NULL, "jbc_init, JBC_INTERRUPT_STATUS: 0x%llx\n",
243 243 CSR_XR(xbc_csr_base, JBC_INTERRUPT_STATUS));
244 244
245 245 DBG(DBG_CB, NULL, "jbc_init, JBC_ERROR_STATUS_CLEAR: 0x%llx\n",
246 246 CSR_XR(xbc_csr_base, JBC_ERROR_STATUS_CLEAR));
247 247 }
248 248
249 249 /*
250 250 * Initialize the UBC module, but do not enable interrupts.
251 251 */
252 252 /* ARGSUSED */
253 253 static void
254 254 ubc_init(caddr_t xbc_csr_base, pxu_t *pxu_p)
255 255 {
256 256 /*
257 257 * Enable Uranus bus error log bits.
258 258 */
259 259 CSR_XS(xbc_csr_base, UBC_ERROR_LOG_ENABLE, -1ull);
260 260 DBG(DBG_CB, NULL, "ubc_init, UBC_ERROR_LOG_ENABLE: 0x%llx\n",
261 261 CSR_XR(xbc_csr_base, UBC_ERROR_LOG_ENABLE));
262 262
263 263 /*
264 264 * Clear Uranus bus errors.
265 265 */
266 266 CSR_XS(xbc_csr_base, UBC_ERROR_STATUS_CLEAR, -1ull);
267 267 DBG(DBG_CB, NULL, "ubc_init, UBC_ERROR_STATUS_CLEAR: 0x%llx\n",
268 268 CSR_XR(xbc_csr_base, UBC_ERROR_STATUS_CLEAR));
269 269
270 270 /*
271 271 * CSR_V UBC's interrupt regs (log, enable, status, clear)
272 272 */
273 273 DBG(DBG_CB, NULL, "ubc_init, UBC_ERROR_LOG_ENABLE: 0x%llx\n",
274 274 CSR_XR(xbc_csr_base, UBC_ERROR_LOG_ENABLE));
275 275
276 276 DBG(DBG_CB, NULL, "ubc_init, UBC_INTERRUPT_ENABLE: 0x%llx\n",
277 277 CSR_XR(xbc_csr_base, UBC_INTERRUPT_ENABLE));
278 278
279 279 DBG(DBG_CB, NULL, "ubc_init, UBC_INTERRUPT_STATUS: 0x%llx\n",
280 280 CSR_XR(xbc_csr_base, UBC_INTERRUPT_STATUS));
281 281
282 282 DBG(DBG_CB, NULL, "ubc_init, UBC_ERROR_STATUS_CLEAR: 0x%llx\n",
283 283 CSR_XR(xbc_csr_base, UBC_ERROR_STATUS_CLEAR));
284 284 }
285 285
286 286 /*
287 287 * Initialize the module, but do not enable interrupts.
288 288 */
289 289 /* ARGSUSED */
290 290 void
291 291 hvio_ib_init(caddr_t csr_base, pxu_t *pxu_p)
292 292 {
293 293 /*
294 294 * CSR_V IB's interrupt regs (log, enable, status, clear)
295 295 */
296 296 DBG(DBG_IB, NULL, "hvio_ib_init - IMU_ERROR_LOG_ENABLE: 0x%llx\n",
297 297 CSR_XR(csr_base, IMU_ERROR_LOG_ENABLE));
298 298
299 299 DBG(DBG_IB, NULL, "hvio_ib_init - IMU_INTERRUPT_ENABLE: 0x%llx\n",
300 300 CSR_XR(csr_base, IMU_INTERRUPT_ENABLE));
301 301
302 302 DBG(DBG_IB, NULL, "hvio_ib_init - IMU_INTERRUPT_STATUS: 0x%llx\n",
303 303 CSR_XR(csr_base, IMU_INTERRUPT_STATUS));
304 304
305 305 DBG(DBG_IB, NULL, "hvio_ib_init - IMU_ERROR_STATUS_CLEAR: 0x%llx\n",
306 306 CSR_XR(csr_base, IMU_ERROR_STATUS_CLEAR));
307 307 }
308 308
309 309 /*
310 310 * Initialize the module, but do not enable interrupts.
311 311 */
312 312 /* ARGSUSED */
313 313 static void
314 314 ilu_init(caddr_t csr_base, pxu_t *pxu_p)
315 315 {
316 316 /*
317 317 * CSR_V ILU's interrupt regs (log, enable, status, clear)
318 318 */
319 319 DBG(DBG_ILU, NULL, "ilu_init - ILU_ERROR_LOG_ENABLE: 0x%llx\n",
320 320 CSR_XR(csr_base, ILU_ERROR_LOG_ENABLE));
321 321
322 322 DBG(DBG_ILU, NULL, "ilu_init - ILU_INTERRUPT_ENABLE: 0x%llx\n",
323 323 CSR_XR(csr_base, ILU_INTERRUPT_ENABLE));
324 324
325 325 DBG(DBG_ILU, NULL, "ilu_init - ILU_INTERRUPT_STATUS: 0x%llx\n",
326 326 CSR_XR(csr_base, ILU_INTERRUPT_STATUS));
327 327
328 328 DBG(DBG_ILU, NULL, "ilu_init - ILU_ERROR_STATUS_CLEAR: 0x%llx\n",
329 329 CSR_XR(csr_base, ILU_ERROR_STATUS_CLEAR));
330 330 }
331 331
332 332 /*
333 333 * Initialize the module, but do not enable interrupts.
334 334 */
335 335 /* ARGSUSED */
336 336 static void
337 337 tlu_init(caddr_t csr_base, pxu_t *pxu_p)
338 338 {
339 339 uint64_t val;
340 340
341 341 /*
342 342 * CSR_V TLU_CONTROL Expect OBP ???
343 343 */
344 344
345 345 /*
346 346 * L0s entry default timer value - 7.0 us
347 347 * Completion timeout select default value - 67.1 ms and
348 348 * OBP will set this value.
349 349 *
350 350 * Configuration - Bit 0 should always be 0 for upstream port.
351 351 * Bit 1 is clock - how is this related to the clock bit in TLU
352 352 * Link Control register? Both are hardware dependent and likely
353 353 * set by OBP.
354 354 *
355 355 * NOTE: Do not set the NPWR_EN bit. The desired value of this bit
356 356 * will be set by OBP.
357 357 */
358 358 val = CSR_XR(csr_base, TLU_CONTROL);
359 359 val |= (TLU_CONTROL_L0S_TIM_DEFAULT << TLU_CONTROL_L0S_TIM) |
360 360 TLU_CONTROL_CONFIG_DEFAULT;
361 361
362 362 /*
363 363 * For Oberon, NPWR_EN is set to 0 to prevent PIO reads from blocking
364 364 * behind non-posted PIO writes. This blocking could cause a master or
365 365 * slave timeout on the host bus if multiple serialized PIOs were to
366 366 * suffer Completion Timeouts because the CTO delays for each PIO ahead
367 367 * of the read would accumulate. Since the Olympus processor can have
368 368 * only 1 PIO outstanding, there is no possibility of PIO accesses from
369 369 * a given CPU to a given device being re-ordered by the PCIe fabric;
370 370 * therefore turning off serialization should be safe from a PCIe
371 371 * ordering perspective.
372 372 */
373 373 if (PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON)
374 374 val &= ~(1ull << TLU_CONTROL_NPWR_EN);
375 375
376 376 /*
377 377 * Set Detect.Quiet. This will disable automatic link
378 378 * re-training, if the link goes down e.g. power management
379 379 * turns off power to the downstream device. This will enable
380 380 * Fire to go to Drain state, after link down. The drain state
381 381 * forces a reset to the FC state machine, which is required for
382 382 * proper link re-training.
383 383 */
384 384 val |= (1ull << TLU_REMAIN_DETECT_QUIET);
385 385 CSR_XS(csr_base, TLU_CONTROL, val);
386 386 DBG(DBG_TLU, NULL, "tlu_init - TLU_CONTROL: 0x%llx\n",
387 387 CSR_XR(csr_base, TLU_CONTROL));
388 388
389 389 /*
390 390 * CSR_V TLU_STATUS Expect HW 0x4
391 391 */
392 392
393 393 /*
394 394 * Only bit [7:0] are currently defined. Bits [2:0]
395 395 * are the state, which should likely be in state active,
396 396 * 100b. Bit three is 'recovery', which is not understood.
397 397 * All other bits are reserved.
398 398 */
399 399 DBG(DBG_TLU, NULL, "tlu_init - TLU_STATUS: 0x%llx\n",
400 400 CSR_XR(csr_base, TLU_STATUS));
401 401
402 402 /*
403 403 * CSR_V TLU_PME_TURN_OFF_GENERATE Expect HW 0x0
404 404 */
405 405 DBG(DBG_TLU, NULL, "tlu_init - TLU_PME_TURN_OFF_GENERATE: 0x%llx\n",
406 406 CSR_XR(csr_base, TLU_PME_TURN_OFF_GENERATE));
407 407
408 408 /*
409 409 * CSR_V TLU_INGRESS_CREDITS_INITIAL Expect HW 0x10000200C0
410 410 */
411 411
412 412 /*
413 413 * Ingress credits initial register. Bits [39:32] should be
414 414 * 0x10, bits [19:12] should be 0x20, and bits [11:0] should
415 415 * be 0xC0. These are the reset values, and should be set by
416 416 * HW.
417 417 */
418 418 DBG(DBG_TLU, NULL, "tlu_init - TLU_INGRESS_CREDITS_INITIAL: 0x%llx\n",
419 419 CSR_XR(csr_base, TLU_INGRESS_CREDITS_INITIAL));
420 420
421 421 /*
422 422 * CSR_V TLU_DIAGNOSTIC Expect HW 0x0
423 423 */
424 424
425 425 /*
426 426 * Diagnostic register - always zero unless we are debugging.
427 427 */
428 428 DBG(DBG_TLU, NULL, "tlu_init - TLU_DIAGNOSTIC: 0x%llx\n",
429 429 CSR_XR(csr_base, TLU_DIAGNOSTIC));
430 430
431 431 /*
432 432 * CSR_V TLU_EGRESS_CREDITS_CONSUMED Expect HW 0x0
433 433 */
434 434 DBG(DBG_TLU, NULL, "tlu_init - TLU_EGRESS_CREDITS_CONSUMED: 0x%llx\n",
435 435 CSR_XR(csr_base, TLU_EGRESS_CREDITS_CONSUMED));
436 436
437 437 /*
438 438 * CSR_V TLU_EGRESS_CREDIT_LIMIT Expect HW 0x0
439 439 */
440 440 DBG(DBG_TLU, NULL, "tlu_init - TLU_EGRESS_CREDIT_LIMIT: 0x%llx\n",
441 441 CSR_XR(csr_base, TLU_EGRESS_CREDIT_LIMIT));
442 442
443 443 /*
444 444 * CSR_V TLU_EGRESS_RETRY_BUFFER Expect HW 0x0
445 445 */
446 446 DBG(DBG_TLU, NULL, "tlu_init - TLU_EGRESS_RETRY_BUFFER: 0x%llx\n",
447 447 CSR_XR(csr_base, TLU_EGRESS_RETRY_BUFFER));
448 448
449 449 /*
450 450 * CSR_V TLU_INGRESS_CREDITS_ALLOCATED Expected HW 0x0
451 451 */
452 452 DBG(DBG_TLU, NULL,
453 453 "tlu_init - TLU_INGRESS_CREDITS_ALLOCATED: 0x%llx\n",
454 454 CSR_XR(csr_base, TLU_INGRESS_CREDITS_ALLOCATED));
455 455
456 456 /*
457 457 * CSR_V TLU_INGRESS_CREDITS_RECEIVED Expected HW 0x0
458 458 */
459 459 DBG(DBG_TLU, NULL,
460 460 "tlu_init - TLU_INGRESS_CREDITS_RECEIVED: 0x%llx\n",
461 461 CSR_XR(csr_base, TLU_INGRESS_CREDITS_RECEIVED));
462 462
463 463 /*
464 464 * CSR_V TLU's interrupt regs (log, enable, status, clear)
465 465 */
466 466 DBG(DBG_TLU, NULL,
467 467 "tlu_init - TLU_OTHER_EVENT_LOG_ENABLE: 0x%llx\n",
468 468 CSR_XR(csr_base, TLU_OTHER_EVENT_LOG_ENABLE));
469 469
470 470 DBG(DBG_TLU, NULL,
471 471 "tlu_init - TLU_OTHER_EVENT_INTERRUPT_ENABLE: 0x%llx\n",
472 472 CSR_XR(csr_base, TLU_OTHER_EVENT_INTERRUPT_ENABLE));
473 473
474 474 DBG(DBG_TLU, NULL,
475 475 "tlu_init - TLU_OTHER_EVENT_INTERRUPT_STATUS: 0x%llx\n",
476 476 CSR_XR(csr_base, TLU_OTHER_EVENT_INTERRUPT_STATUS));
477 477
478 478 DBG(DBG_TLU, NULL,
479 479 "tlu_init - TLU_OTHER_EVENT_STATUS_CLEAR: 0x%llx\n",
480 480 CSR_XR(csr_base, TLU_OTHER_EVENT_STATUS_CLEAR));
481 481
482 482 /*
483 483 * CSR_V TLU_RECEIVE_OTHER_EVENT_HEADER1_LOG Expect HW 0x0
484 484 */
485 485 DBG(DBG_TLU, NULL,
486 486 "tlu_init - TLU_RECEIVE_OTHER_EVENT_HEADER1_LOG: 0x%llx\n",
487 487 CSR_XR(csr_base, TLU_RECEIVE_OTHER_EVENT_HEADER1_LOG));
488 488
489 489 /*
490 490 * CSR_V TLU_RECEIVE_OTHER_EVENT_HEADER2_LOG Expect HW 0x0
491 491 */
492 492 DBG(DBG_TLU, NULL,
493 493 "tlu_init - TLU_RECEIVE_OTHER_EVENT_HEADER2_LOG: 0x%llx\n",
494 494 CSR_XR(csr_base, TLU_RECEIVE_OTHER_EVENT_HEADER2_LOG));
495 495
496 496 /*
497 497 * CSR_V TLU_TRANSMIT_OTHER_EVENT_HEADER1_LOG Expect HW 0x0
498 498 */
499 499 DBG(DBG_TLU, NULL,
500 500 "tlu_init - TLU_TRANSMIT_OTHER_EVENT_HEADER1_LOG: 0x%llx\n",
501 501 CSR_XR(csr_base, TLU_TRANSMIT_OTHER_EVENT_HEADER1_LOG));
502 502
503 503 /*
504 504 * CSR_V TLU_TRANSMIT_OTHER_EVENT_HEADER2_LOG Expect HW 0x0
505 505 */
506 506 DBG(DBG_TLU, NULL,
507 507 "tlu_init - TLU_TRANSMIT_OTHER_EVENT_HEADER2_LOG: 0x%llx\n",
508 508 CSR_XR(csr_base, TLU_TRANSMIT_OTHER_EVENT_HEADER2_LOG));
509 509
510 510 /*
511 511 * CSR_V TLU_PERFORMANCE_COUNTER_SELECT Expect HW 0x0
512 512 */
513 513 DBG(DBG_TLU, NULL,
514 514 "tlu_init - TLU_PERFORMANCE_COUNTER_SELECT: 0x%llx\n",
515 515 CSR_XR(csr_base, TLU_PERFORMANCE_COUNTER_SELECT));
516 516
517 517 /*
518 518 * CSR_V TLU_PERFORMANCE_COUNTER_ZERO Expect HW 0x0
519 519 */
520 520 DBG(DBG_TLU, NULL,
521 521 "tlu_init - TLU_PERFORMANCE_COUNTER_ZERO: 0x%llx\n",
522 522 CSR_XR(csr_base, TLU_PERFORMANCE_COUNTER_ZERO));
523 523
524 524 /*
525 525 * CSR_V TLU_PERFORMANCE_COUNTER_ONE Expect HW 0x0
526 526 */
527 527 DBG(DBG_TLU, NULL, "tlu_init - TLU_PERFORMANCE_COUNTER_ONE: 0x%llx\n",
528 528 CSR_XR(csr_base, TLU_PERFORMANCE_COUNTER_ONE));
529 529
530 530 /*
531 531 * CSR_V TLU_PERFORMANCE_COUNTER_TWO Expect HW 0x0
532 532 */
533 533 DBG(DBG_TLU, NULL, "tlu_init - TLU_PERFORMANCE_COUNTER_TWO: 0x%llx\n",
534 534 CSR_XR(csr_base, TLU_PERFORMANCE_COUNTER_TWO));
535 535
536 536 /*
537 537 * CSR_V TLU_DEBUG_SELECT_A Expect HW 0x0
538 538 */
539 539
540 540 DBG(DBG_TLU, NULL, "tlu_init - TLU_DEBUG_SELECT_A: 0x%llx\n",
541 541 CSR_XR(csr_base, TLU_DEBUG_SELECT_A));
542 542
543 543 /*
544 544 * CSR_V TLU_DEBUG_SELECT_B Expect HW 0x0
545 545 */
546 546 DBG(DBG_TLU, NULL, "tlu_init - TLU_DEBUG_SELECT_B: 0x%llx\n",
547 547 CSR_XR(csr_base, TLU_DEBUG_SELECT_B));
548 548
549 549 /*
550 550 * CSR_V TLU_DEVICE_CAPABILITIES Expect HW 0xFC2
551 551 */
552 552 DBG(DBG_TLU, NULL, "tlu_init - TLU_DEVICE_CAPABILITIES: 0x%llx\n",
553 553 CSR_XR(csr_base, TLU_DEVICE_CAPABILITIES));
554 554
555 555 /*
556 556 * CSR_V TLU_DEVICE_CONTROL Expect HW 0x0
557 557 */
558 558
559 559 /*
560 560 * Bits [14:12] are the Max Read Request Size, which is always 64
561 561 * bytes which is 000b. Bits [7:5] are Max Payload Size, which
562 562 * start at 128 bytes which is 000b. This may be revisited if
563 563 * init_child finds greater values.
564 564 */
565 565 val = 0x0ull;
566 566 CSR_XS(csr_base, TLU_DEVICE_CONTROL, val);
567 567 DBG(DBG_TLU, NULL, "tlu_init - TLU_DEVICE_CONTROL: 0x%llx\n",
568 568 CSR_XR(csr_base, TLU_DEVICE_CONTROL));
569 569
570 570 /*
571 571 * CSR_V TLU_DEVICE_STATUS Expect HW 0x0
572 572 */
573 573 DBG(DBG_TLU, NULL, "tlu_init - TLU_DEVICE_STATUS: 0x%llx\n",
574 574 CSR_XR(csr_base, TLU_DEVICE_STATUS));
575 575
576 576 /*
577 577 * CSR_V TLU_LINK_CAPABILITIES Expect HW 0x15C81
578 578 */
579 579 DBG(DBG_TLU, NULL, "tlu_init - TLU_LINK_CAPABILITIES: 0x%llx\n",
580 580 CSR_XR(csr_base, TLU_LINK_CAPABILITIES));
581 581
582 582 /*
583 583 * CSR_V TLU_LINK_CONTROL Expect OBP 0x40
584 584 */
585 585
586 586 /*
587 587 * The CLOCK bit should be set by OBP if the hardware dictates,
588 588 * and if it is set then ASPM should be used since then L0s exit
589 589 * latency should be lower than L1 exit latency.
590 590 *
591 591 * Note that we will not enable power management during bringup
592 592 * since it has not been test and is creating some problems in
593 593 * simulation.
594 594 */
595 595 val = (1ull << TLU_LINK_CONTROL_CLOCK);
596 596
597 597 CSR_XS(csr_base, TLU_LINK_CONTROL, val);
598 598 DBG(DBG_TLU, NULL, "tlu_init - TLU_LINK_CONTROL: 0x%llx\n",
599 599 CSR_XR(csr_base, TLU_LINK_CONTROL));
600 600
601 601 /*
602 602 * CSR_V TLU_LINK_STATUS Expect OBP 0x1011
603 603 */
604 604
605 605 /*
606 606 * Not sure if HW or OBP will be setting this read only
607 607 * register. Bit 12 is Clock, and it should always be 1
608 608 * signifying that the component uses the same physical
609 609 * clock as the platform. Bits [9:4] are for the width,
610 610 * with the expected value above signifying a x1 width.
611 611 * Bits [3:0] are the speed, with 1b signifying 2.5 Gb/s,
612 612 * the only speed as yet supported by the PCI-E spec.
613 613 */
614 614 DBG(DBG_TLU, NULL, "tlu_init - TLU_LINK_STATUS: 0x%llx\n",
615 615 CSR_XR(csr_base, TLU_LINK_STATUS));
616 616
617 617 /*
618 618 * CSR_V TLU_SLOT_CAPABILITIES Expect OBP ???
619 619 */
620 620
621 621 /*
622 622 * Power Limits for the slots. Will be platform
623 623 * dependent, and OBP will need to set after consulting
624 624 * with the HW guys.
625 625 *
626 626 * Bits [16:15] are power limit scale, which most likely
627 627 * will be 0b signifying 1x. Bits [14:7] are the Set
628 628 * Power Limit Value, which is a number which is multiplied
629 629 * by the power limit scale to get the actual power limit.
630 630 */
631 631 DBG(DBG_TLU, NULL, "tlu_init - TLU_SLOT_CAPABILITIES: 0x%llx\n",
632 632 CSR_XR(csr_base, TLU_SLOT_CAPABILITIES));
633 633
634 634 /*
635 635 * CSR_V TLU_UNCORRECTABLE_ERROR_LOG_ENABLE Expect Kernel 0x17F011
636 636 */
637 637 DBG(DBG_TLU, NULL,
638 638 "tlu_init - TLU_UNCORRECTABLE_ERROR_LOG_ENABLE: 0x%llx\n",
639 639 CSR_XR(csr_base, TLU_UNCORRECTABLE_ERROR_LOG_ENABLE));
640 640
641 641 /*
642 642 * CSR_V TLU_UNCORRECTABLE_ERROR_INTERRUPT_ENABLE Expect
643 643 * Kernel 0x17F0110017F011
644 644 */
645 645 DBG(DBG_TLU, NULL,
646 646 "tlu_init - TLU_UNCORRECTABLE_ERROR_INTERRUPT_ENABLE: 0x%llx\n",
647 647 CSR_XR(csr_base, TLU_UNCORRECTABLE_ERROR_INTERRUPT_ENABLE));
648 648
649 649 /*
650 650 * CSR_V TLU_UNCORRECTABLE_ERROR_INTERRUPT_STATUS Expect HW 0x0
651 651 */
652 652 DBG(DBG_TLU, NULL,
653 653 "tlu_init - TLU_UNCORRECTABLE_ERROR_INTERRUPT_STATUS: 0x%llx\n",
654 654 CSR_XR(csr_base, TLU_UNCORRECTABLE_ERROR_INTERRUPT_STATUS));
655 655
656 656 /*
657 657 * CSR_V TLU_UNCORRECTABLE_ERROR_STATUS_CLEAR Expect HW 0x0
658 658 */
659 659 DBG(DBG_TLU, NULL,
660 660 "tlu_init - TLU_UNCORRECTABLE_ERROR_STATUS_CLEAR: 0x%llx\n",
661 661 CSR_XR(csr_base, TLU_UNCORRECTABLE_ERROR_STATUS_CLEAR));
662 662
663 663 /*
664 664 * CSR_V TLU_RECEIVE_UNCORRECTABLE_ERROR_HEADER1_LOG HW 0x0
665 665 */
666 666 DBG(DBG_TLU, NULL,
667 667 "tlu_init - TLU_RECEIVE_UNCORRECTABLE_ERROR_HEADER1_LOG: 0x%llx\n",
668 668 CSR_XR(csr_base, TLU_RECEIVE_UNCORRECTABLE_ERROR_HEADER1_LOG));
669 669
670 670 /*
671 671 * CSR_V TLU_RECEIVE_UNCORRECTABLE_ERROR_HEADER2_LOG HW 0x0
672 672 */
673 673 DBG(DBG_TLU, NULL,
674 674 "tlu_init - TLU_RECEIVE_UNCORRECTABLE_ERROR_HEADER2_LOG: 0x%llx\n",
675 675 CSR_XR(csr_base, TLU_RECEIVE_UNCORRECTABLE_ERROR_HEADER2_LOG));
676 676
677 677 /*
678 678 * CSR_V TLU_TRANSMIT_UNCORRECTABLE_ERROR_HEADER1_LOG HW 0x0
679 679 */
680 680 DBG(DBG_TLU, NULL,
681 681 "tlu_init - TLU_TRANSMIT_UNCORRECTABLE_ERROR_HEADER1_LOG: 0x%llx\n",
682 682 CSR_XR(csr_base, TLU_TRANSMIT_UNCORRECTABLE_ERROR_HEADER1_LOG));
683 683
684 684 /*
685 685 * CSR_V TLU_TRANSMIT_UNCORRECTABLE_ERROR_HEADER2_LOG HW 0x0
686 686 */
687 687 DBG(DBG_TLU, NULL,
688 688 "tlu_init - TLU_TRANSMIT_UNCORRECTABLE_ERROR_HEADER2_LOG: 0x%llx\n",
689 689 CSR_XR(csr_base, TLU_TRANSMIT_UNCORRECTABLE_ERROR_HEADER2_LOG));
690 690
691 691
692 692 /*
693 693 * CSR_V TLU's CE interrupt regs (log, enable, status, clear)
694 694 * Plus header logs
695 695 */
696 696
697 697 /*
698 698 * CSR_V TLU_CORRECTABLE_ERROR_LOG_ENABLE Expect Kernel 0x11C1
699 699 */
700 700 DBG(DBG_TLU, NULL,
701 701 "tlu_init - TLU_CORRECTABLE_ERROR_LOG_ENABLE: 0x%llx\n",
702 702 CSR_XR(csr_base, TLU_CORRECTABLE_ERROR_LOG_ENABLE));
703 703
704 704 /*
705 705 * CSR_V TLU_CORRECTABLE_ERROR_INTERRUPT_ENABLE Kernel 0x11C1000011C1
706 706 */
707 707 DBG(DBG_TLU, NULL,
708 708 "tlu_init - TLU_CORRECTABLE_ERROR_INTERRUPT_ENABLE: 0x%llx\n",
709 709 CSR_XR(csr_base, TLU_CORRECTABLE_ERROR_INTERRUPT_ENABLE));
710 710
711 711 /*
712 712 * CSR_V TLU_CORRECTABLE_ERROR_INTERRUPT_STATUS Expect HW 0x0
713 713 */
714 714 DBG(DBG_TLU, NULL,
715 715 "tlu_init - TLU_CORRECTABLE_ERROR_INTERRUPT_STATUS: 0x%llx\n",
716 716 CSR_XR(csr_base, TLU_CORRECTABLE_ERROR_INTERRUPT_STATUS));
717 717
718 718 /*
719 719 * CSR_V TLU_CORRECTABLE_ERROR_STATUS_CLEAR Expect HW 0x0
720 720 */
721 721 DBG(DBG_TLU, NULL,
722 722 "tlu_init - TLU_CORRECTABLE_ERROR_STATUS_CLEAR: 0x%llx\n",
723 723 CSR_XR(csr_base, TLU_CORRECTABLE_ERROR_STATUS_CLEAR));
724 724 }
725 725
726 726 /* ARGSUSED */
727 727 static void
728 728 lpu_init(caddr_t csr_base, pxu_t *pxu_p)
729 729 {
730 730 /* Variables used to set the ACKNAK Latency Timer and Replay Timer */
731 731 int link_width, max_payload;
732 732
733 733 uint64_t val;
734 734
735 735 /*
736 736 * Get the Link Width. See table above LINK_WIDTH_ARR_SIZE #define
737 737 * Only Link Widths of x1, x4, and x8 are supported.
738 738 * If any width is reported other than x8, set default to x8.
739 739 */
740 740 link_width = CSR_FR(csr_base, TLU_LINK_STATUS, WIDTH);
741 741 DBG(DBG_LPU, NULL, "lpu_init - Link Width: x%d\n", link_width);
742 742
743 743 /*
744 744 * Convert link_width to match timer array configuration.
745 745 */
746 746 switch (link_width) {
747 747 case 1:
748 748 link_width = 0;
749 749 break;
750 750 case 4:
751 751 link_width = 1;
752 752 break;
753 753 case 8:
754 754 link_width = 2;
755 755 break;
756 756 case 16:
757 757 link_width = 3;
758 758 break;
759 759 default:
760 760 link_width = 0;
761 761 }
762 762
763 763 /*
764 764 * Get the Max Payload Size.
765 765 * See table above LINK_MAX_PKT_ARR_SIZE #define
766 766 */
767 767 max_payload = ((CSR_FR(csr_base, TLU_CONTROL, CONFIG) &
768 768 TLU_CONTROL_MPS_MASK) >> TLU_CONTROL_MPS_SHIFT);
769 769
770 770 DBG(DBG_LPU, NULL, "lpu_init - May Payload: %d\n",
771 771 (0x80 << max_payload));
772 772
773 773 /* Make sure the packet size is not greater than 4096 */
774 774 max_payload = (max_payload >= LINK_MAX_PKT_ARR_SIZE) ?
775 775 (LINK_MAX_PKT_ARR_SIZE - 1) : max_payload;
776 776
777 777 /*
778 778 * CSR_V LPU_ID Expect HW 0x0
779 779 */
780 780
781 781 /*
782 782 * This register has link id, phy id and gigablaze id.
783 783 * Should be set by HW.
784 784 */
785 785 DBG(DBG_LPU, NULL, "lpu_init - LPU_ID: 0x%llx\n",
786 786 CSR_XR(csr_base, LPU_ID));
787 787
788 788 /*
789 789 * CSR_V LPU_RESET Expect Kernel 0x0
790 790 */
791 791
792 792 /*
793 793 * No reason to have any reset bits high until an error is
794 794 * detected on the link.
795 795 */
796 796 val = 0ull;
797 797 CSR_XS(csr_base, LPU_RESET, val);
798 798 DBG(DBG_LPU, NULL, "lpu_init - LPU_RESET: 0x%llx\n",
799 799 CSR_XR(csr_base, LPU_RESET));
800 800
801 801 /*
802 802 * CSR_V LPU_DEBUG_STATUS Expect HW 0x0
803 803 */
804 804
805 805 /*
806 806 * Bits [15:8] are Debug B, and bit [7:0] are Debug A.
807 807 * They are read-only. What do the 8 bits mean, and
808 808 * how do they get set if they are read only?
809 809 */
810 810 DBG(DBG_LPU, NULL, "lpu_init - LPU_DEBUG_STATUS: 0x%llx\n",
811 811 CSR_XR(csr_base, LPU_DEBUG_STATUS));
812 812
813 813 /*
814 814 * CSR_V LPU_DEBUG_CONFIG Expect Kernel 0x0
815 815 */
816 816 DBG(DBG_LPU, NULL, "lpu_init - LPU_DEBUG_CONFIG: 0x%llx\n",
817 817 CSR_XR(csr_base, LPU_DEBUG_CONFIG));
818 818
819 819 /*
820 820 * CSR_V LPU_LTSSM_CONTROL Expect HW 0x0
821 821 */
822 822 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_CONTROL: 0x%llx\n",
823 823 CSR_XR(csr_base, LPU_LTSSM_CONTROL));
824 824
825 825 /*
826 826 * CSR_V LPU_LINK_STATUS Expect HW 0x101
827 827 */
828 828
829 829 /*
830 830 * This register has bits [9:4] for link width, and the
831 831 * default 0x10, means a width of x16. The problem is
832 832 * this width is not supported according to the TLU
833 833 * link status register.
834 834 */
835 835 DBG(DBG_LPU, NULL, "lpu_init - LPU_LINK_STATUS: 0x%llx\n",
836 836 CSR_XR(csr_base, LPU_LINK_STATUS));
837 837
838 838 /*
839 839 * CSR_V LPU_INTERRUPT_STATUS Expect HW 0x0
840 840 */
841 841 DBG(DBG_LPU, NULL, "lpu_init - LPU_INTERRUPT_STATUS: 0x%llx\n",
842 842 CSR_XR(csr_base, LPU_INTERRUPT_STATUS));
843 843
844 844 /*
845 845 * CSR_V LPU_INTERRUPT_MASK Expect HW 0x0
846 846 */
847 847 DBG(DBG_LPU, NULL, "lpu_init - LPU_INTERRUPT_MASK: 0x%llx\n",
848 848 CSR_XR(csr_base, LPU_INTERRUPT_MASK));
849 849
850 850 /*
851 851 * CSR_V LPU_LINK_PERFORMANCE_COUNTER_SELECT Expect HW 0x0
852 852 */
853 853 DBG(DBG_LPU, NULL,
854 854 "lpu_init - LPU_LINK_PERFORMANCE_COUNTER_SELECT: 0x%llx\n",
855 855 CSR_XR(csr_base, LPU_LINK_PERFORMANCE_COUNTER_SELECT));
856 856
857 857 /*
858 858 * CSR_V LPU_LINK_PERFORMANCE_COUNTER_CONTROL Expect HW 0x0
859 859 */
860 860 DBG(DBG_LPU, NULL,
861 861 "lpu_init - LPU_LINK_PERFORMANCE_COUNTER_CONTROL: 0x%llx\n",
862 862 CSR_XR(csr_base, LPU_LINK_PERFORMANCE_COUNTER_CONTROL));
863 863
864 864 /*
865 865 * CSR_V LPU_LINK_PERFORMANCE_COUNTER1 Expect HW 0x0
866 866 */
867 867 DBG(DBG_LPU, NULL,
868 868 "lpu_init - LPU_LINK_PERFORMANCE_COUNTER1: 0x%llx\n",
869 869 CSR_XR(csr_base, LPU_LINK_PERFORMANCE_COUNTER1));
870 870
871 871 /*
872 872 * CSR_V LPU_LINK_PERFORMANCE_COUNTER1_TEST Expect HW 0x0
873 873 */
874 874 DBG(DBG_LPU, NULL,
875 875 "lpu_init - LPU_LINK_PERFORMANCE_COUNTER1_TEST: 0x%llx\n",
876 876 CSR_XR(csr_base, LPU_LINK_PERFORMANCE_COUNTER1_TEST));
877 877
878 878 /*
879 879 * CSR_V LPU_LINK_PERFORMANCE_COUNTER2 Expect HW 0x0
880 880 */
881 881 DBG(DBG_LPU, NULL,
882 882 "lpu_init - LPU_LINK_PERFORMANCE_COUNTER2: 0x%llx\n",
883 883 CSR_XR(csr_base, LPU_LINK_PERFORMANCE_COUNTER2));
884 884
885 885 /*
886 886 * CSR_V LPU_LINK_PERFORMANCE_COUNTER2_TEST Expect HW 0x0
887 887 */
888 888 DBG(DBG_LPU, NULL,
889 889 "lpu_init - LPU_LINK_PERFORMANCE_COUNTER2_TEST: 0x%llx\n",
890 890 CSR_XR(csr_base, LPU_LINK_PERFORMANCE_COUNTER2_TEST));
891 891
892 892 /*
893 893 * CSR_V LPU_LINK_LAYER_CONFIG Expect HW 0x100
894 894 */
895 895
896 896 /*
897 897 * This is another place where Max Payload can be set,
898 898 * this time for the link layer. It will be set to
899 899 * 128B, which is the default, but this will need to
900 900 * be revisited.
901 901 */
902 902 val = (1ull << LPU_LINK_LAYER_CONFIG_VC0_EN);
903 903 CSR_XS(csr_base, LPU_LINK_LAYER_CONFIG, val);
904 904 DBG(DBG_LPU, NULL, "lpu_init - LPU_LINK_LAYER_CONFIG: 0x%llx\n",
905 905 CSR_XR(csr_base, LPU_LINK_LAYER_CONFIG));
906 906
907 907 /*
908 908 * CSR_V LPU_LINK_LAYER_STATUS Expect OBP 0x5
909 909 */
910 910
911 911 /*
912 912 * Another R/W status register. Bit 3, DL up Status, will
913 913 * be set high. The link state machine status bits [2:0]
914 914 * are set to 0x1, but the status bits are not defined in the
915 915 * PRM. What does 0x1 mean, what others values are possible
916 916 * and what are thier meanings?
917 917 *
918 918 * This register has been giving us problems in simulation.
919 919 * It has been mentioned that software should not program
920 920 * any registers with WE bits except during debug. So
921 921 * this register will no longer be programmed.
922 922 */
923 923
924 924 DBG(DBG_LPU, NULL, "lpu_init - LPU_LINK_LAYER_STATUS: 0x%llx\n",
925 925 CSR_XR(csr_base, LPU_LINK_LAYER_STATUS));
926 926
927 927 /*
928 928 * CSR_V LPU_LINK_LAYER_INTERRUPT_AND_STATUS_TEST Expect HW 0x0
929 929 */
930 930 DBG(DBG_LPU, NULL,
931 931 "lpu_init - LPU_LINK_LAYER_INTERRUPT_AND_STATUS_TEST: 0x%llx\n",
932 932 CSR_XR(csr_base, LPU_LINK_LAYER_INTERRUPT_AND_STATUS_TEST));
933 933
934 934 /*
935 935 * CSR_V LPU Link Layer interrupt regs (mask, status)
936 936 */
937 937 DBG(DBG_LPU, NULL,
938 938 "lpu_init - LPU_LINK_LAYER_INTERRUPT_MASK: 0x%llx\n",
939 939 CSR_XR(csr_base, LPU_LINK_LAYER_INTERRUPT_MASK));
940 940
941 941 DBG(DBG_LPU, NULL,
942 942 "lpu_init - LPU_LINK_LAYER_INTERRUPT_AND_STATUS: 0x%llx\n",
943 943 CSR_XR(csr_base, LPU_LINK_LAYER_INTERRUPT_AND_STATUS));
944 944
945 945 /*
946 946 * CSR_V LPU_FLOW_CONTROL_UPDATE_CONTROL Expect OBP 0x7
947 947 */
948 948
949 949 /*
950 950 * The PRM says that only the first two bits will be set
951 951 * high by default, which will enable flow control for
952 952 * posted and non-posted updates, but NOT completetion
953 953 * updates.
954 954 */
955 955 val = (1ull << LPU_FLOW_CONTROL_UPDATE_CONTROL_FC0_U_NP_EN) |
956 956 (1ull << LPU_FLOW_CONTROL_UPDATE_CONTROL_FC0_U_P_EN);
957 957 CSR_XS(csr_base, LPU_FLOW_CONTROL_UPDATE_CONTROL, val);
958 958 DBG(DBG_LPU, NULL,
959 959 "lpu_init - LPU_FLOW_CONTROL_UPDATE_CONTROL: 0x%llx\n",
960 960 CSR_XR(csr_base, LPU_FLOW_CONTROL_UPDATE_CONTROL));
961 961
962 962 /*
963 963 * CSR_V LPU_LINK_LAYER_FLOW_CONTROL_UPDATE_TIMEOUT_VALUE
964 964 * Expect OBP 0x1D4C
965 965 */
966 966
967 967 /*
968 968 * This should be set by OBP. We'll check to make sure.
969 969 */
970 970 DBG(DBG_LPU, NULL, "lpu_init - "
971 971 "LPU_LINK_LAYER_FLOW_CONTROL_UPDATE_TIMEOUT_VALUE: 0x%llx\n",
972 972 CSR_XR(csr_base,
973 973 LPU_LINK_LAYER_FLOW_CONTROL_UPDATE_TIMEOUT_VALUE));
974 974
975 975 /*
976 976 * CSR_V LPU_LINK_LAYER_VC0_FLOW_CONTROL_UPDATE_TIMER0 Expect OBP ???
977 977 */
978 978
979 979 /*
980 980 * This register has Flow Control Update Timer values for
981 981 * non-posted and posted requests, bits [30:16] and bits
982 982 * [14:0], respectively. These are read-only to SW so
983 983 * either HW or OBP needs to set them.
984 984 */
985 985 DBG(DBG_LPU, NULL, "lpu_init - "
986 986 "LPU_LINK_LAYER_VC0_FLOW_CONTROL_UPDATE_TIMER0: 0x%llx\n",
987 987 CSR_XR(csr_base,
988 988 LPU_LINK_LAYER_VC0_FLOW_CONTROL_UPDATE_TIMER0));
989 989
990 990 /*
991 991 * CSR_V LPU_LINK_LAYER_VC0_FLOW_CONTROL_UPDATE_TIMER1 Expect OBP ???
992 992 */
993 993
994 994 /*
995 995 * Same as timer0 register above, except for bits [14:0]
996 996 * have the timer values for completetions. Read-only to
997 997 * SW; OBP or HW need to set it.
998 998 */
999 999 DBG(DBG_LPU, NULL, "lpu_init - "
1000 1000 "LPU_LINK_LAYER_VC0_FLOW_CONTROL_UPDATE_TIMER1: 0x%llx\n",
1001 1001 CSR_XR(csr_base,
1002 1002 LPU_LINK_LAYER_VC0_FLOW_CONTROL_UPDATE_TIMER1));
1003 1003
1004 1004 /*
1005 1005 * CSR_V LPU_TXLINK_FREQUENT_NAK_LATENCY_TIMER_THRESHOLD
1006 1006 */
1007 1007 val = px_acknak_timer_table[max_payload][link_width];
1008 1008 CSR_XS(csr_base, LPU_TXLINK_FREQUENT_NAK_LATENCY_TIMER_THRESHOLD, val);
1009 1009
1010 1010 DBG(DBG_LPU, NULL, "lpu_init - "
1011 1011 "LPU_TXLINK_FREQUENT_NAK_LATENCY_TIMER_THRESHOLD: 0x%llx\n",
1012 1012 CSR_XR(csr_base, LPU_TXLINK_FREQUENT_NAK_LATENCY_TIMER_THRESHOLD));
1013 1013
1014 1014 /*
1015 1015 * CSR_V LPU_TXLINK_ACKNAK_LATENCY_TIMER Expect HW 0x0
1016 1016 */
1017 1017 DBG(DBG_LPU, NULL,
1018 1018 "lpu_init - LPU_TXLINK_ACKNAK_LATENCY_TIMER: 0x%llx\n",
1019 1019 CSR_XR(csr_base, LPU_TXLINK_ACKNAK_LATENCY_TIMER));
1020 1020
1021 1021 /*
1022 1022 * CSR_V LPU_TXLINK_REPLAY_TIMER_THRESHOLD
1023 1023 */
1024 1024 val = px_replay_timer_table[max_payload][link_width];
1025 1025 CSR_XS(csr_base, LPU_TXLINK_REPLAY_TIMER_THRESHOLD, val);
1026 1026
1027 1027 DBG(DBG_LPU, NULL,
1028 1028 "lpu_init - LPU_TXLINK_REPLAY_TIMER_THRESHOLD: 0x%llx\n",
1029 1029 CSR_XR(csr_base, LPU_TXLINK_REPLAY_TIMER_THRESHOLD));
1030 1030
1031 1031 /*
1032 1032 * CSR_V LPU_TXLINK_REPLAY_TIMER Expect HW 0x0
1033 1033 */
1034 1034 DBG(DBG_LPU, NULL, "lpu_init - LPU_TXLINK_REPLAY_TIMER: 0x%llx\n",
1035 1035 CSR_XR(csr_base, LPU_TXLINK_REPLAY_TIMER));
1036 1036
1037 1037 /*
1038 1038 * CSR_V LPU_TXLINK_REPLAY_NUMBER_STATUS Expect OBP 0x3
1039 1039 */
1040 1040 DBG(DBG_LPU, NULL,
1041 1041 "lpu_init - LPU_TXLINK_REPLAY_NUMBER_STATUS: 0x%llx\n",
1042 1042 CSR_XR(csr_base, LPU_TXLINK_REPLAY_NUMBER_STATUS));
1043 1043
1044 1044 /*
1045 1045 * CSR_V LPU_REPLAY_BUFFER_MAX_ADDRESS Expect OBP 0xB3F
1046 1046 */
1047 1047 DBG(DBG_LPU, NULL,
1048 1048 "lpu_init - LPU_REPLAY_BUFFER_MAX_ADDRESS: 0x%llx\n",
1049 1049 CSR_XR(csr_base, LPU_REPLAY_BUFFER_MAX_ADDRESS));
1050 1050
1051 1051 /*
1052 1052 * CSR_V LPU_TXLINK_RETRY_FIFO_POINTER Expect OBP 0xFFFF0000
1053 1053 */
1054 1054 val = ((LPU_TXLINK_RETRY_FIFO_POINTER_RTRY_FIFO_TLPTR_DEFAULT <<
1055 1055 LPU_TXLINK_RETRY_FIFO_POINTER_RTRY_FIFO_TLPTR) |
1056 1056 (LPU_TXLINK_RETRY_FIFO_POINTER_RTRY_FIFO_HDPTR_DEFAULT <<
1057 1057 LPU_TXLINK_RETRY_FIFO_POINTER_RTRY_FIFO_HDPTR));
1058 1058
1059 1059 CSR_XS(csr_base, LPU_TXLINK_RETRY_FIFO_POINTER, val);
1060 1060 DBG(DBG_LPU, NULL,
1061 1061 "lpu_init - LPU_TXLINK_RETRY_FIFO_POINTER: 0x%llx\n",
1062 1062 CSR_XR(csr_base, LPU_TXLINK_RETRY_FIFO_POINTER));
1063 1063
1064 1064 /*
1065 1065 * CSR_V LPU_TXLINK_RETRY_FIFO_R_W_POINTER Expect OBP 0x0
1066 1066 */
1067 1067 DBG(DBG_LPU, NULL,
1068 1068 "lpu_init - LPU_TXLINK_RETRY_FIFO_R_W_POINTER: 0x%llx\n",
1069 1069 CSR_XR(csr_base, LPU_TXLINK_RETRY_FIFO_R_W_POINTER));
1070 1070
1071 1071 /*
1072 1072 * CSR_V LPU_TXLINK_RETRY_FIFO_CREDIT Expect HW 0x1580
1073 1073 */
1074 1074 DBG(DBG_LPU, NULL,
1075 1075 "lpu_init - LPU_TXLINK_RETRY_FIFO_CREDIT: 0x%llx\n",
1076 1076 CSR_XR(csr_base, LPU_TXLINK_RETRY_FIFO_CREDIT));
1077 1077
1078 1078 /*
1079 1079 * CSR_V LPU_TXLINK_SEQUENCE_COUNTER Expect OBP 0xFFF0000
1080 1080 */
1081 1081 DBG(DBG_LPU, NULL, "lpu_init - LPU_TXLINK_SEQUENCE_COUNTER: 0x%llx\n",
1082 1082 CSR_XR(csr_base, LPU_TXLINK_SEQUENCE_COUNTER));
1083 1083
1084 1084 /*
1085 1085 * CSR_V LPU_TXLINK_ACK_SENT_SEQUENCE_NUMBER Expect HW 0xFFF
1086 1086 */
1087 1087 DBG(DBG_LPU, NULL,
1088 1088 "lpu_init - LPU_TXLINK_ACK_SENT_SEQUENCE_NUMBER: 0x%llx\n",
1089 1089 CSR_XR(csr_base, LPU_TXLINK_ACK_SENT_SEQUENCE_NUMBER));
1090 1090
1091 1091 /*
1092 1092 * CSR_V LPU_TXLINK_SEQUENCE_COUNT_FIFO_MAX_ADDR Expect OBP 0x157
1093 1093 */
1094 1094
1095 1095 /*
1096 1096 * Test only register. Will not be programmed.
1097 1097 */
1098 1098 DBG(DBG_LPU, NULL,
1099 1099 "lpu_init - LPU_TXLINK_SEQUENCE_COUNT_FIFO_MAX_ADDR: 0x%llx\n",
1100 1100 CSR_XR(csr_base, LPU_TXLINK_SEQUENCE_COUNT_FIFO_MAX_ADDR));
1101 1101
1102 1102 /*
1103 1103 * CSR_V LPU_TXLINK_SEQUENCE_COUNT_FIFO_POINTERS Expect HW 0xFFF0000
1104 1104 */
1105 1105
1106 1106 /*
1107 1107 * Test only register. Will not be programmed.
1108 1108 */
1109 1109 DBG(DBG_LPU, NULL,
1110 1110 "lpu_init - LPU_TXLINK_SEQUENCE_COUNT_FIFO_POINTERS: 0x%llx\n",
1111 1111 CSR_XR(csr_base, LPU_TXLINK_SEQUENCE_COUNT_FIFO_POINTERS));
1112 1112
1113 1113 /*
1114 1114 * CSR_V LPU_TXLINK_SEQUENCE_COUNT_R_W_POINTERS Expect HW 0x0
1115 1115 */
1116 1116 DBG(DBG_LPU, NULL,
1117 1117 "lpu_init - LPU_TXLINK_SEQUENCE_COUNT_R_W_POINTERS: 0x%llx\n",
1118 1118 CSR_XR(csr_base, LPU_TXLINK_SEQUENCE_COUNT_R_W_POINTERS));
1119 1119
1120 1120 /*
1121 1121 * CSR_V LPU_TXLINK_TEST_CONTROL Expect HW 0x0
1122 1122 */
1123 1123 DBG(DBG_LPU, NULL, "lpu_init - LPU_TXLINK_TEST_CONTROL: 0x%llx\n",
1124 1124 CSR_XR(csr_base, LPU_TXLINK_TEST_CONTROL));
1125 1125
1126 1126 /*
1127 1127 * CSR_V LPU_TXLINK_MEMORY_ADDRESS_CONTROL Expect HW 0x0
1128 1128 */
1129 1129
1130 1130 /*
1131 1131 * Test only register. Will not be programmed.
1132 1132 */
1133 1133 DBG(DBG_LPU, NULL,
1134 1134 "lpu_init - LPU_TXLINK_MEMORY_ADDRESS_CONTROL: 0x%llx\n",
1135 1135 CSR_XR(csr_base, LPU_TXLINK_MEMORY_ADDRESS_CONTROL));
1136 1136
1137 1137 /*
1138 1138 * CSR_V LPU_TXLINK_MEMORY_DATA_LOAD0 Expect HW 0x0
1139 1139 */
1140 1140 DBG(DBG_LPU, NULL,
1141 1141 "lpu_init - LPU_TXLINK_MEMORY_DATA_LOAD0: 0x%llx\n",
1142 1142 CSR_XR(csr_base, LPU_TXLINK_MEMORY_DATA_LOAD0));
1143 1143
1144 1144 /*
1145 1145 * CSR_V LPU_TXLINK_MEMORY_DATA_LOAD1 Expect HW 0x0
1146 1146 */
1147 1147 DBG(DBG_LPU, NULL,
1148 1148 "lpu_init - LPU_TXLINK_MEMORY_DATA_LOAD1: 0x%llx\n",
1149 1149 CSR_XR(csr_base, LPU_TXLINK_MEMORY_DATA_LOAD1));
1150 1150
1151 1151 /*
1152 1152 * CSR_V LPU_TXLINK_MEMORY_DATA_LOAD2 Expect HW 0x0
1153 1153 */
1154 1154 DBG(DBG_LPU, NULL,
1155 1155 "lpu_init - LPU_TXLINK_MEMORY_DATA_LOAD2: 0x%llx\n",
1156 1156 CSR_XR(csr_base, LPU_TXLINK_MEMORY_DATA_LOAD2));
1157 1157
1158 1158 /*
1159 1159 * CSR_V LPU_TXLINK_MEMORY_DATA_LOAD3 Expect HW 0x0
1160 1160 */
1161 1161 DBG(DBG_LPU, NULL,
1162 1162 "lpu_init - LPU_TXLINK_MEMORY_DATA_LOAD3: 0x%llx\n",
1163 1163 CSR_XR(csr_base, LPU_TXLINK_MEMORY_DATA_LOAD3));
1164 1164
1165 1165 /*
1166 1166 * CSR_V LPU_TXLINK_MEMORY_DATA_LOAD4 Expect HW 0x0
1167 1167 */
1168 1168 DBG(DBG_LPU, NULL,
1169 1169 "lpu_init - LPU_TXLINK_MEMORY_DATA_LOAD4: 0x%llx\n",
1170 1170 CSR_XR(csr_base, LPU_TXLINK_MEMORY_DATA_LOAD4));
1171 1171
1172 1172 /*
1173 1173 * CSR_V LPU_TXLINK_RETRY_DATA_COUNT Expect HW 0x0
1174 1174 */
1175 1175
1176 1176 /*
1177 1177 * Test only register. Will not be programmed.
1178 1178 */
1179 1179 DBG(DBG_LPU, NULL, "lpu_init - LPU_TXLINK_RETRY_DATA_COUNT: 0x%llx\n",
1180 1180 CSR_XR(csr_base, LPU_TXLINK_RETRY_DATA_COUNT));
1181 1181
1182 1182 /*
1183 1183 * CSR_V LPU_TXLINK_SEQUENCE_BUFFER_COUNT Expect HW 0x0
1184 1184 */
1185 1185
1186 1186 /*
1187 1187 * Test only register. Will not be programmed.
1188 1188 */
1189 1189 DBG(DBG_LPU, NULL,
1190 1190 "lpu_init - LPU_TXLINK_SEQUENCE_BUFFER_COUNT: 0x%llx\n",
1191 1191 CSR_XR(csr_base, LPU_TXLINK_SEQUENCE_BUFFER_COUNT));
1192 1192
1193 1193 /*
1194 1194 * CSR_V LPU_TXLINK_SEQUENCE_BUFFER_BOTTOM_DATA Expect HW 0x0
1195 1195 */
1196 1196
1197 1197 /*
1198 1198 * Test only register.
1199 1199 */
1200 1200 DBG(DBG_LPU, NULL,
1201 1201 "lpu_init - LPU_TXLINK_SEQUENCE_BUFFER_BOTTOM_DATA: 0x%llx\n",
1202 1202 CSR_XR(csr_base, LPU_TXLINK_SEQUENCE_BUFFER_BOTTOM_DATA));
1203 1203
1204 1204 /*
1205 1205 * CSR_V LPU_RXLINK_NEXT_RECEIVE_SEQUENCE_1_COUNTER Expect HW 0x0
1206 1206 */
1207 1207 DBG(DBG_LPU, NULL, "lpu_init - "
1208 1208 "LPU_RXLINK_NEXT_RECEIVE_SEQUENCE_1_COUNTER: 0x%llx\n",
1209 1209 CSR_XR(csr_base, LPU_RXLINK_NEXT_RECEIVE_SEQUENCE_1_COUNTER));
1210 1210
1211 1211 /*
1212 1212 * CSR_V LPU_RXLINK_UNSUPPORTED_DLLP_RECEIVED Expect HW 0x0
1213 1213 */
1214 1214
1215 1215 /*
1216 1216 * test only register.
1217 1217 */
1218 1218 DBG(DBG_LPU, NULL,
1219 1219 "lpu_init - LPU_RXLINK_UNSUPPORTED_DLLP_RECEIVED: 0x%llx\n",
1220 1220 CSR_XR(csr_base, LPU_RXLINK_UNSUPPORTED_DLLP_RECEIVED));
1221 1221
1222 1222 /*
1223 1223 * CSR_V LPU_RXLINK_TEST_CONTROL Expect HW 0x0
1224 1224 */
1225 1225
1226 1226 /*
1227 1227 * test only register.
1228 1228 */
1229 1229 DBG(DBG_LPU, NULL, "lpu_init - LPU_RXLINK_TEST_CONTROL: 0x%llx\n",
1230 1230 CSR_XR(csr_base, LPU_RXLINK_TEST_CONTROL));
1231 1231
1232 1232 /*
1233 1233 * CSR_V LPU_PHYSICAL_LAYER_CONFIGURATION Expect HW 0x10
1234 1234 */
1235 1235 DBG(DBG_LPU, NULL,
1236 1236 "lpu_init - LPU_PHYSICAL_LAYER_CONFIGURATION: 0x%llx\n",
1237 1237 CSR_XR(csr_base, LPU_PHYSICAL_LAYER_CONFIGURATION));
1238 1238
1239 1239 /*
1240 1240 * CSR_V LPU_PHY_LAYER_STATUS Expect HW 0x0
1241 1241 */
1242 1242 DBG(DBG_LPU, NULL, "lpu_init - LPU_PHY_LAYER_STATUS: 0x%llx\n",
1243 1243 CSR_XR(csr_base, LPU_PHY_LAYER_STATUS));
1244 1244
1245 1245 /*
1246 1246 * CSR_V LPU_PHY_INTERRUPT_AND_STATUS_TEST Expect HW 0x0
1247 1247 */
1248 1248 DBG(DBG_LPU, NULL,
1249 1249 "lpu_init - LPU_PHY_INTERRUPT_AND_STATUS_TEST: 0x%llx\n",
1250 1250 CSR_XR(csr_base, LPU_PHY_INTERRUPT_AND_STATUS_TEST));
1251 1251
1252 1252 /*
1253 1253 * CSR_V LPU PHY LAYER interrupt regs (mask, status)
1254 1254 */
1255 1255 DBG(DBG_LPU, NULL, "lpu_init - LPU_PHY_INTERRUPT_MASK: 0x%llx\n",
1256 1256 CSR_XR(csr_base, LPU_PHY_INTERRUPT_MASK));
1257 1257
1258 1258 DBG(DBG_LPU, NULL,
1259 1259 "lpu_init - LPU_PHY_LAYER_INTERRUPT_AND_STATUS: 0x%llx\n",
1260 1260 CSR_XR(csr_base, LPU_PHY_LAYER_INTERRUPT_AND_STATUS));
1261 1261
1262 1262 /*
1263 1263 * CSR_V LPU_RECEIVE_PHY_CONFIG Expect HW 0x0
1264 1264 */
1265 1265
1266 1266 /*
1267 1267 * This also needs some explanation. What is the best value
1268 1268 * for the water mark? Test mode enables which test mode?
1269 1269 * Programming model needed for the Receiver Reset Lane N
1270 1270 * bits.
1271 1271 */
1272 1272 DBG(DBG_LPU, NULL, "lpu_init - LPU_RECEIVE_PHY_CONFIG: 0x%llx\n",
1273 1273 CSR_XR(csr_base, LPU_RECEIVE_PHY_CONFIG));
1274 1274
1275 1275 /*
1276 1276 * CSR_V LPU_RECEIVE_PHY_STATUS1 Expect HW 0x0
1277 1277 */
1278 1278 DBG(DBG_LPU, NULL, "lpu_init - LPU_RECEIVE_PHY_STATUS1: 0x%llx\n",
1279 1279 CSR_XR(csr_base, LPU_RECEIVE_PHY_STATUS1));
1280 1280
1281 1281 /*
1282 1282 * CSR_V LPU_RECEIVE_PHY_STATUS2 Expect HW 0x0
1283 1283 */
1284 1284 DBG(DBG_LPU, NULL, "lpu_init - LPU_RECEIVE_PHY_STATUS2: 0x%llx\n",
1285 1285 CSR_XR(csr_base, LPU_RECEIVE_PHY_STATUS2));
1286 1286
1287 1287 /*
1288 1288 * CSR_V LPU_RECEIVE_PHY_STATUS3 Expect HW 0x0
1289 1289 */
1290 1290 DBG(DBG_LPU, NULL, "lpu_init - LPU_RECEIVE_PHY_STATUS3: 0x%llx\n",
1291 1291 CSR_XR(csr_base, LPU_RECEIVE_PHY_STATUS3));
1292 1292
1293 1293 /*
1294 1294 * CSR_V LPU_RECEIVE_PHY_INTERRUPT_AND_STATUS_TEST Expect HW 0x0
1295 1295 */
1296 1296 DBG(DBG_LPU, NULL,
1297 1297 "lpu_init - LPU_RECEIVE_PHY_INTERRUPT_AND_STATUS_TEST: 0x%llx\n",
1298 1298 CSR_XR(csr_base, LPU_RECEIVE_PHY_INTERRUPT_AND_STATUS_TEST));
1299 1299
1300 1300 /*
1301 1301 * CSR_V LPU RX LAYER interrupt regs (mask, status)
1302 1302 */
1303 1303 DBG(DBG_LPU, NULL,
1304 1304 "lpu_init - LPU_RECEIVE_PHY_INTERRUPT_MASK: 0x%llx\n",
1305 1305 CSR_XR(csr_base, LPU_RECEIVE_PHY_INTERRUPT_MASK));
1306 1306
1307 1307 DBG(DBG_LPU, NULL,
1308 1308 "lpu_init - LPU_RECEIVE_PHY_INTERRUPT_AND_STATUS: 0x%llx\n",
1309 1309 CSR_XR(csr_base, LPU_RECEIVE_PHY_INTERRUPT_AND_STATUS));
1310 1310
1311 1311 /*
1312 1312 * CSR_V LPU_TRANSMIT_PHY_CONFIG Expect HW 0x0
1313 1313 */
1314 1314 DBG(DBG_LPU, NULL, "lpu_init - LPU_TRANSMIT_PHY_CONFIG: 0x%llx\n",
1315 1315 CSR_XR(csr_base, LPU_TRANSMIT_PHY_CONFIG));
1316 1316
1317 1317 /*
1318 1318 * CSR_V LPU_TRANSMIT_PHY_STATUS Expect HW 0x0
1319 1319 */
1320 1320 DBG(DBG_LPU, NULL, "lpu_init - LPU_TRANSMIT_PHY_STATUS: 0x%llx\n",
1321 1321 CSR_XR(csr_base, LPU_TRANSMIT_PHY_STATUS));
1322 1322
1323 1323 /*
1324 1324 * CSR_V LPU_TRANSMIT_PHY_INTERRUPT_AND_STATUS_TEST Expect HW 0x0
1325 1325 */
1326 1326 DBG(DBG_LPU, NULL,
1327 1327 "lpu_init - LPU_TRANSMIT_PHY_INTERRUPT_AND_STATUS_TEST: 0x%llx\n",
1328 1328 CSR_XR(csr_base,
1329 1329 LPU_TRANSMIT_PHY_INTERRUPT_AND_STATUS_TEST));
1330 1330
1331 1331 /*
1332 1332 * CSR_V LPU TX LAYER interrupt regs (mask, status)
1333 1333 */
1334 1334 DBG(DBG_LPU, NULL,
1335 1335 "lpu_init - LPU_TRANSMIT_PHY_INTERRUPT_MASK: 0x%llx\n",
1336 1336 CSR_XR(csr_base, LPU_TRANSMIT_PHY_INTERRUPT_MASK));
1337 1337
1338 1338 DBG(DBG_LPU, NULL,
1339 1339 "lpu_init - LPU_TRANSMIT_PHY_INTERRUPT_AND_STATUS: 0x%llx\n",
1340 1340 CSR_XR(csr_base, LPU_TRANSMIT_PHY_INTERRUPT_AND_STATUS));
1341 1341
1342 1342 /*
1343 1343 * CSR_V LPU_TRANSMIT_PHY_STATUS_2 Expect HW 0x0
1344 1344 */
1345 1345 DBG(DBG_LPU, NULL, "lpu_init - LPU_TRANSMIT_PHY_STATUS_2: 0x%llx\n",
1346 1346 CSR_XR(csr_base, LPU_TRANSMIT_PHY_STATUS_2));
1347 1347
1348 1348 /*
1349 1349 * CSR_V LPU_LTSSM_CONFIG1 Expect OBP 0x205
1350 1350 */
1351 1351
1352 1352 /*
1353 1353 * The new PRM has values for LTSSM 8 ns timeout value and
1354 1354 * LTSSM 20 ns timeout value. But what do these values mean?
1355 1355 * Most of the other bits are questions as well.
1356 1356 *
1357 1357 * As such we will use the reset value.
1358 1358 */
1359 1359 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_CONFIG1: 0x%llx\n",
1360 1360 CSR_XR(csr_base, LPU_LTSSM_CONFIG1));
1361 1361
1362 1362 /*
1363 1363 * CSR_V LPU_LTSSM_CONFIG2 Expect OBP 0x2DC6C0
1364 1364 */
1365 1365
1366 1366 /*
1367 1367 * Again, what does '12 ms timeout value mean'?
1368 1368 */
1369 1369 val = (LPU_LTSSM_CONFIG2_LTSSM_12_TO_DEFAULT <<
1370 1370 LPU_LTSSM_CONFIG2_LTSSM_12_TO);
1371 1371 CSR_XS(csr_base, LPU_LTSSM_CONFIG2, val);
1372 1372 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_CONFIG2: 0x%llx\n",
1373 1373 CSR_XR(csr_base, LPU_LTSSM_CONFIG2));
1374 1374
1375 1375 /*
1376 1376 * CSR_V LPU_LTSSM_CONFIG3 Expect OBP 0x7A120
1377 1377 */
1378 1378 val = (LPU_LTSSM_CONFIG3_LTSSM_2_TO_DEFAULT <<
1379 1379 LPU_LTSSM_CONFIG3_LTSSM_2_TO);
1380 1380 CSR_XS(csr_base, LPU_LTSSM_CONFIG3, val);
1381 1381 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_CONFIG3: 0x%llx\n",
1382 1382 CSR_XR(csr_base, LPU_LTSSM_CONFIG3));
1383 1383
1384 1384 /*
1385 1385 * CSR_V LPU_LTSSM_CONFIG4 Expect OBP 0x21300
1386 1386 */
1387 1387 val = ((LPU_LTSSM_CONFIG4_DATA_RATE_DEFAULT <<
1388 1388 LPU_LTSSM_CONFIG4_DATA_RATE) |
1389 1389 (LPU_LTSSM_CONFIG4_N_FTS_DEFAULT <<
1390 1390 LPU_LTSSM_CONFIG4_N_FTS));
1391 1391
1392 1392 CSR_XS(csr_base, LPU_LTSSM_CONFIG4, val);
1393 1393 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_CONFIG4: 0x%llx\n",
1394 1394 CSR_XR(csr_base, LPU_LTSSM_CONFIG4));
1395 1395
1396 1396 /*
1397 1397 * CSR_V LPU_LTSSM_CONFIG5 Expect OBP 0x0
1398 1398 */
1399 1399 val = 0ull;
1400 1400 CSR_XS(csr_base, LPU_LTSSM_CONFIG5, val);
1401 1401 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_CONFIG5: 0x%llx\n",
1402 1402 CSR_XR(csr_base, LPU_LTSSM_CONFIG5));
1403 1403
1404 1404 /*
1405 1405 * CSR_V LPU_LTSSM_STATUS1 Expect OBP 0x0
1406 1406 */
1407 1407
1408 1408 /*
1409 1409 * LTSSM Status registers are test only.
1410 1410 */
1411 1411 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_STATUS1: 0x%llx\n",
1412 1412 CSR_XR(csr_base, LPU_LTSSM_STATUS1));
1413 1413
1414 1414 /*
1415 1415 * CSR_V LPU_LTSSM_STATUS2 Expect OBP 0x0
1416 1416 */
1417 1417 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_STATUS2: 0x%llx\n",
1418 1418 CSR_XR(csr_base, LPU_LTSSM_STATUS2));
1419 1419
1420 1420 /*
1421 1421 * CSR_V LPU_LTSSM_INTERRUPT_AND_STATUS_TEST Expect HW 0x0
1422 1422 */
1423 1423 DBG(DBG_LPU, NULL,
1424 1424 "lpu_init - LPU_LTSSM_INTERRUPT_AND_STATUS_TEST: 0x%llx\n",
1425 1425 CSR_XR(csr_base, LPU_LTSSM_INTERRUPT_AND_STATUS_TEST));
1426 1426
1427 1427 /*
1428 1428 * CSR_V LPU LTSSM LAYER interrupt regs (mask, status)
1429 1429 */
1430 1430 DBG(DBG_LPU, NULL, "lpu_init - LPU_LTSSM_INTERRUPT_MASK: 0x%llx\n",
1431 1431 CSR_XR(csr_base, LPU_LTSSM_INTERRUPT_MASK));
1432 1432
1433 1433 DBG(DBG_LPU, NULL,
1434 1434 "lpu_init - LPU_LTSSM_INTERRUPT_AND_STATUS: 0x%llx\n",
1435 1435 CSR_XR(csr_base, LPU_LTSSM_INTERRUPT_AND_STATUS));
1436 1436
1437 1437 /*
1438 1438 * CSR_V LPU_LTSSM_STATUS_WRITE_ENABLE Expect OBP 0x0
1439 1439 */
1440 1440 DBG(DBG_LPU, NULL,
1441 1441 "lpu_init - LPU_LTSSM_STATUS_WRITE_ENABLE: 0x%llx\n",
1442 1442 CSR_XR(csr_base, LPU_LTSSM_STATUS_WRITE_ENABLE));
1443 1443
1444 1444 /*
1445 1445 * CSR_V LPU_GIGABLAZE_GLUE_CONFIG1 Expect OBP 0x88407
1446 1446 */
1447 1447 DBG(DBG_LPU, NULL, "lpu_init - LPU_GIGABLAZE_GLUE_CONFIG1: 0x%llx\n",
1448 1448 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_CONFIG1));
1449 1449
1450 1450 /*
1451 1451 * CSR_V LPU_GIGABLAZE_GLUE_CONFIG2 Expect OBP 0x35
1452 1452 */
1453 1453 DBG(DBG_LPU, NULL, "lpu_init - LPU_GIGABLAZE_GLUE_CONFIG2: 0x%llx\n",
1454 1454 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_CONFIG2));
1455 1455
1456 1456 /*
1457 1457 * CSR_V LPU_GIGABLAZE_GLUE_CONFIG3 Expect OBP 0x4400FA
1458 1458 */
1459 1459 DBG(DBG_LPU, NULL, "lpu_init - LPU_GIGABLAZE_GLUE_CONFIG3: 0x%llx\n",
1460 1460 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_CONFIG3));
1461 1461
1462 1462 /*
1463 1463 * CSR_V LPU_GIGABLAZE_GLUE_CONFIG4 Expect OBP 0x1E848
1464 1464 */
1465 1465 DBG(DBG_LPU, NULL, "lpu_init - LPU_GIGABLAZE_GLUE_CONFIG4: 0x%llx\n",
1466 1466 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_CONFIG4));
1467 1467
1468 1468 /*
1469 1469 * CSR_V LPU_GIGABLAZE_GLUE_STATUS Expect OBP 0x0
1470 1470 */
1471 1471 DBG(DBG_LPU, NULL, "lpu_init - LPU_GIGABLAZE_GLUE_STATUS: 0x%llx\n",
1472 1472 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_STATUS));
1473 1473
1474 1474 /*
1475 1475 * CSR_V LPU_GIGABLAZE_GLUE_INTERRUPT_AND_STATUS_TEST Expect OBP 0x0
1476 1476 */
1477 1477 DBG(DBG_LPU, NULL, "lpu_init - "
1478 1478 "LPU_GIGABLAZE_GLUE_INTERRUPT_AND_STATUS_TEST: 0x%llx\n",
1479 1479 CSR_XR(csr_base,
1480 1480 LPU_GIGABLAZE_GLUE_INTERRUPT_AND_STATUS_TEST));
1481 1481
1482 1482 /*
1483 1483 * CSR_V LPU GIGABLASE LAYER interrupt regs (mask, status)
1484 1484 */
1485 1485 DBG(DBG_LPU, NULL,
1486 1486 "lpu_init - LPU_GIGABLAZE_GLUE_INTERRUPT_MASK: 0x%llx\n",
1487 1487 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_INTERRUPT_MASK));
1488 1488
1489 1489 DBG(DBG_LPU, NULL,
1490 1490 "lpu_init - LPU_GIGABLAZE_GLUE_INTERRUPT_AND_STATUS: 0x%llx\n",
1491 1491 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_INTERRUPT_AND_STATUS));
1492 1492
1493 1493 /*
1494 1494 * CSR_V LPU_GIGABLAZE_GLUE_POWER_DOWN1 Expect HW 0x0
1495 1495 */
1496 1496 DBG(DBG_LPU, NULL,
1497 1497 "lpu_init - LPU_GIGABLAZE_GLUE_POWER_DOWN1: 0x%llx\n",
1498 1498 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_POWER_DOWN1));
1499 1499
1500 1500 /*
1501 1501 * CSR_V LPU_GIGABLAZE_GLUE_POWER_DOWN2 Expect HW 0x0
1502 1502 */
1503 1503 DBG(DBG_LPU, NULL,
1504 1504 "lpu_init - LPU_GIGABLAZE_GLUE_POWER_DOWN2: 0x%llx\n",
1505 1505 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_POWER_DOWN2));
1506 1506
1507 1507 /*
1508 1508 * CSR_V LPU_GIGABLAZE_GLUE_CONFIG5 Expect OBP 0x0
1509 1509 */
1510 1510 DBG(DBG_LPU, NULL, "lpu_init - LPU_GIGABLAZE_GLUE_CONFIG5: 0x%llx\n",
1511 1511 CSR_XR(csr_base, LPU_GIGABLAZE_GLUE_CONFIG5));
1512 1512 }
1513 1513
1514 1514 /* ARGSUSED */
1515 1515 static void
1516 1516 dlu_init(caddr_t csr_base, pxu_t *pxu_p)
1517 1517 {
1518 1518 uint64_t val;
1519 1519
1520 1520 CSR_XS(csr_base, DLU_INTERRUPT_MASK, 0ull);
1521 1521 DBG(DBG_TLU, NULL, "dlu_init - DLU_INTERRUPT_MASK: 0x%llx\n",
1522 1522 CSR_XR(csr_base, DLU_INTERRUPT_MASK));
1523 1523
1524 1524 val = (1ull << DLU_LINK_LAYER_CONFIG_VC0_EN);
1525 1525 CSR_XS(csr_base, DLU_LINK_LAYER_CONFIG, val);
1526 1526 DBG(DBG_TLU, NULL, "dlu_init - DLU_LINK_LAYER_CONFIG: 0x%llx\n",
1527 1527 CSR_XR(csr_base, DLU_LINK_LAYER_CONFIG));
1528 1528
1529 1529 val = (1ull << DLU_FLOW_CONTROL_UPDATE_CONTROL_FC0_U_NP_EN) |
1530 1530 (1ull << DLU_FLOW_CONTROL_UPDATE_CONTROL_FC0_U_P_EN);
1531 1531
1532 1532 CSR_XS(csr_base, DLU_FLOW_CONTROL_UPDATE_CONTROL, val);
1533 1533 DBG(DBG_TLU, NULL, "dlu_init - DLU_FLOW_CONTROL_UPDATE_CONTROL: "
1534 1534 "0x%llx\n", CSR_XR(csr_base, DLU_FLOW_CONTROL_UPDATE_CONTROL));
1535 1535
1536 1536 val = (DLU_TXLINK_REPLAY_TIMER_THRESHOLD_DEFAULT <<
1537 1537 DLU_TXLINK_REPLAY_TIMER_THRESHOLD_RPLAY_TMR_THR);
1538 1538
1539 1539 CSR_XS(csr_base, DLU_TXLINK_REPLAY_TIMER_THRESHOLD, val);
1540 1540
1541 1541 DBG(DBG_TLU, NULL, "dlu_init - DLU_TXLINK_REPLAY_TIMER_THRESHOLD: "
1542 1542 "0x%llx\n", CSR_XR(csr_base, DLU_TXLINK_REPLAY_TIMER_THRESHOLD));
1543 1543 }
1544 1544
1545 1545 /* ARGSUSED */
1546 1546 static void
1547 1547 dmc_init(caddr_t csr_base, pxu_t *pxu_p)
1548 1548 {
1549 1549 uint64_t val;
1550 1550
1551 1551 /*
1552 1552 * CSR_V DMC_CORE_AND_BLOCK_INTERRUPT_ENABLE Expect OBP 0x8000000000000003
1553 1553 */
1554 1554
1555 1555 val = -1ull;
1556 1556 CSR_XS(csr_base, DMC_CORE_AND_BLOCK_INTERRUPT_ENABLE, val);
1557 1557 DBG(DBG_DMC, NULL,
1558 1558 "dmc_init - DMC_CORE_AND_BLOCK_INTERRUPT_ENABLE: 0x%llx\n",
1559 1559 CSR_XR(csr_base, DMC_CORE_AND_BLOCK_INTERRUPT_ENABLE));
1560 1560
1561 1561 /*
1562 1562 * CSR_V DMC_CORE_AND_BLOCK_ERROR_STATUS Expect HW 0x0
1563 1563 */
1564 1564 DBG(DBG_DMC, NULL,
1565 1565 "dmc_init - DMC_CORE_AND_BLOCK_ERROR_STATUS: 0x%llx\n",
1566 1566 CSR_XR(csr_base, DMC_CORE_AND_BLOCK_ERROR_STATUS));
1567 1567
1568 1568 /*
1569 1569 * CSR_V DMC_DEBUG_SELECT_FOR_PORT_A Expect HW 0x0
1570 1570 */
1571 1571 val = 0x0ull;
1572 1572 CSR_XS(csr_base, DMC_DEBUG_SELECT_FOR_PORT_A, val);
1573 1573 DBG(DBG_DMC, NULL, "dmc_init - DMC_DEBUG_SELECT_FOR_PORT_A: 0x%llx\n",
1574 1574 CSR_XR(csr_base, DMC_DEBUG_SELECT_FOR_PORT_A));
1575 1575
1576 1576 /*
1577 1577 * CSR_V DMC_DEBUG_SELECT_FOR_PORT_B Expect HW 0x0
1578 1578 */
1579 1579 val = 0x0ull;
1580 1580 CSR_XS(csr_base, DMC_DEBUG_SELECT_FOR_PORT_B, val);
1581 1581 DBG(DBG_DMC, NULL, "dmc_init - DMC_DEBUG_SELECT_FOR_PORT_B: 0x%llx\n",
1582 1582 CSR_XR(csr_base, DMC_DEBUG_SELECT_FOR_PORT_B));
1583 1583 }
1584 1584
1585 1585 void
1586 1586 hvio_pec_init(caddr_t csr_base, pxu_t *pxu_p)
1587 1587 {
1588 1588 uint64_t val;
1589 1589
1590 1590 ilu_init(csr_base, pxu_p);
1591 1591 tlu_init(csr_base, pxu_p);
1592 1592
1593 1593 switch (PX_CHIP_TYPE(pxu_p)) {
1594 1594 case PX_CHIP_OBERON:
1595 1595 dlu_init(csr_base, pxu_p);
1596 1596 break;
1597 1597 case PX_CHIP_FIRE:
1598 1598 lpu_init(csr_base, pxu_p);
1599 1599 break;
1600 1600 default:
1601 1601 DBG(DBG_PEC, NULL, "hvio_pec_init - unknown chip type: 0x%x\n",
1602 1602 PX_CHIP_TYPE(pxu_p));
1603 1603 break;
1604 1604 }
1605 1605
1606 1606 dmc_init(csr_base, pxu_p);
1607 1607
1608 1608 /*
1609 1609 * CSR_V PEC_CORE_AND_BLOCK_INTERRUPT_ENABLE Expect Kernel 0x800000000000000F
1610 1610 */
1611 1611
1612 1612 val = -1ull;
1613 1613 CSR_XS(csr_base, PEC_CORE_AND_BLOCK_INTERRUPT_ENABLE, val);
1614 1614 DBG(DBG_PEC, NULL,
1615 1615 "hvio_pec_init - PEC_CORE_AND_BLOCK_INTERRUPT_ENABLE: 0x%llx\n",
1616 1616 CSR_XR(csr_base, PEC_CORE_AND_BLOCK_INTERRUPT_ENABLE));
1617 1617
1618 1618 /*
1619 1619 * CSR_V PEC_CORE_AND_BLOCK_INTERRUPT_STATUS Expect HW 0x0
1620 1620 */
1621 1621 DBG(DBG_PEC, NULL,
1622 1622 "hvio_pec_init - PEC_CORE_AND_BLOCK_INTERRUPT_STATUS: 0x%llx\n",
1623 1623 CSR_XR(csr_base, PEC_CORE_AND_BLOCK_INTERRUPT_STATUS));
1624 1624 }
1625 1625
1626 1626 /*
1627 1627 * Convert a TTE to physical address
1628 1628 */
1629 1629 static r_addr_t
1630 1630 mmu_tte_to_pa(uint64_t tte, pxu_t *pxu_p)
1631 1631 {
1632 1632 uint64_t pa_mask;
1633 1633
1634 1634 switch (PX_CHIP_TYPE(pxu_p)) {
1635 1635 case PX_CHIP_OBERON:
1636 1636 pa_mask = MMU_OBERON_PADDR_MASK;
1637 1637 break;
1638 1638 case PX_CHIP_FIRE:
1639 1639 pa_mask = MMU_FIRE_PADDR_MASK;
1640 1640 break;
1641 1641 default:
1642 1642 DBG(DBG_MMU, NULL, "mmu_tte_to_pa - unknown chip type: 0x%x\n",
1643 1643 PX_CHIP_TYPE(pxu_p));
1644 1644 pa_mask = 0;
1645 1645 break;
1646 1646 }
1647 1647 return ((tte & pa_mask) >> MMU_PAGE_SHIFT);
1648 1648 }
1649 1649
1650 1650 /*
1651 1651 * Return MMU bypass noncache bit for chip
1652 1652 */
1653 1653 static r_addr_t
1654 1654 mmu_bypass_noncache(pxu_t *pxu_p)
1655 1655 {
1656 1656 r_addr_t bypass_noncache_bit;
1657 1657
1658 1658 switch (PX_CHIP_TYPE(pxu_p)) {
1659 1659 case PX_CHIP_OBERON:
1660 1660 bypass_noncache_bit = MMU_OBERON_BYPASS_NONCACHE;
1661 1661 break;
1662 1662 case PX_CHIP_FIRE:
1663 1663 bypass_noncache_bit = MMU_FIRE_BYPASS_NONCACHE;
1664 1664 break;
1665 1665 default:
1666 1666 DBG(DBG_MMU, NULL,
1667 1667 "mmu_bypass_nocache - unknown chip type: 0x%x\n",
1668 1668 PX_CHIP_TYPE(pxu_p));
1669 1669 bypass_noncache_bit = 0;
1670 1670 break;
1671 1671 }
1672 1672 return (bypass_noncache_bit);
1673 1673 }
1674 1674
1675 1675 /*
1676 1676 * Calculate number of TSB entries for the chip.
1677 1677 */
1678 1678 /* ARGSUSED */
1679 1679 static uint_t
1680 1680 mmu_tsb_entries(caddr_t csr_base, pxu_t *pxu_p)
1681 1681 {
1682 1682 uint64_t tsb_ctrl;
1683 1683 uint_t obp_tsb_entries, obp_tsb_size;
1684 1684
1685 1685 tsb_ctrl = CSR_XR(csr_base, MMU_TSB_CONTROL);
1686 1686
1687 1687 obp_tsb_size = tsb_ctrl & 0xF;
1688 1688
1689 1689 obp_tsb_entries = MMU_TSBSIZE_TO_TSBENTRIES(obp_tsb_size);
1690 1690
1691 1691 return (obp_tsb_entries);
1692 1692 }
1693 1693
1694 1694 /*
1695 1695 * Initialize the module, but do not enable interrupts.
1696 1696 */
1697 1697 void
1698 1698 hvio_mmu_init(caddr_t csr_base, pxu_t *pxu_p)
1699 1699 {
1700 1700 uint64_t val, i, obp_tsb_pa;
1701 1701 uint_t obp_tsb_entries;
1702 1702
1703 1703 bzero(pxu_p->tsb_vaddr, pxu_p->tsb_size);
1704 1704
1705 1705 /*
1706 1706 * Preserve OBP's TSB
1707 1707 */
1708 1708 obp_tsb_pa = CSR_XR(csr_base, MMU_TSB_CONTROL) & MMU_TSB_PA_MASK;
1709 1709
1710 1710 obp_tsb_entries = mmu_tsb_entries(csr_base, pxu_p);
1711 1711
1712 1712 /* save "shape" of OBP's TSB for use during Detach */
1713 1713 pxu_p->obp_tsb_paddr = obp_tsb_pa;
1714 1714 pxu_p->obp_tsb_entries = obp_tsb_entries;
1715 1715
1716 1716 /* For each Valid TTE in OBP's TSB, save its value in px's IOTSB */
1717 1717 hvio_obptsb_attach(pxu_p);
1718 1718
1719 1719 /*
1720 1720 * Invalidate the TLB through the diagnostic register.
1721 1721 */
1722 1722
1723 1723 CSR_XS(csr_base, MMU_TTE_CACHE_INVALIDATE, -1ull);
1724 1724
1725 1725 /*
1726 1726 * Configure the Fire MMU TSB Control Register. Determine
1727 1727 * the encoding for either 8KB pages (0) or 64KB pages (1).
1728 1728 *
1729 1729 * Write the most significant 30 bits of the TSB physical address
1730 1730 * and the encoded TSB table size.
1731 1731 */
1732 1732 for (i = 8; i && (pxu_p->tsb_size < (0x2000 << i)); i--)
1733 1733 ;
1734 1734
1735 1735 val = (((((va_to_pa(pxu_p->tsb_vaddr)) >> 13) << 13) |
1736 1736 ((MMU_PAGE_SHIFT == 13) ? 0 : 1) << 8) | i);
1737 1737
1738 1738 CSR_XS(csr_base, MMU_TSB_CONTROL, val);
1739 1739
1740 1740 /*
1741 1741 * Enable the MMU, set the "TSB Cache Snoop Enable",
1742 1742 * the "Cache Mode", the "Bypass Enable" and
1743 1743 * the "Translation Enable" bits.
1744 1744 */
1745 1745 val = CSR_XR(csr_base, MMU_CONTROL_AND_STATUS);
1746 1746 val |= ((1ull << MMU_CONTROL_AND_STATUS_SE)
1747 1747 | (MMU_CONTROL_AND_STATUS_ROE_BIT63_ENABLE <<
1748 1748 MMU_CONTROL_AND_STATUS_ROE)
1749 1749 | (MMU_CONTROL_AND_STATUS_CM_MASK << MMU_CONTROL_AND_STATUS_CM)
1750 1750 | (1ull << MMU_CONTROL_AND_STATUS_BE)
1751 1751 | (1ull << MMU_CONTROL_AND_STATUS_TE));
1752 1752
1753 1753 CSR_XS(csr_base, MMU_CONTROL_AND_STATUS, val);
1754 1754
1755 1755 /*
1756 1756 * Read the register here to ensure that the previous writes to
1757 1757 * the Fire MMU registers have been flushed. (Technically, this
1758 1758 * is not entirely necessary here as we will likely do later reads
1759 1759 * during Fire initialization, but it is a small price to pay for
1760 1760 * more modular code.)
1761 1761 */
1762 1762 (void) CSR_XR(csr_base, MMU_CONTROL_AND_STATUS);
1763 1763
1764 1764 /*
1765 1765 * CSR_V TLU's UE interrupt regs (log, enable, status, clear)
1766 1766 * Plus header logs
1767 1767 */
1768 1768 DBG(DBG_MMU, NULL, "mmu_init - MMU_ERROR_LOG_ENABLE: 0x%llx\n",
1769 1769 CSR_XR(csr_base, MMU_ERROR_LOG_ENABLE));
1770 1770
1771 1771 DBG(DBG_MMU, NULL, "mmu_init - MMU_INTERRUPT_ENABLE: 0x%llx\n",
1772 1772 CSR_XR(csr_base, MMU_INTERRUPT_ENABLE));
1773 1773
1774 1774 DBG(DBG_MMU, NULL, "mmu_init - MMU_INTERRUPT_STATUS: 0x%llx\n",
1775 1775 CSR_XR(csr_base, MMU_INTERRUPT_STATUS));
1776 1776
1777 1777 DBG(DBG_MMU, NULL, "mmu_init - MMU_ERROR_STATUS_CLEAR: 0x%llx\n",
1778 1778 CSR_XR(csr_base, MMU_ERROR_STATUS_CLEAR));
1779 1779 }
1780 1780
1781 1781 /*
1782 1782 * Generic IOMMU Servies
1783 1783 */
1784 1784
1785 1785 /* ARGSUSED */
1786 1786 uint64_t
1787 1787 hvio_iommu_map(devhandle_t dev_hdl, pxu_t *pxu_p, tsbid_t tsbid, pages_t pages,
1788 1788 io_attributes_t io_attr, void *addr, size_t pfn_index, int flags)
1789 1789 {
1790 1790 tsbindex_t tsb_index = PCI_TSBID_TO_TSBINDEX(tsbid);
1791 1791 uint64_t attr = MMU_TTE_V;
1792 1792 int i;
1793 1793
1794 1794 if (io_attr & PCI_MAP_ATTR_WRITE)
1795 1795 attr |= MMU_TTE_W;
1796 1796
1797 1797 if ((PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON) &&
1798 1798 (io_attr & PCI_MAP_ATTR_RO))
1799 1799 attr |= MMU_TTE_RO;
1800 1800
1801 1801 if (attr & MMU_TTE_RO) {
1802 1802 DBG(DBG_MMU, NULL, "hvio_iommu_map: pfn_index=0x%x "
1803 1803 "pages=0x%x attr = 0x%lx\n", pfn_index, pages, attr);
1804 1804 }
1805 1805
1806 1806 if (flags & MMU_MAP_PFN) {
1807 1807 ddi_dma_impl_t *mp = (ddi_dma_impl_t *)addr;
1808 1808 for (i = 0; i < pages; i++, pfn_index++, tsb_index++) {
1809 1809 px_iopfn_t pfn = PX_GET_MP_PFN(mp, pfn_index);
1810 1810 pxu_p->tsb_vaddr[tsb_index] = MMU_PTOB(pfn) | attr;
1811 1811
1812 1812 /*
1813 1813 * Oberon will need to flush the corresponding TTEs in
1814 1814 * Cache. We only need to flush every cache line.
1815 1815 * Extra PIO's are expensive.
1816 1816 */
1817 1817 if (PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON) {
1818 1818 if ((i == (pages-1))||!((tsb_index+1) & 0x7)) {
1819 1819 CSR_XS(dev_hdl,
1820 1820 MMU_TTE_CACHE_FLUSH_ADDRESS,
1821 1821 (pxu_p->tsb_paddr+
1822 1822 (tsb_index*MMU_TTE_SIZE)));
1823 1823 }
1824 1824 }
1825 1825 }
1826 1826 } else {
1827 1827 caddr_t a = (caddr_t)addr;
1828 1828 for (i = 0; i < pages; i++, a += MMU_PAGE_SIZE, tsb_index++) {
1829 1829 px_iopfn_t pfn = hat_getpfnum(kas.a_hat, a);
1830 1830 pxu_p->tsb_vaddr[tsb_index] = MMU_PTOB(pfn) | attr;
1831 1831
1832 1832 /*
1833 1833 * Oberon will need to flush the corresponding TTEs in
1834 1834 * Cache. We only need to flush every cache line.
1835 1835 * Extra PIO's are expensive.
1836 1836 */
1837 1837 if (PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON) {
1838 1838 if ((i == (pages-1))||!((tsb_index+1) & 0x7)) {
1839 1839 CSR_XS(dev_hdl,
1840 1840 MMU_TTE_CACHE_FLUSH_ADDRESS,
1841 1841 (pxu_p->tsb_paddr+
1842 1842 (tsb_index*MMU_TTE_SIZE)));
1843 1843 }
1844 1844 }
1845 1845 }
1846 1846 }
1847 1847
1848 1848 return (H_EOK);
1849 1849 }
1850 1850
1851 1851 /* ARGSUSED */
1852 1852 uint64_t
1853 1853 hvio_iommu_demap(devhandle_t dev_hdl, pxu_t *pxu_p, tsbid_t tsbid,
1854 1854 pages_t pages)
1855 1855 {
1856 1856 tsbindex_t tsb_index = PCI_TSBID_TO_TSBINDEX(tsbid);
1857 1857 int i;
1858 1858
1859 1859 for (i = 0; i < pages; i++, tsb_index++) {
1860 1860 pxu_p->tsb_vaddr[tsb_index] = MMU_INVALID_TTE;
1861 1861
1862 1862 /*
1863 1863 * Oberon will need to flush the corresponding TTEs in
1864 1864 * Cache. We only need to flush every cache line.
1865 1865 * Extra PIO's are expensive.
1866 1866 */
1867 1867 if (PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON) {
1868 1868 if ((i == (pages-1))||!((tsb_index+1) & 0x7)) {
1869 1869 CSR_XS(dev_hdl,
1870 1870 MMU_TTE_CACHE_FLUSH_ADDRESS,
1871 1871 (pxu_p->tsb_paddr+
1872 1872 (tsb_index*MMU_TTE_SIZE)));
1873 1873 }
1874 1874 }
1875 1875 }
1876 1876
1877 1877 return (H_EOK);
1878 1878 }
1879 1879
1880 1880 /* ARGSUSED */
1881 1881 uint64_t
1882 1882 hvio_iommu_getmap(devhandle_t dev_hdl, pxu_t *pxu_p, tsbid_t tsbid,
1883 1883 io_attributes_t *attr_p, r_addr_t *r_addr_p)
1884 1884 {
1885 1885 tsbindex_t tsb_index = PCI_TSBID_TO_TSBINDEX(tsbid);
1886 1886 uint64_t *tte_addr;
1887 1887 uint64_t ret = H_EOK;
1888 1888
1889 1889 tte_addr = (uint64_t *)(pxu_p->tsb_vaddr) + tsb_index;
1890 1890
1891 1891 if (*tte_addr & MMU_TTE_V) {
1892 1892 *r_addr_p = mmu_tte_to_pa(*tte_addr, pxu_p);
1893 1893 *attr_p = (*tte_addr & MMU_TTE_W) ?
1894 1894 PCI_MAP_ATTR_WRITE:PCI_MAP_ATTR_READ;
1895 1895 } else {
1896 1896 *r_addr_p = 0;
1897 1897 *attr_p = 0;
1898 1898 ret = H_ENOMAP;
1899 1899 }
1900 1900
1901 1901 return (ret);
1902 1902 }
1903 1903
1904 1904 /*
1905 1905 * Copy each Valid OBP TTE from OBP's IOTSB to px's IOTSB.
1906 1906 */
1907 1907 void
1908 1908 hvio_obptsb_attach(pxu_t *pxu_p)
1909 1909 {
1910 1910 uint64_t obp_tsb_pa;
1911 1911 uint64_t *base_tte_addr;
1912 1912 uint64_t i;
1913 1913 uint_t obp_tsb_entries;
1914 1914
1915 1915 obp_tsb_pa = pxu_p->obp_tsb_paddr;
1916 1916 obp_tsb_entries = pxu_p->obp_tsb_entries;
1917 1917
1918 1918 /*
1919 1919 * Compute the starting addr of the area reserved for
1920 1920 * OBP's TTEs; OBP's TTEs are stored at the highest addrs
1921 1921 * of px's IOTSB.
1922 1922 */
1923 1923 base_tte_addr = pxu_p->tsb_vaddr +
1924 1924 ((pxu_p->tsb_size >> 3) - obp_tsb_entries);
1925 1925
1926 1926 for (i = 0; i < obp_tsb_entries; i++) {
1927 1927 uint64_t tte = lddphys(obp_tsb_pa + i * 8);
1928 1928
1929 1929 if (!MMU_TTE_VALID(tte))
1930 1930 continue;
1931 1931
1932 1932 base_tte_addr[i] = tte;
1933 1933 }
1934 1934 }
1935 1935
1936 1936 /*
1937 1937 * For each Valid OBP TTE, deallocate space from the vmem Arena used
1938 1938 * to manage the TTE's associated DVMA addr space. (Allocation from
1939 1939 * the DVMA Arena was done in px_mmu_attach).
1940 1940 */
1941 1941 void
1942 1942 hvio_obptsb_detach(px_t *px_p)
1943 1943 {
1944 1944 uint64_t obp_tsb_pa;
1945 1945 uint64_t i;
1946 1946 uint_t obp_tsb_entries;
1947 1947 uint_t obp_tsb_bias;
1948 1948 px_mmu_t *mmu_p = px_p->px_mmu_p;
1949 1949 vmem_t *dvma_map;
1950 1950 pxu_t *pxu_p = (pxu_t *)px_p->px_plat_p;
1951 1951
1952 1952 dvma_map = mmu_p->mmu_dvma_map;
1953 1953
1954 1954 obp_tsb_pa = pxu_p->obp_tsb_paddr;
1955 1955 obp_tsb_entries = pxu_p->obp_tsb_entries;
1956 1956 /*
1957 1957 * OBP's TTEs are located at the high end of px's IOTSB.
1958 1958 * Equivalently, OBP's DVMA space is allocated at the high end
1959 1959 * of px's DVMA space. Compute the bias that references
1960 1960 * OBP's first possible page of DVMA space.
1961 1961 */
1962 1962 obp_tsb_bias = (pxu_p->tsb_size >> 3) - obp_tsb_entries;
1963 1963
1964 1964 for (i = 0; i < obp_tsb_entries; i++) {
1965 1965 caddr_t va;
1966 1966 uint64_t tte = lddphys(obp_tsb_pa + i * 8);
1967 1967
1968 1968 if (!MMU_TTE_VALID(tte))
1969 1969 continue;
1970 1970
1971 1971 /* deallocate the TTE's associated page of DVMA space */
1972 1972 va = (caddr_t)(MMU_PTOB(mmu_p->dvma_base_pg + obp_tsb_bias +
1973 1973 i));
1974 1974 vmem_xfree(dvma_map, va, MMU_PAGE_SIZE);
1975 1975 }
1976 1976 }
1977 1977
1978 1978 /* ARGSUSED */
1979 1979 uint64_t
1980 1980 hvio_get_bypass_base(pxu_t *pxu_p)
1981 1981 {
1982 1982 uint64_t base;
1983 1983
1984 1984 switch (PX_CHIP_TYPE(pxu_p)) {
1985 1985 case PX_CHIP_OBERON:
1986 1986 base = MMU_OBERON_BYPASS_BASE;
1987 1987 break;
1988 1988 case PX_CHIP_FIRE:
1989 1989 base = MMU_FIRE_BYPASS_BASE;
1990 1990 break;
1991 1991 default:
1992 1992 DBG(DBG_MMU, NULL,
1993 1993 "hvio_get_bypass_base - unknown chip type: 0x%x\n",
1994 1994 PX_CHIP_TYPE(pxu_p));
1995 1995 base = 0;
1996 1996 break;
1997 1997 }
1998 1998 return (base);
1999 1999 }
2000 2000
2001 2001 /* ARGSUSED */
2002 2002 uint64_t
2003 2003 hvio_get_bypass_end(pxu_t *pxu_p)
2004 2004 {
2005 2005 uint64_t end;
2006 2006
2007 2007 switch (PX_CHIP_TYPE(pxu_p)) {
2008 2008 case PX_CHIP_OBERON:
2009 2009 end = MMU_OBERON_BYPASS_END;
2010 2010 break;
2011 2011 case PX_CHIP_FIRE:
2012 2012 end = MMU_FIRE_BYPASS_END;
2013 2013 break;
2014 2014 default:
2015 2015 DBG(DBG_MMU, NULL,
2016 2016 "hvio_get_bypass_end - unknown chip type: 0x%x\n",
2017 2017 PX_CHIP_TYPE(pxu_p));
2018 2018 end = 0;
2019 2019 break;
2020 2020 }
2021 2021 return (end);
2022 2022 }
2023 2023
2024 2024 /* ARGSUSED */
2025 2025 uint64_t
2026 2026 hvio_iommu_getbypass(devhandle_t dev_hdl, pxu_t *pxu_p, r_addr_t ra,
2027 2027 io_attributes_t attr, io_addr_t *io_addr_p)
2028 2028 {
2029 2029 uint64_t pfn = MMU_BTOP(ra);
2030 2030
2031 2031 *io_addr_p = hvio_get_bypass_base(pxu_p) | ra |
2032 2032 (pf_is_memory(pfn) ? 0 : mmu_bypass_noncache(pxu_p));
2033 2033
2034 2034 return (H_EOK);
2035 2035 }
2036 2036
2037 2037 /*
2038 2038 * Generic IO Interrupt Servies
2039 2039 */
2040 2040
2041 2041 /*
2042 2042 * Converts a device specific interrupt number given by the
2043 2043 * arguments devhandle and devino into a system specific ino.
2044 2044 */
2045 2045 /* ARGSUSED */
2046 2046 uint64_t
2047 2047 hvio_intr_devino_to_sysino(devhandle_t dev_hdl, pxu_t *pxu_p, devino_t devino,
2048 2048 sysino_t *sysino)
2049 2049 {
2050 2050 if (devino > INTERRUPT_MAPPING_ENTRIES) {
2051 2051 DBG(DBG_IB, NULL, "ino %x is invalid\n", devino);
2052 2052 return (H_ENOINTR);
2053 2053 }
2054 2054
2055 2055 *sysino = DEVINO_TO_SYSINO(pxu_p->portid, devino);
2056 2056
2057 2057 return (H_EOK);
2058 2058 }
2059 2059
2060 2060 /*
2061 2061 * Returns state in intr_valid_state if the interrupt defined by sysino
2062 2062 * is valid (enabled) or not-valid (disabled).
2063 2063 */
2064 2064 uint64_t
2065 2065 hvio_intr_getvalid(devhandle_t dev_hdl, sysino_t sysino,
2066 2066 intr_valid_state_t *intr_valid_state)
2067 2067 {
2068 2068 if (CSRA_BR((caddr_t)dev_hdl, INTERRUPT_MAPPING,
2069 2069 SYSINO_TO_DEVINO(sysino), ENTRIES_V)) {
2070 2070 *intr_valid_state = INTR_VALID;
2071 2071 } else {
2072 2072 *intr_valid_state = INTR_NOTVALID;
2073 2073 }
2074 2074
2075 2075 return (H_EOK);
2076 2076 }
2077 2077
2078 2078 /*
2079 2079 * Sets the 'valid' state of the interrupt defined by
2080 2080 * the argument sysino to the state defined by the
2081 2081 * argument intr_valid_state.
2082 2082 */
2083 2083 uint64_t
2084 2084 hvio_intr_setvalid(devhandle_t dev_hdl, sysino_t sysino,
2085 2085 intr_valid_state_t intr_valid_state)
2086 2086 {
2087 2087 switch (intr_valid_state) {
2088 2088 case INTR_VALID:
2089 2089 CSRA_BS((caddr_t)dev_hdl, INTERRUPT_MAPPING,
2090 2090 SYSINO_TO_DEVINO(sysino), ENTRIES_V);
2091 2091 break;
2092 2092 case INTR_NOTVALID:
2093 2093 CSRA_BC((caddr_t)dev_hdl, INTERRUPT_MAPPING,
2094 2094 SYSINO_TO_DEVINO(sysino), ENTRIES_V);
2095 2095 break;
2096 2096 default:
2097 2097 return (EINVAL);
2098 2098 }
2099 2099
2100 2100 return (H_EOK);
2101 2101 }
2102 2102
2103 2103 /*
2104 2104 * Returns the current state of the interrupt given by the sysino
2105 2105 * argument.
2106 2106 */
2107 2107 uint64_t
2108 2108 hvio_intr_getstate(devhandle_t dev_hdl, sysino_t sysino,
2109 2109 intr_state_t *intr_state)
2110 2110 {
2111 2111 intr_state_t state;
2112 2112
2113 2113 state = CSRA_FR((caddr_t)dev_hdl, INTERRUPT_CLEAR,
2114 2114 SYSINO_TO_DEVINO(sysino), ENTRIES_INT_STATE);
2115 2115
2116 2116 switch (state) {
2117 2117 case INTERRUPT_IDLE_STATE:
2118 2118 *intr_state = INTR_IDLE_STATE;
2119 2119 break;
2120 2120 case INTERRUPT_RECEIVED_STATE:
2121 2121 *intr_state = INTR_RECEIVED_STATE;
2122 2122 break;
2123 2123 case INTERRUPT_PENDING_STATE:
2124 2124 *intr_state = INTR_DELIVERED_STATE;
2125 2125 break;
2126 2126 default:
2127 2127 return (EINVAL);
2128 2128 }
2129 2129
2130 2130 return (H_EOK);
2131 2131
2132 2132 }
2133 2133
2134 2134 /*
2135 2135 * Sets the current state of the interrupt given by the sysino
2136 2136 * argument to the value given in the argument intr_state.
2137 2137 *
2138 2138 * Note: Setting the state to INTR_IDLE clears any pending
2139 2139 * interrupt for sysino.
2140 2140 */
2141 2141 uint64_t
2142 2142 hvio_intr_setstate(devhandle_t dev_hdl, sysino_t sysino,
2143 2143 intr_state_t intr_state)
2144 2144 {
2145 2145 intr_state_t state;
2146 2146
2147 2147 switch (intr_state) {
2148 2148 case INTR_IDLE_STATE:
2149 2149 state = INTERRUPT_IDLE_STATE;
2150 2150 break;
2151 2151 case INTR_DELIVERED_STATE:
2152 2152 state = INTERRUPT_PENDING_STATE;
2153 2153 break;
2154 2154 default:
2155 2155 return (EINVAL);
2156 2156 }
2157 2157
2158 2158 CSRA_FS((caddr_t)dev_hdl, INTERRUPT_CLEAR,
2159 2159 SYSINO_TO_DEVINO(sysino), ENTRIES_INT_STATE, state);
2160 2160
2161 2161 return (H_EOK);
2162 2162 }
2163 2163
2164 2164 /*
2165 2165 * Returns the cpuid that is the current target of the
2166 2166 * interrupt given by the sysino argument.
2167 2167 *
2168 2168 * The cpuid value returned is undefined if the target
2169 2169 * has not been set via intr_settarget.
2170 2170 */
2171 2171 uint64_t
2172 2172 hvio_intr_gettarget(devhandle_t dev_hdl, pxu_t *pxu_p, sysino_t sysino,
2173 2173 cpuid_t *cpuid)
2174 2174 {
2175 2175 switch (PX_CHIP_TYPE(pxu_p)) {
2176 2176 case PX_CHIP_OBERON:
2177 2177 *cpuid = CSRA_FR((caddr_t)dev_hdl, INTERRUPT_MAPPING,
2178 2178 SYSINO_TO_DEVINO(sysino), ENTRIES_T_DESTID);
2179 2179 break;
2180 2180 case PX_CHIP_FIRE:
2181 2181 *cpuid = CSRA_FR((caddr_t)dev_hdl, INTERRUPT_MAPPING,
2182 2182 SYSINO_TO_DEVINO(sysino), ENTRIES_T_JPID);
2183 2183 break;
2184 2184 default:
2185 2185 DBG(DBG_CB, NULL, "hvio_intr_gettarget - "
2186 2186 "unknown chip type: 0x%x\n", PX_CHIP_TYPE(pxu_p));
2187 2187 return (EINVAL);
2188 2188 }
2189 2189
2190 2190 return (H_EOK);
2191 2191 }
2192 2192
2193 2193 /*
2194 2194 * Set the target cpu for the interrupt defined by the argument
2195 2195 * sysino to the target cpu value defined by the argument cpuid.
2196 2196 */
2197 2197 uint64_t
2198 2198 hvio_intr_settarget(devhandle_t dev_hdl, pxu_t *pxu_p, sysino_t sysino,
2199 2199 cpuid_t cpuid)
2200 2200 {
2201 2201 uint64_t val, intr_controller;
2202 2202 uint32_t ino = SYSINO_TO_DEVINO(sysino);
2203 2203
2204 2204 /*
2205 2205 * For now, we assign interrupt controller in a round
2206 2206 * robin fashion. Later, we may need to come up with
2207 2207 * a more efficient assignment algorithm.
2208 2208 */
2209 2209 intr_controller = 0x1ull << (cpuid % 4);
2210 2210
2211 2211 switch (PX_CHIP_TYPE(pxu_p)) {
2212 2212 case PX_CHIP_OBERON:
2213 2213 val = (((cpuid &
2214 2214 INTERRUPT_MAPPING_ENTRIES_T_DESTID_MASK) <<
2215 2215 INTERRUPT_MAPPING_ENTRIES_T_DESTID) |
2216 2216 ((intr_controller &
2217 2217 INTERRUPT_MAPPING_ENTRIES_INT_CNTRL_NUM_MASK)
2218 2218 << INTERRUPT_MAPPING_ENTRIES_INT_CNTRL_NUM));
2219 2219 break;
2220 2220 case PX_CHIP_FIRE:
2221 2221 val = (((cpuid & INTERRUPT_MAPPING_ENTRIES_T_JPID_MASK) <<
2222 2222 INTERRUPT_MAPPING_ENTRIES_T_JPID) |
2223 2223 ((intr_controller &
2224 2224 INTERRUPT_MAPPING_ENTRIES_INT_CNTRL_NUM_MASK)
2225 2225 << INTERRUPT_MAPPING_ENTRIES_INT_CNTRL_NUM));
2226 2226 break;
2227 2227 default:
2228 2228 DBG(DBG_CB, NULL, "hvio_intr_settarget - "
2229 2229 "unknown chip type: 0x%x\n", PX_CHIP_TYPE(pxu_p));
2230 2230 return (EINVAL);
2231 2231 }
2232 2232
2233 2233 /* For EQ interrupts, set DATA MONDO bit */
2234 2234 if ((ino >= EQ_1ST_DEVINO) && (ino < (EQ_1ST_DEVINO + EQ_CNT)))
2235 2235 val |= (0x1ull << INTERRUPT_MAPPING_ENTRIES_MDO_MODE);
2236 2236
2237 2237 CSRA_XS((caddr_t)dev_hdl, INTERRUPT_MAPPING, ino, val);
2238 2238
2239 2239 return (H_EOK);
2240 2240 }
2241 2241
2242 2242 /*
2243 2243 * MSIQ Functions:
2244 2244 */
2245 2245 uint64_t
2246 2246 hvio_msiq_init(devhandle_t dev_hdl, pxu_t *pxu_p)
2247 2247 {
2248 2248 CSRA_XS((caddr_t)dev_hdl, EVENT_QUEUE_BASE_ADDRESS, 0,
2249 2249 (uint64_t)pxu_p->msiq_mapped_p);
2250 2250 DBG(DBG_IB, NULL,
2251 2251 "hvio_msiq_init: EVENT_QUEUE_BASE_ADDRESS 0x%llx\n",
2252 2252 CSR_XR((caddr_t)dev_hdl, EVENT_QUEUE_BASE_ADDRESS));
2253 2253
2254 2254 CSRA_XS((caddr_t)dev_hdl, INTERRUPT_MONDO_DATA_0, 0,
2255 2255 (uint64_t)ID_TO_IGN(PX_CHIP_TYPE(pxu_p),
2256 2256 pxu_p->portid) << INO_BITS);
2257 2257 DBG(DBG_IB, NULL, "hvio_msiq_init: "
2258 2258 "INTERRUPT_MONDO_DATA_0: 0x%llx\n",
2259 2259 CSR_XR((caddr_t)dev_hdl, INTERRUPT_MONDO_DATA_0));
2260 2260
2261 2261 return (H_EOK);
2262 2262 }
2263 2263
2264 2264 uint64_t
2265 2265 hvio_msiq_getvalid(devhandle_t dev_hdl, msiqid_t msiq_id,
2266 2266 pci_msiq_valid_state_t *msiq_valid_state)
2267 2267 {
2268 2268 uint32_t eq_state;
2269 2269 uint64_t ret = H_EOK;
2270 2270
2271 2271 eq_state = CSRA_FR((caddr_t)dev_hdl, EVENT_QUEUE_STATE,
2272 2272 msiq_id, ENTRIES_STATE);
2273 2273
2274 2274 switch (eq_state) {
2275 2275 case EQ_IDLE_STATE:
2276 2276 *msiq_valid_state = PCI_MSIQ_INVALID;
2277 2277 break;
2278 2278 case EQ_ACTIVE_STATE:
2279 2279 case EQ_ERROR_STATE:
2280 2280 *msiq_valid_state = PCI_MSIQ_VALID;
2281 2281 break;
2282 2282 default:
2283 2283 ret = H_EIO;
2284 2284 break;
2285 2285 }
2286 2286
2287 2287 return (ret);
2288 2288 }
2289 2289
2290 2290 uint64_t
2291 2291 hvio_msiq_setvalid(devhandle_t dev_hdl, msiqid_t msiq_id,
2292 2292 pci_msiq_valid_state_t msiq_valid_state)
2293 2293 {
2294 2294 uint64_t ret = H_EOK;
2295 2295
2296 2296 switch (msiq_valid_state) {
2297 2297 case PCI_MSIQ_INVALID:
2298 2298 CSRA_BS((caddr_t)dev_hdl, EVENT_QUEUE_CONTROL_CLEAR,
2299 2299 msiq_id, ENTRIES_DIS);
2300 2300 break;
2301 2301 case PCI_MSIQ_VALID:
2302 2302 CSRA_BS((caddr_t)dev_hdl, EVENT_QUEUE_CONTROL_SET,
2303 2303 msiq_id, ENTRIES_EN);
2304 2304 break;
2305 2305 default:
2306 2306 ret = H_EINVAL;
2307 2307 break;
2308 2308 }
2309 2309
2310 2310 return (ret);
2311 2311 }
2312 2312
2313 2313 uint64_t
2314 2314 hvio_msiq_getstate(devhandle_t dev_hdl, msiqid_t msiq_id,
2315 2315 pci_msiq_state_t *msiq_state)
2316 2316 {
2317 2317 uint32_t eq_state;
2318 2318 uint64_t ret = H_EOK;
2319 2319
2320 2320 eq_state = CSRA_FR((caddr_t)dev_hdl, EVENT_QUEUE_STATE,
2321 2321 msiq_id, ENTRIES_STATE);
2322 2322
2323 2323 switch (eq_state) {
2324 2324 case EQ_IDLE_STATE:
2325 2325 case EQ_ACTIVE_STATE:
2326 2326 *msiq_state = PCI_MSIQ_STATE_IDLE;
2327 2327 break;
2328 2328 case EQ_ERROR_STATE:
2329 2329 *msiq_state = PCI_MSIQ_STATE_ERROR;
2330 2330 break;
2331 2331 default:
2332 2332 ret = H_EIO;
2333 2333 }
2334 2334
2335 2335 return (ret);
2336 2336 }
2337 2337
2338 2338 uint64_t
2339 2339 hvio_msiq_setstate(devhandle_t dev_hdl, msiqid_t msiq_id,
2340 2340 pci_msiq_state_t msiq_state)
2341 2341 {
2342 2342 uint32_t eq_state;
2343 2343 uint64_t ret = H_EOK;
2344 2344
2345 2345 eq_state = CSRA_FR((caddr_t)dev_hdl, EVENT_QUEUE_STATE,
2346 2346 msiq_id, ENTRIES_STATE);
2347 2347
2348 2348 switch (eq_state) {
2349 2349 case EQ_IDLE_STATE:
2350 2350 if (msiq_state == PCI_MSIQ_STATE_ERROR)
2351 2351 ret = H_EIO;
2352 2352 break;
2353 2353 case EQ_ACTIVE_STATE:
2354 2354 if (msiq_state == PCI_MSIQ_STATE_ERROR)
2355 2355 CSRA_BS((caddr_t)dev_hdl, EVENT_QUEUE_CONTROL_SET,
2356 2356 msiq_id, ENTRIES_ENOVERR);
2357 2357 else
2358 2358 ret = H_EIO;
2359 2359 break;
2360 2360 case EQ_ERROR_STATE:
2361 2361 if (msiq_state == PCI_MSIQ_STATE_IDLE)
2362 2362 CSRA_BS((caddr_t)dev_hdl, EVENT_QUEUE_CONTROL_CLEAR,
2363 2363 msiq_id, ENTRIES_E2I);
2364 2364 else
2365 2365 ret = H_EIO;
2366 2366 break;
2367 2367 default:
2368 2368 ret = H_EIO;
2369 2369 }
2370 2370
2371 2371 return (ret);
2372 2372 }
2373 2373
2374 2374 uint64_t
2375 2375 hvio_msiq_gethead(devhandle_t dev_hdl, msiqid_t msiq_id,
2376 2376 msiqhead_t *msiq_head)
2377 2377 {
2378 2378 *msiq_head = CSRA_FR((caddr_t)dev_hdl, EVENT_QUEUE_HEAD,
2379 2379 msiq_id, ENTRIES_HEAD);
2380 2380
2381 2381 return (H_EOK);
2382 2382 }
2383 2383
2384 2384 uint64_t
2385 2385 hvio_msiq_sethead(devhandle_t dev_hdl, msiqid_t msiq_id,
2386 2386 msiqhead_t msiq_head)
2387 2387 {
2388 2388 CSRA_FS((caddr_t)dev_hdl, EVENT_QUEUE_HEAD, msiq_id,
2389 2389 ENTRIES_HEAD, msiq_head);
2390 2390
2391 2391 return (H_EOK);
2392 2392 }
2393 2393
2394 2394 uint64_t
2395 2395 hvio_msiq_gettail(devhandle_t dev_hdl, msiqid_t msiq_id,
2396 2396 msiqtail_t *msiq_tail)
2397 2397 {
2398 2398 *msiq_tail = CSRA_FR((caddr_t)dev_hdl, EVENT_QUEUE_TAIL,
2399 2399 msiq_id, ENTRIES_TAIL);
2400 2400
2401 2401 return (H_EOK);
2402 2402 }
2403 2403
2404 2404 /*
2405 2405 * MSI Functions:
2406 2406 */
2407 2407 uint64_t
2408 2408 hvio_msi_init(devhandle_t dev_hdl, uint64_t addr32, uint64_t addr64)
2409 2409 {
2410 2410 /* PCI MEM 32 resources to perform 32 bit MSI transactions */
2411 2411 CSRA_FS((caddr_t)dev_hdl, MSI_32_BIT_ADDRESS, 0,
2412 2412 ADDR, (uint64_t)addr32 >> MSI_32_BIT_ADDRESS_ADDR);
2413 2413 DBG(DBG_IB, NULL, "hvio_msi_init: MSI_32_BIT_ADDRESS: 0x%llx\n",
2414 2414 CSR_XR((caddr_t)dev_hdl, MSI_32_BIT_ADDRESS));
2415 2415
2416 2416 /* Reserve PCI MEM 64 resources to perform 64 bit MSI transactions */
2417 2417 CSRA_FS((caddr_t)dev_hdl, MSI_64_BIT_ADDRESS, 0,
2418 2418 ADDR, (uint64_t)addr64 >> MSI_64_BIT_ADDRESS_ADDR);
2419 2419 DBG(DBG_IB, NULL, "hvio_msi_init: MSI_64_BIT_ADDRESS: 0x%llx\n",
2420 2420 CSR_XR((caddr_t)dev_hdl, MSI_64_BIT_ADDRESS));
2421 2421
2422 2422 return (H_EOK);
2423 2423 }
2424 2424
2425 2425 uint64_t
2426 2426 hvio_msi_getmsiq(devhandle_t dev_hdl, msinum_t msi_num,
2427 2427 msiqid_t *msiq_id)
2428 2428 {
2429 2429 *msiq_id = CSRA_FR((caddr_t)dev_hdl, MSI_MAPPING,
2430 2430 msi_num, ENTRIES_EQNUM);
2431 2431
2432 2432 return (H_EOK);
2433 2433 }
2434 2434
2435 2435 uint64_t
2436 2436 hvio_msi_setmsiq(devhandle_t dev_hdl, msinum_t msi_num,
2437 2437 msiqid_t msiq_id)
2438 2438 {
2439 2439 CSRA_FS((caddr_t)dev_hdl, MSI_MAPPING, msi_num,
2440 2440 ENTRIES_EQNUM, msiq_id);
2441 2441
2442 2442 return (H_EOK);
2443 2443 }
2444 2444
2445 2445 uint64_t
2446 2446 hvio_msi_getvalid(devhandle_t dev_hdl, msinum_t msi_num,
2447 2447 pci_msi_valid_state_t *msi_valid_state)
2448 2448 {
2449 2449 *msi_valid_state = CSRA_BR((caddr_t)dev_hdl, MSI_MAPPING,
2450 2450 msi_num, ENTRIES_V);
2451 2451
2452 2452 return (H_EOK);
2453 2453 }
2454 2454
2455 2455 uint64_t
2456 2456 hvio_msi_setvalid(devhandle_t dev_hdl, msinum_t msi_num,
2457 2457 pci_msi_valid_state_t msi_valid_state)
2458 2458 {
2459 2459 uint64_t ret = H_EOK;
2460 2460
2461 2461 switch (msi_valid_state) {
2462 2462 case PCI_MSI_VALID:
2463 2463 CSRA_BS((caddr_t)dev_hdl, MSI_MAPPING, msi_num,
2464 2464 ENTRIES_V);
2465 2465 break;
2466 2466 case PCI_MSI_INVALID:
2467 2467 CSRA_BC((caddr_t)dev_hdl, MSI_MAPPING, msi_num,
2468 2468 ENTRIES_V);
2469 2469 break;
2470 2470 default:
2471 2471 ret = H_EINVAL;
2472 2472 }
2473 2473
2474 2474 return (ret);
2475 2475 }
2476 2476
2477 2477 uint64_t
2478 2478 hvio_msi_getstate(devhandle_t dev_hdl, msinum_t msi_num,
2479 2479 pci_msi_state_t *msi_state)
2480 2480 {
2481 2481 *msi_state = CSRA_BR((caddr_t)dev_hdl, MSI_MAPPING,
2482 2482 msi_num, ENTRIES_EQWR_N);
2483 2483
2484 2484 return (H_EOK);
2485 2485 }
2486 2486
2487 2487 uint64_t
2488 2488 hvio_msi_setstate(devhandle_t dev_hdl, msinum_t msi_num,
2489 2489 pci_msi_state_t msi_state)
2490 2490 {
2491 2491 uint64_t ret = H_EOK;
2492 2492
2493 2493 switch (msi_state) {
2494 2494 case PCI_MSI_STATE_IDLE:
2495 2495 CSRA_BS((caddr_t)dev_hdl, MSI_CLEAR, msi_num,
2496 2496 ENTRIES_EQWR_N);
2497 2497 break;
2498 2498 case PCI_MSI_STATE_DELIVERED:
2499 2499 default:
2500 2500 ret = H_EINVAL;
2501 2501 break;
2502 2502 }
2503 2503
2504 2504 return (ret);
2505 2505 }
2506 2506
2507 2507 /*
2508 2508 * MSG Functions:
2509 2509 */
2510 2510 uint64_t
2511 2511 hvio_msg_getmsiq(devhandle_t dev_hdl, pcie_msg_type_t msg_type,
2512 2512 msiqid_t *msiq_id)
2513 2513 {
2514 2514 uint64_t ret = H_EOK;
2515 2515
2516 2516 switch (msg_type) {
2517 2517 case PCIE_PME_MSG:
2518 2518 *msiq_id = CSR_FR((caddr_t)dev_hdl, PM_PME_MAPPING, EQNUM);
2519 2519 break;
2520 2520 case PCIE_PME_ACK_MSG:
2521 2521 *msiq_id = CSR_FR((caddr_t)dev_hdl, PME_TO_ACK_MAPPING,
2522 2522 EQNUM);
2523 2523 break;
2524 2524 case PCIE_CORR_MSG:
2525 2525 *msiq_id = CSR_FR((caddr_t)dev_hdl, ERR_COR_MAPPING, EQNUM);
2526 2526 break;
2527 2527 case PCIE_NONFATAL_MSG:
2528 2528 *msiq_id = CSR_FR((caddr_t)dev_hdl, ERR_NONFATAL_MAPPING,
2529 2529 EQNUM);
2530 2530 break;
2531 2531 case PCIE_FATAL_MSG:
2532 2532 *msiq_id = CSR_FR((caddr_t)dev_hdl, ERR_FATAL_MAPPING, EQNUM);
2533 2533 break;
2534 2534 default:
2535 2535 ret = H_EINVAL;
2536 2536 break;
2537 2537 }
2538 2538
2539 2539 return (ret);
2540 2540 }
2541 2541
2542 2542 uint64_t
2543 2543 hvio_msg_setmsiq(devhandle_t dev_hdl, pcie_msg_type_t msg_type,
2544 2544 msiqid_t msiq_id)
2545 2545 {
2546 2546 uint64_t ret = H_EOK;
2547 2547
2548 2548 switch (msg_type) {
2549 2549 case PCIE_PME_MSG:
2550 2550 CSR_FS((caddr_t)dev_hdl, PM_PME_MAPPING, EQNUM, msiq_id);
2551 2551 break;
2552 2552 case PCIE_PME_ACK_MSG:
2553 2553 CSR_FS((caddr_t)dev_hdl, PME_TO_ACK_MAPPING, EQNUM, msiq_id);
2554 2554 break;
2555 2555 case PCIE_CORR_MSG:
2556 2556 CSR_FS((caddr_t)dev_hdl, ERR_COR_MAPPING, EQNUM, msiq_id);
2557 2557 break;
2558 2558 case PCIE_NONFATAL_MSG:
2559 2559 CSR_FS((caddr_t)dev_hdl, ERR_NONFATAL_MAPPING, EQNUM, msiq_id);
2560 2560 break;
2561 2561 case PCIE_FATAL_MSG:
2562 2562 CSR_FS((caddr_t)dev_hdl, ERR_FATAL_MAPPING, EQNUM, msiq_id);
2563 2563 break;
2564 2564 default:
2565 2565 ret = H_EINVAL;
2566 2566 break;
2567 2567 }
2568 2568
2569 2569 return (ret);
2570 2570 }
2571 2571
2572 2572 uint64_t
2573 2573 hvio_msg_getvalid(devhandle_t dev_hdl, pcie_msg_type_t msg_type,
2574 2574 pcie_msg_valid_state_t *msg_valid_state)
2575 2575 {
2576 2576 uint64_t ret = H_EOK;
2577 2577
2578 2578 switch (msg_type) {
2579 2579 case PCIE_PME_MSG:
2580 2580 *msg_valid_state = CSR_BR((caddr_t)dev_hdl, PM_PME_MAPPING, V);
2581 2581 break;
2582 2582 case PCIE_PME_ACK_MSG:
2583 2583 *msg_valid_state = CSR_BR((caddr_t)dev_hdl,
2584 2584 PME_TO_ACK_MAPPING, V);
2585 2585 break;
2586 2586 case PCIE_CORR_MSG:
2587 2587 *msg_valid_state = CSR_BR((caddr_t)dev_hdl, ERR_COR_MAPPING, V);
2588 2588 break;
2589 2589 case PCIE_NONFATAL_MSG:
2590 2590 *msg_valid_state = CSR_BR((caddr_t)dev_hdl,
2591 2591 ERR_NONFATAL_MAPPING, V);
2592 2592 break;
2593 2593 case PCIE_FATAL_MSG:
2594 2594 *msg_valid_state = CSR_BR((caddr_t)dev_hdl, ERR_FATAL_MAPPING,
2595 2595 V);
2596 2596 break;
2597 2597 default:
2598 2598 ret = H_EINVAL;
2599 2599 break;
2600 2600 }
2601 2601
2602 2602 return (ret);
2603 2603 }
2604 2604
2605 2605 uint64_t
2606 2606 hvio_msg_setvalid(devhandle_t dev_hdl, pcie_msg_type_t msg_type,
2607 2607 pcie_msg_valid_state_t msg_valid_state)
2608 2608 {
2609 2609 uint64_t ret = H_EOK;
2610 2610
2611 2611 switch (msg_valid_state) {
2612 2612 case PCIE_MSG_VALID:
2613 2613 switch (msg_type) {
2614 2614 case PCIE_PME_MSG:
2615 2615 CSR_BS((caddr_t)dev_hdl, PM_PME_MAPPING, V);
2616 2616 break;
2617 2617 case PCIE_PME_ACK_MSG:
2618 2618 CSR_BS((caddr_t)dev_hdl, PME_TO_ACK_MAPPING, V);
2619 2619 break;
2620 2620 case PCIE_CORR_MSG:
2621 2621 CSR_BS((caddr_t)dev_hdl, ERR_COR_MAPPING, V);
2622 2622 break;
2623 2623 case PCIE_NONFATAL_MSG:
2624 2624 CSR_BS((caddr_t)dev_hdl, ERR_NONFATAL_MAPPING, V);
2625 2625 break;
2626 2626 case PCIE_FATAL_MSG:
2627 2627 CSR_BS((caddr_t)dev_hdl, ERR_FATAL_MAPPING, V);
2628 2628 break;
2629 2629 default:
2630 2630 ret = H_EINVAL;
2631 2631 break;
2632 2632 }
2633 2633
2634 2634 break;
2635 2635 case PCIE_MSG_INVALID:
2636 2636 switch (msg_type) {
2637 2637 case PCIE_PME_MSG:
2638 2638 CSR_BC((caddr_t)dev_hdl, PM_PME_MAPPING, V);
2639 2639 break;
2640 2640 case PCIE_PME_ACK_MSG:
2641 2641 CSR_BC((caddr_t)dev_hdl, PME_TO_ACK_MAPPING, V);
2642 2642 break;
2643 2643 case PCIE_CORR_MSG:
2644 2644 CSR_BC((caddr_t)dev_hdl, ERR_COR_MAPPING, V);
2645 2645 break;
2646 2646 case PCIE_NONFATAL_MSG:
2647 2647 CSR_BC((caddr_t)dev_hdl, ERR_NONFATAL_MAPPING, V);
2648 2648 break;
2649 2649 case PCIE_FATAL_MSG:
2650 2650 CSR_BC((caddr_t)dev_hdl, ERR_FATAL_MAPPING, V);
2651 2651 break;
2652 2652 default:
2653 2653 ret = H_EINVAL;
2654 2654 break;
2655 2655 }
2656 2656 break;
2657 2657 default:
2658 2658 ret = H_EINVAL;
2659 2659 }
2660 2660
2661 2661 return (ret);
2662 2662 }
2663 2663
2664 2664 /*
2665 2665 * Suspend/Resume Functions:
2666 2666 * (pec, mmu, ib)
2667 2667 * cb
2668 2668 * Registers saved have all been touched in the XXX_init functions.
2669 2669 */
2670 2670 uint64_t
2671 2671 hvio_suspend(devhandle_t dev_hdl, pxu_t *pxu_p)
2672 2672 {
2673 2673 uint64_t *config_state;
2674 2674 int total_size;
2675 2675 int i;
2676 2676
2677 2677 if (msiq_suspend(dev_hdl, pxu_p) != H_EOK)
2678 2678 return (H_EIO);
2679 2679
2680 2680 total_size = PEC_SIZE + MMU_SIZE + IB_SIZE + IB_MAP_SIZE;
2681 2681 config_state = kmem_zalloc(total_size, KM_NOSLEEP);
2682 2682
2683 2683 if (config_state == NULL) {
2684 2684 return (H_EIO);
2685 2685 }
2686 2686
2687 2687 /*
2688 2688 * Soft state for suspend/resume from pxu_t
2689 2689 * uint64_t *pec_config_state;
2690 2690 * uint64_t *mmu_config_state;
2691 2691 * uint64_t *ib_intr_map;
2692 2692 * uint64_t *ib_config_state;
2693 2693 * uint64_t *xcb_config_state;
2694 2694 */
2695 2695
2696 2696 /* Save the PEC configuration states */
2697 2697 pxu_p->pec_config_state = config_state;
2698 2698 for (i = 0; i < PEC_KEYS; i++) {
2699 2699 if ((pec_config_state_regs[i].chip == PX_CHIP_TYPE(pxu_p)) ||
2700 2700 (pec_config_state_regs[i].chip == PX_CHIP_UNIDENTIFIED)) {
2701 2701 pxu_p->pec_config_state[i] =
2702 2702 CSR_XR((caddr_t)dev_hdl,
2703 2703 pec_config_state_regs[i].reg);
2704 2704 }
2705 2705 }
2706 2706
2707 2707 /* Save the MMU configuration states */
2708 2708 pxu_p->mmu_config_state = pxu_p->pec_config_state + PEC_KEYS;
2709 2709 for (i = 0; i < MMU_KEYS; i++) {
2710 2710 pxu_p->mmu_config_state[i] =
2711 2711 CSR_XR((caddr_t)dev_hdl, mmu_config_state_regs[i]);
2712 2712 }
2713 2713
2714 2714 /* Save the interrupt mapping registers */
2715 2715 pxu_p->ib_intr_map = pxu_p->mmu_config_state + MMU_KEYS;
2716 2716 for (i = 0; i < INTERRUPT_MAPPING_ENTRIES; i++) {
2717 2717 pxu_p->ib_intr_map[i] =
2718 2718 CSRA_XR((caddr_t)dev_hdl, INTERRUPT_MAPPING, i);
2719 2719 }
2720 2720
2721 2721 /* Save the IB configuration states */
2722 2722 pxu_p->ib_config_state = pxu_p->ib_intr_map + INTERRUPT_MAPPING_ENTRIES;
2723 2723 for (i = 0; i < IB_KEYS; i++) {
2724 2724 pxu_p->ib_config_state[i] =
2725 2725 CSR_XR((caddr_t)dev_hdl, ib_config_state_regs[i]);
2726 2726 }
2727 2727
2728 2728 return (H_EOK);
2729 2729 }
2730 2730
2731 2731 void
2732 2732 hvio_resume(devhandle_t dev_hdl, devino_t devino, pxu_t *pxu_p)
2733 2733 {
2734 2734 int total_size;
2735 2735 sysino_t sysino;
2736 2736 int i;
2737 2737 uint64_t ret;
2738 2738
2739 2739 /* Make sure that suspend actually did occur */
2740 2740 if (!pxu_p->pec_config_state) {
2741 2741 return;
2742 2742 }
2743 2743
2744 2744 /* Restore IB configuration states */
2745 2745 for (i = 0; i < IB_KEYS; i++) {
2746 2746 CSR_XS((caddr_t)dev_hdl, ib_config_state_regs[i],
2747 2747 pxu_p->ib_config_state[i]);
2748 2748 }
2749 2749
2750 2750 /*
2751 2751 * Restore the interrupt mapping registers
2752 2752 * And make sure the intrs are idle.
2753 2753 */
2754 2754 for (i = 0; i < INTERRUPT_MAPPING_ENTRIES; i++) {
2755 2755 CSRA_FS((caddr_t)dev_hdl, INTERRUPT_CLEAR, i,
2756 2756 ENTRIES_INT_STATE, INTERRUPT_IDLE_STATE);
2757 2757 CSRA_XS((caddr_t)dev_hdl, INTERRUPT_MAPPING, i,
2758 2758 pxu_p->ib_intr_map[i]);
2759 2759 }
2760 2760
2761 2761 /* Restore MMU configuration states */
2762 2762 /* Clear the cache. */
2763 2763 CSR_XS((caddr_t)dev_hdl, MMU_TTE_CACHE_INVALIDATE, -1ull);
2764 2764
2765 2765 for (i = 0; i < MMU_KEYS; i++) {
2766 2766 CSR_XS((caddr_t)dev_hdl, mmu_config_state_regs[i],
2767 2767 pxu_p->mmu_config_state[i]);
2768 2768 }
2769 2769
2770 2770 /* Restore PEC configuration states */
2771 2771 /* Make sure all reset bits are low until error is detected */
2772 2772 CSR_XS((caddr_t)dev_hdl, LPU_RESET, 0ull);
2773 2773
2774 2774 for (i = 0; i < PEC_KEYS; i++) {
2775 2775 if ((pec_config_state_regs[i].chip == PX_CHIP_TYPE(pxu_p)) ||
2776 2776 (pec_config_state_regs[i].chip == PX_CHIP_UNIDENTIFIED)) {
2777 2777 CSR_XS((caddr_t)dev_hdl, pec_config_state_regs[i].reg,
2778 2778 pxu_p->pec_config_state[i]);
2779 2779 }
2780 2780 }
2781 2781
2782 2782 /* Enable PCI-E interrupt */
2783 2783 if ((ret = hvio_intr_devino_to_sysino(dev_hdl, pxu_p, devino,
2784 2784 &sysino)) != H_EOK) {
2785 2785 cmn_err(CE_WARN,
2786 2786 "hvio_resume: hvio_intr_devino_to_sysino failed, "
2787 2787 "ret 0x%lx", ret);
2788 2788 }
2789 2789
2790 2790 if ((ret = hvio_intr_setstate(dev_hdl, sysino, INTR_IDLE_STATE))
2791 2791 != H_EOK) {
2792 2792 cmn_err(CE_WARN,
2793 2793 "hvio_resume: hvio_intr_setstate failed, "
2794 2794 "ret 0x%lx", ret);
2795 2795 }
2796 2796
2797 2797 total_size = PEC_SIZE + MMU_SIZE + IB_SIZE + IB_MAP_SIZE;
2798 2798 kmem_free(pxu_p->pec_config_state, total_size);
2799 2799
2800 2800 pxu_p->pec_config_state = NULL;
2801 2801 pxu_p->mmu_config_state = NULL;
2802 2802 pxu_p->ib_config_state = NULL;
2803 2803 pxu_p->ib_intr_map = NULL;
2804 2804
2805 2805 msiq_resume(dev_hdl, pxu_p);
2806 2806 }
2807 2807
2808 2808 uint64_t
2809 2809 hvio_cb_suspend(devhandle_t dev_hdl, pxu_t *pxu_p)
2810 2810 {
2811 2811 uint64_t *config_state, *cb_regs;
2812 2812 int i, cb_size, cb_keys;
2813 2813
2814 2814 switch (PX_CHIP_TYPE(pxu_p)) {
2815 2815 case PX_CHIP_OBERON:
2816 2816 cb_size = UBC_SIZE;
2817 2817 cb_keys = UBC_KEYS;
2818 2818 cb_regs = ubc_config_state_regs;
2819 2819 break;
2820 2820 case PX_CHIP_FIRE:
2821 2821 cb_size = JBC_SIZE;
2822 2822 cb_keys = JBC_KEYS;
2823 2823 cb_regs = jbc_config_state_regs;
2824 2824 break;
2825 2825 default:
2826 2826 DBG(DBG_CB, NULL, "hvio_cb_suspend - unknown chip type: 0x%x\n",
2827 2827 PX_CHIP_TYPE(pxu_p));
2828 2828 break;
2829 2829 }
2830 2830
2831 2831 config_state = kmem_zalloc(cb_size, KM_NOSLEEP);
2832 2832
2833 2833 if (config_state == NULL) {
2834 2834 return (H_EIO);
2835 2835 }
2836 2836
2837 2837 /* Save the configuration states */
2838 2838 pxu_p->xcb_config_state = config_state;
2839 2839 for (i = 0; i < cb_keys; i++) {
2840 2840 pxu_p->xcb_config_state[i] =
2841 2841 CSR_XR((caddr_t)dev_hdl, cb_regs[i]);
2842 2842 }
2843 2843
2844 2844 return (H_EOK);
2845 2845 }
2846 2846
2847 2847 void
2848 2848 hvio_cb_resume(devhandle_t pci_dev_hdl, devhandle_t xbus_dev_hdl,
2849 2849 devino_t devino, pxu_t *pxu_p)
2850 2850 {
2851 2851 sysino_t sysino;
2852 2852 uint64_t *cb_regs;
2853 2853 int i, cb_size, cb_keys;
2854 2854 uint64_t ret;
2855 2855
2856 2856 switch (PX_CHIP_TYPE(pxu_p)) {
2857 2857 case PX_CHIP_OBERON:
2858 2858 cb_size = UBC_SIZE;
2859 2859 cb_keys = UBC_KEYS;
2860 2860 cb_regs = ubc_config_state_regs;
2861 2861 /*
2862 2862 * No reason to have any reset bits high until an error is
2863 2863 * detected on the link.
2864 2864 */
2865 2865 CSR_XS((caddr_t)xbus_dev_hdl, UBC_ERROR_STATUS_CLEAR, -1ull);
2866 2866 break;
2867 2867 case PX_CHIP_FIRE:
2868 2868 cb_size = JBC_SIZE;
2869 2869 cb_keys = JBC_KEYS;
2870 2870 cb_regs = jbc_config_state_regs;
2871 2871 /*
2872 2872 * No reason to have any reset bits high until an error is
2873 2873 * detected on the link.
2874 2874 */
2875 2875 CSR_XS((caddr_t)xbus_dev_hdl, JBC_ERROR_STATUS_CLEAR, -1ull);
2876 2876 break;
2877 2877 default:
2878 2878 DBG(DBG_CB, NULL, "hvio_cb_resume - unknown chip type: 0x%x\n",
2879 2879 PX_CHIP_TYPE(pxu_p));
2880 2880 break;
2881 2881 }
2882 2882
2883 2883 ASSERT(pxu_p->xcb_config_state);
2884 2884
2885 2885 /* Restore the configuration states */
2886 2886 for (i = 0; i < cb_keys; i++) {
2887 2887 CSR_XS((caddr_t)xbus_dev_hdl, cb_regs[i],
2888 2888 pxu_p->xcb_config_state[i]);
2889 2889 }
2890 2890
2891 2891 /* Enable XBC interrupt */
2892 2892 if ((ret = hvio_intr_devino_to_sysino(pci_dev_hdl, pxu_p, devino,
2893 2893 &sysino)) != H_EOK) {
2894 2894 cmn_err(CE_WARN,
2895 2895 "hvio_cb_resume: hvio_intr_devino_to_sysino failed, "
2896 2896 "ret 0x%lx", ret);
2897 2897 }
2898 2898
2899 2899 if ((ret = hvio_intr_setstate(pci_dev_hdl, sysino, INTR_IDLE_STATE))
2900 2900 != H_EOK) {
2901 2901 cmn_err(CE_WARN,
2902 2902 "hvio_cb_resume: hvio_intr_setstate failed, "
2903 2903 "ret 0x%lx", ret);
2904 2904 }
2905 2905
2906 2906 kmem_free(pxu_p->xcb_config_state, cb_size);
2907 2907
2908 2908 pxu_p->xcb_config_state = NULL;
2909 2909 }
2910 2910
2911 2911 static uint64_t
2912 2912 msiq_suspend(devhandle_t dev_hdl, pxu_t *pxu_p)
2913 2913 {
2914 2914 size_t bufsz;
2915 2915 volatile uint64_t *cur_p;
2916 2916 int i;
2917 2917
2918 2918 bufsz = MSIQ_STATE_SIZE + MSIQ_MAPPING_SIZE + MSIQ_OTHER_SIZE;
2919 2919 if ((pxu_p->msiq_config_state = kmem_zalloc(bufsz, KM_NOSLEEP)) ==
2920 2920 NULL)
2921 2921 return (H_EIO);
2922 2922
2923 2923 cur_p = pxu_p->msiq_config_state;
2924 2924
2925 2925 /* Save each EQ state */
2926 2926 for (i = 0; i < EVENT_QUEUE_STATE_ENTRIES; i++, cur_p++)
2927 2927 *cur_p = CSRA_XR((caddr_t)dev_hdl, EVENT_QUEUE_STATE, i);
2928 2928
2929 2929 /* Save MSI mapping registers */
2930 2930 for (i = 0; i < MSI_MAPPING_ENTRIES; i++, cur_p++)
2931 2931 *cur_p = CSRA_XR((caddr_t)dev_hdl, MSI_MAPPING, i);
2932 2932
2933 2933 /* Save all other MSIQ registers */
2934 2934 for (i = 0; i < MSIQ_OTHER_KEYS; i++, cur_p++)
2935 2935 *cur_p = CSR_XR((caddr_t)dev_hdl, msiq_config_other_regs[i]);
2936 2936 return (H_EOK);
2937 2937 }
2938 2938
2939 2939 static void
2940 2940 msiq_resume(devhandle_t dev_hdl, pxu_t *pxu_p)
2941 2941 {
2942 2942 size_t bufsz;
2943 2943 uint64_t *cur_p, state;
2944 2944 int i;
2945 2945 uint64_t ret;
2946 2946
2947 2947 bufsz = MSIQ_STATE_SIZE + MSIQ_MAPPING_SIZE + MSIQ_OTHER_SIZE;
2948 2948 cur_p = pxu_p->msiq_config_state;
2949 2949 /*
2950 2950 * Initialize EQ base address register and
2951 2951 * Interrupt Mondo Data 0 register.
2952 2952 */
2953 2953 if ((ret = hvio_msiq_init(dev_hdl, pxu_p)) != H_EOK) {
2954 2954 cmn_err(CE_WARN,
2955 2955 "msiq_resume: hvio_msiq_init failed, "
2956 2956 "ret 0x%lx", ret);
2957 2957 }
2958 2958
2959 2959 /* Restore EQ states */
2960 2960 for (i = 0; i < EVENT_QUEUE_STATE_ENTRIES; i++, cur_p++) {
2961 2961 state = (*cur_p) & EVENT_QUEUE_STATE_ENTRIES_STATE_MASK;
2962 2962 if ((state == EQ_ACTIVE_STATE) || (state == EQ_ERROR_STATE))
2963 2963 CSRA_BS((caddr_t)dev_hdl, EVENT_QUEUE_CONTROL_SET,
2964 2964 i, ENTRIES_EN);
2965 2965 }
2966 2966
2967 2967 /* Restore MSI mapping */
2968 2968 for (i = 0; i < MSI_MAPPING_ENTRIES; i++, cur_p++)
2969 2969 CSRA_XS((caddr_t)dev_hdl, MSI_MAPPING, i, *cur_p);
2970 2970
2971 2971 /*
2972 2972 * Restore all other registers. MSI 32 bit address and
2973 2973 * MSI 64 bit address are restored as part of this.
2974 2974 */
2975 2975 for (i = 0; i < MSIQ_OTHER_KEYS; i++, cur_p++)
2976 2976 CSR_XS((caddr_t)dev_hdl, msiq_config_other_regs[i], *cur_p);
2977 2977
2978 2978 kmem_free(pxu_p->msiq_config_state, bufsz);
2979 2979 pxu_p->msiq_config_state = NULL;
2980 2980 }
2981 2981
2982 2982 /*
2983 2983 * sends PME_Turn_Off message to put the link in L2/L3 ready state.
2984 2984 * called by px_goto_l23ready.
2985 2985 * returns DDI_SUCCESS or DDI_FAILURE
2986 2986 */
2987 2987 int
2988 2988 px_send_pme_turnoff(caddr_t csr_base)
2989 2989 {
2990 2990 volatile uint64_t reg;
2991 2991
2992 2992 reg = CSR_XR(csr_base, TLU_PME_TURN_OFF_GENERATE);
2993 2993 /* If already pending, return failure */
2994 2994 if (reg & (1ull << TLU_PME_TURN_OFF_GENERATE_PTO)) {
2995 2995 DBG(DBG_PWR, NULL, "send_pme_turnoff: pending PTO bit "
2996 2996 "tlu_pme_turn_off_generate = %x\n", reg);
2997 2997 return (DDI_FAILURE);
2998 2998 }
2999 2999
3000 3000 /* write to PME_Turn_off reg to boradcast */
3001 3001 reg |= (1ull << TLU_PME_TURN_OFF_GENERATE_PTO);
3002 3002 CSR_XS(csr_base, TLU_PME_TURN_OFF_GENERATE, reg);
3003 3003
3004 3004 return (DDI_SUCCESS);
3005 3005 }
3006 3006
3007 3007 /*
3008 3008 * Checks for link being in L1idle state.
3009 3009 * Returns
3010 3010 * DDI_SUCCESS - if the link is in L1idle
3011 3011 * DDI_FAILURE - if the link is not in L1idle
3012 3012 */
3013 3013 int
3014 3014 px_link_wait4l1idle(caddr_t csr_base)
3015 3015 {
3016 3016 uint8_t ltssm_state;
3017 3017 int ntries = px_max_l1_tries;
3018 3018
3019 3019 while (ntries > 0) {
3020 3020 ltssm_state = CSR_FR(csr_base, LPU_LTSSM_STATUS1, LTSSM_STATE);
3021 3021 if (ltssm_state == LPU_LTSSM_L1_IDLE || (--ntries <= 0))
3022 3022 break;
3023 3023 delay(1);
3024 3024 }
3025 3025 DBG(DBG_PWR, NULL, "check_for_l1idle: ltssm_state %x\n", ltssm_state);
3026 3026 return ((ltssm_state == LPU_LTSSM_L1_IDLE) ? DDI_SUCCESS : DDI_FAILURE);
3027 3027 }
3028 3028
3029 3029 /*
3030 3030 * Tranisition the link to L0, after it is down.
3031 3031 */
3032 3032 int
3033 3033 px_link_retrain(caddr_t csr_base)
3034 3034 {
3035 3035 volatile uint64_t reg;
3036 3036
3037 3037 reg = CSR_XR(csr_base, TLU_CONTROL);
3038 3038 if (!(reg & (1ull << TLU_REMAIN_DETECT_QUIET))) {
3039 3039 DBG(DBG_PWR, NULL, "retrain_link: detect.quiet bit not set\n");
3040 3040 return (DDI_FAILURE);
3041 3041 }
3042 3042
3043 3043 /* Clear link down bit in TLU Other Event Clear Status Register. */
3044 3044 CSR_BS(csr_base, TLU_OTHER_EVENT_STATUS_CLEAR, LDN_P);
3045 3045
3046 3046 /* Clear Drain bit in TLU Status Register */
3047 3047 CSR_BS(csr_base, TLU_STATUS, DRAIN);
3048 3048
3049 3049 /* Clear Remain in Detect.Quiet bit in TLU Control Register */
3050 3050 reg = CSR_XR(csr_base, TLU_CONTROL);
3051 3051 reg &= ~(1ull << TLU_REMAIN_DETECT_QUIET);
3052 3052 CSR_XS(csr_base, TLU_CONTROL, reg);
3053 3053
3054 3054 return (DDI_SUCCESS);
3055 3055 }
3056 3056
3057 3057 void
3058 3058 px_enable_detect_quiet(caddr_t csr_base)
3059 3059 {
3060 3060 volatile uint64_t tlu_ctrl;
3061 3061
3062 3062 tlu_ctrl = CSR_XR(csr_base, TLU_CONTROL);
3063 3063 tlu_ctrl |= (1ull << TLU_REMAIN_DETECT_QUIET);
3064 3064 CSR_XS(csr_base, TLU_CONTROL, tlu_ctrl);
3065 3065 }
3066 3066
3067 3067 static uint_t
3068 3068 oberon_hp_pwron(caddr_t csr_base)
3069 3069 {
3070 3070 volatile uint64_t reg;
3071 3071 boolean_t link_retry, link_up;
3072 3072 int loop, i;
3073 3073
3074 3074 DBG(DBG_HP, NULL, "oberon_hp_pwron the slot\n");
3075 3075
3076 3076 /* Check Leaf Reset status */
3077 3077 reg = CSR_XR(csr_base, ILU_ERROR_LOG_ENABLE);
3078 3078 if (!(reg & (1ull << ILU_ERROR_LOG_ENABLE_SPARE3))) {
3079 3079 DBG(DBG_HP, NULL, "oberon_hp_pwron fails: leaf not reset\n");
3080 3080 goto fail;
3081 3081 }
3082 3082
3083 3083 /* Check HP Capable */
3084 3084 if (!CSR_BR(csr_base, TLU_SLOT_CAPABILITIES, HP)) {
3085 3085 DBG(DBG_HP, NULL, "oberon_hp_pwron fails: leaf not "
3086 3086 "hotplugable\n");
3087 3087 goto fail;
3088 3088 }
3089 3089
3090 3090 /* Check Slot status */
3091 3091 reg = CSR_XR(csr_base, TLU_SLOT_STATUS);
3092 3092 if (!(reg & (1ull << TLU_SLOT_STATUS_PSD)) ||
3093 3093 (reg & (1ull << TLU_SLOT_STATUS_MRLS))) {
3094 3094 DBG(DBG_HP, NULL, "oberon_hp_pwron fails: slot status %lx\n",
3095 3095 reg);
3096 3096 goto fail;
3097 3097 }
3098 3098
3099 3099 /* Blink power LED, this is done from pciehpc already */
3100 3100
3101 3101 /* Turn on slot power */
3102 3102 CSR_BS(csr_base, HOTPLUG_CONTROL, PWREN);
3103 3103
3104 3104 /* power fault detection */
3105 3105 delay(drv_usectohz(25000));
3106 3106 CSR_BS(csr_base, TLU_SLOT_STATUS, PWFD);
3107 3107 CSR_BC(csr_base, HOTPLUG_CONTROL, PWREN);
3108 3108
3109 3109 /* wait to check power state */
3110 3110 delay(drv_usectohz(25000));
3111 3111
3112 3112 if (!CSR_BR(csr_base, TLU_SLOT_STATUS, PWFD)) {
3113 3113 DBG(DBG_HP, NULL, "oberon_hp_pwron fails: power fault\n");
3114 3114 goto fail1;
3115 3115 }
3116 3116
3117 3117 /* power is good */
3118 3118 CSR_BS(csr_base, HOTPLUG_CONTROL, PWREN);
3119 3119
3120 3120 delay(drv_usectohz(25000));
3121 3121 CSR_BS(csr_base, TLU_SLOT_STATUS, PWFD);
3122 3122 CSR_BS(csr_base, TLU_SLOT_CONTROL, PWFDEN);
3123 3123
3124 3124 /* Turn on slot clock */
3125 3125 CSR_BS(csr_base, HOTPLUG_CONTROL, CLKEN);
3126 3126
3127 3127 link_up = B_FALSE;
3128 3128 link_retry = B_FALSE;
3129 3129
3130 3130 for (loop = 0; (loop < link_retry_count) && (link_up == B_FALSE);
3131 3131 loop++) {
3132 3132 if (link_retry == B_TRUE) {
3133 3133 DBG(DBG_HP, NULL, "oberon_hp_pwron : retry link loop "
3134 3134 "%d\n", loop);
3135 3135 CSR_BS(csr_base, TLU_CONTROL, DRN_TR_DIS);
3136 3136 CSR_XS(csr_base, FLP_PORT_CONTROL, 0x1);
3137 3137 delay(drv_usectohz(10000));
3138 3138 CSR_BC(csr_base, TLU_CONTROL, DRN_TR_DIS);
3139 3139 CSR_BS(csr_base, TLU_DIAGNOSTIC, IFC_DIS);
3140 3140 CSR_BC(csr_base, HOTPLUG_CONTROL, N_PERST);
3141 3141 delay(drv_usectohz(50000));
3142 3142 }
3143 3143
3144 3144 /* Release PCI-E Reset */
3145 3145 delay(drv_usectohz(wait_perst));
3146 3146 CSR_BS(csr_base, HOTPLUG_CONTROL, N_PERST);
3147 3147
3148 3148 /*
3149 3149 * Open events' mask
3150 3150 * This should be done from pciehpc already
3151 3151 */
3152 3152
3153 3153 /* Enable PCIE port */
3154 3154 delay(drv_usectohz(wait_enable_port));
3155 3155 CSR_BS(csr_base, TLU_CONTROL, DRN_TR_DIS);
3156 3156 CSR_XS(csr_base, FLP_PORT_CONTROL, 0x20);
3157 3157
3158 3158 /* wait for the link up */
3159 3159 /* BEGIN CSTYLED */
3160 3160 for (i = 0; (i < 2) && (link_up == B_FALSE); i++) {
3161 3161 delay(drv_usectohz(link_status_check));
3162 3162 reg = CSR_XR(csr_base, DLU_LINK_LAYER_STATUS);
3163 3163
3164 3164 if ((((reg >> DLU_LINK_LAYER_STATUS_INIT_FC_SM_STS) &
3165 3165 DLU_LINK_LAYER_STATUS_INIT_FC_SM_STS_MASK) ==
3166 3166 DLU_LINK_LAYER_STATUS_INIT_FC_SM_STS_FC_INIT_DONE) &&
3167 3167 (reg & (1ull << DLU_LINK_LAYER_STATUS_DLUP_STS)) &&
3168 3168 ((reg &
3169 3169 DLU_LINK_LAYER_STATUS_LNK_STATE_MACH_STS_MASK) ==
3170 3170 DLU_LINK_LAYER_STATUS_LNK_STATE_MACH_STS_DL_ACTIVE)) {
3171 3171 DBG(DBG_HP, NULL, "oberon_hp_pwron : "
3172 3172 "link is up\n");
3173 3173 link_up = B_TRUE;
3174 3174 } else
3175 3175 link_retry = B_TRUE;
3176 3176
3177 3177 }
3178 3178 /* END CSTYLED */
3179 3179 }
3180 3180
3181 3181 if (link_up == B_FALSE) {
3182 3182 DBG(DBG_HP, NULL, "oberon_hp_pwron fails to enable "
3183 3183 "PCI-E port\n");
3184 3184 goto fail2;
3185 3185 }
3186 3186
3187 3187 /* link is up */
3188 3188 CSR_BC(csr_base, TLU_DIAGNOSTIC, IFC_DIS);
3189 3189 CSR_BS(csr_base, FLP_PORT_ACTIVE_STATUS, TRAIN_ERROR);
3190 3190 CSR_BS(csr_base, TLU_UNCORRECTABLE_ERROR_STATUS_CLEAR, TE_P);
3191 3191 CSR_BS(csr_base, TLU_UNCORRECTABLE_ERROR_STATUS_CLEAR, TE_S);
3192 3192 CSR_BC(csr_base, TLU_CONTROL, DRN_TR_DIS);
3193 3193
3194 3194 /* Restore LUP/LDN */
3195 3195 reg = CSR_XR(csr_base, TLU_OTHER_EVENT_LOG_ENABLE);
3196 3196 if (px_tlu_oe_log_mask & (1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_P))
3197 3197 reg |= 1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_P;
3198 3198 if (px_tlu_oe_log_mask & (1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_P))
3199 3199 reg |= 1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_P;
3200 3200 if (px_tlu_oe_log_mask & (1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_S))
3201 3201 reg |= 1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_S;
3202 3202 if (px_tlu_oe_log_mask & (1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_S))
3203 3203 reg |= 1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_S;
3204 3204 CSR_XS(csr_base, TLU_OTHER_EVENT_LOG_ENABLE, reg);
3205 3205
3206 3206 /*
3207 3207 * Initialize Leaf
3208 3208 * SPLS = 00b, SPLV = 11001b, i.e. 25W
3209 3209 */
3210 3210 reg = CSR_XR(csr_base, TLU_SLOT_CAPABILITIES);
3211 3211 reg &= ~(TLU_SLOT_CAPABILITIES_SPLS_MASK <<
3212 3212 TLU_SLOT_CAPABILITIES_SPLS);
3213 3213 reg &= ~(TLU_SLOT_CAPABILITIES_SPLV_MASK <<
3214 3214 TLU_SLOT_CAPABILITIES_SPLV);
3215 3215 reg |= (0x19 << TLU_SLOT_CAPABILITIES_SPLV);
3216 3216 CSR_XS(csr_base, TLU_SLOT_CAPABILITIES, reg);
3217 3217
3218 3218 /* Turn on Power LED */
3219 3219 reg = CSR_XR(csr_base, TLU_SLOT_CONTROL);
3220 3220 reg &= ~PCIE_SLOTCTL_PWR_INDICATOR_MASK;
3221 3221 reg = pcie_slotctl_pwr_indicator_set(reg,
|
↓ open down ↓ |
3221 lines elided |
↑ open up ↑ |
3222 3222 PCIE_SLOTCTL_INDICATOR_STATE_ON);
3223 3223 CSR_XS(csr_base, TLU_SLOT_CONTROL, reg);
3224 3224
3225 3225 /* Notify to SCF */
3226 3226 if (CSR_BR(csr_base, HOTPLUG_CONTROL, SLOTPON))
3227 3227 CSR_BC(csr_base, HOTPLUG_CONTROL, SLOTPON);
3228 3228 else
3229 3229 CSR_BS(csr_base, HOTPLUG_CONTROL, SLOTPON);
3230 3230
3231 3231 /* Wait for one second */
3232 - delay(drv_usectohz(1000000));
3232 + delay(drv_sectohz(1));
3233 3233
3234 3234 return (DDI_SUCCESS);
3235 3235
3236 3236 fail2:
3237 3237 /* Link up is failed */
3238 3238 CSR_BS(csr_base, FLP_PORT_CONTROL, PORT_DIS);
3239 3239 CSR_BC(csr_base, HOTPLUG_CONTROL, N_PERST);
3240 3240 delay(drv_usectohz(150));
3241 3241
3242 3242 CSR_BC(csr_base, HOTPLUG_CONTROL, CLKEN);
3243 3243 delay(drv_usectohz(100));
3244 3244
3245 3245 fail1:
3246 3246 CSR_BC(csr_base, TLU_SLOT_CONTROL, PWFDEN);
3247 3247
3248 3248 CSR_BC(csr_base, HOTPLUG_CONTROL, PWREN);
3249 3249
3250 3250 reg = CSR_XR(csr_base, TLU_SLOT_CONTROL);
3251 3251 reg &= ~PCIE_SLOTCTL_PWR_INDICATOR_MASK;
3252 3252 reg = pcie_slotctl_pwr_indicator_set(reg,
3253 3253 PCIE_SLOTCTL_INDICATOR_STATE_OFF);
3254 3254 CSR_XS(csr_base, TLU_SLOT_CONTROL, reg);
3255 3255
3256 3256 CSR_BC(csr_base, TLU_SLOT_STATUS, PWFD);
3257 3257
3258 3258 fail:
3259 3259 return ((uint_t)DDI_FAILURE);
3260 3260 }
3261 3261
3262 3262 hrtime_t oberon_leaf_reset_timeout = 120ll * NANOSEC; /* 120 seconds */
3263 3263
3264 3264 static uint_t
3265 3265 oberon_hp_pwroff(caddr_t csr_base)
3266 3266 {
3267 3267 volatile uint64_t reg;
3268 3268 volatile uint64_t reg_tluue, reg_tluce;
3269 3269 hrtime_t start_time, end_time;
3270 3270
3271 3271 DBG(DBG_HP, NULL, "oberon_hp_pwroff the slot\n");
3272 3272
3273 3273 /* Blink power LED, this is done from pciehpc already */
3274 3274
3275 3275 /* Clear Slot Event */
3276 3276 CSR_BS(csr_base, TLU_SLOT_STATUS, PSDC);
3277 3277 CSR_BS(csr_base, TLU_SLOT_STATUS, PWFD);
3278 3278
3279 3279 /* DRN_TR_DIS on */
3280 3280 CSR_BS(csr_base, TLU_CONTROL, DRN_TR_DIS);
3281 3281 delay(drv_usectohz(10000));
3282 3282
3283 3283 /* Disable LUP/LDN */
3284 3284 reg = CSR_XR(csr_base, TLU_OTHER_EVENT_LOG_ENABLE);
3285 3285 reg &= ~((1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_P) |
3286 3286 (1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_P) |
3287 3287 (1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_S) |
3288 3288 (1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_S));
3289 3289 CSR_XS(csr_base, TLU_OTHER_EVENT_LOG_ENABLE, reg);
3290 3290
3291 3291 /* Save the TLU registers */
3292 3292 reg_tluue = CSR_XR(csr_base, TLU_UNCORRECTABLE_ERROR_LOG_ENABLE);
3293 3293 reg_tluce = CSR_XR(csr_base, TLU_CORRECTABLE_ERROR_LOG_ENABLE);
3294 3294 /* All clear */
3295 3295 CSR_XS(csr_base, TLU_UNCORRECTABLE_ERROR_LOG_ENABLE, 0);
3296 3296 CSR_XS(csr_base, TLU_CORRECTABLE_ERROR_LOG_ENABLE, 0);
3297 3297
3298 3298 /* Disable port */
3299 3299 CSR_BS(csr_base, FLP_PORT_CONTROL, PORT_DIS);
3300 3300
3301 3301 /* PCIE reset */
3302 3302 delay(drv_usectohz(10000));
3303 3303 CSR_BC(csr_base, HOTPLUG_CONTROL, N_PERST);
3304 3304
3305 3305 /* PCIE clock stop */
3306 3306 delay(drv_usectohz(150));
3307 3307 CSR_BC(csr_base, HOTPLUG_CONTROL, CLKEN);
3308 3308
3309 3309 /* Turn off slot power */
3310 3310 delay(drv_usectohz(100));
3311 3311 CSR_BC(csr_base, TLU_SLOT_CONTROL, PWFDEN);
3312 3312 CSR_BC(csr_base, HOTPLUG_CONTROL, PWREN);
3313 3313 delay(drv_usectohz(25000));
3314 3314 CSR_BS(csr_base, TLU_SLOT_STATUS, PWFD);
3315 3315
3316 3316 /* write 0 to bit 7 of ILU Error Log Enable Register */
3317 3317 CSR_BC(csr_base, ILU_ERROR_LOG_ENABLE, SPARE3);
3318 3318
3319 3319 /* Set back TLU registers */
3320 3320 CSR_XS(csr_base, TLU_UNCORRECTABLE_ERROR_LOG_ENABLE, reg_tluue);
3321 3321 CSR_XS(csr_base, TLU_CORRECTABLE_ERROR_LOG_ENABLE, reg_tluce);
3322 3322
3323 3323 /* Power LED off */
3324 3324 reg = CSR_XR(csr_base, TLU_SLOT_CONTROL);
3325 3325 reg &= ~PCIE_SLOTCTL_PWR_INDICATOR_MASK;
3326 3326 reg = pcie_slotctl_pwr_indicator_set(reg,
3327 3327 PCIE_SLOTCTL_INDICATOR_STATE_OFF);
3328 3328 CSR_XS(csr_base, TLU_SLOT_CONTROL, reg);
3329 3329
3330 3330 /* Indicator LED blink */
3331 3331 reg = CSR_XR(csr_base, TLU_SLOT_CONTROL);
3332 3332 reg &= ~PCIE_SLOTCTL_ATTN_INDICATOR_MASK;
3333 3333 reg = pcie_slotctl_attn_indicator_set(reg,
3334 3334 PCIE_SLOTCTL_INDICATOR_STATE_BLINK);
3335 3335 CSR_XS(csr_base, TLU_SLOT_CONTROL, reg);
3336 3336
3337 3337 /* Notify to SCF */
3338 3338 if (CSR_BR(csr_base, HOTPLUG_CONTROL, SLOTPON))
3339 3339 CSR_BC(csr_base, HOTPLUG_CONTROL, SLOTPON);
3340 3340 else
3341 3341 CSR_BS(csr_base, HOTPLUG_CONTROL, SLOTPON);
3342 3342
3343 3343 start_time = gethrtime();
3344 3344 /* Check Leaf Reset status */
|
↓ open down ↓ |
102 lines elided |
↑ open up ↑ |
3345 3345 while (!(CSR_BR(csr_base, ILU_ERROR_LOG_ENABLE, SPARE3))) {
3346 3346 if ((end_time = (gethrtime() - start_time)) >
3347 3347 oberon_leaf_reset_timeout) {
3348 3348 cmn_err(CE_WARN, "Oberon leaf reset is not completed, "
3349 3349 "even after waiting %llx ticks", end_time);
3350 3350
3351 3351 break;
3352 3352 }
3353 3353
3354 3354 /* Wait for one second */
3355 - delay(drv_usectohz(1000000));
3355 + delay(drv_sectohz(1));
3356 3356 }
3357 3357
3358 3358 /* Indicator LED off */
3359 3359 reg = CSR_XR(csr_base, TLU_SLOT_CONTROL);
3360 3360 reg &= ~PCIE_SLOTCTL_ATTN_INDICATOR_MASK;
3361 3361 reg = pcie_slotctl_attn_indicator_set(reg,
3362 3362 PCIE_SLOTCTL_INDICATOR_STATE_OFF);
3363 3363 CSR_XS(csr_base, TLU_SLOT_CONTROL, reg);
3364 3364
3365 3365 return (DDI_SUCCESS);
3366 3366 }
3367 3367
3368 3368 static uint_t
3369 3369 oberon_hpreg_get(void *cookie, off_t off)
3370 3370 {
3371 3371 caddr_t csr_base = *(caddr_t *)cookie;
3372 3372 volatile uint64_t val = -1ull;
3373 3373
3374 3374 switch (off) {
3375 3375 case PCIE_SLOTCAP:
3376 3376 val = CSR_XR(csr_base, TLU_SLOT_CAPABILITIES);
3377 3377 break;
3378 3378 case PCIE_SLOTCTL:
3379 3379 val = CSR_XR(csr_base, TLU_SLOT_CONTROL);
3380 3380
3381 3381 /* Get the power state */
3382 3382 val |= (CSR_XR(csr_base, HOTPLUG_CONTROL) &
3383 3383 (1ull << HOTPLUG_CONTROL_PWREN)) ?
3384 3384 0 : PCIE_SLOTCTL_PWR_CONTROL;
3385 3385 break;
3386 3386 case PCIE_SLOTSTS:
3387 3387 val = CSR_XR(csr_base, TLU_SLOT_STATUS);
3388 3388 break;
3389 3389 case PCIE_LINKCAP:
3390 3390 val = CSR_XR(csr_base, TLU_LINK_CAPABILITIES);
3391 3391 break;
3392 3392 case PCIE_LINKSTS:
3393 3393 val = CSR_XR(csr_base, TLU_LINK_STATUS);
3394 3394 break;
3395 3395 default:
3396 3396 DBG(DBG_HP, NULL, "oberon_hpreg_get(): "
3397 3397 "unsupported offset 0x%lx\n", off);
3398 3398 break;
3399 3399 }
3400 3400
3401 3401 return ((uint_t)val);
3402 3402 }
3403 3403
3404 3404 static uint_t
3405 3405 oberon_hpreg_put(void *cookie, off_t off, uint_t val)
3406 3406 {
3407 3407 caddr_t csr_base = *(caddr_t *)cookie;
3408 3408 volatile uint64_t pwr_state_on, pwr_fault;
3409 3409 uint_t pwr_off, ret = DDI_SUCCESS;
3410 3410
3411 3411 DBG(DBG_HP, NULL, "oberon_hpreg_put 0x%lx: cur %x, new %x\n",
3412 3412 off, oberon_hpreg_get(cookie, off), val);
3413 3413
3414 3414 switch (off) {
3415 3415 case PCIE_SLOTCTL:
3416 3416 /*
3417 3417 * Depending on the current state, insertion or removal
3418 3418 * will go through their respective sequences.
3419 3419 */
3420 3420 pwr_state_on = CSR_BR(csr_base, HOTPLUG_CONTROL, PWREN);
3421 3421 pwr_off = val & PCIE_SLOTCTL_PWR_CONTROL;
3422 3422
3423 3423 if (!pwr_off && !pwr_state_on)
3424 3424 ret = oberon_hp_pwron(csr_base);
3425 3425 else if (pwr_off && pwr_state_on) {
3426 3426 pwr_fault = CSR_XR(csr_base, TLU_SLOT_STATUS) &
3427 3427 (1ull << TLU_SLOT_STATUS_PWFD);
3428 3428
3429 3429 if (pwr_fault) {
3430 3430 DBG(DBG_HP, NULL, "oberon_hpreg_put: power "
3431 3431 "off because of power fault\n");
3432 3432 CSR_BC(csr_base, HOTPLUG_CONTROL, PWREN);
3433 3433 }
3434 3434 else
3435 3435 ret = oberon_hp_pwroff(csr_base);
3436 3436 } else
3437 3437 CSR_XS(csr_base, TLU_SLOT_CONTROL, val);
3438 3438 break;
3439 3439 case PCIE_SLOTSTS:
3440 3440 CSR_XS(csr_base, TLU_SLOT_STATUS, val);
3441 3441 break;
3442 3442 default:
3443 3443 DBG(DBG_HP, NULL, "oberon_hpreg_put(): "
3444 3444 "unsupported offset 0x%lx\n", off);
3445 3445 ret = (uint_t)DDI_FAILURE;
3446 3446 break;
3447 3447 }
3448 3448
3449 3449 return (ret);
3450 3450 }
3451 3451
3452 3452 int
3453 3453 hvio_hotplug_init(dev_info_t *dip, void *arg)
3454 3454 {
3455 3455 pcie_hp_regops_t *regops = (pcie_hp_regops_t *)arg;
3456 3456 px_t *px_p = DIP_TO_STATE(dip);
3457 3457 pxu_t *pxu_p = (pxu_t *)px_p->px_plat_p;
3458 3458 volatile uint64_t reg;
3459 3459
3460 3460 if (PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON) {
3461 3461 if (!CSR_BR((caddr_t)pxu_p->px_address[PX_REG_CSR],
3462 3462 TLU_SLOT_CAPABILITIES, HP)) {
3463 3463 DBG(DBG_HP, NULL, "%s%d: hotplug capabale not set\n",
3464 3464 ddi_driver_name(dip), ddi_get_instance(dip));
3465 3465 return (DDI_FAILURE);
3466 3466 }
3467 3467
3468 3468 /* For empty or disconnected slot, disable LUP/LDN */
3469 3469 if (!CSR_BR((caddr_t)pxu_p->px_address[PX_REG_CSR],
3470 3470 TLU_SLOT_STATUS, PSD) ||
3471 3471 !CSR_BR((caddr_t)pxu_p->px_address[PX_REG_CSR],
3472 3472 HOTPLUG_CONTROL, PWREN)) {
3473 3473
3474 3474 reg = CSR_XR((caddr_t)pxu_p->px_address[PX_REG_CSR],
3475 3475 TLU_OTHER_EVENT_LOG_ENABLE);
3476 3476 reg &= ~((1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_P) |
3477 3477 (1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_P) |
3478 3478 (1ull << TLU_OTHER_EVENT_STATUS_SET_LDN_S) |
3479 3479 (1ull << TLU_OTHER_EVENT_STATUS_SET_LUP_S));
3480 3480 CSR_XS((caddr_t)pxu_p->px_address[PX_REG_CSR],
3481 3481 TLU_OTHER_EVENT_LOG_ENABLE, reg);
3482 3482 }
3483 3483
3484 3484 regops->get = oberon_hpreg_get;
3485 3485 regops->put = oberon_hpreg_put;
3486 3486
3487 3487 /* cookie is the csr_base */
3488 3488 regops->cookie = (void *)&pxu_p->px_address[PX_REG_CSR];
3489 3489
3490 3490 return (DDI_SUCCESS);
3491 3491 }
3492 3492
3493 3493 return (DDI_ENOTSUP);
3494 3494 }
3495 3495
3496 3496 int
3497 3497 hvio_hotplug_uninit(dev_info_t *dip)
3498 3498 {
3499 3499 px_t *px_p = DIP_TO_STATE(dip);
3500 3500 pxu_t *pxu_p = (pxu_t *)px_p->px_plat_p;
3501 3501
3502 3502 if (PX_CHIP_TYPE(pxu_p) == PX_CHIP_OBERON)
3503 3503 return (DDI_SUCCESS);
3504 3504
3505 3505 return (DDI_FAILURE);
3506 3506 }
|
↓ open down ↓ |
141 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX