~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/firewire/dice/dice-hwdep.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * dice_hwdep.c - a part of driver for DICE based devices
  3  *
  4  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
  5  * Copyright (c) 2014 Takashi Sakamoto <o-takashi@sakamocchi.jp>
  6  *
  7  * Licensed under the terms of the GNU General Public License, version 2.
  8  */
  9 
 10 #include "dice.h"
 11 
 12 static long hwdep_read(struct snd_hwdep *hwdep, char __user *buf,
 13                             long count, loff_t *offset)
 14 {
 15         struct snd_dice *dice = hwdep->private_data;
 16         DEFINE_WAIT(wait);
 17         union snd_firewire_event event;
 18 
 19         spin_lock_irq(&dice->lock);
 20 
 21         while (!dice->dev_lock_changed && dice->notification_bits == 0) {
 22                 prepare_to_wait(&dice->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
 23                 spin_unlock_irq(&dice->lock);
 24                 schedule();
 25                 finish_wait(&dice->hwdep_wait, &wait);
 26                 if (signal_pending(current))
 27                         return -ERESTARTSYS;
 28                 spin_lock_irq(&dice->lock);
 29         }
 30 
 31         memset(&event, 0, sizeof(event));
 32         if (dice->dev_lock_changed) {
 33                 event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS;
 34                 event.lock_status.status = dice->dev_lock_count > 0;
 35                 dice->dev_lock_changed = false;
 36 
 37                 count = min_t(long, count, sizeof(event.lock_status));
 38         } else {
 39                 event.dice_notification.type =
 40                                         SNDRV_FIREWIRE_EVENT_DICE_NOTIFICATION;
 41                 event.dice_notification.notification = dice->notification_bits;
 42                 dice->notification_bits = 0;
 43 
 44                 count = min_t(long, count, sizeof(event.dice_notification));
 45         }
 46 
 47         spin_unlock_irq(&dice->lock);
 48 
 49         if (copy_to_user(buf, &event, count))
 50                 return -EFAULT;
 51 
 52         return count;
 53 }
 54 
 55 static unsigned int hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 56                                poll_table *wait)
 57 {
 58         struct snd_dice *dice = hwdep->private_data;
 59         unsigned int events;
 60 
 61         poll_wait(file, &dice->hwdep_wait, wait);
 62 
 63         spin_lock_irq(&dice->lock);
 64         if (dice->dev_lock_changed || dice->notification_bits != 0)
 65                 events = POLLIN | POLLRDNORM;
 66         else
 67                 events = 0;
 68         spin_unlock_irq(&dice->lock);
 69 
 70         return events;
 71 }
 72 
 73 static int hwdep_get_info(struct snd_dice *dice, void __user *arg)
 74 {
 75         struct fw_device *dev = fw_parent_device(dice->unit);
 76         struct snd_firewire_get_info info;
 77 
 78         memset(&info, 0, sizeof(info));
 79         info.type = SNDRV_FIREWIRE_TYPE_DICE;
 80         info.card = dev->card->index;
 81         *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
 82         *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
 83         strlcpy(info.device_name, dev_name(&dev->device),
 84                 sizeof(info.device_name));
 85 
 86         if (copy_to_user(arg, &info, sizeof(info)))
 87                 return -EFAULT;
 88 
 89         return 0;
 90 }
 91 
 92 static int hwdep_lock(struct snd_dice *dice)
 93 {
 94         int err;
 95 
 96         spin_lock_irq(&dice->lock);
 97 
 98         if (dice->dev_lock_count == 0) {
 99                 dice->dev_lock_count = -1;
100                 err = 0;
101         } else {
102                 err = -EBUSY;
103         }
104 
105         spin_unlock_irq(&dice->lock);
106 
107         return err;
108 }
109 
110 static int hwdep_unlock(struct snd_dice *dice)
111 {
112         int err;
113 
114         spin_lock_irq(&dice->lock);
115 
116         if (dice->dev_lock_count == -1) {
117                 dice->dev_lock_count = 0;
118                 err = 0;
119         } else {
120                 err = -EBADFD;
121         }
122 
123         spin_unlock_irq(&dice->lock);
124 
125         return err;
126 }
127 
128 static int hwdep_release(struct snd_hwdep *hwdep, struct file *file)
129 {
130         struct snd_dice *dice = hwdep->private_data;
131 
132         spin_lock_irq(&dice->lock);
133         if (dice->dev_lock_count == -1)
134                 dice->dev_lock_count = 0;
135         spin_unlock_irq(&dice->lock);
136 
137         return 0;
138 }
139 
140 static int hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
141                        unsigned int cmd, unsigned long arg)
142 {
143         struct snd_dice *dice = hwdep->private_data;
144 
145         switch (cmd) {
146         case SNDRV_FIREWIRE_IOCTL_GET_INFO:
147                 return hwdep_get_info(dice, (void __user *)arg);
148         case SNDRV_FIREWIRE_IOCTL_LOCK:
149                 return hwdep_lock(dice);
150         case SNDRV_FIREWIRE_IOCTL_UNLOCK:
151                 return hwdep_unlock(dice);
152         default:
153                 return -ENOIOCTLCMD;
154         }
155 }
156 
157 #ifdef CONFIG_COMPAT
158 static int hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
159                               unsigned int cmd, unsigned long arg)
160 {
161         return hwdep_ioctl(hwdep, file, cmd,
162                            (unsigned long)compat_ptr(arg));
163 }
164 #else
165 #define hwdep_compat_ioctl NULL
166 #endif
167 
168 int snd_dice_create_hwdep(struct snd_dice *dice)
169 {
170         static const struct snd_hwdep_ops ops = {
171                 .read         = hwdep_read,
172                 .release      = hwdep_release,
173                 .poll         = hwdep_poll,
174                 .ioctl        = hwdep_ioctl,
175                 .ioctl_compat = hwdep_compat_ioctl,
176         };
177         struct snd_hwdep *hwdep;
178         int err;
179 
180         err = snd_hwdep_new(dice->card, "DICE", 0, &hwdep);
181         if (err < 0)
182                 return err;
183         strcpy(hwdep->name, "DICE");
184         hwdep->iface = SNDRV_HWDEP_IFACE_FW_DICE;
185         hwdep->ops = ops;
186         hwdep->private_data = dice;
187         hwdep->exclusive = true;
188 
189         return 0;
190 }
191 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp