Commit 651425fb authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge tag 'misc-habanalabs-next-2021-12-27' of... 

Merge tag 'misc-habanalabs-next-2021-12-27' of https://git.kernel.org/pub/scm/linux/kernel/git/ogabbay/linux into char-misc-next

Oded writes:

This tag contains habanalabs driver changes for v5.17:

- Support reset-during-reset. In case the f/w notifies the driver
  that the f/w is going to reset the device, the driver should
  support that even if it is in the middle of doing another
  reset

- Support events from f/w that arrive during device resets.
  These events would be ignored which is bad as critical errors
  would not be reported and treated by the driver.

- Don't kill processes that hold the control device open during
  hard-reset of the device. The control device operations can't
  crash if done during hard-reset. And usually, only monitoring
  applications are using the control device, so killing them
  defies their purpose.

- Fix handling of hwmon nodes when working with legacy f/w

- Change the compute context pointer to be boolean. This pointer
  was abused by multiple code paths that wanted fast access to
  the compute context structure.

- Add uapi to fetch historical errors. This is necessary as errors
  sometimes result in hard-reset where the user application is
  being terminated.

- Optimize GAUDI's MMU cache invalidation.

- Add support for loading the latest f/w.

- Add uapi to fetch HBM replacement and pending rows information.

- Multiple bug fixes to the reset code.

- Multiple bug fixes for Multi-CS ioctl code.

- Multiple bug fixes for wait-for-interrupt ioctl code.

- Many small bug fixes and cleanups.

* tag 'misc-habanalabs-next-2021-12-27' of https://git.kernel.org/pub/scm/linux/kernel/git/ogabbay/linux: (70 commits)
  habanalabs: support hard-reset scheduling during soft-reset
  habanalabs: add a lock to protect multiple reset variables
  habanalabs: refactor reset information variables
  habanalabs: handle skip multi-CS if handling not done
  habanalabs: add CPU-CP packet for engine core ASID cfg
  habanalabs: replace some -ENOTTY with -EINVAL
  habanalabs: fix comments according to kernel-doc
  habanalabs: fix endianness when reading cpld version
  habanalabs: change wait_for_interrupt implementation
  habanalabs: prevent wait if CS in multi-CS list completed
  habanalabs: modify cpu boot status error print
  habanalabs: clean MMU headers definitions
  habanalabs: expose soft reset sysfs nodes for inference ASIC
  habanalabs: sysfs support for two infineon versions
  habanalabs: keep control device alive during hard reset
  habanalabs: fix hwmon handling for legacy f/w
  habanalabs: add current PI value to cpu packets
  habanalabs: remove in_debug check in device open
  habanalabs: return correct clock throttling period
  habanalabs: wait again for multi-CS if no CS completed
  ...
parents 372c73b4 ce80098d

Documentation/ABI/testing/debugfs-driver-habanalabs

+15 −8
Original line number Diff line number Diff line
@@ -155,6 +155,13 @@ Description: Triggers an I2C transaction that is generated by the device's 
                CPU. Writing to this file generates a write transaction while

                reading from the file generates a read transaction



What:           /sys/kernel/debug/habanalabs/hl<n>/i2c_len

Date:           Dec 2021

KernelVersion:  5.17

Contact:        obitton@habana.ai

Description:    Sets I2C length in bytes for I2C transaction that is generated by

                the device's CPU



What:           /sys/kernel/debug/habanalabs/hl<n>/i2c_reg

Date:           Jan 2019

KernelVersion:  5.1
@@ -226,12 +233,6 @@ Description: Gets the state dump occurring on a CS timeout or failure. 
                Writing an integer X discards X state dumps, so that the

                next read would return X+1-st newest state dump.



What:           /sys/kernel/debug/habanalabs/hl<n>/timeout_locked

Date:           Sep 2021

KernelVersion:  5.16

Contact:        obitton@habana.ai

Description:    Sets the command submission timeout value in seconds.



What:           /sys/kernel/debug/habanalabs/hl<n>/stop_on_err

