sound/oss/ymfpci.c

   1 /*
   2  *  Copyright 1999 Jaroslav Kysela <perex@suse.cz>
   3  *  Copyright 2000 Alan Cox <alan@redhat.com>
   4  *  Copyright 2001 Kai Germaschewski <kai@tp1.ruhr-uni-bochum.de>
   5  *  Copyright 2002 Pete Zaitcev <zaitcev@yahoo.com>
   6  *
   7  *  Yamaha YMF7xx driver.
   8  *
   9  *  This code is a result of high-speed collision
  10  *  between ymfpci.c of ALSA and cs46xx.c of Linux.
  11  *  -- Pete Zaitcev <zaitcev@yahoo.com>; 2000/09/18
  12  *
  13  *   This program is free software; you can redistribute it and/or modify
  14  *   it under the terms of the GNU General Public License as published by
  15  *   the Free Software Foundation; either version 2 of the License, or
  16  *   (at your option) any later version.
  17  *
  18  *   This program is distributed in the hope that it will be useful,
  19  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *   GNU General Public License for more details.
  22  *
  23  *   You should have received a copy of the GNU General Public License
  24  *   along with this program; if not, write to the Free Software
  25  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  *
  27  * TODO:
  28  *  - Use P44Slot for 44.1 playback (beware of idle buzzing in P44Slot).
  29  *  - 96KHz playback for DVD - use pitch of 2.0.
  30  *  - Retain DMA buffer on close, do not wait the end of frame.
  31  *  - Resolve XXX tagged questions.
  32  *  - Cannot play 5133Hz.
  33  *  - 2001/01/07 Consider if we can remove voice_lock, like so:
  34  *     : Allocate/deallocate voices in open/close under semafore.
  35  *     : We access voices in interrupt, that only for pcms that open.
  36  *    voice_lock around playback_prepare closes interrupts for insane duration.
  37  *  - Revisit the way voice_alloc is done - too confusing, overcomplicated.
  38  *    Should support various channel types, however.
  39  *  - Remove prog_dmabuf from read/write, leave it in open.
  40  *  - 2001/01/07 Replace the OPL3 part of CONFIG_SOUND_YMFPCI_LEGACY code with
  41  *    native synthesizer through a playback slot.
  42  *  - 2001/11/29 ac97_save_state
  43  *    Talk to Kai to remove ac97_save_state before it's too late!
  44  *  - Second AC97
  45  *  - Restore S/PDIF - Toshibas have it.
  46  *
  47  * Kai used pci_alloc_consistent for DMA buffer, which sounds a little
  48  * unconventional. However, given how small our fragments can be,
  49  * a little uncached access is perhaps better than endless flushing.
  50  * On i386 and other I/O-coherent architectures pci_alloc_consistent
  51  * is entirely harmless.
  52  */
  53
  54 #include <linux/config.h>
  55 #include <linux/module.h>
  56 #include <linux/init.h>
  57 #include <linux/interrupt.h>
  58 #include <linux/ioport.h>
  59 #include <linux/delay.h>
  60 #include <linux/pci.h>
  61 #include <linux/slab.h>
  62 #include <linux/poll.h>
  63 #include <linux/soundcard.h>
  64 #include <linux/ac97_codec.h>
  65 #include <linux/sound.h>
  66
  67 #include <asm/io.h>
  68 #include <asm/dma.h>
  69 #include <asm/uaccess.h>
  70
  71 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
  72 # include "sound_config.h"
  73 # include "mpu401.h"
  74 #endif
  75 #include "ymfpci.h"
  76
  77 /*
  78  * I do not believe in debug levels as I never can guess what
  79  * part of the code is going to be problematic in the future.
  80  * Don't forget to run your klogd with -c 8.
  81  *
  82  * Example (do not remove):
  83  * #define YMFDBG(fmt, arg...)  do{ printk(KERN_DEBUG fmt, ##arg); }while(0)
  84  */
  85 #define YMFDBGW(fmt, arg...)  /* */     /* write counts */
  86 #define YMFDBGI(fmt, arg...)  /* */     /* interrupts */
  87 #define YMFDBGX(fmt, arg...)  /* */     /* ioctl */
  88
  89 static int ymf_playback_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
  90 static void ymf_capture_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
  91 static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice);
  92 static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank);
  93 static int ymf_playback_prepare(struct ymf_state *state);
  94 static int ymf_capture_prepare(struct ymf_state *state);
  95 static struct ymf_state *ymf_state_alloc(ymfpci_t *unit);
  96
  97 static void ymfpci_aclink_reset(struct pci_dev * pci);
  98 static void ymfpci_disable_dsp(ymfpci_t *unit);
  99 static void ymfpci_download_image(ymfpci_t *codec);
 100 static void ymf_memload(ymfpci_t *unit);
 101
 102 static spinlock_t ymf_devs_lock = SPIN_LOCK_UNLOCKED;
 103 static LIST_HEAD(ymf_devs);
 104
 105 /*
 106  *  constants
 107  */
 108
 109 static struct pci_device_id ymf_id_tbl[] = {
 110 #define DEV(v, d, data) \
 111   { PCI_VENDOR_ID_##v, PCI_DEVICE_ID_##v##_##d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (unsigned long)data }
 112         DEV (YAMAHA, 724,  "YMF724"),
 113         DEV (YAMAHA, 724F, "YMF724F"),
 114         DEV (YAMAHA, 740,  "YMF740"),
 115         DEV (YAMAHA, 740C, "YMF740C"),
 116         DEV (YAMAHA, 744,  "YMF744"),
 117         DEV (YAMAHA, 754,  "YMF754"),
 118 #undef DEV
 119         { }
 120 };
 121 MODULE_DEVICE_TABLE(pci, ymf_id_tbl);
 122
 123 /*
 124  *  common I/O routines
 125  */
 126
 127 static inline u8 ymfpci_readb(ymfpci_t *codec, u32 offset)
 128 {
 129         return readb(codec->reg_area_virt + offset);
 130 }
 131
 132 static inline void ymfpci_writeb(ymfpci_t *codec, u32 offset, u8 val)
 133 {
 134         writeb(val, codec->reg_area_virt + offset);
 135 }
 136
 137 static inline u16 ymfpci_readw(ymfpci_t *codec, u32 offset)
 138 {
 139         return readw(codec->reg_area_virt + offset);
 140 }
 141
 142 static inline void ymfpci_writew(ymfpci_t *codec, u32 offset, u16 val)
 143 {
 144         writew(val, codec->reg_area_virt + offset);
 145 }
 146
 147 static inline u32 ymfpci_readl(ymfpci_t *codec, u32 offset)
 148 {
 149         return readl(codec->reg_area_virt + offset);
 150 }
 151
 152 static inline void ymfpci_writel(ymfpci_t *codec, u32 offset, u32 val)
 153 {
 154         writel(val, codec->reg_area_virt + offset);
 155 }
 156
 157 static int ymfpci_codec_ready(ymfpci_t *codec, int secondary, int sched)
 158 {
 159         signed long end_time;
 160         u32 reg = secondary ? YDSXGR_SECSTATUSADR : YDSXGR_PRISTATUSADR;
 161
 162         end_time = jiffies + 3 * (HZ / 4);
 163         do {
 164                 if ((ymfpci_readw(codec, reg) & 0x8000) == 0)
 165                         return 0;
 166                 if (sched) {
 167                         set_current_state(TASK_UNINTERRUPTIBLE);
 168                         schedule_timeout(1);
 169                 }
 170         } while (end_time - (signed long)jiffies >= 0);
 171         printk(KERN_ERR "ymfpci_codec_ready: codec %i is not ready [0x%x]\n",
 172             secondary, ymfpci_readw(codec, reg));
 173         return -EBUSY;
 174 }
 175
 176 static void ymfpci_codec_write(struct ac97_codec *dev, u8 reg, u16 val)
 177 {
 178         ymfpci_t *codec = dev->private_data;
 179         u32 cmd;
 180
 181         spin_lock(&codec->ac97_lock);
 182         /* XXX Do make use of dev->id */
 183         ymfpci_codec_ready(codec, 0, 0);
 184         cmd = ((YDSXG_AC97WRITECMD | reg) << 16) | val;
 185         ymfpci_writel(codec, YDSXGR_AC97CMDDATA, cmd);
 186         spin_unlock(&codec->ac97_lock);
 187 }
 188
 189 static u16 _ymfpci_codec_read(ymfpci_t *unit, u8 reg)
 190 {
 191         int i;
 192
 193         if (ymfpci_codec_ready(unit, 0, 0))
 194                 return ~0;
 195         ymfpci_writew(unit, YDSXGR_AC97CMDADR, YDSXG_AC97READCMD | reg);
 196         if (ymfpci_codec_ready(unit, 0, 0))
 197                 return ~0;
 198         if (unit->pci->device == PCI_DEVICE_ID_YAMAHA_744 && unit->rev < 2) {
 199                 for (i = 0; i < 600; i++)
 200                         ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
 201         }
 202         return ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
 203 }
 204
 205 static u16 ymfpci_codec_read(struct ac97_codec *dev, u8 reg)
 206 {
 207         ymfpci_t *unit = dev->private_data;
 208         u16 ret;
 209
 210         spin_lock(&unit->ac97_lock);
 211         ret = _ymfpci_codec_read(unit, reg);
 212         spin_unlock(&unit->ac97_lock);
 213
 214         return ret;
 215 }
 216
 217 /*
 218  *  Misc routines
 219  */
 220
 221 /*
 222  * Calculate the actual sampling rate relatetively to the base clock (48kHz).
 223  */
 224 static u32 ymfpci_calc_delta(u32 rate)
 225 {
 226         switch (rate) {
 227         case 8000:      return 0x02aaab00;
 228         case 11025:     return 0x03accd00;
 229         case 16000:     return 0x05555500;
 230         case 22050:     return 0x07599a00;
 231         case 32000:     return 0x0aaaab00;
 232         case 44100:     return 0x0eb33300;
 233         default:        return ((rate << 16) / 48000) << 12;
 234         }
 235 }
 236
 237 static u32 def_rate[8] = {
 238         100, 2000, 8000, 11025, 16000, 22050, 32000, 48000
 239 };
 240
 241 static u32 ymfpci_calc_lpfK(u32 rate)
 242 {
 243         u32 i;
 244         static u32 val[8] = {
 245                 0x00570000, 0x06AA0000, 0x18B20000, 0x20930000,
 246                 0x2B9A0000, 0x35A10000, 0x3EAA0000, 0x40000000
 247         };
 248
 249         if (rate == 44100)
 250                 return 0x40000000;      /* FIXME: What's the right value? */
 251         for (i = 0; i < 8; i++)
 252                 if (rate <= def_rate[i])
 253                         return val[i];
 254         return val[0];
 255 }
 256
 257 static u32 ymfpci_calc_lpfQ(u32 rate)
 258 {
 259         u32 i;
 260         static u32 val[8] = {
 261                 0x35280000, 0x34A70000, 0x32020000, 0x31770000,
 262                 0x31390000, 0x31C90000, 0x33D00000, 0x40000000
 263         };
 264
 265         if (rate == 44100)
 266                 return 0x370A0000;
 267         for (i = 0; i < 8; i++)
 268                 if (rate <= def_rate[i])
 269                         return val[i];
 270         return val[0];
 271 }
 272
 273 static u32 ymf_calc_lend(u32 rate)
 274 {
 275         return (rate * YMF_SAMPF) / 48000;
 276 }
 277
 278 /*
 279  * We ever allow only a few formats, but let's be generic, for smaller surprise.
 280  */
 281 static int ymf_pcm_format_width(int format)
 282 {
 283         static int mask16 = AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE;
 284
 285         if ((format & (format-1)) != 0) {
 286                 printk(KERN_ERR "ymfpci: format 0x%x is not a power of 2\n", format);
 287                 return 8;
 288         }
 289
 290         if (format == AFMT_IMA_ADPCM) return 4;
 291         if ((format & mask16) != 0) return 16;
 292         return 8;
 293 }
 294
 295 static void ymf_pcm_update_shift(struct ymf_pcm_format *f)
 296 {
 297         f->shift = 0;
 298         if (f->voices == 2)
 299                 f->shift++;
 300         if (ymf_pcm_format_width(f->format) == 16)
 301                 f->shift++;
 302 }
 303
 304 /* Are you sure 32K is not too much? See if mpg123 skips on loaded systems. */
 305 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
 306 #define DMABUF_MINORDER 1
 307
 308 /*
 309  * Allocate DMA buffer
 310  */
 311 static int alloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
 312 {
 313         void *rawbuf = NULL;
 314         dma_addr_t dma_addr;
 315         int order;
 316         struct page *map, *mapend;
 317
 318         /* alloc as big a chunk as we can */
 319         for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
 320                 rawbuf = pci_alloc_consistent(unit->pci, PAGE_SIZE << order, &dma_addr);
 321                 if (rawbuf)
 322                         break;
 323         }
 324         if (!rawbuf)
 325                 return -ENOMEM;
 326
 327 #if 0
 328         printk(KERN_DEBUG "ymfpci: allocated %ld (order = %d) bytes at %p\n",
 329                PAGE_SIZE << order, order, rawbuf);
 330 #endif
 331
 332         dmabuf->ready  = dmabuf->mapped = 0;
 333         dmabuf->rawbuf = rawbuf;
 334         dmabuf->dma_addr = dma_addr;
 335         dmabuf->buforder = order;
 336
 337         /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
 338         mapend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
 339         for (map = virt_to_page(rawbuf); map <= mapend; map++)
 340                 set_bit(PG_reserved, &map->flags);
 341
 342         return 0;
 343 }
 344
 345 /*
 346  * Free DMA buffer
 347  */
 348 static void dealloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
 349 {
 350         struct page *map, *mapend;
 351
 352         if (dmabuf->rawbuf) {
 353                 /* undo marking the pages as reserved */
 354                 mapend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
 355                 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
 356                         clear_bit(PG_reserved, &map->flags);
 357
 358                 pci_free_consistent(unit->pci, PAGE_SIZE << dmabuf->buforder,
 359                     dmabuf->rawbuf, dmabuf->dma_addr);
 360         }
 361         dmabuf->rawbuf = NULL;
 362         dmabuf->mapped = dmabuf->ready = 0;
 363 }
 364
 365 static int prog_dmabuf(struct ymf_state *state, int rec)
 366 {
 367         struct ymf_dmabuf *dmabuf;
 368         int w_16;
 369         unsigned bufsize;
 370         unsigned long flags;
 371         int redzone, redfrags;
 372         int ret;
 373
 374         w_16 = ymf_pcm_format_width(state->format.format) == 16;
 375         dmabuf = rec ? &state->rpcm.dmabuf : &state->wpcm.dmabuf;
 376
 377         spin_lock_irqsave(&state->unit->reg_lock, flags);
 378         dmabuf->hwptr = dmabuf->swptr = 0;
 379         dmabuf->total_bytes = 0;
 380         dmabuf->count = 0;
 381         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
 382
 383         /* allocate DMA buffer if not allocated yet */
 384         if (!dmabuf->rawbuf)
 385                 if ((ret = alloc_dmabuf(state->unit, dmabuf)))
 386                         return ret;
 387
 388         /*
 389          * Create fake fragment sizes and numbers for OSS ioctls.
 390          * Import what Doom might have set with SNDCTL_DSP_SETFRAGMENT.
 391          */
 392         bufsize = PAGE_SIZE << dmabuf->buforder;
 393         /* By default we give 4 big buffers. */
 394         dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
 395         if (dmabuf->ossfragshift > 3 &&
 396             dmabuf->ossfragshift < dmabuf->fragshift) {
 397                 /* If OSS set smaller fragments, give more smaller buffers. */
 398                 dmabuf->fragshift = dmabuf->ossfragshift;
 399         }
 400         dmabuf->fragsize = 1 << dmabuf->fragshift;
 401
 402         dmabuf->numfrag = bufsize >> dmabuf->fragshift;
 403         dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
 404
 405         if (dmabuf->ossmaxfrags >= 2) {
 406                 redzone = ymf_calc_lend(state->format.rate);
 407                 redzone <<= state->format.shift;
 408                 redzone *= 3;
 409                 redfrags = (redzone + dmabuf->fragsize-1) >> dmabuf->fragshift;
 410
 411                 if (dmabuf->ossmaxfrags + redfrags < dmabuf->numfrag) {
 412                         dmabuf->numfrag = dmabuf->ossmaxfrags + redfrags;
 413                         dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
 414                 }
 415         }
 416
 417         memset(dmabuf->rawbuf, w_16 ? 0 : 0x80, dmabuf->dmasize);
 418
 419         /*
 420          *      Now set up the ring
 421          */
 422
 423         /* XXX   ret = rec? cap_pre(): pbk_pre();  */
 424         spin_lock_irqsave(&state->unit->voice_lock, flags);
 425         if (rec) {
 426                 if ((ret = ymf_capture_prepare(state)) != 0) {
 427                         spin_unlock_irqrestore(&state->unit->voice_lock, flags);
 428                         return ret;
 429                 }
 430         } else {
 431                 if ((ret = ymf_playback_prepare(state)) != 0) {
 432                         spin_unlock_irqrestore(&state->unit->voice_lock, flags);
 433                         return ret;
 434                 }
 435         }
 436         spin_unlock_irqrestore(&state->unit->voice_lock, flags);
 437
 438         /* set the ready flag for the dma buffer (this comment is not stupid) */
 439         dmabuf->ready = 1;
 440
 441 #if 0
 442         printk(KERN_DEBUG "prog_dmabuf: rate %d format 0x%x,"
 443             " numfrag %d fragsize %d dmasize %d\n",
 444                state->format.rate, state->format.format, dmabuf->numfrag,
 445                dmabuf->fragsize, dmabuf->dmasize);
 446 #endif
 447
 448         return 0;
 449 }
 450
 451 static void ymf_start_dac(struct ymf_state *state)
 452 {
 453         ymf_playback_trigger(state->unit, &state->wpcm, 1);
 454 }
 455
 456 // static void ymf_start_adc(struct ymf_state *state)
 457 // {
 458 //      ymf_capture_trigger(state->unit, &state->rpcm, 1);
 459 // }
 460
 461 /*
 462  * Wait until output is drained.
 463  * This does not kill the hardware for the sake of ioctls.
 464  */
 465 static void ymf_wait_dac(struct ymf_state *state)
 466 {
 467         struct ymf_unit *unit = state->unit;
 468         struct ymf_pcm *ypcm = &state->wpcm;
 469         DECLARE_WAITQUEUE(waita, current);
 470         unsigned long flags;
 471
 472         add_wait_queue(&ypcm->dmabuf.wait, &waita);
 473
 474         spin_lock_irqsave(&unit->reg_lock, flags);
 475         if (ypcm->dmabuf.count != 0 && !ypcm->running) {
 476                 ymf_playback_trigger(unit, ypcm, 1);
 477         }
 478
 479 #if 0
 480         if (file->f_flags & O_NONBLOCK) {
 481                 /*
 482                  * XXX Our  mistake is to attach DMA buffer to state
 483                  * rather than to some per-device structure.
 484                  * Cannot skip waiting, can only make it shorter.
 485                  */
 486         }
 487 #endif
 488
 489         set_current_state(TASK_UNINTERRUPTIBLE);
 490         while (ypcm->running) {
 491                 spin_unlock_irqrestore(&unit->reg_lock, flags);
 492                 schedule();
 493                 spin_lock_irqsave(&unit->reg_lock, flags);
 494                 set_current_state(TASK_UNINTERRUPTIBLE);
 495         }
 496         spin_unlock_irqrestore(&unit->reg_lock, flags);
 497
 498         set_current_state(TASK_RUNNING);
 499         remove_wait_queue(&ypcm->dmabuf.wait, &waita);
 500
 501         /*
 502          * This function may take up to 4 seconds to reach this point
 503          * (32K circular buffer, 8000 Hz). User notices.
 504          */
 505 }
 506
 507 /* Can just stop, without wait. Or can we? */
 508 static void ymf_stop_adc(struct ymf_state *state)
 509 {
 510         struct ymf_unit *unit = state->unit;
 511         unsigned long flags;
 512
 513         spin_lock_irqsave(&unit->reg_lock, flags);
 514         ymf_capture_trigger(unit, &state->rpcm, 0);
 515         spin_unlock_irqrestore(&unit->reg_lock, flags);
 516 }
 517
 518 /*
 519  *  Hardware start management
 520  */
 521
 522 static void ymfpci_hw_start(ymfpci_t *unit)
 523 {
 524         unsigned long flags;
 525
 526         spin_lock_irqsave(&unit->reg_lock, flags);
 527         if (unit->start_count++ == 0) {
 528                 ymfpci_writel(unit, YDSXGR_MODE,
 529                     ymfpci_readl(unit, YDSXGR_MODE) | 3);
 530                 unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
 531         }
 532         spin_unlock_irqrestore(&unit->reg_lock, flags);
 533 }
 534
 535 static void ymfpci_hw_stop(ymfpci_t *unit)
 536 {
 537         unsigned long flags;
 538         long timeout = 1000;
 539
 540         spin_lock_irqsave(&unit->reg_lock, flags);
 541         if (--unit->start_count == 0) {
 542                 ymfpci_writel(unit, YDSXGR_MODE,
 543                     ymfpci_readl(unit, YDSXGR_MODE) & ~3);
 544                 while (timeout-- > 0) {
 545                         if ((ymfpci_readl(unit, YDSXGR_STATUS) & 2) == 0)
 546                                 break;
 547                 }
 548         }
 549         spin_unlock_irqrestore(&unit->reg_lock, flags);
 550 }
 551
 552 /*
 553  *  Playback voice management
 554  */
 555
 556 static int voice_alloc(ymfpci_t *codec, ymfpci_voice_type_t type, int pair, ymfpci_voice_t *rvoice[])
 557 {
 558         ymfpci_voice_t *voice, *voice2;
 559         int idx;
 560
 561         for (idx = 0; idx < YDSXG_PLAYBACK_VOICES; idx += pair ? 2 : 1) {
 562                 voice = &codec->voices[idx];
 563                 voice2 = pair ? &codec->voices[idx+1] : NULL;
 564                 if (voice->use || (voice2 && voice2->use))
 565                         continue;
 566                 voice->use = 1;
 567                 if (voice2)
 568                         voice2->use = 1;
 569                 switch (type) {
 570                 case YMFPCI_PCM:
 571                         voice->pcm = 1;
 572                         if (voice2)
 573                                 voice2->pcm = 1;
 574                         break;
 575                 case YMFPCI_SYNTH:
 576                         voice->synth = 1;
 577                         break;
 578                 case YMFPCI_MIDI:
 579                         voice->midi = 1;
 580                         break;
 581                 }
 582                 ymfpci_hw_start(codec);
 583                 rvoice[0] = voice;
 584                 if (voice2) {
 585                         ymfpci_hw_start(codec);
 586                         rvoice[1] = voice2;
 587                 }
 588                 return 0;
 589         }
 590         return -EBUSY;  /* Your audio channel is open by someone else. */
 591 }
 592
 593 static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice)
 594 {
 595         ymfpci_hw_stop(unit);
 596         pvoice->use = pvoice->pcm = pvoice->synth = pvoice->midi = 0;
 597         pvoice->ypcm = NULL;
 598 }
 599
 600 /*
 601  */
 602
 603 static void ymf_pcm_interrupt(ymfpci_t *codec, ymfpci_voice_t *voice)
 604 {
 605         struct ymf_pcm *ypcm;
 606         int redzone;
 607         int pos, delta, swptr;
 608         int played, distance;
 609         struct ymf_state *state;
 610         struct ymf_dmabuf *dmabuf;
 611         char silence;
 612
 613         if ((ypcm = voice->ypcm) == NULL) {
 614                 return;
 615         }
 616         if ((state = ypcm->state) == NULL) {
 617                 ypcm->running = 0;      // lock it
 618                 return;
 619         }
 620         dmabuf = &ypcm->dmabuf;
 621         spin_lock(&codec->reg_lock);
 622         if (ypcm->running) {
 623                 YMFDBGI("ymfpci: %d, intr bank %d count %d start 0x%x:%x\n",
 624                    voice->number, codec->active_bank, dmabuf->count,
 625                    le32_to_cpu(voice->bank[0].start),
 626                    le32_to_cpu(voice->bank[1].start));
 627                 silence = (ymf_pcm_format_width(state->format.format) == 16) ?
 628                     0 : 0x80;
 629                 /* We need actual left-hand-side redzone size here. */
 630                 redzone = ymf_calc_lend(state->format.rate);
 631                 redzone <<= (state->format.shift + 1);
 632                 swptr = dmabuf->swptr;
 633
 634                 pos = le32_to_cpu(voice->bank[codec->active_bank].start);
 635                 pos <<= state->format.shift;
 636                 if (pos < 0 || pos >= dmabuf->dmasize) {        /* ucode bug */
 637                         printk(KERN_ERR "ymfpci%d: runaway voice %d: hwptr %d=>%d dmasize %d\n",
 638                             codec->dev_audio, voice->number,
 639                             dmabuf->hwptr, pos, dmabuf->dmasize);
 640                         pos = 0;
 641                 }
 642                 if (pos < dmabuf->hwptr) {
 643                         delta = dmabuf->dmasize - dmabuf->hwptr;
 644                         memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
 645                         delta += pos;
 646                         memset(dmabuf->rawbuf, silence, pos);
 647                 } else {
 648                         delta = pos - dmabuf->hwptr;
 649                         memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
 650                 }
 651                 dmabuf->hwptr = pos;
 652
 653                 if (dmabuf->count == 0) {
 654                         printk(KERN_ERR "ymfpci%d: %d: strain: hwptr %d\n",
 655                             codec->dev_audio, voice->number, dmabuf->hwptr);
 656                         ymf_playback_trigger(codec, ypcm, 0);
 657                 }
 658
 659                 if (swptr <= pos) {
 660                         distance = pos - swptr;
 661                 } else {
 662                         distance = dmabuf->dmasize - (swptr - pos);
 663                 }
 664                 if (distance < redzone) {
 665                         /*
 666                          * hwptr inside redzone => DMA ran out of samples.
 667                          */
 668                         if (delta < dmabuf->count) {
 669                                 /*
 670                                  * Lost interrupt or other screwage.
 671                                  */
 672                                 printk(KERN_ERR "ymfpci%d: %d: lost: delta %d"
 673                                     " hwptr %d swptr %d distance %d count %d\n",
 674                                     codec->dev_audio, voice->number, delta,
 675                                     dmabuf->hwptr, swptr, distance, dmabuf->count);
 676                         } else {
 677                                 /*
 678                                  * Normal end of DMA.
 679                                  */
 680                                 YMFDBGI("ymfpci%d: %d: done: delta %d"
 681                                     " hwptr %d swptr %d distance %d count %d\n",
 682                                     codec->dev_audio, voice->number, delta,
 683                                     dmabuf->hwptr, swptr, distance, dmabuf->count);
 684                         }
 685                         played = dmabuf->count;
 686                         if (ypcm->running) {
 687                                 ymf_playback_trigger(codec, ypcm, 0);
 688                         }
 689                 } else {
 690                         /*
 691                          * hwptr is chipping away towards a remote swptr.
 692                          * Calculate other distance and apply it to count.
 693                          */
 694                         if (swptr >= pos) {
 695                                 distance = swptr - pos;
 696                         } else {
 697                                 distance = dmabuf->dmasize - (pos - swptr);
 698                         }
 699                         if (distance < dmabuf->count) {
 700                                 played = dmabuf->count - distance;
 701                         } else {
 702                                 played = 0;
 703                         }
 704                 }
 705
 706                 dmabuf->total_bytes += played;
 707                 dmabuf->count -= played;
 708                 if (dmabuf->count < dmabuf->dmasize / 2) {
 709                         wake_up(&dmabuf->wait);
 710                 }
 711         }
 712         spin_unlock(&codec->reg_lock);
 713 }
 714
 715 static void ymf_cap_interrupt(ymfpci_t *unit, struct ymf_capture *cap)
 716 {
 717         struct ymf_pcm *ypcm;
 718         int redzone;
 719         struct ymf_state *state;
 720         struct ymf_dmabuf *dmabuf;
 721         int pos, delta;
 722         int cnt;
 723
 724         if ((ypcm = cap->ypcm) == NULL) {
 725                 return;
 726         }
 727         if ((state = ypcm->state) == NULL) {
 728                 ypcm->running = 0;      // lock it
 729                 return;
 730         }
 731         dmabuf = &ypcm->dmabuf;
 732         spin_lock(&unit->reg_lock);
 733         if (ypcm->running) {
 734                 redzone = ymf_calc_lend(state->format.rate);
 735                 redzone <<= (state->format.shift + 1);
 736
 737                 pos = le32_to_cpu(cap->bank[unit->active_bank].start);
 738                 // pos <<= state->format.shift;
 739                 if (pos < 0 || pos >= dmabuf->dmasize) {        /* ucode bug */
 740                         printk(KERN_ERR "ymfpci%d: runaway capture %d: hwptr %d=>%d dmasize %d\n",
 741                             unit->dev_audio, ypcm->capture_bank_number,
 742                             dmabuf->hwptr, pos, dmabuf->dmasize);
 743                         pos = 0;
 744                 }
 745                 if (pos < dmabuf->hwptr) {
 746                         delta = dmabuf->dmasize - dmabuf->hwptr;
 747                         delta += pos;
 748                 } else {
 749                         delta = pos - dmabuf->hwptr;
 750                 }
 751                 dmabuf->hwptr = pos;
 752
 753                 cnt = dmabuf->count;
 754                 cnt += delta;
 755                 if (cnt + redzone > dmabuf->dmasize) {
 756                         /* Overflow - bump swptr */
 757                         dmabuf->count = dmabuf->dmasize - redzone;
 758                         dmabuf->swptr = dmabuf->hwptr + redzone;
 759                         if (dmabuf->swptr >= dmabuf->dmasize) {
 760                                 dmabuf->swptr -= dmabuf->dmasize;
 761                         }
 762                 } else {
 763                         dmabuf->count = cnt;
 764                 }
 765
 766                 dmabuf->total_bytes += delta;
 767                 if (dmabuf->count) {            /* && is_sleeping  XXX */
 768                         wake_up(&dmabuf->wait);
 769                 }
 770         }
 771         spin_unlock(&unit->reg_lock);
 772 }
 773
 774 static int ymf_playback_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
 775 {
 776
 777         if (ypcm->voices[0] == NULL) {
 778                 return -EINVAL;
 779         }
 780         if (cmd != 0) {
 781                 codec->ctrl_playback[ypcm->voices[0]->number + 1] =
 782                     cpu_to_le32(ypcm->voices[0]->bank_ba);
 783                 if (ypcm->voices[1] != NULL)
 784                         codec->ctrl_playback[ypcm->voices[1]->number + 1] =
 785                             cpu_to_le32(ypcm->voices[1]->bank_ba);
 786                 ypcm->running = 1;
 787         } else {
 788                 codec->ctrl_playback[ypcm->voices[0]->number + 1] = 0;
 789                 if (ypcm->voices[1] != NULL)
 790                         codec->ctrl_playback[ypcm->voices[1]->number + 1] = 0;
 791                 ypcm->running = 0;
 792         }
 793         return 0;
 794 }
 795
 796 static void ymf_capture_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
 797 {
 798         u32 tmp;
 799
 800         if (cmd != 0) {
 801                 tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) | (1 << ypcm->capture_bank_number);
 802                 ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
 803                 ypcm->running = 1;
 804         } else {
 805                 tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) & ~(1 << ypcm->capture_bank_number);
 806                 ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
 807                 ypcm->running = 0;
 808         }
 809 }
 810
 811 static int ymfpci_pcm_voice_alloc(struct ymf_pcm *ypcm, int voices)
 812 {
 813         struct ymf_unit *unit;
 814         int err;
 815
 816         unit = ypcm->state->unit;
 817         if (ypcm->voices[1] != NULL && voices < 2) {
 818                 ymfpci_voice_free(unit, ypcm->voices[1]);
 819                 ypcm->voices[1] = NULL;
 820         }
 821         if (voices == 1 && ypcm->voices[0] != NULL)
 822                 return 0;               /* already allocated */
 823         if (voices == 2 && ypcm->voices[0] != NULL && ypcm->voices[1] != NULL)
 824                 return 0;               /* already allocated */
 825         if (voices > 1) {
 826                 if (ypcm->voices[0] != NULL && ypcm->voices[1] == NULL) {
 827                         ymfpci_voice_free(unit, ypcm->voices[0]);
 828                         ypcm->voices[0] = NULL;
 829                 }
 830                 if ((err = voice_alloc(unit, YMFPCI_PCM, 1, ypcm->voices)) < 0)
 831                         return err;
 832                 ypcm->voices[0]->ypcm = ypcm;
 833                 ypcm->voices[1]->ypcm = ypcm;
 834         } else {
 835                 if ((err = voice_alloc(unit, YMFPCI_PCM, 0, ypcm->voices)) < 0)
 836                         return err;
 837                 ypcm->voices[0]->ypcm = ypcm;
 838         }
 839         return 0;
 840 }
 841
 842 static void ymf_pcm_init_voice(ymfpci_voice_t *voice, int stereo,
 843     int rate, int w_16, unsigned long addr, unsigned int end, int spdif)
 844 {
 845         u32 format;
 846         u32 delta = ymfpci_calc_delta(rate);
 847         u32 lpfQ = ymfpci_calc_lpfQ(rate);
 848         u32 lpfK = ymfpci_calc_lpfK(rate);
 849         ymfpci_playback_bank_t *bank;
 850         int nbank;
 851
 852         /*
 853          * The gain is a floating point number. According to the manual,
 854          * bit 31 indicates a sign bit, bit 30 indicates an integer part,
 855          * and bits [29:15] indicate a decimal fraction part. Thus,
 856          * for a gain of 1.0 the constant of 0x40000000 is loaded.
 857          */
 858         unsigned default_gain = cpu_to_le32(0x40000000);
 859
 860         format = (stereo ? 0x00010000 : 0) | (w_16 ? 0 : 0x80000000);
 861         if (stereo)
 862                 end >>= 1;
 863         if (w_16)
 864                 end >>= 1;
 865         for (nbank = 0; nbank < 2; nbank++) {
 866                 bank = &voice->bank[nbank];
 867                 bank->format = cpu_to_le32(format);
 868                 bank->loop_default = 0; /* 0-loops forever, otherwise count */
 869                 bank->base = cpu_to_le32(addr);
 870                 bank->loop_start = 0;
 871                 bank->loop_end = cpu_to_le32(end);
 872                 bank->loop_frac = 0;
 873                 bank->eg_gain_end = default_gain;
 874                 bank->lpfQ = cpu_to_le32(lpfQ);
 875                 bank->status = 0;
 876                 bank->num_of_frames = 0;
 877                 bank->loop_count = 0;
 878                 bank->start = 0;
 879                 bank->start_frac = 0;
 880                 bank->delta =
 881                 bank->delta_end = cpu_to_le32(delta);
 882                 bank->lpfK =
 883                 bank->lpfK_end = cpu_to_le32(lpfK);
 884                 bank->eg_gain = default_gain;
 885                 bank->lpfD1 =
 886                 bank->lpfD2 = 0;
 887
 888                 bank->left_gain =
 889                 bank->right_gain =
 890                 bank->left_gain_end =
 891                 bank->right_gain_end =
 892                 bank->eff1_gain =
 893                 bank->eff2_gain =
 894                 bank->eff3_gain =
 895                 bank->eff1_gain_end =
 896                 bank->eff2_gain_end =
 897                 bank->eff3_gain_end = 0;
 898
 899                 if (!stereo) {
 900                         if (!spdif) {
 901                                 bank->left_gain =
 902                                 bank->right_gain =
 903                                 bank->left_gain_end =
 904                                 bank->right_gain_end = default_gain;
 905                         } else {
 906                                 bank->eff2_gain =
 907                                 bank->eff2_gain_end =
 908                                 bank->eff3_gain =
 909                                 bank->eff3_gain_end = default_gain;
 910                         }
 911                 } else {
 912                         if (!spdif) {
 913                                 if ((voice->number & 1) == 0) {
 914                                         bank->left_gain =
 915                                         bank->left_gain_end = default_gain;
 916                                 } else {
 917                                         bank->format |= cpu_to_le32(1);
 918                                         bank->right_gain =
 919                                         bank->right_gain_end = default_gain;
 920                                 }
 921                         } else {
 922                                 if ((voice->number & 1) == 0) {
 923                                         bank->eff2_gain =
 924                                         bank->eff2_gain_end = default_gain;
 925                                 } else {
 926                                         bank->format |= cpu_to_le32(1);
 927                                         bank->eff3_gain =
 928                                         bank->eff3_gain_end = default_gain;
 929                                 }
 930                         }
 931                 }
 932         }
 933 }
 934
 935 /*
 936  * XXX Capture channel allocation is entirely fake at the moment.
 937  * We use only one channel and mark it busy as required.
 938  */
 939 static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank)
 940 {
 941         struct ymf_capture *cap;
 942         int cbank;
 943
 944         cbank = 1;              /* Only ADC slot is used for now. */
 945         cap = &unit->capture[cbank];
 946         if (cap->use)
 947                 return -EBUSY;
 948         cap->use = 1;
 949         *pbank = cbank;
 950         return 0;
 951 }
 952
 953 static int ymf_playback_prepare(struct ymf_state *state)
 954 {
 955         struct ymf_pcm *ypcm = &state->wpcm;
 956         int err, nvoice;
 957
 958         if ((err = ymfpci_pcm_voice_alloc(ypcm, state->format.voices)) < 0) {
 959                 /* Somebody started 32 mpg123's in parallel? */
 960                 printk(KERN_INFO "ymfpci%d: cannot allocate voice\n",
 961                     state->unit->dev_audio);
 962                 return err;
 963         }
 964
 965         for (nvoice = 0; nvoice < state->format.voices; nvoice++) {
 966                 ymf_pcm_init_voice(ypcm->voices[nvoice],
 967                     state->format.voices == 2, state->format.rate,
 968                     ymf_pcm_format_width(state->format.format) == 16,
 969                     ypcm->dmabuf.dma_addr, ypcm->dmabuf.dmasize,
 970                     ypcm->spdif);
 971         }
 972         return 0;
 973 }
 974
 975 static int ymf_capture_prepare(struct ymf_state *state)
 976 {
 977         ymfpci_t *unit = state->unit;
 978         struct ymf_pcm *ypcm = &state->rpcm;
 979         ymfpci_capture_bank_t * bank;
 980         /* XXX This is confusing, gotta rename one of them banks... */
 981         int nbank;              /* flip-flop bank */
 982         int cbank;              /* input [super-]bank */
 983         struct ymf_capture *cap;
 984         u32 rate, format;
 985
 986         if (ypcm->capture_bank_number == -1) {
 987                 if (ymf_capture_alloc(unit, &cbank) != 0)
 988                         return -EBUSY;
 989
 990                 ypcm->capture_bank_number = cbank;
 991
 992                 cap = &unit->capture[cbank];
 993                 cap->bank = unit->bank_capture[cbank][0];
 994                 cap->ypcm = ypcm;
 995                 ymfpci_hw_start(unit);
 996         }
 997
 998         // ypcm->frag_size = snd_pcm_lib_transfer_fragment(substream);
 999         // frag_size is replaced with nonfragged byte-aligned rolling buffer
1000         rate = ((48000 * 4096) / state->format.rate) - 1;
1001         format = 0;
1002         if (state->format.voices == 2)
1003                 format |= 2;
1004         if (ymf_pcm_format_width(state->format.format) == 8)
1005                 format |= 1;
1006         switch (ypcm->capture_bank_number) {
1007         case 0:
1008                 ymfpci_writel(unit, YDSXGR_RECFORMAT, format);
1009                 ymfpci_writel(unit, YDSXGR_RECSLOTSR, rate);
1010                 break;
1011         case 1:
1012                 ymfpci_writel(unit, YDSXGR_ADCFORMAT, format);
1013                 ymfpci_writel(unit, YDSXGR_ADCSLOTSR, rate);
1014                 break;
1015         }
1016         for (nbank = 0; nbank < 2; nbank++) {
1017                 bank = unit->bank_capture[ypcm->capture_bank_number][nbank];
1018                 bank->base = cpu_to_le32(ypcm->dmabuf.dma_addr);
1019                 // bank->loop_end = ypcm->dmabuf.dmasize >> state->format.shift;
1020                 bank->loop_end = cpu_to_le32(ypcm->dmabuf.dmasize);
1021                 bank->start = 0;
1022                 bank->num_of_loops = 0;
1023         }
1024 #if 0 /* s/pdif */
1025         if (state->digital.dig_valid)
1026                 /*state->digital.type == SND_PCM_DIG_AES_IEC958*/
1027                 ymfpci_writew(codec, YDSXGR_SPDIFOUTSTATUS,
1028                     state->digital.dig_status[0] | (state->digital.dig_status[1] << 8));
1029 #endif
1030         return 0;
1031 }
1032
1033 static irqreturn_t ymf_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1034 {
1035         ymfpci_t *codec = dev_id;
1036         u32 status, nvoice, mode;
1037         struct ymf_voice *voice;
1038         struct ymf_capture *cap;
1039
1040         status = ymfpci_readl(codec, YDSXGR_STATUS);
1041         if (status & 0x80000000) {
1042                 codec->active_bank = ymfpci_readl(codec, YDSXGR_CTRLSELECT) & 1;
1043                 spin_lock(&codec->voice_lock);
1044                 for (nvoice = 0; nvoice < YDSXG_PLAYBACK_VOICES; nvoice++) {
1045                         voice = &codec->voices[nvoice];
1046                         if (voice->use)
1047                                 ymf_pcm_interrupt(codec, voice);
1048                 }
1049                 for (nvoice = 0; nvoice < YDSXG_CAPTURE_VOICES; nvoice++) {
1050                         cap = &codec->capture[nvoice];
1051                         if (cap->use)
1052                                 ymf_cap_interrupt(codec, cap);
1053                 }
1054                 spin_unlock(&codec->voice_lock);
1055                 spin_lock(&codec->reg_lock);
1056                 ymfpci_writel(codec, YDSXGR_STATUS, 0x80000000);
1057                 mode = ymfpci_readl(codec, YDSXGR_MODE) | 2;
1058                 ymfpci_writel(codec, YDSXGR_MODE, mode);
1059                 spin_unlock(&codec->reg_lock);
1060         }
1061
1062         status = ymfpci_readl(codec, YDSXGR_INTFLAG);
1063         if (status & 1) {
1064                 /* timer handler */
1065                 ymfpci_writel(codec, YDSXGR_INTFLAG, ~0);
1066         }
1067         return IRQ_HANDLED;
1068 }
1069
1070 static void ymf_pcm_free_substream(struct ymf_pcm *ypcm)
1071 {
1072         unsigned long flags;
1073         struct ymf_unit *unit;
1074
1075         unit = ypcm->state->unit;
1076
1077         if (ypcm->type == PLAYBACK_VOICE) {
1078                 spin_lock_irqsave(&unit->voice_lock, flags);
1079                 if (ypcm->voices[1])
1080                         ymfpci_voice_free(unit, ypcm->voices[1]);
1081                 if (ypcm->voices[0])
1082                         ymfpci_voice_free(unit, ypcm->voices[0]);
1083                 spin_unlock_irqrestore(&unit->voice_lock, flags);
1084         } else {
1085                 if (ypcm->capture_bank_number != -1) {
1086                         unit->capture[ypcm->capture_bank_number].use = 0;
1087                         ypcm->capture_bank_number = -1;
1088                         ymfpci_hw_stop(unit);
1089                 }
1090         }
1091 }
1092
1093 static struct ymf_state *ymf_state_alloc(ymfpci_t *unit)
1094 {
1095         struct ymf_pcm *ypcm;
1096         struct ymf_state *state;
1097
1098         if ((state = kmalloc(sizeof(struct ymf_state), GFP_KERNEL)) == NULL) {
1099                 goto out0;
1100         }
1101         memset(state, 0, sizeof(struct ymf_state));
1102
1103         ypcm = &state->wpcm;
1104         ypcm->state = state;
1105         ypcm->type = PLAYBACK_VOICE;
1106         ypcm->capture_bank_number = -1;
1107         init_waitqueue_head(&ypcm->dmabuf.wait);
1108
1109         ypcm = &state->rpcm;
1110         ypcm->state = state;
1111         ypcm->type = CAPTURE_AC97;
1112         ypcm->capture_bank_number = -1;
1113         init_waitqueue_head(&ypcm->dmabuf.wait);
1114
1115         state->unit = unit;
1116
1117         state->format.format = AFMT_U8;
1118         state->format.rate = 8000;
1119         state->format.voices = 1;
1120         ymf_pcm_update_shift(&state->format);
1121
1122         return state;
1123
1124 out0:
1125         return NULL;
1126 }
1127
1128 /* AES/IEC958 channel status bits */
1129 #define SND_PCM_AES0_PROFESSIONAL       (1<<0)  /* 0 = consumer, 1 = professional */
1130 #define SND_PCM_AES0_NONAUDIO           (1<<1)  /* 0 = audio, 1 = non-audio */
1131 #define SND_PCM_AES0_PRO_EMPHASIS       (7<<2)  /* mask - emphasis */
1132 #define SND_PCM_AES0_PRO_EMPHASIS_NOTID (0<<2)  /* emphasis not indicated */
1133 #define SND_PCM_AES0_PRO_EMPHASIS_NONE  (1<<2)  /* none emphasis */
1134 #define SND_PCM_AES0_PRO_EMPHASIS_5015  (3<<2)  /* 50/15us emphasis */
1135 #define SND_PCM_AES0_PRO_EMPHASIS_CCITT (7<<2)  /* CCITT J.17 emphasis */
1136 #define SND_PCM_AES0_PRO_FREQ_UNLOCKED  (1<<5)  /* source sample frequency: 0 = locked, 1 = unlocked */
1137 #define SND_PCM_AES0_PRO_FS             (3<<6)  /* mask - sample frequency */
1138 #define SND_PCM_AES0_PRO_FS_NOTID       (0<<6)  /* fs not indicated */
1139 #define SND_PCM_AES0_PRO_FS_44100       (1<<6)  /* 44.1kHz */
1140 #define SND_PCM_AES0_PRO_FS_48000       (2<<6)  /* 48kHz */
1141 #define SND_PCM_AES0_PRO_FS_32000       (3<<6)  /* 32kHz */
1142 #define SND_PCM_AES0_CON_NOT_COPYRIGHT  (1<<2)  /* 0 = copyright, 1 = not copyright */
1143 #define SND_PCM_AES0_CON_EMPHASIS       (7<<3)  /* mask - emphasis */
1144 #define SND_PCM_AES0_CON_EMPHASIS_NONE  (0<<3)  /* none emphasis */
1145 #define SND_PCM_AES0_CON_EMPHASIS_5015  (1<<3)  /* 50/15us emphasis */
1146 #define SND_PCM_AES0_CON_MODE           (3<<6)  /* mask - mode */
1147 #define SND_PCM_AES1_PRO_MODE           (15<<0) /* mask - channel mode */
1148 #define SND_PCM_AES1_PRO_MODE_NOTID     (0<<0)  /* not indicated */
1149 #define SND_PCM_AES1_PRO_MODE_STEREOPHONIC (2<<0) /* stereophonic - ch A is left */
1150 #define SND_PCM_AES1_PRO_MODE_SINGLE    (4<<0)  /* single channel */
1151 #define SND_PCM_AES1_PRO_MODE_TWO       (8<<0)  /* two channels */
1152 #define SND_PCM_AES1_PRO_MODE_PRIMARY   (12<<0) /* primary/secondary */
1153 #define SND_PCM_AES1_PRO_MODE_BYTE3     (15<<0) /* vector to byte 3 */
1154 #define SND_PCM_AES1_PRO_USERBITS       (15<<4) /* mask - user bits */
1155 #define SND_PCM_AES1_PRO_USERBITS_NOTID (0<<4)  /* not indicated */
1156 #define SND_PCM_AES1_PRO_USERBITS_192   (8<<4)  /* 192-bit structure */
1157 #define SND_PCM_AES1_PRO_USERBITS_UDEF  (12<<4) /* user defined application */
1158 #define SND_PCM_AES1_CON_CATEGORY       0x7f
1159 #define SND_PCM_AES1_CON_GENERAL        0x00
1160 #define SND_PCM_AES1_CON_EXPERIMENTAL   0x40
1161 #define SND_PCM_AES1_CON_SOLIDMEM_MASK  0x0f
1162 #define SND_PCM_AES1_CON_SOLIDMEM_ID    0x08
1163 #define SND_PCM_AES1_CON_BROADCAST1_MASK 0x07
1164 #define SND_PCM_AES1_CON_BROADCAST1_ID  0x04
1165 #define SND_PCM_AES1_CON_DIGDIGCONV_MASK 0x07
1166 #define SND_PCM_AES1_CON_DIGDIGCONV_ID  0x02
1167 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_MASK 0x1f
1168 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_ID 0x06
1169 #define SND_PCM_AES1_CON_ADC_MASK       0x1f
1170 #define SND_PCM_AES1_CON_ADC_ID         0x16
1171 #define SND_PCM_AES1_CON_BROADCAST2_MASK 0x0f
1172 #define SND_PCM_AES1_CON_BROADCAST2_ID  0x0e
1173 #define SND_PCM_AES1_CON_LASEROPT_MASK  0x07
1174 #define SND_PCM_AES1_CON_LASEROPT_ID    0x01
1175 #define SND_PCM_AES1_CON_MUSICAL_MASK   0x07
1176 #define SND_PCM_AES1_CON_MUSICAL_ID     0x05
1177 #define SND_PCM_AES1_CON_MAGNETIC_MASK  0x07
1178 #define SND_PCM_AES1_CON_MAGNETIC_ID    0x03
1179 #define SND_PCM_AES1_CON_IEC908_CD      (SND_PCM_AES1_CON_LASEROPT_ID|0x00)
1180 #define SND_PCM_AES1_CON_NON_IEC908_CD  (SND_PCM_AES1_CON_LASEROPT_ID|0x08)
1181 #define SND_PCM_AES1_CON_PCM_CODER      (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x00)
1182 #define SND_PCM_AES1_CON_SAMPLER        (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x20)
1183 #define SND_PCM_AES1_CON_MIXER          (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x10)
1184 #define SND_PCM_AES1_CON_RATE_CONVERTER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x18)
1185 #define SND_PCM_AES1_CON_SYNTHESIZER    (SND_PCM_AES1_CON_MUSICAL_ID|0x00)
1186 #define SND_PCM_AES1_CON_MICROPHONE     (SND_PCM_AES1_CON_MUSICAL_ID|0x08)
1187 #define SND_PCM_AES1_CON_DAT            (SND_PCM_AES1_CON_MAGNETIC_ID|0x00)
1188 #define SND_PCM_AES1_CON_VCR            (SND_PCM_AES1_CON_MAGNETIC_ID|0x08)
1189 #define SND_PCM_AES1_CON_ORIGINAL       (1<<7)  /* this bits depends on the category code */
1190 #define SND_PCM_AES2_PRO_SBITS          (7<<0)  /* mask - sample bits */
1191 #define SND_PCM_AES2_PRO_SBITS_20       (2<<0)  /* 20-bit - coordination */
1192 #define SND_PCM_AES2_PRO_SBITS_24       (4<<0)  /* 24-bit - main audio */
1193 #define SND_PCM_AES2_PRO_SBITS_UDEF     (6<<0)  /* user defined application */
1194 #define SND_PCM_AES2_PRO_WORDLEN        (7<<3)  /* mask - source word length */
1195 #define SND_PCM_AES2_PRO_WORDLEN_NOTID  (0<<3)  /* not indicated */
1196 #define SND_PCM_AES2_PRO_WORDLEN_22_18  (2<<3)  /* 22-bit or 18-bit */
1197 #define SND_PCM_AES2_PRO_WORDLEN_23_19  (4<<3)  /* 23-bit or 19-bit */
1198 #define SND_PCM_AES2_PRO_WORDLEN_24_20  (5<<3)  /* 24-bit or 20-bit */
1199 #define SND_PCM_AES2_PRO_WORDLEN_20_16  (6<<3)  /* 20-bit or 16-bit */
1200 #define SND_PCM_AES2_CON_SOURCE         (15<<0) /* mask - source number */
1201 #define SND_PCM_AES2_CON_SOURCE_UNSPEC  (0<<0)  /* unspecified */
1202 #define SND_PCM_AES2_CON_CHANNEL        (15<<4) /* mask - channel number */
1203 #define SND_PCM_AES2_CON_CHANNEL_UNSPEC (0<<4)  /* unspecified */
1204 #define SND_PCM_AES3_CON_FS             (15<<0) /* mask - sample frequency */
1205 #define SND_PCM_AES3_CON_FS_44100       (0<<0)  /* 44.1kHz */
1206 #define SND_PCM_AES3_CON_FS_48000       (2<<0)  /* 48kHz */
1207 #define SND_PCM_AES3_CON_FS_32000       (3<<0)  /* 32kHz */
1208 #define SND_PCM_AES3_CON_CLOCK          (3<<4)  /* mask - clock accuracy */
1209 #define SND_PCM_AES3_CON_CLOCK_1000PPM  (0<<4)  /* 1000 ppm */
1210 #define SND_PCM_AES3_CON_CLOCK_50PPM    (1<<4)  /* 50 ppm */
1211 #define SND_PCM_AES3_CON_CLOCK_VARIABLE (2<<4)  /* variable pitch */
1212
1213 /*
1214  * User interface
1215  */
1216
1217 /*
1218  * in this loop, dmabuf.count signifies the amount of data that is
1219  * waiting to be copied to the user's buffer.  it is filled by the dma
1220  * machine and drained by this loop.
1221  */
1222 static ssize_t
1223 ymf_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1224 {
1225         struct ymf_state *state = (struct ymf_state *)file->private_data;
1226         struct ymf_dmabuf *dmabuf = &state->rpcm.dmabuf;
1227         struct ymf_unit *unit = state->unit;
1228         DECLARE_WAITQUEUE(waita, current);
1229         ssize_t ret;
1230         unsigned long flags;
1231         unsigned int swptr;
1232         int cnt;                        /* This many to go in this revolution */
1233
1234         if (ppos != &file->f_pos)
1235                 return -ESPIPE;
1236         if (dmabuf->mapped)
1237                 return -ENXIO;
1238         if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1239                 return ret;
1240         ret = 0;
1241
1242         add_wait_queue(&dmabuf->wait, &waita);
1243         set_current_state(TASK_INTERRUPTIBLE);
1244         while (count > 0) {
1245                 spin_lock_irqsave(&unit->reg_lock, flags);
1246                 if (unit->suspended) {
1247                         spin_unlock_irqrestore(&unit->reg_lock, flags);
1248                         schedule();
1249                         set_current_state(TASK_INTERRUPTIBLE);
1250                         if (signal_pending(current)) {
1251                                 if (!ret) ret = -EAGAIN;
1252                                 break;
1253                         }
1254                         continue;
1255                 }
1256                 swptr = dmabuf->swptr;
1257                 cnt = dmabuf->dmasize - swptr;
1258                 if (dmabuf->count < cnt)
1259                         cnt = dmabuf->count;
1260                 spin_unlock_irqrestore(&unit->reg_lock, flags);
1261
1262                 if (cnt > count)
1263                         cnt = count;
1264                 if (cnt <= 0) {
1265                         unsigned long tmo;
1266                         /* buffer is empty, start the dma machine and wait for data to be
1267                            recorded */
1268                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1269                         if (!state->rpcm.running) {
1270                                 ymf_capture_trigger(state->unit, &state->rpcm, 1);
1271                         }
1272                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1273                         if (file->f_flags & O_NONBLOCK) {
1274                                 if (!ret) ret = -EAGAIN;
1275                                 break;
1276                         }
1277                         /* This isnt strictly right for the 810  but it'll do */
1278                         tmo = (dmabuf->dmasize * HZ) / (state->format.rate * 2);
1279                         tmo >>= state->format.shift;
1280                         /* There are two situations when sleep_on_timeout returns, one is when
1281                            the interrupt is serviced correctly and the process is waked up by
1282                            ISR ON TIME. Another is when timeout is expired, which means that
1283                            either interrupt is NOT serviced correctly (pending interrupt) or it
1284                            is TOO LATE for the process to be scheduled to run (scheduler latency)
1285                            which results in a (potential) buffer overrun. And worse, there is
1286                            NOTHING we can do to prevent it. */
1287                         tmo = schedule_timeout(tmo);
1288                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1289                         set_current_state(TASK_INTERRUPTIBLE);
1290                         if (tmo == 0 && dmabuf->count == 0) {
1291                                 printk(KERN_ERR "ymfpci%d: recording schedule timeout, "
1292                                     "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1293                                     state->unit->dev_audio,
1294                                     dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1295                                     dmabuf->hwptr, dmabuf->swptr);
1296                         }
1297                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1298                         if (signal_pending(current)) {
1299                                 if (!ret) ret = -ERESTARTSYS;
1300                                 break;
1301                         }
1302                         continue;
1303                 }
1304
1305                 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1306                         if (!ret) ret = -EFAULT;
1307                         break;
1308                 }
1309
1310                 swptr = (swptr + cnt) % dmabuf->dmasize;
1311
1312                 spin_lock_irqsave(&unit->reg_lock, flags);
1313                 if (unit->suspended) {
1314                         spin_unlock_irqrestore(&unit->reg_lock, flags);
1315                         continue;
1316                 }
1317
1318                 dmabuf->swptr = swptr;
1319                 dmabuf->count -= cnt;
1320                 // spin_unlock_irqrestore(&unit->reg_lock, flags);
1321
1322                 count -= cnt;
1323                 buffer += cnt;
1324                 ret += cnt;
1325                 // spin_lock_irqsave(&unit->reg_lock, flags);
1326                 if (!state->rpcm.running) {
1327                         ymf_capture_trigger(unit, &state->rpcm, 1);
1328                 }
1329                 spin_unlock_irqrestore(&unit->reg_lock, flags);
1330         }
1331         set_current_state(TASK_RUNNING);
1332         remove_wait_queue(&dmabuf->wait, &waita);
1333
1334         return ret;
1335 }
1336
1337 static ssize_t
1338 ymf_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1339 {
1340         struct ymf_state *state = (struct ymf_state *)file->private_data;
1341         struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
1342         struct ymf_unit *unit = state->unit;
1343         DECLARE_WAITQUEUE(waita, current);
1344         ssize_t ret;
1345         unsigned long flags;
1346         unsigned int swptr;
1347         int cnt;                        /* This many to go in this revolution */
1348         int redzone;
1349         int delay;
1350
1351         YMFDBGW("ymf_write: count %d\n", count);
1352
1353         if (ppos != &file->f_pos)
1354                 return -ESPIPE;
1355         if (dmabuf->mapped)
1356                 return -ENXIO;
1357         if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1358                 return ret;
1359         ret = 0;
1360
1361         /*
1362          * Alan's cs46xx works without a red zone - marvel of ingenuity.
1363          * We are not so brilliant... Red zone does two things:
1364          *  1. allows for safe start after a pause as we have no way
1365          *     to know what the actual, relentlessly advancing, hwptr is.
1366          *  2. makes computations in ymf_pcm_interrupt simpler.
1367          */
1368         redzone = ymf_calc_lend(state->format.rate) << state->format.shift;
1369         redzone *= 3;   /* 2 redzone + 1 possible uncertainty reserve. */
1370
1371         add_wait_queue(&dmabuf->wait, &waita);
1372         set_current_state(TASK_INTERRUPTIBLE);
1373         while (count > 0) {
1374                 spin_lock_irqsave(&unit->reg_lock, flags);
1375                 if (unit->suspended) {
1376                         spin_unlock_irqrestore(&unit->reg_lock, flags);
1377                         schedule();
1378                         set_current_state(TASK_INTERRUPTIBLE);
1379                         if (signal_pending(current)) {
1380                                 if (!ret) ret = -EAGAIN;
1381                                 break;
1382                         }
1383                         continue;
1384                 }
1385                 if (dmabuf->count < 0) {
1386                         printk(KERN_ERR
1387                            "ymf_write: count %d, was legal in cs46xx\n",
1388                             dmabuf->count);
1389                         dmabuf->count = 0;
1390                 }
1391                 if (dmabuf->count == 0) {
1392                         swptr = dmabuf->hwptr;
1393                         if (state->wpcm.running) {
1394                                 /*
1395                                  * Add uncertainty reserve.
1396                                  */
1397                                 cnt = ymf_calc_lend(state->format.rate);
1398                                 cnt <<= state->format.shift;
1399                                 if ((swptr += cnt) >= dmabuf->dmasize) {
1400                                         swptr -= dmabuf->dmasize;
1401                                 }
1402                         }
1403                         dmabuf->swptr = swptr;
1404                 } else {
1405                         /*
1406                          * XXX This is not right if dmabuf->count is small -
1407                          * about 2*x frame size or less. We cannot count on
1408                          * on appending and not causing an artefact.
1409                          * Should use a variation of the count==0 case above.
1410                          */
1411                         swptr = dmabuf->swptr;
1412                 }
1413                 cnt = dmabuf->dmasize - swptr;
1414                 if (dmabuf->count + cnt > dmabuf->dmasize - redzone)
1415                         cnt = (dmabuf->dmasize - redzone) - dmabuf->count;
1416                 spin_unlock_irqrestore(&unit->reg_lock, flags);
1417
1418                 if (cnt > count)
1419                         cnt = count;
1420                 if (cnt <= 0) {
1421                         YMFDBGW("ymf_write: full, count %d swptr %d\n",
1422                            dmabuf->count, dmabuf->swptr);
1423                         /*
1424                          * buffer is full, start the dma machine and
1425                          * wait for data to be played
1426                          */
1427                         spin_lock_irqsave(&unit->reg_lock, flags);
1428                         if (!state->wpcm.running) {
1429                                 ymf_playback_trigger(unit, &state->wpcm, 1);
1430                         }
1431                         spin_unlock_irqrestore(&unit->reg_lock, flags);
1432                         if (file->f_flags & O_NONBLOCK) {
1433                                 if (!ret) ret = -EAGAIN;
1434                                 break;
1435                         }
1436                         schedule();
1437                         set_current_state(TASK_INTERRUPTIBLE);
1438                         if (signal_pending(current)) {
1439                                 if (!ret) ret = -ERESTARTSYS;
1440                                 break;
1441                         }
1442                         continue;
1443                 }
1444                 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1445                         if (!ret) ret = -EFAULT;
1446                         break;
1447                 }
1448
1449                 if ((swptr += cnt) >= dmabuf->dmasize) {
1450                         swptr -= dmabuf->dmasize;
1451                 }
1452
1453                 spin_lock_irqsave(&unit->reg_lock, flags);
1454                 if (unit->suspended) {
1455                         spin_unlock_irqrestore(&unit->reg_lock, flags);
1456                         continue;
1457                 }
1458                 dmabuf->swptr = swptr;
1459                 dmabuf->count += cnt;
1460
1461                 /*
1462                  * Start here is a bad idea - may cause startup click
1463                  * in /bin/play when dmabuf is not full yet.
1464                  * However, some broken applications do not make
1465                  * any use of SNDCTL_DSP_SYNC (Doom is the worst).
1466                  * One frame is about 5.3ms, Doom write size is 46ms.
1467                  */
1468                 delay = state->format.rate / 20;        /* 50ms */
1469                 delay <<= state->format.shift;
1470                 if (dmabuf->count >= delay && !state->wpcm.running) {
1471                         ymf_playback_trigger(unit, &state->wpcm, 1);
1472                 }
1473
1474                 spin_unlock_irqrestore(&unit->reg_lock, flags);
1475
1476                 count -= cnt;
1477                 buffer += cnt;
1478                 ret += cnt;
1479         }
1480
1481         set_current_state(TASK_RUNNING);
1482         remove_wait_queue(&dmabuf->wait, &waita);
1483
1484         YMFDBGW("ymf_write: ret %d dmabuf.count %d\n", ret, dmabuf->count);
1485         return ret;
1486 }
1487
1488 static unsigned int ymf_poll(struct file *file, struct poll_table_struct *wait)
1489 {
1490         struct ymf_state *state = (struct ymf_state *)file->private_data;
1491         struct ymf_dmabuf *dmabuf;
1492         int redzone;
1493         unsigned long flags;
1494         unsigned int mask = 0;
1495
1496         if (file->f_mode & FMODE_WRITE)
1497                 poll_wait(file, &state->wpcm.dmabuf.wait, wait);
1498         if (file->f_mode & FMODE_READ)
1499                 poll_wait(file, &state->rpcm.dmabuf.wait, wait);
1500
1501         spin_lock_irqsave(&state->unit->reg_lock, flags);
1502         if (file->f_mode & FMODE_READ) {
1503                 dmabuf = &state->rpcm.dmabuf;
1504                 if (dmabuf->count >= (signed)dmabuf->fragsize)
1505                         mask |= POLLIN | POLLRDNORM;
1506         }
1507         if (file->f_mode & FMODE_WRITE) {
1508                 redzone = ymf_calc_lend(state->format.rate);
1509                 redzone <<= state->format.shift;
1510                 redzone *= 3;
1511
1512                 dmabuf = &state->wpcm.dmabuf;
1513                 if (dmabuf->mapped) {
1514                         if (dmabuf->count >= (signed)dmabuf->fragsize)
1515                                 mask |= POLLOUT | POLLWRNORM;
1516                 } else {
1517                         /*
1518                          * Don't select unless a full fragment is available.
1519                          * Otherwise artsd does GETOSPACE, sees 0, and loops.
1520                          */
1521                         if (dmabuf->count + redzone + dmabuf->fragsize
1522                              <= dmabuf->dmasize)
1523                                 mask |= POLLOUT | POLLWRNORM;
1524                 }
1525         }
1526         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1527
1528         return mask;
1529 }
1530
1531 static int ymf_mmap(struct file *file, struct vm_area_struct *vma)
1532 {
1533         struct ymf_state *state = (struct ymf_state *)file->private_data;
1534         struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
1535         int ret;
1536         unsigned long size;
1537
1538         if (vma->vm_flags & VM_WRITE) {
1539                 if ((ret = prog_dmabuf(state, 0)) != 0)
1540                         return ret;
1541         } else if (vma->vm_flags & VM_READ) {
1542                 if ((ret = prog_dmabuf(state, 1)) != 0)
1543                         return ret;
1544         } else
1545                 return -EINVAL;
1546
1547         if (vma->vm_pgoff != 0)
1548                 return -EINVAL;
1549         size = vma->vm_end - vma->vm_start;
1550         if (size > (PAGE_SIZE << dmabuf->buforder))
1551                 return -EINVAL;
1552         if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
1553                              size, vma->vm_page_prot))
1554                 return -EAGAIN;
1555         dmabuf->mapped = 1;
1556
1557 /* P3 */ printk(KERN_INFO "ymfpci: using memory mapped sound, untested!\n");
1558         return 0;
1559 }
1560
1561 static int ymf_ioctl(struct inode *inode, struct file *file,
1562     unsigned int cmd, unsigned long arg)
1563 {
1564         struct ymf_state *state = (struct ymf_state *)file->private_data;
1565         struct ymf_dmabuf *dmabuf;
1566         unsigned long flags;
1567         audio_buf_info abinfo;
1568         count_info cinfo;
1569         int redzone;
1570         int val;
1571         void __user *argp = (void __user *)arg;
1572         int __user *p = argp;
1573
1574         switch (cmd) {
1575         case OSS_GETVERSION:
1576                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETVER) arg 0x%lx\n", cmd, arg);
1577                 return put_user(SOUND_VERSION, p);
1578
1579         case SNDCTL_DSP_RESET:
1580                 YMFDBGX("ymf_ioctl: cmd 0x%x(RESET)\n", cmd);
1581                 if (file->f_mode & FMODE_WRITE) {
1582                         ymf_wait_dac(state);
1583                         dmabuf = &state->wpcm.dmabuf;
1584                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1585                         dmabuf->ready = 0;
1586                         dmabuf->swptr = dmabuf->hwptr;
1587                         dmabuf->count = dmabuf->total_bytes = 0;
1588                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1589                 }
1590                 if (file->f_mode & FMODE_READ) {
1591                         ymf_stop_adc(state);
1592                         dmabuf = &state->rpcm.dmabuf;
1593                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1594                         dmabuf->ready = 0;
1595                         dmabuf->swptr = dmabuf->hwptr;
1596                         dmabuf->count = dmabuf->total_bytes = 0;
1597                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1598                 }
1599                 return 0;
1600
1601         case SNDCTL_DSP_SYNC:
1602                 YMFDBGX("ymf_ioctl: cmd 0x%x(SYNC)\n", cmd);
1603                 if (file->f_mode & FMODE_WRITE) {
1604                         dmabuf = &state->wpcm.dmabuf;
1605                         if (file->f_flags & O_NONBLOCK) {
1606                                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1607                                 if (dmabuf->count != 0 && !state->wpcm.running) {
1608                                         ymf_start_dac(state);
1609                                 }
1610                                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1611                         } else {
1612                                 ymf_wait_dac(state);
1613                         }
1614                 }
1615                 /* XXX What does this do for reading? dmabuf->count=0; ? */
1616                 return 0;
1617
1618         case SNDCTL_DSP_SPEED: /* set smaple rate */
1619                 if (get_user(val, p))
1620                         return -EFAULT;
1621                 YMFDBGX("ymf_ioctl: cmd 0x%x(SPEED) sp %d\n", cmd, val);
1622                 if (val >= 8000 && val <= 48000) {
1623                         if (file->f_mode & FMODE_WRITE) {
1624                                 ymf_wait_dac(state);
1625                                 dmabuf = &state->wpcm.dmabuf;
1626                                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1627                                 dmabuf->ready = 0;
1628                                 state->format.rate = val;
1629                                 ymf_pcm_update_shift(&state->format);
1630                                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1631                         }
1632                         if (file->f_mode & FMODE_READ) {
1633                                 ymf_stop_adc(state);
1634                                 dmabuf = &state->rpcm.dmabuf;
1635                                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1636                                 dmabuf->ready = 0;
1637                                 state->format.rate = val;
1638                                 ymf_pcm_update_shift(&state->format);
1639                                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1640                         }
1641                 }
1642                 return put_user(state->format.rate, p);
1643
1644         /*
1645          * OSS manual does not mention SNDCTL_DSP_STEREO at all.
1646          * All channels are mono and if you want stereo, you
1647          * play into two channels with SNDCTL_DSP_CHANNELS.
1648          * However, mpg123 calls it. I wonder, why Michael Hipp used it.
1649          */
1650         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
1651                 if (get_user(val, p))
1652                         return -EFAULT;
1653                 YMFDBGX("ymf_ioctl: cmd 0x%x(STEREO) st %d\n", cmd, val);
1654                 if (file->f_mode & FMODE_WRITE) {
1655                         ymf_wait_dac(state);
1656                         dmabuf = &state->wpcm.dmabuf;
1657                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1658                         dmabuf->ready = 0;
1659                         state->format.voices = val ? 2 : 1;
1660                         ymf_pcm_update_shift(&state->format);
1661                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1662                 }
1663                 if (file->f_mode & FMODE_READ) {
1664                         ymf_stop_adc(state);
1665                         dmabuf = &state->rpcm.dmabuf;
1666                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1667                         dmabuf->ready = 0;
1668                         state->format.voices = val ? 2 : 1;
1669                         ymf_pcm_update_shift(&state->format);
1670                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1671                 }
1672                 return 0;
1673
1674         case SNDCTL_DSP_GETBLKSIZE:
1675                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETBLK)\n", cmd);
1676                 if (file->f_mode & FMODE_WRITE) {
1677                         if ((val = prog_dmabuf(state, 0)))
1678                                 return val;
1679                         val = state->wpcm.dmabuf.fragsize;
1680                         YMFDBGX("ymf_ioctl: GETBLK w %d\n", val);
1681                         return put_user(val, p);
1682                 }
1683                 if (file->f_mode & FMODE_READ) {
1684                         if ((val = prog_dmabuf(state, 1)))
1685                                 return val;
1686                         val = state->rpcm.dmabuf.fragsize;
1687                         YMFDBGX("ymf_ioctl: GETBLK r %d\n", val);
1688                         return put_user(val, p);
1689                 }
1690                 return -EINVAL;
1691
1692         case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
1693                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETFMTS)\n", cmd);
1694                 return put_user(AFMT_S16_LE|AFMT_U8, p);
1695
1696         case SNDCTL_DSP_SETFMT: /* Select sample format */
1697                 if (get_user(val, p))
1698                         return -EFAULT;
1699                 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFMT) fmt %d\n", cmd, val);
1700                 if (val == AFMT_S16_LE || val == AFMT_U8) {
1701                         if (file->f_mode & FMODE_WRITE) {
1702                                 ymf_wait_dac(state);
1703                                 dmabuf = &state->wpcm.dmabuf;
1704                                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1705                                 dmabuf->ready = 0;
1706                                 state->format.format = val;
1707                                 ymf_pcm_update_shift(&state->format);
1708                                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1709                         }
1710                         if (file->f_mode & FMODE_READ) {
1711                                 ymf_stop_adc(state);
1712                                 dmabuf = &state->rpcm.dmabuf;
1713                                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1714                                 dmabuf->ready = 0;
1715                                 state->format.format = val;
1716                                 ymf_pcm_update_shift(&state->format);
1717                                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1718                         }
1719                 }
1720                 return put_user(state->format.format, p);
1721
1722         case SNDCTL_DSP_CHANNELS:
1723                 if (get_user(val, p))
1724                         return -EFAULT;
1725                 YMFDBGX("ymf_ioctl: cmd 0x%x(CHAN) ch %d\n", cmd, val);
1726                 if (val != 0) {
1727                         if (file->f_mode & FMODE_WRITE) {
1728                                 ymf_wait_dac(state);
1729                                 if (val == 1 || val == 2) {
1730                                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1731                                         dmabuf = &state->wpcm.dmabuf;
1732                                         dmabuf->ready = 0;
1733                                         state->format.voices = val;
1734                                         ymf_pcm_update_shift(&state->format);
1735                                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1736                                 }
1737                         }
1738                         if (file->f_mode & FMODE_READ) {
1739                                 ymf_stop_adc(state);
1740                                 if (val == 1 || val == 2) {
1741                                         spin_lock_irqsave(&state->unit->reg_lock, flags);
1742                                         dmabuf = &state->rpcm.dmabuf;
1743                                         dmabuf->ready = 0;
1744                                         state->format.voices = val;
1745                                         ymf_pcm_update_shift(&state->format);
1746                                         spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1747                                 }
1748                         }
1749                 }
1750                 return put_user(state->format.voices, p);
1751
1752         case SNDCTL_DSP_POST:
1753                 YMFDBGX("ymf_ioctl: cmd 0x%x(POST)\n", cmd);
1754                 /*
1755                  * Quoting OSS PG:
1756                  *    The ioctl SNDCTL_DSP_POST is a lightweight version of
1757                  *    SNDCTL_DSP_SYNC. It just tells to the driver that there
1758                  *    is likely to be a pause in the output. This makes it
1759                  *    possible for the device to handle the pause more
1760                  *    intelligently. This ioctl doesn't block the application.
1761                  *
1762                  * The paragraph above is a clumsy way to say "flush ioctl".
1763                  * This ioctl is used by mpg123.
1764                  */
1765                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1766                 if (state->wpcm.dmabuf.count != 0 && !state->wpcm.running) {
1767                         ymf_start_dac(state);
1768                 }
1769                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1770                 return 0;
1771
1772         case SNDCTL_DSP_SETFRAGMENT:
1773                 if (get_user(val, p))
1774                         return -EFAULT;
1775                 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFRAG) fr 0x%04x:%04x(%d:%d)\n",
1776                     cmd,
1777                     (val >> 16) & 0xFFFF, val & 0xFFFF,
1778                     (val >> 16) & 0xFFFF, val & 0xFFFF);
1779                 dmabuf = &state->wpcm.dmabuf;
1780                 dmabuf->ossfragshift = val & 0xffff;
1781                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
1782                 if (dmabuf->ossfragshift < 4)
1783                         dmabuf->ossfragshift = 4;
1784                 if (dmabuf->ossfragshift > 15)
1785                         dmabuf->ossfragshift = 15;
1786                 return 0;
1787
1788         case SNDCTL_DSP_GETOSPACE:
1789                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOSPACE)\n", cmd);
1790                 if (!(file->f_mode & FMODE_WRITE))
1791                         return -EINVAL;
1792                 dmabuf = &state->wpcm.dmabuf;
1793                 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
1794                         return val;
1795                 redzone = ymf_calc_lend(state->format.rate);
1796                 redzone <<= state->format.shift;
1797                 redzone *= 3;
1798                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1799                 abinfo.fragsize = dmabuf->fragsize;
1800                 abinfo.bytes = dmabuf->dmasize - dmabuf->count - redzone;
1801                 abinfo.fragstotal = dmabuf->numfrag;
1802                 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
1803                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1804                 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1805
1806         case SNDCTL_DSP_GETISPACE:
1807                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETISPACE)\n", cmd);
1808                 if (!(file->f_mode & FMODE_READ))
1809                         return -EINVAL;
1810                 dmabuf = &state->rpcm.dmabuf;
1811                 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
1812                         return val;
1813                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1814                 abinfo.fragsize = dmabuf->fragsize;
1815                 abinfo.bytes = dmabuf->count;
1816                 abinfo.fragstotal = dmabuf->numfrag;
1817                 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
1818                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1819                 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1820
1821         case SNDCTL_DSP_NONBLOCK:
1822                 YMFDBGX("ymf_ioctl: cmd 0x%x(NONBLOCK)\n", cmd);
1823                 file->f_flags |= O_NONBLOCK;
1824                 return 0;
1825
1826         case SNDCTL_DSP_GETCAPS:
1827                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETCAPS)\n", cmd);
1828                 /* return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
1829                             p); */
1830                 return put_user(0, p);
1831
1832         case SNDCTL_DSP_GETIPTR:
1833                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETIPTR)\n", cmd);
1834                 if (!(file->f_mode & FMODE_READ))
1835                         return -EINVAL;
1836                 dmabuf = &state->rpcm.dmabuf;
1837                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1838                 cinfo.bytes = dmabuf->total_bytes;
1839                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
1840                 cinfo.ptr = dmabuf->hwptr;
1841                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1842                 YMFDBGX("ymf_ioctl: GETIPTR ptr %d bytes %d\n",
1843                     cinfo.ptr, cinfo.bytes);
1844                 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
1845
1846         case SNDCTL_DSP_GETOPTR:
1847                 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOPTR)\n", cmd);
1848                 if (!(file->f_mode & FMODE_WRITE))
1849                         return -EINVAL;
1850                 dmabuf = &state->wpcm.dmabuf;
1851                 spin_lock_irqsave(&state->unit->reg_lock, flags);
1852                 cinfo.bytes = dmabuf->total_bytes;
1853                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
1854                 cinfo.ptr = dmabuf->hwptr;
1855                 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1856                 YMFDBGX("ymf_ioctl: GETOPTR ptr %d bytes %d\n",
1857                     cinfo.ptr, cinfo.bytes);
1858                 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
1859
1860         case SNDCTL_DSP_SETDUPLEX:
1861                 YMFDBGX("ymf_ioctl: cmd 0x%x(SETDUPLEX)\n", cmd);
1862                 return 0;               /* Always duplex */
1863
1864         case SOUND_PCM_READ_RATE:
1865                 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_RATE)\n", cmd);
1866                 return put_user(state->format.rate, p);
1867
1868         case SOUND_PCM_READ_CHANNELS:
1869                 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_CH)\n", cmd);
1870                 return put_user(state->format.voices, p);
1871
1872         case SOUND_PCM_READ_BITS:
1873                 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_BITS)\n", cmd);
1874                 return put_user(AFMT_S16_LE, p);
1875
1876         case SNDCTL_DSP_MAPINBUF:
1877         case SNDCTL_DSP_MAPOUTBUF:
1878         case SNDCTL_DSP_SETSYNCRO:
1879         case SOUND_PCM_WRITE_FILTER:
1880         case SOUND_PCM_READ_FILTER:
1881                 YMFDBGX("ymf_ioctl: cmd 0x%x unsupported\n", cmd);
1882                 return -ENOTTY;
1883
1884         default:
1885                 /*
1886                  * Some programs mix up audio devices and ioctls
1887                  * or perhaps they expect "universal" ioctls,
1888                  * for instance we get SNDCTL_TMR_CONTINUE here.
1889                  * (mpg123 -g 100 ends here too - to be fixed.)
1890                  */
1891                 YMFDBGX("ymf_ioctl: cmd 0x%x unknown\n", cmd);
1892                 break;
1893         }
1894         return -ENOTTY;
1895 }
1896
1897 /*
1898  * open(2)
1899  * We use upper part of the minor to distinguish between soundcards.
1900  * Channels are opened with a clone open.
1901  */
1902 static int ymf_open(struct inode *inode, struct file *file)
1903 {
1904         struct list_head *list;
1905         ymfpci_t *unit = NULL;
1906         int minor;
1907         struct ymf_state *state;
1908         int err;
1909
1910         minor = iminor(inode);
1911         if ((minor & 0x0F) == 3) {      /* /dev/dspN */
1912                 ;
1913         } else {
1914                 return -ENXIO;
1915         }
1916
1917         unit = NULL;    /* gcc warns */
1918         spin_lock(&ymf_devs_lock);
1919         list_for_each(list, &ymf_devs) {
1920                 unit = list_entry(list, ymfpci_t, ymf_devs);
1921                 if (((unit->dev_audio ^ minor) & ~0x0F) == 0)
1922                         break;
1923         }
1924         spin_unlock(&ymf_devs_lock);
1925         if (unit == NULL)
1926                 return -ENODEV;
1927
1928         down(&unit->open_sem);
1929
1930         if ((state = ymf_state_alloc(unit)) == NULL) {
1931                 up(&unit->open_sem);
1932                 return -ENOMEM;
1933         }
1934         list_add_tail(&state->chain, &unit->states);
1935
1936         file->private_data = state;
1937
1938         /*
1939          * ymf_read and ymf_write that we borrowed from cs46xx
1940          * allocate buffers with prog_dmabuf(). We call prog_dmabuf
1941          * here so that in case of DMA memory exhaustion open
1942          * fails rather than write.
1943          *
1944          * XXX prog_dmabuf allocates voice. Should allocate explicitly, above.
1945          */
1946         if (file->f_mode & FMODE_WRITE) {
1947                 if (!state->wpcm.dmabuf.ready) {
1948                         if ((err = prog_dmabuf(state, 0)) != 0) {
1949                                 goto out_nodma;
1950                         }
1951                 }
1952         }
1953         if (file->f_mode & FMODE_READ) {
1954                 if (!state->rpcm.dmabuf.ready) {
1955                         if ((err = prog_dmabuf(state, 1)) != 0) {
1956                                 goto out_nodma;
1957                         }
1958                 }
1959         }
1960
1961 #if 0 /* test if interrupts work */
1962         ymfpci_writew(unit, YDSXGR_TIMERCOUNT, 0xfffe); /* ~ 680ms */
1963         ymfpci_writeb(unit, YDSXGR_TIMERCTRL,
1964             (YDSXGR_TIMERCTRL_TEN|YDSXGR_TIMERCTRL_TIEN));
1965 #endif
1966         up(&unit->open_sem);
1967
1968         return 0;
1969
1970 out_nodma:
1971         /*
1972          * XXX Broken custom: "goto out_xxx" in other place is
1973          * a nestable exception, but here it is not nestable due to semaphore.
1974          * XXX Doubtful technique of self-describing objects....
1975          */
1976         dealloc_dmabuf(unit, &state->wpcm.dmabuf);
1977         dealloc_dmabuf(unit, &state->rpcm.dmabuf);
1978         ymf_pcm_free_substream(&state->wpcm);
1979         ymf_pcm_free_substream(&state->rpcm);
1980
1981         list_del(&state->chain);
1982         kfree(state);
1983
1984         up(&unit->open_sem);
1985         return err;
1986 }
1987
1988 static int ymf_release(struct inode *inode, struct file *file)
1989 {
1990         struct ymf_state *state = (struct ymf_state *)file->private_data;
1991         ymfpci_t *unit = state->unit;
1992
1993 #if 0 /* test if interrupts work */
1994         ymfpci_writeb(unit, YDSXGR_TIMERCTRL, 0);
1995 #endif
1996
1997         down(&unit->open_sem);
1998
1999         /*
2000          * XXX Solve the case of O_NONBLOCK close - don't deallocate here.
2001          * Deallocate when unloading the driver and we can wait.
2002          */
2003         ymf_wait_dac(state);
2004         ymf_stop_adc(state);            /* fortunately, it's immediate */
2005         dealloc_dmabuf(unit, &state->wpcm.dmabuf);
2006         dealloc_dmabuf(unit, &state->rpcm.dmabuf);
2007         ymf_pcm_free_substream(&state->wpcm);
2008         ymf_pcm_free_substream(&state->rpcm);
2009
2010         list_del(&state->chain);
2011         file->private_data = NULL;      /* Can you tell I programmed Solaris */
2012         kfree(state);
2013
2014         up(&unit->open_sem);
2015
2016         return 0;
2017 }
2018
2019 /*
2020  * Mixer operations are based on cs46xx.
2021  */
2022 static int ymf_open_mixdev(struct inode *inode, struct file *file)
2023 {
2024         int minor = iminor(inode);
2025         struct list_head *list;
2026         ymfpci_t *unit;
2027         int i;
2028
2029         spin_lock(&ymf_devs_lock);
2030         list_for_each(list, &ymf_devs) {
2031                 unit = list_entry(list, ymfpci_t, ymf_devs);
2032                 for (i = 0; i < NR_AC97; i++) {
2033                         if (unit->ac97_codec[i] != NULL &&
2034                             unit->ac97_codec[i]->dev_mixer == minor) {
2035                                 spin_unlock(&ymf_devs_lock);
2036                                 goto match;
2037                         }
2038                 }
2039         }
2040         spin_unlock(&ymf_devs_lock);
2041         return -ENODEV;
2042
2043  match:
2044         file->private_data = unit->ac97_codec[i];
2045
2046         return 0;
2047 }
2048
2049 static int ymf_ioctl_mixdev(struct inode *inode, struct file *file,
2050     unsigned int cmd, unsigned long arg)
2051 {
2052         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
2053
2054         return codec->mixer_ioctl(codec, cmd, arg);
2055 }
2056
2057 static int ymf_release_mixdev(struct inode *inode, struct file *file)
2058 {
2059         return 0;
2060 }
2061
2062 static /*const*/ struct file_operations ymf_fops = {
2063         .owner          = THIS_MODULE,
2064         .llseek         = no_llseek,
2065         .read           = ymf_read,
2066         .write          = ymf_write,
2067         .poll           = ymf_poll,
2068         .ioctl          = ymf_ioctl,
2069         .mmap           = ymf_mmap,
2070         .open           = ymf_open,
2071         .release        = ymf_release,
2072 };
2073
2074 static /*const*/ struct file_operations ymf_mixer_fops = {
2075         .owner          = THIS_MODULE,
2076         .llseek         = no_llseek,
2077         .ioctl          = ymf_ioctl_mixdev,
2078         .open           = ymf_open_mixdev,
2079         .release        = ymf_release_mixdev,
2080 };
2081
2082 /*
2083  */
2084
2085 static int ymf_suspend(struct pci_dev *pcidev, u32 unused)
2086 {
2087         struct ymf_unit *unit = pci_get_drvdata(pcidev);
2088         unsigned long flags;
2089         struct ymf_dmabuf *dmabuf;
2090         struct list_head *p;
2091         struct ymf_state *state;
2092         struct ac97_codec *codec;
2093         int i;
2094
2095         spin_lock_irqsave(&unit->reg_lock, flags);
2096
2097         unit->suspended = 1;
2098
2099         for (i = 0; i < NR_AC97; i++) {
2100                 if ((codec = unit->ac97_codec[i]) != NULL)
2101                         ac97_save_state(codec);
2102         }
2103
2104         list_for_each(p, &unit->states) {
2105                 state = list_entry(p, struct ymf_state, chain);
2106
2107                 dmabuf = &state->wpcm.dmabuf;
2108                 dmabuf->hwptr = dmabuf->swptr = 0;
2109                 dmabuf->total_bytes = 0;
2110                 dmabuf->count = 0;
2111
2112                 dmabuf = &state->rpcm.dmabuf;
2113                 dmabuf->hwptr = dmabuf->swptr = 0;
2114                 dmabuf->total_bytes = 0;
2115                 dmabuf->count = 0;
2116         }
2117
2118         ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0);
2119         ymfpci_disable_dsp(unit);
2120
2121         spin_unlock_irqrestore(&unit->reg_lock, flags);
2122
2123         return 0;
2124 }
2125
2126 static int ymf_resume(struct pci_dev *pcidev)
2127 {
2128         struct ymf_unit *unit = pci_get_drvdata(pcidev);
2129         unsigned long flags;
2130         struct list_head *p;
2131         struct ymf_state *state;
2132         struct ac97_codec *codec;
2133         int i;
2134
2135         ymfpci_aclink_reset(unit->pci);
2136         ymfpci_codec_ready(unit, 0, 1);         /* prints diag if not ready. */
2137
2138 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2139         /* XXX At this time the legacy registers are probably deprogrammed. */
2140 #endif
2141
2142         ymfpci_download_image(unit);
2143
2144         ymf_memload(unit);
2145
2146         spin_lock_irqsave(&unit->reg_lock, flags);
2147
2148         if (unit->start_count) {
2149                 ymfpci_writel(unit, YDSXGR_MODE, 3);
2150                 unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
2151         }
2152
2153         for (i = 0; i < NR_AC97; i++) {
2154                 if ((codec = unit->ac97_codec[i]) != NULL)
2155                         ac97_restore_state(codec);
2156         }
2157
2158         unit->suspended = 0;
2159         list_for_each(p, &unit->states) {
2160                 state = list_entry(p, struct ymf_state, chain);
2161                 wake_up(&state->wpcm.dmabuf.wait);
2162                 wake_up(&state->rpcm.dmabuf.wait);
2163         }
2164
2165         spin_unlock_irqrestore(&unit->reg_lock, flags);
2166         return 0;
2167 }
2168
2169 /*
2170  *  initialization routines
2171  */
2172
2173 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2174
2175 static int ymfpci_setup_legacy(ymfpci_t *unit, struct pci_dev *pcidev)
2176 {
2177         int v;
2178         int mpuio = -1, oplio = -1;
2179
2180         switch (unit->iomidi) {
2181         case 0x330:
2182                 mpuio = 0;
2183                 break;
2184         case 0x300:
2185                 mpuio = 1;
2186                 break;
2187         case 0x332:
2188                 mpuio = 2;
2189                 break;
2190         case 0x334:
2191                 mpuio = 3;
2192                 break;
2193         default: ;
2194         }
2195
2196         switch (unit->iosynth) {
2197         case 0x388:
2198                 oplio = 0;
2199                 break;
2200         case 0x398:
2201                 oplio = 1;
2202                 break;
2203         case 0x3a0:
2204                 oplio = 2;
2205                 break;
2206         case 0x3a8:
2207                 oplio = 3;
2208                 break;
2209         default: ;
2210         }
2211
2212         if (mpuio >= 0 || oplio >= 0) {
2213                 /* 0x0020: 1 - 10 bits of I/O address decoded, 0 - 16 bits. */
2214                 v = 0x001e;
2215                 pci_write_config_word(pcidev, PCIR_LEGCTRL, v);
2216
2217                 switch (pcidev->device) {
2218                 case PCI_DEVICE_ID_YAMAHA_724:
2219                 case PCI_DEVICE_ID_YAMAHA_740:
2220                 case PCI_DEVICE_ID_YAMAHA_724F:
2221                 case PCI_DEVICE_ID_YAMAHA_740C:
2222                         v = 0x8800;
2223                         if (mpuio >= 0) { v |= mpuio<<4; }
2224                         if (oplio >= 0) { v |= oplio; }
2225                         pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
2226                         break;
2227
2228                 case PCI_DEVICE_ID_YAMAHA_744:
2229                 case PCI_DEVICE_ID_YAMAHA_754:
2230                         v = 0x8800;
2231                         pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
2232                         if (oplio >= 0) {
2233                                 pci_write_config_word(pcidev, PCIR_OPLADR, unit->iosynth);
2234                         }
2235                         if (mpuio >= 0) {
2236                                 pci_write_config_word(pcidev, PCIR_MPUADR, unit->iomidi);
2237                         }
2238                         break;
2239
2240                 default:
2241                         printk(KERN_ERR "ymfpci: Unknown device ID: 0x%x\n",
2242                             pcidev->device);
2243                         return -EINVAL;
2244                 }
2245         }
2246
2247         return 0;
2248 }
2249 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2250
2251 static void ymfpci_aclink_reset(struct pci_dev * pci)
2252 {
2253         u8 cmd;
2254
2255         /*
2256          * In the 744, 754 only 0x01 exists, 0x02 is undefined.
2257          * It does not seem to hurt to trip both regardless of revision.
2258          */
2259         pci_read_config_byte(pci, PCIR_DSXGCTRL, &cmd);
2260         pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
2261         pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd | 0x03);
2262         pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
2263
2264         pci_write_config_word(pci, PCIR_DSXPWRCTRL1, 0);
2265         pci_write_config_word(pci, PCIR_DSXPWRCTRL2, 0);
2266 }
2267
2268 static void ymfpci_enable_dsp(ymfpci_t *codec)
2269 {
2270         ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000001);
2271 }
2272
2273 static void ymfpci_disable_dsp(ymfpci_t *codec)
2274 {
2275         u32 val;
2276         int timeout = 1000;
2277
2278         val = ymfpci_readl(codec, YDSXGR_CONFIG);
2279         if (val)
2280                 ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000000);
2281         while (timeout-- > 0) {
2282                 val = ymfpci_readl(codec, YDSXGR_STATUS);
2283                 if ((val & 0x00000002) == 0)
2284                         break;
2285         }
2286 }
2287
2288 #include "ymfpci_image.h"
2289
2290 static void ymfpci_download_image(ymfpci_t *codec)
2291 {
2292         int i, ver_1e;
2293         u16 ctrl;
2294
2295         ymfpci_writel(codec, YDSXGR_NATIVEDACOUTVOL, 0x00000000);
2296         ymfpci_disable_dsp(codec);
2297         ymfpci_writel(codec, YDSXGR_MODE, 0x00010000);
2298         ymfpci_writel(codec, YDSXGR_MODE, 0x00000000);
2299         ymfpci_writel(codec, YDSXGR_MAPOFREC, 0x00000000);
2300         ymfpci_writel(codec, YDSXGR_MAPOFEFFECT, 0x00000000);
2301         ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0x00000000);
2302         ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0x00000000);
2303         ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0x00000000);
2304         ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2305         ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2306
2307         /* setup DSP instruction code */
2308         for (i = 0; i < YDSXG_DSPLENGTH / 4; i++)
2309                 ymfpci_writel(codec, YDSXGR_DSPINSTRAM + (i << 2), DspInst[i]);
2310
2311         switch (codec->pci->device) {
2312         case PCI_DEVICE_ID_YAMAHA_724F:
2313         case PCI_DEVICE_ID_YAMAHA_740C:
2314         case PCI_DEVICE_ID_YAMAHA_744:
2315         case PCI_DEVICE_ID_YAMAHA_754:
2316                 ver_1e = 1;
2317                 break;
2318         default:
2319                 ver_1e = 0;
2320         }
2321
2322         if (ver_1e) {
2323                 /* setup control instruction code */
2324                 for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
2325                         ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst1E[i]);
2326         } else {
2327                 for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
2328                         ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst[i]);
2329         }
2330
2331         ymfpci_enable_dsp(codec);
2332
2333         /* 0.02s sounds not too bad, we may do schedule_timeout() later. */
2334         mdelay(20); /* seems we need some delay after downloading image.. */
2335 }
2336
2337 static int ymfpci_memalloc(ymfpci_t *codec)
2338 {
2339         unsigned int playback_ctrl_size;
2340         unsigned int bank_size_playback;
2341         unsigned int bank_size_capture;
2342         unsigned int bank_size_effect;
2343         unsigned int size;
2344         unsigned int off;
2345         char *ptr;
2346         dma_addr_t pba;
2347         int voice, bank;
2348
2349         playback_ctrl_size = 4 + 4 * YDSXG_PLAYBACK_VOICES;
2350         bank_size_playback = ymfpci_readl(codec, YDSXGR_PLAYCTRLSIZE) << 2;
2351         bank_size_capture = ymfpci_readl(codec, YDSXGR_RECCTRLSIZE) << 2;
2352         bank_size_effect = ymfpci_readl(codec, YDSXGR_EFFCTRLSIZE) << 2;
2353         codec->work_size = YDSXG_DEFAULT_WORK_SIZE;
2354
2355         size = ((playback_ctrl_size + 0x00ff) & ~0x00ff) +
2356             ((bank_size_playback * 2 * YDSXG_PLAYBACK_VOICES + 0xff) & ~0xff) +
2357             ((bank_size_capture * 2 * YDSXG_CAPTURE_VOICES + 0xff) & ~0xff) +
2358             ((bank_size_effect * 2 * YDSXG_EFFECT_VOICES + 0xff) & ~0xff) +
2359             codec->work_size;
2360
2361         ptr = pci_alloc_consistent(codec->pci, size + 0xff, &pba);
2362         if (ptr == NULL)
2363                 return -ENOMEM;
2364         codec->dma_area_va = ptr;
2365         codec->dma_area_ba = pba;
2366         codec->dma_area_size = size + 0xff;
2367
2368         if ((off = ((uint) ptr) & 0xff) != 0) {
2369                 ptr += 0x100 - off;
2370                 pba += 0x100 - off;
2371         }
2372
2373         /*
2374          * Hardware requires only ptr[playback_ctrl_size] zeroed,
2375          * but in our judgement it is a wrong kind of savings, so clear it all.
2376          */
2377         memset(ptr, 0, size);
2378
2379         codec->ctrl_playback = (u32 *)ptr;
2380         codec->ctrl_playback_ba = pba;
2381         codec->ctrl_playback[0] = cpu_to_le32(YDSXG_PLAYBACK_VOICES);
2382         ptr += (playback_ctrl_size + 0x00ff) & ~0x00ff;
2383         pba += (playback_ctrl_size + 0x00ff) & ~0x00ff;
2384
2385         off = 0;
2386         for (voice = 0; voice < YDSXG_PLAYBACK_VOICES; voice++) {
2387                 codec->voices[voice].number = voice;
2388                 codec->voices[voice].bank =
2389                     (ymfpci_playback_bank_t *) (ptr + off);
2390                 codec->voices[voice].bank_ba = pba + off;
2391                 off += 2 * bank_size_playback;          /* 2 banks */
2392         }
2393         off = (off + 0xff) & ~0xff;
2394         ptr += off;
2395         pba += off;
2396
2397         off = 0;
2398         codec->bank_base_capture = pba;
2399         for (voice = 0; voice < YDSXG_CAPTURE_VOICES; voice++)
2400                 for (bank = 0; bank < 2; bank++) {
2401                         codec->bank_capture[voice][bank] =
2402                             (ymfpci_capture_bank_t *) (ptr + off);
2403                         off += bank_size_capture;
2404                 }
2405         off = (off + 0xff) & ~0xff;
2406         ptr += off;
2407         pba += off;
2408
2409         off = 0;
2410         codec->bank_base_effect = pba;
2411         for (voice = 0; voice < YDSXG_EFFECT_VOICES; voice++)
2412                 for (bank = 0; bank < 2; bank++) {
2413                         codec->bank_effect[voice][bank] =
2414                             (ymfpci_effect_bank_t *) (ptr + off);
2415                         off += bank_size_effect;
2416                 }
2417         off = (off + 0xff) & ~0xff;
2418         ptr += off;
2419         pba += off;
2420
2421         codec->work_base = pba;
2422
2423         return 0;
2424 }
2425
2426 static void ymfpci_memfree(ymfpci_t *codec)
2427 {
2428         ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0);
2429         ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0);
2430         ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0);
2431         ymfpci_writel(codec, YDSXGR_WORKBASE, 0);
2432         ymfpci_writel(codec, YDSXGR_WORKSIZE, 0);
2433         pci_free_consistent(codec->pci,
2434             codec->dma_area_size, codec->dma_area_va, codec->dma_area_ba);
2435 }
2436
2437 static void ymf_memload(ymfpci_t *unit)
2438 {
2439
2440         ymfpci_writel(unit, YDSXGR_PLAYCTRLBASE, unit->ctrl_playback_ba);
2441         ymfpci_writel(unit, YDSXGR_RECCTRLBASE, unit->bank_base_capture);
2442         ymfpci_writel(unit, YDSXGR_EFFCTRLBASE, unit->bank_base_effect);
2443         ymfpci_writel(unit, YDSXGR_WORKBASE, unit->work_base);
2444         ymfpci_writel(unit, YDSXGR_WORKSIZE, unit->work_size >> 2);
2445
2446         /* S/PDIF output initialization */
2447         ymfpci_writew(unit, YDSXGR_SPDIFOUTCTRL, 0);
2448         ymfpci_writew(unit, YDSXGR_SPDIFOUTSTATUS,
2449                 SND_PCM_AES0_CON_EMPHASIS_NONE |
2450                 (SND_PCM_AES1_CON_ORIGINAL << 8) |
2451                 (SND_PCM_AES1_CON_PCM_CODER << 8));
2452
2453         /* S/PDIF input initialization */
2454         ymfpci_writew(unit, YDSXGR_SPDIFINCTRL, 0);
2455
2456         /* move this volume setup to mixer */
2457         ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0x3fff3fff);
2458         ymfpci_writel(unit, YDSXGR_BUF441OUTVOL, 0);
2459         ymfpci_writel(unit, YDSXGR_NATIVEADCINVOL, 0x3fff3fff);
2460         ymfpci_writel(unit, YDSXGR_NATIVEDACINVOL, 0x3fff3fff);
2461 }
2462
2463 static int ymf_ac97_init(ymfpci_t *unit, int num_ac97)
2464 {
2465         struct ac97_codec *codec;
2466         u16 eid;
2467
2468         if ((codec = ac97_alloc_codec()) == NULL)
2469                 return -ENOMEM;
2470
2471         /* initialize some basic codec information, other fields will be filled
2472            in ac97_probe_codec */
2473         codec->private_data = unit;
2474         codec->id = num_ac97;
2475
2476         codec->codec_read = ymfpci_codec_read;
2477         codec->codec_write = ymfpci_codec_write;
2478
2479         if (ac97_probe_codec(codec) == 0) {
2480                 printk(KERN_ERR "ymfpci: ac97_probe_codec failed\n");
2481                 goto out_kfree;
2482         }
2483
2484         eid = ymfpci_codec_read(codec, AC97_EXTENDED_ID);
2485         if (eid==0xFFFF) {
2486                 printk(KERN_WARNING "ymfpci: no codec attached ?\n");
2487                 goto out_kfree;
2488         }
2489
2490         unit->ac97_features = eid;
2491
2492         if ((codec->dev_mixer = register_sound_mixer(&ymf_mixer_fops, -1)) < 0) {
2493                 printk(KERN_ERR "ymfpci: couldn't register mixer!\n");
2494                 goto out_kfree;
2495         }
2496
2497         unit->ac97_codec[num_ac97] = codec;
2498
2499         return 0;
2500  out_kfree:
2501         ac97_release_codec(codec);
2502         return -ENODEV;
2503 }
2504
2505 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2506 # ifdef MODULE
2507 static int mpu_io;
2508 static int synth_io;
2509 MODULE_PARM(mpu_io, "i");
2510 MODULE_PARM(synth_io, "i");
2511 # else
2512 static int mpu_io     = 0x330;
2513 static int synth_io   = 0x388;
2514 # endif
2515 static int assigned;
2516 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2517
2518 static int __devinit ymf_probe_one(struct pci_dev *pcidev, const struct pci_device_id *ent)
2519 {
2520         u16 ctrl;
2521         unsigned long base;
2522         ymfpci_t *codec;
2523
2524         int err;
2525
2526         if ((err = pci_enable_device(pcidev)) != 0) {
2527                 printk(KERN_ERR "ymfpci: pci_enable_device failed\n");
2528                 return err;
2529         }
2530         base = pci_resource_start(pcidev, 0);
2531
2532         if ((codec = kmalloc(sizeof(ymfpci_t), GFP_KERNEL)) == NULL) {
2533                 printk(KERN_ERR "ymfpci: no core\n");
2534                 return -ENOMEM;
2535         }
2536         memset(codec, 0, sizeof(*codec));
2537
2538         spin_lock_init(&codec->reg_lock);
2539         spin_lock_init(&codec->voice_lock);
2540         spin_lock_init(&codec->ac97_lock);
2541         init_MUTEX(&codec->open_sem);
2542         INIT_LIST_HEAD(&codec->states);
2543         codec->pci = pcidev;
2544
2545         pci_read_config_byte(pcidev, PCI_REVISION_ID, &codec->rev);
2546
2547         if (request_mem_region(base, 0x8000, "ymfpci") == NULL) {
2548                 printk(KERN_ERR "ymfpci: unable to request mem region\n");
2549                 goto out_free;
2550         }
2551
2552         if ((codec->reg_area_virt = ioremap(base, 0x8000)) == NULL) {
2553                 printk(KERN_ERR "ymfpci: unable to map registers\n");
2554                 goto out_release_region;
2555         }
2556
2557         pci_set_master(pcidev);
2558
2559         printk(KERN_INFO "ymfpci: %s at 0x%lx IRQ %d\n",
2560             (char *)ent->driver_data, base, pcidev->irq);
2561
2562         ymfpci_aclink_reset(pcidev);
2563         if (ymfpci_codec_ready(codec, 0, 1) < 0)
2564                 goto out_unmap;
2565
2566 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2567         if (assigned == 0) {
2568                 codec->iomidi = mpu_io;
2569                 codec->iosynth = synth_io;
2570                 if (ymfpci_setup_legacy(codec, pcidev) < 0)
2571                         goto out_unmap;
2572                 assigned = 1;
2573         }
2574 #endif
2575
2576         ymfpci_download_image(codec);
2577
2578         if (ymfpci_memalloc(codec) < 0)
2579                 goto out_disable_dsp;
2580         ymf_memload(codec);
2581
2582         if (request_irq(pcidev->irq, ymf_interrupt, SA_SHIRQ, "ymfpci", codec) != 0) {
2583                 printk(KERN_ERR "ymfpci: unable to request IRQ %d\n",
2584                     pcidev->irq);
2585                 goto out_memfree;
2586         }
2587
2588         /* register /dev/dsp */
2589         if ((codec->dev_audio = register_sound_dsp(&ymf_fops, -1)) < 0) {
2590                 printk(KERN_ERR "ymfpci: unable to register dsp\n");
2591                 goto out_free_irq;
2592         }
2593
2594         /*
2595          * Poke just the primary for the moment.
2596          */
2597         if ((err = ymf_ac97_init(codec, 0)) != 0)
2598                 goto out_unregister_sound_dsp;
2599
2600 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2601         codec->opl3_data.name = "ymfpci";
2602         codec->mpu_data.name  = "ymfpci";
2603
2604         codec->opl3_data.io_base = codec->iosynth;
2605         codec->opl3_data.irq     = -1;
2606
2607         codec->mpu_data.io_base  = codec->iomidi;
2608         codec->mpu_data.irq      = -1;  /* May be different from our PCI IRQ. */
2609
2610         if (codec->iomidi) {
2611                 if (!probe_uart401(&codec->mpu_data, THIS_MODULE)) {
2612                         codec->iomidi = 0;      /* XXX kludge */
2613                 }
2614         }
2615 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2616
2617         /* put it into driver list */
2618         spin_lock(&ymf_devs_lock);
2619         list_add_tail(&codec->ymf_devs, &ymf_devs);
2620         spin_unlock(&ymf_devs_lock);
2621         pci_set_drvdata(pcidev, codec);
2622
2623         return 0;
2624
2625  out_unregister_sound_dsp:
2626         unregister_sound_dsp(codec->dev_audio);
2627  out_free_irq:
2628         free_irq(pcidev->irq, codec);
2629  out_memfree:
2630         ymfpci_memfree(codec);
2631  out_disable_dsp:
2632         ymfpci_disable_dsp(codec);
2633         ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2634         ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2635         ymfpci_writel(codec, YDSXGR_STATUS, ~0);
2636  out_unmap:
2637         iounmap(codec->reg_area_virt);
2638  out_release_region:
2639         release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
2640  out_free:
2641         if (codec->ac97_codec[0])
2642                 ac97_release_codec(codec->ac97_codec[0]);
2643         return -ENODEV;
2644 }
2645
2646 static void __devexit ymf_remove_one(struct pci_dev *pcidev)
2647 {
2648         __u16 ctrl;
2649         ymfpci_t *codec = pci_get_drvdata(pcidev);
2650
2651         /* remove from list of devices */
2652         spin_lock(&ymf_devs_lock);
2653         list_del(&codec->ymf_devs);
2654         spin_unlock(&ymf_devs_lock);
2655
2656         unregister_sound_mixer(codec->ac97_codec[0]->dev_mixer);
2657         ac97_release_codec(codec->ac97_codec[0]);
2658         unregister_sound_dsp(codec->dev_audio);
2659         free_irq(pcidev->irq, codec);
2660         ymfpci_memfree(codec);
2661         ymfpci_writel(codec, YDSXGR_STATUS, ~0);
2662         ymfpci_disable_dsp(codec);
2663         ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2664         ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2665         iounmap(codec->reg_area_virt);
2666         release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
2667 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2668         if (codec->iomidi) {
2669                 unload_uart401(&codec->mpu_data);
2670         }
2671 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2672 }
2673
2674 MODULE_AUTHOR("Jaroslav Kysela");
2675 MODULE_DESCRIPTION("Yamaha YMF7xx PCI Audio");
2676 MODULE_LICENSE("GPL");
2677
2678 static struct pci_driver ymfpci_driver = {
2679         .name           = "ymfpci",
2680         .id_table       = ymf_id_tbl,
2681         .probe          = ymf_probe_one,
2682         .remove         = __devexit_p(ymf_remove_one),
2683         .suspend        = ymf_suspend,
2684         .resume         = ymf_resume
2685 };
2686
2687 static int __init ymf_init_module(void)
2688 {
2689         return pci_module_init(&ymfpci_driver);
2690 }
2691
2692 static void __exit ymf_cleanup_module (void)
2693 {
2694         pci_unregister_driver(&ymfpci_driver);
2695 }
2696
2697 module_init(ymf_init_module);
2698 module_exit(ymf_cleanup_module);