(incompatible) rename: ZATTR* to ZIO_ATTR*

Signed-off-by: Federico Vaga <federico.vaga@gmail.com> Acked-by: Alessandro Rubini <rubini@gnudd.com>

(incompatible) rename: ZATTR* to ZIO_ATTR*
Signed-off-by: Federico Vaga <federico.vaga@gmail.com> Acked-by: Alessandro Rubini <rubini@gnudd.com>
59dbd209 · Federico Vaga · 0be7a061 · 59dbd209 · 59dbd209 · 59dbd209
Commit 59dbd209 authored Nov 03, 2012 by Federico Vaga
10 changed files
--- a/buffers/zio-buf-kmalloc.c
+++ b/buffers/zio-buf-kmalloc.c
@@ -41,8 +41,8 @@ struct zbk_item {
 };
 #define to_item(block) container_of(block, struct zbk_item, block);

-static DEFINE_ZATTR_STD(ZIO_BUF, zbk_std_zattr) = {
-	ZATTR_REG(zbuf, ZATTR_ZBUF_MAXLEN, S_IRUGO | S_IWUGO, 0x0, 16),
+static ZIO_ATTR_DEFINE_STD(ZIO_BUF, zbk_std_zattr) = {
+	ZIO_ATTR_REG(zbuf, ZIO_ATTR_ZBUF_MAXLEN, S_IRUGO | S_IWUGO, 0x0, 16),
 };

 static int zbk_conf_set(struct device *dev, struct zio_attribute *zattr,
@@ -149,7 +149,7 @@ static int zbk_store_block(struct zio_bi *bi, struct zio_block *block)

 	/* add to the buffer instance or push to the trigger */
 	spin_lock(&bi->lock);
-	if (zbki->nitem >= bi->zattr_set.std_zattr[ZATTR_ZBUF_MAXLEN].value)
+	if (zbki->nitem >= bi->zattr_set.std_zattr[ZIO_ATTR_ZBUF_MAXLEN].value)
 		goto out_unlock;
 	list_add_tail(&item->list, &zbki->list);
 	if (!zbki->nitem) {
@@ -190,7 +190,7 @@ static struct zio_block *zbk_retr_block(struct zio_bi *bi)
 	first = zbki->list.next;
 	item = list_entry(first, struct zbk_item, list);
 	list_del(&item->list);
-	if (zbki->nitem == bi->zattr_set.std_zattr[ZATTR_ZBUF_MAXLEN].value)
+	if (zbki->nitem == bi->zattr_set.std_zattr[ZIO_ATTR_ZBUF_MAXLEN].value)
 		awake = 1;
 	zbki->nitem--;
 	spin_unlock(&bi->lock);

--- a/buffers/zio-buf-vmalloc.c
+++ b/buffers/zio-buf-vmalloc.c
@@ -50,8 +50,8 @@ struct zbk_item {
 };
 #define to_item(block) container_of(block, struct zbk_item, block);

-static DEFINE_ZATTR_STD(ZIO_BUF, zbk_std_zattr) = {
-	ZATTR_REG(zbuf, ZATTR_ZBUF_MAXKB, S_IRUGO | S_IWUGO, 0x0, 128 /* kB */),
+static ZIO_ATTR_DEFINE_STD(ZIO_BUF, zbk_std_zattr) = {
+	ZIO_ATTR_REG(zbuf, ZIO_ATTR_ZBUF_MAXKB, S_IRUGO | S_IWUGO, 0x0, 128 /* kB */),
 };

 static int zbk_conf_set(struct device *dev, struct zio_attribute *zattr,
@@ -273,7 +273,7 @@ static struct zio_bi *zbk_create(struct zio_buffer_type *zbuf,
 	zbki = kzalloc(sizeof(*zbki), GFP_KERNEL);
 	if (!zbki)
 		return ERR_PTR(-ENOMEM);
-	size = 1024 * zbuf->zattr_set.std_zattr[ZATTR_ZBUF_MAXKB].value;
+	size = 1024 * zbuf->zattr_set.std_zattr[ZIO_ATTR_ZBUF_MAXKB].value;
 	zbki->size = size;
 	zbki->data = vmalloc(size);
 	if (!zbki->data) {

--- a/drivers/zio-ad788x.c
+++ b/drivers/zio-ad788x.c
@@ -55,28 +55,28 @@ struct ad788x {
 * register to set but only a value. Address is used as mask in the tx_buf.
 */
 /* Standard attributes for AD7887*/
-static DEFINE_ZATTR_STD(ZIO_DEV, zattr_dev_ad7887) = {
-	ZATTR_REG(zdev, ZATTR_NBITS, S_IRUGO, 0, 12),
+static ZIO_ATTR_DEFINE_STD(ZIO_DEV, zattr_dev_ad7887) = {
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_NBITS, S_IRUGO, 0, 12),
 	/* vref_src can be internal (0) or external (1)*/
-	ZATTR_REG(zdev, ZATTR_VREFTYPE, S_IRUGO | S_IWUGO, AD7887_VREF_ADDR, 1),
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_VREFTYPE, S_IRUGO | S_IWUGO, AD7887_VREF_ADDR, 1),
 };
 /* Standard attributes for AD7888*/
-static DEFINE_ZATTR_STD(ZIO_DEV, zattr_dev_ad7888) = {
-	ZATTR_REG(zdev, ZATTR_NBITS, S_IRUGO, 0, 12),
+static ZIO_ATTR_DEFINE_STD(ZIO_DEV, zattr_dev_ad7888) = {
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_NBITS, S_IRUGO, 0, 12),
 	/* vref_src can be internal (0) or external (1)*/
-	ZATTR_REG(zdev, ZATTR_VREFTYPE, S_IRUGO | S_IWUGO, AD7888_VREF_ADDR, 0),
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_VREFTYPE, S_IRUGO | S_IWUGO, AD7888_VREF_ADDR, 0),
 };
 /* Extended attributes for AD7887 */
 static struct zio_attribute zattr_dev_ext_ad7887[] = {
-		ZATTR_EXT_REG(AD788x_PM_NAME, S_IRUGO | S_IWUGO,
+		ZIO_ATTR_EXT_REG(AD788x_PM_NAME, S_IRUGO | S_IWUGO,
 			      AD788x_PM_ADDR, 0x0),
 		/* 0 single channel, 1 dual channel*/
-		ZATTR_EXT_REG(AD7887_DUAL_NAME, S_IRUGO | S_IWUGO,
+		ZIO_ATTR_EXT_REG(AD7887_DUAL_NAME, S_IRUGO | S_IWUGO,
 			      AD7887_SINDUAL_ADDR, 1),
 };
 /* Extended attributes for AD7888 */
 static struct zio_attribute zattr_dev_ext_ad7888[] = {
-		ZATTR_EXT_REG(AD788x_PM_NAME, S_IRUGO | S_IWUGO,
+		ZIO_ATTR_EXT_REG(AD788x_PM_NAME, S_IRUGO | S_IWUGO,
 			      AD788x_PM_ADDR, 0x0),
 };

@@ -251,7 +251,7 @@ static int ad788x_zio_probe(struct zio_device *zdev)
 	/* Setting up the default value for the SPI command */
 	vshift = (ad788x->type == ID_AD7887 ? AD7887_VREF_SHIFT :
 					      AD7888_VREF_SHIFT);
-	ad788x->cmd = zattr_set->std_zattr[ZATTR_VREFTYPE].value << vshift;
+	ad788x->cmd = zattr_set->std_zattr[ZIO_ATTR_VREFTYPE].value << vshift;
 	ad788x->cmd |= zattr_set->ext_zattr[0].value << AD788x_PM_SHIFT;
 	if (ad788x->type == ID_AD7887)
 		ad788x->cmd |= zattr_set->ext_zattr[1].value <<

--- a/drivers/zio-gpio.c
+++ b/drivers/zio-gpio.c
@@ -35,8 +35,8 @@ module_param_array_named(in, zgp_in, int, &zgp_nin, 0444);
 ZIO_PARAM_TRIGGER(zgp_trigger);
 ZIO_PARAM_BUFFER(zgp_buffer);

-DEFINE_ZATTR_STD(ZIO_DEV, zgp_zattr_dev) = {
-	ZATTR_REG(zdev, ZATTR_NBITS, S_IRUGO, 0, 1), /* digital */
+ZIO_ATTR_DEFINE_STD(ZIO_DEV, zgp_zattr_dev) = {
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_NBITS, S_IRUGO, 0, 1), /* digital */
 };

 /* This outputs a cset, currently made up of one channel only */

--- a/drivers/zio-zero.c
+++ b/drivers/zio-zero.c
@@ -18,18 +18,18 @@
 ZIO_PARAM_TRIGGER(zzero_trigger);
 ZIO_PARAM_BUFFER(zzero_buffer);

-DEFINE_ZATTR_STD(ZIO_DEV, zzero_zattr_cset8) = {
-	ZATTR_REG(zdev, ZATTR_NBITS, S_IRUGO, 0, 8), /* 8 bit -> ssize = 1 */
+ZIO_ATTR_DEFINE_STD(ZIO_DEV, zzero_zattr_cset8) = {
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_NBITS, S_IRUGO, 0, 8), /* 8 bit -> ssize = 1 */
 };
-DEFINE_ZATTR_STD(ZIO_DEV, zzero_zattr_cset32) = {
-	ZATTR_REG(zdev, ZATTR_NBITS, S_IRUGO, 0, 32), /* 32 bit -> ssize = 4 */
+ZIO_ATTR_DEFINE_STD(ZIO_DEV, zzero_zattr_cset32) = {
+	ZIO_ATTR_REG(zdev, ZIO_ATTR_NBITS, S_IRUGO, 0, 32), /* 32 bit -> ssize = 4 */
 };
 /* This attribute is the sequence point for input channel number 0 of cset 2 */
 enum zzero_ext{
 	ZZERO_SEQ,
 };
 static struct zio_attribute zzero_cset1_ext[] = {
-	ZATTR_EXT_REG("sequence", S_IRUGO | S_IWUGO, ZZERO_SEQ, 0),
+	ZIO_ATTR_EXT_REG("sequence", S_IRUGO | S_IWUGO, ZZERO_SEQ, 0),
 };
 /*
 * This generates a sequence of 32-bit little-endian numbers.

--- a/include/linux/zio-sysfs.h
+++ b/include/linux/zio-sysfs.h
@@ -39,12 +39,12 @@ struct zio_attribute {
 	uint32_t				value;
 	const struct zio_sysfs_operations	*s_op;
 };
-#define ZATTR_INDEX_NONE -1
+#define ZIO_ATTR_INDEX_NONE -1
 enum zattr_flags {
-	ZATTR_TYPE	= 0x10,
-	ZATTR_TYPE_STD	= 0x00,
-	ZATTR_TYPE_EXT	= 0x10,
-	ZATTR_CONTROL	= 0x20,
+    ZIO_ATTR_TYPE	 = 0x10,
+	ZIO_ATTR_TYPE_STD	= 0x00,
+	ZIO_ATTR_TYPE_EXT	= 0x10,
+	ZIO_ATTR_CONTROL	= 0x20,
 };

 struct zio_sysfs_operations {
@@ -70,22 +70,22 @@ struct zio_attribute_set {
 };

 enum zio_dev_std_attr {
-	ZATTR_NBITS,	/* number of bits per sample */
-	ZATTR_GAIN,	/* gain for signal, integer in 0.001 steps */
-	ZATTR_OFFSET,	/* microvolts */
-	ZATTR_MAXRATE,	/* hertz */
-	ZATTR_VREFTYPE,	/* source of Vref (0 = default) */
+	ZIO_ATTR_NBITS,	/* number of bits per sample */
+	ZIO_ATTR_GAIN,	/* gain for signal, integer in 0.001 steps */
+	ZIO_ATTR_OFFSET,	/* microvolts */
+	ZIO_ATTR_MAXRATE,	/* hertz */
+	ZIO_ATTR_VREFTYPE,	/* source of Vref (0 = default) */
 	_ZIO_DEV_ATTR_STD_NUM,	/* used to size arrays */
 };
 enum zio_trg_std_attr {
-	ZATTR_TRIG_REENABLE = 0,/* re-arm trigger */
-	ZATTR_TRIG_POST_SAMP,	/* samples after trigger fire */
-	ZATTR_TRIG_PRE_SAMP,	/* samples before trigger fire */
+	ZIO_ATTR_TRIG_REENABLE = 0,/* re-arm trigger */
+	ZIO_ATTR_TRIG_POST_SAMP,	/* samples after trigger fire */
+	ZIO_ATTR_TRIG_PRE_SAMP,	/* samples before trigger fire */
 	_ZIO_TRG_ATTR_STD_NUM,	/* used to size arrays */
 };
 enum zio_buf_std_attr {
-	ZATTR_ZBUF_MAXLEN = 0,	/* max number of element in buffer */
-	ZATTR_ZBUF_MAXKB,	/* max number of kB in buffer */
+	ZIO_ATTR_ZBUF_MAXLEN = 0,	/* max number of element in buffer */
+	ZIO_ATTR_ZBUF_MAXKB,	/* max number of kB in buffer */
 	_ZIO_BUF_ATTR_STD_NUM,	/* used to size arrays */
 };

@@ -93,16 +93,20 @@ extern const char zio_zdev_attr_names[_ZIO_DEV_ATTR_STD_NUM][ZIO_NAME_LEN];
 extern const char zio_trig_attr_names[_ZIO_TRG_ATTR_STD_NUM][ZIO_NAME_LEN];
 extern const char zio_zbuf_attr_names[_ZIO_BUF_ATTR_STD_NUM][ZIO_NAME_LEN];

-#define DEFINE_ZATTR_STD(_type, _name) struct zio_attribute \
+#define ZIO_ATTR_DEFINE_STD(_type, _name) struct zio_attribute \
 	_name[_##_type##_ATTR_STD_NUM]

 /*
- * @ZATTR_REG: define a zio attribute with address register
- * @ZATTR_PRV: define a zio attribute with private register
- * @ZATTR_EXT_REG: define a zio extended attribute with address register
- * @ZATTR_EXT_PRV: define a zio extended attribute with private register
+ * @ZIO_ATTR_REG: define a zio attribute with address register
+ * @ZIO_ATTR_PRV: define a zio attribute with private register
+ * @ZIO_ATTR_EXT_REG: define a zio extended attribute with address register
+ * @ZIO_ATTR_EXT_PRV: define a zio extended attribute with private register
+ * @ZIO_PARAM_EXT_REG: define a zio attribute parameter with address register
+ *                     (not included in ctrl)
+ * @ZIO_PARAM_EXT_PRV: define a zio attribute parameter with private register
+ *                     (not included in ctrl)
 */
-#define ZATTR_REG(zobj, _type, _mode, _add, _val)[_type] = {		\
+#define ZIO_ATTR_REG(zobj, _type, _mode, _add, _val)[_type] = {		\
 		.attr = {						\
 			.attr = {					\
 				.name = zio_##zobj##_attr_names[_type],	\
@@ -111,9 +115,9 @@ extern const char zio_zbuf_attr_names[_ZIO_BUF_ATTR_STD_NUM][ZIO_NAME_LEN];
 		},							\
 		.priv.addr = _add,					\
 		.value = _val,						\
-		.flags = ZATTR_CONTROL,					\
+		.flags = ZIO_ATTR_CONTROL,		       		\
 }
-#define ZATTR_PRV(zobj, _type, _mode, _priv, _val)[_type] = {		\
+#define ZIO_ATTR_PRV(zobj, _type, _mode, _priv, _val)[_type] = {	\
 		.attr = {						\
 			.attr = {					\
 				.name = zio_##zobj##_attr_names[_type],	\
@@ -122,25 +126,25 @@ extern const char zio_zbuf_attr_names[_ZIO_BUF_ATTR_STD_NUM][ZIO_NAME_LEN];
 		},							\
 		.priv.ptr = _priv,					\
 		.value = _val,						\
-		.flags = ZATTR_CONTROL,					\
+		.flags = ZIO_ATTR_CONTROL,				\
 }
-#define ZATTR_EXT_REG(_name, _mode, _add, _val) {			\
+#define ZIO_ATTR_EXT_REG(_name, _mode, _add, _val) {			\
 		.attr = { .attr = {.name = _name, .mode = _mode},},	\
 		.priv.addr = _add,					\
 		.value = _val,						\
-		.flags = ZATTR_CONTROL,					\
+		.flags = ZIO_ATTR_CONTROL,				\
 }
-#define PARAM_EXT_REG(_name, _mode, _add, _val) {			\
+#define ZIO_PARAM_EXT_REG(_name, _mode, _add, _val) {			\
 		.attr = { .attr = {.name = _name, .mode = _mode},},	\
 		.priv.addr = _add,					\
 		.value = _val,						\
 		.flags = 0,						\
 }
-#define ZATTR_EXT_PRV(_name, _mode, _priv, _val) {			\
+#define ZIO_ATTR_EXT_PRV(_name, _mode, _priv, _val) {			\
 		.attr = { .attr = {.name = _name, .mode = _mode},},	\
 		.priv.ptr = _priv,					\
 		.value = _val,						\
-		.flags = ZATTR_CONTROL,					\
+		.flags = ZIO_ATTR_CONTROL,				\
 }

 #endif /* ZIO_SYSFS_H_ */
--- a/triggers/zio-trig-irq.c
+++ b/triggers/zio-trig-irq.c
@@ -28,14 +28,14 @@ enum zti_attrs {
 	ZTI_ATTR_GPIO,
 };

-static DEFINE_ZATTR_STD(ZIO_TRG, zti_std_attr) = {
-	ZATTR_REG(trig, ZATTR_TRIG_POST_SAMP, S_IRUGO | S_IWUGO,
+static ZIO_ATTR_DEFINE_STD(ZIO_TRG, zti_std_attr) = {
+	ZIO_ATTR_REG(trig, ZIO_ATTR_TRIG_POST_SAMP, S_IRUGO | S_IWUGO,
 		  ZTI_ATTR_NSAMPLES, 16),
 };

 static struct zio_attribute zti_ext_attr[] = {
-	ZATTR_EXT_REG("irq", S_IRUGO, ZTI_ATTR_IRQ, -1),
-	ZATTR_EXT_REG("gpio", S_IRUGO, ZTI_ATTR_GPIO, -1),
+	ZIO_ATTR_EXT_REG("irq", S_IRUGO, ZTI_ATTR_IRQ, -1),
+	ZIO_ATTR_EXT_REG("gpio", S_IRUGO, ZTI_ATTR_GPIO, -1),
 };
 static int zti_conf_set(struct device *dev, struct zio_attribute *zattr,
 		uint32_t  usr_val)

--- a/triggers/zio-trig-timer.c
+++ b/triggers/zio-trig-timer.c
@@ -32,13 +32,13 @@ enum ztt_attrs { /* names for the "addr" value of sw parameters */
 	ZTT_ATTR_PERIOD,
 };

-static DEFINE_ZATTR_STD(ZIO_TRG, ztt_std_attr) = {
-	ZATTR_REG(trig, ZATTR_TRIG_POST_SAMP, S_IRUGO | S_IWUGO,
+static ZIO_ATTR_DEFINE_STD(ZIO_TRG, ztt_std_attr) = {
+	ZIO_ATTR_REG(trig, ZIO_ATTR_TRIG_POST_SAMP, S_IRUGO | S_IWUGO,
 		  ZTT_ATTR_NSAMPLES, 16),
 };

 static struct zio_attribute ztt_ext_attr[] = {
-	ZATTR_EXT_REG("ms-period", S_IRUGO | S_IWUGO,
+	ZIO_ATTR_EXT_REG("ms-period", S_IRUGO | S_IWUGO,
 		      ZTT_ATTR_PERIOD, 2000),
 };
 static int ztt_conf_set(struct device *dev, struct zio_attribute *zattr,

--- a/triggers/zio-trig-user.c
+++ b/triggers/zio-trig-user.c
@@ -19,8 +19,8 @@

 #define ZTU_DEFAULT_BLOCK_SIZE 16

-static DEFINE_ZATTR_STD(ZIO_TRG, ztu_std_attr) = {
-	ZATTR_REG(trig, ZATTR_TRIG_POST_SAMP, S_IRUGO | S_IWUGO,
+static ZIO_ATTR_DEFINE_STD(ZIO_TRG, ztu_std_attr) = {
+	ZIO_ATTR_REG(trig, ZIO_ATTR_TRIG_POST_SAMP, S_IRUGO | S_IWUGO,
 		  0 /* no addr needed */, ZTU_DEFAULT_BLOCK_SIZE),
 };


--- a/zio-sys.c
+++ b/zio-sys.c
@@ -24,22 +24,22 @@
 static struct zio_status *zstat = &zio_global_status; /* Always use ptr */

 const char zio_zdev_attr_names[_ZIO_DEV_ATTR_STD_NUM][ZIO_NAME_LEN] = {
-	[ZATTR_GAIN]		= "gain_factor",
-	[ZATTR_OFFSET]		= "offset",
-	[ZATTR_NBITS]		= "resolution-bits",
-	[ZATTR_MAXRATE]		= "max-sample-rate",
-	[ZATTR_VREFTYPE]	= "vref-src",
+	[ZIO_ATTR_GAIN]		= "gain_factor",
+	[ZIO_ATTR_OFFSET]		= "offset",
+	[ZIO_ATTR_NBITS]		= "resolution-bits",
+	[ZIO_ATTR_MAXRATE]		= "max-sample-rate",
+	[ZIO_ATTR_VREFTYPE]	= "vref-src",
 };
 EXPORT_SYMBOL(zio_zdev_attr_names);
 const char zio_trig_attr_names[_ZIO_TRG_ATTR_STD_NUM][ZIO_NAME_LEN] = {
-	[ZATTR_TRIG_REENABLE]	= "re-enable",
-	[ZATTR_TRIG_PRE_SAMP]	= "pre-samples",
-	[ZATTR_TRIG_POST_SAMP]	= "post-samples",
+	[ZIO_ATTR_TRIG_REENABLE]	= "re-enable",
+	[ZIO_ATTR_TRIG_PRE_SAMP]	= "pre-samples",
+	[ZIO_ATTR_TRIG_POST_SAMP]	= "post-samples",
 };
 EXPORT_SYMBOL(zio_trig_attr_names);
 const char zio_zbuf_attr_names[_ZIO_BUF_ATTR_STD_NUM][ZIO_NAME_LEN] = {
-	[ZATTR_ZBUF_MAXLEN]	= "max-buffer-len",
-	[ZATTR_ZBUF_MAXKB]	= "max-buffer-kb",
+	[ZIO_ATTR_ZBUF_MAXLEN]	= "max-buffer-len",
+	[ZIO_ATTR_ZBUF_MAXKB]	= "max-buffer-kb",
 };
 EXPORT_SYMBOL(zio_zbuf_attr_names);

@@ -604,11 +604,11 @@ out:
 static inline void __zattr_valcpy(struct zio_ctrl_attr *ctrl,
 				  struct zio_attribute *zattr)
 {
-	if ((zattr->flags & ZATTR_TYPE) == ZATTR_TYPE_EXT) {
+	if ((zattr->flags & ZIO_ATTR_TYPE) == ZIO_ATTR_TYPE_EXT) {
 		ctrl->ext_mask |= (1 << zattr->index);
 		ctrl->ext_val[zattr->index] = zattr->value;
 	} else {
-		if (zattr->index == ZATTR_INDEX_NONE)
+		if (zattr->index == ZIO_ATTR_INDEX_NONE)
 			return;
 		ctrl->std_mask |= (1 << zattr->index);
 		ctrl->std_val[zattr->index] = zattr->value;
@@ -617,8 +617,8 @@ static inline void __zattr_valcpy(struct zio_ctrl_attr *ctrl,

 static void __ctrl_update_nsamples(struct zio_ti *ti, struct zio_control *ctrl)
 {
-	ctrl->nsamples = ti->zattr_set.std_zattr[ZATTR_TRIG_PRE_SAMP].value +
-			 ti->zattr_set.std_zattr[ZATTR_TRIG_POST_SAMP].value;
+	ctrl->nsamples = ti->zattr_set.std_zattr[ZIO_ATTR_TRIG_PRE_SAMP].value +
+			 ti->zattr_set.std_zattr[ZIO_ATTR_TRIG_POST_SAMP].value;
 }
 static void __zattr_propagate_value(struct zio_obj_head *head,
 			       struct zio_attribute *zattr)
@@ -630,7 +630,7 @@ static void __zattr_propagate_value(struct zio_obj_head *head,
 	struct zio_cset *cset;
 	struct zio_control *ctrl;

-	if (!(zattr->flags & ZATTR_CONTROL))
+	if (!(zattr->flags & ZIO_ATTR_CONTROL))
 		return; /* the attribute is not in the control */

 	pr_debug("%s\n", __func__);
@@ -663,12 +663,12 @@ static void __zattr_propagate_value(struct zio_obj_head *head,
 			chan = &ti->cset->chan[i];
 			ctrl = chan->current_ctrl;
 			__zattr_valcpy(&ctrl->attr_trigger, zattr);
-			if ((zattr->flags & ZATTR_TYPE) == ZATTR_TYPE_EXT)
+			if ((zattr->flags & ZIO_ATTR_TYPE) == ZIO_ATTR_TYPE_EXT)
 				continue; /* continue to the next channel */

 			/* Only standard attributes */
-			if (zattr->index == ZATTR_TRIG_PRE_SAMP ||
-					zattr->index == ZATTR_TRIG_POST_SAMP)
+			if (zattr->index == ZIO_ATTR_TRIG_PRE_SAMP ||
+					zattr->index == ZIO_ATTR_TRIG_POST_SAMP)
 				__ctrl_update_nsamples(ti, ctrl);
 		}
 		break;
@@ -689,7 +689,7 @@ static void __zattr_trig_init_ctrl(struct zio_ti *ti, struct zio_control *ctrl)
 	for (i = 0; i < ti->zattr_set.n_std_attr; ++i)
 		__zattr_valcpy(ctrl_attr_trig, &ti->zattr_set.std_zattr[i]);
 	for (i = 0; i < ti->zattr_set.n_ext_attr; ++i)
-		if (ti->zattr_set.ext_zattr[i].flags & ZATTR_CONTROL)
+		if (ti->zattr_set.ext_zattr[i].flags & ZIO_ATTR_CONTROL)
 			__zattr_valcpy(ctrl_attr_trig,
 				       &ti->zattr_set.ext_zattr[i]);
 }
@@ -725,21 +725,21 @@ static int __zattr_chan_init_ctrl(struct zio_channel *chan, unsigned int start)
 		__zattr_valcpy(ctrl_attr_chan, &zdev->zattr_set.std_zattr[i]);

 	for (i = 0; i < chan->zattr_set.n_ext_attr; ++i) {
-		if (chan->zattr_set.ext_zattr[i].flags & ZATTR_CONTROL) {
+		if (chan->zattr_set.ext_zattr[i].flags & ZIO_ATTR_CONTROL) {
 			/* Fix channel extended attribute index */
 			chan->zattr_set.ext_zattr[i].index = start + i;
 			__zattr_valcpy(ctrl_attr_chan,
 				       &chan->zattr_set.ext_zattr[i]);
 		} else {
-			chan->zattr_set.ext_zattr[i].index = ZATTR_INDEX_NONE;
+			chan->zattr_set.ext_zattr[i].index = ZIO_ATTR_INDEX_NONE;
 		}
 	}
 	for (i = 0; i < cset->zattr_set.n_ext_attr; ++i)
-		if (cset->zattr_set.ext_zattr[i].flags & ZATTR_CONTROL)
+		if (cset->zattr_set.ext_zattr[i].flags & ZIO_ATTR_CONTROL)
 			__zattr_valcpy(ctrl_attr_chan,
 				       &cset->zattr_set.ext_zattr[i]);
 	for (i = 0; i < zdev->zattr_set.n_ext_attr; ++i)
-		if (zdev->zattr_set.ext_zattr[i].flags & ZATTR_CONTROL)
+		if (zdev->zattr_set.ext_zattr[i].flags & ZIO_ATTR_CONTROL)
 			__zattr_valcpy(ctrl_attr_chan,
 				       &zdev->zattr_set.ext_zattr[i]);

@@ -751,10 +751,10 @@ static int __zattr_cset_init_ctrl(struct zio_cset *cset, unsigned int start)

 	/* Fix cset extended attribute index */
 	for (i = 0; i < cset->zattr_set.n_ext_attr; ++i)
-		if (cset->zattr_set.ext_zattr[i].flags & ZATTR_CONTROL)
+		if (cset->zattr_set.ext_zattr[i].flags & ZIO_ATTR_CONTROL)
 			cset->zattr_set.ext_zattr[i].index = start_c++;
 		else
-			cset->zattr_set.ext_zattr[i].index = ZATTR_INDEX_NONE;
+			cset->zattr_set.ext_zattr[i].index = ZIO_ATTR_INDEX_NONE;

 	for (i = 0; i < cset->n_chan; ++i) {
 		err = __zattr_chan_init_ctrl(&cset->chan[i], start_c);
@@ -776,10 +776,10 @@ static int __zattr_dev_init_ctrl(struct zio_device *zdev)
 	/* Device level */
 	/* Fix device extended attribute index */
 	for (i = 0; i < zdev->zattr_set.n_ext_attr; ++i)
-		if (zdev->zattr_set.ext_zattr[i].flags & ZATTR_CONTROL)
+		if (zdev->zattr_set.ext_zattr[i].flags & ZIO_ATTR_CONTROL)
 			zdev->zattr_set.ext_zattr[i].index = start++;
 		else
-			zdev->zattr_set.ext_zattr[i].index = ZATTR_INDEX_NONE;
+			zdev->zattr_set.ext_zattr[i].index = ZIO_ATTR_INDEX_NONE;

 	for (i = 0; i < zdev->n_cset; ++i) {
 		err = __zattr_cset_init_ctrl(&zdev->cset[i], start);
@@ -1292,7 +1292,7 @@ static int __check_dev_zattr(struct zio_attribute_set *parent,
 	pr_debug("%s %d\n", __func__, this->n_std_attr);
 	/* verify standard attribute */
 	for (i = 0; i < this->n_std_attr; ++i) {
-		if (this->std_zattr[i].index == ZATTR_INDEX_NONE)
+		if (this->std_zattr[i].index == ZIO_ATTR_INDEX_NONE)
 			continue; /* next attribute */
 		for (j = 0; j < parent->n_std_attr; ++j) {
 			/*
@@ -1390,7 +1390,7 @@ static int zattr_set_create(struct zio_obj_head *head,
 			zattr_set->std_zattr[i].index = i;
 			break;
 		case -EINVAL: /* unused std attribute */
-			zattr_set->std_zattr[i].index = ZATTR_INDEX_NONE;
+			zattr_set->std_zattr[i].index = ZIO_ATTR_INDEX_NONE;
 			break;
 		default:
 			return err;
@@ -1415,7 +1415,7 @@ ext:
 		zattr_set->ext_zattr[i].attr.store = zattr_store;
 		zattr_set->ext_zattr[i].s_op = s_op;
 		zattr_set->ext_zattr[i].index = i; /* FIXME useless for zdev*/
-		zattr_set->ext_zattr[i].flags |= ZATTR_TYPE_EXT;
+		zattr_set->ext_zattr[i].flags |= ZIO_ATTR_TYPE_EXT;
 	}
 	++g;

@@ -1628,16 +1628,16 @@ static uint16_t __get_nbits(struct zio_channel *chan)

 	pr_debug("%s:%d\n", __func__, __LINE__);
 	if (chan->zattr_set.std_zattr)
-		if (chan->zattr_set.std_zattr[ZATTR_NBITS].value)
-			return chan->zattr_set.std_zattr[ZATTR_NBITS].value;
+		if (chan->zattr_set.std_zattr[ZIO_ATTR_NBITS].value)
+			return chan->zattr_set.std_zattr[ZIO_ATTR_NBITS].value;
 	cset = chan->cset;
 	if (cset->zattr_set.std_zattr)
-		if (cset->zattr_set.std_zattr[ZATTR_NBITS].value)
-			return cset->zattr_set.std_zattr[ZATTR_NBITS].value;
+		if (cset->zattr_set.std_zattr[ZIO_ATTR_NBITS].value)
+			return cset->zattr_set.std_zattr[ZIO_ATTR_NBITS].value;
 	zdev = cset->zdev;
 	if (zdev->zattr_set.std_zattr)
-		if (zdev->zattr_set.std_zattr[ZATTR_NBITS].value)
-			return zdev->zattr_set.std_zattr[ZATTR_NBITS].value;
+		if (zdev->zattr_set.std_zattr[ZIO_ATTR_NBITS].value)
+			return zdev->zattr_set.std_zattr[ZIO_ATTR_NBITS].value;

 	pr_warn("%s: device \"%s\" lacks \"resolution bit\" attribute\n",
 		__func__, chan->cset->zdev->head.name);
@@ -2284,8 +2284,8 @@ int zio_register_trig(struct zio_trigger_type *trig, const char *name)
 	 * The trigger must define how many samples acquire, so POST_SAMP or
 	 * PRE_SAMP attribute must be available
 	 */
-	if (!(trig->zattr_set.std_zattr[ZATTR_TRIG_POST_SAMP].attr.attr.mode ||
-		trig->zattr_set.std_zattr[ZATTR_TRIG_PRE_SAMP].attr.attr.mode))
+	if (!(trig->zattr_set.std_zattr[ZIO_ATTR_TRIG_POST_SAMP].attr.attr.mode ||
+		trig->zattr_set.std_zattr[ZIO_ATTR_TRIG_PRE_SAMP].attr.attr.mode))
 		goto err_nsamp;
 	/* Verify if it is a valid name */
 	err = zobj_unique_name(&zstat->all_trigger_types, name);