Date:           Mar 2020

KernelVersion:  5.6
@@ -239,6 +240,12 @@ Contact: ogabbay@kernel.org 
Description:    Sets the stop-on_error option for the device engines. Value of

                "0" is for disable, otherwise enable.



What:           /sys/kernel/debug/habanalabs/hl<n>/timeout_locked

Date:           Sep 2021

KernelVersion:  5.16

Contact:        obitton@habana.ai

Description:    Sets the command submission timeout value in seconds.



What:           /sys/kernel/debug/habanalabs/hl<n>/userptr

Date:           Jan 2019

KernelVersion:  5.1

drivers/misc/habanalabs/common/command_buffer.c

+32 −14
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ static int cb_map_mem(struct hl_ctx *ctx, struct hl_cb *cb) 
		}



		va_block->start = virt_addr;

		va_block->end = virt_addr + page_size;

		va_block->end = virt_addr + page_size - 1;

		va_block->size = page_size;

		list_add_tail(&va_block->node, &cb->va_block_list);

	}
@@ -80,13 +80,13 @@ static int cb_map_mem(struct hl_ctx *ctx, struct hl_cb *cb) 
		offset += va_block->size;

	}



	hdev->asic_funcs->mmu_invalidate_cache(hdev, false, VM_TYPE_USERPTR);

	rc = hl_mmu_invalidate_cache(hdev, false, MMU_OP_USERPTR | MMU_OP_SKIP_LOW_CACHE_INV);



	mutex_unlock(&ctx->mmu_lock);



	cb->is_mmu_mapped = true;



	return 0;

	return rc;



err_va_umap:

	list_for_each_entry(va_block, &cb->va_block_list, node) {
@@ -97,7 +97,7 @@ static int cb_map_mem(struct hl_ctx *ctx, struct hl_cb *cb) 
		offset -= va_block->size;

	}



	hdev->asic_funcs->mmu_invalidate_cache(hdev, true, VM_TYPE_USERPTR);

	rc = hl_mmu_invalidate_cache(hdev, true, MMU_OP_USERPTR);



	mutex_unlock(&ctx->mmu_lock);
@@ -126,7 +126,7 @@ static void cb_unmap_mem(struct hl_ctx *ctx, struct hl_cb *cb) 
					"Failed to unmap CB's va 0x%llx\n",

					va_block->start);



	hdev->asic_funcs->mmu_invalidate_cache(hdev, true, VM_TYPE_USERPTR);

	hl_mmu_invalidate_cache(hdev, true, MMU_OP_USERPTR);



	mutex_unlock(&ctx->mmu_lock);
