iio: sx9324: avoid copying property strings

We're doing some needless string copies when trying to assign the proper
`prop` string. We can make `prop` a const char* and simply assign to
string literals.

For the case where a format string is used, let's extract the parsing
logic out into sx9324_parse_phase_prop(). We no longer need to create
copies or allocate new memory.

sx9324_parse_phase_prop() will simply return the default def value if it
fails.

This also cleans up some deprecated strncpy() uses [1].

Furthermore, let's clean up this code further by removing some unused
defines:
|  #define SX9324_PIN_DEF "semtech,ph0-pin"
|  #define SX9324_RESOLUTION_DEF "semtech,ph01-resolution"
|  #define SX9324_PROXRAW_DEF "semtech,ph01-proxraw-strength"

Link: https://www.kernel.org/doc/html/latest/process/deprecated.html#strncpy-on-nul-terminated-strings
Link: https://github.com/KSPP/linux/issues/90
Cc: linux-hardening@vger.kernel.org
Signed-off-by: Justin Stitt <justinstitt@google.com>
Reviewed-by: Stephen Boyd <swboyd@chromium.org>
Link: https://lore.kernel.org/r/20240201-strncpy-drivers-iio-proximity-sx9324-c-v5-1-78dde23553bc@google.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/proximity/sx9324.c b/drivers/iio/proximity/sx9324.c
index ac2ed2da21ccc99f8f830458e7b83becef504eda..b0403fc7906bae3aeea5fe6e509319a8d82f4069 100644 (file)
--- a/drivers/iio/proximity/sx9324.c
+++ b/drivers/iio/proximity/sx9324.c
@@ -873,6 +873,29 @@ static int sx9324_init_compensation(struct iio_dev *indio_dev)
                                        20000, 2000000);
 }
 
+static u8 sx9324_parse_phase_prop(struct device *dev,
+                                 struct sx_common_reg_default *reg_def,
+                                 const char *prop)
+{
+       unsigned int pin_defs[SX9324_NUM_PINS];
+       int count, ret, pin;
+       u32 raw = 0;
+
+       count = device_property_count_u32(dev, prop);
+       if (count != ARRAY_SIZE(pin_defs))
+               return reg_def->def;
+       ret = device_property_read_u32_array(dev, prop, pin_defs,
+                                            ARRAY_SIZE(pin_defs));
+       if (ret)
+               return reg_def->def;
+
+       for (pin = 0; pin < SX9324_NUM_PINS; pin++)
+               raw |= (pin_defs[pin] << (2 * pin)) &
+                      SX9324_REG_AFE_PH0_PIN_MASK(pin);
+
+       return raw;
+}
+
 static const struct sx_common_reg_default *
 sx9324_get_default_reg(struct device *dev, int idx,
                       struct sx_common_reg_default *reg_def)
@@ -881,37 +904,29 @@ sx9324_get_default_reg(struct device *dev, int idx,
                "highest" };
        static const char * const sx9324_csidle[] = { "hi-z", "hi-z", "gnd",
                "vdd" };
-#define SX9324_PIN_DEF "semtech,ph0-pin"
-#define SX9324_RESOLUTION_DEF "semtech,ph01-resolution"
-#define SX9324_PROXRAW_DEF "semtech,ph01-proxraw-strength"
-       unsigned int pin_defs[SX9324_NUM_PINS];
-       char prop[] = SX9324_PROXRAW_DEF;
        u32 start = 0, raw = 0, pos = 0;
-       int ret, count, ph, pin;
+       const char *prop;
+       int ret;
 
        memcpy(reg_def, &sx9324_default_regs[idx], sizeof(*reg_def));
 
        sx_common_get_raw_register_config(dev, reg_def);
        switch (reg_def->reg) {
        case SX9324_REG_AFE_PH0:
+               reg_def->def = sx9324_parse_phase_prop(dev, reg_def,
+                                                      "semtech,ph0-pin");
+               break;
        case SX9324_REG_AFE_PH1:
+               reg_def->def = sx9324_parse_phase_prop(dev, reg_def,
+                                                      "semtech,ph1-pin");
+               break;
        case SX9324_REG_AFE_PH2:
+               reg_def->def = sx9324_parse_phase_prop(dev, reg_def,
+                                                      "semtech,ph2-pin");
+               break;
        case SX9324_REG_AFE_PH3:
-               ph = reg_def->reg - SX9324_REG_AFE_PH0;
-               snprintf(prop, ARRAY_SIZE(prop), "semtech,ph%d-pin", ph);
-
-               count = device_property_count_u32(dev, prop);
-               if (count != ARRAY_SIZE(pin_defs))
-                       break;
-               ret = device_property_read_u32_array(dev, prop, pin_defs,
-                                                    ARRAY_SIZE(pin_defs));
-               if (ret)
-                       break;
-
-               for (pin = 0; pin < SX9324_NUM_PINS; pin++)
-                       raw |= (pin_defs[pin] << (2 * pin)) &
-                              SX9324_REG_AFE_PH0_PIN_MASK(pin);
-               reg_def->def = raw;
+               reg_def->def = sx9324_parse_phase_prop(dev, reg_def,
+                                                      "semtech,ph3-pin");
                break;
        case SX9324_REG_AFE_CTRL0:
                ret = device_property_match_property_string(dev, "semtech,cs-idle-sleep",
@@ -933,11 +948,9 @@ sx9324_get_default_reg(struct device *dev, int idx,
        case SX9324_REG_AFE_CTRL4:
        case SX9324_REG_AFE_CTRL7:
                if (reg_def->reg == SX9324_REG_AFE_CTRL4)
-                       strncpy(prop, "semtech,ph01-resolution",
-                               ARRAY_SIZE(prop));
+                       prop = "semtech,ph01-resolution";
                else
-                       strncpy(prop, "semtech,ph23-resolution",
-                               ARRAY_SIZE(prop));
+                       prop = "semtech,ph23-resolution";
 
                ret = device_property_read_u32(dev, prop, &raw);
                if (ret)
@@ -1008,11 +1021,9 @@ sx9324_get_default_reg(struct device *dev, int idx,
        case SX9324_REG_PROX_CTRL0:
        case SX9324_REG_PROX_CTRL1:
                if (reg_def->reg == SX9324_REG_PROX_CTRL0)
-                       strncpy(prop, "semtech,ph01-proxraw-strength",
-                               ARRAY_SIZE(prop));
+                       prop = "semtech,ph01-proxraw-strength";
                else
-                       strncpy(prop, "semtech,ph23-proxraw-strength",
-                               ARRAY_SIZE(prop));
+                       prop = "semtech,ph23-proxraw-strength";
                ret = device_property_read_u32(dev, prop, &raw);
                if (ret)
                        break;