litmus-rt-budgetable-locks.git/.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Hugh Dickins <hugh.dickins@tiscali.co.uk>	2009-12-30 15:17:34 -0500
committer	Linus Torvalds <torvalds@linux-foundation.org>	2009-12-30 15:23:27 -0500
commit	66f0dc481e5b802ab363b979fc1753410c7d82b5 (patch)
tree	9f8609685f07d410bc6536a0d3e47e366edf93d4 /mm
parent	75c85a0bc13367aabb36e8208d4e373b022b43b3 (diff)

mm: move sys_mmap_pgoff from util.c

Move sys_mmap_pgoff() from mm/util.c to mm/mmap.c and mm/nommu.c, where we'd expect to find such code: especially now that it contains the MAP_HUGETLB handling. Revert mm/util.c to how it was in 2.6.32. This patch just ignores MAP_HUGETLB in the nommu case, as in 2.6.32, whereas 2.6.33-rc2 reported -ENOSYS. Perhaps validate_mmap_request() should reject it with -EINVAL? Add that later if necessary. Signed-off-by: Hugh Dickins <hugh.dickins@tiscali.co.uk> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Diffstat (limited to 'mm')

-rw-r--r--

mm/mmap.c

-rw-r--r--

mm/nommu.c

-rw-r--r--

mm/util.c

3 files changed, 65 insertions, 44 deletions

 }
 EXPORT_SYMBOL(do_mmap_pgoff);
+SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,
+                unsigned long, prot, unsigned long, flags,
+                unsigned long, fd, unsigned long, pgoff)
+{
+        struct file *file = NULL;
+        unsigned long retval = -EBADF;
+        if (!(flags & MAP_ANONYMOUS)) {
+                if (unlikely(flags & MAP_HUGETLB))
+                        return -EINVAL;
+                file = fget(fd);
+                if (!file)
+                        goto out;
+        } else if (flags & MAP_HUGETLB) {
+                struct user_struct *user = NULL;
+                /*
+                 * VM_NORESERVE is used because the reservations will be
+                 * taken when vm_ops->mmap() is called
+                 * A dummy user value is used because we are not locking
+                 * memory so no accounting is necessary
+                 */
+                len = ALIGN(len, huge_page_size(&default_hstate));
+                file = hugetlb_file_setup(HUGETLB_ANON_FILE, len, VM_NORESERVE,
+                                                &user, HUGETLB_ANONHUGE_INODE);
+                if (IS_ERR(file))
+                        return PTR_ERR(file);
+        }
+        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
+        down_write(&current->mm->mmap_sem);
+        retval = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
+        up_write(&current->mm->mmap_sem);
+        if (file)
+                fput(file);
+out:
+        return retval;
+}
 /*
  * Some shared mappigns will want the pages marked read-only
  * to track write events. If so, we'll downgrade vm_page_prot
 }
 EXPORT_SYMBOL(do_mmap_pgoff);
+SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,
+                unsigned long, prot, unsigned long, flags,
+                unsigned long, fd, unsigned long, pgoff)
+{
+        struct file *file = NULL;
+        unsigned long retval = -EBADF;
+        if (!(flags & MAP_ANONYMOUS)) {
+                file = fget(fd);
+                if (!file)
+                        goto out;
+        }
+        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
+        down_write(&current->mm->mmap_sem);
+        retval = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
+        up_write(&current->mm->mmap_sem);
+        if (file)
+                fput(file);
+out:
+        return retval;
+}
 /*
  * split a vma into two pieces at address 'addr', a new vma is allocated either
  * for the first part or the tail.
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/sched.h>
-#include <linux/hugetlb.h>
-#include <linux/syscalls.h>
-#include <linux/mman.h>
-#include <linux/file.h>
 #include <asm/uaccess.h>
 #define CREATE_TRACE_POINTS
 }
 EXPORT_SYMBOL_GPL(get_user_pages_fast);
-SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,
-                unsigned long, prot, unsigned long, flags,
-                unsigned long, fd, unsigned long, pgoff)
-{
-        struct file * file = NULL;
-        unsigned long retval = -EBADF;
-        if (!(flags & MAP_ANONYMOUS)) {
-                if (unlikely(flags & MAP_HUGETLB))
-                        return -EINVAL;
-                file = fget(fd);
-                if (!file)
-                        goto out;
-        } else if (flags & MAP_HUGETLB) {
-                struct user_struct *user = NULL;
-                /*
-                 * VM_NORESERVE is used because the reservations will be
-                 * taken when vm_ops->mmap() is called
-                 * A dummy user value is used because we are not locking
-                 * memory so no accounting is necessary
-                 */
-                len = ALIGN(len, huge_page_size(&default_hstate));
-                file = hugetlb_file_setup(HUGETLB_ANON_FILE, len, VM_NORESERVE,
-                                                &user, HUGETLB_ANONHUGE_INODE);
-                if (IS_ERR(file))
-                        return PTR_ERR(file);
-        }
-        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
-        down_write(&current->mm->mmap_sem);
-        retval = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
-        up_write(&current->mm->mmap_sem);
-        if (file)
-                fput(file);
-out:
-        return retval;
-}
 /* Tracepoints definitions. */
 EXPORT_TRACEPOINT_SYMBOL(kmalloc);
 EXPORT_TRACEPOINT_SYMBOL(kmem_cache_alloc);

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996

1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746

