OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "ui/ozone/platform/drm/gpu/intel_drm_pixmap.h" |
| 6 |
| 7 #include <fcntl.h> |
| 8 #include <libdrm/i915_drm.h> |
| 9 extern "C" { |
| 10 #include <libdrm/intel_bufmgr.h> |
| 11 } |
| 12 |
| 13 #include "base/posix/eintr_wrapper.h" |
| 14 #include "base/lazy_instance.h" |
| 15 #include "base/numerics/safe_math.h" |
| 16 #include "base/trace_event/trace_event.h" |
| 17 #include "ui/ozone/platform/drm/gpu/gbm_device.h" |
| 18 |
| 19 #include "base/file_descriptor_posix.h" |
| 20 #include "base/memory/scoped_ptr.h" |
| 21 #include "ui/ozone/ozone_export.h" |
| 22 |
| 23 namespace ui { |
| 24 |
| 25 namespace { |
| 26 |
| 27 class DrmIntelBufferManager { |
| 28 public: |
| 29 DrmIntelBufferManager() : buffer_manager_(nullptr) {} |
| 30 ~DrmIntelBufferManager() { |
| 31 if (buffer_manager_) |
| 32 drm_intel_bufmgr_destroy(buffer_manager_); |
| 33 if (device_fd_.auto_close) |
| 34 base::ScopedFD closing_fd(device_fd_.fd); |
| 35 } |
| 36 |
| 37 bool Initialize(const base::FileDescriptor& device_fd) { |
| 38 if (buffer_manager_) |
| 39 return true; |
| 40 |
| 41 device_fd_ = device_fd; |
| 42 |
| 43 // TODO(dshwang): drm bufmgr doesn't need an execbuffer, so batch size is 0. |
| 44 const int kBatchSize = 16 * 4096; |
| 45 buffer_manager_ = drm_intel_bufmgr_gem_init(device_fd_.fd, kBatchSize); |
| 46 if (!buffer_manager_) { |
| 47 DLOG(ERROR) << "drm_intel_bufmgr_gem_init failed."; |
| 48 return false; |
| 49 } |
| 50 return true; |
| 51 } |
| 52 |
| 53 drm_intel_bufmgr* buffer_manager() const { return buffer_manager_; } |
| 54 int device_fd() const { return device_fd_.fd; } |
| 55 |
| 56 private: |
| 57 base::FileDescriptor device_fd_; |
| 58 drm_intel_bufmgr* buffer_manager_; |
| 59 |
| 60 DISALLOW_COPY_AND_ASSIGN(DrmIntelBufferManager); |
| 61 }; |
| 62 |
| 63 int BytesPerPixel(gfx::BufferFormat format) { |
| 64 switch (format) { |
| 65 case gfx::BufferFormat::BGRA_8888: |
| 66 case gfx::BufferFormat::RGBX_8888: |
| 67 return 4; |
| 68 default: |
| 69 NOTREACHED(); |
| 70 return 0; |
| 71 } |
| 72 } |
| 73 |
| 74 base::LazyInstance<DrmIntelBufferManager>::Leaky g_buffer_manager = |
| 75 LAZY_INSTANCE_INITIALIZER; |
| 76 |
| 77 } // namespace |
| 78 |
| 79 // static |
| 80 scoped_refptr<IntelDrmPixmap> IntelDrmPixmap::Create( |
| 81 const base::FileDescriptor& device_fd, |
| 82 gfx::BufferFormat format, |
| 83 const gfx::Size& size) { |
| 84 TRACE_EVENT1("drm", "IntelDrmPixmap::Create", "size", size.ToString()); |
| 85 |
| 86 scoped_refptr<IntelDrmPixmap> pixmap(new IntelDrmPixmap()); |
| 87 if (!pixmap->Initialize(device_fd, format, size)) |
| 88 return nullptr; |
| 89 |
| 90 return pixmap; |
| 91 } |
| 92 |
| 93 IntelDrmPixmap::IntelDrmPixmap() : buffer_(nullptr), stride_(0) {} |
| 94 |
| 95 IntelDrmPixmap::~IntelDrmPixmap() { |
| 96 if (buffer_) { |
| 97 drm_intel_bo_unreference(buffer_); |
| 98 buffer_ = nullptr; |
| 99 } |
| 100 } |
| 101 bool IntelDrmPixmap::Initialize(const base::FileDescriptor& device_fd, |
| 102 gfx::BufferFormat format, |
| 103 const gfx::Size& size) { |
| 104 if (!g_buffer_manager.Pointer()->buffer_manager()) { |
| 105 g_buffer_manager.Pointer()->Initialize(device_fd); |
| 106 } else { |
| 107 DCHECK(g_buffer_manager.Pointer()->device_fd() == device_fd.fd); |
| 108 } |
| 109 |
| 110 uint32_t tiling_mode = I915_TILING_NONE; |
| 111 unsigned long stride = 0; |
| 112 buffer_ = drm_intel_bo_alloc_tiled( |
| 113 g_buffer_manager.Pointer()->buffer_manager(), |
| 114 "chromium-gpu-memory-buffer", size.width(), size.height(), |
| 115 BytesPerPixel(format), &tiling_mode, &stride, 0); |
| 116 if (!buffer_) { |
| 117 DLOG(ERROR) << "drm_intel_bo_alloc_tiled failed."; |
| 118 return false; |
| 119 } |
| 120 DCHECK(stride); |
| 121 stride_ = stride; |
| 122 |
| 123 int prime_fd = -1; |
| 124 drm_intel_bo_gem_export_to_prime(buffer_, &prime_fd); |
| 125 if (prime_fd <= 0) { |
| 126 DLOG(ERROR) << "Fail to export a drm buffer file descriptor"; |
| 127 return false; |
| 128 } |
| 129 prime_fd_.reset(prime_fd); |
| 130 return true; |
| 131 } |
| 132 |
| 133 void* IntelDrmPixmap::GetEGLClientBuffer() { |
| 134 return nullptr; |
| 135 } |
| 136 |
| 137 int IntelDrmPixmap::GetDmaBufFd() { |
| 138 return prime_fd_.get(); |
| 139 } |
| 140 |
| 141 int IntelDrmPixmap::GetDmaBufPitch() { |
| 142 return stride_; |
| 143 } |
| 144 |
| 145 bool IntelDrmPixmap::ScheduleOverlayPlane(gfx::AcceleratedWidget widget, |
| 146 int plane_z_order, |
| 147 gfx::OverlayTransform plane_transform, |
| 148 const gfx::Rect& display_bounds, |
| 149 const gfx::RectF& crop_rect) { |
| 150 // IntelDrmPixmap is used in Browser and Renderer, so this feature is not |
| 151 // needed. |
| 152 NOTREACHED(); |
| 153 return false; |
| 154 } |
| 155 |
| 156 void IntelDrmPixmap::SetScalingCallback( |
| 157 const ScalingCallback& scaling_callback) { |
| 158 // IntelDrmPixmap is used in Browser and Renderer, so this feature is not |
| 159 // needed. |
| 160 NOTREACHED(); |
| 161 } |
| 162 |
| 163 scoped_refptr<NativePixmap> IntelDrmPixmap::GetScaledPixmap( |
| 164 gfx::Size new_size) { |
| 165 // IntelDrmPixmap is used in Browser and Renderer, so this feature is not |
| 166 // needed. |
| 167 NOTREACHED(); |
| 168 return nullptr; |
| 169 } |
| 170 |
| 171 gfx::NativePixmapHandle IntelDrmPixmap::ExportHandle() { |
| 172 gfx::NativePixmapHandle handle; |
| 173 |
| 174 int dmabuf_fd = HANDLE_EINTR(dup(prime_fd_.get())); |
| 175 if (dmabuf_fd < 0) { |
| 176 PLOG(ERROR) << "dup"; |
| 177 return handle; |
| 178 } |
| 179 |
| 180 handle.fd = base::FileDescriptor(base::ScopedFD(dmabuf_fd)); |
| 181 handle.stride = stride_; |
| 182 return handle; |
| 183 } |
| 184 |
| 185 //////////// IntelDrmClientPixmap |
| 186 |
| 187 // static |
| 188 scoped_ptr<IntelDrmClientPixmap> IntelDrmClientPixmap::CreateFromHandle( |
| 189 const gfx::NativePixmapHandle& handle, |
| 190 const base::FileDescriptor& device_fd, |
| 191 gfx::BufferFormat format, |
| 192 const gfx::Size& size) { |
| 193 TRACE_EVENT1("drm", "IntelDrmClientPixmap::CreateFromHandle", "size", |
| 194 size.ToString()); |
| 195 |
| 196 scoped_ptr<IntelDrmClientPixmap> pixmap(new IntelDrmClientPixmap()); |
| 197 if (!pixmap->InitializeFromHandle(handle, device_fd, format, size)) |
| 198 return nullptr; |
| 199 |
| 200 return pixmap; |
| 201 } |
| 202 |
| 203 IntelDrmClientPixmap::IntelDrmClientPixmap() : buffer_(nullptr), stride_(0) {} |
| 204 |
| 205 IntelDrmClientPixmap::~IntelDrmClientPixmap() { |
| 206 if (buffer_) { |
| 207 drm_intel_bo_unreference(buffer_); |
| 208 buffer_ = nullptr; |
| 209 } |
| 210 } |
| 211 |
| 212 bool IntelDrmClientPixmap::InitializeFromHandle( |
| 213 const gfx::NativePixmapHandle& handle, |
| 214 const base::FileDescriptor& device_fd, |
| 215 gfx::BufferFormat format, |
| 216 const gfx::Size& size) { |
| 217 if (!g_buffer_manager.Pointer()->buffer_manager()) { |
| 218 g_buffer_manager.Pointer()->Initialize(device_fd); |
| 219 } |
| 220 |
| 221 stride_ = handle.stride; |
| 222 int buffer_size = stride_ * size.height(); |
| 223 buffer_ = drm_intel_bo_gem_create_from_prime( |
| 224 g_buffer_manager.Pointer()->buffer_manager(), handle.fd.fd, buffer_size); |
| 225 if (!buffer_) { |
| 226 DLOG(ERROR) << "drm_intel_bo_gem_create_from_prime failed."; |
| 227 return false; |
| 228 } |
| 229 DCHECK(handle.fd.auto_close); |
| 230 prime_fd_.reset(handle.fd.fd); |
| 231 return true; |
| 232 } |
| 233 |
| 234 bool IntelDrmClientPixmap::Map(void** data) { |
| 235 TRACE_EVENT0("gpu", "IntelDrmClientPixmap::Map"); |
| 236 DCHECK(buffer_); |
| 237 int write_enable = 1; |
| 238 int error = drm_intel_bo_map(buffer_, write_enable); |
| 239 if (error) { |
| 240 DLOG(ERROR) << "fail to map a drm buffer. error:" << error; |
| 241 return false; |
| 242 } |
| 243 DCHECK(buffer_->virt); |
| 244 *data = buffer_->virt; |
| 245 return true; |
| 246 } |
| 247 |
| 248 void IntelDrmClientPixmap::Unmap() { |
| 249 TRACE_EVENT0("gpu", "IntelDrmClientPixmap::Unmap"); |
| 250 DCHECK(buffer_); |
| 251 int error = drm_intel_bo_unmap(buffer_); |
| 252 DCHECK(!error) << error; |
| 253 } |
| 254 |
| 255 void IntelDrmClientPixmap::GetStride(int* stride) const { |
| 256 *stride = stride_; |
| 257 } |
| 258 |
| 259 } // namespace ui |
OLD | NEW |