drm/panel/panel-olimex-lcd-olinuxino.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * LCD-OLinuXino support for panel driver
0004  *
0005  * Copyright (C) 2018 Olimex Ltd.
0006  *   Author: Stefan Mavrodiev <stefan@olimex.com>
0007  */
0008
0009 #include <linux/crc32.h>
0010 #include <linux/gpio/consumer.h>
0011 #include <linux/i2c.h>
0012 #include <linux/module.h>
0013 #include <linux/mutex.h>
0014 #include <linux/of.h>
0015 #include <linux/regulator/consumer.h>
0016
0017 #include <video/videomode.h>
0018 #include <video/display_timing.h>
0019
0020 #include <drm/drm_device.h>
0021 #include <drm/drm_modes.h>
0022 #include <drm/drm_panel.h>
0023
0024 #define LCD_OLINUXINO_HEADER_MAGIC  0x4F4CB727
0025 #define LCD_OLINUXINO_DATA_LEN      256
0026
0027 struct lcd_olinuxino_mode {
0028     u32 pixelclock;
0029     u32 hactive;
0030     u32 hfp;
0031     u32 hbp;
0032     u32 hpw;
0033     u32 vactive;
0034     u32 vfp;
0035     u32 vbp;
0036     u32 vpw;
0037     u32 refresh;
0038     u32 flags;
0039 };
0040
0041 struct lcd_olinuxino_info {
0042     char name[32];
0043     u32 width_mm;
0044     u32 height_mm;
0045     u32 bpc;
0046     u32 bus_format;
0047     u32 bus_flag;
0048 } __attribute__((__packed__));
0049
0050 struct lcd_olinuxino_eeprom {
0051     u32 header;
0052     u32 id;
0053     char revision[4];
0054     u32 serial;
0055     struct lcd_olinuxino_info info;
0056     u32 num_modes;
0057     u8 reserved[180];
0058     u32 checksum;
0059 } __attribute__((__packed__));
0060
0061 struct lcd_olinuxino {
0062     struct drm_panel panel;
0063     struct device *dev;
0064     struct i2c_client *client;
0065     struct mutex mutex;
0066
0067     bool prepared;
0068     bool enabled;
0069
0070     struct regulator *supply;
0071     struct gpio_desc *enable_gpio;
0072
0073     struct lcd_olinuxino_eeprom eeprom;
0074 };
0075
0076 static inline struct lcd_olinuxino *to_lcd_olinuxino(struct drm_panel *panel)
0077 {
0078     return container_of(panel, struct lcd_olinuxino, panel);
0079 }
0080
0081 static int lcd_olinuxino_disable(struct drm_panel *panel)
0082 {
0083     struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
0084
0085     if (!lcd->enabled)
0086         return 0;
0087
0088     lcd->enabled = false;
0089
0090     return 0;
0091 }
0092
0093 static int lcd_olinuxino_unprepare(struct drm_panel *panel)
0094 {
0095     struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
0096
0097     if (!lcd->prepared)
0098         return 0;
0099
0100     gpiod_set_value_cansleep(lcd->enable_gpio, 0);
0101     regulator_disable(lcd->supply);
0102
0103     lcd->prepared = false;
0104
0105     return 0;
0106 }
0107
0108 static int lcd_olinuxino_prepare(struct drm_panel *panel)
0109 {
0110     struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
0111     int ret;
0112
0113     if (lcd->prepared)
0114         return 0;
0115
0116     ret = regulator_enable(lcd->supply);
0117     if (ret < 0)
0118         return ret;
0119
0120     gpiod_set_value_cansleep(lcd->enable_gpio, 1);
0121     lcd->prepared = true;
0122
0123     return 0;
0124 }
0125
0126 static int lcd_olinuxino_enable(struct drm_panel *panel)
0127 {
0128     struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
0129
0130     if (lcd->enabled)
0131         return 0;
0132
0133     lcd->enabled = true;
0134
0135     return 0;
0136 }
0137
0138 static int lcd_olinuxino_get_modes(struct drm_panel *panel,
0139                    struct drm_connector *connector)
0140 {
0141     struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
0142     struct lcd_olinuxino_info *lcd_info = &lcd->eeprom.info;
0143     struct lcd_olinuxino_mode *lcd_mode;
0144     struct drm_display_mode *mode;
0145     u32 i, num = 0;
0146
0147     for (i = 0; i < lcd->eeprom.num_modes; i++) {
0148         lcd_mode = (struct lcd_olinuxino_mode *)
0149                &lcd->eeprom.reserved[i * sizeof(*lcd_mode)];
0150
0151         mode = drm_mode_create(connector->dev);
0152         if (!mode) {
0153             dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
0154                 lcd_mode->hactive,
0155                 lcd_mode->vactive,
0156                 lcd_mode->refresh);
0157             continue;
0158         }
0159
0160         mode->clock = lcd_mode->pixelclock;
0161         mode->hdisplay = lcd_mode->hactive;
0162         mode->hsync_start = lcd_mode->hactive + lcd_mode->hfp;
0163         mode->hsync_end = lcd_mode->hactive + lcd_mode->hfp +
0164                   lcd_mode->hpw;
0165         mode->htotal = lcd_mode->hactive + lcd_mode->hfp +
0166                    lcd_mode->hpw + lcd_mode->hbp;
0167         mode->vdisplay = lcd_mode->vactive;
0168         mode->vsync_start = lcd_mode->vactive + lcd_mode->vfp;
0169         mode->vsync_end = lcd_mode->vactive + lcd_mode->vfp +
0170                   lcd_mode->vpw;
0171         mode->vtotal = lcd_mode->vactive + lcd_mode->vfp +
0172                    lcd_mode->vpw + lcd_mode->vbp;
0173
0174         /* Always make the first mode preferred */
0175         if (i == 0)
0176             mode->type |= DRM_MODE_TYPE_PREFERRED;
0177         mode->type |= DRM_MODE_TYPE_DRIVER;
0178
0179         drm_mode_set_name(mode);
0180         drm_mode_probed_add(connector, mode);
0181
0182         num++;
0183     }
0184
0185     connector->display_info.width_mm = lcd_info->width_mm;
0186     connector->display_info.height_mm = lcd_info->height_mm;
0187     connector->display_info.bpc = lcd_info->bpc;
0188
0189     if (lcd_info->bus_format)
0190         drm_display_info_set_bus_formats(&connector->display_info,
0191                          &lcd_info->bus_format, 1);
0192     connector->display_info.bus_flags = lcd_info->bus_flag;
0193
0194     return num;
0195 }
0196
0197 static const struct drm_panel_funcs lcd_olinuxino_funcs = {
0198     .disable = lcd_olinuxino_disable,
0199     .unprepare = lcd_olinuxino_unprepare,
0200     .prepare = lcd_olinuxino_prepare,
0201     .enable = lcd_olinuxino_enable,
0202     .get_modes = lcd_olinuxino_get_modes,
0203 };
0204
0205 static int lcd_olinuxino_probe(struct i2c_client *client,
0206                    const struct i2c_device_id *id)
0207 {
0208     struct device *dev = &client->dev;
0209     struct lcd_olinuxino *lcd;
0210     u32 checksum, i;
0211     int ret = 0;
0212
0213     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
0214                      I2C_FUNC_SMBUS_READ_I2C_BLOCK))
0215         return -ENODEV;
0216
0217     lcd = devm_kzalloc(dev, sizeof(*lcd), GFP_KERNEL);
0218     if (!lcd)
0219         return -ENOMEM;
0220
0221     i2c_set_clientdata(client, lcd);
0222     lcd->dev = dev;
0223     lcd->client = client;
0224
0225     mutex_init(&lcd->mutex);
0226
0227     /* Copy data into buffer */
0228     for (i = 0; i < LCD_OLINUXINO_DATA_LEN; i += I2C_SMBUS_BLOCK_MAX) {
0229         mutex_lock(&lcd->mutex);
0230         ret = i2c_smbus_read_i2c_block_data(client,
0231                             i,
0232                             I2C_SMBUS_BLOCK_MAX,
0233                             (u8 *)&lcd->eeprom + i);
0234         mutex_unlock(&lcd->mutex);
0235         if (ret < 0) {
0236             dev_err(dev, "error reading from device at %02x\n", i);
0237             return ret;
0238         }
0239     }
0240
0241     /* Check configuration checksum */
0242     checksum = ~crc32(~0, (u8 *)&lcd->eeprom, 252);
0243     if (checksum != lcd->eeprom.checksum) {
0244         dev_err(dev, "configuration checksum does not match!\n");
0245         return -EINVAL;
0246     }
0247
0248     /* Check magic header */
0249     if (lcd->eeprom.header != LCD_OLINUXINO_HEADER_MAGIC) {
0250         dev_err(dev, "magic header does not match\n");
0251         return -EINVAL;
0252     }
0253
0254     dev_info(dev, "Detected %s, Rev. %s, Serial: %08x\n",
0255          lcd->eeprom.info.name,
0256          lcd->eeprom.revision,
0257          lcd->eeprom.serial);
0258
0259     /*
0260      * The eeprom can hold up to 4 modes.
0261      * If the stored value is bigger, overwrite it.
0262      */
0263     if (lcd->eeprom.num_modes > 4) {
0264         dev_warn(dev, "invalid number of modes, falling back to 4\n");
0265         lcd->eeprom.num_modes = 4;
0266     }
0267
0268     lcd->enabled = false;
0269     lcd->prepared = false;
0270
0271     lcd->supply = devm_regulator_get(dev, "power");
0272     if (IS_ERR(lcd->supply))
0273         return PTR_ERR(lcd->supply);
0274
0275     lcd->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
0276     if (IS_ERR(lcd->enable_gpio))
0277         return PTR_ERR(lcd->enable_gpio);
0278
0279     drm_panel_init(&lcd->panel, dev, &lcd_olinuxino_funcs,
0280                DRM_MODE_CONNECTOR_DPI);
0281
0282     ret = drm_panel_of_backlight(&lcd->panel);
0283     if (ret)
0284         return ret;
0285
0286     drm_panel_add(&lcd->panel);
0287
0288     return 0;
0289 }
0290
0291 static int lcd_olinuxino_remove(struct i2c_client *client)
0292 {
0293     struct lcd_olinuxino *panel = i2c_get_clientdata(client);
0294
0295     drm_panel_remove(&panel->panel);
0296
0297     drm_panel_disable(&panel->panel);
0298     drm_panel_unprepare(&panel->panel);
0299
0300     return 0;
0301 }
0302
0303 static const struct of_device_id lcd_olinuxino_of_ids[] = {
0304     { .compatible = "olimex,lcd-olinuxino" },
0305     { }
0306 };
0307 MODULE_DEVICE_TABLE(of, lcd_olinuxino_of_ids);
0308
0309 static struct i2c_driver lcd_olinuxino_driver = {
0310     .driver = {
0311         .name = "lcd_olinuxino",
0312         .of_match_table = lcd_olinuxino_of_ids,
0313     },
0314     .probe = lcd_olinuxino_probe,
0315     .remove = lcd_olinuxino_remove,
0316 };
0317
0318 module_i2c_driver(lcd_olinuxino_driver);
0319
0320 MODULE_AUTHOR("Stefan Mavrodiev <stefan@olimex.com>");
0321 MODULE_DESCRIPTION("LCD-OLinuXino driver");
0322 MODULE_LICENSE("GPL");