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

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

嵌入式Linux

开发平台：

Unix_Linux

es1370.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  *      es1370.c  --  Ensoniq ES1370/Asahi Kasei AK4531 audio driver.
  5.  *
  6.  *      Copyright (C) 1998-2001  Thomas Sailer (t.sailer@alumni.ethz.ch)
  7.  *
  8.  *      This program is free software; you can redistribute it and/or modify
  9.  *      it under the terms of the GNU General Public License as published by
  10.  *      the Free Software Foundation; either version 2 of the License, or
  11.  *      (at your option) any later version.
  12.  *
  13.  *      This program is distributed in the hope that it will be useful,
  14.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *      GNU General Public License for more details.
  17.  *
  18.  *      You should have received a copy of the GNU General Public License
  19.  *      along with this program; if not, write to the Free Software
  20.  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  * Special thanks to David C. Niemi
  23.  *
  24.  *
  25.  * Module command line parameters:
  26.  *   joystick if 1 enables the joystick interface on the card; but it still
  27.  *            needs a driver for joysticks connected to a standard IBM-PC
  28.  *       joyport. It is tested with the joy-analog driver. This 
  29.  *       module must be loaded before the joystick driver. Kmod will
  30.  *       not ensure that.
  31.  *   lineout  if 1 the LINE jack is used as an output instead of an input.
  32.  *            LINE then contains the unmixed dsp output. This can be used
  33.  *            to make the card a four channel one: use dsp to output two
  34.  *            channels to LINE and dac to output the other two channels to
  35.  *            SPKR. Set the mixer to only output synth to SPKR.
  36.  *   micbias  sets the +5V bias to the mic if using an electretmic.
  37.  *            
  38.  *
  39.  *  Note: sync mode is not yet supported (i.e. running dsp and dac from the same
  40.  *  clock source)
  41.  *
  42.  *  Supported devices:
  43.  *  /dev/dsp    standard /dev/dsp device, (mostly) OSS compatible
  44.  *  /dev/mixer  standard /dev/mixer device, (mostly) OSS compatible
  45.  *  /dev/dsp1   additional DAC, like /dev/dsp, but output only,
  46.  *              only 5512, 11025, 22050 and 44100 samples/s,
  47.  *              outputs to mixer "SYNTH" setting
  48.  *  /dev/midi   simple MIDI UART interface, no ioctl
  49.  *
  50.  *  NOTE: the card does not have any FM/Wavetable synthesizer, it is supposed
  51.  *  to be done in software. That is what /dev/dac is for. By now (Q2 1998)
  52.  *  there are several MIDI to PCM (WAV) packages, one of them is timidity.
  53.  *
  54.  *  Revision history
  55.  *    26.03.1998   0.1   Initial release
  56.  *    31.03.1998   0.2   Fix bug in GETOSPACE
  57.  *    04.04.1998   0.3   Make it work (again) under 2.0.33
  58.  *                       Fix mixer write operation not returning the actual
  59.  *                       settings
  60.  *    05.04.1998   0.4   First attempt at using the new PCI stuff
  61.  *    29.04.1998   0.5   Fix hang when ^C is pressed on amp
  62.  *    07.05.1998   0.6   Don't double lock around stop_*() in *_release()
  63.  *    10.05.1998   0.7   First stab at a simple midi interface (no bells&whistles)
  64.  *    14.05.1998   0.8   Don't allow excessive interrupt rates
  65.  *    08.06.1998   0.9   First release using Alan Cox' soundcore instead of
  66.  *                       miscdevice
  67.  *    05.07.1998   0.10  Fixed the driver to correctly maintin OSS style volume
  68.  *                       settings (not sure if this should be standard)
  69.  *                       Fixed many references: f_flags should be f_mode
  70.  *                       -- Gerald Britton <gbritton@mit.edu>
  71.  *    03.08.1998   0.11  Now mixer behaviour can basically be selected between
  72.  *                       "OSS documented" and "OSS actual" behaviour
  73.  *                       Fixed mixer table thanks to Hakan.Lennestal@lu.erisoft.se
  74.  *                       On module startup, set DAC2 to 11kSPS instead of 5.5kSPS,
  75.  *                       as it produces an annoying ssssh in the lower sampling rate
  76.  *                       Do not include modversions.h
  77.  *    22.08.1998   0.12  Mixer registers actually have 5 instead of 4 bits
  78.  *                       pointed out by Itai Nahshon
  79.  *    31.08.1998   0.13  Fix realplayer problems - dac.count issues
  80.  *    08.10.1998   0.14  Joystick support fixed
  81.  *          -- Oliver Neukum <c188@org.chemie.uni-muenchen.de>
  82.  *    10.12.1998   0.15  Fix drain_dac trying to wait on not yet initialized DMA
  83.  *    16.12.1998   0.16  Don't wake up app until there are fragsize bytes to read/write
  84.  *    06.01.1999   0.17  remove the silly SA_INTERRUPT flag.
  85.  *                       hopefully killed the egcs section type conflict
  86.  *    12.03.1999   0.18  cinfo.blocks should be reset after GETxPTR ioctl.
  87.  *                       reported by Johan Maes <joma@telindus.be>
  88.  *    22.03.1999   0.19  return EAGAIN instead of EBUSY when O_NONBLOCK
  89.  *                       read/write cannot be executed
  90.  *    07.04.1999   0.20  implemented the following ioctl's: SOUND_PCM_READ_RATE, 
  91.  *                       SOUND_PCM_READ_CHANNELS, SOUND_PCM_READ_BITS; 
  92.  *                       Alpha fixes reported by Peter Jones <pjones@redhat.com>
  93.  *                       Note: joystick address handling might still be wrong on archs
  94.  *                       other than i386
  95.  *    10.05.1999   0.21  Added support for an electret mic for SB PCI64
  96.  *                       to the Linux kernel sound driver. This mod also straighten
  97.  *                       out the question marks around the mic impedance setting
  98.  *                       (micz). From Kim.Berts@fisub.mail.abb.com
  99.  *    11.05.1999   0.22  Implemented the IMIX call to mute recording monitor.
  100.  *                       Guenter Geiger <geiger@epy.co.at>
  101.  *    15.06.1999   0.23  Fix bad allocation bug.
  102.  *                       Thanks to Deti Fliegl <fliegl@in.tum.de>
  103.  *    28.06.1999   0.24  Add pci_set_master
  104.  *    02.08.1999   0.25  Added workaround for the "phantom write" bug first
  105.  *                       documented by Dave Sharpless from Anchor Games
  106.  *    03.08.1999   0.26  adapt to Linus' new __setup/__initcall
  107.  *                       added kernel command line option "es1370=joystick[,lineout[,micbias]]"
  108.  *                       removed CONFIG_SOUND_ES1370_JOYPORT_BOOT kludge
  109.  *    12.08.1999   0.27  module_init/__setup fixes
  110.  *    19.08.1999   0.28  SOUND_MIXER_IMIX fixes, reported by Gianluca <gialluca@mail.tiscalinet.it>
  111.  *    31.08.1999   0.29  add spin_lock_init
  112.  *                       replaced current->state = x with set_current_state(x)
  113.  *    03.09.1999   0.30  change read semantics for MIDI to match
  114.  *                       OSS more closely; remove possible wakeup race
  115.  *    28.10.1999   0.31  More waitqueue races fixed
  116.  *    08.01.2000   0.32  Prevent some ioctl's from returning bad count values on underrun/overrun;
  117.  *                       Tim Janik's BSE (Bedevilled Sound Engine) found this
  118.  *    07.02.2000   0.33  Use pci_alloc_consistent and pci_register_driver
  119.  *    21.11.2000   0.34  Initialize dma buffers in poll, otherwise poll may return a bogus mask
  120.  *    12.12.2000   0.35  More dma buffer initializations, patch from
  121.  *                       Tjeerd Mulder <tjeerd.mulder@fujitsu-siemens.com>
  122.  *    07.01.2001   0.36  Timeout change in wrcodec as requested by Frank Klemm <pfk@fuchs.offl.uni-jena.de>
  123.  *    31.01.2001   0.37  Register/Unregister gameport
  124.  *                       Fix SETTRIGGER non OSS API conformity
  125.  *
  126.  * some important things missing in Ensoniq documentation:
  127.  *
  128.  * Experimental PCLKDIV results:  play the same waveforms on both DAC1 and DAC2
  129.  * and vary PCLKDIV to obtain zero beat.
  130.  *  5512sps:  254
  131.  * 44100sps:   30
  132.  * seems to be fs = 1411200/(PCLKDIV+2)
  133.  *
  134.  * should find out when curr_sample_ct is cleared and
  135.  * where exactly the CCB fetches data
  136.  *
  137.  * The card uses a 22.5792 MHz crystal.
  138.  * The LINEIN jack may be converted to an AOUT jack by
  139.  * setting pin 47 (XCTL0) of the ES1370 to high.
  140.  * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
  141.  * 
  142.  *
  143.  */
  145. /*****************************************************************************/
  146.       
  147. #include <linux/version.h>
  148. #include <linux/module.h>
  149. #include <linux/string.h>
  150. #include <linux/ioport.h>
  151. #include <linux/sched.h>
  152. #include <linux/delay.h>
  153. #include <linux/sound.h>
  154. #include <linux/slab.h>
  155. #include <linux/soundcard.h>
  156. #include <linux/pci.h>
  157. #include <linux/smp_lock.h>
  158. #include <linux/wrapper.h>
  159. #include <asm/io.h>
  160. #include <asm/dma.h>
  161. #include <linux/init.h>
  162. #include <linux/poll.h>
  163. #include <linux/spinlock.h>
  164. #include <asm/uaccess.h>
  165. #include <asm/hardirq.h>
  166. #include <linux/gameport.h>
  168. /* --------------------------------------------------------------------- */
  170. #undef OSS_DOCUMENTED_MIXER_SEMANTICS
  171. #define DBG(x) {}
  172. /*#define DBG(x) {x}*/
  174. /* --------------------------------------------------------------------- */
  176. #ifndef PCI_VENDOR_ID_ENSONIQ
  177. #define PCI_VENDOR_ID_ENSONIQ        0x1274    
  178. #endif
  180. #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
  181. #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
  182. #endif
  184. #define ES1370_MAGIC  ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
  186. #define ES1370_EXTENT             0x40
  187. #define JOY_EXTENT                8
  189. #define ES1370_REG_CONTROL        0x00
  190. #define ES1370_REG_STATUS         0x04
  191. #define ES1370_REG_UART_DATA      0x08
  192. #define ES1370_REG_UART_STATUS    0x09
  193. #define ES1370_REG_UART_CONTROL   0x09
  194. #define ES1370_REG_UART_TEST      0x0a
  195. #define ES1370_REG_MEMPAGE        0x0c
  196. #define ES1370_REG_CODEC          0x10
  197. #define ES1370_REG_SERIAL_CONTROL 0x20
  198. #define ES1370_REG_DAC1_SCOUNT    0x24
  199. #define ES1370_REG_DAC2_SCOUNT    0x28
  200. #define ES1370_REG_ADC_SCOUNT     0x2c
  202. #define ES1370_REG_DAC1_FRAMEADR    0xc30
  203. #define ES1370_REG_DAC1_FRAMECNT    0xc34
  204. #define ES1370_REG_DAC2_FRAMEADR    0xc38
  205. #define ES1370_REG_DAC2_FRAMECNT    0xc3c
  206. #define ES1370_REG_ADC_FRAMEADR     0xd30
  207. #define ES1370_REG_ADC_FRAMECNT     0xd34
  208. #define ES1370_REG_PHANTOM_FRAMEADR 0xd38
  209. #define ES1370_REG_PHANTOM_FRAMECNT 0xd3c
  211. #define ES1370_FMT_U8_MONO     0
  212. #define ES1370_FMT_U8_STEREO   1
  213. #define ES1370_FMT_S16_MONO    2
  214. #define ES1370_FMT_S16_STEREO  3
  215. #define ES1370_FMT_STEREO      1
  216. #define ES1370_FMT_S16         2
  217. #define ES1370_FMT_MASK        3
  219. static const unsigned sample_size[] = { 1, 2, 2, 4 };
  220. static const unsigned sample_shift[] = { 0, 1, 1, 2 };
  222. static const unsigned dac1_samplerate[] = { 5512, 11025, 22050, 44100 };
  224. #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
  225. #define DAC2_DIVTOSR(x) (1411200/((x)+2))
  227. #define CTRL_ADC_STOP   0x80000000  /* 1 = ADC stopped */
  228. #define CTRL_XCTL1      0x40000000  /* electret mic bias */
  229. #define CTRL_OPEN       0x20000000  /* no function, can be read and written */
  230. #define CTRL_PCLKDIV    0x1fff0000  /* ADC/DAC2 clock divider */
  231. #define CTRL_SH_PCLKDIV 16
  232. #define CTRL_MSFMTSEL   0x00008000  /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
  233. #define CTRL_M_SBB      0x00004000  /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
  234. #define CTRL_WTSRSEL    0x00003000  /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
  235. #define CTRL_SH_WTSRSEL 12
  236. #define CTRL_DAC_SYNC   0x00000800  /* 1 = DAC2 runs off DAC1 clock */
  237. #define CTRL_CCB_INTRM  0x00000400  /* 1 = CCB "voice" ints enabled */
  238. #define CTRL_M_CB       0x00000200  /* recording source: 0 = ADC, 1 = MPEG */
  239. #define CTRL_XCTL0      0x00000100  /* 0 = Line in, 1 = Line out */
  240. #define CTRL_BREQ       0x00000080  /* 1 = test mode (internal mem test) */
  241. #define CTRL_DAC1_EN    0x00000040  /* enable DAC1 */
  242. #define CTRL_DAC2_EN    0x00000020  /* enable DAC2 */
  243. #define CTRL_ADC_EN     0x00000010  /* enable ADC */
  244. #define CTRL_UART_EN    0x00000008  /* enable MIDI uart */
  245. #define CTRL_JYSTK_EN   0x00000004  /* enable Joystick port (presumably at address 0x200) */
  246. #define CTRL_CDC_EN     0x00000002  /* enable serial (CODEC) interface */
  247. #define CTRL_SERR_DIS   0x00000001  /* 1 = disable PCI SERR signal */
  249. #define STAT_INTR       0x80000000  /* wired or of all interrupt bits */
  250. #define STAT_CSTAT      0x00000400  /* 1 = codec busy or codec write in progress */
  251. #define STAT_CBUSY      0x00000200  /* 1 = codec busy */
  252. #define STAT_CWRIP      0x00000100  /* 1 = codec write in progress */
  253. #define STAT_VC         0x00000060  /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
  254. #define STAT_SH_VC      5
  255. #define STAT_MCCB       0x00000010  /* CCB int pending */
  256. #define STAT_UART       0x00000008  /* UART int pending */
  257. #define STAT_DAC1       0x00000004  /* DAC1 int pending */
  258. #define STAT_DAC2       0x00000002  /* DAC2 int pending */
  259. #define STAT_ADC        0x00000001  /* ADC int pending */
  261. #define USTAT_RXINT     0x80        /* UART rx int pending */
  262. #define USTAT_TXINT     0x04        /* UART tx int pending */
  263. #define USTAT_TXRDY     0x02        /* UART tx ready */
  264. #define USTAT_RXRDY     0x01        /* UART rx ready */
  266. #define UCTRL_RXINTEN   0x80        /* 1 = enable RX ints */
  267. #define UCTRL_TXINTEN   0x60        /* TX int enable field mask */
  268. #define UCTRL_ENA_TXINT 0x20        /* enable TX int */
  269. #define UCTRL_CNTRL     0x03        /* control field */
  270. #define UCTRL_CNTRL_SWR 0x03        /* software reset command */
  272. #define SCTRL_P2ENDINC    0x00380000  /*  */
  273. #define SCTRL_SH_P2ENDINC 19
  274. #define SCTRL_P2STINC     0x00070000  /*  */
  275. #define SCTRL_SH_P2STINC  16
  276. #define SCTRL_R1LOOPSEL   0x00008000  /* 0 = loop mode */
  277. #define SCTRL_P2LOOPSEL   0x00004000  /* 0 = loop mode */
  278. #define SCTRL_P1LOOPSEL   0x00002000  /* 0 = loop mode */
  279. #define SCTRL_P2PAUSE     0x00001000  /* 1 = pause mode */
  280. #define SCTRL_P1PAUSE     0x00000800  /* 1 = pause mode */
  281. #define SCTRL_R1INTEN     0x00000400  /* enable interrupt */
  282. #define SCTRL_P2INTEN     0x00000200  /* enable interrupt */
  283. #define SCTRL_P1INTEN     0x00000100  /* enable interrupt */
  284. #define SCTRL_P1SCTRLD    0x00000080  /* reload sample count register for DAC1 */
  285. #define SCTRL_P2DACSEN    0x00000040  /* 1 = DAC2 play back last sample when disabled */
  286. #define SCTRL_R1SEB       0x00000020  /* 1 = 16bit */
  287. #define SCTRL_R1SMB       0x00000010  /* 1 = stereo */
  288. #define SCTRL_R1FMT       0x00000030  /* format mask */
  289. #define SCTRL_SH_R1FMT    4
  290. #define SCTRL_P2SEB       0x00000008  /* 1 = 16bit */
  291. #define SCTRL_P2SMB       0x00000004  /* 1 = stereo */
  292. #define SCTRL_P2FMT       0x0000000c  /* format mask */
  293. #define SCTRL_SH_P2FMT    2
  294. #define SCTRL_P1SEB       0x00000002  /* 1 = 16bit */
  295. #define SCTRL_P1SMB       0x00000001  /* 1 = stereo */
  296. #define SCTRL_P1FMT       0x00000003  /* format mask */
  297. #define SCTRL_SH_P1FMT    0
  299. /* misc stuff */
  301. #define FMODE_DAC         4           /* slight misuse of mode_t */
  303. /* MIDI buffer sizes */
  305. #define MIDIINBUF  256
  306. #define MIDIOUTBUF 256
  308. #define FMODE_MIDI_SHIFT 3
  309. #define FMODE_MIDI_READ  (FMODE_READ << FMODE_MIDI_SHIFT)
  310. #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
  312. /* --------------------------------------------------------------------- */
  314. struct es1370_state {
  315. /* magic */
  316. unsigned int magic;
  318. /* list of es1370 devices */
  319. struct list_head devs;
  321. /* the corresponding pci_dev structure */
  322. struct pci_dev *dev;
  324. /* soundcore stuff */
  325. int dev_audio;
  326. int dev_mixer;
  327. int dev_dac;
  328. int dev_midi;
  330. /* hardware resources */
  331. unsigned long io; /* long for SPARC */
  332. unsigned int irq;
  334. /* mixer registers; there is no HW readback */
  335. struct {
  336. unsigned short vol[10];
  337. unsigned int recsrc;
  338. unsigned int modcnt;
  339. unsigned short micpreamp;
  340.         unsigned int imix;
  341. } mix;
  343. /* wave stuff */
  344. unsigned ctrl;
  345. unsigned sctrl;
  347. spinlock_t lock;
  348. struct semaphore open_sem;
  349. mode_t open_mode;
  350. wait_queue_head_t open_wait;
  352. struct dmabuf {
  353. void *rawbuf;
  354. dma_addr_t dmaaddr;
  355. unsigned buforder;
  356. unsigned numfrag;
  357. unsigned fragshift;
  358. unsigned hwptr, swptr;
  359. unsigned total_bytes;
  360. int count;
  361. unsigned error; /* over/underrun */
  362. wait_queue_head_t wait;
  363. /* redundant, but makes calculations easier */
  364. unsigned fragsize;
  365. unsigned dmasize;
  366. unsigned fragsamples;
  367. /* OSS stuff */
  368. unsigned mapped:1;
  369. unsigned ready:1;
  370. unsigned endcleared:1;
  371. unsigned enabled:1;
  372. unsigned ossfragshift;
  373. int ossmaxfrags;
  374. unsigned subdivision;
  375. } dma_dac1, dma_dac2, dma_adc;
  377. /* midi stuff */
  378. struct {
  379. unsigned ird, iwr, icnt;
  380. unsigned ord, owr, ocnt;
  381. wait_queue_head_t iwait;
  382. wait_queue_head_t owait;
  383. unsigned char ibuf[MIDIINBUF];
  384. unsigned char obuf[MIDIOUTBUF];
  385. } midi;
  387. struct gameport gameport;
  388. struct semaphore sem;
  389. };
  391. /* --------------------------------------------------------------------- */
  393. static LIST_HEAD(devs);
  395. /*
  396.  * The following buffer is used to point the phantom write channel to,
  397.  * so that it cannot wreak havoc. The attribute makes sure it doesn't
  398.  * cross a page boundary and ensures dword alignment for the DMA engine
  399.  */
  400. static unsigned char bugbuf[16] __attribute__ ((aligned (16)));
  402. /* --------------------------------------------------------------------- */
  404. static inline unsigned ld2(unsigned int x)
  405. {
  406. unsigned r = 0;
  408. if (x >= 0x10000) {
  409. x >>= 16;
  410. r += 16;
  411. }
  412. if (x >= 0x100) {
  413. x >>= 8;
  414. r += 8;
  415. }
  416. if (x >= 0x10) {
  417. x >>= 4;
  418. r += 4;
  419. }
  420. if (x >= 4) {
  421. x >>= 2;
  422. r += 2;
  423. }
  424. if (x >= 2)
  425. r++;
  426. return r;
  427. }
  429. /* --------------------------------------------------------------------- */
  431. static void wrcodec(struct es1370_state *s, unsigned char idx, unsigned char data)
  432. {
  433. unsigned long tmo = jiffies + HZ/10, j;
  435. do {
  436. j = jiffies;
  437. if (!(inl(s->io+ES1370_REG_STATUS) & STAT_CSTAT)) {
  438. outw((((unsigned short)idx)<<8)|data, s->io+ES1370_REG_CODEC);
  439. return;
  440. }
  441. schedule();
  442. } while ((signed)(tmo-j) > 0);
  443. printk(KERN_ERR "es1370: write to codec register timeoutn");
  444. }
  446. /* --------------------------------------------------------------------- */
  448. static inline void stop_adc(struct es1370_state *s)
  449. {
  450. unsigned long flags;
  452. spin_lock_irqsave(&s->lock, flags);
  453. s->ctrl &= ~CTRL_ADC_EN;
  454. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  455. spin_unlock_irqrestore(&s->lock, flags);
  456. }
  458. static inline void stop_dac1(struct es1370_state *s)
  459. {
  460. unsigned long flags;
  462. spin_lock_irqsave(&s->lock, flags);
  463. s->ctrl &= ~CTRL_DAC1_EN;
  464. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  465. spin_unlock_irqrestore(&s->lock, flags);
  466. }
  468. static inline void stop_dac2(struct es1370_state *s)
  469. {
  470. unsigned long flags;
  472. spin_lock_irqsave(&s->lock, flags);
  473. s->ctrl &= ~CTRL_DAC2_EN;
  474. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  475. spin_unlock_irqrestore(&s->lock, flags);
  476. }
  478. static void start_dac1(struct es1370_state *s)
  479. {
  480. unsigned long flags;
  481. unsigned fragremain, fshift;
  483. spin_lock_irqsave(&s->lock, flags);
  484. if (!(s->ctrl & CTRL_DAC1_EN) && (s->dma_dac1.mapped || s->dma_dac1.count > 0)
  485.     && s->dma_dac1.ready) {
  486. s->ctrl |= CTRL_DAC1_EN;
  487. s->sctrl = (s->sctrl & ~(SCTRL_P1LOOPSEL | SCTRL_P1PAUSE | SCTRL_P1SCTRLD)) | SCTRL_P1INTEN;
  488. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  489. fragremain = ((- s->dma_dac1.hwptr) & (s->dma_dac1.fragsize-1));
  490. fshift = sample_shift[(s->sctrl & SCTRL_P1FMT) >> SCTRL_SH_P1FMT];
  491. if (fragremain < 2*fshift)
  492. fragremain = s->dma_dac1.fragsize;
  493. outl((fragremain >> fshift) - 1, s->io+ES1370_REG_DAC1_SCOUNT);
  494. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  495. outl((s->dma_dac1.fragsize >> fshift) - 1, s->io+ES1370_REG_DAC1_SCOUNT);
  496. }
  497. spin_unlock_irqrestore(&s->lock, flags);
  498. }
  500. static void start_dac2(struct es1370_state *s)
  501. {
  502. unsigned long flags;
  503. unsigned fragremain, fshift;
  505. spin_lock_irqsave(&s->lock, flags);
  506. if (!(s->ctrl & CTRL_DAC2_EN) && (s->dma_dac2.mapped || s->dma_dac2.count > 0)
  507.     && s->dma_dac2.ready) {
  508. s->ctrl |= CTRL_DAC2_EN;
  509. s->sctrl = (s->sctrl & ~(SCTRL_P2LOOPSEL | SCTRL_P2PAUSE | SCTRL_P2DACSEN | 
  510.  SCTRL_P2ENDINC | SCTRL_P2STINC)) | SCTRL_P2INTEN |
  511. (((s->sctrl & SCTRL_P2FMT) ? 2 : 1) << SCTRL_SH_P2ENDINC) | 
  512. (0 << SCTRL_SH_P2STINC);
  513. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  514. fragremain = ((- s->dma_dac2.hwptr) & (s->dma_dac2.fragsize-1));
  515. fshift = sample_shift[(s->sctrl & SCTRL_P2FMT) >> SCTRL_SH_P2FMT];
  516. if (fragremain < 2*fshift)
  517. fragremain = s->dma_dac2.fragsize;
  518. outl((fragremain >> fshift) - 1, s->io+ES1370_REG_DAC2_SCOUNT);
  519. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  520. outl((s->dma_dac2.fragsize >> fshift) - 1, s->io+ES1370_REG_DAC2_SCOUNT);
  521. }
  522. spin_unlock_irqrestore(&s->lock, flags);
  523. }
  525. static void start_adc(struct es1370_state *s)
  526. {
  527. unsigned long flags;
  528. unsigned fragremain, fshift;
  530. spin_lock_irqsave(&s->lock, flags);
  531. if (!(s->ctrl & CTRL_ADC_EN) && (s->dma_adc.mapped || s->dma_adc.count < (signed)(s->dma_adc.dmasize - 2*s->dma_adc.fragsize))
  532.     && s->dma_adc.ready) {
  533. s->ctrl |= CTRL_ADC_EN;
  534. s->sctrl = (s->sctrl & ~SCTRL_R1LOOPSEL) | SCTRL_R1INTEN;
  535. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  536. fragremain = ((- s->dma_adc.hwptr) & (s->dma_adc.fragsize-1));
  537. fshift = sample_shift[(s->sctrl & SCTRL_R1FMT) >> SCTRL_SH_R1FMT];
  538. if (fragremain < 2*fshift)
  539. fragremain = s->dma_adc.fragsize;
  540. outl((fragremain >> fshift) - 1, s->io+ES1370_REG_ADC_SCOUNT);
  541. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  542. outl((s->dma_adc.fragsize >> fshift) - 1, s->io+ES1370_REG_ADC_SCOUNT);
  543. }
  544. spin_unlock_irqrestore(&s->lock, flags);
  545. }
  547. /* --------------------------------------------------------------------- */
  549. #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
  550. #define DMABUF_MINORDER 1
  552. static inline void dealloc_dmabuf(struct es1370_state *s, struct dmabuf *db)
  553. {
  554. struct page *page, *pend;
  556. if (db->rawbuf) {
  557. /* undo marking the pages as reserved */
  558. pend = virt_to_page(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
  559. for (page = virt_to_page(db->rawbuf); page <= pend; page++)
  560. mem_map_unreserve(page);
  561. pci_free_consistent(s->dev, PAGE_SIZE << db->buforder, db->rawbuf, db->dmaaddr);
  562. }
  563. db->rawbuf = NULL;
  564. db->mapped = db->ready = 0;
  565. }
  567. static int prog_dmabuf(struct es1370_state *s, struct dmabuf *db, unsigned rate, unsigned fmt, unsigned reg)
  568. {
  569. int order;
  570. unsigned bytepersec;
  571. unsigned bufs;
  572. struct page *page, *pend;
  574. db->hwptr = db->swptr = db->total_bytes = db->count = db->error = db->endcleared = 0;
  575. if (!db->rawbuf) {
  576. db->ready = db->mapped = 0;
  577. for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--)
  578. if ((db->rawbuf = pci_alloc_consistent(s->dev, PAGE_SIZE << order, &db->dmaaddr)))
  579. break;
  580. if (!db->rawbuf)
  581. return -ENOMEM;
  582. db->buforder = order;
  583. /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
  584. pend = virt_to_page(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
  585. for (page = virt_to_page(db->rawbuf); page <= pend; page++)
  586. mem_map_reserve(page);
  587. }
  588. fmt &= ES1370_FMT_MASK;
  589. bytepersec = rate << sample_shift[fmt];
  590. bufs = PAGE_SIZE << db->buforder;
  591. if (db->ossfragshift) {
  592. if ((1000 << db->ossfragshift) < bytepersec)
  593. db->fragshift = ld2(bytepersec/1000);
  594. else
  595. db->fragshift = db->ossfragshift;
  596. } else {
  597. db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
  598. if (db->fragshift < 3)
  599. db->fragshift = 3;
  600. }
  601. db->numfrag = bufs >> db->fragshift;
  602. while (db->numfrag < 4 && db->fragshift > 3) {
  603. db->fragshift--;
  604. db->numfrag = bufs >> db->fragshift;
  605. }
  606. db->fragsize = 1 << db->fragshift;
  607. if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
  608. db->numfrag = db->ossmaxfrags;
  609. db->fragsamples = db->fragsize >> sample_shift[fmt];
  610. db->dmasize = db->numfrag << db->fragshift;
  611. memset(db->rawbuf, (fmt & ES1370_FMT_S16) ? 0 : 0x80, db->dmasize);
  612. outl((reg >> 8) & 15, s->io+ES1370_REG_MEMPAGE);
  613. outl(db->dmaaddr, s->io+(reg & 0xff));
  614. outl((db->dmasize >> 2)-1, s->io+((reg + 4) & 0xff));
  615. db->enabled = 1;
  616. db->ready = 1;
  617. return 0;
  618. }
  620. static inline int prog_dmabuf_adc(struct es1370_state *s)
  621. {
  622. stop_adc(s);
  623. return prog_dmabuf(s, &s->dma_adc, DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV),
  624.    (s->sctrl >> SCTRL_SH_R1FMT) & ES1370_FMT_MASK, ES1370_REG_ADC_FRAMEADR);
  625. }
  627. static inline int prog_dmabuf_dac2(struct es1370_state *s)
  628. {
  629. stop_dac2(s);
  630. return prog_dmabuf(s, &s->dma_dac2, DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV),
  631.    (s->sctrl >> SCTRL_SH_P2FMT) & ES1370_FMT_MASK, ES1370_REG_DAC2_FRAMEADR);
  632. }
  634. static inline int prog_dmabuf_dac1(struct es1370_state *s)
  635. {
  636. stop_dac1(s);
  637. return prog_dmabuf(s, &s->dma_dac1, dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL],
  638.    (s->sctrl >> SCTRL_SH_P1FMT) & ES1370_FMT_MASK, ES1370_REG_DAC1_FRAMEADR);
  639. }
  641. static inline unsigned get_hwptr(struct es1370_state *s, struct dmabuf *db, unsigned reg)
  642. {
  643. unsigned hwptr, diff;
  645. outl((reg >> 8) & 15, s->io+ES1370_REG_MEMPAGE);
  646. hwptr = (inl(s->io+(reg & 0xff)) >> 14) & 0x3fffc;
  647. diff = (db->dmasize + hwptr - db->hwptr) % db->dmasize;
  648. db->hwptr = hwptr;
  649. return diff;
  650. }
  652. static inline void clear_advance(void *buf, unsigned bsize, unsigned bptr, unsigned len, unsigned char c)
  653. {
  654. if (bptr + len > bsize) {
  655. unsigned x = bsize - bptr;
  656. memset(((char *)buf) + bptr, c, x);
  657. bptr = 0;
  658. len -= x;
  659. }
  660. memset(((char *)buf) + bptr, c, len);
  661. }
  663. /* call with spinlock held! */
  664. static void es1370_update_ptr(struct es1370_state *s)
  665. {
  666. int diff;
  668. /* update ADC pointer */
  669. if (s->ctrl & CTRL_ADC_EN) {
  670. diff = get_hwptr(s, &s->dma_adc, ES1370_REG_ADC_FRAMECNT);
  671. s->dma_adc.total_bytes += diff;
  672. s->dma_adc.count += diff;
  673. if (s->dma_adc.count >= (signed)s->dma_adc.fragsize) 
  674. wake_up(&s->dma_adc.wait);
  675. if (!s->dma_adc.mapped) {
  676. if (s->dma_adc.count > (signed)(s->dma_adc.dmasize - ((3 * s->dma_adc.fragsize) >> 1))) {
  677. s->ctrl &= ~CTRL_ADC_EN;
  678. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  679. s->dma_adc.error++;
  680. }
  681. }
  682. }
  683. /* update DAC1 pointer */
  684. if (s->ctrl & CTRL_DAC1_EN) {
  685. diff = get_hwptr(s, &s->dma_dac1, ES1370_REG_DAC1_FRAMECNT);
  686. s->dma_dac1.total_bytes += diff;
  687. if (s->dma_dac1.mapped) {
  688. s->dma_dac1.count += diff;
  689. if (s->dma_dac1.count >= (signed)s->dma_dac1.fragsize)
  690. wake_up(&s->dma_dac1.wait);
  691. } else {
  692. s->dma_dac1.count -= diff;
  693. if (s->dma_dac1.count <= 0) {
  694. s->ctrl &= ~CTRL_DAC1_EN;
  695. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  696. s->dma_dac1.error++;
  697. } else if (s->dma_dac1.count <= (signed)s->dma_dac1.fragsize && !s->dma_dac1.endcleared) {
  698. clear_advance(s->dma_dac1.rawbuf, s->dma_dac1.dmasize, s->dma_dac1.swptr, 
  699.       s->dma_dac1.fragsize, (s->sctrl & SCTRL_P1SEB) ? 0 : 0x80);
  700. s->dma_dac1.endcleared = 1;
  701. }
  702. if (s->dma_dac1.count + (signed)s->dma_dac1.fragsize <= (signed)s->dma_dac1.dmasize)
  703. wake_up(&s->dma_dac1.wait);
  704. }
  705. }
  706. /* update DAC2 pointer */
  707. if (s->ctrl & CTRL_DAC2_EN) {
  708. diff = get_hwptr(s, &s->dma_dac2, ES1370_REG_DAC2_FRAMECNT);
  709. s->dma_dac2.total_bytes += diff;
  710. if (s->dma_dac2.mapped) {
  711. s->dma_dac2.count += diff;
  712. if (s->dma_dac2.count >= (signed)s->dma_dac2.fragsize)
  713. wake_up(&s->dma_dac2.wait);
  714. } else {
  715. s->dma_dac2.count -= diff;
  716. if (s->dma_dac2.count <= 0) {
  717. s->ctrl &= ~CTRL_DAC2_EN;
  718. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  719. s->dma_dac2.error++;
  720. } else if (s->dma_dac2.count <= (signed)s->dma_dac2.fragsize && !s->dma_dac2.endcleared) {
  721. clear_advance(s->dma_dac2.rawbuf, s->dma_dac2.dmasize, s->dma_dac2.swptr, 
  722.       s->dma_dac2.fragsize, (s->sctrl & SCTRL_P2SEB) ? 0 : 0x80);
  723. s->dma_dac2.endcleared = 1;
  724. }
  725. if (s->dma_dac2.count + (signed)s->dma_dac2.fragsize <= (signed)s->dma_dac2.dmasize)
  726. wake_up(&s->dma_dac2.wait);
  727. }
  728. }
  729. }
  731. /* hold spinlock for the following! */
  732. static void es1370_handle_midi(struct es1370_state *s)
  733. {
  734. unsigned char ch;
  735. int wake;
  737. if (!(s->ctrl & CTRL_UART_EN))
  738. return;
  739. wake = 0;
  740. while (inb(s->io+ES1370_REG_UART_STATUS) & USTAT_RXRDY) {
  741. ch = inb(s->io+ES1370_REG_UART_DATA);
  742. if (s->midi.icnt < MIDIINBUF) {
  743. s->midi.ibuf[s->midi.iwr] = ch;
  744. s->midi.iwr = (s->midi.iwr + 1) % MIDIINBUF;
  745. s->midi.icnt++;
  746. }
  747. wake = 1;
  748. }
  749. if (wake)
  750. wake_up(&s->midi.iwait);
  751. wake = 0;
  752. while ((inb(s->io+ES1370_REG_UART_STATUS) & USTAT_TXRDY) && s->midi.ocnt > 0) {
  753. outb(s->midi.obuf[s->midi.ord], s->io+ES1370_REG_UART_DATA);
  754. s->midi.ord = (s->midi.ord + 1) % MIDIOUTBUF;
  755. s->midi.ocnt--;
  756. if (s->midi.ocnt < MIDIOUTBUF-16)
  757. wake = 1;
  758. }
  759. if (wake)
  760. wake_up(&s->midi.owait);
  761. outb((s->midi.ocnt > 0) ? UCTRL_RXINTEN | UCTRL_ENA_TXINT : UCTRL_RXINTEN, s->io+ES1370_REG_UART_CONTROL);
  762. }
  764. static void es1370_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  765. {
  766.         struct es1370_state *s = (struct es1370_state *)dev_id;
  767. unsigned int intsrc, sctl;
  769. /* fastpath out, to ease interrupt sharing */
  770. intsrc = inl(s->io+ES1370_REG_STATUS);
  771. if (!(intsrc & 0x80000000))
  772. return;
  773. spin_lock(&s->lock);
  774. /* clear audio interrupts first */
  775. sctl = s->sctrl;
  776. if (intsrc & STAT_ADC)
  777. sctl &= ~SCTRL_R1INTEN;
  778. if (intsrc & STAT_DAC1)
  779. sctl &= ~SCTRL_P1INTEN;
  780. if (intsrc & STAT_DAC2)
  781. sctl &= ~SCTRL_P2INTEN;
  782. outl(sctl, s->io+ES1370_REG_SERIAL_CONTROL);
  783. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  784. es1370_update_ptr(s);
  785. es1370_handle_midi(s);
  786. spin_unlock(&s->lock);
  787. }
  789. /* --------------------------------------------------------------------- */
  791. static const char invalid_magic[] = KERN_CRIT "es1370: invalid magic valuen";
  793. #define VALIDATE_STATE(s)                         
  794. ({                                                
  795. if (!(s) || (s)->magic != ES1370_MAGIC) { 
  796. printk(invalid_magic);            
  797. return -ENXIO;                    
  798. }                                         
  799. })
  801. /* --------------------------------------------------------------------- */
  803. static const struct {
  804. unsigned volidx:4;
  805. unsigned left:4;
  806. unsigned right:4;
  807. unsigned stereo:1;
  808. unsigned recmask:13;
  809. unsigned avail:1;
  810. } mixtable[SOUND_MIXER_NRDEVICES] = {
  811. [SOUND_MIXER_VOLUME] = { 0, 0x0, 0x1, 1, 0x0000, 1 },   /* master */
  812. [SOUND_MIXER_PCM]    = { 1, 0x2, 0x3, 1, 0x0400, 1 },   /* voice */
  813. [SOUND_MIXER_SYNTH]  = { 2, 0x4, 0x5, 1, 0x0060, 1 },   /* FM */
  814. [SOUND_MIXER_CD]     = { 3, 0x6, 0x7, 1, 0x0006, 1 },   /* CD */
  815. [SOUND_MIXER_LINE]   = { 4, 0x8, 0x9, 1, 0x0018, 1 },   /* Line */
  816. [SOUND_MIXER_LINE1]  = { 5, 0xa, 0xb, 1, 0x1800, 1 },   /* AUX */
  817. [SOUND_MIXER_LINE2]  = { 6, 0xc, 0x0, 0, 0x0100, 1 },   /* Mono1 */
  818. [SOUND_MIXER_LINE3]  = { 7, 0xd, 0x0, 0, 0x0200, 1 },   /* Mono2 */
  819. [SOUND_MIXER_MIC]    = { 8, 0xe, 0x0, 0, 0x0001, 1 },   /* Mic */
  820. [SOUND_MIXER_OGAIN]  = { 9, 0xf, 0x0, 0, 0x0000, 1 }    /* mono out */
  821. };
  823. static void set_recsrc(struct es1370_state *s, unsigned int val)
  824. {
  825. unsigned int i, j;
  827. for (j = i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  828. if (!(val & (1 << i)))
  829. continue;
  830. if (!mixtable[i].recmask) {
  831. val &= ~(1 << i);
  832. continue;
  833. }
  834. j |= mixtable[i].recmask;
  835. }
  836. s->mix.recsrc = val;
  837. wrcodec(s, 0x12, j & 0xd5);
  838. wrcodec(s, 0x13, j & 0xaa);
  839. wrcodec(s, 0x14, (j >> 8) & 0x17);
  840. wrcodec(s, 0x15, (j >> 8) & 0x0f);
  841. i = (j & 0x37f) | ((j << 1) & 0x3000) | 0xc60;
  842. if (!s->mix.imix) {
  843. i &= 0xff60;  /* mute record and line monitor */
  844. }
  845. wrcodec(s, 0x10, i);
  846. wrcodec(s, 0x11, i >> 8);
  847. }
  849. static int mixer_ioctl(struct es1370_state *s, unsigned int cmd, unsigned long arg)
  850. {
  851. unsigned long flags;
  852. int i, val;
  853. unsigned char l, r, rl, rr;
  855. VALIDATE_STATE(s);
  856. if (cmd == SOUND_MIXER_PRIVATE1) {
  857. /* enable/disable/query mixer preamp */
  858. if (get_user(val, (int *)arg))
  859. return -EFAULT;
  860. if (val != -1) {
  861. s->mix.micpreamp = !!val;
  862. wrcodec(s, 0x19, s->mix.micpreamp);
  863. }
  864. return put_user(s->mix.micpreamp, (int *)arg);
  865. }
  866. if (cmd == SOUND_MIXER_PRIVATE2) {
  867. /* enable/disable/query use of linein as second lineout */
  868. if (get_user(val, (int *)arg))
  869. return -EFAULT;
  870. if (val != -1) {
  871. spin_lock_irqsave(&s->lock, flags);
  872. if (val)
  873. s->ctrl |= CTRL_XCTL0;
  874. else
  875. s->ctrl &= ~CTRL_XCTL0;
  876. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  877. spin_unlock_irqrestore(&s->lock, flags);
  878. }
  879. return put_user((s->ctrl & CTRL_XCTL0) ? 1 : 0, (int *)arg);
  880. }
  881. if (cmd == SOUND_MIXER_PRIVATE3) {
  882. /* enable/disable/query microphone impedance setting */
  883. if (get_user(val, (int *)arg))
  884. return -EFAULT;
  885. if (val != -1) {
  886. spin_lock_irqsave(&s->lock, flags);
  887. if (val)
  888. s->ctrl |= CTRL_XCTL1;
  889. else
  890. s->ctrl &= ~CTRL_XCTL1;
  891. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  892. spin_unlock_irqrestore(&s->lock, flags);
  893. }
  894. return put_user((s->ctrl & CTRL_XCTL1) ? 1 : 0, (int *)arg);
  895. }
  896.         if (cmd == SOUND_MIXER_INFO) {
  897. mixer_info info;
  898. strncpy(info.id, "ES1370", sizeof(info.id));
  899. strncpy(info.name, "Ensoniq ES1370", sizeof(info.name));
  900. info.modify_counter = s->mix.modcnt;
  901. if (copy_to_user((void *)arg, &info, sizeof(info)))
  902. return -EFAULT;
  903. return 0;
  904. }
  905. if (cmd == SOUND_OLD_MIXER_INFO) {
  906. _old_mixer_info info;
  907. strncpy(info.id, "ES1370", sizeof(info.id));
  908. strncpy(info.name, "Ensoniq ES1370", sizeof(info.name));
  909. if (copy_to_user((void *)arg, &info, sizeof(info)))
  910. return -EFAULT;
  911. return 0;
  912. }
  913. if (cmd == OSS_GETVERSION)
  914. return put_user(SOUND_VERSION, (int *)arg);
  915. if (_IOC_TYPE(cmd) != 'M' || _SIOC_SIZE(cmd) != sizeof(int))
  916.                 return -EINVAL;
  917.         if (_SIOC_DIR(cmd) == _SIOC_READ) {
  918.                 switch (_IOC_NR(cmd)) {
  919.                 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
  920. return put_user(s->mix.recsrc, (int *)arg);
  922.                 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
  923. val = SOUND_MASK_IMIX;
  924. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
  925. if (mixtable[i].avail)
  926. val |= 1 << i;
  927. return put_user(val, (int *)arg);
  929.                 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
  930. for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
  931. if (mixtable[i].recmask)
  932. val |= 1 << i;
  933. return put_user(val, (int *)arg);
  935.                 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
  936. for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
  937. if (mixtable[i].stereo)
  938. val |= 1 << i;
  939. return put_user(val, (int *)arg);
  941.                 case SOUND_MIXER_CAPS:
  942. return put_user(0, (int *)arg);
  944. case SOUND_MIXER_IMIX:
  945. return put_user(s->mix.imix, (int *)arg);
  947. default:
  948. i = _IOC_NR(cmd);
  949.                         if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].avail)
  950.                                 return -EINVAL;
  951. return put_user(s->mix.vol[mixtable[i].volidx], (int *)arg);
  952. }
  953. }
  954.         if (_SIOC_DIR(cmd) != (_SIOC_READ|_SIOC_WRITE)) 
  955. return -EINVAL;
  956. s->mix.modcnt++;
  957. switch (_IOC_NR(cmd)) {
  959. case SOUND_MIXER_IMIX:
  960. if (get_user(s->mix.imix, (int *)arg))
  961. return -EFAULT;
  962. set_recsrc(s, s->mix.recsrc);
  963. return 0;
  965. case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
  966. if (get_user(val, (int *)arg))
  967. return -EFAULT;
  968. set_recsrc(s, val);
  969. return 0;
  971. default:
  972. i = _IOC_NR(cmd);
  973. if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].avail)
  974. return -EINVAL;
  975. if (get_user(val, (int *)arg))
  976. return -EFAULT;
  977. l = val & 0xff;
  978. if (l > 100)
  979. l = 100;
  980. if (mixtable[i].stereo) {
  981. r = (val >> 8) & 0xff;
  982. if (r > 100)
  983. r = 100;
  984. if (l < 7) {
  985. rl = 0x80;
  986. l = 0;
  987. } else {
  988. rl = 31 - ((l - 7) / 3);
  989. l = (31 - rl) * 3 + 7;
  990. }
  991. if (r < 7) {
  992. rr = 0x80;
  993. r = 0;
  994. } else {
  995. rr =  31 - ((r - 7) / 3);
  996. r = (31 - rr) * 3 + 7;
  997. }
  998. wrcodec(s, mixtable[i].right, rr);
  999. } else { 
  1000. if (mixtable[i].left == 15) {
  1001. if (l < 2) {
  1002. rr = rl = 0x80;
  1003. r = l = 0;
  1004. } else {
  1005. rl = 7 - ((l - 2) / 14);
  1006. r = l = (7 - rl) * 14 + 2;
  1007. }
  1008. } else {
  1009. if (l < 7) {
  1010. rl = 0x80;
  1011. r = l = 0;
  1012. } else {
  1013. rl = 31 - ((l - 7) / 3);
  1014. r = l = (31 - rl) * 3 + 7;
  1015. }
  1016. }
  1017. }
  1018. wrcodec(s, mixtable[i].left, rl);
  1019. #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
  1020. s->mix.vol[mixtable[i].volidx] = ((unsigned int)r << 8) | l;
  1021. #else
  1022. s->mix.vol[mixtable[i].volidx] = val;
  1023. #endif
  1024.                 return put_user(s->mix.vol[mixtable[i].volidx], (int *)arg);
  1025. }
  1026. }
  1028. /* --------------------------------------------------------------------- */
  1030. static int es1370_open_mixdev(struct inode *inode, struct file *file)
  1031. {
  1032. int minor = MINOR(inode->i_rdev);
  1033. struct list_head *list;
  1034. struct es1370_state *s;
  1036. for (list = devs.next; ; list = list->next) {
  1037. if (list == &devs)
  1038. return -ENODEV;
  1039. s = list_entry(list, struct es1370_state, devs);
  1040. if (s->dev_mixer == minor)
  1041. break;
  1042. }
  1043.         VALIDATE_STATE(s);
  1044. file->private_data = s;
  1045. return 0;
  1046. }
  1048. static int es1370_release_mixdev(struct inode *inode, struct file *file)
  1049. {
  1050. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1052. VALIDATE_STATE(s);
  1053. return 0;
  1054. }
  1056. static int es1370_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  1057. {
  1058. return mixer_ioctl((struct es1370_state *)file->private_data, cmd, arg);
  1059. }
  1061. static /*const*/ struct file_operations es1370_mixer_fops = {
  1062. owner: THIS_MODULE,
  1063. llseek: no_llseek,
  1064. ioctl: es1370_ioctl_mixdev,
  1065. open: es1370_open_mixdev,
  1066. release: es1370_release_mixdev,
  1067. };
  1069. /* --------------------------------------------------------------------- */
  1071. static int drain_dac1(struct es1370_state *s, int nonblock)
  1072. {
  1073. DECLARE_WAITQUEUE(wait, current);
  1074. unsigned long flags;
  1075. int count, tmo;
  1077. if (s->dma_dac1.mapped || !s->dma_dac1.ready)
  1078. return 0;
  1079.         add_wait_queue(&s->dma_dac1.wait, &wait);
  1080.         for (;;) {
  1081. __set_current_state(TASK_INTERRUPTIBLE);
  1082.                 spin_lock_irqsave(&s->lock, flags);
  1083. count = s->dma_dac1.count;
  1084.                 spin_unlock_irqrestore(&s->lock, flags);
  1085. if (count <= 0)
  1086. break;
  1087. if (signal_pending(current))
  1088.                         break;
  1089.                 if (nonblock) {
  1090.                         remove_wait_queue(&s->dma_dac1.wait, &wait);
  1091.                         set_current_state(TASK_RUNNING);
  1092.                         return -EBUSY;
  1093.                 }
  1094. tmo = 3 * HZ * (count + s->dma_dac1.fragsize) / 2
  1095. / dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL];
  1096. tmo >>= sample_shift[(s->sctrl & SCTRL_P1FMT) >> SCTRL_SH_P1FMT];
  1097. if (!schedule_timeout(tmo + 1))
  1098. DBG(printk(KERN_DEBUG "es1370: dma timed out??n");)
  1099.         }
  1100.         remove_wait_queue(&s->dma_dac1.wait, &wait);
  1101.         set_current_state(TASK_RUNNING);
  1102.         if (signal_pending(current))
  1103.                 return -ERESTARTSYS;
  1104.         return 0;
  1105. }
  1107. static int drain_dac2(struct es1370_state *s, int nonblock)
  1108. {
  1109. DECLARE_WAITQUEUE(wait, current);
  1110. unsigned long flags;
  1111. int count, tmo;
  1113. if (s->dma_dac2.mapped || !s->dma_dac2.ready)
  1114. return 0;
  1115.         add_wait_queue(&s->dma_dac2.wait, &wait);
  1116.         for (;;) {
  1117. __set_current_state(TASK_INTERRUPTIBLE);
  1118.                 spin_lock_irqsave(&s->lock, flags);
  1119. count = s->dma_dac2.count;
  1120.                 spin_unlock_irqrestore(&s->lock, flags);
  1121. if (count <= 0)
  1122. break;
  1123. if (signal_pending(current))
  1124.                         break;
  1125.                 if (nonblock) {
  1126.                         remove_wait_queue(&s->dma_dac2.wait, &wait);
  1127.                         set_current_state(TASK_RUNNING);
  1128.                         return -EBUSY;
  1129.                 }
  1130. tmo = 3 * HZ * (count + s->dma_dac2.fragsize) / 2
  1131. / DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV);
  1132. tmo >>= sample_shift[(s->sctrl & SCTRL_P2FMT) >> SCTRL_SH_P2FMT];
  1133. if (!schedule_timeout(tmo + 1))
  1134. DBG(printk(KERN_DEBUG "es1370: dma timed out??n");)
  1135.         }
  1136.         remove_wait_queue(&s->dma_dac2.wait, &wait);
  1137.         set_current_state(TASK_RUNNING);
  1138.         if (signal_pending(current))
  1139.                 return -ERESTARTSYS;
  1140.         return 0;
  1141. }
  1143. /* --------------------------------------------------------------------- */
  1145. static ssize_t es1370_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
  1146. {
  1147. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1148. DECLARE_WAITQUEUE(wait, current);
  1149. ssize_t ret = 0;
  1150. unsigned long flags;
  1151. unsigned swptr;
  1152. int cnt;
  1154. VALIDATE_STATE(s);
  1155. if (ppos != &file->f_pos)
  1156. return -ESPIPE;
  1157. if (s->dma_adc.mapped)
  1158. return -ENXIO;
  1159. if (!access_ok(VERIFY_WRITE, buffer, count))
  1160. return -EFAULT;
  1161. down(&s->sem);
  1162. if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
  1163. goto out;
  1164.         
  1165. add_wait_queue(&s->dma_adc.wait, &wait);
  1166. while (count > 0) {
  1167. spin_lock_irqsave(&s->lock, flags);
  1168. swptr = s->dma_adc.swptr;
  1169. cnt = s->dma_adc.dmasize-swptr;
  1170. if (s->dma_adc.count < cnt)
  1171. cnt = s->dma_adc.count;
  1172. if (cnt <= 0)
  1173. __set_current_state(TASK_INTERRUPTIBLE);
  1174. spin_unlock_irqrestore(&s->lock, flags);
  1175. if (cnt > count)
  1176. cnt = count;
  1177. if (cnt <= 0) {
  1178. if (s->dma_adc.enabled)
  1179. start_adc(s);
  1180. if (file->f_flags & O_NONBLOCK) {
  1181. if (!ret)
  1182. ret = -EAGAIN;
  1183. goto out;
  1184. }
  1185. up(&s->sem);
  1186. schedule();
  1187. if (signal_pending(current)) {
  1188. if (!ret)
  1189. ret = -ERESTARTSYS;
  1190. goto out;
  1191. }
  1192. down(&s->sem);
  1193. if (s->dma_adc.mapped)
  1194. {
  1195. ret = -ENXIO;
  1196. goto out;
  1197. }
  1198. continue;
  1199. }
  1200. if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt)) {
  1201. if (!ret)
  1202. ret = -EFAULT;
  1203. goto out;
  1204. }
  1205. swptr = (swptr + cnt) % s->dma_adc.dmasize;
  1206. spin_lock_irqsave(&s->lock, flags);
  1207. s->dma_adc.swptr = swptr;
  1208. s->dma_adc.count -= cnt;
  1209. spin_unlock_irqrestore(&s->lock, flags);
  1210. count -= cnt;
  1211. buffer += cnt;
  1212. ret += cnt;
  1213. if (s->dma_adc.enabled)
  1214. start_adc(s);
  1215. }
  1216. out:
  1217. up(&s->sem);
  1218.         remove_wait_queue(&s->dma_adc.wait, &wait);
  1219. set_current_state(TASK_RUNNING);
  1220. return ret;
  1221. }
  1223. static ssize_t es1370_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
  1224. {
  1225. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1226. DECLARE_WAITQUEUE(wait, current);
  1227. ssize_t ret = 0;
  1228. unsigned long flags;
  1229. unsigned swptr;
  1230. int cnt;
  1232. VALIDATE_STATE(s);
  1233. if (ppos != &file->f_pos)
  1234. return -ESPIPE;
  1235. if (s->dma_dac2.mapped)
  1236. return -ENXIO;
  1237. if (!access_ok(VERIFY_READ, buffer, count))
  1238. return -EFAULT;
  1239. down(&s->sem);
  1240. if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
  1241. goto out;
  1242. ret = 0;
  1243.         add_wait_queue(&s->dma_dac2.wait, &wait);
  1244. while (count > 0) {
  1245. spin_lock_irqsave(&s->lock, flags);
  1246. if (s->dma_dac2.count < 0) {
  1247. s->dma_dac2.count = 0;
  1248. s->dma_dac2.swptr = s->dma_dac2.hwptr;
  1249. }
  1250. swptr = s->dma_dac2.swptr;
  1251. cnt = s->dma_dac2.dmasize-swptr;
  1252. if (s->dma_dac2.count + cnt > s->dma_dac2.dmasize)
  1253. cnt = s->dma_dac2.dmasize - s->dma_dac2.count;
  1254. if (cnt <= 0)
  1255. __set_current_state(TASK_INTERRUPTIBLE);
  1256. spin_unlock_irqrestore(&s->lock, flags);
  1257. if (cnt > count)
  1258. cnt = count;
  1259. if (cnt <= 0) {
  1260. if (s->dma_dac2.enabled)
  1261. start_dac2(s);
  1262. if (file->f_flags & O_NONBLOCK) {
  1263. if (!ret)
  1264. ret = -EAGAIN;
  1265. goto out;
  1266. }
  1267. up(&s->sem);
  1268. schedule();
  1269. if (signal_pending(current)) {
  1270. if (!ret)
  1271. ret = -ERESTARTSYS;
  1272. goto out;
  1273. }
  1274. down(&s->sem);
  1275. if (s->dma_dac2.mapped)
  1276. {
  1277. ret = -ENXIO;
  1278. goto out;
  1279. }
  1280. continue;
  1281. }
  1282. if (copy_from_user(s->dma_dac2.rawbuf + swptr, buffer, cnt)) {
  1283. if (!ret)
  1284. ret = -EFAULT;
  1285. goto out;
  1286. }
  1287. swptr = (swptr + cnt) % s->dma_dac2.dmasize;
  1288. spin_lock_irqsave(&s->lock, flags);
  1289. s->dma_dac2.swptr = swptr;
  1290. s->dma_dac2.count += cnt;
  1291. s->dma_dac2.endcleared = 0;
  1292. spin_unlock_irqrestore(&s->lock, flags);
  1293. count -= cnt;
  1294. buffer += cnt;
  1295. ret += cnt;
  1296. if (s->dma_dac2.enabled)
  1297. start_dac2(s);
  1298. }
  1299. out:
  1300. up(&s->sem);
  1301.         remove_wait_queue(&s->dma_dac2.wait, &wait);
  1302. set_current_state(TASK_RUNNING);
  1303. return ret;
  1304. }
  1306. /* No kernel lock - we have our own spinlock */
  1307. static unsigned int es1370_poll(struct file *file, struct poll_table_struct *wait)
  1308. {
  1309. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1310. unsigned long flags;
  1311. unsigned int mask = 0;
  1313. VALIDATE_STATE(s);
  1314. if (file->f_mode & FMODE_WRITE) {
  1315. if (!s->dma_dac2.ready && prog_dmabuf_dac2(s))
  1316. return 0;
  1317. poll_wait(file, &s->dma_dac2.wait, wait);
  1318. }
  1319. if (file->f_mode & FMODE_READ) {
  1320. if (!s->dma_adc.ready && prog_dmabuf_adc(s))
  1321. return 0;
  1322. poll_wait(file, &s->dma_adc.wait, wait);
  1323. }
  1324. spin_lock_irqsave(&s->lock, flags);
  1325. es1370_update_ptr(s);
  1326. if (file->f_mode & FMODE_READ) {
  1327. if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
  1328. mask |= POLLIN | POLLRDNORM;
  1329. }
  1330. if (file->f_mode & FMODE_WRITE) {
  1331. if (s->dma_dac2.mapped) {
  1332. if (s->dma_dac2.count >= (signed)s->dma_dac2.fragsize) 
  1333. mask |= POLLOUT | POLLWRNORM;
  1334. } else {
  1335. if ((signed)s->dma_dac2.dmasize >= s->dma_dac2.count + (signed)s->dma_dac2.fragsize)
  1336. mask |= POLLOUT | POLLWRNORM;
  1337. }
  1338. }
  1339. spin_unlock_irqrestore(&s->lock, flags);
  1340. return mask;
  1341. }
  1343. static int es1370_mmap(struct file *file, struct vm_area_struct *vma)
  1344. {
  1345. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1346. struct dmabuf *db;
  1347. int ret = 0;
  1348. unsigned long size;
  1350. VALIDATE_STATE(s);
  1351. lock_kernel();
  1352. down(&s->sem);
  1353. if (vma->vm_flags & VM_WRITE) {
  1354. if ((ret = prog_dmabuf_dac2(s)) != 0) {
  1355. goto out;
  1356. }
  1357. db = &s->dma_dac2;
  1358. } else if (vma->vm_flags & VM_READ) {
  1359. if ((ret = prog_dmabuf_adc(s)) != 0) {
  1360. goto out;
  1361. }
  1362. db = &s->dma_adc;
  1363. } else  {
  1364. ret = -EINVAL;
  1365. goto out;
  1366. }
  1367. if (vma->vm_pgoff != 0) {
  1368. ret = -EINVAL;
  1369. goto out;
  1370. }
  1371. size = vma->vm_end - vma->vm_start;
  1372. if (size > (PAGE_SIZE << db->buforder)) {
  1373. ret = -EINVAL;
  1374. goto out;
  1375. }
  1376. if (remap_page_range(vma->vm_start, virt_to_phys(db->rawbuf), size, vma->vm_page_prot)) {
  1377. ret = -EAGAIN;
  1378. goto out;
  1379. }
  1380. db->mapped = 1;
  1381. out:
  1382. up(&s->sem);
  1383. unlock_kernel();
  1384. return ret;
  1385. }
  1387. static int es1370_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  1388. {
  1389. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1390. unsigned long flags;
  1391.         audio_buf_info abinfo;
  1392.         count_info cinfo;
  1393. int count;
  1394. int val, mapped, ret;
  1396. VALIDATE_STATE(s);
  1397.         mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac2.mapped) ||
  1398. ((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
  1399. switch (cmd) {
  1400. case OSS_GETVERSION:
  1401. return put_user(SOUND_VERSION, (int *)arg);
  1403. case SNDCTL_DSP_SYNC:
  1404. if (file->f_mode & FMODE_WRITE)
  1405. return drain_dac2(s, 0/*file->f_flags & O_NONBLOCK*/);
  1406. return 0;
  1408. case SNDCTL_DSP_SETDUPLEX:
  1409. return 0;
  1411. case SNDCTL_DSP_GETCAPS:
  1412. return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
  1414.         case SNDCTL_DSP_RESET:
  1415. if (file->f_mode & FMODE_WRITE) {
  1416. stop_dac2(s);
  1417. synchronize_irq();
  1418. s->dma_dac2.swptr = s->dma_dac2.hwptr = s->dma_dac2.count = s->dma_dac2.total_bytes = 0;
  1419. }
  1420. if (file->f_mode & FMODE_READ) {
  1421. stop_adc(s);
  1422. synchronize_irq();
  1423. s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
  1424. }
  1425. return 0;
  1427.         case SNDCTL_DSP_SPEED:
  1428.                 if (get_user(val, (int *)arg))
  1429. return -EFAULT;
  1430. if (val >= 0) {
  1431. if (s->open_mode & (~file->f_mode) & (FMODE_READ|FMODE_WRITE))
  1432. return -EINVAL;
  1433. if (val < 4000)
  1434. val = 4000;
  1435. if (val > 50000)
  1436. val = 50000;
  1437. stop_adc(s);
  1438. stop_dac2(s);
  1439. s->dma_adc.ready = s->dma_dac2.ready = 0;
  1440. spin_lock_irqsave(&s->lock, flags);
  1441. s->ctrl = (s->ctrl & ~CTRL_PCLKDIV) | (DAC2_SRTODIV(val) << CTRL_SH_PCLKDIV);
  1442. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  1443. spin_unlock_irqrestore(&s->lock, flags);
  1444. }
  1445. return put_user(DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV), (int *)arg);
  1447.         case SNDCTL_DSP_STEREO:
  1448.                 if (get_user(val, (int *)arg))
  1449. return -EFAULT;
  1450. if (file->f_mode & FMODE_READ) {
  1451. stop_adc(s);
  1452. s->dma_adc.ready = 0;
  1453. spin_lock_irqsave(&s->lock, flags);
  1454. if (val)
  1455. s->sctrl |= SCTRL_R1SMB;
  1456. else
  1457. s->sctrl &= ~SCTRL_R1SMB;
  1458. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1459. spin_unlock_irqrestore(&s->lock, flags);
  1460. }
  1461. if (file->f_mode & FMODE_WRITE) {
  1462. stop_dac2(s);
  1463. s->dma_dac2.ready = 0;
  1464. spin_lock_irqsave(&s->lock, flags);
  1465. if (val)
  1466. s->sctrl |= SCTRL_P2SMB;
  1467. else
  1468. s->sctrl &= ~SCTRL_P2SMB;
  1469. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1470. spin_unlock_irqrestore(&s->lock, flags);
  1471.                 }
  1472. return 0;
  1474.         case SNDCTL_DSP_CHANNELS:
  1475.                 if (get_user(val, (int *)arg))
  1476. return -EFAULT;
  1477. if (val != 0) {
  1478. if (file->f_mode & FMODE_READ) {
  1479. stop_adc(s);
  1480. s->dma_adc.ready = 0;
  1481. spin_lock_irqsave(&s->lock, flags);
  1482. if (val >= 2)
  1483. s->sctrl |= SCTRL_R1SMB;
  1484. else
  1485. s->sctrl &= ~SCTRL_R1SMB;
  1486. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1487. spin_unlock_irqrestore(&s->lock, flags);
  1488. }
  1489. if (file->f_mode & FMODE_WRITE) {
  1490. stop_dac2(s);
  1491. s->dma_dac2.ready = 0;
  1492. spin_lock_irqsave(&s->lock, flags);
  1493. if (val >= 2)
  1494. s->sctrl |= SCTRL_P2SMB;
  1495. else
  1496. s->sctrl &= ~SCTRL_P2SMB;
  1497. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1498. spin_unlock_irqrestore(&s->lock, flags);
  1499. }
  1500. }
  1501. return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SMB : SCTRL_P2SMB)) ? 2 : 1, (int *)arg);
  1503. case SNDCTL_DSP_GETFMTS: /* Returns a mask */
  1504.                 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
  1506. case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
  1507. if (get_user(val, (int *)arg))
  1508. return -EFAULT;
  1509. if (val != AFMT_QUERY) {
  1510. if (file->f_mode & FMODE_READ) {
  1511. stop_adc(s);
  1512. s->dma_adc.ready = 0;
  1513. spin_lock_irqsave(&s->lock, flags);
  1514. if (val == AFMT_S16_LE)
  1515. s->sctrl |= SCTRL_R1SEB;
  1516. else
  1517. s->sctrl &= ~SCTRL_R1SEB;
  1518. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1519. spin_unlock_irqrestore(&s->lock, flags);
  1520. }
  1521. if (file->f_mode & FMODE_WRITE) {
  1522. stop_dac2(s);
  1523. s->dma_dac2.ready = 0;
  1524. spin_lock_irqsave(&s->lock, flags);
  1525. if (val == AFMT_S16_LE)
  1526. s->sctrl |= SCTRL_P2SEB;
  1527. else
  1528. s->sctrl &= ~SCTRL_P2SEB;
  1529. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1530. spin_unlock_irqrestore(&s->lock, flags);
  1531. }
  1532. }
  1533. return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SEB : SCTRL_P2SEB)) ? 
  1534. AFMT_S16_LE : AFMT_U8, (int *)arg);
  1536. case SNDCTL_DSP_POST:
  1537.                 return 0;
  1539.         case SNDCTL_DSP_GETTRIGGER:
  1540. val = 0;
  1541. if (file->f_mode & FMODE_READ && s->ctrl & CTRL_ADC_EN) 
  1542. val |= PCM_ENABLE_INPUT;
  1543. if (file->f_mode & FMODE_WRITE && s->ctrl & CTRL_DAC2_EN) 
  1544. val |= PCM_ENABLE_OUTPUT;
  1545. return put_user(val, (int *)arg);
  1547. case SNDCTL_DSP_SETTRIGGER:
  1548. if (get_user(val, (int *)arg))
  1549. return -EFAULT;
  1550. if (file->f_mode & FMODE_READ) {
  1551. if (val & PCM_ENABLE_INPUT) {
  1552. if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
  1553. return ret;
  1554. s->dma_adc.enabled = 1;
  1555. start_adc(s);
  1556. } else {
  1557. s->dma_adc.enabled = 0;
  1558. stop_adc(s);
  1559. }
  1560. }
  1561. if (file->f_mode & FMODE_WRITE) {
  1562. if (val & PCM_ENABLE_OUTPUT) {
  1563. if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
  1564. return ret;
  1565. s->dma_dac2.enabled = 1;
  1566. start_dac2(s);
  1567. } else {
  1568. s->dma_dac2.enabled = 0;
  1569. stop_dac2(s);
  1570. }
  1571. }
  1572. return 0;
  1574. case SNDCTL_DSP_GETOSPACE:
  1575. if (!(file->f_mode & FMODE_WRITE))
  1576. return -EINVAL;
  1577. if (!s->dma_dac2.ready && (val = prog_dmabuf_dac2(s)) != 0)
  1578. return val;
  1579. spin_lock_irqsave(&s->lock, flags);
  1580. es1370_update_ptr(s);
  1581. abinfo.fragsize = s->dma_dac2.fragsize;
  1582. count = s->dma_dac2.count;
  1583. if (count < 0)
  1584. count = 0;
  1585.                 abinfo.bytes = s->dma_dac2.dmasize - count;
  1586.                 abinfo.fragstotal = s->dma_dac2.numfrag;
  1587.                 abinfo.fragments = abinfo.bytes >> s->dma_dac2.fragshift;      
  1588. spin_unlock_irqrestore(&s->lock, flags);
  1589. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  1591. case SNDCTL_DSP_GETISPACE:
  1592. if (!(file->f_mode & FMODE_READ))
  1593. return -EINVAL;
  1594. if (!s->dma_adc.ready && (val = prog_dmabuf_adc(s)) != 0)
  1595. return val;
  1596. spin_lock_irqsave(&s->lock, flags);
  1597. es1370_update_ptr(s);
  1598. abinfo.fragsize = s->dma_adc.fragsize;
  1599. count = s->dma_adc.count;
  1600. if (count < 0)
  1601. count = 0;
  1602.                 abinfo.bytes = count;
  1603.                 abinfo.fragstotal = s->dma_adc.numfrag;
  1604.                 abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;      
  1605. spin_unlock_irqrestore(&s->lock, flags);
  1606. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  1608.         case SNDCTL_DSP_NONBLOCK:
  1609.                 file->f_flags |= O_NONBLOCK;
  1610.                 return 0;
  1612.         case SNDCTL_DSP_GETODELAY:
  1613. if (!(file->f_mode & FMODE_WRITE))
  1614. return -EINVAL;
  1615. if (!s->dma_dac2.ready && (val = prog_dmabuf_dac2(s)) != 0)
  1616. return val;
  1617. spin_lock_irqsave(&s->lock, flags);
  1618. es1370_update_ptr(s);
  1619.                 count = s->dma_dac2.count;
  1620. spin_unlock_irqrestore(&s->lock, flags);
  1621. if (count < 0)
  1622. count = 0;
  1623. return put_user(count, (int *)arg);
  1625.         case SNDCTL_DSP_GETIPTR:
  1626. if (!(file->f_mode & FMODE_READ))
  1627. return -EINVAL;
  1628. if (!s->dma_adc.ready && (val = prog_dmabuf_adc(s)) != 0)
  1629. return val;
  1630. spin_lock_irqsave(&s->lock, flags);
  1631. es1370_update_ptr(s);
  1632.                 cinfo.bytes = s->dma_adc.total_bytes;
  1633. count = s->dma_adc.count;
  1634. if (count < 0)
  1635. count = 0;
  1636.                 cinfo.blocks = count >> s->dma_adc.fragshift;
  1637.                 cinfo.ptr = s->dma_adc.hwptr;
  1638. if (s->dma_adc.mapped)
  1639. s->dma_adc.count &= s->dma_adc.fragsize-1;
  1640. spin_unlock_irqrestore(&s->lock, flags);
  1641.                 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
  1643.         case SNDCTL_DSP_GETOPTR:
  1644. if (!(file->f_mode & FMODE_WRITE))
  1645. return -EINVAL;
  1646. if (!s->dma_dac2.ready && (val = prog_dmabuf_dac2(s)) != 0)
  1647. return val;
  1648. spin_lock_irqsave(&s->lock, flags);
  1649. es1370_update_ptr(s);
  1650.                 cinfo.bytes = s->dma_dac2.total_bytes;
  1651. count = s->dma_dac2.count;
  1652. if (count < 0)
  1653. count = 0;
  1654.                 cinfo.blocks = count >> s->dma_dac2.fragshift;
  1655.                 cinfo.ptr = s->dma_dac2.hwptr;
  1656. if (s->dma_dac2.mapped)
  1657. s->dma_dac2.count &= s->dma_dac2.fragsize-1;
  1658. spin_unlock_irqrestore(&s->lock, flags);
  1659.                 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
  1661.         case SNDCTL_DSP_GETBLKSIZE:
  1662. if (file->f_mode & FMODE_WRITE) {
  1663. if ((val = prog_dmabuf_dac2(s)))
  1664. return val;
  1665. return put_user(s->dma_dac2.fragsize, (int *)arg);
  1666. }
  1667. if ((val = prog_dmabuf_adc(s)))
  1668. return val;
  1669. return put_user(s->dma_adc.fragsize, (int *)arg);
  1671.         case SNDCTL_DSP_SETFRAGMENT:
  1672.                 if (get_user(val, (int *)arg))
  1673. return -EFAULT;
  1674. if (file->f_mode & FMODE_READ) {
  1675. s->dma_adc.ossfragshift = val & 0xffff;
  1676. s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
  1677. if (s->dma_adc.ossfragshift < 4)
  1678. s->dma_adc.ossfragshift = 4;
  1679. if (s->dma_adc.ossfragshift > 15)
  1680. s->dma_adc.ossfragshift = 15;
  1681. if (s->dma_adc.ossmaxfrags < 4)
  1682. s->dma_adc.ossmaxfrags = 4;
  1683. }
  1684. if (file->f_mode & FMODE_WRITE) {
  1685. s->dma_dac2.ossfragshift = val & 0xffff;
  1686. s->dma_dac2.ossmaxfrags = (val >> 16) & 0xffff;
  1687. if (s->dma_dac2.ossfragshift < 4)
  1688. s->dma_dac2.ossfragshift = 4;
  1689. if (s->dma_dac2.ossfragshift > 15)
  1690. s->dma_dac2.ossfragshift = 15;
  1691. if (s->dma_dac2.ossmaxfrags < 4)
  1692. s->dma_dac2.ossmaxfrags = 4;
  1693. }
  1694. return 0;
  1696.         case SNDCTL_DSP_SUBDIVIDE:
  1697. if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
  1698.     (file->f_mode & FMODE_WRITE && s->dma_dac2.subdivision))
  1699. return -EINVAL;
  1700.                 if (get_user(val, (int *)arg))
  1701. return -EFAULT;
  1702. if (val != 1 && val != 2 && val != 4)
  1703. return -EINVAL;
  1704. if (file->f_mode & FMODE_READ)
  1705. s->dma_adc.subdivision = val;
  1706. if (file->f_mode & FMODE_WRITE)
  1707. s->dma_dac2.subdivision = val;
  1708. return 0;
  1710.         case SOUND_PCM_READ_RATE:
  1711. return put_user(DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV), (int *)arg);
  1713.         case SOUND_PCM_READ_CHANNELS:
  1714. return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SMB : SCTRL_P2SMB)) ?
  1715. 2 : 1, (int *)arg);
  1717.         case SOUND_PCM_READ_BITS:
  1718. return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SEB : SCTRL_P2SEB)) ? 
  1719. 16 : 8, (int *)arg);
  1721.         case SOUND_PCM_WRITE_FILTER:
  1722.         case SNDCTL_DSP_SETSYNCRO:
  1723.         case SOUND_PCM_READ_FILTER:
  1724.                 return -EINVAL;
  1726. }
  1727. return mixer_ioctl(s, cmd, arg);
  1728. }
  1730. static int es1370_open(struct inode *inode, struct file *file)
  1731. {
  1732. int minor = MINOR(inode->i_rdev);
  1733. DECLARE_WAITQUEUE(wait, current);
  1734. unsigned long flags;
  1735. struct list_head *list;
  1736. struct es1370_state *s;
  1738. for (list = devs.next; ; list = list->next) {
  1739. if (list == &devs)
  1740. return -ENODEV;
  1741. s = list_entry(list, struct es1370_state, devs);
  1742. if (!((s->dev_audio ^ minor) & ~0xf))
  1743. break;
  1744. }
  1745.         VALIDATE_STATE(s);
  1746. file->private_data = s;
  1747. /* wait for device to become free */
  1748. down(&s->open_sem);
  1749. while (s->open_mode & file->f_mode) {
  1750. if (file->f_flags & O_NONBLOCK) {
  1751. up(&s->open_sem);
  1752. return -EBUSY;
  1753. }
  1754. add_wait_queue(&s->open_wait, &wait);
  1755. __set_current_state(TASK_INTERRUPTIBLE);
  1756. up(&s->open_sem);
  1757. schedule();
  1758. remove_wait_queue(&s->open_wait, &wait);
  1759. set_current_state(TASK_RUNNING);
  1760. if (signal_pending(current))
  1761. return -ERESTARTSYS;
  1762. down(&s->open_sem);
  1763. }
  1764. spin_lock_irqsave(&s->lock, flags);
  1765. if (!(s->open_mode & (FMODE_READ|FMODE_WRITE)))
  1766. s->ctrl = (s->ctrl & ~CTRL_PCLKDIV) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV);
  1767. if (file->f_mode & FMODE_READ) {
  1768. s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
  1769. s->dma_adc.enabled = 1;
  1770. s->sctrl &= ~SCTRL_R1FMT;
  1771. if ((minor & 0xf) == SND_DEV_DSP16)
  1772. s->sctrl |= ES1370_FMT_S16_MONO << SCTRL_SH_R1FMT;
  1773. else
  1774. s->sctrl |= ES1370_FMT_U8_MONO << SCTRL_SH_R1FMT;
  1775. }
  1776. if (file->f_mode & FMODE_WRITE) {
  1777. s->dma_dac2.ossfragshift = s->dma_dac2.ossmaxfrags = s->dma_dac2.subdivision = 0;
  1778. s->dma_dac2.enabled = 1;
  1779. s->sctrl &= ~SCTRL_P2FMT;
  1780. if ((minor & 0xf) == SND_DEV_DSP16)
  1781. s->sctrl |= ES1370_FMT_S16_MONO << SCTRL_SH_P2FMT;
  1782. else
  1783. s->sctrl |= ES1370_FMT_U8_MONO << SCTRL_SH_P2FMT;
  1784. }
  1785. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  1786. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  1787. spin_unlock_irqrestore(&s->lock, flags);
  1788. s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
  1789. up(&s->open_sem);
  1790. init_MUTEX(&s->sem);
  1791. return 0;
  1792. }
  1794. static int es1370_release(struct inode *inode, struct file *file)
  1795. {
  1796. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1798. VALIDATE_STATE(s);
  1799. lock_kernel();
  1800. if (file->f_mode & FMODE_WRITE)
  1801. drain_dac2(s, file->f_flags & O_NONBLOCK);
  1802. down(&s->open_sem);
  1803. if (file->f_mode & FMODE_WRITE) {
  1804. stop_dac2(s);
  1805. synchronize_irq();
  1806. dealloc_dmabuf(s, &s->dma_dac2);
  1807. }
  1808. if (file->f_mode & FMODE_READ) {
  1809. stop_adc(s);
  1810. dealloc_dmabuf(s, &s->dma_adc);
  1811. }
  1812. s->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
  1813. wake_up(&s->open_wait);
  1814. up(&s->open_sem);
  1815. unlock_kernel();
  1816. return 0;
  1817. }
  1819. static /*const*/ struct file_operations es1370_audio_fops = {
  1820. owner: THIS_MODULE,
  1821. llseek: no_llseek,
  1822. read: es1370_read,
  1823. write: es1370_write,
  1824. poll: es1370_poll,
  1825. ioctl: es1370_ioctl,
  1826. mmap: es1370_mmap,
  1827. open: es1370_open,
  1828. release: es1370_release,
  1829. };
  1831. /* --------------------------------------------------------------------- */
  1833. static ssize_t es1370_write_dac(struct file *file, const char *buffer, size_t count, loff_t *ppos)
  1834. {
  1835. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1836. DECLARE_WAITQUEUE(wait, current);
  1837. ssize_t ret = 0;
  1838. unsigned long flags;
  1839. unsigned swptr;
  1840. int cnt;
  1842. VALIDATE_STATE(s);
  1843. if (ppos != &file->f_pos)
  1844. return -ESPIPE;
  1845. if (s->dma_dac1.mapped)
  1846. return -ENXIO;
  1847. if (!s->dma_dac1.ready && (ret = prog_dmabuf_dac1(s)))
  1848. return ret;
  1849. if (!access_ok(VERIFY_READ, buffer, count))
  1850. return -EFAULT;
  1851.         add_wait_queue(&s->dma_dac1.wait, &wait);
  1852. while (count > 0) {
  1853. spin_lock_irqsave(&s->lock, flags);
  1854. if (s->dma_dac1.count < 0) {
  1855. s->dma_dac1.count = 0;
  1856. s->dma_dac1.swptr = s->dma_dac1.hwptr;
  1857. }
  1858. swptr = s->dma_dac1.swptr;
  1859. cnt = s->dma_dac1.dmasize-swptr;
  1860. if (s->dma_dac1.count + cnt > s->dma_dac1.dmasize)
  1861. cnt = s->dma_dac1.dmasize - s->dma_dac1.count;
  1862. if (cnt <= 0)
  1863. __set_current_state(TASK_INTERRUPTIBLE);
  1864. spin_unlock_irqrestore(&s->lock, flags);
  1865. if (cnt > count)
  1866. cnt = count;
  1867. if (cnt <= 0) {
  1868. if (s->dma_dac1.enabled)
  1869. start_dac1(s);
  1870. if (file->f_flags & O_NONBLOCK) {
  1871. if (!ret)
  1872. ret = -EAGAIN;
  1873. break;
  1874. }
  1875. schedule();
  1876. if (signal_pending(current)) {
  1877. if (!ret)
  1878. ret = -ERESTARTSYS;
  1879. break;
  1880. }
  1881. continue;
  1882. }
  1883. if (copy_from_user(s->dma_dac1.rawbuf + swptr, buffer, cnt)) {
  1884. if (!ret)
  1885. ret = -EFAULT;
  1886. break;
  1887. }
  1888. swptr = (swptr + cnt) % s->dma_dac1.dmasize;
  1889. spin_lock_irqsave(&s->lock, flags);
  1890. s->dma_dac1.swptr = swptr;
  1891. s->dma_dac1.count += cnt;
  1892. s->dma_dac1.endcleared = 0;
  1893. spin_unlock_irqrestore(&s->lock, flags);
  1894. count -= cnt;
  1895. buffer += cnt;
  1896. ret += cnt;
  1897. if (s->dma_dac1.enabled)
  1898. start_dac1(s);
  1899. }
  1900.         remove_wait_queue(&s->dma_dac1.wait, &wait);
  1901. set_current_state(TASK_RUNNING);
  1902. return ret;
  1903. }
  1905. /* No kernel lock - we have our own spinlock */
  1906. static unsigned int es1370_poll_dac(struct file *file, struct poll_table_struct *wait)
  1907. {
  1908. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1909. unsigned long flags;
  1910. unsigned int mask = 0;
  1912. VALIDATE_STATE(s);
  1913. if (!s->dma_dac1.ready && prog_dmabuf_dac1(s))
  1914. return 0;
  1915. poll_wait(file, &s->dma_dac1.wait, wait);
  1916. spin_lock_irqsave(&s->lock, flags);
  1917. es1370_update_ptr(s);
  1918. if (s->dma_dac1.mapped) {
  1919. if (s->dma_dac1.count >= (signed)s->dma_dac1.fragsize)
  1920. mask |= POLLOUT | POLLWRNORM;
  1921. } else {
  1922. if ((signed)s->dma_dac1.dmasize >= s->dma_dac1.count + (signed)s->dma_dac1.fragsize)
  1923. mask |= POLLOUT | POLLWRNORM;
  1924. }
  1925. spin_unlock_irqrestore(&s->lock, flags);
  1926. return mask;
  1927. }
  1929. static int es1370_mmap_dac(struct file *file, struct vm_area_struct *vma)
  1930. {
  1931. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1932. int ret;
  1933. unsigned long size;
  1935. VALIDATE_STATE(s);
  1936. if (!(vma->vm_flags & VM_WRITE))
  1937. return -EINVAL;
  1938. lock_kernel();
  1939. if ((ret = prog_dmabuf_dac1(s)) != 0)
  1940. goto out;
  1941. ret = -EINVAL;
  1942. if (vma->vm_pgoff != 0)
  1943. goto out;
  1944. size = vma->vm_end - vma->vm_start;
  1945. if (size > (PAGE_SIZE << s->dma_dac1.buforder))
  1946. goto out;
  1947. ret = -EAGAIN;
  1948. if (remap_page_range(vma->vm_start, virt_to_phys(s->dma_dac1.rawbuf), size, vma->vm_page_prot))
  1949. goto out;
  1950. s->dma_dac1.mapped = 1;
  1951. ret = 0;
  1952. out:
  1953. unlock_kernel();
  1954. return ret;
  1955. }
  1957. static int es1370_ioctl_dac(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  1958. {
  1959. struct es1370_state *s = (struct es1370_state *)file->private_data;
  1960. unsigned long flags;
  1961.         audio_buf_info abinfo;
  1962.         count_info cinfo;
  1963. int count;
  1964. unsigned ctrl;
  1965. int val, ret;
  1967. VALIDATE_STATE(s);
  1968. switch (cmd) {
  1969. case OSS_GETVERSION:
  1970. return put_user(SOUND_VERSION, (int *)arg);
  1972. case SNDCTL_DSP_SYNC:
  1973. return drain_dac1(s, 0/*file->f_flags & O_NONBLOCK*/);
  1975. case SNDCTL_DSP_SETDUPLEX:
  1976. return -EINVAL;
  1978. case SNDCTL_DSP_GETCAPS:
  1979. return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
  1981.         case SNDCTL_DSP_RESET:
  1982. stop_dac1(s);
  1983. synchronize_irq();
  1984. s->dma_dac1.swptr = s->dma_dac1.hwptr = s->dma_dac1.count = s->dma_dac1.total_bytes = 0;
  1985. return 0;
  1987.         case SNDCTL_DSP_SPEED:
  1988.                 if (get_user(val, (int *)arg))
  1989. return -EFAULT;
  1990. if (val >= 0) {
  1991. stop_dac1(s);
  1992. s->dma_dac1.ready = 0;
  1993. for (ctrl = 0; ctrl <= 2; ctrl++)
  1994. if (val < (dac1_samplerate[ctrl] + dac1_samplerate[ctrl+1]) / 2)
  1995. break;
  1996. spin_lock_irqsave(&s->lock, flags);
  1997. s->ctrl = (s->ctrl & ~CTRL_WTSRSEL) | (ctrl << CTRL_SH_WTSRSEL);
  1998. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  1999. spin_unlock_irqrestore(&s->lock, flags);
  2000. }
  2001. return put_user(dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL], (int *)arg);
  2003.         case SNDCTL_DSP_STEREO:
  2004.                 if (get_user(val, (int *)arg))
  2005. return -EFAULT;
  2006. stop_dac1(s);
  2007. s->dma_dac1.ready = 0;
  2008. spin_lock_irqsave(&s->lock, flags);
  2009. if (val)
  2010. s->sctrl |= SCTRL_P1SMB;
  2011. else
  2012. s->sctrl &= ~SCTRL_P1SMB;
  2013. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  2014. spin_unlock_irqrestore(&s->lock, flags);
  2015. return 0;
  2017.         case SNDCTL_DSP_CHANNELS:
  2018.                 if (get_user(val, (int *)arg))
  2019. return -EFAULT;
  2020. if (val != 0) {
  2021. if (s->dma_dac1.mapped)
  2022. return -EINVAL;
  2023. stop_dac1(s);
  2024. s->dma_dac1.ready = 0;
  2025. spin_lock_irqsave(&s->lock, flags);
  2026. if (val >= 2)
  2027. s->sctrl |= SCTRL_P1SMB;
  2028. else
  2029. s->sctrl &= ~SCTRL_P1SMB;
  2030. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  2031. spin_unlock_irqrestore(&s->lock, flags);
  2032. }
  2033. return put_user((s->sctrl & SCTRL_P1SMB) ? 2 : 1, (int *)arg);
  2035.         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
  2036.                 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
  2038.         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
  2039. if (get_user(val, (int *)arg))
  2040. return -EFAULT;
  2041. if (val != AFMT_QUERY) {
  2042. stop_dac1(s);
  2043. s->dma_dac1.ready = 0;
  2044. spin_lock_irqsave(&s->lock, flags);
  2045. if (val == AFMT_S16_LE)
  2046. s->sctrl |= SCTRL_P1SEB;
  2047. else
  2048. s->sctrl &= ~SCTRL_P1SEB;
  2049. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  2050. spin_unlock_irqrestore(&s->lock, flags);
  2051. }
  2052. return put_user((s->sctrl & SCTRL_P1SEB) ? AFMT_S16_LE : AFMT_U8, (int *)arg);
  2054.         case SNDCTL_DSP_POST:
  2055.                 return 0;
  2057.         case SNDCTL_DSP_GETTRIGGER:
  2058. return put_user((s->ctrl & CTRL_DAC1_EN) ? PCM_ENABLE_OUTPUT : 0, (int *)arg);
  2060. case SNDCTL_DSP_SETTRIGGER:
  2061. if (get_user(val, (int *)arg))
  2062. return -EFAULT;
  2063. if (val & PCM_ENABLE_OUTPUT) {
  2064. if (!s->dma_dac1.ready && (ret = prog_dmabuf_dac1(s)))
  2065. return ret;
  2066. s->dma_dac1.enabled = 1;
  2067. start_dac1(s);
  2068. } else {
  2069. s->dma_dac1.enabled = 0;
  2070. stop_dac1(s);
  2071. }
  2072. return 0;
  2074. case SNDCTL_DSP_GETOSPACE:
  2075. if (!s->dma_dac1.ready && (val = prog_dmabuf_dac1(s)) != 0)
  2076. return val;
  2077. spin_lock_irqsave(&s->lock, flags);
  2078. es1370_update_ptr(s);
  2079. abinfo.fragsize = s->dma_dac1.fragsize;
  2080. count = s->dma_dac1.count;
  2081. if (count < 0)
  2082. count = 0;
  2083.                 abinfo.bytes = s->dma_dac1.dmasize - count;
  2084.                 abinfo.fragstotal = s->dma_dac1.numfrag;
  2085.                 abinfo.fragments = abinfo.bytes >> s->dma_dac1.fragshift;      
  2086. spin_unlock_irqrestore(&s->lock, flags);
  2087. return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
  2089.         case SNDCTL_DSP_NONBLOCK:
  2090.                 file->f_flags |= O_NONBLOCK;
  2091.                 return 0;
  2093.         case SNDCTL_DSP_GETODELAY:
  2094. if (!s->dma_dac1.ready && (val = prog_dmabuf_dac1(s)) != 0)
  2095. return val;
  2096. spin_lock_irqsave(&s->lock, flags);
  2097. es1370_update_ptr(s);
  2098.                 count = s->dma_dac1.count;
  2099. spin_unlock_irqrestore(&s->lock, flags);
  2100. if (count < 0)
  2101. count = 0;
  2102. return put_user(count, (int *)arg);
  2104.         case SNDCTL_DSP_GETOPTR:
  2105. if (!s->dma_dac1.ready && (val = prog_dmabuf_dac1(s)) != 0)
  2106. return val;
  2107. spin_lock_irqsave(&s->lock, flags);
  2108. es1370_update_ptr(s);
  2109.                 cinfo.bytes = s->dma_dac1.total_bytes;
  2110. count = s->dma_dac1.count;
  2111. if (count < 0)
  2112. count = 0;
  2113.                 cinfo.blocks = count >> s->dma_dac1.fragshift;
  2114.                 cinfo.ptr = s->dma_dac1.hwptr;
  2115. if (s->dma_dac1.mapped)
  2116. s->dma_dac1.count &= s->dma_dac1.fragsize-1;
  2117. spin_unlock_irqrestore(&s->lock, flags);
  2118.                 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
  2120.         case SNDCTL_DSP_GETBLKSIZE:
  2121. if ((val = prog_dmabuf_dac1(s)))
  2122. return val;
  2123.                 return put_user(s->dma_dac1.fragsize, (int *)arg);
  2125.         case SNDCTL_DSP_SETFRAGMENT:
  2126.                 if (get_user(val, (int *)arg))
  2127. return -EFAULT;
  2128. s->dma_dac1.ossfragshift = val & 0xffff;
  2129. s->dma_dac1.ossmaxfrags = (val >> 16) & 0xffff;
  2130. if (s->dma_dac1.ossfragshift < 4)
  2131. s->dma_dac1.ossfragshift = 4;
  2132. if (s->dma_dac1.ossfragshift > 15)
  2133. s->dma_dac1.ossfragshift = 15;
  2134. if (s->dma_dac1.ossmaxfrags < 4)
  2135. s->dma_dac1.ossmaxfrags = 4;
  2136. return 0;
  2138.         case SNDCTL_DSP_SUBDIVIDE:
  2139. if (s->dma_dac1.subdivision)
  2140. return -EINVAL;
  2141.                 if (get_user(val, (int *)arg))
  2142. return -EFAULT;
  2143. if (val != 1 && val != 2 && val != 4)
  2144. return -EINVAL;
  2145. s->dma_dac1.subdivision = val;
  2146. return 0;
  2148.         case SOUND_PCM_READ_RATE:
  2149. return put_user(dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL], (int *)arg);
  2151.         case SOUND_PCM_READ_CHANNELS:
  2152. return put_user((s->sctrl & SCTRL_P1SMB) ? 2 : 1, (int *)arg);
  2154.         case SOUND_PCM_READ_BITS:
  2155. return put_user((s->sctrl & SCTRL_P1SEB) ? 16 : 8, (int *)arg);
  2157.         case SOUND_PCM_WRITE_FILTER:
  2158.         case SNDCTL_DSP_SETSYNCRO:
  2159.         case SOUND_PCM_READ_FILTER:
  2160.                 return -EINVAL;
  2162. }
  2163. return mixer_ioctl(s, cmd, arg);
  2164. }
  2166. static int es1370_open_dac(struct inode *inode, struct file *file)
  2167. {
  2168. int minor = MINOR(inode->i_rdev);
  2169. DECLARE_WAITQUEUE(wait, current);
  2170. unsigned long flags;
  2171. struct list_head *list;
  2172. struct es1370_state *s;
  2174. for (list = devs.next; ; list = list->next) {
  2175. if (list == &devs)
  2176. return -ENODEV;
  2177. s = list_entry(list, struct es1370_state, devs);
  2178. if (!((s->dev_dac ^ minor) & ~0xf))
  2179. break;
  2180. }
  2181.         VALIDATE_STATE(s);
  2182.         /* we allow opening with O_RDWR, most programs do it although they will only write */
  2183. #if 0
  2184. if (file->f_mode & FMODE_READ)
  2185. return -EPERM;
  2186. #endif
  2187. if (!(file->f_mode & FMODE_WRITE))
  2188. return -EINVAL;
  2189.         file->private_data = s;
  2190. /* wait for device to become free */
  2191. down(&s->open_sem);
  2192. while (s->open_mode & FMODE_DAC) {
  2193. if (file->f_flags & O_NONBLOCK) {
  2194. up(&s->open_sem);
  2195. return -EBUSY;
  2196. }
  2197. add_wait_queue(&s->open_wait, &wait);
  2198. __set_current_state(TASK_INTERRUPTIBLE);
  2199. up(&s->open_sem);
  2200. schedule();
  2201. remove_wait_queue(&s->open_wait, &wait);
  2202. set_current_state(TASK_RUNNING);
  2203. if (signal_pending(current))
  2204. return -ERESTARTSYS;
  2205. down(&s->open_sem);
  2206. }
  2207. s->dma_dac1.ossfragshift = s->dma_dac1.ossmaxfrags = s->dma_dac1.subdivision = 0;
  2208. s->dma_dac1.enabled = 1;
  2209. spin_lock_irqsave(&s->lock, flags);
  2210. s->ctrl = (s->ctrl & ~CTRL_WTSRSEL) | (1 << CTRL_SH_WTSRSEL);
  2211.        s->sctrl &= ~SCTRL_P1FMT;
  2212. if ((minor & 0xf) == SND_DEV_DSP16)
  2213. s->sctrl |= ES1370_FMT_S16_MONO << SCTRL_SH_P1FMT;
  2214. else
  2215. s->sctrl |= ES1370_FMT_U8_MONO << SCTRL_SH_P1FMT;
  2216. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  2217. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  2218. spin_unlock_irqrestore(&s->lock, flags);
  2219. s->open_mode |= FMODE_DAC;
  2220. up(&s->open_sem);
  2221. return 0;
  2222. }
  2224. static int es1370_release_dac(struct inode *inode, struct file *file)
  2225. {
  2226. struct es1370_state *s = (struct es1370_state *)file->private_data;
  2228. VALIDATE_STATE(s);
  2229. lock_kernel();
  2230. drain_dac1(s, file->f_flags & O_NONBLOCK);
  2231. down(&s->open_sem);
  2232. stop_dac1(s);
  2233. dealloc_dmabuf(s, &s->dma_dac1);
  2234. s->open_mode &= ~FMODE_DAC;
  2235. wake_up(&s->open_wait);
  2236. up(&s->open_sem);
  2237. unlock_kernel();
  2238. return 0;
  2239. }
  2241. static /*const*/ struct file_operations es1370_dac_fops = {
  2242. owner: THIS_MODULE,
  2243. llseek: no_llseek,
  2244. write: es1370_write_dac,
  2245. poll: es1370_poll_dac,
  2246. ioctl: es1370_ioctl_dac,
  2247. mmap: es1370_mmap_dac,
  2248. open: es1370_open_dac,
  2249. release: es1370_release_dac,
  2250. };
  2252. /* --------------------------------------------------------------------- */
  2254. static ssize_t es1370_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
  2255. {
  2256. struct es1370_state *s = (struct es1370_state *)file->private_data;
  2257. DECLARE_WAITQUEUE(wait, current);
  2258. ssize_t ret;
  2259. unsigned long flags;
  2260. unsigned ptr;
  2261. int cnt;
  2263. VALIDATE_STATE(s);
  2264. if (ppos != &file->f_pos)
  2265. return -ESPIPE;
  2266. if (!access_ok(VERIFY_WRITE, buffer, count))
  2267. return -EFAULT;
  2268. if (count == 0)
  2269. return 0;
  2270. ret = 0;
  2271.         add_wait_queue(&s->midi.iwait, &wait);
  2272. while (count > 0) {
  2273. spin_lock_irqsave(&s->lock, flags);
  2274. ptr = s->midi.ird;
  2275. cnt = MIDIINBUF - ptr;
  2276. if (s->midi.icnt < cnt)
  2277. cnt = s->midi.icnt;
  2278. if (cnt <= 0)
  2279. __set_current_state(TASK_INTERRUPTIBLE);
  2280. spin_unlock_irqrestore(&s->lock, flags);
  2281. if (cnt > count)
  2282. cnt = count;
  2283. if (cnt <= 0) {
  2284. if (file->f_flags & O_NONBLOCK) {
  2285. if (!ret)
  2286. ret = -EAGAIN;
  2287. break;
  2288. }
  2289. schedule();
  2290. if (signal_pending(current)) {
  2291. if (!ret)
  2292. ret = -ERESTARTSYS;
  2293. break;
  2294. }
  2295. continue;
  2296. }
  2297. if (copy_to_user(buffer, s->midi.ibuf + ptr, cnt)) {
  2298. if (!ret)
  2299. ret = -EFAULT;
  2300. break;
  2301. }
  2302. ptr = (ptr + cnt) % MIDIINBUF;
  2303. spin_lock_irqsave(&s->lock, flags);
  2304. s->midi.ird = ptr;
  2305. s->midi.icnt -= cnt;
  2306. spin_unlock_irqrestore(&s->lock, flags);
  2307. count -= cnt;
  2308. buffer += cnt;
  2309. ret += cnt;
  2310. break;
  2311. }
  2312. __set_current_state(TASK_RUNNING);
  2313.         remove_wait_queue(&s->midi.iwait, &wait);
  2314. return ret;
  2315. }
  2317. static ssize_t es1370_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
  2318. {
  2319. struct es1370_state *s = (struct es1370_state *)file->private_data;
  2320. DECLARE_WAITQUEUE(wait, current);
  2321. ssize_t ret;
  2322. unsigned long flags;
  2323. unsigned ptr;
  2324. int cnt;
  2326. VALIDATE_STATE(s);
  2327. if (ppos != &file->f_pos)
  2328. return -ESPIPE;
  2329. if (!access_ok(VERIFY_READ, buffer, count))
  2330. return -EFAULT;
  2331. if (count == 0)
  2332. return 0;
  2333. ret = 0;
  2334.         add_wait_queue(&s->midi.owait, &wait);
  2335. while (count > 0) {
  2336. spin_lock_irqsave(&s->lock, flags);
  2337. ptr = s->midi.owr;
  2338. cnt = MIDIOUTBUF - ptr;
  2339. if (s->midi.ocnt + cnt > MIDIOUTBUF)
  2340. cnt = MIDIOUTBUF - s->midi.ocnt;
  2341. if (cnt <= 0) {
  2342. __set_current_state(TASK_INTERRUPTIBLE);
  2343. es1370_handle_midi(s);
  2344. }
  2345. spin_unlock_irqrestore(&s->lock, flags);
  2346. if (cnt > count)
  2347. cnt = count;
  2348. if (cnt <= 0) {
  2349. if (file->f_flags & O_NONBLOCK) {
  2350. if (!ret)
  2351. ret = -EAGAIN;
  2352. break;
  2353. }
  2354. schedule();
  2355. if (signal_pending(current)) {
  2356. if (!ret)
  2357. ret = -ERESTARTSYS;
  2358. break;
  2359. }
  2360. continue;
  2361. }
  2362. if (copy_from_user(s->midi.obuf + ptr, buffer, cnt)) {
  2363. if (!ret)
  2364. ret = -EFAULT;
  2365. break;
  2366. }
  2367. ptr = (ptr + cnt) % MIDIOUTBUF;
  2368. spin_lock_irqsave(&s->lock, flags);
  2369. s->midi.owr = ptr;
  2370. s->midi.ocnt += cnt;
  2371. spin_unlock_irqrestore(&s->lock, flags);
  2372. count -= cnt;
  2373. buffer += cnt;
  2374. ret += cnt;
  2375. spin_lock_irqsave(&s->lock, flags);
  2376. es1370_handle_midi(s);
  2377. spin_unlock_irqrestore(&s->lock, flags);
  2378. }
  2379. __set_current_state(TASK_RUNNING);
  2380.         remove_wait_queue(&s->midi.owait, &wait);
  2381. return ret;
  2382. }
  2384. /* No kernel lock - we have our own spinlock */
  2385. static unsigned int es1370_midi_poll(struct file *file, struct poll_table_struct *wait)
  2386. {
  2387. struct es1370_state *s = (struct es1370_state *)file->private_data;
  2388. unsigned long flags;
  2389. unsigned int mask = 0;
  2391. VALIDATE_STATE(s);
  2392. if (file->f_mode & FMODE_WRITE)
  2393. poll_wait(file, &s->midi.owait, wait);
  2394. if (file->f_mode & FMODE_READ)
  2395. poll_wait(file, &s->midi.iwait, wait);
  2396. spin_lock_irqsave(&s->lock, flags);
  2397. if (file->f_mode & FMODE_READ) {
  2398. if (s->midi.icnt > 0)
  2399. mask |= POLLIN | POLLRDNORM;
  2400. }
  2401. if (file->f_mode & FMODE_WRITE) {
  2402. if (s->midi.ocnt < MIDIOUTBUF)
  2403. mask |= POLLOUT | POLLWRNORM;
  2404. }
  2405. spin_unlock_irqrestore(&s->lock, flags);
  2406. return mask;
  2407. }
  2409. static int es1370_midi_open(struct inode *inode, struct file *file)
  2410. {
  2411. int minor = MINOR(inode->i_rdev);
  2412. DECLARE_WAITQUEUE(wait, current);
  2413. unsigned long flags;
  2414. struct list_head *list;
  2415. struct es1370_state *s;
  2417. for (list = devs.next; ; list = list->next) {
  2418. if (list == &devs)
  2419. return -ENODEV;
  2420. s = list_entry(list, struct es1370_state, devs);
  2421. if (s->dev_midi == minor)
  2422. break;
  2423. }
  2424.         VALIDATE_STATE(s);
  2425. file->private_data = s;
  2426. /* wait for device to become free */
  2427. down(&s->open_sem);
  2428. while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
  2429. if (file->f_flags & O_NONBLOCK) {
  2430. up(&s->open_sem);
  2431. return -EBUSY;
  2432. }
  2433. add_wait_queue(&s->open_wait, &wait);
  2434. __set_current_state(TASK_INTERRUPTIBLE);
  2435. up(&s->open_sem);
  2436. schedule();
  2437. remove_wait_queue(&s->open_wait, &wait);
  2438. set_current_state(TASK_RUNNING);
  2439. if (signal_pending(current))
  2440. return -ERESTARTSYS;
  2441. down(&s->open_sem);
  2442. }
  2443. spin_lock_irqsave(&s->lock, flags);
  2444. if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
  2445. s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
  2446. s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
  2447. outb(UCTRL_CNTRL_SWR, s->io+ES1370_REG_UART_CONTROL);
  2448. outb(0, s->io+ES1370_REG_UART_CONTROL);
  2449. outb(0, s->io+ES1370_REG_UART_TEST);
  2450. }
  2451. if (file->f_mode & FMODE_READ) {
  2452. s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
  2453. }
  2454. if (file->f_mode & FMODE_WRITE) {
  2455. s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
  2456. }
  2457. s->ctrl |= CTRL_UART_EN;
  2458. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  2459. es1370_handle_midi(s);
  2460. spin_unlock_irqrestore(&s->lock, flags);
  2461. s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
  2462. up(&s->open_sem);
  2463. return 0;
  2464. }
  2466. static int es1370_midi_release(struct inode *inode, struct file *file)
  2467. {
  2468. struct es1370_state *s = (struct es1370_state *)file->private_data;
  2469. DECLARE_WAITQUEUE(wait, current);
  2470. unsigned long flags;
  2471. unsigned count, tmo;
  2473. VALIDATE_STATE(s);
  2475. lock_kernel();
  2476. if (file->f_mode & FMODE_WRITE) {
  2477. add_wait_queue(&s->midi.owait, &wait);
  2478. for (;;) {
  2479. __set_current_state(TASK_INTERRUPTIBLE);
  2480. spin_lock_irqsave(&s->lock, flags);
  2481. count = s->midi.ocnt;
  2482. spin_unlock_irqrestore(&s->lock, flags);
  2483. if (count <= 0)
  2484. break;
  2485. if (signal_pending(current))
  2486. break;
  2487. if (file->f_flags & O_NONBLOCK) 
  2488. break;
  2489. tmo = (count * HZ) / 3100;
  2490. if (!schedule_timeout(tmo ? : 1) && tmo)
  2491. DBG(printk(KERN_DEBUG "es1370: midi timed out??n");)
  2492. }
  2493. remove_wait_queue(&s->midi.owait, &wait);
  2494. set_current_state(TASK_RUNNING);
  2495. }
  2496. down(&s->open_sem);
  2497. s->open_mode &= (~(file->f_mode << FMODE_MIDI_SHIFT)) & (FMODE_MIDI_READ|FMODE_MIDI_WRITE);
  2498. spin_lock_irqsave(&s->lock, flags);
  2499. if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
  2500. s->ctrl &= ~CTRL_UART_EN;
  2501. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  2502. }
  2503. spin_unlock_irqrestore(&s->lock, flags);
  2504. wake_up(&s->open_wait);
  2505. up(&s->open_sem);
  2506. unlock_kernel();
  2507. return 0;
  2508. }
  2510. static /*const*/ struct file_operations es1370_midi_fops = {
  2511. owner: THIS_MODULE,
  2512. llseek: no_llseek,
  2513. read: es1370_midi_read,
  2514. write: es1370_midi_write,
  2515. poll: es1370_midi_poll,
  2516. open: es1370_midi_open,
  2517. release: es1370_midi_release,
  2518. };
  2520. /* --------------------------------------------------------------------- */
  2522. /* maximum number of devices; only used for command line params */
  2523. #define NR_DEVICE 5
  2525. static int joystick[NR_DEVICE] = { 0, };
  2526. static int lineout[NR_DEVICE] = { 0, };
  2527. static int micbias[NR_DEVICE] = { 0, };
  2529. static unsigned int devindex = 0;
  2531. MODULE_PARM(joystick, "1-" __MODULE_STRING(NR_DEVICE) "i");
  2532. MODULE_PARM_DESC(joystick, "if 1 enables joystick interface (still need separate driver)");
  2533. MODULE_PARM(lineout, "1-" __MODULE_STRING(NR_DEVICE) "i");
  2534. MODULE_PARM_DESC(lineout, "if 1 the LINE input is converted to LINE out");
  2535. MODULE_PARM(micbias, "1-" __MODULE_STRING(NR_DEVICE) "i");
  2536. MODULE_PARM_DESC(micbias, "sets the +5V bias for an electret microphone");
  2538. MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
  2539. MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
  2540. MODULE_LICENSE("GPL");
  2543. /* --------------------------------------------------------------------- */
  2545. static struct initvol {
  2546. int mixch;
  2547. int vol;
  2548. } initvol[] __initdata = {
  2549. { SOUND_MIXER_WRITE_VOLUME, 0x4040 },
  2550. { SOUND_MIXER_WRITE_PCM, 0x4040 },
  2551. { SOUND_MIXER_WRITE_SYNTH, 0x4040 },
  2552. { SOUND_MIXER_WRITE_CD, 0x4040 },
  2553. { SOUND_MIXER_WRITE_LINE, 0x4040 },
  2554. { SOUND_MIXER_WRITE_LINE1, 0x4040 },
  2555. { SOUND_MIXER_WRITE_LINE2, 0x4040 },
  2556. { SOUND_MIXER_WRITE_LINE3, 0x4040 },
  2557. { SOUND_MIXER_WRITE_MIC, 0x4040 },
  2558. { SOUND_MIXER_WRITE_OGAIN, 0x4040 }
  2559. };
  2561. static int __devinit es1370_probe(struct pci_dev *pcidev, const struct pci_device_id *pciid)
  2562. {
  2563. struct es1370_state *s;
  2564. mm_segment_t fs;
  2565. int i, val, ret;
  2567. if ((ret=pci_enable_device(pcidev)))
  2568. return ret;
  2570. if ( !(pci_resource_flags(pcidev, 0) & IORESOURCE_IO) ||
  2571.      !pci_resource_start(pcidev, 0)
  2572. )
  2573. return -ENODEV;
  2574. if (pcidev->irq == 0) 
  2575. return -ENODEV;
  2576. i = pci_set_dma_mask(pcidev, 0xffffffff);
  2577. if (i) {
  2578. printk(KERN_WARNING "es1370: architecture does not support 32bit PCI busmaster DMAn");
  2579. return i;
  2580. }
  2581. if (!(s = kmalloc(sizeof(struct es1370_state), GFP_KERNEL))) {
  2582. printk(KERN_WARNING "es1370: out of memoryn");
  2583. return -ENOMEM;
  2584. }
  2585. memset(s, 0, sizeof(struct es1370_state));
  2586. init_waitqueue_head(&s->dma_adc.wait);
  2587. init_waitqueue_head(&s->dma_dac1.wait);
  2588. init_waitqueue_head(&s->dma_dac2.wait);
  2589. init_waitqueue_head(&s->open_wait);
  2590. init_waitqueue_head(&s->midi.iwait);
  2591. init_waitqueue_head(&s->midi.owait);
  2592. init_MUTEX(&s->open_sem);
  2593. spin_lock_init(&s->lock);
  2594. s->magic = ES1370_MAGIC;
  2595. s->dev = pcidev;
  2596. s->io = pci_resource_start(pcidev, 0);
  2597. s->irq = pcidev->irq;
  2598. if (!request_region(s->io, ES1370_EXTENT, "es1370")) {
  2599. printk(KERN_ERR "es1370: io ports %#lx-%#lx in usen", s->io, s->io+ES1370_EXTENT-1);
  2600. ret = -EBUSY;
  2601. goto err_region;
  2602. }
  2603. if ((ret=request_irq(s->irq, es1370_interrupt, SA_SHIRQ, "es1370",s))) {
  2604. printk(KERN_ERR "es1370: irq %u in usen", s->irq);
  2605. goto err_irq;
  2606. }
  2608. /* initialize codec registers */
  2609. /* note: setting CTRL_SERR_DIS is reported to break
  2610.  * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
  2611. s->ctrl = CTRL_CDC_EN | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV) | (1 << CTRL_SH_WTSRSEL);
  2612. s->gameport.io = 0;
  2613. if (joystick[devindex]) {
  2614. if (!request_region(0x200, JOY_EXTENT, "es1370"))
  2615. printk(KERN_ERR "es1370: joystick io port 0x200 in usen");
  2616. else {
  2617. s->ctrl |= CTRL_JYSTK_EN;
  2618. s->gameport.io = 0x200;
  2619. }
  2620. }
  2621. if (lineout[devindex])
  2622. s->ctrl |= CTRL_XCTL0;
  2623. if (micbias[devindex])
  2624. s->ctrl |= CTRL_XCTL1;
  2625. s->sctrl = 0;
  2626. printk(KERN_INFO "es1370: found adapter at io %#lx irq %un"
  2627.        KERN_INFO "es1370: features: joystick %s, line %s, mic impedance %sn",
  2628.        s->io, s->irq, (s->ctrl & CTRL_JYSTK_EN) ? "on" : "off",
  2629.        (s->ctrl & CTRL_XCTL0) ? "out" : "in",
  2630.        (s->ctrl & CTRL_XCTL1) ? "1" : "0");
  2631. /* register devices */
  2632. if ((s->dev_audio = register_sound_dsp(&es1370_audio_fops, -1)) < 0) {
  2633. ret = s->dev_audio;
  2634. goto err_dev1;
  2635. }
  2636. if ((s->dev_mixer = register_sound_mixer(&es1370_mixer_fops, -1)) < 0) {
  2637. ret = s->dev_mixer;
  2638. goto err_dev2;
  2639. }
  2640. if ((s->dev_dac = register_sound_dsp(&es1370_dac_fops, -1)) < 0) {
  2641. ret = s->dev_dac;
  2642. goto err_dev3;
  2643. }
  2644. if ((s->dev_midi = register_sound_midi(&es1370_midi_fops, -1)) < 0) {
  2645. ret = s->dev_midi;
  2646. goto err_dev4;
  2647. }
  2648. /* initialize the chips */
  2649. outl(s->ctrl, s->io+ES1370_REG_CONTROL);
  2650. outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
  2651. /* point phantom write channel to "bugbuf" */
  2652. outl((ES1370_REG_PHANTOM_FRAMEADR >> 8) & 15, s->io+ES1370_REG_MEMPAGE);
  2653. outl(virt_to_bus(bugbuf), s->io+(ES1370_REG_PHANTOM_FRAMEADR & 0xff));
  2654. outl(0, s->io+(ES1370_REG_PHANTOM_FRAMECNT & 0xff));
  2655. pci_set_master(pcidev);  /* enable bus mastering */
  2656. wrcodec(s, 0x16, 3); /* no RST, PD */
  2657. wrcodec(s, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!!  */
  2658. wrcodec(s, 0x18, 0); /* recording source is mixer */
  2659. wrcodec(s, 0x19, s->mix.micpreamp = 1); /* turn on MIC preamp */
  2660. s->mix.imix = 1;
  2661. fs = get_fs();
  2662. set_fs(KERNEL_DS);
  2663. val = SOUND_MASK_LINE|SOUND_MASK_SYNTH|SOUND_MASK_CD;
  2664. mixer_ioctl(s, SOUND_MIXER_WRITE_RECSRC, (unsigned long)&val);
  2665. for (i = 0; i < sizeof(initvol)/sizeof(initvol[0]); i++) {
  2666. val = initvol[i].vol;
  2667. mixer_ioctl(s, initvol[i].mixch, (unsigned long)&val);
  2668. }
  2669. set_fs(fs);
  2670. /* register gameport */
  2671. gameport_register_port(&s->gameport);
  2673. /* store it in the driver field */
  2674. pci_set_drvdata(pcidev, s);
  2675. /* put it into driver list */
  2676. list_add_tail(&s->devs, &devs);
  2677. /* increment devindex */
  2678. if (devindex < NR_DEVICE-1)
  2679. devindex++;
  2680. return 0;
  2682.  err_dev4:
  2683. unregister_sound_dsp(s->dev_dac);
  2684.  err_dev3:
  2685. unregister_sound_mixer(s->dev_mixer);
  2686.  err_dev2:
  2687. unregister_sound_dsp(s->dev_audio);
  2688.  err_dev1:
  2689. printk(KERN_ERR "es1370: cannot register misc devicen");
  2690. free_irq(s->irq, s);
  2691. if (s->gameport.io)
  2692. release_region(s->gameport.io, JOY_EXTENT);
  2693.  err_irq:
  2694. release_region(s->io, ES1370_EXTENT);
  2695.  err_region:
  2696. kfree(s);
  2697. return ret;
  2698. }
  2700. static void __devinit es1370_remove(struct pci_dev *dev)
  2701. {
  2702. struct es1370_state *s = pci_get_drvdata(dev);
  2704. if (!s)
  2705. return;
  2706. list_del(&s->devs);
  2707. outl(CTRL_SERR_DIS | (1 << CTRL_SH_WTSRSEL), s->io+ES1370_REG_CONTROL); /* switch everything off */
  2708. outl(0, s->io+ES1370_REG_SERIAL_CONTROL); /* clear serial interrupts */
  2709. synchronize_irq();
  2710. free_irq(s->irq, s);
  2711. if (s->gameport.io) {
  2712. gameport_unregister_port(&s->gameport);
  2713. release_region(s->gameport.io, JOY_EXTENT);
  2714. }
  2715. release_region(s->io, ES1370_EXTENT);
  2716. unregister_sound_dsp(s->dev_audio);
  2717. unregister_sound_mixer(s->dev_mixer);
  2718. unregister_sound_dsp(s->dev_dac);
  2719. unregister_sound_midi(s->dev_midi);
  2720. kfree(s);
  2721. pci_set_drvdata(dev, NULL);
  2722. }
  2724. static struct pci_device_id id_table[] __devinitdata = {
  2725. { PCI_VENDOR_ID_ENSONIQ, PCI_DEVICE_ID_ENSONIQ_ES1370, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
  2726. { 0, }
  2727. };
  2729. MODULE_DEVICE_TABLE(pci, id_table);
  2731. static struct pci_driver es1370_driver = {
  2732. name: "es1370",
  2733. id_table: id_table,
  2734. probe: es1370_probe,
  2735. remove: es1370_remove
  2736. };
  2738. static int __init init_es1370(void)
  2739. {
  2740. if (!pci_present())   /* No PCI bus in this machine! */
  2741. return -ENODEV;
  2742. printk(KERN_INFO "es1370: version v0.37 time " __TIME__ " " __DATE__ "n");
  2743. return pci_module_init(&es1370_driver);
  2744. }
  2746. static void __exit cleanup_es1370(void)
  2747. {
  2748. printk(KERN_INFO "es1370: unloadingn");
  2749. pci_unregister_driver(&es1370_driver);
  2750. }
  2752. module_init(init_es1370);
  2753. module_exit(cleanup_es1370);
  2755. /* --------------------------------------------------------------------- */
  2757. #ifndef MODULE
  2759. /* format is: es1370=[joystick[,lineout[,micbias]]] */
  2761. static int __init es1370_setup(char *str)
  2762. {
  2763. static unsigned __initdata nr_dev = 0;
  2765. if (nr_dev >= NR_DEVICE)
  2766. return 0;
  2768. (void)
  2769. (   (get_option(&str,&joystick[nr_dev]) == 2)
  2770.  && (get_option(&str,&lineout [nr_dev]) == 2)
  2771.  &&  get_option(&str,&micbias [nr_dev])
  2772. );
  2774. nr_dev++;
  2775. return 1;
  2776. }
  2778. __setup("es1370=", es1370_setup);
  2780. #endif /* MODULE */