1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * The Huawei Cache Coherence System (HCCS) is a multi-chip interconnection 4 * bus protocol. 5 * 6 * Copyright (c) 2023 Hisilicon Limited. 7 * Author: Huisong Li <lihuisong@huawei.com> 8 * 9 * HCCS driver for Kunpeng SoC provides the following features: 10 * - Retrieve the following information about each port: 11 * - port type 12 * - lane mode 13 * - enable 14 * - current lane mode 15 * - link finite state machine 16 * - lane mask 17 * - CRC error count 18 * 19 * - Retrieve the following information about all the ports on the chip or 20 * the die: 21 * - if all enabled ports are in linked 22 * - if all linked ports are in full lane 23 * - CRC error count sum 24 */ 25 #include <linux/acpi.h> 26 #include <linux/iopoll.h> 27 #include <linux/platform_device.h> 28 #include <linux/sysfs.h> 29 30 #include <acpi/pcc.h> 31 32 #include "kunpeng_hccs.h" 33 34 /* PCC defines */ 35 #define HCCS_PCC_SIGNATURE_MASK 0x50434300 36 #define HCCS_PCC_STATUS_CMD_COMPLETE BIT(0) 37 38 /* 39 * Arbitrary retries in case the remote processor is slow to respond 40 * to PCC commands 41 */ 42 #define HCCS_PCC_CMD_WAIT_RETRIES_NUM 500ULL 43 #define HCCS_POLL_STATUS_TIME_INTERVAL_US 3 44 45 static struct hccs_port_info *kobj_to_port_info(struct kobject *k) 46 { 47 return container_of(k, struct hccs_port_info, kobj); 48 } 49 50 static struct hccs_die_info *kobj_to_die_info(struct kobject *k) 51 { 52 return container_of(k, struct hccs_die_info, kobj); 53 } 54 55 static struct hccs_chip_info *kobj_to_chip_info(struct kobject *k) 56 { 57 return container_of(k, struct hccs_chip_info, kobj); 58 } 59 60 struct hccs_register_ctx { 61 struct device *dev; 62 u8 chan_id; 63 int err; 64 }; 65 66 static acpi_status hccs_get_register_cb(struct acpi_resource *ares, 67 void *context) 68 { 69 struct acpi_resource_generic_register *reg; 70 struct hccs_register_ctx *ctx = context; 71 72 if (ares->type != ACPI_RESOURCE_TYPE_GENERIC_REGISTER) 73 return AE_OK; 74 75 reg = &ares->data.generic_reg; 76 if (reg->space_id != ACPI_ADR_SPACE_PLATFORM_COMM) { 77 dev_err(ctx->dev, "Bad register resource.\n"); 78 ctx->err = -EINVAL; 79 return AE_ERROR; 80 } 81 ctx->chan_id = reg->access_size; 82 83 return AE_OK; 84 } 85 86 static int hccs_get_pcc_chan_id(struct hccs_dev *hdev) 87 { 88 acpi_handle handle = ACPI_HANDLE(hdev->dev); 89 struct hccs_register_ctx ctx = {0}; 90 acpi_status status; 91 92 if (!acpi_has_method(handle, METHOD_NAME__CRS)) 93 return -ENODEV; 94 95 ctx.dev = hdev->dev; 96 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 97 hccs_get_register_cb, &ctx); 98 if (ACPI_FAILURE(status)) 99 return ctx.err; 100 hdev->chan_id = ctx.chan_id; 101 102 return 0; 103 } 104 105 static void hccs_chan_tx_done(struct mbox_client *cl, void *msg, int ret) 106 { 107 if (ret < 0) 108 pr_debug("TX did not complete: CMD sent:0x%x, ret:%d\n", 109 *(u8 *)msg, ret); 110 else 111 pr_debug("TX completed. CMD sent:0x%x, ret:%d\n", 112 *(u8 *)msg, ret); 113 } 114 115 static void hccs_unregister_pcc_channel(struct hccs_dev *hdev) 116 { 117 struct hccs_mbox_client_info *cl_info = &hdev->cl_info; 118 119 if (cl_info->pcc_comm_addr) 120 iounmap(cl_info->pcc_comm_addr); 121 pcc_mbox_free_channel(hdev->cl_info.pcc_chan); 122 } 123 124 static int hccs_register_pcc_channel(struct hccs_dev *hdev) 125 { 126 struct hccs_mbox_client_info *cl_info = &hdev->cl_info; 127 struct mbox_client *cl = &cl_info->client; 128 struct pcc_mbox_chan *pcc_chan; 129 struct device *dev = hdev->dev; 130 int rc; 131 132 cl->dev = dev; 133 cl->tx_block = false; 134 cl->knows_txdone = true; 135 cl->tx_done = hccs_chan_tx_done; 136 pcc_chan = pcc_mbox_request_channel(cl, hdev->chan_id); 137 if (IS_ERR(pcc_chan)) { 138 dev_err(dev, "PPC channel request failed.\n"); 139 rc = -ENODEV; 140 goto out; 141 } 142 cl_info->pcc_chan = pcc_chan; 143 cl_info->mbox_chan = pcc_chan->mchan; 144 145 /* 146 * pcc_chan->latency is just a nominal value. In reality the remote 147 * processor could be much slower to reply. So add an arbitrary amount 148 * of wait on top of nominal. 149 */ 150 cl_info->deadline_us = 151 HCCS_PCC_CMD_WAIT_RETRIES_NUM * pcc_chan->latency; 152 if (cl_info->mbox_chan->mbox->txdone_irq) { 153 dev_err(dev, "PCC IRQ in PCCT is enabled.\n"); 154 rc = -EINVAL; 155 goto err_mbx_channel_free; 156 } 157 158 if (pcc_chan->shmem_base_addr) { 159 cl_info->pcc_comm_addr = ioremap(pcc_chan->shmem_base_addr, 160 pcc_chan->shmem_size); 161 if (!cl_info->pcc_comm_addr) { 162 dev_err(dev, "Failed to ioremap PCC communication region for channel-%d.\n", 163 hdev->chan_id); 164 rc = -ENOMEM; 165 goto err_mbx_channel_free; 166 } 167 } 168 169 return 0; 170 171 err_mbx_channel_free: 172 pcc_mbox_free_channel(cl_info->pcc_chan); 173 out: 174 return rc; 175 } 176 177 static int hccs_check_chan_cmd_complete(struct hccs_dev *hdev) 178 { 179 struct hccs_mbox_client_info *cl_info = &hdev->cl_info; 180 struct acpi_pcct_shared_memory __iomem *comm_base = 181 cl_info->pcc_comm_addr; 182 u16 status; 183 int ret; 184 185 /* 186 * Poll PCC status register every 3us(delay_us) for maximum of 187 * deadline_us(timeout_us) until PCC command complete bit is set(cond) 188 */ 189 ret = readw_poll_timeout(&comm_base->status, status, 190 status & HCCS_PCC_STATUS_CMD_COMPLETE, 191 HCCS_POLL_STATUS_TIME_INTERVAL_US, 192 cl_info->deadline_us); 193 if (unlikely(ret)) 194 dev_err(hdev->dev, "poll PCC status failed, ret = %d.\n", ret); 195 196 return ret; 197 } 198 199 static int hccs_pcc_cmd_send(struct hccs_dev *hdev, u8 cmd, 200 struct hccs_desc *desc) 201 { 202 struct hccs_mbox_client_info *cl_info = &hdev->cl_info; 203 void __iomem *comm_space = cl_info->pcc_comm_addr + 204 sizeof(struct acpi_pcct_shared_memory); 205 struct hccs_fw_inner_head *fw_inner_head; 206 struct acpi_pcct_shared_memory tmp = {0}; 207 u16 comm_space_size; 208 int ret; 209 210 /* Write signature for this subspace */ 211 tmp.signature = HCCS_PCC_SIGNATURE_MASK | hdev->chan_id; 212 /* Write to the shared command region */ 213 tmp.command = cmd; 214 /* Clear cmd complete bit */ 215 tmp.status = 0; 216 memcpy_toio(cl_info->pcc_comm_addr, (void *)&tmp, 217 sizeof(struct acpi_pcct_shared_memory)); 218 219 /* Copy the message to the PCC comm space */ 220 comm_space_size = HCCS_PCC_SHARE_MEM_BYTES - 221 sizeof(struct acpi_pcct_shared_memory); 222 memcpy_toio(comm_space, (void *)desc, comm_space_size); 223 224 /* Ring doorbell */ 225 ret = mbox_send_message(cl_info->mbox_chan, &cmd); 226 if (ret < 0) { 227 dev_err(hdev->dev, "Send PCC mbox message failed, ret = %d.\n", 228 ret); 229 goto end; 230 } 231 232 /* Wait for completion */ 233 ret = hccs_check_chan_cmd_complete(hdev); 234 if (ret) 235 goto end; 236 237 /* Copy response data */ 238 memcpy_fromio((void *)desc, comm_space, comm_space_size); 239 fw_inner_head = &desc->rsp.fw_inner_head; 240 if (fw_inner_head->retStatus) { 241 dev_err(hdev->dev, "Execute PCC command failed, error code = %u.\n", 242 fw_inner_head->retStatus); 243 ret = -EIO; 244 } 245 246 end: 247 mbox_client_txdone(cl_info->mbox_chan, ret); 248 return ret; 249 } 250 251 static void hccs_init_req_desc(struct hccs_desc *desc) 252 { 253 struct hccs_req_desc *req = &desc->req; 254 255 memset(desc, 0, sizeof(*desc)); 256 req->req_head.module_code = HCCS_SERDES_MODULE_CODE; 257 } 258 259 static int hccs_get_dev_caps(struct hccs_dev *hdev) 260 { 261 struct hccs_desc desc; 262 int ret; 263 264 hccs_init_req_desc(&desc); 265 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DEV_CAP, &desc); 266 if (ret) { 267 dev_err(hdev->dev, "Get device capabilities failed, ret = %d.\n", 268 ret); 269 return ret; 270 } 271 memcpy(&hdev->caps, desc.rsp.data, sizeof(hdev->caps)); 272 273 return 0; 274 } 275 276 static int hccs_query_chip_num_on_platform(struct hccs_dev *hdev) 277 { 278 struct hccs_desc desc; 279 int ret; 280 281 hccs_init_req_desc(&desc); 282 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_CHIP_NUM, &desc); 283 if (ret) { 284 dev_err(hdev->dev, "query system chip number failed, ret = %d.\n", 285 ret); 286 return ret; 287 } 288 289 hdev->chip_num = *((u8 *)&desc.rsp.data); 290 if (!hdev->chip_num) { 291 dev_err(hdev->dev, "chip num obtained from firmware is zero.\n"); 292 return -EINVAL; 293 } 294 295 return 0; 296 } 297 298 static int hccs_get_chip_info(struct hccs_dev *hdev, 299 struct hccs_chip_info *chip) 300 { 301 struct hccs_die_num_req_param *req_param; 302 struct hccs_desc desc; 303 int ret; 304 305 hccs_init_req_desc(&desc); 306 req_param = (struct hccs_die_num_req_param *)desc.req.data; 307 req_param->chip_id = chip->chip_id; 308 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_NUM, &desc); 309 if (ret) 310 return ret; 311 312 chip->die_num = *((u8 *)&desc.rsp.data); 313 314 return 0; 315 } 316 317 static int hccs_query_chip_info_on_platform(struct hccs_dev *hdev) 318 { 319 struct hccs_chip_info *chip; 320 int ret; 321 u8 idx; 322 323 ret = hccs_query_chip_num_on_platform(hdev); 324 if (ret) { 325 dev_err(hdev->dev, "query chip number on platform failed, ret = %d.\n", 326 ret); 327 return ret; 328 } 329 330 hdev->chips = devm_kzalloc(hdev->dev, 331 hdev->chip_num * sizeof(struct hccs_chip_info), 332 GFP_KERNEL); 333 if (!hdev->chips) { 334 dev_err(hdev->dev, "allocate all chips memory failed.\n"); 335 return -ENOMEM; 336 } 337 338 for (idx = 0; idx < hdev->chip_num; idx++) { 339 chip = &hdev->chips[idx]; 340 chip->chip_id = idx; 341 ret = hccs_get_chip_info(hdev, chip); 342 if (ret) { 343 dev_err(hdev->dev, "get chip%u info failed, ret = %d.\n", 344 idx, ret); 345 return ret; 346 } 347 chip->hdev = hdev; 348 } 349 350 return 0; 351 } 352 353 static int hccs_query_die_info_on_chip(struct hccs_dev *hdev, u8 chip_id, 354 u8 die_idx, struct hccs_die_info *die) 355 { 356 struct hccs_die_info_req_param *req_param; 357 struct hccs_die_info_rsp_data *rsp_data; 358 struct hccs_desc desc; 359 int ret; 360 361 hccs_init_req_desc(&desc); 362 req_param = (struct hccs_die_info_req_param *)desc.req.data; 363 req_param->chip_id = chip_id; 364 req_param->die_idx = die_idx; 365 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_INFO, &desc); 366 if (ret) 367 return ret; 368 369 rsp_data = (struct hccs_die_info_rsp_data *)desc.rsp.data; 370 die->die_id = rsp_data->die_id; 371 die->port_num = rsp_data->port_num; 372 die->min_port_id = rsp_data->min_port_id; 373 die->max_port_id = rsp_data->max_port_id; 374 if (die->min_port_id > die->max_port_id) { 375 dev_err(hdev->dev, "min port id(%u) > max port id(%u) on die_idx(%u).\n", 376 die->min_port_id, die->max_port_id, die_idx); 377 return -EINVAL; 378 } 379 if (die->max_port_id > HCCS_DIE_MAX_PORT_ID) { 380 dev_err(hdev->dev, "max port id(%u) on die_idx(%u) is too big.\n", 381 die->max_port_id, die_idx); 382 return -EINVAL; 383 } 384 385 return 0; 386 } 387 388 static int hccs_query_all_die_info_on_platform(struct hccs_dev *hdev) 389 { 390 struct device *dev = hdev->dev; 391 struct hccs_chip_info *chip; 392 struct hccs_die_info *die; 393 u8 i, j; 394 int ret; 395 396 for (i = 0; i < hdev->chip_num; i++) { 397 chip = &hdev->chips[i]; 398 if (!chip->die_num) 399 continue; 400 401 chip->dies = devm_kzalloc(hdev->dev, 402 chip->die_num * sizeof(struct hccs_die_info), 403 GFP_KERNEL); 404 if (!chip->dies) { 405 dev_err(dev, "allocate all dies memory on chip%u failed.\n", 406 i); 407 return -ENOMEM; 408 } 409 410 for (j = 0; j < chip->die_num; j++) { 411 die = &chip->dies[j]; 412 ret = hccs_query_die_info_on_chip(hdev, i, j, die); 413 if (ret) { 414 dev_err(dev, "get die idx (%u) info on chip%u failed, ret = %d.\n", 415 j, i, ret); 416 return ret; 417 } 418 die->chip = chip; 419 } 420 } 421 422 return 0; 423 } 424 425 static int hccs_get_bd_info(struct hccs_dev *hdev, u8 opcode, 426 struct hccs_desc *desc, 427 void *buf, size_t buf_len, 428 struct hccs_rsp_head *rsp_head) 429 { 430 struct hccs_rsp_head *head; 431 struct hccs_rsp_desc *rsp; 432 int ret; 433 434 ret = hccs_pcc_cmd_send(hdev, opcode, desc); 435 if (ret) 436 return ret; 437 438 rsp = &desc->rsp; 439 head = &rsp->rsp_head; 440 if (head->data_len > buf_len) { 441 dev_err(hdev->dev, 442 "buffer overflow (buf_len = %zu, data_len = %u)!\n", 443 buf_len, head->data_len); 444 return -ENOMEM; 445 } 446 447 memcpy(buf, rsp->data, head->data_len); 448 *rsp_head = *head; 449 450 return 0; 451 } 452 453 static int hccs_get_all_port_attr(struct hccs_dev *hdev, 454 struct hccs_die_info *die, 455 struct hccs_port_attr *attrs, u16 size) 456 { 457 struct hccs_die_comm_req_param *req_param; 458 struct hccs_req_head *req_head; 459 struct hccs_rsp_head rsp_head; 460 struct hccs_desc desc; 461 size_t left_buf_len; 462 u32 data_len = 0; 463 u8 start_id; 464 u8 *buf; 465 int ret; 466 467 buf = (u8 *)attrs; 468 left_buf_len = sizeof(struct hccs_port_attr) * size; 469 start_id = die->min_port_id; 470 while (start_id <= die->max_port_id) { 471 hccs_init_req_desc(&desc); 472 req_head = &desc.req.req_head; 473 req_head->start_id = start_id; 474 req_param = (struct hccs_die_comm_req_param *)desc.req.data; 475 req_param->chip_id = die->chip->chip_id; 476 req_param->die_id = die->die_id; 477 478 ret = hccs_get_bd_info(hdev, HCCS_GET_DIE_PORT_INFO, &desc, 479 buf + data_len, left_buf_len, &rsp_head); 480 if (ret) { 481 dev_err(hdev->dev, 482 "get the information of port%u on die%u failed, ret = %d.\n", 483 start_id, die->die_id, ret); 484 return ret; 485 } 486 487 data_len += rsp_head.data_len; 488 left_buf_len -= rsp_head.data_len; 489 if (unlikely(rsp_head.next_id <= start_id)) { 490 dev_err(hdev->dev, 491 "next port id (%u) is not greater than last start id (%u) on die%u.\n", 492 rsp_head.next_id, start_id, die->die_id); 493 return -EINVAL; 494 } 495 start_id = rsp_head.next_id; 496 } 497 498 return 0; 499 } 500 501 static int hccs_get_all_port_info_on_die(struct hccs_dev *hdev, 502 struct hccs_die_info *die) 503 { 504 struct hccs_port_attr *attrs; 505 struct hccs_port_info *port; 506 int ret; 507 u8 i; 508 509 attrs = kcalloc(die->port_num, sizeof(struct hccs_port_attr), 510 GFP_KERNEL); 511 if (!attrs) 512 return -ENOMEM; 513 514 ret = hccs_get_all_port_attr(hdev, die, attrs, die->port_num); 515 if (ret) 516 goto out; 517 518 for (i = 0; i < die->port_num; i++) { 519 port = &die->ports[i]; 520 port->port_id = attrs[i].port_id; 521 port->port_type = attrs[i].port_type; 522 port->lane_mode = attrs[i].lane_mode; 523 port->enable = attrs[i].enable; 524 port->die = die; 525 } 526 527 out: 528 kfree(attrs); 529 return ret; 530 } 531 532 static int hccs_query_all_port_info_on_platform(struct hccs_dev *hdev) 533 { 534 535 struct device *dev = hdev->dev; 536 struct hccs_chip_info *chip; 537 struct hccs_die_info *die; 538 u8 i, j; 539 int ret; 540 541 for (i = 0; i < hdev->chip_num; i++) { 542 chip = &hdev->chips[i]; 543 for (j = 0; j < chip->die_num; j++) { 544 die = &chip->dies[j]; 545 if (!die->port_num) 546 continue; 547 548 die->ports = devm_kzalloc(dev, 549 die->port_num * sizeof(struct hccs_port_info), 550 GFP_KERNEL); 551 if (!die->ports) { 552 dev_err(dev, "allocate ports memory on chip%u/die%u failed.\n", 553 i, die->die_id); 554 return -ENOMEM; 555 } 556 557 ret = hccs_get_all_port_info_on_die(hdev, die); 558 if (ret) { 559 dev_err(dev, "get all port info on chip%u/die%u failed, ret = %d.\n", 560 i, die->die_id, ret); 561 return ret; 562 } 563 } 564 } 565 566 return 0; 567 } 568 569 static int hccs_get_hw_info(struct hccs_dev *hdev) 570 { 571 int ret; 572 573 ret = hccs_query_chip_info_on_platform(hdev); 574 if (ret) { 575 dev_err(hdev->dev, "query chip info on platform failed, ret = %d.\n", 576 ret); 577 return ret; 578 } 579 580 ret = hccs_query_all_die_info_on_platform(hdev); 581 if (ret) { 582 dev_err(hdev->dev, "query all die info on platform failed, ret = %d.\n", 583 ret); 584 return ret; 585 } 586 587 ret = hccs_query_all_port_info_on_platform(hdev); 588 if (ret) { 589 dev_err(hdev->dev, "query all port info on platform failed, ret = %d.\n", 590 ret); 591 return ret; 592 } 593 594 return 0; 595 } 596 597 static int hccs_query_port_link_status(struct hccs_dev *hdev, 598 const struct hccs_port_info *port, 599 struct hccs_link_status *link_status) 600 { 601 const struct hccs_die_info *die = port->die; 602 const struct hccs_chip_info *chip = die->chip; 603 struct hccs_port_comm_req_param *req_param; 604 struct hccs_desc desc; 605 int ret; 606 607 hccs_init_req_desc(&desc); 608 req_param = (struct hccs_port_comm_req_param *)desc.req.data; 609 req_param->chip_id = chip->chip_id; 610 req_param->die_id = die->die_id; 611 req_param->port_id = port->port_id; 612 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_PORT_LINK_STATUS, &desc); 613 if (ret) { 614 dev_err(hdev->dev, 615 "get port link status info failed, ret = %d.\n", ret); 616 return ret; 617 } 618 619 *link_status = *((struct hccs_link_status *)desc.rsp.data); 620 621 return 0; 622 } 623 624 static int hccs_query_port_crc_err_cnt(struct hccs_dev *hdev, 625 const struct hccs_port_info *port, 626 u64 *crc_err_cnt) 627 { 628 const struct hccs_die_info *die = port->die; 629 const struct hccs_chip_info *chip = die->chip; 630 struct hccs_port_comm_req_param *req_param; 631 struct hccs_desc desc; 632 int ret; 633 634 hccs_init_req_desc(&desc); 635 req_param = (struct hccs_port_comm_req_param *)desc.req.data; 636 req_param->chip_id = chip->chip_id; 637 req_param->die_id = die->die_id; 638 req_param->port_id = port->port_id; 639 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_PORT_CRC_ERR_CNT, &desc); 640 if (ret) { 641 dev_err(hdev->dev, 642 "get port crc error count failed, ret = %d.\n", ret); 643 return ret; 644 } 645 646 memcpy(crc_err_cnt, &desc.rsp.data, sizeof(u64)); 647 648 return 0; 649 } 650 651 static int hccs_get_die_all_link_status(struct hccs_dev *hdev, 652 const struct hccs_die_info *die, 653 u8 *all_linked) 654 { 655 struct hccs_die_comm_req_param *req_param; 656 struct hccs_desc desc; 657 int ret; 658 659 if (die->port_num == 0) { 660 *all_linked = 1; 661 return 0; 662 } 663 664 hccs_init_req_desc(&desc); 665 req_param = (struct hccs_die_comm_req_param *)desc.req.data; 666 req_param->chip_id = die->chip->chip_id; 667 req_param->die_id = die->die_id; 668 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_PORTS_LINK_STA, &desc); 669 if (ret) { 670 dev_err(hdev->dev, 671 "get link status of all ports failed on die%u, ret = %d.\n", 672 die->die_id, ret); 673 return ret; 674 } 675 676 *all_linked = *((u8 *)&desc.rsp.data); 677 678 return 0; 679 } 680 681 static int hccs_get_die_all_port_lane_status(struct hccs_dev *hdev, 682 const struct hccs_die_info *die, 683 u8 *full_lane) 684 { 685 struct hccs_die_comm_req_param *req_param; 686 struct hccs_desc desc; 687 int ret; 688 689 if (die->port_num == 0) { 690 *full_lane = 1; 691 return 0; 692 } 693 694 hccs_init_req_desc(&desc); 695 req_param = (struct hccs_die_comm_req_param *)desc.req.data; 696 req_param->chip_id = die->chip->chip_id; 697 req_param->die_id = die->die_id; 698 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_PORTS_LANE_STA, &desc); 699 if (ret) { 700 dev_err(hdev->dev, "get lane status of all ports failed on die%u, ret = %d.\n", 701 die->die_id, ret); 702 return ret; 703 } 704 705 *full_lane = *((u8 *)&desc.rsp.data); 706 707 return 0; 708 } 709 710 static int hccs_get_die_total_crc_err_cnt(struct hccs_dev *hdev, 711 const struct hccs_die_info *die, 712 u64 *total_crc_err_cnt) 713 { 714 struct hccs_die_comm_req_param *req_param; 715 struct hccs_desc desc; 716 int ret; 717 718 if (die->port_num == 0) { 719 *total_crc_err_cnt = 0; 720 return 0; 721 } 722 723 hccs_init_req_desc(&desc); 724 req_param = (struct hccs_die_comm_req_param *)desc.req.data; 725 req_param->chip_id = die->chip->chip_id; 726 req_param->die_id = die->die_id; 727 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_PORTS_CRC_ERR_CNT, &desc); 728 if (ret) { 729 dev_err(hdev->dev, "get crc error count sum failed on die%u, ret = %d.\n", 730 die->die_id, ret); 731 return ret; 732 } 733 734 memcpy(total_crc_err_cnt, &desc.rsp.data, sizeof(u64)); 735 736 return 0; 737 } 738 739 static ssize_t hccs_show(struct kobject *k, struct attribute *attr, char *buf) 740 { 741 struct kobj_attribute *kobj_attr; 742 743 kobj_attr = container_of(attr, struct kobj_attribute, attr); 744 745 return kobj_attr->show(k, kobj_attr, buf); 746 } 747 748 static const struct sysfs_ops hccs_comm_ops = { 749 .show = hccs_show, 750 }; 751 752 static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr, 753 char *buf) 754 { 755 const struct hccs_port_info *port = kobj_to_port_info(kobj); 756 757 return sysfs_emit(buf, "HCCS-v%u\n", port->port_type); 758 } 759 static struct kobj_attribute hccs_type_attr = __ATTR_RO(type); 760 761 static ssize_t lane_mode_show(struct kobject *kobj, struct kobj_attribute *attr, 762 char *buf) 763 { 764 const struct hccs_port_info *port = kobj_to_port_info(kobj); 765 766 return sysfs_emit(buf, "x%u\n", port->lane_mode); 767 } 768 static struct kobj_attribute lane_mode_attr = __ATTR_RO(lane_mode); 769 770 static ssize_t enable_show(struct kobject *kobj, 771 struct kobj_attribute *attr, char *buf) 772 { 773 const struct hccs_port_info *port = kobj_to_port_info(kobj); 774 775 return sysfs_emit(buf, "%u\n", port->enable); 776 } 777 static struct kobj_attribute port_enable_attr = __ATTR_RO(enable); 778 779 static ssize_t cur_lane_num_show(struct kobject *kobj, 780 struct kobj_attribute *attr, char *buf) 781 { 782 const struct hccs_port_info *port = kobj_to_port_info(kobj); 783 struct hccs_dev *hdev = port->die->chip->hdev; 784 struct hccs_link_status link_status = {0}; 785 int ret; 786 787 mutex_lock(&hdev->lock); 788 ret = hccs_query_port_link_status(hdev, port, &link_status); 789 mutex_unlock(&hdev->lock); 790 if (ret) 791 return ret; 792 793 return sysfs_emit(buf, "%u\n", link_status.lane_num); 794 } 795 static struct kobj_attribute cur_lane_num_attr = __ATTR_RO(cur_lane_num); 796 797 static ssize_t link_fsm_show(struct kobject *kobj, 798 struct kobj_attribute *attr, char *buf) 799 { 800 const struct hccs_port_info *port = kobj_to_port_info(kobj); 801 struct hccs_dev *hdev = port->die->chip->hdev; 802 struct hccs_link_status link_status = {0}; 803 const struct { 804 u8 link_fsm; 805 char *str; 806 } link_fsm_map[] = { 807 {HCCS_PORT_RESET, "reset"}, 808 {HCCS_PORT_SETUP, "setup"}, 809 {HCCS_PORT_CONFIG, "config"}, 810 {HCCS_PORT_READY, "link-up"}, 811 }; 812 const char *link_fsm_str = "unknown"; 813 size_t i; 814 int ret; 815 816 mutex_lock(&hdev->lock); 817 ret = hccs_query_port_link_status(hdev, port, &link_status); 818 mutex_unlock(&hdev->lock); 819 if (ret) 820 return ret; 821 822 for (i = 0; i < ARRAY_SIZE(link_fsm_map); i++) { 823 if (link_fsm_map[i].link_fsm == link_status.link_fsm) { 824 link_fsm_str = link_fsm_map[i].str; 825 break; 826 } 827 } 828 829 return sysfs_emit(buf, "%s\n", link_fsm_str); 830 } 831 static struct kobj_attribute link_fsm_attr = __ATTR_RO(link_fsm); 832 833 static ssize_t lane_mask_show(struct kobject *kobj, 834 struct kobj_attribute *attr, char *buf) 835 { 836 const struct hccs_port_info *port = kobj_to_port_info(kobj); 837 struct hccs_dev *hdev = port->die->chip->hdev; 838 struct hccs_link_status link_status = {0}; 839 int ret; 840 841 mutex_lock(&hdev->lock); 842 ret = hccs_query_port_link_status(hdev, port, &link_status); 843 mutex_unlock(&hdev->lock); 844 if (ret) 845 return ret; 846 847 return sysfs_emit(buf, "0x%x\n", link_status.lane_mask); 848 } 849 static struct kobj_attribute lane_mask_attr = __ATTR_RO(lane_mask); 850 851 static ssize_t crc_err_cnt_show(struct kobject *kobj, 852 struct kobj_attribute *attr, char *buf) 853 { 854 const struct hccs_port_info *port = kobj_to_port_info(kobj); 855 struct hccs_dev *hdev = port->die->chip->hdev; 856 u64 crc_err_cnt; 857 int ret; 858 859 mutex_lock(&hdev->lock); 860 ret = hccs_query_port_crc_err_cnt(hdev, port, &crc_err_cnt); 861 mutex_unlock(&hdev->lock); 862 if (ret) 863 return ret; 864 865 return sysfs_emit(buf, "%llu\n", crc_err_cnt); 866 } 867 static struct kobj_attribute crc_err_cnt_attr = __ATTR_RO(crc_err_cnt); 868 869 static struct attribute *hccs_port_default_attrs[] = { 870 &hccs_type_attr.attr, 871 &lane_mode_attr.attr, 872 &port_enable_attr.attr, 873 &cur_lane_num_attr.attr, 874 &link_fsm_attr.attr, 875 &lane_mask_attr.attr, 876 &crc_err_cnt_attr.attr, 877 NULL, 878 }; 879 ATTRIBUTE_GROUPS(hccs_port_default); 880 881 static const struct kobj_type hccs_port_type = { 882 .sysfs_ops = &hccs_comm_ops, 883 .default_groups = hccs_port_default_groups, 884 }; 885 886 static ssize_t all_linked_on_die_show(struct kobject *kobj, 887 struct kobj_attribute *attr, char *buf) 888 { 889 const struct hccs_die_info *die = kobj_to_die_info(kobj); 890 struct hccs_dev *hdev = die->chip->hdev; 891 u8 all_linked; 892 int ret; 893 894 mutex_lock(&hdev->lock); 895 ret = hccs_get_die_all_link_status(hdev, die, &all_linked); 896 mutex_unlock(&hdev->lock); 897 if (ret) 898 return ret; 899 900 return sysfs_emit(buf, "%u\n", all_linked); 901 } 902 static struct kobj_attribute all_linked_on_die_attr = 903 __ATTR(all_linked, 0444, all_linked_on_die_show, NULL); 904 905 static ssize_t linked_full_lane_on_die_show(struct kobject *kobj, 906 struct kobj_attribute *attr, 907 char *buf) 908 { 909 const struct hccs_die_info *die = kobj_to_die_info(kobj); 910 struct hccs_dev *hdev = die->chip->hdev; 911 u8 full_lane; 912 int ret; 913 914 mutex_lock(&hdev->lock); 915 ret = hccs_get_die_all_port_lane_status(hdev, die, &full_lane); 916 mutex_unlock(&hdev->lock); 917 if (ret) 918 return ret; 919 920 return sysfs_emit(buf, "%u\n", full_lane); 921 } 922 static struct kobj_attribute linked_full_lane_on_die_attr = 923 __ATTR(linked_full_lane, 0444, linked_full_lane_on_die_show, NULL); 924 925 static ssize_t crc_err_cnt_sum_on_die_show(struct kobject *kobj, 926 struct kobj_attribute *attr, 927 char *buf) 928 { 929 const struct hccs_die_info *die = kobj_to_die_info(kobj); 930 struct hccs_dev *hdev = die->chip->hdev; 931 u64 total_crc_err_cnt; 932 int ret; 933 934 mutex_lock(&hdev->lock); 935 ret = hccs_get_die_total_crc_err_cnt(hdev, die, &total_crc_err_cnt); 936 mutex_unlock(&hdev->lock); 937 if (ret) 938 return ret; 939 940 return sysfs_emit(buf, "%llu\n", total_crc_err_cnt); 941 } 942 static struct kobj_attribute crc_err_cnt_sum_on_die_attr = 943 __ATTR(crc_err_cnt, 0444, crc_err_cnt_sum_on_die_show, NULL); 944 945 static struct attribute *hccs_die_default_attrs[] = { 946 &all_linked_on_die_attr.attr, 947 &linked_full_lane_on_die_attr.attr, 948 &crc_err_cnt_sum_on_die_attr.attr, 949 NULL, 950 }; 951 ATTRIBUTE_GROUPS(hccs_die_default); 952 953 static const struct kobj_type hccs_die_type = { 954 .sysfs_ops = &hccs_comm_ops, 955 .default_groups = hccs_die_default_groups, 956 }; 957 958 static ssize_t all_linked_on_chip_show(struct kobject *kobj, 959 struct kobj_attribute *attr, char *buf) 960 { 961 const struct hccs_chip_info *chip = kobj_to_chip_info(kobj); 962 struct hccs_dev *hdev = chip->hdev; 963 const struct hccs_die_info *die; 964 u8 all_linked = 1; 965 u8 i, tmp; 966 int ret; 967 968 mutex_lock(&hdev->lock); 969 for (i = 0; i < chip->die_num; i++) { 970 die = &chip->dies[i]; 971 ret = hccs_get_die_all_link_status(hdev, die, &tmp); 972 if (ret) { 973 mutex_unlock(&hdev->lock); 974 return ret; 975 } 976 if (tmp != all_linked) { 977 all_linked = 0; 978 break; 979 } 980 } 981 mutex_unlock(&hdev->lock); 982 983 return sysfs_emit(buf, "%u\n", all_linked); 984 } 985 static struct kobj_attribute all_linked_on_chip_attr = 986 __ATTR(all_linked, 0444, all_linked_on_chip_show, NULL); 987 988 static ssize_t linked_full_lane_on_chip_show(struct kobject *kobj, 989 struct kobj_attribute *attr, 990 char *buf) 991 { 992 const struct hccs_chip_info *chip = kobj_to_chip_info(kobj); 993 struct hccs_dev *hdev = chip->hdev; 994 const struct hccs_die_info *die; 995 u8 full_lane = 1; 996 u8 i, tmp; 997 int ret; 998 999 mutex_lock(&hdev->lock); 1000 for (i = 0; i < chip->die_num; i++) { 1001 die = &chip->dies[i]; 1002 ret = hccs_get_die_all_port_lane_status(hdev, die, &tmp); 1003 if (ret) { 1004 mutex_unlock(&hdev->lock); 1005 return ret; 1006 } 1007 if (tmp != full_lane) { 1008 full_lane = 0; 1009 break; 1010 } 1011 } 1012 mutex_unlock(&hdev->lock); 1013 1014 return sysfs_emit(buf, "%u\n", full_lane); 1015 } 1016 static struct kobj_attribute linked_full_lane_on_chip_attr = 1017 __ATTR(linked_full_lane, 0444, linked_full_lane_on_chip_show, NULL); 1018 1019 static ssize_t crc_err_cnt_sum_on_chip_show(struct kobject *kobj, 1020 struct kobj_attribute *attr, 1021 char *buf) 1022 { 1023 const struct hccs_chip_info *chip = kobj_to_chip_info(kobj); 1024 u64 crc_err_cnt, total_crc_err_cnt = 0; 1025 struct hccs_dev *hdev = chip->hdev; 1026 const struct hccs_die_info *die; 1027 int ret; 1028 u16 i; 1029 1030 mutex_lock(&hdev->lock); 1031 for (i = 0; i < chip->die_num; i++) { 1032 die = &chip->dies[i]; 1033 ret = hccs_get_die_total_crc_err_cnt(hdev, die, &crc_err_cnt); 1034 if (ret) { 1035 mutex_unlock(&hdev->lock); 1036 return ret; 1037 } 1038 1039 total_crc_err_cnt += crc_err_cnt; 1040 } 1041 mutex_unlock(&hdev->lock); 1042 1043 return sysfs_emit(buf, "%llu\n", total_crc_err_cnt); 1044 } 1045 static struct kobj_attribute crc_err_cnt_sum_on_chip_attr = 1046 __ATTR(crc_err_cnt, 0444, crc_err_cnt_sum_on_chip_show, NULL); 1047 1048 static struct attribute *hccs_chip_default_attrs[] = { 1049 &all_linked_on_chip_attr.attr, 1050 &linked_full_lane_on_chip_attr.attr, 1051 &crc_err_cnt_sum_on_chip_attr.attr, 1052 NULL, 1053 }; 1054 ATTRIBUTE_GROUPS(hccs_chip_default); 1055 1056 static const struct kobj_type hccs_chip_type = { 1057 .sysfs_ops = &hccs_comm_ops, 1058 .default_groups = hccs_chip_default_groups, 1059 }; 1060 1061 static void hccs_remove_die_dir(struct hccs_die_info *die) 1062 { 1063 struct hccs_port_info *port; 1064 u8 i; 1065 1066 for (i = 0; i < die->port_num; i++) { 1067 port = &die->ports[i]; 1068 if (port->dir_created) 1069 kobject_put(&port->kobj); 1070 } 1071 1072 kobject_put(&die->kobj); 1073 } 1074 1075 static void hccs_remove_chip_dir(struct hccs_chip_info *chip) 1076 { 1077 struct hccs_die_info *die; 1078 u8 i; 1079 1080 for (i = 0; i < chip->die_num; i++) { 1081 die = &chip->dies[i]; 1082 if (die->dir_created) 1083 hccs_remove_die_dir(die); 1084 } 1085 1086 kobject_put(&chip->kobj); 1087 } 1088 1089 static void hccs_remove_topo_dirs(struct hccs_dev *hdev) 1090 { 1091 u8 i; 1092 1093 for (i = 0; i < hdev->chip_num; i++) 1094 hccs_remove_chip_dir(&hdev->chips[i]); 1095 } 1096 1097 static int hccs_create_hccs_dir(struct hccs_dev *hdev, 1098 struct hccs_die_info *die, 1099 struct hccs_port_info *port) 1100 { 1101 int ret; 1102 1103 ret = kobject_init_and_add(&port->kobj, &hccs_port_type, 1104 &die->kobj, "hccs%d", port->port_id); 1105 if (ret) { 1106 kobject_put(&port->kobj); 1107 return ret; 1108 } 1109 1110 return 0; 1111 } 1112 1113 static int hccs_create_die_dir(struct hccs_dev *hdev, 1114 struct hccs_chip_info *chip, 1115 struct hccs_die_info *die) 1116 { 1117 struct hccs_port_info *port; 1118 int ret; 1119 u16 i; 1120 1121 ret = kobject_init_and_add(&die->kobj, &hccs_die_type, 1122 &chip->kobj, "die%d", die->die_id); 1123 if (ret) { 1124 kobject_put(&die->kobj); 1125 return ret; 1126 } 1127 1128 for (i = 0; i < die->port_num; i++) { 1129 port = &die->ports[i]; 1130 ret = hccs_create_hccs_dir(hdev, die, port); 1131 if (ret) { 1132 dev_err(hdev->dev, "create hccs%d dir failed.\n", 1133 port->port_id); 1134 goto err; 1135 } 1136 port->dir_created = true; 1137 } 1138 1139 return 0; 1140 err: 1141 hccs_remove_die_dir(die); 1142 1143 return ret; 1144 } 1145 1146 static int hccs_create_chip_dir(struct hccs_dev *hdev, 1147 struct hccs_chip_info *chip) 1148 { 1149 struct hccs_die_info *die; 1150 int ret; 1151 u16 id; 1152 1153 ret = kobject_init_and_add(&chip->kobj, &hccs_chip_type, 1154 &hdev->dev->kobj, "chip%d", chip->chip_id); 1155 if (ret) { 1156 kobject_put(&chip->kobj); 1157 return ret; 1158 } 1159 1160 for (id = 0; id < chip->die_num; id++) { 1161 die = &chip->dies[id]; 1162 ret = hccs_create_die_dir(hdev, chip, die); 1163 if (ret) 1164 goto err; 1165 die->dir_created = true; 1166 } 1167 1168 return 0; 1169 err: 1170 hccs_remove_chip_dir(chip); 1171 1172 return ret; 1173 } 1174 1175 static int hccs_create_topo_dirs(struct hccs_dev *hdev) 1176 { 1177 struct hccs_chip_info *chip; 1178 u8 id, k; 1179 int ret; 1180 1181 for (id = 0; id < hdev->chip_num; id++) { 1182 chip = &hdev->chips[id]; 1183 ret = hccs_create_chip_dir(hdev, chip); 1184 if (ret) { 1185 dev_err(hdev->dev, "init chip%d dir failed!\n", id); 1186 goto err; 1187 } 1188 } 1189 1190 return 0; 1191 err: 1192 for (k = 0; k < id; k++) 1193 hccs_remove_chip_dir(&hdev->chips[k]); 1194 1195 return ret; 1196 } 1197 1198 static int hccs_probe(struct platform_device *pdev) 1199 { 1200 struct acpi_device *acpi_dev; 1201 struct hccs_dev *hdev; 1202 int rc; 1203 1204 if (acpi_disabled) { 1205 dev_err(&pdev->dev, "acpi is disabled.\n"); 1206 return -ENODEV; 1207 } 1208 acpi_dev = ACPI_COMPANION(&pdev->dev); 1209 if (!acpi_dev) 1210 return -ENODEV; 1211 1212 hdev = devm_kzalloc(&pdev->dev, sizeof(*hdev), GFP_KERNEL); 1213 if (!hdev) 1214 return -ENOMEM; 1215 hdev->acpi_dev = acpi_dev; 1216 hdev->dev = &pdev->dev; 1217 platform_set_drvdata(pdev, hdev); 1218 1219 mutex_init(&hdev->lock); 1220 rc = hccs_get_pcc_chan_id(hdev); 1221 if (rc) 1222 return rc; 1223 rc = hccs_register_pcc_channel(hdev); 1224 if (rc) 1225 return rc; 1226 1227 rc = hccs_get_dev_caps(hdev); 1228 if (rc) 1229 goto unregister_pcc_chan; 1230 1231 rc = hccs_get_hw_info(hdev); 1232 if (rc) 1233 goto unregister_pcc_chan; 1234 1235 rc = hccs_create_topo_dirs(hdev); 1236 if (rc) 1237 goto unregister_pcc_chan; 1238 1239 return 0; 1240 1241 unregister_pcc_chan: 1242 hccs_unregister_pcc_channel(hdev); 1243 1244 return rc; 1245 } 1246 1247 static int hccs_remove(struct platform_device *pdev) 1248 { 1249 struct hccs_dev *hdev = platform_get_drvdata(pdev); 1250 1251 hccs_remove_topo_dirs(hdev); 1252 hccs_unregister_pcc_channel(hdev); 1253 1254 return 0; 1255 } 1256 1257 static const struct acpi_device_id hccs_acpi_match[] = { 1258 { "HISI04B1"}, 1259 { ""}, 1260 }; 1261 MODULE_DEVICE_TABLE(acpi, hccs_acpi_match); 1262 1263 static struct platform_driver hccs_driver = { 1264 .probe = hccs_probe, 1265 .remove = hccs_remove, 1266 .driver = { 1267 .name = "kunpeng_hccs", 1268 .acpi_match_table = hccs_acpi_match, 1269 }, 1270 }; 1271 1272 module_platform_driver(hccs_driver); 1273 1274 MODULE_DESCRIPTION("Kunpeng SoC HCCS driver"); 1275 MODULE_LICENSE("GPL"); 1276 MODULE_AUTHOR("Huisong Li <lihuisong@huawei.com>"); 1277