FramebufferDevice.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256
  1. /*
  2. * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Checked.h>
  7. #include <AK/Try.h>
  8. #include <Kernel/API/POSIX/errno.h>
  9. #include <Kernel/Debug.h>
  10. #include <Kernel/Devices/DeviceManagement.h>
  11. #include <Kernel/Graphics/FramebufferDevice.h>
  12. #include <Kernel/Graphics/GraphicsManagement.h>
  13. #include <Kernel/Memory/AnonymousVMObject.h>
  14. #include <Kernel/Memory/MemoryManager.h>
  15. #include <Kernel/Process.h>
  16. #include <Kernel/Sections.h>
  17. #include <LibC/sys/ioctl_numbers.h>
  18. namespace Kernel {
  19. NonnullRefPtr<FramebufferDevice> FramebufferDevice::create(const GenericGraphicsAdapter& adapter, PhysicalAddress paddr, size_t width, size_t height, size_t pitch)
  20. {
  21. auto framebuffer_device_or_error = DeviceManagement::try_create_device<FramebufferDevice>(adapter, paddr, width, height, pitch);
  22. // FIXME: Find a way to propagate errors
  23. VERIFY(!framebuffer_device_or_error.is_error());
  24. return framebuffer_device_or_error.release_value();
  25. }
  26. ErrorOr<Memory::Region*> FramebufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
  27. {
  28. TRY(process.require_promise(Pledge::video));
  29. SpinlockLocker lock(m_activation_lock);
  30. if (!shared)
  31. return ENODEV;
  32. if (offset != 0)
  33. return ENXIO;
  34. auto framebuffer_length = TRY(buffer_length(0));
  35. framebuffer_length = TRY(Memory::page_round_up(framebuffer_length));
  36. if (range.size() != framebuffer_length)
  37. return EOVERFLOW;
  38. m_userspace_real_framebuffer_vmobject = TRY(Memory::AnonymousVMObject::try_create_for_physical_range(m_framebuffer_address, framebuffer_length));
  39. m_real_framebuffer_vmobject = TRY(Memory::AnonymousVMObject::try_create_for_physical_range(m_framebuffer_address, framebuffer_length));
  40. m_swapped_framebuffer_vmobject = TRY(Memory::AnonymousVMObject::try_create_with_size(framebuffer_length, AllocationStrategy::AllocateNow));
  41. m_real_framebuffer_region = TRY(MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, framebuffer_length, "Framebuffer", Memory::Region::Access::ReadWrite));
  42. m_swapped_framebuffer_region = TRY(MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, framebuffer_length, "Framebuffer Swap (Blank)", Memory::Region::Access::ReadWrite));
  43. RefPtr<Memory::VMObject> chosen_vmobject;
  44. if (m_graphical_writes_enabled) {
  45. chosen_vmobject = m_real_framebuffer_vmobject;
  46. } else {
  47. chosen_vmobject = m_swapped_framebuffer_vmobject;
  48. }
  49. m_userspace_framebuffer_region = TRY(process.address_space().allocate_region_with_vmobject(
  50. range,
  51. chosen_vmobject.release_nonnull(),
  52. 0,
  53. "Framebuffer",
  54. prot,
  55. shared));
  56. if (auto result = m_userspace_framebuffer_region->set_write_combine(true); result.is_error())
  57. dbgln("FramebufferDevice: Failed to enable Write-Combine on Framebuffer: {}", result.error());
  58. return m_userspace_framebuffer_region;
  59. }
  60. void FramebufferDevice::deactivate_writes()
  61. {
  62. SpinlockLocker lock(m_activation_lock);
  63. if (!m_userspace_framebuffer_region)
  64. return;
  65. auto framebuffer_length_or_error = buffer_length(0);
  66. VERIFY(!framebuffer_length_or_error.is_error());
  67. size_t rounded_framebuffer_length = Memory::page_round_up(framebuffer_length_or_error.release_value()).release_value_but_fixme_should_propagate_errors();
  68. memcpy(m_swapped_framebuffer_region->vaddr().as_ptr(), m_real_framebuffer_region->vaddr().as_ptr(), rounded_framebuffer_length);
  69. auto vmobject = m_swapped_framebuffer_vmobject;
  70. m_userspace_framebuffer_region->set_vmobject(vmobject.release_nonnull());
  71. m_userspace_framebuffer_region->remap();
  72. m_graphical_writes_enabled = false;
  73. }
  74. void FramebufferDevice::activate_writes()
  75. {
  76. SpinlockLocker lock(m_activation_lock);
  77. if (!m_userspace_framebuffer_region || !m_real_framebuffer_vmobject)
  78. return;
  79. // restore the image we had in the void area
  80. // FIXME: if we happen to have multiple Framebuffers that are writing to that location
  81. // we will experience glitches...
  82. auto framebuffer_length_or_error = buffer_length(0);
  83. VERIFY(!framebuffer_length_or_error.is_error());
  84. size_t rounded_framebuffer_length = Memory::page_round_up(framebuffer_length_or_error.release_value()).release_value_but_fixme_should_propagate_errors();
  85. memcpy(m_real_framebuffer_region->vaddr().as_ptr(), m_swapped_framebuffer_region->vaddr().as_ptr(), rounded_framebuffer_length);
  86. auto vmobject = m_userspace_real_framebuffer_vmobject;
  87. m_userspace_framebuffer_region->set_vmobject(vmobject.release_nonnull());
  88. m_userspace_framebuffer_region->remap();
  89. m_graphical_writes_enabled = true;
  90. }
  91. UNMAP_AFTER_INIT ErrorOr<void> FramebufferDevice::try_to_initialize()
  92. {
  93. // FIXME: Would be nice to be able to unify this with mmap above, but this
  94. // function is UNMAP_AFTER_INIT for the time being.
  95. auto framebuffer_length = TRY(buffer_length(0));
  96. framebuffer_length = TRY(Memory::page_round_up(framebuffer_length));
  97. m_real_framebuffer_vmobject = TRY(Memory::AnonymousVMObject::try_create_for_physical_range(m_framebuffer_address, framebuffer_length));
  98. m_swapped_framebuffer_vmobject = TRY(Memory::AnonymousVMObject::try_create_with_size(framebuffer_length, AllocationStrategy::AllocateNow));
  99. m_real_framebuffer_region = TRY(MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, framebuffer_length, "Framebuffer", Memory::Region::Access::ReadWrite));
  100. m_swapped_framebuffer_region = TRY(MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, framebuffer_length, "Framebuffer Swap (Blank)", Memory::Region::Access::ReadWrite));
  101. return {};
  102. }
  103. UNMAP_AFTER_INIT FramebufferDevice::FramebufferDevice(const GenericGraphicsAdapter& adapter, PhysicalAddress addr, size_t width, size_t height, size_t pitch)
  104. : GenericFramebufferDevice(adapter)
  105. , m_framebuffer_address(addr)
  106. , m_framebuffer_pitch(pitch)
  107. , m_framebuffer_width(width)
  108. , m_framebuffer_height(height)
  109. {
  110. VERIFY(!m_framebuffer_address.is_null());
  111. VERIFY(m_framebuffer_pitch);
  112. VERIFY(m_framebuffer_width);
  113. VERIFY(m_framebuffer_height);
  114. dbgln("Framebuffer {}: address={}, pitch={}, width={}, height={}", minor(), addr, pitch, width, height);
  115. }
  116. ErrorOr<size_t> FramebufferDevice::buffer_length(size_t head) const
  117. {
  118. // Note: This FramebufferDevice class doesn't support multihead setup.
  119. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  120. // so if we happen to accidentally have a value different than 0, assert.
  121. VERIFY(head == 0);
  122. SpinlockLocker locker(m_resolution_lock);
  123. auto adapter = m_graphics_adapter.strong_ref();
  124. if (!adapter)
  125. return Error::from_errno(EIO);
  126. if (adapter->double_framebuffering_capable())
  127. return m_framebuffer_pitch * m_framebuffer_height * 2;
  128. return m_framebuffer_pitch * m_framebuffer_height;
  129. }
  130. ErrorOr<size_t> FramebufferDevice::pitch(size_t head) const
  131. {
  132. // Note: This FramebufferDevice class doesn't support multihead setup.
  133. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  134. // so if we happen to accidentally have a value different than 0, assert.
  135. VERIFY(head == 0);
  136. SpinlockLocker locker(m_resolution_lock);
  137. return m_framebuffer_pitch;
  138. }
  139. ErrorOr<size_t> FramebufferDevice::height(size_t head) const
  140. {
  141. // Note: This FramebufferDevice class doesn't support multihead setup.
  142. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  143. // so if we happen to accidentally have a value different than 0, assert.
  144. VERIFY(head == 0);
  145. SpinlockLocker locker(m_resolution_lock);
  146. return m_framebuffer_height;
  147. }
  148. ErrorOr<size_t> FramebufferDevice::width(size_t head) const
  149. {
  150. // Note: This FramebufferDevice class doesn't support multihead setup.
  151. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  152. // so if we happen to accidentally have a value different than 0, assert.
  153. VERIFY(head == 0);
  154. SpinlockLocker locker(m_resolution_lock);
  155. return m_framebuffer_width;
  156. }
  157. ErrorOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
  158. {
  159. // Note: This FramebufferDevice class doesn't support multihead setup.
  160. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  161. // so if we happen to accidentally have a value different than 0, assert.
  162. VERIFY(head == 0);
  163. SpinlockLocker locker(m_buffer_offset_lock);
  164. return m_y_offset;
  165. }
  166. ErrorOr<bool> FramebufferDevice::vertical_offsetted(size_t head) const
  167. {
  168. // Note: This FramebufferDevice class doesn't support multihead setup.
  169. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  170. // so if we happen to accidentally have a value different than 0, assert.
  171. VERIFY(head == 0);
  172. SpinlockLocker locker(m_buffer_offset_lock);
  173. return m_y_offset == 0 ? 0 : 1;
  174. }
  175. ErrorOr<void> FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t height, size_t)
  176. {
  177. // Note: This FramebufferDevice class doesn't support multihead setup.
  178. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  179. // so if we happen to accidentally have a value different than 0, assert.
  180. VERIFY(head == 0);
  181. SpinlockLocker buffer_offset_locker(m_buffer_offset_lock);
  182. SpinlockLocker resolution_locker(m_resolution_lock);
  183. auto adapter = m_graphics_adapter.strong_ref();
  184. if (!adapter)
  185. return Error::from_errno(EIO);
  186. auto result = adapter->try_to_set_resolution(0, width, height);
  187. // FIXME: Find a better way to return here a ErrorOr<void>.
  188. if (!result)
  189. return Error::from_errno(ENOTSUP);
  190. m_framebuffer_width = width;
  191. m_framebuffer_height = height;
  192. m_framebuffer_pitch = width * sizeof(u32);
  193. return {};
  194. }
  195. ErrorOr<void> FramebufferDevice::set_head_buffer(size_t head, bool second_buffer)
  196. {
  197. // Note: This FramebufferDevice class doesn't support multihead setup.
  198. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  199. // so if we happen to accidentally have a value different than 0, assert.
  200. VERIFY(head == 0);
  201. SpinlockLocker locker(m_buffer_offset_lock);
  202. auto adapter = m_graphics_adapter.strong_ref();
  203. if (!adapter)
  204. return Error::from_errno(EIO);
  205. if (second_buffer) {
  206. if (!adapter->set_y_offset(0, m_framebuffer_height)) {
  207. // FIXME: Find a better ErrorOr<void> here.
  208. return Error::from_errno(ENOTSUP);
  209. }
  210. m_y_offset = m_framebuffer_height;
  211. } else {
  212. if (!adapter->set_y_offset(0, 0)) {
  213. // FIXME: Find a better ErrorOr<void> here.
  214. return Error::from_errno(ENOTSUP);
  215. }
  216. m_y_offset = 0;
  217. }
  218. return {};
  219. }
  220. ErrorOr<void> FramebufferDevice::flush_head_buffer(size_t)
  221. {
  222. // Note: This FramebufferDevice class doesn't support flushing.
  223. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  224. // so if we happen to accidentally reach this code, assert.
  225. VERIFY_NOT_REACHED();
  226. }
  227. ErrorOr<void> FramebufferDevice::flush_rectangle(size_t, FBRect const&)
  228. {
  229. // Note: This FramebufferDevice class doesn't support partial flushing.
  230. // We take care to verify this at the GenericFramebufferDevice::ioctl method
  231. // so if we happen to accidentally reach this code, assert.
  232. VERIFY_NOT_REACHED();
  233. }
  234. ErrorOr<ByteBuffer> FramebufferDevice::get_edid(size_t head) const
  235. {
  236. auto adapter = m_graphics_adapter.strong_ref();
  237. if (!adapter)
  238. return Error::from_errno(EIO);
  239. return adapter->get_edid(head);
  240. }
  241. }