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

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

嵌入式Linux

开发平台：

Unix_Linux

wf_midi.c：源码内容
  1. /*
  2.  * sound/wf_midi.c
  3.  *
  4.  * The low level driver for the WaveFront ICS2115 MIDI interface(s)
  5.  * Note that there is also an MPU-401 emulation (actually, a UART-401
  6.  * emulation) on the CS4232 on the Tropez Plus. This code has nothing
  7.  * to do with that interface at all.
  8.  *
  9.  * The interface is essentially just a UART-401, but is has the
  10.  * interesting property of supporting what Turtle Beach called
  11.  * "Virtual MIDI" mode. In this mode, there are effectively *two*
  12.  * MIDI buses accessible via the interface, one that is routed
  13.  * solely to/from the external WaveFront synthesizer and the other
  14.  * corresponding to the pin/socket connector used to link external
  15.  * MIDI devices to the board.
  16.  *
  17.  * This driver fully supports this mode, allowing two distinct
  18.  * midi devices (/dev/midiNN and /dev/midiNN+1) to be used
  19.  * completely independently, giving 32 channels of MIDI routing,
  20.  * 16 to the WaveFront synth and 16 to the external MIDI bus.
  21.  *
  22.  * Switching between the two is accomplished externally by the driver
  23.  * using the two otherwise unused MIDI bytes. See the code for more details.
  24.  *
  25.  * NOTE: VIRTUAL MIDI MODE IS ON BY DEFAULT (see wavefront.c)
  26.  *
  27.  * The main reason to turn off Virtual MIDI mode is when you want to
  28.  * tightly couple the WaveFront synth with an external MIDI
  29.  * device. You won't be able to distinguish the source of any MIDI
  30.  * data except via SysEx ID, but thats probably OK, since for the most
  31.  * part, the WaveFront won't be sending any MIDI data at all.
  32.  *  
  33.  * The main reason to turn on Virtual MIDI Mode is to provide two
  34.  * completely independent 16-channel MIDI buses, one to the
  35.  * WaveFront and one to any external MIDI devices. Given the 32
  36.  * voice nature of the WaveFront, its pretty easy to find a use
  37.  * for all 16 channels driving just that synth.
  38.  *
  39.  */
  41. /*
  42.  * Copyright (C) by Paul Barton-Davis 1998
  43.  * Some portions of this file are derived from work that is:
  44.  *
  45.  *    CopyriGht (C) by Hannu Savolainen 1993-1996
  46.  *
  47.  * USS/Lite for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  48.  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  49.  * for more info.
  50.  */
  52. #include <linux/init.h>
  53. #include "sound_config.h"
  55. #include <linux/wavefront.h>
  57. #ifdef MODULE
  59. struct wf_mpu_config {
  60. int             base;
  61. #define DATAPORT(d)   (d)->base
  62. #define COMDPORT(d)   (d)->base+1
  63. #define STATPORT(d)   (d)->base+1
  65. int             irq;
  66. int             opened;
  67. int             devno;
  68. int             synthno;
  69. int             mode;
  70. #define MODE_MIDI 1
  71. #define MODE_SYNTH 2
  73. void            (*inputintr) (int dev, unsigned char data);
  74. char isvirtual;                /* do virtual I/O stuff */
  75. };
  77. static struct wf_mpu_config  devs[2];
  78. static struct wf_mpu_config *phys_dev = &devs[0];
  79. static struct wf_mpu_config *virt_dev = &devs[1];
  81. static void start_uart_mode (void);
  83. #define OUTPUT_READY 0x40
  84. #define INPUT_AVAIL 0x80
  85. #define MPU_ACK 0xFE
  86. #define UART_MODE_ON 0x3F
  88. static inline int wf_mpu_status (void)
  89. {
  90. return inb (STATPORT (phys_dev));
  91. }
  93. static inline int input_avail (void)
  94. {
  95. return !(wf_mpu_status() & INPUT_AVAIL);
  96. }
  98. static inline int output_ready (void)
  99. {
  100. return !(wf_mpu_status() & OUTPUT_READY);
  101. }
  103. static inline int  read_data (void)
  104. {
  105. return inb (DATAPORT (phys_dev));
  106. }
  108. static inline void write_data (unsigned char byte)
  109. {
  110. outb (byte, DATAPORT (phys_dev));
  111. }
  113. /*
  114.  * States for the input scanner (should be in dev_table.h)
  115.  */
  117. #define MST_SYSMSG 100 /* System message (sysx etc). */
  118. #define MST_MTC 102 /* Midi Time Code (MTC) qframe msg */
  119. #define MST_SONGSEL 103 /* Song select */
  120. #define MST_SONGPOS 104 /* Song position pointer */
  121. #define MST_TIMED 105 /* Leading timing byte rcvd */
  123. /* buffer space check for input scanner */
  125. #define BUFTEST(mi) if (mi->m_ptr >= MI_MAX || mi->m_ptr < 0) 
  126. {printk(KERN_ERR "WF-MPU: Invalid buffer pointer %d/%d, s=%dn", 
  127. mi->m_ptr, mi->m_left, mi->m_state);mi->m_ptr--;}
  129. static unsigned char len_tab[] = /* # of data bytes following a status
  130.  */
  131. {
  132. 2, /* 8x */
  133. 2, /* 9x */
  134. 2, /* Ax */
  135. 2, /* Bx */
  136. 1, /* Cx */
  137. 1, /* Dx */
  138. 2, /* Ex */
  139. 0 /* Fx */
  140. };
  142. static int
  143. wf_mpu_input_scanner (int devno, int synthdev, unsigned char midic)
  145. {
  146. struct midi_input_info *mi = &midi_devs[devno]->in_info;
  148. switch (mi->m_state) {
  149. case MST_INIT:
  150. switch (midic) {
  151. case 0xf8:
  152. /* Timer overflow */
  153. break;
  155. case 0xfc:
  156. break;
  158. case 0xfd:
  159. /* XXX do something useful with this. If there is
  160.    an external MIDI timer (e.g. a hardware sequencer,
  161.    a useful timer can be derived ...
  162.    
  163.    For now, no timer support.
  164. */
  165. break;
  167. case 0xfe:
  168. return MPU_ACK;
  169. break;
  171. case 0xf0:
  172. case 0xf1:
  173. case 0xf2:
  174. case 0xf3:
  175. case 0xf4:
  176. case 0xf5:
  177. case 0xf6:
  178. case 0xf7:
  179. break;
  181. case 0xf9:
  182. break;
  184. case 0xff:
  185. mi->m_state = MST_SYSMSG;
  186. break;
  188. default:
  189. if (midic <= 0xef) {
  190. mi->m_state = MST_TIMED;
  191. }
  192. else
  193. printk (KERN_ERR "<MPU: Unknown event %02x> ",
  194. midic);
  195. }
  196. break;
  197.   
  198. case MST_TIMED:
  199. {
  200. int             msg = ((int) (midic & 0xf0) >> 4);
  201.   
  202. mi->m_state = MST_DATA;
  203.   
  204. if (msg < 8) { /* Data byte */
  205.       
  206. msg = ((int) (mi->m_prev_status & 0xf0) >> 4);
  207. msg -= 8;
  208. mi->m_left = len_tab[msg] - 1;
  209.       
  210. mi->m_ptr = 2;
  211. mi->m_buf[0] = mi->m_prev_status;
  212. mi->m_buf[1] = midic;
  214. if (mi->m_left <= 0) {
  215. mi->m_state = MST_INIT;
  216. do_midi_msg (synthdev, mi->m_buf, mi->m_ptr);
  217. mi->m_ptr = 0;
  218. }
  219. } else if (msg == 0xf) { /* MPU MARK */
  220.       
  221. mi->m_state = MST_INIT;
  223. switch (midic) {
  224. case 0xf8:
  225. break;
  226.     
  227. case 0xf9:
  228. break;
  229.     
  230. case 0xfc:
  231. break;
  232.     
  233. default:
  234. break;
  235. }
  236. } else {
  237. mi->m_prev_status = midic;
  238. msg -= 8;
  239. mi->m_left = len_tab[msg];
  240.       
  241. mi->m_ptr = 1;
  242. mi->m_buf[0] = midic;
  243.       
  244. if (mi->m_left <= 0) {
  245. mi->m_state = MST_INIT;
  246. do_midi_msg (synthdev, mi->m_buf, mi->m_ptr);
  247. mi->m_ptr = 0;
  248. }
  249. }
  250. }
  251. break;
  253. case MST_SYSMSG:
  254. switch (midic) {
  255. case 0xf0:
  256. mi->m_state = MST_SYSEX;
  257. break;
  258.     
  259. case 0xf1:
  260. mi->m_state = MST_MTC;
  261. break;
  263. case 0xf2:
  264. mi->m_state = MST_SONGPOS;
  265. mi->m_ptr = 0;
  266. break;
  267.     
  268. case 0xf3:
  269. mi->m_state = MST_SONGSEL;
  270. break;
  271.     
  272. case 0xf6:
  273. mi->m_state = MST_INIT;
  274.     
  275. /*
  276.  *    Real time messages
  277.  */
  278. case 0xf8:
  279. /* midi clock */
  280. mi->m_state = MST_INIT;
  281. /* XXX need ext MIDI timer support */
  282. break;
  283.     
  284. case 0xfA:
  285. mi->m_state = MST_INIT;
  286. /* XXX need ext MIDI timer support */
  287. break;
  288.     
  289. case 0xFB:
  290. mi->m_state = MST_INIT;
  291. /* XXX need ext MIDI timer support */
  292. break;
  293.     
  294. case 0xFC:
  295. mi->m_state = MST_INIT;
  296. /* XXX need ext MIDI timer support */
  297. break;
  298.     
  299. case 0xFE:
  300. /* active sensing */
  301. mi->m_state = MST_INIT;
  302. break;
  303.     
  304. case 0xff:
  305. mi->m_state = MST_INIT;
  306. break;
  308. default:
  309. printk (KERN_ERR "unknown MIDI sysmsg %0xn", midic);
  310. mi->m_state = MST_INIT;
  311. }
  312. break;
  314. case MST_MTC:
  315. mi->m_state = MST_INIT;
  316. break;
  318. case MST_SYSEX:
  319. if (midic == 0xf7) {
  320. mi->m_state = MST_INIT;
  321. } else {
  322. /* XXX fix me */
  323. }
  324. break;
  326. case MST_SONGPOS:
  327. BUFTEST (mi);
  328. mi->m_buf[mi->m_ptr++] = midic;
  329. if (mi->m_ptr == 2) {
  330. mi->m_state = MST_INIT;
  331. mi->m_ptr = 0;
  332. /* XXX need ext MIDI timer support */
  333. }
  334. break;
  336. case MST_DATA:
  337. BUFTEST (mi);
  338. mi->m_buf[mi->m_ptr++] = midic;
  339. if ((--mi->m_left) <= 0) {
  340. mi->m_state = MST_INIT;
  341. do_midi_msg (synthdev, mi->m_buf, mi->m_ptr);
  342. mi->m_ptr = 0;
  343. }
  344. break;
  346. default:
  347. printk (KERN_ERR "Bad state %d ", mi->m_state);
  348. mi->m_state = MST_INIT;
  349. }
  351. return 1;
  352. }
  354. void
  355. wf_mpuintr (int irq, void *dev_id, struct pt_regs *dummy)
  357. {
  358. struct wf_mpu_config *physical_dev = dev_id;
  359. static struct wf_mpu_config *input_dev = 0;
  360. struct midi_input_info *mi = &midi_devs[physical_dev->devno]->in_info;
  361. int n;
  363. if (!input_avail()) { /* not for us */
  364. return;
  365. }
  367. if (mi->m_busy) return;
  368. mi->m_busy = 1;
  369. sti (); 
  371. if (!input_dev) {
  372. input_dev = physical_dev;
  373. }
  375. n = 50; /* XXX why ? */
  377. do {
  378. unsigned char c = read_data ();
  379.       
  380. if (phys_dev->isvirtual) {
  382. if (c == WF_EXTERNAL_SWITCH) {
  383. input_dev = virt_dev;
  384. continue;
  385. } else if (c == WF_INTERNAL_SWITCH) { 
  386. input_dev = phys_dev;
  387. continue;
  388. } /* else just leave it as it is */
  390. } else {
  391. input_dev = phys_dev;
  392. }
  394. if (input_dev->mode == MODE_SYNTH) {
  395.   
  396. wf_mpu_input_scanner (input_dev->devno,
  397.       input_dev->synthno, c);
  398.   
  399. } else if (input_dev->opened & OPEN_READ) {
  400.   
  401. if (input_dev->inputintr) {
  402. input_dev->inputintr (input_dev->devno, c);
  403. } 
  404. }
  406. } while (input_avail() && n-- > 0);
  408. mi->m_busy = 0;
  409. }
  411. static int
  412. wf_mpu_open (int dev, int mode,
  413.      void            (*input) (int dev, unsigned char data),
  414.      void            (*output) (int dev)
  415. )
  416. {
  417. struct wf_mpu_config *devc;
  419. if (dev < 0 || dev >= num_midis || midi_devs[dev]==NULL)
  420. return -(ENXIO);
  422. if (phys_dev->devno == dev) {
  423. devc = phys_dev;
  424. } else if (phys_dev->isvirtual && virt_dev->devno == dev) {
  425. devc = virt_dev;
  426. } else {
  427. printk (KERN_ERR "WF-MPU: unknown device number %dn", dev);
  428. return -(EINVAL);
  429. }
  431. if (devc->opened) {
  432. return -(EBUSY);
  433. }
  435. devc->mode = MODE_MIDI;
  436. devc->opened = mode;
  437. devc->synthno = 0;
  439. devc->inputintr = input;
  440. return 0;
  441. }
  442.  
  443. static void
  444. wf_mpu_close (int dev)
  445. {
  446. struct wf_mpu_config *devc;
  448. if (dev < 0 || dev >= num_midis || midi_devs[dev]==NULL)
  449. return;
  451. if (phys_dev->devno == dev) {
  452. devc = phys_dev;
  453. } else if (phys_dev->isvirtual && virt_dev->devno == dev) {
  454. devc = virt_dev;
  455. } else {
  456. printk (KERN_ERR "WF-MPU: unknown device number %dn", dev);
  457. return;
  458. }
  460. devc->mode = 0;
  461. devc->inputintr = NULL;
  462. devc->opened = 0;
  463. }
  465. static int
  466. wf_mpu_out (int dev, unsigned char midi_byte)
  467. {
  468. int             timeout;
  469. unsigned long   flags;
  470. static int lastoutdev = -1;
  471. unsigned char switchch;
  473. if (phys_dev->isvirtual && lastoutdev != dev) {
  474.       
  475. if (dev == phys_dev->devno) { 
  476. switchch = WF_INTERNAL_SWITCH;
  477. } else if (dev == virt_dev->devno) { 
  478. switchch = WF_EXTERNAL_SWITCH;
  479. } else {
  480. printk (KERN_ERR "WF-MPU: bad device number %d", dev);
  481. return (0);
  482. }
  484. /* XXX fix me */
  485.       
  486. for (timeout = 30000; timeout > 0 && !output_ready ();
  487.      timeout--);
  488.       
  489. save_flags (flags);
  490. cli ();
  491.       
  492. if (!output_ready ()) {
  493. printk (KERN_WARNING "WF-MPU: Send switch "
  494. "byte timeoutn");
  495. restore_flags (flags);
  496. return 0;
  497. }
  498.       
  499. write_data (switchch);
  500. restore_flags (flags);
  501. } 
  503. lastoutdev = dev;
  505. /*
  506.  * Sometimes it takes about 30000 loops before the output becomes ready
  507.  * (After reset). Normally it takes just about 10 loops.
  508.  */
  510. /* XXX fix me */
  512. for (timeout = 30000; timeout > 0 && !output_ready (); timeout--);
  514. save_flags (flags);
  515. cli ();
  516. if (!output_ready ()) {
  517. printk (KERN_WARNING "WF-MPU: Send data timeoutn");
  518. restore_flags (flags);
  519. return 0;
  520. }
  522. write_data (midi_byte);
  523. restore_flags (flags);
  525. return 1;
  526. }
  528. static inline int wf_mpu_start_read (int dev) {
  529. return 0;
  530. }
  532. static inline int wf_mpu_end_read (int dev) {
  533. return 0;
  534. }
  536. static int wf_mpu_ioctl (int dev, unsigned cmd, caddr_t arg)
  537. {
  538. printk (KERN_WARNING
  539. "WF-MPU: Intelligent mode not supported by hardware.n");
  540. return -(EINVAL);
  541. }
  543. static int wf_mpu_buffer_status (int dev)
  544. {
  545. return 0;
  546. }
  548. static struct synth_operations wf_mpu_synth_operations[2];
  549. static struct midi_operations  wf_mpu_midi_operations[2];
  551. static struct midi_operations wf_mpu_midi_proto =
  552. {
  553. owner: THIS_MODULE,
  554. info: {"WF-MPU MIDI", 0, MIDI_CAP_MPU401, SNDCARD_MPU401},
  555. in_info: {0},   /* in_info */
  556. open: wf_mpu_open,
  557. close: wf_mpu_close,
  558. ioctl: wf_mpu_ioctl,
  559. outputc: wf_mpu_out,
  560. start_read: wf_mpu_start_read,
  561. end_read: wf_mpu_end_read,
  562. buffer_status: wf_mpu_buffer_status,
  563. };
  565. static struct synth_info wf_mpu_synth_info_proto =
  566. {"WaveFront MPU-401 interface", 0,
  567.  SYNTH_TYPE_MIDI, MIDI_TYPE_MPU401, 0, 128, 0, 128, SYNTH_CAP_INPUT};
  569. static struct synth_info wf_mpu_synth_info[2];
  571. static int
  572. wf_mpu_synth_ioctl (int dev,
  573.     unsigned int cmd, caddr_t arg)
  574. {
  575. int             midi_dev;
  576. int index;
  578. midi_dev = synth_devs[dev]->midi_dev;
  580. if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev]==NULL)
  581. return -(ENXIO);
  583. if (midi_dev == phys_dev->devno) {
  584. index = 0;
  585. } else if (phys_dev->isvirtual && midi_dev == virt_dev->devno) {
  586. index = 1;
  587. } else {
  588. return -(EINVAL);
  589. }
  591. switch (cmd) {
  593. case SNDCTL_SYNTH_INFO:
  594. if(copy_to_user (&((char *) arg)[0],
  595.       &wf_mpu_synth_info[index],
  596.       sizeof (struct synth_info)))
  597. return -EFAULT;
  598. return 0;
  600. case SNDCTL_SYNTH_MEMAVL:
  601. return 0x7fffffff;
  603. default:
  604. return -EINVAL;
  605. }
  606. }
  608. static int
  609. wf_mpu_synth_open (int dev, int mode)
  610. {
  611. int             midi_dev;
  612. struct wf_mpu_config *devc;
  614. midi_dev = synth_devs[dev]->midi_dev;
  616. if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev]==NULL) {
  617. return -(ENXIO);
  618. }
  619.   
  620. if (phys_dev->devno == midi_dev) {
  621. devc = phys_dev;
  622. } else if (phys_dev->isvirtual && virt_dev->devno == midi_dev) {
  623. devc = virt_dev;
  624. } else {
  625. printk (KERN_ERR "WF-MPU: unknown device number %dn", dev);
  626. return -(EINVAL);
  627. }
  629. if (devc->opened) {
  630. return -(EBUSY);
  631. }
  632.   
  633. devc->mode = MODE_SYNTH;
  634. devc->synthno = dev;
  635. devc->opened = mode;
  636. devc->inputintr = NULL;
  637. return 0;
  638. }
  640. static void
  641. wf_mpu_synth_close (int dev)
  642. {
  643. int             midi_dev;
  644. struct wf_mpu_config *devc;
  646. midi_dev = synth_devs[dev]->midi_dev;
  648. if (phys_dev->devno == midi_dev) {
  649. devc = phys_dev;
  650. } else if (phys_dev->isvirtual && virt_dev->devno == midi_dev) {
  651. devc = virt_dev;
  652. } else {
  653. printk (KERN_ERR "WF-MPU: unknown device number %dn", dev);
  654. return;
  655. }
  657. devc->inputintr = NULL;
  658. devc->opened = 0;
  659. devc->mode = 0;
  660. }
  662. #define _MIDI_SYNTH_C_
  663. #define MIDI_SYNTH_NAME "WaveFront (MIDI)"
  664. #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
  665. #include "midi_synth.h"
  667. static struct synth_operations wf_mpu_synth_proto =
  668. {
  669. owner: THIS_MODULE,
  670. id: "WaveFront (ICS2115)",
  671. info: NULL,  /* info field, filled in during configuration */
  672. midi_dev: 0,     /* MIDI dev XXX should this be -1 ? */
  673. synth_type: SYNTH_TYPE_MIDI,
  674. synth_subtype: SAMPLE_TYPE_WAVEFRONT,
  675. open: wf_mpu_synth_open,
  676. close: wf_mpu_synth_close,
  677. ioctl: wf_mpu_synth_ioctl,
  678. kill_note: midi_synth_kill_note,
  679. start_note: midi_synth_start_note,
  680. set_instr: midi_synth_set_instr,
  681. reset: midi_synth_reset,
  682. hw_control: midi_synth_hw_control,
  683. load_patch: midi_synth_load_patch,
  684. aftertouch: midi_synth_aftertouch,
  685. controller: midi_synth_controller,
  686. panning: midi_synth_panning,
  687. bender: midi_synth_bender,
  688. setup_voice: midi_synth_setup_voice,
  689. send_sysex: midi_synth_send_sysex
  690. };
  692. static int
  693. config_wf_mpu (struct wf_mpu_config *dev)
  695. {
  696. int is_external;
  697. char *name;
  698. int index;
  700. if (dev == phys_dev) {
  701. name = "WaveFront internal MIDI";
  702. is_external = 0;
  703. index = 0;
  704. memcpy ((char *) &wf_mpu_synth_operations[index],
  705. (char *) &wf_mpu_synth_proto,
  706. sizeof (struct synth_operations));
  707. } else {
  708. name = "WaveFront external MIDI";
  709. is_external = 1;
  710. index = 1;
  711. /* no synth operations for an external MIDI interface */
  712. }
  714. memcpy ((char *) &wf_mpu_synth_info[dev->devno],
  715. (char *) &wf_mpu_synth_info_proto,
  716. sizeof (struct synth_info));
  718. strcpy (wf_mpu_synth_info[index].name, name);
  720. wf_mpu_synth_operations[index].midi_dev = dev->devno;
  721. wf_mpu_synth_operations[index].info = &wf_mpu_synth_info[index];
  723. memcpy ((char *) &wf_mpu_midi_operations[index],
  724. (char *) &wf_mpu_midi_proto,
  725. sizeof (struct midi_operations));
  726.   
  727. if (is_external) {
  728. wf_mpu_midi_operations[index].converter = NULL;
  729. } else {
  730. wf_mpu_midi_operations[index].converter =
  731. &wf_mpu_synth_operations[index];
  732. }
  734. strcpy (wf_mpu_midi_operations[index].info.name, name);
  736. midi_devs[dev->devno] = &wf_mpu_midi_operations[index];
  737. midi_devs[dev->devno]->in_info.m_busy = 0;
  738. midi_devs[dev->devno]->in_info.m_state = MST_INIT;
  739. midi_devs[dev->devno]->in_info.m_ptr = 0;
  740. midi_devs[dev->devno]->in_info.m_left = 0;
  741. midi_devs[dev->devno]->in_info.m_prev_status = 0;
  743. devs[index].opened = 0;
  744. devs[index].mode = 0;
  746. return (0);
  747. }
  749. int virtual_midi_enable (void)
  751. {
  752. if ((virt_dev->devno < 0) &&
  753.     (virt_dev->devno = sound_alloc_mididev()) == -1) {
  754. printk (KERN_ERR
  755. "WF-MPU: too many midi devices detectedn");
  756. return -1;
  757. }
  759. config_wf_mpu (virt_dev);
  761. phys_dev->isvirtual = 1;
  762. return virt_dev->devno;
  763. }
  765. int
  766. virtual_midi_disable (void)
  768. {
  769. unsigned long flags;
  771. save_flags (flags);
  772. cli();
  774. wf_mpu_close (virt_dev->devno);
  775. /* no synth on virt_dev, so no need to call wf_mpu_synth_close() */
  776. phys_dev->isvirtual = 0;
  778. restore_flags (flags);
  780. return 0;
  781. }
  783. int __init detect_wf_mpu (int irq, int io_base)
  784. {
  785. if (check_region (io_base, 2)) {
  786. printk (KERN_WARNING "WF-MPU: I/O port %x already in use.n",
  787. io_base);
  788. return -1;
  789. }
  791. phys_dev->base = io_base;
  792. phys_dev->irq = irq;
  793. phys_dev->devno = -1;
  794. virt_dev->devno = -1;
  796. return 0;
  797. }
  799. int __init install_wf_mpu (void)
  800. {
  801. if ((phys_dev->devno = sound_alloc_mididev()) < 0){
  803. printk (KERN_ERR "WF-MPU: Too many MIDI devices detected.n");
  804. return -1;
  806. }
  808. request_region (phys_dev->base, 2, "wavefront midi");
  809. phys_dev->isvirtual = 0;
  811. if (config_wf_mpu (phys_dev)) {
  813. printk (KERN_WARNING
  814. "WF-MPU: configuration for MIDI device %d failedn",
  815. phys_dev->devno);
  816. sound_unload_mididev (phys_dev->devno);
  818. }
  820. /* OK, now we're configured to handle an interrupt ... */
  822. if (request_irq (phys_dev->irq, wf_mpuintr, SA_INTERRUPT|SA_SHIRQ,
  823.  "wavefront midi", phys_dev) < 0) {
  825. printk (KERN_ERR "WF-MPU: Failed to allocate IRQ%dn",
  826. phys_dev->irq);
  827. return -1;
  829. }
  831. /* This being a WaveFront (ICS-2115) emulated MPU-401, we have
  832.    to switch it into UART (dumb) mode, because otherwise, it
  833.    won't do anything at all.
  834. */
  835.   
  836. start_uart_mode ();
  838. return phys_dev->devno;
  839. }
  840.  
  841. void
  842. uninstall_wf_mpu (void)
  844. {
  845. release_region (phys_dev->base, 2); 
  846. free_irq (phys_dev->irq, phys_dev);
  847. sound_unload_mididev (phys_dev->devno);
  849. if (virt_dev->devno >= 0) {
  850. sound_unload_mididev (virt_dev->devno);
  851. }
  852. }
  854. static void
  855. start_uart_mode (void)
  857. {
  858. int             ok, i;
  859. unsigned long   flags;
  861. save_flags (flags);
  862. cli ();
  864. /* XXX fix me */
  866. for (i = 0; i < 30000 && !output_ready (); i++);
  868. outb (UART_MODE_ON, COMDPORT(phys_dev));
  870. for (ok = 0, i = 50000; i > 0 && !ok; i--) {
  871. if (input_avail ()) {
  872. if (read_data () == MPU_ACK) {
  873. ok = 1;
  874. }
  875. }
  876. }
  878. restore_flags (flags);
  879. }
  880. #endif