Merge tag 'dt-5.15' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc

[linux-2.6-microblaze.git] / drivers / counter / 104-quad-8.c

diff --git a/drivers/counter/104-quad-8.c b/drivers/counter/104-quad-8.c
index 09a9a77..0caa605 100644 (file)
--- a/drivers/counter/104-quad-8.c
+++ b/drivers/counter/104-quad-8.c
@@ -28,6 +28,7 @@ MODULE_PARM_DESC(base, "ACCES 104-QUAD-8 base addresses");
 
 /**
  * struct quad8 - device private data structure
+ * @lock:              lock to prevent clobbering device states during R/W ops
  * @counter:           instance of the counter_device
  * @fck_prescaler:     array of filter clock prescaler configurations
  * @preset:            array of preset values
@@ -97,7 +98,8 @@ struct quad8 {
 #define QUAD8_CMR_QUADRATURE_X4 0x18
 
 static int quad8_signal_read(struct counter_device *counter,
-       struct counter_signal *signal, enum counter_signal_value *val)
+                            struct counter_signal *signal,
+                            enum counter_signal_level *level)
 {
        const struct quad8 *const priv = counter->priv;
        unsigned int state;
@@ -109,7 +111,7 @@ static int quad8_signal_read(struct counter_device *counter,
        state = inb(priv->base + QUAD8_REG_INDEX_INPUT_LEVELS)
                & BIT(signal->id - 16);
 
-       *val = (state) ? COUNTER_SIGNAL_HIGH : COUNTER_SIGNAL_LOW;
+       *level = (state) ? COUNTER_SIGNAL_LEVEL_HIGH : COUNTER_SIGNAL_LEVEL_LOW;
 
        return 0;
 }
@@ -154,7 +156,7 @@ static int quad8_count_write(struct counter_device *counter,
 
        /* Only 24-bit values are supported */
        if (val > 0xFFFFFF)
-               return -EINVAL;
+               return -ERANGE;
 
        mutex_lock(&priv->lock);
 
@@ -193,11 +195,11 @@ enum quad8_count_function {
        QUAD8_COUNT_FUNCTION_QUADRATURE_X4
 };
 
-static const enum counter_count_function quad8_count_functions_list[] = {
-       [QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
-       [QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
-       [QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
-       [QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4
+static const enum counter_function quad8_count_functions_list[] = {
+       [QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_FUNCTION_PULSE_DIRECTION,
+       [QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_FUNCTION_QUADRATURE_X1_A,
+       [QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_FUNCTION_QUADRATURE_X2_A,
+       [QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_FUNCTION_QUADRATURE_X4
 };
 
 static int quad8_function_get(struct counter_device *counter,
@@ -273,6 +275,10 @@ static int quad8_function_set(struct counter_device *counter,
                        *scale = 2;
                        mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
                        break;
+               default:
+                       /* should never reach this path */
+                       mutex_unlock(&priv->lock);
+                       return -EINVAL;
                }
        }
 
@@ -349,7 +355,7 @@ static int quad8_action_get(struct counter_device *counter,
        case QUAD8_COUNT_FUNCTION_PULSE_DIRECTION:
                if (synapse->signal->id == signal_a_id)
                        *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
-               break;
+               return 0;
        case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
                if (synapse->signal->id == signal_a_id) {
                        quad8_direction_get(counter, count, &direction);
@@ -359,17 +365,18 @@ static int quad8_action_get(struct counter_device *counter,
                        else
                                *action = QUAD8_SYNAPSE_ACTION_FALLING_EDGE;
                }
-               break;
+               return 0;
        case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
                if (synapse->signal->id == signal_a_id)
                        *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
-               break;
+               return 0;
        case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
                *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
-               break;
+               return 0;
+       default:
+               /* should never reach this path */
+               return -EINVAL;
        }
-
-       return 0;
 }
 
 static const struct counter_ops quad8_ops = {
@@ -529,6 +536,9 @@ static int quad8_count_mode_set(struct counter_device *counter,
        case COUNTER_COUNT_MODE_MODULO_N:
                cnt_mode = 3;
                break;
+       default:
+               /* should never reach this path */
+               return -EINVAL;
        }
 
        mutex_lock(&priv->lock);
@@ -661,7 +671,7 @@ static ssize_t quad8_count_preset_write(struct counter_device *counter,
 
        /* Only 24-bit values are supported */
        if (preset > 0xFFFFFF)
-               return -EINVAL;
+               return -ERANGE;
 
        mutex_lock(&priv->lock);
 
@@ -706,7 +716,7 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
 
        /* Only 24-bit values are supported */
        if (ceiling > 0xFFFFFF)
-               return -EINVAL;
+               return -ERANGE;
 
        mutex_lock(&priv->lock);
 
@@ -715,12 +725,13 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
        case 1:
        case 3:
                quad8_preset_register_set(priv, count->id, ceiling);
-               break;
+               mutex_unlock(&priv->lock);
+               return len;
        }
 
        mutex_unlock(&priv->lock);
 
-       return len;
+       return -EINVAL;
 }
 
 static ssize_t quad8_count_preset_enable_read(struct counter_device *counter,