sound/hda/hdac_bus.c

   1 /*
   2  * HD-audio core bus driver
   3  */
   4
   5 #include <linux/init.h>
   6 #include <linux/device.h>
   7 #include <linux/module.h>
   8 #include <linux/export.h>
   9 #include <sound/hdaudio.h>
  10 #include "trace.h"
  11
  12 static const struct hdac_bus_ops default_ops = {
  13         .command = snd_hdac_bus_send_cmd,
  14         .get_response = snd_hdac_bus_get_response,
  15 };
  16
  17 /**
  18  * snd_hdac_bus_init - initialize a HD-audio bas bus
  19  * @bus: the pointer to bus object
  20  * @ops: bus verb operators
  21  * @io_ops: lowlevel I/O operators
  22  *
  23  * Returns 0 if successful, or a negative error code.
  24  */
  25 int snd_hdac_bus_init(struct hdac_bus *bus, struct device *dev,
  26                       const struct hdac_bus_ops *ops,
  27                       const struct hdac_io_ops *io_ops)
  28 {
  29         memset(bus, 0, sizeof(*bus));
  30         bus->dev = dev;
  31         if (ops)
  32                 bus->ops = ops;
  33         else
  34                 bus->ops = &default_ops;
  35         bus->io_ops = io_ops;
  36         INIT_LIST_HEAD(&bus->stream_list);
  37         INIT_LIST_HEAD(&bus->codec_list);
  38         INIT_WORK(&bus->unsol_work, snd_hdac_bus_process_unsol_events);
  39         spin_lock_init(&bus->reg_lock);
  40         mutex_init(&bus->cmd_mutex);
  41         mutex_init(&bus->lock);
  42         INIT_LIST_HEAD(&bus->hlink_list);
  43         bus->irq = -1;
  44         return 0;
  45 }
  46 EXPORT_SYMBOL_GPL(snd_hdac_bus_init);
  47
  48 /**
  49  * snd_hdac_bus_exit - clean up a HD-audio bas bus
  50  * @bus: the pointer to bus object
  51  */
  52 void snd_hdac_bus_exit(struct hdac_bus *bus)
  53 {
  54         WARN_ON(!list_empty(&bus->stream_list));
  55         WARN_ON(!list_empty(&bus->codec_list));
  56         cancel_work_sync(&bus->unsol_work);
  57 }
  58 EXPORT_SYMBOL_GPL(snd_hdac_bus_exit);
  59
  60 /**
  61  * snd_hdac_bus_exec_verb - execute a HD-audio verb on the given bus
  62  * @bus: bus object
  63  * @cmd: HD-audio encoded verb
  64  * @res: pointer to store the response, NULL if performing asynchronously
  65  *
  66  * Returns 0 if successful, or a negative error code.
  67  */
  68 int snd_hdac_bus_exec_verb(struct hdac_bus *bus, unsigned int addr,
  69                            unsigned int cmd, unsigned int *res)
  70 {
  71         int err;
  72
  73         mutex_lock(&bus->cmd_mutex);
  74         err = snd_hdac_bus_exec_verb_unlocked(bus, addr, cmd, res);
  75         mutex_unlock(&bus->cmd_mutex);
  76         return err;
  77 }
  78 EXPORT_SYMBOL_GPL(snd_hdac_bus_exec_verb);
  79
  80 /**
  81  * snd_hdac_bus_exec_verb_unlocked - unlocked version
  82  * @bus: bus object
  83  * @cmd: HD-audio encoded verb
  84  * @res: pointer to store the response, NULL if performing asynchronously
  85  *
  86  * Returns 0 if successful, or a negative error code.
  87  */
  88 int snd_hdac_bus_exec_verb_unlocked(struct hdac_bus *bus, unsigned int addr,
  89                                     unsigned int cmd, unsigned int *res)
  90 {
  91         unsigned int tmp;
  92         int err;
  93
  94         if (cmd == ~0)
  95                 return -EINVAL;
  96
  97         if (res)
  98                 *res = -1;
  99         else if (bus->sync_write)
 100                 res = &tmp;
 101         for (;;) {
 102                 trace_hda_send_cmd(bus, cmd);
 103                 err = bus->ops->command(bus, cmd);
 104                 if (err != -EAGAIN)
 105                         break;
 106                 /* process pending verbs */
 107                 err = bus->ops->get_response(bus, addr, &tmp);
 108                 if (err)
 109                         break;
 110         }
 111         if (!err && res) {
 112                 err = bus->ops->get_response(bus, addr, res);
 113                 trace_hda_get_response(bus, addr, *res);
 114         }
 115         return err;
 116 }
 117 EXPORT_SYMBOL_GPL(snd_hdac_bus_exec_verb_unlocked);
 118
 119 /**
 120  * snd_hdac_bus_queue_event - add an unsolicited event to queue
 121  * @bus: the BUS
 122  * @res: unsolicited event (lower 32bit of RIRB entry)
 123  * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
 124  *
 125  * Adds the given event to the queue.  The events are processed in
 126  * the workqueue asynchronously.  Call this function in the interrupt
 127  * hanlder when RIRB receives an unsolicited event.
 128  */
 129 void snd_hdac_bus_queue_event(struct hdac_bus *bus, u32 res, u32 res_ex)
 130 {
 131         unsigned int wp;
 132
 133         if (!bus)
 134                 return;
 135
 136         trace_hda_unsol_event(bus, res, res_ex);
 137         wp = (bus->unsol_wp + 1) % HDA_UNSOL_QUEUE_SIZE;
 138         bus->unsol_wp = wp;
 139
 140         wp <<= 1;
 141         bus->unsol_queue[wp] = res;
 142         bus->unsol_queue[wp + 1] = res_ex;
 143
 144         schedule_work(&bus->unsol_work);
 145 }
 146 EXPORT_SYMBOL_GPL(snd_hdac_bus_queue_event);
 147
 148 /*
 149  * process queued unsolicited events
 150  */
 151 void snd_hdac_bus_process_unsol_events(struct work_struct *work)
 152 {
 153         struct hdac_bus *bus = container_of(work, struct hdac_bus, unsol_work);
 154         struct hdac_device *codec;
 155         struct hdac_driver *drv;
 156         unsigned int rp, caddr, res;
 157
 158         while (bus->unsol_rp != bus->unsol_wp) {
 159                 rp = (bus->unsol_rp + 1) % HDA_UNSOL_QUEUE_SIZE;
 160                 bus->unsol_rp = rp;
 161                 rp <<= 1;
 162                 res = bus->unsol_queue[rp];
 163                 caddr = bus->unsol_queue[rp + 1];
 164                 if (!(caddr & (1 << 4))) /* no unsolicited event? */
 165                         continue;
 166                 codec = bus->caddr_tbl[caddr & 0x0f];
 167                 if (!codec || !codec->dev.driver)
 168                         continue;
 169                 drv = drv_to_hdac_driver(codec->dev.driver);
 170                 if (drv->unsol_event)
 171                         drv->unsol_event(codec, res);
 172         }
 173 }
 174 EXPORT_SYMBOL_GPL(snd_hdac_bus_process_unsol_events);
 175
 176 /**
 177  * snd_hdac_bus_add_device - Add a codec to bus
 178  * @bus: HDA core bus
 179  * @codec: HDA core device to add
 180  *
 181  * Adds the given codec to the list in the bus.  The caddr_tbl array
 182  * and codec_powered bits are updated, as well.
 183  * Returns zero if success, or a negative error code.
 184  */
 185 int snd_hdac_bus_add_device(struct hdac_bus *bus, struct hdac_device *codec)
 186 {
 187         if (bus->caddr_tbl[codec->addr]) {
 188                 dev_err(bus->dev, "address 0x%x is already occupied\n",
 189                         codec->addr);
 190                 return -EBUSY;
 191         }
 192
 193         list_add_tail(&codec->list, &bus->codec_list);
 194         bus->caddr_tbl[codec->addr] = codec;
 195         set_bit(codec->addr, &bus->codec_powered);
 196         bus->num_codecs++;
 197         return 0;
 198 }
 199 EXPORT_SYMBOL_GPL(snd_hdac_bus_add_device);
 200
 201 /**
 202  * snd_hdac_bus_remove_device - Remove a codec from bus
 203  * @bus: HDA core bus
 204  * @codec: HDA core device to remove
 205  */
 206 void snd_hdac_bus_remove_device(struct hdac_bus *bus,
 207                                 struct hdac_device *codec)
 208 {
 209         WARN_ON(bus != codec->bus);
 210         if (list_empty(&codec->list))
 211                 return;
 212         list_del_init(&codec->list);
 213         bus->caddr_tbl[codec->addr] = NULL;
 214         clear_bit(codec->addr, &bus->codec_powered);
 215         bus->num_codecs--;
 216         flush_work(&bus->unsol_work);
 217 }
 218 EXPORT_SYMBOL_GPL(snd_hdac_bus_remove_device);