/**
  * cxlflash_manage_lun() - handles LUN management activities
  * @sdev:      SCSI device associated with LUN.
- * @manage:    Manage ioctl data structure.
+ * @arg:       Manage ioctl data structure.
  *
  * This routine is used to notify the driver about a LUN's WWID and associate
  * SCSI devices (sdev) with a global LUN instance. Additionally it serves to
  *
  * Return: 0 on success, -errno on failure
  */
-int cxlflash_manage_lun(struct scsi_device *sdev,
-                       struct dk_cxlflash_manage_lun *manage)
+int cxlflash_manage_lun(struct scsi_device *sdev, void *arg)
 {
+       struct dk_cxlflash_manage_lun *manage = arg;
        struct cxlflash_cfg *cfg = shost_priv(sdev->host);
        struct device *dev = &cfg->dev->dev;
        struct llun_info *lli = NULL;
 
 /**
  * cxlflash_lun_provision() - host LUN provisioning handler
  * @cfg:       Internal structure associated with the host.
- * @lunprov:   Kernel copy of userspace ioctl data structure.
+ * @arg:       Kernel copy of userspace ioctl data structure.
  *
  * Return: 0 on success, -errno on failure
  */
-static int cxlflash_lun_provision(struct cxlflash_cfg *cfg,
-                                 struct ht_cxlflash_lun_provision *lunprov)
+static int cxlflash_lun_provision(struct cxlflash_cfg *cfg, void *arg)
 {
+       struct ht_cxlflash_lun_provision *lunprov = arg;
        struct afu *afu = cfg->afu;
        struct device *dev = &cfg->dev->dev;
        struct sisl_ioarcb rcb;
 /**
  * cxlflash_afu_debug() - host AFU debug handler
  * @cfg:       Internal structure associated with the host.
- * @afu_dbg:   Kernel copy of userspace ioctl data structure.
+ * @arg:       Kernel copy of userspace ioctl data structure.
  *
  * For debug requests requiring a data buffer, always provide an aligned
  * (cache line) buffer to the AFU to appease any alignment requirements.
  *
  * Return: 0 on success, -errno on failure
  */
-static int cxlflash_afu_debug(struct cxlflash_cfg *cfg,
-                             struct ht_cxlflash_afu_debug *afu_dbg)
+static int cxlflash_afu_debug(struct cxlflash_cfg *cfg, void *arg)
 {
+       struct ht_cxlflash_afu_debug *afu_dbg = arg;
        struct afu *afu = cfg->afu;
        struct device *dev = &cfg->dev->dev;
        struct sisl_ioarcb rcb;
                size_t size;
                hioctl ioctl;
        } ioctl_tbl[] = {       /* NOTE: order matters here */
-       { sizeof(struct ht_cxlflash_lun_provision),
-               (hioctl)cxlflash_lun_provision },
-       { sizeof(struct ht_cxlflash_afu_debug),
-               (hioctl)cxlflash_afu_debug },
+       { sizeof(struct ht_cxlflash_lun_provision), cxlflash_lun_provision },
+       { sizeof(struct ht_cxlflash_afu_debug), cxlflash_afu_debug },
        };
 
        /* Hold read semaphore so we can drain if needed */
 
        return rc;
 }
 
-int cxlflash_disk_release(struct scsi_device *sdev,
-                         struct dk_cxlflash_release *release)
+int cxlflash_disk_release(struct scsi_device *sdev, void *release)
 {
        return _cxlflash_disk_release(sdev, NULL, release);
 }
        return rc;
 }
 
-static int cxlflash_disk_detach(struct scsi_device *sdev,
-                               struct dk_cxlflash_detach *detach)
+static int cxlflash_disk_detach(struct scsi_device *sdev, void *detach)
 {
        return _cxlflash_disk_detach(sdev, NULL, detach);
 }
 /**
  * cxlflash_disk_attach() - attach a LUN to a context
  * @sdev:      SCSI device associated with LUN.
- * @attach:    Attach ioctl data structure.
+ * @arg:       Attach ioctl data structure.
  *
  * Creates a context and attaches LUN to it. A LUN can only be attached
  * one time to a context (subsequent attaches for the same context/LUN pair
  *
  * Return: 0 on success, -errno on failure
  */
