1 /*- 2 * Copyright (c) 2007-2015 Solarflare Communications Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * The views and conclusions contained in the software and documentation are 27 * those of the authors and should not be interpreted as representing official 28 * policies, either expressed or implied, of the FreeBSD Project. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include "efx.h" 35 #include "efx_impl.h" 36 37 __checkReturn efx_rc_t 38 efx_sram_buf_tbl_set( 39 __in efx_nic_t *enp, 40 __in uint32_t id, 41 __in efsys_mem_t *esmp, 42 __in size_t n) 43 { 44 efx_qword_t qword; 45 uint32_t start = id; 46 uint32_t stop = start + n; 47 efsys_dma_addr_t addr; 48 efx_oword_t oword; 49 unsigned int count; 50 efx_rc_t rc; 51 52 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 53 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC); 54 55 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD 56 if (enp->en_family == EFX_FAMILY_HUNTINGTON || 57 enp->en_family == EFX_FAMILY_MEDFORD) { 58 /* 59 * FIXME: the efx_sram_buf_tbl_*() functionality needs to be 60 * pulled inside the Falcon/Siena queue create/destroy code, 61 * and then the original functions can be removed (see bug30834 62 * comment #1). But, for now, we just ensure that they are 63 * no-ops for EF10, to allow bringing up existing drivers 64 * without modification. 65 */ 66 67 return (0); 68 } 69 #endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */ 70 71 if (stop >= EFX_BUF_TBL_SIZE) { 72 rc = EFBIG; 73 goto fail1; 74 } 75 76 /* Add the entries into the buffer table */ 77 addr = EFSYS_MEM_ADDR(esmp); 78 for (id = start; id != stop; id++) { 79 EFX_POPULATE_QWORD_5(qword, 80 FRF_AZ_IP_DAT_BUF_SIZE, 0, FRF_AZ_BUF_ADR_REGION, 0, 81 FRF_AZ_BUF_ADR_FBUF_DW0, 82 (uint32_t)((addr >> 12) & 0xffffffff), 83 FRF_AZ_BUF_ADR_FBUF_DW1, 84 (uint32_t)((addr >> 12) >> 32), 85 FRF_AZ_BUF_OWNER_ID_FBUF, 0); 86 87 EFX_BAR_TBL_WRITEQ(enp, FR_AZ_BUF_FULL_TBL, 88 id, &qword); 89 90 addr += EFX_BUF_SIZE; 91 } 92 93 EFSYS_PROBE2(buf, uint32_t, start, uint32_t, stop - 1); 94 95 /* Flush the write buffer */ 96 EFX_POPULATE_OWORD_2(oword, FRF_AZ_BUF_UPD_CMD, 1, 97 FRF_AZ_BUF_CLR_CMD, 0); 98 EFX_BAR_WRITEO(enp, FR_AZ_BUF_TBL_UPD_REG, &oword); 99 100 /* Poll for the last entry being written to the buffer table */ 101 EFSYS_ASSERT3U(id, ==, stop); 102 addr -= EFX_BUF_SIZE; 103 104 count = 0; 105 do { 106 EFSYS_PROBE1(wait, unsigned int, count); 107 108 /* Spin for 1 ms */ 109 EFSYS_SPIN(1000); 110 111 EFX_BAR_TBL_READQ(enp, FR_AZ_BUF_FULL_TBL, 112 id - 1, &qword); 113 114 if (EFX_QWORD_FIELD(qword, FRF_AZ_BUF_ADR_FBUF_DW0) == 115 (uint32_t)((addr >> 12) & 0xffffffff) && 116 EFX_QWORD_FIELD(qword, FRF_AZ_BUF_ADR_FBUF_DW1) == 117 (uint32_t)((addr >> 12) >> 32)) 118 goto verify; 119 120 } while (++count < 100); 121 122 rc = ETIMEDOUT; 123 goto fail2; 124 125 verify: 126 /* Verify the rest of the entries in the buffer table */ 127 while (--id != start) { 128 addr -= EFX_BUF_SIZE; 129 130 /* Read the buffer table entry */ 131 EFX_BAR_TBL_READQ(enp, FR_AZ_BUF_FULL_TBL, 132 id - 1, &qword); 133 134 if (EFX_QWORD_FIELD(qword, FRF_AZ_BUF_ADR_FBUF_DW0) != 135 (uint32_t)((addr >> 12) & 0xffffffff) || 136 EFX_QWORD_FIELD(qword, FRF_AZ_BUF_ADR_FBUF_DW1) != 137 (uint32_t)((addr >> 12) >> 32)) { 138 rc = EFAULT; 139 goto fail3; 140 } 141 } 142 143 return (0); 144 145 fail3: 146 EFSYS_PROBE(fail3); 147 148 id = stop; 149 150 fail2: 151 EFSYS_PROBE(fail2); 152 153 EFX_POPULATE_OWORD_4(oword, FRF_AZ_BUF_UPD_CMD, 0, 154 FRF_AZ_BUF_CLR_CMD, 1, FRF_AZ_BUF_CLR_END_ID, id - 1, 155 FRF_AZ_BUF_CLR_START_ID, start); 156 EFX_BAR_WRITEO(enp, FR_AZ_BUF_TBL_UPD_REG, &oword); 157 158 fail1: 159 EFSYS_PROBE1(fail1, efx_rc_t, rc); 160 161 return (rc); 162 } 163 164 void 165 efx_sram_buf_tbl_clear( 166 __in efx_nic_t *enp, 167 __in uint32_t id, 168 __in size_t n) 169 { 170 efx_oword_t oword; 171 uint32_t start = id; 172 uint32_t stop = start + n; 173 174 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 175 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC); 176 177 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD 178 if (enp->en_family == EFX_FAMILY_HUNTINGTON || 179 enp->en_family == EFX_FAMILY_MEDFORD) { 180 /* 181 * FIXME: the efx_sram_buf_tbl_*() functionality needs to be 182 * pulled inside the Falcon/Siena queue create/destroy code, 183 * and then the original functions can be removed (see bug30834 184 * comment #1). But, for now, we just ensure that they are 185 * no-ops for EF10, to allow bringing up existing drivers 186 * without modification. 187 */ 188 189 return; 190 } 191 #endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */ 192 193 EFSYS_ASSERT3U(stop, <, EFX_BUF_TBL_SIZE); 194 195 EFSYS_PROBE2(buf, uint32_t, start, uint32_t, stop - 1); 196 197 EFX_POPULATE_OWORD_4(oword, FRF_AZ_BUF_UPD_CMD, 0, 198 FRF_AZ_BUF_CLR_CMD, 1, FRF_AZ_BUF_CLR_END_ID, stop - 1, 199 FRF_AZ_BUF_CLR_START_ID, start); 200 EFX_BAR_WRITEO(enp, FR_AZ_BUF_TBL_UPD_REG, &oword); 201 } 202 203 204 #if EFSYS_OPT_DIAG 205 206 static void 207 efx_sram_byte_increment_set( 208 __in size_t row, 209 __in boolean_t negate, 210 __out efx_qword_t *eqp) 211 { 212 size_t offset = row * FR_AZ_SRM_DBG_REG_STEP; 213 unsigned int index; 214 215 _NOTE(ARGUNUSED(negate)) 216 217 for (index = 0; index < sizeof (efx_qword_t); index++) 218 eqp->eq_u8[index] = offset + index; 219 } 220 221 static void 222 efx_sram_all_the_same_set( 223 __in size_t row, 224 __in boolean_t negate, 225 __out efx_qword_t *eqp) 226 { 227 _NOTE(ARGUNUSED(row)) 228 229 if (negate) 230 EFX_SET_QWORD(*eqp); 231 else 232 EFX_ZERO_QWORD(*eqp); 233 } 234 235 static void 236 efx_sram_bit_alternate_set( 237 __in size_t row, 238 __in boolean_t negate, 239 __out efx_qword_t *eqp) 240 { 241 _NOTE(ARGUNUSED(row)) 242 243 EFX_POPULATE_QWORD_2(*eqp, 244 EFX_DWORD_0, (negate) ? 0x55555555 : 0xaaaaaaaa, 245 EFX_DWORD_1, (negate) ? 0x55555555 : 0xaaaaaaaa); 246 } 247 248 static void 249 efx_sram_byte_alternate_set( 250 __in size_t row, 251 __in boolean_t negate, 252 __out efx_qword_t *eqp) 253 { 254 _NOTE(ARGUNUSED(row)) 255 256 EFX_POPULATE_QWORD_2(*eqp, 257 EFX_DWORD_0, (negate) ? 0x00ff00ff : 0xff00ff00, 258 EFX_DWORD_1, (negate) ? 0x00ff00ff : 0xff00ff00); 259 } 260 261 static void 262 efx_sram_byte_changing_set( 263 __in size_t row, 264 __in boolean_t negate, 265 __out efx_qword_t *eqp) 266 { 267 size_t offset = row * FR_AZ_SRM_DBG_REG_STEP; 268 unsigned int index; 269 270 for (index = 0; index < sizeof (efx_qword_t); index++) { 271 uint8_t byte; 272 273 if (offset / 256 == 0) 274 byte = (uint8_t)((offset % 257) % 256); 275 else 276 byte = (uint8_t)(~((offset - 8) % 257) % 256); 277 278 eqp->eq_u8[index] = (negate) ? ~byte : byte; 279 } 280 } 281 282 static void 283 efx_sram_bit_sweep_set( 284 __in size_t row, 285 __in boolean_t negate, 286 __out efx_qword_t *eqp) 287 { 288 size_t offset = row * FR_AZ_SRM_DBG_REG_STEP; 289 290 if (negate) { 291 EFX_SET_QWORD(*eqp); 292 EFX_CLEAR_QWORD_BIT(*eqp, (offset / sizeof (efx_qword_t)) % 64); 293 } else { 294 EFX_ZERO_QWORD(*eqp); 295 EFX_SET_QWORD_BIT(*eqp, (offset / sizeof (efx_qword_t)) % 64); 296 } 297 } 298 299 efx_sram_pattern_fn_t __efx_sram_pattern_fns[] = { 300 efx_sram_byte_increment_set, 301 efx_sram_all_the_same_set, 302 efx_sram_bit_alternate_set, 303 efx_sram_byte_alternate_set, 304 efx_sram_byte_changing_set, 305 efx_sram_bit_sweep_set 306 }; 307 308 __checkReturn efx_rc_t 309 efx_sram_test( 310 __in efx_nic_t *enp, 311 __in efx_pattern_type_t type) 312 { 313 efx_nic_ops_t *enop = enp->en_enop; 314 efx_sram_pattern_fn_t func; 315 316 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 317 318 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC); 319 320 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_RX)); 321 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_TX)); 322 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_EV)); 323 324 /* Select pattern generator */ 325 EFSYS_ASSERT3U(type, <, EFX_PATTERN_NTYPES); 326 func = __efx_sram_pattern_fns[type]; 327 328 return (enop->eno_sram_test(enp, func)); 329 } 330 331 #endif /* EFSYS_OPT_DIAG */ 332