Commit 2f55342c authored by Oded Gabbay's avatar Oded Gabbay
Browse files

habanalabs: replace armcp with the generic cpucp 



ArmCP mandates that the device CPU is always an ARM processor, which might
be wrong in the future.

Most of this change is an internal renaming of variables, functions and
defines but there are two entries in sysfs which have armcp in their
names. Add identical cpucp entries but don't remove yet the armcp entries.
Those will be deprecated next year. Add the documentation about it in sysfs
documentation.

Signed-off-by: default avatarMoti Haimovski <mhaimovski@habana.ai>
Reviewed-by: default avatarOded Gabbay <oded.gabbay@gmail.com>
Signed-off-by: default avatarOded Gabbay <oded.gabbay@gmail.com>
parent 42b0698a

Documentation/ABI/testing/sysfs-driver-habanalabs

+17 −1
Original line number Diff line number Diff line
@@ -2,13 +2,17 @@ What: /sys/class/habanalabs/hl<n>/armcp_kernel_ver 
Date:           Jan 2019

KernelVersion:  5.1

Contact:        oded.gabbay@gmail.com

Description:    Version of the Linux kernel running on the device's CPU

Description:    Version of the Linux kernel running on the device's CPU.

                Will be DEPRECATED in Linux kernel version 5.10, and be

                replaced with cpucp_kernel_ver



What:           /sys/class/habanalabs/hl<n>/armcp_ver

Date:           Jan 2019

KernelVersion:  5.1

Contact:        oded.gabbay@gmail.com

Description:    Version of the application running on the device's CPU

                Will be DEPRECATED in Linux kernel version 5.10, and be

                replaced with cpucp_ver



What:           /sys/class/habanalabs/hl<n>/clk_max_freq_mhz

Date:           Jun 2019
@@ -33,6 +37,18 @@ KernelVersion: 5.1 
Contact:        oded.gabbay@gmail.com

Description:    Version of the Device's CPLD F/W



What:           /sys/class/habanalabs/hl<n>/cpucp_kernel_ver

Date:           Oct 2020

KernelVersion:  5.10

Contact:        oded.gabbay@gmail.com

Description:    Version of the Linux kernel running on the device's CPU



What:           /sys/class/habanalabs/hl<n>/cpucp_ver

Date:           Oct 2020

KernelVersion:  5.10

Contact:        oded.gabbay@gmail.com

Description:    Version of the application running on the device's CPU



What:           /sys/class/habanalabs/hl<n>/device_type

Date:           Jan 2019

KernelVersion:  5.1

drivers/misc/habanalabs/common/debugfs.c

+9 −9
Original line number Diff line number Diff line
@@ -21,7 +21,7 @@ static struct dentry *hl_debug_root; 
static int hl_debugfs_i2c_read(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr,

				u8 i2c_reg, long *val)

