midibuf.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424
  1. /*
  2. * sound/oss/midibuf.c
  3. *
  4. * Device file manager for /dev/midi#
  5. */
  6. /*
  7. * Copyright (C) by Hannu Savolainen 1993-1997
  8. *
  9. * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10. * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11. * for more info.
  12. */
  13. /*
  14. * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
  15. */
  16. #include <linux/stddef.h>
  17. #include <linux/kmod.h>
  18. #include <linux/spinlock.h>
  19. #define MIDIBUF_C
  20. #include "sound_config.h"
  21. /*
  22. * Don't make MAX_QUEUE_SIZE larger than 4000
  23. */
  24. #define MAX_QUEUE_SIZE 4000
  25. static wait_queue_head_t midi_sleeper[MAX_MIDI_DEV];
  26. static wait_queue_head_t input_sleeper[MAX_MIDI_DEV];
  27. struct midi_buf
  28. {
  29. int len, head, tail;
  30. unsigned char queue[MAX_QUEUE_SIZE];
  31. };
  32. struct midi_parms
  33. {
  34. long prech_timeout; /*
  35. * Timeout before the first ch
  36. */
  37. };
  38. static struct midi_buf *midi_out_buf[MAX_MIDI_DEV] = {NULL};
  39. static struct midi_buf *midi_in_buf[MAX_MIDI_DEV] = {NULL};
  40. static struct midi_parms parms[MAX_MIDI_DEV];
  41. static void midi_poll(unsigned long dummy);
  42. static DEFINE_TIMER(poll_timer, midi_poll, 0, 0);
  43. static volatile int open_devs;
  44. static DEFINE_SPINLOCK(lock);
  45. #define DATA_AVAIL(q) (q->len)
  46. #define SPACE_AVAIL(q) (MAX_QUEUE_SIZE - q->len)
  47. #define QUEUE_BYTE(q, data) \
  48. if (SPACE_AVAIL(q)) \
  49. { \
  50. unsigned long flags; \
  51. spin_lock_irqsave(&lock, flags); \
  52. q->queue[q->tail] = (data); \
  53. q->len++; q->tail = (q->tail+1) % MAX_QUEUE_SIZE; \
  54. spin_unlock_irqrestore(&lock, flags); \
  55. }
  56. #define REMOVE_BYTE(q, data) \
  57. if (DATA_AVAIL(q)) \
  58. { \
  59. unsigned long flags; \
  60. spin_lock_irqsave(&lock, flags); \
  61. data = q->queue[q->head]; \
  62. q->len--; q->head = (q->head+1) % MAX_QUEUE_SIZE; \
  63. spin_unlock_irqrestore(&lock, flags); \
  64. }
  65. static void drain_midi_queue(int dev)
  66. {
  67. /*
  68. * Give the Midi driver time to drain its output queues
  69. */
  70. if (midi_devs[dev]->buffer_status != NULL)
  71. while (!signal_pending(current) && midi_devs[dev]->buffer_status(dev))
  72. interruptible_sleep_on_timeout(&midi_sleeper[dev],
  73. HZ/10);
  74. }
  75. static void midi_input_intr(int dev, unsigned char data)
  76. {
  77. if (midi_in_buf[dev] == NULL)
  78. return;
  79. if (data == 0xfe) /*
  80. * Active sensing
  81. */
  82. return; /*
  83. * Ignore
  84. */
  85. if (SPACE_AVAIL(midi_in_buf[dev])) {
  86. QUEUE_BYTE(midi_in_buf[dev], data);
  87. wake_up(&input_sleeper[dev]);
  88. }
  89. }
  90. static void midi_output_intr(int dev)
  91. {
  92. /*
  93. * Currently NOP
  94. */
  95. }
  96. static void midi_poll(unsigned long dummy)
  97. {
  98. unsigned long flags;
  99. int dev;
  100. spin_lock_irqsave(&lock, flags);
  101. if (open_devs)
  102. {
  103. for (dev = 0; dev < num_midis; dev++)
  104. if (midi_devs[dev] != NULL && midi_out_buf[dev] != NULL)
  105. {
  106. int ok = 1;
  107. while (DATA_AVAIL(midi_out_buf[dev]) && ok)
  108. {
  109. int c = midi_out_buf[dev]->queue[midi_out_buf[dev]->head];
  110. spin_unlock_irqrestore(&lock,flags);/* Give some time to others */
  111. ok = midi_devs[dev]->outputc(dev, c);
  112. spin_lock_irqsave(&lock, flags);
  113. midi_out_buf[dev]->head = (midi_out_buf[dev]->head + 1) % MAX_QUEUE_SIZE;
  114. midi_out_buf[dev]->len--;
  115. }
  116. if (DATA_AVAIL(midi_out_buf[dev]) < 100)
  117. wake_up(&midi_sleeper[dev]);
  118. }
  119. poll_timer.expires = (1) + jiffies;
  120. add_timer(&poll_timer);
  121. /*
  122. * Come back later
  123. */
  124. }
  125. spin_unlock_irqrestore(&lock, flags);
  126. }
  127. int MIDIbuf_open(int dev, struct file *file)
  128. {
  129. int mode, err;
  130. dev = dev >> 4;
  131. mode = translate_mode(file);
  132. if (num_midis > MAX_MIDI_DEV)
  133. {
  134. printk(KERN_ERR "midi: Too many midi interfaces\n");
  135. num_midis = MAX_MIDI_DEV;
  136. }
  137. if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
  138. return -ENXIO;
  139. /*
  140. * Interrupts disabled. Be careful
  141. */
  142. module_put(midi_devs[dev]->owner);
  143. if ((err = midi_devs[dev]->open(dev, mode,
  144. midi_input_intr, midi_output_intr)) < 0)
  145. return err;
  146. parms[dev].prech_timeout = MAX_SCHEDULE_TIMEOUT;
  147. midi_in_buf[dev] = (struct midi_buf *) vmalloc(sizeof(struct midi_buf));
  148. if (midi_in_buf[dev] == NULL)
  149. {
  150. printk(KERN_WARNING "midi: Can't allocate buffer\n");
  151. midi_devs[dev]->close(dev);
  152. return -EIO;
  153. }
  154. midi_in_buf[dev]->len = midi_in_buf[dev]->head = midi_in_buf[dev]->tail = 0;
  155. midi_out_buf[dev] = (struct midi_buf *) vmalloc(sizeof(struct midi_buf));
  156. if (midi_out_buf[dev] == NULL)
  157. {
  158. printk(KERN_WARNING "midi: Can't allocate buffer\n");
  159. midi_devs[dev]->close(dev);
  160. vfree(midi_in_buf[dev]);
  161. midi_in_buf[dev] = NULL;
  162. return -EIO;
  163. }
  164. midi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
  165. open_devs++;
  166. init_waitqueue_head(&midi_sleeper[dev]);
  167. init_waitqueue_head(&input_sleeper[dev]);
  168. if (open_devs < 2) /* This was first open */
  169. {
  170. poll_timer.expires = 1 + jiffies;
  171. add_timer(&poll_timer); /* Start polling */
  172. }
  173. return err;
  174. }
  175. void MIDIbuf_release(int dev, struct file *file)
  176. {
  177. int mode;
  178. dev = dev >> 4;
  179. mode = translate_mode(file);
  180. if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
  181. return;
  182. /*
  183. * Wait until the queue is empty
  184. */
  185. if (mode != OPEN_READ)
  186. {
  187. midi_devs[dev]->outputc(dev, 0xfe); /*
  188. * Active sensing to shut the
  189. * devices
  190. */
  191. while (!signal_pending(current) && DATA_AVAIL(midi_out_buf[dev]))
  192. interruptible_sleep_on(&midi_sleeper[dev]);
  193. /*
  194. * Sync
  195. */
  196. drain_midi_queue(dev); /*
  197. * Ensure the output queues are empty
  198. */
  199. }
  200. midi_devs[dev]->close(dev);
  201. open_devs--;
  202. if (open_devs == 0)
  203. del_timer_sync(&poll_timer);
  204. vfree(midi_in_buf[dev]);
  205. vfree(midi_out_buf[dev]);
  206. midi_in_buf[dev] = NULL;
  207. midi_out_buf[dev] = NULL;
  208. module_put(midi_devs[dev]->owner);
  209. }
  210. int MIDIbuf_write(int dev, struct file *file, const char __user *buf, int count)
  211. {
  212. int c, n, i;
  213. unsigned char tmp_data;
  214. dev = dev >> 4;
  215. if (!count)
  216. return 0;
  217. c = 0;
  218. while (c < count)
  219. {
  220. n = SPACE_AVAIL(midi_out_buf[dev]);
  221. if (n == 0) { /*
  222. * No space just now.
  223. */
  224. if (file->f_flags & O_NONBLOCK) {
  225. c = -EAGAIN;
  226. goto out;
  227. }
  228. interruptible_sleep_on(&midi_sleeper[dev]);
  229. if (signal_pending(current))
  230. {
  231. c = -EINTR;
  232. goto out;
  233. }
  234. n = SPACE_AVAIL(midi_out_buf[dev]);
  235. }
  236. if (n > (count - c))
  237. n = count - c;
  238. for (i = 0; i < n; i++)
  239. {
  240. /* BROKE BROKE BROKE - CANT DO THIS WITH CLI !! */
  241. /* yes, think the same, so I removed the cli() brackets
  242. QUEUE_BYTE is protected against interrupts */
  243. if (copy_from_user((char *) &tmp_data, &(buf)[c], 1)) {
  244. c = -EFAULT;
  245. goto out;
  246. }
  247. QUEUE_BYTE(midi_out_buf[dev], tmp_data);
  248. c++;
  249. }
  250. }
  251. out:
  252. return c;
  253. }
  254. int MIDIbuf_read(int dev, struct file *file, char __user *buf, int count)
  255. {
  256. int n, c = 0;
  257. unsigned char tmp_data;
  258. dev = dev >> 4;
  259. if (!DATA_AVAIL(midi_in_buf[dev])) { /*
  260. * No data yet, wait
  261. */
  262. if (file->f_flags & O_NONBLOCK) {
  263. c = -EAGAIN;
  264. goto out;
  265. }
  266. interruptible_sleep_on_timeout(&input_sleeper[dev],
  267. parms[dev].prech_timeout);
  268. if (signal_pending(current))
  269. c = -EINTR; /* The user is getting restless */
  270. }
  271. if (c == 0 && DATA_AVAIL(midi_in_buf[dev])) /*
  272. * Got some bytes
  273. */
  274. {
  275. n = DATA_AVAIL(midi_in_buf[dev]);
  276. if (n > count)
  277. n = count;
  278. c = 0;
  279. while (c < n)
  280. {
  281. char *fixit;
  282. REMOVE_BYTE(midi_in_buf[dev], tmp_data);
  283. fixit = (char *) &tmp_data;
  284. /* BROKE BROKE BROKE */
  285. /* yes removed the cli() brackets again
  286. should q->len,tail&head be atomic_t? */
  287. if (copy_to_user(&(buf)[c], fixit, 1)) {
  288. c = -EFAULT;
  289. goto out;
  290. }
  291. c++;
  292. }
  293. }
  294. out:
  295. return c;
  296. }
  297. int MIDIbuf_ioctl(int dev, struct file *file,
  298. unsigned int cmd, void __user *arg)
  299. {
  300. int val;
  301. dev = dev >> 4;
  302. if (((cmd >> 8) & 0xff) == 'C')
  303. {
  304. if (midi_devs[dev]->coproc) /* Coprocessor ioctl */
  305. return midi_devs[dev]->coproc->ioctl(midi_devs[dev]->coproc->devc, cmd, arg, 0);
  306. /* printk("/dev/midi%d: No coprocessor for this device\n", dev);*/
  307. return -ENXIO;
  308. }
  309. else
  310. {
  311. switch (cmd)
  312. {
  313. case SNDCTL_MIDI_PRETIME:
  314. if (get_user(val, (int __user *)arg))
  315. return -EFAULT;
  316. if (val < 0)
  317. val = 0;
  318. val = (HZ * val) / 10;
  319. parms[dev].prech_timeout = val;
  320. return put_user(val, (int __user *)arg);
  321. default:
  322. if (!midi_devs[dev]->ioctl)
  323. return -EINVAL;
  324. return midi_devs[dev]->ioctl(dev, cmd, arg);
  325. }
  326. }
  327. }
  328. /* No kernel lock - fine */
  329. unsigned int MIDIbuf_poll(int dev, struct file *file, poll_table * wait)
  330. {
  331. unsigned int mask = 0;
  332. dev = dev >> 4;
  333. /* input */
  334. poll_wait(file, &input_sleeper[dev], wait);
  335. if (DATA_AVAIL(midi_in_buf[dev]))
  336. mask |= POLLIN | POLLRDNORM;
  337. /* output */
  338. poll_wait(file, &midi_sleeper[dev], wait);
  339. if (!SPACE_AVAIL(midi_out_buf[dev]))
  340. mask |= POLLOUT | POLLWRNORM;
  341. return mask;
  342. }
  343. int MIDIbuf_avail(int dev)
  344. {
  345. if (midi_in_buf[dev])
  346. return DATA_AVAIL (midi_in_buf[dev]);
  347. return 0;
  348. }
  349. EXPORT_SYMBOL(MIDIbuf_avail);