@@ -250,8 +250,7 @@ int hl_cb_create(struct hl_device *hdev, struct hl_cb_mgr *mgr, 
	 * Can't use generic function to check this because of special case

	 * where we create a CB as part of the reset process

	 */

	if ((hdev->disabled) || ((atomic_read(&hdev->in_reset)) &&

					(ctx_id != HL_KERNEL_ASID_ID))) {

	if ((hdev->disabled) || (hdev->reset_info.in_reset && (ctx_id != HL_KERNEL_ASID_ID))) {

		dev_warn_ratelimited(hdev->dev,

			"Device is disabled or in reset. Can't create new CBs\n");

		rc = -EBUSY;
@@ -380,8 +379,9 @@ int hl_cb_destroy(struct hl_device *hdev, struct hl_cb_mgr *mgr, u64 cb_handle) 
}



static int hl_cb_info(struct hl_device *hdev, struct hl_cb_mgr *mgr,

			u64 cb_handle, u32 *usage_cnt)

			u64 cb_handle, u32 flags, u32 *usage_cnt, u64 *device_va)

{

	struct hl_vm_va_block *va_block;

	struct hl_cb *cb;

	u32 handle;

	int rc = 0;
@@ -402,7 +402,18 @@ static int hl_cb_info(struct hl_device *hdev, struct hl_cb_mgr *mgr, 
		goto out;

	}



	if (flags & HL_CB_FLAGS_GET_DEVICE_VA) {

		va_block = list_first_entry(&cb->va_block_list, struct hl_vm_va_block, node);

		if (va_block) {

			*device_va = va_block->start;

		} else {

			dev_err(hdev->dev, "CB is not mapped to the device's MMU\n");

			rc = -EINVAL;

			goto out;

		}

	} else {

		*usage_cnt = atomic_read(&cb->cs_cnt);

	}



out:

	spin_unlock(&mgr->cb_lock);
@@ -414,7 +425,7 @@ int hl_cb_ioctl(struct hl_fpriv *hpriv, void *data) 
	union hl_cb_args *args = data;

	struct hl_device *hdev = hpriv->hdev;

	enum hl_device_status status;

	u64 handle = 0;

	u64 handle = 0, device_va;

	u32 usage_cnt = 0;

	int rc;
@@ -450,13 +461,20 @@ int hl_cb_ioctl(struct hl_fpriv *hpriv, void *data) 


	case HL_CB_OP_INFO:

		rc = hl_cb_info(hdev, &hpriv->cb_mgr, args->in.cb_handle,

				&usage_cnt);

		memset(args, 0, sizeof(*args));

				args->in.flags,

				&usage_cnt,

				&device_va);



		memset(&args->out, 0, sizeof(args->out));



		if (args->in.flags & HL_CB_FLAGS_GET_DEVICE_VA)

			args->out.device_va = device_va;

		else

			args->out.usage_cnt = usage_cnt;

		break;



	default:

		rc = -ENOTTY;

		rc = -EINVAL;

		break;

	}

drivers/misc/habanalabs/common/command_submission.c

+287 −102

File changed.

Preview size limit exceeded, changes collapsed.

drivers/misc/habanalabs/common/context.c

+29 −10
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



/*

 * Copyright 2016-2019 HabanaLabs, Ltd.

 * Copyright 2016-2021 HabanaLabs, Ltd.

 * All Rights Reserved.

 */
@@ -13,13 +13,13 @@ void hl_encaps_handle_do_release(struct kref *ref) 
{

	struct hl_cs_encaps_sig_handle *handle =

		container_of(ref, struct hl_cs_encaps_sig_handle, refcount);

	struct hl_ctx *ctx = handle->hdev->compute_ctx;

	struct hl_encaps_signals_mgr *mgr = &ctx->sig_mgr;

	struct hl_encaps_signals_mgr *mgr = &handle->ctx->sig_mgr;



	spin_lock(&mgr->lock);

	idr_remove(&mgr->handles, handle->id);

	spin_unlock(&mgr->lock);



	hl_ctx_put(handle->ctx);

	kfree(handle);

}
@@ -27,8 +27,7 @@ static void hl_encaps_handle_do_release_sob(struct kref *ref) 
{

	struct hl_cs_encaps_sig_handle *handle =

		container_of(ref, struct hl_cs_encaps_sig_handle, refcount);

	struct hl_ctx *ctx = handle->hdev->compute_ctx;

	struct hl_encaps_signals_mgr *mgr = &ctx->sig_mgr;

	struct hl_encaps_signals_mgr *mgr = &handle->ctx->sig_mgr;



	/* if we're here, then there was a signals reservation but cs with

	 * encaps signals wasn't submitted, so need to put refcount
@@ -40,6 +39,7 @@ static void hl_encaps_handle_do_release_sob(struct kref *ref) 
	idr_remove(&mgr->handles, handle->id);

	spin_unlock(&mgr->lock);



	hl_ctx_put(handle->ctx);

	kfree(handle);

}
@@ -97,11 +97,9 @@ static void hl_ctx_fini(struct hl_ctx *ctx) 
		/* The engines are stopped as there is no executing CS, but the

		 * Coresight might be still working by accessing addresses

		 * related to the stopped engines. Hence stop it explicitly.

		 * Stop only if this is the compute context, as there can be

		 * only one compute context

		 */

		if ((hdev->in_debug) && (hdev->compute_ctx == ctx))

			hl_device_set_debug_mode(hdev, false);

		if (hdev->in_debug)

			hl_device_set_debug_mode(hdev, ctx, false);



		hdev->asic_funcs->ctx_fini(ctx);

		hl_cb_va_pool_fini(ctx);
@@ -167,7 +165,7 @@ int hl_ctx_create(struct hl_device *hdev, struct hl_fpriv *hpriv) 
	hpriv->ctx = ctx;



	/* TODO: remove the following line for multiple process support */

	hdev->compute_ctx = ctx;

	hdev->is_compute_ctx_active = true;



	return 0;
@@ -274,6 +272,27 @@ int hl_ctx_put(struct hl_ctx *ctx) 
	return kref_put(&ctx->refcount, hl_ctx_do_release);

}



