--- /dev/null
+/*
+ * Copyright (c) 2013-2014, Motorola Mobility, LLC.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only 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.
+ *
+ */
+
+#include <asm/page.h>
+#include <linux/export.h>
+#include <linux/kobject.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/string.h>
+#include <linux/sysfs.h>
+#include <linux/time.h>
+#include <linux/vmalloc.h>
+
+#define DROPBOX_TEXT_FLAG 0x00000002
+#define DROPBOX_FILE_FLAG 0x40000000
+
+#define EVENT_QUEUE_SIZE 5
+#define EVENT_NAME_LENGTH 64
+
+static DEFINE_MUTEX(dropbox_queue_lock);
+static struct kobject dropbox_kobj;
+
+struct dropbox_event {
+ char name[EVENT_NAME_LENGTH];
+ void *data;
+ size_t size;
+ int flags;
+ struct list_head list;
+};
+
+static LIST_HEAD(dropbox_event_list);
+
+static int dropbox_event_queue_depth_locked(void)
+{
+ struct dropbox_event *event = NULL;
+ int queue_depth = 0;
+
+ list_for_each_entry(event, &dropbox_event_list, list)
+ queue_depth++;
+ return queue_depth;
+}
+
+static bool dropbox_event_queue_full_locked(void)
+{
+ return dropbox_event_queue_depth_locked() >= EVENT_QUEUE_SIZE;
+}
+
+static bool dropbox_event_queue_empty_locked(void)
+{
+ return dropbox_event_queue_depth_locked() == 0;
+}
+
+static void dropbox_notify_if_events(void)
+{
+ if (mutex_lock_interruptible(&dropbox_queue_lock))
+ sysfs_notify(&dropbox_kobj, NULL, "event");
+ else {
+ if (!dropbox_event_queue_empty_locked())
+ sysfs_notify(&dropbox_kobj, NULL, "event");
+ mutex_unlock(&dropbox_queue_lock);
+ }
+}
+
+static void dropbox_free_event(struct dropbox_event *event)
+{
+ if (event) {
+ if (event->data) {
+ vfree(event->data);
+ event->data = NULL;
+ }
+ vfree(event);
+ }
+}
+
+static struct dropbox_event *dropbox_dequeue_event_locked(void)
+{
+ struct dropbox_event *event = NULL;
+
+ if (!list_empty(&dropbox_event_list)) {
+ event = list_first_entry(&dropbox_event_list,
+ struct dropbox_event, list);
+ list_del(&event->list);
+ }
+
+ return event;
+}
+
+static struct dropbox_event *dropbox_dequeue_event(void)
+{
+ struct dropbox_event *event = NULL;
+
+ mutex_lock(&dropbox_queue_lock);
+ event = dropbox_dequeue_event_locked();
+ mutex_unlock(&dropbox_queue_lock);
+
+ return event;
+}
+
+static void dropbox_queue_event(char *name, void *data, size_t size, int flags)
+{
+ struct dropbox_event *new_event = NULL;
+
+ if (!name || strlen(name) <= 0 || strlen(name) > EVENT_NAME_LENGTH) {
+ pr_err("%s: invalid name\n", __func__);
+ return;
+ }
+
+ if (!data || !size) {
+ pr_err("%s: invalid arguments [%s][%p][%zu]\n", __func__, name,
+ data, size);
+ return;
+ }
+
+ mutex_lock(&dropbox_queue_lock);
+
+ if (dropbox_event_queue_full_locked()) {
+ struct dropbox_event *cur = NULL;
+ /* drop oldest event */
+ cur = dropbox_dequeue_event_locked();
+ if (cur) {
+ pr_warn("%s: Dropping oldest event [%s]",
+ __func__, cur->name);
+ dropbox_free_event(cur);
+ }
+ }
+
+ new_event = vzalloc(sizeof(struct dropbox_event));
+ if (new_event) {
+ scnprintf(new_event->name,
+ sizeof(new_event->name), "%s", name);
+ new_event->data = vmalloc(size);
+ if (new_event->data) {
+ memcpy(new_event->data, data, size);
+ new_event->size = size;
+ new_event->flags = flags;
+
+ list_add_tail(&new_event->list, &dropbox_event_list);
+ sysfs_notify(&dropbox_kobj, NULL, "event");
+ } else {
+ pr_err("%s: Failed to allocate new event data",
+ __func__);
+ dropbox_free_event(new_event);
+ }
+ } else {
+ pr_err("%s: Failed to allocate new event", __func__);
+ }
+
+ mutex_unlock(&dropbox_queue_lock);
+}
+
+void dropbox_queue_event_binary(char *name, void *data, size_t size)
+{
+ dropbox_queue_event(name, data, size, 0);
+}
+
+void dropbox_queue_event_text(char *name, void *data, size_t size)
+{
+ dropbox_queue_event(name, data, size, DROPBOX_TEXT_FLAG);
+}
+
+void dropbox_queue_event_binaryfile(char *name, char *path)
+{
+ dropbox_queue_event(name, path, strlen(path), DROPBOX_FILE_FLAG);
+}
+
+void dropbox_queue_event_textfile(char *name, char *path)
+{
+ dropbox_queue_event(name, path, strlen(path),
+ DROPBOX_TEXT_FLAG | DROPBOX_FILE_FLAG);
+}
+
+void dropbox_queue_event_empty(char *name)
+{
+ dropbox_queue_event(name, name, strlen(name), DROPBOX_TEXT_FLAG);
+}
+
+struct dropbox_trigger_callback {
+ char name[EVENT_NAME_LENGTH];
+ void (*callback)(void *);
+ void *data;
+ struct list_head list;
+};
+
+static LIST_HEAD(dropbox_trigger_callback_list);
+
+void dropbox_register_trigger_callback(const char *name,
+ void (*callback)(void *),
+ void *data)
+{
+ struct dropbox_trigger_callback *cur = NULL;
+
+ if (!name || strlen(name) <= 0 || strlen(name) > EVENT_NAME_LENGTH) {
+ pr_err("%s: invalid name\n", __func__);
+ return;
+ }
+
+ list_for_each_entry(cur, &dropbox_trigger_callback_list, list) {
+ if (!strncmp(cur->name, name, sizeof(cur->name))) {
+ pr_err("%s: Event already registered with name: %s\n",
+ __func__, name);
+ return;
+ }
+ }
+
+ cur = vzalloc(sizeof(struct dropbox_trigger_callback));
+ if (cur) {
+ scnprintf(cur->name, sizeof(cur->name), "%s", name);
+ cur->callback = callback;
+ cur->data = data;
+
+ list_add_tail(&cur->list, &dropbox_trigger_callback_list);
+ } else {
+ pr_err("%s: Failed to allocate new trigger callback", __func__);
+ }
+}
+
+static void do_dropbox_trigger_callback(const char *name)
+{
+ struct dropbox_trigger_callback *cur = NULL;
+
+ if (!name || strlen(name) <= 0 || strlen(name) > EVENT_NAME_LENGTH) {
+ pr_err("%s: invalid name\n", __func__);
+ return;
+ }
+
+ list_for_each_entry(cur, &dropbox_trigger_callback_list, list) {
+ if (!strncmp(cur->name, name, sizeof(cur->name))) {
+ cur->callback(cur->data);
+ return;
+ }
+ }
+
+ pr_err("%s: No callback found for event [%s]", __func__, name);
+}
+
+void dropbox_dummy_test_trigger(void *data)
+{
+ dropbox_queue_event_empty("dropbox_dummy_test");
+}
+
+/* sysfs entry code */
+
+
+struct dropbox_attribute {
+ struct attribute attr;
+ ssize_t (*show)(struct kobject *kobj, char *buf);
+ ssize_t (*store)(struct kobject *kobj, const char *buf,
+ size_t count);
+};
+
+#define to_dropbox_attr(a) \
+container_of(a, struct dropbox_attribute, attr)
+
+static struct dropbox_event *dropbox_current_event;
+
+/* Dump the sysfs binary data to the user */
+static ssize_t dropbox_data_show(struct file *filep, struct kobject *kobj,
+ struct bin_attribute *attr, char *buf,
+ loff_t off, size_t count)
+{
+ int size = 0;
+
+ if (!dropbox_current_event)
+ dropbox_current_event = dropbox_dequeue_event();
+
+ if (!dropbox_current_event) {
+ pr_err("%s: no dropbox events", __func__);
+ goto end;
+ }
+
+ if (dropbox_current_event->data) {
+ void *src = dropbox_current_event->data + off;
+
+ if (dropbox_current_event->size > off) {
+ size = dropbox_current_event->size - off;
+ size = size > count ? count : size;
+ memcpy(buf, src, size);
+ }
+ } else
+ pr_err("%s: dropbox_data is empty\n", __func__);
+
+ if (!size) {
+ dropbox_free_event(dropbox_current_event);
+ dropbox_current_event = NULL;
+ dropbox_notify_if_events();
+ }
+
+end:
+ return size;
+}
+
+static ssize_t dropbox_event_show(struct kobject *kobj, char *buf)
+{
+ if (!list_empty(&dropbox_event_list)) {
+ struct dropbox_event *event = list_first_entry(
+ &dropbox_event_list, struct dropbox_event, list);
+ return scnprintf(buf, PAGE_SIZE, "%s:%d\n", event->name,
+ event->flags);
+ } else
+ return scnprintf(buf, PAGE_SIZE, "\n");
+}
+
+static ssize_t dropbox_trigger_store(struct kobject *kobj, const char *buf,
+ size_t count)
+{
+ unsigned int ret = -EINVAL;
+ char event_name[EVENT_NAME_LENGTH];
+
+ if (count <= 0 || count > EVENT_NAME_LENGTH) {
+ pr_err("%s: invalid string, max length is 64 characters\n",
+ __func__);
+ } else {
+ ret = sscanf(buf, "%63s", event_name);
+ if (ret != 1)
+ return -EINVAL;
+ pr_info("%s: forcing event [%s]\n", __func__, event_name);
+ do_dropbox_trigger_callback(event_name);
+ }
+
+ return count;
+}
+
+static ssize_t dropbox_available_triggers_show(struct kobject *kobj, char *buf)
+{
+ char *cur = buf;
+ struct dropbox_trigger_callback *cb_cur = NULL;
+
+ list_for_each_entry(cb_cur, &dropbox_trigger_callback_list, list) {
+ int count = scnprintf(cur, PAGE_SIZE-(cur-buf), "%s\n",
+ cb_cur->name);
+ cur = cur + count;
+ }
+
+ return cur-buf;
+}
+
+static struct bin_attribute attr_data = {
+ .attr.name = "data",
+ .attr.mode = 0440,
+ .size = 0,
+ .read = dropbox_data_show
+};
+
+#define DROPBOX_ATTR(_name, _mode, _show, _store) \
+static struct dropbox_attribute attr_##_name = { \
+ .attr = { .name = __stringify(_name), .mode = _mode }, \
+ .show = _show, \
+ .store = _store, \
+}
+
+DROPBOX_ATTR(event, 0440, dropbox_event_show, NULL);
+DROPBOX_ATTR(trigger, 0200, NULL, dropbox_trigger_store);
+DROPBOX_ATTR(available_triggers, 0400, dropbox_available_triggers_show, NULL);
+
+static void dropbox_sysfs_release(struct kobject *kobj)
+{
+}
+
+static ssize_t dropbox_sysfs_show(struct kobject *kobj,
+ struct attribute *attr, char *buf)
+{
+ struct dropbox_attribute *pattr = to_dropbox_attr(attr);
+ ssize_t ret = -EIO;
+
+ if (kobj && pattr->show)
+ ret = pattr->show(kobj, buf);
+
+ return ret;
+}
+
+static ssize_t dropbox_sysfs_store(struct kobject *kobj,
+ struct attribute *attr,
+ const char *buf, size_t count)
+{
+ struct dropbox_attribute *pattr = to_dropbox_attr(attr);
+ ssize_t ret = -EIO;
+
+ if (kobj && pattr->store)
+ ret = pattr->store(kobj, buf, count);
+
+ return ret;
+}
+
+static const struct sysfs_ops dropbox_sysfs_ops = {
+ .show = dropbox_sysfs_show,
+ .store = dropbox_sysfs_store,
+};
+
+static struct kobj_type ktype_dropbox = {
+ .sysfs_ops = &dropbox_sysfs_ops,
+ .default_attrs = NULL,
+ .release = dropbox_sysfs_release,
+};
+
+int __init dropbox_init(void)
+{
+ int ret = 0;
+
+ ret = kobject_init_and_add(&dropbox_kobj, &ktype_dropbox,
+ kernel_kobj, "dropbox");
+ if (ret)
+ goto done;
+
+ ret = sysfs_create_file(&dropbox_kobj, &attr_event.attr);
+ if (ret)
+ goto done;
+
+ ret = sysfs_create_file(&dropbox_kobj, &attr_trigger.attr);
+ if (ret)
+ goto done;
+
+ ret = sysfs_create_file(&dropbox_kobj, &attr_available_triggers.attr);
+ if (ret)
+ goto done;
+
+ ret = sysfs_create_bin_file(&dropbox_kobj, &attr_data);
+ if (ret)
+ goto done;
+
+ dropbox_register_trigger_callback("dummy_test_trigger",
+ &dropbox_dummy_test_trigger, NULL);
+
+done:
+ return ret;
+}
+
+core_initcall(dropbox_init);
projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / commitdiff