jacks & power: changed max buf size to 512

Change-Id: I02fd40b37f6d295e546122e8f18ca1c1ddb7d5fc
Signed-off-by: Jinhyung Choi <jinhyung2.choi@samsung.com>

diff --git a/drivers/maru/maru_jack.c b/drivers/maru/maru_jack.c
index c20b845f42712893e8e6389d5f01671856c42402..abfecf0ecf4c62d317bfbf6a96d95863ea6ff09e 100644 (file)
--- a/drivers/maru/maru_jack.c
+++ b/drivers/maru/maru_jack.c
@@ -44,6 +44,7 @@
 #include <linux/sched.h>
 
 #define __MAX_BUF_SIZE         1024
+#define __MAX_BUF_JACK         512
 
 struct msg_info {
        char buf[__MAX_BUF_SIZE];
@@ -95,7 +96,7 @@ struct jack_data {
 
 struct virtio_jack *v_jack;
 
-static char jack_data [PAGE_SIZE];
+static char jack_data [__MAX_BUF_JACK];
 static int jack_capability = 0;
 
 static DECLARE_WAIT_QUEUE_HEAD(wq);
@@ -139,7 +140,12 @@ static void jack_vq_done(struct virtqueue *vq) {
                return;
        }
 
-       if (msg->req != request_answer || msg->buf == NULL) {
+       if (msg->req != request_answer) {
+               DLOG(KERN_DEBUG, "receive queue- not an answer message: %d", msg->req);
+               return;
+       }
+       if (msg->buf == NULL) {
+               DLOG(KERN_ERR, "receive queue- message from host is NULL.");
                return;
        }
 
@@ -147,8 +153,7 @@ static void jack_vq_done(struct virtqueue *vq) {
 
        mutex_lock(&v_jack->lock);
        strcpy(jack_data, msg->buf);
-       v_jack->flags ++;
-       DLOG(KERN_DEBUG, "flags : %d", v_jack->flags);
+       v_jack->flags = 1;
        mutex_unlock(&v_jack->lock);
 
        wake_up_interruptible(&wq);
@@ -169,7 +174,7 @@ static void set_jack_data(int type, const char* buf)
        }
 
        mutex_lock(&v_jack->lock);
-       memset(jack_data, 0, PAGE_SIZE);
+       memset(jack_data, 0, sizeof(jack_data));
        memset(&v_jack->msginfo, 0, sizeof(v_jack->msginfo));
 
        strcpy(jack_data, buf);
@@ -191,23 +196,21 @@ static void set_jack_data(int type, const char* buf)
        virtqueue_kick(v_jack->vq);
 }
 
-static void get_jack_data(int type)
+static int get_jack_data(int type, char* data)
 {
        struct scatterlist *sgs[2];
        int err = 0;
 
        if (v_jack == NULL) {
                DLOG(KERN_ERR, "Invalid jack handle");
-               return;
+               return -1;
        }
 
        mutex_lock(&v_jack->lock);
-       memset(jack_data, 0, PAGE_SIZE);
        memset(&v_jack->msginfo, 0, sizeof(v_jack->msginfo));
 
        v_jack->msginfo.req = request_get;
        v_jack->msginfo.type = type;
-
        mutex_unlock(&v_jack->lock);
 
        DLOG(KERN_DEBUG, "get_jack_data type: %d, req: %d",
@@ -218,7 +221,7 @@ static void get_jack_data(int type)
        err = virtqueue_add_sgs(v_jack->vq, sgs, 1, 1, &v_jack->msginfo, GFP_ATOMIC);
        if (err < 0) {
                DLOG(KERN_ERR, "failed to add buffer to virtqueue (err = %d)", err);
-               return;
+               return -1;
        }
 
        virtqueue_kick(v_jack->vq);
@@ -226,79 +229,88 @@ static void get_jack_data(int type)
        wait_event_interruptible(wq, v_jack->flags != 0);
 
        mutex_lock(&v_jack->lock);
-       v_jack->flags --;
-       DLOG(KERN_DEBUG, "flags : %d", v_jack->flags);
+       v_jack->flags = 0;
+       memcpy(data, jack_data, strlen(jack_data));
        mutex_unlock(&v_jack->lock);
+
+       return 0;
+}
+
+static int get_data_for_show(int type, char* buf)
+{
+       int ret;
+       char jack_data[__MAX_BUF_JACK];
+       memset(jack_data, 0, sizeof(jack_data));
+       ret = get_jack_data(type, jack_data);
+       if (ret)
+               return 0;
+       return sprintf(buf, "%s", jack_data);
+
 }
 
 static ssize_t show_charger_online(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       get_jack_data(jack_type_charger);
-       return snprintf(buf, PAGE_SIZE, "%s", jack_data);
+       return get_data_for_show(jack_type_charger, buf);
 }
 
 static ssize_t store_charger_online(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
 {
        set_jack_data(jack_type_charger, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static ssize_t show_earjack_online(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       get_jack_data(jack_type_earjack);
-       return snprintf(buf, PAGE_SIZE, "%s", jack_data);
+       return get_data_for_show(jack_type_earjack, buf);
 }
 
 static ssize_t store_earjack_online(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
 {
        set_jack_data(jack_type_earjack, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static ssize_t show_earkey_online(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       get_jack_data(jack_type_earkey);
-       return snprintf(buf, PAGE_SIZE, "%s", jack_data);
+       return get_data_for_show(jack_type_earkey, buf);
 }
 
 static ssize_t store_earkey_online(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
 {
        set_jack_data(jack_type_earkey, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static ssize_t show_hdmi_online(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       get_jack_data(jack_type_hdmi);
-       return snprintf(buf, PAGE_SIZE, "%s", jack_data);
+       return get_data_for_show(jack_type_hdmi, buf);
 }
 
 static ssize_t store_hdmi_online(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
 {
        set_jack_data(jack_type_hdmi, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static ssize_t show_usb_online(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       get_jack_data(jack_type_usb);
-       return snprintf(buf, PAGE_SIZE, "%s", jack_data);
+       return get_data_for_show(jack_type_usb, buf);
 }
 
 static ssize_t store_usb_online(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
 {
        set_jack_data(jack_type_usb, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static DEVICE_ATTR(charger_online, S_IRUGO | S_IWUSR, show_charger_online, store_charger_online);
@@ -384,6 +396,7 @@ static struct platform_device the_pdev = {
 static int jack_probe(struct virtio_device* dev){
        int err = 0, index = 0;
        struct jack_data *data;
+       char jack_data[__MAX_BUF_JACK];
 
        DLOG(KERN_INFO, "jack_probe\n");
 
@@ -429,7 +442,15 @@ static int jack_probe(struct virtio_device* dev){
 
        DLOG(KERN_INFO, "request jack capability");
 
-       get_jack_data(jack_type_list);
+       memset(jack_data, 0, sizeof(jack_data));
+
+       err = get_jack_data(jack_type_list, jack_data);
+       if (err) {
+               DLOG(KERN_ERR, "Cannot get jack list.\n");
+               kfree(data);
+               platform_device_unregister(&the_pdev);
+       }
+
        jack_capability = jack_atoi(jack_data);
        DLOG(KERN_INFO, "jack capability is %02x", jack_capability);
 

diff --git a/drivers/maru/maru_power_supply.c b/drivers/maru/maru_power_supply.c
index 414d614412f4d91eaaa4dbd6b307bd3002597977..5943b5bc704ed36ce391ad91dff3d0a331871832 100644 (file)
--- a/drivers/maru/maru_power_supply.c
+++ b/drivers/maru/maru_power_supply.c
@@ -47,6 +47,8 @@
 #define DEVICE_NAME                            "power_supply"
 #define FILE_PERMISSION                        (S_IRUGO | S_IWUSR)
 
+#define __MAX_BUF_POWER                        512
+
 //#define DEBUG_MARU_POWER_SUPPLY
 
 #ifdef DEBUG_MARU_POWER_SUPPLY
@@ -99,7 +101,7 @@ struct virtio_power *v_power;
 static struct class* power_class;
 static struct device* power_device;
 
-static char power_data [PAGE_SIZE];
+static char power_data [__MAX_BUF_POWER];
 
 static DECLARE_WAIT_QUEUE_HEAD(wq);
 
@@ -113,16 +115,21 @@ static void power_vq_done(struct virtqueue *vq) {
                return;
        }
 
-       if (msg->req != request_answer || msg->buf == NULL) {
+       if (msg->req != request_answer) {
+               DLOG(KERN_DEBUG, "receive queue- not an answer message: %d", msg->req);
+               return;
+       }
+       if (msg->buf == NULL) {
+               DLOG(KERN_ERR, "receive queue- message from host is NULL.");
                return;
        }
 
        DLOG(KERN_DEBUG, "msg buf: %s, req: %d, type: %d", msg->buf, msg->req, msg->type);
 
        mutex_lock(&v_power->lock);
+       memset(power_data, 0, __MAX_BUF_POWER);
        strcpy(power_data, msg->buf);
-       v_power->flags ++;
-       DLOG(KERN_DEBUG, "flags : %d", v_power->flags);
+       v_power->flags = 1;
        mutex_unlock(&v_power->lock);
 
        wake_up_interruptible(&wq);
@@ -143,7 +150,7 @@ static void set_power_data(int type, const char* buf)
        }
 
        mutex_lock(&v_power->lock);
-       memset(power_data, 0, PAGE_SIZE);
+       memset(power_data, 0, __MAX_BUF_POWER);
        memset(&v_power->msginfo, 0, sizeof(v_power->msginfo));
 
        strcpy(power_data, buf);
@@ -165,23 +172,21 @@ static void set_power_data(int type, const char* buf)
        virtqueue_kick(v_power->vq);
 }
 
-static void get_power_data(int type)
+static int get_power_data(int type, char* data)
 {
        struct scatterlist *sgs[2];
        int err = 0;
 
-       if (v_power == NULL) {
-               DLOG(KERN_ERR, "Invalid power handle");
-               return;
+       if (v_power == NULL || data == NULL) {
+               DLOG(KERN_ERR, "Invalid power handle or data is NULL");
+               return -1;
        }
 
        mutex_lock(&v_power->lock);
-       memset(power_data, 0, PAGE_SIZE);
        memset(&v_power->msginfo, 0, sizeof(v_power->msginfo));
 
        v_power->msginfo.req = request_get;
        v_power->msginfo.type = type;
-
        mutex_unlock(&v_power->lock);
 
        DLOG(KERN_DEBUG, "get_power_data type: %d, req: %d",
@@ -192,7 +197,7 @@ static void get_power_data(int type)
        err = virtqueue_add_sgs(v_power->vq, sgs, 1, 1, &v_power->msginfo, GFP_ATOMIC);
        if (err < 0) {
                DLOG(KERN_ERR, "failed to add buffer to virtqueue (err = %d)", err);
-               return;
+               return -1;
        }
 
        virtqueue_kick(v_power->vq);
@@ -200,45 +205,56 @@ static void get_power_data(int type)
        wait_event_interruptible(wq, v_power->flags != 0);
 
        mutex_lock(&v_power->lock);
-       v_power->flags --;
-       DLOG(KERN_DEBUG, "flags : %d", v_power->flags);
+       v_power->flags = 0;
+       memcpy(data, power_data, strlen(power_data));
        mutex_unlock(&v_power->lock);
+
+       return 0;
+}
+
+static int get_data_for_show(int type, char* buf)
+{
+       int ret;
+       char power_data[__MAX_BUF_POWER];
+       memset(power_data, 0, sizeof(power_data));
+       ret = get_power_data(type, power_data);
+       if (ret)
+               return 0;
+       return sprintf(buf, "%s", power_data);
+
 }
 
 static ssize_t show_capacity(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       get_power_data(power_type_capacity);
-       return snprintf(buf, PAGE_SIZE, "%s", power_data);
+       return get_data_for_show(power_type_capacity, buf);
 }
 
 static ssize_t store_capacity(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
        set_power_data(power_type_capacity, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static ssize_t show_charge_full(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       get_power_data(power_type_charge_full);
-       return snprintf(buf, PAGE_SIZE, "%s", power_data);
+       return get_data_for_show(power_type_charge_full, buf);
 }
 
 static ssize_t store_charge_full(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
        set_power_data(power_type_charge_full, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static ssize_t show_charge_now(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       get_power_data(power_type_charge_now);
-       return snprintf(buf, PAGE_SIZE, "%s", power_data);
+       return get_data_for_show(power_type_charge_now, buf);
 }
 
 static ssize_t store_charge_now(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
        set_power_data(power_type_charge_now, buf);
-       return strnlen(buf, PAGE_SIZE);
+       return strnlen(buf, count);
 }
 
 static struct device_attribute ps_device_attributes[] = {
@@ -310,7 +326,6 @@ static int power_probe(struct virtio_device* dev)
 
        v_power->vdev = dev;
        dev->priv = v_power;
-       v_power->flags = 0;
 
        power_class = class_create(THIS_MODULE, DEVICE_NAME);
        if (power_class == NULL) {