-static int cxlflash_disk_attach(struct scsi_device *sdev,
-                               struct dk_cxlflash_attach *attach)
+static int cxlflash_disk_attach(struct scsi_device *sdev, void *arg)
 {
+       struct dk_cxlflash_attach *attach = arg;
        struct cxlflash_cfg *cfg = shost_priv(sdev->host);
        struct device *dev = &cfg->dev->dev;
        struct afu *afu = cfg->afu;
 /**
  * cxlflash_afu_recover() - initiates AFU recovery
  * @sdev:      SCSI device associated with LUN.
- * @recover:   Recover ioctl data structure.
+ * @arg:       Recover ioctl data structure.
  *
  * Only a single recovery is allowed at a time to avoid exhausting CXL
  * resources (leading to recovery failure) in the event that we're up
  *
  * Return: 0 on success, -errno on failure
  */
-static int cxlflash_afu_recover(struct scsi_device *sdev,
-                               struct dk_cxlflash_recover_afu *recover)
+static int cxlflash_afu_recover(struct scsi_device *sdev, void *arg)
 {
+       struct dk_cxlflash_recover_afu *recover = arg;
        struct cxlflash_cfg *cfg = shost_priv(sdev->host);
        struct device *dev = &cfg->dev->dev;
        struct llun_info *lli = sdev->hostdata;
 /**
  * cxlflash_disk_verify() - verifies a LUN is the same and handle size changes
  * @sdev:      SCSI device associated with LUN.
- * @verify:    Verify ioctl data structure.
+ * @arg:       Verify ioctl data structure.
  *
  * Return: 0 on success, -errno on failure
  */
-static int cxlflash_disk_verify(struct scsi_device *sdev,
-                               struct dk_cxlflash_verify *verify)
+static int cxlflash_disk_verify(struct scsi_device *sdev, void *arg)
 {
+       struct dk_cxlflash_verify *verify = arg;
        int rc = 0;
        struct ctx_info *ctxi = NULL;
        struct cxlflash_cfg *cfg = shost_priv(sdev->host);
                size_t size;
                sioctl ioctl;
        } ioctl_tbl[] = {       /* NOTE: order matters here */
-       {sizeof(struct dk_cxlflash_attach), (sioctl)cxlflash_disk_attach},
+       {sizeof(struct dk_cxlflash_attach), cxlflash_disk_attach},
        {sizeof(struct dk_cxlflash_udirect), cxlflash_disk_direct_open},
-       {sizeof(struct dk_cxlflash_release), (sioctl)cxlflash_disk_release},
-       {sizeof(struct dk_cxlflash_detach), (sioctl)cxlflash_disk_detach},
-       {sizeof(struct dk_cxlflash_verify), (sioctl)cxlflash_disk_verify},
-       {sizeof(struct dk_cxlflash_recover_afu), (sioctl)cxlflash_afu_recover},
-       {sizeof(struct dk_cxlflash_manage_lun), (sioctl)cxlflash_manage_lun},
+       {sizeof(struct dk_cxlflash_release), cxlflash_disk_release},
+       {sizeof(struct dk_cxlflash_detach), cxlflash_disk_detach},
+       {sizeof(struct dk_cxlflash_verify), cxlflash_disk_verify},
+       {sizeof(struct dk_cxlflash_recover_afu), cxlflash_afu_recover},
+       {sizeof(struct dk_cxlflash_manage_lun), cxlflash_manage_lun},
        {sizeof(struct dk_cxlflash_uvirtual), cxlflash_disk_virtual_open},
-       {sizeof(struct dk_cxlflash_resize), (sioctl)cxlflash_vlun_resize},
-       {sizeof(struct dk_cxlflash_clone), (sioctl)cxlflash_disk_clone},
+       {sizeof(struct dk_cxlflash_resize), cxlflash_vlun_resize},
+       {sizeof(struct dk_cxlflash_clone), cxlflash_disk_clone},
        };
 
        /* Hold read semaphore so we can drain if needed */
 
        struct page *err_page; /* One page of all 0xF for error notification */
 };
 
-int cxlflash_vlun_resize(struct scsi_device *sdev,
-                        struct dk_cxlflash_resize *resize);
+int cxlflash_vlun_resize(struct scsi_device *sdev, void *resize);
 int _cxlflash_vlun_resize(struct scsi_device *sdev, struct ctx_info *ctxi,
                          struct dk_cxlflash_resize *resize);
 
 int cxlflash_disk_release(struct scsi_device *sdev,
-                         struct dk_cxlflash_release *release);
+                         void *release);
 int _cxlflash_disk_release(struct scsi_device *sdev, struct ctx_info *ctxi,
                           struct dk_cxlflash_release *release);
 
-int cxlflash_disk_clone(struct scsi_device *sdev,
-                       struct dk_cxlflash_clone *clone);
+int cxlflash_disk_clone(struct scsi_device *sdev, void *arg);
 
 int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg);
 
 
 void cxlflash_ba_terminate(struct ba_lun *ba_lun);
 
-int cxlflash_manage_lun(struct scsi_device *sdev,
-                       struct dk_cxlflash_manage_lun *manage);
+int cxlflash_manage_lun(struct scsi_device *sdev, void *manage);
 
 int check_state(struct cxlflash_cfg *cfg);
 
 
        return rc;
 }
 
-int cxlflash_vlun_resize(struct scsi_device *sdev,
-                        struct dk_cxlflash_resize *resize)
+int cxlflash_vlun_resize(struct scsi_device *sdev, void *resize)
 {
        return _cxlflash_vlun_resize(sdev, NULL, resize);
 }
 /**
  * cxlflash_disk_clone() - clone a context by making snapshot of another
  * @sdev:      SCSI device associated with LUN owning virtual LUN.
- * @clone:     Clone ioctl data structure.
+ * @arg:       Clone ioctl data structure.
  *
  * This routine effectively performs cxlflash_disk_open operation for each
  * in-use virtual resource in the source context. Note that the destination
  *
  * Return: 0 on success, -errno on failure
  */
-int cxlflash_disk_clone(struct scsi_device *sdev,
-                       struct dk_cxlflash_clone *clone)
+int cxlflash_disk_clone(struct scsi_device *sdev, void *arg)
 {
+       struct dk_cxlflash_clone *clone = arg;
        struct cxlflash_cfg *cfg = shost_priv(sdev->host);
        struct device *dev = &cfg->dev->dev;
        struct llun_info *lli = sdev->hostdata;