{

	struct armcp_packet pkt;

	struct cpucp_packet pkt;

	int rc;



	if (hl_device_disabled_or_in_reset(hdev))
@@ -29,8 +29,8 @@ static int hl_debugfs_i2c_read(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 


	memset(&pkt, 0, sizeof(pkt));



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_I2C_RD <<

				ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_I2C_RD <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);

	pkt.i2c_bus = i2c_bus;

	pkt.i2c_addr = i2c_addr;

	pkt.i2c_reg = i2c_reg;
@@ -47,7 +47,7 @@ static int hl_debugfs_i2c_read(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 
static int hl_debugfs_i2c_write(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr,

				u8 i2c_reg, u32 val)

{

	struct armcp_packet pkt;

	struct cpucp_packet pkt;

	int rc;



	if (hl_device_disabled_or_in_reset(hdev))
@@ -55,8 +55,8 @@ static int hl_debugfs_i2c_write(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 


	memset(&pkt, 0, sizeof(pkt));



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_I2C_WR <<

				ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_I2C_WR <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);

	pkt.i2c_bus = i2c_bus;

	pkt.i2c_addr = i2c_addr;

	pkt.i2c_reg = i2c_reg;
@@ -73,7 +73,7 @@ static int hl_debugfs_i2c_write(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 


static void hl_debugfs_led_set(struct hl_device *hdev, u8 led, u8 state)

{

	struct armcp_packet pkt;

	struct cpucp_packet pkt;

	int rc;



	if (hl_device_disabled_or_in_reset(hdev))
@@ -81,8 +81,8 @@ static void hl_debugfs_led_set(struct hl_device *hdev, u8 led, u8 state) 


	memset(&pkt, 0, sizeof(pkt));



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_LED_SET <<

				ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_LED_SET <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);

	pkt.led_index = cpu_to_le32(led);

	pkt.value = cpu_to_le64(state);

drivers/misc/habanalabs/common/device.c

+1 −1
Original line number Diff line number Diff line
@@ -871,7 +871,7 @@ int hl_device_reset(struct hl_device *hdev, bool hard_reset, 
			 * so this message won't be sent

			 */

			if (hl_fw_send_pci_access_msg(hdev,

					ARMCP_PACKET_DISABLE_PCI_ACCESS))

					CPUCP_PACKET_DISABLE_PCI_ACCESS))

				dev_warn(hdev->dev,

					"Failed to disable PCI access by F/W\n");

		}

drivers/misc/habanalabs/common/firmware_if.c

+63 −64
Original line number Diff line number Diff line
@@ -68,9 +68,9 @@ out: 


int hl_fw_send_pci_access_msg(struct hl_device *hdev, u32 opcode)

{

	struct armcp_packet pkt = {};

	struct cpucp_packet pkt = {};



	pkt.ctl = cpu_to_le32(opcode << ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(opcode << CPUCP_PKT_CTL_OPCODE_SHIFT);



	return hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt,

						sizeof(pkt), 0, NULL);
@@ -79,7 +79,7 @@ int hl_fw_send_pci_access_msg(struct hl_device *hdev, u32 opcode) 
int hl_fw_send_cpu_message(struct hl_device *hdev, u32 hw_queue_id, u32 *msg,

				u16 len, u32 timeout, long *result)

{

	struct armcp_packet *pkt;

	struct cpucp_packet *pkt;

	dma_addr_t pkt_dma_addr;

	u32 tmp;

	int rc = 0;
@@ -111,7 +111,7 @@ int hl_fw_send_cpu_message(struct hl_device *hdev, u32 hw_queue_id, u32 *msg, 
	}



	rc = hl_poll_timeout_memory(hdev, &pkt->fence, tmp,

				(tmp == ARMCP_PACKET_FENCE_VAL), 1000,

				(tmp == CPUCP_PACKET_FENCE_VAL), 1000,

				timeout, true);



	hl_hw_queue_inc_ci_kernel(hdev, hw_queue_id);
@@ -124,12 +124,12 @@ int hl_fw_send_cpu_message(struct hl_device *hdev, u32 hw_queue_id, u32 *msg, 


	tmp = le32_to_cpu(pkt->ctl);



	rc = (tmp & ARMCP_PKT_CTL_RC_MASK) >> ARMCP_PKT_CTL_RC_SHIFT;

	rc = (tmp & CPUCP_PKT_CTL_RC_MASK) >> CPUCP_PKT_CTL_RC_SHIFT;

	if (rc) {

		dev_err(hdev->dev, "F/W ERROR %d for CPU packet %d\n",

			rc,

			(tmp & ARMCP_PKT_CTL_OPCODE_MASK)

						>> ARMCP_PKT_CTL_OPCODE_SHIFT);

			(tmp & CPUCP_PKT_CTL_OPCODE_MASK)

						>> CPUCP_PKT_CTL_OPCODE_SHIFT);

		rc = -EIO;

	} else if (result) {

		*result = (long) le64_to_cpu(pkt->result);
@@ -145,14 +145,14 @@ out: 


int hl_fw_unmask_irq(struct hl_device *hdev, u16 event_type)

{

	struct armcp_packet pkt;

	struct cpucp_packet pkt;

	long result;

	int rc;



	memset(&pkt, 0, sizeof(pkt));



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_UNMASK_RAZWI_IRQ <<

				ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_UNMASK_RAZWI_IRQ <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);

	pkt.value = cpu_to_le64(event_type);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
@@ -167,12 +167,12 @@ int hl_fw_unmask_irq(struct hl_device *hdev, u16 event_type) 
int hl_fw_unmask_irq_arr(struct hl_device *hdev, const u32 *irq_arr,

		size_t irq_arr_size)

{

	struct armcp_unmask_irq_arr_packet *pkt;

	struct cpucp_unmask_irq_arr_packet *pkt;

	size_t total_pkt_size;

	long result;

	int rc;



	total_pkt_size = sizeof(struct armcp_unmask_irq_arr_packet) +

	total_pkt_size = sizeof(struct cpucp_unmask_irq_arr_packet) +

			irq_arr_size;



	/* data should be aligned to 8 bytes in order to ArmCP to copy it */
@@ -191,8 +191,8 @@ int hl_fw_unmask_irq_arr(struct hl_device *hdev, const u32 *irq_arr, 
	pkt->length = cpu_to_le32(irq_arr_size / sizeof(irq_arr[0]));

	memcpy(&pkt->irqs, irq_arr, irq_arr_size);



	pkt->armcp_pkt.ctl = cpu_to_le32(ARMCP_PACKET_UNMASK_RAZWI_IRQ_ARRAY <<

						ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt->cpucp_pkt.ctl = cpu_to_le32(CPUCP_PACKET_UNMASK_RAZWI_IRQ_ARRAY <<

						CPUCP_PKT_CTL_OPCODE_SHIFT);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) pkt,

						total_pkt_size, 0, &result);
@@ -207,19 +207,19 @@ int hl_fw_unmask_irq_arr(struct hl_device *hdev, const u32 *irq_arr, 


int hl_fw_test_cpu_queue(struct hl_device *hdev)

{

	struct armcp_packet test_pkt = {};

	struct cpucp_packet test_pkt = {};

	long result;

	int rc;



	test_pkt.ctl = cpu_to_le32(ARMCP_PACKET_TEST <<

					ARMCP_PKT_CTL_OPCODE_SHIFT);

	test_pkt.value = cpu_to_le64(ARMCP_PACKET_FENCE_VAL);

	test_pkt.ctl = cpu_to_le32(CPUCP_PACKET_TEST <<

					CPUCP_PKT_CTL_OPCODE_SHIFT);

	test_pkt.value = cpu_to_le64(CPUCP_PACKET_FENCE_VAL);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &test_pkt,

						sizeof(test_pkt), 0, &result);



	if (!rc) {

		if (result != ARMCP_PACKET_FENCE_VAL)

		if (result != CPUCP_PACKET_FENCE_VAL)

			dev_err(hdev->dev,

				"CPU queue test failed (0x%08lX)\n", result);

	} else {
@@ -251,61 +251,61 @@ void hl_fw_cpu_accessible_dma_pool_free(struct hl_device *hdev, size_t size, 


int hl_fw_send_heartbeat(struct hl_device *hdev)

{

	struct armcp_packet hb_pkt = {};

	struct cpucp_packet hb_pkt = {};

	long result;

	int rc;



	hb_pkt.ctl = cpu_to_le32(ARMCP_PACKET_TEST <<

					ARMCP_PKT_CTL_OPCODE_SHIFT);

	hb_pkt.value = cpu_to_le64(ARMCP_PACKET_FENCE_VAL);

	hb_pkt.ctl = cpu_to_le32(CPUCP_PACKET_TEST <<

					CPUCP_PKT_CTL_OPCODE_SHIFT);

	hb_pkt.value = cpu_to_le64(CPUCP_PACKET_FENCE_VAL);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &hb_pkt,

						sizeof(hb_pkt), 0, &result);



	if ((rc) || (result != ARMCP_PACKET_FENCE_VAL))

	if ((rc) || (result != CPUCP_PACKET_FENCE_VAL))

		rc = -EIO;



	return rc;

}



int hl_fw_armcp_info_get(struct hl_device *hdev)

int hl_fw_cpucp_info_get(struct hl_device *hdev)

{

	struct asic_fixed_properties *prop = &hdev->asic_prop;

	struct armcp_packet pkt = {};

	void *armcp_info_cpu_addr;

	dma_addr_t armcp_info_dma_addr;

	struct cpucp_packet pkt = {};

	void *cpucp_info_cpu_addr;

	dma_addr_t cpucp_info_dma_addr;

	long result;

	int rc;



	armcp_info_cpu_addr =

	cpucp_info_cpu_addr =

			hdev->asic_funcs->cpu_accessible_dma_pool_alloc(hdev,

					sizeof(struct armcp_info),

					&armcp_info_dma_addr);

	if (!armcp_info_cpu_addr) {

					sizeof(struct cpucp_info),

					&cpucp_info_dma_addr);

	if (!cpucp_info_cpu_addr) {

		dev_err(hdev->dev,

			"Failed to allocate DMA memory for ArmCP info packet\n");

		return -ENOMEM;

	}



	memset(armcp_info_cpu_addr, 0, sizeof(struct armcp_info));

	memset(cpucp_info_cpu_addr, 0, sizeof(struct cpucp_info));



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_INFO_GET <<

				ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.addr = cpu_to_le64(armcp_info_dma_addr);

	pkt.data_max_size = cpu_to_le32(sizeof(struct armcp_info));

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_INFO_GET <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);

	pkt.addr = cpu_to_le64(cpucp_info_dma_addr);

	pkt.data_max_size = cpu_to_le32(sizeof(struct cpucp_info));



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),

					HL_ARMCP_INFO_TIMEOUT_USEC, &result);

					HL_CPUCP_INFO_TIMEOUT_USEC, &result);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to handle ArmCP info pkt, error %d\n", rc);

		goto out;

	}



	memcpy(&prop->armcp_info, armcp_info_cpu_addr,

			sizeof(prop->armcp_info));

	memcpy(&prop->cpucp_info, cpucp_info_cpu_addr,

			sizeof(prop->cpucp_info));



	rc = hl_build_hwmon_channel_info(hdev, prop->armcp_info.sensors);

	rc = hl_build_hwmon_channel_info(hdev, prop->cpucp_info.sensors);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to build hwmon channel info, error %d\n", rc);
@@ -315,14 +315,14 @@ int hl_fw_armcp_info_get(struct hl_device *hdev) 


out:

	hdev->asic_funcs->cpu_accessible_dma_pool_free(hdev,

			sizeof(struct armcp_info), armcp_info_cpu_addr);

			sizeof(struct cpucp_info), cpucp_info_cpu_addr);



	return rc;

}



int hl_fw_get_eeprom_data(struct hl_device *hdev, void *data, size_t max_size)

{

	struct armcp_packet pkt = {};

	struct cpucp_packet pkt = {};

	void *eeprom_info_cpu_addr;

	dma_addr_t eeprom_info_dma_addr;

	long result;
@@ -339,13 +339,13 @@ int hl_fw_get_eeprom_data(struct hl_device *hdev, void *data, size_t max_size) 


	memset(eeprom_info_cpu_addr, 0, max_size);



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_EEPROM_DATA_GET <<

				ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_EEPROM_DATA_GET <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);

	pkt.addr = cpu_to_le64(eeprom_info_dma_addr);

	pkt.data_max_size = cpu_to_le32(max_size);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),

			HL_ARMCP_EEPROM_TIMEOUT_USEC, &result);

			HL_CPUCP_EEPROM_TIMEOUT_USEC, &result);



	if (rc) {

		dev_err(hdev->dev,
@@ -363,20 +363,20 @@ out: 
	return rc;

}



int hl_fw_armcp_pci_counters_get(struct hl_device *hdev,

int hl_fw_cpucp_pci_counters_get(struct hl_device *hdev,

		struct hl_info_pci_counters *counters)

{

	struct armcp_packet pkt = {};

	struct cpucp_packet pkt = {};

	long result;

	int rc;



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_PCIE_THROUGHPUT_GET <<

			ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_PCIE_THROUGHPUT_GET <<

			CPUCP_PKT_CTL_OPCODE_SHIFT);



	/* Fetch PCI rx counter */

	pkt.index = cpu_to_le32(armcp_pcie_throughput_rx);

	pkt.index = cpu_to_le32(cpucp_pcie_throughput_rx);

	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),

					HL_ARMCP_INFO_TIMEOUT_USEC, &result);

					HL_CPUCP_INFO_TIMEOUT_USEC, &result);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to handle ArmCP PCI info pkt, error %d\n", rc);
