sound/firewire/fireworks/fireworks_hwdep.c

   1 /*
   2  * fireworks_hwdep.c - a part of driver for Fireworks based devices
   3  *
   4  * Copyright (c) 2013-2014 Takashi Sakamoto
   5  *
   6  * Licensed under the terms of the GNU General Public License, version 2.
   7  */
   8
   9 /*
  10  * This codes have five functionalities.
  11  *
  12  * 1.get information about firewire node
  13  * 2.get notification about starting/stopping stream
  14  * 3.lock/unlock streaming
  15  * 4.transmit command of EFW transaction
  16  * 5.receive response of EFW transaction
  17  *
  18  */
  19
  20 #include "fireworks.h"
  21
  22 static long
  23 hwdep_read_resp_buf(struct snd_efw *efw, char __user *buf, long remained,
  24                     loff_t *offset)
  25 {
  26         unsigned int length, till_end, type;
  27         struct snd_efw_transaction *t;
  28         u8 *pull_ptr;
  29         long count = 0;
  30
  31         if (remained < sizeof(type) + sizeof(struct snd_efw_transaction))
  32                 return -ENOSPC;
  33
  34         /* data type is SNDRV_FIREWIRE_EVENT_EFW_RESPONSE */
  35         type = SNDRV_FIREWIRE_EVENT_EFW_RESPONSE;
  36         if (copy_to_user(buf, &type, sizeof(type)))
  37                 return -EFAULT;
  38         remained -= sizeof(type);
  39         buf += sizeof(type);
  40
  41         /* write into buffer as many responses as possible */
  42         spin_lock_irq(&efw->lock);
  43
  44         /*
  45          * When another task reaches here during this task's access to user
  46          * space, it picks up current position in buffer and can read the same
  47          * series of responses.
  48          */
  49         pull_ptr = efw->pull_ptr;
  50
  51         while (efw->push_ptr != pull_ptr) {
  52                 t = (struct snd_efw_transaction *)(pull_ptr);
  53                 length = be32_to_cpu(t->length) * sizeof(__be32);
  54
  55                 /* confirm enough space for this response */
  56                 if (remained < length)
  57                         break;
  58
  59                 /* copy from ring buffer to user buffer */
  60                 while (length > 0) {
  61                         till_end = snd_efw_resp_buf_size -
  62                                 (unsigned int)(pull_ptr - efw->resp_buf);
  63                         till_end = min_t(unsigned int, length, till_end);
  64
  65                         spin_unlock_irq(&efw->lock);
  66
  67                         if (copy_to_user(buf, pull_ptr, till_end))
  68                                 return -EFAULT;
  69
  70                         spin_lock_irq(&efw->lock);
  71
  72                         pull_ptr += till_end;
  73                         if (pull_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
  74                                 pull_ptr -= snd_efw_resp_buf_size;
  75
  76                         length -= till_end;
  77                         buf += till_end;
  78                         count += till_end;
  79                         remained -= till_end;
  80                 }
  81         }
  82
  83         /*
  84          * All of tasks can read from the buffer nearly simultaneously, but the
  85          * last position for each task is different depending on the length of
  86          * given buffer. Here, for simplicity, a position of buffer is set by
  87          * the latest task. It's better for a listening application to allow one
  88          * thread to read from the buffer. Unless, each task can read different
  89          * sequence of responses depending on variation of buffer length.
  90          */
  91         efw->pull_ptr = pull_ptr;
  92
  93         spin_unlock_irq(&efw->lock);
  94
  95         return count;
  96 }
  97
  98 static long
  99 hwdep_read_locked(struct snd_efw *efw, char __user *buf, long count,
 100                   loff_t *offset)
 101 {
 102         union snd_firewire_event event = {
 103                 .lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS,
 104         };
 105
 106         spin_lock_irq(&efw->lock);
 107
 108         event.lock_status.status = (efw->dev_lock_count > 0);
 109         efw->dev_lock_changed = false;
 110
 111         spin_unlock_irq(&efw->lock);
 112
 113         count = min_t(long, count, sizeof(event.lock_status));
 114
 115         if (copy_to_user(buf, &event, count))
 116                 return -EFAULT;
 117
 118         return count;
 119 }
 120
 121 static long
 122 hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count,
 123            loff_t *offset)
 124 {
 125         struct snd_efw *efw = hwdep->private_data;
 126         DEFINE_WAIT(wait);
 127         bool dev_lock_changed;
 128         bool queued;
 129
 130         spin_lock_irq(&efw->lock);
 131
 132         dev_lock_changed = efw->dev_lock_changed;
 133         queued = efw->push_ptr != efw->pull_ptr;
 134
 135         while (!dev_lock_changed && !queued) {
 136                 prepare_to_wait(&efw->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
 137                 spin_unlock_irq(&efw->lock);
 138                 schedule();
 139                 finish_wait(&efw->hwdep_wait, &wait);
 140                 if (signal_pending(current))
 141                         return -ERESTARTSYS;
 142                 spin_lock_irq(&efw->lock);
 143                 dev_lock_changed = efw->dev_lock_changed;
 144                 queued = efw->push_ptr != efw->pull_ptr;
 145         }
 146
 147         spin_unlock_irq(&efw->lock);
 148
 149         if (dev_lock_changed)
 150                 count = hwdep_read_locked(efw, buf, count, offset);
 151         else if (queued)
 152                 count = hwdep_read_resp_buf(efw, buf, count, offset);
 153
 154         return count;
 155 }
 156
 157 static long
 158 hwdep_write(struct snd_hwdep *hwdep, const char __user *data, long count,
 159             loff_t *offset)
 160 {
 161         struct snd_efw *efw = hwdep->private_data;
 162         u32 seqnum;
 163         u8 *buf;
 164
 165         if (count < sizeof(struct snd_efw_transaction) ||
 166             SND_EFW_RESPONSE_MAXIMUM_BYTES < count)
 167                 return -EINVAL;
 168
 169         buf = memdup_user(data, count);
 170         if (IS_ERR(buf))
 171                 return PTR_ERR(buf);
 172
 173         /* check seqnum is not for kernel-land */
 174         seqnum = be32_to_cpu(((struct snd_efw_transaction *)buf)->seqnum);
 175         if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX) {
 176                 count = -EINVAL;
 177                 goto end;
 178         }
 179
 180         if (snd_efw_transaction_cmd(efw->unit, buf, count) < 0)
 181                 count = -EIO;
 182 end:
 183         kfree(buf);
 184         return count;
 185 }
 186
 187 static unsigned int
 188 hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait)
 189 {
 190         struct snd_efw *efw = hwdep->private_data;
 191         unsigned int events;
 192
 193         poll_wait(file, &efw->hwdep_wait, wait);
 194
 195         spin_lock_irq(&efw->lock);
 196         if (efw->dev_lock_changed || efw->pull_ptr != efw->push_ptr)
 197                 events = POLLIN | POLLRDNORM;
 198         else
 199                 events = 0;
 200         spin_unlock_irq(&efw->lock);
 201
 202         return events | POLLOUT;
 203 }
 204
 205 static int
 206 hwdep_get_info(struct snd_efw *efw, void __user *arg)
 207 {
 208         struct fw_device *dev = fw_parent_device(efw->unit);
 209         struct snd_firewire_get_info info;
 210
 211         memset(&info, 0, sizeof(info));
 212         info.type = SNDRV_FIREWIRE_TYPE_FIREWORKS;
 213         info.card = dev->card->index;
 214         *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
 215         *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
 216         strlcpy(info.device_name, dev_name(&dev->device),
 217                 sizeof(info.device_name));
 218
 219         if (copy_to_user(arg, &info, sizeof(info)))
 220                 return -EFAULT;
 221
 222         return 0;
 223 }
 224
 225 static int
 226 hwdep_lock(struct snd_efw *efw)
 227 {
 228         int err;
 229
 230         spin_lock_irq(&efw->lock);
 231
 232         if (efw->dev_lock_count == 0) {
 233                 efw->dev_lock_count = -1;
 234                 err = 0;
 235         } else {
 236                 err = -EBUSY;
 237         }
 238
 239         spin_unlock_irq(&efw->lock);
 240
 241         return err;
 242 }
 243
 244 static int
 245 hwdep_unlock(struct snd_efw *efw)
 246 {
 247         int err;
 248
 249         spin_lock_irq(&efw->lock);
 250
 251         if (efw->dev_lock_count == -1) {
 252                 efw->dev_lock_count = 0;
 253                 err = 0;
 254         } else {
 255                 err = -EBADFD;
 256         }
 257
 258         spin_unlock_irq(&efw->lock);
 259
 260         return err;
 261 }
 262
 263 static int
 264 hwdep_release(struct snd_hwdep *hwdep, struct file *file)
 265 {
 266         struct snd_efw *efw = hwdep->private_data;
 267
 268         spin_lock_irq(&efw->lock);
 269         if (efw->dev_lock_count == -1)
 270                 efw->dev_lock_count = 0;
 271         spin_unlock_irq(&efw->lock);
 272
 273         return 0;
 274 }
 275
 276 static int
 277 hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
 278             unsigned int cmd, unsigned long arg)
 279 {
 280         struct snd_efw *efw = hwdep->private_data;
 281
 282         switch (cmd) {
 283         case SNDRV_FIREWIRE_IOCTL_GET_INFO:
 284                 return hwdep_get_info(efw, (void __user *)arg);
 285         case SNDRV_FIREWIRE_IOCTL_LOCK:
 286                 return hwdep_lock(efw);
 287         case SNDRV_FIREWIRE_IOCTL_UNLOCK:
 288                 return hwdep_unlock(efw);
 289         default:
 290                 return -ENOIOCTLCMD;
 291         }
 292 }
 293
 294 #ifdef CONFIG_COMPAT
 295 static int
 296 hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
 297                    unsigned int cmd, unsigned long arg)
 298 {
 299         return hwdep_ioctl(hwdep, file, cmd,
 300                            (unsigned long)compat_ptr(arg));
 301 }
 302 #else
 303 #define hwdep_compat_ioctl NULL
 304 #endif
 305
 306 int snd_efw_create_hwdep_device(struct snd_efw *efw)
 307 {
 308         static const struct snd_hwdep_ops ops = {
 309                 .read           = hwdep_read,
 310                 .write          = hwdep_write,
 311                 .release        = hwdep_release,
 312                 .poll           = hwdep_poll,
 313                 .ioctl          = hwdep_ioctl,
 314                 .ioctl_compat   = hwdep_compat_ioctl,
 315         };
 316         struct snd_hwdep *hwdep;
 317         int err;
 318
 319         err = snd_hwdep_new(efw->card, "Fireworks", 0, &hwdep);
 320         if (err < 0)
 321                 goto end;
 322         strcpy(hwdep->name, "Fireworks");
 323         hwdep->iface = SNDRV_HWDEP_IFACE_FW_FIREWORKS;
 324         hwdep->ops = ops;
 325         hwdep->private_data = efw;
 326         hwdep->exclusive = true;
 327 end:
 328         return err;
 329 }
 330