struct hl_ctx *hl_get_compute_ctx(struct hl_device *hdev)

{

	struct hl_ctx *ctx = NULL;

	struct hl_fpriv *hpriv;



	mutex_lock(&hdev->fpriv_list_lock);



	list_for_each_entry(hpriv, &hdev->fpriv_list, dev_node) {

		/* There can only be a single user which has opened the compute device, so exit

		 * immediately once we find him

		 */

		ctx = hpriv->ctx;

		hl_ctx_get(hdev, ctx);

		break;

	}



	mutex_unlock(&hdev->fpriv_list_lock);



	return ctx;

}



/*

 * hl_ctx_get_fence_locked - get CS fence under CS lock

 *

drivers/misc/habanalabs/common/debugfs.c

+68 −29
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



/*

 * Copyright 2016-2019 HabanaLabs, Ltd.

 * Copyright 2016-2021 HabanaLabs, Ltd.

 * All Rights Reserved.

 */
@@ -15,19 +15,25 @@ 
#define MMU_ADDR_BUF_SIZE	40

#define MMU_ASID_BUF_SIZE	10

#define MMU_KBUF_SIZE		(MMU_ADDR_BUF_SIZE + MMU_ASID_BUF_SIZE)

#define I2C_MAX_TRANSACTION_LEN	8



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)

				u8 i2c_reg, u8 i2c_len, u64 *val)

{

	struct cpucp_packet pkt;

	u64 result;

	int rc;



	if (!hl_device_operational(hdev, NULL))

		return -EBUSY;



	if (i2c_len > I2C_MAX_TRANSACTION_LEN) {

		dev_err(hdev->dev, "I2C transaction length %u, exceeds maximum of %u\n",

				i2c_len, I2C_MAX_TRANSACTION_LEN);

		return -EINVAL;

	}



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



	pkt.ctl = cpu_to_le32(CPUCP_PACKET_I2C_RD <<
@@ -35,12 +41,10 @@ static int hl_debugfs_i2c_read(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 
	pkt.i2c_bus = i2c_bus;

	pkt.i2c_addr = i2c_addr;

	pkt.i2c_reg = i2c_reg;

	pkt.i2c_len = i2c_len;



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

						0, &result);



	*val = (long) result;



						0, val);

	if (rc)

		dev_err(hdev->dev, "Failed to read from I2C, error %d\n", rc);
@@ -48,7 +52,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)

				u8 i2c_reg, u8 i2c_len, u64 val)