@@ -385,9 +385,9 @@ int hl_fw_armcp_pci_counters_get(struct hl_device *hdev, 
	counters->rx_throughput = result;



	/* Fetch PCI tx counter */

	pkt.index = cpu_to_le32(armcp_pcie_throughput_tx);

	pkt.index = cpu_to_le32(cpucp_pcie_throughput_tx);

	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),

					HL_ARMCP_INFO_TIMEOUT_USEC, &result);

					HL_CPUCP_INFO_TIMEOUT_USEC, &result);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to handle ArmCP PCI info pkt, error %d\n", rc);
@@ -396,11 +396,11 @@ int hl_fw_armcp_pci_counters_get(struct hl_device *hdev, 
	counters->tx_throughput = result;



	/* Fetch PCI replay counter */

	pkt.ctl = cpu_to_le32(ARMCP_PACKET_PCIE_REPLAY_CNT_GET <<

			ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_PCIE_REPLAY_CNT_GET <<

			CPUCP_PKT_CTL_OPCODE_SHIFT);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),

			HL_ARMCP_INFO_TIMEOUT_USEC, &result);

			HL_CPUCP_INFO_TIMEOUT_USEC, &result);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to handle ArmCP PCI info pkt, error %d\n", rc);
@@ -411,21 +411,20 @@ int hl_fw_armcp_pci_counters_get(struct hl_device *hdev, 
	return rc;

}



