drivers/regulator/rpi-panel-attiny-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2020 Marek Vasut <marex@denx.de>
   4  *
   5  * Based on rpi_touchscreen.c by Eric Anholt <eric@anholt.net>
   6  */
   7
   8 #include <linux/backlight.h>
   9 #include <linux/err.h>
  10 #include <linux/gpio.h>
  11 #include <linux/i2c.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/module.h>
  15 #include <linux/regmap.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/regulator/machine.h>
  18 #include <linux/regulator/of_regulator.h>
  19 #include <linux/slab.h>
  20
  21 /* I2C registers of the Atmel microcontroller. */
  22 #define REG_ID          0x80
  23 #define REG_PORTA       0x81
  24 #define REG_PORTA_HF    BIT(2)
  25 #define REG_PORTA_VF    BIT(3)
  26 #define REG_PORTB       0x82
  27 #define REG_POWERON     0x85
  28 #define REG_PWM         0x86
  29
  30 static const struct regmap_config attiny_regmap_config = {
  31         .reg_bits = 8,
  32         .val_bits = 8,
  33         .max_register = REG_PWM,
  34         .cache_type = REGCACHE_NONE,
  35 };
  36
  37 static int attiny_lcd_power_enable(struct regulator_dev *rdev)
  38 {
  39         unsigned int data;
  40
  41         regmap_write(rdev->regmap, REG_POWERON, 1);
  42         /* Wait for nPWRDWN to go low to indicate poweron is done. */
  43         regmap_read_poll_timeout(rdev->regmap, REG_PORTB, data,
  44                                         data & BIT(0), 10, 1000000);
  45
  46         /* Default to the same orientation as the closed source
  47          * firmware used for the panel.  Runtime rotation
  48          * configuration will be supported using VC4's plane
  49          * orientation bits.
  50          */
  51         regmap_write(rdev->regmap, REG_PORTA, BIT(2));
  52
  53         return 0;
  54 }
  55
  56 static int attiny_lcd_power_disable(struct regulator_dev *rdev)
  57 {
  58         regmap_write(rdev->regmap, REG_PWM, 0);
  59         regmap_write(rdev->regmap, REG_POWERON, 0);
  60         udelay(1);
  61         return 0;
  62 }
  63
  64 static int attiny_lcd_power_is_enabled(struct regulator_dev *rdev)
  65 {
  66         unsigned int data;
  67         int ret;
  68
  69         ret = regmap_read(rdev->regmap, REG_POWERON, &data);
  70         if (ret < 0)
  71                 return ret;
  72
  73         if (!(data & BIT(0)))
  74                 return 0;
  75
  76         ret = regmap_read(rdev->regmap, REG_PORTB, &data);
  77         if (ret < 0)
  78                 return ret;
  79
  80         return data & BIT(0);
  81 }
  82
  83 static const struct regulator_init_data attiny_regulator_default = {
  84         .constraints = {
  85                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
  86         },
  87 };
  88
  89 static const struct regulator_ops attiny_regulator_ops = {
  90         .enable = attiny_lcd_power_enable,
  91         .disable = attiny_lcd_power_disable,
  92         .is_enabled = attiny_lcd_power_is_enabled,
  93 };
  94
  95 static const struct regulator_desc attiny_regulator = {
  96         .name   = "tc358762-power",
  97         .ops    = &attiny_regulator_ops,
  98         .type   = REGULATOR_VOLTAGE,
  99         .owner  = THIS_MODULE,
 100 };
 101
 102 static int attiny_update_status(struct backlight_device *bl)
 103 {
 104         struct regmap *regmap = bl_get_data(bl);
 105         int brightness = bl->props.brightness;
 106
 107         if (bl->props.power != FB_BLANK_UNBLANK ||
 108             bl->props.fb_blank != FB_BLANK_UNBLANK)
 109                 brightness = 0;
 110
 111         return regmap_write(regmap, REG_PWM, brightness);
 112 }
 113
 114 static int attiny_get_brightness(struct backlight_device *bl)
 115 {
 116         struct regmap *regmap = bl_get_data(bl);
 117         int ret, brightness;
 118
 119         ret = regmap_read(regmap, REG_PWM, &brightness);
 120         if (ret)
 121                 return ret;
 122
 123         return brightness;
 124 }
 125
 126 static const struct backlight_ops attiny_bl = {
 127         .update_status  = attiny_update_status,
 128         .get_brightness = attiny_get_brightness,
 129 };
 130
 131 /*
 132  * I2C driver interface functions
 133  */
 134 static int attiny_i2c_probe(struct i2c_client *i2c,
 135                 const struct i2c_device_id *id)
 136 {
 137         struct backlight_properties props = { };
 138         struct regulator_config config = { };
 139         struct backlight_device *bl;
 140         struct regulator_dev *rdev;
 141         struct regmap *regmap;
 142         unsigned int data;
 143         int ret;
 144
 145         regmap = devm_regmap_init_i2c(i2c, &attiny_regmap_config);
 146         if (IS_ERR(regmap)) {
 147                 ret = PTR_ERR(regmap);
 148                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
 149                         ret);
 150                 return ret;
 151         }
 152
 153         ret = regmap_read(regmap, REG_ID, &data);
 154         if (ret < 0) {
 155                 dev_err(&i2c->dev, "Failed to read REG_ID reg: %d\n", ret);
 156                 return ret;
 157         }
 158
 159         switch (data) {
 160         case 0xde: /* ver 1 */
 161         case 0xc3: /* ver 2 */
 162                 break;
 163         default:
 164                 dev_err(&i2c->dev, "Unknown Atmel firmware revision: 0x%02x\n", data);
 165                 return -ENODEV;
 166         }
 167
 168         regmap_write(regmap, REG_POWERON, 0);
 169         mdelay(1);
 170
 171         config.dev = &i2c->dev;
 172         config.regmap = regmap;
 173         config.of_node = i2c->dev.of_node;
 174         config.init_data = &attiny_regulator_default;
 175
 176         rdev = devm_regulator_register(&i2c->dev, &attiny_regulator, &config);
 177         if (IS_ERR(rdev)) {
 178                 dev_err(&i2c->dev, "Failed to register ATTINY regulator\n");
 179                 return PTR_ERR(rdev);
 180         }
 181
 182         props.type = BACKLIGHT_RAW;
 183         props.max_brightness = 0xff;
 184         bl = devm_backlight_device_register(&i2c->dev,
 185                                             "7inch-touchscreen-panel-bl",
 186                                             &i2c->dev, regmap, &attiny_bl,
 187                                             &props);
 188         if (IS_ERR(bl))
 189                 return PTR_ERR(bl);
 190
 191         bl->props.brightness = 0xff;
 192
 193         return 0;
 194 }
 195
 196 static const struct of_device_id attiny_dt_ids[] = {
 197         { .compatible = "raspberrypi,7inch-touchscreen-panel-regulator" },
 198         {},
 199 };
 200 MODULE_DEVICE_TABLE(of, attiny_dt_ids);
 201
 202 static struct i2c_driver attiny_regulator_driver = {
 203         .driver = {
 204                 .name = "rpi_touchscreen_attiny",
 205                 .of_match_table = of_match_ptr(attiny_dt_ids),
 206         },
 207         .probe = attiny_i2c_probe,
 208 };
 209
 210 module_i2c_driver(attiny_regulator_driver);
 211
 212 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
 213 MODULE_DESCRIPTION("Regulator device driver for Raspberry Pi 7-inch touchscreen");
 214 MODULE_LICENSE("GPL v2");