1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/aperture.h> 4 #include <linux/ioport.h> 5 #include <linux/limits.h> 6 #include <linux/platform_device.h> 7 #include <linux/screen_info.h> 8 9 #include <drm/clients/drm_client_setup.h> 10 #include <drm/drm_atomic.h> 11 #include <drm/drm_atomic_state_helper.h> 12 #include <drm/drm_connector.h> 13 #include <drm/drm_damage_helper.h> 14 #include <drm/drm_device.h> 15 #include <drm/drm_drv.h> 16 #include <drm/drm_edid.h> 17 #include <drm/drm_fbdev_shmem.h> 18 #include <drm/drm_framebuffer.h> 19 #include <drm/drm_gem_atomic_helper.h> 20 #include <drm/drm_gem_framebuffer_helper.h> 21 #include <drm/drm_gem_shmem_helper.h> 22 #include <drm/drm_managed.h> 23 #include <drm/drm_modeset_helper_vtables.h> 24 #include <drm/drm_probe_helper.h> 25 26 #include <video/edid.h> 27 #include <video/pixel_format.h> 28 29 #include "drm_sysfb_helper.h" 30 31 #define DRIVER_NAME "vesadrm" 32 #define DRIVER_DESC "DRM driver for VESA platform devices" 33 #define DRIVER_MAJOR 1 34 #define DRIVER_MINOR 0 35 36 static int vesadrm_get_validated_int(struct drm_device *dev, const char *name, 37 u64 value, u32 max) 38 { 39 if (max > INT_MAX) 40 max = INT_MAX; 41 if (value > max) { 42 drm_err(dev, "%s of %llu exceeds maximum of %u\n", name, value, max); 43 return -EINVAL; 44 } 45 return value; 46 } 47 48 static int vesadrm_get_validated_int0(struct drm_device *dev, const char *name, 49 u64 value, u32 max) 50 { 51 if (!value) { 52 drm_err(dev, "%s of 0 not allowed\n", name); 53 return -EINVAL; 54 } 55 return vesadrm_get_validated_int(dev, name, value, max); 56 } 57 58 static s64 vesadrm_get_validated_size0(struct drm_device *dev, const char *name, 59 u64 value, u64 max) 60 { 61 if (!value) { 62 drm_err(dev, "vesadrm: %s of 0 not allowed\n", name); 63 return -EINVAL; 64 } else if (value > max) { 65 drm_err(dev, "vesadrm: %s of %llu exceeds maximum of %llu\n", name, value, max); 66 return -EINVAL; 67 } 68 return value; 69 } 70 71 static int vesadrm_get_width_si(struct drm_device *dev, const struct screen_info *si) 72 { 73 return vesadrm_get_validated_int0(dev, "width", si->lfb_width, U16_MAX); 74 } 75 76 static int vesadrm_get_height_si(struct drm_device *dev, const struct screen_info *si) 77 { 78 return vesadrm_get_validated_int0(dev, "height", si->lfb_height, U16_MAX); 79 } 80 81 static struct resource *vesadrm_get_memory_si(struct drm_device *dev, 82 const struct screen_info *si, 83 struct resource *res) 84 { 85 ssize_t num; 86 87 num = screen_info_resources(si, res, 1); 88 if (!num) { 89 drm_err(dev, "vesadrm: memory resource not found\n"); 90 return NULL; 91 } 92 93 return res; 94 } 95 96 static int vesadrm_get_stride_si(struct drm_device *dev, const struct screen_info *si, 97 const struct drm_format_info *format, 98 unsigned int width, unsigned int height, u64 size) 99 { 100 u64 lfb_linelength = si->lfb_linelength; 101 102 if (!lfb_linelength) 103 lfb_linelength = drm_format_info_min_pitch(format, 0, width); 104 105 return vesadrm_get_validated_int0(dev, "stride", lfb_linelength, div64_u64(size, height)); 106 } 107 108 static u64 vesadrm_get_visible_size_si(struct drm_device *dev, const struct screen_info *si, 109 unsigned int height, unsigned int stride, u64 size) 110 { 111 u64 vsize = PAGE_ALIGN(height * stride); 112 113 return vesadrm_get_validated_size0(dev, "visible size", vsize, size); 114 } 115 116 static const struct drm_format_info *vesadrm_get_format_si(struct drm_device *dev, 117 const struct screen_info *si) 118 { 119 static const struct { 120 struct pixel_format pixel; 121 u32 fourcc; 122 } vesa_formats[] = { 123 { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, }, 124 { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, }, 125 { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, }, 126 { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, }, 127 { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, }, 128 }; 129 const struct drm_format_info *format = NULL; 130 u32 bits_per_pixel; 131 size_t i; 132 133 bits_per_pixel = __screen_info_lfb_bits_per_pixel(si); 134 135 for (i = 0; i < ARRAY_SIZE(vesa_formats); ++i) { 136 const struct pixel_format *f = &vesa_formats[i].pixel; 137 138 if (bits_per_pixel == f->bits_per_pixel && 139 si->red_size == f->red.length && 140 si->red_pos == f->red.offset && 141 si->green_size == f->green.length && 142 si->green_pos == f->green.offset && 143 si->blue_size == f->blue.length && 144 si->blue_pos == f->blue.offset) { 145 format = drm_format_info(vesa_formats[i].fourcc); 146 break; 147 } 148 } 149 150 if (!format) 151 return ERR_PTR(-EINVAL); 152 if (format->is_color_indexed) 153 return ERR_PTR(-EINVAL); 154 155 return format; 156 } 157 158 /* 159 * VESA device 160 */ 161 162 struct vesadrm_device { 163 struct drm_sysfb_device sysfb; 164 165 /* modesetting */ 166 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)]; 167 struct drm_plane primary_plane; 168 struct drm_crtc crtc; 169 struct drm_encoder encoder; 170 struct drm_connector connector; 171 }; 172 173 /* 174 * Modesetting 175 */ 176 177 static const u64 vesadrm_primary_plane_format_modifiers[] = { 178 DRM_SYSFB_PLANE_FORMAT_MODIFIERS, 179 }; 180 181 static const struct drm_plane_helper_funcs vesadrm_primary_plane_helper_funcs = { 182 DRM_SYSFB_PLANE_HELPER_FUNCS, 183 }; 184 185 static const struct drm_plane_funcs vesadrm_primary_plane_funcs = { 186 DRM_SYSFB_PLANE_FUNCS, 187 .destroy = drm_plane_cleanup, 188 }; 189 190 static const struct drm_crtc_helper_funcs vesadrm_crtc_helper_funcs = { 191 DRM_SYSFB_CRTC_HELPER_FUNCS, 192 }; 193 194 static const struct drm_crtc_funcs vesadrm_crtc_funcs = { 195 DRM_SYSFB_CRTC_FUNCS, 196 .destroy = drm_crtc_cleanup, 197 }; 198 199 static const struct drm_encoder_funcs vesadrm_encoder_funcs = { 200 .destroy = drm_encoder_cleanup, 201 }; 202 203 static const struct drm_connector_helper_funcs vesadrm_connector_helper_funcs = { 204 DRM_SYSFB_CONNECTOR_HELPER_FUNCS, 205 }; 206 207 static const struct drm_connector_funcs vesadrm_connector_funcs = { 208 DRM_SYSFB_CONNECTOR_FUNCS, 209 .destroy = drm_connector_cleanup, 210 }; 211 212 static const struct drm_mode_config_funcs vesadrm_mode_config_funcs = { 213 DRM_SYSFB_MODE_CONFIG_FUNCS, 214 }; 215 216 /* 217 * Init / Cleanup 218 */ 219 220 static struct vesadrm_device *vesadrm_device_create(struct drm_driver *drv, 221 struct platform_device *pdev) 222 { 223 const struct screen_info *si; 224 const struct drm_format_info *format; 225 int width, height, stride; 226 u64 vsize; 227 struct resource resbuf; 228 struct resource *res; 229 struct vesadrm_device *vesa; 230 struct drm_sysfb_device *sysfb; 231 struct drm_device *dev; 232 struct resource *mem = NULL; 233 void __iomem *screen_base; 234 struct drm_plane *primary_plane; 235 struct drm_crtc *crtc; 236 struct drm_encoder *encoder; 237 struct drm_connector *connector; 238 unsigned long max_width, max_height; 239 size_t nformats; 240 int ret; 241 242 si = dev_get_platdata(&pdev->dev); 243 if (!si) 244 return ERR_PTR(-ENODEV); 245 if (screen_info_video_type(si) != VIDEO_TYPE_VLFB) 246 return ERR_PTR(-ENODEV); 247 248 /* 249 * VESA DRM driver 250 */ 251 252 vesa = devm_drm_dev_alloc(&pdev->dev, drv, struct vesadrm_device, sysfb.dev); 253 if (IS_ERR(vesa)) 254 return ERR_CAST(vesa); 255 sysfb = &vesa->sysfb; 256 dev = &sysfb->dev; 257 platform_set_drvdata(pdev, dev); 258 259 /* 260 * Hardware settings 261 */ 262 263 format = vesadrm_get_format_si(dev, si); 264 if (IS_ERR(format)) 265 return ERR_CAST(format); 266 width = vesadrm_get_width_si(dev, si); 267 if (width < 0) 268 return ERR_PTR(width); 269 height = vesadrm_get_height_si(dev, si); 270 if (height < 0) 271 return ERR_PTR(height); 272 res = vesadrm_get_memory_si(dev, si, &resbuf); 273 if (!res) 274 return ERR_PTR(-EINVAL); 275 stride = vesadrm_get_stride_si(dev, si, format, width, height, resource_size(res)); 276 if (stride < 0) 277 return ERR_PTR(stride); 278 vsize = vesadrm_get_visible_size_si(dev, si, height, stride, resource_size(res)); 279 if (!vsize) 280 return ERR_PTR(-EINVAL); 281 282 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n", 283 &format->format, width, height, stride); 284 285 #ifdef CONFIG_X86 286 if (drm_edid_header_is_valid(edid_info.dummy) == 8) 287 sysfb->edid = edid_info.dummy; 288 #endif 289 sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0); 290 sysfb->fb_format = format; 291 sysfb->fb_pitch = stride; 292 293 /* 294 * Memory management 295 */ 296 297 ret = devm_aperture_acquire_for_platform_device(pdev, res->start, vsize); 298 if (ret) { 299 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret); 300 return ERR_PTR(ret); 301 } 302 303 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res); 304 305 mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name); 306 if (!mem) { 307 /* 308 * We cannot make this fatal. Sometimes this comes from magic 309 * spaces our resource handlers simply don't know about. Use 310 * the I/O-memory resource as-is and try to map that instead. 311 */ 312 drm_warn(dev, "could not acquire memory region %pr\n", res); 313 mem = res; 314 } 315 316 screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem)); 317 if (!screen_base) 318 return ERR_PTR(-ENOMEM); 319 iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base); 320 321 /* 322 * Modesetting 323 */ 324 325 ret = drmm_mode_config_init(dev); 326 if (ret) 327 return ERR_PTR(ret); 328 329 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH); 330 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT); 331 332 dev->mode_config.min_width = width; 333 dev->mode_config.max_width = max_width; 334 dev->mode_config.min_height = height; 335 dev->mode_config.max_height = max_height; 336 dev->mode_config.preferred_depth = format->depth; 337 dev->mode_config.funcs = &vesadrm_mode_config_funcs; 338 339 /* Primary plane */ 340 341 nformats = drm_fb_build_fourcc_list(dev, &format->format, 1, 342 vesa->formats, ARRAY_SIZE(vesa->formats)); 343 344 primary_plane = &vesa->primary_plane; 345 ret = drm_universal_plane_init(dev, primary_plane, 0, &vesadrm_primary_plane_funcs, 346 vesa->formats, nformats, 347 vesadrm_primary_plane_format_modifiers, 348 DRM_PLANE_TYPE_PRIMARY, NULL); 349 if (ret) 350 return ERR_PTR(ret); 351 drm_plane_helper_add(primary_plane, &vesadrm_primary_plane_helper_funcs); 352 drm_plane_enable_fb_damage_clips(primary_plane); 353 354 /* CRTC */ 355 356 crtc = &vesa->crtc; 357 ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, 358 &vesadrm_crtc_funcs, NULL); 359 if (ret) 360 return ERR_PTR(ret); 361 drm_crtc_helper_add(crtc, &vesadrm_crtc_helper_funcs); 362 363 /* Encoder */ 364 365 encoder = &vesa->encoder; 366 ret = drm_encoder_init(dev, encoder, &vesadrm_encoder_funcs, 367 DRM_MODE_ENCODER_NONE, NULL); 368 if (ret) 369 return ERR_PTR(ret); 370 encoder->possible_crtcs = drm_crtc_mask(crtc); 371 372 /* Connector */ 373 374 connector = &vesa->connector; 375 ret = drm_connector_init(dev, connector, &vesadrm_connector_funcs, 376 DRM_MODE_CONNECTOR_Unknown); 377 if (ret) 378 return ERR_PTR(ret); 379 drm_connector_helper_add(connector, &vesadrm_connector_helper_funcs); 380 drm_connector_set_panel_orientation_with_quirk(connector, 381 DRM_MODE_PANEL_ORIENTATION_UNKNOWN, 382 width, height); 383 if (sysfb->edid) 384 drm_connector_attach_edid_property(connector); 385 386 ret = drm_connector_attach_encoder(connector, encoder); 387 if (ret) 388 return ERR_PTR(ret); 389 390 drm_mode_config_reset(dev); 391 392 return vesa; 393 } 394 395 /* 396 * DRM driver 397 */ 398 399 DEFINE_DRM_GEM_FOPS(vesadrm_fops); 400 401 static struct drm_driver vesadrm_driver = { 402 DRM_GEM_SHMEM_DRIVER_OPS, 403 DRM_FBDEV_SHMEM_DRIVER_OPS, 404 .name = DRIVER_NAME, 405 .desc = DRIVER_DESC, 406 .major = DRIVER_MAJOR, 407 .minor = DRIVER_MINOR, 408 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET, 409 .fops = &vesadrm_fops, 410 }; 411 412 /* 413 * Platform driver 414 */ 415 416 static int vesadrm_probe(struct platform_device *pdev) 417 { 418 struct vesadrm_device *vesa; 419 struct drm_sysfb_device *sysfb; 420 struct drm_device *dev; 421 int ret; 422 423 vesa = vesadrm_device_create(&vesadrm_driver, pdev); 424 if (IS_ERR(vesa)) 425 return PTR_ERR(vesa); 426 sysfb = &vesa->sysfb; 427 dev = &sysfb->dev; 428 429 ret = drm_dev_register(dev, 0); 430 if (ret) 431 return ret; 432 433 drm_client_setup(dev, sysfb->fb_format); 434 435 return 0; 436 } 437 438 static void vesadrm_remove(struct platform_device *pdev) 439 { 440 struct drm_device *dev = platform_get_drvdata(pdev); 441 442 drm_dev_unplug(dev); 443 } 444 445 static struct platform_driver vesadrm_platform_driver = { 446 .driver = { 447 .name = "vesa-framebuffer", 448 }, 449 .probe = vesadrm_probe, 450 .remove = vesadrm_remove, 451 }; 452 453 module_platform_driver(vesadrm_platform_driver); 454 455 MODULE_DESCRIPTION(DRIVER_DESC); 456 MODULE_LICENSE("GPL"); 457