drivers/sound/sound-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2018 Google LLC
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <i2s.h>
  10 #include <sound.h>
  11
  12 #define SOUND_BITS_IN_BYTE 8
  13
  14 int sound_setup(struct udevice *dev)
  15 {
  16         struct sound_ops *ops = sound_get_ops(dev);
  17
  18         if (!ops->setup)
  19                 return 0;
  20
  21         return ops->setup(dev);
  22 }
  23
  24 int sound_play(struct udevice *dev, void *data, uint data_size)
  25 {
  26         struct sound_ops *ops = sound_get_ops(dev);
  27
  28         if (!ops->play)
  29                 return -ENOSYS;
  30
  31         return ops->play(dev, data, data_size);
  32 }
  33
  34 int sound_stop_play(struct udevice *dev)
  35 {
  36         struct sound_ops *ops = sound_get_ops(dev);
  37
  38         if (!ops->play)
  39                 return -ENOSYS;
  40
  41         return ops->stop_play(dev);
  42 }
  43
  44 int sound_start_beep(struct udevice *dev, int frequency_hz)
  45 {
  46         struct sound_ops *ops = sound_get_ops(dev);
  47
  48         if (!ops->start_beep)
  49                 return -ENOSYS;
  50
  51         return ops->start_beep(dev, frequency_hz);
  52 }
  53
  54 int sound_stop_beep(struct udevice *dev)
  55 {
  56         struct sound_ops *ops = sound_get_ops(dev);
  57
  58         if (!ops->stop_beep)
  59                 return -ENOSYS;
  60
  61         return ops->stop_beep(dev);
  62 }
  63
  64 int sound_beep(struct udevice *dev, int msecs, int frequency_hz)
  65 {
  66         struct sound_uc_priv *uc_priv = dev_get_uclass_priv(dev);
  67         struct i2s_uc_priv *i2s_uc_priv;
  68         unsigned short *data;
  69         uint data_size;
  70         int ret;
  71
  72         ret = sound_setup(dev);
  73         if (ret && ret != -EALREADY)
  74                 return ret;
  75
  76         /* Try using the beep interface if available */
  77         ret = sound_start_beep(dev, frequency_hz);
  78         if (ret != -ENOSYS) {
  79                 if (ret)
  80                         return ret;
  81                 mdelay(msecs);
  82                 ret = sound_stop_beep(dev);
  83
  84                 return ret;
  85         }
  86
  87         /* Buffer length computation */
  88         i2s_uc_priv = dev_get_uclass_priv(uc_priv->i2s);
  89         data_size = i2s_uc_priv->samplingrate * i2s_uc_priv->channels;
  90         data_size *= (i2s_uc_priv->bitspersample / SOUND_BITS_IN_BYTE);
  91         data = malloc(data_size);
  92         if (!data) {
  93                 debug("%s: malloc failed\n", __func__);
  94                 return -ENOMEM;
  95         }
  96
  97         sound_create_square_wave(i2s_uc_priv->samplingrate, data, data_size,
  98                                  frequency_hz, i2s_uc_priv->channels);
  99
 100         ret = 0;
 101         while (msecs >= 1000) {
 102                 ret = sound_play(dev, data, data_size);
 103                 if (ret)
 104                         break;
 105                 msecs -= 1000;
 106         }
 107         if (!ret && msecs) {
 108                 unsigned long size =
 109                         (data_size * msecs) / (sizeof(int) * 1000);
 110
 111                 ret = sound_play(dev, data, size);
 112         }
 113         sound_stop_play(dev);
 114
 115         free(data);
 116
 117         return ret;
 118 }
 119
 120 int sound_find_codec_i2s(struct udevice *dev)
 121 {
 122         struct sound_uc_priv *uc_priv = dev_get_uclass_priv(dev);
 123         struct ofnode_phandle_args args;
 124         ofnode node;
 125         int ret;
 126
 127         /* First the codec */
 128         node = ofnode_find_subnode(dev_ofnode(dev), "codec");
 129         if (!ofnode_valid(node)) {
 130                 debug("Failed to find /cpu subnode\n");
 131                 return -EINVAL;
 132         }
 133         ret = ofnode_parse_phandle_with_args(node, "sound-dai",
 134                                              "#sound-dai-cells", 0, 0, &args);
 135         if (ret) {
 136                 debug("Cannot find phandle: %d\n", ret);
 137                 return ret;
 138         }
 139         ret = uclass_get_device_by_ofnode(UCLASS_AUDIO_CODEC, args.node,
 140                                           &uc_priv->codec);
 141         if (ret) {
 142                 debug("Cannot find codec: %d\n", ret);
 143                 return ret;
 144         }
 145
 146         /* Now the i2s */
 147         node = ofnode_find_subnode(dev_ofnode(dev), "cpu");
 148         if (!ofnode_valid(node)) {
 149                 debug("Failed to find /cpu subnode\n");
 150                 return -EINVAL;
 151         }
 152         ret = ofnode_parse_phandle_with_args(node, "sound-dai",
 153                                              "#sound-dai-cells", 0, 0, &args);
 154         if (ret) {
 155                 debug("Cannot find phandle: %d\n", ret);
 156                 return ret;
 157         }
 158         ret = uclass_get_device_by_ofnode(UCLASS_I2S, args.node, &uc_priv->i2s);
 159         if (ret) {
 160                 debug("Cannot find i2s: %d\n", ret);
 161                 return ret;
 162         }
 163         debug("Probed sound '%s' with codec '%s' and i2s '%s'\n", dev->name,
 164               uc_priv->codec->name, uc_priv->i2s->name);
 165
 166         return 0;
 167 }
 168
 169 UCLASS_DRIVER(sound) = {
 170         .id             = UCLASS_SOUND,
 171         .name           = "sound",
 172         .per_device_auto_alloc_size     = sizeof(struct sound_uc_priv),
 173 };