1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * DRM driver for Solomon SSD13xx OLED displays 4 * 5 * Copyright 2022 Red Hat Inc. 6 * Author: Javier Martinez Canillas <javierm@redhat.com> 7 * 8 * Based on drivers/video/fbdev/ssd1307fb.c 9 * Copyright 2012 Free Electrons 10 */ 11 12 #include <linux/backlight.h> 13 #include <linux/bitfield.h> 14 #include <linux/bits.h> 15 #include <linux/delay.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/property.h> 18 #include <linux/pwm.h> 19 #include <linux/regulator/consumer.h> 20 21 #include <drm/clients/drm_client_setup.h> 22 #include <drm/drm_atomic.h> 23 #include <drm/drm_atomic_helper.h> 24 #include <drm/drm_crtc_helper.h> 25 #include <drm/drm_damage_helper.h> 26 #include <drm/drm_edid.h> 27 #include <drm/drm_fbdev_shmem.h> 28 #include <drm/drm_format_helper.h> 29 #include <drm/drm_framebuffer.h> 30 #include <drm/drm_gem_atomic_helper.h> 31 #include <drm/drm_gem_framebuffer_helper.h> 32 #include <drm/drm_gem_shmem_helper.h> 33 #include <drm/drm_managed.h> 34 #include <drm/drm_modes.h> 35 #include <drm/drm_rect.h> 36 #include <drm/drm_probe_helper.h> 37 38 #include "ssd130x.h" 39 40 #define DRIVER_NAME "ssd130x" 41 #define DRIVER_DESC "DRM driver for Solomon SSD13xx OLED displays" 42 #define DRIVER_MAJOR 1 43 #define DRIVER_MINOR 0 44 45 #define SSD130X_PAGE_HEIGHT 8 46 47 #define SSD132X_SEGMENT_WIDTH 2 48 49 /* ssd13xx commands */ 50 #define SSD13XX_CONTRAST 0x81 51 #define SSD13XX_SET_SEG_REMAP 0xa0 52 #define SSD13XX_SET_MULTIPLEX_RATIO 0xa8 53 #define SSD13XX_DISPLAY_OFF 0xae 54 #define SSD13XX_DISPLAY_ON 0xaf 55 56 #define SSD13XX_SET_SEG_REMAP_MASK GENMASK(0, 0) 57 #define SSD13XX_SET_SEG_REMAP_SET(val) FIELD_PREP(SSD13XX_SET_SEG_REMAP_MASK, (val)) 58 59 /* ssd130x commands */ 60 #define SSD130X_PAGE_COL_START_LOW 0x00 61 #define SSD130X_PAGE_COL_START_HIGH 0x10 62 #define SSD130X_SET_ADDRESS_MODE 0x20 63 #define SSD130X_SET_COL_RANGE 0x21 64 #define SSD130X_SET_PAGE_RANGE 0x22 65 #define SSD130X_SET_LOOKUP_TABLE 0x91 66 #define SSD130X_CHARGE_PUMP 0x8d 67 #define SSD130X_START_PAGE_ADDRESS 0xb0 68 #define SSD130X_SET_COM_SCAN_DIR 0xc0 69 #define SSD130X_SET_DISPLAY_OFFSET 0xd3 70 #define SSD130X_SET_CLOCK_FREQ 0xd5 71 #define SSD130X_SET_AREA_COLOR_MODE 0xd8 72 #define SSD130X_SET_PRECHARGE_PERIOD 0xd9 73 #define SSD130X_SET_COM_PINS_CONFIG 0xda 74 #define SSD130X_SET_VCOMH 0xdb 75 76 /* ssd130x commands accessors */ 77 #define SSD130X_PAGE_COL_START_MASK GENMASK(3, 0) 78 #define SSD130X_PAGE_COL_START_HIGH_SET(val) FIELD_PREP(SSD130X_PAGE_COL_START_MASK, (val) >> 4) 79 #define SSD130X_PAGE_COL_START_LOW_SET(val) FIELD_PREP(SSD130X_PAGE_COL_START_MASK, (val)) 80 #define SSD130X_START_PAGE_ADDRESS_MASK GENMASK(2, 0) 81 #define SSD130X_START_PAGE_ADDRESS_SET(val) FIELD_PREP(SSD130X_START_PAGE_ADDRESS_MASK, (val)) 82 #define SSD130X_SET_COM_SCAN_DIR_MASK GENMASK(3, 3) 83 #define SSD130X_SET_COM_SCAN_DIR_SET(val) FIELD_PREP(SSD130X_SET_COM_SCAN_DIR_MASK, (val)) 84 #define SSD130X_SET_CLOCK_DIV_MASK GENMASK(3, 0) 85 #define SSD130X_SET_CLOCK_DIV_SET(val) FIELD_PREP(SSD130X_SET_CLOCK_DIV_MASK, (val)) 86 #define SSD130X_SET_CLOCK_FREQ_MASK GENMASK(7, 4) 87 #define SSD130X_SET_CLOCK_FREQ_SET(val) FIELD_PREP(SSD130X_SET_CLOCK_FREQ_MASK, (val)) 88 #define SSD130X_SET_PRECHARGE_PERIOD1_MASK GENMASK(3, 0) 89 #define SSD130X_SET_PRECHARGE_PERIOD1_SET(val) FIELD_PREP(SSD130X_SET_PRECHARGE_PERIOD1_MASK, (val)) 90 #define SSD130X_SET_PRECHARGE_PERIOD2_MASK GENMASK(7, 4) 91 #define SSD130X_SET_PRECHARGE_PERIOD2_SET(val) FIELD_PREP(SSD130X_SET_PRECHARGE_PERIOD2_MASK, (val)) 92 #define SSD130X_SET_COM_PINS_CONFIG1_MASK GENMASK(4, 4) 93 #define SSD130X_SET_COM_PINS_CONFIG1_SET(val) FIELD_PREP(SSD130X_SET_COM_PINS_CONFIG1_MASK, (val)) 94 #define SSD130X_SET_COM_PINS_CONFIG2_MASK GENMASK(5, 5) 95 #define SSD130X_SET_COM_PINS_CONFIG2_SET(val) FIELD_PREP(SSD130X_SET_COM_PINS_CONFIG2_MASK, (val)) 96 97 #define SSD130X_SET_ADDRESS_MODE_HORIZONTAL 0x00 98 #define SSD130X_SET_ADDRESS_MODE_VERTICAL 0x01 99 #define SSD130X_SET_ADDRESS_MODE_PAGE 0x02 100 101 #define SSD130X_SET_AREA_COLOR_MODE_ENABLE 0x1e 102 #define SSD130X_SET_AREA_COLOR_MODE_LOW_POWER 0x05 103 104 /* ssd132x commands */ 105 #define SSD132X_SET_COL_RANGE 0x15 106 #define SSD132X_SET_DEACTIVATE_SCROLL 0x2e 107 #define SSD132X_SET_ROW_RANGE 0x75 108 #define SSD132X_SET_DISPLAY_START 0xa1 109 #define SSD132X_SET_DISPLAY_OFFSET 0xa2 110 #define SSD132X_SET_DISPLAY_NORMAL 0xa4 111 #define SSD132X_SET_FUNCTION_SELECT_A 0xab 112 #define SSD132X_SET_PHASE_LENGTH 0xb1 113 #define SSD132X_SET_CLOCK_FREQ 0xb3 114 #define SSD132X_SET_GPIO 0xb5 115 #define SSD132X_SET_PRECHARGE_PERIOD 0xb6 116 #define SSD132X_SET_GRAY_SCALE_TABLE 0xb8 117 #define SSD132X_SELECT_DEFAULT_TABLE 0xb9 118 #define SSD132X_SET_PRECHARGE_VOLTAGE 0xbc 119 #define SSD130X_SET_VCOMH_VOLTAGE 0xbe 120 #define SSD132X_SET_FUNCTION_SELECT_B 0xd5 121 122 /* ssd133x commands */ 123 #define SSD133X_SET_COL_RANGE 0x15 124 #define SSD133X_SET_ROW_RANGE 0x75 125 #define SSD133X_CONTRAST_A 0x81 126 #define SSD133X_CONTRAST_B 0x82 127 #define SSD133X_CONTRAST_C 0x83 128 #define SSD133X_SET_MASTER_CURRENT 0x87 129 #define SSD132X_SET_PRECHARGE_A 0x8a 130 #define SSD132X_SET_PRECHARGE_B 0x8b 131 #define SSD132X_SET_PRECHARGE_C 0x8c 132 #define SSD133X_SET_DISPLAY_START 0xa1 133 #define SSD133X_SET_DISPLAY_OFFSET 0xa2 134 #define SSD133X_SET_DISPLAY_NORMAL 0xa4 135 #define SSD133X_SET_MASTER_CONFIG 0xad 136 #define SSD133X_POWER_SAVE_MODE 0xb0 137 #define SSD133X_PHASES_PERIOD 0xb1 138 #define SSD133X_SET_CLOCK_FREQ 0xb3 139 #define SSD133X_SET_PRECHARGE_VOLTAGE 0xbb 140 #define SSD133X_SET_VCOMH_VOLTAGE 0xbe 141 142 #define MAX_CONTRAST 255 143 144 const struct ssd130x_deviceinfo ssd130x_variants[] = { 145 [SH1106_ID] = { 146 .default_vcomh = 0x40, 147 .default_dclk_div = 1, 148 .default_dclk_frq = 5, 149 .default_width = 132, 150 .default_height = 64, 151 .page_mode_only = 1, 152 .family_id = SSD130X_FAMILY, 153 }, 154 [SSD1305_ID] = { 155 .default_vcomh = 0x34, 156 .default_dclk_div = 1, 157 .default_dclk_frq = 7, 158 .default_width = 132, 159 .default_height = 64, 160 .family_id = SSD130X_FAMILY, 161 }, 162 [SSD1306_ID] = { 163 .default_vcomh = 0x20, 164 .default_dclk_div = 1, 165 .default_dclk_frq = 8, 166 .need_chargepump = 1, 167 .default_width = 128, 168 .default_height = 64, 169 .family_id = SSD130X_FAMILY, 170 }, 171 [SSD1307_ID] = { 172 .default_vcomh = 0x20, 173 .default_dclk_div = 2, 174 .default_dclk_frq = 12, 175 .need_pwm = 1, 176 .default_width = 128, 177 .default_height = 39, 178 .family_id = SSD130X_FAMILY, 179 }, 180 [SSD1309_ID] = { 181 .default_vcomh = 0x34, 182 .default_dclk_div = 1, 183 .default_dclk_frq = 10, 184 .default_width = 128, 185 .default_height = 64, 186 .family_id = SSD130X_FAMILY, 187 }, 188 /* ssd132x family */ 189 [SSD1322_ID] = { 190 .default_width = 480, 191 .default_height = 128, 192 .family_id = SSD132X_FAMILY, 193 }, 194 [SSD1325_ID] = { 195 .default_width = 128, 196 .default_height = 80, 197 .family_id = SSD132X_FAMILY, 198 }, 199 [SSD1327_ID] = { 200 .default_width = 128, 201 .default_height = 128, 202 .family_id = SSD132X_FAMILY, 203 }, 204 /* ssd133x family */ 205 [SSD1331_ID] = { 206 .default_width = 96, 207 .default_height = 64, 208 .family_id = SSD133X_FAMILY, 209 } 210 }; 211 EXPORT_SYMBOL_NS_GPL(ssd130x_variants, "DRM_SSD130X"); 212 213 struct ssd130x_crtc_state { 214 struct drm_crtc_state base; 215 /* Buffer to store pixels in HW format and written to the panel */ 216 u8 *data_array; 217 }; 218 219 struct ssd130x_plane_state { 220 struct drm_shadow_plane_state base; 221 /* Intermediate buffer to convert pixels from XRGB8888 to HW format */ 222 u8 *buffer; 223 }; 224 225 static inline struct ssd130x_crtc_state *to_ssd130x_crtc_state(struct drm_crtc_state *state) 226 { 227 return container_of(state, struct ssd130x_crtc_state, base); 228 } 229 230 static inline struct ssd130x_plane_state *to_ssd130x_plane_state(struct drm_plane_state *state) 231 { 232 return container_of(state, struct ssd130x_plane_state, base.base); 233 } 234 235 static inline struct ssd130x_device *drm_to_ssd130x(struct drm_device *drm) 236 { 237 return container_of(drm, struct ssd130x_device, drm); 238 } 239 240 /* 241 * Helper to write data (SSD13XX_DATA) to the device. 242 */ 243 static int ssd130x_write_data(struct ssd130x_device *ssd130x, u8 *values, int count) 244 { 245 return regmap_bulk_write(ssd130x->regmap, SSD13XX_DATA, values, count); 246 } 247 248 /* 249 * Helper to write command (SSD13XX_COMMAND). The fist variadic argument 250 * is the command to write and the following are the command options. 251 * 252 * Note that the ssd13xx protocol requires each command and option to be 253 * written as a SSD13XX_COMMAND device register value. That is why a call 254 * to regmap_write(..., SSD13XX_COMMAND, ...) is done for each argument. 255 */ 256 static int ssd130x_write_cmd(struct ssd130x_device *ssd130x, int count, 257 /* u8 cmd, u8 option, ... */...) 258 { 259 va_list ap; 260 u8 value; 261 int ret; 262 263 va_start(ap, count); 264 265 do { 266 value = va_arg(ap, int); 267 ret = regmap_write(ssd130x->regmap, SSD13XX_COMMAND, value); 268 if (ret) 269 goto out_end; 270 } while (--count); 271 272 out_end: 273 va_end(ap); 274 275 return ret; 276 } 277 278 /* Set address range for horizontal/vertical addressing modes */ 279 static int ssd130x_set_col_range(struct ssd130x_device *ssd130x, 280 u8 col_start, u8 cols) 281 { 282 u8 col_end = col_start + cols - 1; 283 int ret; 284 285 if (col_start == ssd130x->col_start && col_end == ssd130x->col_end) 286 return 0; 287 288 ret = ssd130x_write_cmd(ssd130x, 3, SSD130X_SET_COL_RANGE, col_start, col_end); 289 if (ret < 0) 290 return ret; 291 292 ssd130x->col_start = col_start; 293 ssd130x->col_end = col_end; 294 return 0; 295 } 296 297 static int ssd130x_set_page_range(struct ssd130x_device *ssd130x, 298 u8 page_start, u8 pages) 299 { 300 u8 page_end = page_start + pages - 1; 301 int ret; 302 303 if (page_start == ssd130x->page_start && page_end == ssd130x->page_end) 304 return 0; 305 306 ret = ssd130x_write_cmd(ssd130x, 3, SSD130X_SET_PAGE_RANGE, page_start, page_end); 307 if (ret < 0) 308 return ret; 309 310 ssd130x->page_start = page_start; 311 ssd130x->page_end = page_end; 312 return 0; 313 } 314 315 /* Set page and column start address for page addressing mode */ 316 static int ssd130x_set_page_pos(struct ssd130x_device *ssd130x, 317 u8 page_start, u8 col_start) 318 { 319 int ret; 320 u32 page, col_low, col_high; 321 322 page = SSD130X_START_PAGE_ADDRESS | 323 SSD130X_START_PAGE_ADDRESS_SET(page_start); 324 col_low = SSD130X_PAGE_COL_START_LOW | 325 SSD130X_PAGE_COL_START_LOW_SET(col_start); 326 col_high = SSD130X_PAGE_COL_START_HIGH | 327 SSD130X_PAGE_COL_START_HIGH_SET(col_start); 328 ret = ssd130x_write_cmd(ssd130x, 3, page, col_low, col_high); 329 if (ret < 0) 330 return ret; 331 332 return 0; 333 } 334 335 static int ssd130x_pwm_enable(struct ssd130x_device *ssd130x) 336 { 337 struct device *dev = ssd130x->dev; 338 struct pwm_state pwmstate; 339 340 ssd130x->pwm = pwm_get(dev, NULL); 341 if (IS_ERR(ssd130x->pwm)) { 342 dev_err(dev, "Could not get PWM from firmware description!\n"); 343 return PTR_ERR(ssd130x->pwm); 344 } 345 346 pwm_init_state(ssd130x->pwm, &pwmstate); 347 pwm_set_relative_duty_cycle(&pwmstate, 50, 100); 348 pwm_apply_might_sleep(ssd130x->pwm, &pwmstate); 349 350 /* Enable the PWM */ 351 pwm_enable(ssd130x->pwm); 352 353 dev_dbg(dev, "Using PWM %s with a %lluns period.\n", 354 ssd130x->pwm->label, pwm_get_period(ssd130x->pwm)); 355 356 return 0; 357 } 358 359 static void ssd130x_reset(struct ssd130x_device *ssd130x) 360 { 361 if (!ssd130x->reset) 362 return; 363 364 /* Reset the screen */ 365 gpiod_set_value_cansleep(ssd130x->reset, 1); 366 udelay(4); 367 gpiod_set_value_cansleep(ssd130x->reset, 0); 368 udelay(4); 369 } 370 371 static int ssd130x_power_on(struct ssd130x_device *ssd130x) 372 { 373 struct device *dev = ssd130x->dev; 374 int ret; 375 376 ssd130x_reset(ssd130x); 377 378 ret = regulator_enable(ssd130x->vcc_reg); 379 if (ret) { 380 dev_err(dev, "Failed to enable VCC: %d\n", ret); 381 return ret; 382 } 383 384 if (ssd130x->device_info->need_pwm) { 385 ret = ssd130x_pwm_enable(ssd130x); 386 if (ret) { 387 dev_err(dev, "Failed to enable PWM: %d\n", ret); 388 regulator_disable(ssd130x->vcc_reg); 389 return ret; 390 } 391 } 392 393 return 0; 394 } 395 396 static void ssd130x_power_off(struct ssd130x_device *ssd130x) 397 { 398 pwm_disable(ssd130x->pwm); 399 pwm_put(ssd130x->pwm); 400 401 regulator_disable(ssd130x->vcc_reg); 402 } 403 404 static int ssd130x_init(struct ssd130x_device *ssd130x) 405 { 406 u32 precharge, dclk, com_invdir, compins, chargepump, seg_remap; 407 bool scan_mode; 408 int ret; 409 410 /* Set initial contrast */ 411 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_CONTRAST, ssd130x->contrast); 412 if (ret < 0) 413 return ret; 414 415 /* Set segment re-map */ 416 seg_remap = (SSD13XX_SET_SEG_REMAP | 417 SSD13XX_SET_SEG_REMAP_SET(ssd130x->seg_remap)); 418 ret = ssd130x_write_cmd(ssd130x, 1, seg_remap); 419 if (ret < 0) 420 return ret; 421 422 /* Set COM direction */ 423 com_invdir = (SSD130X_SET_COM_SCAN_DIR | 424 SSD130X_SET_COM_SCAN_DIR_SET(ssd130x->com_invdir)); 425 ret = ssd130x_write_cmd(ssd130x, 1, com_invdir); 426 if (ret < 0) 427 return ret; 428 429 /* Set multiplex ratio value */ 430 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_SET_MULTIPLEX_RATIO, ssd130x->height - 1); 431 if (ret < 0) 432 return ret; 433 434 /* set display offset value */ 435 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_DISPLAY_OFFSET, ssd130x->com_offset); 436 if (ret < 0) 437 return ret; 438 439 /* Set clock frequency */ 440 dclk = (SSD130X_SET_CLOCK_DIV_SET(ssd130x->dclk_div - 1) | 441 SSD130X_SET_CLOCK_FREQ_SET(ssd130x->dclk_frq)); 442 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_CLOCK_FREQ, dclk); 443 if (ret < 0) 444 return ret; 445 446 /* Set Area Color Mode ON/OFF & Low Power Display Mode */ 447 if (ssd130x->area_color_enable || ssd130x->low_power) { 448 u32 mode = 0; 449 450 if (ssd130x->area_color_enable) 451 mode |= SSD130X_SET_AREA_COLOR_MODE_ENABLE; 452 453 if (ssd130x->low_power) 454 mode |= SSD130X_SET_AREA_COLOR_MODE_LOW_POWER; 455 456 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_AREA_COLOR_MODE, mode); 457 if (ret < 0) 458 return ret; 459 } 460 461 /* Set precharge period in number of ticks from the internal clock */ 462 precharge = (SSD130X_SET_PRECHARGE_PERIOD1_SET(ssd130x->prechargep1) | 463 SSD130X_SET_PRECHARGE_PERIOD2_SET(ssd130x->prechargep2)); 464 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_PRECHARGE_PERIOD, precharge); 465 if (ret < 0) 466 return ret; 467 468 /* Set COM pins configuration */ 469 compins = BIT(1); 470 /* 471 * The COM scan mode field values are the inverse of the boolean DT 472 * property "solomon,com-seq". The value 0b means scan from COM0 to 473 * COM[N - 1] while 1b means scan from COM[N - 1] to COM0. 474 */ 475 scan_mode = !ssd130x->com_seq; 476 compins |= (SSD130X_SET_COM_PINS_CONFIG1_SET(scan_mode) | 477 SSD130X_SET_COM_PINS_CONFIG2_SET(ssd130x->com_lrremap)); 478 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_COM_PINS_CONFIG, compins); 479 if (ret < 0) 480 return ret; 481 482 /* Set VCOMH */ 483 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_VCOMH, ssd130x->vcomh); 484 if (ret < 0) 485 return ret; 486 487 /* Turn on the DC-DC Charge Pump */ 488 chargepump = BIT(4); 489 490 if (ssd130x->device_info->need_chargepump) 491 chargepump |= BIT(2); 492 493 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_CHARGE_PUMP, chargepump); 494 if (ret < 0) 495 return ret; 496 497 /* Set lookup table */ 498 if (ssd130x->lookup_table_set) { 499 int i; 500 501 ret = ssd130x_write_cmd(ssd130x, 1, SSD130X_SET_LOOKUP_TABLE); 502 if (ret < 0) 503 return ret; 504 505 for (i = 0; i < ARRAY_SIZE(ssd130x->lookup_table); i++) { 506 u8 val = ssd130x->lookup_table[i]; 507 508 if (val < 31 || val > 63) 509 dev_warn(ssd130x->dev, 510 "lookup table index %d value out of range 31 <= %d <= 63\n", 511 i, val); 512 ret = ssd130x_write_cmd(ssd130x, 1, val); 513 if (ret < 0) 514 return ret; 515 } 516 } 517 518 /* Switch to page addressing mode */ 519 if (ssd130x->page_address_mode) 520 return ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_ADDRESS_MODE, 521 SSD130X_SET_ADDRESS_MODE_PAGE); 522 523 /* Switch to horizontal addressing mode */ 524 return ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_ADDRESS_MODE, 525 SSD130X_SET_ADDRESS_MODE_HORIZONTAL); 526 } 527 528 static int ssd132x_init(struct ssd130x_device *ssd130x) 529 { 530 int ret; 531 532 /* Set initial contrast */ 533 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_CONTRAST, 0x80); 534 if (ret < 0) 535 return ret; 536 537 /* Set column start and end */ 538 ret = ssd130x_write_cmd(ssd130x, 3, SSD132X_SET_COL_RANGE, 0x00, 539 ssd130x->width / SSD132X_SEGMENT_WIDTH - 1); 540 if (ret < 0) 541 return ret; 542 543 /* Set row start and end */ 544 ret = ssd130x_write_cmd(ssd130x, 3, SSD132X_SET_ROW_RANGE, 0x00, ssd130x->height - 1); 545 if (ret < 0) 546 return ret; 547 /* 548 * Horizontal Address Increment 549 * Re-map for Column Address, Nibble and COM 550 * COM Split Odd Even 551 */ 552 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_SET_SEG_REMAP, 0x53); 553 if (ret < 0) 554 return ret; 555 556 /* Set display start and offset */ 557 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_DISPLAY_START, 0x00); 558 if (ret < 0) 559 return ret; 560 561 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_DISPLAY_OFFSET, 0x00); 562 if (ret < 0) 563 return ret; 564 565 /* Set display mode normal */ 566 ret = ssd130x_write_cmd(ssd130x, 1, SSD132X_SET_DISPLAY_NORMAL); 567 if (ret < 0) 568 return ret; 569 570 /* Set multiplex ratio value */ 571 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_SET_MULTIPLEX_RATIO, ssd130x->height - 1); 572 if (ret < 0) 573 return ret; 574 575 /* Set phase length */ 576 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_PHASE_LENGTH, 0x55); 577 if (ret < 0) 578 return ret; 579 580 /* Select default linear gray scale table */ 581 ret = ssd130x_write_cmd(ssd130x, 1, SSD132X_SELECT_DEFAULT_TABLE); 582 if (ret < 0) 583 return ret; 584 585 /* Set clock frequency */ 586 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_CLOCK_FREQ, 0x01); 587 if (ret < 0) 588 return ret; 589 590 /* Enable internal VDD regulator */ 591 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_FUNCTION_SELECT_A, 0x1); 592 if (ret < 0) 593 return ret; 594 595 /* Set pre-charge period */ 596 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_PRECHARGE_PERIOD, 0x01); 597 if (ret < 0) 598 return ret; 599 600 /* Set pre-charge voltage */ 601 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_PRECHARGE_VOLTAGE, 0x08); 602 if (ret < 0) 603 return ret; 604 605 /* Set VCOMH voltage */ 606 ret = ssd130x_write_cmd(ssd130x, 2, SSD130X_SET_VCOMH_VOLTAGE, 0x07); 607 if (ret < 0) 608 return ret; 609 610 /* Enable second pre-charge and internal VSL */ 611 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_FUNCTION_SELECT_B, 0x62); 612 if (ret < 0) 613 return ret; 614 615 return 0; 616 } 617 618 static int ssd133x_init(struct ssd130x_device *ssd130x) 619 { 620 int ret; 621 622 /* Set color A contrast */ 623 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_CONTRAST_A, 0x91); 624 if (ret < 0) 625 return ret; 626 627 /* Set color B contrast */ 628 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_CONTRAST_B, 0x50); 629 if (ret < 0) 630 return ret; 631 632 /* Set color C contrast */ 633 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_CONTRAST_C, 0x7d); 634 if (ret < 0) 635 return ret; 636 637 /* Set master current */ 638 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_MASTER_CURRENT, 0x06); 639 if (ret < 0) 640 return ret; 641 642 /* Set column start and end */ 643 ret = ssd130x_write_cmd(ssd130x, 3, SSD133X_SET_COL_RANGE, 0x00, ssd130x->width - 1); 644 if (ret < 0) 645 return ret; 646 647 /* Set row start and end */ 648 ret = ssd130x_write_cmd(ssd130x, 3, SSD133X_SET_ROW_RANGE, 0x00, ssd130x->height - 1); 649 if (ret < 0) 650 return ret; 651 652 /* 653 * Horizontal Address Increment 654 * Normal order SA,SB,SC (e.g. RGB) 655 * COM Split Odd Even 656 * 256 color format 657 */ 658 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_SET_SEG_REMAP, 0x20); 659 if (ret < 0) 660 return ret; 661 662 /* Set display start and offset */ 663 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_DISPLAY_START, 0x00); 664 if (ret < 0) 665 return ret; 666 667 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_DISPLAY_OFFSET, 0x00); 668 if (ret < 0) 669 return ret; 670 671 /* Set display mode normal */ 672 ret = ssd130x_write_cmd(ssd130x, 1, SSD133X_SET_DISPLAY_NORMAL); 673 if (ret < 0) 674 return ret; 675 676 /* Set multiplex ratio value */ 677 ret = ssd130x_write_cmd(ssd130x, 2, SSD13XX_SET_MULTIPLEX_RATIO, ssd130x->height - 1); 678 if (ret < 0) 679 return ret; 680 681 /* Set master configuration */ 682 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_MASTER_CONFIG, 0x8e); 683 if (ret < 0) 684 return ret; 685 686 /* Set power mode */ 687 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_POWER_SAVE_MODE, 0x0b); 688 if (ret < 0) 689 return ret; 690 691 /* Set Phase 1 and 2 period */ 692 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_PHASES_PERIOD, 0x31); 693 if (ret < 0) 694 return ret; 695 696 /* Set clock divider */ 697 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_CLOCK_FREQ, 0xf0); 698 if (ret < 0) 699 return ret; 700 701 /* Set pre-charge A */ 702 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_PRECHARGE_A, 0x64); 703 if (ret < 0) 704 return ret; 705 706 /* Set pre-charge B */ 707 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_PRECHARGE_B, 0x78); 708 if (ret < 0) 709 return ret; 710 711 /* Set pre-charge C */ 712 ret = ssd130x_write_cmd(ssd130x, 2, SSD132X_SET_PRECHARGE_C, 0x64); 713 if (ret < 0) 714 return ret; 715 716 /* Set pre-charge level */ 717 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_PRECHARGE_VOLTAGE, 0x3a); 718 if (ret < 0) 719 return ret; 720 721 /* Set VCOMH voltage */ 722 ret = ssd130x_write_cmd(ssd130x, 2, SSD133X_SET_VCOMH_VOLTAGE, 0x3e); 723 if (ret < 0) 724 return ret; 725 726 return 0; 727 } 728 729 static int ssd130x_update_rect(struct ssd130x_device *ssd130x, 730 struct drm_rect *rect, u8 *buf, 731 u8 *data_array) 732 { 733 unsigned int x = rect->x1; 734 unsigned int y = rect->y1; 735 unsigned int width = drm_rect_width(rect); 736 unsigned int height = drm_rect_height(rect); 737 unsigned int line_length = DIV_ROUND_UP(width, 8); 738 unsigned int page_height = SSD130X_PAGE_HEIGHT; 739 unsigned int pages = DIV_ROUND_UP(height, page_height); 740 struct drm_device *drm = &ssd130x->drm; 741 u32 array_idx = 0; 742 int ret, i, j, k; 743 744 drm_WARN_ONCE(drm, y % page_height != 0, "y must be aligned to screen page\n"); 745 746 /* 747 * The screen is divided in pages, each having a height of 8 748 * pixels, and the width of the screen. When sending a byte of 749 * data to the controller, it gives the 8 bits for the current 750 * column. I.e, the first byte are the 8 bits of the first 751 * column, then the 8 bits for the second column, etc. 752 * 753 * 754 * Representation of the screen, assuming it is 5 bits 755 * wide. Each letter-number combination is a bit that controls 756 * one pixel. 757 * 758 * A0 A1 A2 A3 A4 759 * B0 B1 B2 B3 B4 760 * C0 C1 C2 C3 C4 761 * D0 D1 D2 D3 D4 762 * E0 E1 E2 E3 E4 763 * F0 F1 F2 F3 F4 764 * G0 G1 G2 G3 G4 765 * H0 H1 H2 H3 H4 766 * 767 * If you want to update this screen, you need to send 5 bytes: 768 * (1) A0 B0 C0 D0 E0 F0 G0 H0 769 * (2) A1 B1 C1 D1 E1 F1 G1 H1 770 * (3) A2 B2 C2 D2 E2 F2 G2 H2 771 * (4) A3 B3 C3 D3 E3 F3 G3 H3 772 * (5) A4 B4 C4 D4 E4 F4 G4 H4 773 */ 774 775 if (!ssd130x->page_address_mode) { 776 u8 page_start; 777 778 /* Set address range for horizontal addressing mode */ 779 ret = ssd130x_set_col_range(ssd130x, ssd130x->col_offset + x, width); 780 if (ret < 0) 781 return ret; 782 783 page_start = ssd130x->page_offset + y / page_height; 784 ret = ssd130x_set_page_range(ssd130x, page_start, pages); 785 if (ret < 0) 786 return ret; 787 } 788 789 for (i = 0; i < pages; i++) { 790 int m = page_height; 791 792 /* Last page may be partial */ 793 if (page_height * (y / page_height + i + 1) > ssd130x->height) 794 m = ssd130x->height % page_height; 795 796 for (j = 0; j < width; j++) { 797 u8 data = 0; 798 799 for (k = 0; k < m; k++) { 800 u32 idx = (page_height * i + k) * line_length + j / 8; 801 u8 byte = buf[idx]; 802 u8 bit = (byte >> (j % 8)) & 1; 803 804 data |= bit << k; 805 } 806 data_array[array_idx++] = data; 807 } 808 809 /* 810 * In page addressing mode, the start address needs to be reset, 811 * and each page then needs to be written out separately. 812 */ 813 if (ssd130x->page_address_mode) { 814 ret = ssd130x_set_page_pos(ssd130x, 815 ssd130x->page_offset + i, 816 ssd130x->col_offset + x); 817 if (ret < 0) 818 return ret; 819 820 ret = ssd130x_write_data(ssd130x, data_array, width); 821 if (ret < 0) 822 return ret; 823 824 array_idx = 0; 825 } 826 } 827 828 /* Write out update in one go if we aren't using page addressing mode */ 829 if (!ssd130x->page_address_mode) 830 ret = ssd130x_write_data(ssd130x, data_array, width * pages); 831 832 return ret; 833 } 834 835 static int ssd132x_update_rect(struct ssd130x_device *ssd130x, 836 struct drm_rect *rect, u8 *buf, 837 u8 *data_array) 838 { 839 unsigned int x = rect->x1; 840 unsigned int y = rect->y1; 841 unsigned int segment_width = SSD132X_SEGMENT_WIDTH; 842 unsigned int width = drm_rect_width(rect); 843 unsigned int height = drm_rect_height(rect); 844 unsigned int columns = DIV_ROUND_UP(width, segment_width); 845 unsigned int rows = height; 846 struct drm_device *drm = &ssd130x->drm; 847 u32 array_idx = 0; 848 unsigned int i, j; 849 int ret; 850 851 drm_WARN_ONCE(drm, x % segment_width != 0, "x must be aligned to screen segment\n"); 852 853 /* 854 * The screen is divided in Segment and Common outputs, where 855 * COM0 to COM[N - 1] are the rows and SEG0 to SEG[M - 1] are 856 * the columns. 857 * 858 * Each Segment has a 4-bit pixel and each Common output has a 859 * row of pixels. When using the (default) horizontal address 860 * increment mode, each byte of data sent to the controller has 861 * two Segments (e.g: SEG0 and SEG1) that are stored in the lower 862 * and higher nibbles of a single byte representing one column. 863 * That is, the first byte are SEG0 (D0[3:0]) and SEG1 (D0[7:4]), 864 * the second byte are SEG2 (D1[3:0]) and SEG3 (D1[7:4]) and so on. 865 */ 866 867 /* Set column start and end */ 868 ret = ssd130x_write_cmd(ssd130x, 3, SSD132X_SET_COL_RANGE, x / segment_width, columns - 1); 869 if (ret < 0) 870 return ret; 871 872 /* Set row start and end */ 873 ret = ssd130x_write_cmd(ssd130x, 3, SSD132X_SET_ROW_RANGE, y, rows - 1); 874 if (ret < 0) 875 return ret; 876 877 for (i = 0; i < height; i++) { 878 /* Process pair of pixels and combine them into a single byte */ 879 for (j = 0; j < width; j += segment_width) { 880 u8 n1 = buf[i * width + j]; 881 u8 n2 = buf[i * width + j + 1]; 882 883 data_array[array_idx++] = (n2 & 0xf0) | (n1 >> 4); 884 } 885 } 886 887 /* Write out update in one go since horizontal addressing mode is used */ 888 ret = ssd130x_write_data(ssd130x, data_array, columns * rows); 889 890 return ret; 891 } 892 893 static int ssd133x_update_rect(struct ssd130x_device *ssd130x, 894 struct drm_rect *rect, u8 *data_array, 895 unsigned int pitch) 896 { 897 unsigned int x = rect->x1; 898 unsigned int y = rect->y1; 899 unsigned int columns = drm_rect_width(rect); 900 unsigned int rows = drm_rect_height(rect); 901 int ret; 902 903 /* 904 * The screen is divided in Segment and Common outputs, where 905 * COM0 to COM[N - 1] are the rows and SEG0 to SEG[M - 1] are 906 * the columns. 907 * 908 * Each Segment has a 8-bit pixel and each Common output has a 909 * row of pixels. When using the (default) horizontal address 910 * increment mode, each byte of data sent to the controller has 911 * a Segment (e.g: SEG0). 912 * 913 * When using the 256 color depth format, each pixel contains 3 914 * sub-pixels for color A, B and C. These have 3 bit, 3 bit and 915 * 2 bits respectively. 916 */ 917 918 /* Set column start and end */ 919 ret = ssd130x_write_cmd(ssd130x, 3, SSD133X_SET_COL_RANGE, x, columns - 1); 920 if (ret < 0) 921 return ret; 922 923 /* Set row start and end */ 924 ret = ssd130x_write_cmd(ssd130x, 3, SSD133X_SET_ROW_RANGE, y, rows - 1); 925 if (ret < 0) 926 return ret; 927 928 /* Write out update in one go since horizontal addressing mode is used */ 929 ret = ssd130x_write_data(ssd130x, data_array, pitch * rows); 930 931 return ret; 932 } 933 934 static void ssd130x_clear_screen(struct ssd130x_device *ssd130x, u8 *data_array) 935 { 936 unsigned int pages = DIV_ROUND_UP(ssd130x->height, SSD130X_PAGE_HEIGHT); 937 unsigned int width = ssd130x->width; 938 int ret, i; 939 940 if (!ssd130x->page_address_mode) { 941 memset(data_array, 0, width * pages); 942 943 /* Set address range for horizontal addressing mode */ 944 ret = ssd130x_set_col_range(ssd130x, ssd130x->col_offset, width); 945 if (ret < 0) 946 return; 947 948 ret = ssd130x_set_page_range(ssd130x, ssd130x->page_offset, pages); 949 if (ret < 0) 950 return; 951 952 /* Write out update in one go if we aren't using page addressing mode */ 953 ssd130x_write_data(ssd130x, data_array, width * pages); 954 } else { 955 /* 956 * In page addressing mode, the start address needs to be reset, 957 * and each page then needs to be written out separately. 958 */ 959 memset(data_array, 0, width); 960 961 for (i = 0; i < pages; i++) { 962 ret = ssd130x_set_page_pos(ssd130x, 963 ssd130x->page_offset + i, 964 ssd130x->col_offset); 965 if (ret < 0) 966 return; 967 968 ret = ssd130x_write_data(ssd130x, data_array, width); 969 if (ret < 0) 970 return; 971 } 972 } 973 } 974 975 static void ssd132x_clear_screen(struct ssd130x_device *ssd130x, u8 *data_array) 976 { 977 unsigned int columns = DIV_ROUND_UP(ssd130x->height, SSD132X_SEGMENT_WIDTH); 978 unsigned int height = ssd130x->height; 979 980 memset(data_array, 0, columns * height); 981 982 /* Write out update in one go since horizontal addressing mode is used */ 983 ssd130x_write_data(ssd130x, data_array, columns * height); 984 } 985 986 static void ssd133x_clear_screen(struct ssd130x_device *ssd130x, u8 *data_array) 987 { 988 const struct drm_format_info *fi = drm_format_info(DRM_FORMAT_RGB332); 989 unsigned int pitch; 990 991 if (!fi) 992 return; 993 994 pitch = drm_format_info_min_pitch(fi, 0, ssd130x->width); 995 996 memset(data_array, 0, pitch * ssd130x->height); 997 998 /* Write out update in one go since horizontal addressing mode is used */ 999 ssd130x_write_data(ssd130x, data_array, pitch * ssd130x->height); 1000 } 1001 1002 static int ssd130x_fb_blit_rect(struct drm_framebuffer *fb, 1003 const struct iosys_map *vmap, 1004 struct drm_rect *rect, 1005 u8 *buf, u8 *data_array, 1006 struct drm_format_conv_state *fmtcnv_state) 1007 { 1008 struct ssd130x_device *ssd130x = drm_to_ssd130x(fb->dev); 1009 struct iosys_map dst; 1010 unsigned int dst_pitch; 1011 int ret = 0; 1012 1013 /* Align y to display page boundaries */ 1014 rect->y1 = round_down(rect->y1, SSD130X_PAGE_HEIGHT); 1015 rect->y2 = min_t(unsigned int, round_up(rect->y2, SSD130X_PAGE_HEIGHT), ssd130x->height); 1016 1017 dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 8); 1018 1019 ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); 1020 if (ret) 1021 return ret; 1022 1023 iosys_map_set_vaddr(&dst, buf); 1024 drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state); 1025 1026 drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); 1027 1028 ssd130x_update_rect(ssd130x, rect, buf, data_array); 1029 1030 return ret; 1031 } 1032 1033 static int ssd132x_fb_blit_rect(struct drm_framebuffer *fb, 1034 const struct iosys_map *vmap, 1035 struct drm_rect *rect, u8 *buf, 1036 u8 *data_array, 1037 struct drm_format_conv_state *fmtcnv_state) 1038 { 1039 struct ssd130x_device *ssd130x = drm_to_ssd130x(fb->dev); 1040 unsigned int dst_pitch; 1041 struct iosys_map dst; 1042 int ret = 0; 1043 1044 /* Align x to display segment boundaries */ 1045 rect->x1 = round_down(rect->x1, SSD132X_SEGMENT_WIDTH); 1046 rect->x2 = min_t(unsigned int, round_up(rect->x2, SSD132X_SEGMENT_WIDTH), 1047 ssd130x->width); 1048 1049 dst_pitch = drm_rect_width(rect); 1050 1051 ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); 1052 if (ret) 1053 return ret; 1054 1055 iosys_map_set_vaddr(&dst, buf); 1056 drm_fb_xrgb8888_to_gray8(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state); 1057 1058 drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); 1059 1060 ssd132x_update_rect(ssd130x, rect, buf, data_array); 1061 1062 return ret; 1063 } 1064 1065 static int ssd133x_fb_blit_rect(struct drm_framebuffer *fb, 1066 const struct iosys_map *vmap, 1067 struct drm_rect *rect, u8 *data_array, 1068 struct drm_format_conv_state *fmtcnv_state) 1069 { 1070 struct ssd130x_device *ssd130x = drm_to_ssd130x(fb->dev); 1071 const struct drm_format_info *fi = drm_format_info(DRM_FORMAT_RGB332); 1072 unsigned int dst_pitch; 1073 struct iosys_map dst; 1074 int ret = 0; 1075 1076 if (!fi) 1077 return -EINVAL; 1078 1079 dst_pitch = drm_format_info_min_pitch(fi, 0, drm_rect_width(rect)); 1080 1081 ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); 1082 if (ret) 1083 return ret; 1084 1085 iosys_map_set_vaddr(&dst, data_array); 1086 drm_fb_xrgb8888_to_rgb332(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state); 1087 1088 drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); 1089 1090 ssd133x_update_rect(ssd130x, rect, data_array, dst_pitch); 1091 1092 return ret; 1093 } 1094 1095 static int ssd130x_primary_plane_atomic_check(struct drm_plane *plane, 1096 struct drm_atomic_state *state) 1097 { 1098 struct drm_device *drm = plane->dev; 1099 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1100 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1101 struct ssd130x_plane_state *ssd130x_state = to_ssd130x_plane_state(plane_state); 1102 struct drm_shadow_plane_state *shadow_plane_state = &ssd130x_state->base; 1103 struct drm_crtc *crtc = plane_state->crtc; 1104 struct drm_crtc_state *crtc_state = NULL; 1105 const struct drm_format_info *fi; 1106 unsigned int pitch; 1107 int ret; 1108 1109 if (crtc) 1110 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 1111 1112 ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state, 1113 DRM_PLANE_NO_SCALING, 1114 DRM_PLANE_NO_SCALING, 1115 false, false); 1116 if (ret) 1117 return ret; 1118 else if (!plane_state->visible) 1119 return 0; 1120 1121 fi = drm_format_info(DRM_FORMAT_R1); 1122 if (!fi) 1123 return -EINVAL; 1124 1125 pitch = drm_format_info_min_pitch(fi, 0, ssd130x->width); 1126 1127 if (plane_state->fb->format != fi) { 1128 void *buf; 1129 1130 /* format conversion necessary; reserve buffer */ 1131 buf = drm_format_conv_state_reserve(&shadow_plane_state->fmtcnv_state, 1132 pitch, GFP_KERNEL); 1133 if (!buf) 1134 return -ENOMEM; 1135 } 1136 1137 ssd130x_state->buffer = kcalloc(pitch, ssd130x->height, GFP_KERNEL); 1138 if (!ssd130x_state->buffer) 1139 return -ENOMEM; 1140 1141 return 0; 1142 } 1143 1144 static int ssd132x_primary_plane_atomic_check(struct drm_plane *plane, 1145 struct drm_atomic_state *state) 1146 { 1147 struct drm_device *drm = plane->dev; 1148 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1149 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1150 struct ssd130x_plane_state *ssd130x_state = to_ssd130x_plane_state(plane_state); 1151 struct drm_shadow_plane_state *shadow_plane_state = &ssd130x_state->base; 1152 struct drm_crtc *crtc = plane_state->crtc; 1153 struct drm_crtc_state *crtc_state = NULL; 1154 const struct drm_format_info *fi; 1155 unsigned int pitch; 1156 int ret; 1157 1158 if (crtc) 1159 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 1160 1161 ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state, 1162 DRM_PLANE_NO_SCALING, 1163 DRM_PLANE_NO_SCALING, 1164 false, false); 1165 if (ret) 1166 return ret; 1167 else if (!plane_state->visible) 1168 return 0; 1169 1170 fi = drm_format_info(DRM_FORMAT_R8); 1171 if (!fi) 1172 return -EINVAL; 1173 1174 pitch = drm_format_info_min_pitch(fi, 0, ssd130x->width); 1175 1176 if (plane_state->fb->format != fi) { 1177 void *buf; 1178 1179 /* format conversion necessary; reserve buffer */ 1180 buf = drm_format_conv_state_reserve(&shadow_plane_state->fmtcnv_state, 1181 pitch, GFP_KERNEL); 1182 if (!buf) 1183 return -ENOMEM; 1184 } 1185 1186 ssd130x_state->buffer = kcalloc(pitch, ssd130x->height, GFP_KERNEL); 1187 if (!ssd130x_state->buffer) 1188 return -ENOMEM; 1189 1190 return 0; 1191 } 1192 1193 static int ssd133x_primary_plane_atomic_check(struct drm_plane *plane, 1194 struct drm_atomic_state *state) 1195 { 1196 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1197 struct drm_crtc *crtc = plane_state->crtc; 1198 struct drm_crtc_state *crtc_state = NULL; 1199 int ret; 1200 1201 if (crtc) 1202 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 1203 1204 ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state, 1205 DRM_PLANE_NO_SCALING, 1206 DRM_PLANE_NO_SCALING, 1207 false, false); 1208 if (ret) 1209 return ret; 1210 else if (!plane_state->visible) 1211 return 0; 1212 1213 return 0; 1214 } 1215 1216 static void ssd130x_primary_plane_atomic_update(struct drm_plane *plane, 1217 struct drm_atomic_state *state) 1218 { 1219 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1220 struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); 1221 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); 1222 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc); 1223 struct ssd130x_crtc_state *ssd130x_crtc_state = to_ssd130x_crtc_state(crtc_state); 1224 struct ssd130x_plane_state *ssd130x_plane_state = to_ssd130x_plane_state(plane_state); 1225 struct drm_framebuffer *fb = plane_state->fb; 1226 struct drm_atomic_helper_damage_iter iter; 1227 struct drm_device *drm = plane->dev; 1228 struct drm_rect dst_clip; 1229 struct drm_rect damage; 1230 int idx; 1231 1232 if (!drm_dev_enter(drm, &idx)) 1233 return; 1234 1235 drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); 1236 drm_atomic_for_each_plane_damage(&iter, &damage) { 1237 dst_clip = plane_state->dst; 1238 1239 if (!drm_rect_intersect(&dst_clip, &damage)) 1240 continue; 1241 1242 ssd130x_fb_blit_rect(fb, &shadow_plane_state->data[0], &dst_clip, 1243 ssd130x_plane_state->buffer, 1244 ssd130x_crtc_state->data_array, 1245 &shadow_plane_state->fmtcnv_state); 1246 } 1247 1248 drm_dev_exit(idx); 1249 } 1250 1251 static void ssd132x_primary_plane_atomic_update(struct drm_plane *plane, 1252 struct drm_atomic_state *state) 1253 { 1254 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1255 struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); 1256 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); 1257 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc); 1258 struct ssd130x_crtc_state *ssd130x_crtc_state = to_ssd130x_crtc_state(crtc_state); 1259 struct ssd130x_plane_state *ssd130x_plane_state = to_ssd130x_plane_state(plane_state); 1260 struct drm_framebuffer *fb = plane_state->fb; 1261 struct drm_atomic_helper_damage_iter iter; 1262 struct drm_device *drm = plane->dev; 1263 struct drm_rect dst_clip; 1264 struct drm_rect damage; 1265 int idx; 1266 1267 if (!drm_dev_enter(drm, &idx)) 1268 return; 1269 1270 drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); 1271 drm_atomic_for_each_plane_damage(&iter, &damage) { 1272 dst_clip = plane_state->dst; 1273 1274 if (!drm_rect_intersect(&dst_clip, &damage)) 1275 continue; 1276 1277 ssd132x_fb_blit_rect(fb, &shadow_plane_state->data[0], &dst_clip, 1278 ssd130x_plane_state->buffer, 1279 ssd130x_crtc_state->data_array, 1280 &shadow_plane_state->fmtcnv_state); 1281 } 1282 1283 drm_dev_exit(idx); 1284 } 1285 1286 static void ssd133x_primary_plane_atomic_update(struct drm_plane *plane, 1287 struct drm_atomic_state *state) 1288 { 1289 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1290 struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); 1291 struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); 1292 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc); 1293 struct ssd130x_crtc_state *ssd130x_crtc_state = to_ssd130x_crtc_state(crtc_state); 1294 struct drm_framebuffer *fb = plane_state->fb; 1295 struct drm_atomic_helper_damage_iter iter; 1296 struct drm_device *drm = plane->dev; 1297 struct drm_rect dst_clip; 1298 struct drm_rect damage; 1299 int idx; 1300 1301 if (!drm_dev_enter(drm, &idx)) 1302 return; 1303 1304 drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); 1305 drm_atomic_for_each_plane_damage(&iter, &damage) { 1306 dst_clip = plane_state->dst; 1307 1308 if (!drm_rect_intersect(&dst_clip, &damage)) 1309 continue; 1310 1311 ssd133x_fb_blit_rect(fb, &shadow_plane_state->data[0], &dst_clip, 1312 ssd130x_crtc_state->data_array, 1313 &shadow_plane_state->fmtcnv_state); 1314 } 1315 1316 drm_dev_exit(idx); 1317 } 1318 1319 static void ssd130x_primary_plane_atomic_disable(struct drm_plane *plane, 1320 struct drm_atomic_state *state) 1321 { 1322 struct drm_device *drm = plane->dev; 1323 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1324 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1325 struct drm_crtc_state *crtc_state; 1326 struct ssd130x_crtc_state *ssd130x_crtc_state; 1327 int idx; 1328 1329 if (!plane_state->crtc) 1330 return; 1331 1332 crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc); 1333 ssd130x_crtc_state = to_ssd130x_crtc_state(crtc_state); 1334 1335 if (!drm_dev_enter(drm, &idx)) 1336 return; 1337 1338 ssd130x_clear_screen(ssd130x, ssd130x_crtc_state->data_array); 1339 1340 drm_dev_exit(idx); 1341 } 1342 1343 static void ssd132x_primary_plane_atomic_disable(struct drm_plane *plane, 1344 struct drm_atomic_state *state) 1345 { 1346 struct drm_device *drm = plane->dev; 1347 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1348 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1349 struct drm_crtc_state *crtc_state; 1350 struct ssd130x_crtc_state *ssd130x_crtc_state; 1351 int idx; 1352 1353 if (!plane_state->crtc) 1354 return; 1355 1356 crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc); 1357 ssd130x_crtc_state = to_ssd130x_crtc_state(crtc_state); 1358 1359 if (!drm_dev_enter(drm, &idx)) 1360 return; 1361 1362 ssd132x_clear_screen(ssd130x, ssd130x_crtc_state->data_array); 1363 1364 drm_dev_exit(idx); 1365 } 1366 1367 static void ssd133x_primary_plane_atomic_disable(struct drm_plane *plane, 1368 struct drm_atomic_state *state) 1369 { 1370 struct drm_device *drm = plane->dev; 1371 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1372 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); 1373 struct drm_crtc_state *crtc_state; 1374 struct ssd130x_crtc_state *ssd130x_crtc_state; 1375 int idx; 1376 1377 if (!plane_state->crtc) 1378 return; 1379 1380 crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc); 1381 ssd130x_crtc_state = to_ssd130x_crtc_state(crtc_state); 1382 1383 if (!drm_dev_enter(drm, &idx)) 1384 return; 1385 1386 ssd133x_clear_screen(ssd130x, ssd130x_crtc_state->data_array); 1387 1388 drm_dev_exit(idx); 1389 } 1390 1391 /* Called during init to allocate the plane's atomic state. */ 1392 static void ssd130x_primary_plane_reset(struct drm_plane *plane) 1393 { 1394 struct ssd130x_plane_state *ssd130x_state; 1395 1396 WARN_ON(plane->state); 1397 1398 ssd130x_state = kzalloc(sizeof(*ssd130x_state), GFP_KERNEL); 1399 if (!ssd130x_state) 1400 return; 1401 1402 __drm_gem_reset_shadow_plane(plane, &ssd130x_state->base); 1403 } 1404 1405 static struct drm_plane_state *ssd130x_primary_plane_duplicate_state(struct drm_plane *plane) 1406 { 1407 struct drm_shadow_plane_state *new_shadow_plane_state; 1408 struct ssd130x_plane_state *old_ssd130x_state; 1409 struct ssd130x_plane_state *ssd130x_state; 1410 1411 if (WARN_ON(!plane->state)) 1412 return NULL; 1413 1414 old_ssd130x_state = to_ssd130x_plane_state(plane->state); 1415 ssd130x_state = kmemdup(old_ssd130x_state, sizeof(*ssd130x_state), GFP_KERNEL); 1416 if (!ssd130x_state) 1417 return NULL; 1418 1419 /* The buffer is not duplicated and is allocated in .atomic_check */ 1420 ssd130x_state->buffer = NULL; 1421 1422 new_shadow_plane_state = &ssd130x_state->base; 1423 1424 __drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state); 1425 1426 return &new_shadow_plane_state->base; 1427 } 1428 1429 static void ssd130x_primary_plane_destroy_state(struct drm_plane *plane, 1430 struct drm_plane_state *state) 1431 { 1432 struct ssd130x_plane_state *ssd130x_state = to_ssd130x_plane_state(state); 1433 1434 kfree(ssd130x_state->buffer); 1435 1436 __drm_gem_destroy_shadow_plane_state(&ssd130x_state->base); 1437 1438 kfree(ssd130x_state); 1439 } 1440 1441 static const struct drm_plane_helper_funcs ssd130x_primary_plane_helper_funcs[] = { 1442 [SSD130X_FAMILY] = { 1443 DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, 1444 .atomic_check = ssd130x_primary_plane_atomic_check, 1445 .atomic_update = ssd130x_primary_plane_atomic_update, 1446 .atomic_disable = ssd130x_primary_plane_atomic_disable, 1447 }, 1448 [SSD132X_FAMILY] = { 1449 DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, 1450 .atomic_check = ssd132x_primary_plane_atomic_check, 1451 .atomic_update = ssd132x_primary_plane_atomic_update, 1452 .atomic_disable = ssd132x_primary_plane_atomic_disable, 1453 }, 1454 [SSD133X_FAMILY] = { 1455 DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, 1456 .atomic_check = ssd133x_primary_plane_atomic_check, 1457 .atomic_update = ssd133x_primary_plane_atomic_update, 1458 .atomic_disable = ssd133x_primary_plane_atomic_disable, 1459 } 1460 }; 1461 1462 static const struct drm_plane_funcs ssd130x_primary_plane_funcs = { 1463 .update_plane = drm_atomic_helper_update_plane, 1464 .disable_plane = drm_atomic_helper_disable_plane, 1465 .reset = ssd130x_primary_plane_reset, 1466 .atomic_duplicate_state = ssd130x_primary_plane_duplicate_state, 1467 .atomic_destroy_state = ssd130x_primary_plane_destroy_state, 1468 .destroy = drm_plane_cleanup, 1469 }; 1470 1471 static enum drm_mode_status ssd130x_crtc_mode_valid(struct drm_crtc *crtc, 1472 const struct drm_display_mode *mode) 1473 { 1474 struct ssd130x_device *ssd130x = drm_to_ssd130x(crtc->dev); 1475 1476 if (mode->hdisplay != ssd130x->mode.hdisplay && 1477 mode->vdisplay != ssd130x->mode.vdisplay) 1478 return MODE_ONE_SIZE; 1479 else if (mode->hdisplay != ssd130x->mode.hdisplay) 1480 return MODE_ONE_WIDTH; 1481 else if (mode->vdisplay != ssd130x->mode.vdisplay) 1482 return MODE_ONE_HEIGHT; 1483 1484 return MODE_OK; 1485 } 1486 1487 static int ssd130x_crtc_atomic_check(struct drm_crtc *crtc, 1488 struct drm_atomic_state *state) 1489 { 1490 struct drm_device *drm = crtc->dev; 1491 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1492 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 1493 struct ssd130x_crtc_state *ssd130x_state = to_ssd130x_crtc_state(crtc_state); 1494 unsigned int pages = DIV_ROUND_UP(ssd130x->height, SSD130X_PAGE_HEIGHT); 1495 int ret; 1496 1497 ret = drm_crtc_helper_atomic_check(crtc, state); 1498 if (ret) 1499 return ret; 1500 1501 ssd130x_state->data_array = kmalloc(ssd130x->width * pages, GFP_KERNEL); 1502 if (!ssd130x_state->data_array) 1503 return -ENOMEM; 1504 1505 return 0; 1506 } 1507 1508 static int ssd132x_crtc_atomic_check(struct drm_crtc *crtc, 1509 struct drm_atomic_state *state) 1510 { 1511 struct drm_device *drm = crtc->dev; 1512 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1513 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 1514 struct ssd130x_crtc_state *ssd130x_state = to_ssd130x_crtc_state(crtc_state); 1515 unsigned int columns = DIV_ROUND_UP(ssd130x->width, SSD132X_SEGMENT_WIDTH); 1516 int ret; 1517 1518 ret = drm_crtc_helper_atomic_check(crtc, state); 1519 if (ret) 1520 return ret; 1521 1522 ssd130x_state->data_array = kmalloc(columns * ssd130x->height, GFP_KERNEL); 1523 if (!ssd130x_state->data_array) 1524 return -ENOMEM; 1525 1526 return 0; 1527 } 1528 1529 static int ssd133x_crtc_atomic_check(struct drm_crtc *crtc, 1530 struct drm_atomic_state *state) 1531 { 1532 struct drm_device *drm = crtc->dev; 1533 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1534 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 1535 struct ssd130x_crtc_state *ssd130x_state = to_ssd130x_crtc_state(crtc_state); 1536 const struct drm_format_info *fi = drm_format_info(DRM_FORMAT_RGB332); 1537 unsigned int pitch; 1538 int ret; 1539 1540 if (!fi) 1541 return -EINVAL; 1542 1543 ret = drm_crtc_helper_atomic_check(crtc, state); 1544 if (ret) 1545 return ret; 1546 1547 pitch = drm_format_info_min_pitch(fi, 0, ssd130x->width); 1548 1549 ssd130x_state->data_array = kmalloc(pitch * ssd130x->height, GFP_KERNEL); 1550 if (!ssd130x_state->data_array) 1551 return -ENOMEM; 1552 1553 return 0; 1554 } 1555 1556 /* Called during init to allocate the CRTC's atomic state. */ 1557 static void ssd130x_crtc_reset(struct drm_crtc *crtc) 1558 { 1559 struct ssd130x_crtc_state *ssd130x_state; 1560 1561 WARN_ON(crtc->state); 1562 1563 ssd130x_state = kzalloc(sizeof(*ssd130x_state), GFP_KERNEL); 1564 if (!ssd130x_state) 1565 return; 1566 1567 __drm_atomic_helper_crtc_reset(crtc, &ssd130x_state->base); 1568 } 1569 1570 static struct drm_crtc_state *ssd130x_crtc_duplicate_state(struct drm_crtc *crtc) 1571 { 1572 struct ssd130x_crtc_state *old_ssd130x_state; 1573 struct ssd130x_crtc_state *ssd130x_state; 1574 1575 if (WARN_ON(!crtc->state)) 1576 return NULL; 1577 1578 old_ssd130x_state = to_ssd130x_crtc_state(crtc->state); 1579 ssd130x_state = kmemdup(old_ssd130x_state, sizeof(*ssd130x_state), GFP_KERNEL); 1580 if (!ssd130x_state) 1581 return NULL; 1582 1583 /* The buffer is not duplicated and is allocated in .atomic_check */ 1584 ssd130x_state->data_array = NULL; 1585 1586 __drm_atomic_helper_crtc_duplicate_state(crtc, &ssd130x_state->base); 1587 1588 return &ssd130x_state->base; 1589 } 1590 1591 static void ssd130x_crtc_destroy_state(struct drm_crtc *crtc, 1592 struct drm_crtc_state *state) 1593 { 1594 struct ssd130x_crtc_state *ssd130x_state = to_ssd130x_crtc_state(state); 1595 1596 kfree(ssd130x_state->data_array); 1597 1598 __drm_atomic_helper_crtc_destroy_state(state); 1599 1600 kfree(ssd130x_state); 1601 } 1602 1603 /* 1604 * The CRTC is always enabled. Screen updates are performed by 1605 * the primary plane's atomic_update function. Disabling clears 1606 * the screen in the primary plane's atomic_disable function. 1607 */ 1608 static const struct drm_crtc_helper_funcs ssd130x_crtc_helper_funcs[] = { 1609 [SSD130X_FAMILY] = { 1610 .mode_valid = ssd130x_crtc_mode_valid, 1611 .atomic_check = ssd130x_crtc_atomic_check, 1612 }, 1613 [SSD132X_FAMILY] = { 1614 .mode_valid = ssd130x_crtc_mode_valid, 1615 .atomic_check = ssd132x_crtc_atomic_check, 1616 }, 1617 [SSD133X_FAMILY] = { 1618 .mode_valid = ssd130x_crtc_mode_valid, 1619 .atomic_check = ssd133x_crtc_atomic_check, 1620 }, 1621 }; 1622 1623 static const struct drm_crtc_funcs ssd130x_crtc_funcs = { 1624 .reset = ssd130x_crtc_reset, 1625 .destroy = drm_crtc_cleanup, 1626 .set_config = drm_atomic_helper_set_config, 1627 .page_flip = drm_atomic_helper_page_flip, 1628 .atomic_duplicate_state = ssd130x_crtc_duplicate_state, 1629 .atomic_destroy_state = ssd130x_crtc_destroy_state, 1630 }; 1631 1632 static void ssd130x_encoder_atomic_enable(struct drm_encoder *encoder, 1633 struct drm_atomic_state *state) 1634 { 1635 struct drm_device *drm = encoder->dev; 1636 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1637 int ret; 1638 1639 ret = ssd130x_power_on(ssd130x); 1640 if (ret) 1641 return; 1642 1643 ret = ssd130x_init(ssd130x); 1644 if (ret) 1645 goto power_off; 1646 1647 ssd130x_write_cmd(ssd130x, 1, SSD13XX_DISPLAY_ON); 1648 1649 backlight_enable(ssd130x->bl_dev); 1650 1651 return; 1652 1653 power_off: 1654 ssd130x_power_off(ssd130x); 1655 return; 1656 } 1657 1658 static void ssd132x_encoder_atomic_enable(struct drm_encoder *encoder, 1659 struct drm_atomic_state *state) 1660 { 1661 struct drm_device *drm = encoder->dev; 1662 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1663 int ret; 1664 1665 ret = ssd130x_power_on(ssd130x); 1666 if (ret) 1667 return; 1668 1669 ret = ssd132x_init(ssd130x); 1670 if (ret) 1671 goto power_off; 1672 1673 ssd130x_write_cmd(ssd130x, 1, SSD13XX_DISPLAY_ON); 1674 1675 backlight_enable(ssd130x->bl_dev); 1676 1677 return; 1678 1679 power_off: 1680 ssd130x_power_off(ssd130x); 1681 } 1682 1683 static void ssd133x_encoder_atomic_enable(struct drm_encoder *encoder, 1684 struct drm_atomic_state *state) 1685 { 1686 struct drm_device *drm = encoder->dev; 1687 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1688 int ret; 1689 1690 ret = ssd130x_power_on(ssd130x); 1691 if (ret) 1692 return; 1693 1694 ret = ssd133x_init(ssd130x); 1695 if (ret) 1696 goto power_off; 1697 1698 ssd130x_write_cmd(ssd130x, 1, SSD13XX_DISPLAY_ON); 1699 1700 backlight_enable(ssd130x->bl_dev); 1701 1702 return; 1703 1704 power_off: 1705 ssd130x_power_off(ssd130x); 1706 } 1707 1708 static void ssd130x_encoder_atomic_disable(struct drm_encoder *encoder, 1709 struct drm_atomic_state *state) 1710 { 1711 struct drm_device *drm = encoder->dev; 1712 struct ssd130x_device *ssd130x = drm_to_ssd130x(drm); 1713 1714 backlight_disable(ssd130x->bl_dev); 1715 1716 ssd130x_write_cmd(ssd130x, 1, SSD13XX_DISPLAY_OFF); 1717 1718 ssd130x_power_off(ssd130x); 1719 } 1720 1721 static const struct drm_encoder_helper_funcs ssd130x_encoder_helper_funcs[] = { 1722 [SSD130X_FAMILY] = { 1723 .atomic_enable = ssd130x_encoder_atomic_enable, 1724 .atomic_disable = ssd130x_encoder_atomic_disable, 1725 }, 1726 [SSD132X_FAMILY] = { 1727 .atomic_enable = ssd132x_encoder_atomic_enable, 1728 .atomic_disable = ssd130x_encoder_atomic_disable, 1729 }, 1730 [SSD133X_FAMILY] = { 1731 .atomic_enable = ssd133x_encoder_atomic_enable, 1732 .atomic_disable = ssd130x_encoder_atomic_disable, 1733 } 1734 }; 1735 1736 static const struct drm_encoder_funcs ssd130x_encoder_funcs = { 1737 .destroy = drm_encoder_cleanup, 1738 }; 1739 1740 static int ssd130x_connector_get_modes(struct drm_connector *connector) 1741 { 1742 struct ssd130x_device *ssd130x = drm_to_ssd130x(connector->dev); 1743 struct drm_display_mode *mode; 1744 struct device *dev = ssd130x->dev; 1745 1746 mode = drm_mode_duplicate(connector->dev, &ssd130x->mode); 1747 if (!mode) { 1748 dev_err(dev, "Failed to duplicated mode\n"); 1749 return 0; 1750 } 1751 1752 drm_mode_probed_add(connector, mode); 1753 drm_set_preferred_mode(connector, mode->hdisplay, mode->vdisplay); 1754 1755 /* There is only a single mode */ 1756 return 1; 1757 } 1758 1759 static const struct drm_connector_helper_funcs ssd130x_connector_helper_funcs = { 1760 .get_modes = ssd130x_connector_get_modes, 1761 }; 1762 1763 static const struct drm_connector_funcs ssd130x_connector_funcs = { 1764 .reset = drm_atomic_helper_connector_reset, 1765 .fill_modes = drm_helper_probe_single_connector_modes, 1766 .destroy = drm_connector_cleanup, 1767 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 1768 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 1769 }; 1770 1771 static const struct drm_mode_config_funcs ssd130x_mode_config_funcs = { 1772 .fb_create = drm_gem_fb_create_with_dirty, 1773 .atomic_check = drm_atomic_helper_check, 1774 .atomic_commit = drm_atomic_helper_commit, 1775 }; 1776 1777 static const uint32_t ssd130x_formats[] = { 1778 DRM_FORMAT_XRGB8888, 1779 }; 1780 1781 DEFINE_DRM_GEM_FOPS(ssd130x_fops); 1782 1783 static const struct drm_driver ssd130x_drm_driver = { 1784 DRM_GEM_SHMEM_DRIVER_OPS, 1785 DRM_FBDEV_SHMEM_DRIVER_OPS, 1786 .name = DRIVER_NAME, 1787 .desc = DRIVER_DESC, 1788 .major = DRIVER_MAJOR, 1789 .minor = DRIVER_MINOR, 1790 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, 1791 .fops = &ssd130x_fops, 1792 }; 1793 1794 static int ssd130x_update_bl(struct backlight_device *bdev) 1795 { 1796 struct ssd130x_device *ssd130x = bl_get_data(bdev); 1797 int brightness = backlight_get_brightness(bdev); 1798 int ret; 1799 1800 ssd130x->contrast = brightness; 1801 1802 ret = ssd130x_write_cmd(ssd130x, 1, SSD13XX_CONTRAST); 1803 if (ret < 0) 1804 return ret; 1805 1806 ret = ssd130x_write_cmd(ssd130x, 1, ssd130x->contrast); 1807 if (ret < 0) 1808 return ret; 1809 1810 return 0; 1811 } 1812 1813 static const struct backlight_ops ssd130xfb_bl_ops = { 1814 .update_status = ssd130x_update_bl, 1815 }; 1816 1817 static void ssd130x_parse_properties(struct ssd130x_device *ssd130x) 1818 { 1819 struct device *dev = ssd130x->dev; 1820 1821 if (device_property_read_u32(dev, "solomon,width", &ssd130x->width)) 1822 ssd130x->width = ssd130x->device_info->default_width; 1823 1824 if (device_property_read_u32(dev, "solomon,height", &ssd130x->height)) 1825 ssd130x->height = ssd130x->device_info->default_height; 1826 1827 if (device_property_read_u32(dev, "solomon,page-offset", &ssd130x->page_offset)) 1828 ssd130x->page_offset = 1; 1829 1830 if (device_property_read_u32(dev, "solomon,col-offset", &ssd130x->col_offset)) 1831 ssd130x->col_offset = 0; 1832 1833 if (device_property_read_u32(dev, "solomon,com-offset", &ssd130x->com_offset)) 1834 ssd130x->com_offset = 0; 1835 1836 if (device_property_read_u32(dev, "solomon,prechargep1", &ssd130x->prechargep1)) 1837 ssd130x->prechargep1 = 2; 1838 1839 if (device_property_read_u32(dev, "solomon,prechargep2", &ssd130x->prechargep2)) 1840 ssd130x->prechargep2 = 2; 1841 1842 if (!device_property_read_u8_array(dev, "solomon,lookup-table", 1843 ssd130x->lookup_table, 1844 ARRAY_SIZE(ssd130x->lookup_table))) 1845 ssd130x->lookup_table_set = 1; 1846 1847 ssd130x->seg_remap = !device_property_read_bool(dev, "solomon,segment-no-remap"); 1848 ssd130x->com_seq = device_property_read_bool(dev, "solomon,com-seq"); 1849 ssd130x->com_lrremap = device_property_read_bool(dev, "solomon,com-lrremap"); 1850 ssd130x->com_invdir = device_property_read_bool(dev, "solomon,com-invdir"); 1851 ssd130x->area_color_enable = 1852 device_property_read_bool(dev, "solomon,area-color-enable"); 1853 ssd130x->low_power = device_property_read_bool(dev, "solomon,low-power"); 1854 1855 ssd130x->contrast = 127; 1856 ssd130x->vcomh = ssd130x->device_info->default_vcomh; 1857 1858 /* Setup display timing */ 1859 if (device_property_read_u32(dev, "solomon,dclk-div", &ssd130x->dclk_div)) 1860 ssd130x->dclk_div = ssd130x->device_info->default_dclk_div; 1861 if (device_property_read_u32(dev, "solomon,dclk-frq", &ssd130x->dclk_frq)) 1862 ssd130x->dclk_frq = ssd130x->device_info->default_dclk_frq; 1863 } 1864 1865 static int ssd130x_init_modeset(struct ssd130x_device *ssd130x) 1866 { 1867 enum ssd130x_family_ids family_id = ssd130x->device_info->family_id; 1868 struct drm_display_mode *mode = &ssd130x->mode; 1869 struct device *dev = ssd130x->dev; 1870 struct drm_device *drm = &ssd130x->drm; 1871 unsigned long max_width, max_height; 1872 struct drm_plane *primary_plane; 1873 struct drm_crtc *crtc; 1874 struct drm_encoder *encoder; 1875 struct drm_connector *connector; 1876 int ret; 1877 1878 /* 1879 * Modesetting 1880 */ 1881 1882 ret = drmm_mode_config_init(drm); 1883 if (ret) { 1884 dev_err(dev, "DRM mode config init failed: %d\n", ret); 1885 return ret; 1886 } 1887 1888 mode->type = DRM_MODE_TYPE_DRIVER; 1889 mode->clock = 1; 1890 mode->hdisplay = mode->htotal = ssd130x->width; 1891 mode->hsync_start = mode->hsync_end = ssd130x->width; 1892 mode->vdisplay = mode->vtotal = ssd130x->height; 1893 mode->vsync_start = mode->vsync_end = ssd130x->height; 1894 mode->width_mm = 27; 1895 mode->height_mm = 27; 1896 1897 max_width = max_t(unsigned long, mode->hdisplay, DRM_SHADOW_PLANE_MAX_WIDTH); 1898 max_height = max_t(unsigned long, mode->vdisplay, DRM_SHADOW_PLANE_MAX_HEIGHT); 1899 1900 drm->mode_config.min_width = mode->hdisplay; 1901 drm->mode_config.max_width = max_width; 1902 drm->mode_config.min_height = mode->vdisplay; 1903 drm->mode_config.max_height = max_height; 1904 drm->mode_config.preferred_depth = 24; 1905 drm->mode_config.funcs = &ssd130x_mode_config_funcs; 1906 1907 /* Primary plane */ 1908 1909 primary_plane = &ssd130x->primary_plane; 1910 ret = drm_universal_plane_init(drm, primary_plane, 0, &ssd130x_primary_plane_funcs, 1911 ssd130x_formats, ARRAY_SIZE(ssd130x_formats), 1912 NULL, DRM_PLANE_TYPE_PRIMARY, NULL); 1913 if (ret) { 1914 dev_err(dev, "DRM primary plane init failed: %d\n", ret); 1915 return ret; 1916 } 1917 1918 drm_plane_helper_add(primary_plane, &ssd130x_primary_plane_helper_funcs[family_id]); 1919 1920 drm_plane_enable_fb_damage_clips(primary_plane); 1921 1922 /* CRTC */ 1923 1924 crtc = &ssd130x->crtc; 1925 ret = drm_crtc_init_with_planes(drm, crtc, primary_plane, NULL, 1926 &ssd130x_crtc_funcs, NULL); 1927 if (ret) { 1928 dev_err(dev, "DRM crtc init failed: %d\n", ret); 1929 return ret; 1930 } 1931 1932 drm_crtc_helper_add(crtc, &ssd130x_crtc_helper_funcs[family_id]); 1933 1934 /* Encoder */ 1935 1936 encoder = &ssd130x->encoder; 1937 ret = drm_encoder_init(drm, encoder, &ssd130x_encoder_funcs, 1938 DRM_MODE_ENCODER_NONE, NULL); 1939 if (ret) { 1940 dev_err(dev, "DRM encoder init failed: %d\n", ret); 1941 return ret; 1942 } 1943 1944 drm_encoder_helper_add(encoder, &ssd130x_encoder_helper_funcs[family_id]); 1945 1946 encoder->possible_crtcs = drm_crtc_mask(crtc); 1947 1948 /* Connector */ 1949 1950 connector = &ssd130x->connector; 1951 ret = drm_connector_init(drm, connector, &ssd130x_connector_funcs, 1952 DRM_MODE_CONNECTOR_Unknown); 1953 if (ret) { 1954 dev_err(dev, "DRM connector init failed: %d\n", ret); 1955 return ret; 1956 } 1957 1958 drm_connector_helper_add(connector, &ssd130x_connector_helper_funcs); 1959 1960 ret = drm_connector_attach_encoder(connector, encoder); 1961 if (ret) { 1962 dev_err(dev, "DRM attach connector to encoder failed: %d\n", ret); 1963 return ret; 1964 } 1965 1966 drm_mode_config_reset(drm); 1967 1968 return 0; 1969 } 1970 1971 static int ssd130x_get_resources(struct ssd130x_device *ssd130x) 1972 { 1973 struct device *dev = ssd130x->dev; 1974 1975 ssd130x->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); 1976 if (IS_ERR(ssd130x->reset)) 1977 return dev_err_probe(dev, PTR_ERR(ssd130x->reset), 1978 "Failed to get reset gpio\n"); 1979 1980 ssd130x->vcc_reg = devm_regulator_get(dev, "vcc"); 1981 if (IS_ERR(ssd130x->vcc_reg)) 1982 return dev_err_probe(dev, PTR_ERR(ssd130x->vcc_reg), 1983 "Failed to get VCC regulator\n"); 1984 1985 return 0; 1986 } 1987 1988 struct ssd130x_device *ssd130x_probe(struct device *dev, struct regmap *regmap) 1989 { 1990 struct ssd130x_device *ssd130x; 1991 struct backlight_device *bl; 1992 struct drm_device *drm; 1993 int ret; 1994 1995 ssd130x = devm_drm_dev_alloc(dev, &ssd130x_drm_driver, 1996 struct ssd130x_device, drm); 1997 if (IS_ERR(ssd130x)) 1998 return ERR_PTR(dev_err_probe(dev, PTR_ERR(ssd130x), 1999 "Failed to allocate DRM device\n")); 2000 2001 drm = &ssd130x->drm; 2002 2003 ssd130x->dev = dev; 2004 ssd130x->regmap = regmap; 2005 ssd130x->device_info = device_get_match_data(dev); 2006 2007 if (ssd130x->device_info->page_mode_only) 2008 ssd130x->page_address_mode = 1; 2009 2010 ssd130x_parse_properties(ssd130x); 2011 2012 ret = ssd130x_get_resources(ssd130x); 2013 if (ret) 2014 return ERR_PTR(ret); 2015 2016 bl = devm_backlight_device_register(dev, dev_name(dev), dev, ssd130x, 2017 &ssd130xfb_bl_ops, NULL); 2018 if (IS_ERR(bl)) 2019 return ERR_PTR(dev_err_probe(dev, PTR_ERR(bl), 2020 "Unable to register backlight device\n")); 2021 2022 bl->props.brightness = ssd130x->contrast; 2023 bl->props.max_brightness = MAX_CONTRAST; 2024 ssd130x->bl_dev = bl; 2025 2026 ret = ssd130x_init_modeset(ssd130x); 2027 if (ret) 2028 return ERR_PTR(ret); 2029 2030 ret = drm_dev_register(drm, 0); 2031 if (ret) 2032 return ERR_PTR(dev_err_probe(dev, ret, "DRM device register failed\n")); 2033 2034 drm_client_setup(drm, NULL); 2035 2036 return ssd130x; 2037 } 2038 EXPORT_SYMBOL_GPL(ssd130x_probe); 2039 2040 void ssd130x_remove(struct ssd130x_device *ssd130x) 2041 { 2042 drm_dev_unplug(&ssd130x->drm); 2043 drm_atomic_helper_shutdown(&ssd130x->drm); 2044 } 2045 EXPORT_SYMBOL_GPL(ssd130x_remove); 2046 2047 void ssd130x_shutdown(struct ssd130x_device *ssd130x) 2048 { 2049 drm_atomic_helper_shutdown(&ssd130x->drm); 2050 } 2051 EXPORT_SYMBOL_GPL(ssd130x_shutdown); 2052 2053 MODULE_DESCRIPTION(DRIVER_DESC); 2054 MODULE_AUTHOR("Javier Martinez Canillas <javierm@redhat.com>"); 2055 MODULE_LICENSE("GPL v2"); 2056