1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * BOE BF060Y8M-AJ0 5.99" MIPI-DSI OLED Panel on SW43404 DriverIC 4 * 5 * Copyright (c) 2020 AngeloGioacchino Del Regno 6 * <angelogioacchino.delregno@somainline.org> 7 */ 8 9 #include <linux/backlight.h> 10 #include <linux/delay.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/module.h> 13 #include <linux/of.h> 14 #include <linux/regulator/consumer.h> 15 #include <video/mipi_display.h> 16 #include <drm/drm_mipi_dsi.h> 17 #include <drm/drm_modes.h> 18 #include <drm/drm_panel.h> 19 20 #define DCS_ALLOW_HBM_RANGE 0x0c 21 #define DCS_DISALLOW_HBM_RANGE 0x08 22 23 enum boe_bf060y8m_aj0_supplies { 24 BF060Y8M_VREG_VCC, 25 BF060Y8M_VREG_VDDIO, 26 BF060Y8M_VREG_VCI, 27 BF060Y8M_VREG_EL_VDD, 28 BF060Y8M_VREG_EL_VSS, 29 BF060Y8M_VREG_MAX 30 }; 31 32 struct boe_bf060y8m_aj0 { 33 struct drm_panel panel; 34 struct mipi_dsi_device *dsi; 35 struct regulator_bulk_data vregs[BF060Y8M_VREG_MAX]; 36 struct gpio_desc *reset_gpio; 37 bool prepared; 38 }; 39 40 static inline 41 struct boe_bf060y8m_aj0 *to_boe_bf060y8m_aj0(struct drm_panel *panel) 42 { 43 return container_of(panel, struct boe_bf060y8m_aj0, panel); 44 } 45 46 #define dsi_dcs_write_seq(dsi, seq...) do { \ 47 static const u8 d[] = { seq }; \ 48 int ret; \ 49 ret = mipi_dsi_dcs_write_buffer(dsi, d, ARRAY_SIZE(d)); \ 50 if (ret < 0) \ 51 return ret; \ 52 } while (0) 53 54 static void boe_bf060y8m_aj0_reset(struct boe_bf060y8m_aj0 *boe) 55 { 56 gpiod_set_value_cansleep(boe->reset_gpio, 0); 57 usleep_range(2000, 3000); 58 gpiod_set_value_cansleep(boe->reset_gpio, 1); 59 usleep_range(15000, 16000); 60 gpiod_set_value_cansleep(boe->reset_gpio, 0); 61 usleep_range(5000, 6000); 62 } 63 64 static int boe_bf060y8m_aj0_on(struct boe_bf060y8m_aj0 *boe) 65 { 66 struct mipi_dsi_device *dsi = boe->dsi; 67 struct device *dev = &dsi->dev; 68 int ret; 69 70 dsi_dcs_write_seq(dsi, 0xb0, 0xa5, 0x00); 71 dsi_dcs_write_seq(dsi, 0xb2, 0x00, 0x4c); 72 dsi_dcs_write_seq(dsi, MIPI_DCS_SET_3D_CONTROL, 0x10); 73 dsi_dcs_write_seq(dsi, MIPI_DCS_WRITE_POWER_SAVE, DCS_ALLOW_HBM_RANGE); 74 dsi_dcs_write_seq(dsi, 0xf8, 75 0x00, 0x08, 0x10, 0x00, 0x22, 0x00, 0x00, 0x2d); 76 77 ret = mipi_dsi_dcs_exit_sleep_mode(dsi); 78 if (ret < 0) { 79 dev_err(dev, "Failed to exit sleep mode: %d\n", ret); 80 return ret; 81 } 82 msleep(30); 83 84 dsi_dcs_write_seq(dsi, 0xb0, 0xa5, 0x00); 85 dsi_dcs_write_seq(dsi, 0xc0, 86 0x08, 0x48, 0x65, 0x33, 0x33, 0x33, 87 0x2a, 0x31, 0x39, 0x20, 0x09); 88 dsi_dcs_write_seq(dsi, 0xc1, 0x00, 0x00, 0x00, 0x1f, 0x1f, 89 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 90 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f); 91 dsi_dcs_write_seq(dsi, 0xe2, 0x20, 0x04, 0x10, 0x12, 0x92, 92 0x4f, 0x8f, 0x44, 0x84, 0x83, 0x83, 0x83, 93 0x5c, 0x5c, 0x5c); 94 dsi_dcs_write_seq(dsi, 0xde, 0x01, 0x2c, 0x00, 0x77, 0x3e); 95 96 msleep(30); 97 98 ret = mipi_dsi_dcs_set_display_on(dsi); 99 if (ret < 0) { 100 dev_err(dev, "Failed to set display on: %d\n", ret); 101 return ret; 102 } 103 msleep(50); 104 105 return 0; 106 } 107 108 static int boe_bf060y8m_aj0_off(struct boe_bf060y8m_aj0 *boe) 109 { 110 struct mipi_dsi_device *dsi = boe->dsi; 111 struct device *dev = &dsi->dev; 112 int ret; 113 114 /* OFF commands sent in HS mode */ 115 dsi->mode_flags &= ~MIPI_DSI_MODE_LPM; 116 ret = mipi_dsi_dcs_set_display_off(dsi); 117 if (ret < 0) { 118 dev_err(dev, "Failed to set display off: %d\n", ret); 119 return ret; 120 } 121 msleep(20); 122 123 ret = mipi_dsi_dcs_enter_sleep_mode(dsi); 124 if (ret < 0) { 125 dev_err(dev, "Failed to enter sleep mode: %d\n", ret); 126 return ret; 127 } 128 usleep_range(1000, 2000); 129 dsi->mode_flags |= MIPI_DSI_MODE_LPM; 130 131 return 0; 132 } 133 134 static int boe_bf060y8m_aj0_prepare(struct drm_panel *panel) 135 { 136 struct boe_bf060y8m_aj0 *boe = to_boe_bf060y8m_aj0(panel); 137 struct device *dev = &boe->dsi->dev; 138 int ret; 139 140 if (boe->prepared) 141 return 0; 142 143 /* 144 * Enable EL Driving Voltage first - doing that at the beginning 145 * or at the end of the power sequence doesn't matter, so enable 146 * it here to avoid yet another usleep at the end. 147 */ 148 ret = regulator_enable(boe->vregs[BF060Y8M_VREG_EL_VDD].consumer); 149 if (ret) 150 return ret; 151 ret = regulator_enable(boe->vregs[BF060Y8M_VREG_EL_VSS].consumer); 152 if (ret) 153 goto err_elvss; 154 155 ret = regulator_enable(boe->vregs[BF060Y8M_VREG_VCC].consumer); 156 if (ret) 157 goto err_vcc; 158 usleep_range(1000, 2000); 159 ret = regulator_enable(boe->vregs[BF060Y8M_VREG_VDDIO].consumer); 160 if (ret) 161 goto err_vddio; 162 usleep_range(500, 1000); 163 ret = regulator_enable(boe->vregs[BF060Y8M_VREG_VCI].consumer); 164 if (ret) 165 goto err_vci; 166 usleep_range(2000, 3000); 167 168 boe_bf060y8m_aj0_reset(boe); 169 170 ret = boe_bf060y8m_aj0_on(boe); 171 if (ret < 0) { 172 dev_err(dev, "Failed to initialize panel: %d\n", ret); 173 gpiod_set_value_cansleep(boe->reset_gpio, 1); 174 return ret; 175 } 176 177 boe->prepared = true; 178 return 0; 179 180 err_vci: 181 regulator_disable(boe->vregs[BF060Y8M_VREG_VDDIO].consumer); 182 err_vddio: 183 regulator_disable(boe->vregs[BF060Y8M_VREG_VCC].consumer); 184 err_vcc: 185 regulator_disable(boe->vregs[BF060Y8M_VREG_EL_VSS].consumer); 186 err_elvss: 187 regulator_disable(boe->vregs[BF060Y8M_VREG_EL_VDD].consumer); 188 return ret; 189 } 190 191 static int boe_bf060y8m_aj0_unprepare(struct drm_panel *panel) 192 { 193 struct boe_bf060y8m_aj0 *boe = to_boe_bf060y8m_aj0(panel); 194 struct device *dev = &boe->dsi->dev; 195 int ret; 196 197 if (!boe->prepared) 198 return 0; 199 200 ret = boe_bf060y8m_aj0_off(boe); 201 if (ret < 0) 202 dev_err(dev, "Failed to un-initialize panel: %d\n", ret); 203 204 gpiod_set_value_cansleep(boe->reset_gpio, 1); 205 ret = regulator_bulk_disable(ARRAY_SIZE(boe->vregs), boe->vregs); 206 207 boe->prepared = false; 208 return 0; 209 } 210 211 static const struct drm_display_mode boe_bf060y8m_aj0_mode = { 212 .clock = 165268, 213 .hdisplay = 1080, 214 .hsync_start = 1080 + 36, 215 .hsync_end = 1080 + 36 + 24, 216 .htotal = 1080 + 36 + 24 + 96, 217 .vdisplay = 2160, 218 .vsync_start = 2160 + 16, 219 .vsync_end = 2160 + 16 + 1, 220 .vtotal = 2160 + 16 + 1 + 15, 221 .width_mm = 68, /* 68.04 mm */ 222 .height_mm = 136, /* 136.08 mm */ 223 }; 224 225 static int boe_bf060y8m_aj0_get_modes(struct drm_panel *panel, 226 struct drm_connector *connector) 227 { 228 struct drm_display_mode *mode; 229 230 mode = drm_mode_duplicate(connector->dev, &boe_bf060y8m_aj0_mode); 231 if (!mode) 232 return -ENOMEM; 233 234 drm_mode_set_name(mode); 235 236 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 237 connector->display_info.width_mm = mode->width_mm; 238 connector->display_info.height_mm = mode->height_mm; 239 drm_mode_probed_add(connector, mode); 240 241 return 1; 242 } 243 244 static const struct drm_panel_funcs boe_bf060y8m_aj0_panel_funcs = { 245 .prepare = boe_bf060y8m_aj0_prepare, 246 .unprepare = boe_bf060y8m_aj0_unprepare, 247 .get_modes = boe_bf060y8m_aj0_get_modes, 248 }; 249 250 static int boe_bf060y8m_aj0_bl_update_status(struct backlight_device *bl) 251 { 252 struct mipi_dsi_device *dsi = bl_get_data(bl); 253 u16 brightness = backlight_get_brightness(bl); 254 int ret; 255 256 ret = mipi_dsi_dcs_set_display_brightness(dsi, brightness); 257 if (ret < 0) 258 return ret; 259 260 return 0; 261 } 262 263 static int boe_bf060y8m_aj0_bl_get_brightness(struct backlight_device *bl) 264 { 265 struct mipi_dsi_device *dsi = bl_get_data(bl); 266 u16 brightness; 267 int ret; 268 269 ret = mipi_dsi_dcs_get_display_brightness(dsi, &brightness); 270 if (ret < 0) 271 return ret; 272 273 return brightness & 0xff; 274 } 275 276 static const struct backlight_ops boe_bf060y8m_aj0_bl_ops = { 277 .update_status = boe_bf060y8m_aj0_bl_update_status, 278 .get_brightness = boe_bf060y8m_aj0_bl_get_brightness, 279 }; 280 281 static struct backlight_device * 282 boe_bf060y8m_aj0_create_backlight(struct mipi_dsi_device *dsi) 283 { 284 struct device *dev = &dsi->dev; 285 const struct backlight_properties props = { 286 .type = BACKLIGHT_RAW, 287 .brightness = 127, 288 .max_brightness = 255, 289 .scale = BACKLIGHT_SCALE_NON_LINEAR, 290 }; 291 292 return devm_backlight_device_register(dev, dev_name(dev), dev, dsi, 293 &boe_bf060y8m_aj0_bl_ops, &props); 294 } 295 296 static int boe_bf060y8m_aj0_init_vregs(struct boe_bf060y8m_aj0 *boe, 297 struct device *dev) 298 { 299 struct regulator *vreg; 300 int ret; 301 302 boe->vregs[BF060Y8M_VREG_VCC].supply = "vcc"; 303 boe->vregs[BF060Y8M_VREG_VDDIO].supply = "vddio"; 304 boe->vregs[BF060Y8M_VREG_VCI].supply = "vci"; 305 boe->vregs[BF060Y8M_VREG_EL_VDD].supply = "elvdd"; 306 boe->vregs[BF060Y8M_VREG_EL_VSS].supply = "elvss"; 307 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(boe->vregs), 308 boe->vregs); 309 if (ret < 0) { 310 dev_err(dev, "Failed to get regulators: %d\n", ret); 311 return ret; 312 } 313 314 vreg = boe->vregs[BF060Y8M_VREG_VCC].consumer; 315 ret = regulator_is_supported_voltage(vreg, 2700000, 3600000); 316 if (!ret) 317 return ret; 318 319 vreg = boe->vregs[BF060Y8M_VREG_VDDIO].consumer; 320 ret = regulator_is_supported_voltage(vreg, 1620000, 1980000); 321 if (!ret) 322 return ret; 323 324 vreg = boe->vregs[BF060Y8M_VREG_VCI].consumer; 325 ret = regulator_is_supported_voltage(vreg, 2600000, 3600000); 326 if (!ret) 327 return ret; 328 329 vreg = boe->vregs[BF060Y8M_VREG_EL_VDD].consumer; 330 ret = regulator_is_supported_voltage(vreg, 4400000, 4800000); 331 if (!ret) 332 return ret; 333 334 /* ELVSS is negative: -5.00V to -1.40V */ 335 vreg = boe->vregs[BF060Y8M_VREG_EL_VSS].consumer; 336 ret = regulator_is_supported_voltage(vreg, 1400000, 5000000); 337 if (!ret) 338 return ret; 339 340 /* 341 * Set min/max rated current, known only for VCI and VDDIO and, 342 * in case of failure, just go on gracefully, as this step is not 343 * guaranteed to succeed on all regulator HW but do a debug print 344 * to inform the developer during debugging. 345 * In any case, these two supplies are also optional, so they may 346 * be fixed-regulator which, at the time of writing, does not 347 * support fake current limiting. 348 */ 349 vreg = boe->vregs[BF060Y8M_VREG_VDDIO].consumer; 350 ret = regulator_set_current_limit(vreg, 1500, 2500); 351 if (ret) 352 dev_dbg(dev, "Current limit cannot be set on %s: %d\n", 353 boe->vregs[1].supply, ret); 354 355 vreg = boe->vregs[BF060Y8M_VREG_VCI].consumer; 356 ret = regulator_set_current_limit(vreg, 20000, 40000); 357 if (ret) 358 dev_dbg(dev, "Current limit cannot be set on %s: %d\n", 359 boe->vregs[2].supply, ret); 360 361 return 0; 362 } 363 364 static int boe_bf060y8m_aj0_probe(struct mipi_dsi_device *dsi) 365 { 366 struct device *dev = &dsi->dev; 367 struct boe_bf060y8m_aj0 *boe; 368 int ret; 369 370 boe = devm_kzalloc(dev, sizeof(*boe), GFP_KERNEL); 371 if (!boe) 372 return -ENOMEM; 373 374 ret = boe_bf060y8m_aj0_init_vregs(boe, dev); 375 if (ret) 376 return dev_err_probe(dev, ret, 377 "Failed to initialize supplies.\n"); 378 379 boe->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS); 380 if (IS_ERR(boe->reset_gpio)) 381 return dev_err_probe(dev, PTR_ERR(boe->reset_gpio), 382 "Failed to get reset-gpios\n"); 383 384 boe->dsi = dsi; 385 mipi_dsi_set_drvdata(dsi, boe); 386 387 dsi->lanes = 4; 388 dsi->format = MIPI_DSI_FMT_RGB888; 389 dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_NO_EOT_PACKET | 390 MIPI_DSI_MODE_VIDEO_SYNC_PULSE | 391 MIPI_DSI_CLOCK_NON_CONTINUOUS | 392 MIPI_DSI_MODE_LPM; 393 394 drm_panel_init(&boe->panel, dev, &boe_bf060y8m_aj0_panel_funcs, 395 DRM_MODE_CONNECTOR_DSI); 396 397 boe->panel.backlight = boe_bf060y8m_aj0_create_backlight(dsi); 398 if (IS_ERR(boe->panel.backlight)) 399 return dev_err_probe(dev, PTR_ERR(boe->panel.backlight), 400 "Failed to create backlight\n"); 401 402 drm_panel_add(&boe->panel); 403 404 ret = mipi_dsi_attach(dsi); 405 if (ret < 0) { 406 dev_err(dev, "Failed to attach to DSI host: %d\n", ret); 407 return ret; 408 } 409 410 return 0; 411 } 412 413 static void boe_bf060y8m_aj0_remove(struct mipi_dsi_device *dsi) 414 { 415 struct boe_bf060y8m_aj0 *boe = mipi_dsi_get_drvdata(dsi); 416 int ret; 417 418 ret = mipi_dsi_detach(dsi); 419 if (ret < 0) 420 dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret); 421 422 drm_panel_remove(&boe->panel); 423 } 424 425 static const struct of_device_id boe_bf060y8m_aj0_of_match[] = { 426 { .compatible = "boe,bf060y8m-aj0" }, 427 { /* sentinel */ } 428 }; 429 MODULE_DEVICE_TABLE(of, boe_bf060y8m_aj0_of_match); 430 431 static struct mipi_dsi_driver boe_bf060y8m_aj0_driver = { 432 .probe = boe_bf060y8m_aj0_probe, 433 .remove = boe_bf060y8m_aj0_remove, 434 .driver = { 435 .name = "panel-sw43404-boe-fhd-amoled", 436 .of_match_table = boe_bf060y8m_aj0_of_match, 437 }, 438 }; 439 module_mipi_dsi_driver(boe_bf060y8m_aj0_driver); 440 441 MODULE_AUTHOR("AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>"); 442 MODULE_DESCRIPTION("BOE BF060Y8M-AJ0 MIPI-DSI OLED panel"); 443 MODULE_LICENSE("GPL v2"); 444