/* * sound/oss/mpu401.c * * The low level driver for Roland MPU-401 compatible Midi cards. */ /* * Copyright (C) by Hannu Savolainen 1993-1997 * * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) * Version 2 (June 1991). See the "COPYING" file distributed with this software * for more info. * * * Thomas Sailer ioctl code reworked (vmalloc/vfree removed) * Alan Cox modularisation, use normal request_irq, use dev_id * Bartlomiej Zolnierkiewicz removed some __init to allow using many drivers * Chris Rankin Update the module-usage counter for the coprocessor * Zwane Mwaikambo Changed attach/unload resource freeing */ #include <linux/module.h> #include <linux/slab.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/spinlock.h> #define USE_SEQ_MACROS #define USE_SIMPLE_MACROS #include "sound_config.h" #include "coproc.h" #include "mpu401.h" static int timer_mode = TMR_INTERNAL, timer_caps = TMR_INTERNAL; struct mpu_config { int base; /* * I/O base */ int irq; int opened; /* * Open mode */ int devno; int synthno; int uart_mode; int initialized; int mode; #define MODE_MIDI 1 #define MODE_SYNTH 2 unsigned char version, revision; unsigned int capabilities; #define MPU_CAP_INTLG 0x10000000 #define MPU_CAP_SYNC 0x00000010 #define MPU_CAP_FSK 0x00000020 #define MPU_CAP_CLS 0x00000040 #define MPU_CAP_SMPTE 0x00000080 #define MPU_CAP_2PORT 0x00000001 int timer_flag; #define MBUF_MAX 10 #define BUFTEST(dc) if (dc->m_ptr >= MBUF_MAX || dc->m_ptr < 0) \ {printk( "MPU: Invalid buffer pointer %d/%d, s=%d\n", dc->m_ptr, dc->m_left, dc->m_state);dc->m_ptr--;} int m_busy; unsigned char m_buf[MBUF_MAX]; int m_ptr; int m_state; int m_left; unsigned char last_status; void (*inputintr) (int dev, unsigned char data); int shared_irq; int *osp; spinlock_t lock; }; #define DATAPORT(base) (base) #define COMDPORT(base) (base+1) #define STATPORT(base) (base+1) static void mpu401_close(int dev); static inline int mpu401_status(struct mpu_config *devc) { return inb(STATPORT(devc->base)); } #define input_avail(devc) (!(mpu401_status(devc)&INPUT_AVAIL)) #define output_ready(devc) (!(mpu401_status(devc)&OUTPUT_READY)) static inline void write_command(struct mpu_config *devc, unsigned char cmd) { outb(cmd, COMDPORT(devc->base)); } static inline int read_data(struct mpu_config *devc) { return inb(DATAPORT(devc->base)); } static inline void write_data(struct mpu_config *devc, unsigned char byte) { outb(byte, DATAPORT(devc->base)); } #define OUTPUT_READY 0x40 #define INPUT_AVAIL 0x80 #define MPU_ACK 0xFE #define MPU_RESET 0xFF #define UART_MODE_ON 0x3F static struct mpu_config dev_conf[MAX_MIDI_DEV]; static int n_mpu_devs; static int reset_mpu401(struct mpu_config *devc); static void set_uart_mode(int dev, struct mpu_config *devc, int arg); static int mpu_timer_init(int midi_dev); static void mpu_timer_interrupt(void); static void timer_ext_event(struct mpu_config *devc, int event, int parm); static struct synth_info mpu_synth_info_proto = { "MPU-401 MIDI interface", 0, SYNTH_TYPE_MIDI, MIDI_TYPE_MPU401, 0, 128, 0, 128, SYNTH_CAP_INPUT }; static struct synth_info mpu_synth_info[MAX_MIDI_DEV]; /* * States for the input scanner */ #define ST_INIT 0 /* Ready for timing byte or msg */ #define ST_TIMED 1 /* Leading timing byte rcvd */ #define ST_DATABYTE 2 /* Waiting for (nr_left) data bytes */ #define ST_SYSMSG 100 /* System message (sysx etc). */ #define ST_SYSEX 101 /* System exclusive msg */ #define ST_MTC 102 /* Midi Time Code (MTC) qframe msg */ #define ST_SONGSEL 103 /* Song select */ #define ST_SONGPOS 104 /* Song position pointer */ static unsigned char len_tab[] = /* # of data bytes following a status */ { 2, /* 8x */ 2, /* 9x */ 2, /* Ax */ 2, /* Bx */ 1, /* Cx */ 1, /* Dx */ 2, /* Ex */ 0 /* Fx */ }; #define STORE(cmd) \ { \ int len; \ unsigned char obuf[8]; \ cmd; \ seq_input_event(obuf, len); \ } #define _seqbuf obuf #define _seqbufptr 0 #define _SEQ_ADVBUF(x) len=x static int mpu_input_scanner(struct mpu_config *devc, unsigned char midic) { switch (devc->m_state) { case ST_INIT: switch (midic) { case 0xf8: /* Timer overflow */ break; case 0xfc: printk("<all end>"); break; case 0xfd: if (devc->timer_flag) mpu_timer_interrupt(); break; case 0xfe: return MPU_ACK; case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: printk("<Trk data rq #%d>", midic & 0x0f); break; case 0xf9: printk("<conductor rq>"); break; case 0xff: devc->m_state = ST_SYSMSG; break; default: if (midic <= 0xef) { /* printk( "mpu time: %d ", midic); */ devc->m_state = ST_TIMED; } else printk("<MPU: Unknown event %02x> ", midic); } break; case ST_TIMED: { int msg = ((int) (midic & 0xf0) >> 4); devc->m_state = ST_DATABYTE; if (msg < 8) /* Data byte */ { /* printk( "midi msg (running status) "); */ msg = ((int) (devc->last_status & 0xf0) >> 4); msg -= 8; devc->m_left = len_tab[msg] - 1; devc->m_ptr = 2; devc->m_buf[0] = devc->last_status; devc->m_buf[1] = midic; if (devc->m_left <= 0) { devc->m_state = ST_INIT; do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr); devc->m_ptr = 0; } } else if (msg == 0xf) /* MPU MARK */ { devc->m_state = ST_INIT; switch (midic) { case 0xf8: /* printk( "NOP "); */ break; case 0xf9: /* printk( "meas end "); */ break; case 0xfc: /* printk( "data end "); */ break; default: printk("Unknown MPU mark %02x\n", midic); } } else { devc->last_status = midic; /* printk( "midi msg "); */ msg -= 8; devc->m_left = len_tab[msg]; devc->m_ptr = 1; devc->m_buf[0] = midic; if (devc->m_left <= 0) { devc->m_state = ST_INIT; do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr); devc->m_ptr = 0; } } } break; case ST_SYSMSG: switch (midic) { case 0xf0: printk("<SYX>"); devc->m_state = ST_SYSEX; break; case 0xf1: devc->m_state = ST_MTC; break; case 0xf2: devc->m_state = ST_SONGPOS; devc->m_ptr = 0; break; case 0xf3: devc->m_state = ST_SONGSEL; break; case 0xf6: /* printk( "tune_request\n"); */ devc->m_state = ST_INIT; /* * Real time messages */ case 0xf8: /* midi clock */ devc->m_state = ST_INIT; timer_ext_event(devc, TMR_CLOCK, 0); break; case 0xfA: devc->m_state = ST_INIT; timer_ext_event(devc, TMR_START, 0); break; case 0xFB: devc->m_state = ST_INIT; timer_ext_event(devc, TMR_CONTINUE, 0); break; case 0xFC: devc->m_state = ST_INIT; timer_ext_event(devc, TMR_STOP, 0); break; case 0xFE: /* active sensing */ devc->m_state = ST_INIT; break; case 0xff: /* printk( "midi hard reset"); */ devc->m_state = ST_INIT; break; default: printk("unknown MIDI sysmsg %0x\n", midic); devc->m_state = ST_INIT; } break; case ST_MTC: devc->m_state = ST_INIT; printk("MTC frame %x02\n", midic); break; case ST_SYSEX: if (midic == 0xf7) { printk("<EOX>"); devc->m_state = ST_INIT; } else printk("%02x ", midic); break; case ST_SONGPOS: BUFTEST(devc); devc->m_buf[devc->m_ptr++] = midic; if (devc->m_ptr == 2) { devc->m_state = ST_INIT; devc->m_ptr = 0; timer_ext_event(devc, TMR_SPP, ((devc->m_buf[1] & 0x7f) << 7) | (devc->m_buf[0] & 0x7f)); } break; case ST_DATABYTE: BUFTEST(devc); devc->m_buf[devc->m_ptr++] = midic; if ((--devc->m_left) <= 0) { devc->m_state = ST_INIT; do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr); devc->m_ptr = 0; } break; default: printk("Bad state %d ", devc->m_state); devc->m_state = ST_INIT; } return 1; } static void mpu401_input_loop(struct mpu_config *devc) { unsigned long flags; int busy; int n; spin_lock_irqsave(&devc->lock,flags); busy = devc->m_busy; devc->m_busy = 1; spin_unlock_irqrestore(&devc->lock,flags); if (busy) /* Already inside the scanner */ return; n = 50; while (input_avail(devc) && n-- > 0) { unsigned char c = read_data(devc); if (devc->mode == MODE_SYNTH) { mpu_input_scanner(devc, c); } else if (devc->opened & OPEN_READ && devc->inputintr != NULL) devc->inputintr(devc->devno, c); } devc->m_busy = 0; } static irqreturn_t mpuintr(int irq, void *dev_id) { struct mpu_config *devc; int dev = (int)(unsigned long) dev_id; int handled = 0; devc = &dev_conf[dev]; if (input_avail(devc)) { handled = 1; if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH)) mpu401_input_loop(devc); else { /* Dummy read (just to acknowledge the interrupt) */ read_data(devc); } } return IRQ_RETVAL(handled); } static int mpu401_open(int dev, int mode, void (*input) (int dev, unsigned char data), void (*output) (int dev) ) { int err; struct mpu_config *devc; struct coproc_operations *coprocessor; if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL) return -ENXIO; devc = &dev_conf[dev]; if (devc->opened) return -EBUSY; /* * Verify that the device is really running. * Some devices (such as Ensoniq SoundScape don't * work before the on board processor (OBP) is initialized * by downloading its microcode. */ if (!devc->initialized) { if (mpu401_status(devc) == 0xff) /* Bus float */ { printk(KERN_ERR "mpu401: Device not initialized properly\n"); return -EIO; } reset_mpu401(devc); } if ( (coprocessor = midi_devs[dev]->coproc) != NULL ) { if (!try_module_get(coprocessor->owner)) { mpu401_close(dev); return -ENODEV; } if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0) { printk(KERN_WARNING "MPU-401: Can't access coprocessor device\n"); mpu401_close(dev); return err; } } set_uart_mode(dev, devc, 1); devc->mode = MODE_MIDI; devc->synthno = 0; mpu401_input_loop(devc); devc->inputintr = input; devc->opened = mode; return 0; } static void mpu401_close(int dev) { struct mpu_config *devc; struct coproc_operations *coprocessor; devc = &dev_conf[dev]; if (devc->uart_mode) reset_mpu401(devc); /* * This disables the UART mode */ devc->mode = 0; devc->inputintr = NULL; coprocessor = midi_devs[dev]->coproc; if (coprocessor) { coprocessor->close(coprocessor->devc, COPR_MIDI); module_put(coprocessor->owner); } devc->opened = 0; } static int mpu401_out(int dev, unsigned char midi_byte) { int timeout; unsigned long flags; struct mpu_config *devc; devc = &dev_conf[dev]; /* * Sometimes it takes about 30000 loops before the output becomes ready * (After reset). Normally it takes just about 10 loops. */ for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--); spin_lock_irqsave(&devc->lock,flags); if (!output_ready(devc)) { printk(KERN_WARNING "mpu401: Send data timeout\n"); spin_unlock_irqrestore(&devc->lock,flags); return 0; } write_data(devc, midi_byte); spin_unlock_irqrestore(&devc->lock,flags); return 1; } static int mpu401_command(int dev, mpu_command_rec * cmd) { int i, timeout, ok; int ret = 0; unsigned long flags; struct mpu_config *devc; devc = &dev_conf[dev]; if (devc->uart_mode) /* * Not possible in UART mode */ { printk(KERN_WARNING "mpu401: commands not possible in the UART mode\n"); return -EINVAL; } /* * Test for input since pending input seems to block the output. */ if (input_avail(devc)) mpu401_input_loop(devc); /* * Sometimes it takes about 50000 loops before the output becomes ready * (After reset). Normally it takes just about 10 loops. */ timeout = 50000; retry: if (timeout-- <= 0) { printk(KERN_WARNING "mpu401: Command (0x%x) timeout\n", (int) cmd->cmd); return -EIO; } spin_lock_irqsave(&devc->lock,flags); if (!output_ready(devc)) { spin_unlock_irqrestore(&devc->lock,flags); goto retry; } write_command(devc, cmd->cmd); ok = 0; for (timeout = 50000; timeout > 0 && !ok; timeout--) { if (input_avail(devc)) { if (devc->opened && devc->mode == MODE_SYNTH) { if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK) ok = 1; } else { /* Device is not currently open. Use simpler method */ if (read_data(devc) == MPU_ACK) ok = 1; } } } if (!ok) { spin_unlock_irqrestore(&devc->lock,flags); return -EIO; } if (cmd->nr_args) { for (i = 0; i < cmd->nr_args; i++) { for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--); if (!mpu401_out(dev, cmd->data[i])) { spin_unlock_irqrestore(&devc->lock,flags); printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.\n", (int) cmd->cmd); return -EIO; } } } ret = 0; cmd->data[0] = 0; if (cmd->nr_returns) { for (i = 0; i < cmd->nr_returns; i++) { ok = 0; for (timeout = 5000; timeout > 0 && !ok; timeout--) if (input_avail(devc)) { cmd->data[i] = read_data(devc); ok = 1; } if (!ok) { spin_unlock_irqrestore(&devc->lock,flags); return -EIO; } } } spin_unlock_irqrestore(&devc->lock,flags); return ret; } static int mpu_cmd(int dev, int cmd, int data) { int ret; static mpu_command_rec rec; rec.cmd = cmd & 0xff; rec.nr_args = ((cmd & 0xf0) == 0xE0); rec.nr_returns = ((cmd & 0xf0) == 0xA0); rec.data[0] = data & 0xff; if ((ret = mpu401_command(dev, &rec)) < 0) return ret; return (unsigned char) rec.data[0]; } static int mpu401_prefix_cmd(int dev, unsigned char status) { struct mpu_config *devc = &dev_conf[dev]; if (devc->uart_mode) return 1; if (status < 0xf0) { if (mpu_cmd(dev, 0xD0, 0) < 0) return 0; return 1; } switch (status) { case 0xF0: if (mpu_cmd(dev, 0xDF, 0) < 0) return 0; return 1; default: return 0; } } static int mpu401_start_read(int dev) { return 0; } static int mpu401_end_read(int dev) { return 0; } static int mpu401_ioctl(int dev, unsigned cmd, void __user *arg) { struct mpu_config *devc; mpu_command_rec rec; int val, ret; devc = &dev_conf[dev]; switch (cmd) { case SNDCTL_MIDI_MPUMODE: if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */ printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HW\n"); return -EINVAL; } if (get_user(val, (int __user *)arg)) return -EFAULT; set_uart_mode(dev, devc, !val); return 0; case SNDCTL_MIDI_MPUCMD: if (copy_from_user(&rec, arg, sizeof(rec))) return -EFAULT; if ((ret = mpu401_command(dev, &rec)) < 0) return ret; if (copy_to_user(arg, &rec, sizeof(rec))) return -EFAULT; return 0; default: return -EINVAL; } } static void mpu401_kick(int dev) { } static int mpu401_buffer_status(int dev) { return 0; /* * No data in buffers */ } static int mpu_synth_ioctl(int dev, unsigned int cmd, void __user *arg) { int midi_dev; struct mpu_config *devc; midi_dev = synth_devs[dev]->midi_dev; if (midi_dev < 0 || midi_dev >= num_midis || midi_devs[midi_dev] == NULL) return -ENXIO; devc = &dev_conf[midi_dev]; switch (cmd) { case SNDCTL_SYNTH_INFO: if (copy_to_user(arg, &mpu_synth_info[midi_dev], sizeof(struct synth_info))) return -EFAULT; return 0; case SNDCTL_SYNTH_MEMAVL: return 0x7fffffff; default: return -EINVAL; } } static int mpu_synth_open(int dev, int mode) { int midi_dev, err; struct mpu_config *devc; struct coproc_operations *coprocessor; midi_dev = synth_devs[dev]->midi_dev; if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL) return -ENXIO; devc = &dev_conf[midi_dev]; /* * Verify that the device is really running. * Some devices (such as Ensoniq SoundScape don't * work before the on board processor (OBP) is initialized * by downloading its microcode. */ if (!devc->initialized) { if (mpu401_status(devc) == 0xff) /* Bus float */ { printk(KERN_ERR "mpu401: Device not initialized properly\n"); return -EIO; } reset_mpu401(devc); } if (devc->opened) return -EBUSY; devc->mode = MODE_SYNTH; devc->synthno = dev; devc->inputintr = NULL; coprocessor = midi_devs[midi_dev]->coproc; if (coprocessor) { if (!try_module_get(coprocessor->owner)) return -ENODEV; if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0) { printk(KERN_WARNING "mpu401: Can't access coprocessor device\n"); return err; } } devc->opened = mode; reset_mpu401(devc); if (mode & OPEN_READ) { mpu_cmd(midi_dev, 0x8B, 0); /* Enable data in stop mode */ mpu_cmd(midi_dev, 0x34, 0); /* Return timing bytes in stop mode */ mpu_cmd(midi_dev, 0x87, 0); /* Enable pitch & controller */ } return 0; } static void mpu_synth_close(int dev) { int midi_dev; struct mpu_config *devc; struct coproc_operations *coprocessor; midi_dev = synth_devs[dev]->midi_dev; devc = &dev_conf[midi_dev]; mpu_cmd(midi_dev, 0x15, 0); /* Stop recording, playback and MIDI */ mpu_cmd(midi_dev, 0x8a, 0); /* Disable data in stopped mode */ devc->inputintr = NULL; coprocessor = midi_devs[midi_dev]->coproc; if (coprocessor) { coprocessor->close(coprocessor->devc, COPR_MIDI); module_put(coprocessor->owner); } devc->opened = 0; devc->mode = 0; } #define MIDI_SYNTH_NAME "MPU-401 UART Midi" #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT #include "midi_synth.h" static struct synth_operations mpu401_synth_proto = { .owner = THIS_MODULE, .id = "MPU401", .info = NULL, .midi_dev = 0, .synth_type = SYNTH_TYPE_MIDI, .synth_subtype = 0, .open = mpu_synth_open, .close = mpu_synth_close, .ioctl = mpu_synth_ioctl, .kill_note = midi_synth_kill_note, .start_note = midi_synth_start_note, .set_instr = midi_synth_set_instr, .reset = midi_synth_reset, .hw_control = midi_synth_hw_control, .load_patch = midi_synth_load_patch, .aftertouch = midi_synth_aftertouch, .controller = midi_synth_controller, .panning = midi_synth_panning, .bender = midi_synth_bender, .setup_voice = midi_synth_setup_voice, .send_sysex = midi_synth_send_sysex }; static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV]; static struct midi_operations mpu401_midi_proto = { .owner = THIS_MODULE, .info = {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401}, .in_info = {0}, .open = mpu401_open, .close = mpu401_close, .ioctl = mpu401_ioctl, .outputc = mpu401_out, .start_read = mpu401_start_read, .end_read = mpu401_end_read, .kick = mpu401_kick, .buffer_status = mpu401_buffer_status, .prefix_cmd = mpu401_prefix_cmd }; static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV]; static void mpu401_chk_version(int n, struct mpu_config *devc) { int tmp; devc->version = devc->revision = 0; tmp = mpu_cmd(n, 0xAC, 0); if (tmp < 0) return; if ((tmp & 0xf0) > 0x20) /* Why it's larger than 2.x ??? */ return; devc->version = tmp; if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0) { devc->version = 0; return; } devc->revision = tmp; } int attach_mpu401(struct address_info *hw_config, struct module *owner) { unsigned long flags; char revision_char; int m, ret; struct mpu_config *devc; hw_config->slots[1] = -1; m = sound_alloc_mididev(); if (m == -1) { printk(KERN_WARNING "MPU-401: Too many midi devices detected\n"); ret = -ENOMEM; goto out_err; } devc = &dev_conf[m]; devc->base = hw_config->io_base; devc->osp = hw_config->osp; devc->irq = hw_config->irq; devc->opened = 0; devc->uart_mode = 0; devc->initialized = 0; devc->version = 0; devc->revision = 0; devc->capabilities = 0; devc->timer_flag = 0; devc->m_busy = 0; devc->m_state = ST_INIT; devc->shared_irq = hw_config->always_detect; devc->irq = hw_config->irq; spin_lock_init(&devc->lock); if (devc->irq < 0) { devc->irq *= -1; devc->shared_irq = 1; } if (!hw_config->always_detect) { /* Verify the hardware again */ if (!reset_mpu401(devc)) { printk(KERN_WARNING "mpu401: Device didn't respond\n"); ret = -ENODEV; goto out_mididev; } if (!devc->shared_irq) { if (request_irq(devc->irq, mpuintr, 0, "mpu401", hw_config) < 0) { printk(KERN_WARNING "mpu401: Failed to allocate IRQ%d\n", devc->irq); ret = -ENOMEM; goto out_mididev; } } spin_lock_irqsave(&devc->lock,flags); mpu401_chk_version(m, devc); if (devc->version == 0) mpu401_chk_version(m, devc); spin_unlock_irqrestore(&devc->lock, flags); } if (devc->version != 0) if (mpu_cmd(m, 0xC5, 0) >= 0) /* Set timebase OK */ if (mpu_cmd(m, 0xE0, 120) >= 0) /* Set tempo OK */ devc->capabilities |= MPU_CAP_INTLG; /* Supports intelligent mode */ mpu401_synth_operations[m] = kmalloc(sizeof(struct synth_operations), GFP_KERNEL); if (mpu401_synth_operations[m] == NULL) { printk(KERN_ERR "mpu401: Can't allocate memory\n"); ret = -ENOMEM; goto out_irq; } if (!(devc->capabilities & MPU_CAP_INTLG)) /* No intelligent mode */ { memcpy((char *) mpu401_synth_operations[m], (char *) &std_midi_synth, sizeof(struct synth_operations)); } else { memcpy((char *) mpu401_synth_operations[m], (char *) &mpu401_synth_proto, sizeof(struct synth_operations)); } if (owner) mpu401_synth_operations[m]->owner = owner; memcpy((char *) &mpu401_midi_operations[m], (char *) &mpu401_midi_proto, sizeof(struct midi_operations)); mpu401_midi_operations[m].converter = mpu401_synth_operations[m]; memcpy((char *) &mpu_synth_info[m], (char *) &mpu_synth_info_proto, sizeof(struct synth_info)); n_mpu_devs++; if (devc->version == 0x20 && devc->revision >= 0x07) /* MusicQuest interface */ { int ports = (devc->revision & 0x08) ? 32 : 16; devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE | MPU_CAP_CLS | MPU_CAP_2PORT; revision_char = (devc->revision == 0x7f) ? 'M' : ' '; sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d", ports, revision_char, n_mpu_devs); } else { revision_char = devc->revision ? devc->revision + '@' : ' '; if ((int) devc->revision > ('Z' - '@')) revision_char = '+'; devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK; if (hw_config->name) sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name); else sprintf(mpu_synth_info[m].name, "MPU-401 %d.%d%c MIDI #%d", (int) (devc->version & 0xf0) >> 4, devc->version & 0x0f, revision_char, n_mpu_devs); } strcpy(mpu401_midi_operations[m].info.name, mpu_synth_info[m].name); conf_printf(mpu_synth_info[m].name, hw_config); mpu401_synth_operations[m]->midi_dev = devc->devno = m; mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno]; if (devc->capabilities & MPU_CAP_INTLG) /* Intelligent mode */ hw_config->slots[2] = mpu_timer_init(m); midi_devs[m] = &mpu401_midi_operations[devc->devno]; if (owner) midi_devs[m]->owner = owner; hw_config->slots[1] = m; sequencer_init(); return 0; out_irq: free_irq(devc->irq, hw_config); out_mididev: sound_unload_mididev(m); out_err: release_region(hw_config->io_base, 2); return ret; } static int reset_mpu401(struct mpu_config *devc) { unsigned long flags; int ok, timeout, n; int timeout_limit; /* * Send the RESET command. Try again if no success at the first time. * (If the device is in the UART mode, it will not ack the reset cmd). */ ok = 0; timeout_limit = devc->initialized ? 30000 : 100000; devc->initialized = 1; for (n = 0; n < 2 && !ok; n++) { for (timeout = timeout_limit; timeout > 0 && !ok; timeout--) ok = output_ready(devc); write_command(devc, MPU_RESET); /* * Send MPU-401 RESET Command */ /* * Wait at least 25 msec. This method is not accurate so let's make the * loop bit longer. Cannot sleep since this is called during boot. */ for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--) { spin_lock_irqsave(&devc->lock,flags); if (input_avail(devc)) if (read_data(devc) == MPU_ACK) ok = 1; spin_unlock_irqrestore(&devc->lock,flags); } } devc->m_state = ST_INIT; devc->m_ptr = 0; devc->m_left = 0; devc->last_status = 0; devc->uart_mode = 0; return ok; } static void set_uart_mode(int dev, struct mpu_config *devc, int arg) { if (!arg && (devc->capabilities & MPU_CAP_INTLG)) return; if ((devc->uart_mode == 0) == (arg == 0)) return; /* Already set */ reset_mpu401(devc); /* This exits the uart mode */ if (arg) { if (mpu_cmd(dev, UART_MODE_ON, 0) < 0) { printk(KERN_ERR "mpu401: Can't enter UART mode\n"); devc->uart_mode = 0; return; } } devc->uart_mode = arg; } int probe_mpu401(struct address_info *hw_config, struct resource *ports) { int ok = 0; struct mpu_config tmp_devc; tmp_devc.base = hw_config->io_base; tmp_devc.irq = hw_config->irq; tmp_devc.initialized = 0; tmp_devc.opened = 0; tmp_devc.osp = hw_config->osp; if (hw_config->always_detect) return 1; if (inb(hw_config->io_base + 1) == 0xff) { DDB(printk("MPU401: Port %x looks dead.\n", hw_config->io_base)); return 0; /* Just bus float? */ } ok = reset_mpu401(&tmp_devc); if (!ok) { DDB(printk("MPU401: Reset failed on port %x\n", hw_config->io_base)); } return ok; } void unload_mpu401(struct address_info *hw_config) { void *p; int n=hw_config->slots[1]; if (n != -1) { release_region(hw_config->io_base, 2); if (hw_config->always_detect == 0 && hw_config->irq > 0) free_irq(hw_config->irq, hw_config); p=mpu401_synth_operations[n]; sound_unload_mididev(n); sound_unload_timerdev(hw_config->slots[2]); kfree(p); } } /***************************************************** * Timer stuff ****************************************************/ static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0; static volatile int curr_tempo, curr_timebase, hw_timebase; static int max_timebase = 8; /* 8*24=192 ppqn */ static volatile unsigned long next_event_time; static volatile unsigned long curr_ticks, curr_clocks; static unsigned long prev_event_time; static int metronome_mode; static unsigned long clocks2ticks(unsigned long clocks) { /* * The MPU-401 supports just a limited set of possible timebase values. * Since the applications require more choices, the driver has to * program the HW to do its best and to convert between the HW and * actual timebases. */ return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase; } static void set_timebase(int midi_dev, int val) { int hw_val; if (val < 48) val = 48; if (val > 1000) val = 1000; hw_val = val; hw_val = (hw_val + 12) / 24; if (hw_val > max_timebase) hw_val = max_timebase; if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0) { printk(KERN_WARNING "mpu401: Can't set HW timebase to %d\n", hw_val * 24); return; } hw_timebase = hw_val * 24; curr_timebase = val; } static void tmr_reset(struct mpu_config *devc) { unsigned long flags; spin_lock_irqsave(&devc->lock,flags); next_event_time = (unsigned long) -1; prev_event_time = 0; curr_ticks = curr_clocks = 0; spin_unlock_irqrestore(&devc->lock,flags); } static void set_timer_mode(int midi_dev) { if (timer_mode & TMR_MODE_CLS) mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */ else if (timer_mode & TMR_MODE_SMPTE) mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */ if (timer_mode & TMR_INTERNAL) { mpu_cmd(midi_dev, 0x80, 0); /* Use MIDI sync */ } else { if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS)) { mpu_cmd(midi_dev, 0x82, 0); /* Use MIDI sync */ mpu_cmd(midi_dev, 0x91, 0); /* Enable ext MIDI ctrl */ } else if (timer_mode & TMR_MODE_FSK) mpu_cmd(midi_dev, 0x81, 0); /* Use FSK sync */ } } static void stop_metronome(int midi_dev) { mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */ } static void setup_metronome(int midi_dev) { int numerator, denominator; int clks_per_click, num_32nds_per_beat; int beats_per_measure; numerator = ((unsigned) metronome_mode >> 24) & 0xff; denominator = ((unsigned) metronome_mode >> 16) & 0xff; clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff; num_32nds_per_beat = (unsigned) metronome_mode & 0xff; beats_per_measure = (numerator * 4) >> denominator; if (!metronome_mode) mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */ else { mpu_cmd(midi_dev, 0xE4, clks_per_click); mpu_cmd(midi_dev, 0xE6, beats_per_measure); mpu_cmd(midi_dev, 0x83, 0); /* Enable metronome without accents */ } } static int mpu_start_timer(int midi_dev) { struct mpu_config *devc= &dev_conf[midi_dev]; tmr_reset(devc); set_timer_mode(midi_dev); if (tmr_running) return TIMER_NOT_ARMED; /* Already running */ if (timer_mode & TMR_INTERNAL) { mpu_cmd(midi_dev, 0x02, 0); /* Send MIDI start */ tmr_running = 1; return TIMER_NOT_ARMED; } else { mpu_cmd(midi_dev, 0x35, 0); /* Enable mode messages to PC */ mpu_cmd(midi_dev, 0x38, 0); /* Enable sys common messages to PC */ mpu_cmd(midi_dev, 0x39, 0); /* Enable real time messages to PC */ mpu_cmd(midi_dev, 0x97, 0); /* Enable system exclusive messages to PC */ } return TIMER_ARMED; } static int mpu_timer_open(int dev, int mode) { int midi_dev = sound_timer_devs[dev]->devlink; struct mpu_config *devc= &dev_conf[midi_dev]; if (timer_open) return -EBUSY; tmr_reset(devc); curr_tempo = 50; mpu_cmd(midi_dev, 0xE0, 50); curr_timebase = hw_timebase = 120; set_timebase(midi_dev, 120); timer_open = 1; metronome_mode = 0; set_timer_mode(midi_dev); mpu_cmd(midi_dev, 0xe7, 0x04); /* Send all clocks to host */ mpu_cmd(midi_dev, 0x95, 0); /* Enable clock to host */ return 0; } static void mpu_timer_close(int dev) { int midi_dev = sound_timer_devs[dev]->devlink; timer_open = tmr_running = 0; mpu_cmd(midi_dev, 0x15, 0); /* Stop all */ mpu_cmd(midi_dev, 0x94, 0); /* Disable clock to host */ mpu_cmd(midi_dev, 0x8c, 0); /* Disable measure end messages to host */ stop_metronome(midi_dev); } static int mpu_timer_event(int dev, unsigned char *event) { unsigned char command = event[1]; unsigned long parm = *(unsigned int *) &event[4]; int midi_dev = sound_timer_devs[dev]->devlink; switch (command) { case TMR_WAIT_REL: parm += prev_event_time; case TMR_WAIT_ABS: if (parm > 0) { long time; if (parm <= curr_ticks) /* It's the time */ return TIMER_NOT_ARMED; time = parm; next_event_time = prev_event_time = time; return TIMER_ARMED; } break; case TMR_START: if (tmr_running) break; return mpu_start_timer(midi_dev); case TMR_STOP: mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */ stop_metronome(midi_dev); tmr_running = 0; break; case TMR_CONTINUE: if (tmr_running) break; mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */ setup_metronome(midi_dev); tmr_running = 1; break; case TMR_TEMPO: if (parm) { if (parm < 8) parm = 8; if (parm > 250) parm = 250; if (mpu_cmd(midi_dev, 0xE0, parm) < 0) printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) parm); curr_tempo = parm; } break; case TMR_ECHO: seq_copy_to_input(event, 8); break; case TMR_TIMESIG: if (metronome_mode) /* Metronome enabled */ { metronome_mode = parm; setup_metronome(midi_dev); } break; default:; } return TIMER_NOT_ARMED; } static unsigned long mpu_timer_get_time(int dev) { if (!timer_open) return 0; return curr_ticks; } static int mpu_timer_ioctl(int dev, unsigned int command, void __user *arg) { int midi_dev = sound_timer_devs[dev]->devlink; int __user *p = (int __user *)arg; switch (command) { case SNDCTL_TMR_SOURCE: { int parm; if (get_user(parm, p)) return -EFAULT; parm &= timer_caps; if (parm != 0) { timer_mode = parm; if (timer_mode & TMR_MODE_CLS) mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */ else if (timer_mode & TMR_MODE_SMPTE) mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */ } if (put_user(timer_mode, p)) return -EFAULT; return timer_mode; } break; case SNDCTL_TMR_START: mpu_start_timer(midi_dev); return 0; case SNDCTL_TMR_STOP: tmr_running = 0; mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */ stop_metronome(midi_dev); return 0; case SNDCTL_TMR_CONTINUE: if (tmr_running) return 0; tmr_running = 1; mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */ return 0; case SNDCTL_TMR_TIMEBASE: { int val; if (get_user(val, p)) return -EFAULT; if (val) set_timebase(midi_dev, val); if (put_user(curr_timebase, p)) return -EFAULT; return curr_timebase; } break; case SNDCTL_TMR_TEMPO: { int val; int ret; if (get_user(val, p)) return -EFAULT; if (val) { if (val < 8) val = 8; if (val > 250) val = 250; if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0) { printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) val); return ret; } curr_tempo = val; } if (put_user(curr_tempo, p)) return -EFAULT; return curr_tempo; } break; case SNDCTL_SEQ_CTRLRATE: { int val; if (get_user(val, p)) return -EFAULT; if (val != 0) /* Can't change */ return -EINVAL; val = ((curr_tempo * curr_timebase) + 30)/60; if (put_user(val, p)) return -EFAULT; return val; } break; case SNDCTL_SEQ_GETTIME: if (put_user(curr_ticks, p)) return -EFAULT; return curr_ticks; case SNDCTL_TMR_METRONOME: if (get_user(metronome_mode, p)) return -EFAULT; setup_metronome(midi_dev); return 0; default:; } return -EINVAL; } static void mpu_timer_arm(int dev, long time) { if (time < 0) time = curr_ticks + 1; else if (time <= curr_ticks) /* It's the time */ return; next_event_time = prev_event_time = time; return; } static struct sound_timer_operations mpu_timer = { .owner = THIS_MODULE, .info = {"MPU-401 Timer", 0}, .priority = 10, /* Priority */ .devlink = 0, /* Local device link */ .open = mpu_timer_open, .close = mpu_timer_close, .event = mpu_timer_event, .get_time = mpu_timer_get_time, .ioctl = mpu_timer_ioctl, .arm_timer = mpu_timer_arm }; static void mpu_timer_interrupt(void) { if (!timer_open) return; if (!tmr_running) return; curr_clocks++; curr_ticks = clocks2ticks(curr_clocks); if (curr_ticks >= next_event_time) { next_event_time = (unsigned long) -1; sequencer_timer(0); } } static void timer_ext_event(struct mpu_config *devc, int event, int parm) { int midi_dev = devc->devno; if (!devc->timer_flag) return; switch (event) { case TMR_CLOCK: printk("<MIDI clk>"); break; case TMR_START: printk("Ext MIDI start\n"); if (!tmr_running) { if (timer_mode & TMR_EXTERNAL) { tmr_running = 1; setup_metronome(midi_dev); next_event_time = 0; STORE(SEQ_START_TIMER()); } } break; case TMR_STOP: printk("Ext MIDI stop\n"); if (timer_mode & TMR_EXTERNAL) { tmr_running = 0; stop_metronome(midi_dev); STORE(SEQ_STOP_TIMER()); } break; case TMR_CONTINUE: printk("Ext MIDI continue\n"); if (timer_mode & TMR_EXTERNAL) { tmr_running = 1; setup_metronome(midi_dev); STORE(SEQ_CONTINUE_TIMER()); } break; case TMR_SPP: printk("Songpos: %d\n", parm); if (timer_mode & TMR_EXTERNAL) { STORE(SEQ_SONGPOS(parm)); } break; } } static int mpu_timer_init(int midi_dev) { struct mpu_config *devc; int n; devc = &dev_conf[midi_dev]; if (timer_initialized) return -1; /* There is already a similar timer */ timer_initialized = 1; mpu_timer.devlink = midi_dev; dev_conf[midi_dev].timer_flag = 1; n = sound_alloc_timerdev(); if (n == -1) n = 0; sound_timer_devs[n] = &mpu_timer; if (devc->version < 0x20) /* Original MPU-401 */ timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI; else { /* * The version number 2.0 is used (at least) by the * MusicQuest cards and the Roland Super-MPU. * * MusicQuest has given a special meaning to the bits of the * revision number. The Super-MPU returns 0. */ if (devc->revision) timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI; if (devc->revision & 0x02) timer_caps |= TMR_MODE_CLS; if (devc->revision & 0x40) max_timebase = 10; /* Has the 216 and 240 ppqn modes */ } timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps; return n; } EXPORT_SYMBOL(probe_mpu401); EXPORT_SYMBOL(attach_mpu401); EXPORT_SYMBOL(unload_mpu401); static struct address_info cfg; static int io = -1; static int irq = -1; module_param(irq, int, 0); module_param(io, int, 0); static int __init init_mpu401(void) { int ret; /* Can be loaded either for module use or to provide functions to others */ if (io != -1 && irq != -1) { struct resource *ports; cfg.irq = irq; cfg.io_base = io; ports = request_region(io, 2, "mpu401"); if (!ports) return -EBUSY; if (probe_mpu401(&cfg, ports) == 0) { release_region(io, 2); return -ENODEV; } if ((ret = attach_mpu401(&cfg, THIS_MODULE))) return ret; } return 0; } static void __exit cleanup_mpu401(void) { if (io != -1 && irq != -1) { /* Check for use by, for example, sscape driver */ unload_mpu401(&cfg); } } module_init(init_mpu401); module_exit(cleanup_mpu401); #ifndef MODULE static int __init setup_mpu401(char *str) { /* io, irq */ int ints[3]; str = get_options(str, ARRAY_SIZE(ints), ints); io = ints[1]; irq = ints[2]; return 1; } __setup("mpu401=", setup_mpu401); #endif MODULE_LICENSE("GPL");


context:
space:
mode: