CONFIG_RFKILL=y
CONFIG_RFKILL_LEDS=y
CONFIG_RFKILL_INPUT=y
+# CONFIG_RFKILL_GPIO is not set
CONFIG_NET_9P=y
CONFIG_NET_9P_VIRTIO=y
# CONFIG_NET_9P_DEBUG is not set
#
# Texas Instruments shared transport line discipline
#
+# CONFIG_TI_ST is not set
# CONFIG_SENSORS_LIS3_I2C is not set
#
# CONFIG_KEYBOARD_QT1070 is not set
# CONFIG_KEYBOARD_QT2160 is not set
# CONFIG_KEYBOARD_LKKBD is not set
+# CONFIG_KEYBOARD_GPIO is not set
+# CONFIG_KEYBOARD_GPIO_POLLED is not set
# CONFIG_KEYBOARD_TCA6416 is not set
# CONFIG_KEYBOARD_TCA8418 is not set
+# CONFIG_KEYBOARD_MATRIX is not set
# CONFIG_KEYBOARD_LM8323 is not set
# CONFIG_KEYBOARD_LM8333 is not set
# CONFIG_KEYBOARD_MAX7359 is not set
# CONFIG_MOUSE_CYAPA is not set
# CONFIG_MOUSE_ELAN_I2C is not set
# CONFIG_MOUSE_VSXXXAA is not set
+# CONFIG_MOUSE_GPIO is not set
# CONFIG_MOUSE_SYNAPTICS_I2C is not set
# CONFIG_MOUSE_SYNAPTICS_USB is not set
CONFIG_INPUT_JOYSTICK=y
CONFIG_TOUCHSCREEN_PROPERTIES=y
# CONFIG_TOUCHSCREEN_AD7879 is not set
# CONFIG_TOUCHSCREEN_ATMEL_MXT is not set
+# CONFIG_TOUCHSCREEN_AUO_PIXCIR is not set
# CONFIG_TOUCHSCREEN_BU21013 is not set
+# CONFIG_TOUCHSCREEN_CY8CTMG110 is not set
# CONFIG_TOUCHSCREEN_CYTTSP_CORE is not set
# CONFIG_TOUCHSCREEN_CYTTSP4_CORE is not set
# CONFIG_TOUCHSCREEN_DYNAPRO is not set
# CONFIG_TOUCHSCREEN_HAMPSHIRE is not set
# CONFIG_TOUCHSCREEN_EETI is not set
+# CONFIG_TOUCHSCREEN_FT6236 is not set
# CONFIG_TOUCHSCREEN_FUJITSU is not set
# CONFIG_TOUCHSCREEN_GOODIX is not set
# CONFIG_TOUCHSCREEN_ILI210X is not set
# CONFIG_TOUCHSCREEN_ST1232 is not set
# CONFIG_TOUCHSCREEN_SX8654 is not set
# CONFIG_TOUCHSCREEN_TPS6507X is not set
+# CONFIG_TOUCHSCREEN_ZFORCE is not set
# CONFIG_TOUCHSCREEN_ROHM_BU21023 is not set
CONFIG_INPUT_MISC=y
# CONFIG_INPUT_AD714X is not set
# CONFIG_INPUT_MMA8450 is not set
# CONFIG_INPUT_MPU3050 is not set
# CONFIG_INPUT_APANEL is not set
+# CONFIG_INPUT_GP2A is not set
+# CONFIG_INPUT_GPIO_BEEPER is not set
+# CONFIG_INPUT_GPIO_TILT_POLLED is not set
# CONFIG_INPUT_WISTRON_BTNS is not set
# CONFIG_INPUT_ATLAS_BTNS is not set
# CONFIG_INPUT_ATI_REMOTE2 is not set
# CONFIG_INPUT_CM109 is not set
CONFIG_INPUT_UINPUT=y
# CONFIG_INPUT_PCF8574 is not set
+# CONFIG_INPUT_GPIO_ROTARY_ENCODER is not set
# CONFIG_INPUT_ADXL34X is not set
# CONFIG_INPUT_IMS_PCU is not set
# CONFIG_INPUT_CMA3000 is not set
# CONFIG_INPUT_IDEAPAD_SLIDEBAR is not set
+# CONFIG_INPUT_DRV260X_HAPTICS is not set
# CONFIG_INPUT_DRV2665_HAPTICS is not set
# CONFIG_INPUT_DRV2667_HAPTICS is not set
#
# Multiplexer I2C Chip support
#
+# CONFIG_I2C_MUX_GPIO is not set
# CONFIG_I2C_MUX_PCA9541 is not set
+# CONFIG_I2C_MUX_PCA954x is not set
# CONFIG_I2C_MUX_REG is not set
CONFIG_I2C_HELPER_AUTO=y
CONFIG_I2C_ALGOBIT=y
#
# I2C system bus drivers (mostly embedded / system-on-chip)
#
+# CONFIG_I2C_CBUS_GPIO is not set
# CONFIG_I2C_DESIGNWARE_PCI is not set
# CONFIG_I2C_EG20T is not set
+# CONFIG_I2C_GPIO is not set
# CONFIG_I2C_OCORES is not set
# CONFIG_I2C_PCA_PLATFORM is not set
# CONFIG_I2C_PXA_PCI is not set
#
# CONFIG_PTP_1588_CLOCK_PCH is not set
CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y
-# CONFIG_GPIOLIB is not set
+CONFIG_GPIOLIB=y
+CONFIG_GPIO_DEVRES=y
+CONFIG_GPIO_ACPI=y
+# CONFIG_DEBUG_GPIO is not set
+# CONFIG_GPIO_SYSFS is not set
+
+#
+# Memory mapped GPIO drivers
+#
+# CONFIG_GPIO_AMDPT is not set
+# CONFIG_GPIO_DWAPB is not set
+# CONFIG_GPIO_GENERIC_PLATFORM is not set
+# CONFIG_GPIO_ICH is not set
+# CONFIG_GPIO_LYNXPOINT is not set
+# CONFIG_GPIO_VX855 is not set
+# CONFIG_GPIO_ZX is not set
+
+#
+# Port-mapped I/O GPIO drivers
+#
+# CONFIG_GPIO_104_IDIO_16 is not set
+# CONFIG_GPIO_F7188X is not set
+# CONFIG_GPIO_IT87 is not set
+# CONFIG_GPIO_SCH is not set
+# CONFIG_GPIO_SCH311X is not set
+
+#
+# I2C GPIO expanders
+#
+# CONFIG_GPIO_ADP5588 is not set
+# CONFIG_GPIO_MAX7300 is not set
+# CONFIG_GPIO_MAX732X is not set
+# CONFIG_GPIO_PCA953X is not set
+# CONFIG_GPIO_PCF857X is not set
+# CONFIG_GPIO_SX150X is not set
+
+#
+# MFD GPIO expanders
+#
+
+#
+# PCI GPIO expanders
+#
+# CONFIG_GPIO_AMD8111 is not set
+# CONFIG_GPIO_BT8XX is not set
+# CONFIG_GPIO_INTEL_MID is not set
+# CONFIG_GPIO_ML_IOH is not set
+# CONFIG_GPIO_PCH is not set
+# CONFIG_GPIO_RDC321X is not set
+
+#
+# SPI or I2C GPIO expanders
+#
+# CONFIG_GPIO_MCP23S08 is not set
+
+#
+# USB GPIO expanders
+#
# CONFIG_W1 is not set
# CONFIG_POWER_SUPPLY is not set
-# CONFIG_POWER_SUPPLY_DEBUG is not set
-# CONFIG_PDA_POWER is not set
-# CONFIG_TEST_POWER is not set
-# CONFIG_BATTERY_DS2780 is not set
-# CONFIG_BATTERY_DS2781 is not set
-# CONFIG_BATTERY_DS2782 is not set
-# CONFIG_BATTERY_SBS is not set
-# CONFIG_BATTERY_BQ27XXX is not set
-# CONFIG_BATTERY_MAX17040 is not set
-# CONFIG_BATTERY_MAX17042 is not set
-# CONFIG_CHARGER_MAX8903 is not set
-# CONFIG_CHARGER_LP8727 is not set
-# CONFIG_CHARGER_BQ2415X is not set
-# CONFIG_CHARGER_SMB347 is not set
-# CONFIG_BATTERY_GAUGE_LTC2941 is not set
-# CONFIG_POWER_RESET is not set
# CONFIG_POWER_AVS is not set
CONFIG_HWMON=y
# CONFIG_HWMON_VID is not set
# CONFIG_SENSORS_GL520SM is not set
# CONFIG_SENSORS_G760A is not set
# CONFIG_SENSORS_G762 is not set
+# CONFIG_SENSORS_GPIO_FAN is not set
# CONFIG_SENSORS_HIH6130 is not set
# CONFIG_SENSORS_I5500 is not set
# CONFIG_SENSORS_CORETEMP is not set
# CONFIG_SENSORS_NCT7904 is not set
# CONFIG_SENSORS_PCF8591 is not set
# CONFIG_PMBUS is not set
+# CONFIG_SENSORS_SHT15 is not set
# CONFIG_SENSORS_SHT21 is not set
# CONFIG_SENSORS_SHTC1 is not set
# CONFIG_SENSORS_SIS5595 is not set
# CONFIG_MACHZ_WDT is not set
# CONFIG_SBC_EPX_C3_WATCHDOG is not set
# CONFIG_BCM7038_WDT is not set
+# CONFIG_MEN_A21_WDT is not set
#
# PCI-based Watchdog Cards
# CONFIG_MFD_CS5535 is not set
# CONFIG_MFD_AS3711 is not set
# CONFIG_PMIC_ADP5520 is not set
+# CONFIG_MFD_AAT2870_CORE is not set
# CONFIG_MFD_BCM590XX is not set
# CONFIG_MFD_AXP20X is not set
# CONFIG_MFD_CROS_EC is not set
# CONFIG_MFD_DLN2 is not set
# CONFIG_MFD_MC13XXX_I2C is not set
# CONFIG_HTC_PASIC3 is not set
+# CONFIG_HTC_I2CPLD is not set
# CONFIG_LPC_ICH is not set
# CONFIG_LPC_SCH is not set
+# CONFIG_INTEL_SOC_PMIC is not set
# CONFIG_MFD_INTEL_LPSS_ACPI is not set
# CONFIG_MFD_INTEL_LPSS_PCI is not set
# CONFIG_MFD_JANZ_CMODIO is not set
# CONFIG_MFD_VIPERBOARD is not set
# CONFIG_MFD_RETU is not set
# CONFIG_MFD_PCF50633 is not set
+# CONFIG_UCB1400_CORE is not set
# CONFIG_MFD_RDC321X is not set
# CONFIG_MFD_RTSX_PCI is not set
# CONFIG_MFD_RT5033 is not set
# CONFIG_MFD_LP8788 is not set
# CONFIG_MFD_PALMAS is not set
# CONFIG_TPS6105X is not set
+# CONFIG_TPS65010 is not set
# CONFIG_TPS6507X is not set
# CONFIG_MFD_TPS65090 is not set
# CONFIG_MFD_TPS65217 is not set
# CONFIG_MFD_TPS65218 is not set
# CONFIG_MFD_TPS6586X is not set
+# CONFIG_MFD_TPS65910 is not set
+# CONFIG_MFD_TPS65912 is not set
+# CONFIG_MFD_TPS65912_I2C is not set
# CONFIG_MFD_TPS80031 is not set
# CONFIG_TWL4030_CORE is not set
# CONFIG_TWL6040_CORE is not set
# CONFIG_MFD_WL1273_CORE is not set
# CONFIG_MFD_LM3533 is not set
+# CONFIG_MFD_TIMBERDALE is not set
# CONFIG_MFD_TMIO is not set
# CONFIG_MFD_VX855 is not set
# CONFIG_MFD_ARIZONA_I2C is not set
# CONFIG_FB_S3 is not set
# CONFIG_FB_SAVAGE is not set
# CONFIG_FB_SIS is not set
+# CONFIG_FB_VIA is not set
# CONFIG_FB_NEOMAGIC is not set
# CONFIG_FB_KYRO is not set
# CONFIG_FB_3DFX is not set
# CONFIG_BACKLIGHT_ADP8860 is not set
# CONFIG_BACKLIGHT_ADP8870 is not set
# CONFIG_BACKLIGHT_LM3639 is not set
+# CONFIG_BACKLIGHT_GPIO is not set
# CONFIG_BACKLIGHT_LV5207LP is not set
# CONFIG_BACKLIGHT_BD6107 is not set
# CONFIG_VGASTATE is not set
# CONFIG_HID_CHICONY is not set
# CONFIG_HID_CORSAIR is not set
# CONFIG_HID_PRODIKEYS is not set
+# CONFIG_HID_CP2112 is not set
# CONFIG_HID_CYPRESS is not set
# CONFIG_HID_DRAGONRISE is not set
# CONFIG_HID_EMS_FF is not set
#
# CONFIG_USB_PHY is not set
# CONFIG_NOP_USB_XCEIV is not set
+# CONFIG_USB_GPIO_VBUS is not set
# CONFIG_USB_ISP1301 is not set
# CONFIG_USB_GADGET is not set
# CONFIG_USB_LED_TRIG is not set
# CONFIG_LEDS_LM3530 is not set
# CONFIG_LEDS_LM3642 is not set
# CONFIG_LEDS_PCA9532 is not set
+# CONFIG_LEDS_GPIO is not set
# CONFIG_LEDS_LP3944 is not set
# CONFIG_LEDS_LP5521 is not set
# CONFIG_LEDS_LP5523 is not set
# CONFIG_LEDS_PCA963X is not set
# CONFIG_LEDS_BD2802 is not set
# CONFIG_LEDS_INTEL_SS4200 is not set
+# CONFIG_LEDS_LT3593 is not set
# CONFIG_LEDS_TCA6507 is not set
# CONFIG_LEDS_TLC591XX is not set
# CONFIG_LEDS_LM355x is not set
# CONFIG_LEDS_TRIGGER_HEARTBEAT is not set
# CONFIG_LEDS_TRIGGER_BACKLIGHT is not set
# CONFIG_LEDS_TRIGGER_CPU is not set
+# CONFIG_LEDS_TRIGGER_GPIO is not set
# CONFIG_LEDS_TRIGGER_DEFAULT_ON is not set
#
# CONFIG_ASHMEM is not set
CONFIG_ANDROID_LOGGER=y
CONFIG_ANDROID_TIMED_OUTPUT=y
+# CONFIG_ANDROID_TIMED_GPIO is not set
# CONFIG_ANDROID_LOW_MEMORY_KILLER is not set
CONFIG_ANDROID_INTF_ALARM_DEV=y
# CONFIG_SYNC is not set
# CONFIG_HP_WIRELESS is not set
# CONFIG_MSI_LAPTOP is not set
# CONFIG_PANASONIC_LAPTOP is not set
-# CONFIG_COMPAL_LAPTOP is not set
# CONFIG_SONY_LAPTOP is not set
# CONFIG_IDEAPAD_LAPTOP is not set
# CONFIG_THINKPAD_ACPI is not set
CONFIG_MARU_BRILLCODEC=y
CONFIG_MARU_VIRTIO_VMODEM=y
CONFIG_MARU_VIRTIO_ROTARY=y
-CONFIG_MARU_EEPROM=y
-CONFIG_MARU_MICOM_MSG=y
-CONFIG_MARU_MICOM_ISP=y
-CONFIG_MARU_DUMMY=y
-CONFIG_MARU_SECURITY=y
-CONFIG_MARU_SDP_MEM=y
-CONFIG_MARU_GPIO=y
-CONFIG_MARU_I2C_SDP=y
+CONFIG_MARU_TV=y
+CONFIG_MARU_TV_EEPROM=y
+CONFIG_MARU_TV_DUMMY=y
+CONFIG_MARU_TV_MICOM_MSG=y
+CONFIG_MARU_TV_MICOM_ISP=y
+CONFIG_MARU_TV_SECURITY=y
+CONFIG_MARU_TV_SDP_MEM=y
+CONFIG_MARU_TV_GPIO=y
+CONFIG_MARU_TV_I2C_SDP=y
# CONFIG_MARU_EXTENSION_SOURCE is not set
#
# CONFIG_RING_BUFFER_BENCHMARK is not set
# CONFIG_RING_BUFFER_STARTUP_TEST is not set
# CONFIG_TRACE_ENUM_MAP_FILE is not set
+CONFIG_TRACING_EVENTS_GPIO=y
#
# Runtime Testing
# CONFIG_SECURITY_SELINUX is not set
CONFIG_SECURITY_SMACK=y
CONFIG_SECURITY_SMACK_BRINGUP=y
-# CONFIG_SECURITY_SMACK_NETFILTER=y
+# CONFIG_SECURITY_SMACK_NETFILTER is not set
# CONFIG_SECURITY_TOMOYO is not set
# CONFIG_SECURITY_APPARMOR is not set
# CONFIG_SECURITY_YAMA is not set
menuconfig MARU
- tristate "MARU virtual device drivers for emulator"
+ bool "MARU virtual device drivers for emulator"
default n
config MARU_VIRTIO_TOUCHSCREEN
tristate "MARU VirtIO Virtual Rotary Device Driver"
depends on MARU != n
-config MARU_EXTENSION_SOURCE
- tristate "MARU Extension source"
+config MARU_TV
+ bool "MARU drivers for TV"
depends on MARU != n
+ default n
-config MARU_EXTENSION_SOURCE_PATH
- string "MARU Extension source path"
- depends on MARU != n && MARU_EXTENSION_SOURCE != n
+config MARU_TV_EEPROM
+ tristate "MARU VirtIO Virtual EEPROM Device Driver"
+ depends on MARU_TV != n
+ depends on SYSFS
+
+config MARU_TV_DUMMY
+ tristate "MARU dummy drivers for TV"
+ depends on MARU_TV != n
-config MARU_MICOM_MSG
+config MARU_TV_MICOM_MSG
tristate "Micom Auto Remocon driver support for WT61P807"
+ depends on MARU_TV_DUMMY != n
-config MARU_MICOM_ISP
+config MARU_TV_MICOM_ISP
tristate "Micom ISP data support for WT61P807"
+ depends on MARU_TV_DUMMY != n
-config MARU_DUMMY
- tristate "MARU Dummy Driver"
- depends on MARU != n
-
-config MARU_SECURITY
+config MARU_TV_SECURITY
tristate "MARU Security Driver"
- depends on MARU != n
+ depends on MARU_TV_DUMMY != n
-config MARU_SDP_MEM
+config MARU_TV_SDP_MEM
tristate "MARU SDP Memory Driver"
- depends on MARU != n
+ depends on MARU_TV_DUMMY != n
-config MARU_GPIO
+config MARU_TV_GPIO
tristate "MARU Dummy GPIO Driver"
- depends on MARU != n && GPIOLIB != n
+ depends on MARU_TV_DUMMY != n && GPIOLIB != n
-config MARU_I2C_SDP
+config MARU_TV_I2C_SDP
tristate "Maru Dummy I2C SDP Driver"
- depends on MARU != n && I2C != n
+ depends on MARU_TV_DUMMY != n && I2C != n
-config MARU_EEPROM
- tristate "MARU VirtIO Virtual EEPROM Device Driver"
+config MARU_EXTENSION_SOURCE
+ bool "MARU Extension source"
depends on MARU != n
- depends on SYSFS
+
+config MARU_EXTENSION_SOURCE_PATH
+ string "MARU Extension source path"
+ depends on MARU != n && MARU_EXTENSION_SOURCE != n
obj-$(CONFIG_MARU_VIRTIO_VMODEM) += maru_virtio_vmodem.o
obj-$(CONFIG_MARU_VIRTIO_ROTARY) += maru_virtio_rotary.o
obj-$(CONFIG_MARU_VIRTIO_TABLET) += maru_virtio_tablet.o
-obj-$(CONFIG_MARU_EEPROM) += maru_eeprom.o
-obj-$(CONFIG_MARU_DUMMY) += tztv-dummy/
+obj-$(CONFIG_MARU_TV) += tv/
obj-$(CONFIG_MARU_EXTENSION_SOURCE) += $(CONFIG_MARU_EXTENSION_SOURCE_PATH)/
+++ /dev/null
-/*
- * MARU EEPROM
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Dongkyun Yun <dk77.yun@samsung.com>
- * Munkyu Im <munkyu.im@samsung.com>
- * Sangho Park <sangho.p@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#include <asm/current.h>
-#include <linux/uaccess.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/sched.h>
-#include <linux/jiffies.h>
-#include <linux/device.h>
-#include <linux/export.h>
-#include <linux/mutex.h>
-#include <linux/i2c.h>
-#include <linux/delay.h>
-#include <linux/of_gpio.h>
-#include <linux/version.h>
-#include <linux/moduleparam.h>
-#include <linux/cdev.h>
-#include <linux/file.h>
-#include "maru_eeprom.h"
-#include <linux/vmalloc.h>
-
-//#define EEP_DEBUG
-
-#ifdef EEP_DEBUG
-#define eep_log(fmt, arg...) \
- printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, EEPROM_DEV_NAME, \
- __func__, __LINE__, current->comm, current->pid, ##arg);
-#else
-#define eep_log(fmt, arg...)
-#endif
-
-#define eep_err(fmt, arg...) \
- printk(KERN_ERR "[%s](%s)[%s:%d]: " fmt, EEPROM_DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-#define eep_warn(fmt, arg...) \
- printk(KERN_WARNING "[%s](%s)[%s:%d]: " fmt, EEPROM_DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-#define eep_info(fmt, arg...) \
- printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, EEPROM_DEV_NAME, __func__, __LINE__, \
- current->comm, current->pid, ##arg);
-
-
-
-#define FILENAME "/boot/eeprom"
-
-#define true 1
-#define false 0
-
-/* device protocol */
-enum req_cmd {
- req_eeprom_get = 1,
- req_eeprom_set,
- req_eeprom_reply
-};
-
-/* eeprom specific macros */
-#define EEP_BLOCK_SIZE 4096
-#define EEP_BLOCK_COUNT 16
-#define EEPROM_MAX_SIZE (EEP_BLOCK_SIZE * EEP_BLOCK_COUNT)
-#define MAX_ATTR_BYTES 6
-
-/* 10 milliseconds of delay is required after each i2c write operation */
-//#define DELAY 10000
-
-/* upper/lower 8-bit word address macros */
-#define HI_BYTE(x) (((x) >> 8) & (0x00FF))
-#define LO_BYTE(x) ((x) & (0x00FF))
-
-/* define global mutex statically ***/
-static DEFINE_MUTEX(eep_mutex);
-
-/* global variables for this module ***/
-static int counter;
-static const unsigned int eeprom_size = EEPROM_MAX_SIZE;
-static int eeprom_dev_major;
-//static struct i2c_client *eep_client;
-
-/* write protection for eeprom */
-static int g_protect;
-
-static struct file *g_file;
-
-static ssize_t eeprom_write_file(const unsigned char __user *buf, int len, loff_t pos)
-{
- ssize_t ret = 0;
- mm_segment_t old_fs;
-
- if (g_file == NULL)
- return -ENODEV;
-
- if (g_protect) {
- eep_info("memory is protected.\n");
- return ret;
- }
- old_fs = get_fs();
- set_fs(KERNEL_DS);
-
- ret = vfs_write(g_file, buf, len, &pos);
- if (ret != len) {
- eep_warn("len mismatch ret: %zi, len: %d, pos: %lld\n", ret, len, pos);
- }
- set_fs(old_fs);
-
- return ret;
-}
-
-static int eeprom_init_file(void)
-{
- unsigned int i;
- loff_t pos = 0;
- int ret = 0;
- int reminder_pos = 0;
- unsigned char *buf = vmalloc(EEP_BLOCK_SIZE);
- if (!buf) {
- eep_warn("memory not allocated for buffer.\n");
- ret = -ENOMEM;
- goto out_ext;
- }
- memset(buf, 0xff, EEP_BLOCK_SIZE);
-
- for (i = 0; i < EEP_BLOCK_COUNT; i++) {
- ret = eeprom_write_file(buf, EEP_BLOCK_SIZE, pos);
- if (ret < 0) {
- eep_warn("failed to initialize. ret: %d\n", ret);
- goto out_ext;
- } else if (ret < EEP_BLOCK_SIZE) {
- eep_info("write reminder.\n");
- reminder_pos = ret;
- do {
- ret = eeprom_write_file(buf, EEP_BLOCK_SIZE - reminder_pos, pos + reminder_pos);
- if (ret <= 0) {
- eep_warn("failed to write reminder. ret: %d\n", ret);
- goto out_ext;
- }
- reminder_pos += ret;
- } while (reminder_pos != EEP_BLOCK_SIZE);
- }
- pos += EEP_BLOCK_SIZE;
- }
- ret = pos;
- vfree(buf);
- eep_info("file initialized: %s\n", FILENAME);
-
-out_ext:
- return ret;
-}
-
-static int eeprom_open_file(void)
-{
- struct file *file;
- eep_log("eeprom_open_file\n");
-
- file = filp_open(FILENAME, O_CREAT|O_RDWR|O_EXCL|O_SYNC, 0666);
- if (IS_ERR(file)) {
- eep_info("file already exists: %s\n", FILENAME);
- file = filp_open(FILENAME, O_CREAT|O_RDWR|O_SYNC, 0666);
- if (IS_ERR(file)) {
- eep_warn("filp_open failed.\n");
- return -ENOENT;
- }
- g_file = file;
- return 0;
- }
- g_file = file;
-
- return eeprom_init_file();
-}
-
-static ssize_t eeprom_read_file(unsigned char __user *buf, int len, loff_t pos)
-{
- ssize_t ret = 0;
- mm_segment_t old_fs;
-
- if (g_file == NULL)
- return -ENODEV;
-
- eep_log("pos(%lld) len(%d) \n", pos, len);
-
- old_fs = get_fs();
- set_fs(KERNEL_DS);
-
- ret = vfs_read(g_file, buf, len, &pos);
- if (ret != len) {
- eep_warn("len mismatch ret: %zi, len: %d, pos: %lld\n", ret, len, pos);
- }
- set_fs(old_fs);
-
- return ret;
-}
-
-static int eeprom_usr_write(const char __user *buf, size_t count, unsigned long addr)
-{
- int ret = -EFAULT;
-
- eep_log("eep write.\n");
- if (!buf) {
- eep_err("Invalid User buffer.\n");
- } else if (count > 0) {
- if (addr + count > eeprom_size) {
- eep_err("overflow!!.\n");
- goto out_err;
- }
- ret = eeprom_write_file(buf, count, addr);
- if (ret < 0) {
- eep_warn("Write failed.\n");
- }
- } else {
- eep_warn("inavalid count.\n");
- }
-
-out_err:
- return ret;
-}
-
-static ssize_t eeprom_usr_read(char __user *buf, size_t count, unsigned long addr)
-{
- int ret = -EFAULT;
-
- eep_log("eep read.\n");
- if (!buf) {
- eep_err("User buf has no memory allocation.\n");
- } else if (count > 0) {
- if (count + addr > eeprom_size) {
- eep_err("overflow!!.\n");
- goto out_err;
- }
- ret = eeprom_read_file(buf, count, addr);
- if (ret < 0) {
- eep_warn("read failed.\n");
- }
- } else {
- eep_warn("invalid count.\n");
- }
-
-out_err:
- return ret;
-}
-
-
-
-
-/* for using sysfs. (class, device, device attribute) */
-
-/** @brief This function inhibits the write operation on eeprom.
- *
- * @param [in] protect value(0 or 1).
- * 1 - To protect memory.
- * 0 - To unprotect memory.
- * @return On success Returns 0.
- * On failure Returns negative error number.
- */
-int eep_set_wp(int protect)
-{
- int ret = 0;
-
- if (protect != 0 && protect != 1) {
- eep_warn("invalid input.\n");
- return -EINVAL;
- }
-
- g_protect = protect;
- eep_log("eeprom => %d (1:locked, 0:unlocked)\n", g_protect);
-
- return ret;
-}
-EXPORT_SYMBOL(eep_set_wp);
-
-/**
- * @brief Returns the status of eeprom write protection.
- *
- * @param [in] void It takes no arguments.
- *
- * @return On success Returns 0.
- * On failure Returns negative error number.
- */
-int eep_get_wp()
-{
- int ret = 0;
-
- ret = g_protect;
- eep_log("eeprom => %d (1:locked, 0:unlocked)\n", g_protect);
-
- return ret;
-}
-EXPORT_SYMBOL(eep_get_wp);
-
-/**
- * @brief This function resets the whole eeprom chip.
- *
- * @parms [in] void It takes no arguments.
- *
- * @return On success Returns 0.
- * On failure Returns negative error number.
- */
-static int eep_reset(void)
-{
- return eeprom_init_file();
-}
-
-/**
- * @brief This function opens the eeprom device.
- *
- * @param inode inode.
- * @param [in] fp File pointer points to the file descriptor.
- *
- * @return On success Returns 0.
- * On failure Returns negative error number.
- */
-int eep_open(struct inode *inode, struct file *fp)
-{
- int ret = 0;
-
- mutex_lock(&eep_mutex);
- if (counter == 0) {
- eeprom_open_file();
- } else if (g_file == NULL) {
- eep_warn("g_file is NULL\n");
- ret = -ENODEV;
- goto out;
- } else {
- //Increase reference count of g_file
- atomic_long_inc_not_zero(&g_file->f_count);
- }
-
- counter++;
- eep_log("Open: #:%d\n" , counter);
- //eep_log("major number=%d, minor number=%d \n", imajor(inode), iminor(inode));
-out:
- mutex_unlock(&eep_mutex);
-
- return ret;
-}
-
-/**
- * @brief This function undo the all open call operations.
- *
- * @param inode inode.
- * @param [in] fp File pointer points to the file descriptor.
- *
- * @return On success Returns 0.
- * On failure Returns negative error number.
- */
-int eep_close(struct inode *inode, struct file *fp)
-{
- int ret = 0;
-
- eep_log("close.\n");
-
- mutex_lock(&eep_mutex);
- BUG_ON(g_file == NULL);
- fput(g_file);
- counter--;
- mutex_unlock(&eep_mutex);
- return ret;
-}
-
-/**
- * @brief The lseek method is used to change the current read/write position
- * in a file
- *
- * @param [in] fp File pointer points to the file descriptor.
- * @param [in] offset Offset.
- * @param [in] origin Origin.
- *
- * @return On success The new position(resulting offset) is returned.
- * On failure Returns negative error number.
- */
-loff_t eep_lseek(struct file *fp, loff_t offset, int origin)
-{
- loff_t current_offset = 0;
-
- eep_log("lseek.\n");
-
- mutex_lock(&eep_mutex);
-
- switch (origin) {
- case SEEK_SET:
- current_offset = offset;
- break;
- case SEEK_CUR:
- current_offset = fp->f_pos + offset;
- break;
- case SEEK_END:
- current_offset = eeprom_size - offset;
- break;
- default:
- break;
- }
- if (current_offset >= eeprom_size) {
- eep_err("offset overflow!\n");
- current_offset = eeprom_size - 1;
- } else if (current_offset < 0) {
- eep_err("offset underflow!\n");
- current_offset = 0;
- }
-
- fp->f_pos = current_offset;
-
- mutex_unlock(&eep_mutex);
- return current_offset;
-}
-
-/**
- * @brief This function reads the data from eeprom device.
- *
- * @param [in] fp File pointer points to the file descriptor.
- * @param [in] buf Pointer to the user space buffer.
- * @param [in] count Number of bytes application intend to read.
- * @param [in/out] pos Current file offset position.
- *
- * @return On success Returns count(number of read bytes).
- * On failure Returns negative error number.
- */
-ssize_t eep_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)
-{
- int ret = 0;
-
- mutex_lock(&eep_mutex);
- ret = eeprom_usr_read(buf, count, fp->f_pos);
- if (ret < 0) {
- eep_warn("eep_read failed. ret: %d", ret);
- }
- mutex_unlock(&eep_mutex);
-
- return ret;
-}
-
-/**
- * @brief This function writes the data to eeprom device.
- *
- * @param [in] fp File pointer points to the file descriptor.
- * @param [in] buf Pointer to the user space buffer.
- * @param [in] count Number of bytes application intend to write.
- * @param [in/out] pos Current file offset position.
- *
- * @return On success Returns count(the number of bytes successfully written).
- * On failure Returns negative error number.
- */
-ssize_t eep_write(struct file *fp, const char __user *buf,
- size_t count, loff_t *pos)
-{
- int ret = 0;
-
- mutex_lock(&eep_mutex);
- ret = eeprom_usr_write(buf, count, fp->f_pos);
- if (ret < 0) {
- eep_warn("eep_write failed. ret: %d", ret);
- }
- mutex_unlock(&eep_mutex);
-
- return ret;
-}
-
-
-/**
- * @brief This function performs control operations on eeprom.
- *
- * @param [in] fp File pointer points to the file descriptor.
- * @param [in] cmd Request command.
- * @param [in/out] args The arguments based on request command.
- *
- * @return On Success Returns zero.
- * On failure Returns negative error number.
- */
-long eep_ioctl(struct file *fp, unsigned int cmd, unsigned long args)
-{
- int protect = 0, size;
- long ret = 0;
-
- eep_log("ioctl.\n");
-
- /*verify args*/
- if (_IOC_TYPE(cmd) != EEPROM_MAGIC)
- return -ENOTTY;
- if (_IOC_NR(cmd) > EEPROM_MAX_CMDS)
- return -ENOTTY;
- if (_IOC_DIR(cmd) & _IOC_READ)
- if (!access_ok(VERIFY_WRITE, (void *)args, _IOC_SIZE(cmd)))
- return -EFAULT;
- if (_IOC_DIR(cmd) & _IOC_WRITE)
- if (!access_ok(VERIFY_READ, (void *)args, _IOC_SIZE(cmd)))
- return -EFAULT;
- mutex_lock(&eep_mutex);
- switch (cmd) {
- case EEPROM_RESET:
- eep_reset();
- break;
- case EEPROM_SET_WP:
- if (copy_from_user(&protect, (int *)args, sizeof(int))) {
- eep_warn("failed copy_from_user.\n");
- return -EFAULT;
- }
- eep_set_wp(protect);
- break;
- case EEPROM_GET_WP:
- protect = eep_get_wp();
- if (copy_to_user((int *)args, &protect, sizeof(int))) {
- eep_warn("failed copy_to_user.\n");
- ret = -EFAULT;
- }
- break;
- case EEPROM_GET_SIZE:
- size = eeprom_size;
- if (copy_to_user((int *)args, &size, sizeof(int))) {
- eep_warn("failed copy_to_user.\n");
- ret = -EFAULT;
- }
- break;
- case EEPROM_WRITE_DATA:
- case EEPROM_READ_DATA:
- {
- struct eeprom_io_pkt *pkt = (struct eeprom_io_pkt *)args;
- if (cmd == EEPROM_WRITE_DATA)
- ret = eeprom_usr_write(pkt->wbuf, pkt->size, pkt->addr);
- else
- ret = eeprom_usr_read(pkt->rbuf, pkt->size, pkt->addr);
- if (ret < 0) {
- eep_warn("failed handle eeprom data: %ld", ret);
- }
- }
- break;
- default:
- eep_warn("invalid cmd %d \n", cmd);
- ret = -EFAULT;
- break;
- }
- mutex_unlock(&eep_mutex);
- return ret;
-}
-
-/**
- * @brief This function will be called when the user read from sysfs.
- *
- * @param [in] dev device.
- * @param [in] attr device attributes.
- * @param [in/out] buf buffer.
- *
- * @return On success Returns maxlen characters pointed to by buf.
- * On failure Returns negative error number.
- */
-static ssize_t nvram_size_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- eep_log("called.\n");
-
- mutex_lock(&eep_mutex);
- snprintf(buf, sizeof(int), "%d", eeprom_size);
- mutex_unlock(&eep_mutex);
- return strnlen(buf, MAX_ATTR_BYTES);
-}
-
-/* for using sysfs. (class, device, device attribute) */
-static struct class *eep_class;
-static struct device *eep_dev;
-static DEVICE_ATTR_RO(nvram_size);
-
-static const struct of_device_id eepdev_of_match[] = {
- { .compatible = "sii,s24c512c" },
- {},
-};
-MODULE_DEVICE_TABLE(of, eepdev_of_match);
-
-/**
- * Devices are identified using device id
- * of the chip
- */
-static const struct i2c_device_id eep_i2c_id[] = {
- { "s24c512c", 0 },
- {},
-};
-MODULE_DEVICE_TABLE(i2c, eep_i2c_id);
-
-/* device number */
-dev_t eeprom_dev_num;
-
-/* function pointers for file operations */
-static const struct file_operations eep_drv_fops = {
- .llseek = eep_lseek,
- .read = eep_read,
- .open = eep_open,
- .release = eep_close,
- .write = eep_write,
- .unlocked_ioctl = eep_ioctl,
- .owner = THIS_MODULE,
-};
-
-
-/* Device initialization routine */
-static int __init eep_init(void)
-{
- int res = 0;
-
- eep_info("init!!\n");
-
- counter = 0;
- eeprom_dev_major = 0;
- eeprom_dev_num = 0;
- eep_dev = NULL;
- eep_class = NULL;
- //eep_client = NULL;
-
- /* register device with file operation mappings
- * for dynamic allocation of major number
- */
- res = register_chrdev(eeprom_dev_major, EEPROM_DEV_NAME, &eep_drv_fops);
- if (res < 0) {
- eep_err("failed to get major number.\n");
- goto out;
- }
- /* if the allocation is dynamic ?*/
- if (res != 0)
- eeprom_dev_major = res;
-
- eeprom_dev_num = MKDEV(eeprom_dev_major, 0);
-
- /* create class. (/sys/class/eep_class) */
- eep_class = class_create(THIS_MODULE, "eep_class");
- if (IS_ERR(eep_class)) {
- res = PTR_ERR(eep_class);
- goto out_unreg_chrdev;
- }
- /* create class device. (/sys/class/eep_class/eeprom) */
- eep_dev = device_create(eep_class, NULL, eeprom_dev_num, NULL,
- "eeprom");
-
- if (IS_ERR(eep_dev)) {
- res = PTR_ERR(eep_dev);
- goto out_unreg_class;
- }
- /* create sysfs file. (/sys/class/eep_class/eeprom/nvram_size) */
- res = device_create_file(eep_dev, &dev_attr_nvram_size);
- if (res) {
- eep_err("failed to create sysfs.\n");
- goto out_unreg_device;
- }
-
- return res;
-
- //out_unreg_sysfs:
- // device_remove_file(eep_dev, &dev_attr_nvram_size);
-out_unreg_device:
- device_destroy(eep_class, eeprom_dev_num);
-out_unreg_class:
- class_destroy(eep_class);
-out_unreg_chrdev:
- unregister_chrdev(eeprom_dev_major, EEPROM_DEV_NAME);
-out:
- return res;
-}
-
-/* Device exit routine */
-static void __exit eep_exit(void)
-{
- eep_info("Exit!!\n");
-
- /* remove sysfs file */
- device_remove_file(eep_dev, &dev_attr_nvram_size);
- /* remove class device */
- device_destroy(eep_class, eeprom_dev_num);
- /* remove class */
- class_destroy(eep_class);
- //i2c_del_driver(&eep_i2c_driver);
- /* unregister device */
- unregister_chrdev(eeprom_dev_major, EEPROM_DEV_NAME);
-
- /* for emulator */
-}
-
-/* define module init/exit, license */
-subsys_initcall(eep_init);
-module_exit(eep_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Dronamraju Santosh Pavan Kumar, <dronamraj.k@samsung.com>");
+++ /dev/null
-/**
- *
- * Copyright (c) 2013 Samsung Electronics Co. Ltd.
- * Copyright (C) 2013 Samsung R&D Institute India-Delhi.
- * Author: Dronamraju Santosh Pavan Kumar <dronamraj.k@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * @file eeprom.h
- * @brief Header file for the eeprom_s24c512c eeprom chip.
- * @author Dronamraju Santosh pavan Kumar <dronamraj.k@samsung.com>
- * @date 2013/07/12
- *
- */
-
-/* internal Release1 */
-
-#ifndef _EEPROM_H
-#define _EEPROM_H
-
-#include<asm-generic/ioctl.h>
-
-#define EEPROM_MAGIC 'I'
-#define EEPROM_LOCAL_BUFF_SIZE 128
-
-/*device name*/
-#define EEPROM_DEV_NAME "eeprom"
-
-struct eeprom_io_pkt {
- unsigned int addr;
- unsigned int size;
- const char *wbuf;
- char *rbuf;
-};
-
-#define EEPROM_RESET _IOW(EEPROM_MAGIC, 0x01, int)
-#define EEPROM_SET_WP _IOW(EEPROM_MAGIC, 0x02, int)
-#define EEPROM_GET_WP _IOR(EEPROM_MAGIC, 0x03, int)
-#define EEPROM_GET_SIZE _IOR(EEPROM_MAGIC, 0x04, int)
-#define EEPROM_WRITE_DATA _IOW(EEPROM_MAGIC, 0x05, struct eeprom_io_pkt *)
-#define EEPROM_READ_DATA _IOR(EEPROM_MAGIC, 0x06, struct eeprom_io_pkt *)
-#define EEPROM_SLAVE_ADDR 0x50
-#define EEPROM_MAX_CMDS 6
-
-/* function prototypes */
-int eep_i2c_write(unsigned int addr, const unsigned char *buf, int len);
-int eep_reg_write(unsigned int reg, const unsigned char *buf, int len);
-int eep_reg_read(unsigned int reg, unsigned char *buf, int len);
-int eep_set_wp(int protect);
-int eep_get_wp(void);
-ssize_t eeprom_dev_write(char *buf, size_t count, unsigned long addr);
-ssize_t eeprom_dev_read(char *buf, size_t count, unsigned long addr);
-
-#endif /*_EEPROM_H */
--- /dev/null
+obj-$(CONFIG_MARU_TV_EEPROM) += maru_eeprom.o
+obj-$(CONFIG_MARU_TV_DUMMY) += maru_dummy.o
+obj-$(CONFIG_MARU_TV_SECURITY) += maru_dummy_security.o
+obj-$(CONFIG_MARU_TV_SDP_MEM) += maru_dummy_sdp_mem.o
+obj-$(CONFIG_MARU_TV_GPIO) += maru_dummy_gpio.o
+obj-$(CONFIG_MARU_TV_I2C_SDP) += maru_dummy_i2c_sdp.o
+obj-$(CONFIG_MARU_TV_MICOM_MSG) += maru_dummy_micom_msg.o
+obj-$(CONFIG_MARU_TV_MICOM_ISP) += maru_dummy_micom_isp.o
--- /dev/null
+/*
+ * MARU dummy driver
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jinhyung Choi <jinh0.choi@samsung.com>
+ * Hyunjin Lee <hyunjin816.lee@samsung.com>
+ * SangHo Park <sangho.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/ioctl.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/cdev.h>
+
+#include <linux/mm.h>
+#include <linux/mm_types.h>
+
+#include "maru_dummy.h"
+
+struct dummy_device {
+ const char *name;
+ struct class *dev_class;
+ struct device* dev_device;
+ struct cdev cdev;
+ dev_t dev;
+ struct file_operations fops;
+};
+
+static DECLARE_WAIT_QUEUE_HEAD(wq);
+
+int dummy_driver_debug = 0;
+module_param(dummy_driver_debug, int, 0644);
+MODULE_PARM_DESC(dummy_driver_debug, "Turn on/off maru dummy debugging (default:off).");
+
+#define GENERATE_ACCESSORS_DEV(_dev) \
+static int maru_##_dev##_open(struct inode *inode, struct file *file) \
+{ \
+ maru_device_dbg(1, "open is called.\n"); \
+ return 0; \
+} \
+static int maru_##_dev##_close(struct inode *inode, struct file *file) \
+{ \
+ maru_device_dbg(1, "close is called.\n"); \
+ return 0; \
+} \
+static long maru_##_dev##_ioctl(struct file *file, unsigned int cmd, unsigned long arg) \
+{ \
+ maru_device_dbg(1, "ioctl cmd : 0x%08x, arg : 0x%08lx\n", cmd, arg); \
+ return 0; \
+} \
+static ssize_t maru_##_dev##_write(struct file *file, const char __user *buf, \
+ size_t len, loff_t *ppos) \
+{ \
+ maru_device_dbg(1, "write is called. size: %d, buf: %s, \n", len, buf); \
+ return len; \
+} \
+static unsigned int maru_##_dev##_poll(struct file *file, struct poll_table_struct *wait) \
+{ \
+ return 0; \
+}
+
+#define __ATTRIBUTE_DUMMY_DEVICE(_name) { \
+ .name = __stringify(_name), \
+ .fops = { \
+ .open = maru_##_name##_open, \
+ .unlocked_ioctl = maru_##_name##_ioctl, \
+ .write = maru_##_name##_write, \
+ .poll = maru_##_name##_poll, \
+ .release = maru_##_name##_close \
+ }, \
+}
+
+#define __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(_name, _fname) {\
+ .name = __stringify(_name), \
+ .fops = { \
+ .open = maru_##_fname##_open, \
+ .unlocked_ioctl = maru_##_fname##_ioctl,\
+ .write = maru_##_fname##_write, \
+ .poll = maru_##_fname##_poll, \
+ .release = maru_##_fname##_close \
+ }, \
+}
+
+GENERATE_ACCESSORS_DEV(tztv_frc)
+GENERATE_ACCESSORS_DEV(tztv_tcon)
+GENERATE_ACCESSORS_DEV(micom_cec)
+GENERATE_ACCESSORS_DEV(micom_ar)
+GENERATE_ACCESSORS_DEV(micom_bsensor)
+GENERATE_ACCESSORS_DEV(kfactory)
+
+struct dummy_device dummy_device_group[] = {
+ __ATTRIBUTE_DUMMY_DEVICE(tztv_frc),
+ __ATTRIBUTE_DUMMY_DEVICE(tztv_tcon),
+ __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(micom-cec, micom_cec),
+ __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(micom-ar, micom_ar),
+ __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(micom-bsensor, micom_bsensor),
+ __ATTRIBUTE_DUMMY_DEVICE(kfactory),
+};
+
+static void remove_device(struct dummy_device *device)
+{
+ if (device == NULL) {
+ return;
+ }
+
+ if (device->dev_device) {
+ device_destroy(device->dev_class, device->dev);
+ device->dev_device = NULL;
+ }
+
+ if (device->dev) {
+ unregister_chrdev_region(device->dev, 1);
+ }
+
+ if (device->dev_class) {
+ class_destroy(device->dev_class);
+ }
+}
+
+static int create_device(struct dummy_device *device)
+{
+ int ret = 0;
+
+ if (device == NULL) {
+ maru_device_err("failed to create device: device == NULL \n");
+ return ret;
+ }
+
+ ret = alloc_chrdev_region(&device->dev, 0, 1, device->name);
+ if (ret < 0) {
+ maru_device_err("%s alloc_chrdev_region failed.\n", device->name);
+ return ret;
+ }
+
+ device->dev_class = class_create(THIS_MODULE, device->name);
+ if (IS_ERR(device->dev_class)) {
+ ret = PTR_ERR(device->dev_class);
+ maru_device_err("create %s class failed.\n", device->name);
+ remove_device(device);
+ return ret;
+ }
+
+ cdev_init(&device->cdev, &device->fops);
+
+ ret = cdev_add(&device->cdev, device->dev, 1);
+ if (ret < 0) {
+ maru_device_err("%s cdev_add failed\n", device->name);
+ remove_device(device);
+ return ret;
+ }
+
+ device->dev_device = device_create(device->dev_class, 0, device->dev, NULL, "%s", device->name);
+ if (ret < 0) {
+ maru_device_err("%s device_create failed\n", device->name);
+ remove_device(device);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int __init maru_dummy_init(void)
+{
+ int ret = 0;
+ int i = 0;
+ int size = sizeof(dummy_device_group) / sizeof(dummy_device_group[0]);
+
+ for (i = 0; i < size; i++) {
+ ret = create_device(&dummy_device_group[i]);
+ if (ret < 0)
+ continue;
+ }
+
+ maru_device_info("dummy driver was initialized.\n");
+
+ return 0;
+}
+
+static void __exit maru_dummy_exit(void)
+{
+ int i = 0;
+ int size = sizeof(dummy_device_group) / sizeof(dummy_device_group[0]);
+
+ for (i = 0; i < size; i++) {
+ remove_device(&dummy_device_group[i]);
+ }
+
+ maru_device_info("dummy driver was exited.\n");
+}
+
+module_init(maru_dummy_init);
+module_exit(maru_dummy_exit);
\ No newline at end of file
--- /dev/null
+/*
+ * MARU dummy driver
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jinhyung Choi <jinh0.choi@samsung.com>
+ * Hyunjin Lee <hyunjin816.lee@samsung.com>
+ * SangHo Park <sangho.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#ifndef _MARU_DUMMY_H
+#define _MARU_DUMMY_H
+
+extern int dummy_driver_debug;
+
+#define maru_device_err(fmt, arg...) \
+ printk(KERN_ERR "[ERR][%s]: " fmt, __func__, ##arg)
+
+#define maru_device_warn(fmt, arg...) \
+ printk(KERN_WARNING "[WARN][%s]: " fmt, __func__, ##arg)
+
+#define maru_device_info(fmt, arg...) \
+ printk(KERN_INFO "[INFO][%s]: " fmt, __func__, ##arg)
+
+#define maru_device_dbg(log_level, fmt, arg...) \
+ do { \
+ if (dummy_driver_debug >= (log_level)) { \
+ printk(KERN_INFO "[DEBUG][%s]: " fmt, __func__, ##arg); \
+ } \
+ } while (0)
+
+#endif
\ No newline at end of file
--- /dev/null
+/*
+ * MARU Dummy GPIO driver
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jinhyung Choi <jinh0.choi@samsung.com>
+ * SangHo Park <sangho.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License13
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
+#include <linux/platform_device.h>
+
+#include "maru_dummy.h"
+
+#define DRVNAME "maru_gpio"
+
+struct maru_gpio_dev {
+ int addr;
+};
+
+struct maru_gpio {
+ struct gpio_chip chip;
+ struct maru_gpio_dev *dev;
+};
+
+static int maru_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+ maru_device_dbg(1, "gpio request offset : %u\n", offset);
+ return 0;
+}
+
+static int maru_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
+{
+ maru_device_dbg(1, "gpio direction in offset : %u\n", offset);
+ return 0;
+}
+
+static int maru_gpio_direction_out(struct gpio_chip *chip,
+ unsigned offset, int value)
+{
+ maru_device_dbg(1, "gpio direction out offset : %u, value : %d\n", offset, value);
+ return 0;
+}
+
+static int maru_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+ maru_device_dbg(1, "gpio get offset : %u\n", offset);
+ return 0;
+}
+
+static void maru_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+ maru_device_dbg(1, "gpio set offset : %u, value : %d\n", offset, value);
+}
+
+static int maru_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+ maru_device_dbg(1, "gpio to irq offset : %u\n", offset);
+ return 0;
+}
+
+static struct gpio_chip maru_gpio_chip = {
+ .label = DRVNAME,
+ .owner = THIS_MODULE,
+ .request = maru_gpio_request,
+ .direction_input = maru_gpio_direction_in,
+ .direction_output = maru_gpio_direction_out,
+ .get = maru_gpio_get,
+ .set = maru_gpio_set,
+ .to_irq = maru_gpio_to_irq,
+ .can_sleep = 1,
+ .ngpio = 255,
+ .base = 1,
+};
+
+static int maru_gpio_probe(struct platform_device *pdev)
+{
+ struct maru_gpio *maru_gpio;
+ int ret;
+
+ maru_gpio = devm_kzalloc(&pdev->dev, sizeof(*maru_gpio),
+ GFP_KERNEL);
+ if (maru_gpio == NULL){
+ maru_device_err("Could not allocate maru_gpio\n");
+ return -ENOMEM;
+ }
+
+ maru_gpio->chip = maru_gpio_chip;
+ maru_gpio->chip.dev = &pdev->dev;
+
+ ret = gpiochip_add(&maru_gpio->chip);
+ if (ret < 0) {
+ maru_device_err("Could not register maru gpiochip %d\n", ret);
+ return ret;
+ }
+
+ platform_set_drvdata(pdev, maru_gpio);
+
+ maru_device_info("maru gpio device probe done.\n");
+
+ return ret;
+}
+
+static int maru_gpio_remove(struct platform_device *pdev)
+{
+ struct maru_gpio *maru_gpio = platform_get_drvdata(pdev);
+
+ gpiochip_remove(&maru_gpio->chip);
+
+ return 0;
+}
+
+static struct platform_device *maru_gpio_pdev;
+
+static int __init maru_gpio_device_add(const struct maru_gpio_dev *dev)
+{
+ int err;
+
+ maru_gpio_pdev = platform_device_alloc(DRVNAME, -1);
+ if (!maru_gpio_pdev)
+ return -ENOMEM;
+
+ err = platform_device_add_data(maru_gpio_pdev, dev, sizeof(*dev));
+ if (err) {
+ maru_device_err("Platform data allocation failed\n");
+ goto err;
+ }
+
+ err = platform_device_add(maru_gpio_pdev);
+ if (err) {
+ maru_device_err("Device addition failed\n");
+ goto err;
+ }
+
+ maru_device_info("maru_gpio_device is added.\n");
+ return 0;
+err:
+ platform_device_put(maru_gpio_pdev);
+
+ return err;
+}
+
+static struct platform_driver maru_gpio_driver = {
+ .driver = {
+ .name = DRVNAME,
+ .owner = THIS_MODULE,
+ },
+ .probe = maru_gpio_probe,
+ .remove = maru_gpio_remove,
+};
+
+static int __init maru_gpio_init(void)
+{
+ int err;
+ struct maru_gpio_dev dev;
+
+ err = platform_driver_register(&maru_gpio_driver);
+ if (!err) {
+ err = maru_gpio_device_add(&dev);
+ if (err)
+ platform_driver_unregister(&maru_gpio_driver);
+ }
+
+ return err;
+}
+subsys_initcall(maru_gpio_init);
+
+static void __exit maru_gpio_exit(void)
+{
+ platform_driver_unregister(&maru_gpio_driver);
+}
+module_exit(maru_gpio_exit);
+
+MODULE_AUTHOR("Jinhyung Choi");
+MODULE_DESCRIPTION("Maru Dummy GPIO driver");
+MODULE_LICENSE("GPL");
--- /dev/null
+/*
+ * MARU Dummy I2C SDP driver
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Jinhyung Choi <jinh0.choi@samsung.com>
+ * SangHo Park <sangho.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+
+#include <asm/irq.h>
+#include <linux/semaphore.h>
+
+#include "maru_dummy.h"
+
+/* i2c controller state */
+enum sdp_i2c_state {
+ STATE_IDLE,
+ STATE_START,
+ STATE_READ,
+ STATE_WRITE,
+ STATE_STOP
+};
+
+struct sdp_platform_i2c {
+ int bus_num;
+ unsigned int flags;
+ unsigned int slave_addr;
+ unsigned long frequency;
+ unsigned int sda_delay;
+ unsigned int irq_reg;
+};
+
+struct sdp_i2c {
+ wait_queue_head_t wait;
+
+ struct i2c_msg *msg;
+ unsigned int msg_num;
+ unsigned int msg_idx;
+ unsigned int msg_ptr;
+
+ unsigned int tx_setup;
+ unsigned int irq;
+
+ enum sdp_i2c_state state;
+ unsigned long clkrate;
+
+ void __iomem *regs;
+ void __iomem *irq_reg;
+ struct clk *clk;
+ struct device *dev;
+ struct i2c_adapter adap;
+
+ struct sdp_platform_i2c *pdata;
+
+};
+
+static spinlock_t lock_pend;
+static spinlock_t lock_int;
+
+static int sdp_i2c_xfer(struct i2c_adapter *adap,
+ struct i2c_msg *msgs, int num)
+{
+ maru_device_dbg(1, "sdp_i2c_xfer");
+ return 0;
+}
+
+static u32 sdp_i2c_func(struct i2c_adapter *adap)
+{
+ return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |
+ I2C_FUNC_PROTOCOL_MANGLING;
+}
+
+static const struct i2c_algorithm sdp_i2c_algorithm = {
+ .master_xfer = sdp_i2c_xfer,
+ .functionality = sdp_i2c_func,
+};
+
+static int sdp_i2c_get_irq_reg(struct sdp_i2c *i2c)
+{
+ struct sdp_platform_i2c *pdata;
+ pdata = i2c->pdata;
+
+ i2c->irq_reg = ioremap(pdata->irq_reg, 8);
+
+ if (!i2c->irq_reg) {
+ maru_device_err("Can't get interrupts status register\n");
+ return -ENXIO;
+ }
+
+ return 0;
+}
+
+static int sdp_i2c_probe(struct platform_device *pdev)
+{
+ struct sdp_i2c *i2c;
+ struct sdp_platform_i2c *pdata = NULL;
+ int ret;
+
+ i2c = devm_kzalloc(&pdev->dev, sizeof(struct sdp_i2c), GFP_KERNEL);
+ if (!i2c) {
+ maru_device_err("no memory for state\n");
+ return -ENOMEM;
+ }
+
+ i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+ if (!i2c->pdata) {
+ ret = -ENOMEM;
+ goto err_noclk;
+ }
+
+ spin_lock_init(&lock_pend);
+ spin_lock_init(&lock_int);
+
+ strlcpy(i2c->adap.name, "sdp-i2c", sizeof(i2c->adap.name));
+ i2c->adap.owner = THIS_MODULE;
+ i2c->adap.algo = &sdp_i2c_algorithm;
+ i2c->adap.retries = 2;
+ i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
+ i2c->tx_setup = 50;
+
+ init_waitqueue_head(&i2c->wait);
+
+ i2c->dev = &pdev->dev;
+ i2c->clk = clk_get(&pdev->dev, "rstn_i2c");
+ if (IS_ERR(i2c->clk)) {
+ maru_device_err("cannot get clock\n");
+ ret = -ENOENT;
+ goto err_noclk;
+ }
+
+ clk_prepare_enable(i2c->clk);
+
+ i2c->adap.algo_data = i2c;
+ i2c->adap.dev.parent = &pdev->dev;
+
+ ret = sdp_i2c_get_irq_reg(i2c);
+ if (ret != 0)
+ goto err_clk;
+
+ i2c->adap.nr = 6;
+ ret = i2c_add_numbered_adapter(&i2c->adap);
+ if (ret < 0) {
+ maru_device_err("failed to add bus to i2c core\n");
+ goto err_irq;
+ }
+
+ platform_set_drvdata(pdev, i2c);
+
+ return 0;
+
+ err_irq:
+ free_irq(i2c->irq, i2c);
+
+ err_clk:
+ clk_disable_unprepare(i2c->clk);
+ clk_put(i2c->clk);
+
+ err_noclk:
+ return ret;
+}
+
+static int sdp_i2c_remove(struct platform_device *pdev)
+{
+ struct sdp_i2c *i2c = platform_get_drvdata(pdev);
+
+ i2c_del_adapter(&i2c->adap);
+ free_irq(i2c->irq, i2c);
+
+ clk_disable_unprepare(i2c->clk);
+ clk_put(i2c->clk);
+
+ return 0;
+}
+
+static struct platform_driver sdp_i2c_driver = {
+ .probe = sdp_i2c_probe,
+ .remove = sdp_i2c_remove,
+ .driver = {
+ .name = "sdp-i2c",
+ .owner = THIS_MODULE,
+ },
+};
+
+struct maru_i2c_dev {
+ int addr;
+};
+
+static struct platform_device *maru_i2c_pdev;
+
+static int __init maru_i2c_device_add(const struct maru_i2c_dev *dev)
+{
+ int err;
+
+ maru_i2c_pdev = platform_device_alloc("sdp-i2c", -1);
+ if (!maru_i2c_pdev)
+ return -ENOMEM;
+
+ err = platform_device_add_data(maru_i2c_pdev, dev, sizeof(*dev));
+ if (err) {
+ maru_device_err("Platform data allocation failed\n");
+ goto err;
+ }
+
+ err = platform_device_add(maru_i2c_pdev);
+ if (err) {
+ maru_device_err("Device addition failed\n");
+ goto err;
+ }
+
+ maru_device_info("maru_i2c_device is added.\n");
+ return 0;
+err:
+ platform_device_put(maru_i2c_pdev);
+
+ return err;
+}
+
+static int __init sdp_i2c_init(void)
+{
+ int err;
+
+ struct maru_i2c_dev dev;
+
+ err = platform_driver_register(&sdp_i2c_driver);
+ if (!err) {
+ err = maru_i2c_device_add(&dev);
+ if (err)
+ platform_driver_unregister(&sdp_i2c_driver);
+ }
+
+ return err;
+}
+subsys_initcall(sdp_i2c_init);
+
+static void __exit sdp_i2c_exit(void)
+{
+ platform_driver_unregister(&sdp_i2c_driver);
+}
+module_exit(sdp_i2c_exit);
+
+MODULE_AUTHOR("Jinhyung Choi");
+MODULE_DESCRIPTION("Maru Dummy I2C SDP driver");
+MODULE_LICENSE("GPL");
\ No newline at end of file
--- /dev/null
+/*
+ * MARU MICOM ISP
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Dongkyun Yun <dk77.yun@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/sched.h>
+#include <linux/cdev.h>
+
+#define DRIVER_NAME "isp-wt61p807"
+#define DEV_NAME "micom-isp"
+
+static int debug = 0;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Turn on/off maru micom isp debugging (default:off).");
+
+#define print_err(fmt, arg...) \
+ printk(KERN_ERR "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+
+#define print_warn(fmt, arg...) \
+ printk(KERN_WARNING "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+
+#define print_info(fmt, arg...) \
+ printk(KERN_INFO "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+
+#define print_dbg(level, fmt, arg...) \
+ do { \
+ if (debug >= (level)) { \
+ printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, DEV_NAME, \
+ __func__, __LINE__, current->comm, current->pid, ##arg); \
+ } \
+ } while (0)
+
+/* contains device information */
+struct wt61p807_isp_data {
+ struct cdev *isp_dev;
+ struct class *isp_class;
+ struct device *isp_device;
+ int micom_isp_major;
+ int ref_count;
+};
+
+struct wt61p807_isp_data *wt61p807_isp;
+
+/* static mutexes for micom isp driver */
+DEFINE_MUTEX(isp_dev_lock);
+
+/* global structures for wt61p807_isp_data and wt61p807_isp_cdev as those must
+ * be accessible from other functions ie.open, release etc.
+ */
+struct wt61p807_isp_data m_isp_dev;
+static struct cdev wt61p807_isp_cdev;
+
+/* micom isp file operations */
+static int micom_isp_open(struct inode *inode, struct file *filp);
+static int micom_isp_release(struct inode *inode, struct file *filp);
+static long micom_isp_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg);
+
+/* file operations for micom isp device */
+const struct file_operations wt61p807_isp_fops = {
+ .owner = THIS_MODULE,
+ .open = micom_isp_open,
+ .unlocked_ioctl = micom_isp_ioctl,
+ .release = micom_isp_release,
+};
+
+/*
+ *
+ * @fn static int micom_isp_open(struct inode *inode, \
+ * struct file *filp);
+ * @brief opens micom isp device and returns file descriptor
+ * @details opens micom isp device and increments m_isp_dev_p->ref_count by
+ * one.
+ *
+ * @param inode pointer to device node's inode structure
+ * filp pointer to device node file
+ *
+ * @return returns file descriptor if device is opened successfully
+ */
+static int micom_isp_open(struct inode *inode, struct file *filp)
+{
+ struct wt61p807_isp_data *wt61p807_isp = &m_isp_dev;
+
+ /* acquire lock before setting is_open.*/
+ mutex_lock(&isp_dev_lock);
+
+ wt61p807_isp->ref_count++;
+ print_dbg(1, "reference count : %d\n", wt61p807_isp->ref_count);
+
+ /* Release lock*/
+ mutex_unlock(&isp_dev_lock);
+
+ return 0;
+}
+
+/* @fn static long micom_isp_ioctl(struct file *filp, \
+ * unsigned int cmd, unsigned long arg);
+ * @brief handles IOCTLs addressed to micom isp device and returns status
+ * @details valid IOCTLs:
+ * MICOM_MSG_IOCTL_SEND_MSG: Used to send messages
+ * containing normal data to micom device. It expects
+ * acknowledgement from the device.
+ * MICOM_MSG_IOCTL_SEND_MSG_NO_ACK: Used to send messages
+ * containing normal buffer data without expecting any
+ * acknowledgement from micom isp device.
+ *
+ * @param filp pointer to device node file
+ * cmd IOCTL command.
+ * arg argument to ioctl command (struct sdp_micom_usr_isp).
+ *
+ * @return returns status of IOCTL
+ * -EINVAL: if null arg is passed from user.
+ * -EFAULT: if copy_from_user() fails to copy
+ * -ERANGE: if micom command sent from user exceeds the
+ * defined max value (0xFF)
+ * zero: if suceess
+ */
+static long micom_isp_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ long status = 0;
+
+ print_dbg(1, "device ioctl \n");
+
+ return status;
+}
+
+/*
+ *
+ * @fn static int micom_isp_release(struct inode *inode, \
+ * struct file *filp);
+ * @brief closes micom isp device and returns status
+ * @details
+ *
+ * @param inode pointer to device node's inode structure
+ * filp pointer to device node file
+ *
+ * @return returns zero if device is closed
+ */
+static int micom_isp_release(struct inode *inode, struct file *filp)
+{
+
+ struct wt61p807_isp_data *wt61p807_isp = &m_isp_dev;
+
+ /* acquire lock before setting is_open.*/
+ mutex_lock(&isp_dev_lock);
+
+ wt61p807_isp->ref_count--;
+ print_dbg(1 , "reference count : %d\n", wt61p807_isp->ref_count);
+
+ /* Release lock*/
+ mutex_unlock(&isp_dev_lock);
+
+ return 0;
+}
+
+/* Device initialization routine */
+static int __init micom_isp_init(void)
+{
+ dev_t devid = 0;
+ int ret = -1;
+
+ print_info("called\n");
+
+ /* allocate char device region */
+ ret = alloc_chrdev_region(&devid, 0, 1, DRIVER_NAME);
+ if (ret) {
+ print_err("alloc_chrdev_region failed with %d\n", ret);
+ goto chrdev_alloc_fail;
+ }
+
+ /* initialize associated cdev and attach the file_operations */
+ cdev_init(&wt61p807_isp_cdev, &wt61p807_isp_fops);
+ /* add cdev to device */
+ ret = cdev_add(&wt61p807_isp_cdev, devid, 1);
+ if (ret) {
+ print_err("cdev_add failed with %d\n", ret);
+ goto cdev_add_fail;
+ }
+
+ wt61p807_isp = &m_isp_dev;
+
+ wt61p807_isp->isp_dev = &wt61p807_isp_cdev;
+ wt61p807_isp->micom_isp_major = MAJOR(devid);
+ wt61p807_isp->ref_count = 0;
+
+ wt61p807_isp->isp_class = class_create(THIS_MODULE, DRIVER_NAME);
+ if (IS_ERR(wt61p807_isp->isp_class)) {
+ print_err("failed to create sys class\n");
+ } else {
+ wt61p807_isp->isp_device = device_create(
+ wt61p807_isp->isp_class,
+ NULL, devid, NULL, DEV_NAME);
+ if (IS_ERR(wt61p807_isp->isp_device)) {
+ print_err("failed to create sys device\n");
+ class_destroy(wt61p807_isp->isp_class);
+ }
+ }
+
+ /* dynamic initialization of mutex for device */
+ mutex_init(&isp_dev_lock);
+
+ return ret;
+
+ /* cleaning up due to failure. */
+cdev_add_fail:
+ unregister_chrdev_region(devid, 1);
+chrdev_alloc_fail:
+ return ret;
+}
+
+/* Device exit routine */
+static void __exit micom_isp_exit(void)
+{
+ print_info("called\n");
+
+ mutex_destroy(&isp_dev_lock);
+
+ /* destroy micom isp sysfs device and class */
+ if (wt61p807_isp->isp_device != NULL) {
+ device_destroy(wt61p807_isp->isp_class,
+ MKDEV(wt61p807_isp->micom_isp_major, 0));
+ }
+ if (wt61p807_isp->isp_class != NULL)
+ class_destroy(wt61p807_isp->isp_class);
+
+ unregister_chrdev_region(MKDEV(m_isp_dev.micom_isp_major, 0), 1);
+ return;
+}
+
+/* define module init/exit, license */
+subsys_initcall(micom_isp_init);
+module_exit(micom_isp_exit);
+
+MODULE_DESCRIPTION("Micom driver interface for ISP data");
+MODULE_AUTHOR("Abhishek Jaiswal <abhishek1.j@samsung.com>");
+MODULE_LICENSE("GPL");
--- /dev/null
+/*
+ * MARU MICOM MSG
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Dongkyun Yun <dk77.yun@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+/* internal Release1 */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/poll.h>
+#include <linux/sched.h>
+#include <linux/completion.h>
+#include <linux/platform_device.h>
+
+#define DRIVER_NAME "msg-wt61p807"
+#define DEV_NAME "micom-msg"
+
+static int debug = 0;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Turn on/off maru micom msg debugging (default:off).");
+
+#define print_err(fmt, arg...) \
+ printk(KERN_ERR "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+
+#define print_warn(fmt, arg...) \
+ printk(KERN_WARNING "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+
+#define print_info(fmt, arg...) \
+ printk(KERN_INFO "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+
+#define print_dbg(level, fmt, arg...) \
+ do { \
+ if (debug >= (level)) { \
+ printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, DEV_NAME, \
+ __func__, __LINE__, current->comm, current->pid, ##arg); \
+ } \
+ } while (0)
+
+/* no of retries */
+#define ACK_RETRY_MAX 4
+
+/* static mutexes for micom msg device */
+DEFINE_MUTEX(dev_msg_lock);
+
+/* list of micom msg file operations prototypes. */
+static int micom_msg_open(struct inode *inode, struct file *filp);
+static int micom_msg_release(struct inode *inode, struct file *filp);
+static long micom_msg_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg);
+static ssize_t show_jack_ident(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t show_scart_lv_1(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t show_scart_lv_2(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t show_jack_ident_ready(struct device *dev,
+ struct device_attribute *attr, char *buf);
+
+/* file operations for micom msg device */
+const struct file_operations wt61p807_msg_fops = {
+ .owner = THIS_MODULE,
+ .open = micom_msg_open,
+ .unlocked_ioctl = micom_msg_ioctl,
+ .release = micom_msg_release,
+};
+
+struct wt61p807_msg_data {
+ struct cdev *msg_dev;
+ struct class *msg_class;
+ struct device *msg_device;
+ int micom_msg_major;
+ int ref_count;
+
+ int jack_ident;
+ int jack_ident_ready;
+ int scart_lv_1;
+ int scart_lv_2;
+};
+
+struct wt61p807_msg_data *wt61p807_msg;
+
+/* micom msg device specific data */
+struct wt61p807_msg_data m_msg_dev;
+
+/* micom msg cdev */
+struct cdev wt61p807_msg_cdev;
+
+static DEVICE_ATTR(jack_ident, S_IRUGO, show_jack_ident, NULL);
+static DEVICE_ATTR(scart_lv_1, S_IRUGO, show_scart_lv_1, NULL);
+static DEVICE_ATTR(scart_lv_2, S_IRUGO, show_scart_lv_2, NULL);
+static DEVICE_ATTR(jack_ident_ready, S_IRUGO,
+ show_jack_ident_ready, NULL);
+
+/*
+ *
+ * @fn static int micom_msg_open(struct inode *inode, \
+ * struct file *filp);
+ * @brief opens micom msg device and returns file descriptor
+ * @details opens micom msg device and increments m_msg_dev_p->ref_count.
+ *
+ * @param inode pointer to device node's inode structure
+ * filp pointer to device node file
+ *
+ * @return returns file descriptor if device is opened successfully
+ */
+static int micom_msg_open(struct inode *inode, struct file *filp)
+{
+ int ret = 0;
+ struct wt61p807_msg_data *m_msg_dev_p = &m_msg_dev;
+
+ /* acquire lock before opening device.*/
+ mutex_lock(&dev_msg_lock);
+
+ m_msg_dev_p->ref_count++;
+
+ print_dbg(1, "MSG device is opened. ref_count[%d]\n",
+ m_msg_dev_p->ref_count);
+
+ /* Release lock */
+ mutex_unlock(&dev_msg_lock);
+
+ return ret;
+}
+
+/*
+ *
+ * @fn static int micom_msg_release(struct inode *inode, \
+ * struct file *filp);
+ * @brief closes micom msg device and returns status
+ * @details
+ *
+ * @param inode pointer to device node's inode structure
+ * filp pointer to device node file
+ *
+ * @return returns zero if device is closed
+ */
+static int micom_msg_release(struct inode *inode, struct file *filp)
+{
+
+ int ret = 0;
+ struct wt61p807_msg_data *m_msg_dev_p = &m_msg_dev;
+
+ /* acquire lock before closing device.*/
+ mutex_lock(&dev_msg_lock);
+
+ m_msg_dev_p->ref_count--;
+
+ print_dbg(1, "MSG device is closed. ref_count[%d]\n",
+ m_msg_dev_p->ref_count);
+
+ /* Release lock*/
+ mutex_unlock(&dev_msg_lock);
+
+ return ret;
+}
+
+/*
+ *
+ * @fn static long micom_msg_ioctl(struct file *filp, \
+ * unsigned int cmd, unsigned long arg);
+ * @brief handles IOCTLs addressed to micom msg device and returns status
+ * @details valid IOCTLs:
+ * MICOM_MSG_IOCTL_SEND_MSG: Used to send messages
+ * containing normal data to micom device. It expects
+ * acknowledgement from the device.
+ * MICOM_MSG_IOCTL_SEND_MSG_NO_ACK: Used to send messages
+ * containing normal buffer data without expecting any
+ * acknowledgement from micom msg device.
+ *
+ * @param filp pointer to device node file
+ * cmd IOCTL command.
+ * arg argument to ioctl command (struct sdp_micom_usr_msg).
+ *
+ * @return returns status of IOCTL
+ * -EINVAL: if null arg is passed from user.
+ * -EFAULT: if copy_from_user() fails to copy
+ * -ERANGE: if micom command sent from user exceeds the
+ * defined max value (0xFF)
+ * zero: if suceess
+ */
+static long micom_msg_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ long status = 0;
+
+ print_dbg(1, "MSG device ioctl \n");
+
+ return status;
+}
+
+static ssize_t show_jack_ident(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ print_dbg(1, "\n");
+ return snprintf(buf, sizeof(int), "%d", m_msg_dev.jack_ident);
+}
+
+static ssize_t show_scart_lv_1(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ print_dbg(1, "\n");
+ return snprintf(buf, sizeof(int), "%d", m_msg_dev.scart_lv_1);
+}
+
+static ssize_t show_scart_lv_2(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ print_dbg(1, "\n");
+ return snprintf(buf, sizeof(int), "%d", m_msg_dev.scart_lv_2);
+}
+
+static ssize_t show_jack_ident_ready(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ print_dbg(1, "\n");
+ return snprintf(buf, sizeof(int), "%d", m_msg_dev.jack_ident_ready);
+}
+
+/* Device initialization routine */
+static int __init micom_msg_init(void)
+{
+ dev_t devid = 0;
+ int ret = -1;
+
+ print_info("called\n");
+
+ /* allocate char device region */
+ ret = alloc_chrdev_region(&devid, 0, 1, DRIVER_NAME);
+ if (ret) {
+ print_err("alloc_chrdev_region failed with %d\n", ret);
+ goto chrdev_alloc_fail;
+ }
+
+ /* initialize associated cdev and attach the file_operations */
+ cdev_init(&wt61p807_msg_cdev, &wt61p807_msg_fops);
+ /* add cdev to device */
+ ret = cdev_add(&wt61p807_msg_cdev, devid, 1);
+ if (ret) {
+ print_err("cdev_add failed with %d\n", ret);
+ goto cdev_add_fail;
+ }
+
+ wt61p807_msg = &m_msg_dev;
+
+ wt61p807_msg->msg_dev = &wt61p807_msg_cdev;
+ wt61p807_msg->micom_msg_major = MAJOR(devid);
+ wt61p807_msg->ref_count = 0;
+
+ wt61p807_msg->msg_class = class_create(THIS_MODULE, DEV_NAME);
+ if (IS_ERR(wt61p807_msg->msg_class)) {
+ print_err("failed to create sys class\n");
+ } else {
+ wt61p807_msg->msg_device = device_create(
+ wt61p807_msg->msg_class,
+ NULL, devid, NULL, DEV_NAME);
+ if (IS_ERR(wt61p807_msg->msg_device)) {
+ print_err("failed to create sys device\n");
+ class_destroy(wt61p807_msg->msg_class);
+ }
+ }
+
+ ret = device_create_file(wt61p807_msg->msg_device,
+ &dev_attr_jack_ident);
+ if (ret) {
+ print_err("failed to create sysfs files (ret = %d) \n", ret);
+ goto dev_fail;
+ }
+ ret = device_create_file(wt61p807_msg->msg_device,
+ &dev_attr_scart_lv_1);
+ if (ret) {
+ print_err("failed to create sysfs files (ret = %d) \n", ret);
+ goto dev_fail;
+ }
+ ret = device_create_file(wt61p807_msg->msg_device,
+ &dev_attr_scart_lv_2);
+ if (ret) {
+ print_err("failed to create sysfs files (ret = %d) \n", ret);
+ goto dev_fail;
+ }
+ ret = device_create_file(wt61p807_msg->msg_device,
+ &dev_attr_jack_ident_ready);
+ if (ret) {
+ print_err("failed to create sysfs files (ret = %d) \n", ret);
+ goto dev_fail;
+ }
+
+ /* dynamic initialization of mutex for device */
+ mutex_init(&dev_msg_lock);
+
+ return ret;
+
+dev_fail:
+cdev_add_fail:
+ unregister_chrdev_region(devid, 1);
+chrdev_alloc_fail:
+ return ret;
+}
+
+/* Device exit routine */
+static void __exit micom_msg_exit(void)
+{
+ print_info("called\n");
+
+ mutex_destroy(&dev_msg_lock);
+
+ /* destroy micom msg sysfs device and class */
+ if (wt61p807_msg->msg_device != NULL) {
+ device_destroy(wt61p807_msg->msg_class,
+ MKDEV(wt61p807_msg->micom_msg_major, 0));
+ }
+ if (wt61p807_msg->msg_class != NULL)
+ class_destroy(wt61p807_msg->msg_class);
+
+ unregister_chrdev_region(MKDEV(wt61p807_msg->micom_msg_major, 0), 1);
+ return;
+}
+
+/* define module init/exit, license */
+subsys_initcall(micom_msg_init);
+module_exit(micom_msg_exit);
+
+MODULE_DESCRIPTION("Micom driver interface for Normal buffer data");
+MODULE_AUTHOR("Abhishek Jaiswal <abhishek1.j@samsung.com>");
+MODULE_LICENSE("GPL");
--- /dev/null
+/*
+ * MARU SDP Memory Driver
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Dongkyun Yun <dk77.yun@samsung.com>
+ * Jinhyung Choi <jinh0.choi@samsung.com>
+ * Hyunjin Lee <hyunjin816.lee@samsung.com>
+ * SangHo Park <sangho.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/ioctl.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/mm_types.h>
+#include <linux/miscdevice.h>
+#include <linux/vmalloc.h>
+
+#include "maru_dummy.h"
+
+#define DRV_NAME "sdp_mem"
+#define SDP_MEM_MINOR 193
+
+static LIST_HEAD(region_list);
+static DEFINE_MUTEX(region_mutex);
+
+struct sdp_mem_region
+{
+ struct list_head list;
+ unsigned long vm_pgoff;
+ unsigned long size;
+ void *vaddr;
+};
+
+static int
+sdp_mem_mmap(struct file * file, struct vm_area_struct * vma)
+{
+ int ret;
+ unsigned long size = vma->vm_end - vma->vm_start;
+ struct sdp_mem_region *region;
+ int pages;
+
+ maru_device_dbg(1, "[%d:%s] \n", current->pid, current->comm);
+
+ mutex_lock(®ion_mutex);
+
+ list_for_each_entry(region, ®ion_list, list) {
+ if( region->vm_pgoff == vma->vm_pgoff ) {
+ if( region->size != size ) {
+ maru_device_err("size mismatch \n");
+ /* TODO: use first mapping size */
+ size = region->size;
+ }
+ maru_device_dbg(1, "pgoff %lx found \n", vma->vm_pgoff);
+ goto found;
+ }
+ }
+
+ maru_device_dbg(1, "pgoff %lx not found \n", vma->vm_pgoff);
+
+ region = kzalloc(sizeof(struct sdp_mem_region), GFP_KERNEL);
+ if (!region) {
+ maru_device_err("kzalloc fail \n");
+ ret = -ENOMEM;
+ goto error;
+ }
+
+ region->vm_pgoff = vma->vm_pgoff;
+ region->size = size;
+
+ pages = PAGE_ALIGN(size);
+ region->vaddr = vmalloc_user(pages);
+ if (!region->vaddr) {
+ maru_device_err("vmalloc_user fail \n");
+ kfree(region);
+ ret = -ENOMEM;
+ goto error;
+ }
+ list_add_tail(®ion->list, ®ion_list);
+
+ maru_device_dbg(1, "vaddr(%p) with size(%lu) \n", region->vaddr, size);
+
+found:
+
+ /* Try to remap memory */
+ ret = remap_vmalloc_range(vma, region->vaddr, 0);
+ if (ret) {
+ maru_device_err("remap_vmalloc_range failed (ret:%d) \n", ret);
+ goto error;
+ }
+
+ maru_device_info("%s/%d mmap phy addr(0x%lx, size:%lu) to 0x%p\n",
+ current->comm, current->pid, vma->vm_pgoff, size, region->vaddr);
+
+error:
+ mutex_unlock(®ion_mutex);
+ return ret;
+}
+
+static int sdp_mem_open(struct inode *inode, struct file *file)
+{
+ maru_device_dbg(1, "open\n");
+ return 0;
+}
+
+
+static int sdp_mem_close(struct inode *inode, struct file *file)
+{
+ maru_device_dbg(1, "close\n");
+ return 0;
+}
+
+static const struct file_operations sdp_mem_fops = {
+ .owner = THIS_MODULE,
+ .open = sdp_mem_open,
+ .release = sdp_mem_close,
+ .mmap = sdp_mem_mmap,
+};
+
+static struct miscdevice sdp_mem_dev = {
+ .minor = SDP_MEM_MINOR,
+ .name = DRV_NAME,
+ .fops = &sdp_mem_fops
+};
+
+static int __init maru_sdp_mem_init(void)
+{
+ int ret_val = 0;
+
+ ret_val = misc_register(&sdp_mem_dev);
+
+ if(ret_val){
+ maru_device_err("misc_register is failed.");
+ return ret_val;
+ }
+
+ maru_device_info("sdp_mem initialized.");
+
+ return ret_val;
+}
+
+static void __exit maru_sdp_mem_exit(void)
+{
+ misc_deregister(&sdp_mem_dev);
+}
+
+module_init(maru_sdp_mem_init);
+module_exit(maru_sdp_mem_exit);
--- /dev/null
+/*
+ * MARU security driver
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjin Lee <hyunjin816.lee@samsung.com>
+ * SangHo Park <sangho1206.park@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/init.h>
+#include <linux/mutex.h>
+#include <linux/pagemap.h>
+#include <linux/sched.h>
+#include <linux/device.h>
+#include <linux/cdev.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <linux/interrupt.h>
+
+#define SECURITY_DEV_NAME "security"
+
+static unsigned security_debug = 0;
+static struct class *security_class;
+static struct cdev security_cdev;
+dev_t security_dev;
+
+module_param(security_debug, int, 0644);
+MODULE_PARM_DESC(security_debug, "Turn on/off maru security debugging (default:off).");
+
+#define maru_security_err(fmt, arg...) \
+ printk(KERN_ERR "[ERR]maru_security[%s]: " fmt, __func__, ##arg)
+
+#define maru_security_warn(fmt, arg...) \
+ printk(KERN_WARNING "[WARN]maru_security[%s]: " fmt, __func__, ##arg)
+
+#define maru_security_info(fmt, arg...) \
+ printk(KERN_INFO "[INFO]maru_security[%s]: " fmt, __func__, ##arg)
+
+#define maru_security_dbg(level, fmt, arg...) \
+ do { \
+ if (security_debug >= (level)) { \
+ printk(KERN_ERR "[DBG]maru_security[%s]: " fmt, \
+ __func__, ##arg); \
+ } \
+ } while (0)
+#define SECURITY_G_SEQNUM _IOR('S', 0, unsigned int)
+
+struct security_information {
+ unsigned int seq_num;
+};
+
+/* -----------------------------------------------------------------
+ file operations
+ ------------------------------------------------------------------*/
+static int maru_security_open(struct inode *inode, struct file *file)
+{
+ int ret = 0;
+ struct security_information *sec_info;
+
+ maru_security_dbg(5, "[security]enter.\n");
+
+ sec_info = kzalloc(sizeof(struct security_information), GFP_KERNEL);
+ if (!sec_info) {
+ maru_security_err("kzalloc() failed\n");
+ ret = -ENOMEM;
+ goto enomem;
+ }
+
+ sec_info->seq_num = 0;
+ file->private_data = sec_info;
+
+enomem:
+ return ret;
+}
+
+static long maru_security_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ int ret = 0;
+ struct security_information *sec_info = file->private_data;
+ int __user *data = (int __user *)arg;
+
+ switch (cmd) {
+ case SECURITY_G_SEQNUM:
+ ret = copy_to_user(data, &sec_info->seq_num, sizeof(unsigned int));
+ if (ret) {
+ ret = -EFAULT;
+ break;
+ }
+ sec_info->seq_num++;
+ break;
+ default:
+ maru_security_info("[security] unsupported command : %08x.\n", cmd);
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static int maru_security_close(struct inode *inode, struct file *file)
+{
+ struct security_information *sec_info = file->private_data;
+
+ maru_security_dbg(5, "[security]enter.\n");
+
+ if (sec_info) {
+ kfree(sec_info);
+ sec_info = NULL;
+ }
+
+ return 0;
+}
+
+static const struct file_operations maru_security_fops = {
+ .open = maru_security_open,
+ .unlocked_ioctl = maru_security_ioctl,
+ .release = maru_security_close,
+};
+
+/* -----------------------------------------------------------------
+ Initialization
+ ------------------------------------------------------------------*/
+static int __init maru_security_init(void)
+{
+ int ret = 0;
+
+ /* allocate character device */
+ ret = alloc_chrdev_region(&security_dev, 0, 1, SECURITY_DEV_NAME);
+ if (ret < 0) {
+ maru_security_err("security alloc_chrdev_region failed.\n");
+ goto alloc_chrdev_region_err;
+ }
+
+ /* create class */
+ security_class = class_create(THIS_MODULE, SECURITY_DEV_NAME);
+ if (IS_ERR(security_class)) {
+ ret = PTR_ERR(security_class);
+ maru_security_err("create security class failed.\n");
+ goto create_class_err;
+ }
+
+ /* character device initialize */
+ cdev_init(&security_cdev, &maru_security_fops);
+
+ ret = cdev_add(&security_cdev, security_dev, 1);
+ if (ret < 0) {
+ maru_security_err("security cdev_add failed\n");
+ goto cdev_add_err;
+ }
+
+ /* create device */
+ device_create(security_class, 0, security_dev, NULL, "%s", SECURITY_DEV_NAME);
+
+ maru_security_info("security driver was registerd.\n");
+
+ return ret;
+
+cdev_add_err:
+ class_destroy(security_class);
+create_class_err:
+ unregister_chrdev_region(security_dev, 1);
+alloc_chrdev_region_err:
+ return ret;
+}
+
+static void __exit maru_security_exit(void)
+{
+ cdev_del(&security_cdev);
+ class_destroy(security_class);
+ unregister_chrdev_region(security_dev, 1);
+
+ maru_security_info("security driver was exited.\n");
+}
+
+module_init(maru_security_init);
+module_exit(maru_security_exit);
\ No newline at end of file
--- /dev/null
+/*
+ * MARU EEPROM
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Dongkyun Yun <dk77.yun@samsung.com>
+ * Munkyu Im <munkyu.im@samsung.com>
+ * Sangho Park <sangho.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+#include <asm/current.h>
+#include <linux/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/jiffies.h>
+#include <linux/device.h>
+#include <linux/export.h>
+#include <linux/mutex.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/of_gpio.h>
+#include <linux/version.h>
+#include <linux/moduleparam.h>
+#include <linux/cdev.h>
+#include <linux/file.h>
+#include "maru_eeprom.h"
+#include <linux/vmalloc.h>
+
+//#define EEP_DEBUG
+
+#ifdef EEP_DEBUG
+#define eep_log(fmt, arg...) \
+ printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, EEPROM_DEV_NAME, \
+ __func__, __LINE__, current->comm, current->pid, ##arg);
+#else
+#define eep_log(fmt, arg...)
+#endif
+
+#define eep_err(fmt, arg...) \
+ printk(KERN_ERR "[%s](%s)[%s:%d]: " fmt, EEPROM_DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+#define eep_warn(fmt, arg...) \
+ printk(KERN_WARNING "[%s](%s)[%s:%d]: " fmt, EEPROM_DEV_NAME, __func__, \
+ current->comm, current->pid, ##arg);
+#define eep_info(fmt, arg...) \
+ printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, EEPROM_DEV_NAME, __func__, __LINE__, \
+ current->comm, current->pid, ##arg);
+
+
+
+#define FILENAME "/boot/eeprom"
+
+#define true 1
+#define false 0
+
+/* device protocol */
+enum req_cmd {
+ req_eeprom_get = 1,
+ req_eeprom_set,
+ req_eeprom_reply
+};
+
+/* eeprom specific macros */
+#define EEP_BLOCK_SIZE 4096
+#define EEP_BLOCK_COUNT 16
+#define EEPROM_MAX_SIZE (EEP_BLOCK_SIZE * EEP_BLOCK_COUNT)
+#define MAX_ATTR_BYTES 6
+
+/* 10 milliseconds of delay is required after each i2c write operation */
+//#define DELAY 10000
+
+/* upper/lower 8-bit word address macros */
+#define HI_BYTE(x) (((x) >> 8) & (0x00FF))
+#define LO_BYTE(x) ((x) & (0x00FF))
+
+/* define global mutex statically ***/
+static DEFINE_MUTEX(eep_mutex);
+
+/* global variables for this module ***/
+static int counter;
+static const unsigned int eeprom_size = EEPROM_MAX_SIZE;
+static int eeprom_dev_major;
+//static struct i2c_client *eep_client;
+
+/* write protection for eeprom */
+static int g_protect;
+
+static struct file *g_file;
+
+static ssize_t eeprom_write_file(const unsigned char __user *buf, int len, loff_t pos)
+{
+ ssize_t ret = 0;
+ mm_segment_t old_fs;
+
+ if (g_file == NULL)
+ return -ENODEV;
+
+ if (g_protect) {
+ eep_info("memory is protected.\n");
+ return ret;
+ }
+ old_fs = get_fs();
+ set_fs(KERNEL_DS);
+
+ ret = vfs_write(g_file, buf, len, &pos);
+ if (ret != len) {
+ eep_warn("len mismatch ret: %zi, len: %d, pos: %lld\n", ret, len, pos);
+ }
+ set_fs(old_fs);
+
+ return ret;
+}
+
+static int eeprom_init_file(void)
+{
+ unsigned int i;
+ loff_t pos = 0;
+ int ret = 0;
+ int reminder_pos = 0;
+ unsigned char *buf = vmalloc(EEP_BLOCK_SIZE);
+ if (!buf) {
+ eep_warn("memory not allocated for buffer.\n");
+ ret = -ENOMEM;
+ goto out_ext;
+ }
+ memset(buf, 0xff, EEP_BLOCK_SIZE);
+
+ for (i = 0; i < EEP_BLOCK_COUNT; i++) {
+ ret = eeprom_write_file(buf, EEP_BLOCK_SIZE, pos);
+ if (ret < 0) {
+ eep_warn("failed to initialize. ret: %d\n", ret);
+ goto out_ext;
+ } else if (ret < EEP_BLOCK_SIZE) {
+ eep_info("write reminder.\n");
+ reminder_pos = ret;
+ do {
+ ret = eeprom_write_file(buf, EEP_BLOCK_SIZE - reminder_pos, pos + reminder_pos);
+ if (ret <= 0) {
+ eep_warn("failed to write reminder. ret: %d\n", ret);
+ goto out_ext;
+ }
+ reminder_pos += ret;
+ } while (reminder_pos != EEP_BLOCK_SIZE);
+ }
+ pos += EEP_BLOCK_SIZE;
+ }
+ ret = pos;
+ vfree(buf);
+ eep_info("file initialized: %s\n", FILENAME);
+
+out_ext:
+ return ret;
+}
+
+static int eeprom_open_file(void)
+{
+ struct file *file;
+ eep_log("eeprom_open_file\n");
+
+ file = filp_open(FILENAME, O_CREAT|O_RDWR|O_EXCL|O_SYNC, 0666);
+ if (IS_ERR(file)) {
+ eep_info("file already exists: %s\n", FILENAME);
+ file = filp_open(FILENAME, O_CREAT|O_RDWR|O_SYNC, 0666);
+ if (IS_ERR(file)) {
+ eep_warn("filp_open failed.\n");
+ return -ENOENT;
+ }
+ g_file = file;
+ return 0;
+ }
+ g_file = file;
+
+ return eeprom_init_file();
+}
+
+static ssize_t eeprom_read_file(unsigned char __user *buf, int len, loff_t pos)
+{
+ ssize_t ret = 0;
+ mm_segment_t old_fs;
+
+ if (g_file == NULL)
+ return -ENODEV;
+
+ eep_log("pos(%lld) len(%d) \n", pos, len);
+
+ old_fs = get_fs();
+ set_fs(KERNEL_DS);
+
+ ret = vfs_read(g_file, buf, len, &pos);
+ if (ret != len) {
+ eep_warn("len mismatch ret: %zi, len: %d, pos: %lld\n", ret, len, pos);
+ }
+ set_fs(old_fs);
+
+ return ret;
+}
+
+static int eeprom_usr_write(const char __user *buf, size_t count, unsigned long addr)
+{
+ int ret = -EFAULT;
+
+ eep_log("eep write.\n");
+ if (!buf) {
+ eep_err("Invalid User buffer.\n");
+ } else if (count > 0) {
+ if (addr + count > eeprom_size) {
+ eep_err("overflow!!.\n");
+ goto out_err;
+ }
+ ret = eeprom_write_file(buf, count, addr);
+ if (ret < 0) {
+ eep_warn("Write failed.\n");
+ }
+ } else {
+ eep_warn("inavalid count.\n");
+ }
+
+out_err:
+ return ret;
+}
+
+static ssize_t eeprom_usr_read(char __user *buf, size_t count, unsigned long addr)
+{
+ int ret = -EFAULT;
+
+ eep_log("eep read.\n");
+ if (!buf) {
+ eep_err("User buf has no memory allocation.\n");
+ } else if (count > 0) {
+ if (count + addr > eeprom_size) {
+ eep_err("overflow!!.\n");
+ goto out_err;
+ }
+ ret = eeprom_read_file(buf, count, addr);
+ if (ret < 0) {
+ eep_warn("read failed.\n");
+ }
+ } else {
+ eep_warn("invalid count.\n");
+ }
+
+out_err:
+ return ret;
+}
+
+
+
+
+/* for using sysfs. (class, device, device attribute) */
+
+/** @brief This function inhibits the write operation on eeprom.
+ *
+ * @param [in] protect value(0 or 1).
+ * 1 - To protect memory.
+ * 0 - To unprotect memory.
+ * @return On success Returns 0.
+ * On failure Returns negative error number.
+ */
+int eep_set_wp(int protect)
+{
+ int ret = 0;
+
+ if (protect != 0 && protect != 1) {
+ eep_warn("invalid input.\n");
+ return -EINVAL;
+ }
+
+ g_protect = protect;
+ eep_log("eeprom => %d (1:locked, 0:unlocked)\n", g_protect);
+
+ return ret;
+}
+EXPORT_SYMBOL(eep_set_wp);
+
+/**
+ * @brief Returns the status of eeprom write protection.
+ *
+ * @param [in] void It takes no arguments.
+ *
+ * @return On success Returns 0.
+ * On failure Returns negative error number.
+ */
+int eep_get_wp()
+{
+ int ret = 0;
+
+ ret = g_protect;
+ eep_log("eeprom => %d (1:locked, 0:unlocked)\n", g_protect);
+
+ return ret;
+}
+EXPORT_SYMBOL(eep_get_wp);
+
+/**
+ * @brief This function resets the whole eeprom chip.
+ *
+ * @parms [in] void It takes no arguments.
+ *
+ * @return On success Returns 0.
+ * On failure Returns negative error number.
+ */
+static int eep_reset(void)
+{
+ return eeprom_init_file();
+}
+
+/**
+ * @brief This function opens the eeprom device.
+ *
+ * @param inode inode.
+ * @param [in] fp File pointer points to the file descriptor.
+ *
+ * @return On success Returns 0.
+ * On failure Returns negative error number.
+ */
+int eep_open(struct inode *inode, struct file *fp)
+{
+ int ret = 0;
+
+ mutex_lock(&eep_mutex);
+ if (counter == 0) {
+ eeprom_open_file();
+ } else if (g_file == NULL) {
+ eep_warn("g_file is NULL\n");
+ ret = -ENODEV;
+ goto out;
+ } else {
+ //Increase reference count of g_file
+ atomic_long_inc_not_zero(&g_file->f_count);
+ }
+
+ counter++;
+ eep_log("Open: #:%d\n" , counter);
+ //eep_log("major number=%d, minor number=%d \n", imajor(inode), iminor(inode));
+out:
+ mutex_unlock(&eep_mutex);
+
+ return ret;
+}
+
+/**
+ * @brief This function undo the all open call operations.
+ *
+ * @param inode inode.
+ * @param [in] fp File pointer points to the file descriptor.
+ *
+ * @return On success Returns 0.
+ * On failure Returns negative error number.
+ */
+int eep_close(struct inode *inode, struct file *fp)
+{
+ int ret = 0;
+
+ eep_log("close.\n");
+
+ mutex_lock(&eep_mutex);
+ BUG_ON(g_file == NULL);
+ fput(g_file);
+ counter--;
+ mutex_unlock(&eep_mutex);
+ return ret;
+}
+
+/**
+ * @brief The lseek method is used to change the current read/write position
+ * in a file
+ *
+ * @param [in] fp File pointer points to the file descriptor.
+ * @param [in] offset Offset.
+ * @param [in] origin Origin.
+ *
+ * @return On success The new position(resulting offset) is returned.
+ * On failure Returns negative error number.
+ */
+loff_t eep_lseek(struct file *fp, loff_t offset, int origin)
+{
+ loff_t current_offset = 0;
+
+ eep_log("lseek.\n");
+
+ mutex_lock(&eep_mutex);
+
+ switch (origin) {
+ case SEEK_SET:
+ current_offset = offset;
+ break;
+ case SEEK_CUR:
+ current_offset = fp->f_pos + offset;
+ break;
+ case SEEK_END:
+ current_offset = eeprom_size - offset;
+ break;
+ default:
+ break;
+ }
+ if (current_offset >= eeprom_size) {
+ eep_err("offset overflow!\n");
+ current_offset = eeprom_size - 1;
+ } else if (current_offset < 0) {
+ eep_err("offset underflow!\n");
+ current_offset = 0;
+ }
+
+ fp->f_pos = current_offset;
+
+ mutex_unlock(&eep_mutex);
+ return current_offset;
+}
+
+/**
+ * @brief This function reads the data from eeprom device.
+ *
+ * @param [in] fp File pointer points to the file descriptor.
+ * @param [in] buf Pointer to the user space buffer.
+ * @param [in] count Number of bytes application intend to read.
+ * @param [in/out] pos Current file offset position.
+ *
+ * @return On success Returns count(number of read bytes).
+ * On failure Returns negative error number.
+ */
+ssize_t eep_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)
+{
+ int ret = 0;
+
+ mutex_lock(&eep_mutex);
+ ret = eeprom_usr_read(buf, count, fp->f_pos);
+ if (ret < 0) {
+ eep_warn("eep_read failed. ret: %d", ret);
+ }
+ mutex_unlock(&eep_mutex);
+
+ return ret;
+}
+
+/**
+ * @brief This function writes the data to eeprom device.
+ *
+ * @param [in] fp File pointer points to the file descriptor.
+ * @param [in] buf Pointer to the user space buffer.
+ * @param [in] count Number of bytes application intend to write.
+ * @param [in/out] pos Current file offset position.
+ *
+ * @return On success Returns count(the number of bytes successfully written).
+ * On failure Returns negative error number.
+ */
+ssize_t eep_write(struct file *fp, const char __user *buf,
+ size_t count, loff_t *pos)
+{
+ int ret = 0;
+
+ mutex_lock(&eep_mutex);
+ ret = eeprom_usr_write(buf, count, fp->f_pos);
+ if (ret < 0) {
+ eep_warn("eep_write failed. ret: %d", ret);
+ }
+ mutex_unlock(&eep_mutex);
+
+ return ret;
+}
+
+
+/**
+ * @brief This function performs control operations on eeprom.
+ *
+ * @param [in] fp File pointer points to the file descriptor.
+ * @param [in] cmd Request command.
+ * @param [in/out] args The arguments based on request command.
+ *
+ * @return On Success Returns zero.
+ * On failure Returns negative error number.
+ */
+long eep_ioctl(struct file *fp, unsigned int cmd, unsigned long args)
+{
+ int protect = 0, size;
+ long ret = 0;
+
+ eep_log("ioctl.\n");
+
+ /*verify args*/
+ if (_IOC_TYPE(cmd) != EEPROM_MAGIC)
+ return -ENOTTY;
+ if (_IOC_NR(cmd) > EEPROM_MAX_CMDS)
+ return -ENOTTY;
+ if (_IOC_DIR(cmd) & _IOC_READ)
+ if (!access_ok(VERIFY_WRITE, (void *)args, _IOC_SIZE(cmd)))
+ return -EFAULT;
+ if (_IOC_DIR(cmd) & _IOC_WRITE)
+ if (!access_ok(VERIFY_READ, (void *)args, _IOC_SIZE(cmd)))
+ return -EFAULT;
+ mutex_lock(&eep_mutex);
+ switch (cmd) {
+ case EEPROM_RESET:
+ eep_reset();
+ break;
+ case EEPROM_SET_WP:
+ if (copy_from_user(&protect, (int *)args, sizeof(int))) {
+ eep_warn("failed copy_from_user.\n");
+ return -EFAULT;
+ }
+ eep_set_wp(protect);
+ break;
+ case EEPROM_GET_WP:
+ protect = eep_get_wp();
+ if (copy_to_user((int *)args, &protect, sizeof(int))) {
+ eep_warn("failed copy_to_user.\n");
+ ret = -EFAULT;
+ }
+ break;
+ case EEPROM_GET_SIZE:
+ size = eeprom_size;
+ if (copy_to_user((int *)args, &size, sizeof(int))) {
+ eep_warn("failed copy_to_user.\n");
+ ret = -EFAULT;
+ }
+ break;
+ case EEPROM_WRITE_DATA:
+ case EEPROM_READ_DATA:
+ {
+ struct eeprom_io_pkt *pkt = (struct eeprom_io_pkt *)args;
+ if (cmd == EEPROM_WRITE_DATA)
+ ret = eeprom_usr_write(pkt->wbuf, pkt->size, pkt->addr);
+ else
+ ret = eeprom_usr_read(pkt->rbuf, pkt->size, pkt->addr);
+ if (ret < 0) {
+ eep_warn("failed handle eeprom data: %ld", ret);
+ }
+ }
+ break;
+ default:
+ eep_warn("invalid cmd %d \n", cmd);
+ ret = -EFAULT;
+ break;
+ }
+ mutex_unlock(&eep_mutex);
+ return ret;
+}
+
+/**
+ * @brief This function will be called when the user read from sysfs.
+ *
+ * @param [in] dev device.
+ * @param [in] attr device attributes.
+ * @param [in/out] buf buffer.
+ *
+ * @return On success Returns maxlen characters pointed to by buf.
+ * On failure Returns negative error number.
+ */
+static ssize_t nvram_size_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ eep_log("called.\n");
+
+ mutex_lock(&eep_mutex);
+ snprintf(buf, sizeof(int), "%d", eeprom_size);
+ mutex_unlock(&eep_mutex);
+ return strnlen(buf, MAX_ATTR_BYTES);
+}
+
+/* for using sysfs. (class, device, device attribute) */
+static struct class *eep_class;
+static struct device *eep_dev;
+static DEVICE_ATTR_RO(nvram_size);
+
+static const struct of_device_id eepdev_of_match[] = {
+ { .compatible = "sii,s24c512c" },
+ {},
+};
+MODULE_DEVICE_TABLE(of, eepdev_of_match);
+
+/**
+ * Devices are identified using device id
+ * of the chip
+ */
+static const struct i2c_device_id eep_i2c_id[] = {
+ { "s24c512c", 0 },
+ {},
+};
+MODULE_DEVICE_TABLE(i2c, eep_i2c_id);
+
+/* device number */
+dev_t eeprom_dev_num;
+
+/* function pointers for file operations */
+static const struct file_operations eep_drv_fops = {
+ .llseek = eep_lseek,
+ .read = eep_read,
+ .open = eep_open,
+ .release = eep_close,
+ .write = eep_write,
+ .unlocked_ioctl = eep_ioctl,
+ .owner = THIS_MODULE,
+};
+
+
+/* Device initialization routine */
+static int __init eep_init(void)
+{
+ int res = 0;
+
+ eep_info("init!!\n");
+
+ counter = 0;
+ eeprom_dev_major = 0;
+ eeprom_dev_num = 0;
+ eep_dev = NULL;
+ eep_class = NULL;
+ //eep_client = NULL;
+
+ /* register device with file operation mappings
+ * for dynamic allocation of major number
+ */
+ res = register_chrdev(eeprom_dev_major, EEPROM_DEV_NAME, &eep_drv_fops);
+ if (res < 0) {
+ eep_err("failed to get major number.\n");
+ goto out;
+ }
+ /* if the allocation is dynamic ?*/
+ if (res != 0)
+ eeprom_dev_major = res;
+
+ eeprom_dev_num = MKDEV(eeprom_dev_major, 0);
+
+ /* create class. (/sys/class/eep_class) */
+ eep_class = class_create(THIS_MODULE, "eep_class");
+ if (IS_ERR(eep_class)) {
+ res = PTR_ERR(eep_class);
+ goto out_unreg_chrdev;
+ }
+ /* create class device. (/sys/class/eep_class/eeprom) */
+ eep_dev = device_create(eep_class, NULL, eeprom_dev_num, NULL,
+ "eeprom");
+
+ if (IS_ERR(eep_dev)) {
+ res = PTR_ERR(eep_dev);
+ goto out_unreg_class;
+ }
+ /* create sysfs file. (/sys/class/eep_class/eeprom/nvram_size) */
+ res = device_create_file(eep_dev, &dev_attr_nvram_size);
+ if (res) {
+ eep_err("failed to create sysfs.\n");
+ goto out_unreg_device;
+ }
+
+ return res;
+
+ //out_unreg_sysfs:
+ // device_remove_file(eep_dev, &dev_attr_nvram_size);
+out_unreg_device:
+ device_destroy(eep_class, eeprom_dev_num);
+out_unreg_class:
+ class_destroy(eep_class);
+out_unreg_chrdev:
+ unregister_chrdev(eeprom_dev_major, EEPROM_DEV_NAME);
+out:
+ return res;
+}
+
+/* Device exit routine */
+static void __exit eep_exit(void)
+{
+ eep_info("Exit!!\n");
+
+ /* remove sysfs file */
+ device_remove_file(eep_dev, &dev_attr_nvram_size);
+ /* remove class device */
+ device_destroy(eep_class, eeprom_dev_num);
+ /* remove class */
+ class_destroy(eep_class);
+ //i2c_del_driver(&eep_i2c_driver);
+ /* unregister device */
+ unregister_chrdev(eeprom_dev_major, EEPROM_DEV_NAME);
+
+ /* for emulator */
+}
+
+/* define module init/exit, license */
+subsys_initcall(eep_init);
+module_exit(eep_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Dronamraju Santosh Pavan Kumar, <dronamraj.k@samsung.com>");
--- /dev/null
+/**
+ *
+ * Copyright (c) 2013 Samsung Electronics Co. Ltd.
+ * Copyright (C) 2013 Samsung R&D Institute India-Delhi.
+ * Author: Dronamraju Santosh Pavan Kumar <dronamraj.k@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * @file eeprom.h
+ * @brief Header file for the eeprom_s24c512c eeprom chip.
+ * @author Dronamraju Santosh pavan Kumar <dronamraj.k@samsung.com>
+ * @date 2013/07/12
+ *
+ */
+
+/* internal Release1 */
+
+#ifndef _EEPROM_H
+#define _EEPROM_H
+
+#include<asm-generic/ioctl.h>
+
+#define EEPROM_MAGIC 'I'
+#define EEPROM_LOCAL_BUFF_SIZE 128
+
+/*device name*/
+#define EEPROM_DEV_NAME "eeprom"
+
+struct eeprom_io_pkt {
+ unsigned int addr;
+ unsigned int size;
+ const char *wbuf;
+ char *rbuf;
+};
+
+#define EEPROM_RESET _IOW(EEPROM_MAGIC, 0x01, int)
+#define EEPROM_SET_WP _IOW(EEPROM_MAGIC, 0x02, int)
+#define EEPROM_GET_WP _IOR(EEPROM_MAGIC, 0x03, int)
+#define EEPROM_GET_SIZE _IOR(EEPROM_MAGIC, 0x04, int)
+#define EEPROM_WRITE_DATA _IOW(EEPROM_MAGIC, 0x05, struct eeprom_io_pkt *)
+#define EEPROM_READ_DATA _IOR(EEPROM_MAGIC, 0x06, struct eeprom_io_pkt *)
+#define EEPROM_SLAVE_ADDR 0x50
+#define EEPROM_MAX_CMDS 6
+
+/* function prototypes */
+int eep_i2c_write(unsigned int addr, const unsigned char *buf, int len);
+int eep_reg_write(unsigned int reg, const unsigned char *buf, int len);
+int eep_reg_read(unsigned int reg, unsigned char *buf, int len);
+int eep_set_wp(int protect);
+int eep_get_wp(void);
+ssize_t eeprom_dev_write(char *buf, size_t count, unsigned long addr);
+ssize_t eeprom_dev_read(char *buf, size_t count, unsigned long addr);
+
+#endif /*_EEPROM_H */
+++ /dev/null
-obj-$(CONFIG_MARU_DUMMY) += maru_dummy.o
-obj-$(CONFIG_MARU_SECURITY) += maru_dummy_security.o
-obj-$(CONFIG_MARU_SDP_MEM) += maru_dummy_sdp_mem.o
-obj-$(CONFIG_MARU_GPIO) += maru_dummy_gpio.o
-obj-$(CONFIG_MARU_I2C_SDP) += maru_dummy_i2c_sdp.o
-obj-$(CONFIG_MARU_MICOM_MSG) += maru_dummy_micom_msg.o
-obj-$(CONFIG_MARU_MICOM_ISP) += maru_dummy_micom_isp.o
\ No newline at end of file
+++ /dev/null
-/*
- * MARU dummy driver
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jinhyung Choi <jinh0.choi@samsung.com>
- * Hyunjin Lee <hyunjin816.lee@samsung.com>
- * SangHo Park <sangho.p@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/ioctl.h>
-#include <linux/slab.h>
-#include <linux/device.h>
-#include <linux/cdev.h>
-
-#include <linux/mm.h>
-#include <linux/mm_types.h>
-
-#include "maru_dummy.h"
-
-struct dummy_device {
- const char *name;
- struct class *dev_class;
- struct device* dev_device;
- struct cdev cdev;
- dev_t dev;
- struct file_operations fops;
-};
-
-static DECLARE_WAIT_QUEUE_HEAD(wq);
-
-int dummy_driver_debug = 0;
-module_param(dummy_driver_debug, int, 0644);
-MODULE_PARM_DESC(dummy_driver_debug, "Turn on/off maru dummy debugging (default:off).");
-
-#define GENERATE_ACCESSORS_DEV(_dev) \
-static int maru_##_dev##_open(struct inode *inode, struct file *file) \
-{ \
- maru_device_dbg(1, "open is called.\n"); \
- return 0; \
-} \
-static int maru_##_dev##_close(struct inode *inode, struct file *file) \
-{ \
- maru_device_dbg(1, "close is called.\n"); \
- return 0; \
-} \
-static long maru_##_dev##_ioctl(struct file *file, unsigned int cmd, unsigned long arg) \
-{ \
- maru_device_dbg(1, "ioctl cmd : 0x%08x, arg : 0x%08lx\n", cmd, arg); \
- return 0; \
-} \
-static ssize_t maru_##_dev##_write(struct file *file, const char __user *buf, \
- size_t len, loff_t *ppos) \
-{ \
- maru_device_dbg(1, "write is called. size: %d, buf: %s, \n", len, buf); \
- return len; \
-} \
-static unsigned int maru_##_dev##_poll(struct file *file, struct poll_table_struct *wait) \
-{ \
- return 0; \
-}
-
-#define __ATTRIBUTE_DUMMY_DEVICE(_name) { \
- .name = __stringify(_name), \
- .fops = { \
- .open = maru_##_name##_open, \
- .unlocked_ioctl = maru_##_name##_ioctl, \
- .write = maru_##_name##_write, \
- .poll = maru_##_name##_poll, \
- .release = maru_##_name##_close \
- }, \
-}
-
-#define __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(_name, _fname) {\
- .name = __stringify(_name), \
- .fops = { \
- .open = maru_##_fname##_open, \
- .unlocked_ioctl = maru_##_fname##_ioctl,\
- .write = maru_##_fname##_write, \
- .poll = maru_##_fname##_poll, \
- .release = maru_##_fname##_close \
- }, \
-}
-
-GENERATE_ACCESSORS_DEV(tztv_frc)
-GENERATE_ACCESSORS_DEV(tztv_tcon)
-GENERATE_ACCESSORS_DEV(micom_cec)
-GENERATE_ACCESSORS_DEV(micom_ar)
-GENERATE_ACCESSORS_DEV(micom_bsensor)
-GENERATE_ACCESSORS_DEV(kfactory)
-
-struct dummy_device dummy_device_group[] = {
- __ATTRIBUTE_DUMMY_DEVICE(tztv_frc),
- __ATTRIBUTE_DUMMY_DEVICE(tztv_tcon),
- __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(micom-cec, micom_cec),
- __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(micom-ar, micom_ar),
- __ATTRIBUTE_HYPHEN_DUMMY_DEVICE(micom-bsensor, micom_bsensor),
- __ATTRIBUTE_DUMMY_DEVICE(kfactory),
-};
-
-static void remove_device(struct dummy_device *device)
-{
- if (device == NULL) {
- return;
- }
-
- if (device->dev_device) {
- device_destroy(device->dev_class, device->dev);
- device->dev_device = NULL;
- }
-
- if (device->dev) {
- unregister_chrdev_region(device->dev, 1);
- }
-
- if (device->dev_class) {
- class_destroy(device->dev_class);
- }
-}
-
-static int create_device(struct dummy_device *device)
-{
- int ret = 0;
-
- if (device == NULL) {
- maru_device_err("failed to create device: device == NULL \n");
- return ret;
- }
-
- ret = alloc_chrdev_region(&device->dev, 0, 1, device->name);
- if (ret < 0) {
- maru_device_err("%s alloc_chrdev_region failed.\n", device->name);
- return ret;
- }
-
- device->dev_class = class_create(THIS_MODULE, device->name);
- if (IS_ERR(device->dev_class)) {
- ret = PTR_ERR(device->dev_class);
- maru_device_err("create %s class failed.\n", device->name);
- remove_device(device);
- return ret;
- }
-
- cdev_init(&device->cdev, &device->fops);
-
- ret = cdev_add(&device->cdev, device->dev, 1);
- if (ret < 0) {
- maru_device_err("%s cdev_add failed\n", device->name);
- remove_device(device);
- return ret;
- }
-
- device->dev_device = device_create(device->dev_class, 0, device->dev, NULL, "%s", device->name);
- if (ret < 0) {
- maru_device_err("%s device_create failed\n", device->name);
- remove_device(device);
- return ret;
- }
-
- return 0;
-}
-
-static int __init maru_dummy_init(void)
-{
- int ret = 0;
- int i = 0;
- int size = sizeof(dummy_device_group) / sizeof(dummy_device_group[0]);
-
- for (i = 0; i < size; i++) {
- ret = create_device(&dummy_device_group[i]);
- if (ret < 0)
- continue;
- }
-
- maru_device_info("dummy driver was initialized.\n");
-
- return 0;
-}
-
-static void __exit maru_dummy_exit(void)
-{
- int i = 0;
- int size = sizeof(dummy_device_group) / sizeof(dummy_device_group[0]);
-
- for (i = 0; i < size; i++) {
- remove_device(&dummy_device_group[i]);
- }
-
- maru_device_info("dummy driver was exited.\n");
-}
-
-module_init(maru_dummy_init);
-module_exit(maru_dummy_exit);
\ No newline at end of file
+++ /dev/null
-/*
- * MARU dummy driver
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jinhyung Choi <jinh0.choi@samsung.com>
- * Hyunjin Lee <hyunjin816.lee@samsung.com>
- * SangHo Park <sangho.p@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#ifndef _MARU_DUMMY_H
-#define _MARU_DUMMY_H
-
-extern int dummy_driver_debug;
-
-#define maru_device_err(fmt, arg...) \
- printk(KERN_ERR "[ERR][%s]: " fmt, __func__, ##arg)
-
-#define maru_device_warn(fmt, arg...) \
- printk(KERN_WARNING "[WARN][%s]: " fmt, __func__, ##arg)
-
-#define maru_device_info(fmt, arg...) \
- printk(KERN_INFO "[INFO][%s]: " fmt, __func__, ##arg)
-
-#define maru_device_dbg(log_level, fmt, arg...) \
- do { \
- if (dummy_driver_debug >= (log_level)) { \
- printk(KERN_INFO "[DEBUG][%s]: " fmt, __func__, ##arg); \
- } \
- } while (0)
-
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * MARU Dummy GPIO driver
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jinhyung Choi <jinh0.choi@samsung.com>
- * SangHo Park <sangho.p@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License13
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#include <linux/module.h>
-#include <linux/gpio.h>
-#include <linux/gpio/driver.h>
-#include <linux/platform_device.h>
-
-#include "maru_dummy.h"
-
-#define DRVNAME "maru_gpio"
-
-struct maru_gpio_dev {
- int addr;
-};
-
-struct maru_gpio {
- struct gpio_chip chip;
- struct maru_gpio_dev *dev;
-};
-
-static int maru_gpio_request(struct gpio_chip *chip, unsigned offset)
-{
- maru_device_dbg(1, "gpio request offset : %u\n", offset);
- return 0;
-}
-
-static int maru_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
-{
- maru_device_dbg(1, "gpio direction in offset : %u\n", offset);
- return 0;
-}
-
-static int maru_gpio_direction_out(struct gpio_chip *chip,
- unsigned offset, int value)
-{
- maru_device_dbg(1, "gpio direction out offset : %u, value : %d\n", offset, value);
- return 0;
-}
-
-static int maru_gpio_get(struct gpio_chip *chip, unsigned offset)
-{
- maru_device_dbg(1, "gpio get offset : %u\n", offset);
- return 0;
-}
-
-static void maru_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
-{
- maru_device_dbg(1, "gpio set offset : %u, value : %d\n", offset, value);
-}
-
-static int maru_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
-{
- maru_device_dbg(1, "gpio to irq offset : %u\n", offset);
- return 0;
-}
-
-static struct gpio_chip maru_gpio_chip = {
- .label = DRVNAME,
- .owner = THIS_MODULE,
- .request = maru_gpio_request,
- .direction_input = maru_gpio_direction_in,
- .direction_output = maru_gpio_direction_out,
- .get = maru_gpio_get,
- .set = maru_gpio_set,
- .to_irq = maru_gpio_to_irq,
- .can_sleep = 1,
- .ngpio = 255,
- .base = 1,
-};
-
-static int maru_gpio_probe(struct platform_device *pdev)
-{
- struct maru_gpio *maru_gpio;
- int ret;
-
- maru_gpio = devm_kzalloc(&pdev->dev, sizeof(*maru_gpio),
- GFP_KERNEL);
- if (maru_gpio == NULL){
- maru_device_err("Could not allocate maru_gpio\n");
- return -ENOMEM;
- }
-
- maru_gpio->chip = maru_gpio_chip;
- maru_gpio->chip.dev = &pdev->dev;
-
- ret = gpiochip_add(&maru_gpio->chip);
- if (ret < 0) {
- maru_device_err("Could not register maru gpiochip %d\n", ret);
- return ret;
- }
-
- platform_set_drvdata(pdev, maru_gpio);
-
- maru_device_info("maru gpio device probe done.\n");
-
- return ret;
-}
-
-void maru_gpio_remove(struct platform_device *pdev)
-{
- struct maru_gpio *maru_gpio = platform_get_drvdata(pdev);
-
- gpiochip_remove(&maru_gpio->chip);
-}
-
-static struct platform_device *maru_gpio_pdev;
-
-static int __init maru_gpio_device_add(const struct maru_gpio_dev *dev)
-{
- int err;
-
- maru_gpio_pdev = platform_device_alloc(DRVNAME, -1);
- if (!maru_gpio_pdev)
- return -ENOMEM;
-
- err = platform_device_add_data(maru_gpio_pdev, dev, sizeof(*dev));
- if (err) {
- maru_device_err("Platform data allocation failed\n");
- goto err;
- }
-
- err = platform_device_add(maru_gpio_pdev);
- if (err) {
- maru_device_err("Device addition failed\n");
- goto err;
- }
-
- maru_device_info("maru_gpio_device is added.\n");
- return 0;
-err:
- platform_device_put(maru_gpio_pdev);
-
- return err;
-}
-
-static struct platform_driver maru_gpio_driver = {
- .driver = {
- .name = DRVNAME,
- .owner = THIS_MODULE,
- },
- .probe = maru_gpio_probe,
- .remove = maru_gpio_remove,
-};
-
-static int __init maru_gpio_init(void)
-{
- int err;
- struct maru_gpio_dev dev;
-
- err = platform_driver_register(&maru_gpio_driver);
- if (!err) {
- err = maru_gpio_device_add(&dev);
- if (err)
- platform_driver_unregister(&maru_gpio_driver);
- }
-
- return err;
-}
-subsys_initcall(maru_gpio_init);
-
-static void __exit maru_gpio_exit(void)
-{
- platform_driver_unregister(&maru_gpio_driver);
-}
-module_exit(maru_gpio_exit);
-
-MODULE_AUTHOR("Jinhyung Choi");
-MODULE_DESCRIPTION("Maru Dummy GPIO driver");
-MODULE_LICENSE("GPL");
+++ /dev/null
-/*
- * MARU Dummy I2C SDP driver
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Jinhyung Choi <jinh0.choi@samsung.com>
- * SangHo Park <sangho.p@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-
-#include <linux/i2c.h>
-#include <linux/init.h>
-#include <linux/time.h>
-#include <linux/interrupt.h>
-#include <linux/delay.h>
-#include <linux/errno.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/slab.h>
-#include <linux/io.h>
-
-#include <asm/irq.h>
-#include <linux/semaphore.h>
-
-#include "maru_dummy.h"
-
-/* i2c controller state */
-enum sdp_i2c_state {
- STATE_IDLE,
- STATE_START,
- STATE_READ,
- STATE_WRITE,
- STATE_STOP
-};
-
-struct sdp_platform_i2c {
- int bus_num;
- unsigned int flags;
- unsigned int slave_addr;
- unsigned long frequency;
- unsigned int sda_delay;
- unsigned int irq_reg;
-};
-
-struct sdp_i2c {
- wait_queue_head_t wait;
-
- struct i2c_msg *msg;
- unsigned int msg_num;
- unsigned int msg_idx;
- unsigned int msg_ptr;
-
- unsigned int tx_setup;
- unsigned int irq;
-
- enum sdp_i2c_state state;
- unsigned long clkrate;
-
- void __iomem *regs;
- void __iomem *irq_reg;
- struct clk *clk;
- struct device *dev;
- struct i2c_adapter adap;
-
- struct sdp_platform_i2c *pdata;
-
-};
-
-static spinlock_t lock_pend;
-static spinlock_t lock_int;
-
-static int sdp_i2c_xfer(struct i2c_adapter *adap,
- struct i2c_msg *msgs, int num)
-{
- maru_device_dbg(1, "sdp_i2c_xfer");
- return 0;
-}
-
-static u32 sdp_i2c_func(struct i2c_adapter *adap)
-{
- return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |
- I2C_FUNC_PROTOCOL_MANGLING;
-}
-
-static const struct i2c_algorithm sdp_i2c_algorithm = {
- .master_xfer = sdp_i2c_xfer,
- .functionality = sdp_i2c_func,
-};
-
-static int sdp_i2c_get_irq_reg(struct sdp_i2c *i2c)
-{
- struct sdp_platform_i2c *pdata;
- pdata = i2c->pdata;
-
- i2c->irq_reg = ioremap(pdata->irq_reg, 8);
-
- if (!i2c->irq_reg) {
- maru_device_err("Can't get interrupts status register\n");
- return -ENXIO;
- }
-
- return 0;
-}
-
-static int sdp_i2c_probe(struct platform_device *pdev)
-{
- struct sdp_i2c *i2c;
- struct sdp_platform_i2c *pdata = NULL;
- int ret;
-
- i2c = devm_kzalloc(&pdev->dev, sizeof(struct sdp_i2c), GFP_KERNEL);
- if (!i2c) {
- maru_device_err("no memory for state\n");
- return -ENOMEM;
- }
-
- i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
- if (!i2c->pdata) {
- ret = -ENOMEM;
- goto err_noclk;
- }
-
- spin_lock_init(&lock_pend);
- spin_lock_init(&lock_int);
-
- strlcpy(i2c->adap.name, "sdp-i2c", sizeof(i2c->adap.name));
- i2c->adap.owner = THIS_MODULE;
- i2c->adap.algo = &sdp_i2c_algorithm;
- i2c->adap.retries = 2;
- i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
- i2c->tx_setup = 50;
-
- init_waitqueue_head(&i2c->wait);
-
- i2c->dev = &pdev->dev;
- i2c->clk = clk_get(&pdev->dev, "rstn_i2c");
- if (IS_ERR(i2c->clk)) {
- maru_device_err("cannot get clock\n");
- ret = -ENOENT;
- goto err_noclk;
- }
-
- clk_prepare_enable(i2c->clk);
-
- i2c->adap.algo_data = i2c;
- i2c->adap.dev.parent = &pdev->dev;
-
- ret = sdp_i2c_get_irq_reg(i2c);
- if (ret != 0)
- goto err_clk;
-
- i2c->adap.nr = 6;
- ret = i2c_add_numbered_adapter(&i2c->adap);
- if (ret < 0) {
- maru_device_err("failed to add bus to i2c core\n");
- goto err_irq;
- }
-
- platform_set_drvdata(pdev, i2c);
-
- return 0;
-
- err_irq:
- free_irq(i2c->irq, i2c);
-
- err_clk:
- clk_disable_unprepare(i2c->clk);
- clk_put(i2c->clk);
-
- err_noclk:
- return ret;
-}
-
-static int sdp_i2c_remove(struct platform_device *pdev)
-{
- struct sdp_i2c *i2c = platform_get_drvdata(pdev);
-
- i2c_del_adapter(&i2c->adap);
- free_irq(i2c->irq, i2c);
-
- clk_disable_unprepare(i2c->clk);
- clk_put(i2c->clk);
-
- return 0;
-}
-
-static struct platform_driver sdp_i2c_driver = {
- .probe = sdp_i2c_probe,
- .remove = sdp_i2c_remove,
- .driver = {
- .name = "sdp-i2c",
- .owner = THIS_MODULE,
- },
-};
-
-struct maru_i2c_dev {
- int addr;
-};
-
-static struct platform_device *maru_i2c_pdev;
-
-static int __init maru_i2c_device_add(const struct maru_i2c_dev *dev)
-{
- int err;
-
- maru_i2c_pdev = platform_device_alloc("sdp-i2c", -1);
- if (!maru_i2c_pdev)
- return -ENOMEM;
-
- err = platform_device_add_data(maru_i2c_pdev, dev, sizeof(*dev));
- if (err) {
- maru_device_err("Platform data allocation failed\n");
- goto err;
- }
-
- err = platform_device_add(maru_i2c_pdev);
- if (err) {
- maru_device_err("Device addition failed\n");
- goto err;
- }
-
- maru_device_info("maru_i2c_device is added.\n");
- return 0;
-err:
- platform_device_put(maru_i2c_pdev);
-
- return err;
-}
-
-static int __init sdp_i2c_init(void)
-{
- int err;
-
- struct maru_i2c_dev dev;
-
- err = platform_driver_register(&sdp_i2c_driver);
- if (!err) {
- err = maru_i2c_device_add(&dev);
- if (err)
- platform_driver_unregister(&sdp_i2c_driver);
- }
-
- return err;
-}
-subsys_initcall(sdp_i2c_init);
-
-static void __exit sdp_i2c_exit(void)
-{
- platform_driver_unregister(&sdp_i2c_driver);
-}
-module_exit(sdp_i2c_exit);
-
-MODULE_AUTHOR("Jinhyung Choi");
-MODULE_DESCRIPTION("Maru Dummy I2C SDP driver");
-MODULE_LICENSE("GPL");
\ No newline at end of file
+++ /dev/null
-/*
- * MARU MICOM ISP
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Dongkyun Yun <dk77.yun@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/fs.h>
-#include <linux/uaccess.h>
-#include <linux/sched.h>
-#include <linux/cdev.h>
-
-#define DRIVER_NAME "isp-wt61p807"
-#define DEV_NAME "micom-isp"
-
-static int debug = 0;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off maru micom isp debugging (default:off).");
-
-#define print_err(fmt, arg...) \
- printk(KERN_ERR "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-
-#define print_warn(fmt, arg...) \
- printk(KERN_WARNING "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-
-#define print_info(fmt, arg...) \
- printk(KERN_INFO "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-
-#define print_dbg(level, fmt, arg...) \
- do { \
- if (debug >= (level)) { \
- printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, DEV_NAME, \
- __func__, __LINE__, current->comm, current->pid, ##arg); \
- } \
- } while (0)
-
-/* contains device information */
-struct wt61p807_isp_data {
- struct cdev *isp_dev;
- struct class *isp_class;
- struct device *isp_device;
- int micom_isp_major;
- int ref_count;
-};
-
-struct wt61p807_isp_data *wt61p807_isp;
-
-/* static mutexes for micom isp driver */
-DEFINE_MUTEX(isp_dev_lock);
-
-/* global structures for wt61p807_isp_data and wt61p807_isp_cdev as those must
- * be accessible from other functions ie.open, release etc.
- */
-struct wt61p807_isp_data m_isp_dev;
-static struct cdev wt61p807_isp_cdev;
-
-/* micom isp file operations */
-static int micom_isp_open(struct inode *inode, struct file *filp);
-static int micom_isp_release(struct inode *inode, struct file *filp);
-static long micom_isp_ioctl(struct file *filp,
- unsigned int cmd, unsigned long arg);
-
-/* file operations for micom isp device */
-const struct file_operations wt61p807_isp_fops = {
- .owner = THIS_MODULE,
- .open = micom_isp_open,
- .unlocked_ioctl = micom_isp_ioctl,
- .release = micom_isp_release,
-};
-
-/*
- *
- * @fn static int micom_isp_open(struct inode *inode, \
- * struct file *filp);
- * @brief opens micom isp device and returns file descriptor
- * @details opens micom isp device and increments m_isp_dev_p->ref_count by
- * one.
- *
- * @param inode pointer to device node's inode structure
- * filp pointer to device node file
- *
- * @return returns file descriptor if device is opened successfully
- */
-static int micom_isp_open(struct inode *inode, struct file *filp)
-{
- struct wt61p807_isp_data *wt61p807_isp = &m_isp_dev;
-
- /* acquire lock before setting is_open.*/
- mutex_lock(&isp_dev_lock);
-
- wt61p807_isp->ref_count++;
- print_dbg(1, "reference count : %d\n", wt61p807_isp->ref_count);
-
- /* Release lock*/
- mutex_unlock(&isp_dev_lock);
-
- return 0;
-}
-
-/* @fn static long micom_isp_ioctl(struct file *filp, \
- * unsigned int cmd, unsigned long arg);
- * @brief handles IOCTLs addressed to micom isp device and returns status
- * @details valid IOCTLs:
- * MICOM_MSG_IOCTL_SEND_MSG: Used to send messages
- * containing normal data to micom device. It expects
- * acknowledgement from the device.
- * MICOM_MSG_IOCTL_SEND_MSG_NO_ACK: Used to send messages
- * containing normal buffer data without expecting any
- * acknowledgement from micom isp device.
- *
- * @param filp pointer to device node file
- * cmd IOCTL command.
- * arg argument to ioctl command (struct sdp_micom_usr_isp).
- *
- * @return returns status of IOCTL
- * -EINVAL: if null arg is passed from user.
- * -EFAULT: if copy_from_user() fails to copy
- * -ERANGE: if micom command sent from user exceeds the
- * defined max value (0xFF)
- * zero: if suceess
- */
-static long micom_isp_ioctl(struct file *filp,
- unsigned int cmd, unsigned long arg)
-{
- long status = 0;
-
- print_dbg(1, "device ioctl \n");
-
- return status;
-}
-
-/*
- *
- * @fn static int micom_isp_release(struct inode *inode, \
- * struct file *filp);
- * @brief closes micom isp device and returns status
- * @details
- *
- * @param inode pointer to device node's inode structure
- * filp pointer to device node file
- *
- * @return returns zero if device is closed
- */
-static int micom_isp_release(struct inode *inode, struct file *filp)
-{
-
- struct wt61p807_isp_data *wt61p807_isp = &m_isp_dev;
-
- /* acquire lock before setting is_open.*/
- mutex_lock(&isp_dev_lock);
-
- wt61p807_isp->ref_count--;
- print_dbg(1 , "reference count : %d\n", wt61p807_isp->ref_count);
-
- /* Release lock*/
- mutex_unlock(&isp_dev_lock);
-
- return 0;
-}
-
-/* Device initialization routine */
-static int __init micom_isp_init(void)
-{
- dev_t devid = 0;
- int ret = -1;
-
- print_info("called \n");
-
- /* allocate char device region */
- ret = alloc_chrdev_region(&devid, 0, 1, DRIVER_NAME);
- if (ret) {
- print_err("alloc_chrdev_region failed with %d\n", ret);
- goto chrdev_alloc_fail;
- }
-
- /* initialize associated cdev and attach the file_operations */
- cdev_init(&wt61p807_isp_cdev, &wt61p807_isp_fops);
- /* add cdev to device */
- ret = cdev_add(&wt61p807_isp_cdev, devid, 1);
- if (ret) {
- print_err("cdev_add failed with %d\n", ret);
- goto cdev_add_fail;
- }
-
- wt61p807_isp = &m_isp_dev;
-
- wt61p807_isp->isp_dev = &wt61p807_isp_cdev;
- wt61p807_isp->micom_isp_major = MAJOR(devid);
- wt61p807_isp->ref_count = 0;
-
- wt61p807_isp->isp_class = class_create(THIS_MODULE, DRIVER_NAME);
- if (IS_ERR(wt61p807_isp->isp_class)) {
- print_err("failed to create sys class\n");
- } else {
- wt61p807_isp->isp_device = device_create(
- wt61p807_isp->isp_class,
- NULL, devid, NULL, DEV_NAME);
- if (IS_ERR(wt61p807_isp->isp_device)) {
- print_err("failed to create sys device\n");
- class_destroy(wt61p807_isp->isp_class);
- }
- }
-
- /* dynamic initialization of mutex for device */
- mutex_init(&isp_dev_lock);
-
- return ret;
-
- /* cleaning up due to failure. */
-cdev_add_fail:
- unregister_chrdev_region(devid, 1);
-chrdev_alloc_fail:
- return ret;
-}
-
-/* Device exit routine */
-static void __exit micom_isp_exit(void)
-{
- print_info("called \n");
-
- mutex_destroy(&isp_dev_lock);
-
- /* destroy micom isp sysfs device and class */
- if (wt61p807_isp->isp_device != NULL) {
- device_destroy(wt61p807_isp->isp_class,
- MKDEV(wt61p807_isp->micom_isp_major, 0));
- }
- if (wt61p807_isp->isp_class != NULL)
- class_destroy(wt61p807_isp->isp_class);
-
- unregister_chrdev_region(MKDEV(m_isp_dev.micom_isp_major, 0), 1);
- return;
-}
-
-/* define module init/exit, license */
-subsys_initcall(micom_isp_init);
-module_exit(micom_isp_exit);
-
-MODULE_DESCRIPTION("Micom driver interface for ISP data");
-MODULE_AUTHOR("Abhishek Jaiswal <abhishek1.j@samsung.com>");
-MODULE_LICENSE("GPL");
+++ /dev/null
-/*
- * MARU MICOM MSG
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Dongkyun Yun <dk77.yun@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-/* internal Release1 */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/fs.h>
-#include <linux/cdev.h>
-#include <linux/mutex.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/poll.h>
-#include <linux/sched.h>
-#include <linux/completion.h>
-#include <linux/platform_device.h>
-
-#define DRIVER_NAME "msg-wt61p807"
-#define DEV_NAME "micom-msg"
-
-static int debug = 0;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off maru micom msg debugging (default:off).");
-
-#define print_err(fmt, arg...) \
- printk(KERN_ERR "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-
-#define print_warn(fmt, arg...) \
- printk(KERN_WARNING "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-
-#define print_info(fmt, arg...) \
- printk(KERN_INFO "[%s](%s)[%s:%d]: " fmt, DEV_NAME, __func__, \
- current->comm, current->pid, ##arg);
-
-#define print_dbg(level, fmt, arg...) \
- do { \
- if (debug >= (level)) { \
- printk(KERN_INFO "[%s](%s:%d)[%s:%d]: " fmt, DEV_NAME, \
- __func__, __LINE__, current->comm, current->pid, ##arg); \
- } \
- } while (0)
-
-/* no of retries */
-#define ACK_RETRY_MAX 4
-
-/* static mutexes for micom msg device */
-DEFINE_MUTEX(dev_msg_lock);
-
-/* list of micom msg file operations prototypes. */
-static int micom_msg_open(struct inode *inode, struct file *filp);
-static int micom_msg_release(struct inode *inode, struct file *filp);
-static long micom_msg_ioctl(struct file *filp,
- unsigned int cmd, unsigned long arg);
-static ssize_t show_jack_ident(struct device *dev,
- struct device_attribute *attr, char *buf);
-static ssize_t show_scart_lv_1(struct device *dev,
- struct device_attribute *attr, char *buf);
-static ssize_t show_scart_lv_2(struct device *dev,
- struct device_attribute *attr, char *buf);
-static ssize_t show_jack_ident_ready(struct device *dev,
- struct device_attribute *attr, char *buf);
-
-/* file operations for micom msg device */
-const struct file_operations wt61p807_msg_fops = {
- .owner = THIS_MODULE,
- .open = micom_msg_open,
- .unlocked_ioctl = micom_msg_ioctl,
- .release = micom_msg_release,
-};
-
-struct wt61p807_msg_data {
- struct cdev *msg_dev;
- struct class *msg_class;
- struct device *msg_device;
- int micom_msg_major;
- int ref_count;
-
- int jack_ident;
- int jack_ident_ready;
- int scart_lv_1;
- int scart_lv_2;
-};
-
-struct wt61p807_msg_data *wt61p807_msg;
-
-/* micom msg device specific data */
-struct wt61p807_msg_data m_msg_dev;
-
-/* micom msg cdev */
-struct cdev wt61p807_msg_cdev;
-
-static DEVICE_ATTR(jack_ident, S_IRUGO, show_jack_ident, NULL);
-static DEVICE_ATTR(scart_lv_1, S_IRUGO, show_scart_lv_1, NULL);
-static DEVICE_ATTR(scart_lv_2, S_IRUGO, show_scart_lv_2, NULL);
-static DEVICE_ATTR(jack_ident_ready, S_IRUGO,
- show_jack_ident_ready, NULL);
-
-/*
- *
- * @fn static int micom_msg_open(struct inode *inode, \
- * struct file *filp);
- * @brief opens micom msg device and returns file descriptor
- * @details opens micom msg device and increments m_msg_dev_p->ref_count.
- *
- * @param inode pointer to device node's inode structure
- * filp pointer to device node file
- *
- * @return returns file descriptor if device is opened successfully
- */
-static int micom_msg_open(struct inode *inode, struct file *filp)
-{
- int ret = 0;
- struct wt61p807_msg_data *m_msg_dev_p = &m_msg_dev;
-
- /* acquire lock before opening device.*/
- mutex_lock(&dev_msg_lock);
-
- m_msg_dev_p->ref_count++;
-
- print_dbg(1, "MSG device is opened. ref_count[%d]\n",
- m_msg_dev_p->ref_count);
-
- /* Release lock */
- mutex_unlock(&dev_msg_lock);
-
- return ret;
-}
-
-/*
- *
- * @fn static int micom_msg_release(struct inode *inode, \
- * struct file *filp);
- * @brief closes micom msg device and returns status
- * @details
- *
- * @param inode pointer to device node's inode structure
- * filp pointer to device node file
- *
- * @return returns zero if device is closed
- */
-static int micom_msg_release(struct inode *inode, struct file *filp)
-{
-
- int ret = 0;
- struct wt61p807_msg_data *m_msg_dev_p = &m_msg_dev;
-
- /* acquire lock before closing device.*/
- mutex_lock(&dev_msg_lock);
-
- m_msg_dev_p->ref_count--;
-
- print_dbg(1, "MSG device is closed. ref_count[%d]\n",
- m_msg_dev_p->ref_count);
-
- /* Release lock*/
- mutex_unlock(&dev_msg_lock);
-
- return ret;
-}
-
-/*
- *
- * @fn static long micom_msg_ioctl(struct file *filp, \
- * unsigned int cmd, unsigned long arg);
- * @brief handles IOCTLs addressed to micom msg device and returns status
- * @details valid IOCTLs:
- * MICOM_MSG_IOCTL_SEND_MSG: Used to send messages
- * containing normal data to micom device. It expects
- * acknowledgement from the device.
- * MICOM_MSG_IOCTL_SEND_MSG_NO_ACK: Used to send messages
- * containing normal buffer data without expecting any
- * acknowledgement from micom msg device.
- *
- * @param filp pointer to device node file
- * cmd IOCTL command.
- * arg argument to ioctl command (struct sdp_micom_usr_msg).
- *
- * @return returns status of IOCTL
- * -EINVAL: if null arg is passed from user.
- * -EFAULT: if copy_from_user() fails to copy
- * -ERANGE: if micom command sent from user exceeds the
- * defined max value (0xFF)
- * zero: if suceess
- */
-static long micom_msg_ioctl(struct file *filp,
- unsigned int cmd, unsigned long arg)
-{
- long status = 0;
-
- print_dbg(1, "MSG device ioctl \n");
-
- return status;
-}
-
-static ssize_t show_jack_ident(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- print_dbg(1, "\n");
- return snprintf(buf, sizeof(int), "%d", m_msg_dev.jack_ident);
-}
-
-static ssize_t show_scart_lv_1(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- print_dbg(1, "\n");
- return snprintf(buf, sizeof(int), "%d", m_msg_dev.scart_lv_1);
-}
-
-static ssize_t show_scart_lv_2(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- print_dbg(1, "\n");
- return snprintf(buf, sizeof(int), "%d", m_msg_dev.scart_lv_2);
-}
-
-static ssize_t show_jack_ident_ready(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- print_dbg(1, "\n");
- return snprintf(buf, sizeof(int), "%d", m_msg_dev.jack_ident_ready);
-}
-
-/* Device initialization routine */
-static int __init micom_msg_init(void)
-{
- dev_t devid = 0;
- int ret = -1;
-
- print_info("called \n");
-
- /* allocate char device region */
- ret = alloc_chrdev_region(&devid, 0, 1, DRIVER_NAME);
- if (ret) {
- print_err("alloc_chrdev_region failed with %d\n", ret);
- goto chrdev_alloc_fail;
- }
-
- /* initialize associated cdev and attach the file_operations */
- cdev_init(&wt61p807_msg_cdev, &wt61p807_msg_fops);
- /* add cdev to device */
- ret = cdev_add(&wt61p807_msg_cdev, devid, 1);
- if (ret) {
- print_err("cdev_add failed with %d\n", ret);
- goto cdev_add_fail;
- }
-
- wt61p807_msg = &m_msg_dev;
-
- wt61p807_msg->msg_dev = &wt61p807_msg_cdev;
- wt61p807_msg->micom_msg_major = MAJOR(devid);
- wt61p807_msg->ref_count = 0;
-
- wt61p807_msg->msg_class = class_create(THIS_MODULE, DEV_NAME);
- if (IS_ERR(wt61p807_msg->msg_class)) {
- print_err("failed to create sys class\n");
- } else {
- wt61p807_msg->msg_device = device_create(
- wt61p807_msg->msg_class,
- NULL, devid, NULL, DEV_NAME);
- if (IS_ERR(wt61p807_msg->msg_device)) {
- print_err("failed to create sys device\n");
- class_destroy(wt61p807_msg->msg_class);
- }
- }
-
- ret = device_create_file(wt61p807_msg->msg_device,
- &dev_attr_jack_ident);
- if (ret) {
- print_err("failed to create sysfs files (ret = %d) \n", ret);
- goto dev_fail;
- }
- ret = device_create_file(wt61p807_msg->msg_device,
- &dev_attr_scart_lv_1);
- if (ret) {
- print_err("failed to create sysfs files (ret = %d) \n", ret);
- goto dev_fail;
- }
- ret = device_create_file(wt61p807_msg->msg_device,
- &dev_attr_scart_lv_2);
- if (ret) {
- print_err("failed to create sysfs files (ret = %d) \n", ret);
- goto dev_fail;
- }
- ret = device_create_file(wt61p807_msg->msg_device,
- &dev_attr_jack_ident_ready);
- if (ret) {
- print_err("failed to create sysfs files (ret = %d) \n", ret);
- goto dev_fail;
- }
-
- /* dynamic initialization of mutex for device */
- mutex_init(&dev_msg_lock);
-
- return ret;
-
-dev_fail:
-cdev_add_fail:
- unregister_chrdev_region(devid, 1);
-chrdev_alloc_fail:
- return ret;
-}
-
-/* Device exit routine */
-static void __exit micom_msg_exit(void)
-{
- print_info("called \n");
-
- mutex_destroy(&dev_msg_lock);
-
- /* destroy micom msg sysfs device and class */
- if (wt61p807_msg->msg_device != NULL) {
- device_destroy(wt61p807_msg->msg_class,
- MKDEV(wt61p807_msg->micom_msg_major, 0));
- }
- if (wt61p807_msg->msg_class != NULL)
- class_destroy(wt61p807_msg->msg_class);
-
- unregister_chrdev_region(MKDEV(wt61p807_msg->micom_msg_major, 0), 1);
- return;
-}
-
-/* define module init/exit, license */
-subsys_initcall(micom_msg_init);
-module_exit(micom_msg_exit);
-
-MODULE_DESCRIPTION("Micom driver interface for Normal buffer data");
-MODULE_AUTHOR("Abhishek Jaiswal <abhishek1.j@samsung.com>");
-MODULE_LICENSE("GPL");
+++ /dev/null
-/*
- * MARU SDP Memory Driver
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Dongkyun Yun <dk77.yun@samsung.com>
- * Jinhyung Choi <jinh0.choi@samsung.com>
- * Hyunjin Lee <hyunjin816.lee@samsung.com>
- * SangHo Park <sangho.p@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/ioctl.h>
-#include <linux/slab.h>
-#include <linux/mm.h>
-#include <linux/mm_types.h>
-#include <linux/miscdevice.h>
-#include <linux/vmalloc.h>
-
-#include "maru_dummy.h"
-
-#define DRV_NAME "sdp_mem"
-#define SDP_MEM_MINOR 193
-
-static LIST_HEAD(region_list);
-static DEFINE_MUTEX(region_mutex);
-
-struct sdp_mem_region
-{
- struct list_head list;
- unsigned long vm_pgoff;
- unsigned long size;
- void *vaddr;
-};
-
-static int
-sdp_mem_mmap(struct file * file, struct vm_area_struct * vma)
-{
- int ret;
- unsigned long size = vma->vm_end - vma->vm_start;
- struct sdp_mem_region *region;
- int pages;
-
- maru_device_dbg(1, "[%d:%s] \n", current->pid, current->comm);
-
- mutex_lock(®ion_mutex);
-
- list_for_each_entry(region, ®ion_list, list) {
- if( region->vm_pgoff == vma->vm_pgoff ) {
- if( region->size != size ) {
- maru_device_err("size mismatch \n");
- /* TODO: use first mapping size */
- size = region->size;
- }
- maru_device_dbg(1, "pgoff %lx found \n", vma->vm_pgoff);
- goto found;
- }
- }
-
- maru_device_dbg(1, "pgoff %lx not found \n", vma->vm_pgoff);
-
- region = kzalloc(sizeof(struct sdp_mem_region), GFP_KERNEL);
- if (!region) {
- maru_device_err("kzalloc fail \n");
- ret = -ENOMEM;
- goto error;
- }
-
- region->vm_pgoff = vma->vm_pgoff;
- region->size = size;
-
- pages = PAGE_ALIGN(size);
- region->vaddr = vmalloc_user(pages);
- if (!region->vaddr) {
- maru_device_err("vmalloc_user fail \n");
- kfree(region);
- ret = -ENOMEM;
- goto error;
- }
- list_add_tail(®ion->list, ®ion_list);
-
- maru_device_dbg(1, "vaddr(%p) with size(%lu) \n", region->vaddr, size);
-
-found:
-
- /* Try to remap memory */
- ret = remap_vmalloc_range(vma, region->vaddr, 0);
- if (ret) {
- maru_device_err("remap_vmalloc_range failed (ret:%d) \n", ret);
- goto error;
- }
-
- maru_device_info("%s/%d mmap phy addr(0x%lx, size:%lu) to 0x%p\n",
- current->comm, current->pid, vma->vm_pgoff, size, region->vaddr);
-
-error:
- mutex_unlock(®ion_mutex);
- return ret;
-}
-
-static int sdp_mem_open(struct inode *inode, struct file *file)
-{
- maru_device_dbg(1, "open\n");
- return 0;
-}
-
-
-static int sdp_mem_close(struct inode *inode, struct file *file)
-{
- maru_device_dbg(1, "close\n");
- return 0;
-}
-
-static const struct file_operations sdp_mem_fops = {
- .owner = THIS_MODULE,
- .open = sdp_mem_open,
- .release = sdp_mem_close,
- .mmap = sdp_mem_mmap,
-};
-
-static struct miscdevice sdp_mem_dev = {
- .minor = SDP_MEM_MINOR,
- .name = DRV_NAME,
- .fops = &sdp_mem_fops
-};
-
-static int __init maru_sdp_mem_init(void)
-{
- int ret_val = 0;
-
- ret_val = misc_register(&sdp_mem_dev);
-
- if(ret_val){
- maru_device_err("misc_register is failed.");
- return ret_val;
- }
-
- maru_device_info("sdp_mem initialized.");
-
- return ret_val;
-}
-
-static void __exit maru_sdp_mem_exit(void)
-{
- misc_deregister(&sdp_mem_dev);
-}
-
-module_init(maru_sdp_mem_init);
-module_exit(maru_sdp_mem_exit);
+++ /dev/null
-/*
- * MARU security driver
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * Hyunjin Lee <hyunjin816.lee@samsung.com>
- * SangHo Park <sangho1206.park@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/fs.h>
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/init.h>
-#include <linux/mutex.h>
-#include <linux/pagemap.h>
-#include <linux/sched.h>
-#include <linux/device.h>
-#include <linux/cdev.h>
-#include <asm/page.h>
-#include <asm/pgtable.h>
-#include <linux/interrupt.h>
-
-#define SECURITY_DEV_NAME "security"
-
-static unsigned security_debug = 0;
-static struct class *security_class;
-static struct cdev security_cdev;
-dev_t security_dev;
-
-module_param(security_debug, int, 0644);
-MODULE_PARM_DESC(security_debug, "Turn on/off maru security debugging (default:off).");
-
-#define maru_security_err(fmt, arg...) \
- printk(KERN_ERR "[ERR]maru_security[%s]: " fmt, __func__, ##arg)
-
-#define maru_security_warn(fmt, arg...) \
- printk(KERN_WARNING "[WARN]maru_security[%s]: " fmt, __func__, ##arg)
-
-#define maru_security_info(fmt, arg...) \
- printk(KERN_INFO "[INFO]maru_security[%s]: " fmt, __func__, ##arg)
-
-#define maru_security_dbg(level, fmt, arg...) \
- do { \
- if (security_debug >= (level)) { \
- printk(KERN_ERR "[DBG]maru_security[%s]: " fmt, \
- __func__, ##arg); \
- } \
- } while (0)
-#define SECURITY_G_SEQNUM _IOR('S', 0, unsigned int)
-
-struct security_information {
- unsigned int seq_num;
-};
-
-/* -----------------------------------------------------------------
- file operations
- ------------------------------------------------------------------*/
-static int maru_security_open(struct inode *inode, struct file *file)
-{
- int ret = 0;
- struct security_information *sec_info;
-
- maru_security_dbg(5, "[security]enter.\n");
-
- sec_info = kzalloc(sizeof(struct security_information), GFP_KERNEL);
- if (!sec_info) {
- maru_security_err("kzalloc() failed\n");
- ret = -ENOMEM;
- goto enomem;
- }
-
- sec_info->seq_num = 0;
- file->private_data = sec_info;
-
-enomem:
- return ret;
-}
-
-static long maru_security_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
-{
- int ret = 0;
- struct security_information *sec_info = file->private_data;
- int __user *data = (int __user *)arg;
-
- switch (cmd) {
- case SECURITY_G_SEQNUM:
- ret = copy_to_user(data, &sec_info->seq_num, sizeof(unsigned int));
- if (ret) {
- ret = -EFAULT;
- break;
- }
- sec_info->seq_num++;
- break;
- default:
- maru_security_info("[security] unsupported command : %08x.\n", cmd);
- ret = -EINVAL;
- break;
- }
-
- return ret;
-}
-
-static int maru_security_close(struct inode *inode, struct file *file)
-{
- struct security_information *sec_info = file->private_data;
-
- maru_security_dbg(5, "[security]enter.\n");
-
- if (sec_info) {
- kfree(sec_info);
- sec_info = NULL;
- }
-
- return 0;
-}
-
-static const struct file_operations maru_security_fops = {
- .open = maru_security_open,
- .unlocked_ioctl = maru_security_ioctl,
- .release = maru_security_close,
-};
-
-/* -----------------------------------------------------------------
- Initialization
- ------------------------------------------------------------------*/
-static int __init maru_security_init(void)
-{
- int ret = 0;
-
- /* allocate character device */
- ret = alloc_chrdev_region(&security_dev, 0, 1, SECURITY_DEV_NAME);
- if (ret < 0) {
- maru_security_err("security alloc_chrdev_region failed.\n");
- goto alloc_chrdev_region_err;
- }
-
- /* create class */
- security_class = class_create(THIS_MODULE, SECURITY_DEV_NAME);
- if (IS_ERR(security_class)) {
- ret = PTR_ERR(security_class);
- maru_security_err("create security class failed.\n");
- goto create_class_err;
- }
-
- /* character device initialize */
- cdev_init(&security_cdev, &maru_security_fops);
-
- ret = cdev_add(&security_cdev, security_dev, 1);
- if (ret < 0) {
- maru_security_err("security cdev_add failed\n");
- goto cdev_add_err;
- }
-
- /* create device */
- device_create(security_class, 0, security_dev, NULL, "%s", SECURITY_DEV_NAME);
-
- maru_security_info("security driver was registerd.\n");
-
- return ret;
-
-cdev_add_err:
- class_destroy(security_class);
-create_class_err:
- unregister_chrdev_region(security_dev, 1);
-alloc_chrdev_region_err:
- return ret;
-}
-
-static void __exit maru_security_exit(void)
-{
- cdev_del(&security_cdev);
- class_destroy(security_class);
- unregister_chrdev_region(security_dev, 1);
-
- maru_security_info("security driver was exited.\n");
-}
-
-module_init(maru_security_init);
-module_exit(maru_security_exit);
\ No newline at end of file
projects / sdk / emulator / emulator-kernel.git / commitdiff