Pileus Git - ~andy/linux/blob - drivers/staging/android/sw_sync.c

   1 /*
   2  * drivers/base/sw_sync.c
   3  *
   4  * Copyright (C) 2012 Google, Inc.
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/export.h>
  19 #include <linux/file.h>
  20 #include <linux/fs.h>
  21 #include <linux/miscdevice.h>
  22 #include <linux/module.h>
  23 #include <linux/syscalls.h>
  24 #include <linux/uaccess.h>
  25
  26 #include "sw_sync.h"
  27
  28 static int sw_sync_cmp(u32 a, u32 b)
  29 {
  30         if (a == b)
  31                 return 0;
  32
  33         return ((s32)a - (s32)b) < 0 ? -1 : 1;
  34 }
  35
  36 struct sync_pt *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value)
  37 {
  38         struct sw_sync_pt *pt;
  39
  40         pt = (struct sw_sync_pt *)
  41                 sync_pt_create(&obj->obj, sizeof(struct sw_sync_pt));
  42
  43         pt->value = value;
  44
  45         return (struct sync_pt *)pt;
  46 }
  47 EXPORT_SYMBOL(sw_sync_pt_create);
  48
  49 static struct sync_pt *sw_sync_pt_dup(struct sync_pt *sync_pt)
  50 {
  51         struct sw_sync_pt *pt = (struct sw_sync_pt *) sync_pt;
  52         struct sw_sync_timeline *obj =
  53                 (struct sw_sync_timeline *)sync_pt->parent;
  54
  55         return (struct sync_pt *) sw_sync_pt_create(obj, pt->value);
  56 }
  57
  58 static int sw_sync_pt_has_signaled(struct sync_pt *sync_pt)
  59 {
  60         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  61         struct sw_sync_timeline *obj =
  62                 (struct sw_sync_timeline *)sync_pt->parent;
  63
  64         return sw_sync_cmp(obj->value, pt->value) >= 0;
  65 }
  66
  67 static int sw_sync_pt_compare(struct sync_pt *a, struct sync_pt *b)
  68 {
  69         struct sw_sync_pt *pt_a = (struct sw_sync_pt *)a;
  70         struct sw_sync_pt *pt_b = (struct sw_sync_pt *)b;
  71
  72         return sw_sync_cmp(pt_a->value, pt_b->value);
  73 }
  74
  75 static int sw_sync_fill_driver_data(struct sync_pt *sync_pt,
  76                                     void *data, int size)
  77 {
  78         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
  79
  80         if (size < sizeof(pt->value))
  81                 return -ENOMEM;
  82
  83         memcpy(data, &pt->value, sizeof(pt->value));
  84
  85         return sizeof(pt->value);
  86 }
  87
  88 static void sw_sync_timeline_value_str(struct sync_timeline *sync_timeline,
  89                                        char *str, int size)
  90 {
  91         struct sw_sync_timeline *timeline =
  92                 (struct sw_sync_timeline *)sync_timeline;
  93         snprintf(str, size, "%d", timeline->value);
  94 }
  95
  96 static void sw_sync_pt_value_str(struct sync_pt *sync_pt,
  97                                        char *str, int size)
  98 {
  99         struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
 100         snprintf(str, size, "%d", pt->value);
 101 }
 102
 103 static struct sync_timeline_ops sw_sync_timeline_ops = {
 104         .driver_name = "sw_sync",
 105         .dup = sw_sync_pt_dup,
 106         .has_signaled = sw_sync_pt_has_signaled,
 107         .compare = sw_sync_pt_compare,
 108         .fill_driver_data = sw_sync_fill_driver_data,
 109         .timeline_value_str = sw_sync_timeline_value_str,
 110         .pt_value_str = sw_sync_pt_value_str,
 111 };
 112
 113
 114 struct sw_sync_timeline *sw_sync_timeline_create(const char *name)
 115 {
 116         struct sw_sync_timeline *obj = (struct sw_sync_timeline *)
 117                 sync_timeline_create(&sw_sync_timeline_ops,
 118                                      sizeof(struct sw_sync_timeline),
 119                                      name);
 120
 121         return obj;
 122 }
 123 EXPORT_SYMBOL(sw_sync_timeline_create);
 124
 125 void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc)
 126 {
 127         obj->value += inc;
 128
 129         sync_timeline_signal(&obj->obj);
 130 }
 131 EXPORT_SYMBOL(sw_sync_timeline_inc);
 132
 133 #ifdef CONFIG_SW_SYNC_USER
 134 /* *WARNING*
 135  *
 136  * improper use of this can result in deadlocking kernel drivers from userspace.
 137  */
 138
 139 /* opening sw_sync create a new sync obj */
 140 static int sw_sync_open(struct inode *inode, struct file *file)
 141 {
 142         struct sw_sync_timeline *obj;
 143         char task_comm[TASK_COMM_LEN];
 144
 145         get_task_comm(task_comm, current);
 146
 147         obj = sw_sync_timeline_create(task_comm);
 148         if (obj == NULL)
 149                 return -ENOMEM;
 150
 151         file->private_data = obj;
 152
 153         return 0;
 154 }
 155
 156 static int sw_sync_release(struct inode *inode, struct file *file)
 157 {
 158         struct sw_sync_timeline *obj = file->private_data;
 159         sync_timeline_destroy(&obj->obj);
 160         return 0;
 161 }
 162
 163 static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, unsigned long arg)
 164 {
 165         int fd = get_unused_fd();
 166         int err;
 167         struct sync_pt *pt;
 168         struct sync_fence *fence;
 169         struct sw_sync_create_fence_data data;
 170
 171         if (fd < 0)
 172                 return fd;
 173
 174         if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
 175                 err = -EFAULT;
 176                 goto err;
 177         }
 178
 179         pt = sw_sync_pt_create(obj, data.value);
 180         if (pt == NULL) {
 181                 err = -ENOMEM;
 182                 goto err;
 183         }
 184
 185         data.name[sizeof(data.name) - 1] = '\0';
 186         fence = sync_fence_create(data.name, pt);
 187         if (fence == NULL) {
 188                 sync_pt_free(pt);
 189                 err = -ENOMEM;
 190                 goto err;
 191         }
 192
 193         data.fence = fd;
 194         if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
 195                 sync_fence_put(fence);
 196                 err = -EFAULT;
 197                 goto err;
 198         }
 199
 200         sync_fence_install(fence, fd);
 201
 202         return 0;
 203
 204 err:
 205         put_unused_fd(fd);
 206         return err;
 207 }
 208
 209 static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg)
 210 {
 211         u32 value;
 212
 213         if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
 214                 return -EFAULT;
 215
 216         sw_sync_timeline_inc(obj, value);
 217
 218         return 0;
 219 }
 220
 221 static long sw_sync_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 222 {
 223         struct sw_sync_timeline *obj = file->private_data;
 224
 225         switch (cmd) {
 226         case SW_SYNC_IOC_CREATE_FENCE:
 227                 return sw_sync_ioctl_create_fence(obj, arg);
 228
 229         case SW_SYNC_IOC_INC:
 230                 return sw_sync_ioctl_inc(obj, arg);
 231
 232         default:
 233                 return -ENOTTY;
 234         }
 235 }
 236
 237 static const struct file_operations sw_sync_fops = {
 238         .owner = THIS_MODULE,
 239         .open = sw_sync_open,
 240         .release = sw_sync_release,
 241         .unlocked_ioctl = sw_sync_ioctl,
 242         .compat_ioctl = sw_sync_ioctl,
 243 };
 244
 245 static struct miscdevice sw_sync_dev = {
 246         .minor  = MISC_DYNAMIC_MINOR,
 247         .name   = "sw_sync",
 248         .fops   = &sw_sync_fops,
 249 };
 250
 251 static int __init sw_sync_device_init(void)
 252 {
 253         return misc_register(&sw_sync_dev);
 254 }
 255
 256 static void __exit sw_sync_device_remove(void)
 257 {
 258         misc_deregister(&sw_sync_dev);
 259 }
 260
 261 module_init(sw_sync_device_init);
 262 module_exit(sw_sync_device_remove);
 263
 264 #endif /* CONFIG_SW_SYNC_USER */