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

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

Linux/Unix编程

开发平台：

Unix_Linux

pss.c：源码内容
  1. /*
  2.  * sound/pss.c
  3.  *
  4.  * The low level driver for the Personal Sound System (ECHO ESC614).
  5.  *
  6.  *
  7.  * Copyright (C) by Hannu Savolainen 1993-1997
  8.  *
  9.  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10.  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11.  * for more info.
  12.  *
  13.  *
  14.  * Thomas Sailer ioctl code reworked (vmalloc/vfree removed)
  15.  * Alan Cox modularisation, clean up.
  16.  *
  17.  * 98-02-21: Vladimir Michl <vladimir.michl@upol.cz>
  18.  *          Added mixer device for Beethoven ADSP-16 (master volume,
  19.  *     bass, treble, synth), only for speakers.
  20.  *          Fixed bug in pss_write (exchange parameters)
  21.  *          Fixed config port of SB
  22.  *          Requested two regions for PSS (PSS mixer, PSS config)
  23.  *          Modified pss_download_boot
  24.  *          To probe_pss_mss added test for initialize AD1848
  25.  * 98-05-28: Vladimir Michl <vladimir.michl@upol.cz>
  26.  *          Fixed computation of mixer volumes
  27.  * 04-05-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  28.  *          Added code that allows the user to enable his cdrom and/or 
  29.  *          joystick through the module parameters pss_cdrom_port and 
  30.  *          pss_enable_joystick.  pss_cdrom_port takes a port address as its
  31.  *          argument.  pss_enable_joystick takes either a 0 or a non-0 as its
  32.  *          argument.
  33.  * 04-06-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  34.  *          Separated some code into new functions for easier reuse.  
  35.  *          Cleaned up and streamlined new code.  Added code to allow a user 
  36.  *          to only use this driver for enabling non-sound components 
  37.  *          through the new module parameter pss_no_sound (flag).  Added 
  38.  *          code that would allow a user to decide whether the driver should 
  39.  *          reset the configured hardware settings for the PSS board through 
  40.  *          the module parameter pss_keep_settings (flag).   This flag will 
  41.  *          allow a user to free up resources in use by this card if needbe, 
  42.  *          furthermore it allows him to use this driver to just enable the 
  43.  *          emulations and then be unloaded as it is no longer needed.  Both 
  44.  *          new settings are only available to this driver if compiled as a 
  45.  *          module.  The default settings of all new parameters are set to 
  46.  *          load the driver as it did in previous versions.
  47.  * 04-07-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  48.  *          Added module parameter pss_firmware to allow the user to tell 
  49.  *          the driver where the fireware file is located.  The default 
  50.  *          setting is the previous hardcoded setting "/etc/sound/pss_synth".
  51.  * 00-03-03: Christoph Hellwig <chhellwig@infradead.org>
  52.  *     Adapted to module_init/module_exit
  53.  * 11-10-2000: Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
  54.  *     Added __init to probe_pss(), attach_pss() and probe_pss_mpu()
  55.  * 02-Jan-2001: Chris Rankin
  56.  *          Specify that this module owns the coprocessor
  57.  */
  60. #include <linux/config.h>
  61. #include <linux/init.h>
  62. #include <linux/module.h>
  64. #include "sound_config.h"
  65. #include "sound_firmware.h"
  67. #include "ad1848.h"
  68. #include "mpu401.h"
  70. /*
  71.  * PSS registers.
  72.  */
  73. #define REG(x) (devc->base+x)
  74. #define PSS_DATA 0
  75. #define PSS_STATUS 2
  76. #define PSS_CONTROL 2
  77. #define PSS_ID 4
  78. #define PSS_IRQACK 4
  79. #define PSS_PIO 0x1a
  81. /*
  82.  * Config registers
  83.  */
  84. #define CONF_PSS 0x10
  85. #define CONF_WSS 0x12
  86. #define CONF_SB 0x14
  87. #define CONF_CDROM 0x16
  88. #define CONF_MIDI 0x18
  90. /*
  91.  * Status bits.
  92.  */
  93. #define PSS_FLAG3     0x0800
  94. #define PSS_FLAG2     0x0400
  95. #define PSS_FLAG1     0x1000
  96. #define PSS_FLAG0     0x0800
  97. #define PSS_WRITE_EMPTY  0x8000
  98. #define PSS_READ_FULL    0x4000
  100. /*
  101.  * WSS registers
  102.  */
  103. #define WSS_INDEX 4
  104. #define WSS_DATA 5
  106. /*
  107.  * WSS status bits
  108.  */
  109. #define WSS_INITIALIZING 0x80
  110. #define WSS_AUTOCALIBRATION 0x20
  112. #define NO_WSS_MIXER -1
  114. #include "coproc.h"
  116. #include "pss_boot.h"
  118. /* If compiled into kernel, it enable or disable pss mixer */
  119. #ifdef CONFIG_PSS_MIXER
  120. static unsigned char pss_mixer = 1;
  121. #else
  122. static unsigned char pss_mixer = 0;
  123. #endif
  126. typedef struct pss_mixerdata {
  127. unsigned int volume_l;
  128. unsigned int volume_r;
  129. unsigned int bass;
  130. unsigned int treble;
  131. unsigned int synth;
  132. } pss_mixerdata;
  134. typedef struct pss_confdata {
  135. int             base;
  136. int             irq;
  137. int             dma;
  138. int            *osp;
  139. pss_mixerdata   mixer;
  140. int             ad_mixer_dev;
  141. } pss_confdata;
  142.   
  143. static pss_confdata pss_data;
  144. static pss_confdata *devc = &pss_data;
  146. static int      pss_initialized = 0;
  147. static int      nonstandard_microcode = 0;
  148. static int pss_cdrom_port = -1; /* Parameter for the PSS cdrom port */
  149. static int pss_enable_joystick = 0;/* Parameter for enabling the joystick */
  151. static void pss_write(pss_confdata *devc, int data)
  152. {
  153. int i, limit;
  155. limit = jiffies + HZ/10; /* The timeout is 0.1 seconds */
  156. /*
  157.  * Note! the i<5000000 is an emergency exit. The dsp_command() is sometimes
  158.  * called while interrupts are disabled. This means that the timer is
  159.  * disabled also. However the timeout situation is a abnormal condition.
  160.  * Normally the DSP should be ready to accept commands after just couple of
  161.  * loops.
  162.  */
  164. for (i = 0; i < 5000000 && time_before(jiffies, limit); i++)
  165.   {
  166.   if (inw(REG(PSS_STATUS)) & PSS_WRITE_EMPTY)
  167.   {
  168.   outw(data, REG(PSS_DATA));
  169.   return;
  170.   }
  171.   }
  172.   printk(KERN_WARNING "PSS: DSP Command (%04x) Timeout.n", data);
  173. }
  175. int __init probe_pss(struct address_info *hw_config)
  176. {
  177. unsigned short id;
  178. int irq, dma;
  180. devc->base = hw_config->io_base;
  181. irq = devc->irq = hw_config->irq;
  182. dma = devc->dma = hw_config->dma;
  183. devc->osp = hw_config->osp;
  185. if (devc->base != 0x220 && devc->base != 0x240)
  186. if (devc->base != 0x230 && devc->base != 0x250) /* Some cards use these */
  187. return 0;
  189. if (check_region(devc->base, 0x19 /*16*/)) { 
  190. printk(KERN_ERR "PSS: I/O port conflictn");
  191. return 0;
  192. }
  193. id = inw(REG(PSS_ID));
  194. if ((id >> 8) != 'E') {
  195. printk(KERN_ERR "No PSS signature detected at 0x%x (0x%x)n",  devc->base,  id); 
  196. return 0;
  197. }
  198. return 1;
  199. }
  201. static int set_irq(pss_confdata * devc, int dev, int irq)
  202. {
  203. static unsigned short irq_bits[16] =
  204. {
  205. 0x0000, 0x0000, 0x0000, 0x0008,
  206. 0x0000, 0x0010, 0x0000, 0x0018,
  207. 0x0000, 0x0020, 0x0028, 0x0030,
  208. 0x0038, 0x0000, 0x0000, 0x0000
  209. };
  211. unsigned short  tmp, bits;
  213. if (irq < 0 || irq > 15)
  214. return 0;
  216. tmp = inw(REG(dev)) & ~0x38; /* Load confreg, mask IRQ bits out */
  218. if ((bits = irq_bits[irq]) == 0 && irq != 0)
  219. {
  220. printk(KERN_ERR "PSS: Invalid IRQ %dn", irq);
  221. return 0;
  222. }
  223. outw(tmp | bits, REG(dev));
  224. return 1;
  225. }
  227. static int set_io_base(pss_confdata * devc, int dev, int base)
  228. {
  229. unsigned short  tmp = inw(REG(dev)) & 0x003f;
  230. unsigned short  bits = (base & 0x0ffc) << 4;
  232. outw(bits | tmp, REG(dev));
  234. return 1;
  235. }
  237. static int set_dma(pss_confdata * devc, int dev, int dma)
  238. {
  239. static unsigned short dma_bits[8] =
  240. {
  241. 0x0001, 0x0002, 0x0000, 0x0003,
  242. 0x0000, 0x0005, 0x0006, 0x0007
  243. };
  245. unsigned short  tmp, bits;
  247. if (dma < 0 || dma > 7)
  248. return 0;
  250. tmp = inw(REG(dev)) & ~0x07; /* Load confreg, mask DMA bits out */
  252. if ((bits = dma_bits[dma]) == 0 && dma != 4)
  253. {
  254.   printk(KERN_ERR "PSS: Invalid DMA %dn", dma);
  255.   return 0;
  256. }
  257. outw(tmp | bits, REG(dev));
  258. return 1;
  259. }
  261. static int pss_reset_dsp(pss_confdata * devc)
  262. {
  263. unsigned long   i, limit = jiffies + HZ/10;
  265. outw(0x2000, REG(PSS_CONTROL));
  266. for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
  267. inw(REG(PSS_CONTROL));
  268. outw(0x0000, REG(PSS_CONTROL));
  269. return 1;
  270. }
  272. static int pss_put_dspword(pss_confdata * devc, unsigned short word)
  273. {
  274. int i, val;
  276. for (i = 0; i < 327680; i++)
  277. {
  278. val = inw(REG(PSS_STATUS));
  279. if (val & PSS_WRITE_EMPTY)
  280. {
  281. outw(word, REG(PSS_DATA));
  282. return 1;
  283. }
  284. }
  285. return 0;
  286. }
  288. static int pss_get_dspword(pss_confdata * devc, unsigned short *word)
  289. {
  290. int i, val;
  292. for (i = 0; i < 327680; i++)
  293. {
  294. val = inw(REG(PSS_STATUS));
  295. if (val & PSS_READ_FULL)
  296. {
  297. *word = inw(REG(PSS_DATA));
  298. return 1;
  299. }
  300. }
  301. return 0;
  302. }
  304. static int pss_download_boot(pss_confdata * devc, unsigned char *block, int size, int flags)
  305. {
  306. int i, limit, val, count;
  308. if (flags & CPF_FIRST)
  309. {
  310. /*_____ Warn DSP software that a boot is coming */
  311. outw(0x00fe, REG(PSS_DATA));
  313. limit = jiffies + HZ/10;
  314. for (i = 0; i < 32768 && time_before(jiffies, limit); i++)
  315. if (inw(REG(PSS_DATA)) == 0x5500)
  316. break;
  318. outw(*block++, REG(PSS_DATA));
  319. pss_reset_dsp(devc);
  320. }
  321. count = 1;
  322. while ((flags&CPF_LAST) || count<size )
  323. {
  324. int j;
  326. for (j = 0; j < 327670; j++)
  327. {
  328. /*_____ Wait for BG to appear */
  329. if (inw(REG(PSS_STATUS)) & PSS_FLAG3)
  330. break;
  331. }
  333. if (j == 327670)
  334. {
  335. /* It's ok we timed out when the file was empty */
  336. if (count >= size && flags & CPF_LAST)
  337. break;
  338. else
  339. {
  340. printk("n");
  341. printk(KERN_ERR "PSS: Download timeout problems, byte %d=%dn", count, size);
  342. return 0;
  343. }
  344. }
  345. /*_____ Send the next byte */
  346. if (count >= size) 
  347. {
  348. /* If not data in block send 0xffff */
  349. outw (0xffff, REG (PSS_DATA));
  350. }
  351. else
  352. {
  353. /*_____ Send the next byte */
  354. outw (*block++, REG (PSS_DATA));
  355. };
  356. count++;
  357. }
  359. if (flags & CPF_LAST)
  360. {
  361. /*_____ Why */
  362. outw(0, REG(PSS_DATA));
  364. limit = jiffies + HZ/10;
  365. for (i = 0; i < 32768 && (limit - jiffies >= 0); i++)
  366. val = inw(REG(PSS_STATUS));
  368. limit = jiffies + HZ/10;
  369. for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
  370. {
  371. val = inw(REG(PSS_STATUS));
  372. if (val & 0x4000)
  373. break;
  374. }
  376. /* now read the version */
  377. for (i = 0; i < 32000; i++)
  378. {
  379. val = inw(REG(PSS_STATUS));
  380. if (val & PSS_READ_FULL)
  381. break;
  382. }
  383. if (i == 32000)
  384. return 0;
  386. val = inw(REG(PSS_DATA));
  387. /* printk( "<PSS: microcode version %d.%d loaded>",  val/16,  val % 16); */
  388. }
  389. return 1;
  390. }
  392. /* Mixer */
  393. static void set_master_volume(pss_confdata *devc, int left, int right)
  394. {
  395. static unsigned char log_scale[101] =  {
  396. 0xdb, 0xe0, 0xe3, 0xe5, 0xe7, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xed, 0xee,
  397. 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3,
  398. 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7,
  399. 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9,
  400. 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb,
  401. 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc,
  402. 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd,
  403. 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
  404. 0xfe, 0xfe, 0xff, 0xff, 0xff
  405. };
  406. pss_write(devc, 0x0010);
  407. pss_write(devc, log_scale[left] | 0x0000);
  408. pss_write(devc, 0x0010);
  409. pss_write(devc, log_scale[right] | 0x0100);
  410. }
  412. static void set_synth_volume(pss_confdata *devc, int volume)
  413. {
  414. int vol = ((0x8000*volume)/100L);
  415. pss_write(devc, 0x0080);
  416. pss_write(devc, vol);
  417. pss_write(devc, 0x0081);
  418. pss_write(devc, vol);
  419. }
  421. static void set_bass(pss_confdata *devc, int level)
  422. {
  423. int vol = (int)(((0xfd - 0xf0) * level)/100L) + 0xf0;
  424. pss_write(devc, 0x0010);
  425. pss_write(devc, vol | 0x0200);
  426. };
  428. static void set_treble(pss_confdata *devc, int level)
  429. {
  430. int vol = (((0xfd - 0xf0) * level)/100L) + 0xf0;
  431. pss_write(devc, 0x0010);
  432. pss_write(devc, vol | 0x0300);
  433. };
  435. static void pss_mixer_reset(pss_confdata *devc)
  436. {
  437. set_master_volume(devc, 33, 33);
  438. set_bass(devc, 50);
  439. set_treble(devc, 50);
  440. set_synth_volume(devc, 30);
  441. pss_write (devc, 0x0010);
  442. pss_write (devc, 0x0800 | 0xce); /* Stereo */
  444. if(pss_mixer)
  445. {
  446. devc->mixer.volume_l = devc->mixer.volume_r = 33;
  447. devc->mixer.bass = 50;
  448. devc->mixer.treble = 50;
  449. devc->mixer.synth = 30;
  450. }
  451. }
  453. static void arg_to_volume_mono(unsigned int volume, int *aleft)
  454. {
  455. int left;
  457. left = volume & 0x00ff;
  458. if (left > 100)
  459. left = 100;
  460. *aleft = left;
  461. }
  463. static void arg_to_volume_stereo(unsigned int volume, int *aleft, int *aright)
  464. {
  465. arg_to_volume_mono(volume, aleft);
  466. arg_to_volume_mono(volume >> 8, aright);
  467. }
  469. static int ret_vol_mono(int left)
  470. {
  471. return ((left << 8) | left);
  472. }
  474. static int ret_vol_stereo(int left, int right)
  475. {
  476. return ((right << 8) | left);
  477. }
  479. static int call_ad_mixer(pss_confdata *devc,unsigned int cmd, caddr_t arg)
  480. {
  481. if (devc->ad_mixer_dev != NO_WSS_MIXER) 
  482. return mixer_devs[devc->ad_mixer_dev]->ioctl(devc->ad_mixer_dev, cmd, arg);
  483. else 
  484. return -EINVAL;
  485. }
  487. static int pss_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
  488. {
  489. pss_confdata *devc = mixer_devs[dev]->devc;
  490. int cmdf = cmd & 0xff;
  492. if ((cmdf != SOUND_MIXER_VOLUME) && (cmdf != SOUND_MIXER_BASS) &&
  493. (cmdf != SOUND_MIXER_TREBLE) && (cmdf != SOUND_MIXER_SYNTH) &&
  494. (cmdf != SOUND_MIXER_DEVMASK) && (cmdf != SOUND_MIXER_STEREODEVS) &&
  495. (cmdf != SOUND_MIXER_RECMASK) && (cmdf != SOUND_MIXER_CAPS) &&
  496. (cmdf != SOUND_MIXER_RECSRC)) 
  497. {
  498. return call_ad_mixer(devc, cmd, arg);
  499. }
  501. if (((cmd >> 8) & 0xff) != 'M')
  502. return -EINVAL;
  504. if (_SIOC_DIR (cmd) & _SIOC_WRITE)
  505. {
  506. switch (cmdf)
  507. {
  508. case SOUND_MIXER_RECSRC:
  509. if (devc->ad_mixer_dev != NO_WSS_MIXER)
  510. return call_ad_mixer(devc, cmd, arg);
  511. else
  512. {
  513. if (*(int *)arg != 0)
  514. return -EINVAL;
  515. return 0;
  516. }
  517. case SOUND_MIXER_VOLUME:
  518. arg_to_volume_stereo(*(unsigned int *)arg, &devc->mixer.volume_l,
  519. &devc->mixer.volume_r); 
  520. set_master_volume(devc, devc->mixer.volume_l,
  521. devc->mixer.volume_r);
  522. return ret_vol_stereo(devc->mixer.volume_l,
  523. devc->mixer.volume_r);
  524.   
  525. case SOUND_MIXER_BASS:
  526. arg_to_volume_mono(*(unsigned int *)arg,
  527. &devc->mixer.bass);
  528. set_bass(devc, devc->mixer.bass);
  529. return ret_vol_mono(devc->mixer.bass);
  530.   
  531. case SOUND_MIXER_TREBLE:
  532. arg_to_volume_mono(*(unsigned int *)arg,
  533. &devc->mixer.treble);
  534. set_treble(devc, devc->mixer.treble);
  535. return ret_vol_mono(devc->mixer.treble);
  536.   
  537. case SOUND_MIXER_SYNTH:
  538. arg_to_volume_mono(*(unsigned int *)arg,
  539. &devc->mixer.synth);
  540. set_synth_volume(devc, devc->mixer.synth);
  541. return ret_vol_mono(devc->mixer.synth);
  542.   
  543. default:
  544. return -EINVAL;
  545. }
  546. }
  547. else
  548. {
  549. /*
  550.  * Return parameters
  551.  */
  552. switch (cmdf)
  553. {
  555. case SOUND_MIXER_DEVMASK:
  556. if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
  557. *(int *)arg = 0; /* no mixer devices */
  558. return (*(int *)arg |= SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_SYNTH);
  559.   
  560. case SOUND_MIXER_STEREODEVS:
  561. if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
  562. *(int *)arg = 0; /* no stereo devices */
  563. return (*(int *)arg |= SOUND_MASK_VOLUME);
  564.   
  565. case SOUND_MIXER_RECMASK:
  566. if (devc->ad_mixer_dev != NO_WSS_MIXER)
  567. return call_ad_mixer(devc, cmd, arg);
  568. else
  569. return (*(int *)arg = 0); /* no record devices */
  571. case SOUND_MIXER_CAPS:
  572. if (devc->ad_mixer_dev != NO_WSS_MIXER)
  573. return call_ad_mixer(devc, cmd, arg);
  574. else
  575. return (*(int *)arg = SOUND_CAP_EXCL_INPUT);
  577. case SOUND_MIXER_RECSRC:
  578. if (devc->ad_mixer_dev != NO_WSS_MIXER)
  579. return call_ad_mixer(devc, cmd, arg);
  580. else
  581. return (*(int *)arg = 0); /* no record source */
  583. case SOUND_MIXER_VOLUME:
  584. return (*(int *)arg = ret_vol_stereo(devc->mixer.volume_l, devc->mixer.volume_r));
  585.   
  586. case SOUND_MIXER_BASS:
  587. return (*(int *)arg = ret_vol_mono(devc->mixer.bass));
  588.   
  589. case SOUND_MIXER_TREBLE:
  590. return (*(int *)arg = ret_vol_mono(devc->mixer.treble));
  591.   
  592. case SOUND_MIXER_SYNTH:
  593. return (*(int *)arg = ret_vol_mono(devc->mixer.synth));
  594. default:
  595. return -EINVAL;
  596. }
  597. }
  598. }
  600. static struct mixer_operations pss_mixer_operations =
  601. {
  602. owner: THIS_MODULE,
  603. id: "SOUNDPORT",
  604. name: "PSS-AD1848",
  605. ioctl: pss_mixer_ioctl
  606. };
  608. void disable_all_emulations(void)
  609. {
  610. outw(0x0000, REG(CONF_PSS)); /* 0x0400 enables joystick */
  611. outw(0x0000, REG(CONF_WSS));
  612. outw(0x0000, REG(CONF_SB));
  613. outw(0x0000, REG(CONF_MIDI));
  614. outw(0x0000, REG(CONF_CDROM));
  615. }
  617. void configure_nonsound_components(void)
  618. {
  619. /* Configure Joystick port */
  621. if(pss_enable_joystick)
  622. {
  623. outw(0x0400, REG(CONF_PSS)); /* 0x0400 enables joystick */
  624. printk(KERN_INFO "PSS: joystick enabled.n");
  625. }
  626. else
  627. {
  628. printk(KERN_INFO "PSS: joystick port not enabled.n");
  629. }
  631. /* Configure CDROM port */
  633. if(pss_cdrom_port == -1) /* If cdrom port enablation wasn't requested */
  634. {
  635. printk(KERN_INFO "PSS: CDROM port not enabled.n");
  636. }
  637. else if(check_region(pss_cdrom_port, 2))
  638. {
  639. printk(KERN_ERR "PSS: CDROM I/O port conflict.n");
  640. }
  641. else if(!set_io_base(devc, CONF_CDROM, pss_cdrom_port))
  642. {
  643. printk(KERN_ERR "PSS: CDROM I/O port could not be set.n");
  644. }
  645. else /* CDROM port successfully configured */
  646. {
  647. printk(KERN_INFO "PSS: CDROM I/O port set to 0x%x.n", pss_cdrom_port);
  648. }
  649. }
  651. void __init attach_pss(struct address_info *hw_config)
  652. {
  653. unsigned short  id;
  654. char tmp[100];
  656. devc->base = hw_config->io_base;
  657. devc->irq = hw_config->irq;
  658. devc->dma = hw_config->dma;
  659. devc->osp = hw_config->osp;
  660. devc->ad_mixer_dev = NO_WSS_MIXER;
  662. if (!probe_pss(hw_config))
  663. return;
  665. request_region(hw_config->io_base, 0x10, "PSS mixer, SB emulation");
  666. request_region(hw_config->io_base + 0x10, 0x9, "PSS config");
  668. id = inw(REG(PSS_ID)) & 0x00ff;
  670. /*
  671.  * Disable all emulations. Will be enabled later (if required).
  672.  */
  673.  
  674. disable_all_emulations();
  676. #if YOU_REALLY_WANT_TO_ALLOCATE_THESE_RESOURCES
  677. if (sound_alloc_dma(hw_config->dma, "PSS"))
  678. {
  679. printk("pss.c: Can't allocate DMA channel.n");
  680. return;
  681. }
  682. if (!set_irq(devc, CONF_PSS, devc->irq))
  683. {
  684. printk("PSS: IRQ allocation error.n");
  685. return;
  686. }
  687. if (!set_dma(devc, CONF_PSS, devc->dma))
  688. {
  689. printk(KERN_ERR "PSS: DMA allocation errorn");
  690. return;
  691. }
  692. #endif
  694. configure_nonsound_components();
  695. pss_initialized = 1;
  696. sprintf(tmp, "ECHO-PSS  Rev. %d", id);
  697. conf_printf(tmp, hw_config);
  698. }
  700. int __init probe_pss_mpu(struct address_info *hw_config)
  701. {
  702. int timeout;
  704. if (!pss_initialized)
  705. return 0;
  707. if (check_region(hw_config->io_base, 2))
  708. {
  709. printk(KERN_ERR "PSS: MPU I/O port conflictn");
  710. return 0;
  711. }
  712. if (!set_io_base(devc, CONF_MIDI, hw_config->io_base))
  713. {
  714.   printk(KERN_ERR "PSS: MIDI base could not be set.n");
  715.   return 0;
  716. }
  717. if (!set_irq(devc, CONF_MIDI, hw_config->irq))
  718. {
  719.   printk(KERN_ERR "PSS: MIDI IRQ allocation error.n");
  720.   return 0;
  721. }
  722. if (!pss_synthLen)
  723. {
  724. printk(KERN_ERR "PSS: Can't enable MPU. MIDI synth microcode not available.n");
  725. return 0;
  726. }
  727. if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
  728. {
  729. printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.n");
  730. return 0;
  731. }
  733. /*
  734.  * Finally wait until the DSP algorithm has initialized itself and
  735.  * deactivates receive interrupt.
  736.  */
  738. for (timeout = 900000; timeout > 0; timeout--)
  739. {
  740. if ((inb(hw_config->io_base + 1) & 0x80) == 0) /* Input data avail */
  741. inb(hw_config->io_base); /* Discard it */
  742. else
  743. break; /* No more input */
  744. }
  746. return probe_mpu401(hw_config);
  747. }
  749. static int pss_coproc_open(void *dev_info, int sub_device)
  750. {
  751. switch (sub_device)
  752. {
  753. case COPR_MIDI:
  754. if (pss_synthLen == 0)
  755. {
  756. printk(KERN_ERR "PSS: MIDI synth microcode not available.n");
  757. return -EIO;
  758. }
  759. if (nonstandard_microcode)
  760. if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
  761. {
  762. printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.n");
  763. return -EIO;
  764. }
  765. nonstandard_microcode = 0;
  766. break;
  768. default:
  769. break;
  770. }
  771. return 0;
  772. }
  774. static void pss_coproc_close(void *dev_info, int sub_device)
  775. {
  776. return;
  777. }
  779. static void pss_coproc_reset(void *dev_info)
  780. {
  781. if (pss_synthLen)
  782. if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
  783. {
  784. printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.n");
  785. }
  786. nonstandard_microcode = 0;
  787. }
  789. static int download_boot_block(void *dev_info, copr_buffer * buf)
  790. {
  791. if (buf->len <= 0 || buf->len > sizeof(buf->data))
  792. return -EINVAL;
  794. if (!pss_download_boot(devc, buf->data, buf->len, buf->flags))
  795. {
  796. printk(KERN_ERR "PSS: Unable to load microcode block to DSP.n");
  797. return -EIO;
  798. }
  799. nonstandard_microcode = 1; /* The MIDI microcode has been overwritten */
  800. return 0;
  801. }
  803. static int pss_coproc_ioctl(void *dev_info, unsigned int cmd, caddr_t arg, int local)
  804. {
  805. copr_buffer *buf;
  806. copr_msg *mbuf;
  807. copr_debug_buf dbuf;
  808. unsigned short tmp;
  809. unsigned long flags;
  810. unsigned short *data;
  811. int i, err;
  812. /* printk( "PSS coproc ioctl %x %x %dn",  cmd,  arg,  local); */
  814. switch (cmd) 
  815. {
  816. case SNDCTL_COPR_RESET:
  817. pss_coproc_reset(dev_info);
  818. return 0;
  820. case SNDCTL_COPR_LOAD:
  821. buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
  822. if (buf == NULL)
  823. return -ENOSPC;
  824. if (copy_from_user(buf, arg, sizeof(copr_buffer))) {
  825. vfree(buf);
  826. return -EFAULT;
  827. }
  828. err = download_boot_block(dev_info, buf);
  829. vfree(buf);
  830. return err;
  832. case SNDCTL_COPR_SENDMSG:
  833. mbuf = (copr_msg *)vmalloc(sizeof(copr_msg));
  834. if (mbuf == NULL)
  835. return -ENOSPC;
  836. if (copy_from_user(mbuf, arg, sizeof(copr_msg))) {
  837. vfree(mbuf);
  838. return -EFAULT;
  839. }
  840. data = (unsigned short *)(mbuf->data);
  841. save_flags(flags);
  842. cli();
  843. for (i = 0; i < mbuf->len; i++) {
  844. if (!pss_put_dspword(devc, *data++)) {
  845. restore_flags(flags);
  846. mbuf->len = i; /* feed back number of WORDs sent */
  847. err = copy_to_user(arg, mbuf, sizeof(copr_msg));
  848. vfree(mbuf);
  849. return err ? -EFAULT : -EIO;
  850. }
  851. }
  852. restore_flags(flags);
  853. vfree(mbuf);
  854. return 0;
  856. case SNDCTL_COPR_RCVMSG:
  857. err = 0;
  858. mbuf = (copr_msg *)vmalloc(sizeof(copr_msg));
  859. if (mbuf == NULL)
  860. return -ENOSPC;
  861. data = (unsigned short *)mbuf->data;
  862. save_flags(flags);
  863. cli();
  864. for (i = 0; i < sizeof(mbuf->data)/sizeof(unsigned short); i++) {
  865. mbuf->len = i; /* feed back number of WORDs read */
  866. if (!pss_get_dspword(devc, data++)) {
  867. if (i == 0)
  868. err = -EIO;
  869. break;
  870. }
  871. }
  872. restore_flags(flags);
  873. if (copy_to_user(arg, mbuf, sizeof(copr_msg)))
  874. err = -EFAULT;
  875. vfree(mbuf);
  876. return err;
  878. case SNDCTL_COPR_RDATA:
  879. if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
  880. return -EFAULT;
  881. save_flags(flags);
  882. cli();
  883. if (!pss_put_dspword(devc, 0x00d0)) {
  884. restore_flags(flags);
  885. return -EIO;
  886. }
  887. if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
  888. restore_flags(flags);
  889. return -EIO;
  890. }
  891. if (!pss_get_dspword(devc, &tmp)) {
  892. restore_flags(flags);
  893. return -EIO;
  894. }
  895. dbuf.parm1 = tmp;
  896. restore_flags(flags);
  897. if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
  898. return -EFAULT;
  899. return 0;
  901. case SNDCTL_COPR_WDATA:
  902. if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
  903. return -EFAULT;
  904. save_flags(flags);
  905. cli();
  906. if (!pss_put_dspword(devc, 0x00d1)) {
  907. restore_flags(flags);
  908. return -EIO;
  909. }
  910. if (!pss_put_dspword(devc, (unsigned short) (dbuf.parm1 & 0xffff))) {
  911. restore_flags(flags);
  912. return -EIO;
  913. }
  914. tmp = (unsigned int)dbuf.parm2 & 0xffff;
  915. if (!pss_put_dspword(devc, tmp)) {
  916. restore_flags(flags);
  917. return -EIO;
  918. }
  919. restore_flags(flags);
  920. return 0;
  922. case SNDCTL_COPR_WCODE:
  923. if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
  924. return -EFAULT;
  925. save_flags(flags);
  926. cli();
  927. if (!pss_put_dspword(devc, 0x00d3)) {
  928. restore_flags(flags);
  929. return -EIO;
  930. }
  931. if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
  932. restore_flags(flags);
  933. return -EIO;
  934. }
  935. tmp = (unsigned int)dbuf.parm2 & 0x00ff;
  936. if (!pss_put_dspword(devc, tmp)) {
  937. restore_flags(flags);
  938. return -EIO;
  939. }
  940. tmp = ((unsigned int)dbuf.parm2 >> 8) & 0xffff;
  941. if (!pss_put_dspword(devc, tmp)) {
  942. restore_flags(flags);
  943. return -EIO;
  944. }
  945. restore_flags(flags);
  946. return 0;
  948. case SNDCTL_COPR_RCODE:
  949. if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
  950. return -EFAULT;
  951. save_flags(flags);
  952. cli();
  953. if (!pss_put_dspword(devc, 0x00d2)) {
  954. restore_flags(flags);
  955. return -EIO;
  956. }
  957. if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
  958. restore_flags(flags);
  959. return -EIO;
  960. }
  961. if (!pss_get_dspword(devc, &tmp)) { /* Read MSB */
  962. restore_flags(flags);
  963. return -EIO;
  964. }
  965. dbuf.parm1 = tmp << 8;
  966. if (!pss_get_dspword(devc, &tmp)) { /* Read LSB */
  967. restore_flags(flags);
  968. return -EIO;
  969. }
  970. dbuf.parm1 |= tmp & 0x00ff;
  971. restore_flags(flags);
  972. if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
  973. return -EFAULT;
  974. return 0;
  976. default:
  977. return -EINVAL;
  978. }
  979. return -EINVAL;
  980. }
  982. static coproc_operations pss_coproc_operations =
  983. {
  984. "ADSP-2115",
  985. THIS_MODULE,
  986. pss_coproc_open,
  987. pss_coproc_close,
  988. pss_coproc_ioctl,
  989. pss_coproc_reset,
  990. &pss_data
  991. };
  993. static void __init attach_pss_mpu(struct address_info *hw_config)
  994. {
  995. attach_mpu401(hw_config, THIS_MODULE); /* Slot 1 */
  996. if (hw_config->slots[1] != -1) /* The MPU driver installed itself */
  997. midi_devs[hw_config->slots[1]]->coproc = &pss_coproc_operations;
  998. }
  1000. static int __init probe_pss_mss(struct address_info *hw_config)
  1001. {
  1002. volatile int timeout;
  1004. if (!pss_initialized)
  1005. return 0;
  1007. if (check_region(hw_config->io_base, 8))
  1008. {
  1009.   printk(KERN_ERR "PSS: WSS I/O port conflicts.n");
  1010.   return 0;
  1011. }
  1012. if (!set_io_base(devc, CONF_WSS, hw_config->io_base))
  1013. {
  1014. printk("PSS: WSS base not settable.n");
  1015. return 0;
  1016. }
  1017. if (!set_irq(devc, CONF_WSS, hw_config->irq))
  1018. {
  1019. printk("PSS: WSS IRQ allocation error.n");
  1020. return 0;
  1021. }
  1022. if (!set_dma(devc, CONF_WSS, hw_config->dma))
  1023. {
  1024. printk(KERN_ERR "PSS: WSS DMA allocation errorn");
  1025. return 0;
  1026. }
  1027. /*
  1028.  * For some reason the card returns 0xff in the WSS status register
  1029.  * immediately after boot. Probably MIDI+SB emulation algorithm
  1030.  * downloaded to the ADSP2115 spends some time initializing the card.
  1031.  * Let's try to wait until it finishes this task.
  1032.  */
  1033. for (timeout = 0; timeout < 100000 && (inb(hw_config->io_base + WSS_INDEX) &
  1034.   WSS_INITIALIZING); timeout++)
  1035. ;
  1037. outb((0x0b), hw_config->io_base + WSS_INDEX); /* Required by some cards */
  1039. for (timeout = 0; (inb(hw_config->io_base + WSS_DATA) & WSS_AUTOCALIBRATION) &&
  1040.   (timeout < 100000); timeout++)
  1041. ;
  1043. return probe_ms_sound(hw_config);
  1044. }
  1046. static void __init attach_pss_mss(struct address_info *hw_config)
  1047. {
  1048. int        my_mix = -999; /* gcc shut up */
  1050. devc->ad_mixer_dev = NO_WSS_MIXER;
  1051. if (pss_mixer) 
  1052. {
  1053. if ((my_mix = sound_install_mixer (MIXER_DRIVER_VERSION,
  1054. "PSS-SPEAKERS and AD1848 (through MSS audio codec)",
  1055. &pss_mixer_operations,
  1056. sizeof (struct mixer_operations),
  1057. devc)) < 0) 
  1058. {
  1059. printk(KERN_ERR "Could not install PSS mixern");
  1060. return;
  1061. }
  1062. }
  1063. pss_mixer_reset(devc);
  1064. attach_ms_sound(hw_config, THIS_MODULE); /* Slot 0 */
  1066. if (hw_config->slots[0] != -1)
  1067. {
  1068. /* The MSS driver installed itself */
  1069. audio_devs[hw_config->slots[0]]->coproc = &pss_coproc_operations;
  1070. if (pss_mixer && (num_mixers == (my_mix + 2)))
  1071. {
  1072. /* The MSS mixer installed */
  1073. devc->ad_mixer_dev = audio_devs[hw_config->slots[0]]->mixer_dev;
  1074. }
  1075. }
  1076. }
  1078. static inline void __exit unload_pss(struct address_info *hw_config)
  1079. {
  1080. release_region(hw_config->io_base, 0x10);
  1081. release_region(hw_config->io_base+0x10, 0x9);
  1082. }
  1084. static inline void __exit unload_pss_mpu(struct address_info *hw_config)
  1085. {
  1086. unload_mpu401(hw_config);
  1087. }
  1089. static inline void __exit unload_pss_mss(struct address_info *hw_config)
  1090. {
  1091. unload_ms_sound(hw_config);
  1092. }
  1095. static struct address_info cfg;
  1096. static struct address_info cfg2;
  1097. static struct address_info cfg_mpu;
  1099. static int pss_io __initdata = -1;
  1100. static int mss_io __initdata = -1;
  1101. static int mss_irq __initdata = -1;
  1102. static int mss_dma __initdata = -1;
  1103. static int mpu_io __initdata = -1;
  1104. static int mpu_irq __initdata = -1;
  1105. static int pss_no_sound __initdata = 0; /* Just configure non-sound components */
  1106. static int pss_keep_settings  = 1; /* Keep hardware settings at module exit */
  1107. static char *pss_firmware = "/etc/sound/pss_synth";
  1109. MODULE_PARM(pss_io, "i");
  1110. MODULE_PARM_DESC(pss_io, "Set i/o base of PSS card (probably 0x220 or 0x240)");
  1111. MODULE_PARM(mss_io, "i");
  1112. MODULE_PARM_DESC(mss_io, "Set WSS (audio) i/o base (0x530, 0x604, 0xE80, 0xF40, or other. Address must end in 0 or 4 and must be from 0x100 to 0xFF4)");
  1113. MODULE_PARM(mss_irq, "i");
  1114. MODULE_PARM_DESC(mss_irq, "Set WSS (audio) IRQ (3, 5, 7, 9, 10, 11, 12)");
  1115. MODULE_PARM(mss_dma, "i");
  1116. MODULE_PARM_DESC(mss_dma, "Set WSS (audio) DMA (0, 1, 3)");
  1117. MODULE_PARM(mpu_io, "i");
  1118. MODULE_PARM_DESC(mpu_io, "Set MIDI i/o base (0x330 or other. Address must be on 4 location boundaries and must be from 0x100 to 0xFFC)");
  1119. MODULE_PARM(mpu_irq, "i");
  1120. MODULE_PARM_DESC(mpu_irq, "Set MIDI IRQ (3, 5, 7, 9, 10, 11, 12)");
  1121. MODULE_PARM(pss_cdrom_port, "i");
  1122. MODULE_PARM_DESC(pss_cdrom_port, "Set the PSS CDROM port i/o base (0x340 or other)");
  1123. MODULE_PARM(pss_enable_joystick, "i");
  1124. MODULE_PARM_DESC(pss_enable_joystick, "Enables the PSS joystick port (1 to enable, 0 to disable)");
  1125. MODULE_PARM(pss_no_sound, "i");
  1126. MODULE_PARM_DESC(pss_no_sound, "Configure sound compoents (0 - no, 1 - yes)");
  1127. MODULE_PARM(pss_keep_settings, "i");
  1128. MODULE_PARM_DESC(pss_keep_settings, "Keep hardware setting at driver unloading (0 - no, 1 - yes)");
  1129. MODULE_PARM(pss_firmware, "s");
  1130. MODULE_PARM_DESC(pss_firmware, "Location of the firmware file (default - /etc/sound/pss_synth)");
  1131. MODULE_PARM(pss_mixer, "b");
  1132. MODULE_PARM_DESC(pss_mixer, "Enable (1) or disable (0) PSS mixer (controlling of output volume, bass, treble, synth volume). The mixer is not available on all PSS cards.");
  1133. MODULE_AUTHOR("Hannu Savolainen, Vladimir Michl");
  1134. MODULE_DESCRIPTION("Module for PSS sound cards (based on AD1848, ADSP-2115 and ESC614). This module includes control of output amplifier and synth volume of the Beethoven ADSP-16 card (this may work with other PSS cards).");
  1135. MODULE_LICENSE("GPL");
  1138. static int fw_load = 0;
  1139. static int pssmpu = 0, pssmss = 0;
  1141. /*
  1142.  *    Load a PSS sound card module
  1143.  */
  1145. static int __init init_pss(void)
  1146. {
  1148. if(pss_no_sound) /* If configuring only nonsound components */
  1149. {
  1150. cfg.io_base = pss_io;
  1151. if(!probe_pss(&cfg))
  1152. return -ENODEV;
  1153. printk(KERN_INFO "ECHO-PSS  Rev. %dn", inw(REG(PSS_ID)) & 0x00ff);
  1154. printk(KERN_INFO "PSS: loading in no sound mode.n");
  1155. disable_all_emulations();
  1156. configure_nonsound_components();
  1157. return 0;
  1158. }
  1160. cfg.io_base = pss_io;
  1162. cfg2.io_base = mss_io;
  1163. cfg2.irq = mss_irq;
  1164. cfg2.dma = mss_dma;
  1166. cfg_mpu.io_base = mpu_io;
  1167. cfg_mpu.irq = mpu_irq;
  1169. if (cfg.io_base == -1 || cfg2.io_base == -1 || cfg2.irq == -1 || cfg.dma == -1) {
  1170. printk(KERN_INFO "pss: mss_io, mss_dma, mss_irq and pss_io must be set.n");
  1171. return -EINVAL;
  1172. }
  1174. if (!pss_synth) {
  1175. fw_load = 1;
  1176. pss_synthLen = mod_firmware_load(pss_firmware, (void *) &pss_synth);
  1177. }
  1178. if (!probe_pss(&cfg))
  1179. return -ENODEV;
  1180. attach_pss(&cfg);
  1181. /*
  1182.  *    Attach stuff
  1183.  */
  1184. if (probe_pss_mpu(&cfg_mpu)) {
  1185. pssmpu = 1;
  1186. attach_pss_mpu(&cfg_mpu);
  1187. }
  1188. if (probe_pss_mss(&cfg2)) {
  1189. pssmss = 1;
  1190. attach_pss_mss(&cfg2);
  1191. }
  1193. return 0;
  1194. }
  1196. static void __exit cleanup_pss(void)
  1197. {
  1198. if(!pss_no_sound)
  1199. {
  1200. if(fw_load && pss_synth)
  1201. vfree(pss_synth);
  1202. if(pssmss)
  1203. unload_pss_mss(&cfg2);
  1204. if(pssmpu)
  1205. unload_pss_mpu(&cfg_mpu);
  1206. unload_pss(&cfg);
  1207. }
  1209. if(!pss_keep_settings) /* Keep hardware settings if asked */
  1210. {
  1211. disable_all_emulations();
  1212. printk(KERN_INFO "Resetting PSS sound card configurations.n");
  1213. }
  1214. }
  1216. module_init(init_pss);
  1217. module_exit(cleanup_pss);
  1219. #ifndef MODULE
  1220. static int __init setup_pss(char *str)
  1221. {
  1222. /* io, mss_io, mss_irq, mss_dma, mpu_io, mpu_irq */
  1223. int ints[7];
  1225. str = get_options(str, ARRAY_SIZE(ints), ints);
  1227. pss_io = ints[1];
  1228. mss_io = ints[2];
  1229. mss_irq = ints[3];
  1230. mss_dma = ints[4];
  1231. mpu_io = ints[5];
  1232. mpu_irq = ints[6];
  1234. return 1;
  1235. }
  1237. __setup("pss=", setup_pss);
  1238. #endif