Commit | Line | Data |
---|---|---|
80ff0fd3 DD |
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 | ||
af866496 DD |
38 | #include <asm/octeon/cvmx-config.h> |
39 | #include <asm/octeon/cvmx-spi.h> | |
40 | #include <asm/octeon/cvmx-helper.h> | |
80ff0fd3 | 41 | |
af866496 DD |
42 | #include <asm/octeon/cvmx-pip-defs.h> |
43 | #include <asm/octeon/cvmx-pko-defs.h> | |
80ff0fd3 DD |
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 | ||
37d3bfd9 DD |
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 | ||
80ff0fd3 DD |
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(). It is normally best to use | |
192 | * cvmx_helper_link_autoconf() instead. | |
193 | * | |
194 | * @ipd_port: IPD/PKO port to configure | |
195 | * @link_info: The new link state | |
196 | * | |
197 | * Returns Zero on success, negative on failure | |
198 | */ | |
199 | int __cvmx_helper_spi_link_set(int ipd_port, cvmx_helper_link_info_t link_info) | |
200 | { | |
201 | /* Nothing to do. If we have a SPI4000 then the setup was already performed | |
202 | by cvmx_spi4000_check_speed(). If not then there isn't any link | |
203 | info */ | |
204 | return 0; | |
205 | } |