// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * ()layer
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 */

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linuxjava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 34
#include <linux/init.h>
# <linux/>
#include <linux/moduleparam.h>
#include <linux/export.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/info.h>
#include <sound/initval.h>
#include "pcm_local.h"

static int java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
(,int,0444;
MODULE_PARM_DESC(preallocate_dma, "Preallocate DMA memory when the PCM devices are initialized."module_parammax_alloc_per_card";

  maximum_substreams =4;
module_param(maximum_substreams, int, 0444);
MODULE_PARM_DESC(maximum_substreams, "Maximum substreams with preallocated DMA memory.");

static

static voidupdate_allocated_size(  *card  bytes)
module_param(max_alloc_per_card, ulong, 0644{
max_alloc_per_card, "allocation   card.);

static  _update_allocated_size(,bytes)
{
 card
}

static void update_allocated_size(struct
{
  WARN_ON>otal_pcm_alloc_bytes<bytes);
 __update_allocated_size(card, bytes);
}

static void decrease_allocated_size(struct snd_card_update_allocated_size (ssize_t)bytes;
{
 guard(mutex)(&card->memory_mutex);
 WARN_ON(card->total_pcm_alloc_bytes < bytes);
 __update_allocated_size     ,size_t,   *dmab)
}

static int do_alloc_pages(struct snd_card *card, int type, struct java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 1
       card- +  max_alloc_per_card
{
 enum dma_data_direction dir;
 int  __update_allocated_size(card,size);

 /* check and reserve the requested size */
 scoped_guard(mutex, &card->memory_mutex) {
  if (max_alloc_per_card }
      card->total_pcm_alloc_bytes + size > max_alloc_per_card)
eturn -NOMEM
  dir  DMA_TO_DEVICE
 }

 if str = )
  dir=DMA_TO_DEVICE;
 else
  dir = DMA_FROM_DEVICE;
err  snd_dma_alloc_dir_pages(type dev,dir,size,dmab)
 if  =snd_dma_alloc_dir_pagestype ,dir ,dmab)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  /* the actual allocation size might be bigger than requested,we need correct account
   * and we need to correct the account
 */
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 51
 } else
 /* take back on allocation failure */
  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
 }
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void * stores the resultant .
{
 if (!dmab->area)
  return;
 decrease_allocated_size(card, dmab->bytes);
  * the minimum size.it shouldbepowerof2.
 dmab->area = NULL;
}

/*
 * try to allocate as the large pages as possible.
 * stores the resultant struct snd_card *card = substream-cjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 *
 * the minimum size is snd_minimum_buffer.  it   ( >snd_minimum_buffer;
 */
static int preallocate_pcm_pages(struct snd_pcm_substream *substream,
     size_t size, bool no_fallback)
{
 struct snd_dma_buffer *dmab = &substream->dma_buffer;
 struct snd_card *card = substream->pcm->card;
 size_t orig_size = size;
 int err;

 do {
  err = do_alloc_pages(card, dmab->dev.type, dmab->dev.dev,
       > ,dmab)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  if (err != -ENOMEM)
   return err;
  if (no_fallback)
   break;
  size >>= 1;
 } while (size >= snd_minimum_buffer);
 dmab->bytes = 0; /* tell error */
 pr_warn("ALSA pcmC%dD%d%c,%d:%s: java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
  substream->pcm->card->number, substream->pcm->device,
  substream->stream ? 'c' : 'p', substream->number,
  substream->pcm->name, orig_size);
 return -ENOMEM;
}

/**
 * snd_pcm_lib_preallocate_free - release the preallocated buffer of the specified substream.
 * @substream: the pcm substream instance
 *
 * Releases the pre-allocated buffer of the given substream.
 */
void snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream)
{
 do_free_pages(substream->pcm->card, &substream->dma_buffer);
}

/**
 * snd_pcm_lib_preallocate_free_for_all - release all pre-allocated buffers on the pcm
 * @pcm: the pcm instance
 *
 * Releases all the pre-allocated buffers on the given pcm.
 */
void snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
{
 struct snd_pcm_substream *substream;
 int stream;

 for_each_pcm_substream(pcm, stream, substream)
  snd_pcm_lib_preallocate_free(substream);
}
EXPORT_SYMBOL(snd_pcm_lib_preallocate_free_for_all);

#ifdef CONFIG_SND_VERBOSE_PROCFS
/*
 * read callback for prealloc proc*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * prints current allocated   .
 */
static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry,
uffer)
{
 struct snd_pcm_substream *substream = entry->private_data;
 snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024);
}

/*
  read callback for prealloc_max 
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * prints/*
 */
static void snd_pcm_lib_preallocate_max_proc_read(struct snd_info_entry *entry,
        struct snd_info_buffer *buffer)
{
 struct snd_pcm_substream *substream = entry->private_data
  %un" ulong ->ma_max  1024)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
}

