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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mpu401.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：37k
源码类别：

嵌入式Linux

开发平台：

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.  */
  20. #include <linux/module.h>
  21. #include <linux/init.h>
  23. #define USE_SEQ_MACROS
  24. #define USE_SIMPLE_MACROS
  26. #include "sound_config.h"
  28. #include "coproc.h"
  29. #include "mpu401.h"
  31. static int      timer_mode = TMR_INTERNAL, timer_caps = TMR_INTERNAL;
  33. struct mpu_config
  34. {
  35. int             base; /*
  36.  * I/O base
  37.  */
  38. int             irq;
  39. int             opened; /*
  40.  * Open mode
  41.  */
  42. int             devno;
  43. int             synthno;
  44. int             uart_mode;
  45. int             initialized;
  46. int             mode;
  47. #define MODE_MIDI 1
  48. #define MODE_SYNTH 2
  49. unsigned char   version, revision;
  50. unsigned int    capabilities;
  51. #define MPU_CAP_INTLG 0x10000000
  52. #define MPU_CAP_SYNC 0x00000010
  53. #define MPU_CAP_FSK 0x00000020
  54. #define MPU_CAP_CLS 0x00000040
  55. #define MPU_CAP_SMPTE  0x00000080
  56. #define MPU_CAP_2PORT 0x00000001
  57. int             timer_flag;
  59. #define MBUF_MAX 10
  60. #define BUFTEST(dc) if (dc->m_ptr >= MBUF_MAX || dc->m_ptr < 0) 
  61. {printk( "MPU: Invalid buffer pointer %d/%d, s=%dn",  dc->m_ptr,  dc->m_left,  dc->m_state);dc->m_ptr--;}
  62.   int             m_busy;
  63.   unsigned char   m_buf[MBUF_MAX];
  64.   int             m_ptr;
  65.   int             m_state;
  66.   int             m_left;
  67.   unsigned char   last_status;
  68.   void            (*inputintr) (int dev, unsigned char data);
  69.   int             shared_irq;
  70.   int            *osp;
  71.   };
  73. #define DATAPORT(base)   (base)
  74. #define COMDPORT(base)   (base+1)
  75. #define STATPORT(base)   (base+1)
  78. static void mpu401_close(int dev);
  80. static int mpu401_status(struct mpu_config *devc)
  81. {
  82. return inb(STATPORT(devc->base));
  83. }
  85. #define input_avail(devc) (!(mpu401_status(devc)&INPUT_AVAIL))
  86. #define output_ready(devc) (!(mpu401_status(devc)&OUTPUT_READY))
  88. static void write_command(struct mpu_config *devc, unsigned char cmd)
  89. {
  90. outb(cmd, COMDPORT(devc->base));
  91. }
  93. static int read_data(struct mpu_config *devc)
  94. {
  95. return inb(DATAPORT(devc->base));
  96. }
  98. static void write_data(struct mpu_config *devc, unsigned char byte)
  99. {
  100. outb(byte, DATAPORT(devc->base));
  101. }
  103. #define OUTPUT_READY 0x40
  104. #define INPUT_AVAIL 0x80
  105. #define MPU_ACK 0xFE
  106. #define MPU_RESET 0xFF
  107. #define UART_MODE_ON 0x3F
  109. static struct mpu_config dev_conf[MAX_MIDI_DEV] =
  110. {
  111. {0}
  112. };
  114. static int n_mpu_devs = 0;
  116. static int reset_mpu401(struct mpu_config *devc);
  117. static void set_uart_mode(int dev, struct mpu_config *devc, int arg);
  119. static int mpu_timer_init(int midi_dev);
  120. static void mpu_timer_interrupt(void);
  121. static void timer_ext_event(struct mpu_config *devc, int event, int parm);
  123. static struct synth_info mpu_synth_info_proto = {
  124. "MPU-401 MIDI interface", 
  125. 0, 
  126. SYNTH_TYPE_MIDI, 
  127. MIDI_TYPE_MPU401, 
  128. 0, 128, 
  129. 0, 128, 
  130. SYNTH_CAP_INPUT
  131. };
  133. static struct synth_info mpu_synth_info[MAX_MIDI_DEV];
  135. /*
  136.  * States for the input scanner
  137.  */
  139. #define ST_INIT 0 /* Ready for timing byte or msg */
  140. #define ST_TIMED 1 /* Leading timing byte rcvd */
  141. #define ST_DATABYTE 2 /* Waiting for (nr_left) data bytes */
  143. #define ST_SYSMSG 100 /* System message (sysx etc). */
  144. #define ST_SYSEX 101 /* System exclusive msg */
  145. #define ST_MTC 102 /* Midi Time Code (MTC) qframe msg */
  146. #define ST_SONGSEL 103 /* Song select */
  147. #define ST_SONGPOS 104 /* Song position pointer */
  149. static unsigned char len_tab[] = /* # of data bytes following a status
  150.  */
  151. {
  152. 2, /* 8x */
  153. 2, /* 9x */
  154. 2, /* Ax */
  155. 2, /* Bx */
  156. 1, /* Cx */
  157. 1, /* Dx */
  158. 2, /* Ex */
  159. 0 /* Fx */
  160. };
  162. #define STORE(cmd) 
  163. { 
  164. int len; 
  165. unsigned char obuf[8]; 
  166. cmd; 
  167. seq_input_event(obuf, len); 
  168. }
  170. #define _seqbuf obuf
  171. #define _seqbufptr 0
  172. #define _SEQ_ADVBUF(x) len=x
  174. static int mpu_input_scanner(struct mpu_config *devc, unsigned char midic)
  175. {
  177. switch (devc->m_state)
  178. {
  179. case ST_INIT:
  180. switch (midic)
  181. {
  182. case 0xf8:
  183. /* Timer overflow */
  184. break;
  186. case 0xfc:
  187. printk("<all end>");
  188.   break;
  190. case 0xfd:
  191. if (devc->timer_flag)
  192. mpu_timer_interrupt();
  193. break;
  195. case 0xfe:
  196. return MPU_ACK;
  198. case 0xf0:
  199. case 0xf1:
  200. case 0xf2:
  201. case 0xf3:
  202. case 0xf4:
  203. case 0xf5:
  204. case 0xf6:
  205. case 0xf7:
  206. printk("<Trk data rq #%d>", midic & 0x0f);
  207. break;
  209. case 0xf9:
  210. printk("<conductor rq>");
  211. break;
  213. case 0xff:
  214. devc->m_state = ST_SYSMSG;
  215. break;
  217. default:
  218. if (midic <= 0xef)
  219. {
  220. /* printk( "mpu time: %d ",  midic); */
  221. devc->m_state = ST_TIMED;
  222. }
  223. else
  224. printk("<MPU: Unknown event %02x> ", midic);
  225. }
  226. break;
  228. case ST_TIMED:
  229. {
  230. int msg = ((int) (midic & 0xf0) >> 4);
  232. devc->m_state = ST_DATABYTE;
  234. if (msg < 8) /* Data byte */
  235. {
  236. /* printk( "midi msg (running status) "); */
  237. msg = ((int) (devc->last_status & 0xf0) >> 4);
  238. msg -= 8;
  239. devc->m_left = len_tab[msg] - 1;
  241. devc->m_ptr = 2;
  242. devc->m_buf[0] = devc->last_status;
  243. devc->m_buf[1] = midic;
  245. if (devc->m_left <= 0)
  246. {
  247. devc->m_state = ST_INIT;
  248. do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
  249. devc->m_ptr = 0;
  250. }
  251. }
  252. else if (msg == 0xf) /* MPU MARK */
  253. {
  254. devc->m_state = ST_INIT;
  256. switch (midic)
  257. {
  258. case 0xf8:
  259. /* printk( "NOP "); */
  260. break;
  262. case 0xf9:
  263. /* printk( "meas end "); */
  264. break;
  266. case 0xfc:
  267. /* printk( "data end "); */
  268. break;
  270. default:
  271. printk("Unknown MPU mark %02xn", midic);
  272. }
  273. }
  274. else
  275. {
  276. devc->last_status = midic;
  277. /* printk( "midi msg "); */
  278. msg -= 8;
  279. devc->m_left = len_tab[msg];
  281. devc->m_ptr = 1;
  282. devc->m_buf[0] = midic;
  284. if (devc->m_left <= 0)
  285. {
  286. devc->m_state = ST_INIT;
  287. do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
  288. devc->m_ptr = 0;
  289. }
  290. }
  291. }
  292. break;
  294. case ST_SYSMSG:
  295. switch (midic)
  296. {
  297. case 0xf0:
  298. printk("<SYX>");
  299. devc->m_state = ST_SYSEX;
  300. break;
  302. case 0xf1:
  303. devc->m_state = ST_MTC;
  304. break;
  306. case 0xf2:
  307. devc->m_state = ST_SONGPOS;
  308. devc->m_ptr = 0;
  309. break;
  311. case 0xf3:
  312. devc->m_state = ST_SONGSEL;
  313. break;
  315. case 0xf6:
  316. /* printk( "tune_requestn"); */
  317. devc->m_state = ST_INIT;
  319. /*
  320.  *    Real time messages
  321.  */
  322. case 0xf8:
  323. /* midi clock */
  324. devc->m_state = ST_INIT;
  325. timer_ext_event(devc, TMR_CLOCK, 0);
  326. break;
  328. case 0xfA:
  329. devc->m_state = ST_INIT;
  330. timer_ext_event(devc, TMR_START, 0);
  331. break;
  333. case 0xFB:
  334. devc->m_state = ST_INIT;
  335. timer_ext_event(devc, TMR_CONTINUE, 0);
  336. break;
  338. case 0xFC:
  339. devc->m_state = ST_INIT;
  340. timer_ext_event(devc, TMR_STOP, 0);
  341. break;
  343. case 0xFE:
  344. /* active sensing */
  345. devc->m_state = ST_INIT;
  346. break;
  348. case 0xff:
  349. /* printk( "midi hard reset"); */
  350. devc->m_state = ST_INIT;
  351. break;
  353. default:
  354. printk("unknown MIDI sysmsg %0xn", midic);
  355. devc->m_state = ST_INIT;
  356. }
  357. break;
  359. case ST_MTC:
  360. devc->m_state = ST_INIT;
  361. printk("MTC frame %x02n", midic);
  362. break;
  364. case ST_SYSEX:
  365. if (midic == 0xf7)
  366. {
  367. printk("<EOX>");
  368. devc->m_state = ST_INIT;
  369. }
  370. else
  371. printk("%02x ", midic);
  372. break;
  374. case ST_SONGPOS:
  375. BUFTEST(devc);
  376. devc->m_buf[devc->m_ptr++] = midic;
  377. if (devc->m_ptr == 2)
  378. {
  379. devc->m_state = ST_INIT;
  380. devc->m_ptr = 0;
  381. timer_ext_event(devc, TMR_SPP,
  382. ((devc->m_buf[1] & 0x7f) << 7) |
  383. (devc->m_buf[0] & 0x7f));
  384. }
  385. break;
  387. case ST_DATABYTE:
  388. BUFTEST(devc);
  389. devc->m_buf[devc->m_ptr++] = midic;
  390. if ((--devc->m_left) <= 0)
  391. {
  392. devc->m_state = ST_INIT;
  393. do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
  394. devc->m_ptr = 0;
  395. }
  396. break;
  398. default:
  399. printk("Bad state %d ", devc->m_state);
  400. devc->m_state = ST_INIT;
  401. }
  402. return 1;
  403. }
  405. static void mpu401_input_loop(struct mpu_config *devc)
  406. {
  407. unsigned long flags;
  408. int busy;
  409. int n;
  411. save_flags(flags);
  412. cli();
  413. busy = devc->m_busy;
  414. devc->m_busy = 1;
  415. restore_flags(flags);
  417. if (busy) /* Already inside the scanner */
  418. return;
  420. n = 50;
  422. while (input_avail(devc) && n-- > 0)
  423. {
  424. unsigned char c = read_data(devc);
  426. if (devc->mode == MODE_SYNTH)
  427. {
  428. mpu_input_scanner(devc, c);
  429. }
  430. else if (devc->opened & OPEN_READ && devc->inputintr != NULL)
  431. devc->inputintr(devc->devno, c);
  432. }
  433. devc->m_busy = 0;
  434. }
  436. int intchk_mpu401(void *dev_id)
  437. {
  438. struct mpu_config *devc;
  439. int dev = (int) dev_id;
  441. devc = &dev_conf[dev];
  442. return input_avail(devc);
  443. }
  445. void mpuintr(int irq, void *dev_id, struct pt_regs *dummy)
  446. {
  447. struct mpu_config *devc;
  448. int dev = (int) dev_id;
  450. sti();
  451. devc = &dev_conf[dev];
  453. if (input_avail(devc))
  454. {
  455. if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
  456. mpu401_input_loop(devc);
  457. else
  458. {
  459. /* Dummy read (just to acknowledge the interrupt) */
  460. read_data(devc);
  461. }
  462. }
  463. }
  465. static int mpu401_open(int dev, int mode,
  466.     void            (*input) (int dev, unsigned char data),
  467.     void            (*output) (int dev)
  468. )
  469. {
  470. int err;
  471. struct mpu_config *devc;
  472. struct coproc_operations *coprocessor;
  474. if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
  475. return -ENXIO;
  477. devc = &dev_conf[dev];
  479. if (devc->opened)
  480.   return -EBUSY;
  481. /*
  482.  *  Verify that the device is really running.
  483.  *  Some devices (such as Ensoniq SoundScape don't
  484.  *  work before the on board processor (OBP) is initialized
  485.  *  by downloading its microcode.
  486.  */
  488. if (!devc->initialized)
  489. {
  490. if (mpu401_status(devc) == 0xff) /* Bus float */
  491. {
  492. printk(KERN_ERR "mpu401: Device not initialized properlyn");
  493. return -EIO;
  494. }
  495. reset_mpu401(devc);
  496. }
  498. if ( (coprocessor = midi_devs[dev]->coproc) != NULL )
  499. {
  500. if (coprocessor->owner)
  501. __MOD_INC_USE_COUNT(coprocessor->owner);
  503. if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
  504. {
  505. printk(KERN_WARNING "MPU-401: Can't access coprocessor devicen");
  506. mpu401_close(dev);
  507. return err;
  508. }
  509. }
  511. set_uart_mode(dev, devc, 1);
  512. devc->mode = MODE_MIDI;
  513. devc->synthno = 0;
  515. mpu401_input_loop(devc);
  517. devc->inputintr = input;
  518. devc->opened = mode;
  520. return 0;
  521. }
  523. static void mpu401_close(int dev)
  524. {
  525. struct mpu_config *devc;
  526. struct coproc_operations *coprocessor;
  528. devc = &dev_conf[dev];
  529. if (devc->uart_mode)
  530. reset_mpu401(devc); /*
  531.  * This disables the UART mode
  532.  */
  533. devc->mode = 0;
  534. devc->inputintr = NULL;
  536. coprocessor = midi_devs[dev]->coproc;
  537. if (coprocessor) {
  538. coprocessor->close(coprocessor->devc, COPR_MIDI);
  540. if (coprocessor->owner)
  541. __MOD_DEC_USE_COUNT(coprocessor->owner);
  542. }
  543. devc->opened = 0;
  544. }
  546. static int mpu401_out(int dev, unsigned char midi_byte)
  547. {
  548. int timeout;
  549. unsigned long flags;
  551. struct mpu_config *devc;
  553. devc = &dev_conf[dev];
  555. /*
  556.  * Sometimes it takes about 30000 loops before the output becomes ready
  557.  * (After reset). Normally it takes just about 10 loops.
  558.  */
  560. for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);
  562. save_flags(flags);
  563. cli();
  564. if (!output_ready(devc))
  565. {
  566. printk(KERN_WARNING "mpu401: Send data timeoutn");
  567. restore_flags(flags);
  568. return 0;
  569. }
  570. write_data(devc, midi_byte);
  571. restore_flags(flags);
  572. return 1;
  573. }
  575. static int mpu401_command(int dev, mpu_command_rec * cmd)
  576. {
  577. int i, timeout, ok;
  578. int ret = 0;
  579. unsigned long   flags;
  580. struct mpu_config *devc;
  582. devc = &dev_conf[dev];
  584. if (devc->uart_mode) /*
  585.  * Not possible in UART mode
  586.  */
  587. {
  588. printk(KERN_WARNING "mpu401: commands not possible in the UART moden");
  589. return -EINVAL;
  590. }
  591. /*
  592.  * Test for input since pending input seems to block the output.
  593.  */
  594. if (input_avail(devc))
  595. mpu401_input_loop(devc);
  597. /*
  598.  * Sometimes it takes about 50000 loops before the output becomes ready
  599.  * (After reset). Normally it takes just about 10 loops.
  600.  */
  602. timeout = 50000;
  603. retry:
  604. if (timeout-- <= 0)
  605. {
  606. printk(KERN_WARNING "mpu401: Command (0x%x) timeoutn", (int) cmd->cmd);
  607. return -EIO;
  608. }
  609. save_flags(flags);
  610. cli();
  612. if (!output_ready(devc))
  613. {
  614.   restore_flags(flags);
  615.   goto retry;
  616. }
  617. write_command(devc, cmd->cmd);
  619. ok = 0;
  620. for (timeout = 50000; timeout > 0 && !ok; timeout--)
  621. {
  622. if (input_avail(devc))
  623. {
  624. if (devc->opened && devc->mode == MODE_SYNTH)
  625. {
  626. if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK)
  627. ok = 1;
  628. }
  629. else
  630. {
  631. /* Device is not currently open. Use simpler method */
  632. if (read_data(devc) == MPU_ACK)
  633. ok = 1;
  634. }
  635. }
  636. }
  637. if (!ok)
  638. {
  639. restore_flags(flags);
  640. return -EIO;
  641. }
  642. if (cmd->nr_args)
  643. {
  644. for (i = 0; i < cmd->nr_args; i++)
  645. {
  646. for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--);
  648. if (!mpu401_out(dev, cmd->data[i]))
  649. {
  650. restore_flags(flags);
  651. printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.n", (int) cmd->cmd);
  652. return -EIO;
  653. }
  654. }
  655. }
  656. ret = 0;
  657. cmd->data[0] = 0;
  659. if (cmd->nr_returns)
  660. {
  661. for (i = 0; i < cmd->nr_returns; i++)
  662. {
  663. ok = 0;
  664. for (timeout = 5000; timeout > 0 && !ok; timeout--)
  665. if (input_avail(devc))
  666. {
  667. cmd->data[i] = read_data(devc);
  668. ok = 1;
  669. }
  670. if (!ok)
  671. {
  672. restore_flags(flags);
  673. return -EIO;
  674. }
  675. }
  676. }
  677. restore_flags(flags);
  678. return ret;
  679. }
  681. static int mpu_cmd(int dev, int cmd, int data)
  682. {
  683. int ret;
  685. static mpu_command_rec rec;
  687. rec.cmd = cmd & 0xff;
  688. rec.nr_args = ((cmd & 0xf0) == 0xE0);
  689. rec.nr_returns = ((cmd & 0xf0) == 0xA0);
  690. rec.data[0] = data & 0xff;
  692. if ((ret = mpu401_command(dev, &rec)) < 0)
  693. return ret;
  694. return (unsigned char) rec.data[0];
  695. }
  697. static int mpu401_prefix_cmd(int dev, unsigned char status)
  698. {
  699. struct mpu_config *devc = &dev_conf[dev];
  701. if (devc->uart_mode)
  702. return 1;
  704. if (status < 0xf0)
  705. {
  706. if (mpu_cmd(dev, 0xD0, 0) < 0)
  707. return 0;
  708. return 1;
  709. }
  710. switch (status)
  711. {
  712. case 0xF0:
  713. if (mpu_cmd(dev, 0xDF, 0) < 0)
  714. return 0;
  715. return 1;
  717. default:
  718. return 0;
  719. }
  720. }
  722. static int mpu401_start_read(int dev)
  723. {
  724. return 0;
  725. }
  727. static int mpu401_end_read(int dev)
  728. {
  729. return 0;
  730. }
  732. static int mpu401_ioctl(int dev, unsigned cmd, caddr_t arg)
  733. {
  734. struct mpu_config *devc;
  735. mpu_command_rec rec;
  736. int val, ret;
  738. devc = &dev_conf[dev];
  739. switch (cmd) 
  740. {
  741. case SNDCTL_MIDI_MPUMODE:
  742. if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */
  743. printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HWn");
  744. return -EINVAL;
  745. }
  746. if (get_user(val, (int *)arg))
  747. return -EFAULT;
  748. set_uart_mode(dev, devc, !val);
  749. return 0;
  751. case SNDCTL_MIDI_MPUCMD:
  752. if (copy_from_user(&rec, arg, sizeof(rec)))
  753. return -EFAULT;
  754. if ((ret = mpu401_command(dev, &rec)) < 0)
  755. return ret;
  756. if (copy_to_user(arg, &rec, sizeof(rec)))
  757. return -EFAULT;
  758. return 0;
  760. default:
  761. return -EINVAL;
  762. }
  763. }
  765. static void mpu401_kick(int dev)
  766. {
  767. }
  769. static int mpu401_buffer_status(int dev)
  770. {
  771. return 0; /*
  772.  * No data in buffers
  773.  */
  774. }
  776. static int mpu_synth_ioctl(int dev,
  777. unsigned int cmd, caddr_t arg)
  778. {
  779. int midi_dev;
  780. struct mpu_config *devc;
  782. midi_dev = synth_devs[dev]->midi_dev;
  784. if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
  785. return -ENXIO;
  787. devc = &dev_conf[midi_dev];
  789. switch (cmd)
  790. {
  792. case SNDCTL_SYNTH_INFO:
  793. memcpy((&((char *) arg)[0]), (char *) &mpu_synth_info[midi_dev], sizeof(struct synth_info));
  794. return 0;
  796. case SNDCTL_SYNTH_MEMAVL:
  797. return 0x7fffffff;
  799. default:
  800. return -EINVAL;
  801. }
  802. }
  804. static int mpu_synth_open(int dev, int mode)
  805. {
  806. int midi_dev, err;
  807. struct mpu_config *devc;
  808. struct coproc_operations *coprocessor;
  810. midi_dev = synth_devs[dev]->midi_dev;
  812. if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
  813. return -ENXIO;
  815. devc = &dev_conf[midi_dev];
  817. /*
  818.  *  Verify that the device is really running.
  819.  *  Some devices (such as Ensoniq SoundScape don't
  820.  *  work before the on board processor (OBP) is initialized
  821.  *  by downloading its microcode.
  822.  */
  824. if (!devc->initialized)
  825. {
  826. if (mpu401_status(devc) == 0xff) /* Bus float */
  827. {
  828. printk(KERN_ERR "mpu401: Device not initialized properlyn");
  829. return -EIO;
  830. }
  831. reset_mpu401(devc);
  832. }
  833. if (devc->opened)
  834. return -EBUSY;
  835. devc->mode = MODE_SYNTH;
  836. devc->synthno = dev;
  838. devc->inputintr = NULL;
  840. coprocessor = midi_devs[midi_dev]->coproc;
  841. if (coprocessor) {
  842. if (coprocessor->owner)
  843. __MOD_INC_USE_COUNT(coprocessor->owner);
  845. if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
  846. {
  847. printk(KERN_WARNING "mpu401: Can't access coprocessor devicen");
  848. return err;
  849. }
  850. }
  851. devc->opened = mode;
  852. reset_mpu401(devc);
  854. if (mode & OPEN_READ)
  855. {
  856. mpu_cmd(midi_dev, 0x8B, 0); /* Enable data in stop mode */
  857. mpu_cmd(midi_dev, 0x34, 0); /* Return timing bytes in stop mode */
  858. mpu_cmd(midi_dev, 0x87, 0); /* Enable pitch & controller */
  859. }
  860. return 0;
  861. }
  863. static void mpu_synth_close(int dev)
  864. { 
  865. int midi_dev;
  866. struct mpu_config *devc;
  867. struct coproc_operations *coprocessor;
  869. midi_dev = synth_devs[dev]->midi_dev;
  871. devc = &dev_conf[midi_dev];
  872. mpu_cmd(midi_dev, 0x15, 0); /* Stop recording, playback and MIDI */
  873. mpu_cmd(midi_dev, 0x8a, 0); /* Disable data in stopped mode */
  875. devc->inputintr = NULL;
  877. coprocessor = midi_devs[midi_dev]->coproc;
  878. if (coprocessor) {
  879. coprocessor->close(coprocessor->devc, COPR_MIDI);
  881. if (coprocessor->owner)
  882. __MOD_DEC_USE_COUNT(coprocessor->owner);
  883. }
  884. devc->opened = 0;
  885. devc->mode = 0;
  886. }
  888. #define MIDI_SYNTH_NAME "MPU-401 UART Midi"
  889. #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
  890. #include "midi_synth.h"
  892. static struct synth_operations mpu401_synth_proto =
  893. {
  894. owner: THIS_MODULE,
  895. id: "MPU401",
  896. info: NULL,
  897. midi_dev: 0,
  898. synth_type: SYNTH_TYPE_MIDI,
  899. synth_subtype: 0,
  900. open: mpu_synth_open,
  901. close: mpu_synth_close,
  902. ioctl: mpu_synth_ioctl,
  903. kill_note: midi_synth_kill_note,
  904. start_note: midi_synth_start_note,
  905. set_instr: midi_synth_set_instr,
  906. reset: midi_synth_reset,
  907. hw_control: midi_synth_hw_control,
  908. load_patch: midi_synth_load_patch,
  909. aftertouch: midi_synth_aftertouch,
  910. controller: midi_synth_controller,
  911. panning: midi_synth_panning,
  912. bender: midi_synth_bender,
  913. setup_voice: midi_synth_setup_voice,
  914. send_sysex: midi_synth_send_sysex
  915. };
  917. static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV];
  919. static struct midi_operations mpu401_midi_proto =
  920. {
  921. owner: THIS_MODULE,
  922. info: {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401},
  923. in_info: {0},
  924. open: mpu401_open,
  925. close: mpu401_close,
  926. ioctl: mpu401_ioctl,
  927. outputc: mpu401_out,
  928. start_read: mpu401_start_read,
  929. end_read: mpu401_end_read,
  930. kick: mpu401_kick,
  931. buffer_status: mpu401_buffer_status,
  932. prefix_cmd: mpu401_prefix_cmd
  933. };
  935. static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV];
  937. static void mpu401_chk_version(int n, struct mpu_config *devc)
  938. {
  939. int tmp;
  940. unsigned long flags;
  942. devc->version = devc->revision = 0;
  944. save_flags(flags);
  945. cli();
  946. if ((tmp = mpu_cmd(n, 0xAC, 0)) < 0)
  947. {
  948. restore_flags(flags);
  949. return;
  950. }
  951. if ((tmp & 0xf0) > 0x20) /* Why it's larger than 2.x ??? */
  952. {
  953. restore_flags(flags);
  954. return;
  955. }
  956. devc->version = tmp;
  958. if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0)
  959. {
  960. devc->version = 0;
  961. restore_flags(flags);
  962. return;
  963. }
  964. devc->revision = tmp;
  965. restore_flags(flags);
  966. }
  968. void attach_mpu401(struct address_info *hw_config, struct module *owner)
  969. {
  970. unsigned long flags;
  971. char revision_char;
  973. int m;
  974. struct mpu_config *devc;
  976. hw_config->slots[1] = -1;
  977. m = sound_alloc_mididev();
  978. if (m == -1)
  979. {
  980. printk(KERN_WARNING "MPU-401: Too many midi devices detectedn");
  981. return;
  982. }
  983. devc = &dev_conf[m];
  984. devc->base = hw_config->io_base;
  985. devc->osp = hw_config->osp;
  986. devc->irq = hw_config->irq;
  987. devc->opened = 0;
  988. devc->uart_mode = 0;
  989. devc->initialized = 0;
  990. devc->version = 0;
  991. devc->revision = 0;
  992. devc->capabilities = 0;
  993. devc->timer_flag = 0;
  994. devc->m_busy = 0;
  995. devc->m_state = ST_INIT;
  996. devc->shared_irq = hw_config->always_detect;
  997. devc->irq = hw_config->irq;
  999. if (devc->irq < 0)
  1000. {
  1001. devc->irq *= -1;
  1002. devc->shared_irq = 1;
  1003. }
  1005. if (!hw_config->always_detect)
  1006. {
  1007. /* Verify the hardware again */
  1008. if (!reset_mpu401(devc))
  1009. {
  1010. printk(KERN_WARNING "mpu401: Device didn't respondn");
  1011. sound_unload_mididev(m);
  1012. return;
  1013. }
  1014. if (!devc->shared_irq)
  1015. {
  1016. if (request_irq(devc->irq, mpuintr, 0, "mpu401", (void *)m) < 0)
  1017. {
  1018. printk(KERN_WARNING "mpu401: Failed to allocate IRQ%dn", devc->irq);
  1019. sound_unload_mididev(m);
  1020. return;
  1021. }
  1022. }
  1023. save_flags(flags);
  1024. cli();
  1025. mpu401_chk_version(m, devc);
  1026. if (devc->version == 0)
  1027. mpu401_chk_version(m, devc);
  1028. restore_flags(flags);
  1029. }
  1030. request_region(hw_config->io_base, 2, "mpu401");
  1032. if (devc->version != 0)
  1033. if (mpu_cmd(m, 0xC5, 0) >= 0) /* Set timebase OK */
  1034. if (mpu_cmd(m, 0xE0, 120) >= 0) /* Set tempo OK */
  1035. devc->capabilities |= MPU_CAP_INTLG; /* Supports intelligent mode */
  1038. mpu401_synth_operations[m] = (struct synth_operations *)kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
  1040. if (mpu401_synth_operations[m] == NULL)
  1041. {
  1042. sound_unload_mididev(m);
  1043. printk(KERN_ERR "mpu401: Can't allocate memoryn");
  1044. return;
  1045. }
  1046. if (!(devc->capabilities & MPU_CAP_INTLG)) /* No intelligent mode */
  1047. {
  1048. memcpy((char *) mpu401_synth_operations[m],
  1049. (char *) &std_midi_synth,
  1050.  sizeof(struct synth_operations));
  1051. }
  1052. else
  1053. {
  1054. memcpy((char *) mpu401_synth_operations[m],
  1055. (char *) &mpu401_synth_proto,
  1056.  sizeof(struct synth_operations));
  1057. }
  1058. if (owner)
  1059. mpu401_synth_operations[m]->owner = owner;
  1061. memcpy((char *) &mpu401_midi_operations[m],
  1062.        (char *) &mpu401_midi_proto,
  1063.        sizeof(struct midi_operations));
  1065. mpu401_midi_operations[m].converter = mpu401_synth_operations[m];
  1067. memcpy((char *) &mpu_synth_info[m],
  1068.        (char *) &mpu_synth_info_proto,
  1069.        sizeof(struct synth_info));
  1071. n_mpu_devs++;
  1073. if (devc->version == 0x20 && devc->revision >= 0x07) /* MusicQuest interface */
  1074. {
  1075. int ports = (devc->revision & 0x08) ? 32 : 16;
  1077. devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE |
  1078. MPU_CAP_CLS | MPU_CAP_2PORT;
  1080. revision_char = (devc->revision == 0x7f) ? 'M' : ' ';
  1081. sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d",
  1082. ports,
  1083. revision_char,
  1084. n_mpu_devs);
  1085. }
  1086. else
  1087. {
  1088. revision_char = devc->revision ? devc->revision + '@' : ' ';
  1089. if ((int) devc->revision > ('Z' - '@'))
  1090. revision_char = '+';
  1092. devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK;
  1094. if (hw_config->name)
  1095. sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name);
  1096. else
  1097. sprintf(mpu_synth_info[m].name,
  1098. "MPU-401 %d.%d%c Midi interface #%d",
  1099. (int) (devc->version & 0xf0) >> 4,
  1100. devc->version & 0x0f,
  1101. revision_char,
  1102. n_mpu_devs);
  1103. }
  1105. strcpy(mpu401_midi_operations[m].info.name,
  1106.        mpu_synth_info[m].name);
  1108. conf_printf(mpu_synth_info[m].name, hw_config);
  1110. mpu401_synth_operations[m]->midi_dev = devc->devno = m;
  1111. mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno];
  1113. if (devc->capabilities & MPU_CAP_INTLG) /* Intelligent mode */
  1114. hw_config->slots[2] = mpu_timer_init(m);
  1116. midi_devs[m] = &mpu401_midi_operations[devc->devno];
  1118. if (owner)
  1119. midi_devs[m]->owner = owner;
  1121. hw_config->slots[1] = m;
  1122. sequencer_init();
  1123. }
  1125. static int reset_mpu401(struct mpu_config *devc)
  1126. {
  1127. unsigned long flags;
  1128. int ok, timeout, n;
  1129. int timeout_limit;
  1131. /*
  1132.  * Send the RESET command. Try again if no success at the first time.
  1133.  * (If the device is in the UART mode, it will not ack the reset cmd).
  1134.  */
  1136. ok = 0;
  1138. timeout_limit = devc->initialized ? 30000 : 100000;
  1139. devc->initialized = 1;
  1141. for (n = 0; n < 2 && !ok; n++)
  1142. {
  1143. for (timeout = timeout_limit; timeout > 0 && !ok; timeout--)
  1144.   ok = output_ready(devc);
  1146. write_command(devc, MPU_RESET); /*
  1147.    * Send MPU-401 RESET Command
  1148.  */
  1150. /*
  1151.  * Wait at least 25 msec. This method is not accurate so let's make the
  1152.  * loop bit longer. Cannot sleep since this is called during boot.
  1153.  */
  1155. for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--)
  1156. {
  1157. save_flags(flags);
  1158. cli();
  1159. if (input_avail(devc))
  1160. if (read_data(devc) == MPU_ACK)
  1161. ok = 1;
  1162. restore_flags(flags);
  1163. }
  1165. }
  1167. devc->m_state = ST_INIT;
  1168. devc->m_ptr = 0;
  1169. devc->m_left = 0;
  1170. devc->last_status = 0;
  1171. devc->uart_mode = 0;
  1173. return ok;
  1174. }
  1176. static void set_uart_mode(int dev, struct mpu_config *devc, int arg)
  1177. {
  1178. if (!arg && (devc->capabilities & MPU_CAP_INTLG))
  1179. return;
  1180. if ((devc->uart_mode == 0) == (arg == 0))
  1181. return; /* Already set */
  1182. reset_mpu401(devc); /* This exits the uart mode */
  1184. if (arg)
  1185. {
  1186. if (mpu_cmd(dev, UART_MODE_ON, 0) < 0)
  1187. {
  1188. printk(KERN_ERR "mpu401: Can't enter UART moden");
  1189. devc->uart_mode = 0;
  1190. return;
  1191. }
  1192. }
  1193. devc->uart_mode = arg;
  1195. }
  1197. int probe_mpu401(struct address_info *hw_config)
  1198. {
  1199. int ok = 0;
  1200. struct mpu_config tmp_devc;
  1202. if (check_region(hw_config->io_base, 2))
  1203. {
  1204. printk(KERN_ERR "mpu401: I/O port %x already in usenn", hw_config->io_base);
  1205. return 0;
  1206. }
  1207. tmp_devc.base = hw_config->io_base;
  1208. tmp_devc.irq = hw_config->irq;
  1209. tmp_devc.initialized = 0;
  1210. tmp_devc.opened = 0;
  1211. tmp_devc.osp = hw_config->osp;
  1213. if (hw_config->always_detect)
  1214. return 1;
  1216. if (inb(hw_config->io_base + 1) == 0xff)
  1217. {
  1218. DDB(printk("MPU401: Port %x looks dead.n", hw_config->io_base));
  1219. return 0; /* Just bus float? */
  1220. }
  1221. ok = reset_mpu401(&tmp_devc);
  1223. if (!ok)
  1224. {
  1225. DDB(printk("MPU401: Reset failed on port %xn", hw_config->io_base));
  1226. }
  1227. return ok;
  1228. }
  1230. void unload_mpu401(struct address_info *hw_config)
  1231. {
  1232. void *p;
  1233. int n=hw_config->slots[1];
  1235. release_region(hw_config->io_base, 2);
  1236. if (hw_config->always_detect == 0 && hw_config->irq > 0)
  1237. free_irq(hw_config->irq, (void *)n);
  1238. p=mpu401_synth_operations[n];
  1239. sound_unload_mididev(n);
  1240. sound_unload_timerdev(hw_config->slots[2]);
  1241. if(p)
  1242. kfree(p);
  1243. }
  1245. /*****************************************************
  1246.  *      Timer stuff
  1247.  ****************************************************/
  1249. static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0;
  1250. static volatile int curr_tempo, curr_timebase, hw_timebase;
  1251. static int      max_timebase = 8; /* 8*24=192 ppqn */
  1252. static volatile unsigned long next_event_time;
  1253. static volatile unsigned long curr_ticks, curr_clocks;
  1254. static unsigned long prev_event_time;
  1255. static int      metronome_mode;
  1257. static unsigned long clocks2ticks(unsigned long clocks)
  1258. {
  1259. /*
  1260.  * The MPU-401 supports just a limited set of possible timebase values.
  1261.  * Since the applications require more choices, the driver has to
  1262.  * program the HW to do its best and to convert between the HW and
  1263.  * actual timebases.
  1264.  */
  1265. return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase;
  1266. }
  1268. static void set_timebase(int midi_dev, int val)
  1269. {
  1270. int hw_val;
  1272. if (val < 48)
  1273. val = 48;
  1274. if (val > 1000)
  1275. val = 1000;
  1277. hw_val = val;
  1278. hw_val = (hw_val + 12) / 24;
  1279. if (hw_val > max_timebase)
  1280. hw_val = max_timebase;
  1282. if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0)
  1283. {
  1284. printk(KERN_WARNING "mpu401: Can't set HW timebase to %dn", hw_val * 24);
  1285. return;
  1286. }
  1287. hw_timebase = hw_val * 24;
  1288. curr_timebase = val;
  1290. }
  1292. static void tmr_reset(void)
  1293. {
  1294. unsigned long flags;
  1296. save_flags(flags);
  1297. cli();
  1298. next_event_time = (unsigned long) -1;
  1299. prev_event_time = 0;
  1300. curr_ticks = curr_clocks = 0;
  1301. restore_flags(flags);
  1302. }
  1304. static void set_timer_mode(int midi_dev)
  1305. {
  1306. if (timer_mode & TMR_MODE_CLS)
  1307. mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */
  1308. else if (timer_mode & TMR_MODE_SMPTE)
  1309. mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */
  1311. if (timer_mode & TMR_INTERNAL)
  1312. {
  1313.   mpu_cmd(midi_dev, 0x80, 0); /* Use MIDI sync */
  1314. }
  1315. else
  1316. {
  1317. if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS))
  1318. {
  1319. mpu_cmd(midi_dev, 0x82, 0); /* Use MIDI sync */
  1320. mpu_cmd(midi_dev, 0x91, 0); /* Enable ext MIDI ctrl */
  1321. }
  1322. else if (timer_mode & TMR_MODE_FSK)
  1323. mpu_cmd(midi_dev, 0x81, 0); /* Use FSK sync */
  1324. }
  1325. }
  1327. static void stop_metronome(int midi_dev)
  1328. {
  1329. mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */
  1330. }
  1332. static void setup_metronome(int midi_dev)
  1333. {
  1334. int numerator, denominator;
  1335. int clks_per_click, num_32nds_per_beat;
  1336. int beats_per_measure;
  1338. numerator = ((unsigned) metronome_mode >> 24) & 0xff;
  1339. denominator = ((unsigned) metronome_mode >> 16) & 0xff;
  1340. clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff;
  1341. num_32nds_per_beat = (unsigned) metronome_mode & 0xff;
  1342. beats_per_measure = (numerator * 4) >> denominator;
  1344. if (!metronome_mode)
  1345. mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */
  1346. else
  1347. {
  1348. mpu_cmd(midi_dev, 0xE4, clks_per_click);
  1349. mpu_cmd(midi_dev, 0xE6, beats_per_measure);
  1350. mpu_cmd(midi_dev, 0x83, 0); /* Enable metronome without accents */
  1351. }
  1352. }
  1354. static int mpu_start_timer(int midi_dev)
  1355. {
  1356. tmr_reset();
  1357. set_timer_mode(midi_dev);
  1359. if (tmr_running)
  1360. return TIMER_NOT_ARMED; /* Already running */
  1362. if (timer_mode & TMR_INTERNAL)
  1363. {
  1364. mpu_cmd(midi_dev, 0x02, 0); /* Send MIDI start */
  1365. tmr_running = 1;
  1366. return TIMER_NOT_ARMED;
  1367. }
  1368. else
  1369. {
  1370. mpu_cmd(midi_dev, 0x35, 0); /* Enable mode messages to PC */
  1371. mpu_cmd(midi_dev, 0x38, 0); /* Enable sys common messages to PC */
  1372. mpu_cmd(midi_dev, 0x39, 0); /* Enable real time messages to PC */
  1373. mpu_cmd(midi_dev, 0x97, 0); /* Enable system exclusive messages to PC */
  1374. }
  1375. return TIMER_ARMED;
  1376. }
  1378. static int mpu_timer_open(int dev, int mode)
  1379. {
  1380. int midi_dev = sound_timer_devs[dev]->devlink;
  1382. if (timer_open)
  1383. return -EBUSY;
  1385. tmr_reset();
  1386. curr_tempo = 50;
  1387. mpu_cmd(midi_dev, 0xE0, 50);
  1388. curr_timebase = hw_timebase = 120;
  1389. set_timebase(midi_dev, 120);
  1390. timer_open = 1;
  1391. metronome_mode = 0;
  1392. set_timer_mode(midi_dev);
  1394. mpu_cmd(midi_dev, 0xe7, 0x04); /* Send all clocks to host */
  1395. mpu_cmd(midi_dev, 0x95, 0); /* Enable clock to host */
  1397. return 0;
  1398. }
  1400. static void mpu_timer_close(int dev)
  1401. {
  1402. int midi_dev = sound_timer_devs[dev]->devlink;
  1404. timer_open = tmr_running = 0;
  1405. mpu_cmd(midi_dev, 0x15, 0); /* Stop all */
  1406. mpu_cmd(midi_dev, 0x94, 0); /* Disable clock to host */
  1407. mpu_cmd(midi_dev, 0x8c, 0); /* Disable measure end messages to host */
  1408. stop_metronome(midi_dev);
  1409. }
  1411. static int mpu_timer_event(int dev, unsigned char *event)
  1412. {
  1413. unsigned char command = event[1];
  1414. unsigned long parm = *(unsigned int *) &event[4];
  1415. int midi_dev = sound_timer_devs[dev]->devlink;
  1417. switch (command)
  1418. {
  1419. case TMR_WAIT_REL:
  1420. parm += prev_event_time;
  1421. case TMR_WAIT_ABS:
  1422. if (parm > 0)
  1423. {
  1424. long time;
  1426. if (parm <= curr_ticks) /* It's the time */
  1427. return TIMER_NOT_ARMED;
  1428. time = parm;
  1429. next_event_time = prev_event_time = time;
  1431. return TIMER_ARMED;
  1432. }
  1433. break;
  1435. case TMR_START:
  1436. if (tmr_running)
  1437. break;
  1438. return mpu_start_timer(midi_dev);
  1440. case TMR_STOP:
  1441. mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */
  1442. stop_metronome(midi_dev);
  1443. tmr_running = 0;
  1444. break;
  1446. case TMR_CONTINUE:
  1447. if (tmr_running)
  1448. break;
  1449. mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */
  1450. setup_metronome(midi_dev);
  1451. tmr_running = 1;
  1452. break;
  1454. case TMR_TEMPO:
  1455. if (parm)
  1456. {
  1457. if (parm < 8)
  1458. parm = 8;
  1459.   if (parm > 250)
  1460. parm = 250;
  1461. if (mpu_cmd(midi_dev, 0xE0, parm) < 0)
  1462. printk(KERN_WARNING "mpu401: Can't set tempo to %dn", (int) parm);
  1463. curr_tempo = parm;
  1464. }
  1465. break;
  1467. case TMR_ECHO:
  1468. seq_copy_to_input(event, 8);
  1469. break;
  1471. case TMR_TIMESIG:
  1472. if (metronome_mode) /* Metronome enabled */
  1473. {
  1474. metronome_mode = parm;
  1475. setup_metronome(midi_dev);
  1476. }
  1477. break;
  1479. default:;
  1480. }
  1481. return TIMER_NOT_ARMED;
  1482. }
  1484. static unsigned long mpu_timer_get_time(int dev)
  1485. {
  1486. if (!timer_open)
  1487. return 0;
  1489. return curr_ticks;
  1490. }
  1492. static int mpu_timer_ioctl(int dev, unsigned int command, caddr_t arg)
  1493. {
  1494. int midi_dev = sound_timer_devs[dev]->devlink;
  1496. switch (command)
  1497. {
  1498. case SNDCTL_TMR_SOURCE:
  1499. {
  1500. int parm;
  1502. parm = *(int *) arg;
  1503. parm &= timer_caps;
  1505. if (parm != 0)
  1506. {
  1507. timer_mode = parm;
  1509. if (timer_mode & TMR_MODE_CLS)
  1510. mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */
  1511. else if (timer_mode & TMR_MODE_SMPTE)
  1512. mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */
  1513. }
  1514. return (*(int *) arg = timer_mode);
  1515. }
  1516. break;
  1518. case SNDCTL_TMR_START:
  1519. mpu_start_timer(midi_dev);
  1520. return 0;
  1522. case SNDCTL_TMR_STOP:
  1523. tmr_running = 0;
  1524. mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */
  1525. stop_metronome(midi_dev);
  1526. return 0;
  1528. case SNDCTL_TMR_CONTINUE:
  1529. if (tmr_running)
  1530. return 0;
  1531. tmr_running = 1;
  1532. mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */
  1533. return 0;
  1535. case SNDCTL_TMR_TIMEBASE:
  1536. {
  1537. int val;
  1539. val = *(int *) arg;
  1540. if (val)
  1541. set_timebase(midi_dev, val);
  1542. return (*(int *) arg = curr_timebase);
  1543. }
  1544. break;
  1546. case SNDCTL_TMR_TEMPO:
  1547. {
  1548. int val;
  1549. int ret;
  1551. val = *(int *) arg;
  1553. if (val)
  1554. {
  1555. if (val < 8)
  1556. val = 8;
  1557. if (val > 250)
  1558. val = 250;
  1559. if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0)
  1560. {
  1561. printk(KERN_WARNING "mpu401: Can't set tempo to %dn", (int) val);
  1562. return ret;
  1563. }
  1564. curr_tempo = val;
  1565. }
  1566. return (*(int *) arg = curr_tempo);
  1567. }
  1568. break;
  1570. case SNDCTL_SEQ_CTRLRATE:
  1571. {
  1572. int val;
  1574. val = *(int *) arg;
  1575. if (val != 0) /* Can't change */
  1576. return -EINVAL;
  1577. return (*(int *) arg = ((curr_tempo * curr_timebase) + 30) / 60);
  1578. }
  1579. break;
  1581. case SNDCTL_SEQ_GETTIME:
  1582. return (*(int *) arg = curr_ticks);
  1584. case SNDCTL_TMR_METRONOME:
  1585. metronome_mode = *(int *) arg;
  1586. setup_metronome(midi_dev);
  1587. return 0;
  1589. default:;
  1590. }
  1591. return -EINVAL;
  1592. }
  1594. static void mpu_timer_arm(int dev, long time)
  1595. {
  1596. if (time < 0)
  1597. time = curr_ticks + 1;
  1598. else if (time <= curr_ticks) /* It's the time */
  1599. return;
  1600. next_event_time = prev_event_time = time;
  1601. return;
  1602. }
  1604. static struct sound_timer_operations mpu_timer =
  1605. {
  1606. owner: THIS_MODULE,
  1607. info: {"MPU-401 Timer", 0},
  1608. priority: 10, /* Priority */
  1609. devlink: 0, /* Local device link */
  1610. open: mpu_timer_open,
  1611. close: mpu_timer_close,
  1612. event: mpu_timer_event,
  1613. get_time: mpu_timer_get_time,
  1614. ioctl: mpu_timer_ioctl,
  1615. arm_timer: mpu_timer_arm
  1616. };
  1618. static void mpu_timer_interrupt(void)
  1619. {
  1620. if (!timer_open)
  1621. return;
  1623. if (!tmr_running)
  1624. return;
  1626. curr_clocks++;
  1627. curr_ticks = clocks2ticks(curr_clocks);
  1629. if (curr_ticks >= next_event_time)
  1630. {
  1631. next_event_time = (unsigned long) -1;
  1632. sequencer_timer(0);
  1633. }
  1634. }
  1636. static void timer_ext_event(struct mpu_config *devc, int event, int parm)
  1637. {
  1638. int midi_dev = devc->devno;
  1640. if (!devc->timer_flag)
  1641. return;
  1643. switch (event)
  1644. {
  1645. case TMR_CLOCK:
  1646. printk("<MIDI clk>");
  1647. break;
  1649. case TMR_START:
  1650. printk("Ext MIDI startn");
  1651. if (!tmr_running)
  1652. {
  1653. if (timer_mode & TMR_EXTERNAL)
  1654. {
  1655. tmr_running = 1;
  1656. setup_metronome(midi_dev);
  1657. next_event_time = 0;
  1658. STORE(SEQ_START_TIMER());
  1659. }
  1660. }
  1661. break;
  1663. case TMR_STOP:
  1664. printk("Ext MIDI stopn");
  1665. if (timer_mode & TMR_EXTERNAL)
  1666. {
  1667. tmr_running = 0;
  1668. stop_metronome(midi_dev);
  1669. STORE(SEQ_STOP_TIMER());
  1670. }
  1671. break;
  1673. case TMR_CONTINUE:
  1674. printk("Ext MIDI continuen");
  1675. if (timer_mode & TMR_EXTERNAL)
  1676. {
  1677. tmr_running = 1;
  1678. setup_metronome(midi_dev);
  1679. STORE(SEQ_CONTINUE_TIMER());
  1680.    }
  1681.    break;
  1683. case TMR_SPP:
  1684. printk("Songpos: %dn", parm);
  1685. if (timer_mode & TMR_EXTERNAL)
  1686. {
  1687. STORE(SEQ_SONGPOS(parm));
  1688. }
  1689. break;
  1690. }
  1691. }
  1693. static int mpu_timer_init(int midi_dev)
  1694. {
  1695. struct mpu_config *devc;
  1696. int n;
  1698. devc = &dev_conf[midi_dev];
  1700. if (timer_initialized)
  1701. return -1; /* There is already a similar timer */
  1703. timer_initialized = 1;
  1705. mpu_timer.devlink = midi_dev;
  1706. dev_conf[midi_dev].timer_flag = 1;
  1708. n = sound_alloc_timerdev();
  1709. if (n == -1)
  1710. n = 0;
  1711. sound_timer_devs[n] = &mpu_timer;
  1713. if (devc->version < 0x20) /* Original MPU-401 */
  1714. timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI;
  1715. else
  1716. {
  1717. /*
  1718.  * The version number 2.0 is used (at least) by the
  1719.  * MusicQuest cards and the Roland Super-MPU.
  1720.  *
  1721.  * MusicQuest has given a special meaning to the bits of the
  1722.  * revision number. The Super-MPU returns 0.
  1723.  */
  1725. if (devc->revision)
  1726. timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI;
  1728. if (devc->revision & 0x02)
  1729. timer_caps |= TMR_MODE_CLS;
  1732. if (devc->revision & 0x40)
  1733. max_timebase = 10; /* Has the 216 and 240 ppqn modes */
  1734. }
  1736. timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps;
  1737. return n;
  1739. }
  1741. EXPORT_SYMBOL(probe_mpu401);
  1742. EXPORT_SYMBOL(attach_mpu401);
  1743. EXPORT_SYMBOL(unload_mpu401);
  1744. EXPORT_SYMBOL(intchk_mpu401);
  1745. EXPORT_SYMBOL(mpuintr);
  1747. static struct address_info cfg;
  1749. static int __initdata io = -1;
  1750. static int __initdata irq = -1;
  1752. MODULE_PARM(irq, "i");
  1753. MODULE_PARM(io, "i");
  1755. int __init init_mpu401(void)
  1756. {
  1757. /* Can be loaded either for module use or to provide functions
  1758.    to others */
  1759. if (io != -1 && irq != -1) {
  1760.         cfg.irq = irq;
  1761. cfg.io_base = io;
  1762. if (probe_mpu401(&cfg) == 0)
  1763. return -ENODEV;
  1764. attach_mpu401(&cfg, THIS_MODULE);
  1765. }
  1767. return 0;
  1768. }
  1770. void __exit cleanup_mpu401(void)
  1771. {
  1772. if (io != -1 && irq != -1) {
  1773. /* Check for use by, for example, sscape driver */
  1774. unload_mpu401(&cfg);
  1775. }
  1776. }
  1778. module_init(init_mpu401);
  1779. module_exit(cleanup_mpu401);
  1781. #ifndef MODULE
  1782. static int __init setup_mpu401(char *str)
  1783. {
  1784.         /* io, irq */
  1785. int ints[3];
  1787. str = get_options(str, ARRAY_SIZE(ints), ints);
  1789. io = ints[1];
  1790. irq = ints[2];
  1792. return 1;
  1793. }
  1795. __setup("mpu401=", setup_mpu401);
  1796. #endif
  1797. MODULE_LICENSE("GPL");