ssdfb_spi.c revision 1.16
1 /* $NetBSD: ssdfb_spi.c,v 1.16 2025/09/10 04:33:46 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 2019 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Tobias Nygren. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: ssdfb_spi.c,v 1.16 2025/09/10 04:33:46 thorpej Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/device.h> 37 #include <sys/kernel.h> 38 #include <dev/wscons/wsdisplayvar.h> 39 #include <dev/rasops/rasops.h> 40 #include <dev/spi/spivar.h> 41 #include <dev/ic/ssdfbvar.h> 42 #include "opt_fdt.h" 43 #ifdef FDT 44 #include <dev/fdt/fdtvar.h> 45 #endif 46 47 struct bs_state { 48 uint8_t *base; 49 uint8_t *cur; 50 uint8_t mask; 51 }; 52 53 struct ssdfb_spi_softc { 54 struct ssdfb_softc sc; 55 struct spi_handle *sc_sh; 56 #ifdef FDT 57 struct fdtbus_gpio_pin *sc_gpio_dc; 58 struct fdtbus_gpio_pin *sc_gpio_res; 59 #endif 60 bool sc_3wiremode; 61 bool sc_late_dc_deassert; 62 uint8_t sc_padding_cmd; 63 }; 64 65 static int ssdfb_spi_match(device_t, cfdata_t, void *); 66 static void ssdfb_spi_attach(device_t, device_t, void *); 67 68 static int ssdfb_spi_cmd_3wire(void *, uint8_t *, size_t, bool); 69 static int ssdfb_spi_xfer_rect_3wire_ssd1322(void *, uint8_t, uint8_t, 70 uint8_t, uint8_t, uint8_t *, size_t, bool); 71 72 static int ssdfb_spi_cmd_4wire(void *, uint8_t *, size_t, bool); 73 static int ssdfb_spi_xfer_rect_4wire_sh1106(void *, uint8_t, uint8_t, 74 uint8_t, uint8_t, uint8_t *, size_t, bool); 75 static int ssdfb_spi_xfer_rect_4wire_ssd1306(void *, uint8_t, uint8_t, 76 uint8_t, uint8_t, uint8_t *, size_t, bool); 77 static int ssdfb_spi_xfer_rect_4wire_ssd1322(void *, uint8_t, uint8_t, 78 uint8_t, uint8_t, uint8_t *, size_t, bool); 79 static int ssdfb_spi_xfer_rect_4wire_ssd1353(void *, uint8_t, uint8_t, 80 uint8_t, uint8_t, uint8_t *, size_t, bool); 81 82 static void ssdfb_bitstream_init(struct bs_state *, uint8_t *); 83 static void ssdfb_bitstream_append(struct bs_state *, uint8_t, uint8_t); 84 static void ssdfb_bitstream_append_cmd(struct bs_state *, uint8_t); 85 static void ssdfb_bitstream_append_data(struct bs_state *, uint8_t *, 86 size_t); 87 static void ssdfb_bitstream_final(struct bs_state *, uint8_t); 88 89 CFATTACH_DECL_NEW(ssdfb_spi, sizeof(struct ssdfb_spi_softc), 90 ssdfb_spi_match, ssdfb_spi_attach, NULL, NULL); 91 92 static const struct device_compatible_entry compat_data[] = { 93 { .compat = "solomon,ssd1306", .value = SSDFB_PRODUCT_SSD1306_GENERIC }, 94 { .compat = "sino,sh1106", .value = SSDFB_PRODUCT_SH1106_GENERIC }, 95 { .compat = "solomon,ssd1322", .value = SSDFB_PRODUCT_SSD1322_GENERIC }, 96 { .compat = "solomon,ssd1353", .value = SSDFB_PRODUCT_SSD1353_GENERIC }, 97 { .compat = "dep160128a", .value = SSDFB_PRODUCT_DEP_160128A_RGB }, 98 DEVICE_COMPAT_EOL 99 }; 100 101 static int 102 ssdfb_spi_match(device_t parent, cfdata_t match, void *aux) 103 { 104 struct spi_attach_args *sa = aux; 105 106 return spi_compatible_match(sa, match, compat_data); 107 } 108 109 static void 110 ssdfb_spi_attach(device_t parent, device_t self, void *aux) 111 { 112 struct ssdfb_spi_softc *sc = device_private(self); 113 struct cfdata *cf = device_cfdata(self); 114 struct spi_attach_args *sa = aux; 115 int flags = cf->cf_flags; 116 int error; 117 118 sc->sc.sc_dev = self; 119 sc->sc_sh = sa->sa_handle; 120 sc->sc.sc_cookie = (void *)sc; 121 if ((flags & SSDFB_ATTACH_FLAG_PRODUCT_MASK) == SSDFB_PRODUCT_UNKNOWN) { 122 const struct device_compatible_entry *dce = 123 spi_compatible_lookup(sa, compat_data); 124 if (dce) 125 flags |= (int)dce->value; 126 else 127 flags |= SSDFB_PRODUCT_SSD1322_GENERIC; 128 } 129 130 /* 131 * SSD1306 and SSD1322 data sheets specify 100ns cycle time. 132 */ 133 error = spi_configure(self, sa->sa_handle, SPI_MODE_0, 134 SPI_FREQ_MHz(10)); 135 if (error) { 136 return; 137 } 138 139 /* 140 * Note on interface modes. 141 * 142 * 3 wire mode sends 9 bit sequences over the MOSI, MSB contains 143 * the bit that determines if the lower 8 bits are command or data. 144 * 145 * 4 wire mode sends 8 bit sequences and requires an auxiliary GPIO 146 * pin for the command/data bit. 147 */ 148 devhandle_t devhandle = device_handle(self); 149 switch (devhandle_type(devhandle)) { 150 #ifdef FDT 151 case DEVHANDLE_TYPE_OF: { 152 const int phandle = devhandle_to_of(devhandle); 153 sc->sc_gpio_dc = 154 fdtbus_gpio_acquire(phandle, "dc-gpio", GPIO_PIN_OUTPUT); 155 if (!sc->sc_gpio_dc) { 156 sc->sc_gpio_dc = fdtbus_gpio_acquire(phandle, 157 "cd-gpio", GPIO_PIN_OUTPUT); 158 } 159 sc->sc_3wiremode = (sc->sc_gpio_dc == NULL); 160 sc->sc_gpio_res = 161 fdtbus_gpio_acquire(phandle, "res-gpio", GPIO_PIN_OUTPUT); 162 if (sc->sc_gpio_res) { 163 fdtbus_gpio_write_raw(sc->sc_gpio_res, 0); 164 DELAY(100); 165 fdtbus_gpio_write_raw(sc->sc_gpio_res, 1); 166 DELAY(100); 167 } 168 break; 169 } 170 #endif /* FDT */ 171 default: 172 sc->sc_3wiremode = true; 173 break; 174 } 175 176 sc->sc.sc_cmd = sc->sc_3wiremode 177 ? ssdfb_spi_cmd_3wire 178 : ssdfb_spi_cmd_4wire; 179 180 switch (flags & SSDFB_ATTACH_FLAG_PRODUCT_MASK) { 181 case SSDFB_PRODUCT_SH1106_GENERIC: 182 sc->sc.sc_transfer_rect = sc->sc_3wiremode 183 ? NULL 184 : ssdfb_spi_xfer_rect_4wire_sh1106; 185 sc->sc_padding_cmd = SSDFB_CMD_NOP; 186 sc->sc_late_dc_deassert = true; 187 break; 188 case SSDFB_PRODUCT_SSD1306_GENERIC: 189 sc->sc.sc_transfer_rect = sc->sc_3wiremode 190 ? NULL 191 : ssdfb_spi_xfer_rect_4wire_ssd1306; 192 sc->sc_padding_cmd = SSDFB_CMD_NOP; 193 sc->sc_late_dc_deassert = true; 194 break; 195 case SSDFB_PRODUCT_SSD1322_GENERIC: 196 sc->sc.sc_transfer_rect = sc->sc_3wiremode 197 ? ssdfb_spi_xfer_rect_3wire_ssd1322 198 : ssdfb_spi_xfer_rect_4wire_ssd1322; 199 sc->sc_padding_cmd = SSD1322_CMD_WRITE_RAM; 200 break; 201 case SSDFB_PRODUCT_SSD1353_GENERIC: 202 case SSDFB_PRODUCT_DEP_160128A_RGB: 203 sc->sc.sc_transfer_rect = sc->sc_3wiremode 204 ? NULL /* not supported here */ 205 : ssdfb_spi_xfer_rect_4wire_ssd1353; 206 break; 207 } 208 209 if (!sc->sc.sc_transfer_rect) { 210 aprint_error(": sc_transfer_rect not implemented\n"); 211 return; 212 } 213 214 ssdfb_attach(&sc->sc, flags); 215 216 aprint_normal_dev(self, "%d-wire SPI interface\n", 217 sc->sc_3wiremode == true ? 3 : 4); 218 } 219 220 static int 221 ssdfb_spi_cmd_3wire(void *cookie, uint8_t *cmd, size_t len, bool usepoll) 222 { 223 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 224 uint8_t bitstream[16 * 9 / 8]; 225 struct bs_state s; 226 227 KASSERT(len > 0 && len <= 16); 228 ssdfb_bitstream_init(&s, bitstream); 229 ssdfb_bitstream_append_cmd(&s, *cmd); 230 cmd++; 231 len--; 232 ssdfb_bitstream_append_data(&s, cmd, len); 233 ssdfb_bitstream_final(&s, sc->sc_padding_cmd); 234 235 return spi_send(sc->sc_sh, s.cur - s.base, bitstream); 236 } 237 238 static int 239 ssdfb_spi_xfer_rect_3wire_ssd1322(void *cookie, uint8_t fromcol, uint8_t tocol, 240 uint8_t fromrow, uint8_t torow, uint8_t *p, size_t stride, bool usepoll) 241 { 242 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 243 uint8_t bitstream[128 * 9 / 8]; 244 struct bs_state s; 245 size_t rlen = (tocol + 1 - fromcol) * 2; 246 int error; 247 248 /* 249 * Unlike iic(4), there is no way to force spi(4) to use polling. 250 */ 251 if (usepoll && !cold) 252 return 0; 253 254 ssdfb_bitstream_init(&s, bitstream); 255 ssdfb_bitstream_append_cmd(&s, SSD1322_CMD_SET_ROW_ADDRESS); 256 ssdfb_bitstream_append_data(&s, &fromrow, 1); 257 ssdfb_bitstream_append_data(&s, &torow, 1); 258 ssdfb_bitstream_append_cmd(&s, SSD1322_CMD_SET_COLUMN_ADDRESS); 259 ssdfb_bitstream_append_data(&s, &fromcol, 1); 260 ssdfb_bitstream_append_data(&s, &tocol, 1); 261 ssdfb_bitstream_append_cmd(&s, SSD1322_CMD_WRITE_RAM); 262 ssdfb_bitstream_final(&s, sc->sc_padding_cmd); 263 error = spi_send(sc->sc_sh, s.cur - s.base, bitstream); 264 if (error) 265 return error; 266 267 KASSERT(rlen <= 128); 268 while (fromrow <= torow) { 269 ssdfb_bitstream_init(&s, bitstream); 270 ssdfb_bitstream_append_data(&s, p, rlen); 271 ssdfb_bitstream_final(&s, sc->sc_padding_cmd); 272 error = spi_send(sc->sc_sh, s.cur - s.base, bitstream); 273 if (error) 274 return error; 275 fromrow++; 276 p += stride; 277 } 278 279 return 0; 280 } 281 282 static void 283 ssdfb_bitstream_init(struct bs_state *s, uint8_t *dst) 284 { 285 s->base = s->cur = dst; 286 s->mask = 0x80; 287 } 288 289 static void 290 ssdfb_bitstream_append(struct bs_state *s, uint8_t b, uint8_t srcmask) 291 { 292 while(srcmask) { 293 if (b & srcmask) 294 *s->cur |= s->mask; 295 else 296 *s->cur &= ~s->mask; 297 srcmask >>= 1; 298 s->mask >>= 1; 299 if (!s->mask) { 300 s->mask = 0x80; 301 s->cur++; 302 } 303 } 304 } 305 306 static void 307 ssdfb_bitstream_append_cmd(struct bs_state *s, uint8_t cmd) 308 { 309 ssdfb_bitstream_append(s, 0, 1); 310 ssdfb_bitstream_append(s, cmd, 0x80); 311 } 312 313 static void 314 ssdfb_bitstream_append_data(struct bs_state *s, uint8_t *data, size_t len) 315 { 316 while(len--) { 317 ssdfb_bitstream_append(s, 1, 1); 318 ssdfb_bitstream_append(s, *data++, 0x80); 319 } 320 } 321 322 static void 323 ssdfb_bitstream_final(struct bs_state *s, uint8_t padding_cmd) 324 { 325 while (s->mask != 0x80) { 326 ssdfb_bitstream_append_cmd(s, padding_cmd); 327 } 328 } 329 330 static void 331 ssdfb_spi_4wire_set_dc(struct ssdfb_spi_softc *sc, int value) 332 { 333 #ifdef FDT 334 fdtbus_gpio_write_raw(sc->sc_gpio_dc, value); 335 #else 336 panic("ssdfb_spi_4wire_set_dc"); 337 #endif 338 } 339 340 static int 341 ssdfb_spi_cmd_4wire(void *cookie, uint8_t *cmd, size_t len, bool usepoll) 342 { 343 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 344 int error; 345 346 ssdfb_spi_4wire_set_dc(sc, 0); 347 error = spi_send(sc->sc_sh, 1, cmd); 348 if (error) 349 return error; 350 if (len > 1) { 351 if (!sc->sc_late_dc_deassert) 352 ssdfb_spi_4wire_set_dc(sc, 1); 353 len--; 354 cmd++; 355 error = spi_send(sc->sc_sh, len, cmd); 356 if (error) 357 return error; 358 } 359 360 return 0; 361 } 362 363 static int 364 ssdfb_spi_xfer_rect_4wire_sh1106(void *cookie, uint8_t fromcol, uint8_t tocol, 365 uint8_t frompage, uint8_t topage, uint8_t *p, size_t stride, bool usepoll) 366 { 367 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 368 size_t rlen = tocol + 1 - fromcol; 369 int error; 370 uint8_t cmd[] = { 371 SSDFB_CMD_SET_PAGE_START_ADDRESS_BASE + frompage, 372 SSDFB_CMD_SET_HIGHER_COLUMN_START_ADDRESS_BASE + (fromcol >> 4), 373 SSDFB_CMD_SET_LOWER_COLUMN_START_ADDRESS_BASE + (fromcol & 0xf) 374 }; 375 376 if (usepoll && !cold) 377 return 0; 378 379 while (frompage <= topage) { 380 cmd[0] = SSDFB_CMD_SET_PAGE_START_ADDRESS_BASE + frompage; 381 ssdfb_spi_4wire_set_dc(sc, 0); 382 error = spi_send(sc->sc_sh, sizeof(cmd), cmd); 383 if (error) 384 return error; 385 ssdfb_spi_4wire_set_dc(sc, 1); 386 error = spi_send(sc->sc_sh, rlen, p); 387 if (error) 388 return error; 389 frompage++; 390 p += stride; 391 } 392 393 return 0; 394 } 395 396 static int 397 ssdfb_spi_xfer_rect_4wire_ssd1306(void *cookie, uint8_t fromcol, uint8_t tocol, 398 uint8_t frompage, uint8_t topage, uint8_t *p, size_t stride, bool usepoll) 399 { 400 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 401 size_t rlen = tocol + 1 - fromcol; 402 int error; 403 uint8_t cmd[] = { 404 SSD1306_CMD_SET_MEMORY_ADDRESSING_MODE, 405 SSD1306_MEMORY_ADDRESSING_MODE_HORIZONTAL, 406 SSD1306_CMD_SET_COLUMN_ADDRESS, 407 fromcol, 408 tocol, 409 SSD1306_CMD_SET_PAGE_ADDRESS, 410 frompage, 411 topage 412 }; 413 414 if (usepoll && !cold) 415 return 0; 416 417 ssdfb_spi_4wire_set_dc(sc, 0); 418 error = spi_send(sc->sc_sh, sizeof(cmd), cmd); 419 if (error) 420 return error; 421 ssdfb_spi_4wire_set_dc(sc, 1); 422 423 while (frompage <= topage) { 424 error = spi_send(sc->sc_sh, rlen, p); 425 if (error) 426 return error; 427 frompage++; 428 p += stride; 429 } 430 431 return 0; 432 } 433 434 static int 435 ssdfb_spi_xfer_rect_4wire_ssd1322(void *cookie, uint8_t fromcol, uint8_t tocol, 436 uint8_t fromrow, uint8_t torow, uint8_t *p, size_t stride, bool usepoll) 437 { 438 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 439 size_t rlen = (tocol + 1 - fromcol) * 2; 440 int error; 441 uint8_t cmd; 442 uint8_t data[2]; 443 444 if (usepoll && !cold) 445 return 0; 446 447 ssdfb_spi_4wire_set_dc(sc, 0); 448 cmd = SSD1322_CMD_SET_ROW_ADDRESS; 449 error = spi_send(sc->sc_sh, sizeof(cmd), &cmd); 450 if (error) 451 return error; 452 ssdfb_spi_4wire_set_dc(sc, 1); 453 data[0] = fromrow; 454 data[1] = torow; 455 error = spi_send(sc->sc_sh, sizeof(data), data); 456 if (error) 457 return error; 458 459 ssdfb_spi_4wire_set_dc(sc, 0); 460 cmd = SSD1322_CMD_SET_COLUMN_ADDRESS; 461 error = spi_send(sc->sc_sh, sizeof(cmd), &cmd); 462 if (error) 463 return error; 464 ssdfb_spi_4wire_set_dc(sc, 1); 465 data[0] = fromcol; 466 data[1] = tocol; 467 error = spi_send(sc->sc_sh, sizeof(data), data); 468 if (error) 469 return error; 470 471 ssdfb_spi_4wire_set_dc(sc, 0); 472 cmd = SSD1322_CMD_WRITE_RAM; 473 error = spi_send(sc->sc_sh, sizeof(cmd), &cmd); 474 if (error) 475 return error; 476 477 ssdfb_spi_4wire_set_dc(sc, 1); 478 while (fromrow <= torow) { 479 error = spi_send(sc->sc_sh, rlen, p); 480 if (error) 481 return error; 482 fromrow++; 483 p += stride; 484 } 485 486 return 0; 487 } 488 489 static int 490 ssdfb_spi_xfer_rect_4wire_ssd1353(void *cookie, uint8_t fromcol, uint8_t tocol, 491 uint8_t fromrow, uint8_t torow, uint8_t *p, size_t stride, bool usepoll) 492 { 493 struct ssdfb_spi_softc *sc = (struct ssdfb_spi_softc *)cookie; 494 size_t rlen = (tocol + 1 - fromcol) * 3; 495 uint8_t bitstream[160 * 3]; 496 uint8_t *dstp, *srcp, *endp; 497 int error; 498 uint8_t cmd; 499 uint8_t data[2]; 500 501 if (usepoll && !cold) 502 return 0; 503 504 ssdfb_spi_4wire_set_dc(sc, 0); 505 cmd = SSD1353_CMD_SET_ROW_ADDRESS; 506 error = spi_send(sc->sc_sh, sizeof(cmd), &cmd); 507 if (error) 508 return error; 509 ssdfb_spi_4wire_set_dc(sc, 1); 510 data[0] = fromrow; 511 data[1] = torow; 512 if (sc->sc.sc_upsidedown) { 513 /* fix picture outside frame on 160x128 panel */ 514 data[0] += 132 - sc->sc.sc_p->p_height; 515 data[1] += 132 - sc->sc.sc_p->p_height; 516 } 517 error = spi_send(sc->sc_sh, sizeof(data), data); 518 if (error) 519 return error; 520 521 ssdfb_spi_4wire_set_dc(sc, 0); 522 cmd = SSD1353_CMD_SET_COLUMN_ADDRESS; 523 error = spi_send(sc->sc_sh, sizeof(cmd), &cmd); 524 if (error) 525 return error; 526 ssdfb_spi_4wire_set_dc(sc, 1); 527 data[0] = fromcol; 528 data[1] = tocol; 529 error = spi_send(sc->sc_sh, sizeof(data), data); 530 if (error) 531 return error; 532 533 ssdfb_spi_4wire_set_dc(sc, 0); 534 cmd = SSD1353_CMD_WRITE_RAM; 535 error = spi_send(sc->sc_sh, sizeof(cmd), &cmd); 536 if (error) 537 return error; 538 539 ssdfb_spi_4wire_set_dc(sc, 1); 540 KASSERT(rlen <= sizeof(bitstream)); 541 while (fromrow <= torow) { 542 /* downconvert each row from 32bpp rgba to 18bpp panel format */ 543 dstp = bitstream; 544 endp = dstp + rlen; 545 srcp = p; 546 while (dstp < endp) { 547 *dstp++ = (*srcp++) >> 2; 548 *dstp++ = (*srcp++) >> 2; 549 *dstp++ = (*srcp++) >> 2; 550 srcp++; 551 } 552 error = spi_send(sc->sc_sh, rlen, bitstream); 553 if (error) 554 return error; 555 fromrow++; 556 p += stride; 557 } 558 559 return 0; 560 } 561
Indexes created Mon Sep 22 05:09:51 GMT 2025