int hl_fw_armcp_total_energy_get(struct hl_device *hdev,

			u64 *total_energy)

int hl_fw_cpucp_total_energy_get(struct hl_device *hdev, u64 *total_energy)

{

	struct armcp_packet pkt = {};

	struct cpucp_packet pkt = {};

	long result;

	int rc;



	pkt.ctl = cpu_to_le32(ARMCP_PACKET_TOTAL_ENERGY_GET <<

			ARMCP_PKT_CTL_OPCODE_SHIFT);

	pkt.ctl = cpu_to_le32(CPUCP_PACKET_TOTAL_ENERGY_GET <<

				CPUCP_PKT_CTL_OPCODE_SHIFT);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),

					HL_ARMCP_INFO_TIMEOUT_USEC, &result);

					HL_CPUCP_INFO_TIMEOUT_USEC, &result);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to handle ArmCP total energy pkt, error %d\n",

			"Failed to handle CpuCP total energy pkt, error %d\n",

				rc);

		return rc;

	}

drivers/misc/habanalabs/common/habanalabs.h

+10 −10
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ 
#ifndef HABANALABSP_H_

#define HABANALABSP_H_



#include "../include/common/armcp_if.h"

#include "../include/common/cpucp_if.h"

#include "../include/common/qman_if.h"

