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

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

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.         }
  913. /*
  914.  * METROCORE_GTO:
  915.  * sysPciAutoConfig only enumerates bus0.
  916.  * Need to be fixed in the future.
  917.  * Comment out sysPciAutoConfig to use bootloader's (CFE)
  918.  * PCI bus enumeration.
  919.  */
  920. #ifndef METROCORE_GTO
  921. #if 0
  922.     if ( *((char*)PCI_AUTO_CONFIG_ADRS) == FALSE )
  923. #endif
  924.         {
  925.         mot85xxBridgeInit();
  926. #ifdef INCLUDE_PCI_AUTOCONF
  927.         sysPciAutoConfig();
  929.         pci_autoconfig_done = TRUE;
  930. #endif
  931.         *((char*)PCI_AUTO_CONFIG_ADRS) = TRUE;
  932.         }
  934. #endif /* METROCORE_GTO */
  936. #endif /* INCLUDE_PCI */
  939. #ifdef E500_L1_PARITY_RECOVERY
  940.     vxIvor1Set(_EXC_OFF_L1_PARITY);
  941. #endif  /* E500_L1_PARITY_RECOVERY */
  942. #ifdef INCLUDE_L1_IPARITY_HDLR
  943.     installL1ICacheParityErrorRecovery();
  944. #endif /* INCLUDE_L1_IPARITY_HDLR */
  946.     /*
  947.      * The power management mode is initialized here. Reduced power mode
  948.      * is activated only when the kernel is idle (cf vxPowerDown).
  949.      * Power management mode is selected via vxPowerModeSet().
  950.      * DEFAULT_POWER_MGT_MODE is defined in config.h.
  951.      */
  953. #if defined(INCLUDE_L2_SRAM)
  954. #if (defined(INCLUDE_L2_CACHE) && defined(INCLUDE_CACHE_SUPPORT))
  955.     sysL2SramEnable(TRUE);
  956. #elif (defined(INCLUDE_L2_SRAM))
  957.     sysL2SramEnable(FALSE);
  958. #endif
  959. #endif
  961.     CACHE_PIPE_FLUSH();
  963.     vxPowerModeSet (DEFAULT_POWER_MGT_MODE);
  965.     }
  967. #ifdef INCLUDE_L2_SRAM
  968. /*************************************************************************
  969. *
  970. * sysL2SramEnable - enables L2SRAM if L2SRAM only
  971. *
  972. * This routine enables L2SRAM if L2SRAM only or initializes blk
  973. * size etc and leaves the rest to L2 cache code.
  974. *
  975. * RETURNS: N/A
  976. *
  977. * ERRNO: N/A
  978. */
  979. LOCAL void sysL2SramEnable
  980. (
  981. BOOL both
  982. )
  983.     {
  984.     volatile int l2CtlVal;
  986.     /*
  987.      * if INCLUDE_L2_CACHE and CACHE_SUPPORT
  988.      * if ((L2_SRAM_SIZE + L2_CACHE_SIZE) > l2Siz)
  989.      */
  991.     /* Setup Windows for L2SRAM */
  993.     *(M85XX_L2SRBAR0(CCSBAR)) = (UINT32)(L2SRAM_ADDR & M85XX_L2SRBAR_ADDR_MSK);
  995.     /* Get present value */
  997.     l2CtlVal = vxL2CTLGet(M85XX_L2CTL(CCSBAR));
  999.     /* Disable L2CTL initially to allow changing of block size */
  1001.     l2CtlVal &=(~M85XX_L2CTL_L2E_MSK);
  1002.     vxL2CTLSet(l2CtlVal,M85XX_L2CTL(CCSBAR));
  1003.     l2CtlVal &= ~M85XX_L2CTL_L2BLKSIZ_MSK;
  1004.     l2CtlVal &= ~M85XX_L2CTL_L2SRAM_MSK;
  1006.     if (both == TRUE)
  1007.         {
  1008.         /* Setup size of SRAM */
  1010.         l2CtlVal |= (L2SIZ_256KB << M85XX_L2CTL_L2BLKSIZ_BIT) |
  1011.                     (0x2 << M85XX_L2CTL_L2SRAM_BIT);
  1012.         }
  1013.     else
  1014.         {
  1015.         l2CtlVal |= (L2SIZ_512KB << M85XX_L2CTL_L2BLKSIZ_BIT) |
  1016.                     (0x1 << M85XX_L2CTL_L2SRAM_BIT);
  1017.         }
  1019.     /* Setup L2CTL for SRAM */
  1021.     vxL2CTLSet(l2CtlVal,M85XX_L2CTL(CCSBAR));
  1023.     if (both == FALSE)
  1024.         {
  1025.         /* This is done here so L2SRAM is set before enable */
  1027.         l2CtlVal |= M85XX_L2CTL_L2E_MSK; /* No cache so go ahead and enable */
  1029.         /* Enable L2CTL for SRAM */
  1031.         vxL2CTLSet(l2CtlVal,M85XX_L2CTL(CCSBAR));
  1032.         }
  1034.     }
  1035. #endif /* INCLUDE_L2_SRAM */
  1037. /**************************************************************************
  1038. *
  1039. * sysPhysMemTop - get the address of the top of physical memory
  1040. *
  1041. * This routine returns the address of the first missing byte of memory,
  1042. * which indicates the top of memory.
  1043. *
  1044. * RETURNS: The address of the top of physical memory.
  1045. *
  1046. * ERRNO: N/A
  1047. *
  1048. * SEE ALSO: sysMemTop()
  1049. */
  1051. char * sysPhysMemTop (void)
  1052.     {
  1054.     if (physTop == NULL)
  1055.         {
  1056.         physTop = (char *)(LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE);
  1057.         }
  1059.     return(physTop) ;
  1060.     }
  1062. /***************************************************************************
  1063. *
  1064. * sysMemTop - get the address of the top of VxWorks memory
  1065. *
  1066. * This routine returns a pointer to the first byte of memory not
  1067. * controlled or used by VxWorks.
  1068. *
  1069. * The user can reserve memory space by defining the macro USER_RESERVED_MEM
  1070. * in config.h.  This routine returns the address of the reserved memory
  1071. * area.  The value of USER_RESERVED_MEM is in bytes.
  1072. *
  1073. * RETURNS: The address of the top of VxWorks memory.
  1074. *
  1075. * ERRNO: N/A
  1076. */
  1078. char * sysMemTop (void)
  1079.     {
  1081.     if (memTop == NULL)
  1082.         {
  1083.         memTop = sysPhysMemTop () - USER_RESERVED_MEM;
  1085. #ifdef INCLUDE_EDR_PM
  1087.         /* account for ED&R persistent memory */
  1089.         memTop = memTop - PM_RESERVED_MEM;
  1090. #endif
  1092.         }
  1094.     return memTop;
  1095.     }
  1097. /**************************************************************************
  1098. *
  1099. * sysToMonitor - transfer control to the ROM monitor
  1100. *
  1101. * This routine transfers control to the ROM monitor.  Normally, it is called
  1102. * only by reboot()--which services ^X--and bus errors at interrupt level.
  1103. * However, in some circumstances, the user may wish to introduce a
  1104. * <startType> to enable special boot ROM facilities.
  1105. *
  1106. * RETURNS: Does not return.
  1107. *
  1108. * ERRNO: N/A
  1109. */
  1110. int sysToMonitorExcMessage = 0;
  1111. int sysToMonitorBacktrace = 1;
  1112. int sysToMonitorReboot = 1;
  1113. void (*sysToMonitorHook)(void);
  1115. STATUS sysToMonitor
  1116.     (
  1117.     int startType   /* parameter passed to ROM to tell it how to boot */
  1118.     )
  1119.     {
  1120. #if 0
  1121.     FUNCPTR pRom = (FUNCPTR) (ROM_TEXT_ADRS + 4);   /* Warm reboot */
  1122. #endif
  1124.     if (sysToMonitorHook)
  1125.         (*sysToMonitorHook)();
  1127.     sysReboot();
  1129. #if 0
  1130.     intLock();
  1133. #ifdef INCLUDE_BRANCH_PREDICTION
  1134.     disableBranchPrediction();
  1135. #endif /* INCLUDE_BRANCH_PREDICTION */
  1137. #ifdef INCLUDE_CACHE_SUPPORT
  1138.     cacheDisable(INSTRUCTION_CACHE);
  1139.     cacheDisable(DATA_CACHE);
  1140. #endif
  1141.     sysClkDisable();
  1144. #ifdef INCLUDE_AUX_CLK
  1145.     sysAuxClkDisable();
  1146. #endif
  1148.     vxMsrSet(0);
  1150.     /* Clear unnecessary TLBs */
  1152.     mmuE500TlbDynamicInvalidate();
  1153.     mmuE500TlbStaticInvalidate();
  1155.     (*pRom) (startType);    /* jump to bootrom entry point */
  1156. #endif
  1157.     return(OK);    /* in case we ever continue from ROM monitor */
  1158.     }
  1160. /******************************************************************************
  1161. *
  1162. * sysHwInit2 - additional system configuration and initialization
  1163. *
  1164. * This routine connects system interrupts and does any additional
  1165. * configuration necessary.
  1166. *
  1167. * RETURNS: N/A
  1168. *
  1169. * ERRNO: N/A
  1170. */
  1172. void sysHwInit2 (void)
  1173.     {
  1175. #ifdef  INCLUDE_VXBUS
  1176.     vxbDevInit();
  1177. #endif /* INCLUDE_VXBUS */
  1180.     excIntConnect ((VOIDFUNCPTR *) _EXC_OFF_DECR,
  1181.                    (VOIDFUNCPTR) sysClkInt);
  1183.     sysClkRateSet(60);
  1184.     sysClkEnable();
  1186. #ifdef INCLUDE_AUX_CLK
  1187.     excIntConnect ((VOIDFUNCPTR *) _EXC_OFF_FIT, (VOIDFUNCPTR) sysAuxClkInt);
  1188. #endif
  1190. #  if defined(INCLUDE_AUX_CLK)
  1192.      /* initialize and start auxiliary clock support */
  1194.      sysAuxClkEnable ();
  1196. #  endif /* INCLUDE_AUX_CLK */
  1199.     /*
  1200.      * This was previously reqd for errata workaround #29, the workaround
  1201.      * has been replaced with patch for spr99776, so it now serves as an
  1202.      * example of implementing an l1 instruction parity handler
  1203.      */
  1205. #ifdef INCLUDE_L1_IPARITY_HDLR_INBSP
  1206.     memcpy((void*)_EXC_OFF_L1_PARITY, (void *)jumpIParity, sizeof(INSTR));
  1207.     cacheTextUpdate((void *)_EXC_OFF_L1_PARITY, sizeof(INSTR));
  1208.     sysIvor1Set(_EXC_OFF_L1_PARITY);
  1209.     cacheDisable(INSTRUCTION_CACHE);
  1210.     vxL1CSR1Set(vxL1CSR1Get() | _PPC_L1CSR_CPE);
  1211.     cacheEnable(INSTRUCTION_CACHE);
  1212. #endif  /* INCLUDE_L1_IPARITY_HDLR_INBSP */
  1214.     /* initialize the EPIC interrupts */
  1216.     sysEpicIntrInit ();
  1218.     /* initialize serial interrupts */
  1220. #if defined(INCLUDE_DUART)
  1221.     sysSerialHwInit2 ();
  1222. #endif /* INCLUDE_DUART */
  1224. #if     defined (INCLUDE_SPE)
  1225.     _func_speProbeRtn = sysSpeProbe;
  1226. #endif  /* INCLUDE_SPE */
  1229. #ifdef INCLUDE_PCI
  1231. #ifdef INCLUDE_GEI8254X_END
  1232.     sysPciConfigEnable (CDS85XX_PCI_1_BUS);
  1233.     pciConfigForeachFunc (0, FALSE, (PCI_FOREACH_FUNC) sys8254xDeviceCheck, (void *)&sysPci1SysNum);
  1234. #ifdef INCLUDE_CDS85XX_PCIEX
  1235. #ifdef INCLUDE_GEI8254X_END
  1236.     sysPciConfigEnable (CDS85XX_PCIEX_BUS);
  1237.     pciConfigForeachFunc (PCIEX_BUS_MIN + 1, FALSE, (PCI_FOREACH_FUNC) sys8254xDeviceCheck, (void *)&sysPci3SysNum);
  1238. #endif /* INCLUDE_GEI8254X_END */
  1240. #endif /* INCLUDE_CDS85XX_PCIEX */
  1241. #endif /* INCLUDE_GEI8254X_END */
  1242. #endif /* INCLUDE_PCI */
  1244.     /* Configure GPIO */
  1245.     * (VINT32 *) M85XX_GPOUTDR(CCSBAR) = 0x3;
  1246.     * (VINT32 *) M85XX_GPIOCR(CCSBAR) = (1 << 17) | ( 1 << 16) | (1 << 9);
  1248. #ifdef INCLUDE_SYSLED
  1249.     sysLedOn();
  1250. #endif 
  1252. #ifdef INCLUDE_I2C_DEV
  1253.     i2cDrvInit(0, MPC85XX_I2C_CONTROLLER);
  1254.     i2cDrvInit(1, MPC85XX_I2C_CONTROLLER);
  1255.     usrTimeSync();
  1256. #endif /* INCLUDE_I2C_DEV */
  1258. #ifdef  INCLUDE_VXBUS
  1259.     taskSpawn("devConnect",0,0,10000,vxbDevConnect,0,0,0,0,0,0,0,0,0,0);
  1260. #endif /* INCLUDE_VXBUS */
  1262.     }
  1264. /******************************************************************************
  1265. *
  1266. * sysProcNumGet - get the processor number
  1267. *
  1268. * This routine returns the processor number for the CPU board, which is
  1269. * set with sysProcNumSet().
  1270. *
  1271. * RETURNS: The processor number for the CPU board.
  1272. *
  1273. * ERRNO: N/A
  1274. *
  1275. * SEE ALSO: sysProcNumSet()
  1276. */
  1278. int sysProcNumGet (void)
  1279.     {
  1280.     return(sysProcNum);
  1281.     }
  1283. /******************************************************************************
  1284. *
  1285. * sysProcNumSet - set the processor number
  1286. *
  1287. * This routine sets the processor number for the CPU board.  Processor numbers
  1288. * should be unique on a single backplane.
  1289. *
  1290. * Not applicable for the bus-less 8260Ads.
  1291. *
  1292. * RETURNS: N/A
  1293. *
  1294. * ERRNO: N/A
  1295. *
  1296. * SEE ALSO: sysProcNumGet()
  1297. */
  1299. void sysProcNumSet
  1300.     (
  1301.     int     procNum         /* processor number */
  1302.     )
  1303.     {
  1304.     sysProcNum = procNum;
  1305.     }
  1307. /******************************************************************************
  1308. *
  1309. * sysLocalToBusAdrs - convert a local address to a bus address
  1310. *
  1311. * This routine gets the VMEbus address that accesses a specified local
  1312. * memory address.
  1313. *
  1314. * Not applicable for the 8260Ads
  1315. *
  1316. * RETURNS: ERROR, always.
  1317. *
  1318. * ERRNO: N/A
  1319. *
  1320. * SEE ALSO: sysBusToLocalAdrs()
  1321. */
  1323. STATUS sysLocalToBusAdrs
  1324.     (
  1325.     int     adrsSpace,  /* bus address space where busAdrs resides */
  1326.     char *  localAdrs,  /* local address to convert */
  1327.     char ** pBusAdrs    /* where to return bus address */
  1328.     )
  1329.     {
  1331.     *pBusAdrs = localAdrs;
  1333.     return(OK);
  1334.     }
  1336. /******************************************************************************
  1337. *
  1338. * sysBusToLocalAdrs - convert a bus address to a local address
  1339. *
  1340. * This routine gets the local address that accesses a specified VMEbus
  1341. * physical memory address.
  1342. *
  1343. * Not applicable for the 8260Ads
  1344. *
  1345. * RETURNS: ERROR, always.
  1346. *
  1347. * ERRNO: N/A
  1348. *
  1349. * SEE ALSO: sysLocalToBusAdrs()
  1350. */
  1352. STATUS sysBusToLocalAdrs
  1353.     (
  1354.     int     adrsSpace,  /* bus address space where busAdrs resides */
  1355.     char *  busAdrs,    /* bus address to convert */
  1356.     char ** pLocalAdrs  /* where to return local address */
  1357.     )
  1358.     {
  1360.     *pLocalAdrs = busAdrs;
  1362.     return(OK);
  1363.     }
  1367. #ifdef INCLUDE_PCI  /* board level PCI routines */
  1369. /*******************************************************************************
  1370. * sysPciConfigEnable -  enable PCI 1 or PCI 2 bus configuration
  1371. *
  1372. * This function enables PCI 1 or PCI 2 bus configuration
  1373. *
  1374. * RETURNS: N/A
  1375. *
  1376. * ERRNO: N/A
  1377. */
  1379. void sysPciConfigEnable
  1380.     (
  1381.     int pciHost
  1382.     )
  1383.     {
  1384.     int level;
  1386.     level = intLock ();
  1388.     if (pciHost == CDS85XX_PCI_2_BUS)
  1389.         {
  1390.         sysPciConfAddr = PCI2_CFG_ADR_REG;   /* PCI Configuration Address */
  1391.         sysPciConfData = PCI2_CFG_DATA_REG;  /* PCI Configuration Data */
  1392.         }
  1393.     else if (pciHost == CDS85XX_PCIEX_BUS)
  1394.         {
  1395.         sysPciConfAddr = PCIEX_CFG_ADR_REG;   /* PCI Configuration Address */
  1396.         sysPciConfData = PCIEX_CFG_DATA_REG;  /* PCI Configuration Data */
  1397.         }
  1398.     else /* default is for PCI 1 host */
  1399.         {
  1400.         sysPciConfAddr = PCI_CFG_ADR_REG;   /* PCI Configuration Address */
  1401.         sysPciConfData = PCI_CFG_DATA_REG;  /* PCI Configuration Data */
  1402.         }
  1404.     WRS_ASM("sync;eieio");
  1406.     intUnlock (level);
  1407.     }
  1409. /*******************************************************************************
  1410. *
  1411. * sysPciSpecialCycle - generate a special cycle with a message
  1412. *
  1413. * This routine generates a special cycle with a message.
  1414. *
  1415. * NOMANUAL
  1416. *
  1417. * RETURNS: OK
  1418. *
  1419. * ERRNO: N/A
  1420. */
  1422. STATUS sysPciSpecialCycle
  1423.     (
  1424.     int     busNo,
  1425.     UINT32  message
  1426.     )
  1427.     {
  1428.     int deviceNo    = 0x0000001f;
  1429.     int funcNo      = 0x00000007;
  1431.     if (pci_autoconfig_done) {
  1432.         if (busNo >= PCIEX_BUS_MIN) {
  1433.             busNo = busNo - PCIEX_BUS_MIN;
  1434.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1435.         } else {
  1436.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1437.         }
  1438.     }
  1439.  
  1440.     pciRegWrite ((UINT32 *)sysPciConfAddr,
  1441.                  (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1442.                  0x80000000);
  1444.     PCI_OUT_LONG (sysPciConfData, message);
  1446.     return(OK);
  1447.     }
  1449. /*******************************************************************************
  1450. *
  1451. * sysPciConfigRead - read from the PCI configuration space
  1452. *
  1453. * This routine reads either a byte, word or a long word specified by
  1454. * the argument <width>, from the PCI configuration space
  1455. * This routine works around a problem in the hardware which hangs
  1456. * PCI bus if device no 12 is accessed from the PCI configuration space.
  1457. *
  1458. * NOMANUAL
  1459. *
  1460. * RETURNS: OK, or ERROR if this library is not initialized
  1461. *
  1462. * ERRNO: N/A
  1463. */
  1465. STATUS sysPciConfigRead
  1466.     (
  1467.     int busNo,    /* bus number */
  1468.     int deviceNo, /* device number */
  1469.     int funcNo,   /* function number */
  1470.     int offset,   /* offset into the configuration space */
  1471.     int width,    /* width to be read */
  1472.     void * pData /* data read from the offset */
  1473.     )
  1474.     {
  1475.     UINT8  retValByte = 0;
  1476.     UINT16 retValWord = 0;
  1477.     UINT32 retValLong = 0;
  1478.     STATUS retStat = ERROR;
  1480.     /* Set Default values of data */
  1481.     switch(width) {
  1482.         case 1:
  1483.             *((UINT8 *)pData) = 0xff;
  1484.             break;
  1485.         case 2:
  1486.             *((UINT16 *)pData) = 0xffff; 
  1487.             break;
  1488.         case 4:
  1489.             *((UINT32 *)pData) = 0xffffffff;
  1490.             break;
  1491.         default:
  1492.             return ERROR;
  1493.     }
  1494.  
  1495. #if defined(BCM_DEVICE_ON_PCIE) /* Skip device on PCI BUS */
  1496.     if  (0x1e == deviceNo) {
  1497.         return OK;
  1498.     }
  1499. #else
  1500. #endif
  1501.     if (pci_autoconfig_done) {
  1502.         if (busNo >= PCIEX_BUS_MIN) {
  1503.             if ((busNo > (PCIEX_BUS_MIN + 1)) || (deviceNo > 0))  {
  1504.                 return OK;
  1505.             }
  1506.             busNo = busNo - PCIEX_BUS_MIN;
  1507.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1508.         } else {
  1509.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1510.         }
  1511.     }
  1512.     
  1513.     /* This is for PCI Express */
  1514.     if ((sysPciConfAddr == PCIEX_CFG_ADR_REG) && (busNo > 0))
  1515.     {
  1516.          /* Read LTSSM state status register to make sure that the Link is ready */
  1517.          pciRegWrite ((UINT32 *)sysPciConfAddr,
  1518.                          (UINT32)pciConfigBdfPack (0, 0, 0) |
  1519.                          (0x404 & 0xfc) | 0x80000000 | ((0x404 & 0xf00) << 16));
  1520.           retValLong = PCI_IN_LONG (sysPciConfData);
  1521.           if (retValLong != 0x16) {
  1522.               /* Link training is not completed. Cannot read PCIE config 
  1523.                * space. */
  1524.               return OK;
  1525.           }
  1526.     }
  1528.     switch (width)
  1529.         {
  1530.         case 1: /* byte */
  1531.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1532.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1533.                          (offset & 0xffc) | 0x80000000 | ((offset & 0xf00) << 16)) ;
  1535.             retValByte = PCI_IN_BYTE (sysPciConfData + (offset & 0x3));
  1536.             *((UINT8 *)pData) = retValByte;
  1537.             retStat = OK;
  1538.             break;
  1540.         case 2: /* word */
  1541.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1542.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1543.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1545.             retValWord = PCI_IN_WORD (sysPciConfData + (offset & 0x2));
  1546.             *((UINT16 *)pData) = retValWord;
  1547.             retStat = OK;
  1548.             break;
  1550.         case 4: /* long */
  1551.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1552.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1553.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1554.             retValLong = PCI_IN_LONG (sysPciConfData);
  1555.             *((UINT32 *)pData) = retValLong;
  1556.             retStat = OK;
  1557.             break;
  1559.         default:
  1560.             retStat = ERROR;
  1561.             break;
  1562.         }
  1564.     return(retStat);
  1565.     }
  1567. /*******************************************************************************
  1568. *
  1569. * sysPciConfigWrite - write to the PCI configuration space
  1570. *
  1571. * This routine writes either a byte, word or a long word specified by
  1572. * the argument <width>, to the PCI configuration space
  1573. * This routine works around a problem in the hardware which hangs
  1574. * PCI bus if device no 12 is accessed from the PCI configuration space.
  1575. * Errata PCI-Express requires RMW to ensure always write 4byte aligned.
  1576. *
  1577. * NOMANUAL
  1578. *
  1579. * RETURNS: OK, or ERROR if this library is not initialized
  1580. *
  1581. * ERRNO: N/A
  1582. */
  1584. STATUS sysPciConfigWrite
  1585.     (
  1586.     int busNo,    /* bus number */
  1587.     int deviceNo, /* device number */
  1588.     int funcNo,   /* function number */
  1589.     int offset,   /* offset into the configuration space */
  1590.     int width,    /* width to write */
  1591.     ULONG data    /* data to write */
  1592.     )
  1593.     {
  1595.  /*
  1596.   * PCI-Express errata RMW workaround should work for all PCI
  1597.   * Requires always to do 4 byte read/write
  1598.   */
  1600.     ULONG data2,mask;
  1602.    /* Establish the required mask based on width and offset */
  1604.     switch(width)
  1605. {
  1606. case 1:
  1607.     mask=0xff;
  1608.     mask=~(mask << ((offset&0x3)*8));
  1609.     break;
  1610. case 2:
  1611.     mask=0xffff;
  1612.     mask=~(mask << ((offset&0x3)*8));
  1613.     break;
  1614. case 4:
  1615.     mask=0;
  1616.     break;
  1617. default:
  1618.     return(ERROR);
  1619. }
  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.     sysPciConfigRead(busNo,deviceNo,funcNo,(offset & ~0x3), 4, &data2);
  1632.     if (pci_autoconfig_done) {
  1633.         if (busNo >= PCIEX_BUS_MIN) {
  1634.             busNo = busNo - PCIEX_BUS_MIN;
  1635.             sysPciConfigEnable(CDS85XX_PCIEX_BUS);
  1636.         } else {
  1637.             sysPciConfigEnable(CDS85XX_PCI_1_BUS);
  1638.         }
  1639.     }
  1641.     data2 &= mask;
  1643.     data2 |= data << ((offset&0x3)*8); /* Overwite only part of word reqd */
  1645.     data = data2;             /* final 32 bit value to write */
  1646.     width = 4;                /* always do 32 bit write */
  1647.     offset = (offset & ~0x3); /* align by 32 bits */
  1649. #if 0
  1650.     if ((busNo == 0) && (deviceNo == 0x1f))
  1651.         return(ERROR);
  1652. #endif
  1654.     switch (width)
  1655.         {
  1656.         case 1: /* byte */
  1657.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1658.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1659.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1660.             PCI_OUT_BYTE ((sysPciConfData + (offset & 0x3)), data);
  1661.             break;
  1663.         case 2: /* word */
  1664.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1665.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1666.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1667.             PCI_OUT_WORD ((sysPciConfData + (offset & 0x2)), data);
  1668.             break;
  1670.         case 4: /* long */
  1671.             pciRegWrite ((UINT32 *)sysPciConfAddr,
  1672.                          (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
  1673.                          (offset & 0xfc) | 0x80000000 | ((offset & 0xf00) << 16));
  1674.             PCI_OUT_LONG (sysPciConfData, data);
  1675.             break;
  1677.         default:
  1678.             return(ERROR);
  1680.         }
  1681.     return(OK);
  1682.     }
  1683. #endif /* INCLUDE_PCI */
  1685. /******************************************************************************
  1686. *
  1687. * sysUsDelay - delay at least the specified amount of time (in microseconds)
  1688. *
  1689. * This routine will delay for at least the specified amount of time using the
  1690. * lower 32 bit "word" of the Time Base register as the timer.
  1691. *
  1692. * NOTE:  This routine will not relinquish the CPU; it is meant to perform a
  1693. * busy loop delay.  The minimum delay that this routine will provide is
  1694. * approximately 10 microseconds.  The maximum delay is approximately the
  1695. * size of UINT32; however, there is no roll-over compensation for the total
  1696. * delay time, so it is necessary to back off two times the system tick rate
  1697. * from the maximum.
  1698. *
  1699. * RETURNS: N/A
  1700. *
  1701. * ERRNO: N/A
  1702. */
  1704. void sysUsDelay
  1705.     (
  1706.     UINT32    delay        /* length of time in microsec to delay */
  1707.     )
  1708.     {
  1709.     register UINT baselineTickCount;
  1710.     register UINT curTickCount;
  1711.     register UINT terminalTickCount;
  1712.     register int actualRollover = 0;
  1713.     register int calcRollover = 0;
  1714.     UINT ticksToWait;
  1715.     UINT requestedDelay;
  1716.     UINT oneUsDelay;
  1718.     /* Exit if no delay count */
  1720.     if ((requestedDelay = delay) == 0)
  1721.         return;
  1723.     /*
  1724.      * Get the Time Base Lower register tick count, this will be used
  1725.      * as the baseline.
  1726.      */
  1728.     baselineTickCount = sysTimeBaseLGet();
  1730.     /*
  1731.      * Calculate number of ticks equal to 1 microsecond
  1732.      *
  1733.      * The Time Base register and the Decrementer count at the same rate:
  1734.      * once per 8 System Bus cycles.
  1735.      *
  1736.      * e.g., 199999999 cycles     1 tick      1 second            25 ticks
  1737.      *       ----------------  *  ------   *  --------         ~  --------
  1738.      *       second               8 cycles    1000000 microsec    microsec
  1739.      */
  1741.     /* add to round up before div to provide "at least" */
  1743.     oneUsDelay = ((sysTimerClkFreq + 1000000) / 1000000);
  1745.     /* Convert delay time into ticks */
  1747.     ticksToWait = requestedDelay * oneUsDelay;
  1749.     /* Compute when to stop */
  1751.     terminalTickCount = baselineTickCount + ticksToWait;
  1753.     /* Check for expected rollover */
  1755.     if (terminalTickCount < baselineTickCount)
  1756.         {
  1757.         calcRollover = 1;
  1758.         }
  1760.     do
  1761.         {
  1763.         /*
  1764.          * Get current Time Base Lower register count.
  1765.          * The Time Base counts UP from 0 to
  1766.          * all F's.
  1767.          */
  1769.         curTickCount = sysTimeBaseLGet();
  1771.         /* Check for actual rollover */
  1773.         if (curTickCount < baselineTickCount)
  1774.             {
  1775.             actualRollover = 1;
  1776.             }
  1778.         if (((curTickCount >= terminalTickCount)
  1779.              && (actualRollover == calcRollover)) ||
  1780.             ((curTickCount < terminalTickCount)
  1781.              && (actualRollover > calcRollover)))
  1782.             {
  1784.             /* Delay time met */
  1786.             break;
  1787.             }
  1788.         }
  1789.     while (TRUE); /* breaks above when delay time is met */
  1790.     }
  1793. void sysMsDelay
  1794.     (
  1795.     UINT      delay                   /* length of time in MS to delay */
  1796.     )
  1797.     {
  1798.     sysUsDelay ( (UINT32) delay * 1000 );
  1799.     }
  1802. /*********************************************************************
  1803. *
  1804. * sysDelay - Fixed 1ms delay.
  1805. *
  1806. * This routine consumes 1ms of time. It just calls sysMsDelay.
  1807. *
  1808. * RETURNS: N/A
  1809. *
  1810. * ERRNO: N/A
  1811. */
  1813. void sysDelay (void)
  1814.     {
  1815.     sysMsDelay (1);
  1816.     }
  1818. /***************************************************************************
  1819. *
  1820. * sysIntConnect - connect the BSP interrupt to the proper epic/i8259 handler.
  1821. *
  1822. * This routine checks the INT level and connects the proper routine.
  1823. * pciIntConnect() or intConnect().
  1824. *
  1825. * RETURNS:
  1826. * OK, or ERROR if the interrupt handler cannot be built.
  1827. *
  1828. * ERRNO: N/A
  1829. */
  1831. STATUS sysIntConnect
  1832.     (
  1833.     VOIDFUNCPTR *vector,        /* interrupt vector to attach to     */
  1834.     VOIDFUNCPTR routine,        /* routine to be called              */
  1835.     int parameter               /* parameter to be passed to routine */
  1836.     )
  1837.     {
  1838.     int tmpStat = ERROR;
  1839.     UINT32 read;
  1841.     if (((int) vector < 0) || ((int) vector >= EXT_VEC_IRQ0 + EXT_MAX_IRQS))
  1842.         {
  1843.         logMsg ("Error in sysIntConnect: out of range vector = %d.n",
  1844.                 (int)vector,2,3,4,5,6);
  1846.         return(ERROR);
  1847.         }
  1849.     if (vxMemProbe ((char *) routine, VX_READ, 4, (char *) &read) != OK)
  1850.         {
  1851.         logMsg ("Error in sysIntConnect: Cannot access routine.n",
  1852.                 1,2,3,4,5,6);
  1853.         return(ERROR);
  1854.         }
  1856.     if ((int) vector < EXT_VEC_IRQ0)
  1857.         {
  1858.         tmpStat = intConnect (vector, routine, parameter);
  1859.         }
  1860.     else
  1861.         {
  1863.         /* 
  1864.  * call external int controller connect
  1865.          tmpStat = cascadeIntConnect (vector, routine, parameter);
  1866.  */
  1867.         }
  1869.     if (tmpStat == ERROR)
  1870.         {
  1871.         logMsg ("Error in sysIntConnect: Connecting vector = %d.n",
  1872.                 (int)vector,2,3,4,5,6);
  1873.         }
  1875.     return(tmpStat);
  1876.     }
  1879. /*******************************************************************************
  1880. *
  1881. * sysIntEnable - enable an interrupt
  1882. *
  1883. * This function call is used to enable an interrupt.
  1884. *
  1885. * RETURNS: OK or ERROR if unable to enable interrupt.
  1886. *
  1887. * ERRNO: N/A
  1888. */
  1890. STATUS sysIntEnable
  1891.     (
  1892.     int intNum
  1893.     )
  1894.     {
  1895.     int tmpStat = ERROR;
  1896.     if (((int) intNum < 0) || ((int) intNum >= EXT_NUM_IRQ0 + EXT_MAX_IRQS))
  1897.         {
  1898.         logMsg ("Error in sysIntEnable: Out of range intNum = %d.n",
  1899.                 (int)intNum,2,3,4,5,6);
  1901.         return(ERROR);
  1902.         }
  1904.     if ((int) intNum < EXT_NUM_IRQ0)
  1905.         {
  1906.         tmpStat = intEnable (intNum);
  1907.         }
  1908.     else
  1909.         {
  1910.         /* call external int controller connect */
  1912.         tmpStat = sysCascadeIntEnable (intNum - EXT_NUM_IRQ0);
  1913.         }
  1915.     if (tmpStat == ERROR)
  1916.         {
  1917.         logMsg ("Error in sysIntEnable: intNum = %d.n",
  1918.                 (int)intNum,2,3,4,5,6);
  1919.         }
  1921.     return(tmpStat);
  1922.     }
  1924. /****************************************************************************
  1925. *
  1926. * sysCascadeIntEnable - enable an external controller interrupt
  1927. *
  1928. * This function call is used to enable an interrupt outside of the MPC8540 PIC.
  1929. *
  1930. * RETURNS: OK or ERROR if unable to enable interrupt.
  1931. *
  1932. * ERRNO: N/A
  1933. */
  1935. STATUS sysCascadeIntEnable
  1936.     (
  1937.     int intNum
  1938.     )
  1939.     {
  1940.     return(ERROR);
  1941.     }
  1943. /****************************************************************************
  1944. *
  1945. * sysIntDisable - disable an interrupt
  1946. *
  1947. * This function call is used to disable an interrupt.
  1948. *
  1949. * RETURNS: OK or ERROR if unable to disable interrupt.
  1950. *
  1951. * ERRNO: N/A
  1952. */
  1954. STATUS sysIntDisable
  1955.     (
  1956.     int intNum
  1957.     )
  1958.     {
  1959.     int tmpStat = ERROR;
  1960.     if (((int) intNum < 0) || ((int) intNum >= EXT_NUM_IRQ0 + EXT_MAX_IRQS))
  1961.         {
  1962.         logMsg ("Error in sysIntDisable: Out of range intNum = %d.n",
  1963.                 (int)intNum,2,3,4,5,6);
  1965.         return(ERROR);
  1966.         }
  1968.     if ((int) intNum < EXT_NUM_IRQ0)
  1969.         {
  1970.         tmpStat = intDisable (intNum);
  1971.         }
  1972.     else
  1973.         {
  1974.         /* call external int controller connect */
  1976.         tmpStat = sysCascadeIntDisable (intNum - EXT_NUM_IRQ0);
  1977.         }
  1980.     if (tmpStat == ERROR)
  1981.         {
  1982.         logMsg ("Error in sysIntDisable: intNum = %d.n",
  1983.                 (int)intNum,2,3,4,5,6);
  1984.         }
  1986.     return(tmpStat);
  1987.     }
  1989. /**************************************************************************
  1990. *
  1991. * sysCascadeIntDisable - disable an external controller interrupt
  1992. *
  1993. * This function call is used to disable an interrupt outside of the MPC8540 PIC.
  1994. *
  1995. * RETURNS: OK or ERROR if unable to disable interrupt.
  1996. *
  1997. * ERRNO: N/A
  1998. */
  2000. STATUS sysCascadeIntDisable
  2001.     (
  2002.     int intNum
  2003.     )
  2004.     {
  2005.     return(ERROR);
  2006.     }
  2008. #ifdef INCLUDE_CACHE_SUPPORT
  2009. /***********************************************************************
  2010. *
  2011. * sysL1CacheQuery - configure L1 cache size and alignment
  2012. *
  2013. * Populates L1 cache size and alignment from configuration registers.
  2014. *
  2015. * RETURNS: N/A
  2016. *
  2017. * ERRNO: N/A
  2018. */
  2020. LOCAL void sysL1CacheQuery(void)
  2021.     {
  2022.     UINT32 temp;
  2023.     UINT32 align;
  2024.     UINT32 cachesize;
  2026.     temp = vxL1CFG0Get();
  2028.     cachesize = (temp & 0xFF) << 10;
  2030.     align = (temp >> 23) & 0x3;
  2033.     switch (align)
  2034.         {
  2035.         case 0:
  2036.             ppcE500CACHE_ALIGN_SIZE=32;
  2037.             break;
  2038.         case 1:
  2039.             ppcE500CACHE_ALIGN_SIZE=64;
  2040.             break;
  2041.         default:
  2042.             ppcE500CACHE_ALIGN_SIZE=32;
  2043.             break;
  2044.         }
  2046.     ppcE500DCACHE_LINE_NUM = (cachesize / ppcE500CACHE_ALIGN_SIZE);
  2047.     ppcE500ICACHE_LINE_NUM = (cachesize / ppcE500CACHE_ALIGN_SIZE);
  2049.     /*
  2050.      * The core manual suggests for a 32 byte cache line and 8 lines per set
  2051.      * we actually need 12 unique address loads to flush the set.
  2052.      * The number of lines to flush should be ( 3/2 * cache lines )
  2053.      */
  2055.     ppcE500DCACHE_LINE_NUM = (3*ppcE500DCACHE_LINE_NUM)>>1;
  2056.     ppcE500ICACHE_LINE_NUM = (3*ppcE500ICACHE_LINE_NUM)>>1;
  2058.     }
  2060. #endif /* INCLUDE_CACHE_SUPPORT */
  2062. /***************************************************************************
  2063. *
  2064. * saveExcMsg - write exception message to save area for catastrophic error
  2065. *
  2066. * The message will be displayed upon rebooting with a bootrom.
  2067. *
  2068. * RETURNS: N/A
  2069. *
  2070. * ERRNO: N/A
  2071. */
  2073. void saveExcMsg
  2074.     (
  2075.     char *errorMsg
  2076.     )
  2077.     {
  2078.     strcpy ((char *)EXC_MSG_OFFSET, errorMsg);
  2079.     }
  2082. void chipErrataCpu29Print(void)
  2083.     {
  2084.     saveExcMsg("Silicon fault detected, possible machine state corruption.nSystem rebooted to limit damage.");
  2085.     }
  2089. /***************************************************************************
  2090. *
  2091. * vxImmrGet - get the CPM DPRAM base address
  2092. *
  2093. * This routine returns the CPM DP Ram base address for CPM device drivers.
  2094. *
  2095. * RETURNS:
  2096. *
  2097. * ERRNO: N/A
  2098. */
  2100. UINT32 vxImmrGet(void)
  2101.     {
  2102.     return(CCSBAR + 0x80000);
  2103.     }
  2105. /***************************************************************************
  2106. *
  2107. * sysGetPeripheralBase   - Provides CCSRBAR address fro security engine
  2108. *                          drivers.
  2109. *
  2110. * RETURNS:
  2111. *
  2112. * ERRNO: N/A
  2113. */
  2114. UINT32 sysGetPeripheralBase()
  2115.     {
  2116.     return(CCSBAR);
  2117.     }
  2119. #if defined (_GNU_TOOL)
  2120. void sysIntHandler (void)
  2121.     {
  2122.     }
  2124. void vxDecInt (void)
  2125.     {
  2126.     }
  2128. int excRtnTbl = 0;
  2129. #endif  /* _GNU_TOOL */
  2131. #ifdef INCLUDE_SHOW_ROUTINES
  2133. /***************************************************************************
  2134. *
  2135. * coreLbcShow - Show routine for local bus controller
  2136. *
  2137. * This routine shows the local bus controller registers.
  2138. *
  2139. * RETURNS: N/A
  2140. *
  2141. * ERRNO: N/A
  2142. */
  2144. void coreLbcShow(void)
  2145.     {
  2146.     VINT32 tmp, tmp2;
  2148.     tmp = * (VINT32 *) M85XX_BR0(CCSBAR);
  2149.     tmp2 = * (VINT32 *) M85XX_OR0(CCSBAR);
  2150.     printf("Local bus BR0 = 0x%xtOR0 = 0x%xn", tmp, tmp2);
  2152.     tmp = * (VINT32 *) M85XX_BR1(CCSBAR);
  2153.     tmp2 = * (VINT32 *) M85XX_OR1(CCSBAR);
  2154.     printf("Local bus BR1 = 0x%xtOR1 = 0x%xn", tmp, tmp2);
  2156.     tmp = * (VINT32 *) M85XX_BR2(CCSBAR);
  2157.     tmp2 = * (VINT32 *) M85XX_OR2(CCSBAR);
  2158.     printf("Local bus BR2 = 0x%xtOR2 = 0x%xn", tmp, tmp2);
  2160.     tmp = * (VINT32 *) M85XX_BR3(CCSBAR);
  2161.     tmp2 = * (VINT32 *) M85XX_OR3(CCSBAR);
  2162.     printf("Local bus BR3 = 0x%xtOR3 = 0x%xn", tmp, tmp2);
  2164.     tmp = * (VINT32 *) M85XX_BR4(CCSBAR);
  2165.     tmp2 = * (VINT32 *) M85XX_OR4(CCSBAR);
  2166.     printf("Local bus BR4 = 0x%xtOR4 = 0x%xn", tmp, tmp2);
  2168.     tmp = * (VINT32 *) M85XX_BR5(CCSBAR);
  2169.     tmp2 = * (VINT32 *) M85XX_OR5(CCSBAR);
  2170.     printf("Local bus BR5 = 0x%xtOR5 = 0x%xn", tmp, tmp2);
  2172.     tmp = * (VINT32 *) M85XX_BR6(CCSBAR);
  2173.     tmp2 = * (VINT32 *) M85XX_OR6(CCSBAR);
  2174.     printf("Local bus BR6 = 0x%xtOR6 = 0x%xn", tmp, tmp2);
  2176.     tmp = * (VINT32 *) M85XX_BR7(CCSBAR);
  2177.     tmp2 = * (VINT32 *) M85XX_OR7(CCSBAR);
  2178.     printf("Local bus BR7 = 0x%xtOR7 = 0x%xn", tmp, tmp2);
  2180.     tmp = * (VINT32 *) M85XX_LBCR(CCSBAR);
  2181.     printf("Local bus LBCR = 0x%xn", tmp);
  2183.     tmp = * (VINT32 *) M85XX_LCRR(CCSBAR);
  2184.     printf("Local bus LCRR = 0x%xn", tmp);
  2185.     }
  2187.     #define xbit0(x, n)    ((x & (1 << (31 - n))) >> (31 - n))  /* 0..31 */
  2188.     #define xbit32(x, n)   ((x & (1 << (63 - n))) >> (63 - n))  /* 32..63 */
  2189.     #define onoff0(x, n)   xbit0(x, n) ? "ON", "OFF"
  2190.     #define onoff32(x, n)  xbit32(x, n) ? "ON", "OFF"
  2192. /***************************************************************************
  2193. *
  2194. * coreShow - Show routine for core registers
  2195. *
  2196. * This routine shows the core registers.
  2197. *
  2198. * RETURNS: N/A
  2199. *
  2200. * ERRNO: N/A
  2201. */
  2203. void coreShow(void)
  2204.     {
  2205.     VUINT32 tmp, tmp2;
  2207.     tmp = vxMsrGet();
  2208.     printf("MSR - 0x%xn", tmp);
  2209.     printf("      UCLE-%x SPE-%x WE-%x CE-%x EE-%x PR-%x ME-%xn",
  2210.            xbit32(tmp,37), xbit32(tmp,38), xbit32(tmp,45), xbit32(tmp,46),
  2211.            xbit32(tmp,48), xbit32(tmp,49), xbit32(tmp,51));
  2212.     printf("      UBLE-%x DE-%x IS-%x DS-%x PMM-%xn",
  2213.            xbit32(tmp,53), xbit32(tmp,54), xbit32(tmp,58), xbit32(tmp,59),
  2214.            xbit32(tmp,61));
  2215.     tmp = vxHid0Get();
  2216.     tmp2 = vxHid1Get();
  2217.     printf("HID0 = 0x%x, HID1 = 0x%xn", tmp, tmp2);
  2218.     tmp = vxL1CSR0Get();
  2219.     printf("L1CSR0: cache is %s - 0x%xn", tmp&1?"ON":"OFF", tmp);
  2220.     tmp = vxL1CSR1Get();
  2221.     printf("L1CSR1: Icache is %s - 0x%xn", tmp&1?"ON":"OFF", tmp);
  2222.     tmp = vxL1CFG0Get();
  2223.     tmp2 = vxL1CFG1Get();
  2224.     printf("L1CFG0 = 0x%x, L1CFG1 = 0x%xn", tmp, tmp2);
  2225.     tmp = *(VUINT32 *) (CCSBAR + 0x20000);
  2226.     printf("L2CTL - 0x%xn", tmp);
  2227.     printf("        l2 is %sn", tmp&0x80000000?"ON":"OFF");
  2228.     printf("        l2siz-%x l2blksz-%x l2do-%x l2io-%xn",
  2229.            (xbit0(tmp,2)<<1)|xbit0(tmp,3), (xbit0(tmp,4)<<1)|xbit0(tmp,5),
  2230.            xbit0(tmp,9), xbit0(tmp,10));
  2231.     printf("        l2pmextdis-%x l2intdis-%x l2sram-%xn",
  2232.            xbit0(tmp,11), xbit0(tmp,12),
  2233.            (xbit0(tmp,13)<<2)|(xbit0(tmp,14)<<1)|xbit0(tmp,15));
  2234.     tmp = *(VUINT32 *) (CCSBAR + 0x20100);
  2235.     tmp2 = *(VUINT32 *) (CCSBAR + 0x20108);
  2236.     printf("L2SRBAR0 - 0x%xn", tmp);
  2237.     printf("L2SRBAR1 - 0x%xn", tmp2);
  2239.     printf("Core Freq = %3d Hzn",coreFreq);
  2240.     printf("CCB Freq = %3d Hzn",sysClkFreqGet());
  2241.     printf("PCI Freq = %3d Hzn",OSCILLATOR_FREQ);
  2242.     printf("CPM Freq = %3d Hzn",sysClkFreqGet());
  2244.     }
  2246. #endif
  2248. int sysVectorIRQ0 = 0;
  2249. void
  2250. sysReboot(void)
  2251. {
  2252.     int level;
  2254.      level = intLock();
  2255.      * (VINT32 *) M85XX_GPOUTDR(CCSBAR) = ~0x0;
  2256.      * (VINT32 *) M85XX_GPIOCR(CCSBAR) = 0x200;
  2257.      * (VINT32 *) M85XX_GPOUTDR(CCSBAR) &= ~(BCM98548XMC_SYS_RESET);
  2258.      sysMsDelay(500); /* 500 ms delay */
  2259.      * (VINT32 *) M85XX_GPOUTDR(CCSBAR) &=
  2260.                          ~(BCM98548XMC_SYS_RESET| BCM98548XMC_CPU_RESET);
  2261.      for(;;);
  2262. }
  2264. UINT8 sysBoardRev()
  2265. {
  2266.     UINT8 board_id;
  2268.     board_id = 0;
  2270. #ifdef INCLUDE_I2C_DEV
  2271.     if (pcf8574_boardid_get(&board_id) == 0) {
  2272.         return board_id; 
  2273.     }
  2274. #endif
  2276.     return 0;
  2277. }
  2279. STATUS sysRtcGet (struct tm * time)
  2280. {
  2281.     int year, month, date, hour, min, sec;
  2282.     STATUS status;
  2283.  
  2284.     status = ERROR;
  2286. #ifdef INCLUDE_I2C_DEV
  2287.     status = m41t81_tod_get(&year, &month, &date, &hour, &min, &sec);
  2289.     if (status == 0) {
  2290.         time->tm_sec   = sec;
  2291.         time->tm_min   = min;
  2292.         time->tm_hour  = hour;
  2293.         time->tm_mday  = date;
  2294.         time->tm_mon   = month - 1;  /* POSIX needs 0-11 */ 
  2295.         time->tm_year  = year - 1900;
  2296.         time->tm_yday  = 0;          /* unknown */
  2297.         time->tm_isdst = 0;          /* unknown */
  2298.     }
  2299. #endif /* INCLUDE_I2C_DEV */
  2300.     return status;
  2301. }
  2303. void
  2304. pcieShow(int min_bus, int max_bus)
  2305. {
  2306. #define P_MIN_BUS       min_bus
  2307. #define P_MAX_BUS       max_bus
  2308. #define P_MAX_DEV       31
  2309. #define P_MAX_FUNC      0
  2310. #define P_MAX_OFFSET    (0x80 -1)
  2311. #define FOR_EACH_LOOP(curr_id, min_id, max_id, incr_id) 
  2312.         for(curr_id = min_id; curr_id <= max_id; curr_id += incr_id)
  2314.     int bus, devid, func, offset, val, dev_max;
  2316.     printf("BS DV FN OF VALUEn");
  2317.     FOR_EACH_LOOP(bus, P_MIN_BUS, P_MAX_BUS, 1) {
  2318.         dev_max = (bus < PCIEX_BUS_MIN) ? P_MAX_DEV : 0;
  2319.         FOR_EACH_LOOP(devid, 0, dev_max, 1) {
  2320.             FOR_EACH_LOOP(func, 0, P_MAX_FUNC, 1) {
  2321.                 FOR_EACH_LOOP(offset, 0, P_MAX_OFFSET, 4) {
  2322.                     pciConfigInLong(bus, devid, func, offset, &val);
  2323.                     if (val == 0xffffffff) {
  2324.                         break;
  2325.                     }
  2326.                     printf("%02d %02d %02d %02X %08Xn",
  2327.                                 bus, devid, func, offset, val);
  2328.                 }
  2329.             }
  2330.         }
  2331.     }
  2332. }
  2334. void sysPcieConfigShow()
  2335. {
  2336.     int busNo;
  2337.     int devNo;
  2338.     int funcNo;
  2339.     int data;
  2340.     int offset;
  2342.     busNo  = PCIEX_BUS_MIN + 0;
  2343.     devNo  = 0;
  2344.     funcNo = 0;
  2346.     sysPciConfigEnable (CDS85XX_PCIEX_BUS);
  2347.     for (offset = 0; offset <= 0x7c; offset = offset + 4) {
  2348.        if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2349.            printf("offset 0x%08x = 0x%08xn", offset, data);
  2350.        } else {
  2351.            printf("sysPciConfigRead error.n");
  2352.            break;
  2353.        }
  2354.     }
  2356.     printf("PCI-E Extended Configuration Spacen");
  2357.     for (offset = 0x100; offset <= 0x134; offset = offset + 4) {
  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.n");
  2362.            break;
  2363.        }
  2364.     }
  2366.     offset = 0x404;
  2367.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2368.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2369.     } else {
  2370.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2371.     }
  2372.     offset = 0x440;
  2373.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2374.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2375.     } else {
  2376.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2377.     }
  2378.     offset = 0x450;
  2379.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2380.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2381.     } else {
  2382.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2383.     }
  2384.     offset = 0x454;
  2385.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2386.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2387.     } else {
  2388.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2389.     }
  2390.     offset = 0x478;
  2391.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2392.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2393.     } else {
  2394.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2395.     }
  2396.     offset = 0x4b0;
  2397.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2398.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2399.     } else {
  2400.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2401.     }
  2402.     offset = 0x590;
  2403.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2404.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2405.     } else {
  2406.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2407.     }
  2408.     offset = 0x5a0;
  2409.     if (sysPciConfigRead(busNo, devNo, funcNo, offset, 4, &data)== OK) {
  2410.        printf("offset 0x%08x = 0x%08xn", offset, data);
  2411.     } else {
  2412.        printf("sysPciConfigRead error offset 0x%08x.n", offset);
  2413.     }
  2414. }
  2417. static char * e500_ratio[] = {"reserved", "reserved", "1:1", "3:2",
  2418.                              "2:1", "5:2", "3:1", "7:2", "4:1", "9:2",
  2419.                              "reserved", "reserved", "reserved", "reserved",
  2420.                              "reserved", "reserved" };
  2421. static char * tsec_protocol[] = {"FIFO", "MII", "GMII", "TBI"};                        
  2422. static char * io_sel[] = {"reserved", "reserved", "reserved",
  2423.                           "x4 RIO 2.5Gbps, x4 PCI-E", 
  2424.                           "x4 RIO 1.25Gbps, x4 PCI-E", 
  2425.                           "x4 RIO 3.125Gbps", 
  2426.                           "x4 RIO 1.25Gbps", 
  2427.                           "x8 PCI-E"};
  2428. static char * if_mode[] = {"reserved", "10/100 Mbps MII/RMII",
  2429.                            "1000 Mbps GMII/TBI", "resvered"};
  2430. void sysPorStatShow()
  2431. {
  2432.     UINT reg;
  2433.     int  field; 
  2434.     
  2435.     reg = *M85XX_PORPLLSR(CCSBAR);
  2436.     field = (reg >> 16) & 0xf;
  2437.     printf("e500_ratio = %sn", e500_ratio[field]);
  2438.     field = (reg >> 15) & 1;
  2439.     printf("PCI1_clk_sel = %sn", field ? "SYS_CLK" : "PCI1_CLK");
  2440.     field = (reg >> 14) & 1;
  2441.     printf("PCI2_clk_sel = %sn", field ? "SYS_CLK" : "PCI2_CLK");
  2442.     field = (reg >> 1) & 0xf;
  2443.     printf("Plat_Ratio = %d : 1n", field);
  2445.     reg = *M85XX_PORBMSR(CCSBAR);
  2446.     field = (reg >> 31) & 1;
  2447.     printf("BCFG = %sn", field ? "CPU immediate boot" : "CPU wait to boot");
  2449.     reg = *M85XX_PORDEVSR(CCSBAR);
  2450.     field = (reg >> 31) & 1;
  2451.     printf("eTSEC1 and eTSEC2 in %s interface moden", 
  2452.            field ? "full" : "reduced");
  2453.     field = (reg >> 30) & 1;
  2454.     printf("eTSEC3 and eTSEC4 in %s interface moden",
  2455.            field ? "full" : "reduced");
  2456.     field = (reg >> 24) & 3;
  2457.     printf("eTSEC1 operates in %s moden", tsec_protocol[field]); 
  2458.     field = (reg >> 12) & 3;
  2459.     printf("eTSEC2 operates in %s moden", tsec_protocol[field]); 
  2460.     field = (reg >> 10) & 3;
  2461.     printf("eTSEC3 operates in %s moden", tsec_protocol[field]); 
  2462.     field = (reg >> 8) & 3;
  2463.     printf("eTSEC4 operates in %s moden", tsec_protocol[field]); 
  2464.     field = (reg >> 19) & 0xf;
  2465.     printf("%sn", io_sel[field]);
  2467.     reg = *M85XX_PORDEVSR2(CCSBAR);
  2468.     field = (reg >> 2) & 1;
  2469.     printf("Serdes %sn", field ? "enabled" : "disabled");
  2470. }
  2472. void extIsr(int id) {
  2473.     logMsg("Interrupt %dn", id, 0, 0, 0, 0, 0);
  2474. }
  2476. void installExtInt()
  2477. {
  2479.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 4), (VOIDFUNCPTR)extIsr, 4);
  2480.     sysEpicIntEnable((EXT_VEC_IRQ0 + 4));
  2482.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 5), (VOIDFUNCPTR)extIsr, 5);
  2483.     sysEpicIntEnable((EXT_VEC_IRQ0 + 5));
  2485.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 6), (VOIDFUNCPTR)extIsr, 6);
  2486.     sysEpicIntEnable((EXT_VEC_IRQ0 + 6));
  2488.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 7), (VOIDFUNCPTR)extIsr, 7);
  2489.     sysEpicIntEnable((EXT_VEC_IRQ0 + 7));
  2491.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 10), (VOIDFUNCPTR)extIsr, 10);
  2492.     sysEpicIntEnable((EXT_VEC_IRQ0 + 10));
  2494.     sysEpicIntConnect((VOIDFUNCPTR *)(EXT_VEC_IRQ0 + 11), (VOIDFUNCPTR)extIsr, 11);
  2495.     sysEpicIntEnable((EXT_VEC_IRQ0 + 11));
  2496. }
  2498. void gpoutSet(int pin, int val)
  2499. {
  2500.     int  key;
  2501.     UINT reg;
  2503.     key = intLock();
  2505.     reg = *M85XX_GPOUTDR(CCSBAR);
  2507.     if (val) {
  2508.         reg |= (0x80000000 >> pin);
  2509.     } else {
  2510.         reg &= ~(0x80000000 >> pin);
  2511.     } 
  2513.     *M85XX_GPOUTDR(CCSBAR) = reg;
  2514.     intUnlock(key);
  2516. }
  2518. void gpinGet()
  2519. {
  2520.     UINT reg;
  2522.     reg = *M85XX_GPINDR(CCSBAR);
  2524.     printf("PMC_EREADY = %dn", (reg & ( 1 << 16)) ? 1 : 0); 
  2525.     printf("~P4_PRST  = %dn", (reg & ( 1 << 17)) ? 1 : 0); 
  2526.     printf("~XMC_PRST = %dn", (reg & ( 1 << 18)) ? 1 : 0); 
  2527.     printf("FLASH_SEL = %dn", (reg & ( 1 << 19)) ? 1 : 0); 
  2528.     printf("XMC_ROOT0 = %dn", (reg & ( 1 << 20)) ? 1 : 0); 
  2529.     printf("PMC_MONARCH = %dn", (reg & ( 1 << 21)) ? 1 : 0); 
  2530.     printf("GPIO0 = %dn", (reg & ( 1 << 22)) ? 1 : 0); 
  2531.     printf("GPIN5 = %dn", (reg & ( 1 << 23)) ? 1 : 0); 
  2532.  
  2534. }
  2536. void autoconfig_done()
  2537. {
  2538.    printf("pci_autoconfig_done = %dn", pci_autoconfig_done);
  2539. }
  2541. void pcieLinkPoll()
  2542. {
  2543.     int poll_count;
  2544.     int data;
  2545.     for(poll_count=1; poll_count <=1000; poll_count++) {
  2546.         if (sysPciConfigRead(128, 0, 0, 0x404, 4, &data)== OK) {
  2547.             if (data != 0x16) {
  2548.                 printf("Link down on %d polln");
  2549.             }
  2550.         } else {
  2551.             printf("(sysPciConfigRead(128, 0, 0, 0x404, 4, &data) Failedn");
  2552.         }
  2553.     }
  2554. }
  2556. void sysTsecShow(int dev)
  2557. {
  2558.     UINT offset; 
  2559.     UINT maccfg1, maccfg2, ecntrl;
  2560.     int  field;
  2562.         offset = dev * 0x1000;
  2563.         maccfg1 = *M85XX_MACCFG1(CCSBAR + offset);
  2564.         maccfg2 = *M85XX_MACCFG2(CCSBAR + offset);
  2565.         ecntrl  = *M85XX_ECNTRL(CCSBAR + offset);
  2567.         printf("nPort %dn", dev);
  2568.         /* MACCFG 1 */
  2569.         printf("MACCFG1 = 0x%08xn", maccfg1);
  2570.   
  2571.         field = (maccfg1 >> 31) & 1;
  2572.         printf("Soft_Reset   = %dn", field);
  2574.         field = (maccfg1 >> 19) & 1;
  2575.         printf("Reset Rx MC  = %dn", field);
  2577.         field = (maccfg1 >> 18) & 1;
  2578.         printf("Reset Tx MC  = %dn", field);
  2580.         field = (maccfg1 >> 17) & 1;
  2581.         printf("Reset Rx Fun = %dn", field);
  2583.         field = (maccfg1 >> 16) & 1;
  2584.         printf("Reset Rx Fun = %dn", field);
  2586.         field = (maccfg1 >> 8) & 1;
  2587.         printf("Loopback     = %dn", field);
  2589.         field = (maccfg1 >> 5) & 1;
  2590.         printf("Rx_Flow      = %dn", field);
  2592.         field = (maccfg1 >> 4) & 1;
  2593.         printf("Tx_Flow      = %dn", field);
  2595.         field = (maccfg1 >> 3) & 1;
  2596.         printf("Sync'd Rx EN = %dn", field);
  2598.         field = (maccfg1 >> 2) & 1;
  2599.         printf("Rx_EN        = %dn", field);
  2601.         field = (maccfg1 >> 1) & 1;
  2602.         printf("Sync'd Tx EN = %dn", field);
  2604.         field = (maccfg1 >>  0) & 1;
  2605.         printf("Tx_EN        = %dn", field);
  2607.         /* MACCFG2 */
  2608.         printf("MACCFG2 = 0x%08xn", maccfg2);
  2610.         field = (maccfg2 >>  16) & 0xf;
  2611.         printf("Preamble     = %dn", field);
  2613.         field = (maccfg2 >>  8) & 3;
  2614.         printf("I/F Mode     = %sn", if_mode[field]);
  2616.         field = (maccfg2 >>  3) & 1;
  2617.         printf("MPEN         = %dn", field);
  2619.         field = (maccfg2 >>  2) & 1;
  2620.         printf("PAD/CRC      = %dn", field);
  2622.         field = (maccfg2 >>  1) & 1;
  2623.         printf("CRC EN       = %dn", field);
  2625.         field = (maccfg2 >>  0) & 1;
  2626.         printf("Full Duplex  = %dn", field);
  2628.         /* ECNTRL */
  2629.         printf("ECNTRL = 0x%08xn", ecntrl);
  2631.         field = (ecntrl >>  15) & 1;
  2632.         printf("FIFM         = %dn", field);
  2634.         field = (ecntrl >>  14) & 1;
  2635.         printf("CLRCNT       = %dn", field);
  2637.         field = (ecntrl >>  13) & 1;
  2638.         printf("AUTOZ        = %dn", field);
  2640.         field = (ecntrl >>  12) & 1;
  2641.         printf("STEN         = %dn", field);
  2643.         field = (ecntrl >>  6) & 1;
  2644.         printf("GMIIM        = %dn", field);
  2646.         field = (ecntrl >>  5) & 1;
  2647.         printf("TBIM         = %dn", field);
  2649.         field = (ecntrl >>  4) & 1;
  2650.         printf("RPM          = %dn", field);
  2652.         field = (ecntrl >>  3) & 1;
  2653.         printf("R100M        = %dn", field);
  2655.         field = (ecntrl >>  2) & 1;
  2656.         printf("RMM          = %dn", field);
  2657. }
  2659. void sysTsecSetup(int speed)
  2660. {
  2661.     UINT offset; 
  2662.     UINT maccfg2, ecntrl;
  2663.     int  dev;
  2666.     if (speed == 10 || speed == 100) {
  2667.         for (dev = 0; dev < 4; dev++) {
  2668.             offset = dev * 0x1000;
  2669.             maccfg2 = *M85XX_MACCFG2(CCSBAR + offset);
  2670.             maccfg2 &= ~0x300;
  2671.             maccfg2 |= 0x100;
  2672.             *M85XX_MACCFG2(CCSBAR + offset) = maccfg2;
  2674.             ecntrl = *M85XX_ECNTRL(CCSBAR + offset);
  2675.             ecntrl &= ~0x38;
  2676.             ecntrl |= (speed == 10) ? 0x10 : 0x18;
  2677.             *M85XX_ECNTRL(CCSBAR + offset) = ecntrl; 
  2678.         }
  2679.     }
  2681.     if (speed == 1000) {
  2682.         for (dev = 0; dev < 4; dev++) {
  2683.             offset = dev * 0x1000;
  2684.             maccfg2 = *M85XX_MACCFG2(CCSBAR + offset);
  2685.             maccfg2 &= ~0x300;
  2686.             maccfg2 |= 0x200;
  2687.             *M85XX_MACCFG2(CCSBAR + offset) = maccfg2;
  2689.             ecntrl = *M85XX_ECNTRL(CCSBAR + offset);
  2690.             ecntrl &= ~0x38;
  2691.             ecntrl |= 0x10;
  2692.             *M85XX_ECNTRL(CCSBAR + offset) = ecntrl; 
  2693.         }
  2694.  
  2695.     }
  2696. }
  2698. #ifdef INCLUDE_SYS_HW_INIT_0
  2699. IMPORT BOOL excExtendedVectors;
  2700. /***************************************************************************
  2701. *
  2702. * SYS_HW_INIT_0 - test for extended vectors
  2703. *
  2704. * This routine is used for testing extended vectors.
  2705. *
  2706. * RETURNS: N/A
  2707. *
  2708. * ERRNO
  2709. */
  2711. void SYS_HW_INIT_0 (void)
  2712.     {
  2713.     excExtendedVectors = TRUE;
  2714.     }
  2715. #endif  /* INCLUDE_SYS_HW_INIT_0 */