1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/ethtool.h> 4 #include <linux/jiffies.h> 5 #include <net/netdev_lock.h> 6 7 #include "common.h" 8 #include "module_fw.h" 9 #include "cmis.h" 10 11 /* For accessing the LPL field on page 9Fh, the allowable length extension is 12 * min(i, 15) byte octets where i specifies the allowable additional number of 13 * byte octets in a READ or a WRITE. 14 */ 15 u32 ethtool_cmis_get_max_lpl_size(u8 num_of_byte_octs) 16 { 17 return 8 * (1 + min_t(u8, num_of_byte_octs, 15)); 18 } 19 20 void ethtool_cmis_cdb_compose_args(struct ethtool_cmis_cdb_cmd_args *args, 21 enum ethtool_cmis_cdb_cmd_id cmd, u8 *lpl, 22 u8 lpl_len, u8 *epl, u16 epl_len, 23 u16 max_duration, u8 read_write_len_ext, 24 u16 msleep_pre_rpl, u8 rpl_exp_len, u8 flags) 25 { 26 args->req.id = cpu_to_be16(cmd); 27 args->req.lpl_len = lpl_len; 28 if (lpl) 29 memcpy(args->req.payload, lpl, args->req.lpl_len); 30 if (epl) { 31 args->req.epl_len = cpu_to_be16(epl_len); 32 args->req.epl = epl; 33 } 34 35 args->max_duration = max_duration; 36 args->read_write_len_ext = 37 ethtool_cmis_get_max_lpl_size(read_write_len_ext); 38 args->msleep_pre_rpl = msleep_pre_rpl; 39 args->rpl_exp_len = rpl_exp_len; 40 args->flags = flags; 41 args->err_msg = NULL; 42 } 43 44 void ethtool_cmis_page_init(struct ethtool_module_eeprom *page_data, 45 u8 page, u32 offset, u32 length) 46 { 47 page_data->page = page; 48 page_data->offset = offset; 49 page_data->length = length; 50 page_data->i2c_address = ETHTOOL_CMIS_CDB_PAGE_I2C_ADDR; 51 } 52 53 #define CMIS_REVISION_PAGE 0x00 54 #define CMIS_REVISION_OFFSET 0x01 55 56 struct cmis_rev_rpl { 57 u8 rev; 58 }; 59 60 static u8 cmis_rev_rpl_major(struct cmis_rev_rpl *rpl) 61 { 62 return rpl->rev >> 4; 63 } 64 65 static int cmis_rev_major_get(struct net_device *dev, u8 *rev_major) 66 { 67 const struct ethtool_ops *ops = dev->ethtool_ops; 68 struct ethtool_module_eeprom page_data = {0}; 69 struct netlink_ext_ack extack = {}; 70 struct cmis_rev_rpl rpl = {}; 71 int err; 72 73 ethtool_cmis_page_init(&page_data, CMIS_REVISION_PAGE, 74 CMIS_REVISION_OFFSET, sizeof(rpl)); 75 page_data.data = (u8 *)&rpl; 76 77 err = ops->get_module_eeprom_by_page(dev, &page_data, &extack); 78 if (err < 0) { 79 if (extack._msg) 80 netdev_err(dev, "%s\n", extack._msg); 81 return err; 82 } 83 84 *rev_major = cmis_rev_rpl_major(&rpl); 85 86 return 0; 87 } 88 89 #define CMIS_CDB_ADVERTISEMENT_PAGE 0x01 90 #define CMIS_CDB_ADVERTISEMENT_OFFSET 0xA3 91 92 /* Based on section 8.4.11 "CDB Messaging Support Advertisement" in CMIS 93 * standard revision 5.2. 94 */ 95 struct cmis_cdb_advert_rpl { 96 u8 inst_supported; 97 u8 read_write_len_ext; 98 u8 resv1; 99 u8 resv2; 100 }; 101 102 static u8 cmis_cdb_advert_rpl_inst_supported(struct cmis_cdb_advert_rpl *rpl) 103 { 104 return rpl->inst_supported >> 6; 105 } 106 107 static int cmis_cdb_advertisement_get(struct ethtool_cmis_cdb *cdb, 108 struct net_device *dev, 109 struct ethnl_module_fw_flash_ntf_params *ntf_params) 110 { 111 const struct ethtool_ops *ops = dev->ethtool_ops; 112 struct ethtool_module_eeprom page_data = {}; 113 struct cmis_cdb_advert_rpl rpl = {}; 114 struct netlink_ext_ack extack = {}; 115 int err; 116 117 ethtool_cmis_page_init(&page_data, CMIS_CDB_ADVERTISEMENT_PAGE, 118 CMIS_CDB_ADVERTISEMENT_OFFSET, sizeof(rpl)); 119 page_data.data = (u8 *)&rpl; 120 121 err = ops->get_module_eeprom_by_page(dev, &page_data, &extack); 122 if (err < 0) { 123 if (extack._msg) 124 netdev_err(dev, "%s\n", extack._msg); 125 return err; 126 } 127 128 if (!cmis_cdb_advert_rpl_inst_supported(&rpl)) { 129 ethnl_module_fw_flash_ntf_err(dev, ntf_params, 130 "CDB functionality is not supported", 131 NULL); 132 return -EOPNOTSUPP; 133 } 134 135 cdb->read_write_len_ext = rpl.read_write_len_ext; 136 137 return 0; 138 } 139 140 #define CMIS_PASSWORD_ENTRY_PAGE 0x00 141 #define CMIS_PASSWORD_ENTRY_OFFSET 0x7A 142 143 struct cmis_password_entry_pl { 144 __be32 password; 145 }; 146 147 /* See section 9.3.1 "CMD 0000h: Query Status" in CMIS standard revision 5.2. 148 * struct cmis_cdb_query_status_pl and struct cmis_cdb_query_status_rpl are 149 * structured layouts of the flat arrays, 150 * struct ethtool_cmis_cdb_request::payload and 151 * struct ethtool_cmis_cdb_rpl::payload respectively. 152 */ 153 struct cmis_cdb_query_status_pl { 154 u16 response_delay; 155 }; 156 157 struct cmis_cdb_query_status_rpl { 158 u8 length; 159 u8 status; 160 }; 161 162 static int 163 cmis_cdb_validate_password(struct ethtool_cmis_cdb *cdb, 164 struct net_device *dev, 165 const struct ethtool_module_fw_flash_params *params, 166 struct ethnl_module_fw_flash_ntf_params *ntf_params) 167 { 168 const struct ethtool_ops *ops = dev->ethtool_ops; 169 struct cmis_cdb_query_status_pl qs_pl = {0}; 170 struct ethtool_module_eeprom page_data = {}; 171 struct ethtool_cmis_cdb_cmd_args args = {}; 172 struct cmis_password_entry_pl pe_pl = {}; 173 struct cmis_cdb_query_status_rpl *rpl; 174 struct netlink_ext_ack extack = {}; 175 int err; 176 177 ethtool_cmis_page_init(&page_data, CMIS_PASSWORD_ENTRY_PAGE, 178 CMIS_PASSWORD_ENTRY_OFFSET, sizeof(pe_pl)); 179 page_data.data = (u8 *)&pe_pl; 180 181 pe_pl = *((struct cmis_password_entry_pl *)page_data.data); 182 pe_pl.password = params->password; 183 netdev_assert_locked_ops(dev); 184 err = ops->set_module_eeprom_by_page(dev, &page_data, &extack); 185 if (err < 0) { 186 if (extack._msg) 187 netdev_err(dev, "%s\n", extack._msg); 188 return err; 189 } 190 191 ethtool_cmis_cdb_compose_args(&args, ETHTOOL_CMIS_CDB_CMD_QUERY_STATUS, 192 (u8 *)&qs_pl, sizeof(qs_pl), NULL, 0, 0, 193 cdb->read_write_len_ext, 1000, 194 sizeof(*rpl), 195 CDB_F_COMPLETION_VALID | CDB_F_STATUS_VALID); 196 197 err = ethtool_cmis_cdb_execute_cmd(dev, &args); 198 if (err < 0) { 199 ethnl_module_fw_flash_ntf_err(dev, ntf_params, 200 "Query Status command failed", 201 args.err_msg); 202 return err; 203 } 204 205 rpl = (struct cmis_cdb_query_status_rpl *)args.req.payload; 206 if (!rpl->length || !rpl->status) { 207 ethnl_module_fw_flash_ntf_err(dev, ntf_params, 208 "Password was not accepted", 209 NULL); 210 return -EINVAL; 211 } 212 213 return 0; 214 } 215 216 /* Some CDB commands asserts the CDB completion flag only from CMIS 217 * revision 5. Therefore, check the relevant validity flag only when 218 * the revision supports it. 219 */ 220 void ethtool_cmis_cdb_check_completion_flag(u8 cmis_rev, u8 *flags) 221 { 222 *flags |= cmis_rev >= 5 ? CDB_F_COMPLETION_VALID : 0; 223 } 224 225 #define CMIS_CDB_MODULE_FEATURES_RESV_DATA 34 226 227 /* See section 9.4.1 "CMD 0040h: Module Features" in CMIS standard revision 5.2. 228 * struct cmis_cdb_module_features_rpl is structured layout of the flat 229 * array, ethtool_cmis_cdb_rpl::payload. 230 */ 231 struct cmis_cdb_module_features_rpl { 232 u8 resv1[CMIS_CDB_MODULE_FEATURES_RESV_DATA]; 233 __be16 max_completion_time; 234 }; 235 236 static u16 237 cmis_cdb_module_features_completion_time(struct cmis_cdb_module_features_rpl *rpl) 238 { 239 return be16_to_cpu(rpl->max_completion_time); 240 } 241 242 static int cmis_cdb_module_features_get(struct ethtool_cmis_cdb *cdb, 243 struct net_device *dev, 244 struct ethnl_module_fw_flash_ntf_params *ntf_params) 245 { 246 struct ethtool_cmis_cdb_cmd_args args = {}; 247 struct cmis_cdb_module_features_rpl *rpl; 248 u8 flags = CDB_F_STATUS_VALID; 249 int err; 250 251 ethtool_cmis_cdb_check_completion_flag(cdb->cmis_rev, &flags); 252 ethtool_cmis_cdb_compose_args(&args, 253 ETHTOOL_CMIS_CDB_CMD_MODULE_FEATURES, 254 NULL, 0, NULL, 0, 0, 255 cdb->read_write_len_ext, 1000, 256 sizeof(*rpl), flags); 257 258 err = ethtool_cmis_cdb_execute_cmd(dev, &args); 259 if (err < 0) { 260 ethnl_module_fw_flash_ntf_err(dev, ntf_params, 261 "Module Features command failed", 262 args.err_msg); 263 return err; 264 } 265 266 rpl = (struct cmis_cdb_module_features_rpl *)args.req.payload; 267 cdb->max_completion_time = 268 cmis_cdb_module_features_completion_time(rpl); 269 270 return 0; 271 } 272 273 struct ethtool_cmis_cdb * 274 ethtool_cmis_cdb_init(struct net_device *dev, 275 const struct ethtool_module_fw_flash_params *params, 276 struct ethnl_module_fw_flash_ntf_params *ntf_params) 277 { 278 struct ethtool_cmis_cdb *cdb; 279 int err; 280 281 cdb = kzalloc_obj(*cdb); 282 if (!cdb) 283 return ERR_PTR(-ENOMEM); 284 285 err = cmis_rev_major_get(dev, &cdb->cmis_rev); 286 if (err < 0) 287 goto err; 288 289 if (cdb->cmis_rev < 4) { 290 ethnl_module_fw_flash_ntf_err(dev, ntf_params, 291 "CMIS revision doesn't support module firmware flashing", 292 NULL); 293 err = -EOPNOTSUPP; 294 goto err; 295 } 296 297 err = cmis_cdb_advertisement_get(cdb, dev, ntf_params); 298 if (err < 0) 299 goto err; 300 301 if (params->password_valid) { 302 err = cmis_cdb_validate_password(cdb, dev, params, ntf_params); 303 if (err < 0) 304 goto err; 305 } 306 307 err = cmis_cdb_module_features_get(cdb, dev, ntf_params); 308 if (err < 0) 309 goto err; 310 311 return cdb; 312 313 err: 314 ethtool_cmis_cdb_fini(cdb); 315 return ERR_PTR(err); 316 } 317 318 void ethtool_cmis_cdb_fini(struct ethtool_cmis_cdb *cdb) 319 { 320 kfree(cdb); 321 } 322 323 static bool is_completed(u8 data) 324 { 325 return !!(data & 0x40); 326 } 327 328 #define CMIS_CDB_STATUS_SUCCESS 0x01 329 330 static bool status_success(u8 data) 331 { 332 return data == CMIS_CDB_STATUS_SUCCESS; 333 } 334 335 #define CMIS_CDB_STATUS_FAIL 0x40 336 337 static bool status_fail(u8 data) 338 { 339 return data & CMIS_CDB_STATUS_FAIL; 340 } 341 342 struct cmis_wait_for_cond_rpl { 343 u8 state; 344 }; 345 346 static int 347 ethtool_cmis_module_poll(struct net_device *dev, 348 struct cmis_wait_for_cond_rpl *rpl, u32 offset, 349 bool (*cond_success)(u8), bool (*cond_fail)(u8)) 350 { 351 const struct ethtool_ops *ops = dev->ethtool_ops; 352 struct ethtool_module_eeprom page_data = {0}; 353 struct netlink_ext_ack extack = {}; 354 int err; 355 356 ethtool_cmis_page_init(&page_data, 0, offset, sizeof(*rpl)); 357 page_data.data = (u8 *)rpl; 358 359 err = ops->get_module_eeprom_by_page(dev, &page_data, &extack); 360 if (err < 0) { 361 if (extack._msg) 362 netdev_err_once(dev, "%s\n", extack._msg); 363 return -EBUSY; 364 } 365 366 if ((*cond_success)(rpl->state)) 367 return 0; 368 369 if (*cond_fail && (*cond_fail)(rpl->state)) 370 return -EIO; 371 372 return -EBUSY; 373 } 374 375 int ethtool_cmis_wait_for_cond(struct net_device *dev, u8 flags, u8 flag, 376 u16 max_duration, u32 offset, 377 bool (*cond_success)(u8), bool (*cond_fail)(u8), 378 u8 *state) 379 { 380 struct cmis_wait_for_cond_rpl rpl = {}; 381 unsigned long end; 382 int err; 383 384 if (!(flags & flag)) 385 return 0; 386 387 if (max_duration == 0) 388 max_duration = U16_MAX; 389 390 end = jiffies + msecs_to_jiffies(max_duration); 391 do { 392 err = ethtool_cmis_module_poll(dev, &rpl, offset, cond_success, 393 cond_fail); 394 if (err != -EBUSY) 395 goto out; 396 397 msleep(20); 398 } while (time_before(jiffies, end)); 399 400 err = ethtool_cmis_module_poll(dev, &rpl, offset, cond_success, 401 cond_fail); 402 if (err == -EBUSY) 403 err = -ETIMEDOUT; 404 405 out: 406 *state = rpl.state; 407 return err; 408 } 409 410 #define CMIS_CDB_COMPLETION_FLAG_OFFSET 0x08 411 412 static int cmis_cdb_wait_for_completion(struct net_device *dev, 413 struct ethtool_cmis_cdb_cmd_args *args) 414 { 415 u8 flag; 416 int err; 417 418 /* Some vendors demand waiting time before checking completion flag 419 * in some CDB commands. 420 */ 421 msleep(args->msleep_pre_rpl); 422 423 err = ethtool_cmis_wait_for_cond(dev, args->flags, 424 CDB_F_COMPLETION_VALID, 425 args->max_duration, 426 CMIS_CDB_COMPLETION_FLAG_OFFSET, 427 is_completed, NULL, &flag); 428 if (err < 0) 429 args->err_msg = "Completion Flag did not set on time"; 430 431 return err; 432 } 433 434 #define CMIS_CDB_STATUS_OFFSET 0x25 435 436 static void cmis_cdb_status_fail_msg_get(u8 status, char **err_msg) 437 { 438 switch (status) { 439 case 0b10000001: 440 *err_msg = "CDB Status is in progress: Busy capturing command"; 441 break; 442 case 0b10000010: 443 *err_msg = 444 "CDB Status is in progress: Busy checking/validating command"; 445 break; 446 case 0b10000011: 447 *err_msg = "CDB Status is in progress: Busy executing"; 448 break; 449 case 0b01000000: 450 *err_msg = "CDB status failed: no specific failure"; 451 break; 452 case 0b01000010: 453 *err_msg = 454 "CDB status failed: Parameter range error or parameter not supported"; 455 break; 456 case 0b01000101: 457 *err_msg = "CDB status failed: CdbChkCode error"; 458 break; 459 case 0b01000110: 460 *err_msg = "CDB status failed: Password error"; 461 break; 462 default: 463 *err_msg = "Unknown failure reason"; 464 } 465 }; 466 467 static int cmis_cdb_wait_for_status(struct net_device *dev, 468 struct ethtool_cmis_cdb_cmd_args *args) 469 { 470 u8 status; 471 int err; 472 473 /* Some vendors demand waiting time before checking status in some 474 * CDB commands. 475 */ 476 msleep(args->msleep_pre_rpl); 477 478 err = ethtool_cmis_wait_for_cond(dev, args->flags, CDB_F_STATUS_VALID, 479 args->max_duration, 480 CMIS_CDB_STATUS_OFFSET, 481 status_success, status_fail, &status); 482 if (err < 0 && !args->err_msg) 483 cmis_cdb_status_fail_msg_get(status, &args->err_msg); 484 485 return err; 486 } 487 488 #define CMIS_CDB_REPLY_OFFSET 0x86 489 490 static int cmis_cdb_process_reply(struct net_device *dev, 491 struct ethtool_module_eeprom *page_data, 492 struct ethtool_cmis_cdb_cmd_args *args) 493 { 494 u8 rpl_hdr_len = sizeof(struct ethtool_cmis_cdb_rpl_hdr); 495 u8 rpl_exp_len = args->rpl_exp_len + rpl_hdr_len; 496 const struct ethtool_ops *ops = dev->ethtool_ops; 497 struct netlink_ext_ack extack = {}; 498 struct ethtool_cmis_cdb_rpl *rpl; 499 int err; 500 501 if (!args->rpl_exp_len) 502 return 0; 503 504 ethtool_cmis_page_init(page_data, ETHTOOL_CMIS_CDB_CMD_PAGE, 505 CMIS_CDB_REPLY_OFFSET, rpl_exp_len); 506 page_data->data = kmalloc(page_data->length, GFP_KERNEL); 507 if (!page_data->data) 508 return -ENOMEM; 509 510 err = ops->get_module_eeprom_by_page(dev, page_data, &extack); 511 if (err < 0) { 512 if (extack._msg) 513 netdev_err(dev, "%s\n", extack._msg); 514 goto out; 515 } 516 517 rpl = (struct ethtool_cmis_cdb_rpl *)page_data->data; 518 if (rpl->hdr.rpl_len != args->rpl_exp_len) { 519 netdev_warn(dev, "CDB reply length mismatch, expected %u got %u\n", 520 args->rpl_exp_len, rpl->hdr.rpl_len); 521 err = -EIO; 522 goto out; 523 } 524 if (!rpl->hdr.rpl_chk_code) { 525 err = -EIO; 526 goto out; 527 } 528 529 args->req.lpl_len = rpl->hdr.rpl_len; 530 memcpy(args->req.payload, rpl->payload, args->req.lpl_len); 531 532 out: 533 kfree(page_data->data); 534 return err; 535 } 536 537 static int 538 __ethtool_cmis_cdb_execute_cmd(struct net_device *dev, 539 struct ethtool_module_eeprom *page_data, 540 u8 page, u32 offset, u32 length, void *data) 541 { 542 const struct ethtool_ops *ops = dev->ethtool_ops; 543 struct netlink_ext_ack extack = {}; 544 int err; 545 546 ethtool_cmis_page_init(page_data, page, offset, length); 547 page_data->data = kmemdup(data, page_data->length, GFP_KERNEL); 548 if (!page_data->data) 549 return -ENOMEM; 550 551 netdev_assert_locked_ops(dev); 552 err = ops->set_module_eeprom_by_page(dev, page_data, &extack); 553 if (err < 0) { 554 if (extack._msg) 555 netdev_err(dev, "%s\n", extack._msg); 556 } 557 558 kfree(page_data->data); 559 return err; 560 } 561 562 #define CMIS_CDB_EPL_PAGE_START 0xA0 563 #define CMIS_CDB_EPL_PAGE_END 0xAF 564 #define CMIS_CDB_EPL_FW_BLOCK_OFFSET_START 128 565 #define CMIS_CDB_EPL_FW_BLOCK_OFFSET_END 255 566 567 static int 568 ethtool_cmis_cdb_execute_epl_cmd(struct net_device *dev, 569 struct ethtool_cmis_cdb_cmd_args *args, 570 struct ethtool_module_eeprom *page_data) 571 { 572 u16 epl_len = be16_to_cpu(args->req.epl_len); 573 u32 bytes_written = 0; 574 u8 page; 575 int err; 576 577 for (page = CMIS_CDB_EPL_PAGE_START; 578 page <= CMIS_CDB_EPL_PAGE_END && bytes_written < epl_len; page++) { 579 u16 offset = CMIS_CDB_EPL_FW_BLOCK_OFFSET_START; 580 581 while (offset <= CMIS_CDB_EPL_FW_BLOCK_OFFSET_END && 582 bytes_written < epl_len) { 583 u32 bytes_left = epl_len - bytes_written; 584 u16 space_left, bytes_to_write; 585 586 space_left = CMIS_CDB_EPL_FW_BLOCK_OFFSET_END - offset + 1; 587 bytes_to_write = min_t(u16, bytes_left, 588 min_t(u16, space_left, 589 args->read_write_len_ext)); 590 591 err = __ethtool_cmis_cdb_execute_cmd(dev, page_data, 592 page, offset, 593 bytes_to_write, 594 args->req.epl + bytes_written); 595 if (err < 0) 596 return err; 597 598 offset += bytes_to_write; 599 bytes_written += bytes_to_write; 600 } 601 } 602 return 0; 603 } 604 605 static u8 cmis_cdb_calc_checksum(const void *data, size_t size) 606 { 607 const u8 *bytes = (const u8 *)data; 608 u8 checksum = 0; 609 610 for (size_t i = 0; i < size; i++) 611 checksum += bytes[i]; 612 613 return ~checksum; 614 } 615 616 #define CMIS_CDB_CMD_ID_OFFSET 0x80 617 618 int ethtool_cmis_cdb_execute_cmd(struct net_device *dev, 619 struct ethtool_cmis_cdb_cmd_args *args) 620 { 621 struct ethtool_module_eeprom page_data = {}; 622 u32 offset; 623 int err; 624 625 args->req.chk_code = 626 cmis_cdb_calc_checksum(&args->req, 627 offsetof(struct ethtool_cmis_cdb_request, 628 epl)); 629 630 if (args->req.lpl_len > args->read_write_len_ext) { 631 args->err_msg = "LPL length is longer than CDB read write length extension allows"; 632 return -EINVAL; 633 } 634 635 /* According to the CMIS standard, there are two options to trigger the 636 * CDB commands. The default option is triggering the command by writing 637 * the CMDID bytes. Therefore, the command will be split to 2 calls: 638 * First, with everything except the CMDID field and then the CMDID 639 * field. 640 */ 641 offset = CMIS_CDB_CMD_ID_OFFSET + 642 offsetof(struct ethtool_cmis_cdb_request, body); 643 err = __ethtool_cmis_cdb_execute_cmd(dev, &page_data, 644 ETHTOOL_CMIS_CDB_CMD_PAGE, offset, 645 sizeof(args->req.body), 646 &args->req.body); 647 if (err < 0) 648 return err; 649 650 if (args->req.epl_len) { 651 err = ethtool_cmis_cdb_execute_epl_cmd(dev, args, &page_data); 652 if (err < 0) 653 return err; 654 } 655 656 offset = CMIS_CDB_CMD_ID_OFFSET + 657 offsetof(struct ethtool_cmis_cdb_request, id); 658 err = __ethtool_cmis_cdb_execute_cmd(dev, &page_data, 659 ETHTOOL_CMIS_CDB_CMD_PAGE, offset, 660 sizeof(args->req.id), 661 &args->req.id); 662 if (err < 0) 663 return err; 664 665 err = cmis_cdb_wait_for_completion(dev, args); 666 if (err < 0) 667 return err; 668 669 err = cmis_cdb_wait_for_status(dev, args); 670 if (err < 0) 671 return err; 672 673 return cmis_cdb_process_reply(dev, &page_data, args); 674 } 675