samples/vfio-mdev/mdpy-fb.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Framebuffer driver for mdpy (mediated virtual pci display device).
0004  *
0005  * See mdpy-defs.h for device specs
0006  *
0007  *   (c) Gerd Hoffmann <kraxel@redhat.com>
0008  *
0009  * Using some code snippets from simplefb and cirrusfb.
0010  *
0011  * This program is free software; you can redistribute it and/or modify it
0012  * under the terms and conditions of the GNU General Public License,
0013  * version 2, as published by the Free Software Foundation.
0014  *
0015  * This program is distributed in the hope it will be useful, but WITHOUT
0016  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0017  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
0018  * more details.
0019  */
0020 #include <linux/errno.h>
0021 #include <linux/fb.h>
0022 #include <linux/io.h>
0023 #include <linux/pci.h>
0024 #include <linux/module.h>
0025 #include <drm/drm_fourcc.h>
0026 #include "mdpy-defs.h"
0027
0028 static const struct fb_fix_screeninfo mdpy_fb_fix = {
0029     .id     = "mdpy-fb",
0030     .type       = FB_TYPE_PACKED_PIXELS,
0031     .visual     = FB_VISUAL_TRUECOLOR,
0032     .accel      = FB_ACCEL_NONE,
0033 };
0034
0035 static const struct fb_var_screeninfo mdpy_fb_var = {
0036     .height     = -1,
0037     .width      = -1,
0038     .activate   = FB_ACTIVATE_NOW,
0039     .vmode      = FB_VMODE_NONINTERLACED,
0040
0041     .bits_per_pixel = 32,
0042     .transp.offset  = 24,
0043     .red.offset = 16,
0044     .green.offset   = 8,
0045     .blue.offset    = 0,
0046     .transp.length  = 8,
0047     .red.length = 8,
0048     .green.length   = 8,
0049     .blue.length    = 8,
0050 };
0051
0052 #define PSEUDO_PALETTE_SIZE 16
0053
0054 struct mdpy_fb_par {
0055     u32 palette[PSEUDO_PALETTE_SIZE];
0056 };
0057
0058 static int mdpy_fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
0059                   u_int transp, struct fb_info *info)
0060 {
0061     u32 *pal = info->pseudo_palette;
0062     u32 cr = red >> (16 - info->var.red.length);
0063     u32 cg = green >> (16 - info->var.green.length);
0064     u32 cb = blue >> (16 - info->var.blue.length);
0065     u32 value, mask;
0066
0067     if (regno >= PSEUDO_PALETTE_SIZE)
0068         return -EINVAL;
0069
0070     value = (cr << info->var.red.offset) |
0071         (cg << info->var.green.offset) |
0072         (cb << info->var.blue.offset);
0073     if (info->var.transp.length > 0) {
0074         mask = (1 << info->var.transp.length) - 1;
0075         mask <<= info->var.transp.offset;
0076         value |= mask;
0077     }
0078     pal[regno] = value;
0079
0080     return 0;
0081 }
0082
0083 static void mdpy_fb_destroy(struct fb_info *info)
0084 {
0085     if (info->screen_base)
0086         iounmap(info->screen_base);
0087 }
0088
0089 static const struct fb_ops mdpy_fb_ops = {
0090     .owner      = THIS_MODULE,
0091     .fb_destroy = mdpy_fb_destroy,
0092     .fb_setcolreg   = mdpy_fb_setcolreg,
0093     .fb_fillrect    = cfb_fillrect,
0094     .fb_copyarea    = cfb_copyarea,
0095     .fb_imageblit   = cfb_imageblit,
0096 };
0097
0098 static int mdpy_fb_probe(struct pci_dev *pdev,
0099              const struct pci_device_id *ent)
0100 {
0101     struct fb_info *info;
0102     struct mdpy_fb_par *par;
0103     u32 format, width, height;
0104     int ret;
0105
0106     ret = pci_enable_device(pdev);
0107     if (ret < 0)
0108         return ret;
0109
0110     ret = pci_request_regions(pdev, "mdpy-fb");
0111     if (ret < 0)
0112         return ret;
0113
0114     pci_read_config_dword(pdev, MDPY_FORMAT_OFFSET, &format);
0115     pci_read_config_dword(pdev, MDPY_WIDTH_OFFSET,  &width);
0116     pci_read_config_dword(pdev, MDPY_HEIGHT_OFFSET, &height);
0117     if (format != DRM_FORMAT_XRGB8888) {
0118         pci_err(pdev, "format mismatch (0x%x != 0x%x)\n",
0119             format, DRM_FORMAT_XRGB8888);
0120         ret = -EINVAL;
0121         goto err_release_regions;
0122     }
0123     if (width < 100  || width > 10000) {
0124         pci_err(pdev, "width (%d) out of range\n", width);
0125         ret = -EINVAL;
0126         goto err_release_regions;
0127     }
0128     if (height < 100 || height > 10000) {
0129         pci_err(pdev, "height (%d) out of range\n", height);
0130         ret = -EINVAL;
0131         goto err_release_regions;
0132     }
0133     pci_info(pdev, "mdpy found: %dx%d framebuffer\n",
0134          width, height);
0135
0136     info = framebuffer_alloc(sizeof(struct mdpy_fb_par), &pdev->dev);
0137     if (!info) {
0138         ret = -ENOMEM;
0139         goto err_release_regions;
0140     }
0141     pci_set_drvdata(pdev, info);
0142     par = info->par;
0143
0144     info->fix = mdpy_fb_fix;
0145     info->fix.smem_start = pci_resource_start(pdev, 0);
0146     info->fix.smem_len = pci_resource_len(pdev, 0);
0147     info->fix.line_length = width * 4;
0148
0149     info->var = mdpy_fb_var;
0150     info->var.xres = width;
0151     info->var.yres = height;
0152     info->var.xres_virtual = width;
0153     info->var.yres_virtual = height;
0154
0155     info->screen_size = info->fix.smem_len;
0156     info->screen_base = ioremap(info->fix.smem_start,
0157                     info->screen_size);
0158     if (!info->screen_base) {
0159         pci_err(pdev, "ioremap(pcibar) failed\n");
0160         ret = -EIO;
0161         goto err_release_fb;
0162     }
0163
0164     info->apertures = alloc_apertures(1);
0165     if (!info->apertures) {
0166         ret = -ENOMEM;
0167         goto err_unmap;
0168     }
0169     info->apertures->ranges[0].base = info->fix.smem_start;
0170     info->apertures->ranges[0].size = info->fix.smem_len;
0171
0172     info->fbops = &mdpy_fb_ops;
0173     info->flags = FBINFO_DEFAULT;
0174     info->pseudo_palette = par->palette;
0175
0176     ret = register_framebuffer(info);
0177     if (ret < 0) {
0178         pci_err(pdev, "mdpy-fb device register failed: %d\n", ret);
0179         goto err_unmap;
0180     }
0181
0182     pci_info(pdev, "fb%d registered\n", info->node);
0183     return 0;
0184
0185 err_unmap:
0186     iounmap(info->screen_base);
0187
0188 err_release_fb:
0189     framebuffer_release(info);
0190
0191 err_release_regions:
0192     pci_release_regions(pdev);
0193
0194     return ret;
0195 }
0196
0197 static void mdpy_fb_remove(struct pci_dev *pdev)
0198 {
0199     struct fb_info *info = pci_get_drvdata(pdev);
0200
0201     unregister_framebuffer(info);
0202     framebuffer_release(info);
0203 }
0204
0205 static struct pci_device_id mdpy_fb_pci_table[] = {
0206     {
0207         .vendor    = MDPY_PCI_VENDOR_ID,
0208         .device    = MDPY_PCI_DEVICE_ID,
0209         .subvendor = MDPY_PCI_SUBVENDOR_ID,
0210         .subdevice = MDPY_PCI_SUBDEVICE_ID,
0211     }, {
0212         /* end of list */
0213     }
0214 };
0215
0216 static struct pci_driver mdpy_fb_pci_driver = {
0217     .name       = "mdpy-fb",
0218     .id_table   = mdpy_fb_pci_table,
0219     .probe      = mdpy_fb_probe,
0220     .remove     = mdpy_fb_remove,
0221 };
0222
0223 static int __init mdpy_fb_init(void)
0224 {
0225     int ret;
0226
0227     ret = pci_register_driver(&mdpy_fb_pci_driver);
0228     if (ret)
0229         return ret;
0230
0231     return 0;
0232 }
0233
0234 module_init(mdpy_fb_init);
0235
0236 MODULE_DEVICE_TABLE(pci, mdpy_fb_pci_table);
0237 MODULE_LICENSE("GPL v2");