{

	struct cpucp_packet pkt;

	int rc;
@@ -56,6 +60,12 @@ static int hl_debugfs_i2c_write(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 
	if (!hl_device_operational(hdev, NULL))

		return -EBUSY;



	if (i2c_len > I2C_MAX_TRANSACTION_LEN) {

		dev_err(hdev->dev, "I2C transaction length %u, exceeds maximum of %u\n",

				i2c_len, I2C_MAX_TRANSACTION_LEN);

		return -EINVAL;

	}



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



	pkt.ctl = cpu_to_le32(CPUCP_PACKET_I2C_WR <<
@@ -63,6 +73,7 @@ static int hl_debugfs_i2c_write(struct hl_device *hdev, u8 i2c_bus, u8 i2c_addr, 
	pkt.i2c_bus = i2c_bus;

	pkt.i2c_addr = i2c_addr;

	pkt.i2c_reg = i2c_reg;

	pkt.i2c_len = i2c_len;

	pkt.value = cpu_to_le64(val);



	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
@@ -235,6 +246,8 @@ static int vm_show(struct seq_file *s, void *data) 
	struct hl_vm_hash_node *hnode;

	struct hl_userptr *userptr;

	struct hl_vm_phys_pg_pack *phys_pg_pack = NULL;

	struct hl_va_range *va_range;

	struct hl_vm_va_block *va_block;

	enum vm_type *vm_type;

	bool once = true;

	u64 j;
@@ -314,6 +327,25 @@ static int vm_show(struct seq_file *s, void *data) 


	spin_unlock(&dev_entry->ctx_mem_hash_spinlock);



	ctx = hl_get_compute_ctx(dev_entry->hdev);

	if (ctx) {

		seq_puts(s, "\nVA ranges:\n\n");

		for (i = HL_VA_RANGE_TYPE_HOST ; i < HL_VA_RANGE_TYPE_MAX ; ++i) {

			va_range = ctx->va_range[i];

			seq_printf(s, "   va_range %d\n", i);

			seq_puts(s, "---------------------\n");

			mutex_lock(&va_range->lock);

			list_for_each_entry(va_block, &va_range->list, node) {

				seq_printf(s, "%#16llx - %#16llx (%#llx)\n",

					   va_block->start, va_block->end,

					   va_block->size);

			}

			mutex_unlock(&va_range->lock);

			seq_puts(s, "\n");

		}

		hl_ctx_put(ctx);

	}



	if (!once)

		seq_puts(s, "\n");
@@ -407,7 +439,7 @@ static int mmu_show(struct seq_file *s, void *data) 
	if (dev_entry->mmu_asid == HL_KERNEL_ASID_ID)

		ctx = hdev->kernel_ctx;

	else

		ctx = hdev->compute_ctx;

		ctx = hl_get_compute_ctx(hdev);



	if (!ctx) {

		dev_err(hdev->dev, "no ctx available\n");
@@ -495,7 +527,7 @@ static int engines_show(struct seq_file *s, void *data) 
	struct hl_dbg_device_entry *dev_entry = entry->dev_entry;

	struct hl_device *hdev = dev_entry->hdev;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev,

				"Can't check device idle during reset\n");

		return 0;
@@ -560,7 +592,7 @@ static int device_va_to_pa(struct hl_device *hdev, u64 virt_addr, u32 size, 
			u64 *phys_addr)

{

	struct hl_vm_phys_pg_pack *phys_pg_pack;

	struct hl_ctx *ctx = hdev->compute_ctx;

	struct hl_ctx *ctx;

	struct hl_vm_hash_node *hnode;

	u64 end_address, range_size;

	struct hl_userptr *userptr;
@@ -568,6 +600,8 @@ static int device_va_to_pa(struct hl_device *hdev, u64 virt_addr, u32 size, 
	bool valid = false;

	int i, rc = 0;



	ctx = hl_get_compute_ctx(hdev);



	if (!ctx) {

		dev_err(hdev->dev, "no ctx available\n");

		return -EINVAL;
@@ -624,7 +658,7 @@ static ssize_t hl_data_read32(struct file *f, char __user *buf, 
	ssize_t rc;

	u32 val;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev, "Can't read during reset\n");

		return 0;

	}
@@ -660,7 +694,7 @@ static ssize_t hl_data_write32(struct file *f, const char __user *buf, 
	u32 value;

	ssize_t rc;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev, "Can't write during reset\n");

		return 0;

	}
@@ -697,7 +731,7 @@ static ssize_t hl_data_read64(struct file *f, char __user *buf, 
	ssize_t rc;

	u64 val;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev, "Can't read during reset\n");

		return 0;

	}
@@ -733,7 +767,7 @@ static ssize_t hl_data_write64(struct file *f, const char __user *buf, 
	u64 value;

	ssize_t rc;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev, "Can't write during reset\n");

		return 0;

	}
@@ -768,7 +802,7 @@ static ssize_t hl_dma_size_write(struct file *f, const char __user *buf, 
	ssize_t rc;

	u32 size;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev, "Can't DMA during reset\n");

		return 0;

	}
@@ -874,22 +908,22 @@ static ssize_t hl_i2c_data_read(struct file *f, char __user *buf, 
	struct hl_dbg_device_entry *entry = file_inode(f)->i_private;

	struct hl_device *hdev = entry->hdev;

	char tmp_buf[32];

	long val;

	u64 val;

	ssize_t rc;



	if (*ppos)

		return 0;



	rc = hl_debugfs_i2c_read(hdev, entry->i2c_bus, entry->i2c_addr,

			entry->i2c_reg, &val);

			entry->i2c_reg, entry->i2c_len, &val);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to read from I2C bus %d, addr %d, reg %d\n",

			entry->i2c_bus, entry->i2c_addr, entry->i2c_reg);

			"Failed to read from I2C bus %d, addr %d, reg %d, len %d\n",

			entry->i2c_bus, entry->i2c_addr, entry->i2c_reg, entry->i2c_len);

		return rc;

	}



	sprintf(tmp_buf, "0x%02lx\n", val);

	sprintf(tmp_buf, "%#02llx\n", val);

	rc = simple_read_from_buffer(buf, count, ppos, tmp_buf,

			strlen(tmp_buf));
