Root/target/linux/generic/files/crypto/ocf/kirkwood/mvHal/mv_hal/pci-if/mvPciIf.c

1/*******************************************************************************
2Copyright (C) Marvell International Ltd. and its affiliates
3
4This software file (the "File") is owned and distributed by Marvell
5International Ltd. and/or its affiliates ("Marvell") under the following
6alternative licensing terms. Once you have made an election to distribute the
7File under one of the following license alternatives, please (i) delete this
8introductory statement regarding license alternatives, (ii) delete the two
9license alternatives that you have not elected to use and (iii) preserve the
10Marvell copyright notice above.
11
12********************************************************************************
13Marvell Commercial License Option
14
15If you received this File from Marvell and you have entered into a commercial
16license agreement (a "Commercial License") with Marvell, the File is licensed
17to you under the terms of the applicable Commercial License.
18
19********************************************************************************
20Marvell GPL License Option
21
22If you received this File from Marvell, you may opt to use, redistribute and/or
23modify this File in accordance with the terms and conditions of the General
24Public License Version 2, June 1991 (the "GPL License"), a copy of which is
25available along with the File in the license.txt file or by writing to the Free
26Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
27on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
28
29THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
30WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
31DISCLAIMED. The GPL License provides additional details about this warranty
32disclaimer.
33********************************************************************************
34Marvell BSD License Option
35
36If you received this File from Marvell, you may opt to use, redistribute and/or
37modify this File under the following licensing terms.
38Redistribution and use in source and binary forms, with or without modification,
39are 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    
52THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
53ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
54WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
55DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
56ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
57(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
58LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
59ANY 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
61SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62
63*******************************************************************************/
64
65#include "mvPciIf.h"
66#include "ctrlEnv/sys/mvSysPex.h"
67
68#if defined(MV_INCLUDE_PCI)
69#include "ctrlEnv/sys/mvSysPci.h"
70#endif
71
72
73/* defines */
74#ifdef MV_DEBUG
75    #define DB(x) x
76#else
77    #define DB(x)
78#endif
79                     
80
81/*******************************************************************************
82* mvPciInit - Initialize PCI interfaces
83*
84* DESCRIPTION:
85*
86* INPUT:
87*
88*
89* OUTPUT:
90* None.
91*
92* RETURN:
93* MV_OK if function success otherwise MV_ERROR or MV_BAD_PARAM
94*
95*******************************************************************************/
96
97
98MV_STATUS mvPciIfInit(MV_U32 pciIf, PCI_IF_MODE pciIfmode)
99{
100    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
101
102    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
103    {
104        #if defined(MV_INCLUDE_PCI)
105        
106        MV_PCI_MOD pciMod;
107        
108        if (PCI_IF_MODE_HOST == pciIfmode)
109        {
110            pciMod = MV_PCI_MOD_HOST;
111        }
112        else if (PCI_IF_MODE_DEVICE == pciIfmode)
113        {
114            pciMod = MV_PCI_MOD_DEVICE;
115        }
116        else
117        {
118            mvOsPrintf("%s: ERROR!!! Bus %d mode %d neither host nor device!\n",
119                        __FUNCTION__, pciIf, pciIfmode);
120            return MV_FAIL;
121        }
122        
123        return mvPciInit(pciIf - MV_PCI_START_IF, pciMod);
124        #else
125        return MV_OK;
126        #endif
127    }
128    else if (PCI_IF_TYPE_PEX == pciIfType)
129    {
130        #if defined(MV_INCLUDE_PEX)
131        
132        MV_PEX_TYPE pexType;
133        
134        if (PCI_IF_MODE_HOST == pciIfmode)
135        {
136            pexType = MV_PEX_ROOT_COMPLEX;
137        }
138        else if (PCI_IF_MODE_DEVICE == pciIfmode)
139        {
140            pexType = MV_PEX_END_POINT;
141        }
142        else
143        {
144            mvOsPrintf("%s: ERROR!!! Bus %d type %d neither root complex nor" \
145                       " end point\n", __FUNCTION__, pciIf, pciIfmode);
146            return MV_FAIL;
147        }
148        return mvPexInit(pciIf - MV_PEX_START_IF, pexType);
149
150        #else
151        return MV_OK;
152        #endif
153
154    }
155    else
156    {
157        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
158    }
159
160    return MV_FAIL;
161
162}
163
164/* PCI configuration space read write */
165
166/*******************************************************************************
167* mvPciConfigRead - Read from configuration space
168*
169* DESCRIPTION:
170* This function performs a 32 bit read from PCI configuration space.
171* It supports both type 0 and type 1 of Configuration Transactions
172* (local and over bridge). In order to read from local bus segment, use
173* bus number retrieved from mvPciLocalBusNumGet(). Other bus numbers
174* will result configuration transaction of type 1 (over bridge).
175*
176* INPUT:
177* pciIf - PCI interface number.
178* bus - PCI segment bus number.
179* dev - PCI device number.
180* func - Function number.
181* regOffs - Register offset.
182*
183* OUTPUT:
184* None.
185*
186* RETURN:
187* 32bit register data, 0xffffffff on error
188*
189*******************************************************************************/
190MV_U32 mvPciIfConfigRead (MV_U32 pciIf, MV_U32 bus, MV_U32 dev, MV_U32 func,
191                        MV_U32 regOff)
192{
193    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
194
195    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
196    {
197        #if defined(MV_INCLUDE_PCI)
198        return mvPciConfigRead(pciIf - MV_PCI_START_IF,
199                                bus,
200                                dev,
201                                func,
202                                regOff);
203        #else
204        return 0xffffffff;
205        #endif
206    }
207    else if (PCI_IF_TYPE_PEX == pciIfType)
208    {
209        #if defined(MV_INCLUDE_PEX)
210        return mvPexConfigRead(pciIf - MV_PEX_START_IF,
211                                bus,
212                                dev,
213                                func,
214                                regOff);
215        #else
216        return 0xffffffff;
217        #endif
218
219    }
220    else
221    {
222        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
223    }
224
225    return 0;
226
227}
228
229/*******************************************************************************
230* mvPciConfigWrite - Write to configuration space
231*
232* DESCRIPTION:
233* This function performs a 32 bit write to PCI configuration space.
234* It supports both type 0 and type 1 of Configuration Transactions
235* (local and over bridge). In order to write to local bus segment, use
236* bus number retrieved from mvPciLocalBusNumGet(). Other bus numbers
237* will result configuration transaction of type 1 (over bridge).
238*
239* INPUT:
240* pciIf - PCI interface number.
241* bus - PCI segment bus number.
242* dev - PCI device number.
243* func - Function number.
244* regOffs - Register offset.
245* data - 32bit data.
246*
247* OUTPUT:
248* None.
249*
250* RETURN:
251* MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
252*
253*******************************************************************************/
254MV_STATUS mvPciIfConfigWrite(MV_U32 pciIf, MV_U32 bus, MV_U32 dev,
255                           MV_U32 func, MV_U32 regOff, MV_U32 data)
256{
257    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
258
259    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
260    {
261        #if defined(MV_INCLUDE_PCI)
262        return mvPciConfigWrite(pciIf - MV_PCI_START_IF,
263                                bus,
264                                dev,
265                                func,
266                                regOff,
267                                data);
268        #else
269        return MV_OK;
270        #endif
271    }
272    else if (PCI_IF_TYPE_PEX == pciIfType)
273    {
274        #if defined(MV_INCLUDE_PEX)
275        return mvPexConfigWrite(pciIf - MV_PEX_START_IF,
276                                bus,
277                                dev,
278                                func,
279                                regOff,
280                                data);
281        #else
282        return MV_OK;
283        #endif
284
285    }
286    else
287    {
288        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
289    }
290
291    return MV_FAIL;
292
293}
294
295/*******************************************************************************
296* mvPciMasterEnable - Enable/disale PCI interface master transactions.
297*
298* DESCRIPTION:
299* This function performs read modified write to PCI command status
300* (offset 0x4) to set/reset bit 2. After this bit is set, the PCI
301* master is allowed to gain ownership on the bus, otherwise it is
302* incapable to do so.
303*
304* INPUT:
305* pciIf - PCI interface number.
306* enable - Enable/disable parameter.
307*
308* OUTPUT:
309* None.
310*
311* RETURN:
312* MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
313*
314*******************************************************************************/
315MV_STATUS mvPciIfMasterEnable(MV_U32 pciIf, MV_BOOL enable)
316{
317
318    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
319
320    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
321    {
322        #if defined(MV_INCLUDE_PCI)
323        return mvPciMasterEnable(pciIf - MV_PCI_START_IF,
324                                enable);
325        #else
326        return MV_OK;
327        #endif
328    }
329    else if (PCI_IF_TYPE_PEX == pciIfType)
330    {
331        #if defined(MV_INCLUDE_PEX)
332        return mvPexMasterEnable(pciIf - MV_PEX_START_IF,
333                                enable);
334        #else
335        return MV_OK;
336        #endif
337    }
338    else
339    {
340        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
341    }
342
343    return MV_FAIL;
344
345}
346
347
348/*******************************************************************************
349* mvPciSlaveEnable - Enable/disale PCI interface slave transactions.
350*
351* DESCRIPTION:
352* This function performs read modified write to PCI command status
353* (offset 0x4) to set/reset bit 0 and 1. After those bits are set,
354* the PCI slave is allowed to respond to PCI IO space access (bit 0)
355* and PCI memory space access (bit 1).
356*
357* INPUT:
358* pciIf - PCI interface number.
359* dev - PCI device number.
360* enable - Enable/disable parameter.
361*
362* OUTPUT:
363* None.
364*
365* RETURN:
366* MV_BAD_PARAM for bad parameters ,MV_ERROR on error ! otherwise MV_OK
367*
368*******************************************************************************/
369MV_STATUS mvPciIfSlaveEnable(MV_U32 pciIf,MV_U32 bus, MV_U32 dev, MV_BOOL enable)
370{
371
372    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
373
374    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
375    {
376        #if defined(MV_INCLUDE_PCI)
377        return mvPciSlaveEnable(pciIf - MV_PCI_START_IF,bus,dev,
378                                enable);
379        #else
380        return MV_OK;
381        #endif
382    }
383    else if (PCI_IF_TYPE_PEX == pciIfType)
384    {
385        #if defined(MV_INCLUDE_PEX)
386        return mvPexSlaveEnable(pciIf - MV_PEX_START_IF,bus,dev,
387                                enable);
388        #else
389        return MV_OK;
390        #endif
391    }
392    else
393    {
394        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
395    }
396
397    return MV_FAIL;
398
399}
400
401/*******************************************************************************
402* mvPciLocalBusNumSet - Set PCI interface local bus number.
403*
404* DESCRIPTION:
405* This function sets given PCI interface its local bus number.
406* Note: In case the PCI interface is PCI-X, the information is read-only.
407*
408* INPUT:
409* pciIf - PCI interface number.
410* busNum - Bus number.
411*
412* OUTPUT:
413* None.
414*
415* RETURN:
416* MV_NOT_ALLOWED in case PCI interface is PCI-X.
417* MV_BAD_PARAM on bad parameters ,
418* otherwise MV_OK
419*
420*******************************************************************************/
421MV_STATUS mvPciIfLocalBusNumSet(MV_U32 pciIf, MV_U32 busNum)
422{
423    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
424
425    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
426    {
427        #if defined(MV_INCLUDE_PCI)
428        return mvPciLocalBusNumSet(pciIf - MV_PCI_START_IF,
429                                busNum);
430        #else
431        return MV_OK;
432        #endif
433    }
434    else if (PCI_IF_TYPE_PEX == pciIfType)
435    {
436        #if defined(MV_INCLUDE_PEX)
437        return mvPexLocalBusNumSet(pciIf - MV_PEX_START_IF,
438                                busNum);
439        #else
440        return MV_OK;
441        #endif
442    }
443    else
444    {
445        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
446    }
447
448    return MV_FAIL;
449
450}
451
452/*******************************************************************************
453* mvPciLocalBusNumGet - Get PCI interface local bus number.
454*
455* DESCRIPTION:
456* This function gets the local bus number of a given PCI interface.
457*
458* INPUT:
459* pciIf - PCI interface number.
460*
461* OUTPUT:
462* None.
463*
464* RETURN:
465* Local bus number.0xffffffff on Error
466*
467*******************************************************************************/
468MV_U32 mvPciIfLocalBusNumGet(MV_U32 pciIf)
469{
470    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
471
472    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
473    {
474        #if defined(MV_INCLUDE_PCI)
475        return mvPciLocalBusNumGet(pciIf - MV_PCI_START_IF);
476        #else
477        return 0xFFFFFFFF;
478        #endif
479    }
480    else if (PCI_IF_TYPE_PEX == pciIfType)
481    {
482        #if defined(MV_INCLUDE_PEX)
483        return mvPexLocalBusNumGet(pciIf - MV_PEX_START_IF);
484        #else
485        return 0xFFFFFFFF;
486        #endif
487
488    }
489    else
490    {
491        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n",__FUNCTION__, pciIf);
492    }
493
494    return 0;
495
496}
497
498
499/*******************************************************************************
500* mvPciLocalDevNumSet - Set PCI interface local device number.
501*
502* DESCRIPTION:
503* This function sets given PCI interface its local device number.
504* Note: In case the PCI interface is PCI-X, the information is read-only.
505*
506* INPUT:
507* pciIf - PCI interface number.
508* devNum - Device number.
509*
510* OUTPUT:
511* None.
512*
513* RETURN:
514* MV_NOT_ALLOWED in case PCI interface is PCI-X. MV_BAD_PARAM on bad parameters ,
515* otherwise MV_OK
516*
517*******************************************************************************/
518MV_STATUS mvPciIfLocalDevNumSet(MV_U32 pciIf, MV_U32 devNum)
519{
520    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
521
522    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
523    {
524        #if defined(MV_INCLUDE_PCI)
525        return mvPciLocalDevNumSet(pciIf - MV_PCI_START_IF,
526                                devNum);
527        #else
528        return MV_OK;
529        #endif
530    }
531    else if (PCI_IF_TYPE_PEX == pciIfType)
532    {
533        #if defined(MV_INCLUDE_PEX)
534        return mvPexLocalDevNumSet(pciIf - MV_PEX_START_IF,
535                                devNum);
536        #else
537        return MV_OK;
538        #endif
539    }
540    else
541    {
542        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
543    }
544
545    return MV_FAIL;
546
547}
548
549/*******************************************************************************
550* mvPciLocalDevNumGet - Get PCI interface local device number.
551*
552* DESCRIPTION:
553* This function gets the local device number of a given PCI interface.
554*
555* INPUT:
556* pciIf - PCI interface number.
557*
558* OUTPUT:
559* None.
560*
561* RETURN:
562* Local device number. 0xffffffff on Error
563*
564*******************************************************************************/
565MV_U32 mvPciIfLocalDevNumGet(MV_U32 pciIf)
566{
567    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
568
569    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
570    {
571        #if defined(MV_INCLUDE_PCI)
572        return mvPciLocalDevNumGet(pciIf - MV_PCI_START_IF);
573        #else
574        return 0xFFFFFFFF;
575        #endif
576    }
577    else if (PCI_IF_TYPE_PEX == pciIfType)
578    {
579        #if defined(MV_INCLUDE_PEX)
580        return mvPexLocalDevNumGet(pciIf - MV_PEX_START_IF);
581        #else
582        return 0xFFFFFFFF;
583        #endif
584
585    }
586    else
587    {
588        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
589    }
590
591    return 0;
592
593}
594
595/*******************************************************************************
596* mvPciIfTypeGet -
597*
598* DESCRIPTION:
599*
600* INPUT:
601*
602* OUTPUT:
603* None.
604*
605* RETURN:
606*
607*******************************************************************************/
608
609PCI_IF_TYPE mvPciIfTypeGet(MV_U32 pciIf)
610{
611
612    if ((pciIf >= MV_PCI_START_IF)&&(pciIf < MV_PCI_MAX_IF + MV_PCI_START_IF))
613    {
614        return PCI_IF_TYPE_CONVEN_PCIX;
615    }
616    else if ((pciIf >= MV_PEX_START_IF) &&
617             (pciIf < MV_PEX_MAX_IF + MV_PEX_START_IF))
618    {
619        return PCI_IF_TYPE_PEX;
620
621    }
622    else
623    {
624        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
625    }
626
627    return 0xffffffff;
628
629}
630
631/*******************************************************************************
632* mvPciIfTypeGet -
633*
634* DESCRIPTION:
635*
636* INPUT:
637*
638* OUTPUT:
639* None.
640*
641* RETURN:
642*
643*******************************************************************************/
644
645MV_U32 mvPciRealIfNumGet(MV_U32 pciIf)
646{
647
648    PCI_IF_TYPE pciIfType = mvPciIfTypeGet(pciIf);
649
650    if (PCI_IF_TYPE_CONVEN_PCIX == pciIfType)
651    {
652        return (pciIf - MV_PCI_START_IF);
653    }
654    else if (PCI_IF_TYPE_PEX == pciIfType)
655    {
656        return (pciIf - MV_PEX_START_IF);
657
658    }
659    else
660    {
661        mvOsPrintf("%s: ERROR!!! Invalid pciIf %d\n", __FUNCTION__, pciIf);
662    }
663
664    return 0xffffffff;
665
666}
667
668
669
670

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive