From: SooChan Lim Date: Mon, 21 Nov 2016 04:49:26 +0000 (+0900) Subject: change the slp_global_lock to the tgl X-Git-Tag: accepted/tizen/3.0/mobile/20161124.024819~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c0aa72545a4e3cab567478909dfd0d209e66e373;p=platform%2Fadaptation%2Fspreadtrum%2Flibtbm-sprd.git change the slp_global_lock to the tgl We do not use slp_global_lock device anymore on tm1 target. We use tgl device instead and the use space interface is changed because of this change. This is only for the tm1 target. p.s. When the kernel version is up and kernel can use the dma_fence, libtbm-sprd does not use the tgl for the bo lock and for the bo cache_flush anymore. Change-Id: I4631a5f600bfaea47d8618036f40b17885c45493 --- diff --git a/rules/99-libtbm_sprd.rules b/rules/99-libtbm_sprd.rules index b00652e..13cef12 100644 --- a/rules/99-libtbm_sprd.rules +++ b/rules/99-libtbm_sprd.rules @@ -1 +1 @@ -KERNEL=="slp_global_lock*", MODE="0666", GROUP="display", SECLABEL{smack}="*" +KERNEL=="tgl", MODE="0666", GROUP="display", SECLABEL{smack}="*" diff --git a/src/tbm_bufmgr_sprd.c b/src/tbm_bufmgr_sprd.c index 1b30142..1db8ac5 100644 --- a/src/tbm_bufmgr_sprd.c +++ b/src/tbm_bufmgr_sprd.c @@ -59,6 +59,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "tbm_bufmgr_tgl.h" //#define USE_CONTIG_ONLY +//#define USE_CACHE #define USE_DMAIMPORT #define TBM_COLOR_FORMAT_COUNT 4 @@ -246,25 +247,45 @@ char *STR_OPT[] = { uint32_t tbm_sprd_color_format_list[TBM_COLOR_FORMAT_COUNT] = { - TBM_FORMAT_ARGB8888, - TBM_FORMAT_XRGB8888, - TBM_FORMAT_NV12, - TBM_FORMAT_YUV420 - }; + TBM_FORMAT_ARGB8888, + TBM_FORMAT_XRGB8888, + TBM_FORMAT_NV12, + TBM_FORMAT_YUV420 + }; + +static inline int +_tgl_get_version(int fd) +{ + struct tgl_ver_data data; + int err; + + err = ioctl(fd, TGL_IOCTL_GET_VERSION, &data); + if (err) { + TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d\n", + getpid(), strerror(errno), __func__, __LINE__); + return 0; + } + + TBM_SPRD_LOG("[libtbm-sprd:%d] %s:%d tgl version is (%u, %u).\n", + getpid(), __func__, __LINE__, data.major, data.minor); + + return 1; +} + static inline int _tgl_init(int fd, unsigned int key) { - struct tgl_attribute attr; + struct tgl_reg_data data; int err; - attr.key = key; - attr.timeout_ms = 1000; + data.key = key; + data.timeout_ms = 1000; - err = ioctl(fd, TGL_IOC_INIT_LOCK, &attr); + err = ioctl(fd, TGL_IOCTL_REGISTER, &data); if (err) { TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d key:%d\n", - getpid(), strerror(errno), __func__, __LINE__, key); + getpid(), strerror(errno), __func__, __LINE__, key); return 0; } @@ -274,13 +295,14 @@ _tgl_init(int fd, unsigned int key) static inline int _tgl_destroy(int fd, unsigned int key) { + struct tgl_reg_data data; int err; - err = ioctl(fd, TGL_IOC_DESTROY_LOCK, key); + data.key = key; + err = ioctl(fd, TGL_IOCTL_UNREGISTER, &data); if (err) { - TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error(%s) %s:%d key:%d\n", - getpid(), strerror(errno), __func__, __LINE__, key); + TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d key:%d\n", + getpid(), strerror(errno), __func__, __LINE__, key); return 0; } @@ -288,15 +310,31 @@ _tgl_destroy(int fd, unsigned int key) } static inline int -_tgl_lock(int fd, unsigned int key) +_tgl_lock(int fd, unsigned int key, int opt) { + struct tgl_lock_data data; + enum tgl_type_data tgl_type; int err; - err = ioctl(fd, TGL_IOC_LOCK_LOCK, key); + switch (opt) { + case TBM_OPTION_READ: + tgl_type = TGL_TYPE_READ; + break; + case TBM_OPTION_WRITE: + tgl_type = TGL_TYPE_WRITE; + break; + default: + tgl_type = TGL_TYPE_NONE; + break; + } + + data.key = key; + data.type = tgl_type; + + err = ioctl(fd, TGL_IOCTL_LOCK, data); if (err) { - TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error(%s) %s:%d key:%d\n", - getpid(), strerror(errno), __func__, __LINE__, key); + TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d key:%d opt:%d\n", + getpid(), strerror(errno), __func__, __LINE__, key, opt); return 0; } @@ -306,13 +344,16 @@ _tgl_lock(int fd, unsigned int key) static inline int _tgl_unlock(int fd, unsigned int key) { + struct tgl_lock_data data; int err; - err = ioctl(fd, TGL_IOC_UNLOCK_LOCK, key); + data.key = key; + data.type = TGL_TYPE_NONE; + + err = ioctl(fd, TGL_IOCTL_UNLOCK, data); if (err) { - TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error(%s) %s:%d key:%d\n", - getpid(), strerror(errno), __func__, __LINE__, key); + TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d key:%d\n", + getpid(), strerror(errno), __func__, __LINE__, key); return 0; } @@ -323,16 +364,16 @@ _tgl_unlock(int fd, unsigned int key) static inline int _tgl_set_data(int fd, unsigned int key, unsigned int val) { + struct tgl_usr_data data; int err; - struct tgl_user_data arg; - arg.key = key; - arg.data1 = val; - err = ioctl(fd, TGL_IOC_SET_DATA, &arg); + data.key = key; + data.data1 = val; + + err = ioctl(fd, TGL_IOCTL_SET_DATA, &data); if (err) { - TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error(%s) %s:%d key:%d\n", - getpid(), strerror(errno), __func__, __LINE__, key); + TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d key:%d\n", + getpid(), strerror(errno), __func__, __LINE__, key); return 0; } @@ -342,22 +383,22 @@ _tgl_set_data(int fd, unsigned int key, unsigned int val) static inline unsigned int _tgl_get_data(int fd, unsigned int key, unsigned int *locked) { + struct tgl_usr_data data = { 0, }; int err; - struct tgl_user_data arg = { 0, }; - arg.key = key; - err = ioctl(fd, TGL_IOC_GET_DATA, &arg); + data.key = key; + + err = ioctl(fd, TGL_IOCTL_GET_DATA, &data); if (err) { - TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error(%s) %s:%d key:%d\n", - getpid(), strerror(errno), __func__, __LINE__, key); + TBM_SPRD_LOG("[libtbm-sprd:%d] error(%s) %s:%d key:%d\n", + getpid(), strerror(errno), __func__, __LINE__, key); return 0; } if (locked) - *locked = arg.locked; + *locked = (unsigned int)data.status; - return arg.data1; + return data.data1; } #endif @@ -457,7 +498,9 @@ _sprd_bo_cache_flush(tbm_bufmgr_sprd bufmgr_sprd, tbm_bo_sprd bo_sprd, int flags /* cache flush is managed by kernel side when using dma-fence. */ if (bufmgr_sprd->use_dma_fence) return 1; - +// TODO: The tm1 kernel does not support ioctl for cache flush right now. +// The drm in tm1 kernel has to support cache_flush to turn on this feature(TBM_SRPD_CACHE_FLUSH). +#if TBM_SRPD_CACHE_FLUSH struct drm_sprd_gem_cache_op cache_op = {0, }; int ret; @@ -498,7 +541,7 @@ _sprd_bo_cache_flush(tbm_bufmgr_sprd bufmgr_sprd, tbm_bo_sprd bo_sprd, int flags getpid(), __FUNCTION__, __LINE__); return 0; } - +#endif return 1; } #endif @@ -641,22 +684,26 @@ _bufmgr_init_cache_state(tbm_bufmgr_sprd bufmgr_sprd) /* open tgl fd for saving cache flush data */ bufmgr_sprd->tgl_fd = open(tgl_devfile, O_RDWR); - if (bufmgr_sprd->tgl_fd < 0) { - bufmgr_sprd->tgl_fd = open(tgl_devfile1, O_RDWR); - if (bufmgr_sprd->tgl_fd < 0) { - TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error: Fail to open global_lock:%s\n", - getpid(), tgl_devfile); - return 0; - } + TBM_SPRD_LOG("[libtbm-sprd:%d] error: Fail to open global_lock:%s\n", + getpid(), tgl_devfile); + return 0; + } + + if (!_tgl_get_version(bufmgr_sprd->tgl_fd)) { + TBM_SPRD_LOG("[libtbm-sprd:%d] " + "error: fail to get tgl_version. tgl init failed.\n", + getpid()); + + close(bufmgr_sprd->tgl_fd); + return 0; } #ifdef USE_CACHE if (!_tgl_init(bufmgr_sprd->tgl_fd, GLOBAL_KEY)) { TBM_SPRD_LOG("[libtbm-sprd:%d] " - "error: Fail to initialize the tgl\n", - getpid()); + "error: Fail to initialize the tgl\n", + getpid()); close(bufmgr_sprd->tgl_fd); return 0; @@ -1474,7 +1521,7 @@ tbm_sprd_bo_lock(tbm_bo bo, int device, int opt) getpid(), __FUNCTION__, bo_sprd->name, bo_sprd->dmabuf); } else { - ret = _tgl_lock(bufmgr_sprd->tgl_fd, bo_sprd->name); + ret = _tgl_lock(bufmgr_sprd->tgl_fd, bo_sprd->name, opt); DBG("[libtbm-sprd:%d] lock tgl flink_id:%d\n", getpid(), __FUNCTION__, bo_sprd->name); diff --git a/src/tbm_bufmgr_tgl.h b/src/tbm_bufmgr_tgl.h index 2279cac..1790885 100644 --- a/src/tbm_bufmgr_tgl.h +++ b/src/tbm_bufmgr_tgl.h @@ -34,37 +34,92 @@ #include -static char tgl_devfile[] = "/dev/slp_global_lock"; -static char tgl_devfile1[] = "/dev/tgl"; +static char tgl_devfile[] = "/dev/tgl"; -#define TGL_IOC_BASE 0x32 +#define TGL_IOCTL_BASE 0x32 +#define TGL_IO(nr) _IO(TGL_IOCTL_BASE, nr) +#define TGL_IOR(nr, type) _IOR(TGL_IOCTL_BASE, nr, type) +#define TGL_IOW(nr, type) _IOW(TGL_IOCTL_BASE, nr, type) +#define TGL_IOWR(nr, type) _IOWR(TGL_IOCTL_BASE, nr, type) -struct tgl_attribute { +/** + * struct tgl_ver_data - tgl version data structure + * @major: major version + * @minor: minor version + */ +struct tgl_ver_data { + unsigned int major; + unsigned int minor; +}; + +/** + * struct tgl_reg_data - tgl data structure + * @key: lookup key + * @timeout_ms: timeout value for waiting event + */ +struct tgl_reg_data { unsigned int key; unsigned int timeout_ms; }; -struct tgl_user_data { +enum tgl_type_data { + TGL_TYPE_NONE = 0, + TGL_TYPE_READ = (1 << 0), + TGL_TYPE_WRITE = (1 << 1), +}; + +/** + * struct tgl_lock_data - tgl lock data structure + * @key: lookup key + * @type: lock type that is in tgl_type_data + */ +struct tgl_lock_data { + unsigned int key; + enum tgl_type_data type; +}; + +enum tgl_status_data { + TGL_STATUS_UNLOCKED, + TGL_STATUS_LOCKED, +}; + +/** + * struct tgl_usr_data - tgl user data structure + * @key: lookup key + * @data1: user data 1 + * @data2: user data 2 + * @status: lock status that is in tgl_status_data + */ +struct tgl_usr_data { unsigned int key; unsigned int data1; unsigned int data2; - unsigned int locked; + enum tgl_status_data status; }; -typedef enum { - _TGL_INIT_LOCK = 1, - _TGL_DESTROY_LOCK, - _TGL_LOCK_LOCK, - _TGL_UNLOCK_LOCK, +enum { + _TGL_GET_VERSION, + _TGL_REGISTER, + _TGL_UNREGISTER, + _TGL_LOCK, + _TGL_UNLOCK, _TGL_SET_DATA, _TGL_GET_DATA, -} _tgl_ioctls; +}; -#define TGL_IOC_INIT_LOCK _IOW(TGL_IOC_BASE, _TGL_INIT_LOCK, struct tgl_attribute *) -#define TGL_IOC_DESTROY_LOCK _IOW(TGL_IOC_BASE, _TGL_DESTROY_LOCK, unsigned int) -#define TGL_IOC_LOCK_LOCK _IOW(TGL_IOC_BASE, _TGL_LOCK_LOCK, unsigned int) -#define TGL_IOC_UNLOCK_LOCK _IOW(TGL_IOC_BASE, _TGL_UNLOCK_LOCK, unsigned int) -#define TGL_IOC_SET_DATA _IOW(TGL_IOC_BASE, _TGL_SET_DATA, struct tgl_user_data *) -#define TGL_IOC_GET_DATA _IOW(TGL_IOC_BASE, _TGL_GET_DATA, struct tgl_user_data *) +/* get version information */ +#define TGL_IOCTL_GET_VERSION TGL_IOR(_TGL_GET_VERSION, struct tgl_ver_data) +/* register key */ +#define TGL_IOCTL_REGISTER TGL_IOW(_TGL_REGISTER, struct tgl_reg_data) +/* unregister key */ +#define TGL_IOCTL_UNREGISTER TGL_IOW(_TGL_UNREGISTER, struct tgl_reg_data) +/* lock with key */ +#define TGL_IOCTL_LOCK TGL_IOW(_TGL_LOCK, struct tgl_lock_data) +/* unlock with key */ +#define TGL_IOCTL_UNLOCK TGL_IOW(_TGL_UNLOCK, struct tgl_lock_data) +/* set user data with key */ +#define TGL_IOCTL_SET_DATA TGL_IOW(_TGL_SET_DATA, struct tgl_usr_data) +/* get user data with key */ +#define TGL_IOCTL_GET_DATA TGL_IOR(_TGL_GET_DATA, struct tgl_usr_data) -#endif /* __TBM_BUFMGR_TGL_H__ */ +#endif /* __TBM_BUFMGR_TGL_H__ */