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 
kobj_to_port_info(struct kobject * k)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 
kobj_to_die_info(struct kobject * k)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 
kobj_to_chip_info(struct kobject * k)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 
hccs_get_register_cb(struct acpi_resource * ares,void * context)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 
hccs_get_pcc_chan_id(struct hccs_dev * hdev)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 
hccs_chan_tx_done(struct mbox_client * cl,void * msg,int ret)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 
hccs_unregister_pcc_channel(struct hccs_dev * hdev)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 
hccs_register_pcc_channel(struct hccs_dev * hdev)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 
hccs_check_chan_cmd_complete(struct hccs_dev * hdev)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 
hccs_pcc_cmd_send(struct hccs_dev * hdev,u8 cmd,struct hccs_desc * desc)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 
hccs_init_req_desc(struct hccs_desc * desc)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 
hccs_get_dev_caps(struct hccs_dev * hdev)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 
hccs_query_chip_num_on_platform(struct hccs_dev * hdev)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 
hccs_get_chip_info(struct hccs_dev * hdev,struct hccs_chip_info * chip)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 
hccs_query_chip_info_on_platform(struct hccs_dev * hdev)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 
hccs_query_die_info_on_chip(struct hccs_dev * hdev,u8 chip_id,u8 die_idx,struct hccs_die_info * die)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 
hccs_query_all_die_info_on_platform(struct hccs_dev * hdev)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 
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)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 
hccs_get_all_port_attr(struct hccs_dev * hdev,struct hccs_die_info * die,struct hccs_port_attr * attrs,u16 size)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 
hccs_get_all_port_info_on_die(struct hccs_dev * hdev,struct hccs_die_info * die)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 
hccs_query_all_port_info_on_platform(struct hccs_dev * hdev)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 
hccs_get_hw_info(struct hccs_dev * hdev)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 
hccs_query_port_link_status(struct hccs_dev * hdev,const struct hccs_port_info * port,struct hccs_link_status * link_status)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 
hccs_query_port_crc_err_cnt(struct hccs_dev * hdev,const struct hccs_port_info * port,u64 * crc_err_cnt)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 
hccs_get_die_all_link_status(struct hccs_dev * hdev,const struct hccs_die_info * die,u8 * all_linked)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 
hccs_get_die_all_port_lane_status(struct hccs_dev * hdev,const struct hccs_die_info * die,u8 * full_lane)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 
hccs_get_die_total_crc_err_cnt(struct hccs_dev * hdev,const struct hccs_die_info * die,u64 * total_crc_err_cnt)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 
hccs_show(struct kobject * k,struct attribute * attr,char * buf)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 
type_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
lane_mode_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
enable_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
cur_lane_num_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
link_fsm_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
lane_mask_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
crc_err_cnt_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
all_linked_on_die_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
linked_full_lane_on_die_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
crc_err_cnt_sum_on_die_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
all_linked_on_chip_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
linked_full_lane_on_chip_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
crc_err_cnt_sum_on_chip_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
hccs_remove_die_dir(struct hccs_die_info * die)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 
hccs_remove_chip_dir(struct hccs_chip_info * chip)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 
hccs_remove_topo_dirs(struct hccs_dev * hdev)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 
hccs_create_hccs_dir(struct hccs_dev * hdev,struct hccs_die_info * die,struct hccs_port_info * port)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 
hccs_create_die_dir(struct hccs_dev * hdev,struct hccs_chip_info * chip,struct hccs_die_info * die)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 
hccs_create_chip_dir(struct hccs_dev * hdev,struct hccs_chip_info * chip)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 
hccs_create_topo_dirs(struct hccs_dev * hdev)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 
hccs_probe(struct platform_device * pdev)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 
hccs_remove(struct platform_device * pdev)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