diff mbox series

[03/20] iio: buffer: make use of iio_get_masklength()

Message ID 20240702-dev-iio-masklength-private-v1-3-98193bf536a6@analog.com (mailing list archive)
State Accepted
Commit 52fe020e7f9c2051343d68e759186ce11b72acc2
Headers show
Series iio: make masklength __private (round 1) | expand

Commit Message

Nuno Sa via B4 Relay July 2, 2024, 4:02 p.m. UTC
From: Nuno Sa <nuno.sa@analog.com>

Use iio_get_masklength() to access '.masklength' so it can be annotated
as __private when there are no more direct users of it.

While at it, remove some unneeded line breaks.

Signed-off-by: Nuno Sa <nuno.sa@analog.com>
---
 drivers/iio/buffer/industrialio-buffer-cb.c   |  2 +-
 drivers/iio/buffer/industrialio-hw-consumer.c |  4 +--
 drivers/iio/industrialio-buffer.c             | 50 ++++++++++++---------------
 3 files changed, 26 insertions(+), 30 deletions(-)

Comments

Alexandru Ardelean July 3, 2024, 6:14 a.m. UTC | #1
On Tue, Jul 2, 2024 at 7:02 PM Nuno Sa via B4 Relay
<devnull+nuno.sa.analog.com@kernel.org> wrote:
>
> From: Nuno Sa <nuno.sa@analog.com>
>
> Use iio_get_masklength() to access '.masklength' so it can be annotated
> as __private when there are no more direct users of it.
>
> While at it, remove some unneeded line breaks.
>

Reviewed-by: Alexandru Ardelean <aardelean@baylibre.com>

