*/
 struct dfl_dev_info {
        const char *name;
-       u32 dfh_id;
+       u16 dfh_id;
        struct idr id;
        enum dfl_fpga_devt_type devt_type;
 };
        return DFL_ID_MAX;
 }
 
-static enum dfl_id_type dfh_id_to_type(u32 id)
+static enum dfl_id_type dfh_id_to_type(u16 id)
 {
        int i;
 
  * @nr_irqs: number of irqs of this sub feature.
  */
 struct dfl_feature_info {
-       u64 fid;
+       u16 fid;
        struct resource mmio_res;
        void __iomem *ioaddr;
        struct list_head node;
        return ofst ? ofst : 4096;
 }
 
-static u64 feature_id(void __iomem *start)
+static u16 feature_id(void __iomem *start)
 {
        u64 v = readq(start + DFH);
        u16 id = FIELD_GET(DFH_ID, v);
 }
 
 static int parse_feature_irqs(struct build_feature_devs_info *binfo,
-                             resource_size_t ofst, u64 fid,
+                             resource_size_t ofst, u16 fid,
                              unsigned int *irq_base, unsigned int *nr_irqs)
 {
        void __iomem *base = binfo->ioaddr + ofst;
                return 0;
        }
 
-       dev_dbg(binfo->dev, "feature: 0x%llx, irq_base: %u, nr_irqs: %u\n",
+       dev_dbg(binfo->dev, "feature: 0x%x, irq_base: %u, nr_irqs: %u\n",
                fid, ibase, inr);
 
        if (ibase + inr > binfo->nr_irqs) {
                dev_err(binfo->dev,
-                       "Invalid interrupt number in feature 0x%llx\n", fid);
+                       "Invalid interrupt number in feature 0x%x\n", fid);
                return -EINVAL;
        }
 
                virq = binfo->irq_table[ibase + i];
                if (virq < 0 || virq > NR_IRQS) {
                        dev_err(binfo->dev,
-                               "Invalid irq table entry for feature 0x%llx\n",
+                               "Invalid irq table entry for feature 0x%x\n",
                                fid);
                        return -EINVAL;
                }
 static int
 create_feature_instance(struct build_feature_devs_info *binfo,
                        struct dfl_fpga_enum_dfl *dfl, resource_size_t ofst,
-                       resource_size_t size, u64 fid)
+                       resource_size_t size, u16 fid)
 {
        unsigned int irq_base, nr_irqs;
        struct dfl_feature_info *finfo;
                             struct dfl_fpga_enum_dfl *dfl,
                             resource_size_t ofst)
 {
-       u32 id, offset;
-       u64 v;
        int ret = 0;
+       u32 offset;
+       u16 id;
+       u64 v;
 
        v = readq(dfl->ioaddr + ofst + DFH);
        id = FIELD_GET(DFH_ID, v);
                                 resource_size_t ofst)
 {
        if (!binfo->feature_dev) {
-               dev_err(binfo->dev, "the private feature %llx does not belong to any AFU.\n",
-                       (unsigned long long)feature_id(dfl->ioaddr + ofst));
+               dev_err(binfo->dev, "the private feature 0x%x does not belong to any AFU.\n",
+                       feature_id(dfl->ioaddr + ofst));
                return -EINVAL;
        }
 
                return 0;
 
        feature->irq_ctx[idx].name =
-               kasprintf(GFP_KERNEL, "fpga-irq[%u](%s-%llx)", idx,
+               kasprintf(GFP_KERNEL, "fpga-irq[%u](%s-%x)", idx,
                          dev_name(&pdev->dev), feature->id);
        if (!feature->irq_ctx[idx].name)
                return -ENOMEM;
 
  * @id: unique dfl private feature id.
  */
 struct dfl_feature_id {
-       u64 id;
+       u16 id;
 };
 
 /**
  */
 struct dfl_feature {
        struct platform_device *dev;
-       u64 id;
+       u16 id;
        int resource_index;
        void __iomem *ioaddr;
        struct dfl_feature_irq_ctx *irq_ctx;
           (feature) < (pdata)->features + (pdata)->num; (feature)++)
 
 static inline
-struct dfl_feature *dfl_get_feature_by_id(struct device *dev, u64 id)
+struct dfl_feature *dfl_get_feature_by_id(struct device *dev, u16 id)
 {
        struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
        struct dfl_feature *feature;
 }
 
 static inline
-void __iomem *dfl_get_feature_ioaddr_by_id(struct device *dev, u64 id)
+void __iomem *dfl_get_feature_ioaddr_by_id(struct device *dev, u16 id)
 {
        struct dfl_feature *feature = dfl_get_feature_by_id(dev, id);
 
        return NULL;
 }
 
-static inline bool is_dfl_feature_present(struct device *dev, u64 id)
+static inline bool is_dfl_feature_present(struct device *dev, u16 id)
 {
        return !!dfl_get_feature_ioaddr_by_id(dev, id);
 }