Linux ALSA声卡驱动之三：PCM设备的创建

int snd_pcm_new(struct snd_card *card, const char *id, int device, int playback_count, int capture_count,\
          struct snd_pcm ** rpcm);

void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops);

struct snd_minor {
 int type;   /* SNDRV_DEVICE_TYPE_XXX */
 int card;   /* card number */
 int device;   /* device number */
 const struct file_operations *f_ops; /* file operations */
 void *private_data;  /* private data for f_ops->open */
 struct device *dev;  /* device for sysfs */
};

static struct snd_minor *snd_minors[256];

static int snd_pcm_dev_register(struct snd_device *device)
{
    ......

 /* register pcm */
 err = snd_register_device_for_dev(devtype, pcm->card,
             pcm->device,
     &snd_pcm_f_ops[cidx],
     pcm, str, dev);
    ......
}

int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
    const struct file_operations *f_ops,
    void *private_data,
    const char *name, struct device *device)
{
 int minor;
 struct snd_minor *preg;

 if (snd_BUG_ON(!name))
  return -EINVAL;
 preg = kmalloc(sizeof *preg, GFP_KERNEL);
 if (preg == NULL)
  return -ENOMEM;
 preg->type = type;
 preg->card = card ? card->number : -1;
 preg->device = dev;
 preg->f_ops = f_ops;
 preg->private_data = private_data;
 mutex_lock(&sound_mutex);
#ifdef CONFIG_SND_DYNAMIC_MINORS
 minor = snd_find_free_minor();
#else
 minor = snd_kernel_minor(type, card, dev);
 if (minor >= 0 && snd_minors[minor])
  minor = -EBUSY;
#endif
 if (minor < 0) {
  mutex_unlock(&sound_mutex);
  kfree(preg);
  return minor;
 }
 snd_minors[minor] = preg;
 preg->dev = device_create(sound_class, device, MKDEV(major, minor),
      private_data, "%s", name);
 if (IS_ERR(preg->dev)) {
  snd_minors[minor] = NULL;
  mutex_unlock(&sound_mutex);
  minor = PTR_ERR(preg->dev);
  kfree(preg);
  return minor;
 }

 mutex_unlock(&sound_mutex);
 return 0;
}

static int snd_pcm_dev_register(struct snd_device *device)
{
 int cidx, err;
 char str[16];
 struct snd_pcm *pcm;
 struct device *dev;

 pcm = device->device_data;
         ......
 for (cidx = 0; cidx < 2; cidx++) {
                  ......
  switch (cidx) {
  case SNDRV_PCM_STREAM_PLAYBACK:
   sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device);
   devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
   break;
  case SNDRV_PCM_STREAM_CAPTURE:
   sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device);
   devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
   break;
  }
  /* device pointer to use, pcm->dev takes precedence if
   * it is assigned, otherwise fall back to card's device
   * if possible */
  dev = pcm->dev;
  if (!dev)
   dev = snd_card_get_device_link(pcm->card);
  /* register pcm */
  err = snd_register_device_for_dev(devtype, pcm->card,
        pcm->device,
        &snd_pcm_f_ops[cidx],
        pcm, str, dev);
                  ......
 }
         ......
}

const struct file_operations snd_pcm_f_ops[2] = {
 {
  .owner =  THIS_MODULE,
  .write =  snd_pcm_write,
  .aio_write =  snd_pcm_aio_write,
  .open =   snd_pcm_playback_open,
  .release =  snd_pcm_release,
  .llseek =  no_llseek,
  .poll =   snd_pcm_playback_poll,
  .unlocked_ioctl = snd_pcm_playback_ioctl,
  .compat_ioctl =  snd_pcm_ioctl_compat,
  .mmap =   snd_pcm_mmap,
  .fasync =  snd_pcm_fasync,
  .get_unmapped_area = snd_pcm_get_unmapped_area,
 },
 {
  .owner =  THIS_MODULE,
  .read =   snd_pcm_read,
  .aio_read =  snd_pcm_aio_read,
  .open =   snd_pcm_capture_open,
  .release =  snd_pcm_release,
  .llseek =  no_llseek,
  .poll =   snd_pcm_capture_poll,
  .unlocked_ioctl = snd_pcm_capture_ioctl,
  .compat_ioctl =  snd_pcm_ioctl_compat,
  .mmap =   snd_pcm_mmap,
  .fasync =  snd_pcm_fasync,
  .get_unmapped_area = snd_pcm_get_unmapped_area,
 }
};

 snd_minors[minor] = preg;
 preg->dev = device_create(sound_class, device, MKDEV(major, minor),
      private_data, "%s", name);

static int __init alsa_sound_init(void)
{
 snd_major = major;
 snd_ecards_limit = cards_limit;
 if (register_chrdev(major, "alsa", &snd_fops)) {
  snd_printk(KERN_ERR "unable to register native major device number %d/n", major);
  return -EIO;
 }
 if (snd_info_init() < 0) {
  unregister_chrdev(major, "alsa");
  return -ENOMEM;
 }
 snd_info_minor_register();
 return 0;
}

static const struct file_operations snd_fops =
{
 .owner = THIS_MODULE,
 .open =  snd_open
};

static int snd_open(struct inode *inode, struct file *file)
{
 unsigned int minor = iminor(inode);
 struct snd_minor *mptr = NULL;
 const struct file_operations *old_fops;
 int err = 0;

 if (minor >= ARRAY_SIZE(snd_minors))
  return -ENODEV;
 mutex_lock(&sound_mutex);
 mptr = snd_minors[minor];
 if (mptr == NULL) {
  mptr = autoload_device(minor);
  if (!mptr) {
   mutex_unlock(&sound_mutex);
   return -ENODEV;
  }
 }
 old_fops = file->f_op;
 file->f_op = fops_get(mptr->f_ops);
 if (file->f_op == NULL) {
  file->f_op = old_fops;
  err = -ENODEV;
 }
 mutex_unlock(&sound_mutex);
 if (err < 0)
  return err;

 if (file->f_op->open) {
  err = file->f_op->open(inode, file);
  if (err) {
   fops_put(file->f_op);
   file->f_op = fops_get(old_fops);
  }
 }
 fops_put(old_fops);
 return err;
}