diff options
Diffstat (limited to 'drivers/gpu/drm/tiny')
| -rw-r--r-- | drivers/gpu/drm/tiny/Kconfig | 97 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/Makefile | 8 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/appletbdrm.c | 834 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/arcpgu.c | 14 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/bochs.c | 425 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/cirrus-qemu.c (renamed from drivers/gpu/drm/tiny/cirrus.c) | 166 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/gm12u320.c | 68 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/hx8357d.c | 7 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/ili9163.c | 7 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/ili9225.c | 8 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/ili9341.c | 7 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/ili9486.c | 7 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/mi0283qt.c | 8 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/ofdrm.c | 1410 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/panel-mipi-dbi.c | 67 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/repaper.c | 11 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/sharp-memory.c | 670 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/simpledrm.c | 1060 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/st7586.c | 407 | ||||
| -rw-r--r-- | drivers/gpu/drm/tiny/st7735r.c | 276 |
20 files changed, 1957 insertions, 3600 deletions
diff --git a/drivers/gpu/drm/tiny/Kconfig b/drivers/gpu/drm/tiny/Kconfig index f6889f649bc1..06e54694a7f2 100644 --- a/drivers/gpu/drm/tiny/Kconfig +++ b/drivers/gpu/drm/tiny/Kconfig @@ -1,8 +1,22 @@ # 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 + select DRM_CLIENT_SELECTION select DRM_GEM_DMA_HELPER select DRM_KMS_HELPER help @@ -13,10 +27,9 @@ config DRM_ARCPGU config DRM_BOCHS tristate "DRM Support for bochs dispi vga interface (qemu stdvga)" depends on DRM && PCI && MMU + select DRM_CLIENT_SELECTION + select DRM_GEM_SHMEM_HELPER select DRM_KMS_HELPER - select DRM_VRAM_HELPER - select DRM_TTM - select DRM_TTM_HELPER help This is a KMS driver for qemu's stdvga output. Choose this option for qemu. @@ -25,7 +38,8 @@ config DRM_BOCHS config DRM_CIRRUS_QEMU tristate "Cirrus driver for QEMU emulated device" - depends on DRM && PCI && MMU + depends on DRM && PCI + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_SHMEM_HELPER help @@ -45,28 +59,17 @@ config DRM_CIRRUS_QEMU config DRM_GM12U320 tristate "GM12U320 driver for USB projectors" depends on DRM && USB && MMU + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_SHMEM_HELPER help 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_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 + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER select DRM_MIPI_DBI @@ -79,26 +82,10 @@ 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_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 + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER select DRM_MIPI_DBI @@ -113,6 +100,7 @@ config TINYDRM_ILI9163 tristate "DRM support for ILI9163 display panels" depends on DRM && SPI select BACKLIGHT_CLASS_DEVICE + select DRM_CLIENT_SELECTION select DRM_GEM_DMA_HELPER select DRM_KMS_HELPER select DRM_MIPI_DBI @@ -125,6 +113,7 @@ config TINYDRM_ILI9163 config TINYDRM_ILI9225 tristate "DRM support for ILI9225 display panels" depends on DRM && SPI + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER select DRM_MIPI_DBI @@ -137,6 +126,7 @@ config TINYDRM_ILI9225 config TINYDRM_ILI9341 tristate "DRM support for ILI9341 display panels" depends on DRM && SPI + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER select DRM_MIPI_DBI @@ -150,6 +140,7 @@ config TINYDRM_ILI9341 config TINYDRM_ILI9486 tristate "DRM support for ILI9486 display panels" depends on DRM && SPI + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER select DRM_MIPI_DBI @@ -164,6 +155,7 @@ config TINYDRM_ILI9486 config TINYDRM_MI0283QT tristate "DRM support for MI0283QT" depends on DRM && SPI + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER select DRM_MIPI_DBI @@ -175,6 +167,7 @@ config TINYDRM_MI0283QT config TINYDRM_REPAPER tristate "DRM support for Pervasive Displays RePaper panels (V231)" depends on DRM && SPI + select DRM_CLIENT_SELECTION select DRM_KMS_HELPER select DRM_GEM_DMA_HELPER help @@ -186,29 +179,23 @@ config TINYDRM_REPAPER If M is selected the module will be called repaper. -config TINYDRM_ST7586 - tristate "DRM support for Sitronix ST7586 display panels" +config TINYDRM_SHARP_MEMORY + tristate "DRM support for Sharp Memory LCD panels" depends on DRM && SPI - select DRM_KMS_HELPER + select DRM_CLIENT_SELECTION 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_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 + DRM Driver for the following Sharp Memory Panels: + * 1.00" Sharp Memory LCD (LS010B7DH04) + * 1.10" Sharp Memory LCD (LS011B7DH03) + * 1.20" Sharp Memory LCD (LS012B7DD01) + * 1.28" Sharp Memory LCD (LS013B7DH03) + * 1.26" Sharp Memory LCD (LS013B7DH05) + * 1.80" Sharp Memory LCD (LS018B7DH02) + * 2.70" Sharp Memory LCD (LS027B7DH01) + * 2.70" Sharp Memory LCD (LS027B7DH01A) + * 3.20" Sharp Memory LCD (LS032B7DD02) + * 4.40" Sharp Memory LCD (LS044Q7DH01) - If M is selected the module will be called st7735r. + If M is selected the module will be called sharp_memory. diff --git a/drivers/gpu/drm/tiny/Makefile b/drivers/gpu/drm/tiny/Makefile index 76dde89a044b..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.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 @@ -14,5 +13,4 @@ obj-$(CONFIG_TINYDRM_ILI9341) += ili9341.o obj-$(CONFIG_TINYDRM_ILI9486) += ili9486.o obj-$(CONFIG_TINYDRM_MI0283QT) += mi0283qt.o obj-$(CONFIG_TINYDRM_REPAPER) += repaper.o -obj-$(CONFIG_TINYDRM_ST7586) += st7586.o -obj-$(CONFIG_TINYDRM_ST7735R) += st7735r.o +obj-$(CONFIG_TINYDRM_SHARP_MEMORY) += sharp-memory.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 4f8f3172379e..7cf0f0ea1bfe 100644 --- a/drivers/gpu/drm/tiny/arcpgu.c +++ b/drivers/gpu/drm/tiny/arcpgu.c @@ -6,6 +6,8 @@ */ #include <linux/clk.h> + +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_debugfs.h> #include <drm/drm_device.h> @@ -251,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"); @@ -268,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); @@ -288,7 +288,7 @@ static int arcpgu_load(struct arcpgu_drm_private *arcpgu) * There is only one output port inside each device. It is linked with * encoder endpoint. */ - endpoint_node = of_graph_get_next_endpoint(pdev->dev.of_node, NULL); + endpoint_node = of_graph_get_endpoint_by_regs(pdev->dev.of_node, 0, -1); if (endpoint_node) { encoder_node = of_graph_get_remote_port_parent(endpoint_node); of_node_put(endpoint_node); @@ -365,12 +365,12 @@ static const struct drm_driver arcpgu_drm_driver = { .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC, .name = "arcpgu", .desc = "ARC PGU Controller", - .date = "20160219", .major = 1, .minor = 0, .patchlevel = 0, .fops = &arcpgu_drm_ops, DRM_GEM_DMA_DRIVER_OPS, + DRM_FBDEV_DMA_DRIVER_OPS, #ifdef CONFIG_DEBUG_FS .debugfs_init = arcpgu_debugfs_init, #endif @@ -394,7 +394,7 @@ static int arcpgu_probe(struct platform_device *pdev) if (ret) goto err_unload; - drm_fbdev_dma_setup(&arcpgu->drm, 16); + drm_client_setup_with_fourcc(&arcpgu->drm, DRM_FORMAT_RGB565); return 0; @@ -421,7 +421,7 @@ MODULE_DEVICE_TABLE(of, arcpgu_of_table); static struct platform_driver arcpgu_platform_driver = { .probe = arcpgu_probe, - .remove_new = arcpgu_remove, + .remove = arcpgu_remove, .driver = { .name = "arcpgu", .of_match_table = arcpgu_of_table, diff --git a/drivers/gpu/drm/tiny/bochs.c b/drivers/gpu/drm/tiny/bochs.c index c23c9f0cf49c..8706763af8fb 100644 --- a/drivers/gpu/drm/tiny/bochs.c +++ b/drivers/gpu/drm/tiny/bochs.c @@ -1,21 +1,26 @@ // SPDX-License-Identifier: GPL-2.0-or-later +#include <linux/bug.h> +#include <linux/aperture.h> #include <linux/module.h> #include <linux/pci.h> -#include <drm/drm_aperture.h> +#include <drm/clients/drm_client_setup.h> +#include <drm/drm_atomic.h> #include <drm/drm_atomic_helper.h> +#include <drm/drm_damage_helper.h> #include <drm/drm_drv.h> #include <drm/drm_edid.h> -#include <drm/drm_fbdev_generic.h> +#include <drm/drm_fbdev_shmem.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_vram_helper.h> +#include <drm/drm_gem_shmem_helper.h> #include <drm/drm_managed.h> #include <drm/drm_module.h> +#include <drm/drm_plane_helper.h> #include <drm/drm_probe_helper.h> -#include <drm/drm_simple_kms_helper.h> #include <video/vga.h> @@ -71,6 +76,8 @@ enum bochs_types { }; struct bochs_device { + struct drm_device dev; + /* hw */ void __iomem *mmio; int ioports; @@ -85,22 +92,32 @@ struct bochs_device { u16 yres_virtual; u32 stride; u32 bpp; - struct edid *edid; /* drm */ - struct drm_device *dev; - struct drm_simple_display_pipe pipe; + struct drm_plane primary_plane; + struct drm_crtc crtc; + struct drm_encoder encoder; struct drm_connector connector; }; +static struct bochs_device *to_bochs_device(const struct drm_device *dev) +{ + return container_of(dev, struct bochs_device, dev); +} + /* ---------------------------------------------------------------------- */ +static __always_inline bool bochs_uses_mmio(struct bochs_device *bochs) +{ + return !IS_ENABLED(CONFIG_HAS_IOPORT) || bochs->mmio; +} + static void bochs_vga_writeb(struct bochs_device *bochs, u16 ioport, u8 val) { if (WARN_ON(ioport < 0x3c0 || ioport > 0x3df)) return; - if (bochs->mmio) { + if (bochs_uses_mmio(bochs)) { int offset = ioport - 0x3c0 + 0x400; writeb(val, bochs->mmio + offset); @@ -114,7 +131,7 @@ static u8 bochs_vga_readb(struct bochs_device *bochs, u16 ioport) if (WARN_ON(ioport < 0x3c0 || ioport > 0x3df)) return 0xff; - if (bochs->mmio) { + if (bochs_uses_mmio(bochs)) { int offset = ioport - 0x3c0 + 0x400; return readb(bochs->mmio + offset); @@ -127,7 +144,7 @@ static u16 bochs_dispi_read(struct bochs_device *bochs, u16 reg) { u16 ret = 0; - if (bochs->mmio) { + if (bochs_uses_mmio(bochs)) { int offset = 0x500 + (reg << 1); ret = readw(bochs->mmio + offset); @@ -140,7 +157,7 @@ static u16 bochs_dispi_read(struct bochs_device *bochs, u16 reg) static void bochs_dispi_write(struct bochs_device *bochs, u16 reg, u16 val) { - if (bochs->mmio) { + if (bochs_uses_mmio(bochs)) { int offset = 0x500 + (reg << 1); writew(val, bochs->mmio + offset); @@ -172,12 +189,14 @@ static void bochs_hw_set_little_endian(struct bochs_device *bochs) #define bochs_hw_set_native_endian(_b) bochs_hw_set_little_endian(_b) #endif -static int bochs_get_edid_block(void *data, u8 *buf, - unsigned int block, size_t len) +static int bochs_get_edid_block(void *data, u8 *buf, unsigned int block, size_t len) { struct bochs_device *bochs = data; size_t i, start = block * EDID_LENGTH; + if (!bochs->mmio) + return -1; + if (start + len > 0x400 /* vga register offset */) return -1; @@ -187,55 +206,53 @@ static int bochs_get_edid_block(void *data, u8 *buf, return 0; } -static int bochs_hw_load_edid(struct bochs_device *bochs) +static const struct drm_edid *bochs_hw_read_edid(struct drm_connector *connector) { + struct drm_device *dev = connector->dev; + struct bochs_device *bochs = to_bochs_device(dev); u8 header[8]; - if (!bochs->mmio) - return -1; - /* check header to detect whenever edid support is enabled in qemu */ bochs_get_edid_block(bochs, header, 0, ARRAY_SIZE(header)); if (drm_edid_header_is_valid(header) != 8) - return -1; + return NULL; - kfree(bochs->edid); - bochs->edid = drm_do_get_edid(&bochs->connector, - bochs_get_edid_block, bochs); - if (bochs->edid == NULL) - return -1; + drm_dbg(dev, "Found EDID data blob.\n"); - return 0; + return drm_edid_read_custom(connector, bochs_get_edid_block, bochs); } -static int bochs_hw_init(struct drm_device *dev) +static int bochs_hw_init(struct bochs_device *bochs) { - struct bochs_device *bochs = dev->dev_private; + struct drm_device *dev = &bochs->dev; struct pci_dev *pdev = to_pci_dev(dev->dev); unsigned long addr, size, mem, ioaddr, iosize; u16 id; if (pdev->resource[2].flags & IORESOURCE_MEM) { + ioaddr = pci_resource_start(pdev, 2); + iosize = pci_resource_len(pdev, 2); /* mmio bar with vga and bochs registers present */ - if (pci_request_region(pdev, 2, "bochs-drm") != 0) { + if (!devm_request_mem_region(&pdev->dev, ioaddr, iosize, "bochs-drm")) { DRM_ERROR("Cannot request mmio region\n"); return -EBUSY; } - ioaddr = pci_resource_start(pdev, 2); - iosize = pci_resource_len(pdev, 2); - bochs->mmio = ioremap(ioaddr, iosize); + bochs->mmio = devm_ioremap(&pdev->dev, ioaddr, iosize); if (bochs->mmio == NULL) { DRM_ERROR("Cannot map mmio region\n"); return -ENOMEM; } - } else { + } else if (IS_ENABLED(CONFIG_HAS_IOPORT)) { ioaddr = VBE_DISPI_IOPORT_INDEX; iosize = 2; - if (!request_region(ioaddr, iosize, "bochs-drm")) { + if (!devm_request_region(&pdev->dev, ioaddr, iosize, "bochs-drm")) { DRM_ERROR("Cannot request ioports\n"); return -EBUSY; } bochs->ioports = 1; + } else { + dev_err(dev->dev, "I/O ports are not supported\n"); + return -EIO; } id = bochs_dispi_read(bochs, VBE_DISPI_INDEX_ID); @@ -258,10 +275,10 @@ static int bochs_hw_init(struct drm_device *dev) size = min(size, mem); } - if (pci_request_region(pdev, 0, "bochs-drm") != 0) + if (!devm_request_mem_region(&pdev->dev, addr, size, "bochs-drm")) DRM_WARN("Cannot request framebuffer, boot fb still active?\n"); - bochs->fb_map = ioremap(addr, size); + bochs->fb_map = devm_ioremap_wc(&pdev->dev, addr, size); if (bochs->fb_map == NULL) { DRM_ERROR("Cannot map framebuffer\n"); return -ENOMEM; @@ -290,22 +307,6 @@ noext: return 0; } -static void bochs_hw_fini(struct drm_device *dev) -{ - struct bochs_device *bochs = dev->dev_private; - - /* TODO: shot down existing vram mappings */ - - if (bochs->mmio) - iounmap(bochs->mmio); - if (bochs->ioports) - release_region(VBE_DISPI_IOPORT_INDEX, 2); - if (bochs->fb_map) - iounmap(bochs->fb_map); - pci_release_regions(to_pci_dev(dev->dev)); - kfree(bochs->edid); -} - static void bochs_hw_blank(struct bochs_device *bochs, bool blank) { DRM_DEBUG_DRIVER("hw_blank %d\n", blank); @@ -321,7 +322,7 @@ static void bochs_hw_setmode(struct bochs_device *bochs, struct drm_display_mode { int idx; - if (!drm_dev_enter(bochs->dev, &idx)) + if (!drm_dev_enter(&bochs->dev, &idx)) return; bochs->xres = mode->hdisplay; @@ -334,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); @@ -357,7 +356,7 @@ static void bochs_hw_setformat(struct bochs_device *bochs, const struct drm_form { int idx; - if (!drm_dev_enter(bochs->dev, &idx)) + if (!drm_dev_enter(&bochs->dev, &idx)) return; DRM_DEBUG_DRIVER("format %c%c%c%c\n", @@ -388,7 +387,7 @@ static void bochs_hw_setbase(struct bochs_device *bochs, int x, int y, int strid unsigned long offset; unsigned int vx, vy, vwidth, idx; - if (!drm_dev_enter(bochs->dev, &idx)) + if (!drm_dev_enter(&bochs->dev, &idx)) return; bochs->stride = stride; @@ -410,86 +409,159 @@ static void bochs_hw_setbase(struct bochs_device *bochs, int x, int y, int strid /* ---------------------------------------------------------------------- */ -static const uint32_t bochs_formats[] = { +static const uint32_t bochs_primary_plane_formats[] = { DRM_FORMAT_XRGB8888, DRM_FORMAT_BGRX8888, }; -static void bochs_plane_update(struct bochs_device *bochs, struct drm_plane_state *state) +static int bochs_primary_plane_helper_atomic_check(struct drm_plane *plane, + struct drm_atomic_state *state) { - struct drm_gem_vram_object *gbo; - s64 gpu_addr; + struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane); + struct drm_crtc *new_crtc = new_plane_state->crtc; + struct drm_crtc_state *new_crtc_state = NULL; + 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 (!state->fb || !bochs->stride) + return 0; +} + +static void bochs_primary_plane_helper_atomic_update(struct drm_plane *plane, + struct drm_atomic_state *state) +{ + struct drm_device *dev = plane->dev; + struct bochs_device *bochs = to_bochs_device(dev); + struct drm_plane_state *plane_state = plane->state; + 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_atomic_helper_damage_iter iter; + struct drm_rect damage; + + if (!fb || !bochs->stride) return; - gbo = drm_gem_vram_of_gem(state->fb->obj[0]); - gpu_addr = drm_gem_vram_offset(gbo); - if (WARN_ON_ONCE(gpu_addr < 0)) - return; /* Bug: we didn't pin the BO to VRAM in prepare_fb. */ + drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state); + drm_atomic_for_each_plane_damage(&iter, &damage) { + struct iosys_map dst = IOSYS_MAP_INIT_VADDR_IOMEM(bochs->fb_map); + + iosys_map_incr(&dst, drm_fb_clip_offset(fb->pitches[0], fb->format, &damage)); + drm_fb_memcpy(&dst, fb->pitches, shadow_plane_state->data, fb, &damage); + } + /* Always scanout image at VRAM offset 0 */ bochs_hw_setbase(bochs, - state->crtc_x, - state->crtc_y, - state->fb->pitches[0], - state->fb->offsets[0] + gpu_addr); - bochs_hw_setformat(bochs, state->fb->format); + plane_state->crtc_x, + plane_state->crtc_y, + fb->pitches[0], + 0); + bochs_hw_setformat(bochs, fb->format); } -static void bochs_pipe_enable(struct drm_simple_display_pipe *pipe, - struct drm_crtc_state *crtc_state, - struct drm_plane_state *plane_state) +static const struct drm_plane_helper_funcs bochs_primary_plane_helper_funcs = { + DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, + .atomic_check = bochs_primary_plane_helper_atomic_check, + .atomic_update = bochs_primary_plane_helper_atomic_update, +}; + +static const struct drm_plane_funcs bochs_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 void bochs_crtc_helper_mode_set_nofb(struct drm_crtc *crtc) { - struct bochs_device *bochs = pipe->crtc.dev->dev_private; + struct bochs_device *bochs = to_bochs_device(crtc->dev); + struct drm_crtc_state *crtc_state = crtc->state; bochs_hw_setmode(bochs, &crtc_state->mode); - bochs_plane_update(bochs, plane_state); } -static void bochs_pipe_disable(struct drm_simple_display_pipe *pipe) +static int bochs_crtc_helper_atomic_check(struct drm_crtc *crtc, + struct drm_atomic_state *state) { - struct bochs_device *bochs = pipe->crtc.dev->dev_private; + struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); - bochs_hw_blank(bochs, true); + if (!crtc_state->enable) + return 0; + + return drm_atomic_helper_check_crtc_primary_plane(crtc_state); } -static void bochs_pipe_update(struct drm_simple_display_pipe *pipe, - struct drm_plane_state *old_state) +static void bochs_crtc_helper_atomic_enable(struct drm_crtc *crtc, + struct drm_atomic_state *state) { - struct bochs_device *bochs = pipe->crtc.dev->dev_private; + struct bochs_device *bochs = to_bochs_device(crtc->dev); - bochs_plane_update(bochs, pipe->plane.state); + bochs_hw_blank(bochs, false); } -static const struct drm_simple_display_pipe_funcs bochs_pipe_funcs = { - .enable = bochs_pipe_enable, - .disable = bochs_pipe_disable, - .update = bochs_pipe_update, - .prepare_fb = drm_gem_vram_simple_display_pipe_prepare_fb, - .cleanup_fb = drm_gem_vram_simple_display_pipe_cleanup_fb, +static void bochs_crtc_helper_atomic_disable(struct drm_crtc *crtc, + struct drm_atomic_state *crtc_state) +{ + struct bochs_device *bochs = to_bochs_device(crtc->dev); + + bochs_hw_blank(bochs, true); +} + +static const struct drm_crtc_helper_funcs bochs_crtc_helper_funcs = { + .mode_set_nofb = bochs_crtc_helper_mode_set_nofb, + .atomic_check = bochs_crtc_helper_atomic_check, + .atomic_enable = bochs_crtc_helper_atomic_enable, + .atomic_disable = bochs_crtc_helper_atomic_disable, +}; + +static const struct drm_crtc_funcs bochs_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 bochs_encoder_funcs = { + .destroy = drm_encoder_cleanup, }; -static int bochs_connector_get_modes(struct drm_connector *connector) +static int bochs_connector_helper_get_modes(struct drm_connector *connector) { - struct bochs_device *bochs = - container_of(connector, struct bochs_device, connector); - int count = 0; + const struct drm_edid *edid; + int count; - if (bochs->edid) - count = drm_add_edid_modes(connector, bochs->edid); + edid = bochs_hw_read_edid(connector); - if (!count) { + if (edid) { + drm_edid_connector_update(connector, edid); + count = drm_edid_connector_add_modes(connector); + drm_edid_free(edid); + } else { + drm_edid_connector_update(connector, NULL); count = drm_add_modes_noedid(connector, 8192, 8192); drm_set_preferred_mode(connector, defx, defy); } + return count; } -static const struct drm_connector_helper_funcs bochs_connector_connector_helper_funcs = { - .get_modes = bochs_connector_get_modes, +static const struct drm_connector_helper_funcs bochs_connector_helper_funcs = { + .get_modes = bochs_connector_helper_get_modes, }; -static const struct drm_connector_funcs bochs_connector_connector_funcs = { +static const struct drm_connector_funcs bochs_connector_funcs = { .fill_modes = drm_helper_probe_single_connector_modes, .destroy = drm_connector_cleanup, .reset = drm_atomic_helper_connector_reset, @@ -497,68 +569,89 @@ static const struct drm_connector_funcs bochs_connector_connector_funcs = { .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, }; -static void bochs_connector_init(struct drm_device *dev) +static enum drm_mode_status bochs_mode_config_mode_valid(struct drm_device *dev, + const struct drm_display_mode *mode) { - struct bochs_device *bochs = dev->dev_private; - struct drm_connector *connector = &bochs->connector; - - drm_connector_init(dev, connector, &bochs_connector_connector_funcs, - DRM_MODE_CONNECTOR_VIRTUAL); - drm_connector_helper_add(connector, &bochs_connector_connector_helper_funcs); - - bochs_hw_load_edid(bochs); - if (bochs->edid) { - DRM_INFO("Found EDID data blob.\n"); - drm_connector_attach_edid_property(connector); - drm_connector_update_edid_property(connector, bochs->edid); - } -} + struct bochs_device *bochs = to_bochs_device(dev); + const struct drm_format_info *format = drm_format_info(DRM_FORMAT_XRGB8888); + u64 pitch; -static struct drm_framebuffer * -bochs_gem_fb_create(struct drm_device *dev, struct drm_file *file, - const struct drm_mode_fb_cmd2 *mode_cmd) -{ - if (mode_cmd->pixel_format != DRM_FORMAT_XRGB8888 && - mode_cmd->pixel_format != DRM_FORMAT_BGRX8888) - return ERR_PTR(-EINVAL); + if (drm_WARN_ON(dev, !format)) + return MODE_ERROR; + + pitch = drm_format_info_min_pitch(format, 0, mode->hdisplay); + if (!pitch) + return MODE_BAD_WIDTH; + if (mode->vdisplay > DIV_ROUND_DOWN_ULL(bochs->fb_size, pitch)) + return MODE_MEM; - return drm_gem_fb_create(dev, file, mode_cmd); + return MODE_OK; } -static const struct drm_mode_config_funcs bochs_mode_funcs = { - .fb_create = bochs_gem_fb_create, - .mode_valid = drm_vram_helper_mode_valid, +static const struct drm_mode_config_funcs bochs_mode_config_funcs = { + .fb_create = drm_gem_fb_create_with_dirty, + .mode_valid = bochs_mode_config_mode_valid, .atomic_check = drm_atomic_helper_check, .atomic_commit = drm_atomic_helper_commit, }; static int bochs_kms_init(struct bochs_device *bochs) { + struct drm_device *dev = &bochs->dev; + struct drm_plane *primary_plane; + struct drm_crtc *crtc; + struct drm_connector *connector; + struct drm_encoder *encoder; int ret; - ret = drmm_mode_config_init(bochs->dev); + ret = drmm_mode_config_init(dev); if (ret) return ret; - bochs->dev->mode_config.max_width = 8192; - bochs->dev->mode_config.max_height = 8192; + dev->mode_config.max_width = 8192; + dev->mode_config.max_height = 8192; - bochs->dev->mode_config.preferred_depth = 24; - bochs->dev->mode_config.prefer_shadow = 0; - bochs->dev->mode_config.quirk_addfb_prefer_host_byte_order = true; + dev->mode_config.preferred_depth = 24; + dev->mode_config.quirk_addfb_prefer_host_byte_order = true; - bochs->dev->mode_config.funcs = &bochs_mode_funcs; + dev->mode_config.funcs = &bochs_mode_config_funcs; - bochs_connector_init(bochs->dev); - drm_simple_display_pipe_init(bochs->dev, - &bochs->pipe, - &bochs_pipe_funcs, - bochs_formats, - ARRAY_SIZE(bochs_formats), - NULL, - &bochs->connector); + primary_plane = &bochs->primary_plane; + ret = drm_universal_plane_init(dev, primary_plane, 0, + &bochs_primary_plane_funcs, + bochs_primary_plane_formats, + ARRAY_SIZE(bochs_primary_plane_formats), + NULL, + DRM_PLANE_TYPE_PRIMARY, NULL); + if (ret) + return ret; + drm_plane_helper_add(primary_plane, &bochs_primary_plane_helper_funcs); + drm_plane_enable_fb_damage_clips(primary_plane); - drm_mode_config_reset(bochs->dev); + crtc = &bochs->crtc; + ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, + &bochs_crtc_funcs, NULL); + if (ret) + return ret; + drm_crtc_helper_add(crtc, &bochs_crtc_helper_funcs); + + encoder = &bochs->encoder; + ret = drm_encoder_init(dev, encoder, &bochs_encoder_funcs, + DRM_MODE_ENCODER_VIRTUAL, NULL); + if (ret) + return ret; + encoder->possible_crtcs = drm_crtc_mask(crtc); + + connector = &bochs->connector; + ret = drm_connector_init(dev, connector, &bochs_connector_funcs, + DRM_MODE_CONNECTOR_VIRTUAL); + if (ret) + return ret; + drm_connector_helper_add(connector, &bochs_connector_helper_funcs); + drm_connector_attach_edid_property(connector); + drm_connector_attach_encoder(connector, encoder); + + drm_mode_config_reset(dev); return 0; } @@ -566,34 +659,19 @@ static int bochs_kms_init(struct bochs_device *bochs) /* ---------------------------------------------------------------------- */ /* drm interface */ -static int bochs_load(struct drm_device *dev) +static int bochs_load(struct bochs_device *bochs) { - struct bochs_device *bochs; int ret; - bochs = drmm_kzalloc(dev, sizeof(*bochs), GFP_KERNEL); - if (bochs == NULL) - return -ENOMEM; - dev->dev_private = bochs; - bochs->dev = dev; - - ret = bochs_hw_init(dev); + ret = bochs_hw_init(bochs); if (ret) return ret; - ret = drmm_vram_helper_init(dev, bochs->fb_base, bochs->fb_size); - if (ret) - goto err_hw_fini; - ret = bochs_kms_init(bochs); if (ret) - goto err_hw_fini; + return ret; return 0; - -err_hw_fini: - bochs_hw_fini(dev); - return ret; } DEFINE_DRM_GEM_FOPS(bochs_fops); @@ -603,10 +681,10 @@ static const struct drm_driver bochs_driver = { .fops = &bochs_fops, .name = "bochs-drm", .desc = "bochs dispi vga interface (qemu stdvga)", - .date = "20130925", .major = 1, .minor = 0, - DRM_GEM_VRAM_DRIVER, + DRM_GEM_SHMEM_DRIVER_OPS, + DRM_FBDEV_SHMEM_DRIVER_OPS, }; /* ---------------------------------------------------------------------- */ @@ -638,23 +716,18 @@ static const struct dev_pm_ops bochs_pm_ops = { static int bochs_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { + struct bochs_device *bochs; struct drm_device *dev; - unsigned long fbsize; int ret; - fbsize = pci_resource_len(pdev, 0); - if (fbsize < 4 * 1024 * 1024) { - DRM_ERROR("less than 4 MB video memory, ignoring device\n"); - return -ENOMEM; - } - - ret = drm_aperture_remove_conflicting_pci_framebuffers(pdev, &bochs_driver); + ret = aperture_remove_conflicting_pci_devices(pdev, bochs_driver.name); if (ret) return ret; - dev = drm_dev_alloc(&bochs_driver, &pdev->dev); - if (IS_ERR(dev)) - return PTR_ERR(dev); + bochs = devm_drm_dev_alloc(&pdev->dev, &bochs_driver, struct bochs_device, dev); + if (IS_ERR(bochs)) + return PTR_ERR(bochs); + dev = &bochs->dev; ret = pcim_enable_device(pdev); if (ret) @@ -662,19 +735,18 @@ static int bochs_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent pci_set_drvdata(pdev, dev); - ret = bochs_load(dev); + ret = bochs_load(bochs); if (ret) goto err_free_dev; ret = drm_dev_register(dev, 0); if (ret) - goto err_hw_fini; + goto err_free_dev; + + drm_client_setup(dev, NULL); - drm_fbdev_generic_setup(dev, 32); return ret; -err_hw_fini: - bochs_hw_fini(dev); err_free_dev: drm_dev_put(dev); return ret; @@ -686,8 +758,6 @@ static void bochs_pci_remove(struct pci_dev *pdev) drm_dev_unplug(dev); drm_atomic_helper_shutdown(dev); - bochs_hw_fini(dev); - drm_dev_put(dev); } static void bochs_pci_shutdown(struct pci_dev *pdev) @@ -736,4 +806,5 @@ drm_module_pci_driver_if_modeset(bochs_pci_driver, bochs_modeset); MODULE_DEVICE_TABLE(pci, bochs_pci_tbl); MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>"); +MODULE_DESCRIPTION("DRM Support for bochs dispi vga interface (qemu stdvga)"); MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/cirrus.c b/drivers/gpu/drm/tiny/cirrus-qemu.c index 4e3a152f897a..97a93adc5669 100644 --- a/drivers/gpu/drm/tiny/cirrus.c +++ b/drivers/gpu/drm/tiny/cirrus-qemu.c @@ -16,6 +16,7 @@ * Copyright 1999-2001 Jeff Garzik <jgarzik@pobox.com> */ +#include <linux/aperture.h> #include <linux/iosys-map.h> #include <linux/module.h> #include <linux/pci.h> @@ -23,7 +24,7 @@ #include <video/cirrus.h> #include <video/vga.h> -#include <drm/drm_aperture.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_atomic_state_helper.h> @@ -31,7 +32,7 @@ #include <drm/drm_damage_helper.h> #include <drm/drm_drv.h> #include <drm/drm_edid.h> -#include <drm/drm_fbdev_generic.h> +#include <drm/drm_fbdev_shmem.h> #include <drm/drm_file.h> #include <drm/drm_format_helper.h> #include <drm/drm_fourcc.h> @@ -45,9 +46,8 @@ #include <drm/drm_module.h> #include <drm/drm_probe_helper.h> -#define DRIVER_NAME "cirrus" +#define DRIVER_NAME "cirrus-qemu" #define DRIVER_DESC "qemu cirrus vga" -#define DRIVER_DATE "2019" #define DRIVER_MAJOR 2 #define DRIVER_MINOR 0 @@ -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) @@ -509,8 +398,10 @@ static void cirrus_crtc_helper_atomic_enable(struct drm_crtc *crtc, cirrus_mode_set(cirrus, &crtc_state->mode); +#ifdef CONFIG_HAS_IOPORT /* Unblank (needed on S3 resume, vgabios doesn't do it then) */ outb(VGA_AR_ENABLE_DISPLAY, VGA_ATT_W); +#endif drm_dev_exit(idx); } @@ -586,14 +477,14 @@ static int cirrus_pipe_init(struct cirrus_device *cirrus) encoder = &cirrus->encoder; ret = drm_encoder_init(dev, encoder, &cirrus_encoder_funcs, - DRM_MODE_ENCODER_DAC, NULL); + DRM_MODE_ENCODER_VIRTUAL, NULL); if (ret) return ret; encoder->possible_crtcs = drm_crtc_mask(crtc); connector = &cirrus->connector; ret = drm_connector_init(dev, connector, &cirrus_connector_funcs, - DRM_MODE_CONNECTOR_VGA); + DRM_MODE_CONNECTOR_VIRTUAL); if (ret) return ret; drm_connector_helper_add(connector, &cirrus_connector_helper_funcs); @@ -612,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; @@ -656,12 +555,12 @@ static const struct drm_driver cirrus_driver = { .name = DRIVER_NAME, .desc = DRIVER_DESC, - .date = DRIVER_DATE, .major = DRIVER_MAJOR, .minor = DRIVER_MINOR, .fops = &cirrus_fops, DRM_GEM_SHMEM_DRIVER_OPS, + DRM_FBDEV_SHMEM_DRIVER_OPS, }; static int cirrus_pci_probe(struct pci_dev *pdev, @@ -671,7 +570,7 @@ static int cirrus_pci_probe(struct pci_dev *pdev, struct cirrus_device *cirrus; int ret; - ret = drm_aperture_remove_conflicting_pci_framebuffers(pdev, &cirrus_driver); + ret = aperture_remove_conflicting_pci_devices(pdev, cirrus_driver.name); if (ret) return ret; @@ -679,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; @@ -716,7 +615,7 @@ static int cirrus_pci_probe(struct pci_dev *pdev, if (ret) return ret; - drm_fbdev_generic_setup(dev, 16); + drm_client_setup(dev, NULL); return 0; } @@ -760,4 +659,5 @@ static struct pci_driver cirrus_pci_driver = { drm_module_pci_driver(cirrus_pci_driver) MODULE_DEVICE_TABLE(pci, pciidlist); +MODULE_DESCRIPTION("Cirrus driver for QEMU emulated device"); MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/gm12u320.c b/drivers/gpu/drm/tiny/gm12u320.c index 0187539ff5ea..fb0004166f4a 100644 --- a/drivers/gpu/drm/tiny/gm12u320.c +++ b/drivers/gpu/drm/tiny/gm12u320.c @@ -7,13 +7,14 @@ #include <linux/pm.h> #include <linux/usb.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_atomic_state_helper.h> #include <drm/drm_connector.h> #include <drm/drm_damage_helper.h> #include <drm/drm_drv.h> #include <drm/drm_edid.h> -#include <drm/drm_fbdev_generic.h> +#include <drm/drm_fbdev_shmem.h> #include <drm/drm_file.h> #include <drm/drm_format_helper.h> #include <drm/drm_fourcc.h> @@ -33,7 +34,6 @@ MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)"); #define DRIVER_NAME "gm12u320" #define DRIVER_DESC "Grain Media GM12U320 USB projector display" -#define DRIVER_DATE "2019" #define DRIVER_MAJOR 1 #define DRIVER_MINOR 0 @@ -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; @@ -464,7 +463,7 @@ static int gm12u320_set_ecomode(struct gm12u320_device *gm12u320) * Note this assumes this driver is only ever used with the Acer C120, if we * add support for other devices the vendor and model should be parameterized. */ -static struct edid gm12u320_edid = { +static const struct edid gm12u320_edid = { .header = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }, .mfg_id = { 0x04, 0x72 }, /* "ACR" */ .prod_code = { 0x20, 0xc1 }, /* C120h */ @@ -523,8 +522,15 @@ static struct edid gm12u320_edid = { static int gm12u320_conn_get_modes(struct drm_connector *connector) { - drm_connector_update_edid_property(connector, &gm12u320_edid); - return drm_add_edid_modes(connector, &gm12u320_edid); + const struct drm_edid *drm_edid; + int count; + + drm_edid = drm_edid_alloc(&gm12u320_edid, sizeof(gm12u320_edid)); + drm_edid_connector_update(connector, drm_edid); + count = drm_edid_connector_add_modes(connector); + drm_edid_free(drm_edid); + + return count; } static const struct drm_connector_helper_funcs gm12u320_conn_helper_funcs = { @@ -595,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 = { @@ -618,13 +608,12 @@ static const struct drm_driver gm12u320_drm_driver = { .name = DRIVER_NAME, .desc = DRIVER_DESC, - .date = DRIVER_DATE, .major = DRIVER_MAJOR, .minor = DRIVER_MINOR, .fops = &gm12u320_fops, DRM_GEM_SHMEM_DRIVER_OPS, - .gem_prime_import = gm12u320_gem_prime_import, + DRM_FBDEV_SHMEM_DRIVER_OPS, }; static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = { @@ -638,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; /* @@ -653,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; @@ -672,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, @@ -690,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_fbdev_generic_setup(dev, 0); + 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); } @@ -755,4 +742,5 @@ static struct usb_driver gm12u320_usb_driver = { module_usb_driver(gm12u320_usb_driver); MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); +MODULE_DESCRIPTION("GM12U320 driver for USB projectors"); MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/hx8357d.c b/drivers/gpu/drm/tiny/hx8357d.c index cdc4486e059b..df263818f45f 100644 --- a/drivers/gpu/drm/tiny/hx8357d.c +++ b/drivers/gpu/drm/tiny/hx8357d.c @@ -16,9 +16,10 @@ #include <linux/property.h> #include <linux/spi/spi.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_drv.h> -#include <drm/drm_fbdev_generic.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> @@ -194,10 +195,10 @@ static const struct drm_driver hx8357d_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &hx8357d_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .debugfs_init = mipi_dbi_debugfs_init, .name = "hx8357d", .desc = "HX8357D", - .date = "20181023", .major = 1, .minor = 0, }; @@ -256,7 +257,7 @@ static int hx8357d_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } diff --git a/drivers/gpu/drm/tiny/ili9163.c b/drivers/gpu/drm/tiny/ili9163.c index bc4384d410fc..62cadf5e033d 100644 --- a/drivers/gpu/drm/tiny/ili9163.c +++ b/drivers/gpu/drm/tiny/ili9163.c @@ -7,9 +7,10 @@ #include <linux/property.h> #include <linux/spi/spi.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_drv.h> -#include <drm/drm_fbdev_generic.h> +#include <drm/drm_fbdev_dma.h> #include <drm/drm_gem_atomic_helper.h> #include <drm/drm_gem_dma_helper.h> #include <drm/drm_mipi_dbi.h> @@ -113,10 +114,10 @@ static struct drm_driver ili9163_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &ili9163_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .debugfs_init = mipi_dbi_debugfs_init, .name = "ili9163", .desc = "Ilitek ILI9163", - .date = "20210208", .major = 1, .minor = 0, }; @@ -185,7 +186,7 @@ static int ili9163_probe(struct spi_device *spi) if (ret) return ret; - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } diff --git a/drivers/gpu/drm/tiny/ili9225.c b/drivers/gpu/drm/tiny/ili9225.c index dd8b0a181be9..6de44ff69b51 100644 --- a/drivers/gpu/drm/tiny/ili9225.c +++ b/drivers/gpu/drm/tiny/ili9225.c @@ -16,11 +16,12 @@ #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_generic.h> +#include <drm/drm_fbdev_dma.h> #include <drm/drm_fourcc.h> #include <drm/drm_framebuffer.h> #include <drm/drm_gem_atomic_helper.h> @@ -360,9 +361,9 @@ static const struct drm_driver ili9225_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &ili9225_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .name = "ili9225", .desc = "Ilitek ILI9225", - .date = "20171106", .major = 1, .minor = 0, }; @@ -426,7 +427,7 @@ static int ili9225_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } @@ -447,7 +448,6 @@ static void ili9225_shutdown(struct spi_device *spi) static struct spi_driver ili9225_spi_driver = { .driver = { .name = "ili9225", - .owner = THIS_MODULE, .of_match_table = ili9225_of_match, }, .id_table = ili9225_id, diff --git a/drivers/gpu/drm/tiny/ili9341.c b/drivers/gpu/drm/tiny/ili9341.c index 47b61c3bf145..e55029433509 100644 --- a/drivers/gpu/drm/tiny/ili9341.c +++ b/drivers/gpu/drm/tiny/ili9341.c @@ -15,9 +15,10 @@ #include <linux/property.h> #include <linux/spi/spi.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_drv.h> -#include <drm/drm_fbdev_generic.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> @@ -150,10 +151,10 @@ static const struct drm_driver ili9341_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &ili9341_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .debugfs_init = mipi_dbi_debugfs_init, .name = "ili9341", .desc = "Ilitek ILI9341", - .date = "20180514", .major = 1, .minor = 0, }; @@ -218,7 +219,7 @@ static int ili9341_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } diff --git a/drivers/gpu/drm/tiny/ili9486.c b/drivers/gpu/drm/tiny/ili9486.c index 938bceed5999..093661c771a0 100644 --- a/drivers/gpu/drm/tiny/ili9486.c +++ b/drivers/gpu/drm/tiny/ili9486.c @@ -14,9 +14,10 @@ #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_generic.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> @@ -172,10 +173,10 @@ static const struct drm_driver ili9486_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &ili9486_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .debugfs_init = mipi_dbi_debugfs_init, .name = "ili9486", .desc = "Ilitek ILI9486", - .date = "20200118", .major = 1, .minor = 0, }; @@ -247,7 +248,7 @@ static int ili9486_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } diff --git a/drivers/gpu/drm/tiny/mi0283qt.c b/drivers/gpu/drm/tiny/mi0283qt.c index 01ff43c8ac3f..b6b4664908ae 100644 --- a/drivers/gpu/drm/tiny/mi0283qt.c +++ b/drivers/gpu/drm/tiny/mi0283qt.c @@ -13,9 +13,10 @@ #include <linux/regulator/consumer.h> #include <linux/spi/spi.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_drv.h> -#include <drm/drm_fbdev_generic.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> @@ -154,10 +155,10 @@ static const struct drm_driver mi0283qt_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &mi0283qt_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .debugfs_init = mipi_dbi_debugfs_init, .name = "mi0283qt", .desc = "Multi-Inno MI0283QT", - .date = "20160614", .major = 1, .minor = 0, }; @@ -226,7 +227,7 @@ static int mi0283qt_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } @@ -263,7 +264,6 @@ static const struct dev_pm_ops mi0283qt_pm_ops = { static struct spi_driver mi0283qt_spi_driver = { .driver = { .name = "mi0283qt", - .owner = THIS_MODULE, .of_match_table = mi0283qt_of_match, .pm = &mi0283qt_pm_ops, }, diff --git a/drivers/gpu/drm/tiny/ofdrm.c b/drivers/gpu/drm/tiny/ofdrm.c deleted file mode 100644 index ab89b7fc7bf6..000000000000 --- a/drivers/gpu/drm/tiny/ofdrm.c +++ /dev/null @@ -1,1410 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only - -#include <linux/of_address.h> -#include <linux/pci.h> -#include <linux/platform_device.h> - -#include <drm/drm_aperture.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_generic.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_DATE "20220501" -#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_from_firmware(dev, 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, - .name = DRIVER_NAME, - .desc = DRIVER_DESC, - .date = DRIVER_DATE, - .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; - unsigned int color_mode; - 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; - - color_mode = drm_format_info_bpp(odev->format, 0); - if (color_mode == 16) - color_mode = odev->format->depth; // can be 15 or 16 - - drm_fbdev_generic_setup(dev, color_mode); - - 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_new = 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 f80a141fcf36..23914a9f7fd3 100644 --- a/drivers/gpu/drm/tiny/panel-mipi-dbi.c +++ b/drivers/gpu/drm/tiny/panel-mipi-dbi.c @@ -10,13 +10,15 @@ #include <linux/firmware.h> #include <linux/gpio/consumer.h> #include <linux/module.h> +#include <linux/of.h> #include <linux/property.h> #include <linux/regulator/consumer.h> #include <linux/spi/spi.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_drv.h> -#include <drm/drm_fbdev_generic.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> @@ -26,6 +28,49 @@ #include <video/mipi_display.h> +struct panel_mipi_dbi_format { + const char *name; + u32 fourcc; + unsigned int bpp; +}; + +static const struct panel_mipi_dbi_format panel_mipi_dbi_formats[] = { + { "r5g6b5", DRM_FORMAT_RGB565, 16 }, + { "b6x2g6x2r6x2", DRM_FORMAT_RGB888, 24 }, +}; + +static int panel_mipi_dbi_get_format(struct device *dev, u32 *formats, unsigned int *bpp) +{ + const char *format_name; + unsigned int i; + int ret; + + formats[1] = DRM_FORMAT_XRGB8888; + + ret = device_property_read_string(dev, "format", &format_name); + if (ret) { + /* Old Device Trees don't have this property */ + formats[0] = DRM_FORMAT_RGB565; + *bpp = 16; + return 0; + } + + for (i = 0; i < ARRAY_SIZE(panel_mipi_dbi_formats); i++) { + const struct panel_mipi_dbi_format *format = &panel_mipi_dbi_formats[i]; + + if (strcmp(format_name, format->name)) + continue; + + formats[0] = format->fourcc; + *bpp = format->bpp; + return 0; + } + + dev_err(dev, "Pixel format is not supported: '%s'\n", format_name); + + return -EINVAL; +} + static const u8 panel_mipi_dbi_magic[15] = { 'M', 'I', 'P', 'I', ' ', 'D', 'B', 'I', 0, 0, 0, 0, 0, 0, 0 }; @@ -221,10 +266,10 @@ static const struct drm_driver panel_mipi_dbi_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &panel_mipi_dbi_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .debugfs_init = mipi_dbi_debugfs_init, .name = "panel-mipi-dbi", .desc = "MIPI DBI compatible display panel", - .date = "20220103", .major = 1, .minor = 0, }; @@ -276,6 +321,9 @@ static int panel_mipi_dbi_spi_probe(struct spi_device *spi) struct drm_device *drm; struct mipi_dbi *dbi; struct gpio_desc *dc; + unsigned int bpp; + size_t buf_size; + u32 formats[2]; int ret; dbidev = devm_drm_dev_alloc(dev, &panel_mipi_dbi_driver, struct mipi_dbi_dev, drm); @@ -323,7 +371,14 @@ static int panel_mipi_dbi_spi_probe(struct spi_device *spi) if (IS_ERR(dbidev->driver_private)) return PTR_ERR(dbidev->driver_private); - ret = mipi_dbi_dev_init(dbidev, &panel_mipi_dbi_pipe_funcs, &mode, 0); + ret = panel_mipi_dbi_get_format(dev, formats, &bpp); + if (ret) + return ret; + + buf_size = DIV_ROUND_UP(mode.hdisplay * mode.vdisplay * bpp, 8); + ret = mipi_dbi_dev_init_with_formats(dbidev, &panel_mipi_dbi_pipe_funcs, + formats, ARRAY_SIZE(formats), + &mode, 0, buf_size); if (ret) return ret; @@ -335,7 +390,10 @@ static int panel_mipi_dbi_spi_probe(struct spi_device *spi) spi_set_drvdata(spi, drm); - drm_fbdev_generic_setup(drm, 0); + if (bpp == 16) + drm_client_setup_with_fourcc(drm, DRM_FORMAT_RGB565); + else + drm_client_setup_with_fourcc(drm, DRM_FORMAT_RGB888); return 0; } @@ -384,7 +442,6 @@ MODULE_DEVICE_TABLE(spi, panel_mipi_dbi_spi_id); static struct spi_driver panel_mipi_dbi_spi_driver = { .driver = { .name = "panel-mipi-dbi-spi", - .owner = THIS_MODULE, .of_match_table = panel_mipi_dbi_spi_of_match, .pm = &panel_mipi_dbi_pm_ops, }, diff --git a/drivers/gpu/drm/tiny/repaper.c b/drivers/gpu/drm/tiny/repaper.c index 8fd6758f5725..5c3b51eb0a97 100644 --- a/drivers/gpu/drm/tiny/repaper.c +++ b/drivers/gpu/drm/tiny/repaper.c @@ -21,12 +21,13 @@ #include <linux/spi/spi.h> #include <linux/thermal.h> +#include <drm/clients/drm_client_setup.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_connector.h> #include <drm/drm_damage_helper.h> #include <drm/drm_drv.h> #include <drm/drm_fb_dma_helper.h> -#include <drm/drm_fbdev_generic.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> @@ -455,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); @@ -466,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); @@ -913,9 +914,9 @@ static const struct drm_driver repaper_driver = { .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, .fops = &repaper_fops, DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, .name = "repaper", .desc = "Pervasive Displays RePaper e-ink panels", - .date = "20170405", .major = 1, .minor = 0, }; @@ -1118,7 +1119,7 @@ static int repaper_probe(struct spi_device *spi) DRM_DEBUG_DRIVER("SPI speed: %uMHz\n", spi->max_speed_hz / 1000000); - drm_fbdev_generic_setup(drm, 0); + drm_client_setup(drm, NULL); return 0; } diff --git a/drivers/gpu/drm/tiny/sharp-memory.c b/drivers/gpu/drm/tiny/sharp-memory.c new file mode 100644 index 000000000000..03d2850310c4 --- /dev/null +++ b/drivers/gpu/drm/tiny/sharp-memory.c @@ -0,0 +1,670 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) + +#include <drm/clients/drm_client_setup.h> +#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h> +#include <drm/drm_connector.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_modes.h> +#include <drm/drm_probe_helper.h> +#include <drm/drm_rect.h> +#include <linux/bitrev.h> +#include <linux/delay.h> +#include <linux/gpio/consumer.h> +#include <linux/kthread.h> +#include <linux/mod_devicetable.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/pwm.h> +#include <linux/spi/spi.h> + +#define SHARP_MODE_PERIOD 8 +#define SHARP_ADDR_PERIOD 8 +#define SHARP_DUMMY_PERIOD 8 + +#define SHARP_MEMORY_DISPLAY_MAINTAIN_MODE 0 +#define SHARP_MEMORY_DISPLAY_UPDATE_MODE 1 +#define SHARP_MEMORY_DISPLAY_CLEAR_MODE 4 + +enum sharp_memory_model { + LS010B7DH04, + LS011B7DH03, + LS012B7DD01, + LS013B7DH03, + LS013B7DH05, + LS018B7DH02, + LS027B7DH01, + LS027B7DH01A, + LS032B7DD02, + LS044Q7DH01, +}; + +enum sharp_memory_vcom_mode { + SHARP_MEMORY_SOFTWARE_VCOM, + SHARP_MEMORY_EXTERNAL_VCOM, + SHARP_MEMORY_PWM_VCOM +}; + +struct sharp_memory_device { + struct drm_device drm; + struct spi_device *spi; + + const struct drm_display_mode *mode; + + struct drm_crtc crtc; + struct drm_plane plane; + struct drm_encoder encoder; + struct drm_connector connector; + + struct gpio_desc *enable_gpio; + + struct task_struct *sw_vcom_signal; + struct pwm_device *pwm_vcom_signal; + + enum sharp_memory_vcom_mode vcom_mode; + u8 vcom; + + u32 pitch; + u32 tx_buffer_size; + u8 *tx_buffer; + + /* When vcom_mode == "software" a kthread is used to periodically send a + * 'maintain display' message over spi. This mutex ensures tx_buffer access + * and spi bus usage is synchronized in this case. + */ + struct mutex tx_mutex; +}; + +static inline int sharp_memory_spi_write(struct spi_device *spi, void *buf, size_t len) +{ + /* Reverse the bit order */ + for (u8 *b = buf; b < ((u8 *)buf) + len; ++b) + *b = bitrev8(*b); + + return spi_write(spi, buf, len); +} + +static inline struct sharp_memory_device *drm_to_sharp_memory_device(struct drm_device *drm) +{ + return container_of(drm, struct sharp_memory_device, drm); +} + +DEFINE_DRM_GEM_DMA_FOPS(sharp_memory_fops); + +static const struct drm_driver sharp_memory_drm_driver = { + .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC, + .fops = &sharp_memory_fops, + DRM_GEM_DMA_DRIVER_OPS_VMAP, + DRM_FBDEV_DMA_DRIVER_OPS, + .name = "sharp_memory_display", + .desc = "Sharp Display Memory LCD", + .major = 1, + .minor = 0, +}; + +static inline void sharp_memory_set_tx_buffer_mode(u8 *buffer, u8 mode, u8 vcom) +{ + *buffer = mode | (vcom << 1); +} + +static inline void sharp_memory_set_tx_buffer_addresses(u8 *buffer, + struct drm_rect clip, + u32 pitch) +{ + for (u32 line = 0; line < clip.y2; ++line) + buffer[line * pitch] = line + 1; +} + +static void sharp_memory_set_tx_buffer_data(u8 *buffer, + struct drm_framebuffer *fb, + struct drm_rect clip, + u32 pitch, + struct drm_format_conv_state *fmtcnv_state) +{ + int ret; + struct iosys_map dst, vmap; + struct drm_gem_dma_object *dma_obj = drm_fb_dma_get_gem_obj(fb, 0); + + ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE); + if (ret) + return; + + iosys_map_set_vaddr(&dst, buffer); + iosys_map_set_vaddr(&vmap, dma_obj->vaddr); + + drm_fb_xrgb8888_to_mono(&dst, &pitch, &vmap, fb, &clip, fmtcnv_state); + + drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE); +} + +static int sharp_memory_update_display(struct sharp_memory_device *smd, + struct drm_framebuffer *fb, + struct drm_rect clip, + struct drm_format_conv_state *fmtcnv_state) +{ + int ret; + u32 pitch = smd->pitch; + u8 vcom = smd->vcom; + u8 *tx_buffer = smd->tx_buffer; + u32 tx_buffer_size = smd->tx_buffer_size; + + mutex_lock(&smd->tx_mutex); + + /* Populate the transmit buffer with frame data */ + sharp_memory_set_tx_buffer_mode(&tx_buffer[0], + SHARP_MEMORY_DISPLAY_UPDATE_MODE, vcom); + sharp_memory_set_tx_buffer_addresses(&tx_buffer[1], clip, pitch); + sharp_memory_set_tx_buffer_data(&tx_buffer[2], fb, clip, pitch, fmtcnv_state); + + ret = sharp_memory_spi_write(smd->spi, tx_buffer, tx_buffer_size); + + mutex_unlock(&smd->tx_mutex); + + return ret; +} + +static int sharp_memory_maintain_display(struct sharp_memory_device *smd) +{ + int ret; + u8 vcom = smd->vcom; + u8 *tx_buffer = smd->tx_buffer; + + mutex_lock(&smd->tx_mutex); + + sharp_memory_set_tx_buffer_mode(&tx_buffer[0], SHARP_MEMORY_DISPLAY_MAINTAIN_MODE, vcom); + tx_buffer[1] = 0; /* Write dummy data */ + ret = sharp_memory_spi_write(smd->spi, tx_buffer, 2); + + mutex_unlock(&smd->tx_mutex); + + return ret; +} + +static int sharp_memory_clear_display(struct sharp_memory_device *smd) +{ + int ret; + u8 vcom = smd->vcom; + u8 *tx_buffer = smd->tx_buffer; + + mutex_lock(&smd->tx_mutex); + + sharp_memory_set_tx_buffer_mode(&tx_buffer[0], SHARP_MEMORY_DISPLAY_CLEAR_MODE, vcom); + tx_buffer[1] = 0; /* write dummy data */ + ret = sharp_memory_spi_write(smd->spi, tx_buffer, 2); + + mutex_unlock(&smd->tx_mutex); + + return ret; +} + +static void sharp_memory_fb_dirty(struct drm_framebuffer *fb, struct drm_rect *rect, + struct drm_format_conv_state *fmtconv_state) +{ + struct drm_rect clip; + struct sharp_memory_device *smd = drm_to_sharp_memory_device(fb->dev); + + /* Always update a full line regardless of what is dirty */ + clip.x1 = 0; + clip.x2 = fb->width; + clip.y1 = rect->y1; + clip.y2 = rect->y2; + + sharp_memory_update_display(smd, fb, clip, fmtconv_state); +} + +static int sharp_memory_plane_atomic_check(struct drm_plane *plane, + struct drm_atomic_state *state) +{ + struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane); + struct sharp_memory_device *smd; + struct drm_crtc_state *crtc_state; + + smd = container_of(plane, struct sharp_memory_device, plane); + crtc_state = drm_atomic_get_new_crtc_state(state, &smd->crtc); + + return drm_atomic_helper_check_plane_state(plane_state, crtc_state, + DRM_PLANE_NO_SCALING, + DRM_PLANE_NO_SCALING, + false, false); +} + +static void sharp_memory_plane_atomic_update(struct drm_plane *plane, + struct drm_atomic_state *state) +{ + struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane); + struct drm_plane_state *plane_state = plane->state; + struct drm_format_conv_state fmtcnv_state = DRM_FORMAT_CONV_STATE_INIT; + struct sharp_memory_device *smd; + struct drm_rect rect; + + smd = container_of(plane, struct sharp_memory_device, plane); + if (!smd->crtc.state->active) + return; + + if (drm_atomic_helper_damage_merged(old_state, plane_state, &rect)) + sharp_memory_fb_dirty(plane_state->fb, &rect, &fmtcnv_state); + + drm_format_conv_state_release(&fmtcnv_state); +} + +static const struct drm_plane_helper_funcs sharp_memory_plane_helper_funcs = { + .prepare_fb = drm_gem_plane_helper_prepare_fb, + .atomic_check = sharp_memory_plane_atomic_check, + .atomic_update = sharp_memory_plane_atomic_update, +}; + +static bool sharp_memory_format_mod_supported(struct drm_plane *plane, + u32 format, + u64 modifier) +{ + return modifier == DRM_FORMAT_MOD_LINEAR; +} + +static const struct drm_plane_funcs sharp_memory_plane_funcs = { + .update_plane = drm_atomic_helper_update_plane, + .disable_plane = drm_atomic_helper_disable_plane, + .destroy = drm_plane_cleanup, + .reset = drm_atomic_helper_plane_reset, + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, + .format_mod_supported = sharp_memory_format_mod_supported, +}; + +static enum drm_mode_status sharp_memory_crtc_mode_valid(struct drm_crtc *crtc, + const struct drm_display_mode *mode) +{ + struct sharp_memory_device *smd = drm_to_sharp_memory_device(crtc->dev); + + return drm_crtc_helper_mode_valid_fixed(crtc, mode, smd->mode); +} + +static int sharp_memory_crtc_check(struct drm_crtc *crtc, + struct drm_atomic_state *state) +{ + struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); + int ret; + + if (!crtc_state->enable) + goto out; + + ret = drm_atomic_helper_check_crtc_primary_plane(crtc_state); + if (ret) + return ret; + +out: + return drm_atomic_add_affected_planes(state, crtc); +} + +static int sharp_memory_sw_vcom_signal_thread(void *data) +{ + struct sharp_memory_device *smd = data; + + while (!kthread_should_stop()) { + smd->vcom ^= 1; /* Toggle vcom */ + sharp_memory_maintain_display(smd); + msleep(1000); + } + + return 0; +} + +static void sharp_memory_crtc_enable(struct drm_crtc *crtc, + struct drm_atomic_state *state) +{ + struct sharp_memory_device *smd = drm_to_sharp_memory_device(crtc->dev); + + sharp_memory_clear_display(smd); + + if (smd->enable_gpio) + gpiod_set_value(smd->enable_gpio, 1); +} + +static void sharp_memory_crtc_disable(struct drm_crtc *crtc, + struct drm_atomic_state *state) +{ + struct sharp_memory_device *smd = drm_to_sharp_memory_device(crtc->dev); + + sharp_memory_clear_display(smd); + + if (smd->enable_gpio) + gpiod_set_value(smd->enable_gpio, 0); +} + +static const struct drm_crtc_helper_funcs sharp_memory_crtc_helper_funcs = { + .mode_valid = sharp_memory_crtc_mode_valid, + .atomic_check = sharp_memory_crtc_check, + .atomic_enable = sharp_memory_crtc_enable, + .atomic_disable = sharp_memory_crtc_disable, +}; + +static const struct drm_crtc_funcs sharp_memory_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 sharp_memory_encoder_funcs = { + .destroy = drm_encoder_cleanup, +}; + +static int sharp_memory_connector_get_modes(struct drm_connector *connector) +{ + struct sharp_memory_device *smd = drm_to_sharp_memory_device(connector->dev); + + return drm_connector_helper_get_modes_fixed(connector, smd->mode); +} + +static const struct drm_connector_helper_funcs sharp_memory_connector_hfuncs = { + .get_modes = sharp_memory_connector_get_modes, +}; + +static const struct drm_connector_funcs sharp_memory_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 sharp_memory_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_display_mode sharp_memory_ls010b7dh04_mode = { + DRM_SIMPLE_MODE(128, 128, 18, 18), +}; + +static const struct drm_display_mode sharp_memory_ls011b7dh03_mode = { + DRM_SIMPLE_MODE(160, 68, 25, 10), +}; + +static const struct drm_display_mode sharp_memory_ls012b7dd01_mode = { + DRM_SIMPLE_MODE(184, 38, 29, 6), +}; + +static const struct drm_display_mode sharp_memory_ls013b7dh03_mode = { + DRM_SIMPLE_MODE(128, 128, 23, 23), +}; + +static const struct drm_display_mode sharp_memory_ls013b7dh05_mode = { + DRM_SIMPLE_MODE(144, 168, 20, 24), +}; + +static const struct drm_display_mode sharp_memory_ls018b7dh02_mode = { + DRM_SIMPLE_MODE(230, 303, 27, 36), +}; + +static const struct drm_display_mode sharp_memory_ls027b7dh01_mode = { + DRM_SIMPLE_MODE(400, 240, 58, 35), +}; + +static const struct drm_display_mode sharp_memory_ls032b7dd02_mode = { + DRM_SIMPLE_MODE(336, 536, 42, 68), +}; + +static const struct drm_display_mode sharp_memory_ls044q7dh01_mode = { + DRM_SIMPLE_MODE(320, 240, 89, 67), +}; + +static const struct spi_device_id sharp_memory_ids[] = { + {"ls010b7dh04", (kernel_ulong_t)&sharp_memory_ls010b7dh04_mode}, + {"ls011b7dh03", (kernel_ulong_t)&sharp_memory_ls011b7dh03_mode}, + {"ls012b7dd01", (kernel_ulong_t)&sharp_memory_ls012b7dd01_mode}, + {"ls013b7dh03", (kernel_ulong_t)&sharp_memory_ls013b7dh03_mode}, + {"ls013b7dh05", (kernel_ulong_t)&sharp_memory_ls013b7dh05_mode}, + {"ls018b7dh02", (kernel_ulong_t)&sharp_memory_ls018b7dh02_mode}, + {"ls027b7dh01", (kernel_ulong_t)&sharp_memory_ls027b7dh01_mode}, + {"ls027b7dh01a", (kernel_ulong_t)&sharp_memory_ls027b7dh01_mode}, + {"ls032b7dd02", (kernel_ulong_t)&sharp_memory_ls032b7dd02_mode}, + {"ls044q7dh01", (kernel_ulong_t)&sharp_memory_ls044q7dh01_mode}, + {}, +}; +MODULE_DEVICE_TABLE(spi, sharp_memory_ids); + +static const struct of_device_id sharp_memory_of_match[] = { + {.compatible = "sharp,ls010b7dh04", &sharp_memory_ls010b7dh04_mode}, + {.compatible = "sharp,ls011b7dh03", &sharp_memory_ls011b7dh03_mode}, + {.compatible = "sharp,ls012b7dd01", &sharp_memory_ls012b7dd01_mode}, + {.compatible = "sharp,ls013b7dh03", &sharp_memory_ls013b7dh03_mode}, + {.compatible = "sharp,ls013b7dh05", &sharp_memory_ls013b7dh05_mode}, + {.compatible = "sharp,ls018b7dh02", &sharp_memory_ls018b7dh02_mode}, + {.compatible = "sharp,ls027b7dh01", &sharp_memory_ls027b7dh01_mode}, + {.compatible = "sharp,ls027b7dh01a", &sharp_memory_ls027b7dh01_mode}, + {.compatible = "sharp,ls032b7dd02", &sharp_memory_ls032b7dd02_mode}, + {.compatible = "sharp,ls044q7dh01", &sharp_memory_ls044q7dh01_mode}, + {}, +}; +MODULE_DEVICE_TABLE(of, sharp_memory_of_match); + +static const u32 sharp_memory_formats[] = { + DRM_FORMAT_XRGB8888, +}; + +static int sharp_memory_pipe_init(struct drm_device *dev, + struct sharp_memory_device *smd, + const u32 *formats, unsigned int format_count, + const u64 *format_modifiers) +{ + int ret; + struct drm_encoder *encoder = &smd->encoder; + struct drm_plane *plane = &smd->plane; + struct drm_crtc *crtc = &smd->crtc; + struct drm_connector *connector = &smd->connector; + + drm_plane_helper_add(plane, &sharp_memory_plane_helper_funcs); + ret = drm_universal_plane_init(dev, plane, 0, + &sharp_memory_plane_funcs, + formats, format_count, + format_modifiers, + DRM_PLANE_TYPE_PRIMARY, NULL); + if (ret) + return ret; + + drm_crtc_helper_add(crtc, &sharp_memory_crtc_helper_funcs); + ret = drm_crtc_init_with_planes(dev, crtc, plane, NULL, + &sharp_memory_crtc_funcs, NULL); + if (ret) + return ret; + + encoder->possible_crtcs = drm_crtc_mask(crtc); + ret = drm_encoder_init(dev, encoder, &sharp_memory_encoder_funcs, + DRM_MODE_ENCODER_NONE, NULL); + if (ret) + return ret; + + ret = drm_connector_init(&smd->drm, &smd->connector, + &sharp_memory_connector_funcs, + DRM_MODE_CONNECTOR_SPI); + if (ret) + return ret; + + drm_connector_helper_add(&smd->connector, + &sharp_memory_connector_hfuncs); + + return drm_connector_attach_encoder(connector, encoder); +} + +static int sharp_memory_init_pwm_vcom_signal(struct sharp_memory_device *smd) +{ + int ret; + struct device *dev = &smd->spi->dev; + struct pwm_state pwm_state; + + smd->pwm_vcom_signal = devm_pwm_get(dev, NULL); + if (IS_ERR(smd->pwm_vcom_signal)) + return dev_err_probe(dev, PTR_ERR(smd->pwm_vcom_signal), + "Could not get pwm device\n"); + + pwm_init_state(smd->pwm_vcom_signal, &pwm_state); + pwm_set_relative_duty_cycle(&pwm_state, 1, 10); + pwm_state.enabled = true; + ret = pwm_apply_might_sleep(smd->pwm_vcom_signal, &pwm_state); + if (ret) + return dev_err_probe(dev, -EINVAL, "Could not apply pwm state\n"); + + return 0; +} + +static int sharp_memory_probe(struct spi_device *spi) +{ + int ret; + struct device *dev; + struct sharp_memory_device *smd; + struct drm_device *drm; + const char *vcom_mode_str; + + dev = &spi->dev; + + ret = spi_setup(spi); + if (ret < 0) + return dev_err_probe(dev, ret, "Failed to setup spi device\n"); + + if (!dev->coherent_dma_mask) { + ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32)); + if (ret) + return dev_err_probe(dev, ret, "Failed to set dma mask\n"); + } + + smd = devm_drm_dev_alloc(dev, &sharp_memory_drm_driver, + struct sharp_memory_device, drm); + if (!smd) + return -ENOMEM; + + spi_set_drvdata(spi, smd); + + smd->spi = spi; + drm = &smd->drm; + ret = drmm_mode_config_init(drm); + if (ret) + return dev_err_probe(dev, ret, "Failed to initialize drm config\n"); + + smd->enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH); + if (!smd->enable_gpio) + dev_warn(dev, "Enable gpio not defined\n"); + + drm->mode_config.funcs = &sharp_memory_mode_config_funcs; + smd->mode = spi_get_device_match_data(spi); + + smd->pitch = (SHARP_ADDR_PERIOD + smd->mode->hdisplay + SHARP_DUMMY_PERIOD) / 8; + smd->tx_buffer_size = (SHARP_MODE_PERIOD + + (SHARP_ADDR_PERIOD + (smd->mode->hdisplay) + SHARP_DUMMY_PERIOD) * + smd->mode->vdisplay) / 8; + + smd->tx_buffer = devm_kzalloc(dev, smd->tx_buffer_size, GFP_KERNEL); + if (!smd->tx_buffer) + return -ENOMEM; + + mutex_init(&smd->tx_mutex); + + /* + * VCOM is a signal that prevents DC bias from being built up in + * the panel resulting in pixels being forever stuck in one state. + * + * This driver supports three different methods to generate this + * signal depending on EXTMODE pin: + * + * software (EXTMODE = L) - This mode uses a kthread to + * periodically send a "maintain display" message to the display, + * toggling the vcom bit on and off with each message + * + * external (EXTMODE = H) - This mode relies on an external + * clock to generate the signal on the EXTCOMM pin + * + * pwm (EXTMODE = H) - This mode uses a pwm device to generate + * the signal on the EXTCOMM pin + * + */ + if (device_property_read_string(dev, "sharp,vcom-mode", &vcom_mode_str)) + return dev_err_probe(dev, -EINVAL, + "Unable to find sharp,vcom-mode node in device tree\n"); + + if (!strcmp("software", vcom_mode_str)) { + smd->vcom_mode = SHARP_MEMORY_SOFTWARE_VCOM; + smd->sw_vcom_signal = kthread_run(sharp_memory_sw_vcom_signal_thread, + smd, "sw_vcom_signal"); + + } else if (!strcmp("external", vcom_mode_str)) { + smd->vcom_mode = SHARP_MEMORY_EXTERNAL_VCOM; + + } else if (!strcmp("pwm", vcom_mode_str)) { + smd->vcom_mode = SHARP_MEMORY_PWM_VCOM; + ret = sharp_memory_init_pwm_vcom_signal(smd); + if (ret) + return ret; + } else { + return dev_err_probe(dev, -EINVAL, "Invalid value set for vcom-mode\n"); + } + + drm->mode_config.min_width = smd->mode->hdisplay; + drm->mode_config.max_width = smd->mode->hdisplay; + drm->mode_config.min_height = smd->mode->vdisplay; + drm->mode_config.max_height = smd->mode->vdisplay; + + ret = sharp_memory_pipe_init(drm, smd, sharp_memory_formats, + ARRAY_SIZE(sharp_memory_formats), + NULL); + if (ret) + return dev_err_probe(dev, ret, "Failed to initialize display pipeline.\n"); + + drm_plane_enable_fb_damage_clips(&smd->plane); + drm_mode_config_reset(drm); + + ret = drm_dev_register(drm, 0); + if (ret) + return dev_err_probe(dev, ret, "Failed to register drm device.\n"); + + drm_client_setup(drm, NULL); + + return 0; +} + +static void sharp_memory_remove(struct spi_device *spi) +{ + struct sharp_memory_device *smd = spi_get_drvdata(spi); + + drm_dev_unplug(&smd->drm); + drm_atomic_helper_shutdown(&smd->drm); + + switch (smd->vcom_mode) { + case SHARP_MEMORY_SOFTWARE_VCOM: + kthread_stop(smd->sw_vcom_signal); + break; + + case SHARP_MEMORY_EXTERNAL_VCOM: + break; + + case SHARP_MEMORY_PWM_VCOM: + pwm_disable(smd->pwm_vcom_signal); + break; + } +} + +static struct spi_driver sharp_memory_spi_driver = { + .driver = { + .name = "sharp_memory", + .of_match_table = sharp_memory_of_match, + }, + .probe = sharp_memory_probe, + .remove = sharp_memory_remove, + .id_table = sharp_memory_ids, +}; +module_spi_driver(sharp_memory_spi_driver); + +MODULE_AUTHOR("Alex Lanzano <lanzano.alex@gmail.com>"); +MODULE_DESCRIPTION("SPI Protocol driver for the sharp_memory display"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/tiny/simpledrm.c b/drivers/gpu/drm/tiny/simpledrm.c deleted file mode 100644 index 7ce1c4617675..000000000000 --- a/drivers/gpu/drm/tiny/simpledrm.c +++ /dev/null @@ -1,1060 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only - -#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/drm_aperture.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_generic.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> - -#define DRIVER_NAME "simpledrm" -#define DRIVER_DESC "DRM driver for simple-framebuffer platform devices" -#define DRIVER_DATE "20200625" -#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 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, -}; - -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_from_firmware(dev, 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_from_firmware(dev, 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, - .name = DRIVER_NAME, - .desc = DRIVER_DESC, - .date = DRIVER_DATE, - .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; - unsigned int color_mode; - 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; - - color_mode = drm_format_info_bpp(sdev->format, 0); - if (color_mode == 16) - color_mode = sdev->format->depth; // can be 15 or 16 - - drm_fbdev_generic_setup(dev, color_mode); - - 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_new = 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 7336fa1ddaed..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/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_generic.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, - .debugfs_init = mipi_dbi_debugfs_init, - .name = "st7586", - .desc = "Sitronix ST7586", - .date = "20170801", - .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_fbdev_generic_setup(drm, 0); - - 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", - .owner = THIS_MODULE, - .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 477eb36fbb70..000000000000 --- a/drivers/gpu/drm/tiny/st7735r.c +++ /dev/null @@ -1,276 +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/drm_atomic_helper.h> -#include <drm/drm_drv.h> -#include <drm/drm_fbdev_generic.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, - .debugfs_init = mipi_dbi_debugfs_init, - .name = "st7735r", - .desc = "Sitronix ST7735R", - .date = "20171128", - .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_fbdev_generic_setup(drm, 0); - - 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"); |