tizen 2.3.1 releasetizen_2.3.1_releasesubmit/tizen_2.3.1/20150915.082027tizen_2.3.1

5 files changed, 951 insertions, 0 deletions

diff --git a/tizen/DEVICE/CMakeLists.txt b/tizen/DEVICE/CMakeLists.txt
new file mode 100644
index 0000000..6db8080
--- /dev/null
+++ b/tizen/DEVICE/CMakeLists.txt
@@ -0,0 +1,28 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+SET(SRCS
+	src/haptic.c)
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+SET(DEPENDENTS "dlog deviced device-node")
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(rpkgs REQUIRED ${DEPENDENTS})
+
+FOREACH(flag ${rpkgs_CFLAGS})
+    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden")
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -g -fno-omit-frame-pointer")
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,--no-as-needed")
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
+
+ADD_DEFINITIONS("-DPREFIX=\"${PREFIX}\"")
+ADD_DEFINITIONS("-DENABLE_DLOG_OUT -DSLP_DEBUG")
+
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${rpkgs_LDFLAGS})
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${LIB_INSTALL_DIR})
diff --git a/tizen/DEVICE/include/file.h b/tizen/DEVICE/include/file.h
new file mode 100644
index 0000000..798ad5d
--- /dev/null
+++ b/tizen/DEVICE/include/file.h
@@ -0,0 +1,75 @@
+/*
+ * haptic-module-tizen
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __FILE_H__
+#define __FILE_H__
+
+#define GCC_PACK	__attribute__((packed))
+
+/* little-endian form */
+#define mmioHeaderID(ch0,ch1,ch2,ch3)	\
+	((unsigned int)(unsigned char)(ch0) | ((unsigned int)(unsigned char)(ch1) << 8) |	\
+	((unsigned int)(unsigned char)(ch2) << 16) | ((unsigned int)(unsigned char)(ch3) << 24))
+
+#define HEADER_ID		mmioHeaderID('T','H','F','M')		// 0x4D464854
+#define FMT_ID			mmioHeaderID('f','m','t',' ')		// 0x20746D66
+#define DATA_ID			mmioHeaderID('d','a','t','a')		// 0x61746164
+
+typedef unsigned int ID;	/* a four character code */
+
+typedef struct _FormatChunk {
+	ID chunkID;						/* chunk ID */
+	int chunkSize;					/* chunk Size */
+	unsigned short wChannels;		/* number of channels (Mono = 1, Stereo = 2, etc.) */
+	unsigned short wBlockAlign;		/* block size of data (wChannels*1byte) */
+	unsigned int dwMagnitude;		/* max magnitude */
+	unsigned int dwDuration;		/* duration */
+} GCC_PACK FormatChunk;
+
+typedef struct _DataChunk {
+	ID chunkID;
+	int chunkSize;
+	unsigned char pData[];
+} GCC_PACK DataChunk;
+
+typedef struct _HapticFile {
+	ID chunkID;			/* chunk ID */
+	int chunkSize;		/* chunk Size */
+	FormatChunk fmt;	/* Format chunk */
+	DataChunk data;		/* Data chunk */
+} GCC_PACK HapticFile;
+
+typedef struct _HapticElement {
+	int duration;
+	int level;
+} HapticElement;
+
+int GetHapticLevelMax(int *max);
+
+int InitializeBuffer(unsigned char *vibe_buffer, int max_bufsize);
+int InsertElement(unsigned char *vibe_buffer, int max_bufsize, HapticElement *element);
+int GetBufferSize(const unsigned char *vibe_buffer, int *size);
+int GetBufferDuration(const unsigned char *vibe_buffer, int *duration);
+int PlayOneshot(int handle, int duration, int level);
+int PlayBuffer(int handle, const unsigned char *vibe_buffer, int iteration, int level);
+int Stop(int handle);
+int OpenDevice(int handle);
+int CloseDevice(int handle);
+int GetState(int handle, int *state);
+
+#endif // __FIEL_H__
diff --git a/tizen/DEVICE/src/file.c b/tizen/DEVICE/src/file.c
new file mode 100644
index 0000000..1a6ae80
--- /dev/null
+++ b/tizen/DEVICE/src/file.c
@@ -0,0 +1,460 @@
+/*
+ * haptic-module-tizen
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+#include <device-node.h>
+
+#include "file.h"
+#include "haptic_module_log.h"
+
+#define BITPERMS				50
+#define MAX_LEVEL				255.0f
+#define DEFAULT_EFFECT_HANDLE	0x02
+
+#define STATE_PLAY	0
+#define STATE_STOP	1
+
+#define PREDEF_HAPTIC           "haptic"
+
+enum {
+	OPEN = 0,
+	CLOSE,
+	PLAY,
+	ONESHOT,
+	STOP,
+	LEVEL,
+};
+
+typedef struct {
+	int handle;
+	unsigned char **ppbuffer;
+	int channels;
+	int length;
+	int iteration;
+} BUFFER;
+
+static pthread_t tid;
+static BUFFER gbuffer;
+static int stop;
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static int _check_valid_haptic_format(HapticFile *file)
+{
+	if (file->chunkID != HEADER_ID)
+		return -1;
+
+	if (file->fmt.chunkID != FMT_ID)
+		return -1;
+
+	if (file->data.chunkID != DATA_ID)
+		return -1;
+
+	return 0;
+}
+
+static int __haptic_predefine_action(int handle, int prop, int val)
+{
+	char buf_pid[32];
+	char buf_prop[32];
+	char buf_handle[32];
+	char buf_val[32];
+
+	snprintf(buf_pid, sizeof(buf_pid), "%d", getpid());
+	snprintf(buf_prop, sizeof(buf_prop), "%d", prop);
+	snprintf(buf_handle, sizeof(buf_handle), "%d", handle);
+	snprintf(buf_val, sizeof(buf_val), "%d", val);
+
+	MODULE_LOG("pid : %s(%d), prop : %s, handle : %s", buf_pid, pthread_self(), buf_prop, buf_handle);
+	return __haptic_call_predef_action(PREDEF_HAPTIC, 4, buf_pid, buf_prop, buf_handle, buf_val);
+}
+
+static int _create_thread(void* data, void*(*func)(void*))
+{
+	if (tid) {
+		MODULE_ERROR("pthread already created");
+		return -1;
+	}
+
+	if (pthread_create(&tid, NULL, func, data) != 0) {
+		MODULE_ERROR("pthread_create is failed : %s", strerror(errno));
+		return -1;
+	}
+
+	return 0;
+}
+
+static int _cancel_thread(void)
+{
+	int *ptr;
+	int ret;
+
+	if (!tid) {
+		MODULE_LOG("pthread not initialized");
+		return 0;
+	}
+
+	MODULE_LOG("cancel thread!!!");
+
+	stop = 1;
+
+	while (pthread_mutex_trylock(&mutex) == EBUSY) {
+		usleep(100);
+		MODULE_LOG("Already locked..");
+	}
+
+	pthread_mutex_unlock(&mutex);
+
+	if ((ret = pthread_cancel(tid)) < 0) {
+		MODULE_ERROR("pthread_cancel is failed : %s, ret(%d)", strerror(errno), ret);
+		return -1;
+	}
+
+	if (pthread_join(tid, (void**)&ptr) < 0) {
+		MODULE_ERROR("pthread_join is failed : %s", strerror(errno));
+		return -1;
+	}
+
+	stop = 0;
+
+    tid = 0;
+	if (ptr == PTHREAD_CANCELED) {
+		MODULE_LOG("pthread canceled");
+	} else {
+		MODULE_LOG("pthread already finished");
+	}
+
+	return 0;
+}
+
+static void __clean_up(void *arg)
+{
+	BUFFER *pbuffer = (BUFFER*)arg;
+	int i;
+
+	MODULE_LOG("clean up handler!!! : %d", tid);
+
+	for (i = 0; i < pbuffer->channels; ++i) {
+		free(pbuffer->ppbuffer[i]);
+		pbuffer->ppbuffer[i] = NULL;
+	}
+
+	free(pbuffer->ppbuffer);
+	pbuffer->ppbuffer = NULL;
+
+	pbuffer->channels = 0;
+	pbuffer->length = 0;
+
+        if(stop){
+             __haptic_predefine_action(gbuffer.handle, STOP, NULL);
+             pthread_mutex_unlock(&mutex);
+        }
+}
+
+static void* __play_cb(void *arg)
+{
+	BUFFER *pbuffer = (BUFFER*)arg;
+	int i, j, k;
+	unsigned char ch;
+	unsigned char prev = -1;
+
+	MODULE_LOG("Start thread");
+
+	pthread_cleanup_push(__clean_up, arg);
+
+	/* Copy buffer from source buffer */
+	for (i = 0; i < pbuffer->iteration; i++) {
+		for (j = 0; j < pbuffer->length; ++j) {
+			for (k = 0; k < pbuffer->channels; ++k) {
+				pthread_mutex_lock(&mutex);
+				if (stop) {
+					pthread_exit((void*)0);
+				}
+				ch = pbuffer->ppbuffer[k][j];
+				if (ch != prev) {
+					__haptic_predefine_action(pbuffer->handle, LEVEL, ch);
+					prev = ch;
+				}
+				pthread_mutex_unlock(&mutex);
+				usleep(BITPERMS * 1000);
+			}
+		}
+	}
+
+	pthread_mutex_lock(&mutex);
+	__haptic_predefine_action(gbuffer.handle, STOP, NULL);
+	pthread_mutex_unlock(&mutex);
+
+	pthread_cleanup_pop(1);
+	pthread_exit((void *)0);
+}
+
+int GetHapticLevelMax(int *max)
+{
+	int status;
+	status = device_get_property(DEVICE_TYPE_VIBRATOR, PROP_VIBRATOR_LEVEL_MAX, max);
+	if (status < 0) {
+		MODULE_ERROR("device_get_property fail : %d", status);
+		return -1;
+	}
+	return 0;
+}
+
+int InitializeBuffer(unsigned char *vibe_buffer, int max_bufsize)
+{
+	HapticFile *pfile;
+
+	if (max_bufsize < sizeof(HapticFile)) {
+		MODULE_ERROR("buffer lacks a memory : size(%d) minimum size(%d)",
+					max_bufsize, sizeof(HapticFile));
+		return -1;
+	}
+
+	memset(vibe_buffer, 0, sizeof(char)*max_bufsize);
+
+	pfile = (HapticFile*)vibe_buffer;
+
+	pfile->chunkID = HEADER_ID;
+	pfile->chunkSize = sizeof(HapticFile);
+	pfile->fmt.chunkID = FMT_ID;
+	pfile->fmt.chunkSize = sizeof(FormatChunk);
+	pfile->fmt.wChannels = 1;
+	pfile->fmt.wBlockAlign = 1;	// wChannels*1byte
+	pfile->fmt.dwMagnitude = 99;
+	pfile->fmt.dwDuration = 0;
+	pfile->data.chunkID = DATA_ID;
+	pfile->data.chunkSize = sizeof(DataChunk);
+	return 0;
+}
+
+int InsertElement(unsigned char *vibe_buffer, int max_bufsize, HapticElement *element)
+{
+	HapticFile *pfile;
+	int databuf;
+	int needbuf;
+	int duration;
+	unsigned char level;
+	int i;
+
+	pfile = (HapticFile*)vibe_buffer;
+	if (_check_valid_haptic_format(pfile) < 0) {
+		MODULE_ERROR("this buffer is not HapticFormat");
+		return -1;
+	}
+
+	duration = element->duration/BITPERMS;
+	level = (unsigned char)((unsigned int)element->level*MAX_LEVEL/100);
+
+	databuf = max_bufsize - sizeof(HapticFile);
+	needbuf = (pfile->fmt.dwDuration + duration)*pfile->fmt.wBlockAlign;
+	MODULE_LOG("Need buffer size : %d", needbuf);
+
+	if (databuf < needbuf) {
+		MODULE_ERROR("buffer lacks a memory : data buf(%d), need buf(%d)", databuf, needbuf);
+		return -1;
+	}
+
+	for (i = pfile->fmt.dwDuration; i < pfile->fmt.dwDuration+duration; i++) {
+		pfile->data.pData[i] = level;
+	}
+
+	pfile->chunkSize = sizeof(HapticFile)+needbuf ;
+	pfile->fmt.dwDuration = pfile->fmt.dwDuration+duration;
+	pfile->data.chunkSize = sizeof(DataChunk)+needbuf;
+	return 0;
+}
+
+int GetBufferSize(const unsigned char *vibe_buffer, int *size)
+{
+	HapticFile *pfile;
+
+	pfile = (HapticFile*)vibe_buffer;
+	if (_check_valid_haptic_format(pfile) < 0) {
+		MODULE_ERROR("this buffer is not HapticFormat");
+		return -1;
+	}
+
+	*size = pfile->chunkSize;
+	return 0;
+}
+
+int GetBufferDuration(const unsigned char *vibe_buffer, int *duration)
+{
+	HapticFile *pfile;
+
+	pfile = (HapticFile*)vibe_buffer;
+	if (_check_valid_haptic_format(pfile) < 0) {
+		MODULE_ERROR("this buffer is not HapticFormat");
+		return -1;
+	}
+
+	*duration = pfile->fmt.dwDuration;
+	return 0;
+}
+
+int PlayOneshot(int handle, int duration, int level)
+{
+	char buf_pid[32];
+	char buf_prop[32];
+	char buf_handle[32];
+	char buf_duration[32];
+	char buf_level[32];
+
+	if (_cancel_thread() < 0) {
+		MODULE_ERROR("_cancel_thread fail");
+		return -1;
+	}
+
+	snprintf(buf_pid, sizeof(buf_pid), "%d", getpid());
+	snprintf(buf_prop, sizeof(buf_prop), "%d", ONESHOT);
+	snprintf(buf_handle, sizeof(buf_handle), "%d", handle);
+	snprintf(buf_duration, sizeof(buf_duration), "%d", duration);
+	snprintf(buf_level, sizeof(buf_level), "%d", level);
+
+	MODULE_LOG("pid : %s, prop : %s, handle : %s", buf_pid, buf_prop, buf_handle);
+	return __haptic_call_predef_action(PREDEF_HAPTIC, 5, buf_pid, buf_prop,
+										buf_handle, buf_duration, buf_level);
+}
+
+int PlayBuffer(int handle, const unsigned char *vibe_buffer, int iteration, int level)
+{
+	HapticFile *pfile;
+	unsigned char **ppbuffer;
+	unsigned int channels, length, align;
+	unsigned char data;
+	int i, j;
+
+	pfile = (HapticFile*)vibe_buffer;
+	if (_check_valid_haptic_format(pfile) < 0) {
+		MODULE_ERROR("this buffer is not HapticFormat");
+		return -1;
+	}
+
+	/* Temporary code
+	   This code does not support handle and multi channel concept.
+	   Only this code adds to test for playing file. */
+
+	if (_cancel_thread() < 0) {
+		MODULE_ERROR("_cancel_thread fail");
+		return -1;
+	}
+
+	channels = pfile->fmt.wChannels;
+	align = pfile->fmt.wBlockAlign;
+	length = (pfile->data.chunkSize-8)/align;
+	MODULE_LOG("channels : %d, length : %d, align : %d, level : %d", channels, length, align, level);
+
+	/* Create buffer */
+	ppbuffer = (unsigned char**)malloc(sizeof(unsigned char*)*channels);
+	for (i = 0; i < channels; ++i) {
+		ppbuffer[i] = (unsigned char*)malloc(sizeof(unsigned char)*length);
+		memset(ppbuffer[i], 0, sizeof(unsigned char)*length);
+	}
+
+	/* Copy buffer from source buffer */
+	for (i = 0; i < length; ++i) {
+		for (j = 0; j < channels; ++j) {
+			data = (unsigned char)(pfile->data.pData[i*align+j]);
+			ppbuffer[j][i] = (unsigned char)(data*level/0xFF);
+			MODULE_LOG("ppbuffer[%2d][%2d] : data(%x) -> (%x)", j, i, data, ppbuffer[j][i]);
+		}
+	}
+
+	gbuffer.handle = handle;
+	gbuffer.ppbuffer = ppbuffer;
+	gbuffer.channels = channels;
+	gbuffer.length = length;
+	gbuffer.iteration = iteration;
+
+	__haptic_predefine_action(gbuffer.handle, PLAY, NULL);
+
+	/* Start thread */
+	if (_create_thread(&gbuffer, __play_cb) < 0) {
+		MODULE_ERROR("_create_thread fail");
+		return -1;
+	}
+
+	return 0;
+}
+
+int Stop(int handle)
+{
+	char buf_pid[32];
+	char buf_prop[32];
+	char buf_handle[32];
+
+	if (_cancel_thread() < 0) {
+		MODULE_ERROR("_cancel_thread fail");
+		return -1;
+	}
+
+	snprintf(buf_pid, sizeof(buf_pid), "%d", getpid());
+	snprintf(buf_prop, sizeof(buf_prop), "%d", STOP);
+	snprintf(buf_handle, sizeof(buf_handle), "%d", handle);
+
+	MODULE_LOG("pid : %s, prop : %s, handle : %s", buf_pid, buf_prop, buf_handle);
+	return __haptic_call_predef_action(PREDEF_HAPTIC, 3, buf_pid, buf_prop, buf_handle);
+}
+
+int OpenDevice(int handle)
+{
+	char buf_pid[32];
+	char buf_prop[32];
+	char buf_handle[32];
+
+	snprintf(buf_pid, sizeof(buf_pid), "%d", getpid());
+	snprintf(buf_prop, sizeof(buf_prop), "%d", OPEN);
+	snprintf(buf_handle, sizeof(buf_handle), "%d", handle);
+
+	MODULE_LOG("pid : %s, prop : %s, handle : %s", buf_pid, buf_prop, buf_handle);
+	return __haptic_call_predef_action(PREDEF_HAPTIC, 3, buf_pid, buf_prop, buf_handle);
+}
+
+int CloseDevice(int handle)
+{
+	char buf_pid[32];
+	char buf_prop[32];
+	char buf_handle[32];
+
+	if (_cancel_thread() < 0) {
+		MODULE_ERROR("_cancel_thread fail");
+		return -1;
+	}
+
+	snprintf(buf_pid, sizeof(buf_pid), "%d", getpid());
+	snprintf(buf_prop, sizeof(buf_prop), "%d", CLOSE);
+	snprintf(buf_handle, sizeof(buf_handle), "%d", handle);
+
+	MODULE_LOG("pid : %s, prop : %s, handle : %s", buf_pid, buf_prop, buf_handle);
+	return __haptic_call_predef_action(PREDEF_HAPTIC, 3, buf_pid, buf_prop, buf_handle);
+}
+
+int GetState(int handle, int *state)
+{
+	if (gbuffer.handle == handle) {
+		*state = STATE_PLAY;
+		return 0;
+	}
+
+	*state = STATE_STOP;
+	return 0;
+}
diff --git a/tizen/DEVICE/src/haptic.c b/tizen/DEVICE/src/haptic.c
new file mode 100644
index 0000000..34d1ba3
--- /dev/null
+++ b/tizen/DEVICE/src/haptic.c
@@ -0,0 +1,225 @@
+/*
+ * haptic-module-tizen
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <time.h>
+#include <device-node.h>
+
+#include <haptic-plugin-intf.h>
+#include "haptic_module_log.h"
+#include "file.h"
+
+#ifndef EXTAPI
+#define EXTAPI __attribute__ ((visibility("default")))
+#endif
+
+#define DEFAULT_EFFECT_HANDLE	0xFFFF
+#define DEFAULT_MOTOR_COUNT		1
+
+/* START of Static Function Section */
+static int convert_feedback_level(int feedback)
+{
+	static int max = -1;
+	int ret;
+
+	if (max == -1) {
+		ret = device_get_property(DEVICE_TYPE_VIBRATOR,
+				PROP_VIBRATOR_LEVEL_MAX, &max);
+		if (ret < 0)
+			return ret;
+	}
+
+	return feedback * max / HAPTIC_MODULE_FEEDBACK_MAX;
+}
+
+static void *_create_handle(void)
+{
+	static int i = 0;
+	return ((getpid()<<16)|(time(NULL)+(i++)));
+}
+/* END of Static Function Section */
+
+static int _get_device_count(int *count)
+{
+	if (count == NULL)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	*count = DEFAULT_MOTOR_COUNT;
+	return HAPTIC_MODULE_ERROR_NONE;
+}
+
+static int _open_device(int device_index, int *device_handle)
+{
+	int status;
+
+	if (device_index < HAPTIC_MODULE_DEVICE_0 || device_index > HAPTIC_MODULE_DEVICE_ALL)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (device_handle == NULL)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	*device_handle = _create_handle();
+	return HAPTIC_MODULE_ERROR_NONE;
+}
+
+static int _close_device(int device_handle)
+{
+	int status;
+
+	if (device_handle < 0)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	return HAPTIC_MODULE_ERROR_NONE;
+}
+
+static int _vibrate_monotone(int device_handle, int duration, int feedback, int priority, int *effect_handle)
+{
+	int level, ret;
+
+	if (device_handle < 0)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (duration < 0)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (feedback < HAPTIC_MODULE_FEEDBACK_MIN || feedback > HAPTIC_MODULE_FEEDBACK_MAX)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (priority < HAPTIC_MODULE_PRIORITY_MIN || priority > HAPTIC_MODULE_PRIORITY_HIGH)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (effect_handle == NULL)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (feedback == HAPTIC_MODULE_FEEDBACK_MIN)
+		return HAPTIC_MODULE_ERROR_NONE;
+
+	level = convert_feedback_level(feedback);
+	if (level < 0) {
+		MODULE_ERROR("fail to convert haptic level : %d", level);
+		return HAPTIC_MODULE_OPERATION_FAILED;
+	}
+
+	ret = device_set_property(DEVICE_TYPE_VIBRATOR,
+			PROP_VIBRATOR_LEVEL, level);
+	if (ret < 0) {
+		MODULE_ERROR("fail to set haptic level : %d", ret);
+		return HAPTIC_MODULE_OPERATION_FAILED;
+	}
+
+	ret = device_set_property(DEVICE_TYPE_VIBRATOR,
+			PROP_VIBRATOR_ONESHOT, duration);
+	if (ret < 0) {
+		MODULE_ERROR("fail to set oneshot : %d", ret);
+		return HAPTIC_MODULE_OPERATION_FAILED;
+	}
+
+	*effect_handle = DEFAULT_EFFECT_HANDLE;
+	return HAPTIC_MODULE_ERROR_NONE;
+}
+
+static int _vibrate_buffer(int device_handle, const unsigned char *vibe_buffer, int iteration, int feedback, int priority, int *effect_handle)
+{
+	MODULE_ERROR("This device is not supported this function(%s)", __func__);
+	return HAPTIC_MODULE_NOT_SUPPORTED;
+}
+
+static int _stop_device(int device_handle)
+{
+	int ret;
+
+	if (device_handle < 0)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	ret = device_set_property(DEVICE_TYPE_VIBRATOR,
+			PROP_VIBRATOR_ENABLE, 0);
+	if (ret < 0) {
+		MODULE_ERROR("fail to stop haptic device : %d", ret);
+		return HAPTIC_MODULE_OPERATION_FAILED;
+	}
+
+	return HAPTIC_MODULE_ERROR_NONE;
+}
+
+static int _get_device_state(int device_handle, int *state)
+{
+	int ret;
+	int cur_state;
+
+	if (device_handle < 0)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	if (state == NULL)
+		return HAPTIC_MODULE_INVALID_ARGUMENT;
+
+	ret = device_get_property(DEVICE_TYPE_VIBRATOR,
+			PROP_VIBRATOR_ENABLE, &cur_state);
+	if (ret < 0) {
+		MODULE_ERROR("fail to get haptic enble value : %d", ret);
+		return HAPTIC_MODULE_OPERATION_FAILED;
+	}
+
+	*state = (cur_state == 0 ?
+			HAPTIC_MODULE_STATE_STOP : HAPTIC_MODULE_STATE_PLAYING);
+
+	return HAPTIC_MODULE_ERROR_NONE;
+}
+
+static int _create_effect(unsigned char *vibe_buffer, int max_bufsize, haptic_module_effect_element *elem_arr, int max_elemcnt)
+{
+	MODULE_ERROR("This device is not supported this function(%s)", __func__);
+	return HAPTIC_MODULE_NOT_SUPPORTED;
+}
+
+static int _get_buffer_duration(int device_handle, const unsigned char *vibe_buffer, int *buffer_duration)
+{
+	MODULE_ERROR("This device is not supported this function(%s)", __func__);
+	return HAPTIC_MODULE_NOT_SUPPORTED;
+}
+
+static int _convert_binary(void)
+{
+	MODULE_ERROR("This device is not supported this function(%s)", __func__);
+	return HAPTIC_MODULE_NOT_SUPPORTED;
+}
+
+static const struct haptic_plugin_ops haptic_plugin_tizen = {
+	.get_device_count		= _get_device_count,
+	.open_device			= _open_device,
+	.close_device			= _close_device,
+	.vibrate_monotone		= _vibrate_monotone,
+	.vibrate_buffer			= _vibrate_buffer,
+	.stop_device			= _stop_device,
+	.get_device_state		= _get_device_state,
+	.create_effect			= _create_effect,
+	.get_buffer_duration	= _get_buffer_duration,
+	.convert_binary			= _convert_binary,
+};
+
+EXTAPI
+const struct haptic_plugin_ops *get_haptic_plugin_interface(void)
+{
+	return &haptic_plugin_tizen;
+}
diff --git a/tizen/DEVICE/src/sysnoti.c b/tizen/DEVICE/src/sysnoti.c
new file mode 100644
index 0000000..56aaad8
--- /dev/null
+++ b/tizen/DEVICE/src/sysnoti.c
@@ -0,0 +1,163 @@
+/*
+ * haptic-module-tizen
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#include "haptic_module_log.h"
+
+#define HAPTIC_RETRY_READ_COUNT			5
+#define HAPTIC_PARAM_CNT				3
+#define HAPTIC_MAXSTR					100
+#define HAPTIC_MAXARG					16
+#define PREDEF_HAPTIC					"haptic"
+#define SYSNOTI_SOCKET_PATH				"/tmp/sn"
+
+enum sysnoti_cmd {
+	ADD_HAPTIC_ACTION,
+	CALL_HAPTIC_ACTION,
+};
+
+struct sysnoti_type {
+	int pid;
+	int cmd;
+	char *type;
+	char *path;
+	int argc;
+	char *argv[HAPTIC_MAXARG];
+};
+
+static inline int __send_int(int fd, int val)
+{
+	return write(fd, &val, sizeof(int));
+}
+
+static inline int __send_str(int fd, char *str)
+{
+	int len;
+	int r;
+
+	if (str == NULL) {
+		len = 0;
+		r = write(fd, &len, sizeof(int));
+	} else {
+		len = strlen(str);
+		if (len > HAPTIC_MAXSTR)
+			len = HAPTIC_MAXSTR;
+		r = write(fd, &len, sizeof(int));
+		r = write(fd, str, len);
+	}
+
+	return r;
+}
+
+static int __sysnoti_send(struct sysnoti_type *msg)
+{
+	int sockfd;
+	int len;
+	struct sockaddr_un addr;
+	int retry_cnt;
+	int ret;
+	int i;
+	int r;
+
+	sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (sockfd == -1) {
+		MODULE_ERROR("socket create failed");
+		return -1;
+	}
+
+	bzero(&addr, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, SYSNOTI_SOCKET_PATH, sizeof(addr.sun_path) - 1);
+	len = sizeof(addr);
+
+	if (connect(sockfd, (struct sockaddr *)&addr, len) < 0) {
+		MODULE_ERROR("connect failed");
+		close(sockfd);
+		return -1;
+	}
+	MODULE_LOG("connect : %x", sockfd);
+
+	__send_int(sockfd, msg->pid);
+	__send_int(sockfd, msg->cmd);
+	__send_str(sockfd, msg->type);
+	__send_str(sockfd, msg->path);
+	__send_int(sockfd, msg->argc);
+	for (i = 0; i < msg->argc; i++)
+		__send_str(sockfd, msg->argv[i]);
+
+	MODULE_LOG("read");
+	retry_cnt = 0;
+	while ((r = read(sockfd, &ret, sizeof(int))) < 0) {
+
+		if (errno != EINTR) {
+			MODULE_LOG("read fail : %s(%d)", strerror(errno), errno);
+			ret = -1;
+			break;
+		}
+
+		if (retry_cnt == HAPTIC_RETRY_READ_COUNT) {
+			MODULE_ERROR("retry(%d) fail", retry_cnt);
+			ret = -1;
+			break;
+		}
+
+		MODULE_ERROR("Re-read for error(EINTR)");
+		++retry_cnt;
+	}
+
+	MODULE_LOG("close (ret : %d) : %x", ret, sockfd);
+	close(sockfd);
+	return ret;
+}
+
+int __haptic_call_predef_action(const char *type, int num, ...)
+{
+	struct sysnoti_type msg;
+	char *args;
+	va_list argptr;
+	int i;
+
+	if (type == NULL || num > HAPTIC_MAXARG) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	msg.pid = getpid();
+	msg.cmd = CALL_HAPTIC_ACTION;
+	msg.type = (char *)type;
+	msg.path = NULL;
+	msg.argc = num;
+
+	va_start(argptr, num);
+	for (i = 0; i < num; i++) {
+		args = va_arg(argptr, char *);
+		msg.argv[i] = args;
+	}
+	va_end(argptr);
+
+	return __sysnoti_send(&msg);
+}
+