drivers/video/backlight/arcxcnn_bl.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Backlight driver for ArcticSand ARC_X_C_0N_0N Devices
   4  *
   5  * Copyright 2016 ArcticSand, Inc.
   6  * Author : Brian Dodge <bdodge@arcticsand.com>
   7  */
   8
   9 #include <linux/backlight.h>
  10 #include <linux/err.h>
  11 #include <linux/i2c.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/slab.h>
  15
  16 enum arcxcnn_chip_id {
  17         ARC2C0608
  18 };
  19
  20 /**
  21  * struct arcxcnn_platform_data
  22  * @name                : Backlight driver name (NULL will use default)
  23  * @initial_brightness  : initial value of backlight brightness
  24  * @leden               : initial LED string enables, upper bit is global on/off
  25  * @led_config_0        : fading speed (period between intensity steps)
  26  * @led_config_1        : misc settings, see datasheet
  27  * @dim_freq            : pwm dimming frequency if in pwm mode
  28  * @comp_config         : misc config, see datasheet
  29  * @filter_config       : RC/PWM filter config, see datasheet
  30  * @trim_config         : full scale current trim, see datasheet
  31  */
  32 struct arcxcnn_platform_data {
  33         const char *name;
  34         u16 initial_brightness;
  35         u8      leden;
  36         u8      led_config_0;
  37         u8      led_config_1;
  38         u8      dim_freq;
  39         u8      comp_config;
  40         u8      filter_config;
  41         u8      trim_config;
  42 };
  43
  44 #define ARCXCNN_CMD             0x00    /* Command Register */
  45 #define ARCXCNN_CMD_STDBY       0x80    /*   I2C Standby */
  46 #define ARCXCNN_CMD_RESET       0x40    /*   Reset */
  47 #define ARCXCNN_CMD_BOOST       0x10    /*   Boost */
  48 #define ARCXCNN_CMD_OVP_MASK    0x0C    /*   --- Over Voltage Threshold */
  49 #define ARCXCNN_CMD_OVP_XXV     0x0C    /*   <rsvrd> Over Voltage Threshold */
  50 #define ARCXCNN_CMD_OVP_20V     0x08    /*   20v Over Voltage Threshold */
  51 #define ARCXCNN_CMD_OVP_24V     0x04    /*   24v Over Voltage Threshold */
  52 #define ARCXCNN_CMD_OVP_31V     0x00    /*   31.4v Over Voltage Threshold */
  53 #define ARCXCNN_CMD_EXT_COMP    0x01    /*   part (0) or full (1) ext. comp */
  54
  55 #define ARCXCNN_CONFIG          0x01    /* Configuration */
  56 #define ARCXCNN_STATUS1         0x02    /* Status 1 */
  57 #define ARCXCNN_STATUS2         0x03    /* Status 2 */
  58 #define ARCXCNN_FADECTRL        0x04    /* Fading Control */
  59 #define ARCXCNN_ILED_CONFIG     0x05    /* ILED Configuration */
  60 #define ARCXCNN_ILED_DIM_PWM    0x00    /*   config dim mode pwm */
  61 #define ARCXCNN_ILED_DIM_INT    0x04    /*   config dim mode internal */
  62 #define ARCXCNN_LEDEN           0x06    /* LED Enable Register */
  63 #define ARCXCNN_LEDEN_ISETEXT   0x80    /*   Full-scale current set extern */
  64 #define ARCXCNN_LEDEN_MASK      0x3F    /*   LED string enables mask */
  65 #define ARCXCNN_LEDEN_BITS      0x06    /*   Bits of LED string enables */
  66 #define ARCXCNN_LEDEN_LED1      0x01
  67 #define ARCXCNN_LEDEN_LED2      0x02
  68 #define ARCXCNN_LEDEN_LED3      0x04
  69 #define ARCXCNN_LEDEN_LED4      0x08
  70 #define ARCXCNN_LEDEN_LED5      0x10
  71 #define ARCXCNN_LEDEN_LED6      0x20
  72
  73 #define ARCXCNN_WLED_ISET_LSB   0x07    /* LED ISET LSB (in upper nibble) */
  74 #define ARCXCNN_WLED_ISET_LSB_SHIFT 0x04  /* ISET LSB Left Shift */
  75 #define ARCXCNN_WLED_ISET_MSB   0x08    /* LED ISET MSB (8 bits) */
  76
  77 #define ARCXCNN_DIMFREQ         0x09
  78 #define ARCXCNN_COMP_CONFIG     0x0A
  79 #define ARCXCNN_FILT_CONFIG     0x0B
  80 #define ARCXCNN_IMAXTUNE        0x0C
  81 #define ARCXCNN_ID_MSB          0x1E
  82 #define ARCXCNN_ID_LSB          0x1F
  83
  84 #define MAX_BRIGHTNESS          4095
  85 #define INIT_BRIGHT             60
  86
  87 struct arcxcnn {
  88         struct i2c_client *client;
  89         struct backlight_device *bl;
  90         struct device *dev;
  91         struct arcxcnn_platform_data *pdata;
  92 };
  93
  94 static int arcxcnn_update_field(struct arcxcnn *lp, u8 reg, u8 mask, u8 data)
  95 {
  96         int ret;
  97         u8 tmp;
  98
  99         ret = i2c_smbus_read_byte_data(lp->client, reg);
 100         if (ret < 0) {
 101                 dev_err(lp->dev, "failed to read 0x%.2x\n", reg);
 102                 return ret;
 103         }
 104
 105         tmp = (u8)ret;
 106         tmp &= ~mask;
 107         tmp |= data & mask;
 108
 109         return i2c_smbus_write_byte_data(lp->client, reg, tmp);
 110 }
 111
 112 static int arcxcnn_set_brightness(struct arcxcnn *lp, u32 brightness)
 113 {
 114         int ret;
 115         u8 val;
 116
 117         /* lower nibble of brightness goes in upper nibble of LSB register */
 118         val = (brightness & 0xF) << ARCXCNN_WLED_ISET_LSB_SHIFT;
 119         ret = i2c_smbus_write_byte_data(lp->client,
 120                 ARCXCNN_WLED_ISET_LSB, val);
 121         if (ret < 0)
 122                 return ret;
 123
 124         /* remaining 8 bits of brightness go in MSB register */
 125         val = (brightness >> 4);
 126         return i2c_smbus_write_byte_data(lp->client,
 127                 ARCXCNN_WLED_ISET_MSB, val);
 128 }
 129
 130 static int arcxcnn_bl_update_status(struct backlight_device *bl)
 131 {
 132         struct arcxcnn *lp = bl_get_data(bl);
 133         u32 brightness = backlight_get_brightness(bl);
 134         int ret;
 135
 136         ret = arcxcnn_set_brightness(lp, brightness);
 137         if (ret)
 138                 return ret;
 139
 140         /* set power-on/off/save modes */
 141         return arcxcnn_update_field(lp, ARCXCNN_CMD, ARCXCNN_CMD_STDBY,
 142                 (bl->props.power == 0) ? 0 : ARCXCNN_CMD_STDBY);
 143 }
 144
 145 static const struct backlight_ops arcxcnn_bl_ops = {
 146         .options = BL_CORE_SUSPENDRESUME,
 147         .update_status = arcxcnn_bl_update_status,
 148 };
 149
 150 static int arcxcnn_backlight_register(struct arcxcnn *lp)
 151 {
 152         struct backlight_properties *props;
 153         const char *name = lp->pdata->name ? : "arctic_bl";
 154
 155         props = devm_kzalloc(lp->dev, sizeof(*props), GFP_KERNEL);
 156         if (!props)
 157                 return -ENOMEM;
 158
 159         props->type = BACKLIGHT_PLATFORM;
 160         props->max_brightness = MAX_BRIGHTNESS;
 161
 162         if (lp->pdata->initial_brightness > props->max_brightness)
 163                 lp->pdata->initial_brightness = props->max_brightness;
 164
 165         props->brightness = lp->pdata->initial_brightness;
 166
 167         lp->bl = devm_backlight_device_register(lp->dev, name, lp->dev, lp,
 168                                        &arcxcnn_bl_ops, props);
 169         return PTR_ERR_OR_ZERO(lp->bl);
 170 }
 171
 172 static void arcxcnn_parse_dt(struct arcxcnn *lp)
 173 {
 174         struct device *dev = lp->dev;
 175         struct device_node *node = dev->of_node;
 176         u32 prog_val, num_entry, entry, sources[ARCXCNN_LEDEN_BITS];
 177         int ret;
 178
 179         /* device tree entry isn't required, defaults are OK */
 180         if (!node)
 181                 return;
 182
 183         ret = of_property_read_string(node, "label", &lp->pdata->name);
 184         if (ret < 0)
 185                 lp->pdata->name = NULL;
 186
 187         ret = of_property_read_u32(node, "default-brightness", &prog_val);
 188         if (ret == 0)
 189                 lp->pdata->initial_brightness = prog_val;
 190
 191         ret = of_property_read_u32(node, "arc,led-config-0", &prog_val);
 192         if (ret == 0)
 193                 lp->pdata->led_config_0 = (u8)prog_val;
 194
 195         ret = of_property_read_u32(node, "arc,led-config-1", &prog_val);
 196         if (ret == 0)
 197                 lp->pdata->led_config_1 = (u8)prog_val;
 198
 199         ret = of_property_read_u32(node, "arc,dim-freq", &prog_val);
 200         if (ret == 0)
 201                 lp->pdata->dim_freq = (u8)prog_val;
 202
 203         ret = of_property_read_u32(node, "arc,comp-config", &prog_val);
 204         if (ret == 0)
 205                 lp->pdata->comp_config = (u8)prog_val;
 206
 207         ret = of_property_read_u32(node, "arc,filter-config", &prog_val);
 208         if (ret == 0)
 209                 lp->pdata->filter_config = (u8)prog_val;
 210
 211         ret = of_property_read_u32(node, "arc,trim-config", &prog_val);
 212         if (ret == 0)
 213                 lp->pdata->trim_config = (u8)prog_val;
 214
 215         ret = of_property_count_u32_elems(node, "led-sources");
 216         if (ret < 0) {
 217                 lp->pdata->leden = ARCXCNN_LEDEN_MASK; /* all on is default */
 218         } else {
 219                 num_entry = ret;
 220                 if (num_entry > ARCXCNN_LEDEN_BITS)
 221                         num_entry = ARCXCNN_LEDEN_BITS;
 222
 223                 ret = of_property_read_u32_array(node, "led-sources", sources,
 224                                         num_entry);
 225                 if (ret < 0) {
 226                         dev_err(dev, "led-sources node is invalid.\n");
 227                         return;
 228                 }
 229
 230                 lp->pdata->leden = 0;
 231
 232                 /* for each enable in source, set bit in led enable */
 233                 for (entry = 0; entry < num_entry; entry++) {
 234                         u8 onbit = 1 << sources[entry];
 235
 236                         lp->pdata->leden |= onbit;
 237                 }
 238         }
 239 }
 240
 241 static int arcxcnn_probe(struct i2c_client *cl)
 242 {
 243         struct arcxcnn *lp;
 244         int ret;
 245
 246         if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 247                 return -EIO;
 248
 249         lp = devm_kzalloc(&cl->dev, sizeof(*lp), GFP_KERNEL);
 250         if (!lp)
 251                 return -ENOMEM;
 252
 253         lp->client = cl;
 254         lp->dev = &cl->dev;
 255         lp->pdata = dev_get_platdata(&cl->dev);
 256
 257         /* reset the device */
 258         ret = i2c_smbus_write_byte_data(lp->client,
 259                 ARCXCNN_CMD, ARCXCNN_CMD_RESET);
 260         if (ret)
 261                 goto probe_err;
 262
 263         if (!lp->pdata) {
 264                 lp->pdata = devm_kzalloc(lp->dev,
 265                                 sizeof(*lp->pdata), GFP_KERNEL);
 266                 if (!lp->pdata)
 267                         return -ENOMEM;
 268
 269                 /* Setup defaults based on power-on defaults */
 270                 lp->pdata->name = NULL;
 271                 lp->pdata->initial_brightness = INIT_BRIGHT;
 272                 lp->pdata->leden = ARCXCNN_LEDEN_MASK;
 273
 274                 lp->pdata->led_config_0 = i2c_smbus_read_byte_data(
 275                         lp->client, ARCXCNN_FADECTRL);
 276
 277                 lp->pdata->led_config_1 = i2c_smbus_read_byte_data(
 278                         lp->client, ARCXCNN_ILED_CONFIG);
 279                 /* insure dim mode is not default pwm */
 280                 lp->pdata->led_config_1 |= ARCXCNN_ILED_DIM_INT;
 281
 282                 lp->pdata->dim_freq = i2c_smbus_read_byte_data(
 283                         lp->client, ARCXCNN_DIMFREQ);
 284
 285                 lp->pdata->comp_config = i2c_smbus_read_byte_data(
 286                         lp->client, ARCXCNN_COMP_CONFIG);
 287
 288                 lp->pdata->filter_config = i2c_smbus_read_byte_data(
 289                         lp->client, ARCXCNN_FILT_CONFIG);
 290
 291                 lp->pdata->trim_config = i2c_smbus_read_byte_data(
 292                         lp->client, ARCXCNN_IMAXTUNE);
 293
 294                 if (IS_ENABLED(CONFIG_OF))
 295                         arcxcnn_parse_dt(lp);
 296         }
 297
 298         i2c_set_clientdata(cl, lp);
 299
 300         /* constrain settings to what is possible */
 301         if (lp->pdata->initial_brightness > MAX_BRIGHTNESS)
 302                 lp->pdata->initial_brightness = MAX_BRIGHTNESS;
 303
 304         /* set initial brightness */
 305         ret = arcxcnn_set_brightness(lp, lp->pdata->initial_brightness);
 306         if (ret)
 307                 goto probe_err;
 308
 309         /* set other register values directly */
 310         ret = i2c_smbus_write_byte_data(lp->client, ARCXCNN_FADECTRL,
 311                 lp->pdata->led_config_0);
 312         if (ret)
 313                 goto probe_err;
 314
 315         ret = i2c_smbus_write_byte_data(lp->client, ARCXCNN_ILED_CONFIG,
 316                 lp->pdata->led_config_1);
 317         if (ret)
 318                 goto probe_err;
 319
 320         ret = i2c_smbus_write_byte_data(lp->client, ARCXCNN_DIMFREQ,
 321                 lp->pdata->dim_freq);
 322         if (ret)
 323                 goto probe_err;
 324
 325         ret = i2c_smbus_write_byte_data(lp->client, ARCXCNN_COMP_CONFIG,
 326                 lp->pdata->comp_config);
 327         if (ret)
 328                 goto probe_err;
 329
 330         ret = i2c_smbus_write_byte_data(lp->client, ARCXCNN_FILT_CONFIG,
 331                 lp->pdata->filter_config);
 332         if (ret)
 333                 goto probe_err;
 334
 335         ret = i2c_smbus_write_byte_data(lp->client, ARCXCNN_IMAXTUNE,
 336                 lp->pdata->trim_config);
 337         if (ret)
 338                 goto probe_err;
 339
 340         /* set initial LED Enables */
 341         arcxcnn_update_field(lp, ARCXCNN_LEDEN,
 342                 ARCXCNN_LEDEN_MASK, lp->pdata->leden);
 343
 344         ret = arcxcnn_backlight_register(lp);
 345         if (ret)
 346                 goto probe_register_err;
 347
 348         backlight_update_status(lp->bl);
 349
 350         return 0;
 351
 352 probe_register_err:
 353         dev_err(lp->dev,
 354                 "failed to register backlight.\n");
 355
 356 probe_err:
 357         dev_err(lp->dev,
 358                 "failure ret: %d\n", ret);
 359         return ret;
 360 }
 361
 362 static void arcxcnn_remove(struct i2c_client *cl)
 363 {
 364         struct arcxcnn *lp = i2c_get_clientdata(cl);
 365
 366         /* disable all strings (ignore errors) */
 367         i2c_smbus_write_byte_data(lp->client,
 368                 ARCXCNN_LEDEN, 0x00);
 369         /* reset the device (ignore errors) */
 370         i2c_smbus_write_byte_data(lp->client,
 371                 ARCXCNN_CMD, ARCXCNN_CMD_RESET);
 372
 373         lp->bl->props.brightness = 0;
 374
 375         backlight_update_status(lp->bl);
 376 }
 377
 378 static const struct of_device_id arcxcnn_dt_ids[] = {
 379         { .compatible = "arc,arc2c0608" },
 380         { }
 381 };
 382 MODULE_DEVICE_TABLE(of, arcxcnn_dt_ids);
 383
 384 static const struct i2c_device_id arcxcnn_ids[] = {
 385         {"arc2c0608", ARC2C0608},
 386         { }
 387 };
 388 MODULE_DEVICE_TABLE(i2c, arcxcnn_ids);
 389
 390 static struct i2c_driver arcxcnn_driver = {
 391         .driver = {
 392                 .name = "arcxcnn_bl",
 393                 .of_match_table = arcxcnn_dt_ids,
 394         },
 395         .probe = arcxcnn_probe,
 396         .remove = arcxcnn_remove,
 397         .id_table = arcxcnn_ids,
 398 };
 399 module_i2c_driver(arcxcnn_driver);
 400
 401 MODULE_LICENSE("GPL v2");
 402 MODULE_AUTHOR("Brian Dodge <bdodge@arcticsand.com>");
 403 MODULE_DESCRIPTION("ARCXCNN Backlight driver");