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

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

Linux/Unix编程

开发平台：

Unix_Linux

forte.c：源码内容
  1. /*
  2.  * forte.c - ForteMedia FM801 OSS Driver
  3.  *
  4.  * Written by Martin K. Petersen <mkp@mkp.net>
  5.  * Copyright (C) 2002 Hewlett-Packard Company
  6.  *
  7.  * Based upon the ALSA FM801 driver by Jaroslav Kysela and OSS drivers
  8.  * by Thomas Sailer, Alan Cox, Zach Brown, and Jeff Garzik.  Thanks
  9.  * guys!
  10.  *
  11.  * This program is free software; you can redistribute it and/or
  12.  * modify it under the terms of the GNU General Public License version
  13.  * 2 as published by the Free Software Foundation.
  14.  *
  15.  * This program is distributed in the hope that it will be useful, but
  16.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18.  * General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  23.  * USA
  24.  *
  25.  */
  26.  
  27. /*
  28.  * TODO:
  29.  * MMIO
  30.  * Multichannelize
  31.  * Multichipify
  32.  * MPU401
  33.  * M^Gameport
  34.  */
  36. #include <linux/config.h>
  37. #include <linux/module.h>
  38. #include <linux/kernel.h>
  40. #include <linux/init.h>
  41. #include <linux/spinlock.h>
  42. #include <linux/pci.h>
  44. #include <linux/delay.h>
  45. #include <linux/poll.h>
  46. #include <linux/kernel.h>
  48. #include <linux/sound.h>
  49. #include <linux/ac97_codec.h>
  50. #include <linux/wrapper.h>
  52. #include <linux/proc_fs.h>
  54. #include <asm/uaccess.h>
  55. #include <asm/hardirq.h>
  57. #define DRIVER_NAME "forte"
  58. #define DRIVER_VERSION  "$Id: forte.c,v 1.55 2002/10/02 00:01:42 mkp Exp $"
  59. #define PFX  DRIVER_NAME ": "
  61. #undef M_DEBUG
  63. #ifdef M_DEBUG
  64. #define DPRINTK(args...) printk(KERN_WARNING args)
  65. #else
  66. #define DPRINTK(args...)
  67. #endif
  69. /* Card capabilities */
  70. #define FORTE_CAPS              (DSP_CAP_MMAP | DSP_CAP_TRIGGER)
  72. /* Supported audio formats */
  73. #define FORTE_FMTS (AFMT_U8 | AFMT_S16_LE)
  75. /* Buffers */
  76. #define FORTE_MIN_FRAG_SIZE     256
  77. #define FORTE_MAX_FRAG_SIZE     PAGE_SIZE
  78. #define FORTE_DEF_FRAG_SIZE     256
  79. #define FORTE_MIN_FRAGMENTS     16
  80. #define FORTE_MAX_FRAGMENTS     256
  81. #define FORTE_DEF_FRAGMENTS     16
  82. #define FORTE_MIN_BUF           16386
  84. /* PCI BARs */
  85. #define FORTE_PCM_VOL           0x00    /* PCM Output Volume */
  86. #define FORTE_FM_VOL            0x02    /* FM Output Volume */
  87. #define FORTE_I2S_VOL           0x04    /* I2S Volume */
  88. #define FORTE_REC_SRC           0x06    /* Record Source */
  89. #define FORTE_PLY_CTRL          0x08    /* Playback Control */
  90. #define FORTE_PLY_COUNT         0x0a    /* Playback Count */
  91. #define FORTE_PLY_BUF1          0x0c    /* Playback Buffer I */
  92. #define FORTE_PLY_BUF2          0x10    /* Playback Buffer II */
  93. #define FORTE_CAP_CTRL          0x14    /* Capture Control */
  94. #define FORTE_CAP_COUNT         0x16    /* Capture Count */
  95. #define FORTE_CAP_BUF1          0x18    /* Capture Buffer I */
  96. #define FORTE_CAP_BUF2          0x1c    /* Capture Buffer II */
  97. #define FORTE_CODEC_CTRL        0x22    /* Codec Control */
  98. #define FORTE_I2S_MODE          0x24    /* I2S Mode Control */
  99. #define FORTE_VOLUME            0x26    /* Volume Up/Down/Mute Status */
  100. #define FORTE_I2C_CTRL          0x29    /* I2C Control */
  101. #define FORTE_AC97_CMD          0x2a    /* AC'97 Command */
  102. #define FORTE_AC97_DATA         0x2c    /* AC'97 Data */
  103. #define FORTE_MPU401_DATA       0x30    /* MPU401 Data */
  104. #define FORTE_MPU401_CMD        0x31    /* MPU401 Command */
  105. #define FORTE_GPIO_CTRL         0x52    /* General Purpose I/O Control */
  106. #define FORTE_GEN_CTRL          0x54    /* General Control */
  107. #define FORTE_IRQ_MASK          0x56    /* Interrupt Mask */
  108. #define FORTE_IRQ_STATUS        0x5a    /* Interrupt Status */
  109. #define FORTE_OPL3_BANK0        0x68    /* OPL3 Status Read / Bank 0 Write */
  110. #define FORTE_OPL3_DATA0        0x69    /* OPL3 Data 0 Write */
  111. #define FORTE_OPL3_BANK1        0x6a    /* OPL3 Bank 1 Write */
  112. #define FORTE_OPL3_DATA1        0x6b    /* OPL3 Bank 1 Write */
  113. #define FORTE_POWERDOWN         0x70    /* Blocks Power Down Control */
  115. #define FORTE_CAP_OFFSET        FORTE_CAP_CTRL - FORTE_PLY_CTRL
  117. #define FORTE_AC97_ADDR_SHIFT   10
  119. /* Playback and record control register bits */
  120. #define FORTE_BUF1_LAST         (1<<1)
  121. #define FORTE_BUF2_LAST         (1<<2)
  122. #define FORTE_START             (1<<5)
  123. #define FORTE_PAUSE             (1<<6)
  124. #define FORTE_IMMED_STOP        (1<<7)
  125. #define FORTE_RATE_SHIFT        8
  126. #define FORTE_RATE_MASK         (15 << FORTE_RATE_SHIFT)
  127. #define FORTE_CHANNELS_4        (1<<12) /* Playback only */
  128. #define FORTE_CHANNELS_6        (2<<12) /* Playback only */
  129. #define FORTE_CHANNELS_6MS      (3<<12) /* Playback only */
  130. #define FORTE_CHANNELS_MASK     (3<<12)
  131. #define FORTE_16BIT             (1<<14)
  132. #define FORTE_STEREO            (1<<15)
  134. /* IRQ status bits */
  135. #define FORTE_IRQ_PLAYBACK      (1<<8)
  136. #define FORTE_IRQ_CAPTURE       (1<<9)
  137. #define FORTE_IRQ_VOLUME        (1<<14)
  138. #define FORTE_IRQ_MPU           (1<<15)
  140. /* CODEC control */
  141. #define FORTE_CC_CODEC_RESET    (1<<5)
  142. #define FORTE_CC_AC97_RESET     (1<<6)
  144. /* AC97 cmd */
  145. #define FORTE_AC97_WRITE        (0<<7)
  146. #define FORTE_AC97_READ         (1<<7)
  147. #define FORTE_AC97_DP_INVALID   (0<<8)
  148. #define FORTE_AC97_DP_VALID     (1<<8)
  149. #define FORTE_AC97_PORT_RDY     (0<<9)
  150. #define FORTE_AC97_PORT_BSY     (1<<9)
  153. struct forte_channel {
  154.         const char  *name;
  156. unsigned short ctrl;  /* Ctrl BAR contents */
  157. unsigned long  iobase; /* Ctrl BAR address */
  159. wait_queue_head_t wait;
  161. void  *buf;  /* Buffer */
  162. dma_addr_t buf_handle;  /* Buffer handle */
  164.         unsigned int  record;
  165. unsigned int format;
  166.         unsigned int rate;
  167. unsigned int stereo;
  169. unsigned int frag_sz;  /* Current fragment size */
  170. unsigned int frag_num;  /* Current # of fragments */
  171. unsigned int buf_sz; /* Current buffer size */
  173. unsigned int hwptr; /* Tail */
  174. unsigned int swptr;  /* Head */
  175. unsigned int filled_frags;  /* Fragments currently full */
  176. unsigned int next_buf; /* Index of next buffer */
  178. unsigned int blocked; /* Blocked on I/O */
  179. unsigned int drain; /* Drain queued buffers */
  180. unsigned int active; /* Channel currently in use */
  181. unsigned int mapped; /* mmap */
  183. unsigned int buf_pages; /* Real size of buffer */
  184. unsigned int nr_irqs; /* Number of interrupts */
  185. unsigned int bytes; /* Total bytes */
  186. };
  189. struct forte_chip {
  190. struct pci_dev *pci_dev;
  191. unsigned long iobase;
  192. int irq;
  194. struct semaphore open_sem;  /* Device access */
  195. spinlock_t lock; /* State */
  197. spinlock_t ac97_lock;
  198. struct ac97_codec *ac97;
  200. int multichannel;
  201. int dsp;  /* OSS handle */
  202. int                     trigger; /* mmap I/O trigger */
  204. struct forte_channel play;
  205. struct forte_channel rec;
  206. };
  209. static int channels[] = { 2, 4, 6, };
  210. static int rates[]    = { 5500, 8000, 9600, 11025, 16000, 19200, 
  211.   22050, 32000, 38400, 44100, 48000, };
  213. static struct forte_chip *forte;
  214. static int found;
  217. /* AC97 Codec -------------------------------------------------------------- */
  220. /** 
  221.  * forte_ac97_wait:
  222.  * @chip: fm801 instance whose AC97 codec to wait on
  223.  *
  224.  * FIXME:
  225.  * Stop busy-waiting
  226.  */
  228. static inline int
  229. forte_ac97_wait (struct forte_chip *chip)
  230. {
  231. int i = 10000;
  233. while ( (inw (chip->iobase + FORTE_AC97_CMD) & FORTE_AC97_PORT_BSY) 
  234. && i-- )
  235. cpu_relax();
  237. return i == 0;
  238. }
  241. /**
  242.  * forte_ac97_read:
  243.  * @codec: AC97 codec to read from
  244.  * @reg: register to read
  245.  */
  247. u16
  248. forte_ac97_read (struct ac97_codec *codec, u8 reg)
  249. {
  250. u16 ret = 0;
  251. struct forte_chip *chip = codec->private_data;
  253. spin_lock (&chip->ac97_lock);
  255. /* Knock, knock */
  256. if (forte_ac97_wait (chip)) {
  257. printk (KERN_ERR PFX "ac97_read: Serial bus busyn");
  258. goto out;
  259. }
  261. /* Send read command */
  262. outw (reg | (1<<7), chip->iobase + FORTE_AC97_CMD);
  264. if (forte_ac97_wait (chip)) {
  265. printk (KERN_ERR PFX "ac97_read: Bus busy reading reg 0x%xn",
  266. reg);
  267. goto out;
  268. }
  270. /* Sanity checking */
  271. if (inw (chip->iobase + FORTE_AC97_CMD) & FORTE_AC97_DP_INVALID) {
  272. printk (KERN_ERR PFX "ac97_read: Invalid data port");
  273. goto out;
  274. }
  276. /* Fetch result */
  277. ret = inw (chip->iobase + FORTE_AC97_DATA);
  279.  out:
  280. spin_unlock (&chip->ac97_lock);
  281. return ret;
  282. }
  285. /**
  286.  * forte_ac97_write:
  287.  * @codec: AC97 codec to send command to
  288.  * @reg: register to write
  289.  * @val: value to write
  290.  */
  292. void
  293. forte_ac97_write (struct ac97_codec *codec, u8 reg, u16 val)
  294. {
  295. struct forte_chip *chip = codec->private_data;
  297. spin_lock (&chip->ac97_lock);
  299. /* Knock, knock */
  300. if (forte_ac97_wait (chip)) {
  301. printk (KERN_ERR PFX "ac97_write: Serial bus busyn");
  302. goto out;
  303. }
  305. outw (val, chip->iobase + FORTE_AC97_DATA);
  306. outb (reg | FORTE_AC97_WRITE, chip->iobase + FORTE_AC97_CMD);
  308. /* Wait for completion */
  309. if (forte_ac97_wait (chip)) {
  310. printk (KERN_ERR PFX "ac97_write: Bus busy after writen");
  311. goto out;
  312. }
  314.  out:
  315. spin_unlock (&chip->ac97_lock);
  316. }
  319. /* Mixer ------------------------------------------------------------------- */
  322. /**
  323.  * forte_mixer_open:
  324.  * @inode:
  325.  * @file:
  326.  */
  328. static int
  329. forte_mixer_open (struct inode *inode, struct file *file)
  330. {
  331. struct forte_chip *chip = forte;
  333. MOD_INC_USE_COUNT;
  335. file->private_data = chip->ac97;
  337. return 0;
  338. }
  341. /**
  342.  * forte_mixer_release:
  343.  * @inode:
  344.  * @file:
  345.  */
  347. static int
  348. forte_mixer_release (struct inode *inode, struct file *file)
  349. {
  350. /* We will welease Wodewick */
  351. MOD_DEC_USE_COUNT;
  353. return 0;
  354. }
  357. /**
  358.  * forte_mixer_ioctl:
  359.  * @inode:
  360.  * @file:
  361.  */
  363. static int
  364. forte_mixer_ioctl (struct inode *inode, struct file *file, 
  365.    unsigned int cmd, unsigned long arg)
  366. {
  367. struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
  369. return codec->mixer_ioctl (codec, cmd, arg);
  370. }
  373. static struct file_operations forte_mixer_fops = {
  374. owner:      THIS_MODULE,
  375. llseek:          no_llseek,
  376. ioctl:           forte_mixer_ioctl,
  377. open:            forte_mixer_open,
  378. release:         forte_mixer_release,
  379. };
  382. /* Channel ----------------------------------------------------------------- */
  384. /** 
  385.  * forte_channel_reset:
  386.  * @channel: Channel to reset
  387.  * 
  388.  * Locking: Must be called with lock held.
  389.  */
  391. static void
  392. forte_channel_reset (struct forte_channel *channel)
  393. {
  394. if (!channel || !channel->iobase)
  395. return;
  397. DPRINTK ("%s: channel = %sn", __FUNCTION__, channel->name);
  399. channel->ctrl &= ~FORTE_START;
  400. outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
  402. /* We always play at least two fragments, hence these defaults */
  403.   channel->hwptr = channel->frag_sz;
  404. channel->next_buf = 1;
  405. channel->swptr = 0;
  406. channel->filled_frags = 0;
  407. channel->blocked = 0;
  408. channel->drain = 0;
  409. channel->active = 0;
  410. channel->bytes = 0;
  411. channel->nr_irqs = 0;
  412. channel->mapped = 0;
  413. }
  416. /** 
  417.  * forte_channel_start:
  418.  * @channel:  Channel to start (record/playback)
  419.  *
  420.  * Locking: Must be called with lock held.
  421.  */
  423. static void inline
  424. forte_channel_start (struct forte_channel *channel)
  425. {
  426. if (!channel || !channel->iobase) 
  427. return;
  429. DPRINTK ("%s: channel = %sn", __FUNCTION__, channel->name);
  431. channel->ctrl &= ~(FORTE_PAUSE | FORTE_BUF1_LAST | FORTE_BUF2_LAST);
  432. channel->ctrl |= FORTE_START;
  433. channel->active = 1;
  434. outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
  435. }
  438. /** 
  439.  * forte_channel_stop:
  440.  * @channel:  Channel to stop
  441.  *
  442.  * Locking: Must be called with lock held.
  443.  */
  445. static void inline
  446. forte_channel_stop (struct forte_channel *channel)
  447. {
  448. if (!channel || !channel->iobase) 
  449. return;
  451. DPRINTK ("%s: channel = %sn", __FUNCTION__, channel->name);
  453. channel->ctrl &= ~FORTE_START;
  454. channel->active = 0;
  455. outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
  456. }
  459. /** 
  460.  * forte_channel_rate:
  461.  * @channel:  Channel whose rate to set.  Playback and record are
  462.  *            independent.
  463.  * @rate:     Channel rate in Hz
  464.  *
  465.  * Locking: Must be called with lock held.
  466.  */
  468. static int
  469. forte_channel_rate (struct forte_channel *channel, unsigned int rate)
  470. {
  471. int new_rate;
  473. if (!channel || !channel->iobase) 
  474. return -EINVAL;
  476. /* The FM801 only supports a handful of fixed frequencies.
  477.  * We find the value closest to what userland requested.
  478.  */
  479. if      (rate <= 6250)  { rate = 5500;  new_rate =  0; }
  480. else if (rate <= 8800)  { rate = 8000;  new_rate =  1; }
  481. else if (rate <= 10312) { rate = 9600;  new_rate =  2; }
  482. else if (rate <= 13512) { rate = 11025; new_rate =  3; }
  483. else if (rate <= 17600) { rate = 16000; new_rate =  4; }
  484. else if (rate <= 20625) { rate = 19200; new_rate =  5; }
  485. else if (rate <= 27025) { rate = 22050; new_rate =  6; }
  486. else if (rate <= 35200) { rate = 32000; new_rate =  7; }
  487. else if (rate <= 41250) { rate = 38400; new_rate =  8; }
  488. else if (rate <= 46050) { rate = 44100; new_rate =  9; }
  489. else                    { rate = 48000; new_rate = 10; }
  491. channel->ctrl &= ~FORTE_RATE_MASK;
  492. channel->ctrl |= new_rate << FORTE_RATE_SHIFT;
  493. channel->rate = rate;
  495. DPRINTK ("%s: %s rate = %dn", __FUNCTION__, channel->name, rate);
  497. return rate;
  498. }
  501. /** 
  502.  * forte_channel_format:
  503.  * @channel:  Channel whose audio format to set
  504.  * @format:   OSS format ID
  505.  *
  506.  * Locking: Must be called with lock held.
  507.  */
  509. static int
  510. forte_channel_format (struct forte_channel *channel, int format)
  511. {
  512. if (!channel || !channel->iobase) 
  513. return -EINVAL;
  515. switch (format) {
  517. case AFMT_QUERY:
  518. break;
  520. case AFMT_U8:
  521. channel->ctrl &= ~FORTE_16BIT;
  522. channel->format = AFMT_U8;
  523. break;
  525. case AFMT_S16_LE:
  526. default:
  527. channel->ctrl |= FORTE_16BIT;
  528. channel->format = AFMT_S16_LE;
  529. break;
  530. }
  532. DPRINTK ("%s: %s want %d format, got %dn", __FUNCTION__, channel->name, 
  533.  format, channel->format);
  535. return channel->format;
  536. }
  539. /** 
  540.  * forte_channel_stereo:
  541.  * @channel:  Channel to toggle
  542.  * @stereo:   0 for Mono, 1 for Stereo
  543.  *
  544.  * Locking: Must be called with lock held.
  545.  */
  547. static int
  548. forte_channel_stereo (struct forte_channel *channel, unsigned int stereo)
  549. {
  550. int ret;
  552. if (!channel || !channel->iobase)
  553. return -EINVAL;
  555. DPRINTK ("%s: %s stereo = %dn", __FUNCTION__, channel->name, stereo);
  557. switch (stereo) {
  559. case 0:
  560. channel->ctrl &= ~(FORTE_STEREO | FORTE_CHANNELS_MASK);
  561. channel-> stereo = stereo;
  562. ret = stereo;
  563. break;
  565. case 1:
  566. channel->ctrl &= ~FORTE_CHANNELS_MASK;
  567. channel->ctrl |= FORTE_STEREO;
  568. channel-> stereo = stereo;
  569. ret = stereo;
  570. break;
  572. default:
  573. DPRINTK ("Unsupported channel format");
  574. ret = -EINVAL;
  575. break;
  576. }
  578. return ret;
  579. }
  582. /** 
  583.  * forte_channel_buffer:
  584.  * @channel: Channel whose buffer to set up
  585.  *
  586.  * Locking: Must be called with lock held.
  587.  *
  588.  * FIXME: Buffer scaling dependent on rate/channels/bits
  589.  */
  591. static void
  592. forte_channel_buffer (struct forte_channel *channel, int sz, int num)
  593. {
  594. /* Go away, I'm busy */
  595. if (channel->filled_frags || channel->bytes)
  596. return;
  598. channel->frag_sz = sz;
  599. channel->frag_num = num;
  601. if (channel->frag_sz < FORTE_MIN_FRAG_SIZE)
  602. channel->frag_sz = FORTE_MIN_FRAG_SIZE;
  604. if (channel->frag_sz > FORTE_MAX_FRAG_SIZE)
  605. channel->frag_sz = FORTE_MAX_FRAG_SIZE;
  607. if (channel->frag_num < FORTE_MIN_FRAGMENTS)
  608. channel->frag_num = FORTE_MIN_FRAGMENTS;
  610. if (channel->frag_num > FORTE_MAX_FRAGMENTS)
  611. channel->frag_num = FORTE_MAX_FRAGMENTS;
  613. if (channel->frag_sz * channel->frag_num < FORTE_MIN_BUF)
  614. channel->frag_num = FORTE_MIN_BUF / channel->frag_sz;
  616. channel->buf_sz = channel->frag_sz * channel->frag_num;
  618. DPRINTK ("%s: %s frag_sz = %d, frag_num = %d, buf_sz = %dn", 
  619.  __FUNCTION__, channel->name, channel->frag_sz, 
  620.  channel->frag_num, channel->buf_sz);
  621. }
  624. /** 
  625.  * forte_channel_prep:
  626.  * @channel: Channel whose buffer to prepare
  627.  *
  628.  * Locking: Lock held.
  629.  */
  631. static void
  632. forte_channel_prep (struct forte_channel *channel)
  633. {
  634. struct page *page;
  635. int i;
  637. if (channel->buf)
  638. return;
  640. channel->buf_pages = channel->buf_sz >> PAGE_SHIFT;
  642. if (channel->buf_sz % PAGE_SIZE)
  643. channel->buf_pages++;
  645. DPRINTK ("%s: %s frag_sz = %d, frag_num = %d, buf_sz = %d, pg = %dn", 
  646.  __FUNCTION__, channel->name, channel->frag_sz, 
  647.  channel->frag_num, channel->buf_sz, channel->buf_pages);
  649. /* DMA buffer */
  650. channel->buf = pci_alloc_consistent (forte->pci_dev, 
  651.      channel->buf_pages * PAGE_SIZE,
  652.      &channel->buf_handle);
  654. if (!channel->buf || !channel->buf_handle)
  655. BUG();
  657. page = virt_to_page (channel->buf);
  659. for (i = 0 ; i < channel->buf_pages ; i++)
  660. mem_map_reserve (page++);
  662. /* Prep buffer registers */
  663. outw (channel->frag_sz - 1, channel->iobase + FORTE_PLY_COUNT);
  664. outl (channel->buf_handle, channel->iobase + FORTE_PLY_BUF1);
  665. outl (channel->buf_handle + channel->frag_sz, 
  666.       channel->iobase + FORTE_PLY_BUF2);
  668. /* Reset hwptr */
  669.   channel->hwptr = channel->frag_sz;
  670. channel->next_buf = 1;
  672. DPRINTK ("%s: %s buffer @ %p (%p)n", __FUNCTION__, channel->name, 
  673.  channel->buf, channel->buf_handle);
  674. }
  677. /** 
  678.  * forte_channel_drain:
  679.  * @chip:
  680.  * @channel:
  681.  *
  682.  * Locking: Don't hold the lock.
  683.  */
  685. static inline int
  686. forte_channel_drain (struct forte_channel *channel)
  687. {
  688. DECLARE_WAITQUEUE (wait, current);
  689. unsigned long flags;
  691. if (!channel->active)
  692. return 0;
  694. if (channel->mapped) {
  695. spin_lock_irqsave (&forte->lock, flags);
  696. forte_channel_stop (channel);
  697. spin_unlock_irqrestore (&forte->lock, flags);
  698. return 0;
  699. }
  701. channel->drain = 1;
  702. add_wait_queue (&channel->wait, &wait);
  704. for (;;) {
  705. spin_lock_irqsave (&forte->lock, flags);
  707. if (channel->active == 0 || channel->filled_frags < 1)
  708. break;
  710. spin_unlock_irqrestore (&forte->lock, flags);
  711. __set_current_state (TASK_INTERRUPTIBLE);
  712. schedule();
  713. }
  715. channel->drain = 0;
  716. spin_unlock_irqrestore (&forte->lock, flags);
  717. set_current_state (TASK_RUNNING);
  718. remove_wait_queue (&channel->wait, &wait);
  720. return 0;
  721. }
  724. /** 
  725.  * forte_channel_init:
  726.  * @chip:  Forte chip instance the channel hangs off
  727.  * @channel:  Channel to initialize
  728.  *
  729.  * Description:
  730.  *         Initializes a channel, sets defaults, and allocates
  731.  *         buffers.
  732.  *
  733.  * Locking: No lock held.
  734.  */
  736. static int
  737. forte_channel_init (struct forte_chip *chip, struct forte_channel *channel)
  738. {
  739. DPRINTK ("%s: chip iobase @ %pn", __FUNCTION__, (void *)chip->iobase);
  741. spin_lock_irq (&chip->lock);
  742. memset (channel, 0x0, sizeof (*channel));
  744. if (channel == &chip->play) {
  745. channel->name = "PCM_OUT";
  746. channel->iobase = chip->iobase;
  747. DPRINTK ("%s: PCM-OUT iobase @ %pn", __FUNCTION__,
  748.  (void *) channel->iobase);
  749. }
  750. else if (channel == &chip->rec) {
  751. channel->name = "PCM_IN";
  752. channel->iobase = chip->iobase + FORTE_CAP_OFFSET;
  753. channel->record = 1;
  754. DPRINTK ("%s: PCM-IN iobase @ %pn", __FUNCTION__, 
  755.  (void *) channel->iobase);
  756. }
  757. else
  758. BUG();
  760. init_waitqueue_head (&channel->wait);
  762. /* Defaults: 48kHz, 16-bit, stereo */
  763. channel->ctrl = inw (channel->iobase + FORTE_PLY_CTRL);
  764. forte_channel_reset (channel);
  765. forte_channel_stereo (channel, 1);
  766. forte_channel_format (channel, AFMT_S16_LE);
  767. forte_channel_rate (channel, 48000);
  768. forte_channel_buffer (channel, FORTE_DEF_FRAG_SIZE, 
  769.       FORTE_DEF_FRAGMENTS);
  771. chip->trigger = 0;
  772. spin_unlock_irq (&chip->lock);
  774. return 0;
  775. }
  778. /** 
  779.  * forte_channel_free:
  780.  * @chip: Chip this channel hangs off
  781.  * @channel: Channel to nuke 
  782.  *
  783.  * Description:
  784.  *  Resets channel and frees buffers.
  785.  *
  786.  * Locking: Hold your horses.
  787.  */
  789. static void
  790. forte_channel_free (struct forte_chip *chip, struct forte_channel *channel)
  791. {
  792. DPRINTK ("%s: %sn", __FUNCTION__, channel->name);
  794. if (!channel->buf_handle)
  795. return;
  797. pci_free_consistent (chip->pci_dev, channel->buf_pages * PAGE_SIZE, 
  798.      channel->buf, channel->buf_handle);
  800. memset (channel, 0x0, sizeof (*channel));
  801. }
  804. /* DSP --------------------------------------------------------------------- */
  807. /**
  808.  * forte_dsp_ioctl:
  809.  */
  811. static int
  812. forte_dsp_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
  813.  unsigned long arg)
  814. {
  815. int ival=0, ret, rval=0, rd, wr, count;
  816. struct forte_chip *chip;
  817. struct audio_buf_info abi;
  818. struct count_info cinfo;
  820. chip = file->private_data;
  822. if (file->f_mode & FMODE_WRITE)
  823. wr = 1;
  824. else 
  825. wr = 0;
  827. if (file->f_mode & FMODE_READ)
  828. rd = 1;
  829. else
  830. rd = 0;
  832. switch (cmd) {
  834. case OSS_GETVERSION:
  835. return put_user (SOUND_VERSION, (int *) arg);
  837. case SNDCTL_DSP_GETCAPS:
  838. DPRINTK ("%s: GETCAPSn", __FUNCTION__);
  840. ival = FORTE_CAPS; /* DUPLEX */
  841. return put_user (ival, (int *) arg);
  843. case SNDCTL_DSP_GETFMTS:
  844. DPRINTK ("%s: GETFMTSn", __FUNCTION__);
  846. ival = FORTE_FMTS; /* U8, 16LE */
  847. return put_user (ival, (int *) arg);
  849. case SNDCTL_DSP_SETFMT: /* U8, 16LE */
  850. DPRINTK ("%s: SETFMTn", __FUNCTION__);
  852. if (get_user (ival, (int *) arg))
  853. return -EFAULT;
  855. spin_lock_irq (&chip->lock);
  857. if (rd) {
  858. forte_channel_stop (&chip->rec);
  859. rval = forte_channel_format (&chip->rec, ival);
  860. }
  862. if (wr) {
  863. forte_channel_stop (&chip->rec);
  864. rval = forte_channel_format (&chip->play, ival);
  865. }
  867. spin_unlock_irq (&chip->lock);
  869. return put_user (rval, (int *) arg);
  871. case SNDCTL_DSP_STEREO: /* 0 - mono, 1 - stereo */
  872. DPRINTK ("%s: STEREOn", __FUNCTION__);
  874. if (get_user (ival, (int *) arg))
  875. return -EFAULT;
  877. spin_lock_irq (&chip->lock);
  879. if (rd) {
  880. forte_channel_stop (&chip->rec);
  881. rval = forte_channel_stereo (&chip->rec, ival);
  882. }
  884. if (wr) {
  885. forte_channel_stop (&chip->rec);
  886. rval = forte_channel_stereo (&chip->play, ival);
  887. }
  889. spin_unlock_irq (&chip->lock);
  891.                 return put_user (rval, (int *) arg);
  893. case SNDCTL_DSP_CHANNELS: /* 1 - mono, 2 - stereo */
  894. DPRINTK ("%s: CHANNELSn", __FUNCTION__);
  896. if (get_user (ival, (int *) arg))
  897. return -EFAULT;
  899. spin_lock_irq (&chip->lock);
  901. if (rd) {
  902. forte_channel_stop (&chip->rec);
  903. rval = forte_channel_stereo (&chip->rec, ival-1) + 1;
  904. }
  906. if (wr) {
  907. forte_channel_stop (&chip->play);
  908. rval = forte_channel_stereo (&chip->play, ival-1) + 1;
  909. }
  911. spin_unlock_irq (&chip->lock);
  913.                 return put_user (rval, (int *) arg);
  915. case SNDCTL_DSP_SPEED:
  916. DPRINTK ("%s: SPEEDn", __FUNCTION__);
  918. if (get_user (ival, (int *) arg))
  919.                         return -EFAULT;
  921. spin_lock_irq (&chip->lock);
  923. if (rd) {
  924. forte_channel_stop (&chip->rec);
  925. rval = forte_channel_rate (&chip->rec, ival);
  926. }
  928. if (wr) {
  929. forte_channel_stop (&chip->play);
  930. rval = forte_channel_rate (&chip->play, ival);
  931. }
  933. spin_unlock_irq (&chip->lock);
  935.                 return put_user(rval, (int*) arg);
  937. case SNDCTL_DSP_GETBLKSIZE:
  938. DPRINTK ("%s: GETBLKSIZEn", __FUNCTION__);
  940. spin_lock_irq (&chip->lock);
  942. if (rd)
  943. ival = chip->rec.frag_sz;
  945. if (wr)
  946. ival = chip->play.frag_sz;
  948. spin_unlock_irq (&chip->lock);
  950.                 return put_user (ival, (int *) arg);
  952. case SNDCTL_DSP_RESET:
  953. DPRINTK ("%s: RESETn", __FUNCTION__);
  955. spin_lock_irq (&chip->lock);
  957. if (rd)
  958. forte_channel_reset (&chip->rec);
  960. if (wr)
  961. forte_channel_reset (&chip->play);
  963. spin_unlock_irq (&chip->lock);
  965.                 return 0;
  967. case SNDCTL_DSP_SYNC:
  968. DPRINTK ("%s: SYNCn", __FUNCTION__);
  970. if (wr) {
  971. ret = forte_channel_drain (&chip->play);
  972. spin_lock_irq (&chip->lock);
  973. forte_channel_reset (&chip->play);
  974. spin_unlock_irq (&chip->lock);
  975. }
  977. return 0;
  979. case SNDCTL_DSP_POST:
  980. DPRINTK ("%s: POSTn", __FUNCTION__);
  982. if (wr) {
  983. spin_lock_irq (&chip->lock);
  984. forte_channel_reset (&chip->play);
  985. spin_unlock_irq (&chip->lock);
  986. }
  988.                 return 0;
  990. case SNDCTL_DSP_SETFRAGMENT:
  991. DPRINTK ("%s: SETFRAGMENTn", __FUNCTION__);
  993. if (get_user (ival, (int *) arg))
  994. return -EFAULT;
  996. spin_lock_irq (&chip->lock);
  998. if (rd) {
  999. forte_channel_buffer (&chip->rec, ival & 0xffff, 
  1000.       (ival >> 16) & 0xffff);
  1001. ival = (chip->rec.frag_num << 16) + chip->rec.frag_sz;
  1002. }
  1004. if (wr) {
  1005. forte_channel_buffer (&chip->play, ival & 0xffff, 
  1006.       (ival >> 16) & 0xffff);
  1007. ival = (chip->play.frag_num << 16) +chip->play.frag_sz;
  1008. }
  1010. spin_unlock_irq (&chip->lock);
  1012. return put_user (ival, (int *) arg);
  1013.                 
  1014.         case SNDCTL_DSP_GETISPACE:
  1015. DPRINTK ("%s: GETISPACEn", __FUNCTION__);
  1017. if (!rd)
  1018. return -EINVAL;
  1020. spin_lock_irq (&chip->lock);
  1022. abi.fragstotal = chip->rec.frag_num;
  1023. abi.fragsize = chip->rec.frag_sz;
  1025. if (chip->rec.mapped) {
  1026. abi.fragments = chip->rec.frag_num - 2;
  1027. abi.bytes = abi.fragments * abi.fragsize;
  1028. }
  1029. else {
  1030. abi.fragments = chip->rec.filled_frags;
  1031. abi.bytes = abi.fragments * abi.fragsize;
  1032. }
  1034. spin_unlock_irq (&chip->lock);
  1036. return copy_to_user ((void *) arg, &abi, sizeof (abi));
  1038. case SNDCTL_DSP_GETIPTR:
  1039. DPRINTK ("%s: GETIPTRn", __FUNCTION__);
  1041. if (!rd)
  1042. return -EINVAL;
  1044. spin_lock_irq (&chip->lock);
  1046. if (chip->rec.active) 
  1047. cinfo.ptr = chip->rec.hwptr;
  1048. else
  1049. cinfo.ptr = 0;
  1051. cinfo.bytes = chip->rec.bytes;
  1052. cinfo.blocks = chip->rec.nr_irqs;
  1053. chip->rec.nr_irqs = 0;
  1055. spin_unlock_irq (&chip->lock);
  1057. return copy_to_user ((void *) arg, &cinfo, sizeof (cinfo));
  1059.         case SNDCTL_DSP_GETOSPACE:
  1060. if (!wr)
  1061. return -EINVAL;
  1063. spin_lock_irq (&chip->lock);
  1065. abi.fragstotal = chip->play.frag_num;
  1066. abi.fragsize = chip->play.frag_sz;
  1068. if (chip->play.mapped) {
  1069. abi.fragments = chip->play.frag_num - 2;
  1070. abi.bytes = chip->play.buf_sz;
  1071. }
  1072. else {
  1073. abi.fragments = chip->play.frag_num - 
  1074. chip->play.filled_frags;
  1075. abi.bytes = abi.fragments * abi.fragsize;
  1076. }
  1078. spin_unlock_irq (&chip->lock);
  1080. return copy_to_user ((void *) arg, &abi, sizeof (abi));
  1082. case SNDCTL_DSP_GETOPTR:
  1083. if (!wr)
  1084. return -EINVAL;
  1086. spin_lock_irq (&chip->lock);
  1088. if (chip->play.active) 
  1089. cinfo.ptr = chip->play.hwptr;
  1090. else
  1091. cinfo.ptr = 0;
  1093. cinfo.bytes = chip->play.bytes;
  1094. cinfo.blocks = chip->play.nr_irqs;
  1095. chip->play.nr_irqs = 0;
  1097. spin_unlock_irq (&chip->lock);
  1099. return copy_to_user ((void *) arg, &cinfo, sizeof (cinfo));
  1101. case SNDCTL_DSP_GETODELAY:
  1102. if (!chip->play.active)
  1103. return 0;
  1105. if (!wr)
  1106. return -EINVAL;
  1108. spin_lock_irq (&chip->lock);
  1110. if (chip->play.mapped) {
  1111. count = inw (chip->play.iobase + FORTE_PLY_COUNT) + 1;
  1112. ival = chip->play.frag_sz - count;
  1113. }
  1114. else {
  1115. ival = chip->play.filled_frags * chip->play.frag_sz;
  1116. }
  1118. spin_unlock_irq (&chip->lock);
  1120. return put_user (ival, (int *) arg);
  1122. case SNDCTL_DSP_SETDUPLEX:
  1123. DPRINTK ("%s: SETDUPLEXn", __FUNCTION__);
  1125. return -EINVAL;
  1127. case SNDCTL_DSP_GETTRIGGER:
  1128. DPRINTK ("%s: GETTRIGGERn", __FUNCTION__);
  1130. return put_user (chip->trigger, (int *) arg);
  1132. case SNDCTL_DSP_SETTRIGGER:
  1134. if (get_user (ival, (int *) arg))
  1135. return -EFAULT;
  1137. DPRINTK ("%s: SETTRIGGER %dn", __FUNCTION__, ival);
  1139. if (wr) {
  1140. spin_lock_irq (&chip->lock);
  1142. if (ival & PCM_ENABLE_OUTPUT)
  1143. forte_channel_start (&chip->play);
  1144. else {
  1145. chip->trigger = 1;
  1146. forte_channel_prep (&chip->play);
  1147. forte_channel_stop (&chip->play);
  1148. }
  1150. spin_unlock_irq (&chip->lock);
  1151. }
  1152. else if (rd) {
  1153. spin_lock_irq (&chip->lock);
  1155. if (ival & PCM_ENABLE_INPUT)
  1156. forte_channel_start (&chip->rec);
  1157. else {
  1158. chip->trigger = 1;
  1159. forte_channel_prep (&chip->rec);
  1160. forte_channel_stop (&chip->rec);
  1161. }
  1163. spin_unlock_irq (&chip->lock);
  1164. }
  1166. return 0;
  1168. case SOUND_PCM_READ_RATE:
  1169. DPRINTK ("%s: PCM_READ_RATEn", __FUNCTION__);
  1170. return put_user (chip->play.rate, (int *) arg);
  1172. case SOUND_PCM_READ_CHANNELS:
  1173. DPRINTK ("%s: PCM_READ_CHANNELSn", __FUNCTION__);
  1174. return put_user (chip->play.stereo, (int *) arg);
  1176. case SOUND_PCM_READ_BITS:
  1177. DPRINTK ("%s: PCM_READ_BITSn", __FUNCTION__);
  1178. return put_user (chip->play.format, (int *) arg);
  1180. default:
  1181. DPRINTK ("Unsupported ioctl: %x (%p)n", cmd, (void *) arg);
  1182. break;
  1183. }
  1185. return -EINVAL;
  1186. }
  1189. /**
  1190.  * forte_dsp_open:
  1191.  */
  1193. static int 
  1194. forte_dsp_open (struct inode *inode, struct file *file)
  1195. {
  1196. struct forte_chip *chip = forte; /* FIXME: HACK FROM HELL! */
  1198. if (down_interruptible (&chip->open_sem)) {
  1199. DPRINTK ("%s: returning -ERESTARTSYSn", __FUNCTION__);
  1200. return -ERESTARTSYS;
  1201. }
  1203. file->private_data = forte;
  1205. DPRINTK ("%s: chip @ %pn", __FUNCTION__, file->private_data);
  1207. if (file->f_mode & FMODE_WRITE)
  1208. forte_channel_init (forte, &forte->play);
  1210. if (file->f_mode & FMODE_READ)
  1211. forte_channel_init (forte, &forte->rec);
  1213. return 0;
  1214. }
  1217. /**
  1218.  * forte_dsp_release:
  1219.  */
  1221. static int 
  1222. forte_dsp_release (struct inode *inode, struct file *file)
  1223. {
  1224. struct forte_chip *chip = file->private_data;
  1225. int ret = 0;
  1227. DPRINTK ("%s: chip @ %pn", __FUNCTION__, chip);
  1229. if (file->f_mode & FMODE_WRITE) {
  1230. forte_channel_drain (&chip->play);
  1232. spin_lock_irq (&chip->lock);
  1234. chip->play.ctrl |= FORTE_IMMED_STOP;
  1235. forte_channel_stop (&chip->play);
  1236. forte_channel_free (chip, &chip->play);
  1238. spin_unlock_irq (&chip->lock);
  1239.         }
  1241. if (file->f_mode & FMODE_READ) {
  1242. while (chip->rec.filled_frags > 0)
  1243. interruptible_sleep_on (&chip->rec.wait);
  1245. spin_lock_irq (&chip->lock);
  1247. chip->play.ctrl |= FORTE_IMMED_STOP;
  1248. forte_channel_stop (&chip->rec);
  1249. forte_channel_free (chip, &chip->rec);
  1251. spin_unlock_irq (&chip->lock);
  1252. }
  1254. up (&chip->open_sem);
  1256. return ret;
  1257. }
  1260. /**
  1261.  * forte_dsp_poll:
  1262.  *
  1263.  * FIXME: Racy
  1264.  */
  1266. static unsigned int 
  1267. forte_dsp_poll (struct file *file, struct poll_table_struct *wait)
  1268. {
  1269. struct forte_chip *chip;
  1270. struct forte_channel *channel;
  1271. unsigned int mask = 0;
  1273. chip = file->private_data;
  1275. if (file->f_mode & FMODE_WRITE) {
  1276. channel = &chip->play;
  1278. if (channel->active)
  1279. poll_wait (file, &channel->wait, wait);
  1281. if (channel->filled_frags)
  1282. mask |= POLLOUT | POLLWRNORM;
  1283. }
  1285. if (file->f_mode & FMODE_READ) {
  1286. channel = &chip->rec;
  1288. if (channel->active)
  1289. poll_wait (file, &channel->wait, wait);
  1291. if (channel->filled_frags > 0)
  1292. mask |= POLLIN | POLLRDNORM;
  1293. }
  1295. return mask;
  1296. }
  1299. /**
  1300.  * forte_dsp_mmap:
  1301.  */
  1303. static int
  1304. forte_dsp_mmap (struct file *file, struct vm_area_struct *vma)
  1305. {
  1306. struct forte_chip *chip;
  1307. struct forte_channel *channel;
  1308. unsigned long size;
  1309. int ret;
  1311. chip = file->private_data;
  1313. DPRINTK ("%s: start %lXh, size %ld, pgoff %ldn", __FUNCTION__,
  1314.                  vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_pgoff);
  1316. spin_lock_irq (&chip->lock);
  1318. if (vma->vm_flags & VM_WRITE && chip->play.active) {
  1319. ret = -EBUSY;
  1320. goto out;
  1321. }
  1323.         if (vma->vm_flags & VM_READ && chip->rec.active) {
  1324. ret = -EBUSY;
  1325. goto out;
  1326.         }
  1328. if (file->f_mode & FMODE_WRITE)
  1329. channel = &chip->play;
  1330. else if (file->f_mode & FMODE_READ)
  1331. channel = &chip->rec;
  1332. else {
  1333. ret = -EINVAL;
  1334. goto out;
  1335. }
  1337. forte_channel_prep (channel);
  1338. channel->mapped = 1;
  1340.         if (vma->vm_pgoff != 0) {
  1341. ret = -EINVAL;
  1342.                 goto out;
  1343. }
  1345.         size = vma->vm_end - vma->vm_start;
  1347.         if (size > channel->buf_pages * PAGE_SIZE) {
  1348. DPRINTK ("%s: size (%ld) > buf_sz (%d) n", __FUNCTION__,
  1349.  size, channel->buf_sz);
  1350. ret = -EINVAL;
  1351.                 goto out;
  1352. }
  1354.         if (remap_page_range (vma->vm_start, virt_to_phys (channel->buf),
  1355.       size, vma->vm_page_prot)) {
  1356. DPRINTK ("%s: remap el a no workon", __FUNCTION__);
  1357. ret = -EAGAIN;
  1358.                 goto out;
  1359. }
  1361.         ret = 0;
  1363.  out:
  1364. spin_unlock_irq (&chip->lock);
  1365.         return ret;
  1366. }
  1369. /**
  1370.  * forte_dsp_write:
  1371.  */
  1373. static ssize_t 
  1374. forte_dsp_write (struct file *file, const char *buffer, size_t bytes, 
  1375.  loff_t *ppos)
  1376. {
  1377. struct forte_chip *chip;
  1378. struct forte_channel *channel;
  1379. unsigned int i = bytes, sz = 0;
  1380. unsigned long flags;
  1382. if (ppos != &file->f_pos)
  1383. return -ESPIPE;
  1385. if (!access_ok (VERIFY_READ, buffer, bytes))
  1386. return -EFAULT;
  1388. chip = (struct forte_chip *) file->private_data;
  1390. if (!chip)
  1391. BUG();
  1393. channel = &chip->play;
  1395. if (!channel)
  1396. BUG();
  1398. spin_lock_irqsave (&chip->lock, flags);
  1400. /* Set up buffers with the right fragment size */
  1401. forte_channel_prep (channel);
  1403. while (i) {
  1404. /* All fragment buffers in use -> wait */
  1405. if (channel->frag_num - channel->filled_frags == 0) {
  1406. DECLARE_WAITQUEUE (wait, current);
  1408. /* For trigger mode operation, get out */
  1409. if (chip->trigger) {
  1410. spin_unlock_irqrestore (&chip->lock, flags);
  1411. return -EAGAIN;
  1412. }
  1414. /* Otherwise wait for buffers */
  1415. channel->blocked = 1;
  1416. add_wait_queue (&channel->wait, &wait);
  1418. for (;;) {
  1419. if (channel->active == 0)
  1420. break;
  1422. if (channel->frag_num - channel->filled_frags)
  1423. break;
  1425. spin_unlock_irqrestore (&chip->lock, flags);
  1427. set_current_state (TASK_INTERRUPTIBLE);
  1428. schedule();
  1430. spin_lock_irqsave (&chip->lock, flags);
  1431. }
  1433. set_current_state (TASK_RUNNING);
  1434. remove_wait_queue (&channel->wait, &wait);
  1435. channel->blocked = 0;
  1436. }
  1438. if (i > channel->frag_sz)
  1439. sz = channel->frag_sz;
  1440. else
  1441. sz = i;
  1443. spin_unlock_irqrestore (&chip->lock, flags);
  1445. /* Clear the fragment so we don't get noise when copying
  1446.  * smaller buffers
  1447.  */
  1448. memset ((void *) channel->buf + channel->swptr, 0x0, sz);
  1450. if (copy_from_user ((void *) channel->buf + channel->swptr, 
  1451.     buffer, sz)) {
  1452. return -EFAULT;
  1453. }
  1455. spin_lock_irqsave (&chip->lock, flags);
  1457. /* Advance software pointer */
  1458. buffer += sz;
  1459. channel->filled_frags++;
  1460. channel->swptr += channel->frag_sz;
  1461. channel->swptr %= channel->buf_sz;
  1462. i -= sz;
  1464. /* If playback isn't active, start it */
  1465. if (channel->active == 0 && chip->trigger == 0)
  1466. forte_channel_start (channel);
  1467. }
  1469. spin_unlock_irqrestore (&chip->lock, flags);
  1471. return bytes - i;
  1472. }
  1475. /**
  1476.  * forte_dsp_read:
  1477.  */
  1479. static ssize_t 
  1480. forte_dsp_read (struct file *file, char *buffer, size_t bytes, 
  1481. loff_t *ppos)
  1482. {
  1483. struct forte_chip *chip;
  1484. struct forte_channel *channel;
  1485. unsigned int i = bytes, sz;
  1486. unsigned long flags;
  1488. if (ppos != &file->f_pos)
  1489. return -ESPIPE;
  1491. if (!access_ok (VERIFY_WRITE, buffer, bytes))
  1492. return -EFAULT;
  1494. chip = (struct forte_chip *) file->private_data;
  1496. if (!chip)
  1497. BUG();
  1499. channel = &chip->rec;
  1501. if (!channel)
  1502. BUG();
  1504. spin_lock_irqsave (&chip->lock, flags);
  1506. /* Set up buffers with the right fragment size */
  1507. forte_channel_prep (channel);
  1509. /* Start recording */
  1510. if (!chip->trigger)
  1511. forte_channel_start (channel);
  1513. while (i) {
  1514. /* No fragment buffers in use -> wait */
  1515. if (channel->filled_frags == 0) {
  1516. DECLARE_WAITQUEUE (wait, current);
  1518. /* For trigger mode operation, get out */
  1519. if (chip->trigger) {
  1520. spin_unlock_irqrestore (&chip->lock, flags);
  1521. return -EAGAIN;
  1522. }
  1524. channel->blocked = 1;
  1525. add_wait_queue (&channel->wait, &wait);
  1527. for (;;) {
  1528. if (channel->active == 0)
  1529. break;
  1531. if (channel->filled_frags)
  1532. break;
  1534. spin_unlock_irqrestore (&chip->lock, flags);
  1536. set_current_state (TASK_INTERRUPTIBLE);
  1537. schedule();
  1539. spin_lock_irqsave (&chip->lock, flags);
  1540. }
  1542. set_current_state (TASK_RUNNING);
  1543. remove_wait_queue (&channel->wait, &wait);
  1544. channel->blocked = 0;
  1545. }
  1547. if (i > channel->frag_sz)
  1548. sz = channel->frag_sz;
  1549. else
  1550. sz = i;
  1552. spin_unlock_irqrestore (&chip->lock, flags);
  1554. if (copy_to_user (buffer, (void *)channel->buf+channel->swptr, sz)) {
  1555. DPRINTK ("%s: copy_to_user failedn", __FUNCTION__);
  1556. return -EFAULT;
  1557. }
  1559. spin_lock_irqsave (&chip->lock, flags);
  1561. /* Advance software pointer */
  1562. buffer += sz;
  1563. channel->filled_frags--;
  1564. channel->swptr += channel->frag_sz;
  1565. channel->swptr %= channel->buf_sz;
  1566. i -= sz;
  1567. }
  1569. spin_unlock_irqrestore (&chip->lock, flags);
  1571. return bytes - i;
  1572. }
  1575. static struct file_operations forte_dsp_fops = {
  1576. owner: THIS_MODULE,
  1577. llseek:      &no_llseek,
  1578. read:        &forte_dsp_read,
  1579. write:       &forte_dsp_write,
  1580. poll:        &forte_dsp_poll,
  1581. ioctl:       &forte_dsp_ioctl,
  1582. open:        &forte_dsp_open,
  1583. release:     &forte_dsp_release,
  1584. mmap: &forte_dsp_mmap,
  1585. };
  1588. /* Common ------------------------------------------------------------------ */
  1591. /**
  1592.  * forte_interrupt:
  1593.  */
  1595. static void
  1596. forte_interrupt (int irq, void *dev_id, struct pt_regs *regs)
  1597. {
  1598. struct forte_chip *chip = dev_id;
  1599. struct forte_channel *channel = NULL;
  1600. u16 status, count; 
  1602. status = inw (chip->iobase + FORTE_IRQ_STATUS);
  1604. /* If this is not for us, get outta here ASAP */
  1605. if ((status & (FORTE_IRQ_PLAYBACK | FORTE_IRQ_CAPTURE)) == 0)
  1606. return;
  1608. if (status & FORTE_IRQ_PLAYBACK) {
  1609. channel = &chip->play;
  1610. spin_lock (&chip->lock);
  1612. /* Declare a fragment done */
  1613. channel->filled_frags--;
  1615. /* Get # of completed bytes */
  1616. count = inw (channel->iobase + FORTE_PLY_COUNT) + 1;
  1617. channel->bytes += count;
  1619. if (count == 0) {
  1620. DPRINTK ("%s: last, filled_frags = %dn", __FUNCTION__,
  1621.  channel->filled_frags);
  1622. channel->filled_frags = 0;
  1623. forte_channel_stop (channel);
  1624. goto pack;
  1625. }
  1627. channel->nr_irqs++;
  1629. /* Flip-flop between buffer I and II */
  1630. channel->next_buf ^= 1;
  1632. /* Advance hardware pointer by fragment size and wrap around */
  1633. channel->hwptr += channel->frag_sz;
  1634. channel->hwptr %= channel->buf_sz;
  1636. /* Buffer I or buffer II BAR */
  1637.                 outl (channel->buf_handle + channel->hwptr, 
  1638.       channel->next_buf == 0 ?
  1639.       channel->iobase + FORTE_PLY_BUF1 :
  1640.       channel->iobase + FORTE_PLY_BUF2);
  1642. /* If the currently playing fragment is last, schedule stop */
  1643. if (channel->filled_frags == 1)
  1644. forte_channel_stop (channel);
  1645. pack:
  1646. /* Acknowledge interrupt */
  1647.                 outw (FORTE_IRQ_PLAYBACK, chip->iobase + FORTE_IRQ_STATUS);
  1649. spin_unlock (&chip->lock);
  1651. if (channel->blocked || channel->drain)
  1652. wake_up_interruptible (&channel->wait);
  1653. }
  1655. if (status & FORTE_IRQ_CAPTURE) {
  1656. channel = &chip->rec;
  1657. spin_lock (&chip->lock);
  1659. /* One fragment filled */
  1660. channel->filled_frags++;
  1662. /* Get # of completed bytes */
  1663. count = inw (channel->iobase + FORTE_PLY_COUNT) + 1;
  1665. if (count == 0) {
  1666. DPRINTK ("%s: last, filled_frags = %dn", __FUNCTION__,
  1667.  channel->filled_frags);
  1668. channel->filled_frags = 0;
  1669. goto rack;
  1670. }
  1672. /* Buffer I or buffer II BAR */
  1673.                 outl (channel->buf_handle + channel->hwptr, 
  1674.       channel->next_buf == 0 ?
  1675.       channel->iobase + FORTE_PLY_BUF1 :
  1676.       channel->iobase + FORTE_PLY_BUF2);
  1678. /* Flip-flop between buffer I and II */
  1679. channel->next_buf ^= 1;
  1681. /* Advance hardware pointer by fragment size and wrap around */
  1682. channel->hwptr += channel->frag_sz;
  1683. channel->hwptr %= channel->buf_sz;
  1685. /* Out of buffers */
  1686. if (channel->filled_frags == channel->frag_num - 1)
  1687. forte_channel_stop (channel);
  1688. rack:
  1689. /* Acknowledge interrupt */
  1690.                 outw (FORTE_IRQ_CAPTURE, chip->iobase + FORTE_IRQ_STATUS);
  1692. spin_unlock (&chip->lock);
  1694. if (channel->blocked)
  1695. wake_up_all (&channel->wait);
  1696. }
  1698. return;
  1699. }
  1702. /**
  1703.  * forte_proc_read:
  1704.  */
  1706. static int
  1707. forte_proc_read (char *page, char **start, off_t off, int count, 
  1708.  int *eof, void *data)
  1709. {
  1710. int i = 0, p_rate, p_chan, r_rate;
  1711. unsigned short p_reg, r_reg;
  1713. i += sprintf (page, "ForteMedia FM801 OSS Lite drivern%snn", 
  1714.       DRIVER_VERSION);
  1716. if (!forte->iobase)
  1717. return i;
  1719. p_rate = p_chan = -1;
  1720. p_reg  = inw (forte->iobase + FORTE_PLY_CTRL);
  1721. p_rate = (p_reg >> 8) & 15;
  1722. p_chan = (p_reg >> 12) & 3;
  1724.   if (p_rate >= 0 || p_rate <= 10)
  1725. p_rate = rates[p_rate];
  1727. if (p_chan >= 0 || p_chan <= 2)
  1728. p_chan = channels[p_chan];
  1730. r_rate = -1;
  1731. r_reg  = inw (forte->iobase + FORTE_CAP_CTRL);
  1732. r_rate = (r_reg >> 8) & 15;
  1734.   if (r_rate >= 0 || r_rate <= 10)
  1735. r_rate = rates[r_rate]; 
  1737. i += sprintf (page + i,
  1738.       "             Playback  Capturen"
  1739.       "FIFO empty : %-3s       %-3sn"
  1740.       "Buf1 Last  : %-3s       %-3sn"
  1741.       "Buf2 Last  : %-3s       %-3sn"
  1742.       "Started    : %-3s       %-3sn"
  1743.       "Paused     : %-3s       %-3sn"
  1744.       "Immed Stop : %-3s       %-3sn"
  1745.       "Rate       : %-5d     %-5dn"
  1746.       "Channels   : %-5d     -n"
  1747.       "16-bit     : %-3s       %-3sn"
  1748.       "Stereo     : %-3s       %-3sn",
  1749.       p_reg & 1<<0  ? "yes" : "no",
  1750.       r_reg & 1<<0  ? "yes" : "no",
  1751.       p_reg & 1<<1  ? "yes" : "no",
  1752.       r_reg & 1<<1  ? "yes" : "no",
  1753.       p_reg & 1<<2  ? "yes" : "no",
  1754.       r_reg & 1<<2  ? "yes" : "no",
  1755.       p_reg & 1<<5  ? "yes" : "no",
  1756.       r_reg & 1<<5  ? "yes" : "no",
  1757.       p_reg & 1<<6  ? "yes" : "no",
  1758.       r_reg & 1<<6  ? "yes" : "no",
  1759.       p_reg & 1<<7  ? "yes" : "no",
  1760.       r_reg & 1<<7  ? "yes" : "no",
  1761.       p_rate, r_rate,
  1762.       p_chan,
  1763.       p_reg & 1<<14 ? "yes" : "no",
  1764.       r_reg & 1<<14 ? "yes" : "no",
  1765.       p_reg & 1<<15 ? "yes" : "no",
  1766.       r_reg & 1<<15 ? "yes" : "no");
  1768. return i;
  1769. }
  1772. /**
  1773.  * forte_proc_init:
  1774.  *
  1775.  * Creates driver info entries in /proc
  1776.  */
  1778. static int __init 
  1779. forte_proc_init (void)
  1780. {
  1781. if (!proc_mkdir ("driver/forte", 0))
  1782. return -EIO;
  1784. if (!create_proc_read_entry ("driver/forte/chip", 0, 0, forte_proc_read, forte)) {
  1785. remove_proc_entry ("driver/forte", NULL);
  1786. return -EIO;
  1787. }
  1789. if (!create_proc_read_entry("driver/forte/ac97", 0, 0, ac97_read_proc, forte->ac97)) {
  1790. remove_proc_entry ("driver/forte/chip", NULL);
  1791. remove_proc_entry ("driver/forte", NULL);
  1792. return -EIO;
  1793. }
  1795. return 0;
  1796. }
  1799. /**
  1800.  * forte_proc_remove:
  1801.  *
  1802.  * Removes driver info entries in /proc
  1803.  */
  1805. static void
  1806. forte_proc_remove (void)
  1807. {
  1808. remove_proc_entry ("driver/forte/ac97", NULL);
  1809. remove_proc_entry ("driver/forte/chip", NULL);
  1810. remove_proc_entry ("driver/forte", NULL);
  1811. }
  1814. /**
  1815.  * forte_chip_init:
  1816.  * @chip: Chip instance to initialize
  1817.  *
  1818.  * Description:
  1819.  *  Resets chip, configures codec and registers the driver with
  1820.  *  the sound subsystem.
  1821.  *
  1822.  *  Press and hold Start for 8 secs, then switch on Run
  1823.  *  and hold for 4 seconds.  Let go of Start.  Numbers
  1824.  *  assume a properly oiled TWG.
  1825.  */
  1827. static int __devinit
  1828. forte_chip_init (struct forte_chip *chip)
  1829. {
  1830. u8 revision;
  1831. u16 cmdw;
  1832. struct ac97_codec *codec;
  1834. pci_read_config_byte (chip->pci_dev, PCI_REVISION_ID, &revision);
  1836. if (revision >= 0xB1) {
  1837. chip->multichannel = 1;
  1838. printk (KERN_INFO PFX "Multi-channel device detected.n");
  1839. }
  1841. /* Reset chip */
  1842. outw (FORTE_CC_CODEC_RESET | FORTE_CC_AC97_RESET, 
  1843.       chip->iobase + FORTE_CODEC_CTRL);
  1844. udelay(100);
  1845. outw (0, chip->iobase + FORTE_CODEC_CTRL);
  1847. /* Request read from AC97 */
  1848. outw (FORTE_AC97_READ | (0 << FORTE_AC97_ADDR_SHIFT), 
  1849.       chip->iobase + FORTE_AC97_CMD);
  1850. mdelay(750);
  1852. if ((inw (chip->iobase + FORTE_AC97_CMD) & (3<<8)) != (1<<8)) {
  1853. printk (KERN_INFO PFX "AC97 codec not responding");
  1854. return -EIO;
  1855. }
  1857. /* Init volume */
  1858. outw (0x0808, chip->iobase + FORTE_PCM_VOL);
  1859. outw (0x9f1f, chip->iobase + FORTE_FM_VOL);
  1860. outw (0x8808, chip->iobase + FORTE_I2S_VOL);
  1862. /* I2S control - I2S mode */
  1863. outw (0x0003, chip->iobase + FORTE_I2S_MODE);
  1865. /* Interrupt setup - unmask PLAYBACK & CAPTURE */
  1866. cmdw = inw (chip->iobase + FORTE_IRQ_MASK);
  1867. cmdw &= ~0x0003;
  1868. outw (cmdw, chip->iobase + FORTE_IRQ_MASK);
  1870. /* Interrupt clear */
  1871. outw (FORTE_IRQ_PLAYBACK|FORTE_IRQ_CAPTURE, 
  1872.       chip->iobase + FORTE_IRQ_STATUS);
  1874. /* Set up the AC97 codec */
  1875. if ((codec = kmalloc (sizeof (struct ac97_codec), GFP_KERNEL)) == NULL)
  1876. return -ENOMEM;
  1877. memset (codec, 0, sizeof (struct ac97_codec));
  1879. codec->private_data = chip;
  1880. codec->codec_read = forte_ac97_read;
  1881. codec->codec_write = forte_ac97_write;
  1882. codec->id = 0;
  1884. if (ac97_probe_codec (codec) == 0) {
  1885. printk (KERN_ERR PFX "codec probe failedn");
  1886. kfree (codec);
  1887. return -1;
  1888. }
  1890. /* Register mixer */
  1891. if ((codec->dev_mixer = 
  1892.      register_sound_mixer (&forte_mixer_fops, -1)) < 0) {
  1893. printk (KERN_ERR PFX "couldn't register mixer!n");
  1894. kfree (codec);
  1895. return -1;
  1896. }
  1898. chip->ac97 = codec;
  1900. /* Register DSP */
  1901. if ((chip->dsp = register_sound_dsp (&forte_dsp_fops, -1) ) < 0) {
  1902. printk (KERN_ERR PFX "couldn't register dsp!n");
  1903. return -1;
  1904. }
  1906. /* Register with /proc */
  1907. if (forte_proc_init()) {
  1908. printk (KERN_ERR PFX "couldn't add entries to /proc!n");
  1909. return -1;
  1910. }
  1912. return 0;
  1913. }
  1916. /**
  1917.  * forte_probe:
  1918.  * @pci_dev: PCI struct for probed device
  1919.  * @pci_id:
  1920.  *
  1921.  * Description:
  1922.  * Allocates chip instance, I/O region, and IRQ
  1923.  */
  1924. static int __init 
  1925. forte_probe (struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
  1926. {
  1927. struct forte_chip *chip;
  1928. int ret = 0;
  1930. /* FIXME: Support more than one chip */
  1931. if (found++)
  1932. return -EIO;
  1934. /* Ignition */
  1935. if (pci_enable_device (pci_dev))
  1936. return -EIO;
  1938. pci_set_master (pci_dev);
  1940. /* Allocate chip instance and configure */
  1941. forte = (struct forte_chip *) 
  1942. kmalloc (sizeof (struct forte_chip), GFP_KERNEL);
  1943. chip = forte;
  1945. if (chip == NULL) {
  1946. printk (KERN_WARNING PFX "Out of memory");
  1947. return -ENOMEM;
  1948. }
  1950. memset (chip, 0, sizeof (struct forte_chip));
  1951. chip->pci_dev = pci_dev;
  1953. init_MUTEX(&chip->open_sem);
  1954. spin_lock_init (&chip->lock);
  1955. spin_lock_init (&chip->ac97_lock);
  1957. if (! request_region (pci_resource_start (pci_dev, 0),
  1958.       pci_resource_len (pci_dev, 0), DRIVER_NAME)) {
  1959. printk (KERN_WARNING PFX "Unable to reserve I/O space");
  1960. ret = -ENOMEM;
  1961. goto error;
  1962. }
  1964. chip->iobase = pci_resource_start (pci_dev, 0);
  1965. chip->irq = pci_dev->irq;
  1967. if (request_irq (chip->irq, forte_interrupt, SA_SHIRQ, DRIVER_NAME,
  1968.  chip)) {
  1969. printk (KERN_WARNING PFX "Unable to reserve IRQ");
  1970. ret = -EIO;
  1971. goto error;
  1972. }
  1974. pci_set_drvdata (pci_dev, chip);
  1976. printk (KERN_INFO PFX "FM801 chip found at 0x%04lX-0x%04lX IRQ %un", 
  1977. chip->iobase, pci_resource_end (pci_dev, 0), chip->irq);
  1979. /* Power it up */
  1980. if ((ret = forte_chip_init (chip)) == 0)
  1981. return 0;
  1983.  error:
  1984. if (chip->irq)
  1985. free_irq (chip->irq, chip);
  1987. if (chip->iobase) 
  1988. release_region (pci_resource_start (pci_dev, 0),
  1989. pci_resource_len (pci_dev, 0));
  1991. kfree (chip);
  1993. return ret;
  1994. }
  1997. /**
  1998.  * forte_remove:
  1999.  * @pci_dev: PCI device to unclaim
  2000.  *
  2001.  */
  2003. static void 
  2004. forte_remove (struct pci_dev *pci_dev)
  2005. {
  2006. struct forte_chip *chip = pci_get_drvdata (pci_dev);
  2008. if (chip == NULL)
  2009. return;
  2011. /* Turn volume down to avoid popping */
  2012. outw (0x1f1f, chip->iobase + FORTE_PCM_VOL);
  2013. outw (0x1f1f, chip->iobase + FORTE_FM_VOL);
  2014. outw (0x1f1f, chip->iobase + FORTE_I2S_VOL);
  2016. forte_proc_remove();
  2017. free_irq (chip->irq, chip);
  2018. release_region (chip->iobase, pci_resource_len (pci_dev, 0));
  2020. unregister_sound_dsp (chip->dsp);
  2021. unregister_sound_mixer (chip->ac97->dev_mixer);
  2023. kfree (chip);
  2025. printk (KERN_INFO PFX "driver releasedn");
  2026. }
  2029. static struct pci_device_id forte_pci_ids[] __devinitdata = {
  2030. { 0x1319, 0x0801, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
  2031. { 0, }
  2032. };
  2035. static struct pci_driver forte_pci_driver = {
  2036. name:        DRIVER_NAME,
  2037. id_table:    forte_pci_ids,
  2038. probe:       forte_probe,
  2039. remove:      forte_remove,
  2041. };
  2044. /**
  2045.  * forte_init_module:
  2046.  *
  2047.  */
  2049. static int __init
  2050. forte_init_module (void)
  2051. {
  2052. if (!pci_present())
  2053. return -ENODEV;
  2055. printk (KERN_INFO PFX DRIVER_VERSION "n");
  2057. if (!pci_register_driver (&forte_pci_driver)) {
  2058. pci_unregister_driver (&forte_pci_driver);
  2059. return -ENODEV;
  2060. }
  2062. return 0;
  2063. }
  2066. /**
  2067.  * forte_cleanup_module:
  2068.  *
  2069.  */
  2071. static void __exit 
  2072. forte_cleanup_module (void)
  2073. {
  2074. pci_unregister_driver (&forte_pci_driver);
  2075. }
  2078. module_init(forte_init_module);
  2079. module_exit(forte_cleanup_module);
  2081. MODULE_AUTHOR("Martin K. Petersen <mkp@mkp.net>");
  2082. MODULE_DESCRIPTION("ForteMedia FM801 OSS Driver");
  2083. MODULE_LICENSE("GPL");
  2084. MODULE_DEVICE_TABLE (pci, forte_pci_ids);