开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mpu401.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：37k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

mpu401.c：源码内容
  1. /*
  2.  * sound/mpu401.c
  3.  *
  4.  * The low level driver for Roland MPU-401 compatible Midi cards.
  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.  * Alan Cox modularisation, use normal request_irq, use dev_id
  16.  * Bartlomiej Zolnierkiewicz removed some __init to allow using many drivers
  17.  * Chris Rankin Update the module-usage counter for the coprocessor
  18.  * Zwane Mwaikambo Changed attach/unload resource freeing
  19.  */
  21. #include <linux/module.h>
  22. #include <linux/init.h>
  24. #define USE_SEQ_MACROS
  25. #define USE_SIMPLE_MACROS
  27. #include "sound_config.h"
  29. #include "coproc.h"
  30. #include "mpu401.h"
  32. static int      timer_mode = TMR_INTERNAL, timer_caps = TMR_INTERNAL;
  34. struct mpu_config
  35. {
  36. int             base; /*
  37.  * I/O base
  38.  */
  39. int             irq;
  40. int             opened; /*
  41.  * Open mode
  42.  */
  43. int             devno;
  44. int             synthno;
  45. int             uart_mode;
  46. int             initialized;
  47. int             mode;
  48. #define MODE_MIDI 1
  49. #define MODE_SYNTH 2
  50. unsigned char   version, revision;
  51. unsigned int    capabilities;
  52. #define MPU_CAP_INTLG 0x10000000
  53. #define MPU_CAP_SYNC 0x00000010
  54. #define MPU_CAP_FSK 0x00000020
  55. #define MPU_CAP_CLS 0x00000040
  56. #define MPU_CAP_SMPTE  0x00000080
  57. #define MPU_CAP_2PORT 0x00000001
  58. int             timer_flag;
  60. #define MBUF_MAX 10
  61. #define BUFTEST(dc) if (dc->m_ptr >= MBUF_MAX || dc->m_ptr < 0) 
  62. {printk( "MPU: Invalid buffer pointer %d/%d, s=%dn",  dc->m_ptr,  dc->m_left,  dc->m_state);dc->m_ptr--;}
  63.   int             m_busy;
  64.   unsigned char   m_buf[MBUF_MAX];
  65.   int             m_ptr;
  66.   int             m_state;
  67.   int             m_left;
  68.   unsigned char   last_status;
  69.   void            (*inputintr) (int dev, unsigned char data);
  70.   int             shared_irq;
  71.   int            *osp;
  72.   };
  74. #define DATAPORT(base)   (base)
  75. #define COMDPORT(base)   (base+1)
  76. #define STATPORT(base)   (base+1)
  79. static void mpu401_close(int dev);
  81. static inline int mpu401_status(struct mpu_config *devc)
  82. {
  83. return inb(STATPORT(devc->base));
  84. }
  86. #define input_avail(devc) (!(mpu401_status(devc)&INPUT_AVAIL))
  87. #define output_ready(devc) (!(mpu401_status(devc)&OUTPUT_READY))
  89. static inline void write_command(struct mpu_config *devc, unsigned char cmd)
  90. {
  91. outb(cmd, COMDPORT(devc->base));
  92. }
  94. static inline int read_data(struct mpu_config *devc)
  95. {
  96. return inb(DATAPORT(devc->base));
  97. }
  99. static inline void write_data(struct mpu_config *devc, unsigned char byte)
  100. {
  101. outb(byte, DATAPORT(devc->base));
  102. }
  104. #define OUTPUT_READY 0x40
  105. #define INPUT_AVAIL 0x80
  106. #define MPU_ACK 0xFE
  107. #define MPU_RESET 0xFF
  108. #define UART_MODE_ON 0x3F
  110. static struct mpu_config dev_conf[MAX_MIDI_DEV] =
  111. {
  112. {0}
  113. };
  115. static int n_mpu_devs = 0;
  117. static int reset_mpu401(struct mpu_config *devc);
  118. static void set_uart_mode(int dev, struct mpu_config *devc, int arg);
  120. static int mpu_timer_init(int midi_dev);
  121. static void mpu_timer_interrupt(void);
  122. static void timer_ext_event(struct mpu_config *devc, int event, int parm);
  124. static struct synth_info mpu_synth_info_proto = {
  125. "MPU-401 MIDI interface", 
  126. 0, 
  127. SYNTH_TYPE_MIDI, 
  128. MIDI_TYPE_MPU401, 
  129. 0, 128, 
  130. 0, 128, 
  131. SYNTH_CAP_INPUT
  132. };
  134. static struct synth_info mpu_synth_info[MAX_MIDI_DEV];
  136. /*
  137.  * States for the input scanner
  138.  */
  140. #define ST_INIT 0 /* Ready for timing byte or msg */
  141. #define ST_TIMED 1 /* Leading timing byte rcvd */
  142. #define ST_DATABYTE 2 /* Waiting for (nr_left) data bytes */
  144. #define ST_SYSMSG 100 /* System message (sysx etc). */
  145. #define ST_SYSEX 101 /* System exclusive msg */
  146. #define ST_MTC 102 /* Midi Time Code (MTC) qframe msg */
  147. #define ST_SONGSEL 103 /* Song select */
  148. #define ST_SONGPOS 104 /* Song position pointer */
  150. static unsigned char len_tab[] = /* # of data bytes following a status
  151.  */
  152. {
  153. 2, /* 8x */
  154. 2, /* 9x */
  155. 2, /* Ax */
  156. 2, /* Bx */
  157. 1, /* Cx */
  158. 1, /* Dx */
  159. 2, /* Ex */
  160. 0 /* Fx */
  161. };
  163. #define STORE(cmd) 
  164. { 
  165. int len; 
  166. unsigned char obuf[8]; 
  167. cmd; 
  168. seq_input_event(obuf, len); 
  169. }
  171. #define _seqbuf obuf
  172. #define _seqbufptr 0
  173. #define _SEQ_ADVBUF(x) len=x
  175. static int mpu_input_scanner(struct mpu_config *devc, unsigned char midic)
  176. {
  178. switch (devc->m_state)
  179. {
  180. case ST_INIT:
  181. switch (midic)
  182. {
  183. case 0xf8:
  184. /* Timer overflow */
  185. break;
  187. case 0xfc:
  188. printk("<all end>");
  189.   break;
  191. case 0xfd:
  192. if (devc->timer_flag)
  193. mpu_timer_interrupt();
  194. break;
  196. case 0xfe:
  197. return MPU_ACK;
  199. case 0xf0:
  200. case 0xf1:
  201. case 0xf2:
  202. case 0xf3:
  203. case 0xf4:
  204. case 0xf5:
  205. case 0xf6:
  206. case 0xf7:
  207. printk("<Trk data rq #%d>", midic & 0x0f);
  208. break;
  210. case 0xf9:
  211. printk("<conductor rq>");
  212. break;
  214. case 0xff:
  215. devc->m_state = ST_SYSMSG;
  216. break;
  218. default:
  219. if (midic <= 0xef)
  220. {
  221. /* printk( "mpu time: %d ",  midic); */
  222. devc->m_state = ST_TIMED;
  223. }
  224. else
  225. printk("<MPU: Unknown event %02x> ", midic);
  226. }
  227. break;
  229. case ST_TIMED:
  230. {
  231. int msg = ((int) (midic & 0xf0) >> 4);
  233. devc->m_state = ST_DATABYTE;
  235. if (msg < 8) /* Data byte */
  236. {
  237. /* printk( "midi msg (running status) "); */
  238. msg = ((int) (devc->last_status & 0xf0) >> 4);
  239. msg -= 8;
  240. devc->m_left = len_tab[msg] - 1;
  242. devc->m_ptr = 2;
  243. devc->m_buf[0] = devc->last_status;
  244. devc->m_buf[1] = midic;
  246. if (devc->m_left <= 0)
  247. {
  248. devc->m_state = ST_INIT;
  249. do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
  250. devc->m_ptr = 0;
  251. }
  252. }
  253. else if (msg == 0xf) /* MPU MARK */
  254. {
  255. devc->m_state = ST_INIT;
  257. switch (midic)
  258. {
  259. case 0xf8:
  260. /* printk( "NOP "); */
  261. break;
  263. case 0xf9:
  264. /* printk( "meas end "); */
  265. break;
  267. case 0xfc:
  268. /* printk( "data end "); */
  269. break;
  271. default:
  272. printk("Unknown MPU mark %02xn", midic);
  273. }
  274. }
  275. else
  276. {
  277. devc->last_status = midic;
  278. /* printk( "midi msg "); */
  279. msg -= 8;
  280. devc->m_left = len_tab[msg];
  282. devc->m_ptr = 1;
  283. devc->m_buf[0] = midic;
  285. if (devc->m_left <= 0)
  286. {
  287. devc->m_state = ST_INIT;
  288. do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
  289. devc->m_ptr = 0;
  290. }
  291. }
  292. }
  293. break;
  295. case ST_SYSMSG:
  296. switch (midic)
  297. {
  298. case 0xf0:
  299. printk("<SYX>");
  300. devc->m_state = ST_SYSEX;
  301. break;
  303. case 0xf1:
  304. devc->m_state = ST_MTC;
  305. break;
  307. case 0xf2:
  308. devc->m_state = ST_SONGPOS;
  309. devc->m_ptr = 0;
  310. break;
  312. case 0xf3:
  313. devc->m_state = ST_SONGSEL;
  314. break;
  316. case 0xf6:
  317. /* printk( "tune_requestn"); */
  318. devc->m_state = ST_INIT;
  320. /*
  321.  *    Real time messages
  322.  */
  323. case 0xf8:
  324. /* midi clock */
  325. devc->m_state = ST_INIT;
  326. timer_ext_event(devc, TMR_CLOCK, 0);
  327. break;
  329. case 0xfA:
  330. devc->m_state = ST_INIT;
  331. timer_ext_event(devc, TMR_START, 0);
  332. break;
  334. case 0xFB:
  335. devc->m_state = ST_INIT;
  336. timer_ext_event(devc, TMR_CONTINUE, 0);
  337. break;
  339. case 0xFC:
  340. devc->m_state = ST_INIT;
  341. timer_ext_event(devc, TMR_STOP, 0);
  342. break;
  344. case 0xFE:
  345. /* active sensing */
  346. devc->m_state = ST_INIT;
  347. break;
  349. case 0xff:
  350. /* printk( "midi hard reset"); */
  351. devc->m_state = ST_INIT;
  352. break;
  354. default:
  355. printk("unknown MIDI sysmsg %0xn", midic);
  356. devc->m_state = ST_INIT;
  357. }
  358. break;
  360. case ST_MTC:
  361. devc->m_state = ST_INIT;
  362. printk("MTC frame %x02n", midic);
  363. break;
  365. case ST_SYSEX:
  366. if (midic == 0xf7)
  367. {
  368. printk("<EOX>");
  369. devc->m_state = ST_INIT;
  370. }
  371. else
  372. printk("%02x ", midic);
  373. break;
  375. case ST_SONGPOS:
  376. BUFTEST(devc);
  377. devc->m_buf[devc->m_ptr++] = midic;
  378. if (devc->m_ptr == 2)
  379. {
  380. devc->m_state = ST_INIT;
  381. devc->m_ptr = 0;
  382. timer_ext_event(devc, TMR_SPP,
  383. ((devc->m_buf[1] & 0x7f) << 7) |
  384. (devc->m_buf[0] & 0x7f));
  385. }
  386. break;
  388. case ST_DATABYTE:
  389. BUFTEST(devc);
  390. devc->m_buf[devc->m_ptr++] = midic;
  391. if ((--devc->m_left) <= 0)
  392. {
  393. devc->m_state = ST_INIT;
  394. do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
  395. devc->m_ptr = 0;
  396. }
  397. break;
  399. default:
  400. printk("Bad state %d ", devc->m_state);
  401. devc->m_state = ST_INIT;
  402. }
  403. return 1;
  404. }
  406. static void mpu401_input_loop(struct mpu_config *devc)
  407. {
  408. unsigned long flags;
  409. int busy;
  410. int n;
  412. save_flags(flags);
  413. cli();
  414. busy = devc->m_busy;
  415. devc->m_busy = 1;
  416. restore_flags(flags);
  418. if (busy) /* Already inside the scanner */
  419. return;
  421. n = 50;
  423. while (input_avail(devc) && n-- > 0)
  424. {
  425. unsigned char c = read_data(devc);
  427. if (devc->mode == MODE_SYNTH)
  428. {
  429. mpu_input_scanner(devc, c);
  430. }
  431. else if (devc->opened & OPEN_READ && devc->inputintr != NULL)
  432. devc->inputintr(devc->devno, c);
  433. }
  434. devc->m_busy = 0;
  435. }
  437. int intchk_mpu401(void *dev_id)
  438. {
  439. struct mpu_config *devc;
  440. int dev = (int) dev_id;
  442. devc = &dev_conf[dev];
  443. return input_avail(devc);
  444. }
  446. void mpuintr(int irq, void *dev_id, struct pt_regs *dummy)
  447. {
  448. struct mpu_config *devc;
  449. int dev = (int) dev_id;
  451. sti();
  452. devc = &dev_conf[dev];
  454. if (input_avail(devc))
  455. {
  456. if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
  457. mpu401_input_loop(devc);
  458. else
  459. {
  460. /* Dummy read (just to acknowledge the interrupt) */
  461. read_data(devc);
  462. }
  463. }
  464. }
  466. static int mpu401_open(int dev, int mode,
  467.     void            (*input) (int dev, unsigned char data),
  468.     void            (*output) (int dev)
  469. )
  470. {
  471. int err;
  472. struct mpu_config *devc;
  473. struct coproc_operations *coprocessor;
  475. if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
  476. return -ENXIO;
  478. devc = &dev_conf[dev];
  480. if (devc->opened)
  481.   return -EBUSY;
  482. /*
  483.  *  Verify that the device is really running.
  484.  *  Some devices (such as Ensoniq SoundScape don't
  485.  *  work before the on board processor (OBP) is initialized
  486.  *  by downloading its microcode.
  487.  */
  489. if (!devc->initialized)
  490. {
  491. if (mpu401_status(devc) == 0xff) /* Bus float */
  492. {
  493. printk(KERN_ERR "mpu401: Device not initialized properlyn");
  494. return -EIO;
  495. }
  496. reset_mpu401(devc);
  497. }
  499. if ( (coprocessor = midi_devs[dev]->coproc) != NULL )
  500. {
  501. if (coprocessor->owner)
  502. __MOD_INC_USE_COUNT(coprocessor->owner);
  504. if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
  505. {
  506. printk(KERN_WARNING "MPU-401: Can't access coprocessor devicen");
  507. mpu401_close(dev);
  508. return err;
  509. }
  510. }
  512. set_uart_mode(dev, devc, 1);
  513. devc->mode = MODE_MIDI;
  514. devc->synthno = 0;
  516. mpu401_input_loop(devc);
  518. devc->inputintr = input;
  519. devc->opened = mode;
  521. return 0;
  522. }
  524. static void mpu401_close(int dev)
  525. {
  526. struct mpu_config *devc;
  527. struct coproc_operations *coprocessor;
  529. devc = &dev_conf[dev];
  530. if (devc->uart_mode)
  531. reset_mpu401(devc); /*
  532.  * This disables the UART mode
  533.  */
  534. devc->mode = 0;
  535. devc->inputintr = NULL;
  537. coprocessor = midi_devs[dev]->coproc;
  538. if (coprocessor) {
  539. coprocessor->close(coprocessor->devc, COPR_MIDI);
  541. if (coprocessor->owner)
  542. __MOD_DEC_USE_COUNT(coprocessor->owner);
  543. }
  544. devc->opened = 0;
  545. }
  547. static int mpu401_out(int dev, unsigned char midi_byte)
  548. {
  549. int timeout;
  550. unsigned long flags;
  552. struct mpu_config *devc;
  554. devc = &dev_conf[dev];
  556. /*
  557.  * Sometimes it takes about 30000 loops before the output becomes ready
  558.  * (After reset). Normally it takes just about 10 loops.
  559.  */
  561. for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);
  563. save_flags(flags);
  564. cli();
  565. if (!output_ready(devc))
  566. {
  567. printk(KERN_WARNING "mpu401: Send data timeoutn");
  568. restore_flags(flags);
  569. return 0;
  570. }
  571. write_data(devc, midi_byte);
  572. restore_flags(flags);
  573. return 1;
  574. }
  576. static int mpu401_command(int dev, mpu_command_rec * cmd)
  577. {
  578. int i, timeout, ok;
  579. int ret = 0;
  580. unsigned long   flags;
  581. struct mpu_config *devc;
  583. devc = &dev_conf[dev];
  585. if (devc->uart_mode) /*
  586.  * Not possible in UART mode
  587.  */
  588. {
  589. printk(KERN_WARNING "mpu401: commands not possible in the UART moden");
  590. return -EINVAL;
  591. }
  592. /*
  593.  * Test for input since pending input seems to block the output.
  594.  */
  595. if (input_avail(devc))
  596. mpu401_input_loop(devc);
  598. /*
  599.  * Sometimes it takes about 50000 loops before the output becomes ready
  600.  * (After reset). Normally it takes just about 10 loops.
  601.  */
  603. timeout = 50000;
  604. retry:
  605. if (timeout-- <= 0)
  606. {
  607. printk(KERN_WARNING "mpu401: Command (0x%x) timeoutn", (int) cmd->cmd);
  608. return -EIO;
  609. }
  610. save_flags(flags);
  611. cli();
  613. if (!output_ready(devc))
  614. {
  615.   restore_flags(flags);
  616.   goto retry;
  617. }
  618. write_command(devc, cmd->cmd);
  620. ok = 0;
  621. for (timeout = 50000; timeout > 0 && !ok; timeout--)
  622. {
  623. if (input_avail(devc))
  624. {
  625. if (devc->opened && devc->mode == MODE_SYNTH)
  626. {
  627. if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK)
  628. ok = 1;
  629. }
  630. else
  631. {
  632. /* Device is not currently open. Use simpler method */
  633. if (read_data(devc) == MPU_ACK)
  634. ok = 1;
  635. }
  636. }
  637. }
  638. if (!ok)
  639. {
  640. restore_flags(flags);
  641. return -EIO;
  642. }
  643. if (cmd->nr_args)
  644. {
  645. for (i = 0; i < cmd->nr_args; i++)
  646. {
  647. for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--);
  649. if (!mpu401_out(dev, cmd->data[i]))
  650. {
  651. restore_flags(flags);
  652. printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.n", (int) cmd->cmd);
  653. return -EIO;
  654. }
  655. }
  656. }
  657. ret = 0;
  658. cmd->data[0] = 0;
  660. if (cmd->nr_returns)
  661. {
  662. for (i = 0; i < cmd->nr_returns; i++)
  663. {
  664. ok = 0;
  665. for (timeout = 5000; timeout > 0 && !ok; timeout--)
  666. if (input_avail(devc))
  667. {
  668. cmd->data[i] = read_data(devc);
  669. ok = 1;
  670. }
  671. if (!ok)
  672. {
  673. restore_flags(flags);
  674. return -EIO;
  675. }
  676. }
  677. }
  678. restore_flags(flags);
  679. return ret;
  680. }
  682. static int mpu_cmd(int dev, int cmd, int data)
  683. {
  684. int ret;
  686. static mpu_command_rec rec;
  688. rec.cmd = cmd & 0xff;
  689. rec.nr_args = ((cmd & 0xf0) == 0xE0);
  690. rec.nr_returns = ((cmd & 0xf0) == 0xA0);
  691. rec.data[0] = data & 0xff;
  693. if ((ret = mpu401_command(dev, &rec)) < 0)
  694. return ret;
  695. return (unsigned char) rec.data[0];
  696. }
  698. static int mpu401_prefix_cmd(int dev, unsigned char status)
  699. {
  700. struct mpu_config *devc = &dev_conf[dev];
  702. if (devc->uart_mode)
  703. return 1;
  705. if (status < 0xf0)
  706. {
  707. if (mpu_cmd(dev, 0xD0, 0) < 0)
  708. return 0;
  709. return 1;
  710. }
  711. switch (status)
  712. {
  713. case 0xF0:
  714. if (mpu_cmd(dev, 0xDF, 0) < 0)
  715. return 0;
  716. return 1;
  718. default:
  719. return 0;
  720. }
  721. }
  723. static int mpu401_start_read(int dev)
  724. {
  725. return 0;
  726. }
  728. static int mpu401_end_read(int dev)
  729. {
  730. return 0;
  731. }
  733. static int mpu401_ioctl(int dev, unsigned cmd, caddr_t arg)
  734. {
  735. struct mpu_config *devc;
  736. mpu_command_rec rec;
  737. int val, ret;
  739. devc = &dev_conf[dev];
  740. switch (cmd) 
  741. {
  742. case SNDCTL_MIDI_MPUMODE:
  743. if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */
  744. printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HWn");
  745. return -EINVAL;
  746. }
  747. if (get_user(val, (int *)arg))
  748. return -EFAULT;
  749. set_uart_mode(dev, devc, !val);
  750. return 0;
  752. case SNDCTL_MIDI_MPUCMD:
  753. if (copy_from_user(&rec, arg, sizeof(rec)))
  754. return -EFAULT;
  755. if ((ret = mpu401_command(dev, &rec)) < 0)
  756. return ret;
  757. if (copy_to_user(arg, &rec, sizeof(rec)))
  758. return -EFAULT;
  759. return 0;
  761. default:
  762. return -EINVAL;
  763. }
  764. }
  766. static void mpu401_kick(int dev)
  767. {
  768. }
  770. static int mpu401_buffer_status(int dev)
  771. {
  772. return 0; /*
  773.  * No data in buffers
  774.  */
  775. }
  777. static int mpu_synth_ioctl(int dev,
  778. unsigned int cmd, caddr_t arg)
  779. {
  780. int midi_dev;
  781. struct mpu_config *devc;
  783. midi_dev = synth_devs[dev]->midi_dev;
  785. if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
  786. return -ENXIO;
  788. devc = &dev_conf[midi_dev];
  790. switch (cmd)
  791. {
  793. case SNDCTL_SYNTH_INFO:
  794. memcpy((&((char *) arg)[0]), (char *) &mpu_synth_info[midi_dev], sizeof(struct synth_info));
  795. return 0;
  797. case SNDCTL_SYNTH_MEMAVL:
  798. return 0x7fffffff;
  800. default:
  801. return -EINVAL;
  802. }
  803. }
  805. static int mpu_synth_open(int dev, int mode)
  806. {
  807. int midi_dev, err;
  808. struct mpu_config *devc;
  809. struct coproc_operations *coprocessor;
  811. midi_dev = synth_devs[dev]->midi_dev;
  813. if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
  814. return -ENXIO;
  816. devc = &dev_conf[midi_dev];
  818. /*
  819.  *  Verify that the device is really running.
  820.  *  Some devices (such as Ensoniq SoundScape don't
  821.  *  work before the on board processor (OBP) is initialized
  822.  *  by downloading its microcode.
  823.  */
  825. if (!devc->initialized)
  826. {
  827. if (mpu401_status(devc) == 0xff) /* Bus float */
  828. {
  829. printk(KERN_ERR "mpu401: Device not initialized properlyn");
  830. return -EIO;
  831. }
  832. reset_mpu401(devc);
  833. }
  834. if (devc->opened)
  835. return -EBUSY;
  836. devc->mode = MODE_SYNTH;
  837. devc->synthno = dev;
  839. devc->inputintr = NULL;
  841. coprocessor = midi_devs[midi_dev]->coproc;
  842. if (coprocessor) {
  843. if (coprocessor->owner)
  844. __MOD_INC_USE_COUNT(coprocessor->owner);
  846. if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
  847. {
  848. printk(KERN_WARNING "mpu401: Can't access coprocessor devicen");
  849. return err;
  850. }
  851. }
  852. devc->opened = mode;
  853. reset_mpu401(devc);
  855. if (mode & OPEN_READ)
  856. {
  857. mpu_cmd(midi_dev, 0x8B, 0); /* Enable data in stop mode */
  858. mpu_cmd(midi_dev, 0x34, 0); /* Return timing bytes in stop mode */
  859. mpu_cmd(midi_dev, 0x87, 0); /* Enable pitch & controller */
  860. }
  861. return 0;
  862. }
  864. static void mpu_synth_close(int dev)
  865. { 
  866. int midi_dev;
  867. struct mpu_config *devc;
  868. struct coproc_operations *coprocessor;
  870. midi_dev = synth_devs[dev]->midi_dev;
  872. devc = &dev_conf[midi_dev];
  873. mpu_cmd(midi_dev, 0x15, 0); /* Stop recording, playback and MIDI */
  874. mpu_cmd(midi_dev, 0x8a, 0); /* Disable data in stopped mode */
  876. devc->inputintr = NULL;
  878. coprocessor = midi_devs[midi_dev]->coproc;
  879. if (coprocessor) {
  880. coprocessor->close(coprocessor->devc, COPR_MIDI);
  882. if (coprocessor->owner)
  883. __MOD_DEC_USE_COUNT(coprocessor->owner);
  884. }
  885. devc->opened = 0;
  886. devc->mode = 0;
  887. }
  889. #define MIDI_SYNTH_NAME "MPU-401 UART Midi"
  890. #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
  891. #include "midi_synth.h"
  893. static struct synth_operations mpu401_synth_proto =
  894. {
  895. owner: THIS_MODULE,
  896. id: "MPU401",
  897. info: NULL,
  898. midi_dev: 0,
  899. synth_type: SYNTH_TYPE_MIDI,
  900. synth_subtype: 0,
  901. open: mpu_synth_open,
  902. close: mpu_synth_close,
  903. ioctl: mpu_synth_ioctl,
  904. kill_note: midi_synth_kill_note,
  905. start_note: midi_synth_start_note,
  906. set_instr: midi_synth_set_instr,
  907. reset: midi_synth_reset,
  908. hw_control: midi_synth_hw_control,
  909. load_patch: midi_synth_load_patch,
  910. aftertouch: midi_synth_aftertouch,
  911. controller: midi_synth_controller,
  912. panning: midi_synth_panning,
  913. bender: midi_synth_bender,
  914. setup_voice: midi_synth_setup_voice,
  915. send_sysex: midi_synth_send_sysex
  916. };
  918. static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV];
  920. static struct midi_operations mpu401_midi_proto =
  921. {
  922. owner: THIS_MODULE,
  923. info: {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401},
  924. in_info: {0},
  925. open: mpu401_open,
  926. close: mpu401_close,
  927. ioctl: mpu401_ioctl,
  928. outputc: mpu401_out,
  929. start_read: mpu401_start_read,
  930. end_read: mpu401_end_read,
  931. kick: mpu401_kick,
  932. buffer_status: mpu401_buffer_status,
  933. prefix_cmd: mpu401_prefix_cmd
  934. };
  936. static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV];
  938. static void mpu401_chk_version(int n, struct mpu_config *devc)
  939. {
  940. int tmp;
  941. unsigned long flags;
  943. devc->version = devc->revision = 0;
  945. save_flags(flags);
  946. cli();
  947. if ((tmp = mpu_cmd(n, 0xAC, 0)) < 0)
  948. {
  949. restore_flags(flags);
  950. return;
  951. }
  952. if ((tmp & 0xf0) > 0x20) /* Why it's larger than 2.x ??? */
  953. {
  954. restore_flags(flags);
  955. return;
  956. }
  957. devc->version = tmp;
  959. if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0)
  960. {
  961. devc->version = 0;
  962. restore_flags(flags);
  963. return;
  964. }
  965. devc->revision = tmp;
  966. restore_flags(flags);
  967. }
  969. int attach_mpu401(struct address_info *hw_config, struct module *owner)
  970. {
  971. unsigned long flags;
  972. char revision_char;
  974. int m, ret;
  975. struct mpu_config *devc;
  977. hw_config->slots[1] = -1;
  978. m = sound_alloc_mididev();
  979. if (m == -1)
  980. {
  981. printk(KERN_WARNING "MPU-401: Too many midi devices detectedn");
  982. ret = -ENOMEM;
  983. goto out_err;
  984. }
  985. devc = &dev_conf[m];
  986. devc->base = hw_config->io_base;
  987. devc->osp = hw_config->osp;
  988. devc->irq = hw_config->irq;
  989. devc->opened = 0;
  990. devc->uart_mode = 0;
  991. devc->initialized = 0;
  992. devc->version = 0;
  993. devc->revision = 0;
  994. devc->capabilities = 0;
  995. devc->timer_flag = 0;
  996. devc->m_busy = 0;
  997. devc->m_state = ST_INIT;
  998. devc->shared_irq = hw_config->always_detect;
  999. devc->irq = hw_config->irq;
  1001. if (devc->irq < 0)
  1002. {
  1003. devc->irq *= -1;
  1004. devc->shared_irq = 1;
  1005. }
  1007. if (!hw_config->always_detect)
  1008. {
  1009. /* Verify the hardware again */
  1010. if (!reset_mpu401(devc))
  1011. {
  1012. printk(KERN_WARNING "mpu401: Device didn't respondn");
  1013. ret = -ENODEV;
  1014. goto out_mididev;
  1015. }
  1016. if (!devc->shared_irq)
  1017. {
  1018. if (request_irq(devc->irq, mpuintr, 0, "mpu401", (void *)m) < 0)
  1019. {
  1020. printk(KERN_WARNING "mpu401: Failed to allocate IRQ%dn", devc->irq);
  1021. ret = -ENOMEM;
  1022. goto out_mididev;
  1023. }
  1024. }
  1025. save_flags(flags);
  1026. cli();
  1027. mpu401_chk_version(m, devc);
  1028. if (devc->version == 0)
  1029. mpu401_chk_version(m, devc);
  1030. restore_flags(flags);
  1031. }
  1033. if (!request_region(hw_config->io_base, 2, "mpu401"))
  1034. {
  1035. ret = -ENOMEM;
  1036. goto out_irq;
  1037. }
  1039. if (devc->version != 0)
  1040. if (mpu_cmd(m, 0xC5, 0) >= 0) /* Set timebase OK */
  1041. if (mpu_cmd(m, 0xE0, 120) >= 0) /* Set tempo OK */
  1042. devc->capabilities |= MPU_CAP_INTLG; /* Supports intelligent mode */
  1045. mpu401_synth_operations[m] = (struct synth_operations *)kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
  1047. if (mpu401_synth_operations[m] == NULL)
  1048. {
  1049. printk(KERN_ERR "mpu401: Can't allocate memoryn");
  1050. ret = -ENOMEM;
  1051. goto out_resource;
  1052. }
  1053. if (!(devc->capabilities & MPU_CAP_INTLG)) /* No intelligent mode */
  1054. {
  1055. memcpy((char *) mpu401_synth_operations[m],
  1056. (char *) &std_midi_synth,
  1057.  sizeof(struct synth_operations));
  1058. }
  1059. else
  1060. {
  1061. memcpy((char *) mpu401_synth_operations[m],
  1062. (char *) &mpu401_synth_proto,
  1063.  sizeof(struct synth_operations));
  1064. }
  1065. if (owner)
  1066. mpu401_synth_operations[m]->owner = owner;
  1068. memcpy((char *) &mpu401_midi_operations[m],
  1069.        (char *) &mpu401_midi_proto,
  1070.        sizeof(struct midi_operations));
  1072. mpu401_midi_operations[m].converter = mpu401_synth_operations[m];
  1074. memcpy((char *) &mpu_synth_info[m],
  1075.        (char *) &mpu_synth_info_proto,
  1076.        sizeof(struct synth_info));
  1078. n_mpu_devs++;
  1080. if (devc->version == 0x20 && devc->revision >= 0x07) /* MusicQuest interface */
  1081. {
  1082. int ports = (devc->revision & 0x08) ? 32 : 16;
  1084. devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE |
  1085. MPU_CAP_CLS | MPU_CAP_2PORT;
  1087. revision_char = (devc->revision == 0x7f) ? 'M' : ' ';
  1088. sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d",
  1089. ports,
  1090. revision_char,
  1091. n_mpu_devs);
  1092. }
  1093. else
  1094. {
  1095. revision_char = devc->revision ? devc->revision + '@' : ' ';
  1096. if ((int) devc->revision > ('Z' - '@'))
  1097. revision_char = '+';
  1099. devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK;
  1101. if (hw_config->name)
  1102. sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name);
  1103. else
  1104. sprintf(mpu_synth_info[m].name,
  1105. "MPU-401 %d.%d%c Midi interface #%d",
  1106. (int) (devc->version & 0xf0) >> 4,
  1107. devc->version & 0x0f,
  1108. revision_char,
  1109. n_mpu_devs);
  1110. }
  1112. strcpy(mpu401_midi_operations[m].info.name,
  1113.        mpu_synth_info[m].name);
  1115. conf_printf(mpu_synth_info[m].name, hw_config);
  1117. mpu401_synth_operations[m]->midi_dev = devc->devno = m;
  1118. mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno];
  1120. if (devc->capabilities & MPU_CAP_INTLG) /* Intelligent mode */
  1121. hw_config->slots[2] = mpu_timer_init(m);
  1123. midi_devs[m] = &mpu401_midi_operations[devc->devno];
  1125. if (owner)
  1126. midi_devs[m]->owner = owner;
  1128. hw_config->slots[1] = m;
  1129. sequencer_init();
  1131. return 0;
  1133. out_resource:
  1134. release_region(hw_config->io_base, 2);
  1135. out_irq:
  1136. free_irq(devc->irq, (void *)m);
  1137. out_mididev:
  1138. sound_unload_mididev(m);
  1139. out_err:
  1140. return ret;
  1141. }
  1143. static int reset_mpu401(struct mpu_config *devc)
  1144. {
  1145. unsigned long flags;
  1146. int ok, timeout, n;
  1147. int timeout_limit;
  1149. /*
  1150.  * Send the RESET command. Try again if no success at the first time.
  1151.  * (If the device is in the UART mode, it will not ack the reset cmd).
  1152.  */
  1154. ok = 0;
  1156. timeout_limit = devc->initialized ? 30000 : 100000;
  1157. devc->initialized = 1;
  1159. for (n = 0; n < 2 && !ok; n++)
  1160. {
  1161. for (timeout = timeout_limit; timeout > 0 && !ok; timeout--)
  1162.   ok = output_ready(devc);
  1164. write_command(devc, MPU_RESET); /*
  1165.    * Send MPU-401 RESET Command
  1166.  */
  1168. /*
  1169.  * Wait at least 25 msec. This method is not accurate so let's make the
  1170.  * loop bit longer. Cannot sleep since this is called during boot.
  1171.  */
  1173. for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--)
  1174. {
  1175. save_flags(flags);
  1176. cli();
  1177. if (input_avail(devc))
  1178. if (read_data(devc) == MPU_ACK)
  1179. ok = 1;
  1180. restore_flags(flags);
  1181. }
  1183. }
  1185. devc->m_state = ST_INIT;
  1186. devc->m_ptr = 0;
  1187. devc->m_left = 0;
  1188. devc->last_status = 0;
  1189. devc->uart_mode = 0;
  1191. return ok;
  1192. }
  1194. static void set_uart_mode(int dev, struct mpu_config *devc, int arg)
  1195. {
  1196. if (!arg && (devc->capabilities & MPU_CAP_INTLG))
  1197. return;
  1198. if ((devc->uart_mode == 0) == (arg == 0))
  1199. return; /* Already set */
  1200. reset_mpu401(devc); /* This exits the uart mode */
  1202. if (arg)
  1203. {
  1204. if (mpu_cmd(dev, UART_MODE_ON, 0) < 0)
  1205. {
  1206. printk(KERN_ERR "mpu401: Can't enter UART moden");
  1207. devc->uart_mode = 0;
  1208. return;
  1209. }
  1210. }
  1211. devc->uart_mode = arg;
  1213. }
  1215. int probe_mpu401(struct address_info *hw_config)
  1216. {
  1217. int ok = 0;
  1218. struct mpu_config tmp_devc;
  1220. if (check_region(hw_config->io_base, 2))
  1221. {
  1222. printk(KERN_ERR "mpu401: I/O port %x already in usenn", hw_config->io_base);
  1223. return 0;
  1224. }
  1225. tmp_devc.base = hw_config->io_base;
  1226. tmp_devc.irq = hw_config->irq;
  1227. tmp_devc.initialized = 0;
  1228. tmp_devc.opened = 0;
  1229. tmp_devc.osp = hw_config->osp;
  1231. if (hw_config->always_detect)
  1232. return 1;
  1234. if (inb(hw_config->io_base + 1) == 0xff)
  1235. {
  1236. DDB(printk("MPU401: Port %x looks dead.n", hw_config->io_base));
  1237. return 0; /* Just bus float? */
  1238. }
  1239. ok = reset_mpu401(&tmp_devc);
  1241. if (!ok)
  1242. {
  1243. DDB(printk("MPU401: Reset failed on port %xn", hw_config->io_base));
  1244. }
  1245. return ok;
  1246. }
  1248. void unload_mpu401(struct address_info *hw_config)
  1249. {
  1250. void *p;
  1251. int n=hw_config->slots[1];
  1253. if (n != -1) {
  1254. release_region(hw_config->io_base, 2);
  1255. if (hw_config->always_detect == 0 && hw_config->irq > 0)
  1256. free_irq(hw_config->irq, (void *)n);
  1257. p=mpu401_synth_operations[n];
  1258. sound_unload_mididev(n);
  1259. sound_unload_timerdev(hw_config->slots[2]);
  1260. if(p)
  1261. kfree(p);
  1262. }
  1263. }
  1265. /*****************************************************
  1266.  *      Timer stuff
  1267.  ****************************************************/
  1269. static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0;
  1270. static volatile int curr_tempo, curr_timebase, hw_timebase;
  1271. static int      max_timebase = 8; /* 8*24=192 ppqn */
  1272. static volatile unsigned long next_event_time;
  1273. static volatile unsigned long curr_ticks, curr_clocks;
  1274. static unsigned long prev_event_time;
  1275. static int      metronome_mode;
  1277. static unsigned long clocks2ticks(unsigned long clocks)
  1278. {
  1279. /*
  1280.  * The MPU-401 supports just a limited set of possible timebase values.
  1281.  * Since the applications require more choices, the driver has to
  1282.  * program the HW to do its best and to convert between the HW and
  1283.  * actual timebases.
  1284.  */
  1285. return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase;
  1286. }
  1288. static void set_timebase(int midi_dev, int val)
  1289. {
  1290. int hw_val;
  1292. if (val < 48)
  1293. val = 48;
  1294. if (val > 1000)
  1295. val = 1000;
  1297. hw_val = val;
  1298. hw_val = (hw_val + 12) / 24;
  1299. if (hw_val > max_timebase)
  1300. hw_val = max_timebase;
  1302. if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0)
  1303. {
  1304. printk(KERN_WARNING "mpu401: Can't set HW timebase to %dn", hw_val * 24);
  1305. return;
  1306. }
  1307. hw_timebase = hw_val * 24;
  1308. curr_timebase = val;
  1310. }
  1312. static void tmr_reset(void)
  1313. {
  1314. unsigned long flags;
  1316. save_flags(flags);
  1317. cli();
  1318. next_event_time = (unsigned long) -1;
  1319. prev_event_time = 0;
  1320. curr_ticks = curr_clocks = 0;
  1321. restore_flags(flags);
  1322. }
  1324. static void set_timer_mode(int midi_dev)
  1325. {
  1326. if (timer_mode & TMR_MODE_CLS)
  1327. mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */
  1328. else if (timer_mode & TMR_MODE_SMPTE)
  1329. mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */
  1331. if (timer_mode & TMR_INTERNAL)
  1332. {
  1333.   mpu_cmd(midi_dev, 0x80, 0); /* Use MIDI sync */
  1334. }
  1335. else
  1336. {
  1337. if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS))
  1338. {
  1339. mpu_cmd(midi_dev, 0x82, 0); /* Use MIDI sync */
  1340. mpu_cmd(midi_dev, 0x91, 0); /* Enable ext MIDI ctrl */
  1341. }
  1342. else if (timer_mode & TMR_MODE_FSK)
  1343. mpu_cmd(midi_dev, 0x81, 0); /* Use FSK sync */
  1344. }
  1345. }
  1347. static void stop_metronome(int midi_dev)
  1348. {
  1349. mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */
  1350. }
  1352. static void setup_metronome(int midi_dev)
  1353. {
  1354. int numerator, denominator;
  1355. int clks_per_click, num_32nds_per_beat;
  1356. int beats_per_measure;
  1358. numerator = ((unsigned) metronome_mode >> 24) & 0xff;
  1359. denominator = ((unsigned) metronome_mode >> 16) & 0xff;
  1360. clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff;
  1361. num_32nds_per_beat = (unsigned) metronome_mode & 0xff;
  1362. beats_per_measure = (numerator * 4) >> denominator;
  1364. if (!metronome_mode)
  1365. mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */
  1366. else
  1367. {
  1368. mpu_cmd(midi_dev, 0xE4, clks_per_click);
  1369. mpu_cmd(midi_dev, 0xE6, beats_per_measure);
  1370. mpu_cmd(midi_dev, 0x83, 0); /* Enable metronome without accents */
  1371. }
  1372. }
  1374. static int mpu_start_timer(int midi_dev)
  1375. {
  1376. tmr_reset();
  1377. set_timer_mode(midi_dev);
  1379. if (tmr_running)
  1380. return TIMER_NOT_ARMED; /* Already running */
  1382. if (timer_mode & TMR_INTERNAL)
  1383. {
  1384. mpu_cmd(midi_dev, 0x02, 0); /* Send MIDI start */
  1385. tmr_running = 1;
  1386. return TIMER_NOT_ARMED;
  1387. }
  1388. else
  1389. {
  1390. mpu_cmd(midi_dev, 0x35, 0); /* Enable mode messages to PC */
  1391. mpu_cmd(midi_dev, 0x38, 0); /* Enable sys common messages to PC */
  1392. mpu_cmd(midi_dev, 0x39, 0); /* Enable real time messages to PC */
  1393. mpu_cmd(midi_dev, 0x97, 0); /* Enable system exclusive messages to PC */
  1394. }
  1395. return TIMER_ARMED;
  1396. }
  1398. static int mpu_timer_open(int dev, int mode)
  1399. {
  1400. int midi_dev = sound_timer_devs[dev]->devlink;
  1402. if (timer_open)
  1403. return -EBUSY;
  1405. tmr_reset();
  1406. curr_tempo = 50;
  1407. mpu_cmd(midi_dev, 0xE0, 50);
  1408. curr_timebase = hw_timebase = 120;
  1409. set_timebase(midi_dev, 120);
  1410. timer_open = 1;
  1411. metronome_mode = 0;
  1412. set_timer_mode(midi_dev);
  1414. mpu_cmd(midi_dev, 0xe7, 0x04); /* Send all clocks to host */
  1415. mpu_cmd(midi_dev, 0x95, 0); /* Enable clock to host */
  1417. return 0;
  1418. }
  1420. static void mpu_timer_close(int dev)
  1421. {
  1422. int midi_dev = sound_timer_devs[dev]->devlink;
  1424. timer_open = tmr_running = 0;
  1425. mpu_cmd(midi_dev, 0x15, 0); /* Stop all */
  1426. mpu_cmd(midi_dev, 0x94, 0); /* Disable clock to host */
  1427. mpu_cmd(midi_dev, 0x8c, 0); /* Disable measure end messages to host */
  1428. stop_metronome(midi_dev);
  1429. }
  1431. static int mpu_timer_event(int dev, unsigned char *event)
  1432. {
  1433. unsigned char command = event[1];
  1434. unsigned long parm = *(unsigned int *) &event[4];
  1435. int midi_dev = sound_timer_devs[dev]->devlink;
  1437. switch (command)
  1438. {
  1439. case TMR_WAIT_REL:
  1440. parm += prev_event_time;
  1441. case TMR_WAIT_ABS:
  1442. if (parm > 0)
  1443. {
  1444. long time;
  1446. if (parm <= curr_ticks) /* It's the time */
  1447. return TIMER_NOT_ARMED;
  1448. time = parm;
  1449. next_event_time = prev_event_time = time;
  1451. return TIMER_ARMED;
  1452. }
  1453. break;
  1455. case TMR_START:
  1456. if (tmr_running)
  1457. break;
  1458. return mpu_start_timer(midi_dev);
  1460. case TMR_STOP:
  1461. mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */
  1462. stop_metronome(midi_dev);
  1463. tmr_running = 0;
  1464. break;
  1466. case TMR_CONTINUE:
  1467. if (tmr_running)
  1468. break;
  1469. mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */
  1470. setup_metronome(midi_dev);
  1471. tmr_running = 1;
  1472. break;
  1474. case TMR_TEMPO:
  1475. if (parm)
  1476. {
  1477. if (parm < 8)
  1478. parm = 8;
  1479.   if (parm > 250)
  1480. parm = 250;
  1481. if (mpu_cmd(midi_dev, 0xE0, parm) < 0)
  1482. printk(KERN_WARNING "mpu401: Can't set tempo to %dn", (int) parm);
  1483. curr_tempo = parm;
  1484. }
  1485. break;
  1487. case TMR_ECHO:
  1488. seq_copy_to_input(event, 8);
  1489. break;
  1491. case TMR_TIMESIG:
  1492. if (metronome_mode) /* Metronome enabled */
  1493. {
  1494. metronome_mode = parm;
  1495. setup_metronome(midi_dev);
  1496. }
  1497. break;
  1499. default:;
  1500. }
  1501. return TIMER_NOT_ARMED;
  1502. }
  1504. static unsigned long mpu_timer_get_time(int dev)
  1505. {
  1506. if (!timer_open)
  1507. return 0;
  1509. return curr_ticks;
  1510. }
  1512. static int mpu_timer_ioctl(int dev, unsigned int command, caddr_t arg)
  1513. {
  1514. int midi_dev = sound_timer_devs[dev]->devlink;
  1516. switch (command)
  1517. {
  1518. case SNDCTL_TMR_SOURCE:
  1519. {
  1520. int parm;
  1522. parm = *(int *) arg;
  1523. parm &= timer_caps;
  1525. if (parm != 0)
  1526. {
  1527. timer_mode = parm;
  1529. if (timer_mode & TMR_MODE_CLS)
  1530. mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */
  1531. else if (timer_mode & TMR_MODE_SMPTE)
  1532. mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */
  1533. }
  1534. return (*(int *) arg = timer_mode);
  1535. }
  1536. break;
  1538. case SNDCTL_TMR_START:
  1539. mpu_start_timer(midi_dev);
  1540. return 0;
  1542. case SNDCTL_TMR_STOP:
  1543. tmr_running = 0;
  1544. mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */
  1545. stop_metronome(midi_dev);
  1546. return 0;
  1548. case SNDCTL_TMR_CONTINUE:
  1549. if (tmr_running)
  1550. return 0;
  1551. tmr_running = 1;
  1552. mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */
  1553. return 0;
  1555. case SNDCTL_TMR_TIMEBASE:
  1556. {
  1557. int val;
  1559. val = *(int *) arg;
  1560. if (val)
  1561. set_timebase(midi_dev, val);
  1562. return (*(int *) arg = curr_timebase);
  1563. }
  1564. break;
  1566. case SNDCTL_TMR_TEMPO:
  1567. {
  1568. int val;
  1569. int ret;
  1571. val = *(int *) arg;
  1573. if (val)
  1574. {
  1575. if (val < 8)
  1576. val = 8;
  1577. if (val > 250)
  1578. val = 250;
  1579. if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0)
  1580. {
  1581. printk(KERN_WARNING "mpu401: Can't set tempo to %dn", (int) val);
  1582. return ret;
  1583. }
  1584. curr_tempo = val;
  1585. }
  1586. return (*(int *) arg = curr_tempo);
  1587. }
  1588. break;
  1590. case SNDCTL_SEQ_CTRLRATE:
  1591. {
  1592. int val;
  1594. val = *(int *) arg;
  1595. if (val != 0) /* Can't change */
  1596. return -EINVAL;
  1597. return (*(int *) arg = ((curr_tempo * curr_timebase) + 30) / 60);
  1598. }
  1599. break;
  1601. case SNDCTL_SEQ_GETTIME:
  1602. return (*(int *) arg = curr_ticks);
  1604. case SNDCTL_TMR_METRONOME:
  1605. metronome_mode = *(int *) arg;
  1606. setup_metronome(midi_dev);
  1607. return 0;
  1609. default:;
  1610. }
  1611. return -EINVAL;
  1612. }
  1614. static void mpu_timer_arm(int dev, long time)
  1615. {
  1616. if (time < 0)
  1617. time = curr_ticks + 1;
  1618. else if (time <= curr_ticks) /* It's the time */
  1619. return;
  1620. next_event_time = prev_event_time = time;
  1621. return;
  1622. }
  1624. static struct sound_timer_operations mpu_timer =
  1625. {
  1626. owner: THIS_MODULE,
  1627. info: {"MPU-401 Timer", 0},
  1628. priority: 10, /* Priority */
  1629. devlink: 0, /* Local device link */
  1630. open: mpu_timer_open,
  1631. close: mpu_timer_close,
  1632. event: mpu_timer_event,
  1633. get_time: mpu_timer_get_time,
  1634. ioctl: mpu_timer_ioctl,
  1635. arm_timer: mpu_timer_arm
  1636. };
  1638. static void mpu_timer_interrupt(void)
  1639. {
  1640. if (!timer_open)
  1641. return;
  1643. if (!tmr_running)
  1644. return;
  1646. curr_clocks++;
  1647. curr_ticks = clocks2ticks(curr_clocks);
  1649. if (curr_ticks >= next_event_time)
  1650. {
  1651. next_event_time = (unsigned long) -1;
  1652. sequencer_timer(0);
  1653. }
  1654. }
  1656. static void timer_ext_event(struct mpu_config *devc, int event, int parm)
  1657. {
  1658. int midi_dev = devc->devno;
  1660. if (!devc->timer_flag)
  1661. return;
  1663. switch (event)
  1664. {
  1665. case TMR_CLOCK:
  1666. printk("<MIDI clk>");
  1667. break;
  1669. case TMR_START:
  1670. printk("Ext MIDI startn");
  1671. if (!tmr_running)
  1672. {
  1673. if (timer_mode & TMR_EXTERNAL)
  1674. {
  1675. tmr_running = 1;
  1676. setup_metronome(midi_dev);
  1677. next_event_time = 0;
  1678. STORE(SEQ_START_TIMER());
  1679. }
  1680. }
  1681. break;
  1683. case TMR_STOP:
  1684. printk("Ext MIDI stopn");
  1685. if (timer_mode & TMR_EXTERNAL)
  1686. {
  1687. tmr_running = 0;
  1688. stop_metronome(midi_dev);
  1689. STORE(SEQ_STOP_TIMER());
  1690. }
  1691. break;
  1693. case TMR_CONTINUE:
  1694. printk("Ext MIDI continuen");
  1695. if (timer_mode & TMR_EXTERNAL)
  1696. {
  1697. tmr_running = 1;
  1698. setup_metronome(midi_dev);
  1699. STORE(SEQ_CONTINUE_TIMER());
  1700.    }
  1701.    break;
  1703. case TMR_SPP:
  1704. printk("Songpos: %dn", parm);
  1705. if (timer_mode & TMR_EXTERNAL)
  1706. {
  1707. STORE(SEQ_SONGPOS(parm));
  1708. }
  1709. break;
  1710. }
  1711. }
  1713. static int mpu_timer_init(int midi_dev)
  1714. {
  1715. struct mpu_config *devc;
  1716. int n;
  1718. devc = &dev_conf[midi_dev];
  1720. if (timer_initialized)
  1721. return -1; /* There is already a similar timer */
  1723. timer_initialized = 1;
  1725. mpu_timer.devlink = midi_dev;
  1726. dev_conf[midi_dev].timer_flag = 1;
  1728. n = sound_alloc_timerdev();
  1729. if (n == -1)
  1730. n = 0;
  1731. sound_timer_devs[n] = &mpu_timer;
  1733. if (devc->version < 0x20) /* Original MPU-401 */
  1734. timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI;
  1735. else
  1736. {
  1737. /*
  1738.  * The version number 2.0 is used (at least) by the
  1739.  * MusicQuest cards and the Roland Super-MPU.
  1740.  *
  1741.  * MusicQuest has given a special meaning to the bits of the
  1742.  * revision number. The Super-MPU returns 0.
  1743.  */
  1745. if (devc->revision)
  1746. timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI;
  1748. if (devc->revision & 0x02)
  1749. timer_caps |= TMR_MODE_CLS;
  1752. if (devc->revision & 0x40)
  1753. max_timebase = 10; /* Has the 216 and 240 ppqn modes */
  1754. }
  1756. timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps;
  1757. return n;
  1759. }
  1761. EXPORT_SYMBOL(probe_mpu401);
  1762. EXPORT_SYMBOL(attach_mpu401);
  1763. EXPORT_SYMBOL(unload_mpu401);
  1764. EXPORT_SYMBOL(intchk_mpu401);
  1765. EXPORT_SYMBOL(mpuintr);
  1767. static struct address_info cfg;
  1769. static int __initdata io = -1;
  1770. static int __initdata irq = -1;
  1772. MODULE_PARM(irq, "i");
  1773. MODULE_PARM(io, "i");
  1775. int __init init_mpu401(void)
  1776. {
  1777. int ret;
  1778. /* Can be loaded either for module use or to provide functions
  1779.    to others */
  1780. if (io != -1 && irq != -1) {
  1781.         cfg.irq = irq;
  1782. cfg.io_base = io;
  1783. if (probe_mpu401(&cfg) == 0)
  1784. return -ENODEV;
  1785. if ((ret = attach_mpu401(&cfg, THIS_MODULE)))
  1786. return ret;
  1787. }
  1789. return 0;
  1790. }
  1792. void __exit cleanup_mpu401(void)
  1793. {
  1794. if (io != -1 && irq != -1) {
  1795. /* Check for use by, for example, sscape driver */
  1796. unload_mpu401(&cfg);
  1797. }
  1798. }
  1800. module_init(init_mpu401);
  1801. module_exit(cleanup_mpu401);
  1803. #ifndef MODULE
  1804. static int __init setup_mpu401(char *str)
  1805. {
  1806.         /* io, irq */
  1807. int ints[3];
  1809. str = get_options(str, ARRAY_SIZE(ints), ints);
  1811. io = ints[1];
  1812. irq = ints[2];
  1814. return 1;
  1815. }
  1817. __setup("mpu401=", setup_mpu401);
  1818. #endif
  1819. MODULE_LICENSE("GPL");