linux/sound/core/oss/pcm_oss.c
<<
>>
Prefs
   1/*
   2 *  Digital Audio (PCM) abstract layer / OSS compatible
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4 *
   5 *
   6 *   This program is free software; you can redistribute it and/or modify
   7 *   it under the terms of the GNU General Public License as published by
   8 *   the Free Software Foundation; either version 2 of the License, or
   9 *   (at your option) any later version.
  10 *
  11 *   This program is distributed in the hope that it will be useful,
  12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *   GNU General Public License for more details.
  15 *
  16 *   You should have received a copy of the GNU General Public License
  17 *   along with this program; if not, write to the Free Software
  18 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 *
  20 */
  21
  22#if 0
  23#define PLUGIN_DEBUG
  24#endif
  25#if 0
  26#define OSS_DEBUG
  27#endif
  28
  29#include <linux/init.h>
  30#include <linux/slab.h>
  31#include <linux/time.h>
  32#include <linux/vmalloc.h>
  33#include <linux/moduleparam.h>
  34#include <linux/math64.h>
  35#include <linux/string.h>
  36#include <sound/core.h>
  37#include <sound/minors.h>
  38#include <sound/pcm.h>
  39#include <sound/pcm_params.h>
  40#include "pcm_plugin.h"
  41#include <sound/info.h>
  42#include <linux/soundcard.h>
  43#include <sound/initval.h>
  44
  45#define OSS_ALSAEMULVER         _SIOR ('M', 249, int)
  46
  47static int dsp_map[SNDRV_CARDS];
  48static int adsp_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1};
  49static int nonblock_open = 1;
  50
  51MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
  52MODULE_DESCRIPTION("PCM OSS emulation for ALSA.");
  53MODULE_LICENSE("GPL");
  54module_param_array(dsp_map, int, NULL, 0444);
  55MODULE_PARM_DESC(dsp_map, "PCM device number assigned to 1st OSS device.");
  56module_param_array(adsp_map, int, NULL, 0444);
  57MODULE_PARM_DESC(adsp_map, "PCM device number assigned to 2nd OSS device.");
  58module_param(nonblock_open, bool, 0644);
  59MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices.");
  60MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM);
  61MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1);
  62
  63extern int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg);
  64static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file);
  65static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file);
  66static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file);
  67
  68static inline mm_segment_t snd_enter_user(void)
  69{
  70        mm_segment_t fs = get_fs();
  71        set_fs(get_ds());
  72        return fs;
  73}
  74
  75static inline void snd_leave_user(mm_segment_t fs)
  76{
  77        set_fs(fs);
  78}
  79
  80/*
  81 * helper functions to process hw_params
  82 */
  83static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
  84{
  85        int changed = 0;
  86        if (i->min < min) {
  87                i->min = min;
  88                i->openmin = openmin;
  89                changed = 1;
  90        } else if (i->min == min && !i->openmin && openmin) {
  91                i->openmin = 1;
  92                changed = 1;
  93        }
  94        if (i->integer) {
  95                if (i->openmin) {
  96                        i->min++;
  97                        i->openmin = 0;
  98                }
  99        }
 100        if (snd_interval_checkempty(i)) {
 101                snd_interval_none(i);
 102                return -EINVAL;
 103        }
 104        return changed;
 105}
 106
 107static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
 108{
 109        int changed = 0;
 110        if (i->max > max) {
 111                i->max = max;
 112                i->openmax = openmax;
 113                changed = 1;
 114        } else if (i->max == max && !i->openmax && openmax) {
 115                i->openmax = 1;
 116                changed = 1;
 117        }
 118        if (i->integer) {
 119                if (i->openmax) {
 120                        i->max--;
 121                        i->openmax = 0;
 122                }
 123        }
 124        if (snd_interval_checkempty(i)) {
 125                snd_interval_none(i);
 126                return -EINVAL;
 127        }
 128        return changed;
 129}
 130
 131static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
 132{
 133        struct snd_interval t;
 134        t.empty = 0;
 135        t.min = t.max = val;
 136        t.openmin = t.openmax = 0;
 137        t.integer = 1;
 138        return snd_interval_refine(i, &t);
 139}
 140
 141/**
 142 * snd_pcm_hw_param_value_min
 143 * @params: the hw_params instance
 144 * @var: parameter to retrieve
 145 * @dir: pointer to the direction (-1,0,1) or NULL
 146 *
 147 * Return the minimum value for field PAR.
 148 */
 149static unsigned int
 150snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
 151                           snd_pcm_hw_param_t var, int *dir)
 152{
 153        if (hw_is_mask(var)) {
 154                if (dir)
 155                        *dir = 0;
 156                return snd_mask_min(hw_param_mask_c(params, var));
 157        }
 158        if (hw_is_interval(var)) {
 159                const struct snd_interval *i = hw_param_interval_c(params, var);
 160                if (dir)
 161                        *dir = i->openmin;
 162                return snd_interval_min(i);
 163        }
 164        return -EINVAL;
 165}
 166
 167/**
 168 * snd_pcm_hw_param_value_max
 169 * @params: the hw_params instance
 170 * @var: parameter to retrieve
 171 * @dir: pointer to the direction (-1,0,1) or NULL
 172 *
 173 * Return the maximum value for field PAR.
 174 */
 175static unsigned int
 176snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
 177                           snd_pcm_hw_param_t var, int *dir)
 178{
 179        if (hw_is_mask(var)) {
 180                if (dir)
 181                        *dir = 0;
 182                return snd_mask_max(hw_param_mask_c(params, var));
 183        }
 184        if (hw_is_interval(var)) {
 185                const struct snd_interval *i = hw_param_interval_c(params, var);
 186                if (dir)
 187                        *dir = - (int) i->openmax;
 188                return snd_interval_max(i);
 189        }
 190        return -EINVAL;
 191}
 192
 193static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
 194                                  snd_pcm_hw_param_t var,
 195                                  const struct snd_mask *val)
 196{
 197        int changed;
 198        changed = snd_mask_refine(hw_param_mask(params, var), val);
 199        if (changed) {
 200                params->cmask |= 1 << var;
 201                params->rmask |= 1 << var;
 202        }
 203        return changed;
 204}
 205
 206static int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm,
 207                                 struct snd_pcm_hw_params *params,
 208                                 snd_pcm_hw_param_t var,
 209                                 const struct snd_mask *val)
 210{
 211        int changed = _snd_pcm_hw_param_mask(params, var, val);
 212        if (changed < 0)
 213                return changed;
 214        if (params->rmask) {
 215                int err = snd_pcm_hw_refine(pcm, params);
 216                if (err < 0)
 217                        return err;
 218        }
 219        return 0;
 220}
 221
 222static int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
 223                                 snd_pcm_hw_param_t var, unsigned int val,
 224                                 int dir)
 225{
 226        int changed;
 227        int open = 0;
 228        if (dir) {
 229                if (dir > 0) {
 230                        open = 1;
 231                } else if (dir < 0) {
 232                        if (val > 0) {
 233                                open = 1;
 234                                val--;
 235                        }
 236                }
 237        }
 238        if (hw_is_mask(var))
 239                changed = snd_mask_refine_min(hw_param_mask(params, var),
 240                                              val + !!open);
 241        else if (hw_is_interval(var))
 242                changed = snd_interval_refine_min(hw_param_interval(params, var),
 243                                                  val, open);
 244        else
 245                return -EINVAL;
 246        if (changed) {
 247                params->cmask |= 1 << var;
 248                params->rmask |= 1 << var;
 249        }
 250        return changed;
 251}
 252
 253/**
 254 * snd_pcm_hw_param_min
 255 * @pcm: PCM instance
 256 * @params: the hw_params instance
 257 * @var: parameter to retrieve
 258 * @val: minimal value
 259 * @dir: pointer to the direction (-1,0,1) or NULL
 260 *
 261 * Inside configuration space defined by PARAMS remove from PAR all 
 262 * values < VAL. Reduce configuration space accordingly.
 263 * Return new minimum or -EINVAL if the configuration space is empty
 264 */
 265static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm,
 266                                struct snd_pcm_hw_params *params,
 267                                snd_pcm_hw_param_t var, unsigned int val,
 268                                int *dir)
 269{
 270        int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0);
 271        if (changed < 0)
 272                return changed;
 273        if (params->rmask) {
 274                int err = snd_pcm_hw_refine(pcm, params);
 275                if (err < 0)
 276                        return err;
 277        }
 278        return snd_pcm_hw_param_value_min(params, var, dir);
 279}
 280
 281static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
 282                                 snd_pcm_hw_param_t var, unsigned int val,
 283                                 int dir)
 284{
 285        int changed;
 286        int open = 0;
 287        if (dir) {
 288                if (dir < 0) {
 289                        open = 1;
 290                } else if (dir > 0) {
 291                        open = 1;
 292                        val++;
 293                }
 294        }
 295        if (hw_is_mask(var)) {
 296                if (val == 0 && open) {
 297                        snd_mask_none(hw_param_mask(params, var));
 298                        changed = -EINVAL;
 299                } else
 300                        changed = snd_mask_refine_max(hw_param_mask(params, var),
 301                                                      val - !!open);
 302        } else if (hw_is_interval(var))
 303                changed = snd_interval_refine_max(hw_param_interval(params, var),
 304                                                  val, open);
 305        else
 306                return -EINVAL;
 307        if (changed) {
 308                params->cmask |= 1 << var;
 309                params->rmask |= 1 << var;
 310        }
 311        return changed;
 312}
 313
 314/**
 315 * snd_pcm_hw_param_max
 316 * @pcm: PCM instance
 317 * @params: the hw_params instance
 318 * @var: parameter to retrieve
 319 * @val: maximal value
 320 * @dir: pointer to the direction (-1,0,1) or NULL
 321 *
 322 * Inside configuration space defined by PARAMS remove from PAR all 
 323 *  values >= VAL + 1. Reduce configuration space accordingly.
 324 *  Return new maximum or -EINVAL if the configuration space is empty
 325 */
 326static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm,
 327                                struct snd_pcm_hw_params *params,
 328                                snd_pcm_hw_param_t var, unsigned int val,
 329                                int *dir)
 330{
 331        int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0);
 332        if (changed < 0)
 333                return changed;
 334        if (params->rmask) {
 335                int err = snd_pcm_hw_refine(pcm, params);
 336                if (err < 0)
 337                        return err;
 338        }
 339        return snd_pcm_hw_param_value_max(params, var, dir);
 340}
 341
 342static int boundary_sub(int a, int adir,
 343                        int b, int bdir,
 344                        int *c, int *cdir)
 345{
 346        adir = adir < 0 ? -1 : (adir > 0 ? 1 : 0);
 347        bdir = bdir < 0 ? -1 : (bdir > 0 ? 1 : 0);
 348        *c = a - b;
 349        *cdir = adir - bdir;
 350        if (*cdir == -2) {
 351                (*c)--;
 352        } else if (*cdir == 2) {
 353                (*c)++;
 354        }
 355        return 0;
 356}
 357
 358static int boundary_lt(unsigned int a, int adir,
 359                       unsigned int b, int bdir)
 360{
 361        if (adir < 0) {
 362                a--;
 363                adir = 1;
 364        } else if (adir > 0)
 365                adir = 1;
 366        if (bdir < 0) {
 367                b--;
 368                bdir = 1;
 369        } else if (bdir > 0)
 370                bdir = 1;
 371        return a < b || (a == b && adir < bdir);
 372}
 373
 374/* Return 1 if min is nearer to best than max */
 375static int boundary_nearer(int min, int mindir,
 376                           int best, int bestdir,
 377                           int max, int maxdir)
 378{
 379        int dmin, dmindir;
 380        int dmax, dmaxdir;
 381        boundary_sub(best, bestdir, min, mindir, &dmin, &dmindir);
 382        boundary_sub(max, maxdir, best, bestdir, &dmax, &dmaxdir);
 383        return boundary_lt(dmin, dmindir, dmax, dmaxdir);
 384}
 385
 386/**
 387 * snd_pcm_hw_param_near
 388 * @pcm: PCM instance
 389 * @params: the hw_params instance
 390 * @var: parameter to retrieve
 391 * @best: value to set
 392 * @dir: pointer to the direction (-1,0,1) or NULL
 393 *
 394 * Inside configuration space defined by PARAMS set PAR to the available value
 395 * nearest to VAL. Reduce configuration space accordingly.
 396 * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
 397 * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
 398 * Return the value found.
 399  */
 400static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
 401                                 struct snd_pcm_hw_params *params,
 402                                 snd_pcm_hw_param_t var, unsigned int best,
 403                                 int *dir)
 404{
 405        struct snd_pcm_hw_params *save = NULL;
 406        int v;
 407        unsigned int saved_min;
 408        int last = 0;
 409        int min, max;
 410        int mindir, maxdir;
 411        int valdir = dir ? *dir : 0;
 412        /* FIXME */
 413        if (best > INT_MAX)
 414                best = INT_MAX;
 415        min = max = best;
 416        mindir = maxdir = valdir;
 417        if (maxdir > 0)
 418                maxdir = 0;
 419        else if (maxdir == 0)
 420                maxdir = -1;
 421        else {
 422                maxdir = 1;
 423                max--;
 424        }
 425        save = kmalloc(sizeof(*save), GFP_KERNEL);
 426        if (save == NULL)
 427                return -ENOMEM;
 428        *save = *params;
 429        saved_min = min;
 430        min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
 431        if (min >= 0) {
 432                struct snd_pcm_hw_params *params1;
 433                if (max < 0)
 434                        goto _end;
 435                if ((unsigned int)min == saved_min && mindir == valdir)
 436                        goto _end;
 437                params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
 438                if (params1 == NULL) {
 439                        kfree(save);
 440                        return -ENOMEM;
 441                }
 442                *params1 = *save;
 443                max = snd_pcm_hw_param_max(pcm, params1, var, max, &maxdir);
 444                if (max < 0) {
 445                        kfree(params1);
 446                        goto _end;
 447                }
 448                if (boundary_nearer(max, maxdir, best, valdir, min, mindir)) {
 449                        *params = *params1;
 450                        last = 1;
 451                }
 452                kfree(params1);
 453        } else {
 454                *params = *save;
 455                max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
 456                if (max < 0)
 457                        return max;
 458                last = 1;
 459        }
 460 _end:
 461        kfree(save);
 462        if (last)
 463                v = snd_pcm_hw_param_last(pcm, params, var, dir);
 464        else
 465                v = snd_pcm_hw_param_first(pcm, params, var, dir);
 466        snd_BUG_ON(v < 0);
 467        return v;
 468}
 469
 470static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
 471                                 snd_pcm_hw_param_t var, unsigned int val,
 472                                 int dir)
 473{
 474        int changed;
 475        if (hw_is_mask(var)) {
 476                struct snd_mask *m = hw_param_mask(params, var);
 477                if (val == 0 && dir < 0) {
 478                        changed = -EINVAL;
 479                        snd_mask_none(m);
 480                } else {
 481                        if (dir > 0)
 482                                val++;
 483                        else if (dir < 0)
 484                                val--;
 485                        changed = snd_mask_refine_set(hw_param_mask(params, var), val);
 486                }
 487        } else if (hw_is_interval(var)) {
 488                struct snd_interval *i = hw_param_interval(params, var);
 489                if (val == 0 && dir < 0) {
 490                        changed = -EINVAL;
 491                        snd_interval_none(i);
 492                } else if (dir == 0)
 493                        changed = snd_interval_refine_set(i, val);
 494                else {
 495                        struct snd_interval t;
 496                        t.openmin = 1;
 497                        t.openmax = 1;
 498                        t.empty = 0;
 499                        t.integer = 0;
 500                        if (dir < 0) {
 501                                t.min = val - 1;
 502                                t.max = val;
 503                        } else {
 504                                t.min = val;
 505                                t.max = val+1;
 506                        }
 507                        changed = snd_interval_refine(i, &t);
 508                }
 509        } else
 510                return -EINVAL;
 511        if (changed) {
 512                params->cmask |= 1 << var;
 513                params->rmask |= 1 << var;
 514        }
 515        return changed;
 516}
 517
 518/**
 519 * snd_pcm_hw_param_set
 520 * @pcm: PCM instance
 521 * @params: the hw_params instance
 522 * @var: parameter to retrieve
 523 * @val: value to set
 524 * @dir: pointer to the direction (-1,0,1) or NULL
 525 *
 526 * Inside configuration space defined by PARAMS remove from PAR all 
 527 * values != VAL. Reduce configuration space accordingly.
 528 *  Return VAL or -EINVAL if the configuration space is empty
 529 */
 530static int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm,
 531                                struct snd_pcm_hw_params *params,
 532                                snd_pcm_hw_param_t var, unsigned int val,
 533                                int dir)
 534{
 535        int changed = _snd_pcm_hw_param_set(params, var, val, dir);
 536        if (changed < 0)
 537                return changed;
 538        if (params->rmask) {
 539                int err = snd_pcm_hw_refine(pcm, params);
 540                if (err < 0)
 541                        return err;
 542        }
 543        return snd_pcm_hw_param_value(params, var, NULL);
 544}
 545
 546static int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
 547                                        snd_pcm_hw_param_t var)
 548{
 549        int changed;
 550        changed = snd_interval_setinteger(hw_param_interval(params, var));
 551        if (changed) {
 552                params->cmask |= 1 << var;
 553                params->rmask |= 1 << var;
 554        }
 555        return changed;
 556}
 557        
 558/*
 559 * plugin
 560 */
 561
 562#ifdef CONFIG_SND_PCM_OSS_PLUGINS
 563static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream)
 564{
 565        struct snd_pcm_runtime *runtime = substream->runtime;
 566        struct snd_pcm_plugin *plugin, *next;
 567        
 568        plugin = runtime->oss.plugin_first;
 569        while (plugin) {
 570                next = plugin->next;
 571                snd_pcm_plugin_free(plugin);
 572                plugin = next;
 573        }
 574        runtime->oss.plugin_first = runtime->oss.plugin_last = NULL;
 575        return 0;
 576}
 577
 578static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin)
 579{
 580        struct snd_pcm_runtime *runtime = plugin->plug->runtime;
 581        plugin->next = runtime->oss.plugin_first;
 582        plugin->prev = NULL;
 583        if (runtime->oss.plugin_first) {
 584                runtime->oss.plugin_first->prev = plugin;
 585                runtime->oss.plugin_first = plugin;
 586        } else {
 587                runtime->oss.plugin_last =
 588                runtime->oss.plugin_first = plugin;
 589        }
 590        return 0;
 591}
 592
 593int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin)
 594{
 595        struct snd_pcm_runtime *runtime = plugin->plug->runtime;
 596        plugin->next = NULL;
 597        plugin->prev = runtime->oss.plugin_last;
 598        if (runtime->oss.plugin_last) {
 599                runtime->oss.plugin_last->next = plugin;
 600                runtime->oss.plugin_last = plugin;
 601        } else {
 602                runtime->oss.plugin_last =
 603                runtime->oss.plugin_first = plugin;
 604        }
 605        return 0;
 606}
 607#endif /* CONFIG_SND_PCM_OSS_PLUGINS */
 608
 609static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames)
 610{
 611        struct snd_pcm_runtime *runtime = substream->runtime;
 612        long buffer_size = snd_pcm_lib_buffer_bytes(substream);
 613        long bytes = frames_to_bytes(runtime, frames);
 614        if (buffer_size == runtime->oss.buffer_bytes)
 615                return bytes;
 616#if BITS_PER_LONG >= 64
 617        return runtime->oss.buffer_bytes * bytes / buffer_size;
 618#else
 619        {
 620                u64 bsize = (u64)runtime->oss.buffer_bytes * (u64)bytes;
 621                return div_u64(bsize, buffer_size);
 622        }
 623#endif
 624}
 625
 626static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes)
 627{
 628        struct snd_pcm_runtime *runtime = substream->runtime;
 629        long buffer_size = snd_pcm_lib_buffer_bytes(substream);
 630        if (buffer_size == runtime->oss.buffer_bytes)
 631                return bytes_to_frames(runtime, bytes);
 632        return bytes_to_frames(runtime, (buffer_size * bytes) / runtime->oss.buffer_bytes);
 633}
 634
 635static inline
 636snd_pcm_uframes_t get_hw_ptr_period(struct snd_pcm_runtime *runtime)
 637{
 638        return runtime->hw_ptr_interrupt;
 639}
 640
 641/* define extended formats in the recent OSS versions (if any) */
 642/* linear formats */
 643#define AFMT_S32_LE      0x00001000
 644#define AFMT_S32_BE      0x00002000
 645#define AFMT_S24_LE      0x00008000
 646#define AFMT_S24_BE      0x00010000
 647#define AFMT_S24_PACKED  0x00040000
 648
 649/* other supported formats */
 650#define AFMT_FLOAT       0x00004000
 651#define AFMT_SPDIF_RAW   0x00020000
 652
 653/* unsupported formats */
 654#define AFMT_AC3         0x00000400
 655#define AFMT_VORBIS      0x00000800
 656
 657static int snd_pcm_oss_format_from(int format)
 658{
 659        switch (format) {
 660        case AFMT_MU_LAW:       return SNDRV_PCM_FORMAT_MU_LAW;
 661        case AFMT_A_LAW:        return SNDRV_PCM_FORMAT_A_LAW;
 662        case AFMT_IMA_ADPCM:    return SNDRV_PCM_FORMAT_IMA_ADPCM;
 663        case AFMT_U8:           return SNDRV_PCM_FORMAT_U8;
 664        case AFMT_S16_LE:       return SNDRV_PCM_FORMAT_S16_LE;
 665        case AFMT_S16_BE:       return SNDRV_PCM_FORMAT_S16_BE;
 666        case AFMT_S8:           return SNDRV_PCM_FORMAT_S8;
 667        case AFMT_U16_LE:       return SNDRV_PCM_FORMAT_U16_LE;
 668        case AFMT_U16_BE:       return SNDRV_PCM_FORMAT_U16_BE;
 669        case AFMT_MPEG:         return SNDRV_PCM_FORMAT_MPEG;
 670        case AFMT_S32_LE:       return SNDRV_PCM_FORMAT_S32_LE;
 671        case AFMT_S32_BE:       return SNDRV_PCM_FORMAT_S32_BE;
 672        case AFMT_S24_LE:       return SNDRV_PCM_FORMAT_S24_LE;
 673        case AFMT_S24_BE:       return SNDRV_PCM_FORMAT_S24_BE;
 674        case AFMT_S24_PACKED:   return SNDRV_PCM_FORMAT_S24_3LE;
 675        case AFMT_FLOAT:        return SNDRV_PCM_FORMAT_FLOAT;
 676        case AFMT_SPDIF_RAW:    return SNDRV_PCM_FORMAT_IEC958_SUBFRAME;
 677        default:                return SNDRV_PCM_FORMAT_U8;
 678        }
 679}
 680
 681static int snd_pcm_oss_format_to(int format)
 682{
 683        switch (format) {
 684        case SNDRV_PCM_FORMAT_MU_LAW:   return AFMT_MU_LAW;
 685        case SNDRV_PCM_FORMAT_A_LAW:    return AFMT_A_LAW;
 686        case SNDRV_PCM_FORMAT_IMA_ADPCM:        return AFMT_IMA_ADPCM;
 687        case SNDRV_PCM_FORMAT_U8:               return AFMT_U8;
 688        case SNDRV_PCM_FORMAT_S16_LE:   return AFMT_S16_LE;
 689        case SNDRV_PCM_FORMAT_S16_BE:   return AFMT_S16_BE;
 690        case SNDRV_PCM_FORMAT_S8:               return AFMT_S8;
 691        case SNDRV_PCM_FORMAT_U16_LE:   return AFMT_U16_LE;
 692        case SNDRV_PCM_FORMAT_U16_BE:   return AFMT_U16_BE;
 693        case SNDRV_PCM_FORMAT_MPEG:             return AFMT_MPEG;
 694        case SNDRV_PCM_FORMAT_S32_LE:   return AFMT_S32_LE;
 695        case SNDRV_PCM_FORMAT_S32_BE:   return AFMT_S32_BE;
 696        case SNDRV_PCM_FORMAT_S24_LE:   return AFMT_S24_LE;
 697        case SNDRV_PCM_FORMAT_S24_BE:   return AFMT_S24_BE;
 698        case SNDRV_PCM_FORMAT_S24_3LE:  return AFMT_S24_PACKED;
 699        case SNDRV_PCM_FORMAT_FLOAT:    return AFMT_FLOAT;
 700        case SNDRV_PCM_FORMAT_IEC958_SUBFRAME: return AFMT_SPDIF_RAW;
 701        default:                        return -EINVAL;
 702        }
 703}
 704
 705static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, 
 706                                   struct snd_pcm_hw_params *oss_params,
 707                                   struct snd_pcm_hw_params *slave_params)
 708{
 709        size_t s;
 710        size_t oss_buffer_size, oss_period_size, oss_periods;
 711        size_t min_period_size, max_period_size;
 712        struct snd_pcm_runtime *runtime = substream->runtime;
 713        size_t oss_frame_size;
 714
 715        oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *
 716                         params_channels(oss_params) / 8;
 717
 718        oss_buffer_size = snd_pcm_plug_client_size(substream,
 719                                                   snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL)) * oss_frame_size;
 720        oss_buffer_size = 1 << ld2(oss_buffer_size);
 721        if (atomic_read(&substream->mmap_count)) {
 722                if (oss_buffer_size > runtime->oss.mmap_bytes)
 723                        oss_buffer_size = runtime->oss.mmap_bytes;
 724        }
 725
 726        if (substream->oss.setup.period_size > 16)
 727                oss_period_size = substream->oss.setup.period_size;
 728        else if (runtime->oss.fragshift) {
 729                oss_period_size = 1 << runtime->oss.fragshift;
 730                if (oss_period_size > oss_buffer_size / 2)
 731                        oss_period_size = oss_buffer_size / 2;
 732        } else {
 733                int sd;
 734                size_t bytes_per_sec = params_rate(oss_params) * snd_pcm_format_physical_width(params_format(oss_params)) * params_channels(oss_params) / 8;
 735
 736                oss_period_size = oss_buffer_size;
 737                do {
 738                        oss_period_size /= 2;
 739                } while (oss_period_size > bytes_per_sec);
 740                if (runtime->oss.subdivision == 0) {
 741                        sd = 4;
 742                        if (oss_period_size / sd > 4096)
 743                                sd *= 2;
 744                        if (oss_period_size / sd < 4096)
 745                                sd = 1;
 746                } else
 747                        sd = runtime->oss.subdivision;
 748                oss_period_size /= sd;
 749                if (oss_period_size < 16)
 750                        oss_period_size = 16;
 751        }
 752
 753        min_period_size = snd_pcm_plug_client_size(substream,
 754                                                   snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
 755        min_period_size *= oss_frame_size;
 756        min_period_size = 1 << (ld2(min_period_size - 1) + 1);
 757        if (oss_period_size < min_period_size)
 758                oss_period_size = min_period_size;
 759
 760        max_period_size = snd_pcm_plug_client_size(substream,
 761                                                   snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
 762        max_period_size *= oss_frame_size;
 763        max_period_size = 1 << ld2(max_period_size);
 764        if (oss_period_size > max_period_size)
 765                oss_period_size = max_period_size;
 766
 767        oss_periods = oss_buffer_size / oss_period_size;
 768
 769        if (substream->oss.setup.periods > 1)
 770                oss_periods = substream->oss.setup.periods;
 771
 772        s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
 773        if (runtime->oss.maxfrags && s > runtime->oss.maxfrags)
 774                s = runtime->oss.maxfrags;
 775        if (oss_periods > s)
 776                oss_periods = s;
 777
 778        s = snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
 779        if (s < 2)
 780                s = 2;
 781        if (oss_periods < s)
 782                oss_periods = s;
 783
 784        while (oss_period_size * oss_periods > oss_buffer_size)
 785                oss_period_size /= 2;
 786
 787        if (oss_period_size < 16)
 788                return -EINVAL;
 789        runtime->oss.period_bytes = oss_period_size;
 790        runtime->oss.period_frames = 1;
 791        runtime->oss.periods = oss_periods;
 792        return 0;
 793}
 794
 795static int choose_rate(struct snd_pcm_substream *substream,
 796                       struct snd_pcm_hw_params *params, unsigned int best_rate)
 797{
 798        struct snd_interval *it;
 799        struct snd_pcm_hw_params *save;
 800        unsigned int rate, prev;
 801
 802        save = kmalloc(sizeof(*save), GFP_KERNEL);
 803        if (save == NULL)
 804                return -ENOMEM;
 805        *save = *params;
 806        it = hw_param_interval(save, SNDRV_PCM_HW_PARAM_RATE);
 807
 808        /* try multiples of the best rate */
 809        rate = best_rate;
 810        for (;;) {
 811                if (it->max < rate || (it->max == rate && it->openmax))
 812                        break;
 813                if (it->min < rate || (it->min == rate && !it->openmin)) {
 814                        int ret;
 815                        ret = snd_pcm_hw_param_set(substream, params,
 816                                                   SNDRV_PCM_HW_PARAM_RATE,
 817                                                   rate, 0);
 818                        if (ret == (int)rate) {
 819                                kfree(save);
 820                                return rate;
 821                        }
 822                        *params = *save;
 823                }
 824                prev = rate;
 825                rate += best_rate;
 826                if (rate <= prev)
 827                        break;
 828        }
 829
 830        /* not found, use the nearest rate */
 831        kfree(save);
 832        return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL);
 833}
 834
 835static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
 836{
 837        struct snd_pcm_runtime *runtime = substream->runtime;
 838        struct snd_pcm_hw_params *params, *sparams;
 839        struct snd_pcm_sw_params *sw_params;
 840        ssize_t oss_buffer_size, oss_period_size;
 841        size_t oss_frame_size;
 842        int err;
 843        int direct;
 844        int format, sformat, n;
 845        struct snd_mask sformat_mask;
 846        struct snd_mask mask;
 847
 848        if (mutex_lock_interruptible(&runtime->oss.params_lock))
 849                return -EINTR;
 850        sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL);
 851        params = kmalloc(sizeof(*params), GFP_KERNEL);
 852        sparams = kmalloc(sizeof(*sparams), GFP_KERNEL);
 853        if (!sw_params || !params || !sparams) {
 854                snd_printd("No memory\n");
 855                err = -ENOMEM;
 856                goto failure;
 857        }
 858
 859        if (atomic_read(&substream->mmap_count))
 860                direct = 1;
 861        else
 862                direct = substream->oss.setup.direct;
 863
 864        _snd_pcm_hw_params_any(sparams);
 865        _snd_pcm_hw_param_setinteger(sparams, SNDRV_PCM_HW_PARAM_PERIODS);
 866        _snd_pcm_hw_param_min(sparams, SNDRV_PCM_HW_PARAM_PERIODS, 2, 0);
 867        snd_mask_none(&mask);
 868        if (atomic_read(&substream->mmap_count))
 869                snd_mask_set(&mask, SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
 870        else {
 871                snd_mask_set(&mask, SNDRV_PCM_ACCESS_RW_INTERLEAVED);
 872                if (!direct)
 873                        snd_mask_set(&mask, SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
 874        }
 875        err = snd_pcm_hw_param_mask(substream, sparams, SNDRV_PCM_HW_PARAM_ACCESS, &mask);
 876        if (err < 0) {
 877                snd_printd("No usable accesses\n");
 878                err = -EINVAL;
 879                goto failure;
 880        }
 881        choose_rate(substream, sparams, runtime->oss.rate);
 882        snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_CHANNELS, runtime->oss.channels, NULL);
 883
 884        format = snd_pcm_oss_format_from(runtime->oss.format);
 885
 886        sformat_mask = *hw_param_mask(sparams, SNDRV_PCM_HW_PARAM_FORMAT);
 887        if (direct)
 888                sformat = format;
 889        else
 890                sformat = snd_pcm_plug_slave_format(format, &sformat_mask);
 891
 892        if (sformat < 0 || !snd_mask_test(&sformat_mask, sformat)) {
 893                for (sformat = 0; sformat <= SNDRV_PCM_FORMAT_LAST; sformat++) {
 894                        if (snd_mask_test(&sformat_mask, sformat) &&
 895                            snd_pcm_oss_format_to(sformat) >= 0)
 896                                break;
 897                }
 898                if (sformat > SNDRV_PCM_FORMAT_LAST) {
 899                        snd_printd("Cannot find a format!!!\n");
 900                        err = -EINVAL;
 901                        goto failure;
 902                }
 903        }
 904        err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, sformat, 0);
 905        if (err < 0)
 906                goto failure;
 907
 908        if (direct) {
 909                memcpy(params, sparams, sizeof(*params));
 910        } else {
 911                _snd_pcm_hw_params_any(params);
 912                _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS,
 913                                      SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
 914                _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT,
 915                                      snd_pcm_oss_format_from(runtime->oss.format), 0);
 916                _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS,
 917                                      runtime->oss.channels, 0);
 918                _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE,
 919                                      runtime->oss.rate, 0);
 920                pdprintf("client: access = %i, format = %i, channels = %i, rate = %i\n",
 921                         params_access(params), params_format(params),
 922                         params_channels(params), params_rate(params));
 923        }
 924        pdprintf("slave: access = %i, format = %i, channels = %i, rate = %i\n",
 925                 params_access(sparams), params_format(sparams),
 926                 params_channels(sparams), params_rate(sparams));
 927
 928        oss_frame_size = snd_pcm_format_physical_width(params_format(params)) *
 929                         params_channels(params) / 8;
 930
 931#ifdef CONFIG_SND_PCM_OSS_PLUGINS
 932        snd_pcm_oss_plugin_clear(substream);
 933        if (!direct) {
 934                /* add necessary plugins */
 935                snd_pcm_oss_plugin_clear(substream);
 936                if ((err = snd_pcm_plug_format_plugins(substream,
 937                                                       params, 
 938                                                       sparams)) < 0) {
 939                        snd_printd("snd_pcm_plug_format_plugins failed: %i\n", err);
 940                        snd_pcm_oss_plugin_clear(substream);
 941                        goto failure;
 942                }
 943                if (runtime->oss.plugin_first) {
 944                        struct snd_pcm_plugin *plugin;
 945                        if ((err = snd_pcm_plugin_build_io(substream, sparams, &plugin)) < 0) {
 946                                snd_printd("snd_pcm_plugin_build_io failed: %i\n", err);
 947                                snd_pcm_oss_plugin_clear(substream);
 948                                goto failure;
 949                        }
 950                        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 951                                err = snd_pcm_plugin_append(plugin);
 952                        } else {
 953                                err = snd_pcm_plugin_insert(plugin);
 954                        }
 955                        if (err < 0) {
 956                                snd_pcm_oss_plugin_clear(substream);
 957                                goto failure;
 958                        }
 959                }
 960        }
 961#endif
 962
 963        err = snd_pcm_oss_period_size(substream, params, sparams);
 964        if (err < 0)
 965                goto failure;
 966
 967        n = snd_pcm_plug_slave_size(substream, runtime->oss.period_bytes / oss_frame_size);
 968        err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, n, NULL);
 969        if (err < 0)
 970                goto failure;
 971
 972        err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIODS,
 973                                     runtime->oss.periods, NULL);
 974        if (err < 0)
 975                goto failure;
 976
 977        snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
 978
 979        if ((err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, sparams)) < 0) {
 980                snd_printd("HW_PARAMS failed: %i\n", err);
 981                goto failure;
 982        }
 983
 984        memset(sw_params, 0, sizeof(*sw_params));
 985        if (runtime->oss.trigger) {
 986                sw_params->start_threshold = 1;
 987        } else {
 988                sw_params->start_threshold = runtime->boundary;
 989        }
 990        if (atomic_read(&substream->mmap_count) ||
 991            substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 992                sw_params->stop_threshold = runtime->boundary;
 993        else
 994                sw_params->stop_threshold = runtime->buffer_size;
 995        sw_params->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
 996        sw_params->period_step = 1;
 997        sw_params->avail_min = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
 998                1 : runtime->period_size;
 999        if (atomic_read(&substream->mmap_count) ||
1000            substream->oss.setup.nosilence) {
1001                sw_params->silence_threshold = 0;
1002                sw_params->silence_size = 0;
1003        } else {
1004                snd_pcm_uframes_t frames;
1005                frames = runtime->period_size + 16;
1006                if (frames > runtime->buffer_size)
1007                        frames = runtime->buffer_size;
1008                sw_params->silence_threshold = frames;
1009                sw_params->silence_size = frames;
1010        }
1011
1012        if ((err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_SW_PARAMS, sw_params)) < 0) {
1013                snd_printd("SW_PARAMS failed: %i\n", err);
1014                goto failure;
1015        }
1016
1017        runtime->oss.periods = params_periods(sparams);
1018        oss_period_size = snd_pcm_plug_client_size(substream, params_period_size(sparams));
1019        if (oss_period_size < 0) {
1020                err = -EINVAL;
1021                goto failure;
1022        }
1023#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1024        if (runtime->oss.plugin_first) {
1025                err = snd_pcm_plug_alloc(substream, oss_period_size);
1026                if (err < 0)
1027                        goto failure;
1028        }
1029#endif
1030        oss_period_size *= oss_frame_size;
1031
1032        oss_buffer_size = oss_period_size * runtime->oss.periods;
1033        if (oss_buffer_size < 0) {
1034                err = -EINVAL;
1035                goto failure;
1036        }
1037
1038        runtime->oss.period_bytes = oss_period_size;
1039        runtime->oss.buffer_bytes = oss_buffer_size;
1040
1041        pdprintf("oss: period bytes = %i, buffer bytes = %i\n",
1042                 runtime->oss.period_bytes,
1043                 runtime->oss.buffer_bytes);
1044        pdprintf("slave: period_size = %i, buffer_size = %i\n",
1045                 params_period_size(sparams),
1046                 params_buffer_size(sparams));
1047
1048        runtime->oss.format = snd_pcm_oss_format_to(params_format(params));
1049        runtime->oss.channels = params_channels(params);
1050        runtime->oss.rate = params_rate(params);
1051
1052        vfree(runtime->oss.buffer);
1053        runtime->oss.buffer = vmalloc(runtime->oss.period_bytes);
1054        if (!runtime->oss.buffer) {
1055                err = -ENOMEM;
1056                goto failure;
1057        }
1058
1059        runtime->oss.params = 0;
1060        runtime->oss.prepare = 1;
1061        runtime->oss.buffer_used = 0;
1062        if (runtime->dma_area)
1063                snd_pcm_format_set_silence(runtime->format, runtime->dma_area, bytes_to_samples(runtime, runtime->dma_bytes));
1064
1065        runtime->oss.period_frames = snd_pcm_alsa_frames(substream, oss_period_size);
1066
1067        err = 0;
1068failure:
1069        kfree(sw_params);
1070        kfree(params);
1071        kfree(sparams);
1072        mutex_unlock(&runtime->oss.params_lock);
1073        return err;
1074}
1075
1076static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_file, struct snd_pcm_substream **r_substream)
1077{
1078        int idx, err;
1079        struct snd_pcm_substream *asubstream = NULL, *substream;
1080
1081        for (idx = 0; idx < 2; idx++) {
1082                substream = pcm_oss_file->streams[idx];
1083                if (substream == NULL)
1084                        continue;
1085                if (asubstream == NULL)
1086                        asubstream = substream;
1087                if (substream->runtime->oss.params) {
1088                        err = snd_pcm_oss_change_params(substream);
1089                        if (err < 0)
1090                                return err;
1091                }
1092        }
1093        if (!asubstream)
1094                return -EIO;
1095        if (r_substream)
1096                *r_substream = asubstream;
1097        return 0;
1098}
1099
1100static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream)
1101{
1102        int err;
1103        struct snd_pcm_runtime *runtime = substream->runtime;
1104
1105        err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
1106        if (err < 0) {
1107                snd_printd("snd_pcm_oss_prepare: SNDRV_PCM_IOCTL_PREPARE failed\n");
1108                return err;
1109        }
1110        runtime->oss.prepare = 0;
1111        runtime->oss.prev_hw_ptr_period = 0;
1112        runtime->oss.period_ptr = 0;
1113        runtime->oss.buffer_used = 0;
1114
1115        return 0;
1116}
1117
1118static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream)
1119{
1120        struct snd_pcm_runtime *runtime;
1121        int err;
1122
1123        if (substream == NULL)
1124                return 0;
1125        runtime = substream->runtime;
1126        if (runtime->oss.params) {
1127                err = snd_pcm_oss_change_params(substream);
1128                if (err < 0)
1129                        return err;
1130        }
1131        if (runtime->oss.prepare) {
1132                err = snd_pcm_oss_prepare(substream);
1133                if (err < 0)
1134                        return err;
1135        }
1136        return 0;
1137}
1138
1139static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay)
1140{
1141        struct snd_pcm_runtime *runtime;
1142        snd_pcm_uframes_t frames;
1143        int err = 0;
1144
1145        while (1) {
1146                err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, delay);
1147                if (err < 0)
1148                        break;
1149                runtime = substream->runtime;
1150                if (*delay <= (snd_pcm_sframes_t)runtime->buffer_size)
1151                        break;
1152                /* in case of overrun, skip whole periods like OSS/Linux driver does */
1153                /* until avail(delay) <= buffer_size */
1154                frames = (*delay - runtime->buffer_size) + runtime->period_size - 1;
1155                frames /= runtime->period_size;
1156                frames *= runtime->period_size;
1157                err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_FORWARD, &frames);
1158                if (err < 0)
1159                        break;
1160        }
1161        return err;
1162}
1163
1164snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel)
1165{
1166        struct snd_pcm_runtime *runtime = substream->runtime;
1167        int ret;
1168        while (1) {
1169                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
1170                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1171#ifdef OSS_DEBUG
1172                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
1173                                printk(KERN_DEBUG "pcm_oss: write: "
1174                                       "recovering from XRUN\n");
1175                        else
1176                                printk(KERN_DEBUG "pcm_oss: write: "
1177                                       "recovering from SUSPEND\n");
1178#endif
1179                        ret = snd_pcm_oss_prepare(substream);
1180                        if (ret < 0)
1181                                break;
1182                }
1183                if (in_kernel) {
1184                        mm_segment_t fs;
1185                        fs = snd_enter_user();
1186                        ret = snd_pcm_lib_write(substream, (void __user *)ptr, frames);
1187                        snd_leave_user(fs);
1188                } else {
1189                        ret = snd_pcm_lib_write(substream, (void __user *)ptr, frames);
1190                }
1191                if (ret != -EPIPE && ret != -ESTRPIPE)
1192                        break;
1193                /* test, if we can't store new data, because the stream */
1194                /* has not been started */
1195                if (runtime->status->state == SNDRV_PCM_STATE_PREPARED)
1196                        return -EAGAIN;
1197        }
1198        return ret;
1199}
1200
1201snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel)
1202{
1203        struct snd_pcm_runtime *runtime = substream->runtime;
1204        snd_pcm_sframes_t delay;
1205        int ret;
1206        while (1) {
1207                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
1208                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1209#ifdef OSS_DEBUG
1210                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
1211                                printk(KERN_DEBUG "pcm_oss: read: "
1212                                       "recovering from XRUN\n");
1213                        else
1214                                printk(KERN_DEBUG "pcm_oss: read: "
1215                                       "recovering from SUSPEND\n");
1216#endif
1217                        ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
1218                        if (ret < 0)
1219                                break;
1220                } else if (runtime->status->state == SNDRV_PCM_STATE_SETUP) {
1221                        ret = snd_pcm_oss_prepare(substream);
1222                        if (ret < 0)
1223                                break;
1224                }
1225                ret = snd_pcm_oss_capture_position_fixup(substream, &delay);
1226                if (ret < 0)
1227                        break;
1228                if (in_kernel) {
1229                        mm_segment_t fs;
1230                        fs = snd_enter_user();
1231                        ret = snd_pcm_lib_read(substream, (void __user *)ptr, frames);
1232                        snd_leave_user(fs);
1233                } else {
1234                        ret = snd_pcm_lib_read(substream, (void __user *)ptr, frames);
1235                }
1236                if (ret == -EPIPE) {
1237                        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
1238                                ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1239                                if (ret < 0)
1240                                        break;
1241                        }
1242                        continue;
1243                }
1244                if (ret != -ESTRPIPE)
1245                        break;
1246        }
1247        return ret;
1248}
1249
1250snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
1251{
1252        struct snd_pcm_runtime *runtime = substream->runtime;
1253        int ret;
1254        while (1) {
1255                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
1256                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1257#ifdef OSS_DEBUG
1258                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
1259                                printk(KERN_DEBUG "pcm_oss: writev: "
1260                                       "recovering from XRUN\n");
1261                        else
1262                                printk(KERN_DEBUG "pcm_oss: writev: "
1263                                       "recovering from SUSPEND\n");
1264#endif
1265                        ret = snd_pcm_oss_prepare(substream);
1266                        if (ret < 0)
1267                                break;
1268                }
1269                if (in_kernel) {
1270                        mm_segment_t fs;
1271                        fs = snd_enter_user();
1272                        ret = snd_pcm_lib_writev(substream, (void __user **)bufs, frames);
1273                        snd_leave_user(fs);
1274                } else {
1275                        ret = snd_pcm_lib_writev(substream, (void __user **)bufs, frames);
1276                }
1277                if (ret != -EPIPE && ret != -ESTRPIPE)
1278                        break;
1279
1280                /* test, if we can't store new data, because the stream */
1281                /* has not been started */
1282                if (runtime->status->state == SNDRV_PCM_STATE_PREPARED)
1283                        return -EAGAIN;
1284        }
1285        return ret;
1286}
1287        
1288snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
1289{
1290        struct snd_pcm_runtime *runtime = substream->runtime;
1291        int ret;
1292        while (1) {
1293                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
1294                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1295#ifdef OSS_DEBUG
1296                        if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
1297                                printk(KERN_DEBUG "pcm_oss: readv: "
1298                                       "recovering from XRUN\n");
1299                        else
1300                                printk(KERN_DEBUG "pcm_oss: readv: "
1301                                       "recovering from SUSPEND\n");
1302#endif
1303                        ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
1304                        if (ret < 0)
1305                                break;
1306                } else if (runtime->status->state == SNDRV_PCM_STATE_SETUP) {
1307                        ret = snd_pcm_oss_prepare(substream);
1308                        if (ret < 0)
1309                                break;
1310                }
1311                if (in_kernel) {
1312                        mm_segment_t fs;
1313                        fs = snd_enter_user();
1314                        ret = snd_pcm_lib_readv(substream, (void __user **)bufs, frames);
1315                        snd_leave_user(fs);
1316                } else {
1317                        ret = snd_pcm_lib_readv(substream, (void __user **)bufs, frames);
1318                }
1319                if (ret != -EPIPE && ret != -ESTRPIPE)
1320                        break;
1321        }
1322        return ret;
1323}
1324
1325static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel)
1326{
1327        struct snd_pcm_runtime *runtime = substream->runtime;
1328        snd_pcm_sframes_t frames, frames1;
1329#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1330        if (runtime->oss.plugin_first) {
1331                struct snd_pcm_plugin_channel *channels;
1332                size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8;
1333                if (!in_kernel) {
1334                        if (copy_from_user(runtime->oss.buffer, (const char __user *)buf, bytes))
1335                                return -EFAULT;
1336                        buf = runtime->oss.buffer;
1337                }
1338                frames = bytes / oss_frame_bytes;
1339                frames1 = snd_pcm_plug_client_channels_buf(substream, (char *)buf, frames, &channels);
1340                if (frames1 < 0)
1341                        return frames1;
1342                frames1 = snd_pcm_plug_write_transfer(substream, channels, frames1);
1343                if (frames1 <= 0)
1344                        return frames1;
1345                bytes = frames1 * oss_frame_bytes;
1346        } else
1347#endif
1348        {
1349                frames = bytes_to_frames(runtime, bytes);
1350                frames1 = snd_pcm_oss_write3(substream, buf, frames, in_kernel);
1351                if (frames1 <= 0)
1352                        return frames1;
1353                bytes = frames_to_bytes(runtime, frames1);
1354        }
1355        return bytes;
1356}
1357
1358static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const char __user *buf, size_t bytes)
1359{
1360        size_t xfer = 0;
1361        ssize_t tmp;
1362        struct snd_pcm_runtime *runtime = substream->runtime;
1363
1364        if (atomic_read(&substream->mmap_count))
1365                return -ENXIO;
1366
1367        if ((tmp = snd_pcm_oss_make_ready(substream)) < 0)
1368                return tmp;
1369        mutex_lock(&runtime->oss.params_lock);
1370        while (bytes > 0) {
1371                if (bytes < runtime->oss.period_bytes || runtime->oss.buffer_used > 0) {
1372                        tmp = bytes;
1373                        if (tmp + runtime->oss.buffer_used > runtime->oss.period_bytes)
1374                                tmp = runtime->oss.period_bytes - runtime->oss.buffer_used;
1375                        if (tmp > 0) {
1376                                if (copy_from_user(runtime->oss.buffer + runtime->oss.buffer_used, buf, tmp)) {
1377                                        tmp = -EFAULT;
1378                                        goto err;
1379                                }
1380                        }
1381                        runtime->oss.buffer_used += tmp;
1382                        buf += tmp;
1383                        bytes -= tmp;
1384                        xfer += tmp;
1385                        if (substream->oss.setup.partialfrag ||
1386                            runtime->oss.buffer_used == runtime->oss.period_bytes) {
1387                                tmp = snd_pcm_oss_write2(substream, runtime->oss.buffer + runtime->oss.period_ptr, 
1388                                                         runtime->oss.buffer_used - runtime->oss.period_ptr, 1);
1389                                if (tmp <= 0)
1390                                        goto err;
1391                                runtime->oss.bytes += tmp;
1392                                runtime->oss.period_ptr += tmp;
1393                                runtime->oss.period_ptr %= runtime->oss.period_bytes;
1394                                if (runtime->oss.period_ptr == 0 ||
1395                                    runtime->oss.period_ptr == runtime->oss.buffer_used)
1396                                        runtime->oss.buffer_used = 0;
1397                                else if ((substream->f_flags & O_NONBLOCK) != 0) {
1398                                        tmp = -EAGAIN;
1399                                        goto err;
1400                                }
1401                        }
1402                } else {
1403                        tmp = snd_pcm_oss_write2(substream,
1404                                                 (const char __force *)buf,
1405                                                 runtime->oss.period_bytes, 0);
1406                        if (tmp <= 0)
1407                                goto err;
1408                        runtime->oss.bytes += tmp;
1409                        buf += tmp;
1410                        bytes -= tmp;
1411                        xfer += tmp;
1412                        if ((substream->f_flags & O_NONBLOCK) != 0 &&
1413                            tmp != runtime->oss.period_bytes)
1414                                break;
1415                }
1416        }
1417        mutex_unlock(&runtime->oss.params_lock);
1418        return xfer;
1419
1420 err:
1421        mutex_unlock(&runtime->oss.params_lock);
1422        return xfer > 0 ? (snd_pcm_sframes_t)xfer : tmp;
1423}
1424
1425static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, size_t bytes, int in_kernel)
1426{
1427        struct snd_pcm_runtime *runtime = substream->runtime;
1428        snd_pcm_sframes_t frames, frames1;
1429#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1430        char __user *final_dst = (char __user *)buf;
1431        if (runtime->oss.plugin_first) {
1432                struct snd_pcm_plugin_channel *channels;
1433                size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8;
1434                if (!in_kernel)
1435                        buf = runtime->oss.buffer;
1436                frames = bytes / oss_frame_bytes;
1437                frames1 = snd_pcm_plug_client_channels_buf(substream, buf, frames, &channels);
1438                if (frames1 < 0)
1439                        return frames1;
1440                frames1 = snd_pcm_plug_read_transfer(substream, channels, frames1);
1441                if (frames1 <= 0)
1442                        return frames1;
1443                bytes = frames1 * oss_frame_bytes;
1444                if (!in_kernel && copy_to_user(final_dst, buf, bytes))
1445                        return -EFAULT;
1446        } else
1447#endif
1448        {
1449                frames = bytes_to_frames(runtime, bytes);
1450                frames1 = snd_pcm_oss_read3(substream, buf, frames, in_kernel);
1451                if (frames1 <= 0)
1452                        return frames1;
1453                bytes = frames_to_bytes(runtime, frames1);
1454        }
1455        return bytes;
1456}
1457
1458static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __user *buf, size_t bytes)
1459{
1460        size_t xfer = 0;
1461        ssize_t tmp;
1462        struct snd_pcm_runtime *runtime = substream->runtime;
1463
1464        if (atomic_read(&substream->mmap_count))
1465                return -ENXIO;
1466
1467        if ((tmp = snd_pcm_oss_make_ready(substream)) < 0)
1468                return tmp;
1469        mutex_lock(&runtime->oss.params_lock);
1470        while (bytes > 0) {
1471                if (bytes < runtime->oss.period_bytes || runtime->oss.buffer_used > 0) {
1472                        if (runtime->oss.buffer_used == 0) {
1473                                tmp = snd_pcm_oss_read2(substream, runtime->oss.buffer, runtime->oss.period_bytes, 1);
1474                                if (tmp <= 0)
1475                                        goto err;
1476                                runtime->oss.bytes += tmp;
1477                                runtime->oss.period_ptr = tmp;
1478                                runtime->oss.buffer_used = tmp;
1479                        }
1480                        tmp = bytes;
1481                        if ((size_t) tmp > runtime->oss.buffer_used)
1482                                tmp = runtime->oss.buffer_used;
1483                        if (copy_to_user(buf, runtime->oss.buffer + (runtime->oss.period_ptr - runtime->oss.buffer_used), tmp)) {
1484                                tmp = -EFAULT;
1485                                goto err;
1486                        }
1487                        buf += tmp;
1488                        bytes -= tmp;
1489                        xfer += tmp;
1490                        runtime->oss.buffer_used -= tmp;
1491                } else {
1492                        tmp = snd_pcm_oss_read2(substream, (char __force *)buf,
1493                                                runtime->oss.period_bytes, 0);
1494                        if (tmp <= 0)
1495                                goto err;
1496                        runtime->oss.bytes += tmp;
1497                        buf += tmp;
1498                        bytes -= tmp;
1499                        xfer += tmp;
1500                }
1501        }
1502        mutex_unlock(&runtime->oss.params_lock);
1503        return xfer;
1504
1505 err:
1506        mutex_unlock(&runtime->oss.params_lock);
1507        return xfer > 0 ? (snd_pcm_sframes_t)xfer : tmp;
1508}
1509
1510static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file)
1511{
1512        struct snd_pcm_substream *substream;
1513
1514        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
1515        if (substream != NULL) {
1516                snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1517                substream->runtime->oss.prepare = 1;
1518        }
1519        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
1520        if (substream != NULL) {
1521                snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1522                substream->runtime->oss.prepare = 1;
1523        }
1524        return 0;
1525}
1526
1527static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file)
1528{
1529        struct snd_pcm_substream *substream;
1530        int err;
1531
1532        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
1533        if (substream != NULL) {
1534                if ((err = snd_pcm_oss_make_ready(substream)) < 0)
1535                        return err;
1536                snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_START, NULL);
1537        }
1538        /* note: all errors from the start action are ignored */
1539        /* OSS apps do not know, how to handle them */
1540        return 0;
1541}
1542
1543static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
1544{
1545        struct snd_pcm_runtime *runtime;
1546        ssize_t result = 0;
1547        long res;
1548        wait_queue_t wait;
1549
1550        runtime = substream->runtime;
1551        init_waitqueue_entry(&wait, current);
1552        add_wait_queue(&runtime->sleep, &wait);
1553#ifdef OSS_DEBUG
1554        printk(KERN_DEBUG "sync1: size = %li\n", size);
1555#endif
1556        while (1) {
1557                result = snd_pcm_oss_write2(substream, runtime->oss.buffer, size, 1);
1558                if (result > 0) {
1559                        runtime->oss.buffer_used = 0;
1560                        result = 0;
1561                        break;
1562                }
1563                if (result != 0 && result != -EAGAIN)
1564                        break;
1565                result = 0;
1566                set_current_state(TASK_INTERRUPTIBLE);
1567                snd_pcm_stream_lock_irq(substream);
1568                res = runtime->status->state;
1569                snd_pcm_stream_unlock_irq(substream);
1570                if (res != SNDRV_PCM_STATE_RUNNING) {
1571                        set_current_state(TASK_RUNNING);
1572                        break;
1573                }
1574                res = schedule_timeout(10 * HZ);
1575                if (signal_pending(current)) {
1576                        result = -ERESTARTSYS;
1577                        break;
1578                }
1579                if (res == 0) {
1580                        snd_printk(KERN_ERR "OSS sync error - DMA timeout\n");
1581                        result = -EIO;
1582                        break;
1583                }
1584        }
1585        remove_wait_queue(&runtime->sleep, &wait);
1586        return result;
1587}
1588
1589static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
1590{
1591        int err = 0;
1592        unsigned int saved_f_flags;
1593        struct snd_pcm_substream *substream;
1594        struct snd_pcm_runtime *runtime;
1595        snd_pcm_format_t format;
1596        unsigned long width;
1597        size_t size;
1598
1599        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
1600        if (substream != NULL) {
1601                runtime = substream->runtime;
1602                if (atomic_read(&substream->mmap_count))
1603                        goto __direct;
1604                if ((err = snd_pcm_oss_make_ready(substream)) < 0)
1605                        return err;
1606                format = snd_pcm_oss_format_from(runtime->oss.format);
1607                width = snd_pcm_format_physical_width(format);
1608                mutex_lock(&runtime->oss.params_lock);
1609                if (runtime->oss.buffer_used > 0) {
1610#ifdef OSS_DEBUG
1611                        printk(KERN_DEBUG "sync: buffer_used\n");
1612#endif
1613                        size = (8 * (runtime->oss.period_bytes - runtime->oss.buffer_used) + 7) / width;
1614                        snd_pcm_format_set_silence(format,
1615                                                   runtime->oss.buffer + runtime->oss.buffer_used,
1616                                                   size);
1617                        err = snd_pcm_oss_sync1(substream, runtime->oss.period_bytes);
1618                        if (err < 0) {
1619                                mutex_unlock(&runtime->oss.params_lock);
1620                                return err;
1621                        }
1622                } else if (runtime->oss.period_ptr > 0) {
1623#ifdef OSS_DEBUG
1624                        printk(KERN_DEBUG "sync: period_ptr\n");
1625#endif
1626                        size = runtime->oss.period_bytes - runtime->oss.period_ptr;
1627                        snd_pcm_format_set_silence(format,
1628                                                   runtime->oss.buffer,
1629                                                   size * 8 / width);
1630                        err = snd_pcm_oss_sync1(substream, size);
1631                        if (err < 0) {
1632                                mutex_unlock(&runtime->oss.params_lock);
1633                                return err;
1634                        }
1635                }
1636                /*
1637                 * The ALSA's period might be a bit large than OSS one.
1638                 * Fill the remain portion of ALSA period with zeros.
1639                 */
1640                size = runtime->control->appl_ptr % runtime->period_size;
1641                if (size > 0) {
1642                        size = runtime->period_size - size;
1643                        if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
1644                                size = (runtime->frame_bits * size) / 8;
1645                                while (size > 0) {
1646                                        mm_segment_t fs;
1647                                        size_t size1 = size < runtime->oss.period_bytes ? size : runtime->oss.period_bytes;
1648                                        size -= size1;
1649                                        size1 *= 8;
1650                                        size1 /= runtime->sample_bits;
1651                                        snd_pcm_format_set_silence(runtime->format,
1652                                                                   runtime->oss.buffer,
1653                                                                   size1);
1654                                        size1 /= runtime->channels; /* frames */
1655                                        fs = snd_enter_user();
1656                                        snd_pcm_lib_write(substream, (void __user *)runtime->oss.buffer, size1);
1657                                        snd_leave_user(fs);
1658                                }
1659                        } else if (runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) {
1660                                void __user *buffers[runtime->channels];
1661                                memset(buffers, 0, runtime->channels * sizeof(void *));
1662                                snd_pcm_lib_writev(substream, buffers, size);
1663                        }
1664                }
1665                mutex_unlock(&runtime->oss.params_lock);
1666                /*
1667                 * finish sync: drain the buffer
1668                 */
1669              __direct:
1670                saved_f_flags = substream->f_flags;
1671                substream->f_flags &= ~O_NONBLOCK;
1672                err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
1673                substream->f_flags = saved_f_flags;
1674                if (err < 0)
1675                        return err;
1676                runtime->oss.prepare = 1;
1677        }
1678
1679        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
1680        if (substream != NULL) {
1681                if ((err = snd_pcm_oss_make_ready(substream)) < 0)
1682                        return err;
1683                runtime = substream->runtime;
1684                err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
1685                if (err < 0)
1686                        return err;
1687                runtime->oss.buffer_used = 0;
1688                runtime->oss.prepare = 1;
1689        }
1690        return 0;
1691}
1692
1693static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate)
1694{
1695        int idx;
1696
1697        for (idx = 1; idx >= 0; --idx) {
1698                struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1699                struct snd_pcm_runtime *runtime;
1700                if (substream == NULL)
1701                        continue;
1702                runtime = substream->runtime;
1703                if (rate < 1000)
1704                        rate = 1000;
1705                else if (rate > 192000)
1706                        rate = 192000;
1707                if (runtime->oss.rate != rate) {
1708                        runtime->oss.params = 1;
1709                        runtime->oss.rate = rate;
1710                }
1711        }
1712        return snd_pcm_oss_get_rate(pcm_oss_file);
1713}
1714
1715static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file)
1716{
1717        struct snd_pcm_substream *substream;
1718        int err;
1719        
1720        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
1721                return err;
1722        return substream->runtime->oss.rate;
1723}
1724
1725static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsigned int channels)
1726{
1727        int idx;
1728        if (channels < 1)
1729                channels = 1;
1730        if (channels > 128)
1731                return -EINVAL;
1732        for (idx = 1; idx >= 0; --idx) {
1733                struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1734                struct snd_pcm_runtime *runtime;
1735                if (substream == NULL)
1736                        continue;
1737                runtime = substream->runtime;
1738                if (runtime->oss.channels != channels) {
1739                        runtime->oss.params = 1;
1740                        runtime->oss.channels = channels;
1741                }
1742        }
1743        return snd_pcm_oss_get_channels(pcm_oss_file);
1744}
1745
1746static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file)
1747{
1748        struct snd_pcm_substream *substream;
1749        int err;
1750        
1751        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
1752                return err;
1753        return substream->runtime->oss.channels;
1754}
1755
1756static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file)
1757{
1758        struct snd_pcm_substream *substream;
1759        int err;
1760        
1761        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
1762                return err;
1763        return substream->runtime->oss.period_bytes;
1764}
1765
1766static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
1767{
1768        struct snd_pcm_substream *substream;
1769        int err;
1770        int direct;
1771        struct snd_pcm_hw_params *params;
1772        unsigned int formats = 0;
1773        struct snd_mask format_mask;
1774        int fmt;
1775
1776        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
1777                return err;
1778        if (atomic_read(&substream->mmap_count))
1779                direct = 1;
1780        else
1781                direct = substream->oss.setup.direct;
1782        if (!direct)
1783                return AFMT_MU_LAW | AFMT_U8 |
1784                       AFMT_S16_LE | AFMT_S16_BE |
1785                       AFMT_S8 | AFMT_U16_LE |
1786                       AFMT_U16_BE |
1787                        AFMT_S32_LE | AFMT_S32_BE |
1788                        AFMT_S24_LE | AFMT_S24_BE |
1789                        AFMT_S24_PACKED;
1790        params = kmalloc(sizeof(*params), GFP_KERNEL);
1791        if (!params)
1792                return -ENOMEM;
1793        _snd_pcm_hw_params_any(params);
1794        err = snd_pcm_hw_refine(substream, params);
1795        format_mask = *hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 
1796        kfree(params);
1797        if (err < 0)
1798                return err;
1799        for (fmt = 0; fmt < 32; ++fmt) {
1800                if (snd_mask_test(&format_mask, fmt)) {
1801                        int f = snd_pcm_oss_format_to(fmt);
1802                        if (f >= 0)
1803                                formats |= f;
1804                }
1805        }
1806        return formats;
1807}
1808
1809static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format)
1810{
1811        int formats, idx;
1812        
1813        if (format != AFMT_QUERY) {
1814                formats = snd_pcm_oss_get_formats(pcm_oss_file);
1815                if (formats < 0)
1816                        return formats;
1817                if (!(formats & format))
1818                        format = AFMT_U8;
1819                for (idx = 1; idx >= 0; --idx) {
1820                        struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1821                        struct snd_pcm_runtime *runtime;
1822                        if (substream == NULL)
1823                                continue;
1824                        runtime = substream->runtime;
1825                        if (runtime->oss.format != format) {
1826                                runtime->oss.params = 1;
1827                                runtime->oss.format = format;
1828                        }
1829                }
1830        }
1831        return snd_pcm_oss_get_format(pcm_oss_file);
1832}
1833
1834static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file)
1835{
1836        struct snd_pcm_substream *substream;
1837        int err;
1838        
1839        if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
1840                return err;
1841        return substream->runtime->oss.format;
1842}
1843
1844static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int subdivide)
1845{
1846        struct snd_pcm_runtime *runtime;
1847
1848        if (substream == NULL)
1849                return 0;
1850        runtime = substream->runtime;
1851        if (subdivide == 0) {
1852                subdivide = runtime->oss.subdivision;
1853                if (subdivide == 0)
1854                        subdivide = 1;
1855                return subdivide;
1856        }
1857        if (runtime->oss.subdivision || runtime->oss.fragshift)
1858                return -EINVAL;
1859        if (subdivide != 1 && subdivide != 2 && subdivide != 4 &&
1860            subdivide != 8 && subdivide != 16)
1861                return -EINVAL;
1862        runtime->oss.subdivision = subdivide;
1863        runtime->oss.params = 1;
1864        return subdivide;
1865}
1866
1867static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int subdivide)
1868{
1869        int err = -EINVAL, idx;
1870
1871        for (idx = 1; idx >= 0; --idx) {
1872                struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1873                if (substream == NULL)
1874                        continue;
1875                if ((err = snd_pcm_oss_set_subdivide1(substream, subdivide)) < 0)
1876                        return err;
1877        }
1878        return err;
1879}
1880
1881static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsigned int val)
1882{
1883        struct snd_pcm_runtime *runtime;
1884
1885        if (substream == NULL)
1886                return 0;
1887        runtime = substream->runtime;
1888        if (runtime->oss.subdivision || runtime->oss.fragshift)
1889                return -EINVAL;
1890        runtime->oss.fragshift = val & 0xffff;
1891        runtime->oss.maxfrags = (val >> 16) & 0xffff;
1892        if (runtime->oss.fragshift < 4)         /* < 16 */
1893                runtime->oss.fragshift = 4;
1894        if (runtime->oss.maxfrags < 2)
1895                runtime->oss.maxfrags = 2;
1896        runtime->oss.params = 1;
1897        return 0;
1898}
1899
1900static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsigned int val)
1901{
1902        int err = -EINVAL, idx;
1903
1904        for (idx = 1; idx >= 0; --idx) {
1905                struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1906                if (substream == NULL)
1907                        continue;
1908                if ((err = snd_pcm_oss_set_fragment1(substream, val)) < 0)
1909                        return err;
1910        }
1911        return err;
1912}
1913
1914static int snd_pcm_oss_nonblock(struct file * file)
1915{
1916        spin_lock(&file->f_lock);
1917        file->f_flags |= O_NONBLOCK;
1918        spin_unlock(&file->f_lock);
1919        return 0;
1920}
1921
1922static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res)
1923{
1924
1925        if (substream == NULL) {
1926                res &= ~DSP_CAP_DUPLEX;
1927                return res;
1928        }
1929#ifdef DSP_CAP_MULTI
1930        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1931                if (substream->pstr->substream_count > 1)
1932                        res |= DSP_CAP_MULTI;
1933#endif
1934        /* DSP_CAP_REALTIME is set all times: */
1935        /* all ALSA drivers can return actual pointer in ring buffer */
1936#if defined(DSP_CAP_REALTIME) && 0
1937        {
1938                struct snd_pcm_runtime *runtime = substream->runtime;
1939                if (runtime->info & (SNDRV_PCM_INFO_BLOCK_TRANSFER|SNDRV_PCM_INFO_BATCH))
1940                        res &= ~DSP_CAP_REALTIME;
1941        }
1942#endif
1943        return res;
1944}
1945
1946static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file)
1947{
1948        int result, idx;
1949        
1950        result = DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_DUPLEX | DSP_CAP_REALTIME;
1951        for (idx = 0; idx < 2; idx++) {
1952                struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
1953                result = snd_pcm_oss_get_caps1(substream, result);
1954        }
1955        result |= 0x0001;       /* revision - same as SB AWE 64 */
1956        return result;
1957}
1958
1959static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream,
1960                                      snd_pcm_uframes_t hw_ptr)
1961{
1962        struct snd_pcm_runtime *runtime = substream->runtime;
1963        snd_pcm_uframes_t appl_ptr;
1964        appl_ptr = hw_ptr + runtime->buffer_size;
1965        appl_ptr %= runtime->boundary;
1966        runtime->control->appl_ptr = appl_ptr;
1967}
1968
1969static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int trigger)
1970{
1971        struct snd_pcm_runtime *runtime;
1972        struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
1973        int err, cmd;
1974
1975#ifdef OSS_DEBUG
1976        printk(KERN_DEBUG "pcm_oss: trigger = 0x%x\n", trigger);
1977#endif
1978        
1979        psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
1980        csubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
1981
1982        if (psubstream) {
1983                if ((err = snd_pcm_oss_make_ready(psubstream)) < 0)
1984                        return err;
1985        }
1986        if (csubstream) {
1987                if ((err = snd_pcm_oss_make_ready(csubstream)) < 0)
1988                        return err;
1989        }
1990        if (psubstream) {
1991                runtime = psubstream->runtime;
1992                if (trigger & PCM_ENABLE_OUTPUT) {
1993                        if (runtime->oss.trigger)
1994                                goto _skip1;
1995                        if (atomic_read(&psubstream->mmap_count))
1996                                snd_pcm_oss_simulate_fill(psubstream,
1997                                                get_hw_ptr_period(runtime));
1998                        runtime->oss.trigger = 1;
1999                        runtime->start_threshold = 1;
2000                        cmd = SNDRV_PCM_IOCTL_START;
2001                } else {
2002                        if (!runtime->oss.trigger)
2003                                goto _skip1;
2004                        runtime->oss.trigger = 0;
2005                        runtime->start_threshold = runtime->boundary;
2006                        cmd = SNDRV_PCM_IOCTL_DROP;
2007                        runtime->oss.prepare = 1;
2008                }
2009                err = snd_pcm_kernel_ioctl(psubstream, cmd, NULL);
2010                if (err < 0)
2011                        return err;
2012        }
2013 _skip1:
2014        if (csubstream) {
2015                runtime = csubstream->runtime;
2016                if (trigger & PCM_ENABLE_INPUT) {
2017                        if (runtime->oss.trigger)
2018                                goto _skip2;
2019                        runtime->oss.trigger = 1;
2020                        runtime->start_threshold = 1;
2021                        cmd = SNDRV_PCM_IOCTL_START;
2022                } else {
2023                        if (!runtime->oss.trigger)
2024                                goto _skip2;
2025                        runtime->oss.trigger = 0;
2026                        runtime->start_threshold = runtime->boundary;
2027                        cmd = SNDRV_PCM_IOCTL_DROP;
2028                        runtime->oss.prepare = 1;
2029                }
2030                err = snd_pcm_kernel_ioctl(csubstream, cmd, NULL);
2031                if (err < 0)
2032                        return err;
2033        }
2034 _skip2:
2035        return 0;
2036}
2037
2038static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file)
2039{
2040        struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
2041        int result = 0;
2042
2043        psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2044        csubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2045        if (psubstream && psubstream->runtime && psubstream->runtime->oss.trigger)
2046                result |= PCM_ENABLE_OUTPUT;
2047        if (csubstream && csubstream->runtime && csubstream->runtime->oss.trigger)
2048                result |= PCM_ENABLE_INPUT;
2049        return result;
2050}
2051
2052static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file)
2053{
2054        struct snd_pcm_substream *substream;
2055        struct snd_pcm_runtime *runtime;
2056        snd_pcm_sframes_t delay;
2057        int err;
2058
2059        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2060        if (substream == NULL)
2061                return -EINVAL;
2062        if ((err = snd_pcm_oss_make_ready(substream)) < 0)
2063                return err;
2064        runtime = substream->runtime;
2065        if (runtime->oss.params || runtime->oss.prepare)
2066                return 0;
2067        err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, &delay);
2068        if (err == -EPIPE)
2069                delay = 0;      /* hack for broken OSS applications */
2070        else if (err < 0)
2071                return err;
2072        return snd_pcm_oss_bytes(substream, delay);
2073}
2074
2075static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct count_info __user * _info)
2076{       
2077        struct snd_pcm_substream *substream;
2078        struct snd_pcm_runtime *runtime;
2079        snd_pcm_sframes_t delay;
2080        int fixup;
2081        struct count_info info;
2082        int err;
2083
2084        if (_info == NULL)
2085                return -EFAULT;
2086        substream = pcm_oss_file->streams[stream];
2087        if (substream == NULL)
2088                return -EINVAL;
2089        if ((err = snd_pcm_oss_make_ready(substream)) < 0)
2090                return err;
2091        runtime = substream->runtime;
2092        if (runtime->oss.params || runtime->oss.prepare) {
2093                memset(&info, 0, sizeof(info));
2094                if (copy_to_user(_info, &info, sizeof(info)))
2095                        return -EFAULT;
2096                return 0;
2097        }
2098        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2099                err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, &delay);
2100                if (err == -EPIPE || err == -ESTRPIPE || (! err && delay < 0)) {
2101                        err = 0;
2102                        delay = 0;
2103                        fixup = 0;
2104                } else {
2105                        fixup = runtime->oss.buffer_used;
2106                }
2107        } else {
2108                err = snd_pcm_oss_capture_position_fixup(substream, &delay);
2109                fixup = -runtime->oss.buffer_used;
2110        }
2111        if (err < 0)
2112                return err;
2113        info.ptr = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr % runtime->buffer_size);
2114        if (atomic_read(&substream->mmap_count)) {
2115                snd_pcm_sframes_t n;
2116                delay = get_hw_ptr_period(runtime);
2117                n = delay - runtime->oss.prev_hw_ptr_period;
2118                if (n < 0)
2119                        n += runtime->boundary;
2120                info.blocks = n / runtime->period_size;
2121                runtime->oss.prev_hw_ptr_period = delay;
2122                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2123                        snd_pcm_oss_simulate_fill(substream, delay);
2124                info.bytes = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr) & INT_MAX;
2125        } else {
2126                delay = snd_pcm_oss_bytes(substream, delay);
2127                if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2128                        if (substream->oss.setup.buggyptr)
2129                                info.blocks = (runtime->oss.buffer_bytes - delay - fixup) / runtime->oss.period_bytes;
2130                        else
2131                                info.blocks = (delay + fixup) / runtime->oss.period_bytes;
2132                        info.bytes = (runtime->oss.bytes - delay) & INT_MAX;
2133                } else {
2134                        delay += fixup;
2135                        info.blocks = delay / runtime->oss.period_bytes;
2136                        info.bytes = (runtime->oss.bytes + delay) & INT_MAX;
2137                }
2138        }
2139        if (copy_to_user(_info, &info, sizeof(info)))
2140                return -EFAULT;
2141        return 0;
2142}
2143
2144static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct audio_buf_info __user *_info)
2145{
2146        struct snd_pcm_substream *substream;
2147        struct snd_pcm_runtime *runtime;
2148        snd_pcm_sframes_t avail;
2149        int fixup;
2150        struct audio_buf_info info;
2151        int err;
2152
2153        if (_info == NULL)
2154                return -EFAULT;
2155        substream = pcm_oss_file->streams[stream];
2156        if (substream == NULL)
2157                return -EINVAL;
2158        runtime = substream->runtime;
2159
2160        if (runtime->oss.params &&
2161            (err = snd_pcm_oss_change_params(substream)) < 0)
2162                return err;
2163
2164        info.fragsize = runtime->oss.period_bytes;
2165        info.fragstotal = runtime->periods;
2166        if (runtime->oss.prepare) {
2167                if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2168                        info.bytes = runtime->oss.period_bytes * runtime->oss.periods;
2169                        info.fragments = runtime->oss.periods;
2170                } else {
2171                        info.bytes = 0;
2172                        info.fragments = 0;
2173                }
2174        } else {
2175                if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
2176                        err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DELAY, &avail);
2177                        if (err == -EPIPE || err == -ESTRPIPE || (! err && avail < 0)) {
2178                                avail = runtime->buffer_size;
2179                                err = 0;
2180                                fixup = 0;
2181                        } else {
2182                                avail = runtime->buffer_size - avail;
2183                                fixup = -runtime->oss.buffer_used;
2184                        }
2185                } else {
2186                        err = snd_pcm_oss_capture_position_fixup(substream, &avail);
2187                        fixup = runtime->oss.buffer_used;
2188                }
2189                if (err < 0)
2190                        return err;
2191                info.bytes = snd_pcm_oss_bytes(substream, avail) + fixup;
2192                info.fragments = info.bytes / runtime->oss.period_bytes;
2193        }
2194
2195#ifdef OSS_DEBUG
2196        printk(KERN_DEBUG "pcm_oss: space: bytes = %i, fragments = %i, "
2197               "fragstotal = %i, fragsize = %i\n",
2198               info.bytes, info.fragments, info.fragstotal, info.fragsize);
2199#endif
2200        if (copy_to_user(_info, &info, sizeof(info)))
2201                return -EFAULT;
2202        return 0;
2203}
2204
2205static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info)
2206{
2207        // it won't be probably implemented
2208        // snd_printd("TODO: snd_pcm_oss_get_mapbuf\n");
2209        return -EINVAL;
2210}
2211
2212static const char *strip_task_path(const char *path)
2213{
2214        const char *ptr, *ptrl = NULL;
2215        for (ptr = path; *ptr; ptr++) {
2216                if (*ptr == '/')
2217                        ptrl = ptr + 1;
2218        }
2219        return ptrl;
2220}
2221
2222static void snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, int stream,
2223                                      const char *task_name,
2224                                      struct snd_pcm_oss_setup *rsetup)
2225{
2226        struct snd_pcm_oss_setup *setup;
2227
2228        mutex_lock(&pcm->streams[stream].oss.setup_mutex);
2229        do {
2230                for (setup = pcm->streams[stream].oss.setup_list; setup;
2231                     setup = setup->next) {
2232                        if (!strcmp(setup->task_name, task_name))
2233                                goto out;
2234                }
2235        } while ((task_name = strip_task_path(task_name)) != NULL);
2236 out:
2237        if (setup)
2238                *rsetup = *setup;
2239        mutex_unlock(&pcm->streams[stream].oss.setup_mutex);
2240}
2241
2242static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream)
2243{
2244        struct snd_pcm_runtime *runtime;
2245        runtime = substream->runtime;
2246        vfree(runtime->oss.buffer);
2247        runtime->oss.buffer = NULL;
2248#ifdef CONFIG_SND_PCM_OSS_PLUGINS
2249        snd_pcm_oss_plugin_clear(substream);
2250#endif
2251        substream->oss.oss = 0;
2252}
2253
2254static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
2255                                       struct snd_pcm_oss_setup *setup,
2256                                       int minor)
2257{
2258        struct snd_pcm_runtime *runtime;
2259
2260        substream->oss.oss = 1;
2261        substream->oss.setup = *setup;
2262        if (setup->nonblock)
2263                substream->f_flags |= O_NONBLOCK;
2264        else if (setup->block)
2265                substream->f_flags &= ~O_NONBLOCK;
2266        runtime = substream->runtime;
2267        runtime->oss.params = 1;
2268        runtime->oss.trigger = 1;
2269        runtime->oss.rate = 8000;
2270        mutex_init(&runtime->oss.params_lock);
2271        switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
2272        case SNDRV_MINOR_OSS_PCM_8:
2273                runtime->oss.format = AFMT_U8;
2274                break;
2275        case SNDRV_MINOR_OSS_PCM_16:
2276                runtime->oss.format = AFMT_S16_LE;
2277                break;
2278        default:
2279                runtime->oss.format = AFMT_MU_LAW;
2280        }
2281        runtime->oss.channels = 1;
2282        runtime->oss.fragshift = 0;
2283        runtime->oss.maxfrags = 0;
2284        runtime->oss.subdivision = 0;
2285        substream->pcm_release = snd_pcm_oss_release_substream;
2286}
2287
2288static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file)
2289{
2290        int cidx;
2291        if (!pcm_oss_file)
2292                return 0;
2293        for (cidx = 0; cidx < 2; ++cidx) {
2294                struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx];
2295                if (substream)
2296                        snd_pcm_release_substream(substream);
2297        }
2298        kfree(pcm_oss_file);
2299        return 0;
2300}
2301
2302static int snd_pcm_oss_open_file(struct file *file,
2303                                 struct snd_pcm *pcm,
2304                                 struct snd_pcm_oss_file **rpcm_oss_file,
2305                                 int minor,
2306                                 struct snd_pcm_oss_setup *setup)
2307{
2308        int idx, err;
2309        struct snd_pcm_oss_file *pcm_oss_file;
2310        struct snd_pcm_substream *substream;
2311        fmode_t f_mode = file->f_mode;
2312
2313        if (rpcm_oss_file)
2314                *rpcm_oss_file = NULL;
2315
2316        pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL);
2317        if (pcm_oss_file == NULL)
2318                return -ENOMEM;
2319
2320        if ((f_mode & (FMODE_WRITE|FMODE_READ)) == (FMODE_WRITE|FMODE_READ) &&
2321            (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX))
2322                f_mode = FMODE_WRITE;
2323
2324        file->f_flags &= ~O_APPEND;
2325        for (idx = 0; idx < 2; idx++) {
2326                if (setup[idx].disable)
2327                        continue;
2328                if (! pcm->streams[idx].substream_count)
2329                        continue; /* no matching substream */
2330                if (idx == SNDRV_PCM_STREAM_PLAYBACK) {
2331                        if (! (f_mode & FMODE_WRITE))
2332                                continue;
2333                } else {
2334                        if (! (f_mode & FMODE_READ))
2335                                continue;
2336                }
2337                err = snd_pcm_open_substream(pcm, idx, file, &substream);
2338                if (err < 0) {
2339                        snd_pcm_oss_release_file(pcm_oss_file);
2340                        return err;
2341                }
2342
2343                pcm_oss_file->streams[idx] = substream;
2344                substream->file = pcm_oss_file;
2345                snd_pcm_oss_init_substream(substream, &setup[idx], minor);
2346        }
2347        
2348        if (!pcm_oss_file->streams[0] && !pcm_oss_file->streams[1]) {
2349                snd_pcm_oss_release_file(pcm_oss_file);
2350                return -EINVAL;
2351        }
2352
2353        file->private_data = pcm_oss_file;
2354        if (rpcm_oss_file)
2355                *rpcm_oss_file = pcm_oss_file;
2356        return 0;
2357}
2358
2359
2360static int snd_task_name(struct task_struct *task, char *name, size_t size)
2361{
2362        unsigned int idx;
2363
2364        if (snd_BUG_ON(!task || !name || size < 2))
2365                return -EINVAL;
2366        for (idx = 0; idx < sizeof(task->comm) && idx + 1 < size; idx++)
2367                name[idx] = task->comm[idx];
2368        name[idx] = '\0';
2369        return 0;
2370}
2371
2372static int snd_pcm_oss_open(struct inode *inode, struct file *file)
2373{
2374        int err;
2375        char task_name[32];
2376        struct snd_pcm *pcm;
2377        struct snd_pcm_oss_file *pcm_oss_file;
2378        struct snd_pcm_oss_setup setup[2];
2379        int nonblock;
2380        wait_queue_t wait;
2381
2382        err = nonseekable_open(inode, file);
2383        if (err < 0)
2384                return err;
2385
2386        pcm = snd_lookup_oss_minor_data(iminor(inode),
2387                                        SNDRV_OSS_DEVICE_TYPE_PCM);
2388        if (pcm == NULL) {
2389                err = -ENODEV;
2390                goto __error1;
2391        }
2392        err = snd_card_file_add(pcm->card, file);
2393        if (err < 0)
2394                goto __error1;
2395        if (!try_module_get(pcm->card->module)) {
2396                err = -EFAULT;
2397                goto __error2;
2398        }
2399        if (snd_task_name(current, task_name, sizeof(task_name)) < 0) {
2400                err = -EFAULT;
2401                goto __error;
2402        }
2403        memset(setup, 0, sizeof(setup));
2404        if (file->f_mode & FMODE_WRITE)
2405                snd_pcm_oss_look_for_setup(pcm, SNDRV_PCM_STREAM_PLAYBACK,
2406                                           task_name, &setup[0]);
2407        if (file->f_mode & FMODE_READ)
2408                snd_pcm_oss_look_for_setup(pcm, SNDRV_PCM_STREAM_CAPTURE,
2409                                           task_name, &setup[1]);
2410
2411        nonblock = !!(file->f_flags & O_NONBLOCK);
2412        if (!nonblock)
2413                nonblock = nonblock_open;
2414
2415        init_waitqueue_entry(&wait, current);
2416        add_wait_queue(&pcm->open_wait, &wait);
2417        mutex_lock(&pcm->open_mutex);
2418        while (1) {
2419                err = snd_pcm_oss_open_file(file, pcm, &pcm_oss_file,
2420                                            iminor(inode), setup);
2421                if (err >= 0)
2422                        break;
2423                if (err == -EAGAIN) {
2424                        if (nonblock) {
2425                                err = -EBUSY;
2426                                break;
2427                        }
2428                } else
2429                        break;
2430                set_current_state(TASK_INTERRUPTIBLE);
2431                mutex_unlock(&pcm->open_mutex);
2432                schedule();
2433                mutex_lock(&pcm->open_mutex);
2434                if (signal_pending(current)) {
2435                        err = -ERESTARTSYS;
2436                        break;
2437                }
2438        }
2439        remove_wait_queue(&pcm->open_wait, &wait);
2440        mutex_unlock(&pcm->open_mutex);
2441        if (err < 0)
2442                goto __error;
2443        return err;
2444
2445      __error:
2446        module_put(pcm->card->module);
2447      __error2:
2448        snd_card_file_remove(pcm->card, file);
2449      __error1:
2450        return err;
2451}
2452
2453static int snd_pcm_oss_release(struct inode *inode, struct file *file)
2454{
2455        struct snd_pcm *pcm;
2456        struct snd_pcm_substream *substream;
2457        struct snd_pcm_oss_file *pcm_oss_file;
2458
2459        pcm_oss_file = file->private_data;
2460        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2461        if (substream == NULL)
2462                substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2463        if (snd_BUG_ON(!substream))
2464                return -ENXIO;
2465        pcm = substream->pcm;
2466        if (!pcm->card->shutdown)
2467                snd_pcm_oss_sync(pcm_oss_file);
2468        mutex_lock(&pcm->open_mutex);
2469        snd_pcm_oss_release_file(pcm_oss_file);
2470        mutex_unlock(&pcm->open_mutex);
2471        wake_up(&pcm->open_wait);
2472        module_put(pcm->card->module);
2473        snd_card_file_remove(pcm->card, file);
2474        return 0;
2475}
2476
2477static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2478{
2479        struct snd_pcm_oss_file *pcm_oss_file;
2480        int __user *p = (int __user *)arg;
2481        int res;
2482
2483        pcm_oss_file = file->private_data;
2484        if (cmd == OSS_GETVERSION)
2485                return put_user(SNDRV_OSS_VERSION, p);
2486        if (cmd == OSS_ALSAEMULVER)
2487                return put_user(1, p);
2488#if defined(CONFIG_SND_MIXER_OSS) || (defined(MODULE) && defined(CONFIG_SND_MIXER_OSS_MODULE))
2489        if (((cmd >> 8) & 0xff) == 'M') {       /* mixer ioctl - for OSS compatibility */
2490                struct snd_pcm_substream *substream;
2491                int idx;
2492                for (idx = 0; idx < 2; ++idx) {
2493                        substream = pcm_oss_file->streams[idx];
2494                        if (substream != NULL)
2495                                break;
2496                }
2497                if (snd_BUG_ON(idx >= 2))
2498                        return -ENXIO;
2499                return snd_mixer_oss_ioctl_card(substream->pcm->card, cmd, arg);
2500        }
2501#endif
2502        if (((cmd >> 8) & 0xff) != 'P')
2503                return -EINVAL;
2504#ifdef OSS_DEBUG
2505        printk(KERN_DEBUG "pcm_oss: ioctl = 0x%x\n", cmd);
2506#endif
2507        switch (cmd) {
2508        case SNDCTL_DSP_RESET:
2509                return snd_pcm_oss_reset(pcm_oss_file);
2510        case SNDCTL_DSP_SYNC:
2511                return snd_pcm_oss_sync(pcm_oss_file);
2512        case SNDCTL_DSP_SPEED:
2513                if (get_user(res, p))
2514                        return -EFAULT;
2515                if ((res = snd_pcm_oss_set_rate(pcm_oss_file, res))<0)
2516                        return res;
2517                return put_user(res, p);
2518        case SOUND_PCM_READ_RATE:
2519                res = snd_pcm_oss_get_rate(pcm_oss_file);
2520                if (res < 0)
2521                        return res;
2522                return put_user(res, p);
2523        case SNDCTL_DSP_STEREO:
2524                if (get_user(res, p))
2525                        return -EFAULT;
2526                res = res > 0 ? 2 : 1;
2527                if ((res = snd_pcm_oss_set_channels(pcm_oss_file, res)) < 0)
2528                        return res;
2529                return put_user(--res, p);
2530        case SNDCTL_DSP_GETBLKSIZE:
2531                res = snd_pcm_oss_get_block_size(pcm_oss_file);
2532                if (res < 0)
2533                        return res;
2534                return put_user(res, p);
2535        case SNDCTL_DSP_SETFMT:
2536                if (get_user(res, p))
2537                        return -EFAULT;
2538                res = snd_pcm_oss_set_format(pcm_oss_file, res);
2539                if (res < 0)
2540                        return res;
2541                return put_user(res, p);
2542        case SOUND_PCM_READ_BITS:
2543                res = snd_pcm_oss_get_format(pcm_oss_file);
2544                if (res < 0)
2545                        return res;
2546                return put_user(res, p);
2547        case SNDCTL_DSP_CHANNELS:
2548                if (get_user(res, p))
2549                        return -EFAULT;
2550                res = snd_pcm_oss_set_channels(pcm_oss_file, res);
2551                if (res < 0)
2552                        return res;
2553                return put_user(res, p);
2554        case SOUND_PCM_READ_CHANNELS:
2555                res = snd_pcm_oss_get_channels(pcm_oss_file);
2556                if (res < 0)
2557                        return res;
2558                return put_user(res, p);
2559        case SOUND_PCM_WRITE_FILTER:
2560        case SOUND_PCM_READ_FILTER:
2561                return -EIO;
2562        case SNDCTL_DSP_POST:
2563                return snd_pcm_oss_post(pcm_oss_file);
2564        case SNDCTL_DSP_SUBDIVIDE:
2565                if (get_user(res, p))
2566                        return -EFAULT;
2567                res = snd_pcm_oss_set_subdivide(pcm_oss_file, res);
2568                if (res < 0)
2569                        return res;
2570                return put_user(res, p);
2571        case SNDCTL_DSP_SETFRAGMENT:
2572                if (get_user(res, p))
2573                        return -EFAULT;
2574                return snd_pcm_oss_set_fragment(pcm_oss_file, res);
2575        case SNDCTL_DSP_GETFMTS:
2576                res = snd_pcm_oss_get_formats(pcm_oss_file);
2577                if (res < 0)
2578                        return res;
2579                return put_user(res, p);
2580        case SNDCTL_DSP_GETOSPACE:
2581        case SNDCTL_DSP_GETISPACE:
2582                return snd_pcm_oss_get_space(pcm_oss_file,
2583                        cmd == SNDCTL_DSP_GETISPACE ?
2584                                SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK,
2585                        (struct audio_buf_info __user *) arg);
2586        case SNDCTL_DSP_NONBLOCK:
2587                return snd_pcm_oss_nonblock(file);
2588        case SNDCTL_DSP_GETCAPS:
2589                res = snd_pcm_oss_get_caps(pcm_oss_file);
2590                if (res < 0)
2591                        return res;
2592                return put_user(res, p);
2593        case SNDCTL_DSP_GETTRIGGER:
2594                res = snd_pcm_oss_get_trigger(pcm_oss_file);
2595                if (res < 0)
2596                        return res;
2597                return put_user(res, p);
2598        case SNDCTL_DSP_SETTRIGGER:
2599                if (get_user(res, p))
2600                        return -EFAULT;
2601                return snd_pcm_oss_set_trigger(pcm_oss_file, res);
2602        case SNDCTL_DSP_GETIPTR:
2603        case SNDCTL_DSP_GETOPTR:
2604                return snd_pcm_oss_get_ptr(pcm_oss_file,
2605                        cmd == SNDCTL_DSP_GETIPTR ?
2606                                SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK,
2607                        (struct count_info __user *) arg);
2608        case SNDCTL_DSP_MAPINBUF:
2609        case SNDCTL_DSP_MAPOUTBUF:
2610                return snd_pcm_oss_get_mapbuf(pcm_oss_file,
2611                        cmd == SNDCTL_DSP_MAPINBUF ?
2612                                SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK,
2613                        (struct buffmem_desc __user *) arg);
2614        case SNDCTL_DSP_SETSYNCRO:
2615                /* stop DMA now.. */
2616                return 0;
2617        case SNDCTL_DSP_SETDUPLEX:
2618                if (snd_pcm_oss_get_caps(pcm_oss_file) & DSP_CAP_DUPLEX)
2619                        return 0;
2620                return -EIO;
2621        case SNDCTL_DSP_GETODELAY:
2622                res = snd_pcm_oss_get_odelay(pcm_oss_file);
2623                if (res < 0) {
2624                        /* it's for sure, some broken apps don't check for error codes */
2625                        put_user(0, p);
2626                        return res;
2627                }
2628                return put_user(res, p);
2629        case SNDCTL_DSP_PROFILE:
2630                return 0;       /* silently ignore */
2631        default:
2632                snd_printd("pcm_oss: unknown command = 0x%x\n", cmd);
2633        }
2634        return -EINVAL;
2635}
2636
2637#ifdef CONFIG_COMPAT
2638/* all compatible */
2639#define snd_pcm_oss_ioctl_compat        snd_pcm_oss_ioctl
2640#else
2641#define snd_pcm_oss_ioctl_compat        NULL
2642#endif
2643
2644static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
2645{
2646        struct snd_pcm_oss_file *pcm_oss_file;
2647        struct snd_pcm_substream *substream;
2648
2649        pcm_oss_file = file->private_data;
2650        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2651        if (substream == NULL)
2652                return -ENXIO;
2653        substream->f_flags = file->f_flags & O_NONBLOCK;
2654#ifndef OSS_DEBUG
2655        return snd_pcm_oss_read1(substream, buf, count);
2656#else
2657        {
2658                ssize_t res = snd_pcm_oss_read1(substream, buf, count);
2659                printk(KERN_DEBUG "pcm_oss: read %li bytes "
2660                       "(returned %li bytes)\n", (long)count, (long)res);
2661                return res;
2662        }
2663#endif
2664}
2665
2666static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
2667{
2668        struct snd_pcm_oss_file *pcm_oss_file;
2669        struct snd_pcm_substream *substream;
2670        long result;
2671
2672        pcm_oss_file = file->private_data;
2673        substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2674        if (substream == NULL)
2675                return -ENXIO;
2676        substream->f_flags = file->f_flags & O_NONBLOCK;
2677        result = snd_pcm_oss_write1(substream, buf, count);
2678#ifdef OSS_DEBUG
2679        printk(KERN_DEBUG "pcm_oss: write %li bytes (wrote %li bytes)\n",
2680               (long)count, (long)result);
2681#endif
2682        return result;
2683}
2684
2685static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream)
2686{
2687        struct snd_pcm_runtime *runtime = substream->runtime;
2688        if (atomic_read(&substream->mmap_count))
2689                return runtime->oss.prev_hw_ptr_period !=
2690                                                get_hw_ptr_period(runtime);
2691        else
2692                return snd_pcm_playback_avail(runtime) >=
2693                                                runtime->oss.period_frames;
2694}
2695
2696static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream)
2697{
2698        struct snd_pcm_runtime *runtime = substream->runtime;
2699        if (atomic_read(&substream->mmap_count))
2700                return runtime->oss.prev_hw_ptr_period !=
2701                                                get_hw_ptr_period(runtime);
2702        else
2703                return snd_pcm_capture_avail(runtime) >=
2704                                                runtime->oss.period_frames;
2705}
2706
2707static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
2708{
2709        struct snd_pcm_oss_file *pcm_oss_file;
2710        unsigned int mask;
2711        struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL;
2712        
2713        pcm_oss_file = file->private_data;
2714
2715        psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2716        csubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2717
2718        mask = 0;
2719        if (psubstream != NULL) {
2720                struct snd_pcm_runtime *runtime = psubstream->runtime;
2721                poll_wait(file, &runtime->sleep, wait);
2722                snd_pcm_stream_lock_irq(psubstream);
2723                if (runtime->status->state != SNDRV_PCM_STATE_DRAINING &&
2724                    (runtime->status->state != SNDRV_PCM_STATE_RUNNING ||
2725                     snd_pcm_oss_playback_ready(psubstream)))
2726                        mask |= POLLOUT | POLLWRNORM;
2727                snd_pcm_stream_unlock_irq(psubstream);
2728        }
2729        if (csubstream != NULL) {
2730                struct snd_pcm_runtime *runtime = csubstream->runtime;
2731                snd_pcm_state_t ostate;
2732                poll_wait(file, &runtime->sleep, wait);
2733                snd_pcm_stream_lock_irq(csubstream);
2734                if ((ostate = runtime->status->state) != SNDRV_PCM_STATE_RUNNING ||
2735                    snd_pcm_oss_capture_ready(csubstream))
2736                        mask |= POLLIN | POLLRDNORM;
2737                snd_pcm_stream_unlock_irq(csubstream);
2738                if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) {
2739                        struct snd_pcm_oss_file ofile;
2740                        memset(&ofile, 0, sizeof(ofile));
2741                        ofile.streams[SNDRV_PCM_STREAM_CAPTURE] = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2742                        runtime->oss.trigger = 0;
2743                        snd_pcm_oss_set_trigger(&ofile, PCM_ENABLE_INPUT);
2744                }
2745        }
2746
2747        return mask;
2748}
2749
2750static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
2751{
2752        struct snd_pcm_oss_file *pcm_oss_file;
2753        struct snd_pcm_substream *substream = NULL;
2754        struct snd_pcm_runtime *runtime;
2755        int err;
2756
2757#ifdef OSS_DEBUG
2758        printk(KERN_DEBUG "pcm_oss: mmap begin\n");
2759#endif
2760        pcm_oss_file = file->private_data;
2761        switch ((area->vm_flags & (VM_READ | VM_WRITE))) {
2762        case VM_READ | VM_WRITE:
2763                substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2764                if (substream)
2765                        break;
2766                /* Fall through */
2767        case VM_READ:
2768                substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2769                break;
2770        case VM_WRITE:
2771                substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2772                break;
2773        default:
2774                return -EINVAL;
2775        }
2776        /* set VM_READ access as well to fix memset() routines that do
2777           reads before writes (to improve performance) */
2778        area->vm_flags |= VM_READ;
2779        if (substream == NULL)
2780                return -ENXIO;
2781        runtime = substream->runtime;
2782        if (!(runtime->info & SNDRV_PCM_INFO_MMAP_VALID))
2783                return -EIO;
2784        if (runtime->info & SNDRV_PCM_INFO_INTERLEAVED)
2785                runtime->access = SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
2786        else
2787                return -EIO;
2788        
2789        if (runtime->oss.params) {
2790                if ((err = snd_pcm_oss_change_params(substream)) < 0)
2791                        return err;
2792        }
2793#ifdef CONFIG_SND_PCM_OSS_PLUGINS
2794        if (runtime->oss.plugin_first != NULL)
2795                return -EIO;
2796#endif
2797
2798        if (area->vm_pgoff != 0)
2799                return -EINVAL;
2800
2801        err = snd_pcm_mmap_data(substream, file, area);
2802        if (err < 0)
2803                return err;
2804        runtime->oss.mmap_bytes = area->vm_end - area->vm_start;
2805        runtime->silence_threshold = 0;
2806        runtime->silence_size = 0;
2807#ifdef OSS_DEBUG
2808        printk(KERN_DEBUG "pcm_oss: mmap ok, bytes = 0x%x\n",
2809               runtime->oss.mmap_bytes);
2810#endif
2811        /* In mmap mode we never stop */
2812        runtime->stop_threshold = runtime->boundary;
2813
2814        return 0;
2815}
2816
2817#ifdef CONFIG_SND_VERBOSE_PROCFS
2818/*
2819 *  /proc interface
2820 */
2821
2822static void snd_pcm_oss_proc_read(struct snd_info_entry *entry,
2823                                  struct snd_info_buffer *buffer)
2824{
2825        struct snd_pcm_str *pstr = entry->private_data;
2826        struct snd_pcm_oss_setup *setup = pstr->oss.setup_list;
2827        mutex_lock(&pstr->oss.setup_mutex);
2828        while (setup) {
2829                snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n",
2830                            setup->task_name,
2831                            setup->periods,
2832                            setup->period_size,
2833                            setup->disable ? " disable" : "",
2834                            setup->direct ? " direct" : "",
2835                            setup->block ? " block" : "",
2836                            setup->nonblock ? " non-block" : "",
2837                            setup->partialfrag ? " partial-frag" : "",
2838                            setup->nosilence ? " no-silence" : "");
2839                setup = setup->next;
2840        }
2841        mutex_unlock(&pstr->oss.setup_mutex);
2842}
2843
2844static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr)
2845{
2846        struct snd_pcm_oss_setup *setup, *setupn;
2847
2848        for (setup = pstr->oss.setup_list, pstr->oss.setup_list = NULL;
2849             setup; setup = setupn) {
2850                setupn = setup->next;
2851                kfree(setup->task_name);
2852                kfree(setup);
2853        }
2854        pstr->oss.setup_list = NULL;
2855}
2856
2857static void snd_pcm_oss_proc_write(struct snd_info_entry *entry,
2858                                   struct snd_info_buffer *buffer)
2859{
2860        struct snd_pcm_str *pstr = entry->private_data;
2861        char line[128], str[32], task_name[32];
2862        const char *ptr;
2863        int idx1;
2864        struct snd_pcm_oss_setup *setup, *setup1, template;
2865
2866        while (!snd_info_get_line(buffer, line, sizeof(line))) {
2867                mutex_lock(&pstr->oss.setup_mutex);
2868                memset(&template, 0, sizeof(template));
2869                ptr = snd_info_get_str(task_name, line, sizeof(task_name));
2870                if (!strcmp(task_name, "clear") || !strcmp(task_name, "erase")) {
2871                        snd_pcm_oss_proc_free_setup_list(pstr);
2872                        mutex_unlock(&pstr->oss.setup_mutex);
2873                        continue;
2874                }
2875                for (setup = pstr->oss.setup_list; setup; setup = setup->next) {
2876                        if (!strcmp(setup->task_name, task_name)) {
2877                                template = *setup;
2878                                break;
2879                        }
2880                }
2881                ptr = snd_info_get_str(str, ptr, sizeof(str));
2882                template.periods = simple_strtoul(str, NULL, 10);
2883                ptr = snd_info_get_str(str, ptr, sizeof(str));
2884                template.period_size = simple_strtoul(str, NULL, 10);
2885                for (idx1 = 31; idx1 >= 0; idx1--)
2886                        if (template.period_size & (1 << idx1))
2887                                break;
2888                for (idx1--; idx1 >= 0; idx1--)
2889                        template.period_size &= ~(1 << idx1);
2890                do {
2891                        ptr = snd_info_get_str(str, ptr, sizeof(str));
2892                        if (!strcmp(str, "disable")) {
2893                                template.disable = 1;
2894                        } else if (!strcmp(str, "direct")) {
2895                                template.direct = 1;
2896                        } else if (!strcmp(str, "block")) {
2897                                template.block = 1;
2898                        } else if (!strcmp(str, "non-block")) {
2899                                template.nonblock = 1;
2900                        } else if (!strcmp(str, "partial-frag")) {
2901                                template.partialfrag = 1;
2902                        } else if (!strcmp(str, "no-silence")) {
2903                                template.nosilence = 1;
2904                        } else if (!strcmp(str, "buggy-ptr")) {
2905                                template.buggyptr = 1;
2906                        }
2907                } while (*str);
2908                if (setup == NULL) {
2909                        setup = kmalloc(sizeof(*setup), GFP_KERNEL);
2910                        if (! setup) {
2911                                buffer->error = -ENOMEM;
2912                                mutex_unlock(&pstr->oss.setup_mutex);
2913                                return;
2914                        }
2915                        if (pstr->oss.setup_list == NULL)
2916                                pstr->oss.setup_list = setup;
2917                        else {
2918                                for (setup1 = pstr->oss.setup_list;
2919                                     setup1->next; setup1 = setup1->next);
2920                                setup1->next = setup;
2921                        }
2922                        template.task_name = kstrdup(task_name, GFP_KERNEL);
2923                        if (! template.task_name) {
2924                                kfree(setup);
2925                                buffer->error = -ENOMEM;
2926                                mutex_unlock(&pstr->oss.setup_mutex);
2927                                return;
2928                        }
2929                }
2930                *setup = template;
2931                mutex_unlock(&pstr->oss.setup_mutex);
2932        }
2933}
2934
2935static void snd_pcm_oss_proc_init(struct snd_pcm *pcm)
2936{
2937        int stream;
2938        for (stream = 0; stream < 2; ++stream) {
2939                struct snd_info_entry *entry;
2940                struct snd_pcm_str *pstr = &pcm->streams[stream];
2941                if (pstr->substream_count == 0)
2942                        continue;
2943                if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) {
2944                        entry->content = SNDRV_INFO_CONTENT_TEXT;
2945                        entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
2946                        entry->c.text.read = snd_pcm_oss_proc_read;
2947                        entry->c.text.write = snd_pcm_oss_proc_write;
2948                        entry->private_data = pstr;
2949                        if (snd_info_register(entry) < 0) {
2950                                snd_info_free_entry(entry);
2951                                entry = NULL;
2952                        }
2953                }
2954                pstr->oss.proc_entry = entry;
2955        }
2956}
2957
2958static void snd_pcm_oss_proc_done(struct snd_pcm *pcm)
2959{
2960        int stream;
2961        for (stream = 0; stream < 2; ++stream) {
2962                struct snd_pcm_str *pstr = &pcm->streams[stream];
2963                snd_info_free_entry(pstr->oss.proc_entry);
2964                pstr->oss.proc_entry = NULL;
2965                snd_pcm_oss_proc_free_setup_list(pstr);
2966        }
2967}
2968#else /* !CONFIG_SND_VERBOSE_PROCFS */
2969#define snd_pcm_oss_proc_init(pcm)
2970#define snd_pcm_oss_proc_done(pcm)
2971#endif /* CONFIG_SND_VERBOSE_PROCFS */
2972
2973/*
2974 *  ENTRY functions
2975 */
2976
2977static const struct file_operations snd_pcm_oss_f_reg =
2978{
2979        .owner =        THIS_MODULE,
2980        .read =         snd_pcm_oss_read,
2981        .write =        snd_pcm_oss_write,
2982        .open =         snd_pcm_oss_open,
2983        .release =      snd_pcm_oss_release,
2984        .llseek =       no_llseek,
2985        .poll =         snd_pcm_oss_poll,
2986        .unlocked_ioctl =       snd_pcm_oss_ioctl,
2987        .compat_ioctl = snd_pcm_oss_ioctl_compat,
2988        .mmap =         snd_pcm_oss_mmap,
2989};
2990
2991static void register_oss_dsp(struct snd_pcm *pcm, int index)
2992{
2993        char name[128];
2994        sprintf(name, "dsp%i%i", pcm->card->number, pcm->device);
2995        if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
2996                                    pcm->card, index, &snd_pcm_oss_f_reg,
2997                                    pcm, name) < 0) {
2998                snd_printk(KERN_ERR "unable to register OSS PCM device %i:%i\n",
2999                           pcm->card->number, pcm->device);
3000        }
3001}
3002
3003static int snd_pcm_oss_register_minor(struct snd_pcm *pcm)
3004{
3005        pcm->oss.reg = 0;
3006        if (dsp_map[pcm->card->number] == (int)pcm->device) {
3007                char name[128];
3008                int duplex;
3009                register_oss_dsp(pcm, 0);
3010                duplex = (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count > 0 && 
3011                              pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count && 
3012                              !(pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX));
3013                sprintf(name, "%s%s", pcm->name, duplex ? " (DUPLEX)" : "");
3014#ifdef SNDRV_OSS_INFO_DEV_AUDIO
3015                snd_oss_info_register(SNDRV_OSS_INFO_DEV_AUDIO,
3016                                      pcm->card->number,
3017                                      name);
3018#endif
3019                pcm->oss.reg++;
3020                pcm->oss.reg_mask |= 1;
3021        }
3022        if (adsp_map[pcm->card->number] == (int)pcm->device) {
3023                register_oss_dsp(pcm, 1);
3024                pcm->oss.reg++;
3025                pcm->oss.reg_mask |= 2;
3026        }
3027
3028        if (pcm->oss.reg)
3029                snd_pcm_oss_proc_init(pcm);
3030
3031        return 0;
3032}
3033
3034static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm)
3035{
3036        if (pcm->oss.reg) {
3037                if (pcm->oss.reg_mask & 1) {
3038                        pcm->oss.reg_mask &= ~1;
3039                        snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
3040                                                  pcm->card, 0);
3041                }
3042                if (pcm->oss.reg_mask & 2) {
3043                        pcm->oss.reg_mask &= ~2;
3044                        snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
3045                                                  pcm->card, 1);
3046                }
3047                if (dsp_map[pcm->card->number] == (int)pcm->device) {
3048#ifdef SNDRV_OSS_INFO_DEV_AUDIO
3049                        snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_AUDIO, pcm->card->number);
3050#endif
3051                }
3052                pcm->oss.reg = 0;
3053        }
3054        return 0;
3055}
3056
3057static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm)
3058{
3059        snd_pcm_oss_disconnect_minor(pcm);
3060        snd_pcm_oss_proc_done(pcm);
3061        return 0;
3062}
3063
3064static struct snd_pcm_notify snd_pcm_oss_notify =
3065{
3066        .n_register =   snd_pcm_oss_register_minor,
3067        .n_disconnect = snd_pcm_oss_disconnect_minor,
3068        .n_unregister = snd_pcm_oss_unregister_minor,
3069};
3070
3071static int __init alsa_pcm_oss_init(void)
3072{
3073        int i;
3074        int err;
3075
3076        /* check device map table */
3077        for (i = 0; i < SNDRV_CARDS; i++) {
3078                if (dsp_map[i] < 0 || dsp_map[i] >= SNDRV_PCM_DEVICES) {
3079                        snd_printk(KERN_ERR "invalid dsp_map[%d] = %d\n",
3080                                   i, dsp_map[i]);
3081                        dsp_map[i] = 0;
3082                }
3083                if (adsp_map[i] < 0 || adsp_map[i] >= SNDRV_PCM_DEVICES) {
3084                        snd_printk(KERN_ERR "invalid adsp_map[%d] = %d\n",
3085                                   i, adsp_map[i]);
3086                        adsp_map[i] = 1;
3087                }
3088        }
3089        if ((err = snd_pcm_notify(&snd_pcm_oss_notify, 0)) < 0)
3090                return err;
3091        return 0;
3092}
3093
3094static void __exit alsa_pcm_oss_exit(void)
3095{
3096        snd_pcm_notify(&snd_pcm_oss_notify, 1);
3097}
3098
3099module_init(alsa_pcm_oss_init)
3100module_exit(alsa_pcm_oss_exit)
3101
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.