开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
sysLib.c
资源名称：mpc8548.rar　[点击查看]
上传用户：dqzhongke1
上传日期：2022-06-26
资源大小：667k
文件大小：65k
源码类别：

VxWorks

开发平台：

C/C++

sysLib.c：源码内容
  1. /* sysLib.c - Wind River SBC548 board system-dependent library */
  3. /*
  4.  * Copyright (c) 2006-2007 Wind River Systems, Inc.
  5.  *
  6.  * The right to copy, distribute, modify or otherwise make use
  7.  * of this software may be licensed only pursuant to the terms
  8.  * of an applicable Wind River license agreement.
  9.  */
  11. /*
  12. modification history
  13. --------------------
  14. 01b,03apr07,b_m  add TFFS map to static tlb table and phyMemDesc table.
  15. 01a,31jan06,kds  Modified from cds8458/sysLib.c/01c
  16. */
  18. /*
  19.  * DESCRIPTION
  20.  * This library provides board-specific routines for SBC8548.
  21.  *
  22.  * INCLUDE FILES:
  23.  *
  24.  * SEE ALSO:
  25.  * .pG "Configuration"
  26. */
  28. /* includes */
  29. #define SYSLIB_CALL
  30. #include <vxWorks.h>
  31. #include <vme.h>
  32. #include <memLib.h>
  33. #include <cacheLib.h>
  34. #include <sysLib.h>
  35. #include "config.h"
  36. #include "configNet.h"
  37. #include <string.h>
  38. #include <intLib.h>
  39. #include <logLib.h>
  40. #include <stdio.h>
  41. #include <taskLib.h>
  42. #include <vxLib.h>
  43. #include <tyLib.h>
  44. #include <arch/ppc/mmuE500Lib.h>
  45. #include <arch/ppc/vxPpcLib.h>
  46. #include <private/vmLibP.h>
  47. #include <miiLib.h>
  50. #ifdef INCLUDE_PCI
  51.     #include <drv/pci/pciConfigLib.h>
  52.     #include <drv/pci/pciIntLib.h>
  53.     #include "mot85xxPci.h"
  54. #endif /* INCLUDE_PCI */
  56. #ifdef INCLUDE_I2C_DEV
  57. #include "i2cPCF8547Ioport.h"
  58. #include "i2cM41T81Clock.h"
  59. #include "usrTime.c"
  60. #endif
  62. /* globals */
  64. TLB_ENTRY_DESC sysStaticTlbDesc [] =
  65. {
  66.     /*
  67.      * effAddr,  Unused,  realAddr, ts | size | attributes | permissions
  68.      *
  69.      * TLB #0.  Flash
  70.      *
  71.      * needed be first entry here
  72.      */
  74.     { FLASH0_BASE_ADRS, 0x0, FLASH0_BASE_ADRS, _MMU_TLB_TS_0 | _MMU_TLB_SZ_256M |
  75.         _MMU_TLB_IPROT | _MMU_TLB_PERM_W | _MMU_TLB_PERM_X | _MMU_TLB_ATTR_I |
  76.         _MMU_TLB_ATTR_G
  77.     },
  79.     /*
  80.      * LOCAL MEMORY needed be second entry here  -
  81.      * one TLB would be 256MB so use to get required 512MB
  82.      */
  84.     { 0x00000000, 0x0, 0x00000000, _MMU_TLB_TS_0 | _MMU_TLB_SZ_256M |
  85.         _MMU_TLB_PERM_W | _MMU_TLB_PERM_X | _MMU_TLB_ATTR_M |
  86.         CAM_DRAM_CACHE_MODE | _MMU_TLB_IPROT
  87.     },
  88. #if (LOCAL_MEM_SIZE > 0x10000000)
  89.     { 0x10000000, 0x0, 0x10000000, _MMU_TLB_TS_0 | _MMU_TLB_SZ_256M |
  90.         _MMU_TLB_PERM_W | _MMU_TLB_PERM_X | _MMU_TLB_ATTR_M |
  91.         CAM_DRAM_CACHE_MODE | _MMU_TLB_IPROT
  92.     },
  93. #endif
  95.     { CCSBAR, 0x0, CCSBAR, _MMU_TLB_TS_0 | _MMU_TLB_SZ_1M |
  96.         _MMU_TLB_ATTR_I | _MMU_TLB_ATTR_G | _MMU_TLB_PERM_W | _MMU_TLB_IPROT
  97.     }
  99. #ifdef INCLUDE_L2_SRAM
  100.     ,
  101.     { L2SRAM_ADDR, 0x0, L2SRAM_ADDR, _MMU_TLB_TS_0 | _MMU_TLB_SZ_256K |
  102.         _MMU_TLB_PERM_W | _MMU_TLB_PERM_X | _MMU_TLB_ATTR_I |
  103.         _MMU_TLB_ATTR_G
  104.     }
  106. #endif /* INCLUDE_L2_SRAM */
  108.     /* Assume PCI space contiguous and within 256MB */
  110. #ifdef INCLUDE_PCI
  111.     ,
  112.     { PCI_MEM_ADRS, 0x0, PCI_MEM_ADRS, _MMU_TLB_TS_0 | PCI_MMU_TLB_SZ |
  113.         _MMU_TLB_ATTR_I | _MMU_TLB_ATTR_G | _MMU_TLB_PERM_W
  114.     }
  115. #ifdef INCLUDE_CDS85XX_PCIEX
  116.     ,
  117.     { PCI_MEM_ADRS3, 0x0, PCI_MEM_ADRS3, _MMU_TLB_TS_0 |  PCI_MMU_TLB_SZ |
  118.         _MMU_TLB_ATTR_I | _MMU_TLB_ATTR_G | _MMU_TLB_PERM_W
  119.     }
  120. #endif /* INCLUDE_CDS85XX_PCIEX */
  122. #endif  /* INCLUDE_PCI */
  124. };
  126. int sysStaticTlbDescNumEnt = NELEMENTS (sysStaticTlbDesc);
  128. #ifdef MMU_ASID_MAX     /* Base 6 MMU library in effect */
  130.   /* macro to compose 64-bit PHYS_ADDRs */
  132. # define PHYS_64BIT_ADDR(h, l)  (((PHYS_ADDR)(h) << 32) + (l))
  133. #endif
  135. /*
  136. * sysPhysMemDesc[] is used to initialize the Page Table Entry (PTE) array
  137. * used by the MMU to translate addresses with single page (4k) granularity.
  138. * PTE memory space should not, in general, overlap BAT memory space but
  139. * may be allowed if only Data or Instruction access is mapped via BAT.
  140. *
  141. * Address translations for local RAM, memory mapped PCI bus, the Board Control and
  142. * Status registers, the MPC8260 Internal Memory Map, and local FLASH RAM are set here.
  143. *
  144. * PTEs are held, strangely enough, in a Page Table.  Page Table sizes are
  145. * integer powers of two based on amount of memory to be mapped and a
  146. * minimum size of 64 kbytes.  The MINIMUM recommended Page Table sizes
  147. * for 32-bit PowerPCs are:
  148. *
  149. * Total mapped memory Page Table size
  150. * ------------------- ---------------
  151. *        8 Meg      64 K
  152. *       16 Meg     128 K
  153. *       32 Meg     256 K
  154. *       64 Meg     512 K
  155. *      128 Meg       1 Meg
  156. *  . .
  157. *  . .
  158. *  . .
  159. *
  160. * [Ref: chapter 7, PowerPC Microprocessor Family: The Programming Environments]
  161. *
  162. */
  163. PHYS_MEM_DESC sysPhysMemDesc [] =
  164. {
  166.     {
  167.         /*
  168.  * Vector Table and Interrupt Stack
  169.          * Must be sysPhysMemDesc [0] to allow adjustment in sysHwInit()
  170.  */
  172.         (VIRT_ADDR) LOCAL_MEM_LOCAL_ADRS,
  173.         (PHYS_ADDR) LOCAL_MEM_LOCAL_ADRS,
  174.         LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE,
  175.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | VM_STATE_MASK_MEM_COHERENCY,
  176.         VM_STATE_VALID      | VM_STATE_WRITABLE      | TLB_CACHE_MODE | VM_STATE_MEM_COHERENCY
  177.     }
  178.     ,
  179.     {
  180.         /*
  181.          * CCSBAR
  182.         */
  183.         (VIRT_ADDR) CCSBAR,
  184.         (PHYS_ADDR) CCSBAR,
  185.         0x00100000,
  186.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE |
  187.         VM_STATE_MASK_MEM_COHERENCY | VM_STATE_MASK_GUARDED,
  188.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT |
  189.         VM_STATE_MEM_COHERENCY | VM_STATE_GUARDED
  190.     }
  192. #ifdef INCLUDE_L2_SRAM
  193.     ,
  194.     {
  195.         (VIRT_ADDR) L2SRAM_ADDR,
  196.         (PHYS_ADDR) L2SRAM_ADDR,
  197.         L2SRAM_WINDOW_SIZE,
  198.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE,
  199.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT
  200.     }
  201. #endif
  203. #ifdef INCLUDE_PCI
  204.     ,
  205.     {
  206.         (VIRT_ADDR) PCI_MEM_ADRS,
  207.         (PHYS_ADDR) PCI_MEM_ADRS,
  208.         PCI_MEM_SIZE,
  209.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  210.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  211.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  212.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  213.     }
  214.     ,
  215.     {
  216.         (VIRT_ADDR) PCI_MEMIO_ADRS,
  217.         (PHYS_ADDR) PCI_MEMIO_ADRS,
  218.         PCI_MEMIO_SIZE,
  219.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  220.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  221.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  222.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  223.     }
  224.     ,
  225.     {
  226.         (VIRT_ADDR) PCI_IO_ADRS,
  227.         (PHYS_ADDR) PCI_IO_ADRS,
  228.         PCI_IO_SIZE,
  229.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  230.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  231.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  232.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  233.     }
  237. #ifdef INCLUDE_CDS85XX_PCIEX
  238.     ,
  239.     {
  240.         (VIRT_ADDR) PCI_MEM_ADRS3,
  241.         (PHYS_ADDR) PCI_MEM_ADRS3,
  242.         PCI_MEM_SIZE,
  243.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  244.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  245.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  246.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  247.     }
  248.     ,
  249.     {
  250.         (VIRT_ADDR) PCI_MEMIO_ADRS3,
  251.         (PHYS_ADDR) PCI_MEMIO_ADRS3,
  252.         PCI_MEMIO_SIZE,
  253.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  254.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  255.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  256.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  257.     }
  258.     ,
  259.     {
  260.         (VIRT_ADDR) PCI_IO_ADRS3,
  261.         (PHYS_ADDR) PCI_IO_ADRS3,
  262.         PCI_IO_SIZE,
  263.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  264.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  265.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  266.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  267.     }
  268. #endif /* INCLUDE_CDS85XX_PCIEX */
  269. #endif /* INCLUDE_PCI */
  271.     ,
  272.     { 
  273.         (VIRT_ADDR) ALPHA_LED_BASE_ADRS,
  274.         (PHYS_ADDR) ALPHA_LED_BASE_ADRS,
  275.         ALPHA_LED_SIZE,
  276.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  277.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  278.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  279.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  280.     }
  281.     ,
  282.     {
  283.         (VIRT_ADDR) FLASH0_BASE_ADRS,
  284.         (PHYS_ADDR) FLASH0_BASE_ADRS,
  285.         FLASH0_SIZE,
  286.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  287.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  288.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  289.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  290.     }
  291.     ,
  292.     {
  293.         (VIRT_ADDR) FLASH1_BASE_ADRS,
  294.         (PHYS_ADDR) FLASH1_BASE_ADRS,
  295.         FLASH1_SIZE,
  296.         VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | 
  297.         VM_STATE_MASK_GUARDED | VM_STATE_MASK_MEM_COHERENCY,
  298.         VM_STATE_VALID      | VM_STATE_WRITABLE      | VM_STATE_CACHEABLE_NOT | 
  299.         VM_STATE_GUARDED      | VM_STATE_MEM_COHERENCY
  300.     }
  303. };
  305. int sysPhysMemDescNumEnt = NELEMENTS (sysPhysMemDesc);
  307. /* Clock Ratio Tables */
  309. #define MAX_VALUE_PLAT_RATIO 32
  310. UINT32 platRatioTable[MAX_VALUE_PLAT_RATIO][2] =
  311. {
  312.     { 0, 0},
  313.     { 0, 0},
  314.     { 2, 0},
  315.     { 3, 0},
  316.     { 4, 0},
  317.     { 5, 0},
  318.     { 6, 0},
  319.     { 7, 0},
  320.     { 8, 0},
  321.     { 9, 0},
  322.     { 10, 0},
  323.     { 0, 0},
  324.     { 12, 0},
  325.     { 0, 0},
  326.     { 0, 0},
  327.     { 0, 0},
  328.     { 16, 0},
  329.     { 0, 0},
  330.     { 0, 0},
  331.     { 0, 0},
  332.     { 20, 0},
  333.     { 0, 0}
  334. };
  336. #define MAX_VALUE_E500_RATIO 10
  337. UINT32 e500RatioTable[MAX_VALUE_PLAT_RATIO][2] =
  338. {
  339.     { 0, 0},
  340.     { 0, 0},
  341.     { 1, 0},
  342.     { 3, 1},
  343.     { 2, 0},
  344.     { 5, 1},
  345.     { 3, 0},
  346.     { 7, 1},
  347.     { 4, 0},
  348.     { 9, 1}
  349. };
  351. int      pci_autoconfig_done = FALSE;
  352. UINT32   sysPciMode;
  353. UINT32   sysPciSlotDeviceNumber;
  354. int   sysBus      = BUS_TYPE_NONE;      /* system bus type (VME_BUS, etc) */
  355. int   sysCpu      = CPU;                /* system CPU type (PPC8260) */
  356. char *sysBootLine = BOOT_LINE_ADRS; /* address of boot line */
  357. char *sysExcMsg   = EXC_MSG_ADRS;   /* catastrophic message area */
  358. int   sysProcNum;           /* processor number of this CPU */
  359. BOOL  sysVmeEnable = FALSE;     /* by default no VME */
  360. UINT32  coreFreq;
  362. IMPORT void     mmuE500TlbDynamicInvalidate();
  363. IMPORT void     mmuE500TlbStaticInvalidate();
  364. IMPORT void mmuE500TlbStaticInit (int numDescs,
  365.                                   TLB_ENTRY_DESC *pTlbDesc,
  366.                                   BOOL cacheAllow);
  367. IMPORT BOOL     mmuPpcIEnabled;
  368. IMPORT BOOL     mmuPpcDEnabled;
  369. IMPORT void     sysIvprSet(UINT32);
  371. /* forward declarations */
  373. void   sysUsDelay (UINT32);
  374. void   sysLedClkRoutine (int arg);
  376. #ifdef INCLUDE_L1_IPARITY_HDLR_INBSP
  377.     #define _EXC_OFF_L1_PARITY 0x1500
  378. IMPORT void jumpIParity();
  379. IMPORT void sysIvor1Set(UINT32);
  380. UINT32 instrParityCount = 0;
  381. #endif  /* INCLUDE_L1_IPARITY_HDLR_INBSP */
  384. #ifdef INCLUDE_PCI
  386. STATUS sysPciSpecialCycle (int busNo, UINT32 message);
  387. STATUS sysPciConfigRead   (int busNo, int deviceNo, int funcNo,
  388.                            int offset, int width, void * pData);
  389. STATUS sysPciConfigWrite  (int busNo, int deviceNo, int funcNo,
  390.                            int offset, int width, ULONG data);
  392. void   sysPciConfigEnable (int);
  394. #endif /* INCLUDE_PCI */
  396. /* 8260 Reset Configuration Table (From page 9-2 in Rev0 of 8260 book) */
  398. #define END_OF_TABLE 0
  400. UINT32 sysClkFreqGet(void);
  401. UINT32 ppcE500ICACHE_LINE_NUM = (128 * 12);
  402. UINT32 ppcE500DCACHE_LINE_NUM = (128 * 12);
  404. UINT32 ppcE500CACHE_ALIGN_SIZE = 32;
  406. #ifdef INCLUDE_PCI
  407. LOCAL ULONG sysPciConfAddr = PCI_CFG_ADR_REG;   /* PCI Configuration Address */
  408. LOCAL ULONG sysPciConfData = PCI_CFG_DATA_REG;  /* PCI Configuration Data */
  410. #ifdef INCLUDE_GEI8254X_END
  411. LOCAL int   sysPci1SysNum  = CDS85XX_PCI_1_BUS;
  413. #ifdef  INCLUDE_CDS85XX_PCIEX
  414. LOCAL int   sysPci3SysNum  = CDS85XX_PCIEX_BUS;
  415. #endif /* INCLUDE_CDS85XX_PCIEX */
  416. #endif /* INCLUDE_GEI8254X_END */
  418. #include <pci/pciIntLib.c>           /* PCI int support */
  419. #include <pci/pciConfigLib.c>        /* pci configuration library */
  420. #if (defined(INCLUDE_PCI_CFGSHOW) && !defined(PRJ_BUILD))
  421. #include <pci/pciConfigShow.c>
  422. #endif /* (defined(INCLUDE_PCI_CFGSHOW) && !defined(PRJ_BUILD)) */
  423. /* use pci auto config */
  424. #include <pci/pciAutoConfigLib.c>    /* automatic PCI configuration */
  425. #include <sysBusPci.c>               /* pciAutoConfig BSP support file */
  426. #include <mot85xxPci.c>
  429. #ifdef INCLUDE_GEI8254X_END
  430. #include <sysGei8254xEnd.c>
  431. #endif  /* INCLUDE_GEI_END */
  433. #endif /* INCLUDE_PCI */
  435. #include <m85xxTimer.c>
  436. #include <sysMotI2c.c>
  437. #include <sysMpc85xxI2c.c>
  439. #ifdef INCLUDE_NV_RAM
  440.     #include "i2c24LC128Eeprom.c"
  441.     #include <mem/byteNvRam.c>      /* Generic NVRAM routines */
  442. #else
  443.     #include <mem/nullNvRam.c>
  444. #endif /* INCLUDE_NV_RAM */
  446. #ifdef INCLUDE_L1_IPARITY_HDLR
  447.     #include <sysL1ICacheParity.c>
  448. #endif
  450. UINT32 inFullVxWorksImage=FALSE;
  452. #define EXT_VEC_IRQ0            56
  453. #define EXT_NUM_IRQ0            EXT_VEC_IRQ0
  454. #define EXT_MAX_IRQS            200
  456. STATUS  sysIntEnablePIC     (int intNum);   /* Enable i8259 or EPIC */
  457. STATUS  sysCascadeIntEnable      (int intNum);
  458. STATUS  sysCascadeIntDisable     (int intNum);
  459. void    flashTest(VUINT16 *address,VUINT16 *buffer,VINT32 length);
  461. UINT32   baudRateGenClk;
  463. #include <sysEpic.c>
  466. #ifdef INCLUDE_DUART
  467.     #include <sysDuart.c>
  468. #endif
  470. #include <sysL2Cache.c>
  472. #include <cmdLine.c>
  474. #ifdef INCLUDE_VXBUS
  475. IMPORT void hardWareInterFaceInit();
  476. #endif /* INCLUDE_VXBUS */
  478. #define WB_MAX_IRQS 256
  480. #ifdef INCLUDE_SYSLED
  481. #  include <sysLed.c>
  482. #endif /* INCLUDE_SYSLED */
  484. /* defines */
  486. #define ZERO    0
  488. /* needed to enable timer base */
  490. #ifdef INCLUDE_PCI
  491.     #define      M8260_DPPC_MASK 0x0C000000 /* bits 4 and 5 */
  492.     #define      M8260_DPPC_VALUE 0x0C000000 /* bits (4,5) should be (1,0) */
  493. #else
  494.     #define      M8260_DPPC_MASK 0x0C000000 /* bits 4 and 5 */
  495.     #define      M8260_DPPC_VALUE 0x08000000 /* bits (4,5) should be (1,0) */
  496. #endif /*INCLUDE_PCI */
  498. #define DELTA(a,b)                 (abs((int)a - (int)b))
  499. #define HID0_MCP 0x80000000
  500. #define HID1_ABE 0x00001000
  501. #define HID1_ASTME 0x00002000
  502. #define HID1_RXFE  0x00020000
  505. #ifdef INCLUDE_VXBUS
  506. #include <hwif/vxbus/vxBus.h>
  507. #include <../src/hwif/h/busCtlr/m85xxRio.h>
  508. #endif
  510. #ifdef INCLUDE_MOT_TSEC_END
  511. #include <sysNet.c>
  512. #ifndef INCLUDE_VXBUS
  513. #include <sysMotTsecEnd.c>
  514. #endif /* INCLUDE_VXBUS */
  515. #endif /* INCLUDE_MOT_TSEC_END */
  517. #ifdef INCLUDE_VXBUS
  518. #include <hwconf.c>
  519. #endif
  521. #ifdef INCLUDE_BRANCH_PREDICTION
  522. IMPORT void disableBranchPrediction();
  523. #endif
  525. #ifdef INCLUDE_L2_SRAM
  526. LOCAL void sysL2SramEnable(BOOL both);
  527. #endif /* INCLUDE_L2_SRAM */
  529. #ifdef INCLUDE_SPE
  530.     #include <speLib.h>
  531. IMPORT int       (* _func_speProbeRtn) () ;
  532. #endif /* INCLUDE_SPE */
  534. #ifdef INCLUDE_CACHE_SUPPORT
  535. LOCAL void sysL1CacheQuery();
  536. #endif
  538. UINT32 sysTimerClkFreq = OSCILLATOR_FREQ;
  540. IMPORT  void    sysL1Csr1Set(UINT32);
  541. IMPORT  UINT    sysTimeBaseLGet(void);
  543. LOCAL char * physTop = NULL;
  544. LOCAL char * memTop = NULL;
  547. #if     defined (INCLUDE_SPE)
  549. /*******************************************************************************
  550. *
  551. * sysSpeProbe - Check if the CPU has SPE unit.
  552. *
  553. * This routine returns OK it the CPU has an SPE unit in it.
  554. * Presently it assumes available.
  555. *
  556. * RETURNS: OK
  557. *
  558. * ERRNO: N/A
  559. */
  561. int  sysSpeProbe (void)
  562.     {
  563.     ULONG regVal;
  564.     int speUnitPresent = OK;
  566.     /* The CPU type is indicated in the Processor Version Register (PVR) */
  568.     regVal = 0;
  570.     switch (regVal)
  571.         {
  572.         case 0:
  573.         default:
  574.             speUnitPresent = OK;
  575.             break;
  576.         }      /* switch  */
  578.     return(speUnitPresent);
  579.     }
  580. #endif  /* INCLUDE_SPE */
  583. /****************************************************************************
  584. *
  585. * sysModel - return the model name of the CPU board
  586. *
  587. * This routine returns the model name of the CPU board.
  588. *
  589. * RETURNS: A pointer to the string.
  590. *
  591. * ERRNO: N/A
  592. */
  594. char * sysModel (void)
  595.     {
  596.     UINT device;
  597.     char* retChar = NULL;
  598.     device = *M85XX_SVR(CCSBAR);
  600.     switch(device & 0xffffff00)
  601. {
  602. case 0x80390000:
  603.     retChar = SYS_MODEL_8548E;
  604.     break;
  605. case 0x80310000:
  606.     retChar = SYS_MODEL_8548;
  607.     break;
  608. case 0x80390100:
  609.     retChar = SYS_MODEL_8547E;
  610.     break;
  611. case 0x80390200:
  612.     retChar = SYS_MODEL_8545E;
  613.     break;
  614. case 0x80310200:
  615.     retChar = SYS_MODEL_8545;
  616.     break;
  617. case 0x803A0000:
  618.     retChar = SYS_MODEL_8543E;
  619.     break;
  620. case 0x80320000:
  621.     retChar = SYS_MODEL_8543;
  622.     break;
  623. default:
  624.     retChar = SYS_MODEL_E500;
  625.     break;
  626. }
  629.     device = *M85XX_PVR(CCSBAR);
  631.     if ((device & 0xfff00000) != 0x80200000)
  632.         retChar =SYS_MODEL_UNKNOWN;
  634.     return(retChar);
  636.     }
  638. /******************************************************************************
  639. *
  640. * sysBspRev - return the BSP version with the revision eg 1.0/<x>
  641. *
  642. * This function returns a pointer to a BSP version with the revision.
  643. * for eg. 1.0/<x>. BSP_REV defined in config.h is concatenated to
  644. * BSP_VERSION and returned.
  645. *
  646. * RETURNS: A pointer to the BSP version/revision string.
  647. *
  648. * ERRNO: N/A
  649. */
  651. char * sysBspRev (void)
  652.     {
  653.     return(BSP_VERSION BSP_REV);
  654.     }
  656. /******************************************************************************
  657. *
  658. * sysClkFreqGet - return Core Complex Bus clock freq
  659. *
  660. * This function returns the CCB clock freq.
  661. *
  662. * RETURNS: CCB clock freq
  663. *
  664. * ERRNO: N/A
  665. */
  667. UINT32 sysClkFreqGet
  668. (
  669. void
  670. )
  671.     {
  672.     UINT32  sysClkFreq;
  673.     UINT32 e500Ratio,platRatio;
  675.     platRatio = M85XX_PORPLLSR_PLAT_RATIO(CCSBAR);
  677. #ifdef FORCE_DEFAULT_FREQ
  678.     return(DEFAULT_SYSCLKFREQ);
  679. #endif
  681.     if ((platRatio>MAX_VALUE_PLAT_RATIO)||(platRatioTable[platRatio][0]==0))
  682.         return(DEFAULT_SYSCLKFREQ); /* A default value better than zero or -1 */
  684.     sysClkFreq = ((UINT32)(OSCILLATOR_FREQ * platRatioTable[platRatio][0]))>>((UINT32)platRatioTable[platRatio][1]);
  686.     e500Ratio = M85XX_PORPLLSR_E500_RATIO(CCSBAR);
  687.     coreFreq = ((UINT32)(sysClkFreq * e500RatioTable[e500Ratio][0]))>>((UINT32)e500RatioTable[e500Ratio][1]);
  690.     return(sysClkFreq);
  691.     }
  693. /******************************************************************************
  694. *
  695. * sysCpmFreqGet - Determines the CPM Operating Frequency
  696. *
  697. * This routine determines the CPM Operating Frequency.
  698. *
  699. * From page 9-2 Rev. 0  MPC8260  PowerQUICC II User's Manual
  700. *
  701. * RETURNS: CPM clock frequency for the current MOD_CK and MOD_CK_H settings
  702. *
  703. * ERRNO: N/A
  704. */
  706. UINT32 sysCpmFreqGet (void)
  707.     {
  708.     UINT32 sysClkFreq = sysClkFreqGet();
  709.     return(sysClkFreq);
  711.     }
  713. /******************************************************************************
  714. *
  715. * sysBaudClkFreq - Obtains frequency of the BRG_CLK in Hz
  716. *
  717. * From page 9-5 in Rev. 0 MPC8260 PowerQUICC II User's Manual
  718. *
  719. *     baud clock = 2*cpm_freq/2^2*(DFBRG+1) where DFBRG = 01
  720. *                = 2*cpm_freq/16
  721. *
  722. * RETURNS: frequency of the BRG_CLK in Hz
  723. *
  724. * ERRNO: N/A
  725. */
  727. UINT32 sysBaudClkFreq (void)
  728.     {
  729.     UINT32 cpmFreq = sysCpmFreqGet();
  731.     return cpmFreq*2/16;
  732.     }
  734. /******************************************************************************
  735. *
  736. * sysHwMemInit - initialize and configure system memory.
  737. *
  738. * This routine is called before sysHwInit(). It performs memory auto-sizing
  739. * and updates the system's physical regions table, `sysPhysRgnTbl'. It may
  740. * include the code to do runtime configuration of extra memory controllers.
  741. *
  742. * NOTE: This routine should not be called directly by the user application.  It
  743. * cannot be used to initialize interrupt vectors.
  744. *
  745. * RETURNS: N/A
  746. *
  747. * ERRNO: N/A
  748. */
  750. void sysHwMemInit (void)
  751.     {
  753.     /* Call sysPhysMemTop() to do memory autosizing if available */
  755.     sysPhysMemTop ();
  757.     }
  759. /******************************************************************************
  760. *
  761. * sysHwInit - initialize the system hardware
  762. *
  763. * This routine initializes various feature of the MPC8260 ADS board. It sets up
  764. * the control registers, initializes various devices if they are present.
  765. *
  766. * NOTE: This routine should not be called directly by the user.
  767. *
  768. * RETURNS: NA
  769. *
  770. * ERRNO: N/A
  771. */
  773. void sysHwInit (void)
  774.     {
  777. #ifdef INCLUDE_RAPIDIO_BUS
  779.     /* Errata not yet described - required for rapidIO TAS */
  781.     *(UINT32*)(CCSBAR + 0x1010) = 0x01040004;
  782. #endif
  784.     sysIvprSet(0x0);
  786.     /* Disable L1 Icache */
  788.     sysL1Csr1Set(vxL1CSR1Get() & ~0x1);
  790.     /* Check for architecture support for 36 bit physical addressing */
  792. #if defined(PPC_e500v2)
  793.     vxHid0Set(_PPC_HID0_MAS7EN|vxHid0Get());
  794. #endif
  796.     /* Enable machine check pin */
  798.     vxHid0Set(HID0_MCP|vxHid0Get());
  800. #ifdef E500_L1_PARITY_RECOVERY
  802.     /* Enable Parity in L1 caches */
  804.     vxL1CSR0Set(vxL1CSR0Get() | _PPC_L1CSR_CPE);
  805.     vxL1CSR1Set(vxL1CSR1Get() | _PPC_L1CSR_CPE);
  806. #endif  /* E500_L1_PARITY_RECOVERY */
  808.     /* enable time base for delay use before DEC interrupt is setup */
  810.     vxHid0Set(vxHid0Get() | _PPC_HID0_TBEN);
  812.     sysTimerClkFreq = sysClkFreqGet()>>3 /* Clock div is 8 */;
  814. #ifdef INCLUDE_AUX_CLK
  815.     sysAuxClkRateSet(127);
  816. #endif
  818. #ifdef INCLUDE_CACHE_SUPPORT
  819.     sysL1CacheQuery();
  820. #endif /* INCLUDE_CACHE_SUPPORT */
  822.     /* Initialise L2CTL register */
  824.     vxL2CTLSet(0x28000000,M85XX_L2CTL(CCSBAR));
  826.     /*
  827.      * Need to setup static TLB entries for bootrom or any non-MMU
  828.      * enabled images
  829.      */
  830.     mmuE500TlbDynamicInvalidate();
  831.     mmuE500TlbStaticInvalidate();
  832.     mmuE500TlbStaticInit(sysStaticTlbDescNumEnt, &sysStaticTlbDesc[0], TRUE);
  834. #if (!defined(INCLUDE_MMU_BASIC) && !defined(INCLUDE_MMU_FULL))
  835.     mmuPpcIEnabled=TRUE;
  836.     mmuPpcDEnabled=TRUE;
  837. #else /* !defined(INCLUDE_MMU_BASIC) && !defined(INCLUDE_MMU_FULL) */
  838.     if (inFullVxWorksImage==FALSE)
  839.         {
  840.         mmuPpcIEnabled=TRUE;
  841.         mmuPpcDEnabled=TRUE;
  842.         }
  843.     /* Enable I Cache if instruction mmu disabled */
  845. #if (defined(USER_I_CACHE_ENABLE) && !defined(USER_I_MMU_ENABLE))
  846.     mmuPpcIEnabled=TRUE;
  847. #endif /* (defined(USER_I_CACHE_ENABLE) && !defined(USER_I_MMU_ENABLE)) */
  849. #endif /* !defined(INCLUDE_MMU_BASIC) && !defined(INCLUDE_MMU_FULL) */
  852. #if (defined(INCLUDE_L2_CACHE) && defined(INCLUDE_CACHE_SUPPORT))
  853.     vxHid1Set(HID1_ABE); /* Address Broadcast enable */
  854.     sysL2CacheInit();
  855. #endif /* INCLUDE_L2_CACHE  && INCLUDE_CACHE_SUPPORT*/
  857.     /* Machine check via RXFE for RIO */
  859.     vxHid1Set(vxHid1Get()| HID1_ASTME | HID1_RXFE); /* Address Stream Enable */
  861.     /* enable the flash window */
  863.     *M85XX_LAWBAR3(CCSBAR) = FLASH1_BASE_ADRS >> LAWBAR_ADRS_SHIFT;
  864.     *M85XX_LAWAR3(CCSBAR)  = LAWAR_ENABLE | LAWAR_TGTIF_LBC | LAWAR_SIZE_64MB;
  865.     WRS_ASM("isync");
  867.     /* Initialize the Embedded Programmable Interrupt Controller */
  869.     sysEpicInit();
  872. #ifdef INCLUDE_VXBUS
  873.     hardWareInterFaceInit();
  874. #endif /* INCLUDE_VXBUS */
  877. #ifdef INCLUDE_DUART
  878.     sysDuartHwInit ();
  879. #endif
  882. #ifdef INCLUDE_PCI
  884.     /*
  885.      * PCI slot device number is decoded differently between PCI mode and
  886.      * PCI-X mode. So we read the PORDEVSR register to determine which mode
  887.      * the system is in and assign the proper device number access the slot.
  888.      */
  889.     sysPciMode = M85XX_PORDEVSR_PCI_MODE(CCSBAR);
  890.     if (sysPciMode == PORDEVSR_PCIX_MODE)
  891.        {
  892.           sysPciSlotDeviceNumber = 0x1; /* PCI-X */
  893.        }
  894.    else
  895.        {
  896.        sysPciSlotDeviceNumber = 0x11; /* PCI */
  897.        }
  898. /* config pci */
  900.     if (pciConfigLibInit (PCI_MECHANISM_0,(ULONG) sysPciConfigRead,
  901.                           (ULONG) sysPciConfigWrite,(ULONG) sysPciSpecialCycle) != OK)
  902.         {
  903.         sysToMonitor (BOOT_NO_AUTOBOOT);  /* BAIL */
  904.         }
  906.     /*  Initialize PCI interrupt library. */
  908.     if ((pciIntLibInit ()) != OK)
  909.         {
  910.         sysToMonitor (BOOT_NO_AUTOBOOT);
  911.         }
  912. #if 0
  913.     if ( *((char*)PCI_AUTO_CONFIG_ADRS) == FALSE )
  914. #endif
  915.         {
  916.         mot85xxBridgeInit();
  917. #ifdef INCLUDE_PCI_AUTOCONF
  918.         sysPciAutoConfig();
  920.         pci_autoconfig_done = TRUE;
  921. #endif
  922.         *((char*)PCI_AUTO_CONFIG_ADRS) = TRUE;
  923.         }
  925. #endif /* INCLUDE_PCI */
  928. #ifdef E500_L1_PARITY_RECOVERY
  929.     vxIvor1Set(_EXC_OFF_L1_PARITY);
  930. #endif  /* E500_L1_PARITY_RECOVERY */
  931. #ifdef INCLUDE_L1_IPARITY_HDLR
  932.     installL1ICacheParityErrorRecovery();
  933. #endif /* INCLUDE_L1_IPARITY_HDLR */
  935.     /*
  936.      * The power management mode is initialized here. Reduced power mode
  937.      * is activated only when the kernel is idle (cf vxPowerDown).
  938.      * Power management mode is selected via vxPowerModeSet().
  939.      * DEFAULT_POWER_MGT_MODE is defined in config.h.
  940.      */
  942. #if defined(INCLUDE_L2_SRAM)
  943. #if (defined(INCLUDE_L2_CACHE) && defined(INCLUDE_CACHE_SUPPORT))
  944.     sysL2SramEnable(TRUE);
  945. #elif (defined(INCLUDE_L2_SRAM))
  946.     sysL2SramEnable(FALSE);
  947. #endif
  948. #endif
  950.     CACHE_PIPE_FLUSH();
  952.     vxPowerModeSet (DEFAULT_POWER_MGT_MODE);
  954.     }
  956. #ifdef INCLUDE_L2_SRAM
  957. /*************************************************************************
  958. *
  959. * sysL2SramEnable - enables L2SRAM if L2SRAM only
  960. *
  961. * This routine enables L2SRAM if L2SRAM only or initializes blk
  962. * size etc and leaves the rest to L2 cache code.
  963. *
  964. * RETURNS: N/A
  965. *
  966. * ERRNO: N/A
  967. */
  968. LOCAL void sysL2SramEnable
  969. (
  970. BOOL both
  971. )
  972.     {
  973.     volatile int l2CtlVal;
  975.     /*
  976.      * if INCLUDE_L2_CACHE and CACHE_SUPPORT
  977.      * if ((L2_SRAM_SIZE + L2_CACHE_SIZE) > l2Siz)
  978.      */
  980.     /* Setup Windows for L2SRAM */
  982.     *(M85XX_L2SRBAR0(CCSBAR)) = (UINT32)(L2SRAM_ADDR & M85XX_L2SRBAR_ADDR_MSK);
  984.     /* Get present value */
  986.     l2CtlVal = vxL2CTLGet(M85XX_L2CTL(CCSBAR));
  988.     /* Disable L2CTL initially to allow changing of block size */
  990.     l2CtlVal &=(~M85XX_L2CTL_L2E_MSK);
  991.     vxL2CTLSet(l2CtlVal,M85XX_L2CTL(CCSBAR));
  992.     l2CtlVal &= ~M85XX_L2CTL_L2BLKSIZ_MSK;
  993.     l2CtlVal &= ~M85XX_L2CTL_L2SRAM_MSK;
  995.     if (both == TRUE)
  996.         {
  997.         /* Setup size of SRAM */
  999.         l2CtlVal |= (L2SIZ_256KB << M85XX_L2CTL_L2BLKSIZ_BIT) |
  1000.                     (0x2 << M85XX_L2CTL_L2SRAM_BIT);
  1001.         }
  1002.     else
  1003.         {
  1004.         l2CtlVal |= (L2SIZ_512KB << M85XX_L2CTL_L2BLKSIZ_BIT) |
  1005.                     (0x1 << M85XX_L2CTL_L2SRAM_BIT);
  1006.         }
  1008.     /* Setup L2CTL for SRAM */
  1010.     vxL2CTLSet(l2CtlVal,M85XX_L2CTL(CCSBAR));
  1012.     if (both == FALSE)
  1013.         {
  1014.         /* This is done here so L2SRAM is set before enable */
  1016.         l2CtlVal |= M85XX_L2CTL_L2E_MSK; /* No cache so go ahead and enable */
  1018.         /* Enable L2CTL for SRAM */
  1020.         vxL2CTLSet(l2CtlVal,M85XX_L2CTL(CCSBAR));
  1021.         }
  1023.     }
  1024. #endif /* INCLUDE_L2_SRAM */
  1026. /**************************************************************************
  1027. *
  1028. * sysPhysMemTop - get the address of the top of physical memory
  1029. *
  1030. * This routine returns the address of the first missing byte of memory,
  1031. * which indicates the top of memory.
  1032. *
  1033. * RETURNS: The address of the top of physical memory.
  1034. *
  1035. * ERRNO: N/A
  1036. *
  1037. * SEE ALSO: sysMemTop()
  1038. */
  1040. char * sysPhysMemTop (void)
  1041.     {
  1043.     if (physTop == NULL)
  1044.         {
  1045.         physTop = (char *)(LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE);
  1046.         }
  1048.     return(physTop) ;
  1049.     }
  1051. /***************************************************************************
  1052. *
  1053. * sysMemTop - get the address of the top of VxWorks memory
  1054. *
  1055. * This routine returns a pointer to the first byte of memory not
  1056. * controlled or used by VxWorks.
  1057. *
  1058. * The user can reserve memory space by defining the macro USER_RESERVED_MEM
  1059. * in config.h.  This routine returns the address of the reserved memory
  1060. * area.  The value of USER_RESERVED_MEM is in bytes.
  1061. *
  1062. * RETURNS: The address of the top of VxWorks memory.
  1063. *
  1064. * ERRNO: N/A
  1065. */
  1067. char * sysMemTop (void)
  1068.     {
  1070.     if (memTop == NULL)
  1071.         {
  1072.         memTop = sysPhysMemTop () - USER_RESERVED_MEM;
  1074. #ifdef INCLUDE_EDR_PM
  1076.         /* account for ED&R persistent memory */
  1078.         memTop = memTop - PM_RESERVED_MEM;
  1079. #endif
  1081.         }
  1083.     return memTop;
  1084.     }
  1086. /**************************************************************************
  1087. *
  1088. * sysToMonitor - transfer control to the ROM monitor
  1089. *
  1090. * This routine transfers control to the ROM monitor.  Normally, it is called
  1091. * only by reboot()--which services ^X--and bus errors at interrupt level.
  1092. * However, in some circumstances, the user may wish to introduce a
  1093. * <startType> to enable special boot ROM facilities.
  1094. *
  1095. * RETURNS: Does not return.
  1096. *
  1097. * ERRNO: N/A
  1098. */
  1099. int sysToMonitorExcMessage = 0;
  1100. int sysToMonitorBacktrace = 1;
  1101. int sysToMonitorReboot = 1;
  1102. void (*sysToMonitorHook)(void);
  1104. STATUS sysToMonitor
  1105.     (
  1106.     int startType   /* parameter passed to ROM to tell it how to boot */
  1107.     )
  1108.     {
  1109. #if 0
  1110.     FUNCPTR pRom = (FUNCPTR) (ROM_TEXT_ADRS + 4);   /* Warm reboot */
  1111. #endif
  1113.     if (sysToMonitorHook)
  1114.         (*sysToMonitorHook)();
  1116.     sysReboot();
  1118. #if 0
  1119.     intLock();
  1122. #ifdef INCLUDE_BRANCH_PREDICTION
  1123.     disableBranchPrediction();
  1124. #endif /* INCLUDE_BRANCH_PREDICTION */
  1126. #ifdef INCLUDE_CACHE_SUPPORT
  1127.     cacheDisable(INSTRUCTION_CACHE);
  1128.     cacheDisable(DATA_CACHE);
  1129. #endif
  1130.     sysClkDisable();
  1133. #ifdef INCLUDE_AUX_CLK
  1134.     sysAuxClkDisable();
  1135. #endif
  1137.     vxMsrSet(0);
  1139.     /* Clear unnecessary TLBs */
  1141.     mmuE500TlbDynamicInvalidate();
  1142.     mmuE500TlbStaticInvalidate();
  1144.     (*pRom) (startType);    /* jump to bootrom entry point */
  1145. #endif
  1146.     return(OK);    /* in case we ever continue from ROM monitor */
  1147.     }
  1149. /******************************************************************************
  1150. *
  1151. * sysHwInit2 - additional system configuration and initialization
  1152. *
  1153. * This routine connects system interrupts and does any additional
  1154. * configuration necessary.
  1155. *
  1156. * RETURNS: N/A
  1157. *
  1158. * ERRNO: N/A
  1159. */
  1161. void sysHwInit2 (void)
  1162.     {
  1164. #ifdef  INCLUDE_VXBUS
  1165.     vxbDevInit();
  1166. #endif /* INCLUDE_VXBUS */
  1169.     excIntConnect ((VOIDFUNCPTR *) _EXC_OFF_DECR,
  1170.                    (VOIDFUNCPTR) sysClkInt);
  1172.     sysClkRateSet(60);
  1173.     sysClkEnable();
  1175. #ifdef INCLUDE_AUX_CLK
  1176.     excIntConnect ((VOIDFUNCPTR *) _EXC_OFF_FIT, (VOIDFUNCPTR) sysAuxClkInt);
  1177. #endif
  1179. #  if defined(INCLUDE_AUX_CLK)
  1181.      /* initialize and start auxiliary clock support */
  1183.      sysAuxClkEnable ();
  1185. #  endif /* INCLUDE_AUX_CLK */
  1188.     /*
  1189.      * This was previously reqd for errata workaround #29, the workaround
  1190.      * has been replaced with patch for spr99776, so it now serves as an
  1191.      * example of implementing an l1 instruction parity handler
  1192.      */
  1194. #ifdef INCLUDE_L1_IPARITY_HDLR_INBSP
  1195.     memcpy((void*)_EXC_OFF_L1_PARITY, (void *)jumpIParity, sizeof(INSTR));
  1196.     cacheTextUpdate((void *)_EXC_OFF_L1_PARITY, sizeof(INSTR));
  1197.     sysIvor1Set(_EXC_OFF_L1_PARITY);
  1198.     cacheDisable(INSTRUCTION_CACHE);
  1199.     vxL1CSR1Set(vxL1CSR1Get() | _PPC_L1CSR_CPE);
  1200.     cacheEnable(INSTRUCTION_CACHE);
  1201. #endif  /* INCLUDE_L1_IPARITY_HDLR_INBSP */
  1203.     /* initialize the EPIC interrupts */
  1205.     sysEpicIntrInit ();
  1207.     /* initialize serial interrupts */
  1209. #if defined(INCLUDE_DUART)
  1210.     sysSerialHwInit2 ();
  1211. #endif /* INCLUDE_DUART */
  1213. #if     defined (INCLUDE_SPE)
  1214.     _func_speProbeRtn = sysSpeProbe;
  1215. #endif  /* INCLUDE_SPE */
  1218. #ifdef INCLUDE_PCI
  1220. #ifdef INCLUDE_GEI8254X_END
  1221.     sysPciConfigEnable (CDS85XX_PCI_1_BUS);
  1222.     pciConfigForeachFunc (0, FALSE, (PCI_FOREACH_FUNC) sys8254xDeviceCheck, (void *)&sysPci1SysNum);
  1223. #ifdef INCLUDE_CDS85XX_PCIEX
  1224. #ifdef INCLUDE_GEI8254X_END
  1225.     sysPciConfigEnable (CDS85XX_PCIEX_BUS);
  1226.     pciConfigForeachFunc (PCIEX_BUS_MIN + 1, FALSE, (PCI_FOREACH_FUNC) sys8254xDeviceCheck, (void *)&sysPci3SysNum);
  1227. #endif /* INCLUDE_GEI8254X_END */
  1229. #endif /* INCLUDE_CDS85XX_PCIEX */
  1230. #endif /* INCLUDE_GEI8254X_END */
  1231. #endif /* INCLUDE_PCI */
  1233.     /* Configure GPIO */
  1234.     * (VINT32 *) M85XX_GPOUTDR(CCSBAR) = 0x3;
  1235.     * (VINT32 *) M85XX_GPIOCR(CCSBAR) = (1 << 17) | ( 1 << 16) | (1 << 9);
  1237. #ifdef INCLUDE_SYSLED
  1238.     sysLedOn();
  1239. #endif 
  1241. #ifdef INCLUDE_I2C_DEV
  1242.     i2cDrvInit(0, MPC85XX_I2C_CONTROLLER);
  1243.     i2cDrvInit(1, MPC85XX_I2C_CONTROLLER);
  1244.     usrTimeSync();
  1245. #endif /* INCLUDE_I2C_DEV */
  1247. #ifdef  INCLUDE_VXBUS
  1248.     taskSpawn("devConnect",0,0,10000,vxbDevConnect,0,0,0,0,0,0,0,0,0,0);
  1249. #endif /* INCLUDE_VXBUS */
  1251.     }
  1253. /******************************************************************************
  1254. *
  1255. * sysProcNumGet - get the processor number
  1256. *
  1257. * This routine returns the processor number for the CPU board, which is
  1258. * set with sysProcNumSet().
  1259. *
  1260. * RETURNS: The processor number for the CPU board.
  1261. *
  1262. * ERRNO: N/A
  1263. *
  1264. * SEE ALSO: sysProcNumSet()
  1265. */
  1267. int sysProcNumGet (void)
  1268.     {
  1269.     return(sysProcNum);
  1270.     }
  1272. /******************************************************************************
  1273. *
  1274. * sysProcNumSet - set the processor number
  1275. *
  1276. * This routine sets the processor number for the CPU board.  Processor numbers
  1277. * should be unique on a single backplane.
  1278. *
  1279. * Not applicable for the bus-less 8260Ads.
  1280. *
  1281. * RETURNS: N/A
  1282. *
  1283. * ERRNO: N/A
  1284. *
  1285. * SEE ALSO: sysProcNumGet()
  1286. */
  1288. void sysProcNumSet
  1289.     (
  1290.     int     procNum         /* processor number */
  1291.     )
  1292.     {
  1293.     sysProcNum = procNum;
  1294.     }
  1296. /******************************************************************************
  1297. *
  1298. * sysLocalToBusAdrs - convert a local address to a bus address
  1299. *
  1300. * This routine gets the VMEbus address that accesses a specified local
  1301. * memory address.
  1302. *
  1303. * Not applicable for the 8260Ads
  1304. *
  1305. * RETURNS: ERROR, always.
  1306. *
  1307. * ERRNO: N/A
  1308. *
  1309. * SEE ALSO: sysBusToLocalAdrs()
  1310. */
  1312. STATUS sysLocalToBusAdrs
  1313.     (
  1314.     int     adrsSpace,  /* bus address space where busAdrs resides */
  1315.     char *  localAdrs,  /* local address to convert */
  1316.     char ** pBusAdrs    /* where to return bus address */
  1317.     )
  1318.     {
  1320.     *pBusAdrs = localAdrs;
  1322.     return(OK);
  1323.     }
  1325. /******************************************************************************
  1326. *
  1327. * sysBusToLocalAdrs - convert a bus address to a local address
  1328. *
  1329. * This routine gets the local address that accesses a specified VMEbus
  1330. * physical memory address.
  1331. *
  1332. * Not applicable for the 8260Ads
  1333. *
  1334. * RETURNS: ERROR, always.
  1335. *
  1336. * ERRNO: N/A
  1337. *
  1338. * SEE ALSO: sysLocalToBusAdrs()
  1339. */
  1341. STATUS sysBusToLocalAdrs
  1342.     (
  1343.     int     adrsSpace,  /* bus address space where busAdrs resides */
  1344.     char *  busAdrs,    /* bus address to convert */
  1345.     char ** pLocalAdrs  /* where to return local address */
  1346.     )
  1347.     {
  1349.     *pLocalAdrs = busAdrs;
  1351.     return(OK);
  1352.     }
  1356. #ifdef INCLUDE_PCI  /* board level PCI routines */
  1358. /*******************************************************************************
  1359. * sysPciConfigEnable -  enable PCI 1 or PCI 2 bus configuration
  1360. *
  1361. * This function enables PCI 1 or PCI 2 bus configuration
  1362. *
  1363. * RETURNS: N/A
  1364. *
  1365. * ERRNO: N/A
  1366. */
  1368. void sysPciConfigEnable
  1369.     (
  1370.     int pciHost
  1371.     )
  1372.     {
  1373.     int level;
  1375.     level = intLock ();
  1377.     if (pciHost == CDS85XX_PCI_2_BUS)
  1378.         {
  1379.         sysPciConfAddr = PCI2_CFG_ADR_REG;   /* PCI Configuration Address */
  1380.         sysPciConfData = PCI2_CFG_DATA_REG;  /* PCI Configuration Data */
  1381.         }
  1382.     else if (pciHost == CDS85XX_PCIEX_BUS)
  1383.         {
  1384.         sysPciConfAddr = PCIEX_CFG_ADR_REG;   /* PCI Configuration Address */
  1385.         sysPciConfData = PCIEX_CFG_DATA_REG;  /* PCI Configuration Data */
  1386.         }
  1387.     else /* default is for PCI 1 host */
  1388.         {
  1389.         sysPciConfAddr = PCI_CFG_ADR_REG;   /* PCI Configuration Address */
  1390.         sysPciConfData = PCI_CFG_DATA_REG;  /* PCI Configuration Data */
  1391.         }
  1393.     WRS_ASM("sync;eieio");
  1395.     intUnlock (level);
  1396.     }
  1398. /*******************************************************************************
  1399. *
  1400. * sysPciSpecialCycle - generate a special cycle with a message
  1401. *
  1402. * This routine generates a special cycle with a message.
  1403. *
  1404. * NOMANUAL
  1405. *
  1406. * RETURNS: OK
  1407. *
  1408. * ERRNO: N/A
  1409. */
  1411. STATUS sysPciSpecialCycle
  1412.     (
  1413.     int     busNo,
  1414.     UINT32  message
  1415.     )
  1416.     {
  1417.     int deviceNo    = 0x0000001f;
  1418.     int funcNo      = 0x00000007;
  1420.     if (pci_autoconfig_done) {
  1421.         if (busNo >= PCIEX_BUS_MIN) {
  1422.             busNo = busNo - PCIEX_BUS_MIN;
  1423.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1424.         } else {
  1425.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1426.         }
  1427.     }
  1428.  
  1429.     pciRegWrite ((UINT32 *)sysPciConfAddr,
  1430.                  (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1431.                  0x80000000);
  1433.     PCI_OUT_LONG (sysPciConfData, message);
  1435.     return(OK);
  1436.     }
  1438. /*******************************************************************************
  1439. *
  1440. * sysPciConfigRead - read from the PCI configuration space
  1441. *
  1442. * This routine reads either a byte, word or a long word specified by
  1443. * the argument <width>, from the PCI configuration space
  1444. * This routine works around a problem in the hardware which hangs
  1445. * PCI bus if device no 12 is accessed from the PCI configuration space.
  1446. *
  1447. * NOMANUAL
  1448. *
  1449. * RETURNS: OK, or ERROR if this library is not initialized
  1450. *
  1451. * ERRNO: N/A
  1452. */
  1454. STATUS sysPciConfigRead
  1455.     (
  1456.     int busNo,    /* bus number */
  1457.     int deviceNo, /* device number */
  1458.     int funcNo,   /* function number */
  1459.     int offset,   /* offset into the configuration space */
  1460.     int width,    /* width to be read */
  1461.     void * pData /* data read from the offset */
  1462.     )
  1463.     {
  1464.     UINT8  retValByte = 0;
  1465.     UINT16 retValWord = 0;
  1466.     UINT32 retValLong = 0;
  1467.     STATUS retStat = ERROR;
  1469.     /* Set Default values of data */
  1470.     switch(width) {
  1471.         case 1:
  1472.             *((UINT8 *)pData) = 0xff;
  1473.             break;
  1474.         case 2:
  1475.             *((UINT16 *)pData) = 0xffff; 
  1476.             break;
  1477.         case 4:
  1478.             *((UINT32 *)pData) = 0xffffffff;
  1479.             break;
  1480.         default:
  1481.             return ERROR;
  1482.     }
  1483.  
  1484. #if defined(BCM_DEVICE_ON_PCIE) /* Skip device on PCI BUS */
  1485.     if  (0x1e == deviceNo) {
  1486.         return OK;
  1487.     }
  1488. #else
  1489. #endif
  1490.     if (pci_autoconfig_done) {
  1491.         if (busNo >= PCIEX_BUS_MIN) {
  1492.             if ((busNo > (PCIEX_BUS_MIN + 1)) || (deviceNo > 0))  {
  1493.                 return OK;
  1494.             }
  1495.             busNo = busNo - PCIEX_BUS_MIN;
  1496.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1497.         } else {
  1498.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1499.         }
  1500.     }
  1501.     
  1502.     /* This is for PCI Express */
  1503.     if ((sysPciConfAddr == PCIEX_CFG_ADR_REG) && (busNo > 0))
  1504.     {
  1505.          /* Read LTSSM state status register to make sure that the Link is ready */
  1506.          pciRegWrite ((UINT32 *)sysPciConfAddr,
  1507.                          (UINT32)pciConfigBdfPack (0, 0, 0) |
  1508.                          (0x404 & 0xfc) | 0x80000000 | ((0x404 & 0xf00) << 16));
  1509.           retValLong = PCI_IN_LONG (sysPciConfData);
  1510.           if (retValLong != 0x16) {
  1511.               /* Link training is not completed. Cannot read PCIE config 
  1512.                * space. */
  1513.               return OK;
  1514.           }
  1515.     }
  1517.     switch (width)
  1518.         {
  1519.         case 1: /* byte */
  1520.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1521.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1522.                          (offset & 0xffc) | 0x80000000 | ((offset & 0xf00) << 16)) ;
  1524.             retValByte = PCI_IN_BYTE (sysPciConfData + (offset & 0x3));
  1525.             *((UINT8 *)pData) = retValByte;
  1526.             retStat = OK;
  1527.             break;
  1529.         case 2: /* word */
  1530.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1531.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1532.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1534.             retValWord = PCI_IN_WORD (sysPciConfData + (offset & 0x2));
  1535.             *((UINT16 *)pData) = retValWord;
  1536.             retStat = OK;
  1537.             break;
  1539.         case 4: /* long */
  1540.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1541.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1542.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1543.             retValLong = PCI_IN_LONG (sysPciConfData);
  1544.             *((UINT32 *)pData) = retValLong;
  1545.             retStat = OK;
  1546.             break;
  1548.         default:
  1549.             retStat = ERROR;
  1550.             break;
  1551.         }
  1553.     return(retStat);
  1554.     }
  1556. /*******************************************************************************
  1557. *
  1558. * sysPciConfigWrite - write to the PCI configuration space
  1559. *
  1560. * This routine writes either a byte, word or a long word specified by
  1561. * the argument <width>, to the PCI configuration space
  1562. * This routine works around a problem in the hardware which hangs
  1563. * PCI bus if device no 12 is accessed from the PCI configuration space.
  1564. * Errata PCI-Express requires RMW to ensure always write 4byte aligned.
  1565. *
  1566. * NOMANUAL
  1567. *
  1568. * RETURNS: OK, or ERROR if this library is not initialized
  1569. *
  1570. * ERRNO: N/A
  1571. */
  1573. STATUS sysPciConfigWrite
  1574.     (
  1575.     int busNo,    /* bus number */
  1576.     int deviceNo, /* device number */
  1577.     int funcNo,   /* function number */
  1578.     int offset,   /* offset into the configuration space */
  1579.     int width,    /* width to write */
  1580.     ULONG data    /* data to write */
  1581.     )
  1582.     {
  1584.  /*
  1585.   * PCI-Express errata RMW workaround should work for all PCI
  1586.   * Requires always to do 4 byte read/write
  1587.   */
  1589.     ULONG data2,mask;
  1590.  
  1591.    /* Establish the required mask based on width and offset */
  1593.     switch(width)
  1594. {
  1595. case 1:
  1596.     mask=0xff;
  1597.     mask=~(mask << ((offset&0x3)*8));
  1598.     break;
  1599. case 2:
  1600.     mask=0xffff;
  1601.     mask=~(mask << ((offset&0x3)*8));
  1602.     break;
  1603. case 4:
  1604.     mask=0;
  1605.     break;
  1606. default:
  1607.     return(ERROR);
  1608. }
  1610.     if (pci_autoconfig_done) {
  1611.         if (busNo >= PCIEX_BUS_MIN) {
  1612.             /* busNo = busNo - PCIEX_BUS_MIN;*/
  1613.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1614.         } else {
  1615.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1616.         }
  1617.     }
  1619.     sysPciConfigRead(busNo,deviceNo,funcNo,(offset & ~0x3), 4, &data2);
  1621.     if (pci_autoconfig_done) {
  1622.         if (busNo >= PCIEX_BUS_MIN) {
  1623.             busNo = busNo - PCIEX_BUS_MIN;
  1624.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1625.         } else {
  1626.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1627.         }
  1628.     }
  1630.     data2 &= mask;
  1632.     data2 |= data << ((offset&0x3)*8); /* Overwite only part of word reqd */
  1634.     data = data2;             /* final 32 bit value to write */
  1635.     width = 4;                /* always do 32 bit write */
  1636.     offset = (offset & ~0x3); /* align by 32 bits */
  1638. #if 0
  1639.     if ((busNo == 0) && (deviceNo == 0x1f))
  1640.         return(ERROR);
  1641. #endif
  1643.     switch (width)
  1644.         {
  1645.         case 1: /* byte */
  1646.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1647.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1648.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1649.             PCI_OUT_BYTE ((sysPciConfData + (offset & 0x3)), data);
  1650.             break;
  1652.         case 2: /* word */
  1653.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1654.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1655.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1656.             PCI_OUT_WORD ((sysPciConfData + (offset & 0x2)), data);
  1657.             break;
  1659.         case 4: /* long */
  1660.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1661.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1662.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1663.             PCI_OUT_LONG (sysPciConfData, data);
  1664.             break;
  1666.         default:
  1667.             return(ERROR);
  1669.         }
  1670.     return(OK);
  1671.     }
  1672. #endif /* INCLUDE_PCI */
  1674. /******************************************************************************
  1675. *
  1676. * sysUsDelay - delay at least the specified amount of time (in microseconds)
  1677. *
  1678. * This routine will delay for at least the specified amount of time using the
  1679. * lower 32 bit "word" of the Time Base register as the timer.
  1680. *
  1681. * NOTE:  This routine will not relinquish the CPU; it is meant to perform a
  1682. * busy loop delay.  The minimum delay that this routine will provide is
  1683. * approximately 10 microseconds.  The maximum delay is approximately the
  1684. * size of UINT32; however, there is no roll-over compensation for the total
  1685. * delay time, so it is necessary to back off two times the system tick rate
  1686. * from the maximum.
  1687. *
  1688. * RETURNS: N/A
  1689. *
  1690. * ERRNO: N/A
  1691. */
  1693. void sysUsDelay
  1694.     (
  1695.     UINT32    delay        /* length of time in microsec to delay */
  1696.     )
  1697.     {
  1698.     register UINT baselineTickCount;
  1699.     register UINT curTickCount;
  1700.     register UINT terminalTickCount;
  1701.     register int actualRollover = 0;
  1702.     register int calcRollover = 0;
  1703.     UINT ticksToWait;
  1704.     UINT requestedDelay;
  1705.     UINT oneUsDelay;
  1707.     /* Exit if no delay count */
  1709.     if ((requestedDelay = delay) == 0)
  1710.         return;
  1712.     /*
  1713.      * Get the Time Base Lower register tick count, this will be used
  1714.      * as the baseline.
  1715.      */
  1717.     baselineTickCount = sysTimeBaseLGet();
  1719.     /*
  1720.      * Calculate number of ticks equal to 1 microsecond
  1721.      *
  1722.      * The Time Base register and the Decrementer count at the same rate:
  1723.      * once per 8 System Bus cycles.
  1724.      *
  1725.      * e.g., 199999999 cycles     1 tick      1 second            25 ticks
  1726.      *       ----------------  *  ------   *  --------         ~  --------
  1727.      *       second               8 cycles    1000000 microsec    microsec
  1728.      */
  1730.     /* add to round up before div to provide "at least" */
  1732.     oneUsDelay = ((sysTimerClkFreq + 1000000) / 1000000);
  1734.     /* Convert delay time into ticks */
  1736.     ticksToWait = requestedDelay * oneUsDelay;
  1738.     /* Compute when to stop */
  1740.     terminalTickCount = baselineTickCount + ticksToWait;
  1742.     /* Check for expected rollover */
  1744.     if (terminalTickCount < baselineTickCount)
  1745.         {
  1746.         calcRollover = 1;
  1747.         }
  1749.     do
  1750.         {
  1752.         /*
  1753.          * Get current Time Base Lower register count.
  1754.          * The Time Base counts UP from 0 to
  1755.          * all F's.
  1756.          */
  1758.         curTickCount = sysTimeBaseLGet();
  1760.         /* Check for actual rollover */
  1762.         if (curTickCount < baselineTickCount)
  1763.             {
  1764.             actualRollover = 1;
  1765.             }
  1767.         if (((curTickCount >= terminalTickCount)
  1768.              && (actualRollover == calcRollover)) ||
  1769.             ((curTickCount < terminalTickCount)
  1770.              && (actualRollover > calcRollover)))
  1771.             {
  1773.             /* Delay time met */
  1775.             break;
  1776.             }
  1777.         }
  1778.     while (TRUE); /* breaks above when delay time is met */
  1779.     }
  1782. void sysMsDelay
  1783.     (
  1784.     UINT      delay                   /* length of time in MS to delay */
  1785.     )
  1786.     {
  1787.     sysUsDelay ( (UINT32) delay * 1000 );
  1788.     }
  1791. /*********************************************************************
  1792. *
  1793. * sysDelay - Fixed 1ms delay.
  1794. *
  1795. * This routine consumes 1ms of time. It just calls sysMsDelay.
  1796. *
  1797. * RETURNS: N/A
  1798. *
  1799. * ERRNO: N/A
  1800. */
  1802. void sysDelay (void)
  1803.     {
  1804.     sysMsDelay (1);
  1805.     }
  1807. /***************************************************************************
  1808. *
  1809. * sysIntConnect - connect the BSP interrupt to the proper epic/i8259 handler.
  1810. *
  1811. * This routine checks the INT level and connects the proper routine.
  1812. * pciIntConnect() or intConnect().
  1813. *
  1814. * RETURNS:
  1815. * OK, or ERROR if the interrupt handler cannot be built.
  1816. *
  1817. * ERRNO: N/A
  1818. */
  1820. STATUS sysIntConnect
  1821.     (
  1822.     VOIDFUNCPTR *vector,        /* interrupt vector to attach to     */
  1823.     VOIDFUNCPTR routine,        /* routine to be called              */
  1824.     int parameter               /* parameter to be passed to routine */
  1825.     )
  1826.     {
  1827.     int tmpStat = ERROR;
  1828.     UINT32 read;
  1830.     if (((int) vector < 0) || ((int) vector >= EXT_VEC_IRQ0 + EXT_MAX_IRQS))
  1831.         {
  1832.         logMsg ("Error in sysIntConnect: out of range vector = %d.n",
  1833.                 (int)vector,2,3,4,5,6);
  1835.         return(ERROR);
  1836.         }
  1838.     if (vxMemProbe ((char *) routine, VX_READ, 4, (char *) &read) != OK)
  1839.         {
  1840.         logMsg ("Error in sysIntConnect: Cannot access routine.n",
  1841.                 1,2,3,4,5,6);
  1842.         return(ERROR);
  1843.         }
  1845.     if ((int) vector < EXT_VEC_IRQ0)
  1846.         {
  1847.         tmpStat = intConnect (vector, routine, parameter);
  1848.         }
  1849.     else
  1850.         {
  1852.         /* 
  1853.  * call external int controller connect
  1854.          tmpStat = cascadeIntConnect (vector, routine, parameter);
  1855.  */
  1856.         }
  1858.     if (tmpStat == ERROR)
  1859.         {
  1860.         logMsg ("Error in sysIntConnect: Connecting vector = %d.n",
  1861.                 (int)vector,2,3,4,5,6);
  1862.         }
  1864.     return(tmpStat);
  1865.     }
  1868. /*******************************************************************************
  1869. *
  1870. * sysIntEnable - enable an interrupt
  1871. *
  1872. * This function call is used to enable an interrupt.
  1873. *
  1874. * RETURNS: OK or ERROR if unable to enable interrupt.
  1875. *
  1876. * ERRNO: N/A
  1877. */
  1879. STATUS sysIntEnable
  1880.     (
  1881.     int intNum
  1882.     )
  1883.     {
  1884.     int tmpStat = ERROR;
  1885.     if (((int) intNum < 0) || ((int) intNum >= EXT_NUM_IRQ0 + EXT_MAX_IRQS))
  1886.         {
  1887.         logMsg ("Error in sysIntEnable: Out of range intNum = %d.n",
  1888.                 (int)intNum,2,3,4,5,6);
  1890.         return(ERROR);
  1891.         }
  1893.     if ((int) intNum < EXT_NUM_IRQ0)
  1894.         {
  1895.         tmpStat = intEnable (intNum);
  1896.         }
  1897.     else
  1898.         {
  1899.         /* call external int controller connect */
  1901.         tmpStat = sysCascadeIntEnable (intNum - EXT_NUM_IRQ0);
  1902.         }
  1904.     if (tmpStat == ERROR)
  1905.         {
  1906.         logMsg ("Error in sysIntEnable: intNum = %d.n",
  1907.                 (int)intNum,2,3,4,5,6);
  1908.         }
  1910.     return(tmpStat);
  1911.     }
  1913. /****************************************************************************
  1914. *
  1915. * sysCascadeIntEnable - enable an external controller interrupt
  1916. *
  1917. * This function call is used to enable an interrupt outside of the MPC8540 PIC.
  1918. *
  1919. * RETURNS: OK or ERROR if unable to enable interrupt.
  1920. *
  1921. * ERRNO: N/A
  1922. */
  1924. STATUS sysCascadeIntEnable
  1925.     (
  1926.     int intNum
  1927.     )
  1928.     {
  1929.     return(ERROR);
  1930.     }
  1932. /****************************************************************************
  1933. *
  1934. * sysIntDisable - disable an interrupt
  1935. *
  1936. * This function call is used to disable an interrupt.
  1937. *
  1938. * RETURNS: OK or ERROR if unable to disable interrupt.
  1939. *
  1940. * ERRNO: N/A
  1941. */
  1943. STATUS sysIntDisable
  1944.     (
  1945.     int intNum
  1946.     )
  1947.     {
  1948.     int tmpStat = ERROR;
  1949.     if (((int) intNum < 0) || ((int) intNum >= EXT_NUM_IRQ0 + EXT_MAX_IRQS))
  1950.         {
  1951.         logMsg ("Error in sysIntDisable: Out of range intNum = %d.n",
  1952.                 (int)intNum,2,3,4,5,6);
  1954.         return(ERROR);
  1955.         }
  1957.     if ((int) intNum < EXT_NUM_IRQ0)
  1958.         {
  1959.         tmpStat = intDisable (intNum);
  1960.         }
  1961.     else
  1962.         {
  1963.         /* call external int controller connect */
  1965.         tmpStat = sysCascadeIntDisable (intNum - EXT_NUM_IRQ0);
  1966.         }
  1969.     if (tmpStat == ERROR)
  1970.         {
  1971.         logMsg ("Error in sysIntDisable: intNum = %d.n",
  1972.                 (int)intNum,2,3,4,5,6);
  1973.         }
  1975.     return(tmpStat);
  1976.     }
  1978. /**************************************************************************
  1979. *
  1980. * sysCascadeIntDisable - disable an external controller interrupt
  1981. *
  1982. * This function call is used to disable an interrupt outside of the MPC8540 PIC.
  1983. *
  1984. * RETURNS: OK or ERROR if unable to disable interrupt.
  1985. *
  1986. * ERRNO: N/A
  1987. */
  1989. STATUS sysCascadeIntDisable
  1990.     (
  1991.     int intNum
  1992.     )
  1993.     {
  1994.     return(ERROR);
  1995.     }
  1997. #ifdef INCLUDE_CACHE_SUPPORT
  1998. /***********************************************************************
  1999. *
  2000. * sysL1CacheQuery - configure L1 cache size and alignment
  2001. *
  2002. * Populates L1 cache size and alignment from configuration registers.
  2003. *
  2004. * RETURNS: N/A
  2005. *
  2006. * ERRNO: N/A
  2007. */
  2009. LOCAL void sysL1CacheQuery(void)
  2010.     {
  2011.     UINT32 temp;
  2012.     UINT32 align;
  2013.     UINT32 cachesize;
  2015.     temp = vxL1CFG0Get();
  2017.     cachesize = (temp & 0xFF) << 10;
  2019.     align = (temp >> 23) & 0x3;
  2022.     switch (align)
  2023.         {
  2024.         case 0:
  2025.             ppcE500CACHE_ALIGN_SIZE=32;
  2026.             break;
  2027.         case 1:
  2028.             ppcE500CACHE_ALIGN_SIZE=64;
  2029.             break;
  2030.         default:
  2031.             ppcE500CACHE_ALIGN_SIZE=32;
  2032.             break;
  2033.         }
  2035.     ppcE500DCACHE_LINE_NUM = (cachesize / ppcE500CACHE_ALIGN_SIZE);
  2036.     ppcE500ICACHE_LINE_NUM = (cachesize / ppcE500CACHE_ALIGN_SIZE);
  2038.     /*
  2039.      * The core manual suggests for a 32 byte cache line and 8 lines per set
  2040.      * we actually need 12 unique address loads to flush the set.
  2041.      * The number of lines to flush should be ( 3/2 * cache lines )
  2042.      */
  2044.     ppcE500DCACHE_LINE_NUM = (3*ppcE500DCACHE_LINE_NUM)>>1;
  2045.     ppcE500ICACHE_LINE_NUM = (3*ppcE500ICACHE_LINE_NUM)>>1;
  2047.     }
  2049. #endif /* INCLUDE_CACHE_SUPPORT */
  2051. /***************************************************************************
  2052. *
  2053. * saveExcMsg - write exception message to save area for catastrophic error
  2054. *
  2055. * The message will be displayed upon rebooting with a bootrom.
  2056. *
  2057. * RETURNS: N/A
  2058. *
  2059. * ERRNO: N/A
  2060. */
  2062. void saveExcMsg
  2063.     (
  2064.     char *errorMsg
  2065.     )
  2066.     {
  2067.     strcpy ((char *)EXC_MSG_OFFSET, errorMsg);
  2068.     }
  2071. void chipErrataCpu29Print(void)
  2072.     {
  2073.     saveExcMsg("Silicon fault detected, possible machine state corruption.nSystem rebooted to limit damage.");
  2074.     }
  2078. /***************************************************************************
  2079. *
  2080. * vxImmrGet - get the CPM DPRAM base address
  2081. *
  2082. * This routine returns the CPM DP Ram base address for CPM device drivers.
  2083. *
  2084. * RETURNS:
  2085. *
  2086. * ERRNO: N/A
  2087. */
  2089. UINT32 vxImmrGet(void)
  2090.     {
  2091.     return(CCSBAR + 0x80000);
  2092.     }
  2094. /***************************************************************************
  2095. *
  2096. * sysGetPeripheralBase   - Provides CCSRBAR address fro security engine
  2097. *                          drivers.
  2098. *
  2099. * RETURNS:
  2100. *
  2101. * ERRNO: N/A
  2102. */
  2103. UINT32 sysGetPeripheralBase()
  2104.     {
  2105.     return(CCSBAR);
  2106.     }
  2108. #if defined (_GNU_TOOL)
  2109. void sysIntHandler (void)
  2110.     {
  2111.     }
  2113. void vxDecInt (void)
  2114.     {
  2115.     }
  2117. int excRtnTbl = 0;
  2118. #endif  /* _GNU_TOOL */
  2120. #ifdef INCLUDE_SHOW_ROUTINES
  2122. /***************************************************************************
  2123. *
  2124. * coreLbcShow - Show routine for local bus controller
  2125. *
  2126. * This routine shows the local bus controller registers.
  2127. *
  2128. * RETURNS: N/A
  2129. *
  2130. * ERRNO: N/A
  2131. */
  2133. void coreLbcShow(void)
  2134.     {
  2135.     VINT32 tmp, tmp2;
  2137.     tmp = * (VINT32 *) M85XX_BR0(CCSBAR);
  2138.     tmp2 = * (VINT32 *) M85XX_OR0(CCSBAR);
  2139.     printf("Local bus BR0 = 0x%xtOR0 = 0x%xn", tmp, tmp2);
  2141.     tmp = * (VINT32 *) M85XX_BR1(CCSBAR);
  2142.     tmp2 = * (VINT32 *) M85XX_OR1(CCSBAR);
  2143.     printf("Local bus BR1 = 0x%xtOR1 = 0x%xn", tmp, tmp2);
  2145.     tmp = * (VINT32 *) M85XX_BR2(CCSBAR);
  2146.     tmp2 = * (VINT32 *) M85XX_OR2(CCSBAR);
  2147.     printf("Local bus BR2 = 0x%xtOR2 = 0x%xn", tmp, tmp2);
  2149.     tmp = * (VINT32 *) M85XX_BR3(CCSBAR);
  2150.     tmp2 = * (VINT32 *) M85XX_OR3(CCSBAR);
  2151.     printf("Local bus BR3 = 0x%xtOR3 = 0x%xn", tmp, tmp2);
  2153.     tmp = * (VINT32 *) M85XX_BR4(CCSBAR);
  2154.     tmp2 = * (VINT32 *) M85XX_OR4(CCSBAR);
  2155.     printf("Local bus BR4 = 0x%xtOR4 = 0x%xn", tmp, tmp2);
  2157.     tmp = * (VINT32 *) M85XX_BR5(CCSBAR);
  2158.     tmp2 = * (VINT32 *) M85XX_OR5(CCSBAR);
  2159.     printf("Local bus BR5 = 0x%xtOR5 = 0x%xn", tmp, tmp2);
  2161.     tmp = * (VINT32 *) M85XX_BR6(CCSBAR);
  2162.     tmp2 = * (VINT32 *) M85XX_OR6(CCSBAR);
  2163.     printf("Local bus BR6 = 0x%xtOR6 = 0x%xn", tmp, tmp2);
  2165.     tmp = * (VINT32 *) M85XX_BR7(CCSBAR);
  2166.     tmp2 = * (VINT32 *) M85XX_OR7(CCSBAR);
  2167.     printf("Local bus BR7 = 0x%xtOR7 = 0x%xn", tmp, tmp2);
  2169.     tmp = * (VINT32 *) M85XX_LBCR(CCSBAR);
  2170.     printf("Local bus LBCR = 0x%xn", tmp);
  2172.     tmp = * (VINT32 *) M85XX_LCRR(CCSBAR);
  2173.     printf("Local bus LCRR = 0x%xn", tmp);
  2174.     }
  2176.     #define xbit0(x, n)    ((x & (1 << (31 - n))) >> (31 - n))  /* 0..31 */
  2177.     #define xbit32(x, n)   ((x & (1 << (63 - n))) >> (63 - n))  /* 32..63 */
  2178.     #define onoff0(x, n)   xbit0(x, n) ? "ON", "OFF"
  2179.     #define onoff32(x, n)  xbit32(x, n) ? "ON", "OFF"
  2181. /***************************************************************************
  2182. *
  2183. * coreShow - Show routine for core registers
  2184. *
  2185. * This routine shows the core registers.
  2186. *
  2187. * RETURNS: N/A
  2188. *
  2189. * ERRNO: N/A
  2190. */
  2192. void coreShow(void)
  2193.     {
  2194.     VUINT32 tmp, tmp2;
  2196.     tmp = vxMsrGet();
  2197.     printf("MSR - 0x%xn", tmp);
  2198.     printf("      UCLE-%x SPE-%x WE-%x CE-%x EE-%x PR-%x ME-%xn",
  2199.            xbit32(tmp,37), xbit32(tmp,38), xbit32(tmp,45), xbit32(tmp,46),
  2200.            xbit32(tmp,48), xbit32(tmp,49), xbit32(tmp,51));
  2201.     printf("      UBLE-%x DE-%x IS-%x DS-%x PMM-%xn",
  2202.            xbit32(tmp,53), xbit32(tmp,54), xbit32(tmp,58), xbit32(tmp,59),
  2203.            xbit32(tmp,61));
  2204.     tmp = vxHid0Get();
  2205.     tmp2 = vxHid1Get();
  2206.     printf("HID0 = 0x%x, HID1 = 0x%xn", tmp, tmp2);
  2207.     tmp = vxL1CSR0Get();
  2208.     printf("L1CSR0: cache is %s - 0x%xn", tmp&1?"ON":"OFF", tmp);
  2209.     tmp = vxL1CSR1Get();
  2210.     printf("L1CSR1: Icache is %s - 0x%xn", tmp&1?"ON":"OFF", tmp);
  2211.     tmp = vxL1CFG0Get();
  2212.     tmp2 = vxL1CFG1Get();
  2213.     printf("L1CFG0 = 0x%x, L1CFG1 = 0x%xn", tmp, tmp2);
  2214.     tmp = *(VUINT32 *) (CCSBAR + 0x20000);
  2215.     printf("L2CTL - 0x%xn", tmp);
  2216.     printf("        l2 is %sn", tmp&0x80000000?"ON":"OFF");
  2217.     printf("        l2siz-%x l2blksz-%x l2do-%x l2io-%xn",
  2218.            (xbit0(tmp,2)<<1)|xbit0(tmp,3), (xbit0(tmp,4)<<1)|xbit0(tmp,5),
  2219.            xbit0(tmp,9), xbit0(tmp,10));
  2220.     printf("        l2pmextdis-%x l2intdis-%x l2sram-%xn",
  2221.            xbit0(tmp,11), xbit0(tmp,12),
  2222.            (xbit0(tmp,13)<<2)|(xbit0(tmp,14)<<1)|xbit0(tmp,15));
  2223.     tmp = *(VUINT32 *) (CCSBAR + 0x20100);
  2224.     tmp2 = *(VUINT32 *) (CCSBAR + 0x20108);
  2225.     printf("L2SRBAR0 - 0x%xn", tmp);
  2226.     printf("L2SRBAR1 - 0x%xn", tmp2);
  2228.     printf("Core Freq = %3d Hzn",coreFreq);
  2229.     printf("CCB Freq = %3d Hzn",sysClkFreqGet());
  2230.     printf("PCI Freq = %3d Hzn",OSCILLATOR_FREQ);
  2231.     printf("CPM Freq = %3d Hzn",sysClkFreqGet());
  2233.     }
  2235. #endif
  2237. int sysVectorIRQ0 = 0;
  2238. void
  2239. sysReboot(void)
  2240. {
  2241.     int level;
  2243.      level = intLock();
  2244.      * (VINT32 *) M85XX_GPOUTDR(CCSBAR) = ~0x0;
  2245.      * (VINT32 *) M85XX_GPIOCR(CCSBAR) = 0x200;
  2246.      * (VINT32 *) M85XX_GPOUTDR(CCSBAR) &= ~(BCM98548XMC_SYS_RESET);
  2247.      sysMsDelay(500); /* 500 ms delay */
  2248.      * (VINT32 *) M85XX_GPOUTDR(CCSBAR) &=
  2249.                          ~(BCM98548XMC_SYS_RESET| BCM98548XMC_CPU_RESET);
  2250.  
  2251.      for(;;);
  2252. }
  2254. UINT8 sysBoardRev()
  2255. {
  2256.     UINT8 board_id;
  2258.     board_id = 0;
  2260. #ifdef INCLUDE_I2C_DEV
  2261.     if (pcf8574_boardid_get(&board_id) == 0) {
  2262.         return board_id; 
  2263.     }
  2264. #endif
  2266.     return 0;
  2267. }
  2269. STATUS sysRtcGet (struct tm * time)
  2270. {
  2271.     int year, month, date, hour, min, sec;
  2272.     STATUS status;
  2273.  
  2274.     status = ERROR;
  2276. #ifdef INCLUDE_I2C_DEV
  2277.     status = m41t81_tod_get(&year, &month, &date, &hour, &min, &sec);
  2279.     if (status == 0) {
  2280.         time->tm_sec   = sec;
  2281.         time->tm_min   = min;
  2282.         time->tm_hour  = hour;
  2283.         time->tm_mday  = date;
  2284.         time->tm_mon   = month - 1;  /* POSIX needs 0-11 */ 
  2285.         time->tm_year  = year - 1900;
  2286.         time->tm_yday  = 0;          /* unknown */
  2287.         time->tm_isdst = 0;          /* unknown */
  2288.     }
  2289. #endif /* INCLUDE_I2C_DEV */
  2290.     return status;
  2291. }
  2293. void
  2294. pcieShow()
  2295. {
  2296. int min_bus =129; int max_bus = 129;
  2297. #define P_MIN_BUS       min_bus
  2298. #define P_MAX_BUS       max_bus
  2299. #define P_MAX_DEV       31
  2300. #define P_MAX_FUNC      0
  2301. #define P_MAX_OFFSET    (0x400 -1)
  2302. #define FOR_EACH_LOOP(curr_id, min_id, max_id, incr_id) 
  2303.         for(curr_id = min_id; curr_id <= max_id; curr_id += incr_id)
  2305.     int bus, devid, func, offset, val, dev_max;
  2307.     printf("BS DV FN OF VALUEn");
  2308.     FOR_EACH_LOOP(bus, P_MIN_BUS, P_MAX_BUS, 1) {
  2309.         dev_max = (bus < PCIEX_BUS_MIN) ? P_MAX_DEV : 0;
  2310.         FOR_EACH_LOOP(devid, 0, dev_max, 1) {
  2311.             FOR_EACH_LOOP(func, 0, P_MAX_FUNC, 1) {
  2312.                 FOR_EACH_LOOP(offset, 0, P_MAX_OFFSET, 4) {
  2313.                     pciConfigInLong(bus, devid, func, offset, &val);
  2314.                     if (val == 0xffffffff) {
  2315.                         break;
  2316.                     }
  2317.                     printf("%02d %02d %02d %02X %08Xn",
  2318.                                 bus, devid, func, offset, val);
  2319.                 }
  2320.             }
  2321.         }
  2322.     }
  2323. }
  2325. void sysPcieConfigShow()
  2326. {
  2327.     int busNo;
  2328.     int devNo;
  2329.     int funcNo;
  2330.     int data;
  2331.     int offset;
  2333.     busNo  = PCIEX_BUS_MIN + 0;
  2334.     devNo  = 0;
  2335.     funcNo = 0;
  2337.     sysPciConfigEnable (CDS85XX_PCIEX_BUS);
  2338.     for (offset = 0; offset <= 0x7c; offset = offset + 4) {
  2339.        if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2340.            printf("offset 0x%08x = 0x%08xn", offset, data);
  2341.        } else {
  2342.            printf("sysPciConfigRead error.n");
  2343.            break;
  2344.        }
  2345.     }
  2347.     printf("PCI-E Extended Configuration Spacen");
  2348.     for (offset = 0x100; offset <= 0x134; offset = offset + 4) {
  2349.        if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2350.            printf("offset 0x%08x = 0x%08xn", offset, data);
  2351.        } else {
  2352.            printf("sysPciConfigRead error.n");
  2353.            break;
  2354.        }
  2355.     }
  2357.     offset = 0x404;
  2358.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2359.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2360.     } else {
  2361.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2362.     }
  2363.     offset = 0x440;
  2364.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2365.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2366.     } else {
  2367.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2368.     }
  2369.     offset = 0x450;
  2370.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2371.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2372.     } else {
  2373.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2374.     }
  2375.     offset = 0x454;
  2376.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2377.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2378.     } else {
  2379.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2380.     }
  2381.     offset = 0x478;
  2382.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2383.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2384.     } else {
  2385.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2386.     }
  2387.     offset = 0x4b0;
  2388.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2389.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2390.     } else {
  2391.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2392.     }
  2393.     offset = 0x590;
  2394.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2395.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2396.     } else {
  2397.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2398.     }
  2399.     offset = 0x5a0;
  2400.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2401.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2402.     } else {
  2403.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2404.     }
  2405. }
  2408. static char * e500_ratio[] = {"reserved", "reserved", "1:1", "3:2",
  2409.                              "2:1", "5:2", "3:1", "7:2", "4:1", "9:2",
  2410.                              "reserved", "reserved", "reserved", "reserved",
  2411.                              "reserved", "reserved" };
  2412. static char * tsec_protocol[] = {"FIFO", "MII", "GMII", "TBI"};                        
  2413. static char * io_sel[] = {"reserved", "reserved", "reserved",
  2414.                           "x4 RIO 2.5Gbps, x4 PCI-E", 
  2415.                           "x4 RIO 1.25Gbps, x4 PCI-E", 
  2416.                           "x4 RIO 3.125Gbps", 
  2417.                           "x4 RIO 1.25Gbps", 
  2418.                           "x8 PCI-E"};
  2419. void sysPorStatShow()
  2420. {
  2421.     UINT reg;
  2422.     int  field; 
  2423.     
  2424.     reg = *M85XX_PORPLLSR(CCSBAR);
  2425.     field = (reg >> 16) & 0xf;
  2426.     printf("e500_ratio = %sn", e500_ratio[field]);
  2427.     field = (reg >> 15) & 1;
  2428.     printf("PCI1_clk_sel = %sn", field ? "SYS_CLK" : "PCI1_CLK");
  2429.     field = (reg >> 14) & 1;
  2430.     printf("PCI2_clk_sel = %sn", field ? "SYS_CLK" : "PCI2_CLK");
  2431.     field = (reg >> 1) & 0xf;
  2432.     printf("Plat_Ratio = %d : 1n", field);
  2434.     reg = *M85XX_PORBMSR(CCSBAR);
  2435.     field = (reg >> 31) & 1;
  2436.     printf("BCFG = %sn", field ? "CPU immediate boot" : "CPU wait to boot");
  2438.     reg = *M85XX_PORDEVSR(CCSBAR);
  2439.     field = (reg >> 31) & 1;
  2440.     printf("eTSEC1 and eTSEC2 in %s interface moden", 
  2441.            field ? "full" : "reduced");
  2442.     field = (reg >> 30) & 1;
  2443.     printf("eTSEC3 and eTSEC4 in %s interface moden",
  2444.            field ? "full" : "reduced");
  2445.     field = (reg >> 24) & 3;
  2446.     printf("eTSEC1 operates in %s moden", tsec_protocol[field]); 
  2447.     field = (reg >> 12) & 3;
  2448.     printf("eTSEC2 operates in %s moden", tsec_protocol[field]); 
  2449.     field = (reg >> 10) & 3;
  2450.     printf("eTSEC3 operates in %s moden", tsec_protocol[field]); 
  2451.     field = (reg >> 8) & 3;
  2452.     printf("eTSEC4 operates in %s moden", tsec_protocol[field]); 
  2453.     field = (reg >> 19) & 0xf;
  2454.     printf("%sn", io_sel[field]);
  2456.     reg = *M85XX_PORDEVSR2(CCSBAR);
  2457.     field = (reg >> 2) & 1;
  2458.     printf("Serdes %sn", field ? "enabled" : "disabled");
  2459. }
  2461. void extIsr(int id) {
  2462.     logMsg("Interrupt %dn", id, 0, 0, 0, 0, 0);
  2463. }
  2465. void installExtInt()
  2466. {
  2468.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 4), (VOIDFUNCPTR)extIsr, 4);
  2469.     sysEpicIntEnable((EXT_VEC_IRQ0 + 4));
  2471.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 5), (VOIDFUNCPTR)extIsr, 5);
  2472.     sysEpicIntEnable((EXT_VEC_IRQ0 + 5));
  2474.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 6), (VOIDFUNCPTR)extIsr, 6);
  2475.     sysEpicIntEnable((EXT_VEC_IRQ0 + 6));
  2477.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 7), (VOIDFUNCPTR)extIsr, 7);
  2478.     sysEpicIntEnable((EXT_VEC_IRQ0 + 7));
  2480.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 10), (VOIDFUNCPTR)extIsr, 10);
  2481.     sysEpicIntEnable((EXT_VEC_IRQ0 + 10));
  2483.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 11), (VOIDFUNCPTR)extIsr, 11);
  2484.     sysEpicIntEnable((EXT_VEC_IRQ0 + 11));
  2485. }
  2487. void gpoutSet(int pin, int val)
  2488. {
  2489.     int  key;
  2490.     UINT reg;
  2492.     key = intLock();
  2494.     reg = *M85XX_GPOUTDR(CCSBAR);
  2496.     if (val) {
  2497.         reg |= (0x80000000 >> pin);
  2498.     } else {
  2499.         reg &= ~(0x80000000 >> pin);
  2500.     } 
  2502.     *M85XX_GPOUTDR(CCSBAR) = reg;
  2503.     intUnlock(key);
  2505. }
  2507. void gpinGet()
  2508. {
  2509.     UINT reg;
  2511.     reg = *M85XX_GPINDR(CCSBAR);
  2513.     printf("PMC_EREADY = %dn", (reg & ( 1 << 16)) ? 1 : 0); 
  2514.     printf("~P4_PRST  = %dn", (reg & ( 1 << 17)) ? 1 : 0); 
  2515.     printf("~XMC_PRST = %dn", (reg & ( 1 << 18)) ? 1 : 0); 
  2516.     printf("FLASH_SEL = %dn", (reg & ( 1 << 19)) ? 1 : 0); 
  2517.     printf("XMC_ROOT0 = %dn", (reg & ( 1 << 20)) ? 1 : 0); 
  2518.     printf("PMC_MONARCH = %dn", (reg & ( 1 << 21)) ? 1 : 0); 
  2519.     printf("GPIO0 = %dn", (reg & ( 1 << 22)) ? 1 : 0); 
  2520.     printf("GPIN5 = %dn", (reg & ( 1 << 23)) ? 1 : 0); 
  2521.  
  2523. }
  2525. void autoconfig_done()
  2526. {
  2527.    printf("pci_autoconfig_done = %dn", pci_autoconfig_done);
  2528. }
  2530. void pcieLinkPoll()
  2531. {
  2532.     int poll_count;
  2533.     int data;
  2534.     for(poll_count=1; poll_count <=1000; poll_count++) {
  2535.         if (sysPciConfigRead(128, 0, 0, 0x404, 4, &data)== OK) {
  2536.             if (data != 0x16) {
  2537.                 printf("Link down on %d polln");
  2538.             }
  2539.         } else {
  2540.             printf("(sysPciConfigRead(128, 0, 0, 0x404, 4, &data) Failedn");
  2541.         }
  2542.     }
  2543. }
  2545. #ifdef INCLUDE_SYS_HW_INIT_0
  2546. IMPORT BOOL excExtendedVectors;
  2547. /***************************************************************************
  2548. *
  2549. * SYS_HW_INIT_0 - test for extended vectors
  2550. *
  2551. * This routine is used for testing extended vectors.
  2552. *
  2553. * RETURNS: N/A
  2554. *
  2555. * ERRNO
  2556. */
  2558. void SYS_HW_INIT_0 (void)
  2559.     {
  2560.     excExtendedVectors = TRUE;
  2561.     }
  2562. #endif  /* INCLUDE_SYS_HW_INIT_0 */