/* $OpenBSD: ssdfb.c,v 1.11 2020/05/25 09:55:48 jsg Exp $ */ /* * Copyright (c) 2018 Patrick Wildt * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define SSDFB_SET_LOWER_COLUMN_START_ADDRESS 0x00 #define SSDFB_SET_HIGHER_COLUMN_START_ADDRESS 0x10 #define SSDFB_SET_MEMORY_ADDRESSING_MODE 0x20 #define SSDFB_SET_COLUMN_RANGE 0x21 #define SSDFB_SET_PAGE_RANGE 0x22 #define SSDFB_SET_START_LINE 0x40 #define SSDFB_SET_CONTRAST_CONTROL 0x81 #define SSDFB_CHARGE_PUMP 0x8d #define SSDFB_SET_COLUMN_DIRECTION_NORMAL 0xa0 #define SSDFB_SET_COLUMN_DIRECTION_REVERSE 0xa1 #define SSDFB_SET_MULTIPLEX_RATIO 0xa8 #define SSDFB_SET_COM_OUTPUT_DIRECTION_NORMAL 0xc0 #define SSDFB_SET_COM_OUTPUT_DIRECTION_REMAP 0xc8 #define SSDFB_ENTIRE_DISPLAY_ON 0xa4 #define SSDFB_SET_DISPLAY_MODE_NORMAL 0xa6 #define SSDFB_SET_DISPLAY_MODE_INVERS 0xa7 #define SSDFB_SET_DISPLAY_OFF 0xae #define SSDFB_SET_DISPLAY_ON 0xaf #define SSDFB_SET_DISPLAY_OFFSET 0xd3 #define SSDFB_SET_DISPLAY_CLOCK_DIVIDE_RATIO 0xd5 #define SSDFB_SET_PRE_CHARGE_PERIOD 0xd9 #define SSDFB_SET_COM_PINS_HARD_CONF 0xda #define SSDFB_SET_VCOM_DESELECT_LEVEL 0xdb #define SSDFB_SET_PAGE_START_ADDRESS 0xb0 #define SSDFB_I2C_COMMAND 0x00 #define SSDFB_I2C_DATA 0x40 struct ssdfb_softc { struct device sc_dev; int sc_node; int sc_width; int sc_height; int sc_pgoff; uint8_t *sc_fb; size_t sc_fbsize; struct rasops_info sc_rinfo; struct wsdisplay_emulops sc_riops; int (*sc_ri_do_cursor)(struct rasops_info *); uint8_t sc_brightness; int sc_mode; uint8_t sc_column_range[2]; uint8_t sc_page_range[2]; /* I2C */ i2c_tag_t sc_i2c_tag; i2c_addr_t sc_i2c_addr; /* SPI */ spi_tag_t sc_spi_tag; struct spi_config sc_spi_conf; uint32_t *sc_gpio; size_t sc_gpiolen; int sc_cd; void (*sc_write_command)(struct ssdfb_softc *, char *, size_t); void (*sc_write_data)(struct ssdfb_softc *, char *, size_t); }; int ssdfb_i2c_match(struct device *, void *, void *); void ssdfb_i2c_attach(struct device *, struct device *, void *); int ssdfb_i2c_detach(struct device *, int); void ssdfb_i2c_write_command(struct ssdfb_softc *, char *, size_t); void ssdfb_i2c_write_data(struct ssdfb_softc *, char *, size_t); int ssdfb_spi_match(struct device *, void *, void *); void ssdfb_spi_attach(struct device *, struct device *, void *); int ssdfb_spi_detach(struct device *, int); void ssdfb_spi_write_command(struct ssdfb_softc *, char *, size_t); void ssdfb_spi_write_data(struct ssdfb_softc *, char *, size_t); void ssdfb_attach(struct ssdfb_softc *); int ssdfb_detach(struct ssdfb_softc *, int); void ssdfb_write_command(struct ssdfb_softc *, char *, size_t); void ssdfb_write_data(struct ssdfb_softc *, char *, size_t); void ssdfb_init(struct ssdfb_softc *); void ssdfb_update(void *); void ssdfb_partial(struct ssdfb_softc *, uint32_t, uint32_t, uint32_t, uint32_t); void ssdfb_set_range(struct ssdfb_softc *, uint8_t, uint8_t, uint8_t, uint8_t); int ssdfb_ioctl(void *, u_long, caddr_t, int, struct proc *); paddr_t ssdfb_mmap(void *, off_t, int); int ssdfb_alloc_screen(void *, const struct wsscreen_descr *, void **, int *, int *, uint32_t *); void ssdfb_free_screen(void *, void *); int ssdfb_show_screen(void *, void *, int, void (*cb) (void *, int, int), void *); int ssdfb_list_font(void *, struct wsdisplay_font *); int ssdfb_load_font(void *, void *, struct wsdisplay_font *); int ssdfb_putchar(void *, int, int, u_int, uint32_t); int ssdfb_copycols(void *, int, int, int, int); int ssdfb_erasecols(void *, int, int, int, uint32_t); int ssdfb_copyrows(void *, int, int, int); int ssdfb_eraserows(void *, int, int, uint32_t); int ssdfb_do_cursor(struct rasops_info *); struct cfattach ssdfb_i2c_ca = { sizeof(struct ssdfb_softc), ssdfb_i2c_match, ssdfb_i2c_attach, ssdfb_i2c_detach, }; struct cfattach ssdfb_spi_ca = { sizeof(struct ssdfb_softc), ssdfb_spi_match, ssdfb_spi_attach, ssdfb_spi_detach, }; struct cfdriver ssdfb_cd = { NULL, "ssdfb", DV_DULL }; struct wsscreen_descr ssdfb_std_descr = { "std" }; const struct wsscreen_descr *ssdfb_descrs[] = { &ssdfb_std_descr }; const struct wsscreen_list ssdfb_screen_list = { nitems(ssdfb_descrs), ssdfb_descrs }; struct wsdisplay_accessops ssdfb_accessops = { .ioctl = ssdfb_ioctl, .mmap = ssdfb_mmap, .alloc_screen = ssdfb_alloc_screen, .free_screen = ssdfb_free_screen, .show_screen = ssdfb_show_screen, .load_font = ssdfb_load_font, .list_font = ssdfb_list_font }; int ssdfb_i2c_match(struct device *parent, void *match, void *aux) { struct i2c_attach_args *ia = aux; if (strcmp(ia->ia_name, "solomon,ssd1306fb-i2c") == 0 || strcmp(ia->ia_name, "solomon,ssd1309fb-i2c") == 0) return 1; return 0; } void ssdfb_i2c_attach(struct device *parent, struct device *self, void *aux) { struct ssdfb_softc *sc = (struct ssdfb_softc *)self; struct i2c_attach_args *ia = aux; sc->sc_i2c_tag = ia->ia_tag; sc->sc_i2c_addr = ia->ia_addr; sc->sc_node = *(int *)ia->ia_cookie; sc->sc_write_command = ssdfb_i2c_write_command; sc->sc_write_data = ssdfb_i2c_write_data; ssdfb_attach(sc); } int ssdfb_i2c_detach(struct device *self, int flags) { struct ssdfb_softc *sc = (struct ssdfb_softc *)self; ssdfb_detach(sc, flags); return 0; } int ssdfb_spi_match(struct device *parent, void *match, void *aux) { struct spi_attach_args *sa = aux; if (strcmp(sa->sa_name, "solomon,ssd1309fb-spi") == 0) return 1; return 0; } void ssdfb_spi_attach(struct device *parent, struct device *self, void *aux) { struct ssdfb_softc *sc = (struct ssdfb_softc *)self; struct spi_attach_args *sa = aux; ssize_t len; sc->sc_spi_tag = sa->sa_tag; sc->sc_node = *(int *)sa->sa_cookie; sc->sc_spi_conf.sc_bpw = 8; sc->sc_spi_conf.sc_freq = 1000 * 1000; sc->sc_spi_conf.sc_cs = OF_getpropint(sc->sc_node, "reg", 0); if (OF_getproplen(sc->sc_node, "spi-cpol") == 0) sc->sc_spi_conf.sc_flags |= SPI_CONFIG_CPOL; if (OF_getproplen(sc->sc_node, "spi-cpha") == 0) sc->sc_spi_conf.sc_flags |= SPI_CONFIG_CPHA; if (OF_getproplen(sc->sc_node, "spi-cs-high") == 0) sc->sc_spi_conf.sc_flags |= SPI_CONFIG_CS_HIGH; len = OF_getproplen(sc->sc_node, "cd-gpio"); if (len <= 0) return; sc->sc_gpio = malloc(len, M_DEVBUF, M_WAITOK); OF_getpropintarray(sc->sc_node, "cd-gpio", sc->sc_gpio, len); sc->sc_gpiolen = len; gpio_controller_config_pin(sc->sc_gpio, GPIO_CONFIG_OUTPUT); gpio_controller_set_pin(sc->sc_gpio, 0); sc->sc_write_command = ssdfb_spi_write_command; sc->sc_write_data = ssdfb_spi_write_data; ssdfb_attach(sc); } int ssdfb_spi_detach(struct device *self, int flags) { struct ssdfb_softc *sc = (struct ssdfb_softc *)self; ssdfb_detach(sc, flags); free(sc->sc_gpio, M_DEVBUF, sc->sc_gpiolen); return 0; } void ssdfb_attach(struct ssdfb_softc *sc) { struct wsemuldisplaydev_attach_args aa; struct rasops_info *ri; uint32_t *gpio; ssize_t len; pinctrl_byname(sc->sc_node, "default"); len = OF_getproplen(sc->sc_node, "reset-gpios"); if (len > 0) { gpio = malloc(len, M_DEVBUF, M_WAITOK); OF_getpropintarray(sc->sc_node, "reset-gpios", gpio, len); gpio_controller_config_pin(gpio, GPIO_CONFIG_OUTPUT); gpio_controller_set_pin(gpio, 1); delay(100 * 1000); gpio_controller_set_pin(gpio, 0); delay(1000 * 1000); free(gpio, M_DEVBUF, len); } sc->sc_width = OF_getpropint(sc->sc_node, "solomon,width", 96); sc->sc_height = OF_getpropint(sc->sc_node, "solomon,height", 16); sc->sc_pgoff = OF_getpropint(sc->sc_node, "solomon,page-offset", 1); sc->sc_fbsize = round_page((sc->sc_width * sc->sc_height) / 8); sc->sc_fb = malloc(sc->sc_fbsize, M_DEVBUF, M_WAITOK | M_ZERO); sc->sc_brightness = 223; ri = &sc->sc_rinfo; ri->ri_bits = malloc(sc->sc_fbsize, M_DEVBUF, M_WAITOK | M_ZERO); ri->ri_bs = mallocarray(sc->sc_width * sc->sc_height, sizeof(struct wsdisplay_charcell), M_DEVBUF, M_WAITOK | M_ZERO); ri->ri_flg = RI_CLEAR | RI_VCONS; ri->ri_depth = 1; ri->ri_width = sc->sc_width; ri->ri_height = sc->sc_height; ri->ri_stride = ri->ri_width * ri->ri_depth / 8; ri->ri_hw = sc; rasops_init(ri, sc->sc_height, sc->sc_width); ssdfb_std_descr.ncols = ri->ri_cols; ssdfb_std_descr.nrows = ri->ri_rows; ssdfb_std_descr.textops = &ri->ri_ops; ssdfb_std_descr.fontwidth = ri->ri_font->fontwidth; ssdfb_std_descr.fontheight = ri->ri_font->fontheight; ssdfb_std_descr.capabilities = ri->ri_caps; sc->sc_riops.putchar = ri->ri_putchar; sc->sc_riops.copycols = ri->ri_copycols; sc->sc_riops.erasecols = ri->ri_erasecols; sc->sc_riops.copyrows = ri->ri_copyrows; sc->sc_riops.eraserows = ri->ri_eraserows; sc->sc_ri_do_cursor = ri->ri_do_cursor; ri->ri_putchar = ssdfb_putchar; ri->ri_copycols = ssdfb_copycols; ri->ri_erasecols = ssdfb_erasecols; ri->ri_copyrows = ssdfb_copyrows; ri->ri_eraserows = ssdfb_eraserows; ri->ri_do_cursor = ssdfb_do_cursor; printf(": %dx%d, %dbpp\n", ri->ri_width, ri->ri_height, ri->ri_depth); memset(&aa, 0, sizeof(aa)); aa.console = 0; aa.scrdata = &ssdfb_screen_list; aa.accessops = &ssdfb_accessops; aa.accesscookie = sc; aa.defaultscreens = 0; config_found_sm(&sc->sc_dev, &aa, wsemuldisplaydevprint, wsemuldisplaydevsubmatch); ssdfb_init(sc); } int ssdfb_detach(struct ssdfb_softc *sc, int flags) { struct rasops_info *ri = &sc->sc_rinfo; free(ri->ri_bs, M_DEVBUF, sc->sc_width * sc->sc_height * sizeof(struct wsdisplay_charcell)); free(ri->ri_bits, M_DEVBUF, sc->sc_fbsize); free(sc->sc_fb, M_DEVBUF, sc->sc_fbsize); return 0; } void ssdfb_init(struct ssdfb_softc *sc) { uint8_t reg[2]; reg[0] = SSDFB_SET_DISPLAY_OFF; ssdfb_write_command(sc, reg, 1); reg[0] = SSDFB_SET_MEMORY_ADDRESSING_MODE; reg[1] = 0x00; /* Horizontal Addressing Mode */ ssdfb_write_command(sc, reg, 2); reg[0] = SSDFB_SET_PAGE_START_ADDRESS; ssdfb_write_command(sc, reg, 1); ssdfb_set_range(sc, 0, sc->sc_width - 1, 0, (sc->sc_height / 8) - 1); if (OF_is_compatible(sc->sc_node, "solomon,ssd1309fb-i2c") || OF_is_compatible(sc->sc_node, "solomon,ssd1309fb-spi")) { reg[0] = SSDFB_SET_DISPLAY_CLOCK_DIVIDE_RATIO; reg[1] = 0xa0; ssdfb_write_command(sc, reg, 2); } if (OF_is_compatible(sc->sc_node, "solomon,ssd1306fb-i2c")) { reg[0] = SSDFB_SET_DISPLAY_CLOCK_DIVIDE_RATIO; reg[1] = 0x80; ssdfb_write_command(sc, reg, 2); } reg[0] = SSDFB_SET_MULTIPLEX_RATIO; reg[1] = 0x3f; ssdfb_write_command(sc, reg, 2); reg[0] = SSDFB_SET_DISPLAY_OFFSET; reg[1] = OF_getpropint(sc->sc_node, "solomon,com-offset", 0); ssdfb_write_command(sc, reg, 2); reg[0] = SSDFB_SET_START_LINE | 0x00; ssdfb_write_command(sc, reg, 1); reg[0] = SSDFB_SET_COLUMN_DIRECTION_NORMAL; if (OF_getproplen(sc->sc_node, "solomon,com-invdir") == 0) reg[0] = SSDFB_SET_COLUMN_DIRECTION_REVERSE; ssdfb_write_command(sc, reg, 1); reg[0] = SSDFB_SET_COM_OUTPUT_DIRECTION_REMAP; if (OF_getproplen(sc->sc_node, "solomon,segment-no-remap") == 0) reg[0] = SSDFB_SET_COM_OUTPUT_DIRECTION_NORMAL; ssdfb_write_command(sc, reg, 1); reg[0] = SSDFB_SET_COM_PINS_HARD_CONF; reg[1] = 0x12; if (OF_getproplen(sc->sc_node, "solomon,com-seq") == 0) reg[1] &= ~(1 << 4); if (OF_getproplen(sc->sc_node, "solomon,com-lrremap") == 0) reg[1] |= 1 << 5; ssdfb_write_command(sc, reg, 2); reg[0] = SSDFB_SET_CONTRAST_CONTROL; reg[1] = sc->sc_brightness; ssdfb_write_command(sc, reg, 2); reg[0] = SSDFB_SET_PRE_CHARGE_PERIOD; reg[1] = (OF_getpropint(sc->sc_node, "solomon,prechargep1", 2) & 0xf) << 0; reg[1] |= (OF_getpropint(sc->sc_node, "solomon,prechargep2", 2) & 0xf) << 4; ssdfb_write_command(sc, reg, 2); if (OF_is_compatible(sc->sc_node, "solomon,ssd1309fb-i2c") || OF_is_compatible(sc->sc_node, "solomon,ssd1309fb-spi")) { reg[0] = SSDFB_SET_VCOM_DESELECT_LEVEL; reg[1] = 0x34; ssdfb_write_command(sc, reg, 2); } if (OF_is_compatible(sc->sc_node, "solomon,ssd1306fb-i2c")) { reg[0] = SSDFB_SET_VCOM_DESELECT_LEVEL; reg[1] = 0x20; ssdfb_write_command(sc, reg, 2); } reg[0] = SSDFB_CHARGE_PUMP; reg[1] = 0x10; if (OF_is_compatible(sc->sc_node, "solomon,ssd1306fb-i2c")) reg[1] |= 1 << 2; ssdfb_write_command(sc, reg, 2); reg[0] = SSDFB_ENTIRE_DISPLAY_ON; ssdfb_write_command(sc, reg, 1); reg[0] = SSDFB_SET_DISPLAY_MODE_NORMAL; ssdfb_write_command(sc, reg, 1); ssdfb_partial(sc, 0, sc->sc_width, 0, sc->sc_height); reg[0] = SSDFB_SET_DISPLAY_ON; ssdfb_write_command(sc, reg, 1); } void ssdfb_set_range(struct ssdfb_softc *sc, uint8_t x1, uint8_t x2, uint8_t y1, uint8_t y2) { uint8_t reg[3]; y1 += sc->sc_pgoff; y2 += sc->sc_pgoff; if (sc->sc_column_range[0] != x1 || sc->sc_column_range[1] != x2) { sc->sc_column_range[0] = x1; sc->sc_column_range[1] = x2; reg[0] = SSDFB_SET_COLUMN_RANGE; reg[1] = sc->sc_column_range[0]; reg[2] = sc->sc_column_range[1]; ssdfb_write_command(sc, reg, 3); } if (sc->sc_page_range[0] != y1 || sc->sc_page_range[1] != y2) { sc->sc_page_range[0] = y1; sc->sc_page_range[1] = y2; reg[0] = SSDFB_SET_PAGE_RANGE; reg[1] = sc->sc_page_range[0]; reg[2] = sc->sc_page_range[1]; ssdfb_write_command(sc, reg, 3); } } void ssdfb_partial(struct ssdfb_softc *sc, uint32_t x1, uint32_t x2, uint32_t y1, uint32_t y2) { struct rasops_info *ri = &sc->sc_rinfo; uint32_t off, width, height; uint8_t *bit, val; int i, j, k; if (x2 < x1 || y2 < y1) return; if (x2 > sc->sc_width || y2 > sc->sc_height) return; y1 = y1 & ~0x7; y2 = roundup(y2, 8); width = x2 - x1; height = y2 - y1; memset(sc->sc_fb, 0, (width * height) / 8); for (i = 0; i < height; i += 8) { for (j = 0; j < width; j++) { bit = &sc->sc_fb[(i / 8) * width + j]; for (k = 0; k < 8; k++) { off = ri->ri_stride * (y1 + i + k); off += (x1 + j) / 8; val = *(ri->ri_bits + off); val &= (1 << ((x1 + j) % 8)); *bit |= !!val << k; } } } ssdfb_set_range(sc, x1, x2 - 1, y1 / 8, (y2 / 8) - 1); ssdfb_write_data(sc, sc->sc_fb, (width * height) / 8); } void ssdfb_write_command(struct ssdfb_softc *sc, char *buf, size_t len) { return sc->sc_write_command(sc, buf, len); } void ssdfb_write_data(struct ssdfb_softc *sc, char *buf, size_t len) { return sc->sc_write_data(sc, buf, len); } void ssdfb_i2c_write_command(struct ssdfb_softc *sc, char *buf, size_t len) { uint8_t type; type = SSDFB_I2C_COMMAND; iic_acquire_bus(sc->sc_i2c_tag, 0); if (iic_exec(sc->sc_i2c_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_i2c_addr, &type, sizeof(type), buf, len, 0)) { printf("%s: cannot write\n", sc->sc_dev.dv_xname); } iic_release_bus(sc->sc_i2c_tag, 0); } void ssdfb_i2c_write_data(struct ssdfb_softc *sc, char *buf, size_t len) { uint8_t type; type = SSDFB_I2C_DATA; iic_acquire_bus(sc->sc_i2c_tag, 0); if (iic_exec(sc->sc_i2c_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_i2c_addr, &type, sizeof(type), buf, len, 0)) { printf("%s: cannot write\n", sc->sc_dev.dv_xname); } iic_release_bus(sc->sc_i2c_tag, 0); } void ssdfb_spi_write_command(struct ssdfb_softc *sc, char *buf, size_t len) { if (sc->sc_cd != 0) { gpio_controller_set_pin(sc->sc_gpio, 0); sc->sc_cd = 0; delay(1); } spi_acquire_bus(sc->sc_spi_tag, 0); spi_config(sc->sc_spi_tag, &sc->sc_spi_conf); if (spi_write(sc->sc_spi_tag, buf, len)) printf("%s: cannot write\n", sc->sc_dev.dv_xname); spi_release_bus(sc->sc_spi_tag, 0); } void ssdfb_spi_write_data(struct ssdfb_softc *sc, char *buf, size_t len) { if (sc->sc_cd != 1) { gpio_controller_set_pin(sc->sc_gpio, 1); sc->sc_cd = 1; delay(1); } spi_acquire_bus(sc->sc_spi_tag, 0); spi_config(sc->sc_spi_tag, &sc->sc_spi_conf); if (spi_write(sc->sc_spi_tag, buf, len)) printf("%s: cannot write\n", sc->sc_dev.dv_xname); spi_release_bus(sc->sc_spi_tag, 0); } int ssdfb_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; struct wsdisplay_param *dp = (struct wsdisplay_param *)data; struct wsdisplay_fbinfo *wdf; struct udl_ioctl_damage *d; int mode; uint8_t reg[2]; switch (cmd) { case WSDISPLAYIO_GETPARAM: switch (dp->param) { case WSDISPLAYIO_PARAM_BRIGHTNESS: dp->min = 0; dp->max = 255; dp->curval = sc->sc_brightness; break; default: return (-1); } break; case WSDISPLAYIO_SETPARAM: switch (dp->param) { case WSDISPLAYIO_PARAM_BRIGHTNESS: if (dp->curval == 0) { reg[0] = SSDFB_SET_DISPLAY_OFF; ssdfb_write_command(sc, reg, 1); } else if (sc->sc_brightness == 0) { reg[0] = SSDFB_SET_DISPLAY_ON; ssdfb_write_command(sc, reg, 1); } reg[0] = SSDFB_SET_CONTRAST_CONTROL; reg[1] = sc->sc_brightness = dp->curval; ssdfb_write_command(sc, reg, 2); break; default: return (-1); } break; case WSDISPLAYIO_GTYPE: *(u_int *)data = WSDISPLAY_TYPE_DL; break; case WSDISPLAYIO_GINFO: wdf = (struct wsdisplay_fbinfo *)data; wdf->width = ri->ri_width; wdf->height = ri->ri_height; wdf->depth = ri->ri_depth; wdf->cmsize = 0; /* color map is unavailable */ break; case WSDISPLAYIO_LINEBYTES: *(u_int *)data = ri->ri_stride; break; case WSDISPLAYIO_SMODE: mode = *(u_int *)data; switch (mode) { case WSDISPLAYIO_MODE_EMUL: if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL) { memset(ri->ri_bits, 0, sc->sc_fbsize); ssdfb_partial(sc, 0, sc->sc_width, 0, sc->sc_height); sc->sc_mode = mode; } break; case WSDISPLAYIO_MODE_DUMBFB: if (sc->sc_mode != WSDISPLAYIO_MODE_DUMBFB) { memset(ri->ri_bits, 0, sc->sc_fbsize); ssdfb_partial(sc, 0, sc->sc_width, 0, sc->sc_height); sc->sc_mode = mode; } break; case WSDISPLAYIO_MODE_MAPPED: default: return (-1); } break; case WSDISPLAYIO_GETSUPPORTEDDEPTH: *(u_int *)data = WSDISPLAYIO_DEPTH_1; break; case UDLIO_DAMAGE: d = (struct udl_ioctl_damage *)data; d->status = UDLIO_STATUS_OK; ssdfb_partial(sc, d->x1, d->x2, d->y1, d->y2); break; default: return (-1); } return (0); } paddr_t ssdfb_mmap(void *v, off_t off, int prot) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; paddr_t pa; if (off >= sc->sc_fbsize || off < 0) return (-1); if (!pmap_extract(pmap_kernel(), (vaddr_t)ri->ri_bits, &pa)) return (-1); return (pa + off); } int ssdfb_alloc_screen(void *v, const struct wsscreen_descr *descr, void **cookiep, int *curxp, int *curyp, uint32_t *attrp) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; return rasops_alloc_screen(ri, cookiep, curxp, curyp, attrp); } void ssdfb_free_screen(void *v, void *cookie) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; rasops_free_screen(ri, cookie); } int ssdfb_show_screen(void *v, void *cookie, int waitok, void (*cb) (void *, int, int), void *cb_arg) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; return rasops_show_screen(ri, cookie, waitok, cb, cb_arg); } int ssdfb_load_font(void *v, void *cookie, struct wsdisplay_font *font) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; return (rasops_load_font(ri, cookie, font)); } int ssdfb_list_font(void *v, struct wsdisplay_font *font) { struct ssdfb_softc *sc = v; struct rasops_info *ri = &sc->sc_rinfo; return (rasops_list_font(ri, font)); } int ssdfb_putchar(void *cookie, int row, int col, u_int uc, uint32_t attr) { struct rasops_info *ri = (struct rasops_info *)cookie; struct ssdfb_softc *sc = ri->ri_hw; sc->sc_riops.putchar(cookie, row, col, uc, attr); ssdfb_partial(sc, col * ri->ri_font->fontwidth, (col + 1) * ri->ri_font->fontwidth, row * ri->ri_font->fontheight, (row + 1) * ri->ri_font->fontheight); return 0; } int ssdfb_copycols(void *cookie, int row, int src, int dst, int num) { struct rasops_info *ri = (struct rasops_info *)cookie; struct ssdfb_softc *sc = ri->ri_hw; sc->sc_riops.copycols(cookie, row, src, dst, num); ssdfb_partial(sc, dst * ri->ri_font->fontwidth, (dst + num) * ri->ri_font->fontwidth, row * ri->ri_font->fontheight, (row + 1) * ri->ri_font->fontheight); return 0; } int ssdfb_erasecols(void *cookie, int row, int col, int num, uint32_t attr) { struct rasops_info *ri = (struct rasops_info *)cookie; struct ssdfb_softc *sc = ri->ri_hw; sc->sc_riops.erasecols(cookie, row, col, num, attr); ssdfb_partial(sc, col * ri->ri_font->fontwidth, (col + num) * ri->ri_font->fontwidth, row * ri->ri_font->fontheight, (row + 1) * ri->ri_font->fontheight); return 0; } int ssdfb_copyrows(void *cookie, int src, int dst, int num) { struct rasops_info *ri = (struct rasops_info *)cookie; struct ssdfb_softc *sc = ri->ri_hw; sc->sc_riops.copyrows(cookie, src, dst, num); ssdfb_partial(sc, 0, sc->sc_width, dst * ri->ri_font->fontheight, (dst + num) * ri->ri_font->fontheight); return 0; } int ssdfb_eraserows(void *cookie, int row, int num, uint32_t attr) { struct rasops_info *ri = (struct rasops_info *)cookie; struct ssdfb_softc *sc = ri->ri_hw; sc->sc_riops.eraserows(cookie, row, num, attr); if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) ssdfb_partial(sc, 0, sc->sc_width, 0, sc->sc_height); else ssdfb_partial(sc, 0, sc->sc_width, row * ri->ri_font->fontheight, (row + num) * ri->ri_font->fontheight); return 0; } int ssdfb_do_cursor(struct rasops_info *ri) { struct ssdfb_softc *sc = ri->ri_hw; int orow, ocol, nrow, ncol; orow = ri->ri_crow; ocol = ri->ri_ccol; sc->sc_ri_do_cursor(ri); nrow = ri->ri_crow; ncol = ri->ri_ccol; ssdfb_partial(sc, ocol * ri->ri_font->fontwidth, (ocol + 1) * ri->ri_font->fontwidth, orow * ri->ri_font->fontheight, (orow + 1) * ri->ri_font->fontheight); ssdfb_partial(sc, ncol * ri->ri_font->fontwidth, (ncol + 1) * ri->ri_font->fontwidth, nrow * ri->ri_font->fontheight, (nrow + 1) * ri->ri_font->fontheight); return 0; }