> Signed-off-by: Nuno Sa <nuno.sa@analog.com>
> ---
>  drivers/iio/buffer/industrialio-buffer-cb.c   |  2 +-
>  drivers/iio/buffer/industrialio-hw-consumer.c |  4 +--
>  drivers/iio/industrialio-buffer.c             | 50 ++++++++++++---------------
>  3 files changed, 26 insertions(+), 30 deletions(-)
>
> diff --git a/drivers/iio/buffer/industrialio-buffer-cb.c b/drivers/iio/buffer/industrialio-buffer-cb.c
> index 4c12b7a94af59..4befc9f55201e 100644
> --- a/drivers/iio/buffer/industrialio-buffer-cb.c
> +++ b/drivers/iio/buffer/industrialio-buffer-cb.c
> @@ -77,7 +77,7 @@ struct iio_cb_buffer *iio_channel_get_all_cb(struct device *dev,
>         }
>
>         cb_buff->indio_dev = cb_buff->channels[0].indio_dev;
> -       cb_buff->buffer.scan_mask = bitmap_zalloc(cb_buff->indio_dev->masklength,
> +       cb_buff->buffer.scan_mask = bitmap_zalloc(iio_get_masklength(cb_buff->indio_dev),
>                                                   GFP_KERNEL);
>         if (cb_buff->buffer.scan_mask == NULL) {
>                 ret = -ENOMEM;
> diff --git a/drivers/iio/buffer/industrialio-hw-consumer.c b/drivers/iio/buffer/industrialio-hw-consumer.c
> index fb58f599a80b1..526b2a8d725d1 100644
> --- a/drivers/iio/buffer/industrialio-hw-consumer.c
> +++ b/drivers/iio/buffer/industrialio-hw-consumer.c
> @@ -52,6 +52,7 @@ static const struct iio_buffer_access_funcs iio_hw_buf_access = {
>  static struct hw_consumer_buffer *iio_hw_consumer_get_buffer(
>         struct iio_hw_consumer *hwc, struct iio_dev *indio_dev)
>  {
> +       unsigned int mask_longs = BITS_TO_LONGS(iio_get_masklength(indio_dev));
>         struct hw_consumer_buffer *buf;
>
>         list_for_each_entry(buf, &hwc->buffers, head) {
> @@ -59,8 +60,7 @@ static struct hw_consumer_buffer *iio_hw_consumer_get_buffer(
>                         return buf;
>         }
>
> -       buf = kzalloc(struct_size(buf, scan_mask, BITS_TO_LONGS(indio_dev->masklength)),
> -                     GFP_KERNEL);
> +       buf = kzalloc(struct_size(buf, scan_mask, mask_longs), GFP_KERNEL);
>         if (!buf)
>                 return NULL;
>
> diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c
> index 0138b21b244f0..389bfb238b510 100644
> --- a/drivers/iio/industrialio-buffer.c
> +++ b/drivers/iio/industrialio-buffer.c
> @@ -473,18 +473,19 @@ static bool iio_validate_scan_mask(struct iio_dev *indio_dev,
>  static int iio_scan_mask_set(struct iio_dev *indio_dev,
>                              struct iio_buffer *buffer, int bit)
>  {
> +       unsigned int masklength = iio_get_masklength(indio_dev);
>         const unsigned long *mask;
>         unsigned long *trialmask;
>
> -       if (!indio_dev->masklength) {
> +       if (!masklength) {
>                 WARN(1, "Trying to set scanmask prior to registering buffer\n");
>                 return -EINVAL;
>         }
>
> -       trialmask = bitmap_alloc(indio_dev->masklength, GFP_KERNEL);
> +       trialmask = bitmap_alloc(masklength, GFP_KERNEL);
>         if (!trialmask)
>                 return -ENOMEM;
> -       bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength);
> +       bitmap_copy(trialmask, buffer->scan_mask, masklength);
>         set_bit(bit, trialmask);
>
>         if (!iio_validate_scan_mask(indio_dev, trialmask))
> @@ -492,12 +493,11 @@ static int iio_scan_mask_set(struct iio_dev *indio_dev,
>
>         if (indio_dev->available_scan_masks) {
>                 mask = iio_scan_mask_match(indio_dev->available_scan_masks,
> -                                          indio_dev->masklength,
> -                                          trialmask, false);
> +                                          masklength, trialmask, false);
>                 if (!mask)
>                         goto err_invalid_mask;
>         }
> -       bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength);
> +       bitmap_copy(buffer->scan_mask, trialmask, masklength);
>
>         bitmap_free(trialmask);
>
> @@ -517,7 +517,7 @@ static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)
>  static int iio_scan_mask_query(struct iio_dev *indio_dev,
>                                struct iio_buffer *buffer, int bit)
>  {
> -       if (bit > indio_dev->masklength)
> +       if (bit > iio_get_masklength(indio_dev))
>                 return -EINVAL;
>
>         if (!buffer->scan_mask)
> @@ -733,8 +733,7 @@ static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
>         int length, i, largest = 0;
>
>         /* How much space will the demuxed element take? */
> -       for_each_set_bit(i, mask,
> -                        indio_dev->masklength) {
> +       for_each_set_bit(i, mask, iio_get_masklength(indio_dev)) {
>                 length = iio_storage_bytes_for_si(indio_dev, i);
>                 if (length < 0)
>                         return length;
> @@ -855,6 +854,7 @@ static int iio_verify_update(struct iio_dev *indio_dev,
>                              struct iio_device_config *config)
>  {
>         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
> +       unsigned int masklength = iio_get_masklength(indio_dev);
>         unsigned long *compound_mask;
>         const unsigned long *scan_mask;
>         bool strict_scanmask = false;
> @@ -863,7 +863,7 @@ static int iio_verify_update(struct iio_dev *indio_dev,
>         unsigned int modes;
>
>         if (insert_buffer &&
> -           bitmap_empty(insert_buffer->scan_mask, indio_dev->masklength)) {
> +           bitmap_empty(insert_buffer->scan_mask, masklength)) {
>                 dev_dbg(&indio_dev->dev,
>                         "At least one scan element must be enabled first\n");
>                 return -EINVAL;
> @@ -917,7 +917,7 @@ static int iio_verify_update(struct iio_dev *indio_dev,
>         }
>
>         /* What scan mask do we actually have? */
> -       compound_mask = bitmap_zalloc(indio_dev->masklength, GFP_KERNEL);
> +       compound_mask = bitmap_zalloc(masklength, GFP_KERNEL);
>         if (!compound_mask)
>                 return -ENOMEM;
>
> @@ -927,20 +927,19 @@ static int iio_verify_update(struct iio_dev *indio_dev,
>                 if (buffer == remove_buffer)
>                         continue;
>                 bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
> -                         indio_dev->masklength);
> +                         masklength);
>                 scan_timestamp |= buffer->scan_timestamp;
>         }
>
>         if (insert_buffer) {
>                 bitmap_or(compound_mask, compound_mask,
> -                         insert_buffer->scan_mask, indio_dev->masklength);
> +                         insert_buffer->scan_mask, masklength);
>                 scan_timestamp |= insert_buffer->scan_timestamp;
>         }
>
>         if (indio_dev->available_scan_masks) {
>                 scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,
> -                                               indio_dev->masklength,
> -                                               compound_mask,
> +                                               masklength, compound_mask,
>                                                 strict_scanmask);
>                 bitmap_free(compound_mask);
>                 if (!scan_mask)
> @@ -1005,6 +1004,7 @@ static int iio_buffer_add_demux(struct iio_buffer *buffer,
>  static int iio_buffer_update_demux(struct iio_dev *indio_dev,
>                                    struct iio_buffer *buffer)
>  {
> +       unsigned int masklength = iio_get_masklength(indio_dev);
>         int ret, in_ind = -1, out_ind, length;
>         unsigned int in_loc = 0, out_loc = 0;
>         struct iio_demux_table *p = NULL;
> @@ -1016,17 +1016,13 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
>
>         /* First work out which scan mode we will actually have */
>         if (bitmap_equal(indio_dev->active_scan_mask,
> -                        buffer->scan_mask,
> -                        indio_dev->masklength))
> +                        buffer->scan_mask, masklength))
>                 return 0;
>
>         /* Now we have the two masks, work from least sig and build up sizes */
> -       for_each_set_bit(out_ind,
> -                        buffer->scan_mask,
> -                        indio_dev->masklength) {
> +       for_each_set_bit(out_ind, buffer->scan_mask, masklength) {
>                 in_ind = find_next_bit(indio_dev->active_scan_mask,
> -                                      indio_dev->masklength,
> -                                      in_ind + 1);
> +                                      masklength, in_ind + 1);
>                 while (in_ind != out_ind) {
>                         ret = iio_storage_bytes_for_si(indio_dev, in_ind);
>                         if (ret < 0)
> @@ -1036,8 +1032,7 @@ static int iio_buffer_update_demux(struct iio_dev *indio_dev,
>                         /* Make sure we are aligned */
>                         in_loc = roundup(in_loc, length) + length;
>                         in_ind = find_next_bit(indio_dev->active_scan_mask,
> -                                              indio_dev->masklength,
> -                                              in_ind + 1);
> +                                              masklength, in_ind + 1);
>                 }
>                 ret = iio_storage_bytes_for_si(indio_dev, in_ind);
>                 if (ret < 0)
> @@ -1646,6 +1641,7 @@ static int __iio_buffer_alloc_sysfs_and_mask(struct iio_buffer *buffer,
>                                              int index)
>  {
>         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
> +       unsigned int masklength = iio_get_masklength(indio_dev);
>         struct iio_dev_attr *p;
>         const struct iio_dev_attr *id_attr;
>         struct attribute **attr;
> @@ -1708,8 +1704,8 @@ static int __iio_buffer_alloc_sysfs_and_mask(struct iio_buffer *buffer,
>                                 iio_dev_opaque->scan_index_timestamp =
>                                         channels[i].scan_index;
>                 }
> -               if (indio_dev->masklength && !buffer->scan_mask) {
> -                       buffer->scan_mask = bitmap_zalloc(indio_dev->masklength,
> +               if (masklength && !buffer->scan_mask) {
> +                       buffer->scan_mask = bitmap_zalloc(masklength,
>                                                           GFP_KERNEL);
>                         if (!buffer->scan_mask) {
>                                 ret = -ENOMEM;
> @@ -1879,7 +1875,7 @@ void iio_buffers_free_sysfs_and_mask(struct iio_dev *indio_dev)
>  bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
>                                    const unsigned long *mask)
>  {
> -       return bitmap_weight(mask, indio_dev->masklength) == 1;
> +       return bitmap_weight(mask, iio_get_masklength(indio_dev)) == 1;
>  }
>  EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);
>
>
> --
> 2.45.2
>
>
>
diff mbox series

Patch

diff --git a/drivers/iio/buffer/industrialio-buffer-cb.c b/drivers/iio/buffer/industrialio-buffer-cb.c
index 4c12b7a94af59..4befc9f55201e 100644
--- a/drivers/iio/buffer/industrialio-buffer-cb.c
+++ b/drivers/iio/buffer/industrialio-buffer-cb.c
@@ -77,7 +77,7 @@  struct iio_cb_buffer *iio_channel_get_all_cb(struct device *dev,
 	}
 
 	cb_buff->indio_dev = cb_buff->channels[0].indio_dev;
-	cb_buff->buffer.scan_mask = bitmap_zalloc(cb_buff->indio_dev->masklength,
+	cb_buff->buffer.scan_mask = bitmap_zalloc(iio_get_masklength(cb_buff->indio_dev),
 						  GFP_KERNEL);
 	if (cb_buff->buffer.scan_mask == NULL) {
 		ret = -ENOMEM;
diff --git a/drivers/iio/buffer/industrialio-hw-consumer.c b/drivers/iio/buffer/industrialio-hw-consumer.c
index fb58f599a80b1..526b2a8d725d1 100644
--- a/drivers/iio/buffer/industrialio-hw-consumer.c
+++ b/drivers/iio/buffer/industrialio-hw-consumer.c
@@ -52,6 +52,7 @@  static const struct iio_buffer_access_funcs iio_hw_buf_access = {
 static struct hw_consumer_buffer *iio_hw_consumer_get_buffer(
 	struct iio_hw_consumer *hwc, struct iio_dev *indio_dev)
 {
+	unsigned int mask_longs = BITS_TO_LONGS(iio_get_masklength(indio_dev));
 	struct hw_consumer_buffer *buf;
 
 	list_for_each_entry(buf, &hwc->buffers, head) {
@@ -59,8 +60,7 @@  static struct hw_consumer_buffer *iio_hw_consumer_get_buffer(
 			return buf;
 	}
 
-	buf = kzalloc(struct_size(buf, scan_mask, BITS_TO_LONGS(indio_dev->masklength)),
-		      GFP_KERNEL);
+	buf = kzalloc(struct_size(buf, scan_mask, mask_longs), GFP_KERNEL);
 	if (!buf)
 		return NULL;
 
diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c
index 0138b21b244f0..389bfb238b510 100644
--- a/drivers/iio/industrialio-buffer.c
+++ b/drivers/iio/industrialio-buffer.c
@@ -473,18 +473,19 @@  static bool iio_validate_scan_mask(struct iio_dev *indio_dev,
 static int iio_scan_mask_set(struct iio_dev *indio_dev,
 			     struct iio_buffer *buffer, int bit)
 {
+	unsigned int masklength = iio_get_masklength(indio_dev);
 	const unsigned long *mask;
 	unsigned long *trialmask;
 
-	if (!indio_dev->masklength) {
+	if (!masklength) {
 		WARN(1, "Trying to set scanmask prior to registering buffer\n");
 		return -EINVAL;
 	}
 
-	trialmask = bitmap_alloc(indio_dev->masklength, GFP_KERNEL);
+	trialmask = bitmap_alloc(masklength, GFP_KERNEL);
 	if (!trialmask)
 		return -ENOMEM;
-	bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength);
+	bitmap_copy(trialmask, buffer->scan_mask, masklength);
 	set_bit(bit, trialmask);
 
 	if (!iio_validate_scan_mask(indio_dev, trialmask))
@@ -492,12 +493,11 @@  static int iio_scan_mask_set(struct iio_dev *indio_dev,
 
 	if (indio_dev->available_scan_masks) {
 		mask = iio_scan_mask_match(indio_dev->available_scan_masks,
-					   indio_dev->masklength,
-					   trialmask, false);
+					   masklength, trialmask, false);
 		if (!mask)
 			goto err_invalid_mask;
 	}
-	bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength);
+	bitmap_copy(buffer->scan_mask, trialmask, masklength);
 
 	bitmap_free(trialmask);
 
@@ -517,7 +517,7 @@  static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)
 static int iio_scan_mask_query(struct iio_dev *indio_dev,
 			       struct iio_buffer *buffer, int bit)
 {
-	if (bit > indio_dev->masklength)
+	if (bit > iio_get_masklength(indio_dev))
 		return -EINVAL;
 
 	if (!buffer->scan_mask)
@@ -733,8 +733,7 @@  static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
 	int length, i, largest = 0;
 
 	/* How much space will the demuxed element take? */
-	for_each_set_bit(i, mask,
-			 indio_dev->masklength) {
+	for_each_set_bit(i, mask, iio_get_masklength(indio_dev)) {
 		length = iio_storage_bytes_for_si(indio_dev, i);
 		if (length < 0)
 			return length;
@@ -855,6 +854,7 @@  static int iio_verify_update(struct iio_dev *indio_dev,
 			     struct iio_device_config *config)
 {
 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
+	unsigned int masklength = iio_get_masklength(indio_dev);
 	unsigned long *compound_mask;
 	const unsigned long *scan_mask;
 	bool strict_scanmask = false;
@@ -863,7 +863,7 @@  static int iio_verify_update(struct iio_dev *indio_dev,
 	unsigned int modes;
 
 	if (insert_buffer &&
-	    bitmap_empty(insert_buffer->scan_mask, indio_dev->masklength)) {
+	    bitmap_empty(insert_buffer->scan_mask, masklength)) {
 		dev_dbg(&indio_dev->dev,
 			"At least one scan element must be enabled first\n");
 		return -EINVAL;
@@ -917,7 +917,7 @@  static int iio_verify_update(struct iio_dev *indio_dev,
 	}
 
 	/* What scan mask do we actually have? */
-	compound_mask = bitmap_zalloc(indio_dev->masklength, GFP_KERNEL);
+	compound_mask = bitmap_zalloc(masklength, GFP_KERNEL);
 	if (!compound_mask)
 		return -ENOMEM;
 
@@ -927,20 +927,19 @@  static int iio_verify_update(struct iio_dev *indio_dev,
 		if (buffer == remove_buffer)
 			continue;
 		bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
-			  indio_dev->masklength);
+			  masklength);
 		scan_timestamp |= buffer->scan_timestamp;
 	}
 
 	if (insert_buffer) {
 		bitmap_or(compound_mask, compound_mask,
-			  insert_buffer->scan_mask, indio_dev->masklength);
+			  insert_buffer->scan_mask, masklength);
 		scan_timestamp |= insert_buffer->scan_timestamp;
 	}
 
 	if (indio_dev->available_scan_masks) {
 		scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,
-						indio_dev->masklength,
-						compound_mask,
+						masklength, compound_mask,
 						strict_scanmask);
 		bitmap_free(compound_mask);
 		if (!scan_mask)
@@ -1005,6 +1004,7 @@  static int iio_buffer_add_demux(struct iio_buffer *buffer,
 static int iio_buffer_update_demux(struct iio_dev *indio_dev,
 				   struct iio_buffer *buffer)
 {
+	unsigned int masklength = iio_get_masklength(indio_dev);
 	int ret, in_ind = -1, out_ind, length;
 	unsigned int in_loc = 0, out_loc = 0;
 	struct iio_demux_table *p = NULL;
@@ -1016,17 +1016,13 @@  static int iio_buffer_update_demux(struct iio_dev *indio_dev,
 
 	/* First work out which scan mode we will actually have */
 	if (bitmap_equal(indio_dev->active_scan_mask,
-			 buffer->scan_mask,
-			 indio_dev->masklength))
+			 buffer->scan_mask, masklength))
 		return 0;
 
 	/* Now we have the two masks, work from least sig and build up sizes */
-	for_each_set_bit(out_ind,
-			 buffer->scan_mask,
-			 indio_dev->masklength) {
+	for_each_set_bit(out_ind, buffer->scan_mask, masklength) {
 		in_ind = find_next_bit(indio_dev->active_scan_mask,
-				       indio_dev->masklength,
-				       in_ind + 1);
+				       masklength, in_ind + 1);
 		while (in_ind != out_ind) {
 			ret = iio_storage_bytes_for_si(indio_dev, in_ind);
 			if (ret < 0)
@@ -1036,8 +1032,7 @@  static int iio_buffer_update_demux(struct iio_dev *indio_dev,
 			/* Make sure we are aligned */
 			in_loc = roundup(in_loc, length) + length;
 			in_ind = find_next_bit(indio_dev->active_scan_mask,
-					       indio_dev->masklength,
-					       in_ind + 1);
+					       masklength, in_ind + 1);
 		}
 		ret = iio_storage_bytes_for_si(indio_dev, in_ind);
 		if (ret < 0)
@@ -1646,6 +1641,7 @@  static int __iio_buffer_alloc_sysfs_and_mask(struct iio_buffer *buffer,
 					     int index)
 {
 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
+	unsigned int masklength = iio_get_masklength(indio_dev);
 	struct iio_dev_attr *p;
 	const struct iio_dev_attr *id_attr;
 	struct attribute **attr;
@@ -1708,8 +1704,8 @@  static int __iio_buffer_alloc_sysfs_and_mask(struct iio_buffer *buffer,
 				iio_dev_opaque->scan_index_timestamp =
 					channels[i].scan_index;
 		}
-		if (indio_dev->masklength && !buffer->scan_mask) {
-			buffer->scan_mask = bitmap_zalloc(indio_dev->masklength,
+		if (masklength && !buffer->scan_mask) {
+			buffer->scan_mask = bitmap_zalloc(masklength,
 							  GFP_KERNEL);
 			if (!buffer->scan_mask) {
 				ret = -ENOMEM;
@@ -1879,7 +1875,7 @@  void iio_buffers_free_sysfs_and_mask(struct iio_dev *indio_dev)
 bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
 				   const unsigned long *mask)
 {
-	return bitmap_weight(mask, indio_dev->masklength) == 1;
+	return bitmap_weight(mask, iio_get_masklength(indio_dev)) == 1;
 }
 EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);