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