~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/samples/vfio-mdev/mdpy-fb.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Framebuffer driver for mdpy (mediated virtual pci display device).
  4  *
  5  * See mdpy-defs.h for device specs
  6  *
  7  *   (c) Gerd Hoffmann <kraxel@redhat.com>
  8  *
  9  * Using some code snippets from simplefb and cirrusfb.
 10  *
 11  * This program is free software; you can redistribute it and/or modify it
 12  * under the terms and conditions of the GNU General Public License,
 13  * version 2, as published by the Free Software Foundation.
 14  *
 15  * This program is distributed in the hope it will be useful, but WITHOUT
 16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 17  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 18  * more details.
 19  */
 20 #include <linux/errno.h>
 21 #include <linux/fb.h>
 22 #include <linux/io.h>
 23 #include <linux/pci.h>
 24 #include <linux/module.h>
 25 #include <drm/drm_fourcc.h>
 26 #include "mdpy-defs.h"
 27 
 28 static const struct fb_fix_screeninfo mdpy_fb_fix = {
 29         .id             = "mdpy-fb",
 30         .type           = FB_TYPE_PACKED_PIXELS,
 31         .visual         = FB_VISUAL_TRUECOLOR,
 32         .accel          = FB_ACCEL_NONE,
 33 };
 34 
 35 static const struct fb_var_screeninfo mdpy_fb_var = {
 36         .height         = -1,
 37         .width          = -1,
 38         .activate       = FB_ACTIVATE_NOW,
 39         .vmode          = FB_VMODE_NONINTERLACED,
 40 
 41         .bits_per_pixel = 32,
 42         .transp.offset  = 24,
 43         .red.offset     = 16,
 44         .green.offset   = 8,
 45         .blue.offset    = 0,
 46         .transp.length  = 8,
 47         .red.length     = 8,
 48         .green.length   = 8,
 49         .blue.length    = 8,
 50 };
 51 
 52 #define PSEUDO_PALETTE_SIZE 16
 53 
 54 struct mdpy_fb_par {
 55         u32 palette[PSEUDO_PALETTE_SIZE];
 56 };
 57 
 58 static int mdpy_fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 59                               u_int transp, struct fb_info *info)
 60 {
 61         u32 *pal = info->pseudo_palette;
 62         u32 cr = red >> (16 - info->var.red.length);
 63         u32 cg = green >> (16 - info->var.green.length);
 64         u32 cb = blue >> (16 - info->var.blue.length);
 65         u32 value, mask;
 66 
 67         if (regno >= PSEUDO_PALETTE_SIZE)
 68                 return -EINVAL;
 69 
 70         value = (cr << info->var.red.offset) |
 71                 (cg << info->var.green.offset) |
 72                 (cb << info->var.blue.offset);
 73         if (info->var.transp.length > 0) {
 74                 mask = (1 << info->var.transp.length) - 1;
 75                 mask <<= info->var.transp.offset;
 76                 value |= mask;
 77         }
 78         pal[regno] = value;
 79 
 80         return 0;
 81 }
 82 
 83 static void mdpy_fb_destroy(struct fb_info *info)
 84 {
 85         if (info->screen_base)
 86                 iounmap(info->screen_base);
 87 }
 88 
 89 static const struct fb_ops mdpy_fb_ops = {
 90         .owner          = THIS_MODULE,
 91         .fb_destroy     = mdpy_fb_destroy,
 92         .fb_setcolreg   = mdpy_fb_setcolreg,
 93         .fb_fillrect    = cfb_fillrect,
 94         .fb_copyarea    = cfb_copyarea,
 95         .fb_imageblit   = cfb_imageblit,
 96 };
 97 
 98 static int mdpy_fb_probe(struct pci_dev *pdev,
 99                          const struct pci_device_id *ent)
