diff options
Diffstat (limited to 'drivers/gpu/drm/tiny')
| -rw-r--r-- | drivers/gpu/drm/tiny/Kconfig | 74 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/Makefile | 5 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/appletbdrm.c | 834 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/arcpgu.c | 4 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/bochs.c | 5 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/cirrus-qemu.c | 145 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/gm12u320.c | 46 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/ofdrm.c | 1405 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/panel-mipi-dbi.c | 5 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/repaper.c | 4 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/simpledrm.c | 1073 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/st7586.c | 407 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/st7735r.c | 277 |
13 files changed, 892 insertions, 3392 deletions
diff --git a/drivers/gpu/drm/tiny/Kconfig b/drivers/gpu/drm/tiny/Kconfig index 94cbdb1337c0..6d1b3e2cb3fb 100644 --- a/drivers/gpu/drm/tiny/Kconfig +++ b/drivers/gpu/drm/tiny/Kconfig @@ -1,5 +1,18 @@ # SPDX-License-Identifier: GPL-2.0-only +config DRM_APPLETBDRM + tristate "DRM support for Apple Touch Bars" + depends on DRM && USB && MMU + depends on X86 || COMPILE_TEST + select DRM_GEM_SHMEM_HELPER + select DRM_KMS_HELPER + help + Say Y here if you want support for the display of Touch Bars on x86 + MacBook Pros. + + To compile this driver as a module, choose M here: the + module will be called appletbdrm. + config DRM_ARCPGU tristate "ARC PGU" depends on DRM && OF @@ -53,20 +66,6 @@ config DRM_GM12U320 This is a KMS driver for projectors which use the GM12U320 chipset for video transfer over USB2/3, such as the Acer C120 mini projector. -config DRM_OFDRM - tristate "Open Firmware display driver" - depends on DRM && MMU && OF && (PPC || COMPILE_TEST) - select APERTURE_HELPERS - select DRM_CLIENT_SELECTION - select DRM_GEM_SHMEM_HELPER - select DRM_KMS_HELPER - help - DRM driver for Open Firmware framebuffers. - - This driver assumes that the display hardware has been initialized - by the Open Firmware before the kernel boots. Scanout buffer, size, - and display format must be provided via device tree. - config DRM_PANEL_MIPI_DBI tristate "DRM support for MIPI DBI compatible panels" depends on DRM && SPI @@ -83,24 +82,6 @@ config DRM_PANEL_MIPI_DBI https://github.com/notro/panel-mipi-dbi/wiki. To compile this driver as a module, choose M here. -config DRM_SIMPLEDRM - tristate "Simple framebuffer driver" - depends on DRM && MMU - select APERTURE_HELPERS - select DRM_CLIENT_SELECTION - select DRM_GEM_SHMEM_HELPER - select DRM_KMS_HELPER - help - DRM driver for simple platform-provided framebuffers. - - This driver assumes that the display hardware has been initialized - by the firmware or bootloader before the kernel boots. Scanout - buffer, size, and display format must be provided via device tree, - UEFI, VESA, etc. - - On x86 BIOS or UEFI systems, you should also select SYSFB_SIMPLEFB - to use UEFI and VESA framebuffers. - config TINYDRM_HX8357D tristate "DRM support for HX8357D display panels" depends on DRM && SPI @@ -218,32 +199,3 @@ config TINYDRM_SHARP_MEMORY * 4.40" Sharp Memory LCD (LS044Q7DH01) If M is selected the module will be called sharp_memory. - -config TINYDRM_ST7586 - tristate "DRM support for Sitronix ST7586 display panels" - depends on DRM && SPI - select DRM_CLIENT_SELECTION - select DRM_KMS_HELPER - select DRM_GEM_DMA_HELPER - select DRM_MIPI_DBI - help - DRM driver for the following Sitronix ST7586 panels: - * LEGO MINDSTORMS EV3 - - If M is selected the module will be called st7586. - -config TINYDRM_ST7735R - tristate "DRM support for Sitronix ST7715R/ST7735R display panels" - depends on DRM && SPI - select DRM_CLIENT_SELECTION - select DRM_KMS_HELPER - select DRM_GEM_DMA_HELPER - select DRM_MIPI_DBI - select BACKLIGHT_CLASS_DEVICE - help - DRM driver for Sitronix ST7715R/ST7735R with one of the following - LCDs: - * Jianda JD-T18003-T01 1.8" 128x160 TFT - * Okaya RH128128T 1.44" 128x128 TFT - - If M is selected the module will be called st7735r. diff --git a/drivers/gpu/drm/tiny/Makefile b/drivers/gpu/drm/tiny/Makefile index 60816d2eb4ff..4a9ff61ec254 100644 --- a/drivers/gpu/drm/tiny/Makefile +++ b/drivers/gpu/drm/tiny/Makefile @@ -1,12 +1,11 @@ # SPDX-License-Identifier: GPL-2.0-only +obj-$(CONFIG_DRM_APPLETBDRM) += appletbdrm.o obj-$(CONFIG_DRM_ARCPGU) += arcpgu.o obj-$(CONFIG_DRM_BOCHS) += bochs.o obj-$(CONFIG_DRM_CIRRUS_QEMU) += cirrus-qemu.o obj-$(CONFIG_DRM_GM12U320) += gm12u320.o -obj-$(CONFIG_DRM_OFDRM) += ofdrm.o obj-$(CONFIG_DRM_PANEL_MIPI_DBI) += panel-mipi-dbi.o -obj-$(CONFIG_DRM_SIMPLEDRM) += simpledrm.o obj-$(CONFIG_TINYDRM_HX8357D) += hx8357d.o obj-$(CONFIG_TINYDRM_ILI9163) += ili9163.o obj-$(CONFIG_TINYDRM_ILI9225) += ili9225.o @@ -15,5 +14,3 @@ obj-$(CONFIG_TINYDRM_ILI9486) += ili9486.o obj-$(CONFIG_TINYDRM_MI0283QT) += mi0283qt.o obj-$(CONFIG_TINYDRM_REPAPER) += repaper.o obj-$(CONFIG_TINYDRM_SHARP_MEMORY) += sharp-memory.o -obj-$(CONFIG_TINYDRM_ST7586) += st7586.o -obj-$(CONFIG_TINYDRM_ST7735R) += st7735r.o diff --git a/drivers/gpu/drm/tiny/appletbdrm.c b/drivers/gpu/drm/tiny/appletbdrm.c new file mode 100644 index 000000000000..751b05753c94 --- /dev/null +++ b/drivers/gpu/drm/tiny/appletbdrm.c @@ -0,0 +1,834 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Apple Touch Bar DRM Driver + * + * Copyright (c) 2023 Kerem Karabay <kekrby@gmail.com> + */ + +#include <linux/align.h> +#include <linux/array_size.h> +#include <linux/bitops.h> +#include <linux/bug.h> +#include <linux/container_of.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/overflow.h> +#include <linux/slab.h> +#include <linux/types.h> +#include <linux/unaligned.h> +#include <linux/usb.h> + +#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h> +#include <drm/drm_crtc.h> +#include <drm/drm_damage_helper.h> +#include <drm/drm_drv.h> +#include <drm/drm_encoder.h> +#include <drm/drm_format_helper.h> +#include <drm/drm_fourcc.h> +#include <drm/drm_framebuffer.h> +#include <drm/drm_gem_atomic_helper.h> +#include <drm/drm_gem_framebuffer_helper.h> +#include <drm/drm_gem_shmem_helper.h> +#include <drm/drm_plane.h> +#include <drm/drm_print.h> +#include <drm/drm_probe_helper.h> + +#define APPLETBDRM_PIXEL_FORMAT cpu_to_le32(0x52474241) /* RGBA, the actual format is BGR888 */ +#define APPLETBDRM_BITS_PER_PIXEL 24 + +#define APPLETBDRM_MSG_CLEAR_DISPLAY cpu_to_le32(0x434c5244) /* CLRD */ +#define APPLETBDRM_MSG_GET_INFORMATION cpu_to_le32(0x47494e46) /* GINF */ +#define APPLETBDRM_MSG_UPDATE_COMPLETE cpu_to_le32(0x5544434c) /* UDCL */ +#define APPLETBDRM_MSG_SIGNAL_READINESS cpu_to_le32(0x52454459) /* REDY */ + +#define APPLETBDRM_BULK_MSG_TIMEOUT 1000 + +#define drm_to_adev(_drm) container_of(_drm, struct appletbdrm_device, drm) +#define adev_to_udev(adev) interface_to_usbdev(to_usb_interface((adev)->drm.dev)) + +struct appletbdrm_msg_request_header { + __le16 unk_00; + __le16 unk_02; + __le32 unk_04; + __le32 unk_08; + __le32 size; +} __packed; + +struct appletbdrm_msg_response_header { + u8 unk_00[16]; + __le32 msg; +} __packed; + +struct appletbdrm_msg_simple_request { + struct appletbdrm_msg_request_header header; + __le32 msg; + u8 unk_14[8]; + __le32 size; +} __packed; + +struct appletbdrm_msg_information { + struct appletbdrm_msg_response_header header; + u8 unk_14[12]; + __le32 width; + __le32 height; + u8 bits_per_pixel; + __le32 bytes_per_row; + __le32 orientation; + __le32 bitmap_info; + __le32 pixel_format; + __le32 width_inches; /* floating point */ + __le32 height_inches; /* floating point */ +} __packed; + +struct appletbdrm_frame { + __le16 begin_x; + __le16 begin_y; + __le16 width; + __le16 height; + __le32 buf_size; + u8 buf[]; +} __packed; + +struct appletbdrm_fb_request_footer { + u8 unk_00[12]; + __le32 unk_0c; + u8 unk_10[12]; + __le32 unk_1c; + __le64 timestamp; + u8 unk_28[12]; + __le32 unk_34; + u8 unk_38[20]; + __le32 unk_4c; +} __packed; + +struct appletbdrm_fb_request { + struct appletbdrm_msg_request_header header; + __le16 unk_10; + u8 msg_id; + u8 unk_13[29]; + /* + * Contents of `data`: + * - struct appletbdrm_frame frames[]; + * - struct appletbdrm_fb_request_footer footer; + * - padding to make the total size a multiple of 16 + */ + u8 data[]; +} __packed; + +struct appletbdrm_fb_request_response { + struct appletbdrm_msg_response_header header; + u8 unk_14[12]; + __le64 timestamp; +} __packed; + +struct appletbdrm_device { + unsigned int in_ep; + unsigned int out_ep; + + unsigned int width; + unsigned int height; + + struct drm_device drm; + struct drm_display_mode mode; + struct drm_connector connector; + struct drm_plane primary_plane; + struct drm_crtc crtc; + struct drm_encoder encoder; +}; + +struct appletbdrm_plane_state { + struct drm_shadow_plane_state base; + struct appletbdrm_fb_request *request; + struct appletbdrm_fb_request_response *response; + size_t request_size; + size_t frames_size; +}; + +static inline struct appletbdrm_plane_state *to_appletbdrm_plane_state(struct drm_plane_state *state) +{ + return container_of(state, struct appletbdrm_plane_state, base.base); +} + +static int appletbdrm_send_request(struct appletbdrm_device *adev, + struct appletbdrm_msg_request_header *request, size_t size) +{ + struct usb_device *udev = adev_to_udev(adev); + struct drm_device *drm = &adev->drm; + int ret, actual_size; + + ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, adev->out_ep), + request, size, &actual_size, APPLETBDRM_BULK_MSG_TIMEOUT); + if (ret) { + drm_err(drm, "Failed to send message (%d)\n", ret); + return ret; + } + + if (actual_size != size) { + drm_err(drm, "Actual size (%d) doesn't match expected size (%zu)\n", + actual_size, size); + return -EIO; + } + + return 0; +} + +static int appletbdrm_read_response(struct appletbdrm_device *adev, + struct appletbdrm_msg_response_header *response, + size_t size, __le32 expected_response) +{ + struct usb_device *udev = adev_to_udev(adev); + struct drm_device *drm = &adev->drm; + int ret, actual_size; + bool readiness_signal_received = false; + +retry: + ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, adev->in_ep), + response, size, &actual_size, APPLETBDRM_BULK_MSG_TIMEOUT); + if (ret) { + drm_err(drm, "Failed to read response (%d)\n", ret); + return ret; + } + + /* + * The device responds to the first request sent in a particular + * timeframe after the USB device configuration is set with a readiness + * signal, in which case the response should be read again + */ + if (response->msg == APPLETBDRM_MSG_SIGNAL_READINESS) { + if (!readiness_signal_received) { + readiness_signal_received = true; + goto retry; + } + + drm_err(drm, "Encountered unexpected readiness signal\n"); + return -EINTR; + } + + if (actual_size != size) { + drm_err(drm, "Actual size (%d) doesn't match expected size (%zu)\n", + actual_size, size); + return -EBADMSG; + } + + if (response->msg != expected_response) { + drm_err(drm, "Unexpected response from device (expected %p4cl found %p4cl)\n", + &expected_response, &response->msg); + return -EIO; + } + + return 0; +} + +static int appletbdrm_send_msg(struct appletbdrm_device *adev, __le32 msg) +{ + struct appletbdrm_msg_simple_request *request; + int ret; + + request = kzalloc(sizeof(*request), GFP_KERNEL); + if (!request) + return -ENOMEM; + + request->header.unk_00 = cpu_to_le16(2); + request->header.unk_02 = cpu_to_le16(0x1512); + request->header.size = cpu_to_le32(sizeof(*request) - sizeof(request->header)); + request->msg = msg; + request->size = request->header.size; + + ret = appletbdrm_send_request(adev, &request->header, sizeof(*request)); + + kfree(request); + + return ret; +} + +static int appletbdrm_clear_display(struct appletbdrm_device *adev) +{ + return appletbdrm_send_msg(adev, APPLETBDRM_MSG_CLEAR_DISPLAY); +} + +static int appletbdrm_signal_readiness(struct appletbdrm_device *adev) +{ + return appletbdrm_send_msg(adev, APPLETBDRM_MSG_SIGNAL_READINESS); +} + +static int appletbdrm_get_information(struct appletbdrm_device *adev) +{ + struct appletbdrm_msg_information *info; + struct drm_device *drm = &adev->drm; + u8 bits_per_pixel; + __le32 pixel_format; + int ret; + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + ret = appletbdrm_send_msg(adev, APPLETBDRM_MSG_GET_INFORMATION); + if (ret) + return ret; + + ret = appletbdrm_read_response(adev, &info->header, sizeof(*info), + APPLETBDRM_MSG_GET_INFORMATION); + if (ret) + goto free_info; + + bits_per_pixel = info->bits_per_pixel; + pixel_format = get_unaligned(&info->pixel_format); + + adev->width = get_unaligned_le32(&info->width); + adev->height = get_unaligned_le32(&info->height); + + if (bits_per_pixel != APPLETBDRM_BITS_PER_PIXEL) { + drm_err(drm, "Encountered unexpected bits per pixel value (%d)\n", bits_per_pixel); + ret = -EINVAL; + goto free_info; + } + + if (pixel_format != APPLETBDRM_PIXEL_FORMAT) { + drm_err(drm, "Encountered unknown pixel format (%p4cl)\n", &pixel_format); + ret = -EINVAL; + goto free_info; + } + +free_info: + kfree(info); + + return ret; +} + +static u32 rect_size(struct drm_rect *rect) +{ + return drm_rect_width(rect) * drm_rect_height(rect) * + (BITS_TO_BYTES(APPLETBDRM_BITS_PER_PIXEL)); +} + +static int appletbdrm_connector_helper_get_modes(struct drm_connector *connector) +{ + struct appletbdrm_device *adev = drm_to_adev(connector->dev); + + return drm_connector_helper_get_modes_fixed(connector, &adev->mode); +} + +static const u32 appletbdrm_primary_plane_formats[] = { + DRM_FORMAT_BGR888, + DRM_FORMAT_XRGB8888, /* emulated */ +}; + +static int appletbdrm_primary_plane_helper_atomic_check(struct drm_plane *plane, + struct drm_atomic_state *state) +{ + struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane); + struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); + struct drm_crtc *new_crtc = new_plane_state->crtc; + struct drm_crtc_state *new_crtc_state = NULL; + struct appletbdrm_plane_state *appletbdrm_state = to_appletbdrm_plane_state(new_plane_state); + struct drm_atomic_helper_damage_iter iter; + struct drm_rect damage; + size_t frames_size = 0; + size_t request_size; + int ret; + + if (new_crtc) + new_crtc_state = drm_atomic_get_new_crtc_state(state, new_crtc); + + ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state, + DRM_PLANE_NO_SCALING, + DRM_PLANE_NO_SCALING, + false, false); + if (ret) + return ret; + else if (!new_plane_state->visible) + return 0; + + drm_atomic_helper_damage_iter_init(&iter, old_plane_state, new_plane_state); + drm_atomic_for_each_plane_damage(&iter, &damage) { + frames_size += struct_size((struct appletbdrm_frame *)0, buf, rect_size(&damage)); + } + + if (!frames_size) + return 0; + + request_size = ALIGN(sizeof(struct appletbdrm_fb_request) + + frames_size + + sizeof(struct appletbdrm_fb_request_footer), 16); + + appletbdrm_state->request = kzalloc(request_size, GFP_KERNEL); + + if (!appletbdrm_state->request) + return -ENOMEM; + + appletbdrm_state->response = kzalloc(sizeof(*appletbdrm_state->response), GFP_KERNEL); + + if (!appletbdrm_state->response) + return -ENOMEM; + + appletbdrm_state->request_size = request_size; + appletbdrm_state->frames_size = frames_size; + + return 0; +} + +static int appletbdrm_flush_damage(struct appletbdrm_device *adev, + struct drm_plane_state *old_state, + struct drm_plane_state *state) +{ + struct appletbdrm_plane_state *appletbdrm_state = to_appletbdrm_plane_state(state); + struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(state); + struct appletbdrm_fb_request_response *response = appletbdrm_state->response; + struct appletbdrm_fb_request_footer *footer; + struct drm_atomic_helper_damage_iter iter; + struct drm_framebuffer *fb = state->fb; + struct appletbdrm_fb_request *request = appletbdrm_state->request; + struct drm_device *drm = &adev->drm; + struct appletbdrm_frame *frame; + u64 timestamp = ktime_get_ns(); + struct drm_rect damage; + size_t frames_size = appletbdrm_state->frames_size; + size_t request_size = appletbdrm_state->request_size; + int ret; + + if (!frames_size) + return 0; + + ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); + if (ret) { + drm_err(drm, "Failed to start CPU framebuffer access (%d)\n", ret); + goto end_fb_cpu_access; + } + + request->header.unk_00 = cpu_to_le16(2); + request->header.unk_02 = cpu_to_le16(0x12); + request->header.unk_04 = cpu_to_le32(9); + request->header.size = cpu_to_le32(request_size - sizeof(request->header)); + request->unk_10 = cpu_to_le16(1); + request->msg_id = timestamp; + + frame = (struct appletbdrm_frame *)request->data; + + drm_atomic_helper_damage_iter_init(&iter, old_state, state); + drm_atomic_for_each_plane_damage(&iter, &damage) { + struct drm_rect dst_clip = state->dst; + struct iosys_map dst = IOSYS_MAP_INIT_VADDR(frame->buf); + u32 buf_size = rect_size(&damage); + + if (!drm_rect_intersect(&dst_clip, &damage)) + continue; + + /* + * The coordinates need to be translated to the coordinate + * system the device expects, see the comment in + * appletbdrm_setup_mode_config + */ + frame->begin_x = cpu_to_le16(damage.y1); + frame->begin_y = cpu_to_le16(adev->height - damage.x2); + frame->width = cpu_to_le16(drm_rect_height(&damage)); + frame->height = cpu_to_le16(drm_rect_width(&damage)); + frame->buf_size = cpu_to_le32(buf_size); + + switch (fb->format->format) { + case DRM_FORMAT_XRGB8888: + drm_fb_xrgb8888_to_bgr888(&dst, NULL, &shadow_plane_state->data[0], fb, &damage, &shadow_plane_state->fmtcnv_state); + break; + default: + drm_fb_memcpy(&dst, NULL, &shadow_plane_state->data[0], fb, &damage); + break; + } + + frame = (void *)frame + struct_size(frame, buf, buf_size); + } + + footer = (struct appletbdrm_fb_request_footer *)&request->data[frames_size]; + + footer->unk_0c = cpu_to_le32(0xfffe); + footer->unk_1c = cpu_to_le32(0x80001); + footer->unk_34 = cpu_to_le32(0x80002); + footer->unk_4c = cpu_to_le32(0xffff); + footer->timestamp = cpu_to_le64(timestamp); + + ret = appletbdrm_send_request(adev, &request->header, request_size); + if (ret) + goto end_fb_cpu_access; + + ret = appletbdrm_read_response(adev, &response->header, sizeof(*response), + APPLETBDRM_MSG_UPDATE_COMPLETE); + if (ret) + goto end_fb_cpu_access; + + if (response->timestamp != footer->timestamp) { + drm_err(drm, "Response timestamp (%llu) doesn't match request timestamp (%llu)\n", + le64_to_cpu(response->timestamp), timestamp); + goto end_fb_cpu_access; + } + +end_fb_cpu_access: + drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); + + return ret; +} + +static void appletbdrm_primary_plane_helper_atomic_update(struct drm_plane *plane, + struct drm_atomic_state *old_state) +{ + struct appletbdrm_device *adev = drm_to_adev(plane->dev); + struct drm_device *drm = plane->dev; + struct drm_plane_state *plane_state = plane->state; + struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(old_state, plane); + int idx; + + if (!drm_dev_enter(drm, &idx)) + return; + + appletbdrm_flush_damage(adev, old_plane_state, plane_state); + + drm_dev_exit(idx); +} + +static void appletbdrm_primary_plane_helper_atomic_disable(struct drm_plane *plane, + struct drm_atomic_state *state) +{ + struct drm_device *dev = plane->dev; + struct appletbdrm_device *adev = drm_to_adev(dev); + int idx; + + if (!drm_dev_enter(dev, &idx)) + return; + + appletbdrm_clear_display(adev); + + drm_dev_exit(idx); +} + +static void appletbdrm_primary_plane_reset(struct drm_plane *plane) +{ + struct appletbdrm_plane_state *appletbdrm_state; + + WARN_ON(plane->state); + + appletbdrm_state = kzalloc(sizeof(*appletbdrm_state), GFP_KERNEL); + if (!appletbdrm_state) + return; + + __drm_gem_reset_shadow_plane(plane, &appletbdrm_state->base); +} + +static struct drm_plane_state *appletbdrm_primary_plane_duplicate_state(struct drm_plane *plane) +{ + struct drm_shadow_plane_state *new_shadow_plane_state; + struct appletbdrm_plane_state *appletbdrm_state; + + if (WARN_ON(!plane->state)) + return NULL; + + appletbdrm_state = kzalloc(sizeof(*appletbdrm_state), GFP_KERNEL); + if (!appletbdrm_state) + return NULL; + + /* Request and response are not duplicated and are allocated in .atomic_check */ + appletbdrm_state->request = NULL; + appletbdrm_state->response = NULL; + + appletbdrm_state->request_size = 0; + appletbdrm_state->frames_size = 0; + + new_shadow_plane_state = &appletbdrm_state->base; + + __drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state); + + return &new_shadow_plane_state->base; +} + +static void appletbdrm_primary_plane_destroy_state(struct drm_plane *plane, + struct drm_plane_state *state) +{ + struct appletbdrm_plane_state *appletbdrm_state = to_appletbdrm_plane_state(state); + + kfree(appletbdrm_state->request); + kfree(appletbdrm_state->response); + + __drm_gem_destroy_shadow_plane_state(&appletbdrm_state->base); + + kfree(appletbdrm_state); +} + +static const struct drm_plane_helper_funcs appletbdrm_primary_plane_helper_funcs = { + DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, + .atomic_check = appletbdrm_primary_plane_helper_atomic_check, + .atomic_update = appletbdrm_primary_plane_helper_atomic_update, + .atomic_disable = appletbdrm_primary_plane_helper_atomic_disable, +}; + +static const struct drm_plane_funcs appletbdrm_primary_plane_funcs = { + .update_plane = drm_atomic_helper_update_plane, + .disable_plane = drm_atomic_helper_disable_plane, + .reset = appletbdrm_primary_plane_reset, + .atomic_duplicate_state = appletbdrm_primary_plane_duplicate_state, + .atomic_destroy_state = appletbdrm_primary_plane_destroy_state, + .destroy = drm_plane_cleanup, +}; + +static enum drm_mode_status appletbdrm_crtc_helper_mode_valid(struct drm_crtc *crtc, + const struct drm_display_mode *mode) +{ + struct appletbdrm_device *adev = drm_to_adev(crtc->dev); + + return drm_crtc_helper_mode_valid_fixed(crtc, mode, &adev->mode); +} + +static const struct drm_mode_config_funcs appletbdrm_mode_config_funcs = { + .fb_create = drm_gem_fb_create_with_dirty, + .atomic_check = drm_atomic_helper_check, + .atomic_commit = drm_atomic_helper_commit, +}; + +static const struct drm_connector_funcs appletbdrm_connector_funcs = { + .reset = drm_atomic_helper_connector_reset, + .destroy = drm_connector_cleanup, + .fill_modes = drm_helper_probe_single_connector_modes, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, +}; + +static const struct drm_connector_helper_funcs appletbdrm_connector_helper_funcs = { + .get_modes = appletbdrm_connector_helper_get_modes, +}; + +static const struct drm_crtc_helper_funcs appletbdrm_crtc_helper_funcs = { + .mode_valid = appletbdrm_crtc_helper_mode_valid, +}; + +static const struct drm_crtc_funcs appletbdrm_crtc_funcs = { + .reset = drm_atomic_helper_crtc_reset, + .destroy = drm_crtc_cleanup, + .set_config = drm_atomic_helper_set_config, + .page_flip = drm_atomic_helper_page_flip, + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, +}; + +static const struct drm_encoder_funcs appletbdrm_encoder_funcs = { + .destroy = drm_encoder_cleanup, +}; + +DEFINE_DRM_GEM_FOPS(appletbdrm_drm_fops); + +static const struct drm_driver appletbdrm_drm_driver = { + DRM_GEM_SHMEM_DRIVER_OPS, + .name = "appletbdrm", + .desc = "Apple Touch Bar DRM Driver", + .major = 1, + .minor = 0, + .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC, + .fops = &appletbdrm_drm_fops, +}; + +static int appletbdrm_setup_mode_config(struct appletbdrm_device *adev) +{ + struct drm_connector *connector = &adev->connector; + struct drm_plane *primary_plane; + struct drm_crtc *crtc; + struct drm_encoder *encoder; + struct drm_device *drm = &adev->drm; + int ret; + + ret = drmm_mode_config_init(drm); + if (ret) { + drm_err(drm, "Failed to initialize mode configuration\n"); + return ret; + } + + primary_plane = &adev->primary_plane; + ret = drm_universal_plane_init(drm, primary_plane, 0, + &appletbdrm_primary_plane_funcs, + appletbdrm_primary_plane_formats, + ARRAY_SIZE(appletbdrm_primary_plane_formats), + NULL, + DRM_PLANE_TYPE_PRIMARY, NULL); + if (ret) { + drm_err(drm, "Failed to initialize universal plane object\n"); + return ret; + } + + drm_plane_helper_add(primary_plane, &appletbdrm_primary_plane_helper_funcs); + drm_plane_enable_fb_damage_clips(primary_plane); + + crtc = &adev->crtc; + ret = drm_crtc_init_with_planes(drm, crtc, primary_plane, NULL, + &appletbdrm_crtc_funcs, NULL); + if (ret) { + drm_err(drm, "Failed to initialize CRTC object\n"); + return ret; + } + + drm_crtc_helper_add(crtc, &appletbdrm_crtc_helper_funcs); + + encoder = &adev->encoder; + ret = drm_encoder_init(drm, encoder, &appletbdrm_encoder_funcs, + DRM_MODE_ENCODER_DAC, NULL); + if (ret) { + drm_err(drm, "Failed to initialize encoder\n"); + return ret; + } + + encoder->possible_crtcs = drm_crtc_mask(crtc); + + /* + * The coordinate system used by the device is different from the + * coordinate system of the framebuffer in that the x and y axes are + * swapped, and that the y axis is inverted; so what the device reports + * as the height is actually the width of the framebuffer and vice + * versa. + */ + drm->mode_config.max_width = max(adev->height, DRM_SHADOW_PLANE_MAX_WIDTH); + drm->mode_config.max_height = max(adev->width, DRM_SHADOW_PLANE_MAX_HEIGHT); + drm->mode_config.preferred_depth = APPLETBDRM_BITS_PER_PIXEL; + drm->mode_config.funcs = &appletbdrm_mode_config_funcs; + + adev->mode = (struct drm_display_mode) { + DRM_MODE_INIT(60, adev->height, adev->width, + DRM_MODE_RES_MM(adev->height, 218), + DRM_MODE_RES_MM(adev->width, 218)) + }; + + ret = drm_connector_init(drm, connector, + &appletbdrm_connector_funcs, DRM_MODE_CONNECTOR_USB); + if (ret) { + drm_err(drm, "Failed to initialize connector\n"); + return ret; + } + + drm_connector_helper_add(connector, &appletbdrm_connector_helper_funcs); + + ret = drm_connector_set_panel_orientation(connector, + DRM_MODE_PANEL_ORIENTATION_RIGHT_UP); + if (ret) { + drm_err(drm, "Failed to set panel orientation\n"); + return ret; + } + + connector->display_info.non_desktop = true; + ret = drm_object_property_set_value(&connector->base, + drm->mode_config.non_desktop_property, true); + if (ret) { + drm_err(drm, "Failed to set non-desktop property\n"); + return ret; + } + + ret = drm_connector_attach_encoder(connector, encoder); + + if (ret) { + drm_err(drm, "Failed to initialize simple display pipe\n"); + return ret; + } + + drm_mode_config_reset(drm); + + return 0; +} + +static int appletbdrm_probe(struct usb_interface *intf, + const struct usb_device_id *id) +{ + struct usb_endpoint_descriptor *bulk_in, *bulk_out; + struct device *dev = &intf->dev; + struct appletbdrm_device *adev; + struct drm_device *drm = NULL; + struct device *dma_dev; + int ret; + + ret = usb_find_common_endpoints(intf->cur_altsetting, &bulk_in, &bulk_out, NULL, NULL); + if (ret) { + drm_err(drm, "appletbdrm: Failed to find bulk endpoints\n"); + return ret; + } + + adev = devm_drm_dev_alloc(dev, &appletbdrm_drm_driver, struct appletbdrm_device, drm); + if (IS_ERR(adev)) + return PTR_ERR(adev); + + adev->in_ep = bulk_in->bEndpointAddress; + adev->out_ep = bulk_out->bEndpointAddress; + + drm = &adev->drm; + + usb_set_intfdata(intf, adev); + + dma_dev = usb_intf_get_dma_device(intf); + if (dma_dev) { + drm_dev_set_dma_dev(drm, dma_dev); + put_device(dma_dev); + } else { + drm_warn(drm, "buffer sharing not supported"); /* not an error */ + } + + ret = appletbdrm_get_information(adev); + if (ret) { + drm_err(drm, "Failed to get display information\n"); + return ret; + } + + ret = appletbdrm_signal_readiness(adev); + if (ret) { + drm_err(drm, "Failed to signal readiness\n"); + return ret; + } + + ret = appletbdrm_setup_mode_config(adev); + if (ret) { + drm_err(drm, "Failed to setup mode config\n"); + return ret; + } + + ret = drm_dev_register(drm, 0); + if (ret) { + drm_err(drm, "Failed to register DRM device\n"); + return ret; + } + + ret = appletbdrm_clear_display(adev); + if (ret) { + drm_err(drm, "Failed to clear display\n"); + return ret; + } + + return 0; +} + +static void appletbdrm_disconnect(struct usb_interface *intf) +{ + struct appletbdrm_device *adev = usb_get_intfdata(intf); + struct drm_device *drm = &adev->drm; + + drm_dev_unplug(drm); + drm_atomic_helper_shutdown(drm); +} + +static void appletbdrm_shutdown(struct usb_interface *intf) +{ + struct appletbdrm_device *adev = usb_get_intfdata(intf); + + /* + * The framebuffer needs to be cleared on shutdown since its content + * persists across boots + */ + drm_atomic_helper_shutdown(&adev->drm); +} + +static const struct usb_device_id appletbdrm_usb_id_table[] = { + { USB_DEVICE_INTERFACE_CLASS(0x05ac, 0x8302, USB_CLASS_AUDIO_VIDEO) }, + {} +}; +MODULE_DEVICE_TABLE(usb, appletbdrm_usb_id_table); + +static struct usb_driver appletbdrm_usb_driver = { + .name = "appletbdrm", + .probe = appletbdrm_probe, + .disconnect = appletbdrm_disconnect, + .shutdown = appletbdrm_shutdown, + .id_table = appletbdrm_usb_id_table, +}; +module_usb_driver(appletbdrm_usb_driver); + +MODULE_AUTHOR("Kerem Karabay <kekrby@gmail.com>"); +MODULE_DESCRIPTION("Apple Touch Bar DRM Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/arcpgu.c b/drivers/gpu/drm/tiny/arcpgu.c index 2748d1f21d86..7cf0f0ea1bfe 100644 --- a/drivers/gpu/drm/tiny/arcpgu.c +++ b/drivers/gpu/drm/tiny/arcpgu.c @@ -253,7 +253,6 @@ static int arcpgu_load(struct arcpgu_drm_private *arcpgu) struct device_node *encoder_node = NULL, *endpoint_node = NULL; struct drm_connector *connector = NULL; struct drm_device *drm = &arcpgu->drm; - struct resource *res; int ret; arcpgu->clk = devm_clk_get(drm->dev, "pxlclk"); @@ -270,8 +269,7 @@ static int arcpgu_load(struct arcpgu_drm_private *arcpgu) drm->mode_config.max_height = 1080; drm->mode_config.funcs = &arcpgu_drm_modecfg_funcs; - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - arcpgu->regs = devm_ioremap_resource(&pdev->dev, res); + arcpgu->regs = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(arcpgu->regs)) return PTR_ERR(arcpgu->regs); diff --git a/drivers/gpu/drm/tiny/bochs.c b/drivers/gpu/drm/tiny/bochs.c index c67e1f906785..8706763af8fb 100644 --- a/drivers/gpu/drm/tiny/bochs.c +++ b/drivers/gpu/drm/tiny/bochs.c @@ -335,8 +335,6 @@ static void bochs_hw_setmode(struct bochs_device *bochs, struct drm_display_mode bochs->xres, bochs->yres, bochs->bpp, bochs->yres_virtual); - bochs_hw_blank(bochs, false); - bochs_dispi_write(bochs, VBE_DISPI_INDEX_ENABLE, 0); bochs_dispi_write(bochs, VBE_DISPI_INDEX_BPP, bochs->bpp); bochs_dispi_write(bochs, VBE_DISPI_INDEX_XRES, bochs->xres); @@ -506,6 +504,9 @@ static int bochs_crtc_helper_atomic_check(struct drm_crtc *crtc, static void bochs_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *state) { + struct bochs_device *bochs = to_bochs_device(crtc->dev); + + bochs_hw_blank(bochs, false); } static void bochs_crtc_helper_atomic_disable(struct drm_crtc *crtc, diff --git a/drivers/gpu/drm/tiny/cirrus-qemu.c b/drivers/gpu/drm/tiny/cirrus-qemu.c index 52ec1e4ea9e5..97a93adc5669 100644 --- a/drivers/gpu/drm/tiny/cirrus-qemu.c +++ b/drivers/gpu/drm/tiny/cirrus-qemu.c @@ -70,20 +70,6 @@ struct cirrus_device { #define to_cirrus(_dev) container_of(_dev, struct cirrus_device, dev) -struct cirrus_primary_plane_state { - struct drm_shadow_plane_state base; - - /* HW scanout buffer */ - const struct drm_format_info *format; - unsigned int pitch; -}; - -static inline struct cirrus_primary_plane_state * -to_cirrus_primary_plane_state(struct drm_plane_state *plane_state) -{ - return container_of(plane_state, struct cirrus_primary_plane_state, base.base); -}; - /* ------------------------------------------------------------------ */ /* * The meat of this driver. The core passes us a mode and we have to program @@ -144,37 +130,6 @@ static void wreg_hdr(struct cirrus_device *cirrus, u8 val) iowrite8(val, cirrus->mmio + VGA_DAC_MASK); } -static const struct drm_format_info *cirrus_convert_to(struct drm_framebuffer *fb) -{ - if (fb->format->format == DRM_FORMAT_XRGB8888 && fb->pitches[0] > CIRRUS_MAX_PITCH) { - if (fb->width * 3 <= CIRRUS_MAX_PITCH) - /* convert from XR24 to RG24 */ - return drm_format_info(DRM_FORMAT_RGB888); - else - /* convert from XR24 to RG16 */ - return drm_format_info(DRM_FORMAT_RGB565); - } - return NULL; -} - -static const struct drm_format_info *cirrus_format(struct drm_framebuffer *fb) -{ - const struct drm_format_info *format = cirrus_convert_to(fb); - - if (format) - return format; - return fb->format; -} - -static int cirrus_pitch(struct drm_framebuffer *fb) -{ - const struct drm_format_info *format = cirrus_convert_to(fb); - - if (format) - return drm_format_info_min_pitch(format, 0, fb->width); - return fb->pitches[0]; -} - static void cirrus_set_start_address(struct cirrus_device *cirrus, u32 offset) { u32 addr; @@ -318,7 +273,6 @@ static void cirrus_pitch_set(struct cirrus_device *cirrus, unsigned int pitch) /* Enable extended blanking and pitch bits, and enable full memory */ cr1b = 0x22; cr1b |= (pitch >> 7) & 0x10; - cr1b |= (pitch >> 6) & 0x40; wreg_crt(cirrus, 0x1b, cr1b); cirrus_set_start_address(cirrus, 0); @@ -342,13 +296,10 @@ static int cirrus_primary_plane_helper_atomic_check(struct drm_plane *plane, struct drm_atomic_state *state) { struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane); - struct cirrus_primary_plane_state *new_primary_plane_state = - to_cirrus_primary_plane_state(new_plane_state); struct drm_framebuffer *fb = new_plane_state->fb; struct drm_crtc *new_crtc = new_plane_state->crtc; struct drm_crtc_state *new_crtc_state = NULL; int ret; - unsigned int pitch; if (new_crtc) new_crtc_state = drm_atomic_get_new_crtc_state(state, new_crtc); @@ -362,17 +313,12 @@ static int cirrus_primary_plane_helper_atomic_check(struct drm_plane *plane, else if (!new_plane_state->visible) return 0; - pitch = cirrus_pitch(fb); - /* validate size constraints */ - if (pitch > CIRRUS_MAX_PITCH) + if (fb->pitches[0] > CIRRUS_MAX_PITCH) return -EINVAL; - else if (pitch * fb->height > CIRRUS_VRAM_SIZE) + else if (fb->pitches[0] > CIRRUS_VRAM_SIZE / fb->height) return -EINVAL; - new_primary_plane_state->format = cirrus_format(fb); - new_primary_plane_state->pitch = pitch; - return 0; } @@ -381,15 +327,10 @@ static void cirrus_primary_plane_helper_atomic_update(struct drm_plane *plane, { struct cirrus_device *cirrus = to_cirrus(plane->dev); struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); - struct cirrus_primary_plane_state *primary_plane_state = - to_cirrus_primary_plane_state(plane_state); struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); struct drm_framebuffer *fb = plane_state->fb; - const struct drm_format_info *format = primary_plane_state->format; - unsigned int pitch = primary_plane_state->pitch; struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); - struct cirrus_primary_plane_state *old_primary_plane_state = - to_cirrus_primary_plane_state(old_plane_state); + struct drm_framebuffer *old_fb = old_plane_state->fb; struct iosys_map vaddr = IOSYS_MAP_INIT_VADDR_IOMEM(cirrus->vram); struct drm_atomic_helper_damage_iter iter; struct drm_rect damage; @@ -401,18 +342,17 @@ static void cirrus_primary_plane_helper_atomic_update(struct drm_plane *plane, if (!drm_dev_enter(&cirrus->dev, &idx)) return; - if (old_primary_plane_state->format != format) - cirrus_format_set(cirrus, format); - if (old_primary_plane_state->pitch != pitch) - cirrus_pitch_set(cirrus, pitch); + if (!old_fb || old_fb->format != fb->format) + cirrus_format_set(cirrus, fb->format); + if (!old_fb || old_fb->pitches[0] != fb->pitches[0]) + cirrus_pitch_set(cirrus, fb->pitches[0]); drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); drm_atomic_for_each_plane_damage(&iter, &damage) { - unsigned int offset = drm_fb_clip_offset(pitch, format, &damage); + unsigned int offset = drm_fb_clip_offset(fb->pitches[0], fb->format, &damage); struct iosys_map dst = IOSYS_MAP_INIT_OFFSET(&vaddr, offset); - drm_fb_blit(&dst, &pitch, format->format, shadow_plane_state->data, fb, - &damage, &shadow_plane_state->fmtcnv_state); + drm_fb_memcpy(&dst, fb->pitches, shadow_plane_state->data, fb, &damage); } drm_dev_exit(idx); @@ -424,62 +364,11 @@ static const struct drm_plane_helper_funcs cirrus_primary_plane_helper_funcs = { .atomic_update = cirrus_primary_plane_helper_atomic_update, }; -static struct drm_plane_state * -cirrus_primary_plane_atomic_duplicate_state(struct drm_plane *plane) -{ - struct drm_plane_state *plane_state = plane->state; - struct cirrus_primary_plane_state *primary_plane_state = - to_cirrus_primary_plane_state(plane_state); - struct cirrus_primary_plane_state *new_primary_plane_state; - struct drm_shadow_plane_state *new_shadow_plane_state; - - if (!plane_state) - return NULL; - - new_primary_plane_state = kzalloc(sizeof(*new_primary_plane_state), GFP_KERNEL); - if (!new_primary_plane_state) - return NULL; - new_shadow_plane_state = &new_primary_plane_state->base; - - __drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state); - new_primary_plane_state->format = primary_plane_state->format; - new_primary_plane_state->pitch = primary_plane_state->pitch; - - return &new_shadow_plane_state->base; -} - -static void cirrus_primary_plane_atomic_destroy_state(struct drm_plane *plane, - struct drm_plane_state *plane_state) -{ - struct cirrus_primary_plane_state *primary_plane_state = - to_cirrus_primary_plane_state(plane_state); - - __drm_gem_destroy_shadow_plane_state(&primary_plane_state->base); - kfree(primary_plane_state); -} - -static void cirrus_reset_primary_plane(struct drm_plane *plane) -{ - struct cirrus_primary_plane_state *primary_plane_state; - - if (plane->state) { - cirrus_primary_plane_atomic_destroy_state(plane, plane->state); - plane->state = NULL; /* must be set to NULL here */ - } - - primary_plane_state = kzalloc(sizeof(*primary_plane_state), GFP_KERNEL); - if (!primary_plane_state) - return; - __drm_gem_reset_shadow_plane(plane, &primary_plane_state->base); -} - static const struct drm_plane_funcs cirrus_primary_plane_funcs = { .update_plane = drm_atomic_helper_update_plane, .disable_plane = drm_atomic_helper_disable_plane, .destroy = drm_plane_cleanup, - .reset = cirrus_reset_primary_plane, - .atomic_duplicate_state = cirrus_primary_plane_atomic_duplicate_state, - .atomic_destroy_state = cirrus_primary_plane_atomic_destroy_state, + DRM_GEM_SHADOW_PLANE_FUNCS, }; static int cirrus_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state) @@ -614,9 +503,17 @@ static enum drm_mode_status cirrus_mode_config_mode_valid(struct drm_device *dev const struct drm_display_mode *mode) { const struct drm_format_info *format = drm_format_info(DRM_FORMAT_XRGB8888); - uint64_t pitch = drm_format_info_min_pitch(format, 0, mode->hdisplay); + u64 pitch; - if (pitch * mode->vdisplay > CIRRUS_VRAM_SIZE) + if (drm_WARN_ON_ONCE(dev, !format)) + return MODE_ERROR; /* driver bug */ + + pitch = drm_format_info_min_pitch(format, 0, mode->hdisplay); + if (!pitch) + return MODE_BAD_WIDTH; + if (pitch > CIRRUS_MAX_PITCH) + return MODE_BAD_WIDTH; /* maximum programmable pitch */ + if (pitch > CIRRUS_VRAM_SIZE / mode->vdisplay) return MODE_MEM; return MODE_OK; @@ -681,7 +578,7 @@ static int cirrus_pci_probe(struct pci_dev *pdev, if (ret) return ret; - ret = pci_request_regions(pdev, DRIVER_NAME); + ret = pcim_request_all_regions(pdev, DRIVER_NAME); if (ret) return ret; diff --git a/drivers/gpu/drm/tiny/gm12u320.c b/drivers/gpu/drm/tiny/gm12u320.c index 41e9bfb2e2ff..fb0004166f4a 100644 --- a/drivers/gpu/drm/tiny/gm12u320.c +++ b/drivers/gpu/drm/tiny/gm12u320.c @@ -86,7 +86,6 @@ MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)"); struct gm12u320_device { struct drm_device dev; - struct device *dmadev; struct drm_simple_display_pipe pipe; struct drm_connector conn; unsigned char *cmd_buf; @@ -602,22 +601,6 @@ static const uint64_t gm12u320_pipe_modifiers[] = { DRM_FORMAT_MOD_INVALID }; -/* - * FIXME: Dma-buf sharing requires DMA support by the importing device. - * This function is a workaround to make USB devices work as well. - * See todo.rst for how to fix the issue in the dma-buf framework. - */ -static struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev, - struct dma_buf *dma_buf) -{ - struct gm12u320_device *gm12u320 = to_gm12u320(dev); - - if (!gm12u320->dmadev) - return ERR_PTR(-ENODEV); - - return drm_gem_prime_import_dev(dev, dma_buf, gm12u320->dmadev); -} - DEFINE_DRM_GEM_FOPS(gm12u320_fops); static const struct drm_driver gm12u320_drm_driver = { @@ -630,7 +613,6 @@ static const struct drm_driver gm12u320_drm_driver = { .fops = &gm12u320_fops, DRM_GEM_SHMEM_DRIVER_OPS, - .gem_prime_import = gm12u320_gem_prime_import, DRM_FBDEV_SHMEM_DRIVER_OPS, }; @@ -645,6 +627,7 @@ static int gm12u320_usb_probe(struct usb_interface *interface, { struct gm12u320_device *gm12u320; struct drm_device *dev; + struct device *dma_dev; int ret; /* @@ -660,16 +643,20 @@ static int gm12u320_usb_probe(struct usb_interface *interface, return PTR_ERR(gm12u320); dev = &gm12u320->dev; - gm12u320->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev)); - if (!gm12u320->dmadev) + dma_dev = usb_intf_get_dma_device(interface); + if (dma_dev) { + drm_dev_set_dma_dev(dev, dma_dev); + put_device(dma_dev); + } else { drm_warn(dev, "buffer sharing not supported"); /* not an error */ + } INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work); mutex_init(&gm12u320->fb_update.lock); ret = drmm_mode_config_init(dev); if (ret) - goto err_put_device; + return ret; dev->mode_config.min_width = GM12U320_USER_WIDTH; dev->mode_config.max_width = GM12U320_USER_WIDTH; @@ -679,15 +666,15 @@ static int gm12u320_usb_probe(struct usb_interface *interface, ret = gm12u320_usb_alloc(gm12u320); if (ret) - goto err_put_device; + return ret; ret = gm12u320_set_ecomode(gm12u320); if (ret) - goto err_put_device; + return ret; ret = gm12u320_conn_init(gm12u320); if (ret) - goto err_put_device; + return ret; ret = drm_simple_display_pipe_init(&gm12u320->dev, &gm12u320->pipe, @@ -697,31 +684,24 @@ static int gm12u320_usb_probe(struct usb_interface *interface, gm12u320_pipe_modifiers, &gm12u320->conn); if (ret) - goto err_put_device; + return ret; drm_mode_config_reset(dev); usb_set_intfdata(interface, dev); ret = drm_dev_register(dev, 0); if (ret) - goto err_put_device; + return ret; drm_client_setup(dev, NULL); return 0; - -err_put_device: - put_device(gm12u320->dmadev); - return ret; } static void gm12u320_usb_disconnect(struct usb_interface *interface) { struct drm_device *dev = usb_get_intfdata(interface); - struct gm12u320_device *gm12u320 = to_gm12u320(dev); - put_device(gm12u320->dmadev); - gm12u320->dmadev = NULL; drm_dev_unplug(dev); drm_atomic_helper_shutdown(dev); } diff --git a/drivers/gpu/drm/tiny/ofdrm.c b/drivers/gpu/drm/tiny/ofdrm.c deleted file mode 100644 index 13491c0e704a..000000000000 --- a/drivers/gpu/drm/tiny/ofdrm.c +++ /dev/null @@ -1,1405 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only - -#include <linux/aperture.h> -#include <linux/of_address.h> -#include <linux/pci.h> -#include <linux/platform_device.h> - -#include <drm/clients/drm_client_setup.h> -#include <drm/drm_atomic.h> -#include <drm/drm_atomic_state_helper.h> -#include <drm/drm_connector.h> -#include <drm/drm_damage_helper.h> -#include <drm/drm_device.h> -#include <drm/drm_drv.h> -#include <drm/drm_fbdev_shmem.h> -#include <drm/drm_format_helper.h> -#include <drm/drm_framebuffer.h> -#include <drm/drm_gem_atomic_helper.h> -#include <drm/drm_gem_framebuffer_helper.h> -#include <drm/drm_gem_shmem_helper.h> -#include <drm/drm_managed.h> -#include <drm/drm_modeset_helper_vtables.h> -#include <drm/drm_probe_helper.h> -#include <drm/drm_simple_kms_helper.h> - -#define DRIVER_NAME "ofdrm" -#define DRIVER_DESC "DRM driver for OF platform devices" -#define DRIVER_MAJOR 1 -#define DRIVER_MINOR 0 - -#define PCI_VENDOR_ID_ATI_R520 0x7100 -#define PCI_VENDOR_ID_ATI_R600 0x9400 - -#define OFDRM_GAMMA_LUT_SIZE 256 - -/* Definitions used by the Avivo palette */ -#define AVIVO_DC_LUT_RW_SELECT 0x6480 -#define AVIVO_DC_LUT_RW_MODE 0x6484 -#define AVIVO_DC_LUT_RW_INDEX 0x6488 -#define AVIVO_DC_LUT_SEQ_COLOR 0x648c -#define AVIVO_DC_LUT_PWL_DATA 0x6490 -#define AVIVO_DC_LUT_30_COLOR 0x6494 -#define AVIVO_DC_LUT_READ_PIPE_SELECT 0x6498 -#define AVIVO_DC_LUT_WRITE_EN_MASK 0x649c -#define AVIVO_DC_LUT_AUTOFILL 0x64a0 -#define AVIVO_DC_LUTA_CONTROL 0x64c0 -#define AVIVO_DC_LUTA_BLACK_OFFSET_BLUE 0x64c4 -#define AVIVO_DC_LUTA_BLACK_OFFSET_GREEN 0x64c8 -#define AVIVO_DC_LUTA_BLACK_OFFSET_RED 0x64cc -#define AVIVO_DC_LUTA_WHITE_OFFSET_BLUE 0x64d0 -#define AVIVO_DC_LUTA_WHITE_OFFSET_GREEN 0x64d4 -#define AVIVO_DC_LUTA_WHITE_OFFSET_RED 0x64d8 -#define AVIVO_DC_LUTB_CONTROL 0x6cc0 -#define AVIVO_DC_LUTB_BLACK_OFFSET_BLUE 0x6cc4 -#define AVIVO_DC_LUTB_BLACK_OFFSET_GREEN 0x6cc8 -#define AVIVO_DC_LUTB_BLACK_OFFSET_RED 0x6ccc -#define AVIVO_DC_LUTB_WHITE_OFFSET_BLUE 0x6cd0 -#define AVIVO_DC_LUTB_WHITE_OFFSET_GREEN 0x6cd4 -#define AVIVO_DC_LUTB_WHITE_OFFSET_RED 0x6cd8 - -enum ofdrm_model { - OFDRM_MODEL_UNKNOWN, - OFDRM_MODEL_MACH64, /* ATI Mach64 */ - OFDRM_MODEL_RAGE128, /* ATI Rage128 */ - OFDRM_MODEL_RAGE_M3A, /* ATI Rage Mobility M3 Head A */ - OFDRM_MODEL_RAGE_M3B, /* ATI Rage Mobility M3 Head B */ - OFDRM_MODEL_RADEON, /* ATI Radeon */ - OFDRM_MODEL_GXT2000, /* IBM GXT2000 */ - OFDRM_MODEL_AVIVO, /* ATI R5xx */ - OFDRM_MODEL_QEMU, /* QEMU VGA */ -}; - -/* - * Helpers for display nodes - */ - -static int display_get_validated_int(struct drm_device *dev, const char *name, uint32_t value) -{ - if (value > INT_MAX) { - drm_err(dev, "invalid framebuffer %s of %u\n", name, value); - return -EINVAL; - } - return (int)value; -} - -static int display_get_validated_int0(struct drm_device *dev, const char *name, uint32_t value) -{ - if (!value) { - drm_err(dev, "invalid framebuffer %s of %u\n", name, value); - return -EINVAL; - } - return display_get_validated_int(dev, name, value); -} - -static const struct drm_format_info *display_get_validated_format(struct drm_device *dev, - u32 depth, bool big_endian) -{ - const struct drm_format_info *info; - u32 format; - - switch (depth) { - case 8: - format = drm_mode_legacy_fb_format(8, 8); - break; - case 15: - case 16: - format = drm_mode_legacy_fb_format(16, depth); - break; - case 32: - format = drm_mode_legacy_fb_format(32, 24); - break; - default: - drm_err(dev, "unsupported framebuffer depth %u\n", depth); - return ERR_PTR(-EINVAL); - } - - /* - * DRM formats assume little-endian byte order. Update the format - * if the scanout buffer uses big-endian ordering. - */ - if (big_endian) { - switch (format) { - case DRM_FORMAT_XRGB8888: - format = DRM_FORMAT_BGRX8888; - break; - case DRM_FORMAT_ARGB8888: - format = DRM_FORMAT_BGRA8888; - break; - case DRM_FORMAT_RGB565: - format = DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN; - break; - case DRM_FORMAT_XRGB1555: - format = DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN; - break; - default: - break; - } - } - - info = drm_format_info(format); - if (!info) { - drm_err(dev, "cannot find framebuffer format for depth %u\n", depth); - return ERR_PTR(-EINVAL); - } - - return info; -} - -static int display_read_u32_of(struct drm_device *dev, struct device_node *of_node, - const char *name, u32 *value) -{ - int ret = of_property_read_u32(of_node, name, value); - - if (ret) - drm_err(dev, "cannot parse framebuffer %s: error %d\n", name, ret); - return ret; -} - -static bool display_get_big_endian_of(struct drm_device *dev, struct device_node *of_node) -{ - bool big_endian; - -#ifdef __BIG_ENDIAN - big_endian = !of_property_read_bool(of_node, "little-endian"); -#else - big_endian = of_property_read_bool(of_node, "big-endian"); -#endif - - return big_endian; -} - -static int display_get_width_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 width; - int ret = display_read_u32_of(dev, of_node, "width", &width); - - if (ret) - return ret; - return display_get_validated_int0(dev, "width", width); -} - -static int display_get_height_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 height; - int ret = display_read_u32_of(dev, of_node, "height", &height); - - if (ret) - return ret; - return display_get_validated_int0(dev, "height", height); -} - -static int display_get_depth_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 depth; - int ret = display_read_u32_of(dev, of_node, "depth", &depth); - - if (ret) - return ret; - return display_get_validated_int0(dev, "depth", depth); -} - -static int display_get_linebytes_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 linebytes; - int ret = display_read_u32_of(dev, of_node, "linebytes", &linebytes); - - if (ret) - return ret; - return display_get_validated_int(dev, "linebytes", linebytes); -} - -static u64 display_get_address_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 address; - int ret; - - /* - * Not all devices provide an address property, it's not - * a bug if this fails. The driver will try to find the - * framebuffer base address from the device's memory regions. - */ - ret = of_property_read_u32(of_node, "address", &address); - if (ret) - return OF_BAD_ADDR; - - return address; -} - -static bool is_avivo(u32 vendor, u32 device) -{ - /* This will match most R5xx */ - return (vendor == PCI_VENDOR_ID_ATI) && - ((device >= PCI_VENDOR_ID_ATI_R520 && device < 0x7800) || - (PCI_VENDOR_ID_ATI_R600 >= 0x9400)); -} - -static enum ofdrm_model display_get_model_of(struct drm_device *dev, struct device_node *of_node) -{ - enum ofdrm_model model = OFDRM_MODEL_UNKNOWN; - - if (of_node_name_prefix(of_node, "ATY,Rage128")) { - model = OFDRM_MODEL_RAGE128; - } else if (of_node_name_prefix(of_node, "ATY,RageM3pA") || - of_node_name_prefix(of_node, "ATY,RageM3p12A")) { - model = OFDRM_MODEL_RAGE_M3A; - } else if (of_node_name_prefix(of_node, "ATY,RageM3pB")) { - model = OFDRM_MODEL_RAGE_M3B; - } else if (of_node_name_prefix(of_node, "ATY,Rage6")) { - model = OFDRM_MODEL_RADEON; - } else if (of_node_name_prefix(of_node, "ATY,")) { - return OFDRM_MODEL_MACH64; - } else if (of_device_is_compatible(of_node, "pci1014,b7") || - of_device_is_compatible(of_node, "pci1014,21c")) { - model = OFDRM_MODEL_GXT2000; - } else if (of_node_name_prefix(of_node, "vga,Display-")) { - struct device_node *of_parent; - const __be32 *vendor_p, *device_p; - - /* Look for AVIVO initialized by SLOF */ - of_parent = of_get_parent(of_node); - vendor_p = of_get_property(of_parent, "vendor-id", NULL); - device_p = of_get_property(of_parent, "device-id", NULL); - if (vendor_p && device_p) { - u32 vendor = be32_to_cpup(vendor_p); - u32 device = be32_to_cpup(device_p); - - if (is_avivo(vendor, device)) - model = OFDRM_MODEL_AVIVO; - } - of_node_put(of_parent); - } else if (of_device_is_compatible(of_node, "qemu,std-vga")) { - model = OFDRM_MODEL_QEMU; - } - - return model; -} - -/* - * Open Firmware display device - */ - -struct ofdrm_device; - -struct ofdrm_device_funcs { - void __iomem *(*cmap_ioremap)(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_bas); - void (*cmap_write)(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b); -}; - -struct ofdrm_device { - struct drm_device dev; - struct platform_device *pdev; - - const struct ofdrm_device_funcs *funcs; - - /* firmware-buffer settings */ - struct iosys_map screen_base; - struct drm_display_mode mode; - const struct drm_format_info *format; - unsigned int pitch; - - /* colormap */ - void __iomem *cmap_base; - - /* modesetting */ - uint32_t formats[8]; - struct drm_plane primary_plane; - struct drm_crtc crtc; - struct drm_encoder encoder; - struct drm_connector connector; -}; - -static struct ofdrm_device *ofdrm_device_of_dev(struct drm_device *dev) -{ - return container_of(dev, struct ofdrm_device, dev); -} - -/* - * Hardware - */ - -#if defined(CONFIG_PCI) -static struct pci_dev *display_get_pci_dev_of(struct drm_device *dev, struct device_node *of_node) -{ - const __be32 *vendor_p, *device_p; - u32 vendor, device; - struct pci_dev *pcidev; - - vendor_p = of_get_property(of_node, "vendor-id", NULL); - if (!vendor_p) - return ERR_PTR(-ENODEV); - vendor = be32_to_cpup(vendor_p); - - device_p = of_get_property(of_node, "device-id", NULL); - if (!device_p) - return ERR_PTR(-ENODEV); - device = be32_to_cpup(device_p); - - pcidev = pci_get_device(vendor, device, NULL); - if (!pcidev) - return ERR_PTR(-ENODEV); - - return pcidev; -} - -static void ofdrm_pci_release(void *data) -{ - struct pci_dev *pcidev = data; - - pci_disable_device(pcidev); -} - -static int ofdrm_device_init_pci(struct ofdrm_device *odev) -{ - struct drm_device *dev = &odev->dev; - struct platform_device *pdev = to_platform_device(dev->dev); - struct device_node *of_node = pdev->dev.of_node; - struct pci_dev *pcidev; - int ret; - - /* - * Never use pcim_ or other managed helpers on the returned PCI - * device. Otherwise, probing the native driver will fail for - * resource conflicts. PCI-device management has to be tied to - * the lifetime of the platform device until the native driver - * takes over. - */ - pcidev = display_get_pci_dev_of(dev, of_node); - if (IS_ERR(pcidev)) - return 0; /* no PCI device found; ignore the error */ - - ret = pci_enable_device(pcidev); - if (ret) { - drm_err(dev, "pci_enable_device(%s) failed: %d\n", - dev_name(&pcidev->dev), ret); - return ret; - } - ret = devm_add_action_or_reset(&pdev->dev, ofdrm_pci_release, pcidev); - if (ret) - return ret; - - return 0; -} -#else -static int ofdrm_device_init_pci(struct ofdrm_device *odev) -{ - return 0; -} -#endif - -/* - * OF display settings - */ - -static struct resource *ofdrm_find_fb_resource(struct ofdrm_device *odev, - struct resource *fb_res) -{ - struct platform_device *pdev = to_platform_device(odev->dev.dev); - struct resource *res, *max_res = NULL; - u32 i; - - for (i = 0; pdev->num_resources; ++i) { - res = platform_get_resource(pdev, IORESOURCE_MEM, i); - if (!res) - break; /* all resources processed */ - if (resource_size(res) < resource_size(fb_res)) - continue; /* resource too small */ - if (fb_res->start && resource_contains(res, fb_res)) - return res; /* resource contains framebuffer */ - if (!max_res || resource_size(res) > resource_size(max_res)) - max_res = res; /* store largest resource as fallback */ - } - - return max_res; -} - -/* - * Colormap / Palette - */ - -static void __iomem *get_cmap_address_of(struct ofdrm_device *odev, struct device_node *of_node, - int bar_no, unsigned long offset, unsigned long size) -{ - struct drm_device *dev = &odev->dev; - const __be32 *addr_p; - u64 max_size, address; - unsigned int flags; - void __iomem *mem; - - addr_p = of_get_pci_address(of_node, bar_no, &max_size, &flags); - if (!addr_p) - addr_p = of_get_address(of_node, bar_no, &max_size, &flags); - if (!addr_p) - return IOMEM_ERR_PTR(-ENODEV); - - if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0) - return IOMEM_ERR_PTR(-ENODEV); - - if ((offset + size) >= max_size) - return IOMEM_ERR_PTR(-ENODEV); - - address = of_translate_address(of_node, addr_p); - if (address == OF_BAD_ADDR) - return IOMEM_ERR_PTR(-ENODEV); - - mem = devm_ioremap(dev->dev, address + offset, size); - if (!mem) - return IOMEM_ERR_PTR(-ENOMEM); - - return mem; -} - -static void __iomem *ofdrm_mach64_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - struct drm_device *dev = &odev->dev; - u64 address; - void __iomem *cmap_base; - - address = fb_base & 0xff000000ul; - address += 0x7ff000; - - cmap_base = devm_ioremap(dev->dev, address, 0x1000); - if (!cmap_base) - return IOMEM_ERR_PTR(-ENOMEM); - - return cmap_base; -} - -static void ofdrm_mach64_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *addr = odev->cmap_base + 0xcc0; - void __iomem *data = odev->cmap_base + 0xcc0 + 1; - - writeb(index, addr); - writeb(r, data); - writeb(g, data); - writeb(b, data); -} - -static void __iomem *ofdrm_rage128_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - return get_cmap_address_of(odev, of_node, 2, 0, 0x1fff); -} - -static void ofdrm_rage128_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *addr = odev->cmap_base + 0xb0; - void __iomem *data = odev->cmap_base + 0xb4; - u32 color = (r << 16) | (g << 8) | b; - - writeb(index, addr); - writel(color, data); -} - -static void __iomem *ofdrm_rage_m3a_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - return get_cmap_address_of(odev, of_node, 2, 0, 0x1fff); -} - -static void ofdrm_rage_m3a_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *dac_ctl = odev->cmap_base + 0x58; - void __iomem *addr = odev->cmap_base + 0xb0; - void __iomem *data = odev->cmap_base + 0xb4; - u32 color = (r << 16) | (g << 8) | b; - u32 val; - - /* Clear PALETTE_ACCESS_CNTL in DAC_CNTL */ - val = readl(dac_ctl); - val &= ~0x20; - writel(val, dac_ctl); - - /* Set color at palette index */ - writeb(index, addr); - writel(color, data); -} - -static void __iomem *ofdrm_rage_m3b_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - return get_cmap_address_of(odev, of_node, 2, 0, 0x1fff); -} - -static void ofdrm_rage_m3b_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *dac_ctl = odev->cmap_base + 0x58; - void __iomem *addr = odev->cmap_base + 0xb0; - void __iomem *data = odev->cmap_base + 0xb4; - u32 color = (r << 16) | (g << 8) | b; - u32 val; - - /* Set PALETTE_ACCESS_CNTL in DAC_CNTL */ - val = readl(dac_ctl); - val |= 0x20; - writel(val, dac_ctl); - - /* Set color at palette index */ - writeb(index, addr); - writel(color, data); -} - -static void __iomem *ofdrm_radeon_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - return get_cmap_address_of(odev, of_node, 1, 0, 0x1fff); -} - -static void __iomem *ofdrm_gxt2000_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - return get_cmap_address_of(odev, of_node, 0, 0x6000, 0x1000); -} - -static void ofdrm_gxt2000_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *data = ((unsigned int __iomem *)odev->cmap_base) + index; - u32 color = (r << 16) | (g << 8) | b; - - writel(color, data); -} - -static void __iomem *ofdrm_avivo_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - struct device_node *of_parent; - void __iomem *cmap_base; - - of_parent = of_get_parent(of_node); - cmap_base = get_cmap_address_of(odev, of_parent, 0, 0, 0x10000); - of_node_put(of_parent); - - return cmap_base; -} - -static void ofdrm_avivo_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *lutsel = odev->cmap_base + AVIVO_DC_LUT_RW_SELECT; - void __iomem *addr = odev->cmap_base + AVIVO_DC_LUT_RW_INDEX; - void __iomem *data = odev->cmap_base + AVIVO_DC_LUT_30_COLOR; - u32 color = (r << 22) | (g << 12) | (b << 2); - - /* Write to both LUTs for now */ - - writel(1, lutsel); - writeb(index, addr); - writel(color, data); - - writel(0, lutsel); - writeb(index, addr); - writel(color, data); -} - -static void __iomem *ofdrm_qemu_cmap_ioremap(struct ofdrm_device *odev, - struct device_node *of_node, - u64 fb_base) -{ - static const __be32 io_of_addr[3] = { - cpu_to_be32(0x01000000), - cpu_to_be32(0x00), - cpu_to_be32(0x00), - }; - - struct drm_device *dev = &odev->dev; - u64 address; - void __iomem *cmap_base; - - address = of_translate_address(of_node, io_of_addr); - if (address == OF_BAD_ADDR) - return IOMEM_ERR_PTR(-ENODEV); - - cmap_base = devm_ioremap(dev->dev, address + 0x3c8, 2); - if (!cmap_base) - return IOMEM_ERR_PTR(-ENOMEM); - - return cmap_base; -} - -static void ofdrm_qemu_cmap_write(struct ofdrm_device *odev, unsigned char index, - unsigned char r, unsigned char g, unsigned char b) -{ - void __iomem *addr = odev->cmap_base; - void __iomem *data = odev->cmap_base + 1; - - writeb(index, addr); - writeb(r, data); - writeb(g, data); - writeb(b, data); -} - -static void ofdrm_device_set_gamma_linear(struct ofdrm_device *odev, - const struct drm_format_info *format) -{ - struct drm_device *dev = &odev->dev; - int i; - - switch (format->format) { - case DRM_FORMAT_RGB565: - case DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN: - /* Use better interpolation, to take 32 values from 0 to 255 */ - for (i = 0; i < OFDRM_GAMMA_LUT_SIZE / 8; i++) { - unsigned char r = i * 8 + i / 4; - unsigned char g = i * 4 + i / 16; - unsigned char b = i * 8 + i / 4; - - odev->funcs->cmap_write(odev, i, r, g, b); - } - /* Green has one more bit, so add padding with 0 for red and blue. */ - for (i = OFDRM_GAMMA_LUT_SIZE / 8; i < OFDRM_GAMMA_LUT_SIZE / 4; i++) { - unsigned char r = 0; - unsigned char g = i * 4 + i / 16; - unsigned char b = 0; - - odev->funcs->cmap_write(odev, i, r, g, b); - } - break; - case DRM_FORMAT_XRGB8888: - case DRM_FORMAT_BGRX8888: - for (i = 0; i < OFDRM_GAMMA_LUT_SIZE; i++) - odev->funcs->cmap_write(odev, i, i, i, i); - break; - default: - drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", - &format->format); - break; - } -} - -static void ofdrm_device_set_gamma(struct ofdrm_device *odev, - const struct drm_format_info *format, - struct drm_color_lut *lut) -{ - struct drm_device *dev = &odev->dev; - int i; - - switch (format->format) { - case DRM_FORMAT_RGB565: - case DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN: - /* Use better interpolation, to take 32 values from lut[0] to lut[255] */ - for (i = 0; i < OFDRM_GAMMA_LUT_SIZE / 8; i++) { - unsigned char r = lut[i * 8 + i / 4].red >> 8; - unsigned char g = lut[i * 4 + i / 16].green >> 8; - unsigned char b = lut[i * 8 + i / 4].blue >> 8; - - odev->funcs->cmap_write(odev, i, r, g, b); - } - /* Green has one more bit, so add padding with 0 for red and blue. */ - for (i = OFDRM_GAMMA_LUT_SIZE / 8; i < OFDRM_GAMMA_LUT_SIZE / 4; i++) { - unsigned char r = 0; - unsigned char g = lut[i * 4 + i / 16].green >> 8; - unsigned char b = 0; - - odev->funcs->cmap_write(odev, i, r, g, b); - } - break; - case DRM_FORMAT_XRGB8888: - case DRM_FORMAT_BGRX8888: - for (i = 0; i < OFDRM_GAMMA_LUT_SIZE; i++) { - unsigned char r = lut[i].red >> 8; - unsigned char g = lut[i].green >> 8; - unsigned char b = lut[i].blue >> 8; - - odev->funcs->cmap_write(odev, i, r, g, b); - } - break; - default: - drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n", - &format->format); - break; - } -} - -/* - * Modesetting - */ - -struct ofdrm_crtc_state { - struct drm_crtc_state base; - - /* Primary-plane format; required for color mgmt. */ - const struct drm_format_info *format; -}; - -static struct ofdrm_crtc_state *to_ofdrm_crtc_state(struct drm_crtc_state *base) -{ - return container_of(base, struct ofdrm_crtc_state, base); -} - -static void ofdrm_crtc_state_destroy(struct ofdrm_crtc_state *ofdrm_crtc_state) -{ - __drm_atomic_helper_crtc_destroy_state(&ofdrm_crtc_state->base); - kfree(ofdrm_crtc_state); -} - -static const uint64_t ofdrm_primary_plane_format_modifiers[] = { - DRM_FORMAT_MOD_LINEAR, - DRM_FORMAT_MOD_INVALID -}; - -static int ofdrm_primary_plane_helper_atomic_check(struct drm_plane *plane, - struct drm_atomic_state *new_state) -{ - struct drm_device *dev = plane->dev; - struct ofdrm_device *odev = ofdrm_device_of_dev(dev); - struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane); - struct drm_shadow_plane_state *new_shadow_plane_state = - to_drm_shadow_plane_state(new_plane_state); - struct drm_framebuffer *new_fb = new_plane_state->fb; - struct drm_crtc *new_crtc = new_plane_state->crtc; - struct drm_crtc_state *new_crtc_state = NULL; - struct ofdrm_crtc_state *new_ofdrm_crtc_state; - int ret; - - if (new_crtc) - new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc); - - ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state, - DRM_PLANE_NO_SCALING, - DRM_PLANE_NO_SCALING, - false, false); - if (ret) - return ret; - else if (!new_plane_state->visible) - return 0; - - if (new_fb->format != odev->format) { - void *buf; - - /* format conversion necessary; reserve buffer */ - buf = drm_format_conv_state_reserve(&new_shadow_plane_state->fmtcnv_state, - odev->pitch, GFP_KERNEL); - if (!buf) - return -ENOMEM; - } - - new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc); - - new_ofdrm_crtc_state = to_ofdrm_crtc_state(new_crtc_state); - new_ofdrm_crtc_state->format = new_fb->format; - - return 0; -} - -static void ofdrm_primary_plane_helper_atomic_update(struct drm_plane *plane, - struct drm_atomic_state *state) -{ - struct drm_device *dev = plane->dev; - struct ofdrm_device *odev = ofdrm_device_of_dev(dev); - struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); - struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); - struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); - struct drm_framebuffer *fb = plane_state->fb; - unsigned int dst_pitch = odev->pitch; - const struct drm_format_info *dst_format = odev->format; - struct drm_atomic_helper_damage_iter iter; - struct drm_rect damage; - int ret, idx; - - ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); - if (ret) - return; - - if (!drm_dev_enter(dev, &idx)) - goto out_drm_gem_fb_end_cpu_access; - - drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); - drm_atomic_for_each_plane_damage(&iter, &damage) { - struct iosys_map dst = odev->screen_base; - struct drm_rect dst_clip = plane_state->dst; - - if (!drm_rect_intersect(&dst_clip, &damage)) - continue; - - iosys_map_incr(&dst, drm_fb_clip_offset(dst_pitch, dst_format, &dst_clip)); - drm_fb_blit(&dst, &dst_pitch, dst_format->format, shadow_plane_state->data, fb, - &damage, &shadow_plane_state->fmtcnv_state); - } - - drm_dev_exit(idx); -out_drm_gem_fb_end_cpu_access: - drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); -} - -static void ofdrm_primary_plane_helper_atomic_disable(struct drm_plane *plane, - struct drm_atomic_state *state) -{ - struct drm_device *dev = plane->dev; - struct ofdrm_device *odev = ofdrm_device_of_dev(dev); - struct iosys_map dst = odev->screen_base; - struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); - void __iomem *dst_vmap = dst.vaddr_iomem; /* TODO: Use mapping abstraction */ - unsigned int dst_pitch = odev->pitch; - const struct drm_format_info *dst_format = odev->format; - struct drm_rect dst_clip; - unsigned long lines, linepixels, i; - int idx; - - drm_rect_init(&dst_clip, - plane_state->src_x >> 16, plane_state->src_y >> 16, - plane_state->src_w >> 16, plane_state->src_h >> 16); - - lines = drm_rect_height(&dst_clip); - linepixels = drm_rect_width(&dst_clip); - - if (!drm_dev_enter(dev, &idx)) - return; - - /* Clear buffer to black if disabled */ - dst_vmap += drm_fb_clip_offset(dst_pitch, dst_format, &dst_clip); - for (i = 0; i < lines; ++i) { - memset_io(dst_vmap, 0, linepixels * dst_format->cpp[0]); - dst_vmap += dst_pitch; - } - - drm_dev_exit(idx); -} - -static const struct drm_plane_helper_funcs ofdrm_primary_plane_helper_funcs = { - DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, - .atomic_check = ofdrm_primary_plane_helper_atomic_check, - .atomic_update = ofdrm_primary_plane_helper_atomic_update, - .atomic_disable = ofdrm_primary_plane_helper_atomic_disable, -}; - -static const struct drm_plane_funcs ofdrm_primary_plane_funcs = { - .update_plane = drm_atomic_helper_update_plane, - .disable_plane = drm_atomic_helper_disable_plane, - .destroy = drm_plane_cleanup, - DRM_GEM_SHADOW_PLANE_FUNCS, -}; - -static enum drm_mode_status ofdrm_crtc_helper_mode_valid(struct drm_crtc *crtc, - const struct drm_display_mode *mode) -{ - struct ofdrm_device *odev = ofdrm_device_of_dev(crtc->dev); - - return drm_crtc_helper_mode_valid_fixed(crtc, mode, &odev->mode); -} - -static int ofdrm_crtc_helper_atomic_check(struct drm_crtc *crtc, - struct drm_atomic_state *new_state) -{ - static const size_t gamma_lut_length = OFDRM_GAMMA_LUT_SIZE * sizeof(struct drm_color_lut); - - struct drm_device *dev = crtc->dev; - struct drm_crtc_state *new_crtc_state = drm_atomic_get_new_crtc_state(new_state, crtc); - int ret; - - if (!new_crtc_state->enable) - return 0; - - ret = drm_atomic_helper_check_crtc_primary_plane(new_crtc_state); - if (ret) - return ret; - - if (new_crtc_state->color_mgmt_changed) { - struct drm_property_blob *gamma_lut = new_crtc_state->gamma_lut; - - if (gamma_lut && (gamma_lut->length != gamma_lut_length)) { - drm_dbg(dev, "Incorrect gamma_lut length %zu\n", gamma_lut->length); - return -EINVAL; - } - } - - return 0; -} - -static void ofdrm_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *state) -{ - struct ofdrm_device *odev = ofdrm_device_of_dev(crtc->dev); - struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); - struct ofdrm_crtc_state *ofdrm_crtc_state = to_ofdrm_crtc_state(crtc_state); - - if (crtc_state->enable && crtc_state->color_mgmt_changed) { - const struct drm_format_info *format = ofdrm_crtc_state->format; - - if (crtc_state->gamma_lut) - ofdrm_device_set_gamma(odev, format, crtc_state->gamma_lut->data); - else - ofdrm_device_set_gamma_linear(odev, format); - } -} - -/* - * The CRTC is always enabled. Screen updates are performed by - * the primary plane's atomic_update function. Disabling clears - * the screen in the primary plane's atomic_disable function. - */ -static const struct drm_crtc_helper_funcs ofdrm_crtc_helper_funcs = { - .mode_valid = ofdrm_crtc_helper_mode_valid, - .atomic_check = ofdrm_crtc_helper_atomic_check, - .atomic_flush = ofdrm_crtc_helper_atomic_flush, -}; - -static void ofdrm_crtc_reset(struct drm_crtc *crtc) -{ - struct ofdrm_crtc_state *ofdrm_crtc_state = - kzalloc(sizeof(*ofdrm_crtc_state), GFP_KERNEL); - - if (crtc->state) - ofdrm_crtc_state_destroy(to_ofdrm_crtc_state(crtc->state)); - - if (ofdrm_crtc_state) - __drm_atomic_helper_crtc_reset(crtc, &ofdrm_crtc_state->base); - else - __drm_atomic_helper_crtc_reset(crtc, NULL); -} - -static struct drm_crtc_state *ofdrm_crtc_atomic_duplicate_state(struct drm_crtc *crtc) -{ - struct drm_device *dev = crtc->dev; - struct drm_crtc_state *crtc_state = crtc->state; - struct ofdrm_crtc_state *new_ofdrm_crtc_state; - struct ofdrm_crtc_state *ofdrm_crtc_state; - - if (drm_WARN_ON(dev, !crtc_state)) - return NULL; - - new_ofdrm_crtc_state = kzalloc(sizeof(*new_ofdrm_crtc_state), GFP_KERNEL); - if (!new_ofdrm_crtc_state) - return NULL; - - ofdrm_crtc_state = to_ofdrm_crtc_state(crtc_state); - - __drm_atomic_helper_crtc_duplicate_state(crtc, &new_ofdrm_crtc_state->base); - new_ofdrm_crtc_state->format = ofdrm_crtc_state->format; - - return &new_ofdrm_crtc_state->base; -} - -static void ofdrm_crtc_atomic_destroy_state(struct drm_crtc *crtc, - struct drm_crtc_state *crtc_state) -{ - ofdrm_crtc_state_destroy(to_ofdrm_crtc_state(crtc_state)); -} - -static const struct drm_crtc_funcs ofdrm_crtc_funcs = { - .reset = ofdrm_crtc_reset, - .destroy = drm_crtc_cleanup, - .set_config = drm_atomic_helper_set_config, - .page_flip = drm_atomic_helper_page_flip, - .atomic_duplicate_state = ofdrm_crtc_atomic_duplicate_state, - .atomic_destroy_state = ofdrm_crtc_atomic_destroy_state, -}; - -static int ofdrm_connector_helper_get_modes(struct drm_connector *connector) -{ - struct ofdrm_device *odev = ofdrm_device_of_dev(connector->dev); - - return drm_connector_helper_get_modes_fixed(connector, &odev->mode); -} - -static const struct drm_connector_helper_funcs ofdrm_connector_helper_funcs = { - .get_modes = ofdrm_connector_helper_get_modes, -}; - -static const struct drm_connector_funcs ofdrm_connector_funcs = { - .reset = drm_atomic_helper_connector_reset, - .fill_modes = drm_helper_probe_single_connector_modes, - .destroy = drm_connector_cleanup, - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, -}; - -static const struct drm_mode_config_funcs ofdrm_mode_config_funcs = { - .fb_create = drm_gem_fb_create_with_dirty, - .atomic_check = drm_atomic_helper_check, - .atomic_commit = drm_atomic_helper_commit, -}; - -/* - * Init / Cleanup - */ - -static const struct ofdrm_device_funcs ofdrm_unknown_device_funcs = { -}; - -static const struct ofdrm_device_funcs ofdrm_mach64_device_funcs = { - .cmap_ioremap = ofdrm_mach64_cmap_ioremap, - .cmap_write = ofdrm_mach64_cmap_write, -}; - -static const struct ofdrm_device_funcs ofdrm_rage128_device_funcs = { - .cmap_ioremap = ofdrm_rage128_cmap_ioremap, - .cmap_write = ofdrm_rage128_cmap_write, -}; - -static const struct ofdrm_device_funcs ofdrm_rage_m3a_device_funcs = { - .cmap_ioremap = ofdrm_rage_m3a_cmap_ioremap, - .cmap_write = ofdrm_rage_m3a_cmap_write, -}; - -static const struct ofdrm_device_funcs ofdrm_rage_m3b_device_funcs = { - .cmap_ioremap = ofdrm_rage_m3b_cmap_ioremap, - .cmap_write = ofdrm_rage_m3b_cmap_write, -}; - -static const struct ofdrm_device_funcs ofdrm_radeon_device_funcs = { - .cmap_ioremap = ofdrm_radeon_cmap_ioremap, - .cmap_write = ofdrm_rage128_cmap_write, /* same as Rage128 */ -}; - -static const struct ofdrm_device_funcs ofdrm_gxt2000_device_funcs = { - .cmap_ioremap = ofdrm_gxt2000_cmap_ioremap, - .cmap_write = ofdrm_gxt2000_cmap_write, -}; - -static const struct ofdrm_device_funcs ofdrm_avivo_device_funcs = { - .cmap_ioremap = ofdrm_avivo_cmap_ioremap, - .cmap_write = ofdrm_avivo_cmap_write, -}; - -static const struct ofdrm_device_funcs ofdrm_qemu_device_funcs = { - .cmap_ioremap = ofdrm_qemu_cmap_ioremap, - .cmap_write = ofdrm_qemu_cmap_write, -}; - -static struct drm_display_mode ofdrm_mode(unsigned int width, unsigned int height) -{ - /* - * Assume a monitor resolution of 96 dpi to - * get a somewhat reasonable screen size. - */ - const struct drm_display_mode mode = { - DRM_MODE_INIT(60, width, height, - DRM_MODE_RES_MM(width, 96ul), - DRM_MODE_RES_MM(height, 96ul)) - }; - - return mode; -} - -static struct ofdrm_device *ofdrm_device_create(struct drm_driver *drv, - struct platform_device *pdev) -{ - struct device_node *of_node = pdev->dev.of_node; - struct ofdrm_device *odev; - struct drm_device *dev; - enum ofdrm_model model; - bool big_endian; - int width, height, depth, linebytes; - const struct drm_format_info *format; - u64 address; - resource_size_t fb_size, fb_base, fb_pgbase, fb_pgsize; - struct resource *res, *mem; - void __iomem *screen_base; - struct drm_plane *primary_plane; - struct drm_crtc *crtc; - struct drm_encoder *encoder; - struct drm_connector *connector; - unsigned long max_width, max_height; - size_t nformats; - int ret; - - odev = devm_drm_dev_alloc(&pdev->dev, drv, struct ofdrm_device, dev); - if (IS_ERR(odev)) - return ERR_CAST(odev); - dev = &odev->dev; - platform_set_drvdata(pdev, dev); - - ret = ofdrm_device_init_pci(odev); - if (ret) - return ERR_PTR(ret); - - /* - * OF display-node settings - */ - - model = display_get_model_of(dev, of_node); - drm_dbg(dev, "detected model %d\n", model); - - switch (model) { - case OFDRM_MODEL_UNKNOWN: - odev->funcs = &ofdrm_unknown_device_funcs; - break; - case OFDRM_MODEL_MACH64: - odev->funcs = &ofdrm_mach64_device_funcs; - break; - case OFDRM_MODEL_RAGE128: - odev->funcs = &ofdrm_rage128_device_funcs; - break; - case OFDRM_MODEL_RAGE_M3A: - odev->funcs = &ofdrm_rage_m3a_device_funcs; - break; - case OFDRM_MODEL_RAGE_M3B: - odev->funcs = &ofdrm_rage_m3b_device_funcs; - break; - case OFDRM_MODEL_RADEON: - odev->funcs = &ofdrm_radeon_device_funcs; - break; - case OFDRM_MODEL_GXT2000: - odev->funcs = &ofdrm_gxt2000_device_funcs; - break; - case OFDRM_MODEL_AVIVO: - odev->funcs = &ofdrm_avivo_device_funcs; - break; - case OFDRM_MODEL_QEMU: - odev->funcs = &ofdrm_qemu_device_funcs; - break; - } - - big_endian = display_get_big_endian_of(dev, of_node); - - width = display_get_width_of(dev, of_node); - if (width < 0) - return ERR_PTR(width); - height = display_get_height_of(dev, of_node); - if (height < 0) - return ERR_PTR(height); - depth = display_get_depth_of(dev, of_node); - if (depth < 0) - return ERR_PTR(depth); - linebytes = display_get_linebytes_of(dev, of_node); - if (linebytes < 0) - return ERR_PTR(linebytes); - - format = display_get_validated_format(dev, depth, big_endian); - if (IS_ERR(format)) - return ERR_CAST(format); - if (!linebytes) { - linebytes = drm_format_info_min_pitch(format, 0, width); - if (drm_WARN_ON(dev, !linebytes)) - return ERR_PTR(-EINVAL); - } - - fb_size = linebytes * height; - - /* - * Try to figure out the address of the framebuffer. Unfortunately, Open - * Firmware doesn't provide a standard way to do so. All we can do is a - * dodgy heuristic that happens to work in practice. - * - * On most machines, the "address" property contains what we need, though - * not on Matrox cards found in IBM machines. What appears to give good - * results is to go through the PCI ranges and pick one that encloses the - * "address" property. If none match, we pick the largest. - */ - address = display_get_address_of(dev, of_node); - if (address != OF_BAD_ADDR) { - struct resource fb_res = DEFINE_RES_MEM(address, fb_size); - - res = ofdrm_find_fb_resource(odev, &fb_res); - if (!res) - return ERR_PTR(-EINVAL); - if (resource_contains(res, &fb_res)) - fb_base = address; - else - fb_base = res->start; - } else { - struct resource fb_res = DEFINE_RES_MEM(0u, fb_size); - - res = ofdrm_find_fb_resource(odev, &fb_res); - if (!res) - return ERR_PTR(-EINVAL); - fb_base = res->start; - } - - /* - * I/O resources - */ - - fb_pgbase = round_down(fb_base, PAGE_SIZE); - fb_pgsize = fb_base - fb_pgbase + round_up(fb_size, PAGE_SIZE); - - ret = devm_aperture_acquire_for_platform_device(pdev, fb_pgbase, fb_pgsize); - if (ret) { - drm_err(dev, "could not acquire memory range %pr: error %d\n", &res, ret); - return ERR_PTR(ret); - } - - mem = devm_request_mem_region(&pdev->dev, fb_pgbase, fb_pgsize, drv->name); - if (!mem) { - drm_warn(dev, "could not acquire memory region %pr\n", &res); - return ERR_PTR(-ENOMEM); - } - - screen_base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem)); - if (!screen_base) - return ERR_PTR(-ENOMEM); - - if (odev->funcs->cmap_ioremap) { - void __iomem *cmap_base = odev->funcs->cmap_ioremap(odev, of_node, fb_base); - - if (IS_ERR(cmap_base)) { - /* Don't fail; continue without colormap */ - drm_warn(dev, "could not find colormap: error %ld\n", PTR_ERR(cmap_base)); - } else { - odev->cmap_base = cmap_base; - } - } - - /* - * Firmware framebuffer - */ - - iosys_map_set_vaddr_iomem(&odev->screen_base, screen_base); - odev->mode = ofdrm_mode(width, height); - odev->format = format; - odev->pitch = linebytes; - - drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&odev->mode)); - drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, linebytes=%d byte\n", - &format->format, width, height, linebytes); - - /* - * Mode-setting pipeline - */ - - ret = drmm_mode_config_init(dev); - if (ret) - return ERR_PTR(ret); - - max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH); - max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT); - - dev->mode_config.min_width = width; - dev->mode_config.max_width = max_width; - dev->mode_config.min_height = height; - dev->mode_config.max_height = max_height; - dev->mode_config.funcs = &ofdrm_mode_config_funcs; - dev->mode_config.preferred_depth = format->depth; - dev->mode_config.quirk_addfb_prefer_host_byte_order = true; - - /* Primary plane */ - - nformats = drm_fb_build_fourcc_list(dev, &format->format, 1, - odev->formats, ARRAY_SIZE(odev->formats)); - - primary_plane = &odev->primary_plane; - ret = drm_universal_plane_init(dev, primary_plane, 0, &ofdrm_primary_plane_funcs, - odev->formats, nformats, - ofdrm_primary_plane_format_modifiers, - DRM_PLANE_TYPE_PRIMARY, NULL); - if (ret) - return ERR_PTR(ret); - drm_plane_helper_add(primary_plane, &ofdrm_primary_plane_helper_funcs); - drm_plane_enable_fb_damage_clips(primary_plane); - - /* CRTC */ - - crtc = &odev->crtc; - ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, - &ofdrm_crtc_funcs, NULL); - if (ret) - return ERR_PTR(ret); - drm_crtc_helper_add(crtc, &ofdrm_crtc_helper_funcs); - - if (odev->cmap_base) { - drm_mode_crtc_set_gamma_size(crtc, OFDRM_GAMMA_LUT_SIZE); - drm_crtc_enable_color_mgmt(crtc, 0, false, OFDRM_GAMMA_LUT_SIZE); - } - - /* Encoder */ - - encoder = &odev->encoder; - ret = drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_NONE); - if (ret) - return ERR_PTR(ret); - encoder->possible_crtcs = drm_crtc_mask(crtc); - - /* Connector */ - - connector = &odev->connector; - ret = drm_connector_init(dev, connector, &ofdrm_connector_funcs, - DRM_MODE_CONNECTOR_Unknown); - if (ret) - return ERR_PTR(ret); - drm_connector_helper_add(connector, &ofdrm_connector_helper_funcs); - drm_connector_set_panel_orientation_with_quirk(connector, - DRM_MODE_PANEL_ORIENTATION_UNKNOWN, - width, height); - - ret = drm_connector_attach_encoder(connector, encoder); - if (ret) - return ERR_PTR(ret); - - drm_mode_config_reset(dev); - - return odev; -} - -/* - * DRM driver - */ - -DEFINE_DRM_GEM_FOPS(ofdrm_fops); - -static struct drm_driver ofdrm_driver = { - DRM_GEM_SHMEM_DRIVER_OPS, - DRM_FBDEV_SHMEM_DRIVER_OPS, - .name = DRIVER_NAME, - .desc = DRIVER_DESC, - .major = DRIVER_MAJOR, - .minor = DRIVER_MINOR, - .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, - .fops = &ofdrm_fops, -}; - -/* - * Platform driver - */ - -static int ofdrm_probe(struct platform_device *pdev) -{ - struct ofdrm_device *odev; - struct drm_device *dev; - int ret; - - odev = ofdrm_device_create(&ofdrm_driver, pdev); - if (IS_ERR(odev)) - return PTR_ERR(odev); - dev = &odev->dev; - - ret = drm_dev_register(dev, 0); - if (ret) - return ret; - - drm_client_setup(dev, odev->format); - - return 0; -} - -static void ofdrm_remove(struct platform_device *pdev) -{ - struct drm_device *dev = platform_get_drvdata(pdev); - - drm_dev_unplug(dev); -} - -static const struct of_device_id ofdrm_of_match_display[] = { - { .compatible = "display", }, - { }, -}; -MODULE_DEVICE_TABLE(of, ofdrm_of_match_display); - -static struct platform_driver ofdrm_platform_driver = { - .driver = { - .name = "of-display", - .of_match_table = ofdrm_of_match_display, - }, - .probe = ofdrm_probe, - .remove = ofdrm_remove, -}; - -module_platform_driver(ofdrm_platform_driver); - -MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/panel-mipi-dbi.c b/drivers/gpu/drm/tiny/panel-mipi-dbi.c index 0460ecaef4bd..23914a9f7fd3 100644 --- a/drivers/gpu/drm/tiny/panel-mipi-dbi.c +++ b/drivers/gpu/drm/tiny/panel-mipi-dbi.c @@ -390,7 +390,10 @@ static int panel_mipi_dbi_spi_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_client_setup(drm, NULL); + if (bpp == 16) + drm_client_setup_with_fourcc(drm, DRM_FORMAT_RGB565); + else + drm_client_setup_with_fourcc(drm, DRM_FORMAT_RGB888); return 0; } diff --git a/drivers/gpu/drm/tiny/repaper.c b/drivers/gpu/drm/tiny/repaper.c index 52ba6c699bc8..5c3b51eb0a97 100644 --- a/drivers/gpu/drm/tiny/repaper.c +++ b/drivers/gpu/drm/tiny/repaper.c @@ -456,7 +456,7 @@ static void repaper_frame_fixed_repeat(struct repaper_epd *epd, u8 fixed_value, enum repaper_stage stage) { u64 start = local_clock(); - u64 end = start + (epd->factored_stage_time * 1000 * 1000); + u64 end = start + ((u64)epd->factored_stage_time * 1000 * 1000); do { repaper_frame_fixed(epd, fixed_value, stage); @@ -467,7 +467,7 @@ static void repaper_frame_data_repeat(struct repaper_epd *epd, const u8 *image, const u8 *mask, enum repaper_stage stage) { u64 start = local_clock(); - u64 end = start + (epd->factored_stage_time * 1000 * 1000); + u64 end = start + ((u64)epd->factored_stage_time * 1000 * 1000); do { repaper_frame_data(epd, image, mask, stage); diff --git a/drivers/gpu/drm/tiny/simpledrm.c b/drivers/gpu/drm/tiny/simpledrm.c deleted file mode 100644 index 5d9ab8adf800..000000000000 --- a/drivers/gpu/drm/tiny/simpledrm.c +++ /dev/null @@ -1,1073 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only - -#include <linux/aperture.h> -#include <linux/clk.h> -#include <linux/of_clk.h> -#include <linux/minmax.h> -#include <linux/of_address.h> -#include <linux/platform_data/simplefb.h> -#include <linux/platform_device.h> -#include <linux/pm_domain.h> -#include <linux/regulator/consumer.h> - -#include <drm/clients/drm_client_setup.h> -#include <drm/drm_atomic.h> -#include <drm/drm_atomic_state_helper.h> -#include <drm/drm_connector.h> -#include <drm/drm_crtc_helper.h> -#include <drm/drm_damage_helper.h> -#include <drm/drm_device.h> -#include <drm/drm_drv.h> -#include <drm/drm_fbdev_shmem.h> -#include <drm/drm_format_helper.h> -#include <drm/drm_framebuffer.h> -#include <drm/drm_gem_atomic_helper.h> -#include <drm/drm_gem_framebuffer_helper.h> -#include <drm/drm_gem_shmem_helper.h> -#include <drm/drm_managed.h> -#include <drm/drm_modeset_helper_vtables.h> -#include <drm/drm_panic.h> -#include <drm/drm_probe_helper.h> - -#define DRIVER_NAME "simpledrm" -#define DRIVER_DESC "DRM driver for simple-framebuffer platform devices" -#define DRIVER_MAJOR 1 -#define DRIVER_MINOR 0 - -/* - * Helpers for simplefb - */ - -static int -simplefb_get_validated_int(struct drm_device *dev, const char *name, - uint32_t value) -{ - if (value > INT_MAX) { - drm_err(dev, "simplefb: invalid framebuffer %s of %u\n", - name, value); - return -EINVAL; - } - return (int)value; -} - -static int -simplefb_get_validated_int0(struct drm_device *dev, const char *name, - uint32_t value) -{ - if (!value) { - drm_err(dev, "simplefb: invalid framebuffer %s of %u\n", - name, value); - return -EINVAL; - } - return simplefb_get_validated_int(dev, name, value); -} - -static const struct drm_format_info * -simplefb_get_validated_format(struct drm_device *dev, const char *format_name) -{ - static const struct simplefb_format formats[] = SIMPLEFB_FORMATS; - const struct simplefb_format *fmt = formats; - const struct simplefb_format *end = fmt + ARRAY_SIZE(formats); - const struct drm_format_info *info; - - if (!format_name) { - drm_err(dev, "simplefb: missing framebuffer format\n"); - return ERR_PTR(-EINVAL); - } - - while (fmt < end) { - if (!strcmp(format_name, fmt->name)) { - info = drm_format_info(fmt->fourcc); - if (!info) - return ERR_PTR(-EINVAL); - return info; - } - ++fmt; - } - - drm_err(dev, "simplefb: unknown framebuffer format %s\n", - format_name); - - return ERR_PTR(-EINVAL); -} - -static int -simplefb_get_width_pd(struct drm_device *dev, - const struct simplefb_platform_data *pd) -{ - return simplefb_get_validated_int0(dev, "width", pd->width); -} - -static int -simplefb_get_height_pd(struct drm_device *dev, - const struct simplefb_platform_data *pd) -{ - return simplefb_get_validated_int0(dev, "height", pd->height); -} - -static int -simplefb_get_stride_pd(struct drm_device *dev, - const struct simplefb_platform_data *pd) -{ - return simplefb_get_validated_int(dev, "stride", pd->stride); -} - -static const struct drm_format_info * -simplefb_get_format_pd(struct drm_device *dev, - const struct simplefb_platform_data *pd) -{ - return simplefb_get_validated_format(dev, pd->format); -} - -static int -simplefb_read_u32_of(struct drm_device *dev, struct device_node *of_node, - const char *name, u32 *value) -{ - int ret = of_property_read_u32(of_node, name, value); - - if (ret) - drm_err(dev, "simplefb: cannot parse framebuffer %s: error %d\n", - name, ret); - return ret; -} - -static int -simplefb_read_string_of(struct drm_device *dev, struct device_node *of_node, - const char *name, const char **value) -{ - int ret = of_property_read_string(of_node, name, value); - - if (ret) - drm_err(dev, "simplefb: cannot parse framebuffer %s: error %d\n", - name, ret); - return ret; -} - -static int -simplefb_get_width_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 width; - int ret = simplefb_read_u32_of(dev, of_node, "width", &width); - - if (ret) - return ret; - return simplefb_get_validated_int0(dev, "width", width); -} - -static int -simplefb_get_height_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 height; - int ret = simplefb_read_u32_of(dev, of_node, "height", &height); - - if (ret) - return ret; - return simplefb_get_validated_int0(dev, "height", height); -} - -static int -simplefb_get_stride_of(struct drm_device *dev, struct device_node *of_node) -{ - u32 stride; - int ret = simplefb_read_u32_of(dev, of_node, "stride", &stride); - - if (ret) - return ret; - return simplefb_get_validated_int(dev, "stride", stride); -} - -static const struct drm_format_info * -simplefb_get_format_of(struct drm_device *dev, struct device_node *of_node) -{ - const char *format; - int ret = simplefb_read_string_of(dev, of_node, "format", &format); - - if (ret) - return ERR_PTR(ret); - return simplefb_get_validated_format(dev, format); -} - -static struct resource * -simplefb_get_memory_of(struct drm_device *dev, struct device_node *of_node) -{ - struct device_node *np; - struct resource *res; - int err; - - np = of_parse_phandle(of_node, "memory-region", 0); - if (!np) - return NULL; - - res = devm_kzalloc(dev->dev, sizeof(*res), GFP_KERNEL); - if (!res) - return ERR_PTR(-ENOMEM); - - err = of_address_to_resource(np, 0, res); - if (err) - return ERR_PTR(err); - - if (of_property_present(of_node, "reg")) - drm_warn(dev, "preferring \"memory-region\" over \"reg\" property\n"); - - return res; -} - -/* - * Simple Framebuffer device - */ - -struct simpledrm_device { - struct drm_device dev; - - /* clocks */ -#if defined CONFIG_OF && defined CONFIG_COMMON_CLK - unsigned int clk_count; - struct clk **clks; -#endif - /* regulators */ -#if defined CONFIG_OF && defined CONFIG_REGULATOR - unsigned int regulator_count; - struct regulator **regulators; -#endif - /* power-domains */ -#if defined CONFIG_OF && defined CONFIG_PM_GENERIC_DOMAINS - int pwr_dom_count; - struct device **pwr_dom_devs; - struct device_link **pwr_dom_links; -#endif - - /* simplefb settings */ - struct drm_display_mode mode; - const struct drm_format_info *format; - unsigned int pitch; - - /* memory management */ - struct iosys_map screen_base; - - /* modesetting */ - uint32_t formats[8]; - size_t nformats; - struct drm_plane primary_plane; - struct drm_crtc crtc; - struct drm_encoder encoder; - struct drm_connector connector; -}; - -static struct simpledrm_device *simpledrm_device_of_dev(struct drm_device *dev) -{ - return container_of(dev, struct simpledrm_device, dev); -} - -/* - * Hardware - */ - -#if defined CONFIG_OF && defined CONFIG_COMMON_CLK -/* - * Clock handling code. - * - * Here we handle the clocks property of our "simple-framebuffer" dt node. - * This is necessary so that we can make sure that any clocks needed by - * the display engine that the bootloader set up for us (and for which it - * provided a simplefb dt node), stay up, for the life of the simplefb - * driver. - * - * When the driver unloads, we cleanly disable, and then release the clocks. - * - * We only complain about errors here, no action is taken as the most likely - * error can only happen due to a mismatch between the bootloader which set - * up simplefb, and the clock definitions in the device tree. Chances are - * that there are no adverse effects, and if there are, a clean teardown of - * the fb probe will not help us much either. So just complain and carry on, - * and hope that the user actually gets a working fb at the end of things. - */ - -static void simpledrm_device_release_clocks(void *res) -{ - struct simpledrm_device *sdev = simpledrm_device_of_dev(res); - unsigned int i; - - for (i = 0; i < sdev->clk_count; ++i) { - if (sdev->clks[i]) { - clk_disable_unprepare(sdev->clks[i]); - clk_put(sdev->clks[i]); - } - } -} - -static int simpledrm_device_init_clocks(struct simpledrm_device *sdev) -{ - struct drm_device *dev = &sdev->dev; - struct platform_device *pdev = to_platform_device(dev->dev); - struct device_node *of_node = pdev->dev.of_node; - struct clk *clock; - unsigned int i; - int ret; - - if (dev_get_platdata(&pdev->dev) || !of_node) - return 0; - - sdev->clk_count = of_clk_get_parent_count(of_node); - if (!sdev->clk_count) - return 0; - - sdev->clks = drmm_kzalloc(dev, sdev->clk_count * sizeof(sdev->clks[0]), - GFP_KERNEL); - if (!sdev->clks) - return -ENOMEM; - - for (i = 0; i < sdev->clk_count; ++i) { - clock = of_clk_get(of_node, i); - if (IS_ERR(clock)) { - ret = PTR_ERR(clock); - if (ret == -EPROBE_DEFER) - goto err; - drm_err(dev, "clock %u not found: %d\n", i, ret); - continue; - } - ret = clk_prepare_enable(clock); - if (ret) { - drm_err(dev, "failed to enable clock %u: %d\n", - i, ret); - clk_put(clock); - continue; - } - sdev->clks[i] = clock; - } - - return devm_add_action_or_reset(&pdev->dev, - simpledrm_device_release_clocks, - sdev); - -err: - while (i) { - --i; - if (sdev->clks[i]) { - clk_disable_unprepare(sdev->clks[i]); - clk_put(sdev->clks[i]); - } - } - return ret; -} -#else -static int simpledrm_device_init_clocks(struct simpledrm_device *sdev) -{ - return 0; -} -#endif - -#if defined CONFIG_OF && defined CONFIG_REGULATOR - -#define SUPPLY_SUFFIX "-supply" - -/* - * Regulator handling code. - * - * Here we handle the num-supplies and vin*-supply properties of our - * "simple-framebuffer" dt node. This is necessary so that we can make sure - * that any regulators needed by the display hardware that the bootloader - * set up for us (and for which it provided a simplefb dt node), stay up, - * for the life of the simplefb driver. - * - * When the driver unloads, we cleanly disable, and then release the - * regulators. - * - * We only complain about errors here, no action is taken as the most likely - * error can only happen due to a mismatch between the bootloader which set - * up simplefb, and the regulator definitions in the device tree. Chances are - * that there are no adverse effects, and if there are, a clean teardown of - * the fb probe will not help us much either. So just complain and carry on, - * and hope that the user actually gets a working fb at the end of things. - */ - -static void simpledrm_device_release_regulators(void *res) -{ - struct simpledrm_device *sdev = simpledrm_device_of_dev(res); - unsigned int i; - - for (i = 0; i < sdev->regulator_count; ++i) { - if (sdev->regulators[i]) { - regulator_disable(sdev->regulators[i]); - regulator_put(sdev->regulators[i]); - } - } -} - -static int simpledrm_device_init_regulators(struct simpledrm_device *sdev) -{ - struct drm_device *dev = &sdev->dev; - struct platform_device *pdev = to_platform_device(dev->dev); - struct device_node *of_node = pdev->dev.of_node; - struct property *prop; - struct regulator *regulator; - const char *p; - unsigned int count = 0, i = 0; - int ret; - - if (dev_get_platdata(&pdev->dev) || !of_node) - return 0; - - /* Count the number of regulator supplies */ - for_each_property_of_node(of_node, prop) { - p = strstr(prop->name, SUPPLY_SUFFIX); - if (p && p != prop->name) - ++count; - } - - if (!count) - return 0; - - sdev->regulators = drmm_kzalloc(dev, - count * sizeof(sdev->regulators[0]), - GFP_KERNEL); - if (!sdev->regulators) - return -ENOMEM; - - for_each_property_of_node(of_node, prop) { - char name[32]; /* 32 is max size of property name */ - size_t len; - - p = strstr(prop->name, SUPPLY_SUFFIX); - if (!p || p == prop->name) - continue; - len = strlen(prop->name) - strlen(SUPPLY_SUFFIX) + 1; - strscpy(name, prop->name, min(sizeof(name), len)); - - regulator = regulator_get_optional(&pdev->dev, name); - if (IS_ERR(regulator)) { - ret = PTR_ERR(regulator); - if (ret == -EPROBE_DEFER) - goto err; - drm_err(dev, "regulator %s not found: %d\n", - name, ret); - continue; - } - - ret = regulator_enable(regulator); - if (ret) { - drm_err(dev, "failed to enable regulator %u: %d\n", - i, ret); - regulator_put(regulator); - continue; - } - - sdev->regulators[i++] = regulator; - } - sdev->regulator_count = i; - - return devm_add_action_or_reset(&pdev->dev, - simpledrm_device_release_regulators, - sdev); - -err: - while (i) { - --i; - if (sdev->regulators[i]) { - regulator_disable(sdev->regulators[i]); - regulator_put(sdev->regulators[i]); - } - } - return ret; -} -#else -static int simpledrm_device_init_regulators(struct simpledrm_device *sdev) -{ - return 0; -} -#endif - -#if defined CONFIG_OF && defined CONFIG_PM_GENERIC_DOMAINS -/* - * Generic power domain handling code. - * - * Here we handle the power-domains properties of our "simple-framebuffer" - * dt node. This is only necessary if there is more than one power-domain. - * A single power-domains is handled automatically by the driver core. Multiple - * power-domains have to be handled by drivers since the driver core can't know - * the correct power sequencing. Power sequencing is not an issue for simpledrm - * since the bootloader has put the power domains already in the correct state. - * simpledrm has only to ensure they remain active for its lifetime. - * - * When the driver unloads, we detach from the power-domains. - * - * We only complain about errors here, no action is taken as the most likely - * error can only happen due to a mismatch between the bootloader which set - * up the "simple-framebuffer" dt node, and the PM domain providers in the - * device tree. Chances are that there are no adverse effects, and if there are, - * a clean teardown of the fb probe will not help us much either. So just - * complain and carry on, and hope that the user actually gets a working fb at - * the end of things. - */ -static void simpledrm_device_detach_genpd(void *res) -{ - int i; - struct simpledrm_device *sdev = res; - - if (sdev->pwr_dom_count <= 1) - return; - - for (i = sdev->pwr_dom_count - 1; i >= 0; i--) { - if (sdev->pwr_dom_links[i]) - device_link_del(sdev->pwr_dom_links[i]); - if (!IS_ERR_OR_NULL(sdev->pwr_dom_devs[i])) - dev_pm_domain_detach(sdev->pwr_dom_devs[i], true); - } -} - -static int simpledrm_device_attach_genpd(struct simpledrm_device *sdev) -{ - struct device *dev = sdev->dev.dev; - int i; - - sdev->pwr_dom_count = of_count_phandle_with_args(dev->of_node, "power-domains", - "#power-domain-cells"); - /* - * Single power-domain devices are handled by driver core nothing to do - * here. The same for device nodes without "power-domains" property. - */ - if (sdev->pwr_dom_count <= 1) - return 0; - - sdev->pwr_dom_devs = devm_kcalloc(dev, sdev->pwr_dom_count, - sizeof(*sdev->pwr_dom_devs), - GFP_KERNEL); - if (!sdev->pwr_dom_devs) - return -ENOMEM; - - sdev->pwr_dom_links = devm_kcalloc(dev, sdev->pwr_dom_count, - sizeof(*sdev->pwr_dom_links), - GFP_KERNEL); - if (!sdev->pwr_dom_links) - return -ENOMEM; - - for (i = 0; i < sdev->pwr_dom_count; i++) { - sdev->pwr_dom_devs[i] = dev_pm_domain_attach_by_id(dev, i); - if (IS_ERR(sdev->pwr_dom_devs[i])) { - int ret = PTR_ERR(sdev->pwr_dom_devs[i]); - if (ret == -EPROBE_DEFER) { - simpledrm_device_detach_genpd(sdev); - return ret; - } - drm_warn(&sdev->dev, - "pm_domain_attach_by_id(%u) failed: %d\n", i, ret); - continue; - } - - sdev->pwr_dom_links[i] = device_link_add(dev, - sdev->pwr_dom_devs[i], - DL_FLAG_STATELESS | - DL_FLAG_PM_RUNTIME | - DL_FLAG_RPM_ACTIVE); - if (!sdev->pwr_dom_links[i]) - drm_warn(&sdev->dev, "failed to link power-domain %d\n", i); - } - - return devm_add_action_or_reset(dev, simpledrm_device_detach_genpd, sdev); -} -#else -static int simpledrm_device_attach_genpd(struct simpledrm_device *sdev) -{ - return 0; -} -#endif - -/* - * Modesetting - */ - -static const uint64_t simpledrm_primary_plane_format_modifiers[] = { - DRM_FORMAT_MOD_LINEAR, - DRM_FORMAT_MOD_INVALID -}; - -static int simpledrm_primary_plane_helper_atomic_check(struct drm_plane *plane, - struct drm_atomic_state *state) -{ - struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane); - struct drm_shadow_plane_state *new_shadow_plane_state = - to_drm_shadow_plane_state(new_plane_state); - struct drm_framebuffer *new_fb = new_plane_state->fb; - struct drm_crtc *new_crtc = new_plane_state->crtc; - struct drm_crtc_state *new_crtc_state = NULL; - struct drm_device *dev = plane->dev; - struct simpledrm_device *sdev = simpledrm_device_of_dev(dev); - int ret; - - if (new_crtc) - new_crtc_state = drm_atomic_get_new_crtc_state(state, new_crtc); - - ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state, - DRM_PLANE_NO_SCALING, - DRM_PLANE_NO_SCALING, - false, false); - if (ret) - return ret; - else if (!new_plane_state->visible) - return 0; - - if (new_fb->format != sdev->format) { - void *buf; - - /* format conversion necessary; reserve buffer */ - buf = drm_format_conv_state_reserve(&new_shadow_plane_state->fmtcnv_state, - sdev->pitch, GFP_KERNEL); - if (!buf) - return -ENOMEM; - } - - return 0; -} - -static void simpledrm_primary_plane_helper_atomic_update(struct drm_plane *plane, - struct drm_atomic_state *state) -{ - struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); - struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane); - struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); - struct drm_framebuffer *fb = plane_state->fb; - struct drm_device *dev = plane->dev; - struct simpledrm_device *sdev = simpledrm_device_of_dev(dev); - struct drm_atomic_helper_damage_iter iter; - struct drm_rect damage; - int ret, idx; - - ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); - if (ret) - return; - - if (!drm_dev_enter(dev, &idx)) - goto out_drm_gem_fb_end_cpu_access; - - drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); - drm_atomic_for_each_plane_damage(&iter, &damage) { - struct drm_rect dst_clip = plane_state->dst; - struct iosys_map dst = sdev->screen_base; - - if (!drm_rect_intersect(&dst_clip, &damage)) - continue; - - iosys_map_incr(&dst, drm_fb_clip_offset(sdev->pitch, sdev->format, &dst_clip)); - drm_fb_blit(&dst, &sdev->pitch, sdev->format->format, shadow_plane_state->data, - fb, &damage, &shadow_plane_state->fmtcnv_state); - } - - drm_dev_exit(idx); -out_drm_gem_fb_end_cpu_access: - drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); -} - -static void simpledrm_primary_plane_helper_atomic_disable(struct drm_plane *plane, - struct drm_atomic_state *state) -{ - struct drm_device *dev = plane->dev; - struct simpledrm_device *sdev = simpledrm_device_of_dev(dev); - int idx; - - if (!drm_dev_enter(dev, &idx)) - return; - - /* Clear screen to black if disabled */ - iosys_map_memset(&sdev->screen_base, 0, 0, sdev->pitch * sdev->mode.vdisplay); - - drm_dev_exit(idx); -} - -static int simpledrm_primary_plane_helper_get_scanout_buffer(struct drm_plane *plane, - struct drm_scanout_buffer *sb) -{ - struct simpledrm_device *sdev = simpledrm_device_of_dev(plane->dev); - - sb->width = sdev->mode.hdisplay; - sb->height = sdev->mode.vdisplay; - sb->format = sdev->format; - sb->pitch[0] = sdev->pitch; - sb->map[0] = sdev->screen_base; - - return 0; -} - -static const struct drm_plane_helper_funcs simpledrm_primary_plane_helper_funcs = { - DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, - .atomic_check = simpledrm_primary_plane_helper_atomic_check, - .atomic_update = simpledrm_primary_plane_helper_atomic_update, - .atomic_disable = simpledrm_primary_plane_helper_atomic_disable, - .get_scanout_buffer = simpledrm_primary_plane_helper_get_scanout_buffer, -}; - -static const struct drm_plane_funcs simpledrm_primary_plane_funcs = { - .update_plane = drm_atomic_helper_update_plane, - .disable_plane = drm_atomic_helper_disable_plane, - .destroy = drm_plane_cleanup, - DRM_GEM_SHADOW_PLANE_FUNCS, -}; - -static enum drm_mode_status simpledrm_crtc_helper_mode_valid(struct drm_crtc *crtc, - const struct drm_display_mode *mode) -{ - struct simpledrm_device *sdev = simpledrm_device_of_dev(crtc->dev); - - return drm_crtc_helper_mode_valid_fixed(crtc, mode, &sdev->mode); -} - -/* - * The CRTC is always enabled. Screen updates are performed by - * the primary plane's atomic_update function. Disabling clears - * the screen in the primary plane's atomic_disable function. - */ -static const struct drm_crtc_helper_funcs simpledrm_crtc_helper_funcs = { - .mode_valid = simpledrm_crtc_helper_mode_valid, - .atomic_check = drm_crtc_helper_atomic_check, -}; - -static const struct drm_crtc_funcs simpledrm_crtc_funcs = { - .reset = drm_atomic_helper_crtc_reset, - .destroy = drm_crtc_cleanup, - .set_config = drm_atomic_helper_set_config, - .page_flip = drm_atomic_helper_page_flip, - .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, -}; - -static const struct drm_encoder_funcs simpledrm_encoder_funcs = { - .destroy = drm_encoder_cleanup, -}; - -static int simpledrm_connector_helper_get_modes(struct drm_connector *connector) -{ - struct simpledrm_device *sdev = simpledrm_device_of_dev(connector->dev); - - return drm_connector_helper_get_modes_fixed(connector, &sdev->mode); -} - -static const struct drm_connector_helper_funcs simpledrm_connector_helper_funcs = { - .get_modes = simpledrm_connector_helper_get_modes, -}; - -static const struct drm_connector_funcs simpledrm_connector_funcs = { - .reset = drm_atomic_helper_connector_reset, - .fill_modes = drm_helper_probe_single_connector_modes, - .destroy = drm_connector_cleanup, - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, -}; - -static const struct drm_mode_config_funcs simpledrm_mode_config_funcs = { - .fb_create = drm_gem_fb_create_with_dirty, - .atomic_check = drm_atomic_helper_check, - .atomic_commit = drm_atomic_helper_commit, -}; - -/* - * Init / Cleanup - */ - -static struct drm_display_mode simpledrm_mode(unsigned int width, - unsigned int height, - unsigned int width_mm, - unsigned int height_mm) -{ - const struct drm_display_mode mode = { - DRM_MODE_INIT(60, width, height, width_mm, height_mm) - }; - - return mode; -} - -static struct simpledrm_device *simpledrm_device_create(struct drm_driver *drv, - struct platform_device *pdev) -{ - const struct simplefb_platform_data *pd = dev_get_platdata(&pdev->dev); - struct device_node *of_node = pdev->dev.of_node; - struct simpledrm_device *sdev; - struct drm_device *dev; - int width, height, stride; - int width_mm = 0, height_mm = 0; - struct device_node *panel_node; - const struct drm_format_info *format; - struct resource *res, *mem = NULL; - struct drm_plane *primary_plane; - struct drm_crtc *crtc; - struct drm_encoder *encoder; - struct drm_connector *connector; - unsigned long max_width, max_height; - size_t nformats; - int ret; - - sdev = devm_drm_dev_alloc(&pdev->dev, drv, struct simpledrm_device, dev); - if (IS_ERR(sdev)) - return ERR_CAST(sdev); - dev = &sdev->dev; - platform_set_drvdata(pdev, sdev); - - /* - * Hardware settings - */ - - ret = simpledrm_device_init_clocks(sdev); - if (ret) - return ERR_PTR(ret); - ret = simpledrm_device_init_regulators(sdev); - if (ret) - return ERR_PTR(ret); - ret = simpledrm_device_attach_genpd(sdev); - if (ret) - return ERR_PTR(ret); - - if (pd) { - width = simplefb_get_width_pd(dev, pd); - if (width < 0) - return ERR_PTR(width); - height = simplefb_get_height_pd(dev, pd); - if (height < 0) - return ERR_PTR(height); - stride = simplefb_get_stride_pd(dev, pd); - if (stride < 0) - return ERR_PTR(stride); - format = simplefb_get_format_pd(dev, pd); - if (IS_ERR(format)) - return ERR_CAST(format); - } else if (of_node) { - width = simplefb_get_width_of(dev, of_node); - if (width < 0) - return ERR_PTR(width); - height = simplefb_get_height_of(dev, of_node); - if (height < 0) - return ERR_PTR(height); - stride = simplefb_get_stride_of(dev, of_node); - if (stride < 0) - return ERR_PTR(stride); - format = simplefb_get_format_of(dev, of_node); - if (IS_ERR(format)) - return ERR_CAST(format); - mem = simplefb_get_memory_of(dev, of_node); - if (IS_ERR(mem)) - return ERR_CAST(mem); - panel_node = of_parse_phandle(of_node, "panel", 0); - if (panel_node) { - simplefb_read_u32_of(dev, panel_node, "width-mm", &width_mm); - simplefb_read_u32_of(dev, panel_node, "height-mm", &height_mm); - of_node_put(panel_node); - } - } else { - drm_err(dev, "no simplefb configuration found\n"); - return ERR_PTR(-ENODEV); - } - if (!stride) { - stride = drm_format_info_min_pitch(format, 0, width); - if (drm_WARN_ON(dev, !stride)) - return ERR_PTR(-EINVAL); - } - - /* - * Assume a monitor resolution of 96 dpi if physical dimensions - * are not specified to get a somewhat reasonable screen size. - */ - if (!width_mm) - width_mm = DRM_MODE_RES_MM(width, 96ul); - if (!height_mm) - height_mm = DRM_MODE_RES_MM(height, 96ul); - - sdev->mode = simpledrm_mode(width, height, width_mm, height_mm); - sdev->format = format; - sdev->pitch = stride; - - drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&sdev->mode)); - drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d byte\n", - &format->format, width, height, stride); - - /* - * Memory management - */ - - if (mem) { - void *screen_base; - - ret = devm_aperture_acquire_for_platform_device(pdev, mem->start, - resource_size(mem)); - if (ret) { - drm_err(dev, "could not acquire memory range %pr: %d\n", mem, ret); - return ERR_PTR(ret); - } - - drm_dbg(dev, "using system memory framebuffer at %pr\n", mem); - - screen_base = devm_memremap(dev->dev, mem->start, resource_size(mem), MEMREMAP_WC); - if (IS_ERR(screen_base)) - return screen_base; - - iosys_map_set_vaddr(&sdev->screen_base, screen_base); - } else { - void __iomem *screen_base; - - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - if (!res) - return ERR_PTR(-EINVAL); - - ret = devm_aperture_acquire_for_platform_device(pdev, res->start, - resource_size(res)); - if (ret) { - drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret); - return ERR_PTR(ret); - } - - drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res); - - mem = devm_request_mem_region(&pdev->dev, res->start, resource_size(res), - drv->name); - if (!mem) { - /* - * We cannot make this fatal. Sometimes this comes from magic - * spaces our resource handlers simply don't know about. Use - * the I/O-memory resource as-is and try to map that instead. - */ - drm_warn(dev, "could not acquire memory region %pr\n", res); - mem = res; - } - - screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem)); - if (!screen_base) - return ERR_PTR(-ENOMEM); - - iosys_map_set_vaddr_iomem(&sdev->screen_base, screen_base); - } - - /* - * Modesetting - */ - - ret = drmm_mode_config_init(dev); - if (ret) - return ERR_PTR(ret); - - max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH); - max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT); - - dev->mode_config.min_width = width; - dev->mode_config.max_width = max_width; - dev->mode_config.min_height = height; - dev->mode_config.max_height = max_height; - dev->mode_config.preferred_depth = format->depth; - dev->mode_config.funcs = &simpledrm_mode_config_funcs; - - /* Primary plane */ - - nformats = drm_fb_build_fourcc_list(dev, &format->format, 1, - sdev->formats, ARRAY_SIZE(sdev->formats)); - - primary_plane = &sdev->primary_plane; - ret = drm_universal_plane_init(dev, primary_plane, 0, &simpledrm_primary_plane_funcs, - sdev->formats, nformats, - simpledrm_primary_plane_format_modifiers, - DRM_PLANE_TYPE_PRIMARY, NULL); - if (ret) - return ERR_PTR(ret); - drm_plane_helper_add(primary_plane, &simpledrm_primary_plane_helper_funcs); - drm_plane_enable_fb_damage_clips(primary_plane); - - /* CRTC */ - - crtc = &sdev->crtc; - ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, - &simpledrm_crtc_funcs, NULL); - if (ret) - return ERR_PTR(ret); - drm_crtc_helper_add(crtc, &simpledrm_crtc_helper_funcs); - - /* Encoder */ - - encoder = &sdev->encoder; - ret = drm_encoder_init(dev, encoder, &simpledrm_encoder_funcs, - DRM_MODE_ENCODER_NONE, NULL); - if (ret) - return ERR_PTR(ret); - encoder->possible_crtcs = drm_crtc_mask(crtc); - - /* Connector */ - - connector = &sdev->connector; - ret = drm_connector_init(dev, connector, &simpledrm_connector_funcs, - DRM_MODE_CONNECTOR_Unknown); - if (ret) - return ERR_PTR(ret); - drm_connector_helper_add(connector, &simpledrm_connector_helper_funcs); - drm_connector_set_panel_orientation_with_quirk(connector, - DRM_MODE_PANEL_ORIENTATION_UNKNOWN, - width, height); - - ret = drm_connector_attach_encoder(connector, encoder); - if (ret) - return ERR_PTR(ret); - - drm_mode_config_reset(dev); - - return sdev; -} - -/* - * DRM driver - */ - -DEFINE_DRM_GEM_FOPS(simpledrm_fops); - -static struct drm_driver simpledrm_driver = { - DRM_GEM_SHMEM_DRIVER_OPS, - DRM_FBDEV_SHMEM_DRIVER_OPS, - .name = DRIVER_NAME, - .desc = DRIVER_DESC, - .major = DRIVER_MAJOR, - .minor = DRIVER_MINOR, - .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, - .fops = &simpledrm_fops, -}; - -/* - * Platform driver - */ - -static int simpledrm_probe(struct platform_device *pdev) -{ - struct simpledrm_device *sdev; - struct drm_device *dev; - int ret; - - sdev = simpledrm_device_create(&simpledrm_driver, pdev); - if (IS_ERR(sdev)) - return PTR_ERR(sdev); - dev = &sdev->dev; - - ret = drm_dev_register(dev, 0); - if (ret) - return ret; - - drm_client_setup(dev, sdev->format); - - return 0; -} - -static void simpledrm_remove(struct platform_device *pdev) -{ - struct simpledrm_device *sdev = platform_get_drvdata(pdev); - struct drm_device *dev = &sdev->dev; - - drm_dev_unplug(dev); -} - -static const struct of_device_id simpledrm_of_match_table[] = { - { .compatible = "simple-framebuffer", }, - { }, -}; -MODULE_DEVICE_TABLE(of, simpledrm_of_match_table); - -static struct platform_driver simpledrm_platform_driver = { - .driver = { - .name = "simple-framebuffer", /* connect to sysfb */ - .of_match_table = simpledrm_of_match_table, - }, - .probe = simpledrm_probe, - .remove = simpledrm_remove, -}; - -module_platform_driver(simpledrm_platform_driver); - -MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/gpu/drm/tiny/st7586.c b/drivers/gpu/drm/tiny/st7586.c deleted file mode 100644 index a29672d84ede..000000000000 --- a/drivers/gpu/drm/tiny/st7586.c +++ /dev/null @@ -1,407 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* - * DRM driver for Sitronix ST7586 panels - * - * Copyright 2017 David Lechner <david@lechnology.com> - */ - -#include <linux/delay.h> -#include <linux/gpio/consumer.h> -#include <linux/module.h> -#include <linux/property.h> -#include <linux/spi/spi.h> -#include <video/mipi_display.h> - -#include <drm/clients/drm_client_setup.h> -#include <drm/drm_atomic_helper.h> -#include <drm/drm_damage_helper.h> -#include <drm/drm_drv.h> -#include <drm/drm_fb_dma_helper.h> -#include <drm/drm_fbdev_dma.h> -#include <drm/drm_format_helper.h> -#include <drm/drm_framebuffer.h> -#include <drm/drm_gem_atomic_helper.h> -#include <drm/drm_gem_dma_helper.h> -#include <drm/drm_gem_framebuffer_helper.h> -#include <drm/drm_managed.h> -#include <drm/drm_mipi_dbi.h> -#include <drm/drm_rect.h> - -/* controller-specific commands */ -#define ST7586_DISP_MODE_GRAY 0x38 -#define ST7586_DISP_MODE_MONO 0x39 -#define ST7586_ENABLE_DDRAM 0x3a -#define ST7586_SET_DISP_DUTY 0xb0 -#define ST7586_SET_PART_DISP 0xb4 -#define ST7586_SET_NLINE_INV 0xb5 -#define ST7586_SET_VOP 0xc0 -#define ST7586_SET_BIAS_SYSTEM 0xc3 -#define ST7586_SET_BOOST_LEVEL 0xc4 -#define ST7586_SET_VOP_OFFSET 0xc7 -#define ST7586_ENABLE_ANALOG 0xd0 -#define ST7586_AUTO_READ_CTRL 0xd7 -#define ST7586_OTP_RW_CTRL 0xe0 -#define ST7586_OTP_CTRL_OUT 0xe1 -#define ST7586_OTP_READ 0xe3 - -#define ST7586_DISP_CTRL_MX BIT(6) -#define ST7586_DISP_CTRL_MY BIT(7) - -/* - * The ST7586 controller has an unusual pixel format where 2bpp grayscale is - * packed 3 pixels per byte with the first two pixels using 3 bits and the 3rd - * pixel using only 2 bits. - * - * | D7 | D6 | D5 || | || 2bpp | - * | (D4) | (D3) | (D2) || D1 | D0 || GRAY | - * +------+------+------++------+------++------+ - * | 1 | 1 | 1 || 1 | 1 || 0 0 | black - * | 1 | 0 | 0 || 1 | 0 || 0 1 | dark gray - * | 0 | 1 | 0 || 0 | 1 || 1 0 | light gray - * | 0 | 0 | 0 || 0 | 0 || 1 1 | white - */ - -static const u8 st7586_lookup[] = { 0x7, 0x4, 0x2, 0x0 }; - -static void st7586_xrgb8888_to_gray332(u8 *dst, void *vaddr, - struct drm_framebuffer *fb, - struct drm_rect *clip, - struct drm_format_conv_state *fmtcnv_state) -{ - size_t len = (clip->x2 - clip->x1) * (clip->y2 - clip->y1); - unsigned int x, y; - u8 *src, *buf, val; - struct iosys_map dst_map, vmap; - - buf = kmalloc(len, GFP_KERNEL); - if (!buf) - return; - - iosys_map_set_vaddr(&dst_map, buf); - iosys_map_set_vaddr(&vmap, vaddr); - drm_fb_xrgb8888_to_gray8(&dst_map, NULL, &vmap, fb, clip, fmtcnv_state); - src = buf; - - for (y = clip->y1; y < clip->y2; y++) { - for (x = clip->x1; x < clip->x2; x += 3) { - val = st7586_lookup[*src++ >> 6] << 5; - val |= st7586_lookup[*src++ >> 6] << 2; - val |= st7586_lookup[*src++ >> 6] >> 1; - *dst++ = val; - } - } - - kfree(buf); -} - -static int st7586_buf_copy(void *dst, struct iosys_map *src, struct drm_framebuffer *fb, - struct drm_rect *clip, struct drm_format_conv_state *fmtcnv_state) -{ - int ret; - - ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); - if (ret) - return ret; - - st7586_xrgb8888_to_gray332(dst, src->vaddr, fb, clip, fmtcnv_state); - - drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); - - return 0; -} - -static void st7586_fb_dirty(struct iosys_map *src, struct drm_framebuffer *fb, - struct drm_rect *rect, struct drm_format_conv_state *fmtcnv_state) -{ - struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(fb->dev); - struct mipi_dbi *dbi = &dbidev->dbi; - int start, end, ret = 0; - - /* 3 pixels per byte, so grow clip to nearest multiple of 3 */ - rect->x1 = rounddown(rect->x1, 3); - rect->x2 = roundup(rect->x2, 3); - - DRM_DEBUG_KMS("Flushing [FB:%d] " DRM_RECT_FMT "\n", fb->base.id, DRM_RECT_ARG(rect)); - - ret = st7586_buf_copy(dbidev->tx_buf, src, fb, rect, fmtcnv_state); - if (ret) - goto err_msg; - - /* Pixels are packed 3 per byte */ - start = rect->x1 / 3; - end = rect->x2 / 3; - - mipi_dbi_command(dbi, MIPI_DCS_SET_COLUMN_ADDRESS, - (start >> 8) & 0xFF, start & 0xFF, - (end >> 8) & 0xFF, (end - 1) & 0xFF); - mipi_dbi_command(dbi, MIPI_DCS_SET_PAGE_ADDRESS, - (rect->y1 >> 8) & 0xFF, rect->y1 & 0xFF, - (rect->y2 >> 8) & 0xFF, (rect->y2 - 1) & 0xFF); - - ret = mipi_dbi_command_buf(dbi, MIPI_DCS_WRITE_MEMORY_START, - (u8 *)dbidev->tx_buf, - (end - start) * (rect->y2 - rect->y1)); -err_msg: - if (ret) - dev_err_once(fb->dev->dev, "Failed to update display %d\n", ret); -} - -static void st7586_pipe_update(struct drm_simple_display_pipe *pipe, - struct drm_plane_state *old_state) -{ - struct drm_plane_state *state = pipe->plane.state; - struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(state); - struct drm_framebuffer *fb = state->fb; - struct drm_rect rect; - int idx; - - if (!pipe->crtc.state->active) - return; - - if (!drm_dev_enter(fb->dev, &idx)) - return; - - if (drm_atomic_helper_damage_merged(old_state, state, &rect)) - st7586_fb_dirty(&shadow_plane_state->data[0], fb, &rect, - &shadow_plane_state->fmtcnv_state); - - drm_dev_exit(idx); -} - -static void st7586_pipe_enable(struct drm_simple_display_pipe *pipe, - struct drm_crtc_state *crtc_state, - struct drm_plane_state *plane_state) -{ - struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(pipe->crtc.dev); - struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state); - struct drm_framebuffer *fb = plane_state->fb; - struct mipi_dbi *dbi = &dbidev->dbi; - struct drm_rect rect = { - .x1 = 0, - .x2 = fb->width, - .y1 = 0, - .y2 = fb->height, - }; - int idx, ret; - u8 addr_mode; - - if (!drm_dev_enter(pipe->crtc.dev, &idx)) - return; - - DRM_DEBUG_KMS("\n"); - - ret = mipi_dbi_poweron_reset(dbidev); - if (ret) - goto out_exit; - - mipi_dbi_command(dbi, ST7586_AUTO_READ_CTRL, 0x9f); - mipi_dbi_command(dbi, ST7586_OTP_RW_CTRL, 0x00); - - msleep(10); - - mipi_dbi_command(dbi, ST7586_OTP_READ); - - msleep(20); - - mipi_dbi_command(dbi, ST7586_OTP_CTRL_OUT); - mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE); - mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_OFF); - - msleep(50); - - mipi_dbi_command(dbi, ST7586_SET_VOP_OFFSET, 0x00); - mipi_dbi_command(dbi, ST7586_SET_VOP, 0xe3, 0x00); - mipi_dbi_command(dbi, ST7586_SET_BIAS_SYSTEM, 0x02); - mipi_dbi_command(dbi, ST7586_SET_BOOST_LEVEL, 0x04); - mipi_dbi_command(dbi, ST7586_ENABLE_ANALOG, 0x1d); - mipi_dbi_command(dbi, ST7586_SET_NLINE_INV, 0x00); - mipi_dbi_command(dbi, ST7586_DISP_MODE_GRAY); - mipi_dbi_command(dbi, ST7586_ENABLE_DDRAM, 0x02); - - switch (dbidev->rotation) { - default: - addr_mode = 0x00; - break; - case 90: - addr_mode = ST7586_DISP_CTRL_MY; - break; - case 180: - addr_mode = ST7586_DISP_CTRL_MX | ST7586_DISP_CTRL_MY; - break; - case 270: - addr_mode = ST7586_DISP_CTRL_MX; - break; - } - mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, addr_mode); - - mipi_dbi_command(dbi, ST7586_SET_DISP_DUTY, 0x7f); - mipi_dbi_command(dbi, ST7586_SET_PART_DISP, 0xa0); - mipi_dbi_command(dbi, MIPI_DCS_SET_PARTIAL_ROWS, 0x00, 0x00, 0x00, 0x77); - mipi_dbi_command(dbi, MIPI_DCS_EXIT_INVERT_MODE); - - msleep(100); - - st7586_fb_dirty(&shadow_plane_state->data[0], fb, &rect, - &shadow_plane_state->fmtcnv_state); - - mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON); -out_exit: - drm_dev_exit(idx); -} - -static void st7586_pipe_disable(struct drm_simple_display_pipe *pipe) -{ - struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(pipe->crtc.dev); - - /* - * This callback is not protected by drm_dev_enter/exit since we want to - * turn off the display on regular driver unload. It's highly unlikely - * that the underlying SPI controller is gone should this be called after - * unplug. - */ - - DRM_DEBUG_KMS("\n"); - - mipi_dbi_command(&dbidev->dbi, MIPI_DCS_SET_DISPLAY_OFF); -} - -static const u32 st7586_formats[] = { - DRM_FORMAT_XRGB8888, -}; - -static const struct drm_simple_display_pipe_funcs st7586_pipe_funcs = { - .mode_valid = mipi_dbi_pipe_mode_valid, - .enable = st7586_pipe_enable, - .disable = st7586_pipe_disable, - .update = st7586_pipe_update, - .begin_fb_access = mipi_dbi_pipe_begin_fb_access, - .end_fb_access = mipi_dbi_pipe_end_fb_access, - .reset_plane = mipi_dbi_pipe_reset_plane, - .duplicate_plane_state = mipi_dbi_pipe_duplicate_plane_state, - .destroy_plane_state = mipi_dbi_pipe_destroy_plane_state, -}; - -static const struct drm_display_mode st7586_mode = { - DRM_SIMPLE_MODE(178, 128, 37, 27), -}; - -DEFINE_DRM_GEM_DMA_FOPS(st7586_fops); - -static const struct drm_driver st7586_driver = { - .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, - .fops = &st7586_fops, - DRM_GEM_DMA_DRIVER_OPS_VMAP, - DRM_FBDEV_DMA_DRIVER_OPS, - .debugfs_init = mipi_dbi_debugfs_init, - .name = "st7586", - .desc = "Sitronix ST7586", - .major = 1, - .minor = 0, -}; - -static const struct of_device_id st7586_of_match[] = { - { .compatible = "lego,ev3-lcd" }, - {}, -}; -MODULE_DEVICE_TABLE(of, st7586_of_match); - -static const struct spi_device_id st7586_id[] = { - { "ev3-lcd", 0 }, - { }, -}; -MODULE_DEVICE_TABLE(spi, st7586_id); - -static int st7586_probe(struct spi_device *spi) -{ - struct device *dev = &spi->dev; - struct mipi_dbi_dev *dbidev; - struct drm_device *drm; - struct mipi_dbi *dbi; - struct gpio_desc *a0; - u32 rotation = 0; - size_t bufsize; - int ret; - - dbidev = devm_drm_dev_alloc(dev, &st7586_driver, - struct mipi_dbi_dev, drm); - if (IS_ERR(dbidev)) - return PTR_ERR(dbidev); - - dbi = &dbidev->dbi; - drm = &dbidev->drm; - - bufsize = (st7586_mode.vdisplay + 2) / 3 * st7586_mode.hdisplay; - - dbi->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); - if (IS_ERR(dbi->reset)) - return dev_err_probe(dev, PTR_ERR(dbi->reset), "Failed to get GPIO 'reset'\n"); - - a0 = devm_gpiod_get(dev, "a0", GPIOD_OUT_LOW); - if (IS_ERR(a0)) - return dev_err_probe(dev, PTR_ERR(a0), "Failed to get GPIO 'a0'\n"); - - device_property_read_u32(dev, "rotation", &rotation); - - ret = mipi_dbi_spi_init(spi, dbi, a0); - if (ret) - return ret; - - /* Cannot read from this controller via SPI */ - dbi->read_commands = NULL; - - ret = mipi_dbi_dev_init_with_formats(dbidev, &st7586_pipe_funcs, - st7586_formats, ARRAY_SIZE(st7586_formats), - &st7586_mode, rotation, bufsize); - if (ret) - return ret; - - /* - * we are using 8-bit data, so we are not actually swapping anything, - * but setting mipi->swap_bytes makes mipi_dbi_typec3_command() do the - * right thing and not use 16-bit transfers (which results in swapped - * bytes on little-endian systems and causes out of order data to be - * sent to the display). - */ - dbi->swap_bytes = true; - - drm_mode_config_reset(drm); - - ret = drm_dev_register(drm, 0); - if (ret) - return ret; - - spi_set_drvdata(spi, drm); - - drm_client_setup(drm, NULL); - - return 0; -} - -static void st7586_remove(struct spi_device *spi) -{ - struct drm_device *drm = spi_get_drvdata(spi); - - drm_dev_unplug(drm); - drm_atomic_helper_shutdown(drm); -} - -static void st7586_shutdown(struct spi_device *spi) -{ - drm_atomic_helper_shutdown(spi_get_drvdata(spi)); -} - -static struct spi_driver st7586_spi_driver = { - .driver = { - .name = "st7586", - .of_match_table = st7586_of_match, - }, - .id_table = st7586_id, - .probe = st7586_probe, - .remove = st7586_remove, - .shutdown = st7586_shutdown, -}; -module_spi_driver(st7586_spi_driver); - -MODULE_DESCRIPTION("Sitronix ST7586 DRM driver"); -MODULE_AUTHOR("David Lechner <david@lechnology.com>"); -MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/st7735r.c b/drivers/gpu/drm/tiny/st7735r.c deleted file mode 100644 index 1d60f6e5b3bc..000000000000 --- a/drivers/gpu/drm/tiny/st7735r.c +++ /dev/null @@ -1,277 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0+ -/* - * DRM driver for display panels connected to a Sitronix ST7715R or ST7735R - * display controller in SPI mode. - * - * Copyright 2017 David Lechner <david@lechnology.com> - * Copyright (C) 2019 Glider bvba - */ - -#include <linux/backlight.h> -#include <linux/delay.h> -#include <linux/dma-buf.h> -#include <linux/gpio/consumer.h> -#include <linux/module.h> -#include <linux/property.h> -#include <linux/spi/spi.h> -#include <video/mipi_display.h> - -#include <drm/clients/drm_client_setup.h> -#include <drm/drm_atomic_helper.h> -#include <drm/drm_drv.h> -#include <drm/drm_fbdev_dma.h> -#include <drm/drm_gem_atomic_helper.h> -#include <drm/drm_gem_dma_helper.h> -#include <drm/drm_managed.h> -#include <drm/drm_mipi_dbi.h> - -#define ST7735R_FRMCTR1 0xb1 -#define ST7735R_FRMCTR2 0xb2 -#define ST7735R_FRMCTR3 0xb3 -#define ST7735R_INVCTR 0xb4 -#define ST7735R_PWCTR1 0xc0 -#define ST7735R_PWCTR2 0xc1 -#define ST7735R_PWCTR3 0xc2 -#define ST7735R_PWCTR4 0xc3 -#define ST7735R_PWCTR5 0xc4 -#define ST7735R_VMCTR1 0xc5 -#define ST7735R_GAMCTRP1 0xe0 -#define ST7735R_GAMCTRN1 0xe1 - -#define ST7735R_MY BIT(7) -#define ST7735R_MX BIT(6) -#define ST7735R_MV BIT(5) -#define ST7735R_RGB BIT(3) - -struct st7735r_cfg { - const struct drm_display_mode mode; - unsigned int left_offset; - unsigned int top_offset; - unsigned int write_only:1; - unsigned int rgb:1; /* RGB (vs. BGR) */ -}; - -struct st7735r_priv { - struct mipi_dbi_dev dbidev; /* Must be first for .release() */ - const struct st7735r_cfg *cfg; -}; - -static void st7735r_pipe_enable(struct drm_simple_display_pipe *pipe, - struct drm_crtc_state *crtc_state, - struct drm_plane_state *plane_state) -{ - struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(pipe->crtc.dev); - struct st7735r_priv *priv = container_of(dbidev, struct st7735r_priv, - dbidev); - struct mipi_dbi *dbi = &dbidev->dbi; - int ret, idx; - u8 addr_mode; - - if (!drm_dev_enter(pipe->crtc.dev, &idx)) - return; - - DRM_DEBUG_KMS("\n"); - - ret = mipi_dbi_poweron_reset(dbidev); - if (ret) - goto out_exit; - - msleep(150); - - mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE); - msleep(500); - - mipi_dbi_command(dbi, ST7735R_FRMCTR1, 0x01, 0x2c, 0x2d); - mipi_dbi_command(dbi, ST7735R_FRMCTR2, 0x01, 0x2c, 0x2d); - mipi_dbi_command(dbi, ST7735R_FRMCTR3, 0x01, 0x2c, 0x2d, 0x01, 0x2c, - 0x2d); - mipi_dbi_command(dbi, ST7735R_INVCTR, 0x07); - mipi_dbi_command(dbi, ST7735R_PWCTR1, 0xa2, 0x02, 0x84); - mipi_dbi_command(dbi, ST7735R_PWCTR2, 0xc5); - mipi_dbi_command(dbi, ST7735R_PWCTR3, 0x0a, 0x00); - mipi_dbi_command(dbi, ST7735R_PWCTR4, 0x8a, 0x2a); - mipi_dbi_command(dbi, ST7735R_PWCTR5, 0x8a, 0xee); - mipi_dbi_command(dbi, ST7735R_VMCTR1, 0x0e); - mipi_dbi_command(dbi, MIPI_DCS_EXIT_INVERT_MODE); - switch (dbidev->rotation) { - default: - addr_mode = ST7735R_MX | ST7735R_MY; - break; - case 90: - addr_mode = ST7735R_MX | ST7735R_MV; - break; - case 180: - addr_mode = 0; - break; - case 270: - addr_mode = ST7735R_MY | ST7735R_MV; - break; - } - - if (priv->cfg->rgb) - addr_mode |= ST7735R_RGB; - - mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, addr_mode); - mipi_dbi_command(dbi, MIPI_DCS_SET_PIXEL_FORMAT, - MIPI_DCS_PIXEL_FMT_16BIT); - mipi_dbi_command(dbi, ST7735R_GAMCTRP1, 0x02, 0x1c, 0x07, 0x12, 0x37, - 0x32, 0x29, 0x2d, 0x29, 0x25, 0x2b, 0x39, 0x00, 0x01, - 0x03, 0x10); - mipi_dbi_command(dbi, ST7735R_GAMCTRN1, 0x03, 0x1d, 0x07, 0x06, 0x2e, - 0x2c, 0x29, 0x2d, 0x2e, 0x2e, 0x37, 0x3f, 0x00, 0x00, - 0x02, 0x10); - mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON); - - msleep(100); - - mipi_dbi_command(dbi, MIPI_DCS_ENTER_NORMAL_MODE); - - msleep(20); - - mipi_dbi_enable_flush(dbidev, crtc_state, plane_state); -out_exit: - drm_dev_exit(idx); -} - -static const struct drm_simple_display_pipe_funcs st7735r_pipe_funcs = { - DRM_MIPI_DBI_SIMPLE_DISPLAY_PIPE_FUNCS(st7735r_pipe_enable), -}; - -static const struct st7735r_cfg jd_t18003_t01_cfg = { - .mode = { DRM_SIMPLE_MODE(128, 160, 28, 35) }, - /* Cannot read from Adafruit 1.8" display via SPI */ - .write_only = true, -}; - -static const struct st7735r_cfg rh128128t_cfg = { - .mode = { DRM_SIMPLE_MODE(128, 128, 25, 26) }, - .left_offset = 2, - .top_offset = 3, - .rgb = true, -}; - -DEFINE_DRM_GEM_DMA_FOPS(st7735r_fops); - -static const struct drm_driver st7735r_driver = { - .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, - .fops = &st7735r_fops, - DRM_GEM_DMA_DRIVER_OPS_VMAP, - DRM_FBDEV_DMA_DRIVER_OPS, - .debugfs_init = mipi_dbi_debugfs_init, - .name = "st7735r", - .desc = "Sitronix ST7735R", - .major = 1, - .minor = 0, -}; - -static const struct of_device_id st7735r_of_match[] = { - { .compatible = "jianda,jd-t18003-t01", .data = &jd_t18003_t01_cfg }, - { .compatible = "okaya,rh128128t", .data = &rh128128t_cfg }, - { }, -}; -MODULE_DEVICE_TABLE(of, st7735r_of_match); - -static const struct spi_device_id st7735r_id[] = { - { "jd-t18003-t01", (uintptr_t)&jd_t18003_t01_cfg }, - { "rh128128t", (uintptr_t)&rh128128t_cfg }, - { }, -}; -MODULE_DEVICE_TABLE(spi, st7735r_id); - -static int st7735r_probe(struct spi_device *spi) -{ - struct device *dev = &spi->dev; - const struct st7735r_cfg *cfg; - struct mipi_dbi_dev *dbidev; - struct st7735r_priv *priv; - struct drm_device *drm; - struct mipi_dbi *dbi; - struct gpio_desc *dc; - u32 rotation = 0; - int ret; - - cfg = device_get_match_data(&spi->dev); - if (!cfg) - cfg = (void *)spi_get_device_id(spi)->driver_data; - - priv = devm_drm_dev_alloc(dev, &st7735r_driver, - struct st7735r_priv, dbidev.drm); - if (IS_ERR(priv)) - return PTR_ERR(priv); - - dbidev = &priv->dbidev; - priv->cfg = cfg; - - dbi = &dbidev->dbi; - drm = &dbidev->drm; - - dbi->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); - if (IS_ERR(dbi->reset)) - return dev_err_probe(dev, PTR_ERR(dbi->reset), "Failed to get GPIO 'reset'\n"); - - dc = devm_gpiod_get(dev, "dc", GPIOD_OUT_LOW); - if (IS_ERR(dc)) - return dev_err_probe(dev, PTR_ERR(dc), "Failed to get GPIO 'dc'\n"); - - dbidev->backlight = devm_of_find_backlight(dev); - if (IS_ERR(dbidev->backlight)) - return PTR_ERR(dbidev->backlight); - - device_property_read_u32(dev, "rotation", &rotation); - - ret = mipi_dbi_spi_init(spi, dbi, dc); - if (ret) - return ret; - - if (cfg->write_only) - dbi->read_commands = NULL; - - dbidev->left_offset = cfg->left_offset; - dbidev->top_offset = cfg->top_offset; - - ret = mipi_dbi_dev_init(dbidev, &st7735r_pipe_funcs, &cfg->mode, - rotation); - if (ret) - return ret; - - drm_mode_config_reset(drm); - - ret = drm_dev_register(drm, 0); - if (ret) - return ret; - - spi_set_drvdata(spi, drm); - - drm_client_setup(drm, NULL); - - return 0; -} - -static void st7735r_remove(struct spi_device *spi) -{ - struct drm_device *drm = spi_get_drvdata(spi); - - drm_dev_unplug(drm); - drm_atomic_helper_shutdown(drm); -} - -static void st7735r_shutdown(struct spi_device *spi) -{ - drm_atomic_helper_shutdown(spi_get_drvdata(spi)); -} - -static struct spi_driver st7735r_spi_driver = { - .driver = { - .name = "st7735r", - .of_match_table = st7735r_of_match, - }, - .id_table = st7735r_id, - .probe = st7735r_probe, - .remove = st7735r_remove, - .shutdown = st7735r_shutdown, -}; -module_spi_driver(st7735r_spi_driver); - -MODULE_DESCRIPTION("Sitronix ST7735R DRM driver"); -MODULE_AUTHOR("David Lechner <david@lechnology.com>"); -MODULE_LICENSE("GPL"); |