#include <uapi/misc/habanalabs.h>
@@ -34,8 +34,8 @@ 


#define HL_PLL_LOW_JOB_FREQ_USEC	5000000 /* 5 s */



#define HL_ARMCP_INFO_TIMEOUT_USEC	10000000 /* 10s */

#define HL_ARMCP_EEPROM_TIMEOUT_USEC	10000000 /* 10s */

#define HL_CPUCP_INFO_TIMEOUT_USEC	10000000 /* 10s */

#define HL_CPUCP_EEPROM_TIMEOUT_USEC	10000000 /* 10s */



#define HL_PCI_ELBI_TIMEOUT_MSEC	10 /* 10ms */
@@ -250,7 +250,7 @@ struct hl_mmu_properties { 
/**

 * struct asic_fixed_properties - ASIC specific immutable properties.

 * @hw_queues_props: H/W queues properties.

 * @armcp_info: received various information from ArmCP regarding the H/W, e.g.

 * @cpucp_info: received various information from CPU-CP regarding the H/W, e.g.

 *		available sensors.

 * @uboot_ver: F/W U-boot version.

 * @preboot_ver: F/W Preboot version.
@@ -301,7 +301,7 @@ struct hl_mmu_properties { 
 */

struct asic_fixed_properties {

	struct hw_queue_properties	*hw_queues_props;

	struct armcp_info		armcp_info;

	struct cpucp_info		cpucp_info;

	char				uboot_ver[VERSION_MAX_LEN];

	char				preboot_ver[VERSION_MAX_LEN];

	struct hl_mmu_properties	dmmu;
@@ -1588,7 +1588,7 @@ struct hl_device { 
	u64				clock_gating_mask;

	atomic_t			in_reset;

	enum hl_pll_frequency		curr_pll_profile;

	enum armcp_card_types		card_type;

	enum cpucp_card_types		card_type;

	int				cs_active_cnt;

	u32				major;

	u32				high_pll;
@@ -1776,7 +1776,7 @@ int hl_device_set_frequency(struct hl_device *hdev, enum hl_pll_frequency freq); 
uint32_t hl_device_utilization(struct hl_device *hdev, uint32_t period_ms);



int hl_build_hwmon_channel_info(struct hl_device *hdev,

		struct armcp_sensor *sensors_arr);

		struct cpucp_sensor *sensors_arr);



int hl_sysfs_init(struct hl_device *hdev);

void hl_sysfs_fini(struct hl_device *hdev);
@@ -1848,11 +1848,11 @@ void *hl_fw_cpu_accessible_dma_pool_alloc(struct hl_device *hdev, size_t size, 
void hl_fw_cpu_accessible_dma_pool_free(struct hl_device *hdev, size_t size,

					void *vaddr);

int hl_fw_send_heartbeat(struct hl_device *hdev);

int hl_fw_armcp_info_get(struct hl_device *hdev);

int hl_fw_cpucp_info_get(struct hl_device *hdev);

int hl_fw_get_eeprom_data(struct hl_device *hdev, void *data, size_t max_size);

int hl_fw_armcp_pci_counters_get(struct hl_device *hdev,

int hl_fw_cpucp_pci_counters_get(struct hl_device *hdev,

		struct hl_info_pci_counters *counters);

int hl_fw_armcp_total_energy_get(struct hl_device *hdev,

int hl_fw_cpucp_total_energy_get(struct hl_device *hdev,

			u64 *total_energy);

int hl_fw_init_cpu(struct hl_device *hdev, u32 cpu_boot_status_reg,

			u32 msg_to_cpu_reg, u32 cpu_msg_status_reg,

CRA Git | Maintained and supported by SUSTech CRA and CCSE