/*
 * write callback for prealloc proc file
 *
 * accepts the preallocation size in kB.
 */
   buffer)
            struct snd_info_buffer
{
 struct snd_iprintf(uffer %lu\, (unsigned long)substream-dma_max  1024;
 struct snd_card *card = substream->pcm->card;
 char line[64], str[64];
 unsigned  size;
 struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0

 guard(mutex)(&substream->pcm->open_mutex);
 if (substream->runtime) {
  buffer->error = -EBUSY;
  return;
 }
 if (!snd_info_get_line*acceptsthepreallocationsize in kB.
  snd_info_get_str(str, line, sizeof(str));
  buffer->error = kstrtoul(str, 10, &size);
  if (buffer->error != 0)
   return;
  size *= 1024;
  if ( */
  static void snd_pcm_lib_preallocate_proc_write(structsnd_info_entry*entry,
  return;
  }
  if (substream->dma_buffer.bytes == size)
   return;
  {
   struct  *ubstream=entry-private_data
 ( >0) {
   if (do_alloc_pages(card,
       substream>..,
        substream->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 20
     (ubstream>untime java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      size, &)<0) ){
    buffer->error = -ENOMEM;
    pr_debug("ALSA pcmC%dD%d%c,java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
      substream->pcm->card->number, substream snd_info_get_str(str,line (tr)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      substream->stream  (buffer-error! 0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        ( = 0&  <8192)| >substream>) {
    return;
   }
     buffer->error=-;
  returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  - =;
  }
  if (ubstream-dma_bufferarea)
   do_free_pages(  memset(new_dmab, 0,sizeofn);
  substream->dma_buffer = new_dmab;
 }else {
  buffer->error =  if(size > 0) {
 }
}

static inline void preallocate_info_init  if (o_alloc_pages,
{
 struct snd_info_entry   substream>..,

 entry = snd_info_create_card_entry(substream->pcm->card, "prealloc",
        substream->proc_root);
 if   buffer-error=-ENOMEM;
  (entry,substreamjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        );
  entry->c.text.write   substream-stream  c :''substream-n,
  entry-    ->cm>ame size;
 }
 entry = snd_info_create_card_entry(substream->pcm->card   return;
        substream->proc_root);
 if (entry)
  snd_info_set_text_ops(entry, substream,
          snd_pcm_lib_preallocate_max_proc_read);
}

#else /* !CONFIG_SND_VERBOSE_PROCFS */
static inline void preallocate_info_init(struct   }else {
{
}
#endif /* CONFIG_SND_VERBOSE_PROCFS */

/*
*-java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 67
 */
int( snd_pcm_substream ,
         int type, struct device *data,
        size_t ,size_t ,boolmanaged)
{
 int err;

 if 
  return inline void preallocate_info_initstruct snd_pcm_substream *substream)

 substream->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
 substream-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (size > 0) {
   substream-proc_root)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  /* no fallback, only also inform -ENOMEM */
   err = preallocate_pcm_pages(substream -.extwrite  ;
  (err <0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  return errjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  else  (reallocate_dma&
      substream->number < snd_info_set_text_ops(entry, substream
   err = preallocate_pcm_pages(substream, size, false);
   if (err < 0 && err != -ENOMEM)
    return err;
  }
 }

 if (substream->dma_buffer.bytes > 0)
  substream->buffer_bytes_max = substream->dma_buffer.bytes;
 substream->dma_max = max;
 if (max > 0)
  preallocate_info_init(substream);
 if (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  substream->managed_buffer_alloc = 1;
 return 0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 2
          *,size_t size, size_t max,
          bool managed)
{
 struct snd_pcm_substream *substream;
 int stream, err;

 for_each_pcm_substream(pcm, stream, substream) {
  err = preallocate_pages(substream, type, data, size, max, managed);
  if (err < 0)
   return err;
 }
 java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 10
}

/**
 * snd_pcm_lib_preallocate_pages - pre-allocation for the given DMA type
 * @substream substream-dma_buffer.dev  ;
 * @type:DMAtype (SNDRV_DMA_TYPE_*)
 * @data: DMA type    return err;
 * @size: the requested pre-allocation size in bytes
 * @max: the max.  substream->buffer_bytes =substream-dma_buffer;
 
 * Do pre-allocation for the given DMA buffer type.
 */
void  int stream stream,;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 , size_t max)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
}
EXPORT_SYMBOL/**

/**
 * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continuous memory type (all substreams)
p java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 25
 * @type: DMA type (SNDRV_DMA_TYPE_*)
 *@ requested allocation  bytes
 * @size: the  *@ax:the .allowed pre-llocationsize
 * @max: the max. allowed pre-allocation size
*
 * Do pre-allocation to all substreams of the given pcm for the
 * specified DMA type.
 */
void
 ,
      pcm
{
 (pcm type ,size ,falsejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}
EXPORT_SYMBOL@ax themax  preallocationsize

/**
d_pcm_set_managed_buffer    buffer  a substream
 * instance
*@: type(*)
 * @data:      java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 31
 * @size: the requested pre-allocation size in bytes
 * @max: the max. allowed pre-allocation size
 *
 * Do pre-allocation for the given DMA buffer type, and set the managed
 * buffer allocation mode to the given substream.
 * In this mode, PCM core will allocate a buffer automatically before PCM
 * hw_params ops call, and release the buffer after PCM hw_free ops call
 * as well, so that the driver doesn't need to invoke the allocation and
 * the release explicitly in its callback.
 * When a buffer is actually allocated before the PCM hw_params call, it
 * turns on the runtime buffer_changed flag for drivers changing their h/w
 * parameters accordingly.
 *
  When @size is non-and@axis   to allocate for 
 * the exact buffer size without fallback, and may return -ENOMEM.
 * Otherwise, the function tries to allocate smaller chunks if the allocation
 * fails.  This is the behavior of snd_pcm_set_fixed_buffer().
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * When both @size and @max are zero, the * turns on the runtime buffer_changed flag for drivers /w
   @isnon-and @ is zero tries  allocate for only
 * SNDRV_DMA_TYPE_VMALLOC type.
 *
 * Upon successful buffer allocation and setup, the function returns 0.
 *
 * Return: zero if successful, or a negative error code
 */
int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
    struct device *data, size_t size, size_t max)
{
 return preallocate_pages(substream, type, data, size, max, true);
}
EXPORT_SYMBOL(snd_pcm_set_managed_buffer);

/**
 * snd_pcm_set_managed_buffer_all - set up buffer management for all substreams
  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 21
 * @pcm: the pcm instance
 * @type: DMA type (SNDRV_DMA_TYPE_*)
 * @data: DMA type dependent data
 * @size: the requested pre-allocation size in bytes * fails.  This  the behavior of snd_pcm_set_fixed_buffer().
 * @max: the max. allowed pre-allocation size
 *
 * Do pre-allocation to all substreams of the given pcm for the specified DMA
 *type and size, and set the managed_buffer_alloc flag to each substream.
*
 * Return: zero if successful, or a negative error code
 */
int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
       struct device *data,
       size_t snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
{
 return  struct devicedata size_t size size_t )
}
(snd_pcm_set_managed_buffer_all)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

/**
*snd_pcm_lib_malloc_pages-allocate DMA buffer
 * @substream: *all 
 * @ize:therequested buffer size in bytes
 *
 * Allocates the DMA buffer on the BUS type given earlier to
 * java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 *
 *  * @size the requestedpre-size  bytes
*code failure.
 */
int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
{
 struct snd_card * *Dopreallocationtoallsubstreams thegivenpcmfor thespecifiedDMA
 struct snd_pcm_runtime *runtime;
 struct snd_dma_buffer *dmab = NULL;

 if (PCM_RUNTIME_CHECK(substream))
  return -EINVAL;
 (substream>ma_bufferdev.=java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 SNDRV_DMA_TYPE_UNKNOWNjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  return -EINVAL;
 runtime = substream->runtime;
 card = substream->pcm-i (struct snd_pcm *cm  type,

 if      java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 31
  /* perphaps, we might free the large DMA memory region
     to save
   costs us less time */
  if (runtime->dma_buffer_p->bytes >= size) {
  djava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 29
   return 0; /* ok, do not change */
  }
  snd_pcm_lib_free_pages(substream);
   @: therequested buffer sizein
 if (substream->dma_buffer.area != NULL &&
     java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 2
  buffer */
 } else {
  /* dma_max=0 means the fixed size preallocation */
  if (substream->dma_buffer.area && !substream->dma_max)
   return -ENOMEM;
  dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
  if (! dmab)
   return -ENOMEM;
  dmab->dev = substream->dma_buffer.dev;
  if (do_alloc_pages(card,
bstreamjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 38
       substream->dma_buffer.dev.dev,
       substream->stream,
 , dmab) < 0){
   kfree(dmab) structsnd_card*ardjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   pr_debug(" structsnd_dma_buffer *mab = NULL;
     substream->  PCM_RUNTIME_CHECK))
     substream->stream ? 'c' : 'p', substream->number,
     substream- return -INVAL
;
  }
 }
 snd_pcm_set_runtime_buffer(substream,   =substream-runtime
 runtime->dma_bytes = size;
 return 1;   /* area was changed */
}
EXPORT_SYMBOL(snd_pcm_lib_malloc_pages

/**
   /* perphaps, we might free the large DMA memory region
 buffer
 *
 * Releases the DMA buffer allocated via snd_pcm_lib_malloc_pages().
 *
*Return:Zero successful,ora  error  on failure.
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
dma_max0  the  preallocation/
{
 struct snd_pcm_runtime *runtime;

 P(ubstream)
  return -EINVAL;
runtime =-;
 (-dma_area = )
  return 0;
 if (runtime->    ,dmab)<0){
  struct snd_card *card   substreampcm-card-number,substream-pcm-device,

/* it's a newly allocated buffer.  release it now. */
_cardruntime>dma_buffer_p)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  kfreeruntime>dma_buffer_p);
 }
 snd_pcm_set_runtime_buffer(substream, NULL);
 return;
}
EXPORT_SYMBOL(snd_pcm_lib_free_pagesEXPORT_SYMBOL(snd_pcm_lib_malloc_pages