1 /***********************license start*************** 2 * Author: Cavium Networks 3 * 4 * Contact: support@caviumnetworks.com 5 * This file is part of the OCTEON SDK 6 * 7 * Copyright (c) 2003-2008 Cavium Networks 8 * 9 * This file is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License, Version 2, as 11 * published by the Free Software Foundation. 12 * 13 * This file is distributed in the hope that it will be useful, but 14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty 15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or 16 * NONINFRINGEMENT. See the GNU General Public License for more 17 * details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this file; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * or visit http://www.gnu.org/licenses/. 23 * 24 * This file may also be available under a different license from Cavium. 25 * Contact Cavium Networks for more information 26 ***********************license end**************************************/ 27 28 void __cvmx_interrupt_gmxx_enable(int interface); 29 void __cvmx_interrupt_spxx_int_msk_enable(int index); 30 void __cvmx_interrupt_stxx_int_msk_enable(int index); 31 32 /* 33 * Functions for SPI initialization, configuration, 34 * and monitoring. 35 */ 36 #include <asm/octeon/octeon.h> 37 38 #include <asm/octeon/cvmx-config.h> 39 #include <asm/octeon/cvmx-spi.h> 40 #include <asm/octeon/cvmx-helper.h> 41 42 #include <asm/octeon/cvmx-pip-defs.h> 43 #include <asm/octeon/cvmx-pko-defs.h> 44 45 /* 46 * CVMX_HELPER_SPI_TIMEOUT is used to determine how long the SPI 47 * initialization routines wait for SPI training. You can override the 48 * value using executive-config.h if necessary. 49 */ 50 #ifndef CVMX_HELPER_SPI_TIMEOUT 51 #define CVMX_HELPER_SPI_TIMEOUT 10 52 #endif 53 54 int __cvmx_helper_spi_enumerate(int interface) 55 { 56 if ((cvmx_sysinfo_get()->board_type != CVMX_BOARD_TYPE_SIM) && 57 cvmx_spi4000_is_present(interface)) { 58 return 10; 59 } else { 60 return 16; 61 } 62 } 63 64 /** 65 * Probe a SPI interface and determine the number of ports 66 * connected to it. The SPI interface should still be down after 67 * this call. 68 * 69 * @interface: Interface to probe 70 * 71 * Returns Number of ports on the interface. Zero to disable. 72 */ 73 int __cvmx_helper_spi_probe(int interface) 74 { 75 int num_ports = 0; 76 77 if ((cvmx_sysinfo_get()->board_type != CVMX_BOARD_TYPE_SIM) && 78 cvmx_spi4000_is_present(interface)) { 79 num_ports = 10; 80 } else { 81 union cvmx_pko_reg_crc_enable enable; 82 num_ports = 16; 83 /* 84 * Unlike the SPI4000, most SPI devices don't 85 * automatically put on the L2 CRC. For everything 86 * except for the SPI4000 have PKO append the L2 CRC 87 * to the packet. 88 */ 89 enable.u64 = cvmx_read_csr(CVMX_PKO_REG_CRC_ENABLE); 90 enable.s.enable |= 0xffff << (interface * 16); 91 cvmx_write_csr(CVMX_PKO_REG_CRC_ENABLE, enable.u64); 92 } 93 __cvmx_helper_setup_gmx(interface, num_ports); 94 return num_ports; 95 } 96 97 /** 98 * Bringup and enable a SPI interface. After this call packet I/O 99 * should be fully functional. This is called with IPD enabled but 100 * PKO disabled. 101 * 102 * @interface: Interface to bring up 103 * 104 * Returns Zero on success, negative on failure 105 */ 106 int __cvmx_helper_spi_enable(int interface) 107 { 108 /* 109 * Normally the ethernet L2 CRC is checked and stripped in the 110 * GMX block. When you are using SPI, this isn' the case and 111 * IPD needs to check the L2 CRC. 112 */ 113 int num_ports = cvmx_helper_ports_on_interface(interface); 114 int ipd_port; 115 for (ipd_port = interface * 16; ipd_port < interface * 16 + num_ports; 116 ipd_port++) { 117 union cvmx_pip_prt_cfgx port_config; 118 port_config.u64 = cvmx_read_csr(CVMX_PIP_PRT_CFGX(ipd_port)); 119 port_config.s.crc_en = 1; 120 cvmx_write_csr(CVMX_PIP_PRT_CFGX(ipd_port), port_config.u64); 121 } 122 123 if (cvmx_sysinfo_get()->board_type != CVMX_BOARD_TYPE_SIM) { 124 cvmx_spi_start_interface(interface, CVMX_SPI_MODE_DUPLEX, 125 CVMX_HELPER_SPI_TIMEOUT, num_ports); 126 if (cvmx_spi4000_is_present(interface)) 127 cvmx_spi4000_initialize(interface); 128 } 129 __cvmx_interrupt_spxx_int_msk_enable(interface); 130 __cvmx_interrupt_stxx_int_msk_enable(interface); 131 __cvmx_interrupt_gmxx_enable(interface); 132 return 0; 133 } 134 135 /** 136 * Return the link state of an IPD/PKO port as returned by 137 * auto negotiation. The result of this function may not match 138 * Octeon's link config if auto negotiation has changed since 139 * the last call to cvmx_helper_link_set(). 140 * 141 * @ipd_port: IPD/PKO port to query 142 * 143 * Returns Link state 144 */ 145 cvmx_helper_link_info_t __cvmx_helper_spi_link_get(int ipd_port) 146 { 147 cvmx_helper_link_info_t result; 148 int interface = cvmx_helper_get_interface_num(ipd_port); 149 int index = cvmx_helper_get_interface_index_num(ipd_port); 150 result.u64 = 0; 151 152 if (cvmx_sysinfo_get()->board_type == CVMX_BOARD_TYPE_SIM) { 153 /* The simulator gives you a simulated full duplex link */ 154 result.s.link_up = 1; 155 result.s.full_duplex = 1; 156 result.s.speed = 10000; 157 } else if (cvmx_spi4000_is_present(interface)) { 158 union cvmx_gmxx_rxx_rx_inbnd inband = 159 cvmx_spi4000_check_speed(interface, index); 160 result.s.link_up = inband.s.status; 161 result.s.full_duplex = inband.s.duplex; 162 switch (inband.s.speed) { 163 case 0: /* 10 Mbps */ 164 result.s.speed = 10; 165 break; 166 case 1: /* 100 Mbps */ 167 result.s.speed = 100; 168 break; 169 case 2: /* 1 Gbps */ 170 result.s.speed = 1000; 171 break; 172 case 3: /* Illegal */ 173 result.s.speed = 0; 174 result.s.link_up = 0; 175 break; 176 } 177 } else { 178 /* For generic SPI we can't determine the link, just return some 179 sane results */ 180 result.s.link_up = 1; 181 result.s.full_duplex = 1; 182 result.s.speed = 10000; 183 } 184 return result; 185 } 186 187 /** 188 * Configure an IPD/PKO port for the specified link state. This 189 * function does not influence auto negotiation at the PHY level. 190 * The passed link state must always match the link state returned 191 * by cvmx_helper_link_get(). 192 * 193 * @ipd_port: IPD/PKO port to configure 194 * @link_info: The new link state 195 * 196 * Returns Zero on success, negative on failure 197 */ 198 int __cvmx_helper_spi_link_set(int ipd_port, cvmx_helper_link_info_t link_info) 199 { 200 /* Nothing to do. If we have a SPI4000 then the setup was already performed 201 by cvmx_spi4000_check_speed(). If not then there isn't any link 202 info */ 203 return 0; 204 } 205