@@ -901,19 +935,19 @@ static ssize_t hl_i2c_data_write(struct file *f, const char __user *buf, 
{

	struct hl_dbg_device_entry *entry = file_inode(f)->i_private;

	struct hl_device *hdev = entry->hdev;

	u32 value;

	u64 value;

	ssize_t rc;



	rc = kstrtouint_from_user(buf, count, 16, &value);

	rc = kstrtou64_from_user(buf, count, 16, &value);

	if (rc)

		return rc;



	rc = hl_debugfs_i2c_write(hdev, entry->i2c_bus, entry->i2c_addr,

			entry->i2c_reg, value);

			entry->i2c_reg, entry->i2c_len, value);

	if (rc) {

		dev_err(hdev->dev,

			"Failed to write 0x%02x to I2C bus %d, addr %d, reg %d\n",

			value, entry->i2c_bus, entry->i2c_addr, entry->i2c_reg);

			"Failed to write %#02llx to I2C bus %d, addr %d, reg %d, len %d\n",

			value, entry->i2c_bus, entry->i2c_addr, entry->i2c_reg, entry->i2c_len);

		return rc;

	}
@@ -1043,7 +1077,7 @@ static ssize_t hl_clk_gate_write(struct file *f, const char __user *buf, 
	u64 value;

	ssize_t rc;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev,

				"Can't change clock gating during reset\n");

		return 0;
@@ -1085,7 +1119,7 @@ static ssize_t hl_stop_on_err_write(struct file *f, const char __user *buf, 
	u32 value;

	ssize_t rc;



	if (atomic_read(&hdev->in_reset)) {

	if (hdev->reset_info.in_reset) {

		dev_warn_ratelimited(hdev->dev,

				"Can't change stop on error during reset\n");

		return 0;
@@ -1396,6 +1430,11 @@ void hl_debugfs_add_device(struct hl_device *hdev) 
				dev_entry->root,

				&dev_entry->i2c_reg);



	debugfs_create_u8("i2c_len",

				0644,

				dev_entry->root,

				&dev_entry->i2c_len);



	debugfs_create_file("i2c_data",

				0644,

				dev_entry->root,
@@ -1458,7 +1497,7 @@ void hl_debugfs_add_device(struct hl_device *hdev) 
	debugfs_create_x8("skip_reset_on_timeout",

				0644,

				dev_entry->root,

				&hdev->skip_reset_on_timeout);

				&hdev->reset_info.skip_reset_on_timeout);



	debugfs_create_file("state_dump",

				0600,