projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
remove linux 2.4 specific build system code
[openwrt/openwrt.git] / target / linux / generic-2.6 / files / crypto / ocf / kirkwood / mvHal / mv_hal / pex / mvPex.c
1 /*******************************************************************************
2 Copyright (C) Marvell International Ltd. and its affiliates
3
4 This software file (the "File") is owned and distributed by Marvell
5 International Ltd. and/or its affiliates ("Marvell") under the following
6 alternative licensing terms. Once you have made an election to distribute the
7 File under one of the following license alternatives, please (i) delete this
8 introductory statement regarding license alternatives, (ii) delete the two
9 license alternatives that you have not elected to use and (iii) preserve the
10 Marvell copyright notice above.
11
12 ********************************************************************************
13 Marvell Commercial License Option
14
15 If you received this File from Marvell and you have entered into a commercial
16 license agreement (a "Commercial License") with Marvell, the File is licensed
17 to you under the terms of the applicable Commercial License.
18
19 ********************************************************************************
20 Marvell GPL License Option
21
22 If you received this File from Marvell, you may opt to use, redistribute and/or
23 modify this File in accordance with the terms and conditions of the General
24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
25 available along with the File in the license.txt file or by writing to the Free
26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
28
29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
31 DISCLAIMED. The GPL License provides additional details about this warranty
32 disclaimer.
33 ********************************************************************************
34 Marvell BSD License Option
35
36 If you received this File from Marvell, you may opt to use, redistribute and/or
37 modify this File under the following licensing terms.
38 Redistribution and use in source and binary forms, with or without modification,
39 are permitted provided that the following conditions are met:
40
41 * Redistributions of source code must retain the above copyright notice,
42 this list of conditions and the following disclaimer.
43
44 * Redistributions in binary form must reproduce the above copyright
45 notice, this list of conditions and the following disclaimer in the
46 documentation and/or other materials provided with the distribution.
47
48 * Neither the name of Marvell nor the names of its contributors may be
49 used to endorse or promote products derived from this software without
50 specific prior written permission.
51
52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62
63 *******************************************************************************/
64
65 #include "pex/mvPex.h"
66
67 #include "ctrlEnv/mvCtrlEnvLib.h"
68
69 /* defines */
70 #ifdef MV_DEBUG
71 #define DB(x) x
72 #else
73 #define DB(x)
74 #endif
75
76 MV_STATUS mvPexHalInit(MV_U32 pexIf, MV_PEX_TYPE pexType)
77 {
78 MV_PEX_MODE pexMode;
79 MV_U32 regVal;
80 MV_U32 status;
81
82 /* First implement Guideline (GL# PCI Express-2) Wrong Default Value */
83 /* to Transmitter Output Current (TXAMP) Relevant for: 88F5181-A1/B0/B1 */
84 /* and 88F5281-B0 and above, 88F5182, 88F5082, 88F5181L, 88F6082/L */
85
86 if ((mvCtrlModelGet() != MV_1281_DEV_ID) &&
87 (mvCtrlModelGet() != MV_6281_DEV_ID) &&
88 (mvCtrlModelGet() != MV_6192_DEV_ID) &&
89 (mvCtrlModelGet() != MV_6190_DEV_ID) &&
90 (mvCtrlModelGet() != MV_6180_DEV_ID) &&
91 (mvCtrlModelGet() != MV_6183_DEV_ID) &&
92 (mvCtrlModelGet() != MV_6183L_DEV_ID) &&
93 (mvCtrlModelGet() != MV_78100_DEV_ID) &&
94 (mvCtrlModelGet() != MV_78200_DEV_ID) &&
95 (mvCtrlModelGet() != MV_76100_DEV_ID) &&
96 (mvCtrlModelGet() != MV_78XX0_DEV_ID))
97 {
98
99 /* Read current value of TXAMP */
100 MV_REG_WRITE(0x41b00, 0x80820000); /* Write the read command */
101
102 regVal = MV_REG_READ(0x41b00); /* Extract the data */
103
104 /* Prepare new data for write */
105 regVal &= ~0x7; /* Clear bits [2:0] */
106 regVal |= 0x4; /* Set the new value */
107 regVal &= ~0x80000000; /* Set "write" command */
108 MV_REG_WRITE(0x41b00, regVal); /* Write the write command */
109
110 }
111 else
112 {
113 /* Implement 1.0V termination GL for 88F1281 device only */
114 /* BIT0 - Common mode feedback */
115 /* BIT3 - TxBuf, extra drive for 1.0V termination */
116 if (mvCtrlModelGet() == MV_1281_DEV_ID)
117 {
118 MV_REG_WRITE(0x41b00, 0x80860000); /* Write the read command */
119 regVal = MV_REG_READ(0x41b00); /* Extract the data */
120 regVal |= (BIT0 | BIT3);
121 regVal &= ~0x80000000; /* Set "write" command */
122 MV_REG_WRITE(0x41b00, regVal); /* Write the write command */
123
124 MV_REG_WRITE(0x31b00, 0x80860000); /* Write the read command */
125 regVal = MV_REG_READ(0x31b00); /* Extract the data */
126 regVal |= (BIT0 | BIT3);
127 regVal &= ~0x80000000; /* Set "write" command */
128 MV_REG_WRITE(0x31b00, regVal); /* Write the write command */
129 }
130 }
131
132 if( mvPexModeGet(pexIf, &pexMode) != MV_OK)
133 {
134 mvOsPrintf("PEX init ERR. mvPexModeGet failed (pexType=%d)\n",pexMode.pexType);
135 return MV_ERROR;
136 }
137
138 /* Check that required PEX type is the one set in reset time */
139 if (pexType != pexMode.pexType)
140 {
141 /* No Link. Shut down the Phy */
142 mvPexPowerDown(pexIf);
143 mvOsPrintf("PEX init ERR. PEX type sampled mismatch (%d,%d)\n",pexType,pexMode.pexType);
144 return MV_ERROR;
145 }
146
147 if (MV_PEX_ROOT_COMPLEX == pexType)
148 {
149 mvPexLocalBusNumSet(pexIf, PEX_HOST_BUS_NUM(pexIf));
150 mvPexLocalDevNumSet(pexIf, PEX_HOST_DEV_NUM(pexIf));
151
152 /* Local device master Enable */
153 mvPexMasterEnable(pexIf, MV_TRUE);
154
155 /* Local device slave Enable */
156 mvPexSlaveEnable(pexIf, mvPexLocalBusNumGet(pexIf),
157 mvPexLocalDevNumGet(pexIf), MV_TRUE);
158 /* Interrupt disable */
159 status = MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_STATUS_AND_COMMAND));
160 status |= PXSAC_INT_DIS;
161 MV_REG_WRITE(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_STATUS_AND_COMMAND), status);
162 }
163
164 /* now wait 500 ms to be sure the link is valid (spec compliant) */
165 mvOsDelay(500);
166 /* Check if we have link */
167 if (MV_REG_READ(PEX_STATUS_REG(pexIf)) & PXSR_DL_DOWN)
168 {
169 mvOsPrintf("PEX%d interface detected no Link.\n",pexIf);
170 return MV_NO_SUCH;
171 }
172
173 if (MV_PEX_WITDH_X1 == pexMode.pexWidth)
174 {
175 mvOsPrintf("PEX%d interface detected Link X1\n",pexIf);
176 }
177 else
178 {
179 mvOsPrintf("PEX%d interface detected Link X4\n",pexIf);
180 }
181
182 #ifdef PCIE_VIRTUAL_BRIDGE_SUPPORT
183 mvPexVrtBrgInit(pexIf);
184 #endif
185 return MV_OK;
186 }
187
188 /*******************************************************************************
189 * mvPexModeGet - Get Pex Mode
190 *
191 * DESCRIPTION:
192 *
193 * INPUT:
194 * pexIf - PEX interface number.
195 *
196 * OUTPUT:
197 * pexMode - Pex mode structure
198 *
199 * RETURN:
200 * MV_OK on success , MV_ERROR otherwise
201 *
202 *******************************************************************************/
203 MV_U32 mvPexModeGet(MV_U32 pexIf,MV_PEX_MODE *pexMode)
204 {
205 MV_U32 pexData;
206
207 /* Parameter checking */
208 if (PEX_DEFAULT_IF != pexIf)
209 {
210 if (pexIf >= mvCtrlPexMaxIfGet())
211 {
212 mvOsPrintf("mvPexModeGet: ERR. Invalid PEX interface %d\n",pexIf);
213 return MV_ERROR;
214 }
215 }
216
217 pexData = MV_REG_READ(PEX_CTRL_REG(pexIf));
218
219 switch (pexData & PXCR_DEV_TYPE_CTRL_MASK)
220 {
221 case PXCR_DEV_TYPE_CTRL_CMPLX:
222 pexMode->pexType = MV_PEX_ROOT_COMPLEX;
223 break;
224 case PXCR_DEV_TYPE_CTRL_POINT:
225 pexMode->pexType = MV_PEX_END_POINT;
226 break;
227
228 }
229
230 /* Check if we have link */
231 if (MV_REG_READ(PEX_STATUS_REG(pexIf)) & PXSR_DL_DOWN)
232 {
233 pexMode->pexLinkUp = MV_FALSE;
234
235 /* If there is no link, the auto negotiation data is worthless */
236 pexMode->pexWidth = MV_PEX_WITDH_INVALID;
237 }
238 else
239 {
240 pexMode->pexLinkUp = MV_TRUE;
241
242 /* We have link. The link width is now valid */
243 pexData = MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CTRL_STAT_REG));
244 pexMode->pexWidth = ((pexData & PXLCSR_NEG_LNK_WDTH_MASK) >>
245 PXLCSR_NEG_LNK_WDTH_OFFS);
246 }
247
248 return MV_OK;
249 }
250
251
252 /* PEX configuration space read write */
253
254 /*******************************************************************************
255 * mvPexConfigRead - Read from configuration space
256 *
257 * DESCRIPTION:
258 * This function performs a 32 bit read from PEX configuration space.
259 * It supports both type 0 and type 1 of Configuration Transactions
260 * (local and over bridge). In order to read from local bus segment, use
261 * bus number retrieved from mvPexLocalBusNumGet(). Other bus numbers
262 * will result configuration transaction of type 1 (over bridge).
263 *
264 * INPUT:
265 * pexIf - PEX interface number.
266 * bus - PEX segment bus number.
267 * dev - PEX device number.
268 * func - Function number.
269 * regOffs - Register offset.
270 *
271 * OUTPUT:
272 * None.
273 *
274 * RETURN:
275 * 32bit register data, 0xffffffff on error
276 *
277 *******************************************************************************/
278 MV_U32 mvPexConfigRead (MV_U32 pexIf, MV_U32 bus, MV_U32 dev, MV_U32 func,
279 MV_U32 regOff)
280 {
281 #if defined(PCIE_VIRTUAL_BRIDGE_SUPPORT)
282 return mvPexVrtBrgConfigRead (pexIf, bus, dev, func, regOff);
283 }
284
285 MV_U32 mvPexHwConfigRead (MV_U32 pexIf, MV_U32 bus, MV_U32 dev, MV_U32 func,
286 MV_U32 regOff)
287 {
288 #endif
289 MV_U32 pexData = 0;
290 MV_U32 localDev,localBus;
291
292 /* Parameter checking */
293 if (PEX_DEFAULT_IF != pexIf)
294 {
295 if (pexIf >= mvCtrlPexMaxIfGet())
296 {
297 mvOsPrintf("mvPexConfigRead: ERR. Invalid PEX interface %d\n",pexIf);
298 return 0xFFFFFFFF;
299 }
300 }
301
302 if (dev >= MAX_PEX_DEVICES)
303 {
304 DB(mvOsPrintf("mvPexConfigRead: ERR. device number illigal %d\n", dev));
305 return 0xFFFFFFFF;
306 }
307
308 if (func >= MAX_PEX_FUNCS)
309 {
310 DB(mvOsPrintf("mvPexConfigRead: ERR. function num illigal %d\n", func));
311 return 0xFFFFFFFF;
312 }
313
314 if (bus >= MAX_PEX_BUSSES)
315 {
316 DB(mvOsPrintf("mvPexConfigRead: ERR. bus number illigal %d\n", bus));
317 return MV_ERROR;
318 }
319
320 DB(mvOsPrintf("mvPexConfigRead: pexIf %d, bus %d, dev %d, func %d, regOff 0x%x\n",
321 pexIf, bus, dev, func, regOff));
322
323 localDev = mvPexLocalDevNumGet(pexIf);
324 localBus = mvPexLocalBusNumGet(pexIf);
325
326 /* Speed up the process. In case on no link, return MV_ERROR */
327 if ((dev != localDev) || (bus != localBus))
328 {
329 pexData = MV_REG_READ(PEX_STATUS_REG(pexIf));
330
331 if ((pexData & PXSR_DL_DOWN))
332 {
333 return MV_ERROR;
334 }
335 }
336
337 /* in PCI Express we have only one device number */
338 /* and this number is the first number we encounter
339 else that the localDev*/
340 /* spec pex define return on config read/write on any device */
341 if (bus == localBus)
342 {
343 if (localDev == 0)
344 {
345 /* if local dev is 0 then the first number we encounter
346 after 0 is 1 */
347 if ((dev != 1)&&(dev != localDev))
348 {
349 return MV_ERROR;
350 }
351 }
352 else
353 {
354 /* if local dev is not 0 then the first number we encounter
355 is 0 */
356
357 if ((dev != 0)&&(dev != localDev))
358 {
359 return MV_ERROR;
360 }
361 }
362 if(func != 0 ) /* i.e bridge */
363 {
364 return MV_ERROR;
365 }
366 }
367
368
369 /* Creating PEX address to be passed */
370 pexData = (bus << PXCAR_BUS_NUM_OFFS);
371 pexData |= (dev << PXCAR_DEVICE_NUM_OFFS);
372 pexData |= (func << PXCAR_FUNC_NUM_OFFS);
373 pexData |= (regOff & PXCAR_REG_NUM_MASK); /* lgacy register space */
374 /* extended register space */
375 pexData |=(((regOff & PXCAR_REAL_EXT_REG_NUM_MASK) >>
376 PXCAR_REAL_EXT_REG_NUM_OFFS) << PXCAR_EXT_REG_NUM_OFFS);
377
378 pexData |= PXCAR_CONFIG_EN;
379
380 /* Write the address to the PEX configuration address register */
381 MV_REG_WRITE(PEX_CFG_ADDR_REG(pexIf), pexData);
382
383 DB(mvOsPrintf("mvPexConfigRead:address pexData=%x ",pexData));
384
385
386 /* In order to let the PEX controller absorbed the address of the read */
387 /* transaction we perform a validity check that the address was written */
388 if(pexData != MV_REG_READ(PEX_CFG_ADDR_REG(pexIf)))
389 {
390 return MV_ERROR;
391 }
392
393 /* cleaning Master Abort */
394 MV_REG_BIT_SET(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_STATUS_AND_COMMAND),
395 PXSAC_MABORT);
396 #if 0
397 /* Guideline (GL# PCI Express-1) Erroneous Read Data on Configuration */
398 /* This guideline is relevant for all devices except of the following devices:
399 88F5281-BO and above, 88F5181L-A0 and above, 88F1281 A0 and above
400 88F6183 A0 and above, 88F6183L */
401 if ( ( (dev != localDev) || (bus != localBus) ) &&
402 (
403 !(MV_5281_DEV_ID == mvCtrlModelGet())&&
404 !((MV_5181_DEV_ID == mvCtrlModelGet())&& (mvCtrlRevGet() >= MV_5181L_A0_REV))&&
405 !(MV_1281_DEV_ID == mvCtrlModelGet())&&
406 !(MV_6183_DEV_ID == mvCtrlModelGet())&&
407 !(MV_6183L_DEV_ID == mvCtrlModelGet())&&
408 !(MV_6281_DEV_ID == mvCtrlModelGet())&&
409 !(MV_6192_DEV_ID == mvCtrlModelGet())&&
410 !(MV_6190_DEV_ID == mvCtrlModelGet())&&
411 !(MV_6180_DEV_ID == mvCtrlModelGet())&&
412 !(MV_78XX0_DEV_ID == mvCtrlModelGet())
413 ))
414 {
415
416 /* PCI-Express configuration read work-around */
417
418 /* we will use one of the Punit (AHBToMbus) windows to access the xbar
419 and read the data from there */
420 /*
421 Need to configure the 2 free Punit (AHB to MBus bridge)
422 address decoding windows:
423 Configure the flash Window to handle Configuration space requests
424 for PEX0/1:
425 1. write 0x7931/0x7941 to the flash window and the size,
426 79-xbar attr (pci cfg), 3/4-xbar target (pex0/1), 1-WinEn
427 2. write base to flash window
428
429 Configuration transactions from the CPU should write/read the data
430 to/from address of the form:
431 addr[31:28] = 0x5 (for PEX0) or 0x6 (for PEX1)
432 addr[27:24] = extended register number
433 addr[23:16] = bus number
434 addr[15:11] = device number
435 addr[10:8] = function number
436 addr[7:0] = register number
437 */
438
439 #include "ctrlEnv/sys/mvAhbToMbus.h"
440 {
441 MV_U32 winNum;
442 MV_AHB_TO_MBUS_DEC_WIN originWin;
443 MV_U32 pciAddr=0;
444 MV_U32 remapLow=0,remapHigh=0;
445
446 /*
447 We will use DEV_CS2\Flash window for this workarround
448 */
449
450 winNum = mvAhbToMbusWinTargetGet(PEX_CONFIG_RW_WA_TARGET);
451
452 /* save remap values if exist */
453 if ((1 == winNum)||(0 == winNum))
454 {
455 remapLow = MV_REG_READ(AHB_TO_MBUS_WIN_REMAP_LOW_REG(winNum));
456 remapHigh = MV_REG_READ(AHB_TO_MBUS_WIN_REMAP_HIGH_REG(winNum));
457
458 }
459
460
461 /* save the original window values */
462 mvAhbToMbusWinGet(winNum,&originWin);
463
464 if (PEX_CONFIG_RW_WA_USE_ORIGINAL_WIN_VALUES)
465 {
466 /* set the window as xbar window */
467 if (pexIf)
468 {
469 MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum),
470 (0x7931 | (((originWin.addrWin.size >> 16)-1) ) << 16));
471 }
472 else
473 {
474 MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum),
475 (0x7941 | (((originWin.addrWin.size >> 16)-1) ) << 16));
476 }
477
478 MV_REG_WRITE(AHB_TO_MBUS_WIN_BASE_REG(winNum),
479 originWin.addrWin.baseLow);
480
481 /*pciAddr = originWin.addrWin.baseLow;*/
482 pciAddr = (MV_U32)CPU_MEMIO_UNCACHED_ADDR(
483 (MV_U32)originWin.addrWin.baseLow);
484
485 }
486 else
487 {
488 /* set the window as xbar window */
489 if (pexIf)
490 {
491 MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum),
492 (0x7931 | (((PEX_CONFIG_RW_WA_SIZE >> 16)-1) ) << 16));
493 }
494 else
495 {
496 MV_REG_WRITE(AHB_TO_MBUS_WIN_CTRL_REG(winNum),
497 (0x7941 | (((PEX_CONFIG_RW_WA_SIZE >> 16)-1) ) << 16));
498 }
499
500 MV_REG_WRITE(AHB_TO_MBUS_WIN_BASE_REG(winNum),
501 PEX_CONFIG_RW_WA_BASE);
502
503 pciAddr = (MV_U32)CPU_MEMIO_UNCACHED_ADDR(PEX_CONFIG_RW_WA_BASE);
504 }
505
506
507 /* remap should be as base */
508 if ((1 == winNum)||(0 == winNum))
509 {
510 MV_REG_WRITE(AHB_TO_MBUS_WIN_REMAP_LOW_REG(winNum),pciAddr);
511 MV_REG_WRITE(AHB_TO_MBUS_WIN_REMAP_HIGH_REG(winNum),0);
512
513 }
514
515 /* extended register space */
516 pciAddr |= (bus << 16);
517 pciAddr |= (dev << 11);
518 pciAddr |= (func << 8);
519 pciAddr |= (regOff & PXCAR_REG_NUM_MASK); /* lgacy register space */
520
521 pexData = *(MV_U32*)pciAddr;
522 pexData = MV_32BIT_LE(pexData); /* Data always in LE */
523
524 /* restore the original window values */
525 mvAhbToMbusWinSet(winNum,&originWin);
526
527 /* restore original remap values*/
528 if ((1 == winNum)||(0 == winNum))
529 {
530 MV_REG_WRITE(AHB_TO_MBUS_WIN_REMAP_LOW_REG(winNum),remapLow);
531 MV_REG_WRITE(AHB_TO_MBUS_WIN_REMAP_HIGH_REG(winNum),remapHigh);
532
533 }
534 }
535 }
536 else
537 #endif
538 {
539 /* Read the Data returned in the PEX Data register */
540 pexData = MV_REG_READ(PEX_CFG_DATA_REG(pexIf));
541
542 }
543
544 DB(mvOsPrintf("mvPexConfigRead: got : %x \n",pexData));
545
546 return pexData;
547
548 }
549
550 /*******************************************************************************
551 * mvPexConfigWrite - Write to configuration space
552 *
553 * DESCRIPTION:
554 * This function performs a 32 bit write to PEX configuration space.
555 * It supports both type 0 and type 1 of Configuration Transactions
556 * (local and over bridge). In order to write to local bus segment, use
557 * bus number retrieved from mvPexLocalBusNumGet(). Other bus numbers
558 * will result configuration transaction of type 1 (over bridge).
559 *
560 * INPUT:
561 * pexIf - PEX interface number.
562 * bus - PEX segment bus number.
563 * dev - PEX device number.
564 * func - Function number.
565 * regOffs - Register offset.
566 * data - 32bit data.
567 *
568 * OUTPUT:
569 * None.
570 *
571 * RETURN:
572 * MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
573 *
574 *******************************************************************************/
575 MV_STATUS mvPexConfigWrite(MV_U32 pexIf, MV_U32 bus, MV_U32 dev,
576 MV_U32 func, MV_U32 regOff, MV_U32 data)
577 {
578 #if defined(PCIE_VIRTUAL_BRIDGE_SUPPORT)
579 return mvPexVrtBrgConfigWrite (pexIf, bus, dev, func, regOff, data);
580 }
581
582 MV_STATUS mvPexHwConfigWrite(MV_U32 pexIf, MV_U32 bus, MV_U32 dev,
583 MV_U32 func, MV_U32 regOff, MV_U32 data)
584 {
585 #endif
586 MV_U32 pexData = 0;
587 MV_U32 localDev,localBus;
588
589 /* Parameter checking */
590 if (PEX_DEFAULT_IF != pexIf)
591 {
592 if (pexIf >= mvCtrlPexMaxIfGet())
593 {
594 mvOsPrintf("mvPexConfigWrite: ERR. Invalid PEX interface %d\n",
595 pexIf);
596 return MV_ERROR;
597 }
598 }
599
600 if (dev >= MAX_PEX_DEVICES)
601 {
602 mvOsPrintf("mvPexConfigWrite: ERR. device number illigal %d\n",dev);
603 return MV_BAD_PARAM;
604 }
605
606 if (func >= MAX_PEX_FUNCS)
607 {
608 mvOsPrintf("mvPexConfigWrite: ERR. function number illigal %d\n", func);
609 return MV_ERROR;
610 }
611
612 if (bus >= MAX_PEX_BUSSES)
613 {
614 mvOsPrintf("mvPexConfigWrite: ERR. bus number illigal %d\n", bus);
615 return MV_ERROR;
616 }
617
618
619
620 localDev = mvPexLocalDevNumGet(pexIf);
621 localBus = mvPexLocalBusNumGet(pexIf);
622
623
624 /* in PCI Express we have only one device number other than ourselves*/
625 /* and this number is the first number we encounter
626 else than the localDev that can be any valid dev number*/
627 /* pex spec define return on config read/write on any device */
628 if (bus == localBus)
629 {
630
631 if (localDev == 0)
632 {
633 /* if local dev is 0 then the first number we encounter
634 after 0 is 1 */
635 if ((dev != 1)&&(dev != localDev))
636 {
637 return MV_ERROR;
638 }
639
640 }
641 else
642 {
643 /* if local dev is not 0 then the first number we encounter
644 is 0 */
645
646 if ((dev != 0)&&(dev != localDev))
647 {
648 return MV_ERROR;
649 }
650 }
651
652
653 }
654
655 /* if we are not accessing ourselves , then check the link */
656 if ((dev != localDev) || (bus != localBus) )
657 {
658 /* workarround */
659 /* when no link return MV_ERROR */
660
661 pexData = MV_REG_READ(PEX_STATUS_REG(pexIf));
662
663 if ((pexData & PXSR_DL_DOWN))
664 {
665 return MV_ERROR;
666 }
667
668 }
669
670 pexData =0;
671
672 /* Creating PEX address to be passed */
673 pexData |= (bus << PXCAR_BUS_NUM_OFFS);
674 pexData |= (dev << PXCAR_DEVICE_NUM_OFFS);
675 pexData |= (func << PXCAR_FUNC_NUM_OFFS);
676 pexData |= (regOff & PXCAR_REG_NUM_MASK); /* lgacy register space */
677 /* extended register space */
678 pexData |=(((regOff & PXCAR_REAL_EXT_REG_NUM_MASK) >>
679 PXCAR_REAL_EXT_REG_NUM_OFFS) << PXCAR_EXT_REG_NUM_OFFS);
680 pexData |= PXCAR_CONFIG_EN;
681
682 DB(mvOsPrintf("mvPexConfigWrite: If=%x bus=%x func=%x dev=%x regOff=%x data=%x \n",
683 pexIf,bus,func,dev,regOff,data,pexData) );
684
685 /* Write the address to the PEX configuration address register */
686 MV_REG_WRITE(PEX_CFG_ADDR_REG(pexIf), pexData);
687
688 /* Clear CPU pipe. Important where CPU can perform OOO execution */
689 CPU_PIPE_FLUSH;
690
691 /* In order to let the PEX controller absorbed the address of the read */
692 /* transaction we perform a validity check that the address was written */
693 if(pexData != MV_REG_READ(PEX_CFG_ADDR_REG(pexIf)))
694 {
695 return MV_ERROR;
696 }
697
698 /* Write the Data passed to the PEX Data register */
699 MV_REG_WRITE(PEX_CFG_DATA_REG(pexIf), data);
700
701 return MV_OK;
702
703 }
704
705 /*******************************************************************************
706 * mvPexMasterEnable - Enable/disale PEX interface master transactions.
707 *
708 * DESCRIPTION:
709 * This function performs read modified write to PEX command status
710 * (offset 0x4) to set/reset bit 2. After this bit is set, the PEX
711 * master is allowed to gain ownership on the bus, otherwise it is
712 * incapable to do so.
713 *
714 * INPUT:
715 * pexIf - PEX interface number.
716 * enable - Enable/disable parameter.
717 *
718 * OUTPUT:
719 * None.
720 *
721 * RETURN:
722 * MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
723 *
724 *******************************************************************************/
725 MV_STATUS mvPexMasterEnable(MV_U32 pexIf, MV_BOOL enable)
726 {
727 MV_U32 pexCommandStatus;
728 MV_U32 localBus;
729 MV_U32 localDev;
730
731 /* Parameter checking */
732 if (pexIf >= mvCtrlPexMaxIfGet())
733 {
734 mvOsPrintf("mvPexMasterEnable: ERR. Invalid PEX interface %d\n", pexIf);
735 return MV_ERROR;
736 }
737
738 localBus = mvPexLocalBusNumGet(pexIf);
739 localDev = mvPexLocalDevNumGet(pexIf);
740
741 pexCommandStatus = MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf,
742 PEX_STATUS_AND_COMMAND));
743
744
745 if (MV_TRUE == enable)
746 {
747 pexCommandStatus |= PXSAC_MASTER_EN;
748 }
749 else
750 {
751 pexCommandStatus &= ~PXSAC_MASTER_EN;
752 }
753
754
755 MV_REG_WRITE(PEX_CFG_DIRECT_ACCESS(pexIf,PEX_STATUS_AND_COMMAND),
756 pexCommandStatus);
757
758 return MV_OK;
759 }
760
761
762 /*******************************************************************************
763 * mvPexSlaveEnable - Enable/disale PEX interface slave transactions.
764 *
765 * DESCRIPTION:
766 * This function performs read modified write to PEX command status
767 * (offset 0x4) to set/reset bit 0 and 1. After those bits are set,
768 * the PEX slave is allowed to respond to PEX IO space access (bit 0)
769 * and PEX memory space access (bit 1).
770 *
771 * INPUT:
772 * pexIf - PEX interface number.
773 * dev - PEX device number.
774 * enable - Enable/disable parameter.
775 *
776 * OUTPUT:
777 * None.
778 *
779 * RETURN:
780 * MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
781 *
782 *******************************************************************************/
783 MV_STATUS mvPexSlaveEnable(MV_U32 pexIf, MV_U32 bus,MV_U32 dev, MV_BOOL enable)
784 {
785 MV_U32 pexCommandStatus;
786 MV_U32 RegOffs;
787
788 /* Parameter checking */
789 if (pexIf >= mvCtrlPexMaxIfGet())
790 {
791 mvOsPrintf("mvPexSlaveEnable: ERR. Invalid PEX interface %d\n", pexIf);
792 return MV_BAD_PARAM;
793 }
794 if (dev >= MAX_PEX_DEVICES)
795 {
796 mvOsPrintf("mvPexLocalDevNumSet: ERR. device number illigal %d\n", dev);
797 return MV_BAD_PARAM;
798
799 }
800
801
802 RegOffs = PEX_STATUS_AND_COMMAND;
803
804 pexCommandStatus = mvPexConfigRead(pexIf, bus, dev, 0, RegOffs);
805
806 if (MV_TRUE == enable)
807 {
808 pexCommandStatus |= (PXSAC_IO_EN | PXSAC_MEM_EN);
809 }
810 else
811 {
812 pexCommandStatus &= ~(PXSAC_IO_EN | PXSAC_MEM_EN);
813 }
814
815 mvPexConfigWrite(pexIf, bus, dev, 0, RegOffs, pexCommandStatus);
816
817 return MV_OK;
818
819 }
820
821 /*******************************************************************************
822 * mvPexLocalBusNumSet - Set PEX interface local bus number.
823 *
824 * DESCRIPTION:
825 * This function sets given PEX interface its local bus number.
826 * Note: In case the PEX interface is PEX-X, the information is read-only.
827 *
828 * INPUT:
829 * pexIf - PEX interface number.
830 * busNum - Bus number.
831 *
832 * OUTPUT:
833 * None.
834 *
835 * RETURN:
836 * MV_NOT_ALLOWED in case PEX interface is PEX-X.
837 * MV_BAD_PARAM on bad parameters ,
838 * otherwise MV_OK
839 *
840 *******************************************************************************/
841 MV_STATUS mvPexLocalBusNumSet(MV_U32 pexIf, MV_U32 busNum)
842 {
843 MV_U32 pexStatus;
844 MV_U32 localBus;
845 MV_U32 localDev;
846
847
848 /* Parameter checking */
849 if (pexIf >= mvCtrlPexMaxIfGet())
850 {
851 mvOsPrintf("mvPexLocalBusNumSet: ERR. Invalid PEX interface %d\n",pexIf);
852 return MV_BAD_PARAM;
853 }
854 if (busNum >= MAX_PEX_BUSSES)
855 {
856 mvOsPrintf("mvPexLocalBusNumSet: ERR. bus number illigal %d\n", busNum);
857 return MV_ERROR;
858
859 }
860
861 localBus = mvPexLocalBusNumGet(pexIf);
862 localDev = mvPexLocalDevNumGet(pexIf);
863
864
865
866 pexStatus = MV_REG_READ(PEX_STATUS_REG(pexIf));
867
868 pexStatus &= ~PXSR_PEX_BUS_NUM_MASK;
869
870 pexStatus |= (busNum << PXSR_PEX_BUS_NUM_OFFS) & PXSR_PEX_BUS_NUM_MASK;
871
872 MV_REG_WRITE(PEX_STATUS_REG(pexIf), pexStatus);
873
874
875 return MV_OK;
876 }
877
878
879 /*******************************************************************************
880 * mvPexLocalBusNumGet - Get PEX interface local bus number.
881 *
882 * DESCRIPTION:
883 * This function gets the local bus number of a given PEX interface.
884 *
885 * INPUT:
886 * pexIf - PEX interface number.
887 *
888 * OUTPUT:
889 * None.
890 *
891 * RETURN:
892 * Local bus number.0xffffffff on Error
893 *
894 *******************************************************************************/
895 MV_U32 mvPexLocalBusNumGet(MV_U32 pexIf)
896 {
897 MV_U32 pexStatus;
898
899 /* Parameter checking */
900 if (PEX_DEFAULT_IF != pexIf)
901 {
902 if (pexIf >= mvCtrlPexMaxIfGet())
903 {
904 mvOsPrintf("mvPexLocalBusNumGet: ERR. Invalid PEX interface %d\n",pexIf);
905 return 0xFFFFFFFF;
906 }
907 }
908
909
910 pexStatus = MV_REG_READ(PEX_STATUS_REG(pexIf));
911
912 pexStatus &= PXSR_PEX_BUS_NUM_MASK;
913
914 return (pexStatus >> PXSR_PEX_BUS_NUM_OFFS);
915
916 }
917
918
919 /*******************************************************************************
920 * mvPexLocalDevNumSet - Set PEX interface local device number.
921 *
922 * DESCRIPTION:
923 * This function sets given PEX interface its local device number.
924 * Note: In case the PEX interface is PEX-X, the information is read-only.
925 *
926 * INPUT:
927 * pexIf - PEX interface number.
928 * devNum - Device number.
929 *
930 * OUTPUT:
931 * None.
932 *
933 * RETURN:
934 * MV_NOT_ALLOWED in case PEX interface is PEX-X.
935 * MV_BAD_PARAM on bad parameters ,
936 * otherwise MV_OK
937 *
938 *******************************************************************************/
939 MV_STATUS mvPexLocalDevNumSet(MV_U32 pexIf, MV_U32 devNum)
940 {
941 MV_U32 pexStatus;
942 MV_U32 localBus;
943 MV_U32 localDev;
944
945 /* Parameter checking */
946 if (pexIf >= mvCtrlPexMaxIfGet())
947 {
948 mvOsPrintf("mvPexLocalDevNumSet: ERR. Invalid PEX interface %d\n",pexIf);
949 return MV_BAD_PARAM;
950 }
951 if (devNum >= MAX_PEX_DEVICES)
952 {
953 mvOsPrintf("mvPexLocalDevNumSet: ERR. device number illigal %d\n",
954 devNum);
955 return MV_BAD_PARAM;
956
957 }
958
959 localBus = mvPexLocalBusNumGet(pexIf);
960 localDev = mvPexLocalDevNumGet(pexIf);
961
962
963 pexStatus = MV_REG_READ(PEX_STATUS_REG(pexIf));
964
965 pexStatus &= ~PXSR_PEX_DEV_NUM_MASK;
966
967 pexStatus |= (devNum << PXSR_PEX_DEV_NUM_OFFS) & PXSR_PEX_DEV_NUM_MASK;
968
969 MV_REG_WRITE(PEX_STATUS_REG(pexIf), pexStatus);
970
971
972 return MV_OK;
973 }
974
975 /*******************************************************************************
976 * mvPexLocalDevNumGet - Get PEX interface local device number.
977 *
978 * DESCRIPTION:
979 * This function gets the local device number of a given PEX interface.
980 *
981 * INPUT:
982 * pexIf - PEX interface number.
983 *
984 * OUTPUT:
985 * None.
986 *
987 * RETURN:
988 * Local device number. 0xffffffff on Error
989 *
990 *******************************************************************************/
991 MV_U32 mvPexLocalDevNumGet(MV_U32 pexIf)
992 {
993 MV_U32 pexStatus;
994
995 /* Parameter checking */
996
997 if (PEX_DEFAULT_IF != pexIf)
998 {
999 if (pexIf >= mvCtrlPexMaxIfGet())
1000 {
1001 mvOsPrintf("mvPexLocalDevNumGet: ERR. Invalid PEX interface %d\n",
1002 pexIf);
1003 return 0xFFFFFFFF;
1004 }
1005 }
1006
1007 pexStatus = MV_REG_READ(PEX_STATUS_REG(pexIf));
1008
1009 pexStatus &= PXSR_PEX_DEV_NUM_MASK;
1010
1011 return (pexStatus >> PXSR_PEX_DEV_NUM_OFFS);
1012 }
1013
1014 MV_VOID mvPexPhyRegRead(MV_U32 pexIf, MV_U32 regOffset, MV_U16 *value)
1015 {
1016
1017 MV_U32 regAddr;
1018 if (pexIf >= mvCtrlPexMaxIfGet())
1019 {
1020 mvOsPrintf("mvPexPhyRegRead: ERR. Invalid PEX interface %d\n", pexIf);
1021 return;
1022 }
1023 regAddr = (BIT31 | ((regOffset & 0x3fff) << 16));
1024 MV_REG_WRITE(PEX_PHY_ACCESS_REG(pexIf), regAddr);
1025 *value = MV_REG_READ(PEX_PHY_ACCESS_REG(pexIf));
1026 }
1027
1028
1029 MV_VOID mvPexPhyRegWrite(MV_U32 pexIf, MV_U32 regOffset, MV_U16 value)
1030 {
1031
1032 MV_U32 regAddr;
1033 if(pexIf >= mvCtrlPexMaxIfGet())
1034 {
1035 mvOsPrintf("mvPexPhyRegWrite: ERR. Invalid PEX interface %d\n", pexIf);
1036 return;
1037 }
1038 regAddr = (((regOffset & 0x3fff) << 16) | value);
1039 MV_REG_WRITE(PEX_PHY_ACCESS_REG(pexIf), regAddr);
1040 }
1041
1042 /*******************************************************************************
1043 * mvPexActiveStateLinkPMEnable
1044 *
1045 * DESCRIPTION:
1046 * Enable Active Link State Power Management
1047 *
1048 * INPUT:
1049 * pexIf - PEX interface number.
1050 * enable - MV_TRUE to enable ASPM, MV_FALSE to disable.
1051 *
1052 * OUTPUT:
1053 * None
1054 *
1055 * RETURN:
1056 * MV_OK on success , MV_ERROR otherwise
1057 *
1058 *******************************************************************************/
1059 MV_STATUS mvPexActiveStateLinkPMEnable(MV_U32 pexIf, MV_BOOL enable)
1060 {
1061 MV_U32 reg;
1062
1063 if(pexIf >= mvCtrlPexMaxIfGet())
1064 {
1065 mvOsPrintf("mvPexActiveStateLinkPMEnable: ERR. Invalid PEX interface %d\n", pexIf);
1066 return MV_ERROR;
1067 }
1068
1069 reg = MV_REG_READ(PEX_PWR_MNG_EXT_REG(pexIf)) & ~PXPMER_L1_ASPM_EN_MASK;
1070 if(enable == MV_TRUE)
1071 reg |= PXPMER_L1_ASPM_EN_MASK;
1072 MV_REG_WRITE(PEX_PWR_MNG_EXT_REG(pexIf), reg);
1073
1074 /* Enable / Disable L0/1 entry */
1075 reg = MV_REG_READ(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CTRL_STAT_REG))
1076 & ~PXLCSR_ASPM_CNT_MASK;
1077 if(enable == MV_TRUE)
1078 reg |= PXLCSR_ASPM_CNT_L0S_L1S_ENT_SUPP;
1079 MV_REG_WRITE(PEX_CFG_DIRECT_ACCESS(pexIf, PEX_LINK_CTRL_STAT_REG), reg);
1080
1081 return MV_OK;
1082 }
1083
1084
1085 /*******************************************************************************
1086 * mvPexForceX1
1087 *
1088 * DESCRIPTION:
1089 * shut down lanes 1-3 if recognize that attached to an x1 end-point
1090 * INPUT:
1091 * pexIf - PEX interface number.
1092 *
1093 * OUTPUT:
1094 * None
1095 *
1096 * RETURN:
1097 * MV_OK on success , MV_ERROR otherwise
1098 *
1099 *******************************************************************************/
1100 MV_U32 mvPexForceX1(MV_U32 pexIf)
1101 {
1102 MV_U32 regData = 0;
1103 if(pexIf >= mvCtrlPexMaxIfGet())
1104 {
1105 mvOsPrintf("mvPexForceX1: ERR. Invalid PEX interface %d\n", pexIf);
1106 return MV_BAD_PARAM;
1107 }
1108
1109 regData = MV_REG_READ(PEX_CTRL_REG(pexIf)) & ~(PXCR_CONF_LINK_MASK) ;
1110 regData |= PXCR_CONF_LINK_X1;
1111
1112 MV_REG_WRITE(PEX_CTRL_REG(pexIf), regData);
1113 return MV_OK;
1114 }
1115
1116 MV_BOOL mvPexIsPowerUp(MV_U32 pexIf)
1117 {
1118 if(pexIf >= mvCtrlPexMaxIfGet())
1119 {
1120 mvOsPrintf("mvPexIsPowerUp: ERR. Invalid PEX interface %d\n", pexIf);
1121 return MV_FALSE;
1122 }
1123 return mvCtrlPwrClckGet(PEX_UNIT_ID, pexIf);
1124 }
1125
1126
1127 MV_VOID mvPexPowerDown(MV_U32 pexIf)
1128 {
1129 if ( (mvCtrlModelGet() == MV_78XX0_DEV_ID) ||
1130 (mvCtrlModelGet() == MV_76100_DEV_ID) ||
1131 (mvCtrlModelGet() == MV_78100_DEV_ID) ||
1132 (mvCtrlModelGet() == MV_78200_DEV_ID) )
1133 {
1134 mvCtrlPwrClckSet(PEX_UNIT_ID, pexIf, MV_FALSE);
1135 }
1136 else
1137 {
1138 MV_REG_WRITE((0x41B00 -(pexIf)*0x10000), 0x20800087);
1139 }
1140 }
1141
1142
1143
OpenWrt Source Repository