mdpy.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Mediated virtual PCI display host device driver
  4. *
  5. * See mdpy-defs.h for device specs
  6. *
  7. * (c) Gerd Hoffmann <kraxel@redhat.com>
  8. *
  9. * based on mtty driver which is:
  10. * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
  11. * Author: Neo Jia <cjia@nvidia.com>
  12. * Kirti Wankhede <kwankhede@nvidia.com>
  13. *
  14. * This program is free software; you can redistribute it and/or modify
  15. * it under the terms of the GNU General Public License version 2 as
  16. * published by the Free Software Foundation.
  17. */
  18. #include <linux/init.h>
  19. #include <linux/module.h>
  20. #include <linux/device.h>
  21. #include <linux/kernel.h>
  22. #include <linux/slab.h>
  23. #include <linux/vmalloc.h>
  24. #include <linux/cdev.h>
  25. #include <linux/vfio.h>
  26. #include <linux/iommu.h>
  27. #include <linux/sysfs.h>
  28. #include <linux/mdev.h>
  29. #include <linux/pci.h>
  30. #include <drm/drm_fourcc.h>
  31. #include "mdpy-defs.h"
  32. #define MDPY_NAME "mdpy"
  33. #define MDPY_CLASS_NAME "mdpy"
  34. #define MDPY_CONFIG_SPACE_SIZE 0xff
  35. #define MDPY_MEMORY_BAR_OFFSET PAGE_SIZE
  36. #define MDPY_DISPLAY_REGION 16
  37. #define STORE_LE16(addr, val) (*(u16 *)addr = val)
  38. #define STORE_LE32(addr, val) (*(u32 *)addr = val)
  39. MODULE_LICENSE("GPL v2");
  40. static int max_devices = 4;
  41. module_param_named(count, max_devices, int, 0444);
  42. MODULE_PARM_DESC(count, "number of " MDPY_NAME " devices");
  43. #define MDPY_TYPE_1 "vga"
  44. #define MDPY_TYPE_2 "xga"
  45. #define MDPY_TYPE_3 "hd"
  46. static const struct mdpy_type {
  47. const char *name;
  48. u32 format;
  49. u32 bytepp;
  50. u32 width;
  51. u32 height;
  52. } mdpy_types[] = {
  53. {
  54. .name = MDPY_CLASS_NAME "-" MDPY_TYPE_1,
  55. .format = DRM_FORMAT_XRGB8888,
  56. .bytepp = 4,
  57. .width = 640,
  58. .height = 480,
  59. }, {
  60. .name = MDPY_CLASS_NAME "-" MDPY_TYPE_2,
  61. .format = DRM_FORMAT_XRGB8888,
  62. .bytepp = 4,
  63. .width = 1024,
  64. .height = 768,
  65. }, {
  66. .name = MDPY_CLASS_NAME "-" MDPY_TYPE_3,
  67. .format = DRM_FORMAT_XRGB8888,
  68. .bytepp = 4,
  69. .width = 1920,
  70. .height = 1080,
  71. },
  72. };
  73. static dev_t mdpy_devt;
  74. static struct class *mdpy_class;
  75. static struct cdev mdpy_cdev;
  76. static struct device mdpy_dev;
  77. static u32 mdpy_count;
  78. /* State of each mdev device */
  79. struct mdev_state {
  80. u8 *vconfig;
  81. u32 bar_mask;
  82. struct mutex ops_lock;
  83. struct mdev_device *mdev;
  84. struct vfio_device_info dev_info;
  85. const struct mdpy_type *type;
  86. u32 memsize;
  87. void *memblk;
  88. };
  89. static const struct mdpy_type *mdpy_find_type(struct kobject *kobj)
  90. {
  91. int i;
  92. for (i = 0; i < ARRAY_SIZE(mdpy_types); i++)
  93. if (strcmp(mdpy_types[i].name, kobj->name) == 0)
  94. return mdpy_types + i;
  95. return NULL;
  96. }
  97. static void mdpy_create_config_space(struct mdev_state *mdev_state)
  98. {
  99. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_VENDOR_ID],
  100. MDPY_PCI_VENDOR_ID);
  101. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_DEVICE_ID],
  102. MDPY_PCI_DEVICE_ID);
  103. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_SUBSYSTEM_VENDOR_ID],
  104. MDPY_PCI_SUBVENDOR_ID);
  105. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_SUBSYSTEM_ID],
  106. MDPY_PCI_SUBDEVICE_ID);
  107. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_COMMAND],
  108. PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
  109. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_STATUS],
  110. PCI_STATUS_CAP_LIST);
  111. STORE_LE16((u16 *) &mdev_state->vconfig[PCI_CLASS_DEVICE],
  112. PCI_CLASS_DISPLAY_OTHER);
  113. mdev_state->vconfig[PCI_CLASS_REVISION] = 0x01;
  114. STORE_LE32((u32 *) &mdev_state->vconfig[PCI_BASE_ADDRESS_0],
  115. PCI_BASE_ADDRESS_SPACE_MEMORY |
  116. PCI_BASE_ADDRESS_MEM_TYPE_32 |
  117. PCI_BASE_ADDRESS_MEM_PREFETCH);
  118. mdev_state->bar_mask = ~(mdev_state->memsize) + 1;
  119. /* vendor specific capability for the config registers */
  120. mdev_state->vconfig[PCI_CAPABILITY_LIST] = MDPY_VENDORCAP_OFFSET;
  121. mdev_state->vconfig[MDPY_VENDORCAP_OFFSET + 0] = 0x09; /* vendor cap */
  122. mdev_state->vconfig[MDPY_VENDORCAP_OFFSET + 1] = 0x00; /* next ptr */
  123. mdev_state->vconfig[MDPY_VENDORCAP_OFFSET + 2] = MDPY_VENDORCAP_SIZE;
  124. STORE_LE32((u32 *) &mdev_state->vconfig[MDPY_FORMAT_OFFSET],
  125. mdev_state->type->format);
  126. STORE_LE32((u32 *) &mdev_state->vconfig[MDPY_WIDTH_OFFSET],
  127. mdev_state->type->width);
  128. STORE_LE32((u32 *) &mdev_state->vconfig[MDPY_HEIGHT_OFFSET],
  129. mdev_state->type->height);
  130. }
  131. static void handle_pci_cfg_write(struct mdev_state *mdev_state, u16 offset,
  132. char *buf, u32 count)
  133. {
  134. struct device *dev = mdev_dev(mdev_state->mdev);
  135. u32 cfg_addr;
  136. switch (offset) {
  137. case PCI_BASE_ADDRESS_0:
  138. cfg_addr = *(u32 *)buf;
  139. if (cfg_addr == 0xffffffff) {
  140. cfg_addr = (cfg_addr & mdev_state->bar_mask);
  141. } else {
  142. cfg_addr &= PCI_BASE_ADDRESS_MEM_MASK;
  143. if (cfg_addr)
  144. dev_info(dev, "BAR0 @ 0x%x\n", cfg_addr);
  145. }
  146. cfg_addr |= (mdev_state->vconfig[offset] &
  147. ~PCI_BASE_ADDRESS_MEM_MASK);
  148. STORE_LE32(&mdev_state->vconfig[offset], cfg_addr);
  149. break;
  150. }
  151. }
  152. static ssize_t mdev_access(struct mdev_device *mdev, char *buf, size_t count,
  153. loff_t pos, bool is_write)
  154. {
  155. struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
  156. struct device *dev = mdev_dev(mdev);
  157. int ret = 0;
  158. mutex_lock(&mdev_state->ops_lock);
  159. if (pos < MDPY_CONFIG_SPACE_SIZE) {
  160. if (is_write)
  161. handle_pci_cfg_write(mdev_state, pos, buf, count);
  162. else
  163. memcpy(buf, (mdev_state->vconfig + pos), count);
  164. } else if ((pos >= MDPY_MEMORY_BAR_OFFSET) &&
  165. (pos + count <=
  166. MDPY_MEMORY_BAR_OFFSET + mdev_state->memsize)) {
  167. pos -= MDPY_MEMORY_BAR_OFFSET;
  168. if (is_write)
  169. memcpy(mdev_state->memblk, buf, count);
  170. else
  171. memcpy(buf, mdev_state->memblk, count);
  172. } else {
  173. dev_info(dev, "%s: %s @0x%llx (unhandled)\n",
  174. __func__, is_write ? "WR" : "RD", pos);
  175. ret = -1;
  176. goto accessfailed;
  177. }
  178. ret = count;
  179. accessfailed:
  180. mutex_unlock(&mdev_state->ops_lock);
  181. return ret;
  182. }
  183. static int mdpy_reset(struct mdev_device *mdev)
  184. {
  185. struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
  186. u32 stride, i;
  187. /* initialize with gray gradient */
  188. stride = mdev_state->type->width * mdev_state->type->bytepp;
  189. for (i = 0; i < mdev_state->type->height; i++)
  190. memset(mdev_state->memblk + i * stride,
  191. i * 255 / mdev_state->type->height,
  192. stride);
  193. return 0;
  194. }
  195. static int mdpy_create(struct kobject *kobj, struct mdev_device *mdev)
  196. {
  197. const struct mdpy_type *type = mdpy_find_type(kobj);
  198. struct device *dev = mdev_dev(mdev);
  199. struct mdev_state *mdev_state;
  200. u32 fbsize;
  201. if (mdpy_count >= max_devices)
  202. return -ENOMEM;
  203. mdev_state = kzalloc(sizeof(struct mdev_state), GFP_KERNEL);
  204. if (mdev_state == NULL)
  205. return -ENOMEM;
  206. mdev_state->vconfig = kzalloc(MDPY_CONFIG_SPACE_SIZE, GFP_KERNEL);
  207. if (mdev_state->vconfig == NULL) {
  208. kfree(mdev_state);
  209. return -ENOMEM;
  210. }
  211. if (!type)
  212. type = &mdpy_types[0];
  213. fbsize = roundup_pow_of_two(type->width * type->height * type->bytepp);
  214. mdev_state->memblk = vmalloc_user(fbsize);
  215. if (!mdev_state->memblk) {
  216. kfree(mdev_state->vconfig);
  217. kfree(mdev_state);
  218. return -ENOMEM;
  219. }
  220. dev_info(dev, "%s: %s (%dx%d)\n",
  221. __func__, kobj->name, type->width, type->height);
  222. mutex_init(&mdev_state->ops_lock);
  223. mdev_state->mdev = mdev;
  224. mdev_set_drvdata(mdev, mdev_state);
  225. mdev_state->type = type;
  226. mdev_state->memsize = fbsize;
  227. mdpy_create_config_space(mdev_state);
  228. mdpy_reset(mdev);
  229. mdpy_count++;
  230. return 0;
  231. }
  232. static int mdpy_remove(struct mdev_device *mdev)
  233. {
  234. struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
  235. struct device *dev = mdev_dev(mdev);
  236. dev_info(dev, "%s\n", __func__);
  237. mdev_set_drvdata(mdev, NULL);
  238. vfree(mdev_state->memblk);
  239. kfree(mdev_state->vconfig);
  240. kfree(mdev_state);
  241. mdpy_count--;
  242. return 0;
  243. }
  244. static ssize_t mdpy_read(struct mdev_device *mdev, char __user *buf,
  245. size_t count, loff_t *ppos)
  246. {
  247. unsigned int done = 0;
  248. int ret;
  249. while (count) {
  250. size_t filled;
  251. if (count >= 4 && !(*ppos % 4)) {
  252. u32 val;
  253. ret = mdev_access(mdev, (char *)&val, sizeof(val),
  254. *ppos, false);
  255. if (ret <= 0)
  256. goto read_err;
  257. if (copy_to_user(buf, &val, sizeof(val)))
  258. goto read_err;
  259. filled = 4;
  260. } else if (count >= 2 && !(*ppos % 2)) {
  261. u16 val;
  262. ret = mdev_access(mdev, (char *)&val, sizeof(val),
  263. *ppos, false);
  264. if (ret <= 0)
  265. goto read_err;
  266. if (copy_to_user(buf, &val, sizeof(val)))
  267. goto read_err;
  268. filled = 2;
  269. } else {
  270. u8 val;
  271. ret = mdev_access(mdev, (char *)&val, sizeof(val),
  272. *ppos, false);
  273. if (ret <= 0)
  274. goto read_err;
  275. if (copy_to_user(buf, &val, sizeof(val)))
  276. goto read_err;
  277. filled = 1;
  278. }
  279. count -= filled;
  280. done += filled;
  281. *ppos += filled;
  282. buf += filled;
  283. }
  284. return done;
  285. read_err:
  286. return -EFAULT;
  287. }
  288. static ssize_t mdpy_write(struct mdev_device *mdev, const char __user *buf,
  289. size_t count, loff_t *ppos)
  290. {
  291. unsigned int done = 0;
  292. int ret;
  293. while (count) {
  294. size_t filled;
  295. if (count >= 4 && !(*ppos % 4)) {
  296. u32 val;
  297. if (copy_from_user(&val, buf, sizeof(val)))
  298. goto write_err;
  299. ret = mdev_access(mdev, (char *)&val, sizeof(val),
  300. *ppos, true);
  301. if (ret <= 0)
  302. goto write_err;
  303. filled = 4;
  304. } else if (count >= 2 && !(*ppos % 2)) {
  305. u16 val;
  306. if (copy_from_user(&val, buf, sizeof(val)))
  307. goto write_err;
  308. ret = mdev_access(mdev, (char *)&val, sizeof(val),
  309. *ppos, true);
  310. if (ret <= 0)
  311. goto write_err;
  312. filled = 2;
  313. } else {
  314. u8 val;
  315. if (copy_from_user(&val, buf, sizeof(val)))
  316. goto write_err;
  317. ret = mdev_access(mdev, (char *)&val, sizeof(val),
  318. *ppos, true);
  319. if (ret <= 0)
  320. goto write_err;
  321. filled = 1;
  322. }
  323. count -= filled;
  324. done += filled;
  325. *ppos += filled;
  326. buf += filled;
  327. }
  328. return done;
  329. write_err:
  330. return -EFAULT;
  331. }
  332. static int mdpy_mmap(struct mdev_device *mdev, struct vm_area_struct *vma)
  333. {
  334. struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
  335. if (vma->vm_pgoff != MDPY_MEMORY_BAR_OFFSET >> PAGE_SHIFT)
  336. return -EINVAL;
  337. if (vma->vm_end < vma->vm_start)
  338. return -EINVAL;
  339. if (vma->vm_end - vma->vm_start > mdev_state->memsize)
  340. return -EINVAL;
  341. if ((vma->vm_flags & VM_SHARED) == 0)
  342. return -EINVAL;
  343. return remap_vmalloc_range_partial(vma, vma->vm_start,
  344. mdev_state->memblk, 0,
  345. vma->vm_end - vma->vm_start);
  346. }
  347. static int mdpy_get_region_info(struct mdev_device *mdev,
  348. struct vfio_region_info *region_info,
  349. u16 *cap_type_id, void **cap_type)
  350. {
  351. struct mdev_state *mdev_state;
  352. mdev_state = mdev_get_drvdata(mdev);
  353. if (!mdev_state)
  354. return -EINVAL;
  355. if (region_info->index >= VFIO_PCI_NUM_REGIONS &&
  356. region_info->index != MDPY_DISPLAY_REGION)
  357. return -EINVAL;
  358. switch (region_info->index) {
  359. case VFIO_PCI_CONFIG_REGION_INDEX:
  360. region_info->offset = 0;
  361. region_info->size = MDPY_CONFIG_SPACE_SIZE;
  362. region_info->flags = (VFIO_REGION_INFO_FLAG_READ |
  363. VFIO_REGION_INFO_FLAG_WRITE);
  364. break;
  365. case VFIO_PCI_BAR0_REGION_INDEX:
  366. case MDPY_DISPLAY_REGION:
  367. region_info->offset = MDPY_MEMORY_BAR_OFFSET;
  368. region_info->size = mdev_state->memsize;
  369. region_info->flags = (VFIO_REGION_INFO_FLAG_READ |
  370. VFIO_REGION_INFO_FLAG_WRITE |
  371. VFIO_REGION_INFO_FLAG_MMAP);
  372. break;
  373. default:
  374. region_info->size = 0;
  375. region_info->offset = 0;
  376. region_info->flags = 0;
  377. }
  378. return 0;
  379. }
  380. static int mdpy_get_irq_info(struct mdev_device *mdev,
  381. struct vfio_irq_info *irq_info)
  382. {
  383. irq_info->count = 0;
  384. return 0;
  385. }
  386. static int mdpy_get_device_info(struct mdev_device *mdev,
  387. struct vfio_device_info *dev_info)
  388. {
  389. dev_info->flags = VFIO_DEVICE_FLAGS_PCI;
  390. dev_info->num_regions = VFIO_PCI_NUM_REGIONS;
  391. dev_info->num_irqs = VFIO_PCI_NUM_IRQS;
  392. return 0;
  393. }
  394. static int mdpy_query_gfx_plane(struct mdev_device *mdev,
  395. struct vfio_device_gfx_plane_info *plane)
  396. {
  397. struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
  398. if (plane->flags & VFIO_GFX_PLANE_TYPE_PROBE) {
  399. if (plane->flags == (VFIO_GFX_PLANE_TYPE_PROBE |
  400. VFIO_GFX_PLANE_TYPE_REGION))
  401. return 0;
  402. return -EINVAL;
  403. }
  404. if (plane->flags != VFIO_GFX_PLANE_TYPE_REGION)
  405. return -EINVAL;
  406. plane->drm_format = mdev_state->type->format;
  407. plane->width = mdev_state->type->width;
  408. plane->height = mdev_state->type->height;
  409. plane->stride = (mdev_state->type->width *
  410. mdev_state->type->bytepp);
  411. plane->size = mdev_state->memsize;
  412. plane->region_index = MDPY_DISPLAY_REGION;
  413. /* unused */
  414. plane->drm_format_mod = 0;
  415. plane->x_pos = 0;
  416. plane->y_pos = 0;
  417. plane->x_hot = 0;
  418. plane->y_hot = 0;
  419. return 0;
  420. }
  421. static long mdpy_ioctl(struct mdev_device *mdev, unsigned int cmd,
  422. unsigned long arg)
  423. {
  424. int ret = 0;
  425. unsigned long minsz;
  426. struct mdev_state *mdev_state;
  427. mdev_state = mdev_get_drvdata(mdev);
  428. switch (cmd) {
  429. case VFIO_DEVICE_GET_INFO:
  430. {
  431. struct vfio_device_info info;
  432. minsz = offsetofend(struct vfio_device_info, num_irqs);
  433. if (copy_from_user(&info, (void __user *)arg, minsz))
  434. return -EFAULT;
  435. if (info.argsz < minsz)
  436. return -EINVAL;
  437. ret = mdpy_get_device_info(mdev, &info);
  438. if (ret)
  439. return ret;
  440. memcpy(&mdev_state->dev_info, &info, sizeof(info));
  441. if (copy_to_user((void __user *)arg, &info, minsz))
  442. return -EFAULT;
  443. return 0;
  444. }
  445. case VFIO_DEVICE_GET_REGION_INFO:
  446. {
  447. struct vfio_region_info info;
  448. u16 cap_type_id = 0;
  449. void *cap_type = NULL;
  450. minsz = offsetofend(struct vfio_region_info, offset);
  451. if (copy_from_user(&info, (void __user *)arg, minsz))
  452. return -EFAULT;
  453. if (info.argsz < minsz)
  454. return -EINVAL;
  455. ret = mdpy_get_region_info(mdev, &info, &cap_type_id,
  456. &cap_type);
  457. if (ret)
  458. return ret;
  459. if (copy_to_user((void __user *)arg, &info, minsz))
  460. return -EFAULT;
  461. return 0;
  462. }
  463. case VFIO_DEVICE_GET_IRQ_INFO:
  464. {
  465. struct vfio_irq_info info;
  466. minsz = offsetofend(struct vfio_irq_info, count);
  467. if (copy_from_user(&info, (void __user *)arg, minsz))
  468. return -EFAULT;
  469. if ((info.argsz < minsz) ||
  470. (info.index >= mdev_state->dev_info.num_irqs))
  471. return -EINVAL;
  472. ret = mdpy_get_irq_info(mdev, &info);
  473. if (ret)
  474. return ret;
  475. if (copy_to_user((void __user *)arg, &info, minsz))
  476. return -EFAULT;
  477. return 0;
  478. }
  479. case VFIO_DEVICE_QUERY_GFX_PLANE:
  480. {
  481. struct vfio_device_gfx_plane_info plane;
  482. minsz = offsetofend(struct vfio_device_gfx_plane_info,
  483. region_index);
  484. if (copy_from_user(&plane, (void __user *)arg, minsz))
  485. return -EFAULT;
  486. if (plane.argsz < minsz)
  487. return -EINVAL;
  488. ret = mdpy_query_gfx_plane(mdev, &plane);
  489. if (ret)
  490. return ret;
  491. if (copy_to_user((void __user *)arg, &plane, minsz))
  492. return -EFAULT;
  493. return 0;
  494. }
  495. case VFIO_DEVICE_SET_IRQS:
  496. return -EINVAL;
  497. case VFIO_DEVICE_RESET:
  498. return mdpy_reset(mdev);
  499. }
  500. return -ENOTTY;
  501. }
  502. static int mdpy_open(struct mdev_device *mdev)
  503. {
  504. if (!try_module_get(THIS_MODULE))
  505. return -ENODEV;
  506. return 0;
  507. }
  508. static void mdpy_close(struct mdev_device *mdev)
  509. {
  510. module_put(THIS_MODULE);
  511. }
  512. static ssize_t
  513. resolution_show(struct device *dev, struct device_attribute *attr,
  514. char *buf)
  515. {
  516. struct mdev_device *mdev = mdev_from_dev(dev);
  517. struct mdev_state *mdev_state = mdev_get_drvdata(mdev);
  518. return sprintf(buf, "%dx%d\n",
  519. mdev_state->type->width,
  520. mdev_state->type->height);
  521. }
  522. static DEVICE_ATTR_RO(resolution);
  523. static struct attribute *mdev_dev_attrs[] = {
  524. &dev_attr_resolution.attr,
  525. NULL,
  526. };
  527. static const struct attribute_group mdev_dev_group = {
  528. .name = "vendor",
  529. .attrs = mdev_dev_attrs,
  530. };
  531. const struct attribute_group *mdev_dev_groups[] = {
  532. &mdev_dev_group,
  533. NULL,
  534. };
  535. static ssize_t
  536. name_show(struct kobject *kobj, struct device *dev, char *buf)
  537. {
  538. return sprintf(buf, "%s\n", kobj->name);
  539. }
  540. MDEV_TYPE_ATTR_RO(name);
  541. static ssize_t
  542. description_show(struct kobject *kobj, struct device *dev, char *buf)
  543. {
  544. const struct mdpy_type *type = mdpy_find_type(kobj);
  545. return sprintf(buf, "virtual display, %dx%d framebuffer\n",
  546. type ? type->width : 0,
  547. type ? type->height : 0);
  548. }
  549. MDEV_TYPE_ATTR_RO(description);
  550. static ssize_t
  551. available_instances_show(struct kobject *kobj, struct device *dev, char *buf)
  552. {
  553. return sprintf(buf, "%d\n", max_devices - mdpy_count);
  554. }
  555. MDEV_TYPE_ATTR_RO(available_instances);
  556. static ssize_t device_api_show(struct kobject *kobj, struct device *dev,
  557. char *buf)
  558. {
  559. return sprintf(buf, "%s\n", VFIO_DEVICE_API_PCI_STRING);
  560. }
  561. MDEV_TYPE_ATTR_RO(device_api);
  562. static struct attribute *mdev_types_attrs[] = {
  563. &mdev_type_attr_name.attr,
  564. &mdev_type_attr_description.attr,
  565. &mdev_type_attr_device_api.attr,
  566. &mdev_type_attr_available_instances.attr,
  567. NULL,
  568. };
  569. static struct attribute_group mdev_type_group1 = {
  570. .name = MDPY_TYPE_1,
  571. .attrs = mdev_types_attrs,
  572. };
  573. static struct attribute_group mdev_type_group2 = {
  574. .name = MDPY_TYPE_2,
  575. .attrs = mdev_types_attrs,
  576. };
  577. static struct attribute_group mdev_type_group3 = {
  578. .name = MDPY_TYPE_3,
  579. .attrs = mdev_types_attrs,
  580. };
  581. static struct attribute_group *mdev_type_groups[] = {
  582. &mdev_type_group1,
  583. &mdev_type_group2,
  584. &mdev_type_group3,
  585. NULL,
  586. };
  587. static const struct mdev_parent_ops mdev_fops = {
  588. .owner = THIS_MODULE,
  589. .mdev_attr_groups = mdev_dev_groups,
  590. .supported_type_groups = mdev_type_groups,
  591. .create = mdpy_create,
  592. .remove = mdpy_remove,
  593. .open = mdpy_open,
  594. .release = mdpy_close,
  595. .read = mdpy_read,
  596. .write = mdpy_write,
  597. .ioctl = mdpy_ioctl,
  598. .mmap = mdpy_mmap,
  599. };
  600. static const struct file_operations vd_fops = {
  601. .owner = THIS_MODULE,
  602. };
  603. static void mdpy_device_release(struct device *dev)
  604. {
  605. /* nothing */
  606. }
  607. static int __init mdpy_dev_init(void)
  608. {
  609. int ret = 0;
  610. ret = alloc_chrdev_region(&mdpy_devt, 0, MINORMASK + 1, MDPY_NAME);
  611. if (ret < 0) {
  612. pr_err("Error: failed to register mdpy_dev, err: %d\n", ret);
  613. return ret;
  614. }
  615. cdev_init(&mdpy_cdev, &vd_fops);
  616. cdev_add(&mdpy_cdev, mdpy_devt, MINORMASK + 1);
  617. pr_info("%s: major %d\n", __func__, MAJOR(mdpy_devt));
  618. mdpy_class = class_create(THIS_MODULE, MDPY_CLASS_NAME);
  619. if (IS_ERR(mdpy_class)) {
  620. pr_err("Error: failed to register mdpy_dev class\n");
  621. ret = PTR_ERR(mdpy_class);
  622. goto failed1;
  623. }
  624. mdpy_dev.class = mdpy_class;
  625. mdpy_dev.release = mdpy_device_release;
  626. dev_set_name(&mdpy_dev, "%s", MDPY_NAME);
  627. ret = device_register(&mdpy_dev);
  628. if (ret)
  629. goto failed2;
  630. ret = mdev_register_device(&mdpy_dev, &mdev_fops);
  631. if (ret)
  632. goto failed3;
  633. return 0;
  634. failed3:
  635. device_unregister(&mdpy_dev);
  636. failed2:
  637. class_destroy(mdpy_class);
  638. failed1:
  639. cdev_del(&mdpy_cdev);
  640. unregister_chrdev_region(mdpy_devt, MINORMASK + 1);
  641. return ret;
  642. }
  643. static void __exit mdpy_dev_exit(void)
  644. {
  645. mdpy_dev.bus = NULL;
  646. mdev_unregister_device(&mdpy_dev);
  647. device_unregister(&mdpy_dev);
  648. cdev_del(&mdpy_cdev);
  649. unregister_chrdev_region(mdpy_devt, MINORMASK + 1);
  650. class_destroy(mdpy_class);
  651. mdpy_class = NULL;
  652. }
  653. module_init(mdpy_dev_init)
  654. module_exit(mdpy_dev_exit)