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 * - Retrieve all HCCS types used on the platform.
26 *
27 * - Support low power feature for all specified HCCS type ports, and
28 * provide the following interface:
29 * - query HCCS types supported increasing and decreasing lane number.
30 * - decrease lane number of all specified HCCS type ports on idle state.
31 * - increase lane number of all specified HCCS type ports.
32 */
33 #include <linux/acpi.h>
34 #include <linux/delay.h>
35 #include <linux/iopoll.h>
36 #include <linux/platform_device.h>
37 #include <linux/stringify.h>
38 #include <linux/sysfs.h>
39 #include <linux/types.h>
40
41 #include <acpi/pcc.h>
42
43 #include "kunpeng_hccs.h"
44
45 /*
46 * Arbitrary retries in case the remote processor is slow to respond
47 * to PCC commands
48 */
49 #define HCCS_PCC_CMD_WAIT_RETRIES_NUM 500ULL
50 #define HCCS_POLL_STATUS_TIME_INTERVAL_US 3
51
kobj_to_port_info(struct kobject * k)52 static struct hccs_port_info *kobj_to_port_info(struct kobject *k)
53 {
54 return container_of(k, struct hccs_port_info, kobj);
55 }
56
kobj_to_die_info(struct kobject * k)57 static struct hccs_die_info *kobj_to_die_info(struct kobject *k)
58 {
59 return container_of(k, struct hccs_die_info, kobj);
60 }
61
kobj_to_chip_info(struct kobject * k)62 static struct hccs_chip_info *kobj_to_chip_info(struct kobject *k)
63 {
64 return container_of(k, struct hccs_chip_info, kobj);
65 }
66
device_kobj_to_hccs_dev(struct kobject * k)67 static struct hccs_dev *device_kobj_to_hccs_dev(struct kobject *k)
68 {
69 struct device *dev = container_of(k, struct device, kobj);
70 struct platform_device *pdev =
71 container_of(dev, struct platform_device, dev);
72
73 return platform_get_drvdata(pdev);
74 }
75
hccs_port_type_to_name(struct hccs_dev * hdev,u8 type)76 static char *hccs_port_type_to_name(struct hccs_dev *hdev, u8 type)
77 {
78 u16 i;
79
80 for (i = 0; i < hdev->used_type_num; i++) {
81 if (hdev->type_name_maps[i].type == type)
82 return hdev->type_name_maps[i].name;
83 }
84
85 return NULL;
86 }
87
hccs_name_to_port_type(struct hccs_dev * hdev,const char * name,u8 * type)88 static int hccs_name_to_port_type(struct hccs_dev *hdev,
89 const char *name, u8 *type)
90 {
91 u16 i;
92
93 for (i = 0; i < hdev->used_type_num; i++) {
94 if (strcmp(hdev->type_name_maps[i].name, name) == 0) {
95 *type = hdev->type_name_maps[i].type;
96 return 0;
97 }
98 }
99
100 return -EINVAL;
101 }
102
103 struct hccs_register_ctx {
104 struct device *dev;
105 u8 chan_id;
106 int err;
107 };
108
hccs_get_register_cb(struct acpi_resource * ares,void * context)109 static acpi_status hccs_get_register_cb(struct acpi_resource *ares,
110 void *context)
111 {
112 struct acpi_resource_generic_register *reg;
113 struct hccs_register_ctx *ctx = context;
114
115 if (ares->type != ACPI_RESOURCE_TYPE_GENERIC_REGISTER)
116 return AE_OK;
117
118 reg = &ares->data.generic_reg;
119 if (reg->space_id != ACPI_ADR_SPACE_PLATFORM_COMM) {
120 dev_err(ctx->dev, "Bad register resource.\n");
121 ctx->err = -EINVAL;
122 return AE_ERROR;
123 }
124 ctx->chan_id = reg->access_size;
125
126 return AE_OK;
127 }
128
hccs_get_pcc_chan_id(struct hccs_dev * hdev)129 static int hccs_get_pcc_chan_id(struct hccs_dev *hdev)
130 {
131 acpi_handle handle = ACPI_HANDLE(hdev->dev);
132 struct hccs_register_ctx ctx = {0};
133 acpi_status status;
134
135 if (!acpi_has_method(handle, METHOD_NAME__CRS)) {
136 dev_err(hdev->dev, "No _CRS method.\n");
137 return -ENODEV;
138 }
139
140 ctx.dev = hdev->dev;
141 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
142 hccs_get_register_cb, &ctx);
143 if (ACPI_FAILURE(status))
144 return ctx.err;
145 hdev->chan_id = ctx.chan_id;
146
147 return 0;
148 }
149
hccs_chan_tx_done(struct mbox_client * cl,void * msg,int ret)150 static void hccs_chan_tx_done(struct mbox_client *cl, void *msg, int ret)
151 {
152 if (ret < 0)
153 pr_debug("TX did not complete: CMD sent:0x%x, ret:%d\n",
154 *(u8 *)msg, ret);
155 else
156 pr_debug("TX completed. CMD sent:0x%x, ret:%d\n",
157 *(u8 *)msg, ret);
158 }
159
hccs_pcc_rx_callback(struct mbox_client * cl,void * mssg)160 static void hccs_pcc_rx_callback(struct mbox_client *cl, void *mssg)
161 {
162 struct hccs_mbox_client_info *cl_info =
163 container_of(cl, struct hccs_mbox_client_info, client);
164
165 complete(&cl_info->done);
166 }
167
hccs_unregister_pcc_channel(struct hccs_dev * hdev)168 static void hccs_unregister_pcc_channel(struct hccs_dev *hdev)
169 {
170 struct hccs_mbox_client_info *cl_info = &hdev->cl_info;
171
172 if (cl_info->pcc_comm_addr)
173 iounmap(cl_info->pcc_comm_addr);
174 pcc_mbox_free_channel(hdev->cl_info.pcc_chan);
175 }
176
hccs_register_pcc_channel(struct hccs_dev * hdev)177 static int hccs_register_pcc_channel(struct hccs_dev *hdev)
178 {
179 struct hccs_mbox_client_info *cl_info = &hdev->cl_info;
180 struct mbox_client *cl = &cl_info->client;
181 struct pcc_mbox_chan *pcc_chan;
182 struct device *dev = hdev->dev;
183 int rc;
184
185 cl->dev = dev;
186 cl->tx_block = false;
187 cl->knows_txdone = true;
188 cl->tx_done = hccs_chan_tx_done;
189 cl->rx_callback = hdev->verspec_data->rx_callback;
190 init_completion(&cl_info->done);
191
192 pcc_chan = pcc_mbox_request_channel(cl, hdev->chan_id);
193 if (IS_ERR(pcc_chan)) {
194 dev_err(dev, "PCC channel request failed.\n");
195 rc = -ENODEV;
196 goto out;
197 }
198 cl_info->pcc_chan = pcc_chan;
199 cl_info->mbox_chan = pcc_chan->mchan;
200
201 /*
202 * pcc_chan->latency is just a nominal value. In reality the remote
203 * processor could be much slower to reply. So add an arbitrary amount
204 * of wait on top of nominal.
205 */
206 cl_info->deadline_us =
207 HCCS_PCC_CMD_WAIT_RETRIES_NUM * pcc_chan->latency;
208 if (!hdev->verspec_data->has_txdone_irq &&
209 cl_info->mbox_chan->mbox->txdone_irq) {
210 dev_err(dev, "PCC IRQ in PCCT is enabled.\n");
211 rc = -EINVAL;
212 goto err_mbx_channel_free;
213 } else if (hdev->verspec_data->has_txdone_irq &&
214 !cl_info->mbox_chan->mbox->txdone_irq) {
215 dev_err(dev, "PCC IRQ in PCCT isn't supported.\n");
216 rc = -EINVAL;
217 goto err_mbx_channel_free;
218 }
219
220 if (!pcc_chan->shmem_base_addr ||
221 pcc_chan->shmem_size != HCCS_PCC_SHARE_MEM_BYTES) {
222 dev_err(dev, "The base address or size (%llu) of PCC communication region is invalid.\n",
223 pcc_chan->shmem_size);
224 rc = -EINVAL;
225 goto err_mbx_channel_free;
226 }
227
228 cl_info->pcc_comm_addr = ioremap(pcc_chan->shmem_base_addr,
229 pcc_chan->shmem_size);
230 if (!cl_info->pcc_comm_addr) {
231 dev_err(dev, "Failed to ioremap PCC communication region for channel-%u.\n",
232 hdev->chan_id);
233 rc = -ENOMEM;
234 goto err_mbx_channel_free;
235 }
236
237 return 0;
238
239 err_mbx_channel_free:
240 pcc_mbox_free_channel(cl_info->pcc_chan);
241 out:
242 return rc;
243 }
244
hccs_wait_cmd_complete_by_poll(struct hccs_dev * hdev)245 static int hccs_wait_cmd_complete_by_poll(struct hccs_dev *hdev)
246 {
247 struct hccs_mbox_client_info *cl_info = &hdev->cl_info;
248 struct acpi_pcct_shared_memory __iomem *comm_base =
249 cl_info->pcc_comm_addr;
250 u16 status;
251 int ret;
252
253 /*
254 * Poll PCC status register every 3us(delay_us) for maximum of
255 * deadline_us(timeout_us) until PCC command complete bit is set(cond)
256 */
257 ret = readw_poll_timeout(&comm_base->status, status,
258 status & PCC_STATUS_CMD_COMPLETE,
259 HCCS_POLL_STATUS_TIME_INTERVAL_US,
260 cl_info->deadline_us);
261 if (unlikely(ret))
262 dev_err(hdev->dev, "poll PCC status failed, ret = %d.\n", ret);
263
264 return ret;
265 }
266
hccs_wait_cmd_complete_by_irq(struct hccs_dev * hdev)267 static int hccs_wait_cmd_complete_by_irq(struct hccs_dev *hdev)
268 {
269 struct hccs_mbox_client_info *cl_info = &hdev->cl_info;
270
271 if (!wait_for_completion_timeout(&cl_info->done,
272 usecs_to_jiffies(cl_info->deadline_us))) {
273 dev_err(hdev->dev, "PCC command executed timeout!\n");
274 return -ETIMEDOUT;
275 }
276
277 return 0;
278 }
279
hccs_fill_pcc_shared_mem_region(struct hccs_dev * hdev,u8 cmd,struct hccs_desc * desc,void __iomem * comm_space,u16 space_size)280 static inline void hccs_fill_pcc_shared_mem_region(struct hccs_dev *hdev,
281 u8 cmd,
282 struct hccs_desc *desc,
283 void __iomem *comm_space,
284 u16 space_size)
285 {
286 struct acpi_pcct_shared_memory tmp = {
287 .signature = PCC_SIGNATURE | hdev->chan_id,
288 .command = cmd,
289 .status = 0,
290 };
291
292 memcpy_toio(hdev->cl_info.pcc_comm_addr, (void *)&tmp,
293 sizeof(struct acpi_pcct_shared_memory));
294
295 /* Copy the message to the PCC comm space */
296 memcpy_toio(comm_space, (void *)desc, space_size);
297 }
298
hccs_fill_ext_pcc_shared_mem_region(struct hccs_dev * hdev,u8 cmd,struct hccs_desc * desc,void __iomem * comm_space,u16 space_size)299 static inline void hccs_fill_ext_pcc_shared_mem_region(struct hccs_dev *hdev,
300 u8 cmd,
301 struct hccs_desc *desc,
302 void __iomem *comm_space,
303 u16 space_size)
304 {
305 struct acpi_pcct_ext_pcc_shared_memory tmp = {
306 .signature = PCC_SIGNATURE | hdev->chan_id,
307 .flags = PCC_CMD_COMPLETION_NOTIFY,
308 .length = HCCS_PCC_SHARE_MEM_BYTES,
309 .command = cmd,
310 };
311
312 memcpy_toio(hdev->cl_info.pcc_comm_addr, (void *)&tmp,
313 sizeof(struct acpi_pcct_ext_pcc_shared_memory));
314
315 /* Copy the message to the PCC comm space */
316 memcpy_toio(comm_space, (void *)desc, space_size);
317 }
318
hccs_pcc_cmd_send(struct hccs_dev * hdev,u8 cmd,struct hccs_desc * desc)319 static int hccs_pcc_cmd_send(struct hccs_dev *hdev, u8 cmd,
320 struct hccs_desc *desc)
321 {
322 const struct hccs_verspecific_data *verspec_data = hdev->verspec_data;
323 struct hccs_mbox_client_info *cl_info = &hdev->cl_info;
324 struct hccs_fw_inner_head *fw_inner_head;
325 void __iomem *comm_space;
326 u16 space_size;
327 int ret;
328
329 comm_space = cl_info->pcc_comm_addr + verspec_data->shared_mem_size;
330 space_size = HCCS_PCC_SHARE_MEM_BYTES - verspec_data->shared_mem_size;
331 verspec_data->fill_pcc_shared_mem(hdev, cmd, desc,
332 comm_space, space_size);
333 if (verspec_data->has_txdone_irq)
334 reinit_completion(&cl_info->done);
335
336 /* Ring doorbell */
337 ret = mbox_send_message(cl_info->mbox_chan, &cmd);
338 if (ret < 0) {
339 dev_err(hdev->dev, "Send PCC mbox message failed, ret = %d.\n",
340 ret);
341 goto end;
342 }
343
344 ret = verspec_data->wait_cmd_complete(hdev);
345 if (ret)
346 goto end;
347
348 /* Copy response data */
349 memcpy_fromio((void *)desc, comm_space, space_size);
350 fw_inner_head = &desc->rsp.fw_inner_head;
351 if (fw_inner_head->retStatus) {
352 dev_err(hdev->dev, "Execute PCC command failed, error code = %u.\n",
353 fw_inner_head->retStatus);
354 ret = -EIO;
355 }
356
357 end:
358 if (verspec_data->has_txdone_irq)
359 mbox_chan_txdone(cl_info->mbox_chan, ret);
360 else
361 mbox_client_txdone(cl_info->mbox_chan, ret);
362 return ret;
363 }
364
hccs_init_req_desc(struct hccs_desc * desc)365 static void hccs_init_req_desc(struct hccs_desc *desc)
366 {
367 struct hccs_req_desc *req = &desc->req;
368
369 memset(desc, 0, sizeof(*desc));
370 req->req_head.module_code = HCCS_SERDES_MODULE_CODE;
371 }
372
hccs_get_dev_caps(struct hccs_dev * hdev)373 static int hccs_get_dev_caps(struct hccs_dev *hdev)
374 {
375 struct hccs_desc desc;
376 int ret;
377
378 hccs_init_req_desc(&desc);
379 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DEV_CAP, &desc);
380 if (ret) {
381 dev_err(hdev->dev, "Get device capabilities failed, ret = %d.\n",
382 ret);
383 return ret;
384 }
385 memcpy(&hdev->caps, desc.rsp.data, sizeof(hdev->caps));
386
387 return 0;
388 }
389
hccs_query_chip_num_on_platform(struct hccs_dev * hdev)390 static int hccs_query_chip_num_on_platform(struct hccs_dev *hdev)
391 {
392 struct hccs_desc desc;
393 int ret;
394
395 hccs_init_req_desc(&desc);
396 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_CHIP_NUM, &desc);
397 if (ret) {
398 dev_err(hdev->dev, "query system chip number failed, ret = %d.\n",
399 ret);
400 return ret;
401 }
402
403 hdev->chip_num = *((u8 *)&desc.rsp.data);
404 if (!hdev->chip_num) {
405 dev_err(hdev->dev, "chip num obtained from firmware is zero.\n");
406 return -EINVAL;
407 }
408
409 return 0;
410 }
411
hccs_get_chip_info(struct hccs_dev * hdev,struct hccs_chip_info * chip)412 static int hccs_get_chip_info(struct hccs_dev *hdev,
413 struct hccs_chip_info *chip)
414 {
415 struct hccs_die_num_req_param *req_param;
416 struct hccs_desc desc;
417 int ret;
418
419 hccs_init_req_desc(&desc);
420 req_param = (struct hccs_die_num_req_param *)desc.req.data;
421 req_param->chip_id = chip->chip_id;
422 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_NUM, &desc);
423 if (ret)
424 return ret;
425
426 chip->die_num = *((u8 *)&desc.rsp.data);
427
428 return 0;
429 }
430
hccs_query_chip_info_on_platform(struct hccs_dev * hdev)431 static int hccs_query_chip_info_on_platform(struct hccs_dev *hdev)
432 {
433 struct hccs_chip_info *chip;
434 int ret;
435 u8 idx;
436
437 ret = hccs_query_chip_num_on_platform(hdev);
438 if (ret) {
439 dev_err(hdev->dev, "query chip number on platform failed, ret = %d.\n",
440 ret);
441 return ret;
442 }
443
444 hdev->chips = devm_kzalloc(hdev->dev,
445 hdev->chip_num * sizeof(struct hccs_chip_info),
446 GFP_KERNEL);
447 if (!hdev->chips) {
448 dev_err(hdev->dev, "allocate all chips memory failed.\n");
449 return -ENOMEM;
450 }
451
452 for (idx = 0; idx < hdev->chip_num; idx++) {
453 chip = &hdev->chips[idx];
454 chip->chip_id = idx;
455 ret = hccs_get_chip_info(hdev, chip);
456 if (ret) {
457 dev_err(hdev->dev, "get chip%u info failed, ret = %d.\n",
458 idx, ret);
459 return ret;
460 }
461 chip->hdev = hdev;
462 }
463
464 return 0;
465 }
466
hccs_query_die_info_on_chip(struct hccs_dev * hdev,u8 chip_id,u8 die_idx,struct hccs_die_info * die)467 static int hccs_query_die_info_on_chip(struct hccs_dev *hdev, u8 chip_id,
468 u8 die_idx, struct hccs_die_info *die)
469 {
470 struct hccs_die_info_req_param *req_param;
471 struct hccs_die_info_rsp_data *rsp_data;
472 struct hccs_desc desc;
473 int ret;
474
475 hccs_init_req_desc(&desc);
476 req_param = (struct hccs_die_info_req_param *)desc.req.data;
477 req_param->chip_id = chip_id;
478 req_param->die_idx = die_idx;
479 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_INFO, &desc);
480 if (ret)
481 return ret;
482
483 rsp_data = (struct hccs_die_info_rsp_data *)desc.rsp.data;
484 die->die_id = rsp_data->die_id;
485 die->port_num = rsp_data->port_num;
486 die->min_port_id = rsp_data->min_port_id;
487 die->max_port_id = rsp_data->max_port_id;
488 if (die->min_port_id > die->max_port_id) {
489 dev_err(hdev->dev, "min port id(%u) > max port id(%u) on die_idx(%u).\n",
490 die->min_port_id, die->max_port_id, die_idx);
491 return -EINVAL;
492 }
493 if (die->max_port_id > HCCS_DIE_MAX_PORT_ID) {
494 dev_err(hdev->dev, "max port id(%u) on die_idx(%u) is too big.\n",
495 die->max_port_id, die_idx);
496 return -EINVAL;
497 }
498
499 return 0;
500 }
501
hccs_query_all_die_info_on_platform(struct hccs_dev * hdev)502 static int hccs_query_all_die_info_on_platform(struct hccs_dev *hdev)
503 {
504 struct device *dev = hdev->dev;
505 struct hccs_chip_info *chip;
506 struct hccs_die_info *die;
507 bool has_die_info = false;
508 u8 i, j;
509 int ret;
510
511 for (i = 0; i < hdev->chip_num; i++) {
512 chip = &hdev->chips[i];
513 if (!chip->die_num)
514 continue;
515
516 has_die_info = true;
517 chip->dies = devm_kzalloc(hdev->dev,
518 chip->die_num * sizeof(struct hccs_die_info),
519 GFP_KERNEL);
520 if (!chip->dies) {
521 dev_err(dev, "allocate all dies memory on chip%u failed.\n",
522 i);
523 return -ENOMEM;
524 }
525
526 for (j = 0; j < chip->die_num; j++) {
527 die = &chip->dies[j];
528 ret = hccs_query_die_info_on_chip(hdev, i, j, die);
529 if (ret) {
530 dev_err(dev, "get die idx (%u) info on chip%u failed, ret = %d.\n",
531 j, i, ret);
532 return ret;
533 }
534 die->chip = chip;
535 }
536 }
537
538 return has_die_info ? 0 : -EINVAL;
539 }
540
hccs_get_bd_info(struct hccs_dev * hdev,u8 opcode,struct hccs_desc * desc,void * buf,size_t buf_len,struct hccs_rsp_head * rsp_head)541 static int hccs_get_bd_info(struct hccs_dev *hdev, u8 opcode,
542 struct hccs_desc *desc,
543 void *buf, size_t buf_len,
544 struct hccs_rsp_head *rsp_head)
545 {
546 struct hccs_rsp_head *head;
547 struct hccs_rsp_desc *rsp;
548 int ret;
549
550 ret = hccs_pcc_cmd_send(hdev, opcode, desc);
551 if (ret)
552 return ret;
553
554 rsp = &desc->rsp;
555 head = &rsp->rsp_head;
556 if (head->data_len > buf_len) {
557 dev_err(hdev->dev,
558 "buffer overflow (buf_len = %zu, data_len = %u)!\n",
559 buf_len, head->data_len);
560 return -ENOMEM;
561 }
562
563 memcpy(buf, rsp->data, head->data_len);
564 *rsp_head = *head;
565
566 return 0;
567 }
568
hccs_get_all_port_attr(struct hccs_dev * hdev,struct hccs_die_info * die,struct hccs_port_attr * attrs,u16 size)569 static int hccs_get_all_port_attr(struct hccs_dev *hdev,
570 struct hccs_die_info *die,
571 struct hccs_port_attr *attrs, u16 size)
572 {
573 struct hccs_die_comm_req_param *req_param;
574 struct hccs_req_head *req_head;
575 struct hccs_rsp_head rsp_head;
576 struct hccs_desc desc;
577 size_t left_buf_len;
578 u32 data_len = 0;
579 u8 start_id;
580 u8 *buf;
581 int ret;
582
583 buf = (u8 *)attrs;
584 left_buf_len = sizeof(struct hccs_port_attr) * size;
585 start_id = die->min_port_id;
586 while (start_id <= die->max_port_id) {
587 hccs_init_req_desc(&desc);
588 req_head = &desc.req.req_head;
589 req_head->start_id = start_id;
590 req_param = (struct hccs_die_comm_req_param *)desc.req.data;
591 req_param->chip_id = die->chip->chip_id;
592 req_param->die_id = die->die_id;
593
594 ret = hccs_get_bd_info(hdev, HCCS_GET_DIE_PORT_INFO, &desc,
595 buf + data_len, left_buf_len, &rsp_head);
596 if (ret) {
597 dev_err(hdev->dev,
598 "get the information of port%u on die%u failed, ret = %d.\n",
599 start_id, die->die_id, ret);
600 return ret;
601 }
602
603 data_len += rsp_head.data_len;
604 left_buf_len -= rsp_head.data_len;
605 if (unlikely(rsp_head.next_id <= start_id)) {
606 dev_err(hdev->dev,
607 "next port id (%u) is not greater than last start id (%u) on die%u.\n",
608 rsp_head.next_id, start_id, die->die_id);
609 return -EINVAL;
610 }
611 start_id = rsp_head.next_id;
612 }
613
614 if (left_buf_len != 0) {
615 dev_err(hdev->dev, "failed to get the expected port number(%u) attribute.\n",
616 size);
617 return -EINVAL;
618 }
619
620 return 0;
621 }
622
hccs_get_all_port_info_on_die(struct hccs_dev * hdev,struct hccs_die_info * die)623 static int hccs_get_all_port_info_on_die(struct hccs_dev *hdev,
624 struct hccs_die_info *die)
625 {
626 struct hccs_port_attr *attrs;
627 struct hccs_port_info *port;
628 int ret;
629 u8 i;
630
631 attrs = kcalloc(die->port_num, sizeof(struct hccs_port_attr),
632 GFP_KERNEL);
633 if (!attrs)
634 return -ENOMEM;
635
636 ret = hccs_get_all_port_attr(hdev, die, attrs, die->port_num);
637 if (ret)
638 goto out;
639
640 for (i = 0; i < die->port_num; i++) {
641 port = &die->ports[i];
642 port->port_id = attrs[i].port_id;
643 port->port_type = attrs[i].port_type;
644 port->max_lane_num = attrs[i].max_lane_num;
645 port->enable = attrs[i].enable;
646 port->die = die;
647 }
648
649 out:
650 kfree(attrs);
651 return ret;
652 }
653
hccs_query_all_port_info_on_platform(struct hccs_dev * hdev)654 static int hccs_query_all_port_info_on_platform(struct hccs_dev *hdev)
655 {
656 struct device *dev = hdev->dev;
657 struct hccs_chip_info *chip;
658 struct hccs_die_info *die;
659 bool has_port_info = false;
660 u8 i, j;
661 int ret;
662
663 for (i = 0; i < hdev->chip_num; i++) {
664 chip = &hdev->chips[i];
665 for (j = 0; j < chip->die_num; j++) {
666 die = &chip->dies[j];
667 if (!die->port_num)
668 continue;
669
670 has_port_info = true;
671 die->ports = devm_kzalloc(dev,
672 die->port_num * sizeof(struct hccs_port_info),
673 GFP_KERNEL);
674 if (!die->ports) {
675 dev_err(dev, "allocate ports memory on chip%u/die%u failed.\n",
676 i, die->die_id);
677 return -ENOMEM;
678 }
679
680 ret = hccs_get_all_port_info_on_die(hdev, die);
681 if (ret) {
682 dev_err(dev, "get all port info on chip%u/die%u failed, ret = %d.\n",
683 i, die->die_id, ret);
684 return ret;
685 }
686 }
687 }
688
689 return has_port_info ? 0 : -EINVAL;
690 }
691
hccs_get_hw_info(struct hccs_dev * hdev)692 static int hccs_get_hw_info(struct hccs_dev *hdev)
693 {
694 int ret;
695
696 ret = hccs_query_chip_info_on_platform(hdev);
697 if (ret) {
698 dev_err(hdev->dev, "query chip info on platform failed, ret = %d.\n",
699 ret);
700 return ret;
701 }
702
703 ret = hccs_query_all_die_info_on_platform(hdev);
704 if (ret) {
705 dev_err(hdev->dev, "query all die info on platform failed, ret = %d.\n",
706 ret);
707 return ret;
708 }
709
710 ret = hccs_query_all_port_info_on_platform(hdev);
711 if (ret) {
712 dev_err(hdev->dev, "query all port info on platform failed, ret = %d.\n",
713 ret);
714 return ret;
715 }
716
717 return 0;
718 }
719
hccs_calc_used_type_num(struct hccs_dev * hdev,unsigned long * hccs_ver)720 static u16 hccs_calc_used_type_num(struct hccs_dev *hdev,
721 unsigned long *hccs_ver)
722 {
723 struct hccs_chip_info *chip;
724 struct hccs_port_info *port;
725 struct hccs_die_info *die;
726 u16 used_type_num = 0;
727 u16 i, j, k;
728
729 for (i = 0; i < hdev->chip_num; i++) {
730 chip = &hdev->chips[i];
731 for (j = 0; j < chip->die_num; j++) {
732 die = &chip->dies[j];
733 for (k = 0; k < die->port_num; k++) {
734 port = &die->ports[k];
735 set_bit(port->port_type, hccs_ver);
736 }
737 }
738 }
739
740 for_each_set_bit(i, hccs_ver, HCCS_IP_MAX + 1)
741 used_type_num++;
742
743 return used_type_num;
744 }
745
hccs_init_type_name_maps(struct hccs_dev * hdev)746 static int hccs_init_type_name_maps(struct hccs_dev *hdev)
747 {
748 DECLARE_BITMAP(hccs_ver, HCCS_IP_MAX + 1) = {};
749 unsigned int i;
750 u16 idx = 0;
751
752 hdev->used_type_num = hccs_calc_used_type_num(hdev, hccs_ver);
753 hdev->type_name_maps = devm_kcalloc(hdev->dev, hdev->used_type_num,
754 sizeof(struct hccs_type_name_map),
755 GFP_KERNEL);
756 if (!hdev->type_name_maps)
757 return -ENOMEM;
758
759 for_each_set_bit(i, hccs_ver, HCCS_IP_MAX + 1) {
760 hdev->type_name_maps[idx].type = i;
761 sprintf(hdev->type_name_maps[idx].name,
762 "%s%u", HCCS_IP_PREFIX, i);
763 idx++;
764 }
765
766 return 0;
767 }
768
hccs_query_port_link_status(struct hccs_dev * hdev,const struct hccs_port_info * port,struct hccs_link_status * link_status)769 static int hccs_query_port_link_status(struct hccs_dev *hdev,
770 const struct hccs_port_info *port,
771 struct hccs_link_status *link_status)
772 {
773 const struct hccs_die_info *die = port->die;
774 const struct hccs_chip_info *chip = die->chip;
775 struct hccs_port_comm_req_param *req_param;
776 struct hccs_desc desc;
777 int ret;
778
779 hccs_init_req_desc(&desc);
780 req_param = (struct hccs_port_comm_req_param *)desc.req.data;
781 req_param->chip_id = chip->chip_id;
782 req_param->die_id = die->die_id;
783 req_param->port_id = port->port_id;
784 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_PORT_LINK_STATUS, &desc);
785 if (ret) {
786 dev_err(hdev->dev,
787 "get port link status info failed, ret = %d.\n", ret);
788 return ret;
789 }
790
791 *link_status = *((struct hccs_link_status *)desc.rsp.data);
792
793 return 0;
794 }
795
hccs_query_port_crc_err_cnt(struct hccs_dev * hdev,const struct hccs_port_info * port,u64 * crc_err_cnt)796 static int hccs_query_port_crc_err_cnt(struct hccs_dev *hdev,
797 const struct hccs_port_info *port,
798 u64 *crc_err_cnt)
799 {
800 const struct hccs_die_info *die = port->die;
801 const struct hccs_chip_info *chip = die->chip;
802 struct hccs_port_comm_req_param *req_param;
803 struct hccs_desc desc;
804 int ret;
805
806 hccs_init_req_desc(&desc);
807 req_param = (struct hccs_port_comm_req_param *)desc.req.data;
808 req_param->chip_id = chip->chip_id;
809 req_param->die_id = die->die_id;
810 req_param->port_id = port->port_id;
811 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_PORT_CRC_ERR_CNT, &desc);
812 if (ret) {
813 dev_err(hdev->dev,
814 "get port crc error count failed, ret = %d.\n", ret);
815 return ret;
816 }
817
818 memcpy(crc_err_cnt, &desc.rsp.data, sizeof(u64));
819
820 return 0;
821 }
822
hccs_get_die_all_link_status(struct hccs_dev * hdev,const struct hccs_die_info * die,u8 * all_linked)823 static int hccs_get_die_all_link_status(struct hccs_dev *hdev,
824 const struct hccs_die_info *die,
825 u8 *all_linked)
826 {
827 struct hccs_die_comm_req_param *req_param;
828 struct hccs_desc desc;
829 int ret;
830
831 if (die->port_num == 0) {
832 *all_linked = 1;
833 return 0;
834 }
835
836 hccs_init_req_desc(&desc);
837 req_param = (struct hccs_die_comm_req_param *)desc.req.data;
838 req_param->chip_id = die->chip->chip_id;
839 req_param->die_id = die->die_id;
840 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_PORTS_LINK_STA, &desc);
841 if (ret) {
842 dev_err(hdev->dev,
843 "get link status of all ports failed on die%u, ret = %d.\n",
844 die->die_id, ret);
845 return ret;
846 }
847
848 *all_linked = *((u8 *)&desc.rsp.data);
849
850 return 0;
851 }
852
hccs_get_die_all_port_lane_status(struct hccs_dev * hdev,const struct hccs_die_info * die,u8 * full_lane)853 static int hccs_get_die_all_port_lane_status(struct hccs_dev *hdev,
854 const struct hccs_die_info *die,
855 u8 *full_lane)
856 {
857 struct hccs_die_comm_req_param *req_param;
858 struct hccs_desc desc;
859 int ret;
860
861 if (die->port_num == 0) {
862 *full_lane = 1;
863 return 0;
864 }
865
866 hccs_init_req_desc(&desc);
867 req_param = (struct hccs_die_comm_req_param *)desc.req.data;
868 req_param->chip_id = die->chip->chip_id;
869 req_param->die_id = die->die_id;
870 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_PORTS_LANE_STA, &desc);
871 if (ret) {
872 dev_err(hdev->dev, "get lane status of all ports failed on die%u, ret = %d.\n",
873 die->die_id, ret);
874 return ret;
875 }
876
877 *full_lane = *((u8 *)&desc.rsp.data);
878
879 return 0;
880 }
881
hccs_get_die_total_crc_err_cnt(struct hccs_dev * hdev,const struct hccs_die_info * die,u64 * total_crc_err_cnt)882 static int hccs_get_die_total_crc_err_cnt(struct hccs_dev *hdev,
883 const struct hccs_die_info *die,
884 u64 *total_crc_err_cnt)
885 {
886 struct hccs_die_comm_req_param *req_param;
887 struct hccs_desc desc;
888 int ret;
889
890 if (die->port_num == 0) {
891 *total_crc_err_cnt = 0;
892 return 0;
893 }
894
895 hccs_init_req_desc(&desc);
896 req_param = (struct hccs_die_comm_req_param *)desc.req.data;
897 req_param->chip_id = die->chip->chip_id;
898 req_param->die_id = die->die_id;
899 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_DIE_PORTS_CRC_ERR_CNT, &desc);
900 if (ret) {
901 dev_err(hdev->dev, "get crc error count sum failed on die%u, ret = %d.\n",
902 die->die_id, ret);
903 return ret;
904 }
905
906 memcpy(total_crc_err_cnt, &desc.rsp.data, sizeof(u64));
907
908 return 0;
909 }
910
hccs_show(struct kobject * k,struct attribute * attr,char * buf)911 static ssize_t hccs_show(struct kobject *k, struct attribute *attr, char *buf)
912 {
913 struct kobj_attribute *kobj_attr;
914
915 kobj_attr = container_of(attr, struct kobj_attribute, attr);
916
917 return kobj_attr->show(k, kobj_attr, buf);
918 }
919
920 static const struct sysfs_ops hccs_comm_ops = {
921 .show = hccs_show,
922 };
923
type_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)924 static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr,
925 char *buf)
926 {
927 const struct hccs_port_info *port = kobj_to_port_info(kobj);
928
929 return sysfs_emit(buf, "%s%u\n", HCCS_IP_PREFIX, port->port_type);
930 }
931 static struct kobj_attribute hccs_type_attr = __ATTR_RO(type);
932
lane_mode_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)933 static ssize_t lane_mode_show(struct kobject *kobj, struct kobj_attribute *attr,
934 char *buf)
935 {
936 const struct hccs_port_info *port = kobj_to_port_info(kobj);
937
938 return sysfs_emit(buf, "x%u\n", port->max_lane_num);
939 }
940 static struct kobj_attribute lane_mode_attr = __ATTR_RO(lane_mode);
941
enable_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)942 static ssize_t enable_show(struct kobject *kobj,
943 struct kobj_attribute *attr, char *buf)
944 {
945 const struct hccs_port_info *port = kobj_to_port_info(kobj);
946
947 return sysfs_emit(buf, "%u\n", port->enable);
948 }
949 static struct kobj_attribute port_enable_attr = __ATTR_RO(enable);
950
cur_lane_num_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)951 static ssize_t cur_lane_num_show(struct kobject *kobj,
952 struct kobj_attribute *attr, char *buf)
953 {
954 const struct hccs_port_info *port = kobj_to_port_info(kobj);
955 struct hccs_dev *hdev = port->die->chip->hdev;
956 struct hccs_link_status link_status = {0};
957 int ret;
958
959 mutex_lock(&hdev->lock);
960 ret = hccs_query_port_link_status(hdev, port, &link_status);
961 mutex_unlock(&hdev->lock);
962 if (ret)
963 return ret;
964
965 return sysfs_emit(buf, "%u\n", link_status.lane_num);
966 }
967 static struct kobj_attribute cur_lane_num_attr = __ATTR_RO(cur_lane_num);
968
link_fsm_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)969 static ssize_t link_fsm_show(struct kobject *kobj,
970 struct kobj_attribute *attr, char *buf)
971 {
972 const struct hccs_port_info *port = kobj_to_port_info(kobj);
973 struct hccs_dev *hdev = port->die->chip->hdev;
974 struct hccs_link_status link_status = {0};
975 const struct {
976 u8 link_fsm;
977 char *str;
978 } link_fsm_map[] = {
979 {HCCS_PORT_RESET, "reset"},
980 {HCCS_PORT_SETUP, "setup"},
981 {HCCS_PORT_CONFIG, "config"},
982 {HCCS_PORT_READY, "link-up"},
983 };
984 const char *link_fsm_str = "unknown";
985 size_t i;
986 int ret;
987
988 mutex_lock(&hdev->lock);
989 ret = hccs_query_port_link_status(hdev, port, &link_status);
990 mutex_unlock(&hdev->lock);
991 if (ret)
992 return ret;
993
994 for (i = 0; i < ARRAY_SIZE(link_fsm_map); i++) {
995 if (link_fsm_map[i].link_fsm == link_status.link_fsm) {
996 link_fsm_str = link_fsm_map[i].str;
997 break;
998 }
999 }
1000
1001 return sysfs_emit(buf, "%s\n", link_fsm_str);
1002 }
1003 static struct kobj_attribute link_fsm_attr = __ATTR_RO(link_fsm);
1004
lane_mask_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1005 static ssize_t lane_mask_show(struct kobject *kobj,
1006 struct kobj_attribute *attr, char *buf)
1007 {
1008 const struct hccs_port_info *port = kobj_to_port_info(kobj);
1009 struct hccs_dev *hdev = port->die->chip->hdev;
1010 struct hccs_link_status link_status = {0};
1011 int ret;
1012
1013 mutex_lock(&hdev->lock);
1014 ret = hccs_query_port_link_status(hdev, port, &link_status);
1015 mutex_unlock(&hdev->lock);
1016 if (ret)
1017 return ret;
1018
1019 return sysfs_emit(buf, "0x%x\n", link_status.lane_mask);
1020 }
1021 static struct kobj_attribute lane_mask_attr = __ATTR_RO(lane_mask);
1022
crc_err_cnt_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1023 static ssize_t crc_err_cnt_show(struct kobject *kobj,
1024 struct kobj_attribute *attr, char *buf)
1025 {
1026 const struct hccs_port_info *port = kobj_to_port_info(kobj);
1027 struct hccs_dev *hdev = port->die->chip->hdev;
1028 u64 crc_err_cnt;
1029 int ret;
1030
1031 mutex_lock(&hdev->lock);
1032 ret = hccs_query_port_crc_err_cnt(hdev, port, &crc_err_cnt);
1033 mutex_unlock(&hdev->lock);
1034 if (ret)
1035 return ret;
1036
1037 return sysfs_emit(buf, "%llu\n", crc_err_cnt);
1038 }
1039 static struct kobj_attribute crc_err_cnt_attr = __ATTR_RO(crc_err_cnt);
1040
1041 static struct attribute *hccs_port_default_attrs[] = {
1042 &hccs_type_attr.attr,
1043 &lane_mode_attr.attr,
1044 &port_enable_attr.attr,
1045 &cur_lane_num_attr.attr,
1046 &link_fsm_attr.attr,
1047 &lane_mask_attr.attr,
1048 &crc_err_cnt_attr.attr,
1049 NULL,
1050 };
1051 ATTRIBUTE_GROUPS(hccs_port_default);
1052
1053 static const struct kobj_type hccs_port_type = {
1054 .sysfs_ops = &hccs_comm_ops,
1055 .default_groups = hccs_port_default_groups,
1056 };
1057
all_linked_on_die_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1058 static ssize_t all_linked_on_die_show(struct kobject *kobj,
1059 struct kobj_attribute *attr, char *buf)
1060 {
1061 const struct hccs_die_info *die = kobj_to_die_info(kobj);
1062 struct hccs_dev *hdev = die->chip->hdev;
1063 u8 all_linked;
1064 int ret;
1065
1066 mutex_lock(&hdev->lock);
1067 ret = hccs_get_die_all_link_status(hdev, die, &all_linked);
1068 mutex_unlock(&hdev->lock);
1069 if (ret)
1070 return ret;
1071
1072 return sysfs_emit(buf, "%u\n", all_linked);
1073 }
1074 static struct kobj_attribute all_linked_on_die_attr =
1075 __ATTR(all_linked, 0444, all_linked_on_die_show, NULL);
1076
linked_full_lane_on_die_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1077 static ssize_t linked_full_lane_on_die_show(struct kobject *kobj,
1078 struct kobj_attribute *attr,
1079 char *buf)
1080 {
1081 const struct hccs_die_info *die = kobj_to_die_info(kobj);
1082 struct hccs_dev *hdev = die->chip->hdev;
1083 u8 full_lane;
1084 int ret;
1085
1086 mutex_lock(&hdev->lock);
1087 ret = hccs_get_die_all_port_lane_status(hdev, die, &full_lane);
1088 mutex_unlock(&hdev->lock);
1089 if (ret)
1090 return ret;
1091
1092 return sysfs_emit(buf, "%u\n", full_lane);
1093 }
1094 static struct kobj_attribute linked_full_lane_on_die_attr =
1095 __ATTR(linked_full_lane, 0444, linked_full_lane_on_die_show, NULL);
1096
crc_err_cnt_sum_on_die_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1097 static ssize_t crc_err_cnt_sum_on_die_show(struct kobject *kobj,
1098 struct kobj_attribute *attr,
1099 char *buf)
1100 {
1101 const struct hccs_die_info *die = kobj_to_die_info(kobj);
1102 struct hccs_dev *hdev = die->chip->hdev;
1103 u64 total_crc_err_cnt;
1104 int ret;
1105
1106 mutex_lock(&hdev->lock);
1107 ret = hccs_get_die_total_crc_err_cnt(hdev, die, &total_crc_err_cnt);
1108 mutex_unlock(&hdev->lock);
1109 if (ret)
1110 return ret;
1111
1112 return sysfs_emit(buf, "%llu\n", total_crc_err_cnt);
1113 }
1114 static struct kobj_attribute crc_err_cnt_sum_on_die_attr =
1115 __ATTR(crc_err_cnt, 0444, crc_err_cnt_sum_on_die_show, NULL);
1116
1117 static struct attribute *hccs_die_default_attrs[] = {
1118 &all_linked_on_die_attr.attr,
1119 &linked_full_lane_on_die_attr.attr,
1120 &crc_err_cnt_sum_on_die_attr.attr,
1121 NULL,
1122 };
1123 ATTRIBUTE_GROUPS(hccs_die_default);
1124
1125 static const struct kobj_type hccs_die_type = {
1126 .sysfs_ops = &hccs_comm_ops,
1127 .default_groups = hccs_die_default_groups,
1128 };
1129
all_linked_on_chip_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1130 static ssize_t all_linked_on_chip_show(struct kobject *kobj,
1131 struct kobj_attribute *attr, char *buf)
1132 {
1133 const struct hccs_chip_info *chip = kobj_to_chip_info(kobj);
1134 struct hccs_dev *hdev = chip->hdev;
1135 const struct hccs_die_info *die;
1136 u8 all_linked = 1;
1137 u8 i, tmp;
1138 int ret;
1139
1140 mutex_lock(&hdev->lock);
1141 for (i = 0; i < chip->die_num; i++) {
1142 die = &chip->dies[i];
1143 ret = hccs_get_die_all_link_status(hdev, die, &tmp);
1144 if (ret) {
1145 mutex_unlock(&hdev->lock);
1146 return ret;
1147 }
1148 if (tmp != all_linked) {
1149 all_linked = 0;
1150 break;
1151 }
1152 }
1153 mutex_unlock(&hdev->lock);
1154
1155 return sysfs_emit(buf, "%u\n", all_linked);
1156 }
1157 static struct kobj_attribute all_linked_on_chip_attr =
1158 __ATTR(all_linked, 0444, all_linked_on_chip_show, NULL);
1159
linked_full_lane_on_chip_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1160 static ssize_t linked_full_lane_on_chip_show(struct kobject *kobj,
1161 struct kobj_attribute *attr,
1162 char *buf)
1163 {
1164 const struct hccs_chip_info *chip = kobj_to_chip_info(kobj);
1165 struct hccs_dev *hdev = chip->hdev;
1166 const struct hccs_die_info *die;
1167 u8 full_lane = 1;
1168 u8 i, tmp;
1169 int ret;
1170
1171 mutex_lock(&hdev->lock);
1172 for (i = 0; i < chip->die_num; i++) {
1173 die = &chip->dies[i];
1174 ret = hccs_get_die_all_port_lane_status(hdev, die, &tmp);
1175 if (ret) {
1176 mutex_unlock(&hdev->lock);
1177 return ret;
1178 }
1179 if (tmp != full_lane) {
1180 full_lane = 0;
1181 break;
1182 }
1183 }
1184 mutex_unlock(&hdev->lock);
1185
1186 return sysfs_emit(buf, "%u\n", full_lane);
1187 }
1188 static struct kobj_attribute linked_full_lane_on_chip_attr =
1189 __ATTR(linked_full_lane, 0444, linked_full_lane_on_chip_show, NULL);
1190
crc_err_cnt_sum_on_chip_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1191 static ssize_t crc_err_cnt_sum_on_chip_show(struct kobject *kobj,
1192 struct kobj_attribute *attr,
1193 char *buf)
1194 {
1195 const struct hccs_chip_info *chip = kobj_to_chip_info(kobj);
1196 u64 crc_err_cnt, total_crc_err_cnt = 0;
1197 struct hccs_dev *hdev = chip->hdev;
1198 const struct hccs_die_info *die;
1199 int ret;
1200 u16 i;
1201
1202 mutex_lock(&hdev->lock);
1203 for (i = 0; i < chip->die_num; i++) {
1204 die = &chip->dies[i];
1205 ret = hccs_get_die_total_crc_err_cnt(hdev, die, &crc_err_cnt);
1206 if (ret) {
1207 mutex_unlock(&hdev->lock);
1208 return ret;
1209 }
1210
1211 total_crc_err_cnt += crc_err_cnt;
1212 }
1213 mutex_unlock(&hdev->lock);
1214
1215 return sysfs_emit(buf, "%llu\n", total_crc_err_cnt);
1216 }
1217 static struct kobj_attribute crc_err_cnt_sum_on_chip_attr =
1218 __ATTR(crc_err_cnt, 0444, crc_err_cnt_sum_on_chip_show, NULL);
1219
1220 static struct attribute *hccs_chip_default_attrs[] = {
1221 &all_linked_on_chip_attr.attr,
1222 &linked_full_lane_on_chip_attr.attr,
1223 &crc_err_cnt_sum_on_chip_attr.attr,
1224 NULL,
1225 };
1226 ATTRIBUTE_GROUPS(hccs_chip_default);
1227
1228 static const struct kobj_type hccs_chip_type = {
1229 .sysfs_ops = &hccs_comm_ops,
1230 .default_groups = hccs_chip_default_groups,
1231 };
1232
hccs_parse_pm_port_type(struct hccs_dev * hdev,const char * buf,u8 * port_type)1233 static int hccs_parse_pm_port_type(struct hccs_dev *hdev, const char *buf,
1234 u8 *port_type)
1235 {
1236 char hccs_name[HCCS_NAME_MAX_LEN + 1] = "";
1237 u8 type;
1238 int ret;
1239
1240 ret = sscanf(buf, "%" __stringify(HCCS_NAME_MAX_LEN) "s", hccs_name);
1241 if (ret != 1)
1242 return -EINVAL;
1243
1244 ret = hccs_name_to_port_type(hdev, hccs_name, &type);
1245 if (ret) {
1246 dev_dbg(hdev->dev, "input invalid, please get the available types from 'used_types'.\n");
1247 return ret;
1248 }
1249
1250 if (type == HCCS_V2 && hdev->caps & HCCS_CAPS_HCCS_V2_PM) {
1251 *port_type = type;
1252 return 0;
1253 }
1254
1255 dev_dbg(hdev->dev, "%s doesn't support for increasing and decreasing lane.\n",
1256 hccs_name);
1257
1258 return -EOPNOTSUPP;
1259 }
1260
hccs_query_port_idle_status(struct hccs_dev * hdev,struct hccs_port_info * port,u8 * idle)1261 static int hccs_query_port_idle_status(struct hccs_dev *hdev,
1262 struct hccs_port_info *port, u8 *idle)
1263 {
1264 const struct hccs_die_info *die = port->die;
1265 const struct hccs_chip_info *chip = die->chip;
1266 struct hccs_port_comm_req_param *req_param;
1267 struct hccs_desc desc;
1268 int ret;
1269
1270 hccs_init_req_desc(&desc);
1271 req_param = (struct hccs_port_comm_req_param *)desc.req.data;
1272 req_param->chip_id = chip->chip_id;
1273 req_param->die_id = die->die_id;
1274 req_param->port_id = port->port_id;
1275 ret = hccs_pcc_cmd_send(hdev, HCCS_GET_PORT_IDLE_STATUS, &desc);
1276 if (ret) {
1277 dev_err(hdev->dev,
1278 "get port idle status failed, ret = %d.\n", ret);
1279 return ret;
1280 }
1281
1282 *idle = *((u8 *)desc.rsp.data);
1283 return 0;
1284 }
1285
hccs_get_all_spec_port_idle_sta(struct hccs_dev * hdev,u8 port_type,bool * all_idle)1286 static int hccs_get_all_spec_port_idle_sta(struct hccs_dev *hdev, u8 port_type,
1287 bool *all_idle)
1288 {
1289 struct hccs_chip_info *chip;
1290 struct hccs_port_info *port;
1291 struct hccs_die_info *die;
1292 int ret = 0;
1293 u8 i, j, k;
1294 u8 idle;
1295
1296 *all_idle = false;
1297 for (i = 0; i < hdev->chip_num; i++) {
1298 chip = &hdev->chips[i];
1299 for (j = 0; j < chip->die_num; j++) {
1300 die = &chip->dies[j];
1301 for (k = 0; k < die->port_num; k++) {
1302 port = &die->ports[k];
1303 if (port->port_type != port_type)
1304 continue;
1305 ret = hccs_query_port_idle_status(hdev, port,
1306 &idle);
1307 if (ret) {
1308 dev_err(hdev->dev,
1309 "hccs%u on chip%u/die%u get idle status failed, ret = %d.\n",
1310 k, i, j, ret);
1311 return ret;
1312 } else if (idle == 0) {
1313 dev_info(hdev->dev, "hccs%u on chip%u/die%u is busy.\n",
1314 k, i, j);
1315 return 0;
1316 }
1317 }
1318 }
1319 }
1320 *all_idle = true;
1321
1322 return 0;
1323 }
1324
hccs_get_all_spec_port_full_lane_sta(struct hccs_dev * hdev,u8 port_type,bool * full_lane)1325 static int hccs_get_all_spec_port_full_lane_sta(struct hccs_dev *hdev,
1326 u8 port_type, bool *full_lane)
1327 {
1328 struct hccs_link_status status = {0};
1329 struct hccs_chip_info *chip;
1330 struct hccs_port_info *port;
1331 struct hccs_die_info *die;
1332 u8 i, j, k;
1333 int ret;
1334
1335 *full_lane = false;
1336 for (i = 0; i < hdev->chip_num; i++) {
1337 chip = &hdev->chips[i];
1338 for (j = 0; j < chip->die_num; j++) {
1339 die = &chip->dies[j];
1340 for (k = 0; k < die->port_num; k++) {
1341 port = &die->ports[k];
1342 if (port->port_type != port_type)
1343 continue;
1344 ret = hccs_query_port_link_status(hdev, port,
1345 &status);
1346 if (ret)
1347 return ret;
1348 if (status.lane_num != port->max_lane_num)
1349 return 0;
1350 }
1351 }
1352 }
1353 *full_lane = true;
1354
1355 return 0;
1356 }
1357
hccs_prepare_inc_lane(struct hccs_dev * hdev,u8 type)1358 static int hccs_prepare_inc_lane(struct hccs_dev *hdev, u8 type)
1359 {
1360 struct hccs_inc_lane_req_param *req_param;
1361 struct hccs_desc desc;
1362 int ret;
1363
1364 hccs_init_req_desc(&desc);
1365 req_param = (struct hccs_inc_lane_req_param *)desc.req.data;
1366 req_param->port_type = type;
1367 req_param->opt_type = HCCS_PREPARE_INC_LANE;
1368 ret = hccs_pcc_cmd_send(hdev, HCCS_PM_INC_LANE, &desc);
1369 if (ret)
1370 dev_err(hdev->dev, "prepare for increasing lane failed, ret = %d.\n",
1371 ret);
1372
1373 return ret;
1374 }
1375
hccs_wait_serdes_adapt_completed(struct hccs_dev * hdev,u8 type)1376 static int hccs_wait_serdes_adapt_completed(struct hccs_dev *hdev, u8 type)
1377 {
1378 #define HCCS_MAX_WAIT_CNT_FOR_ADAPT 10
1379 #define HCCS_QUERY_ADAPT_RES_DELAY_MS 100
1380 #define HCCS_SERDES_ADAPT_OK 0
1381
1382 struct hccs_inc_lane_req_param *req_param;
1383 u8 wait_cnt = HCCS_MAX_WAIT_CNT_FOR_ADAPT;
1384 struct hccs_desc desc;
1385 u8 adapt_res;
1386 int ret;
1387
1388 do {
1389 hccs_init_req_desc(&desc);
1390 req_param = (struct hccs_inc_lane_req_param *)desc.req.data;
1391 req_param->port_type = type;
1392 req_param->opt_type = HCCS_GET_ADAPT_RES;
1393 ret = hccs_pcc_cmd_send(hdev, HCCS_PM_INC_LANE, &desc);
1394 if (ret) {
1395 dev_err(hdev->dev, "query adapting result failed, ret = %d.\n",
1396 ret);
1397 return ret;
1398 }
1399 adapt_res = *((u8 *)&desc.rsp.data);
1400 if (adapt_res == HCCS_SERDES_ADAPT_OK)
1401 return 0;
1402
1403 msleep(HCCS_QUERY_ADAPT_RES_DELAY_MS);
1404 } while (--wait_cnt);
1405
1406 dev_err(hdev->dev, "wait for adapting completed timeout.\n");
1407
1408 return -ETIMEDOUT;
1409 }
1410
hccs_start_hpcs_retraining(struct hccs_dev * hdev,u8 type)1411 static int hccs_start_hpcs_retraining(struct hccs_dev *hdev, u8 type)
1412 {
1413 struct hccs_inc_lane_req_param *req_param;
1414 struct hccs_desc desc;
1415 int ret;
1416
1417 hccs_init_req_desc(&desc);
1418 req_param = (struct hccs_inc_lane_req_param *)desc.req.data;
1419 req_param->port_type = type;
1420 req_param->opt_type = HCCS_START_RETRAINING;
1421 ret = hccs_pcc_cmd_send(hdev, HCCS_PM_INC_LANE, &desc);
1422 if (ret)
1423 dev_err(hdev->dev, "start hpcs retraining failed, ret = %d.\n",
1424 ret);
1425
1426 return ret;
1427 }
1428
hccs_start_inc_lane(struct hccs_dev * hdev,u8 type)1429 static int hccs_start_inc_lane(struct hccs_dev *hdev, u8 type)
1430 {
1431 int ret;
1432
1433 ret = hccs_prepare_inc_lane(hdev, type);
1434 if (ret)
1435 return ret;
1436
1437 ret = hccs_wait_serdes_adapt_completed(hdev, type);
1438 if (ret)
1439 return ret;
1440
1441 return hccs_start_hpcs_retraining(hdev, type);
1442 }
1443
hccs_start_dec_lane(struct hccs_dev * hdev,u8 type)1444 static int hccs_start_dec_lane(struct hccs_dev *hdev, u8 type)
1445 {
1446 struct hccs_desc desc;
1447 u8 *port_type;
1448 int ret;
1449
1450 hccs_init_req_desc(&desc);
1451 port_type = (u8 *)desc.req.data;
1452 *port_type = type;
1453 ret = hccs_pcc_cmd_send(hdev, HCCS_PM_DEC_LANE, &desc);
1454 if (ret)
1455 dev_err(hdev->dev, "start to decrease lane failed, ret = %d.\n",
1456 ret);
1457
1458 return ret;
1459 }
1460
dec_lane_of_type_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)1461 static ssize_t dec_lane_of_type_store(struct kobject *kobj, struct kobj_attribute *attr,
1462 const char *buf, size_t count)
1463 {
1464 struct hccs_dev *hdev = device_kobj_to_hccs_dev(kobj);
1465 bool all_in_idle;
1466 u8 port_type;
1467 int ret;
1468
1469 ret = hccs_parse_pm_port_type(hdev, buf, &port_type);
1470 if (ret)
1471 return ret;
1472
1473 mutex_lock(&hdev->lock);
1474 ret = hccs_get_all_spec_port_idle_sta(hdev, port_type, &all_in_idle);
1475 if (ret)
1476 goto out;
1477 if (!all_in_idle) {
1478 ret = -EBUSY;
1479 dev_err(hdev->dev, "please don't decrese lanes on high load with %s, ret = %d.\n",
1480 hccs_port_type_to_name(hdev, port_type), ret);
1481 goto out;
1482 }
1483
1484 ret = hccs_start_dec_lane(hdev, port_type);
1485 out:
1486 mutex_unlock(&hdev->lock);
1487
1488 return ret == 0 ? count : ret;
1489 }
1490 static struct kobj_attribute dec_lane_of_type_attr =
1491 __ATTR(dec_lane_of_type, 0200, NULL, dec_lane_of_type_store);
1492
inc_lane_of_type_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)1493 static ssize_t inc_lane_of_type_store(struct kobject *kobj, struct kobj_attribute *attr,
1494 const char *buf, size_t count)
1495 {
1496 struct hccs_dev *hdev = device_kobj_to_hccs_dev(kobj);
1497 bool full_lane;
1498 u8 port_type;
1499 int ret;
1500
1501 ret = hccs_parse_pm_port_type(hdev, buf, &port_type);
1502 if (ret)
1503 return ret;
1504
1505 mutex_lock(&hdev->lock);
1506 ret = hccs_get_all_spec_port_full_lane_sta(hdev, port_type, &full_lane);
1507 if (ret || full_lane)
1508 goto out;
1509
1510 ret = hccs_start_inc_lane(hdev, port_type);
1511 out:
1512 mutex_unlock(&hdev->lock);
1513 return ret == 0 ? count : ret;
1514 }
1515 static struct kobj_attribute inc_lane_of_type_attr =
1516 __ATTR(inc_lane_of_type, 0200, NULL, inc_lane_of_type_store);
1517
available_inc_dec_lane_types_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1518 static ssize_t available_inc_dec_lane_types_show(struct kobject *kobj,
1519 struct kobj_attribute *attr,
1520 char *buf)
1521 {
1522 struct hccs_dev *hdev = device_kobj_to_hccs_dev(kobj);
1523
1524 if (hdev->caps & HCCS_CAPS_HCCS_V2_PM)
1525 return sysfs_emit(buf, "%s\n",
1526 hccs_port_type_to_name(hdev, HCCS_V2));
1527
1528 return -EINVAL;
1529 }
1530 static struct kobj_attribute available_inc_dec_lane_types_attr =
1531 __ATTR(available_inc_dec_lane_types, 0444,
1532 available_inc_dec_lane_types_show, NULL);
1533
used_types_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1534 static ssize_t used_types_show(struct kobject *kobj,
1535 struct kobj_attribute *attr, char *buf)
1536 {
1537 struct hccs_dev *hdev = device_kobj_to_hccs_dev(kobj);
1538 int len = 0;
1539 u16 i;
1540
1541 for (i = 0; i < hdev->used_type_num - 1; i++)
1542 len += sysfs_emit_at(buf, len, "%s ", hdev->type_name_maps[i].name);
1543 len += sysfs_emit_at(buf, len, "%s\n", hdev->type_name_maps[i].name);
1544
1545 return len;
1546 }
1547 static struct kobj_attribute used_types_attr =
1548 __ATTR(used_types, 0444, used_types_show, NULL);
1549
hccs_remove_misc_sysfs(struct hccs_dev * hdev)1550 static void hccs_remove_misc_sysfs(struct hccs_dev *hdev)
1551 {
1552 sysfs_remove_file(&hdev->dev->kobj, &used_types_attr.attr);
1553
1554 if (!(hdev->caps & HCCS_CAPS_HCCS_V2_PM))
1555 return;
1556
1557 sysfs_remove_file(&hdev->dev->kobj,
1558 &available_inc_dec_lane_types_attr.attr);
1559 sysfs_remove_file(&hdev->dev->kobj, &dec_lane_of_type_attr.attr);
1560 sysfs_remove_file(&hdev->dev->kobj, &inc_lane_of_type_attr.attr);
1561 }
1562
hccs_add_misc_sysfs(struct hccs_dev * hdev)1563 static int hccs_add_misc_sysfs(struct hccs_dev *hdev)
1564 {
1565 int ret;
1566
1567 ret = sysfs_create_file(&hdev->dev->kobj, &used_types_attr.attr);
1568 if (ret)
1569 return ret;
1570
1571 if (!(hdev->caps & HCCS_CAPS_HCCS_V2_PM))
1572 return 0;
1573
1574 ret = sysfs_create_file(&hdev->dev->kobj,
1575 &available_inc_dec_lane_types_attr.attr);
1576 if (ret)
1577 goto used_types_remove;
1578
1579 ret = sysfs_create_file(&hdev->dev->kobj, &dec_lane_of_type_attr.attr);
1580 if (ret)
1581 goto inc_dec_lane_types_remove;
1582
1583 ret = sysfs_create_file(&hdev->dev->kobj, &inc_lane_of_type_attr.attr);
1584 if (ret)
1585 goto dec_lane_of_type_remove;
1586
1587 return 0;
1588
1589 dec_lane_of_type_remove:
1590 sysfs_remove_file(&hdev->dev->kobj, &dec_lane_of_type_attr.attr);
1591 inc_dec_lane_types_remove:
1592 sysfs_remove_file(&hdev->dev->kobj,
1593 &available_inc_dec_lane_types_attr.attr);
1594 used_types_remove:
1595 sysfs_remove_file(&hdev->dev->kobj, &used_types_attr.attr);
1596 return ret;
1597 }
1598
hccs_remove_die_dir(struct hccs_die_info * die)1599 static void hccs_remove_die_dir(struct hccs_die_info *die)
1600 {
1601 struct hccs_port_info *port;
1602 u8 i;
1603
1604 for (i = 0; i < die->port_num; i++) {
1605 port = &die->ports[i];
1606 if (port->dir_created)
1607 kobject_put(&port->kobj);
1608 }
1609
1610 kobject_put(&die->kobj);
1611 }
1612
hccs_remove_chip_dir(struct hccs_chip_info * chip)1613 static void hccs_remove_chip_dir(struct hccs_chip_info *chip)
1614 {
1615 struct hccs_die_info *die;
1616 u8 i;
1617
1618 for (i = 0; i < chip->die_num; i++) {
1619 die = &chip->dies[i];
1620 if (die->dir_created)
1621 hccs_remove_die_dir(die);
1622 }
1623
1624 kobject_put(&chip->kobj);
1625 }
1626
hccs_remove_topo_dirs(struct hccs_dev * hdev)1627 static void hccs_remove_topo_dirs(struct hccs_dev *hdev)
1628 {
1629 u8 i;
1630
1631 for (i = 0; i < hdev->chip_num; i++)
1632 hccs_remove_chip_dir(&hdev->chips[i]);
1633
1634 hccs_remove_misc_sysfs(hdev);
1635 }
1636
hccs_create_hccs_dir(struct hccs_dev * hdev,struct hccs_die_info * die,struct hccs_port_info * port)1637 static int hccs_create_hccs_dir(struct hccs_dev *hdev,
1638 struct hccs_die_info *die,
1639 struct hccs_port_info *port)
1640 {
1641 int ret;
1642
1643 ret = kobject_init_and_add(&port->kobj, &hccs_port_type,
1644 &die->kobj, "hccs%u", port->port_id);
1645 if (ret) {
1646 kobject_put(&port->kobj);
1647 return ret;
1648 }
1649
1650 return 0;
1651 }
1652
hccs_create_die_dir(struct hccs_dev * hdev,struct hccs_chip_info * chip,struct hccs_die_info * die)1653 static int hccs_create_die_dir(struct hccs_dev *hdev,
1654 struct hccs_chip_info *chip,
1655 struct hccs_die_info *die)
1656 {
1657 struct hccs_port_info *port;
1658 int ret;
1659 u16 i;
1660
1661 ret = kobject_init_and_add(&die->kobj, &hccs_die_type,
1662 &chip->kobj, "die%u", die->die_id);
1663 if (ret) {
1664 kobject_put(&die->kobj);
1665 return ret;
1666 }
1667
1668 for (i = 0; i < die->port_num; i++) {
1669 port = &die->ports[i];
1670 ret = hccs_create_hccs_dir(hdev, die, port);
1671 if (ret) {
1672 dev_err(hdev->dev, "create hccs%u dir failed.\n",
1673 port->port_id);
1674 goto err;
1675 }
1676 port->dir_created = true;
1677 }
1678
1679 return 0;
1680 err:
1681 hccs_remove_die_dir(die);
1682
1683 return ret;
1684 }
1685
hccs_create_chip_dir(struct hccs_dev * hdev,struct hccs_chip_info * chip)1686 static int hccs_create_chip_dir(struct hccs_dev *hdev,
1687 struct hccs_chip_info *chip)
1688 {
1689 struct hccs_die_info *die;
1690 int ret;
1691 u16 id;
1692
1693 ret = kobject_init_and_add(&chip->kobj, &hccs_chip_type,
1694 &hdev->dev->kobj, "chip%u", chip->chip_id);
1695 if (ret) {
1696 kobject_put(&chip->kobj);
1697 return ret;
1698 }
1699
1700 for (id = 0; id < chip->die_num; id++) {
1701 die = &chip->dies[id];
1702 ret = hccs_create_die_dir(hdev, chip, die);
1703 if (ret)
1704 goto err;
1705 die->dir_created = true;
1706 }
1707
1708 return 0;
1709 err:
1710 hccs_remove_chip_dir(chip);
1711
1712 return ret;
1713 }
1714
hccs_create_topo_dirs(struct hccs_dev * hdev)1715 static int hccs_create_topo_dirs(struct hccs_dev *hdev)
1716 {
1717 struct hccs_chip_info *chip;
1718 u8 id, k;
1719 int ret;
1720
1721 for (id = 0; id < hdev->chip_num; id++) {
1722 chip = &hdev->chips[id];
1723 ret = hccs_create_chip_dir(hdev, chip);
1724 if (ret) {
1725 dev_err(hdev->dev, "init chip%u dir failed!\n", id);
1726 goto err;
1727 }
1728 }
1729
1730 ret = hccs_add_misc_sysfs(hdev);
1731 if (ret) {
1732 dev_err(hdev->dev, "create misc sysfs interface failed, ret = %d\n", ret);
1733 goto err;
1734 }
1735
1736 return 0;
1737 err:
1738 for (k = 0; k < id; k++)
1739 hccs_remove_chip_dir(&hdev->chips[k]);
1740
1741 return ret;
1742 }
1743
hccs_probe(struct platform_device * pdev)1744 static int hccs_probe(struct platform_device *pdev)
1745 {
1746 struct acpi_device *acpi_dev;
1747 struct hccs_dev *hdev;
1748 int rc;
1749
1750 if (acpi_disabled) {
1751 dev_err(&pdev->dev, "acpi is disabled.\n");
1752 return -ENODEV;
1753 }
1754 acpi_dev = ACPI_COMPANION(&pdev->dev);
1755 if (!acpi_dev)
1756 return -ENODEV;
1757
1758 hdev = devm_kzalloc(&pdev->dev, sizeof(*hdev), GFP_KERNEL);
1759 if (!hdev)
1760 return -ENOMEM;
1761 hdev->acpi_dev = acpi_dev;
1762 hdev->dev = &pdev->dev;
1763 platform_set_drvdata(pdev, hdev);
1764
1765 /*
1766 * Here would never be failure as the driver and device has been matched.
1767 */
1768 hdev->verspec_data = acpi_device_get_match_data(hdev->dev);
1769
1770 mutex_init(&hdev->lock);
1771 rc = hccs_get_pcc_chan_id(hdev);
1772 if (rc)
1773 return rc;
1774 rc = hccs_register_pcc_channel(hdev);
1775 if (rc)
1776 return rc;
1777
1778 rc = hccs_get_dev_caps(hdev);
1779 if (rc)
1780 goto unregister_pcc_chan;
1781
1782 rc = hccs_get_hw_info(hdev);
1783 if (rc)
1784 goto unregister_pcc_chan;
1785
1786 rc = hccs_init_type_name_maps(hdev);
1787 if (rc)
1788 goto unregister_pcc_chan;
1789
1790 rc = hccs_create_topo_dirs(hdev);
1791 if (rc)
1792 goto unregister_pcc_chan;
1793
1794 return 0;
1795
1796 unregister_pcc_chan:
1797 hccs_unregister_pcc_channel(hdev);
1798
1799 return rc;
1800 }
1801
hccs_remove(struct platform_device * pdev)1802 static void hccs_remove(struct platform_device *pdev)
1803 {
1804 struct hccs_dev *hdev = platform_get_drvdata(pdev);
1805
1806 hccs_remove_topo_dirs(hdev);
1807 hccs_unregister_pcc_channel(hdev);
1808 }
1809
1810 static const struct hccs_verspecific_data hisi04b1_verspec_data = {
1811 .rx_callback = NULL,
1812 .wait_cmd_complete = hccs_wait_cmd_complete_by_poll,
1813 .fill_pcc_shared_mem = hccs_fill_pcc_shared_mem_region,
1814 .shared_mem_size = sizeof(struct acpi_pcct_shared_memory),
1815 .has_txdone_irq = false,
1816 };
1817
1818 static const struct hccs_verspecific_data hisi04b2_verspec_data = {
1819 .rx_callback = hccs_pcc_rx_callback,
1820 .wait_cmd_complete = hccs_wait_cmd_complete_by_irq,
1821 .fill_pcc_shared_mem = hccs_fill_ext_pcc_shared_mem_region,
1822 .shared_mem_size = sizeof(struct acpi_pcct_ext_pcc_shared_memory),
1823 .has_txdone_irq = true,
1824 };
1825
1826 static const struct acpi_device_id hccs_acpi_match[] = {
1827 { "HISI04B1", (unsigned long)&hisi04b1_verspec_data},
1828 { "HISI04B2", (unsigned long)&hisi04b2_verspec_data},
1829 { }
1830 };
1831 MODULE_DEVICE_TABLE(acpi, hccs_acpi_match);
1832
1833 static struct platform_driver hccs_driver = {
1834 .probe = hccs_probe,
1835 .remove = hccs_remove,
1836 .driver = {
1837 .name = "kunpeng_hccs",
1838 .acpi_match_table = hccs_acpi_match,
1839 },
1840 };
1841
1842 module_platform_driver(hccs_driver);
1843
1844 MODULE_DESCRIPTION("Kunpeng SoC HCCS driver");
1845 MODULE_LICENSE("GPL");
1846 MODULE_AUTHOR("Huisong Li <lihuisong@huawei.com>");
1847