| /* |
| <:copyright-BRCM:2016:DUAL/GPL:standard |
| |
| Broadcom Proprietary and Confidential.(c) 2016 Broadcom |
| All Rights Reserved |
| |
| Unless you and Broadcom execute a separate written software license |
| agreement governing use of this software, this software is licensed |
| to you under the terms of the GNU General Public License version 2 |
| (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php, |
| with the following added to such license: |
| |
| As a special exception, the copyright holders of this software give |
| you permission to link this software with independent modules, and |
| to copy and distribute the resulting executable under terms of your |
| choice, provided that you also meet, for each linked independent |
| module, the terms and conditions of the license of that module. |
| An independent module is a module which is not derived from this |
| software. The special exception does not apply to any modifications |
| of the software. |
| |
| Not withstanding the above, under no circumstances may you combine |
| this software in any way with any other Broadcom software provided |
| under a license other than the GPL, without Broadcom's express prior |
| written consent. |
| |
| :> |
| */ |
| |
| #include <vxWorks.h> |
| #include <drv/pci/pciConfigLib.h> |
| #include "bcmolt_llpcie.h" |
| |
| /* Define PCIE device BAR registers */ |
| #define BAR_REGS 0 |
| #define BAR_DDR 2 |
| #define BAR_SRAM 4 |
| |
| /* |
| Define PCIE device BAR space length: |
| bar 1 = 8 Mbyte register space |
| bar 2 = 16 Mbyte DDR space |
| bar 3 = 64 Kbyte SRAM space |
| */ |
| #define MAPLE_REGS_LENGTH 0x00800000 |
| #define MAPLE_DDR_LENGTH 0x01000000 |
| #define MAPLE_SRAM_LENGTH 0x00010000 |
| |
| /* Define special registers address */ |
| #ifdef TX_ENABLE_EVENT_TRACE |
| #define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_LO 0x064014U |
| #define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_HI 0x064018U |
| #define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_BASE_LIMIT 0x064074U |
| #endif |
| #define PCIE_REVISION_REGISTER_OFFSET 0x6406C /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_REVISION */ |
| #define PCIE_STATUS_REGISTER_OFFSET 0x64068 /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_PCIE_STATUS */ |
| #define PCIE_HARD_DEBUG_REGISTER_OFFSET 0x64204U /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_HARD_DEBUG */ |
| #define PCIE_INT_STATUS_REGISTER_OFFSET 0x69400 /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_STATUS */ |
| #define PCIE_INT_CLEAR_MASK_OFFSET 0x6940C /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_MASK_CLEAR */ |
| #define PCIE_INTR1_STATUS_REGISTER_OFFSET 0x69300 /* Interrupt Status Register */ |
| |
| /* Maple device ID */ |
| #define PCIE_MAPLE_VENDOR_ID 0x14E4 /* PCIE_CFG_TYPE0_EP_SUBSYSTEM_ID_VENDOR_ID */ |
| #define PCIE_MAPLE_DEVICE_ID 0x6862 |
| #define PCIE_MAPLE_6863_SKU_DEVICE_ID 0x6863 |
| #define PCIE_MAPLE_EPON_DEVICE_ID 0x5554 |
| |
| /* Define interrupt vector number according BCM53003 BSP */ |
| #define PCIE1_IV_0 86 |
| #define PCIE1_IV_1 87 |
| #define PCIE1_INT_LINE 4 |
| |
| /* Maple device object struct */ |
| typedef struct |
| { |
| bcm_ll_dev_info device; |
| bcmos_fastlock lock; |
| int err_status; |
| int phylink; |
| int prev_datalink; |
| int datalink; |
| uint32_t deviceid; // start from 0 |
| unsigned int *traceaddr; |
| void *pdev; |
| int pciBusNo; /* PCI bus number */ |
| int pciDevNo; /* PCI device number */ |
| int pciFuncNo; /* PCI function number */ |
| uint32_t dev_status_irq; |
| } maple_device_info; |
| |
| /* Maple device objects */ |
| static maple_device_info devices[MAPLE_MAX_DEVICES]; |
| int crt_device = 0; |
| |
| /* Device PCIE interface status change callback */ |
| static bcm_ll_pcie_status_change callback; |
| |
| /** Device status change ISR |
| * \irq IRQ number |
| * \dev_instance device object |
| */ |
| int dev_status_interrupt (int irq, void *dev_instance) |
| { |
| bcmos_errno err = BCM_ERR_OK; |
| uint32_t reg_value = 0; |
| maple_device_info *device_info = NULL; |
| long flags = 0; |
| int handled = 0; |
| uint32_t dev_id = 0; |
| |
| device_info = (maple_device_info *)dev_instance; |
| dev_id = device_info->deviceid; |
| |
| flags = bcmos_fastlock_lock(&device_info->lock); |
| |
| reg_value = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_INT_STATUS_REGISTER_OFFSET)); |
| { |
| if (device_info->datalink != device_info->prev_datalink) |
| { |
| if (device_info->datalink == BCM_LL_PCIE_LINK_UP) |
| printf("Device=%d : Link is up !!!\n", dev_id); |
| else |
| { |
| printf("Device=%d : Link is down !!!\n", dev_id); |
| printf("phy status = 0x%x error status = 0x%x\n", device_info->phylink, device_info->err_status); |
| } |
| device_info->prev_datalink = device_info->datalink; |
| if (callback) |
| { |
| callback(dev_id, device_info->datalink); |
| } |
| } |
| reg_value = bcm_pci_read32( |
| (uint32_t *)(device_info->device.soc_regs_base + PCIE_INTR1_STATUS_REGISTER_OFFSET)); |
| { |
| handled = 1; |
| } |
| } |
| |
| bcmos_fastlock_unlock(&device_info->lock, flags); |
| |
| return handled; |
| } |
| |
| /** Maple device detection and initialization |
| */ |
| bcmos_errno bcm_ll_pcie_interface_init() |
| { |
| STATUS ret_status; |
| maple_device_info *dev_info = NULL; |
| uint32_t readval = 0; |
| uint8_t readvalb = 0; |
| bcmos_errno err = BCM_ERR_OK; |
| uint8_t irq = 0; |
| uint16_t device_id; |
| |
| printf("%s()\r\n", __FUNCTION__); |
| |
| // check maple device number |
| if (crt_device == MAPLE_MAX_DEVICES) |
| { |
| printf(" Maximum Maple devices already defined (%d)\n", MAPLE_MAX_DEVICES); |
| return BCM_ERR_ALREADY; |
| } |
| // Init device object struct |
| dev_info = &devices[crt_device++]; |
| memset(dev_info, 0, sizeof(maple_device_info)); |
| |
| // find maple 6862 device |
| ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID, |
| PCIE_MAPLE_DEVICE_ID, |
| 0, |
| &dev_info->pciBusNo, |
| &dev_info->pciDevNo, |
| &dev_info->pciFuncNo); |
| |
| if (OK == ret_status) |
| { |
| device_id = PCIE_MAPLE_DEVICE_ID; |
| goto found_device_id; |
| } |
| |
| // find maple 6863 device |
| ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID, |
| PCIE_MAPLE_6863_SKU_DEVICE_ID, |
| 0, |
| &dev_info->pciBusNo, |
| &dev_info->pciDevNo, |
| &dev_info->pciFuncNo); |
| |
| if (OK == ret_status) |
| { |
| device_id = PCIE_MAPLE_6863_SKU_DEVICE_ID; |
| goto found_device_id; |
| } |
| |
| // find maple epon device |
| ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID, |
| PCIE_MAPLE_EPON_DEVICE_ID, |
| 0, |
| &dev_info->pciBusNo, |
| &dev_info->pciDevNo, |
| &dev_info->pciFuncNo); |
| |
| if (OK == ret_status) |
| { |
| device_id = PCIE_MAPLE_EPON_DEVICE_ID; |
| goto found_device_id; |
| } |
| |
| printf("Can't find any device[%d]\n", PCIE_MAPLE_VENDOR_ID); |
| return BCM_ERR_NODEV; |
| |
| found_device_id: |
| printf("Found maple device[%x - %x]\n", PCIE_MAPLE_VENDOR_ID, device_id); |
| |
| // init |
| dev_info->deviceid = (crt_device - 1); |
| dev_info->pdev = NULL; |
| |
| |
| // Enable PCI address map |
| pciConfigInByte(dev_info->pciBusNo, |
| dev_info->pciDevNo, |
| dev_info->pciFuncNo, |
| PCI_CFG_COMMAND, |
| (UINT8 *)&readvalb); |
| printf("CMD reg = 0x%x\n", readvalb); |
| |
| readvalb |= 0x6; |
| pciConfigOutByte(dev_info->pciBusNo, |
| dev_info->pciDevNo, |
| dev_info->pciFuncNo, |
| PCI_CFG_COMMAND, |
| (UINT8)readvalb); |
| |
| pciConfigInByte(dev_info->pciBusNo, |
| dev_info->pciDevNo, |
| dev_info->pciFuncNo, |
| PCI_CFG_COMMAND, |
| (UINT8 *)&readvalb); |
| printf("Adjusted CMD reg = 0x%x\n", readvalb); |
| |
| // Init base addresses |
| dev_info->device.soc_regs_base = 0xe0000000; |
| dev_info->device.soc_sram_base = 0xe2000000; |
| dev_info->device.soc_ddr_base = 0xe1000000; |
| dev_info->device.soc_ddr_length = 0x1000000; // 16M |
| |
| // init interrupt line |
| readvalb = PCIE1_INT_LINE; |
| pciConfigOutByte(dev_info->pciBusNo, |
| dev_info->pciDevNo, |
| dev_info->pciFuncNo, |
| PCI_CFG_DEV_INT_LINE, |
| (UINT8)readvalb); |
| pciConfigInByte(dev_info->pciBusNo, |
| dev_info->pciDevNo, |
| dev_info->pciFuncNo, |
| PCI_CFG_DEV_INT_LINE, |
| (UINT8 *)&readvalb); |
| printf("Adjusted INT Line reg = 0x%x\n", readvalb); |
| |
| // init interrupt |
| dev_info->device.irq = PCIE1_IV_0; |
| dev_info->dev_status_irq = PCIE1_IV_1; |
| |
| // read revision register |
| readval = bcm_pci_read32((uint32_t *)(dev_info->device.soc_regs_base + PCIE_REVISION_REGISTER_OFFSET)); |
| printf("readval = 0x%x\n", readval); |
| printf("Card %d version major=%02x minor=%02x\n", |
| dev_info->deviceid, |
| ((readval & 0x0000ff00) >> 8), |
| (readval & 0x000000ff)); |
| |
| // read status register |
| readval = bcm_pci_read32((uint32_t *)(dev_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET)); |
| printf("readval = 0x%x\n", readval); |
| dev_info->err_status = (readval & 0x0000000f); |
| dev_info->phylink = ((readval >> 4) & 0x1); |
| dev_info->datalink = ((readval >> 5) & 0x1); |
| dev_info->prev_datalink = dev_info->datalink; |
| |
| // connect INT for device status |
| bcmos_fastlock_init(&dev_info->lock, 0); |
| bcmos_int_connect((int)dev_info->dev_status_irq, |
| 0, |
| BCMOS_IRQ_SHARED, |
| dev_status_interrupt, |
| "status_isr", |
| dev_info); |
| |
| return BCM_ERR_OK; |
| } |
| |
| /** Get Maple device object struct |
| * \crt devie index,start from 0 |
| */ |
| static maple_device_info *get_maple_pci_info(int crt) |
| { |
| bcmos_errno err = BCM_ERR_OK; |
| uint32_t readval = 0; |
| maple_device_info *device_info = NULL; |
| |
| /* check input parameter */ |
| if (MAPLE_MAX_DEVICES <= crt) |
| { |
| return NULL; |
| } |
| device_info = &devices[crt]; |
| |
| /* read status register */ |
| readval = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET)); |
| device_info->err_status = (readval & 0x0000000f); |
| device_info->phylink = ((readval >> 4) & 0x1); |
| device_info->datalink = ((readval >> 5) & 0x1); |
| |
| /* return device */ |
| return device_info; |
| } |
| |
| /** Register status change notification callback |
| * \param[in] cb Status change notification callback |
| * \return 0=OK or error <0 |
| */ |
| bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb) |
| { |
| int i; |
| maple_device_info *dev_info; |
| |
| callback = cb; |
| for (i = 0; i < crt_device; i++) |
| { |
| dev_info = get_maple_pci_info(i); |
| callback(i, dev_info->datalink); |
| } |
| |
| return BCM_ERR_OK; |
| } |
| |
| /** Unregister status change notification callback |
| * \return 0=OK or error <0 |
| */ |
| bcmos_errno bcm_ll_pcie_status_change_unregister(void) |
| { |
| callback = NULL; |
| |
| return BCM_ERR_OK; |
| } |
| |
| /** Query PCIe device |
| * \param[in] dev_id Device id |
| * \param[out] info Device info |
| * \return 0=OK, BCM_ERR_IO-dev_id is in proper range, but link is down |
| */ |
| bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info) |
| { |
| maple_device_info *dev_info; |
| |
| if (NULL == info) |
| { |
| return BCM_ERR_PARM; |
| } |
| |
| if (dev_id < crt_device) |
| { |
| dev_info = get_maple_pci_info(dev_id); |
| if (dev_info->datalink == BCM_LL_PCIE_LINK_DOWN) |
| { |
| return BCM_ERR_IO; |
| } |
| |
| *info = dev_info->device; |
| return BCM_ERR_OK; |
| } |
| |
| return BCM_ERR_RANGE; |
| } |
| |
| /** Get low-level device handle |
| * \param[in] dev_id Device id |
| * \param[out] lldev Low-level device handle |
| * \return device handle or NULL if link is down |
| */ |
| bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id) |
| { |
| maple_device_info *dev_info; |
| |
| if (dev_id < MAPLE_MAX_DEVICES) |
| { |
| dev_info = get_maple_pci_info(dev_id); |
| return dev_info->pdev; |
| } |
| |
| return NULL; |
| } |
| |
| /** Host reset enable |
| * \enabled |
| */ |
| bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled) |
| { |
| uint32_t val; |
| |
| val = enabled ? 0 : 1; |
| bcm_pci_write32((uint32_t *)(devices[dev_id].device.soc_regs_base + PCIE_HARD_DEBUG_REGISTER_OFFSET) , val); |
| |
| return BCM_ERR_OK; |
| } |
| |