1 /*- 2 * Copyright (c) 2009-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 38 #if EFSYS_OPT_VPD 39 40 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD 41 42 #include "ef10_tlv_layout.h" 43 44 __checkReturn efx_rc_t 45 ef10_vpd_init( 46 __in efx_nic_t *enp) 47 { 48 caddr_t svpd; 49 size_t svpd_size; 50 uint32_t pci_pf; 51 uint32_t tag; 52 efx_rc_t rc; 53 54 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE); 55 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 56 enp->en_family == EFX_FAMILY_MEDFORD); 57 58 if (enp->en_nic_cfg.enc_vpd_is_global) { 59 tag = TLV_TAG_GLOBAL_STATIC_VPD; 60 } else { 61 pci_pf = enp->en_nic_cfg.enc_pf; 62 tag = TLV_TAG_PF_STATIC_VPD(pci_pf); 63 } 64 65 /* 66 * The VPD interface exposes VPD resources from the combined static and 67 * dynamic VPD storage. As the static VPD configuration should *never* 68 * change, we can cache it. 69 */ 70 svpd = NULL; 71 svpd_size = 0; 72 rc = ef10_nvram_partn_read_tlv(enp, 73 NVRAM_PARTITION_TYPE_STATIC_CONFIG, 74 tag, &svpd, &svpd_size); 75 if (rc != 0) { 76 if (rc == EACCES) { 77 /* Unprivileged functions cannot access VPD */ 78 goto out; 79 } 80 goto fail1; 81 } 82 83 if (svpd != NULL && svpd_size > 0) { 84 if ((rc = efx_vpd_hunk_verify(svpd, svpd_size, NULL)) != 0) 85 goto fail2; 86 } 87 88 enp->en_arch.ef10.ena_svpd = svpd; 89 enp->en_arch.ef10.ena_svpd_length = svpd_size; 90 91 out: 92 return (0); 93 94 fail2: 95 EFSYS_PROBE(fail2); 96 97 EFSYS_KMEM_FREE(enp->en_esip, svpd_size, svpd); 98 fail1: 99 EFSYS_PROBE1(fail1, efx_rc_t, rc); 100 101 return (rc); 102 } 103 104 __checkReturn efx_rc_t 105 ef10_vpd_size( 106 __in efx_nic_t *enp, 107 __out size_t *sizep) 108 { 109 efx_rc_t rc; 110 111 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 112 enp->en_family == EFX_FAMILY_MEDFORD); 113 114 /* 115 * This function returns the total size the user should allocate 116 * for all VPD operations. We've already cached the static vpd, 117 * so we just need to return an upper bound on the dynamic vpd, 118 * which is the size of the DYNAMIC_CONFIG partition. 119 */ 120 if ((rc = efx_mcdi_nvram_info(enp, NVRAM_PARTITION_TYPE_DYNAMIC_CONFIG, 121 sizep, NULL, NULL, NULL)) != 0) 122 goto fail1; 123 124 return (0); 125 126 fail1: 127 EFSYS_PROBE1(fail1, efx_rc_t, rc); 128 129 return (rc); 130 } 131 132 __checkReturn efx_rc_t 133 ef10_vpd_read( 134 __in efx_nic_t *enp, 135 __out_bcount(size) caddr_t data, 136 __in size_t size) 137 { 138 caddr_t dvpd; 139 size_t dvpd_size; 140 uint32_t pci_pf; 141 uint32_t tag; 142 efx_rc_t rc; 143 144 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 145 enp->en_family == EFX_FAMILY_MEDFORD); 146 147 if (enp->en_nic_cfg.enc_vpd_is_global) { 148 tag = TLV_TAG_GLOBAL_DYNAMIC_VPD; 149 } else { 150 pci_pf = enp->en_nic_cfg.enc_pf; 151 tag = TLV_TAG_PF_DYNAMIC_VPD(pci_pf); 152 } 153 154 if ((rc = ef10_nvram_partn_read_tlv(enp, 155 NVRAM_PARTITION_TYPE_DYNAMIC_CONFIG, 156 tag, &dvpd, &dvpd_size)) != 0) 157 goto fail1; 158 159 if (dvpd_size > size) { 160 rc = ENOSPC; 161 goto fail2; 162 } 163 memcpy(data, dvpd, dvpd_size); 164 165 /* Pad data with all-1s, consistent with update operations */ 166 memset(data + dvpd_size, 0xff, size - dvpd_size); 167 168 EFSYS_KMEM_FREE(enp->en_esip, dvpd_size, dvpd); 169 170 return (0); 171 172 fail2: 173 EFSYS_PROBE(fail2); 174 175 EFSYS_KMEM_FREE(enp->en_esip, dvpd_size, dvpd); 176 fail1: 177 EFSYS_PROBE1(fail1, efx_rc_t, rc); 178 179 return (rc); 180 } 181 182 __checkReturn efx_rc_t 183 ef10_vpd_verify( 184 __in efx_nic_t *enp, 185 __in_bcount(size) caddr_t data, 186 __in size_t size) 187 { 188 efx_vpd_tag_t stag; 189 efx_vpd_tag_t dtag; 190 efx_vpd_keyword_t skey; 191 efx_vpd_keyword_t dkey; 192 unsigned int scont; 193 unsigned int dcont; 194 efx_rc_t rc; 195 196 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 197 enp->en_family == EFX_FAMILY_MEDFORD); 198 199 /* 200 * Strictly you could take the view that dynamic vpd is optional. 201 * Instead, to conform more closely to the read/verify/reinit() 202 * paradigm, we require dynamic vpd. ef10_vpd_reinit() will 203 * reinitialize it as required. 204 */ 205 if ((rc = efx_vpd_hunk_verify(data, size, NULL)) != 0) 206 goto fail1; 207 208 /* 209 * Verify that there is no duplication between the static and 210 * dynamic cfg sectors. 211 */ 212 if (enp->en_arch.ef10.ena_svpd_length == 0) 213 goto done; 214 215 dcont = 0; 216 _NOTE(CONSTANTCONDITION) 217 while (1) { 218 if ((rc = efx_vpd_hunk_next(data, size, &dtag, 219 &dkey, NULL, NULL, &dcont)) != 0) 220 goto fail2; 221 if (dcont == 0) 222 break; 223 224 /* 225 * Skip the RV keyword. It should be present in both the static 226 * and dynamic cfg sectors. 227 */ 228 if (dtag == EFX_VPD_RO && dkey == EFX_VPD_KEYWORD('R', 'V')) 229 continue; 230 231 scont = 0; 232 _NOTE(CONSTANTCONDITION) 233 while (1) { 234 if ((rc = efx_vpd_hunk_next( 235 enp->en_arch.ef10.ena_svpd, 236 enp->en_arch.ef10.ena_svpd_length, &stag, &skey, 237 NULL, NULL, &scont)) != 0) 238 goto fail3; 239 if (scont == 0) 240 break; 241 242 if (stag == dtag && skey == dkey) { 243 rc = EEXIST; 244 goto fail4; 245 } 246 } 247 } 248 249 done: 250 return (0); 251 252 fail4: 253 EFSYS_PROBE(fail4); 254 fail3: 255 EFSYS_PROBE(fail3); 256 fail2: 257 EFSYS_PROBE(fail2); 258 fail1: 259 EFSYS_PROBE1(fail1, efx_rc_t, rc); 260 261 return (rc); 262 } 263 264 __checkReturn efx_rc_t 265 ef10_vpd_reinit( 266 __in efx_nic_t *enp, 267 __in_bcount(size) caddr_t data, 268 __in size_t size) 269 { 270 boolean_t wantpid; 271 efx_rc_t rc; 272 273 /* 274 * Only create an ID string if the dynamic cfg doesn't have one 275 */ 276 if (enp->en_arch.ef10.ena_svpd_length == 0) 277 wantpid = B_TRUE; 278 else { 279 unsigned int offset; 280 uint8_t length; 281 282 rc = efx_vpd_hunk_get(enp->en_arch.ef10.ena_svpd, 283 enp->en_arch.ef10.ena_svpd_length, 284 EFX_VPD_ID, 0, &offset, &length); 285 if (rc == 0) 286 wantpid = B_FALSE; 287 else if (rc == ENOENT) 288 wantpid = B_TRUE; 289 else 290 goto fail1; 291 } 292 293 if ((rc = efx_vpd_hunk_reinit(data, size, wantpid)) != 0) 294 goto fail2; 295 296 return (0); 297 298 fail2: 299 EFSYS_PROBE(fail2); 300 fail1: 301 EFSYS_PROBE1(fail1, efx_rc_t, rc); 302 303 return (rc); 304 } 305 306 __checkReturn efx_rc_t 307 ef10_vpd_get( 308 __in efx_nic_t *enp, 309 __in_bcount(size) caddr_t data, 310 __in size_t size, 311 __inout efx_vpd_value_t *evvp) 312 { 313 unsigned int offset; 314 uint8_t length; 315 efx_rc_t rc; 316 317 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 318 enp->en_family == EFX_FAMILY_MEDFORD); 319 320 /* Attempt to satisfy the request from svpd first */ 321 if (enp->en_arch.ef10.ena_svpd_length > 0) { 322 if ((rc = efx_vpd_hunk_get(enp->en_arch.ef10.ena_svpd, 323 enp->en_arch.ef10.ena_svpd_length, evvp->evv_tag, 324 evvp->evv_keyword, &offset, &length)) == 0) { 325 evvp->evv_length = length; 326 memcpy(evvp->evv_value, 327 enp->en_arch.ef10.ena_svpd + offset, length); 328 return (0); 329 } else if (rc != ENOENT) 330 goto fail1; 331 } 332 333 /* And then from the provided data buffer */ 334 if ((rc = efx_vpd_hunk_get(data, size, evvp->evv_tag, 335 evvp->evv_keyword, &offset, &length)) != 0) 336 goto fail2; 337 338 evvp->evv_length = length; 339 memcpy(evvp->evv_value, data + offset, length); 340 341 return (0); 342 343 fail2: 344 EFSYS_PROBE(fail2); 345 fail1: 346 EFSYS_PROBE1(fail1, efx_rc_t, rc); 347 348 return (rc); 349 } 350 351 __checkReturn efx_rc_t 352 ef10_vpd_set( 353 __in efx_nic_t *enp, 354 __in_bcount(size) caddr_t data, 355 __in size_t size, 356 __in efx_vpd_value_t *evvp) 357 { 358 efx_rc_t rc; 359 360 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 361 enp->en_family == EFX_FAMILY_MEDFORD); 362 363 /* If the provided (tag,keyword) exists in svpd, then it is readonly */ 364 if (enp->en_arch.ef10.ena_svpd_length > 0) { 365 unsigned int offset; 366 uint8_t length; 367 368 if ((rc = efx_vpd_hunk_get(enp->en_arch.ef10.ena_svpd, 369 enp->en_arch.ef10.ena_svpd_length, evvp->evv_tag, 370 evvp->evv_keyword, &offset, &length)) == 0) { 371 rc = EACCES; 372 goto fail1; 373 } 374 } 375 376 if ((rc = efx_vpd_hunk_set(data, size, evvp)) != 0) 377 goto fail2; 378 379 return (0); 380 381 fail2: 382 EFSYS_PROBE(fail2); 383 fail1: 384 EFSYS_PROBE1(fail1, efx_rc_t, rc); 385 386 return (rc); 387 } 388 389 __checkReturn efx_rc_t 390 ef10_vpd_next( 391 __in efx_nic_t *enp, 392 __in_bcount(size) caddr_t data, 393 __in size_t size, 394 __out efx_vpd_value_t *evvp, 395 __inout unsigned int *contp) 396 { 397 _NOTE(ARGUNUSED(enp, data, size, evvp, contp)) 398 399 return (ENOTSUP); 400 } 401 402 __checkReturn efx_rc_t 403 ef10_vpd_write( 404 __in efx_nic_t *enp, 405 __in_bcount(size) caddr_t data, 406 __in size_t size) 407 { 408 size_t vpd_length; 409 uint32_t pci_pf; 410 uint32_t tag; 411 efx_rc_t rc; 412 413 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 414 enp->en_family == EFX_FAMILY_MEDFORD); 415 416 if (enp->en_nic_cfg.enc_vpd_is_global) { 417 tag = TLV_TAG_GLOBAL_DYNAMIC_VPD; 418 } else { 419 pci_pf = enp->en_nic_cfg.enc_pf; 420 tag = TLV_TAG_PF_DYNAMIC_VPD(pci_pf); 421 } 422 423 /* Determine total length of new dynamic VPD */ 424 if ((rc = efx_vpd_hunk_length(data, size, &vpd_length)) != 0) 425 goto fail1; 426 427 /* Store new dynamic VPD in all segments in DYNAMIC_CONFIG partition */ 428 if ((rc = ef10_nvram_partn_write_segment_tlv(enp, 429 NVRAM_PARTITION_TYPE_DYNAMIC_CONFIG, 430 tag, data, vpd_length, B_TRUE)) != 0) { 431 goto fail2; 432 } 433 434 return (0); 435 436 fail2: 437 EFSYS_PROBE(fail2); 438 439 fail1: 440 EFSYS_PROBE1(fail1, efx_rc_t, rc); 441 442 return (rc); 443 } 444 445 void 446 ef10_vpd_fini( 447 __in efx_nic_t *enp) 448 { 449 EFSYS_ASSERT(enp->en_family == EFX_FAMILY_HUNTINGTON || 450 enp->en_family == EFX_FAMILY_MEDFORD); 451 452 if (enp->en_arch.ef10.ena_svpd_length > 0) { 453 EFSYS_KMEM_FREE(enp->en_esip, enp->en_arch.ef10.ena_svpd_length, 454 enp->en_arch.ef10.ena_svpd); 455 456 enp->en_arch.ef10.ena_svpd = NULL; 457 enp->en_arch.ef10.ena_svpd_length = 0; 458 } 459 } 460 461 #endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD */ 462 463 #endif /* EFSYS_OPT_VPD */ 464