100 {
101         struct fb_info *info;
102         struct mdpy_fb_par *par;
103         u32 format, width, height;
104         int ret;
105 
106         ret = pci_enable_device(pdev);
107         if (ret < 0)
108                 return ret;
109 
110         ret = pci_request_regions(pdev, "mdpy-fb");
111         if (ret < 0)
112                 return ret;
113 
114         pci_read_config_dword(pdev, MDPY_FORMAT_OFFSET, &format);
115         pci_read_config_dword(pdev, MDPY_WIDTH_OFFSET,  &width);
116         pci_read_config_dword(pdev, MDPY_HEIGHT_OFFSET, &height);
117         if (format != DRM_FORMAT_XRGB8888) {
118                 pci_err(pdev, "format mismatch (0x%x != 0x%x)\n",
119                         format, DRM_FORMAT_XRGB8888);
120                 return -EINVAL;
121         }
122         if (width < 100  || width > 10000) {
123                 pci_err(pdev, "width (%d) out of range\n", width);
124                 return -EINVAL;
125         }
126         if (height < 100 || height > 10000) {
127                 pci_err(pdev, "height (%d) out of range\n", height);
128                 return -EINVAL;
129         }
130         pci_info(pdev, "mdpy found: %dx%d framebuffer\n",
131                  width, height);
132 
133         info = framebuffer_alloc(sizeof(struct mdpy_fb_par), &pdev->dev);
134         if (!info)
135                 goto err_release_regions;
136         pci_set_drvdata(pdev, info);
137         par = info->par;
138 
139         info->fix = mdpy_fb_fix;
140         info->fix.smem_start = pci_resource_start(pdev, 0);
141         info->fix.smem_len = pci_resource_len(pdev, 0);
142         info->fix.line_length = width * 4;
143 
144         info->var = mdpy_fb_var;
145         info->var.xres = width;
146         info->var.yres = height;
147         info->var.xres_virtual = width;
148         info->var.yres_virtual = height;
149 
150         info->screen_size = info->fix.smem_len;
151         info->screen_base = ioremap(info->fix.smem_start,
152                                     info->screen_size);
153         if (!info->screen_base) {
154                 pci_err(pdev, "ioremap(pcibar) failed\n");
155                 ret = -EIO;
156                 goto err_release_fb;
157         }
158 
159         info->apertures = alloc_apertures(1);
160         if (!info->apertures) {
161                 ret = -ENOMEM;
162                 goto err_unmap;
163         }
164         info->apertures->ranges[0].base = info->fix.smem_start;
165         info->apertures->ranges[0].size = info->fix.smem_len;
166 
167         info->fbops = &mdpy_fb_ops;
168         info->flags = FBINFO_DEFAULT;
169         info->pseudo_palette = par->palette;
170 
171         ret = register_framebuffer(info);
172         if (ret < 0) {
173                 pci_err(pdev, "mdpy-fb device register failed: %d\n", ret);
174                 goto err_unmap;
175         }
176 
177         pci_info(pdev, "fb%d registered\n", info->node);
178         return 0;
179 
180 err_unmap:
181         iounmap(info->screen_base);
182 
183 err_release_fb:
184         framebuffer_release(info);
185 
186 err_release_regions:
187         pci_release_regions(pdev);
188 
189         return ret;
190 }
191 
192 static void mdpy_fb_remove(struct pci_dev *pdev)
193 {
194         struct fb_info *info = pci_get_drvdata(pdev);
195 
196         unregister_framebuffer(info);
197         framebuffer_release(info);
198 }
199 
200 static struct pci_device_id mdpy_fb_pci_table[] = {
201         {
202                 .vendor    = MDPY_PCI_VENDOR_ID,
203                 .device    = MDPY_PCI_DEVICE_ID,
204                 .subvendor = MDPY_PCI_SUBVENDOR_ID,
205                 .subdevice = MDPY_PCI_SUBDEVICE_ID,
206         }, {
207                 /* end of list */
208         }
209 };
210 
211 static struct pci_driver mdpy_fb_pci_driver = {
212         .name           = "mdpy-fb",
213         .id_table       = mdpy_fb_pci_table,
214         .probe          = mdpy_fb_probe,
215         .remove         = mdpy_fb_remove,
216 };
217 
218 static int __init mdpy_fb_init(void)
219 {
220         int ret;
221 
222         ret = pci_register_driver(&mdpy_fb_pci_driver);
223         if (ret)
224                 return ret;
225 
226         return 0;
227 }
228 
229 module_init(mdpy_fb_init);
230 
231 MODULE_DEVICE_TABLE(pci, mdpy_fb_pci_table);
232 MODULE_LICENSE("GPL v2");
233 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp