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 long count = 0; 29 30 if (remained < sizeof(type) + sizeof(struct snd_efw_transaction)) 31 return -ENOSPC; 32 33 /* data type is SNDRV_FIREWIRE_EVENT_EFW_RESPONSE */ 34 type = SNDRV_FIREWIRE_EVENT_EFW_RESPONSE; 35 if (copy_to_user(buf, &type, sizeof(type))) 36 return -EFAULT; 37 remained -= sizeof(type); 38 buf += sizeof(type); 39 40 /* write into buffer as many responses as possible */ 41 while (efw->resp_queues > 0) { 42 t = (struct snd_efw_transaction *)(efw->pull_ptr); 43 length = be32_to_cpu(t->length) * sizeof(__be32); 44 45 /* confirm enough space for this response */ 46 if (remained < length) 47 break; 48 49 /* copy from ring buffer to user buffer */ 50 while (length > 0) { 51 till_end = snd_efw_resp_buf_size - 52 (unsigned int)(efw->pull_ptr - efw->resp_buf); 53 till_end = min_t(unsigned int, length, till_end); 54 55 if (copy_to_user(buf, efw->pull_ptr, till_end)) 56 return -EFAULT; 57 58 efw->pull_ptr += till_end; 59 if (efw->pull_ptr >= efw->resp_buf + 60 snd_efw_resp_buf_size) 61 efw->pull_ptr -= snd_efw_resp_buf_size; 62 63 length -= till_end; 64 buf += till_end; 65 count += till_end; 66 remained -= till_end; 67 } 68 69 efw->resp_queues--; 70 } 71 72 return count; 73 } 74 75 static long 76 hwdep_read_locked(struct snd_efw *efw, char __user *buf, long count, 77 loff_t *offset) 78 { 79 union snd_firewire_event event; 80 81 memset(&event, 0, sizeof(event)); 82 83 event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS; 84 event.lock_status.status = (efw->dev_lock_count > 0); 85 efw->dev_lock_changed = false; 86 87 count = min_t(long, count, sizeof(event.lock_status)); 88 89 if (copy_to_user(buf, &event, count)) 90 return -EFAULT; 91 92 return count; 93 } 94 95 static long 96 hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count, 97 loff_t *offset) 98 { 99 struct snd_efw *efw = hwdep->private_data; 100 DEFINE_WAIT(wait); 101 102 spin_lock_irq(&efw->lock); 103 104 while ((!efw->dev_lock_changed) && (efw->resp_queues == 0)) { 105 prepare_to_wait(&efw->hwdep_wait, &wait, TASK_INTERRUPTIBLE); 106 spin_unlock_irq(&efw->lock); 107 schedule(); 108 finish_wait(&efw->hwdep_wait, &wait); 109 if (signal_pending(current)) 110 return -ERESTARTSYS; 111 spin_lock_irq(&efw->lock); 112 } 113 114 if (efw->dev_lock_changed) 115 count = hwdep_read_locked(efw, buf, count, offset); 116 else if (efw->resp_queues > 0) 117 count = hwdep_read_resp_buf(efw, buf, count, offset); 118 119 spin_unlock_irq(&efw->lock); 120 121 return count; 122 } 123 124 static long 125 hwdep_write(struct snd_hwdep *hwdep, const char __user *data, long count, 126 loff_t *offset) 127 { 128 struct snd_efw *efw = hwdep->private_data; 129 u32 seqnum; 130 u8 *buf; 131 132 if (count < sizeof(struct snd_efw_transaction) || 133 SND_EFW_RESPONSE_MAXIMUM_BYTES < count) 134 return -EINVAL; 135 136 buf = memdup_user(data, count); 137 if (IS_ERR(buf)) 138 return PTR_ERR(buf); 139 140 /* check seqnum is not for kernel-land */ 141 seqnum = be32_to_cpu(((struct snd_efw_transaction *)buf)->seqnum); 142 if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX) { 143 count = -EINVAL; 144 goto end; 145 } 146 147 if (snd_efw_transaction_cmd(efw->unit, buf, count) < 0) 148 count = -EIO; 149 end: 150 kfree(buf); 151 return count; 152 } 153 154 static unsigned int 155 hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait) 156 { 157 struct snd_efw *efw = hwdep->private_data; 158 unsigned int events; 159 160 poll_wait(file, &efw->hwdep_wait, wait); 161 162 spin_lock_irq(&efw->lock); 163 if (efw->dev_lock_changed || (efw->resp_queues > 0)) 164 events = POLLIN | POLLRDNORM; 165 else 166 events = 0; 167 spin_unlock_irq(&efw->lock); 168 169 return events | POLLOUT; 170 } 171 172 static int 173 hwdep_get_info(struct snd_efw *efw, void __user *arg) 174 { 175 struct fw_device *dev = fw_parent_device(efw->unit); 176 struct snd_firewire_get_info info; 177 178 memset(&info, 0, sizeof(info)); 179 info.type = SNDRV_FIREWIRE_TYPE_FIREWORKS; 180 info.card = dev->card->index; 181 *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]); 182 *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]); 183 strlcpy(info.device_name, dev_name(&dev->device), 184 sizeof(info.device_name)); 185 186 if (copy_to_user(arg, &info, sizeof(info))) 187 return -EFAULT; 188 189 return 0; 190 } 191 192 static int 193 hwdep_lock(struct snd_efw *efw) 194 { 195 int err; 196 197 spin_lock_irq(&efw->lock); 198 199 if (efw->dev_lock_count == 0) { 200 efw->dev_lock_count = -1; 201 err = 0; 202 } else { 203 err = -EBUSY; 204 } 205 206 spin_unlock_irq(&efw->lock); 207 208 return err; 209 } 210 211 static int 212 hwdep_unlock(struct snd_efw *efw) 213 { 214 int err; 215 216 spin_lock_irq(&efw->lock); 217 218 if (efw->dev_lock_count == -1) { 219 efw->dev_lock_count = 0; 220 err = 0; 221 } else { 222 err = -EBADFD; 223 } 224 225 spin_unlock_irq(&efw->lock); 226 227 return err; 228 } 229 230 static int 231 hwdep_release(struct snd_hwdep *hwdep, struct file *file) 232 { 233 struct snd_efw *efw = hwdep->private_data; 234 235 spin_lock_irq(&efw->lock); 236 if (efw->dev_lock_count == -1) 237 efw->dev_lock_count = 0; 238 spin_unlock_irq(&efw->lock); 239 240 return 0; 241 } 242 243 static int 244 hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file, 245 unsigned int cmd, unsigned long arg) 246 { 247 struct snd_efw *efw = hwdep->private_data; 248 249 switch (cmd) { 250 case SNDRV_FIREWIRE_IOCTL_GET_INFO: 251 return hwdep_get_info(efw, (void __user *)arg); 252 case SNDRV_FIREWIRE_IOCTL_LOCK: 253 return hwdep_lock(efw); 254 case SNDRV_FIREWIRE_IOCTL_UNLOCK: 255 return hwdep_unlock(efw); 256 default: 257 return -ENOIOCTLCMD; 258 } 259 } 260 261 #ifdef CONFIG_COMPAT 262 static int 263 hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file, 264 unsigned int cmd, unsigned long arg) 265 { 266 return hwdep_ioctl(hwdep, file, cmd, 267 (unsigned long)compat_ptr(arg)); 268 } 269 #else 270 #define hwdep_compat_ioctl NULL 271 #endif 272 273 static const struct snd_hwdep_ops hwdep_ops = { 274 .read = hwdep_read, 275 .write = hwdep_write, 276 .release = hwdep_release, 277 .poll = hwdep_poll, 278 .ioctl = hwdep_ioctl, 279 .ioctl_compat = hwdep_compat_ioctl, 280 }; 281 282 int snd_efw_create_hwdep_device(struct snd_efw *efw) 283 { 284 struct snd_hwdep *hwdep; 285 int err; 286 287 err = snd_hwdep_new(efw->card, "Fireworks", 0, &hwdep); 288 if (err < 0) 289 goto end; 290 strcpy(hwdep->name, "Fireworks"); 291 hwdep->iface = SNDRV_HWDEP_IFACE_FW_FIREWORKS; 292 hwdep->ops = hwdep_ops; 293 hwdep->private_data = efw; 294 hwdep->exclusive = true; 295 end: 296 return err; 297 } 298 299