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