1/* 2* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. 3* 4* Redistribution and use in source and binary forms, with or without 5* modification, are permitted provided that the following conditions are 6* met: 7* * Redistributions of source code must retain the above copyright 8* notice, this list of conditions and the following disclaimer. 9* * Redistributions in binary form must reproduce the above 10* copyright notice, this list of conditions and the following 11* disclaimer in the documentation and/or other materials provided 12* with the distribution. 13* * Neither the name of The Linux Foundation nor the names of its 14* contributors may be used to endorse or promote products derived 15* from this software without specific prior written permission. 16* 17* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 18* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 20* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 21* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28*/ 29 30#ifndef OVERLAY_UTILS_H 31#define OVERLAY_UTILS_H 32 33#include <cutils/log.h> // ALOGE, etc 34#include <errno.h> 35#include <fcntl.h> // open, O_RDWR, etc 36#include <hardware/hardware.h> 37#include <hardware/gralloc.h> // buffer_handle_t 38#include <linux/msm_mdp.h> // flags 39#include <linux/msm_rotator.h> 40#include <stdio.h> 41#include <stdlib.h> 42#include <string.h> 43#include <sys/stat.h> 44#include <sys/types.h> 45#include <utils/Log.h> 46#include "gralloc_priv.h" //for interlace 47 48// Older platforms do not support Venus 49#ifndef VENUS_COLOR_FORMAT 50#define MDP_Y_CBCR_H2V2_VENUS MDP_IMGTYPE_LIMIT 51#endif 52 53/* 54* 55* Collection of utilities functions/structs/enums etc... 56* 57* */ 58 59// comment that out if you want to remove asserts 60// or put it as -D in Android.mk. your choice. 61#define OVERLAY_HAS_ASSERT 62 63#ifdef OVERLAY_HAS_ASSERT 64# define OVASSERT(x, ...) if(!(x)) { ALOGE(__VA_ARGS__); abort(); } 65#else 66# define OVASSERT(x, ...) ALOGE_IF(!(x), __VA_ARGS__) 67#endif // OVERLAY_HAS_ASSERT 68 69#define DEBUG_OVERLAY 0 70#define PROFILE_OVERLAY 0 71 72#ifndef MDSS_MDP_RIGHT_MIXER 73#define MDSS_MDP_RIGHT_MIXER 0x100 74#endif 75 76#ifndef MDP_OV_PIPE_FORCE_DMA 77#define MDP_OV_PIPE_FORCE_DMA 0x4000 78#endif 79 80#ifndef MDSS_MDP_DUAL_PIPE 81#define MDSS_MDP_DUAL_PIPE 0x200 82#endif 83 84#define FB_DEVICE_TEMPLATE "/dev/graphics/fb%u" 85 86namespace overlay { 87 88// fwd 89class Overlay; 90class OvFD; 91 92/* helper function to open by using fbnum */ 93bool open(OvFD& fd, uint32_t fbnum, const char* const dev, 94 int flags = O_RDWR); 95 96namespace utils { 97struct Whf; 98struct Dim; 99 100inline uint32_t setBit(uint32_t x, uint32_t mask) { 101 return (x | mask); 102} 103 104inline uint32_t clrBit(uint32_t x, uint32_t mask) { 105 return (x & ~mask); 106} 107 108/* Utility class to help avoid copying instances by making the copy ctor 109* and assignment operator private 110* 111* Usage: 112* class SomeClass : utils::NoCopy {...}; 113*/ 114class NoCopy { 115protected: 116 NoCopy(){} 117 ~NoCopy() {} 118private: 119 NoCopy(const NoCopy&); 120 const NoCopy& operator=(const NoCopy&); 121}; 122 123bool isMdssRotator(); 124void normalizeCrop(uint32_t& xy, uint32_t& wh); 125 126template <class Type> 127void swapWidthHeight(Type& width, Type& height); 128 129struct Dim { 130 Dim () : x(0), y(0), 131 w(0), h(0), 132 o(0) {} 133 Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h) : 134 x(_x), y(_y), 135 w(_w), h(_h) {} 136 Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h, uint32_t _o) : 137 x(_x), y(_y), 138 w(_w), h(_h), 139 o(_o) {} 140 bool check(uint32_t _w, uint32_t _h) const { 141 return (x+w <= _w && y+h <= _h); 142 143 } 144 145 bool operator==(const Dim& d) const { 146 return d.x == x && d.y == y && 147 d.w == w && d.h == h && 148 d.o == o; 149 } 150 151 bool operator!=(const Dim& d) const { 152 return !operator==(d); 153 } 154 155 void dump() const; 156 uint32_t x; 157 uint32_t y; 158 uint32_t w; 159 uint32_t h; 160 uint32_t o; 161}; 162 163// TODO have Whfz 164 165struct Whf { 166 Whf() : w(0), h(0), format(0), size(0) {} 167 Whf(uint32_t wi, uint32_t he, uint32_t f) : 168 w(wi), h(he), format(f), size(0) {} 169 Whf(uint32_t wi, uint32_t he, uint32_t f, uint32_t s) : 170 w(wi), h(he), format(f), size(s) {} 171 // FIXME not comparing size at the moment 172 bool operator==(const Whf& whf) const { 173 return whf.w == w && whf.h == h && 174 whf.format == format; 175 } 176 bool operator!=(const Whf& whf) const { 177 return !operator==(whf); 178 } 179 void dump() const; 180 uint32_t w; 181 uint32_t h; 182 uint32_t format; 183 uint32_t size; 184}; 185 186enum { MAX_PATH_LEN = 256 }; 187 188enum { DEFAULT_PLANE_ALPHA = 0xFF }; 189 190/** 191 * Rotator flags: not to be confused with orientation flags. 192 * Usually, you want to open the rotator to make sure it is 193 * ready for business. 194 * */ 195 enum eRotFlags { 196 ROT_FLAGS_NONE = 0, 197 //Use rotator for 0 rotation. It is used anyway for others. 198 ROT_0_ENABLED = 1 << 0, 199 //Enable rotator downscale optimization for hardware bugs not handled in 200 //driver. If downscale optimizatation is required, 201 //then rotator will be used even if its 0 rotation case. 202 ROT_DOWNSCALE_ENABLED = 1 << 1, 203 ROT_PREROTATED = 1 << 2, 204}; 205 206enum eRotDownscale { 207 ROT_DS_NONE = 0, 208 ROT_DS_HALF = 1, 209 ROT_DS_FOURTH = 2, 210 ROT_DS_EIGHTH = 3, 211}; 212 213/* 214 * Various mdp flags like PIPE SHARE, DEINTERLACE etc... 215 * kernel/common/linux/msm_mdp.h 216 * INTERLACE_MASK: hardware/qcom/display/libgralloc/badger/fb_priv.h 217 * */ 218enum eMdpFlags { 219 OV_MDP_FLAGS_NONE = 0, 220 OV_MDP_PIPE_SHARE = MDP_OV_PIPE_SHARE, 221 OV_MDP_PIPE_FORCE_DMA = MDP_OV_PIPE_FORCE_DMA, 222 OV_MDP_DEINTERLACE = MDP_DEINTERLACE, 223 OV_MDP_SECURE_OVERLAY_SESSION = MDP_SECURE_OVERLAY_SESSION, 224 OV_MDP_SECURE_DISPLAY_OVERLAY_SESSION = MDP_SECURE_DISPLAY_OVERLAY_SESSION, 225 OV_MDP_SOURCE_ROTATED_90 = MDP_SOURCE_ROTATED_90, 226 OV_MDP_BLEND_FG_PREMULT = MDP_BLEND_FG_PREMULT, 227 OV_MDP_FLIP_H = MDP_FLIP_LR, 228 OV_MDP_FLIP_V = MDP_FLIP_UD, 229 OV_MDSS_MDP_RIGHT_MIXER = MDSS_MDP_RIGHT_MIXER, 230 OV_MDP_PP_EN = MDP_OVERLAY_PP_CFG_EN, 231 OV_MDSS_MDP_BWC_EN = MDP_BWC_EN, 232 OV_MDSS_MDP_DUAL_PIPE = MDSS_MDP_DUAL_PIPE, 233 OV_MDP_SOLID_FILL = MDP_SOLID_FILL, 234 OV_MDP_SMP_FORCE_ALLOC = MDP_SMP_FORCE_ALLOC, 235}; 236 237enum eZorder { 238 ZORDER_0 = 0, 239 ZORDER_1, 240 ZORDER_2, 241 ZORDER_3, 242 ZORDER_4, 243 ZORDER_5, 244 ZORDER_6, 245 Z_SYSTEM_ALLOC = 0xFFFF 246}; 247 248enum eMdpPipeType { 249 OV_MDP_PIPE_RGB = 0, 250 OV_MDP_PIPE_VG, 251 OV_MDP_PIPE_DMA, 252 OV_MDP_PIPE_ANY, //Any 253}; 254 255// Identify destination pipes 256// TODO Names useless, replace with int and change all interfaces 257enum eDest { 258 OV_P0 = 0, 259 OV_P1, 260 OV_P2, 261 OV_P3, 262 OV_P4, 263 OV_P5, 264 OV_P6, 265 OV_P7, 266 OV_P8, 267 OV_P9, 268 OV_INVALID, 269 OV_MAX = OV_INVALID, 270}; 271 272/* Used when a buffer is split over 2 pipes and sent to display */ 273enum { 274 OV_LEFT_SPLIT = 0, 275 OV_RIGHT_SPLIT, 276}; 277 278/* values for copybit_set_parameter(OVERLAY_TRANSFORM) */ 279enum eTransform { 280 /* No rot */ 281 OVERLAY_TRANSFORM_0 = 0x0, 282 /* flip source image horizontally 0x1 */ 283 OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H, 284 /* flip source image vertically 0x2 */ 285 OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V, 286 /* rotate source image 180 degrees 287 * It is basically bit-or-ed H | V == 0x3 */ 288 OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180, 289 /* rotate source image 90 degrees 0x4 */ 290 OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90, 291 /* rotate source image 90 degrees and flip horizontally 0x5 */ 292 OVERLAY_TRANSFORM_ROT_90_FLIP_H = HAL_TRANSFORM_ROT_90 | 293 HAL_TRANSFORM_FLIP_H, 294 /* rotate source image 90 degrees and flip vertically 0x6 */ 295 OVERLAY_TRANSFORM_ROT_90_FLIP_V = HAL_TRANSFORM_ROT_90 | 296 HAL_TRANSFORM_FLIP_V, 297 /* rotate source image 270 degrees 298 * Basically 180 | 90 == 0x7 */ 299 OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270, 300 /* rotate invalid like in Transform.h */ 301 OVERLAY_TRANSFORM_INV = 0x80 302}; 303 304enum eBlending { 305 OVERLAY_BLENDING_UNDEFINED = 0x0, 306 /* No blending */ 307 OVERLAY_BLENDING_OPAQUE, 308 /* src.rgb + dst.rgb*(1-src_alpha) */ 309 OVERLAY_BLENDING_PREMULT, 310 /* src.rgb * src_alpha + dst.rgb (1 - src_alpha) */ 311 OVERLAY_BLENDING_COVERAGE, 312}; 313 314// Used to consolidate pipe params 315struct PipeArgs { 316 PipeArgs() : mdpFlags(OV_MDP_FLAGS_NONE), 317 zorder(Z_SYSTEM_ALLOC), 318 rotFlags(ROT_FLAGS_NONE), 319 planeAlpha(DEFAULT_PLANE_ALPHA), 320 blending(OVERLAY_BLENDING_COVERAGE){ 321 } 322 323 PipeArgs(eMdpFlags f, Whf _whf, 324 eZorder z, eRotFlags r, 325 int pA = DEFAULT_PLANE_ALPHA, eBlending b = OVERLAY_BLENDING_COVERAGE) : 326 mdpFlags(f), 327 whf(_whf), 328 zorder(z), 329 rotFlags(r), 330 planeAlpha(pA), 331 blending(b){ 332 } 333 334 eMdpFlags mdpFlags; // for mdp_overlay flags 335 Whf whf; 336 eZorder zorder; // stage number 337 eRotFlags rotFlags; 338 int planeAlpha; 339 eBlending blending; 340}; 341 342// Cannot use HW_OVERLAY_MAGNIFICATION_LIMIT, since at the time 343// of integration, HW_OVERLAY_MAGNIFICATION_LIMIT was a define 344enum { HW_OV_MAGNIFICATION_LIMIT = 20, 345 HW_OV_MINIFICATION_LIMIT = 8 346}; 347 348inline void setMdpFlags(eMdpFlags& f, eMdpFlags v) { 349 f = static_cast<eMdpFlags>(setBit(f, v)); 350} 351 352inline void clearMdpFlags(eMdpFlags& f, eMdpFlags v) { 353 f = static_cast<eMdpFlags>(clrBit(f, v)); 354} 355 356enum { FB0, FB1, FB2 }; 357 358struct ScreenInfo { 359 ScreenInfo() : mFBWidth(0), 360 mFBHeight(0), 361 mFBbpp(0), 362 mFBystride(0) {} 363 void dump(const char* const s) const; 364 uint32_t mFBWidth; 365 uint32_t mFBHeight; 366 uint32_t mFBbpp; 367 uint32_t mFBystride; 368}; 369 370int getMdpFormat(int format); 371int getMdpFormat(int format, int flags); 372int getHALFormat(int mdpFormat); 373void getDecimationFactor(const int& src_w, const int& src_h, 374 const int& dst_w, const int& dst_h, uint8_t& horzDeci, 375 uint8_t& vertDeci); 376 377/* flip is upside down and such. V, H flip 378 * rotation is 90, 180 etc 379 * It returns MDP related enum/define that match rot+flip*/ 380int getMdpOrient(eTransform rotation); 381const char* getFormatString(int format); 382 383template <class T> 384inline void memset0(T& t) { ::memset(&t, 0, sizeof(t)); } 385 386template <class T> inline void swap ( T& a, T& b ) 387{ 388 T c(a); a=b; b=c; 389} 390 391template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } 392 393template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } 394 395inline int alignup(int value, int a) { 396 //if align = 0, return the value. Else, do alignment. 397 return a ? ((((value - 1) / a) + 1) * a) : value; 398} 399 400inline int aligndown(int value, int a) { 401 //if align = 0, return the value. Else, do alignment. 402 return a ? ((value) & ~(a-1)) : value; 403} 404 405// FIXME that align should replace the upper one. 406inline int align(int value, int a) { 407 //if align = 0, return the value. Else, do alignment. 408 return a ? ((value + (a-1)) & ~(a-1)) : value; 409} 410 411inline bool isYuv(uint32_t format) { 412 switch(format){ 413 case MDP_Y_CBCR_H2V1: 414 case MDP_Y_CBCR_H2V2: 415 case MDP_Y_CRCB_H2V2: 416 case MDP_Y_CRCB_H1V1: 417 case MDP_Y_CRCB_H2V1: 418 case MDP_Y_CRCB_H2V2_TILE: 419 case MDP_Y_CBCR_H2V2_TILE: 420 case MDP_Y_CR_CB_H2V2: 421 case MDP_Y_CR_CB_GH2V2: 422 case MDP_Y_CBCR_H2V2_VENUS: 423 case MDP_YCBYCR_H2V1: 424 case MDP_YCRYCB_H2V1: 425 return true; 426 default: 427 return false; 428 } 429 return false; 430} 431 432inline bool isRgb(uint32_t format) { 433 switch(format) { 434 case MDP_RGBA_8888: 435 case MDP_BGRA_8888: 436 case MDP_RGBX_8888: 437 case MDP_RGB_565: 438 case MDP_RGBA_4444: 439 case MDP_RGBA_5551: 440 return true; 441 default: 442 return false; 443 } 444 return false; 445} 446 447inline const char* getFormatString(int format){ 448 #define STR(f) #f; 449 static const char* formats[MDP_IMGTYPE_LIMIT + 1] = {0}; 450 formats[MDP_RGB_565] = STR(MDP_RGB_565); 451 formats[MDP_RGBA_5551] = STR(MDP_RGBA_5551); 452 formats[MDP_RGBA_4444] = STR(MDP_RGBA_4444); 453 formats[MDP_XRGB_8888] = STR(MDP_XRGB_8888); 454 formats[MDP_Y_CBCR_H2V2] = STR(MDP_Y_CBCR_H2V2); 455 formats[MDP_Y_CBCR_H2V2_ADRENO] = STR(MDP_Y_CBCR_H2V2_ADRENO); 456 formats[MDP_ARGB_8888] = STR(MDP_ARGB_8888); 457 formats[MDP_RGB_888] = STR(MDP_RGB_888); 458 formats[MDP_Y_CRCB_H2V2] = STR(MDP_Y_CRCB_H2V2); 459 formats[MDP_YCBYCR_H2V1] = STR(MDP_YCBYCR_H2V1); 460 formats[MDP_YCRYCB_H2V1] = STR(MDP_YCRYCB_H2V1); 461 formats[MDP_CBYCRY_H2V1] = STR(MDP_CBYCRY_H2V1); 462 formats[MDP_Y_CRCB_H2V1] = STR(MDP_Y_CRCB_H2V1); 463 formats[MDP_Y_CBCR_H2V1] = STR(MDP_Y_CBCR_H2V1); 464 formats[MDP_Y_CRCB_H1V2] = STR(MDP_Y_CRCB_H1V2); 465 formats[MDP_Y_CBCR_H1V2] = STR(MDP_Y_CBCR_H1V2); 466 formats[MDP_RGBA_8888] = STR(MDP_RGBA_8888); 467 formats[MDP_BGRA_8888] = STR(MDP_BGRA_8888); 468 formats[MDP_RGBX_8888] = STR(MDP_RGBX_8888); 469 formats[MDP_Y_CRCB_H2V2_TILE] = STR(MDP_Y_CRCB_H2V2_TILE); 470 formats[MDP_Y_CBCR_H2V2_TILE] = STR(MDP_Y_CBCR_H2V2_TILE); 471 formats[MDP_Y_CR_CB_H2V2] = STR(MDP_Y_CR_CB_H2V2); 472 formats[MDP_Y_CR_CB_GH2V2] = STR(MDP_Y_CR_CB_GH2V2); 473 formats[MDP_Y_CB_CR_H2V2] = STR(MDP_Y_CB_CR_H2V2); 474 formats[MDP_Y_CRCB_H1V1] = STR(MDP_Y_CRCB_H1V1); 475 formats[MDP_Y_CBCR_H1V1] = STR(MDP_Y_CBCR_H1V1); 476 formats[MDP_YCRCB_H1V1] = STR(MDP_YCRCB_H1V1); 477 formats[MDP_YCBCR_H1V1] = STR(MDP_YCBCR_H1V1); 478 formats[MDP_BGR_565] = STR(MDP_BGR_565); 479 formats[MDP_BGR_888] = STR(MDP_BGR_888); 480 formats[MDP_Y_CBCR_H2V2_VENUS] = STR(MDP_Y_CBCR_H2V2_VENUS); 481 formats[MDP_BGRX_8888] = STR(MDP_BGRX_8888); 482 formats[MDP_RGBA_8888_TILE] = STR(MDP_RGBA_8888_TILE); 483 formats[MDP_ARGB_8888_TILE] = STR(MDP_ARGB_8888_TILE); 484 formats[MDP_ABGR_8888_TILE] = STR(MDP_ABGR_8888_TILE); 485 formats[MDP_BGRA_8888_TILE] = STR(MDP_BGRA_8888_TILE); 486 formats[MDP_RGBX_8888_TILE] = STR(MDP_RGBX_8888_TILE); 487 formats[MDP_XRGB_8888_TILE] = STR(MDP_XRGB_8888_TILE); 488 formats[MDP_XBGR_8888_TILE] = STR(MDP_XBGR_8888_TILE); 489 formats[MDP_BGRX_8888_TILE] = STR(MDP_BGRX_8888_TILE); 490 formats[MDP_RGB_565_TILE] = STR(MDP_RGB_565_TILE); 491 formats[MDP_IMGTYPE_LIMIT] = STR(MDP_IMGTYPE_LIMIT); 492 493 if(format < 0 || format >= MDP_IMGTYPE_LIMIT) { 494 ALOGE("%s wrong fmt %d", __FUNCTION__, format); 495 return "Unsupported format"; 496 } 497 if(formats[format] == 0) { 498 ALOGE("%s: table missing format %d from header", __FUNCTION__, format); 499 return ""; 500 } 501 return formats[format]; 502} 503 504inline void Whf::dump() const { 505 ALOGE("== Dump WHF w=%d h=%d f=%d s=%d start/end ==", 506 w, h, format, size); 507} 508 509inline void Dim::dump() const { 510 ALOGE("== Dump Dim x=%d y=%d w=%d h=%d start/end ==", x, y, w, h); 511} 512 513template <class Type> 514void swapWidthHeight(Type& width, Type& height) { 515 Type tmp = width; 516 width = height; 517 height = tmp; 518} 519 520inline void ScreenInfo::dump(const char* const s) const { 521 ALOGE("== Dump %s ScreenInfo w=%d h=%d" 522 " bpp=%d stride=%d start/end ==", 523 s, mFBWidth, mFBHeight, mFBbpp, mFBystride); 524} 525 526inline bool openDev(OvFD& fd, int fbnum, 527 const char* const devpath, int flags) { 528 return overlay::open(fd, fbnum, devpath, flags); 529} 530 531template <class T> 532inline void even_ceil(T& value) { 533 if(value & 1) 534 value++; 535} 536 537template <class T> 538inline void even_floor(T& value) { 539 if(value & 1) 540 value--; 541} 542 543/* Prerotation adjusts crop co-ordinates to the new transformed values within 544 * destination buffer. This is necessary only when the entire buffer is rotated 545 * irrespective of crop (A-family). If only the crop portion of the buffer is 546 * rotated into a destination buffer matching the size of crop, we don't need to 547 * use this helper (B-family). 548 * @Deprecated as of now, retained for the case where a full buffer needs 549 * transform and also as a reference. 550 */ 551void preRotateSource(const eTransform& tr, Whf& whf, Dim& srcCrop); 552void getDump(char *buf, size_t len, const char *prefix, const mdp_overlay& ov); 553void getDump(char *buf, size_t len, const char *prefix, const msmfb_img& ov); 554void getDump(char *buf, size_t len, const char *prefix, const mdp_rect& ov); 555void getDump(char *buf, size_t len, const char *prefix, 556 const msmfb_overlay_data& ov); 557void getDump(char *buf, size_t len, const char *prefix, const msmfb_data& ov); 558void getDump(char *buf, size_t len, const char *prefix, 559 const msm_rotator_img_info& ov); 560void getDump(char *buf, size_t len, const char *prefix, 561 const msm_rotator_data_info& ov); 562 563} // namespace utils ends 564 565//--------------------Class Res stuff (namespace overlay only) ----------- 566 567class Res { 568public: 569 // /dev/graphics/fb%u 570 static const char* const fbPath; 571 // /dev/msm_rotator 572 static const char* const rotPath; 573}; 574 575 576//--------------------Class OvFD stuff (namespace overlay only) ----------- 577 578/* 579* Holds one FD 580* Dtor will NOT close the underlying FD. 581* That enables us to copy that object around 582* */ 583class OvFD { 584public: 585 /* Ctor */ 586 explicit OvFD(); 587 588 /* dtor will NOT close the underlying FD */ 589 ~OvFD(); 590 591 /* Open fd using the path given by dev. 592 * return false in failure */ 593 bool open(const char* const dev, 594 int flags = O_RDWR); 595 596 /* populate path */ 597 void setPath(const char* const dev); 598 599 /* Close fd if we have a valid fd. */ 600 bool close(); 601 602 /* returns underlying fd.*/ 603 int getFD() const; 604 605 /* returns true if fd is valid */ 606 bool valid() const; 607 608 /* like operator= */ 609 void copy(int fd); 610 611 /* dump the state of the instance */ 612 void dump() const; 613private: 614 /* helper enum for determine valid/invalid fd */ 615 enum { INVAL = -1 }; 616 617 /* actual os fd */ 618 int mFD; 619 620 /* path, for debugging */ 621 char mPath[utils::MAX_PATH_LEN]; 622}; 623 624//-------------------Inlines-------------------------- 625 626inline bool open(OvFD& fd, uint32_t fbnum, const char* const dev, int flags) 627{ 628 char dev_name[64] = {0}; 629 snprintf(dev_name, sizeof(dev_name), dev, fbnum); 630 return fd.open(dev_name, flags); 631} 632 633inline OvFD::OvFD() : mFD (INVAL) { 634 mPath[0] = 0; 635} 636 637inline OvFD::~OvFD() { 638 //no op since copy() can be used to share fd, in 3d cases. 639} 640 641inline bool OvFD::open(const char* const dev, int flags) 642{ 643 mFD = ::open(dev, flags, 0); 644 if (mFD < 0) { 645 // FIXME errno, strerror in bionic? 646 ALOGE("Cant open device %s err=%d", dev, errno); 647 return false; 648 } 649 setPath(dev); 650 return true; 651} 652 653inline void OvFD::setPath(const char* const dev) 654{ 655 ::strlcpy(mPath, dev, sizeof(mPath)); 656} 657 658inline bool OvFD::close() 659{ 660 int ret = 0; 661 if(valid()) { 662 ret = ::close(mFD); 663 mFD = INVAL; 664 } 665 return (ret == 0); 666} 667 668inline bool OvFD::valid() const 669{ 670 return (mFD != INVAL); 671} 672 673inline int OvFD::getFD() const { return mFD; } 674 675inline void OvFD::copy(int fd) { 676 mFD = fd; 677} 678 679inline void OvFD::dump() const 680{ 681 ALOGE("== Dump OvFD fd=%d path=%s start/end ==", 682 mFD, mPath); 683} 684 685//--------------- class OvFD stuff ends --------------------- 686 687} // overlay 688 689 690#endif // OVERLAY_UTILS_H 691