1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/module.h>
21#include <linux/slab.h>
22#include <linux/io.h>
23#include <sound/hdaudio_ext.h>
24
25MODULE_DESCRIPTION("HDA extended core");
26MODULE_LICENSE("GPL v2");
27
28static void hdac_ext_writel(u32 value, u32 __iomem *addr)
29{
30 writel(value, addr);
31}
32
33static u32 hdac_ext_readl(u32 __iomem *addr)
34{
35 return readl(addr);
36}
37
38static void hdac_ext_writew(u16 value, u16 __iomem *addr)
39{
40 writew(value, addr);
41}
42
43static u16 hdac_ext_readw(u16 __iomem *addr)
44{
45 return readw(addr);
46}
47
48static void hdac_ext_writeb(u8 value, u8 __iomem *addr)
49{
50 writeb(value, addr);
51}
52
53static u8 hdac_ext_readb(u8 __iomem *addr)
54{
55 return readb(addr);
56}
57
58static int hdac_ext_dma_alloc_pages(struct hdac_bus *bus, int type,
59 size_t size, struct snd_dma_buffer *buf)
60{
61 return snd_dma_alloc_pages(type, bus->dev, size, buf);
62}
63
64static void hdac_ext_dma_free_pages(struct hdac_bus *bus, struct snd_dma_buffer *buf)
65{
66 snd_dma_free_pages(buf);
67}
68
69static const struct hdac_io_ops hdac_ext_default_io = {
70 .reg_writel = hdac_ext_writel,
71 .reg_readl = hdac_ext_readl,
72 .reg_writew = hdac_ext_writew,
73 .reg_readw = hdac_ext_readw,
74 .reg_writeb = hdac_ext_writeb,
75 .reg_readb = hdac_ext_readb,
76 .dma_alloc_pages = hdac_ext_dma_alloc_pages,
77 .dma_free_pages = hdac_ext_dma_free_pages,
78};
79
80
81
82
83
84
85
86
87
88
89
90int snd_hdac_ext_bus_init(struct hdac_ext_bus *ebus, struct device *dev,
91 const struct hdac_bus_ops *ops,
92 const struct hdac_io_ops *io_ops)
93{
94 int ret;
95 static int idx;
96
97
98 if (io_ops == NULL)
99 io_ops = &hdac_ext_default_io;
100
101 ret = snd_hdac_bus_init(&ebus->bus, dev, ops, io_ops);
102 if (ret < 0)
103 return ret;
104
105 INIT_LIST_HEAD(&ebus->hlink_list);
106 ebus->idx = idx++;
107
108 mutex_init(&ebus->lock);
109 ebus->cmd_dma_state = true;
110
111 return 0;
112}
113EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_init);
114
115
116
117
118
119void snd_hdac_ext_bus_exit(struct hdac_ext_bus *ebus)
120{
121 snd_hdac_bus_exit(&ebus->bus);
122 WARN_ON(!list_empty(&ebus->hlink_list));
123}
124EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_exit);
125
126static void default_release(struct device *dev)
127{
128 snd_hdac_ext_bus_device_exit(container_of(dev, struct hdac_device, dev));
129}
130
131
132
133
134
135
136
137
138int snd_hdac_ext_bus_device_init(struct hdac_ext_bus *ebus, int addr)
139{
140 struct hdac_ext_device *edev;
141 struct hdac_device *hdev = NULL;
142 struct hdac_bus *bus = ebus_to_hbus(ebus);
143 char name[15];
144 int ret;
145
146 edev = kzalloc(sizeof(*edev), GFP_KERNEL);
147 if (!edev)
148 return -ENOMEM;
149 hdev = &edev->hdac;
150 edev->ebus = ebus;
151
152 snprintf(name, sizeof(name), "ehdaudio%dD%d", ebus->idx, addr);
153
154 ret = snd_hdac_device_init(hdev, bus, name, addr);
155 if (ret < 0) {
156 dev_err(bus->dev, "device init failed for hdac device\n");
157 return ret;
158 }
159 hdev->type = HDA_DEV_ASOC;
160 hdev->dev.release = default_release;
161
162 ret = snd_hdac_device_register(hdev);
163 if (ret) {
164 dev_err(bus->dev, "failed to register hdac device\n");
165 snd_hdac_ext_bus_device_exit(hdev);
166 return ret;
167 }
168
169 return 0;
170}
171EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_device_init);
172
173
174
175
176
177void snd_hdac_ext_bus_device_exit(struct hdac_device *hdev)
178{
179 struct hdac_ext_device *edev = to_ehdac_device(hdev);
180
181 snd_hdac_device_exit(hdev);
182 kfree(edev);
183}
184EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_device_exit);
185
186
187
188
189
190
191void snd_hdac_ext_bus_device_remove(struct hdac_ext_bus *ebus)
192{
193 struct hdac_device *codec, *__codec;
194
195
196
197
198 list_for_each_entry_safe(codec, __codec, &ebus->bus.codec_list, list) {
199 snd_hdac_device_unregister(codec);
200 put_device(&codec->dev);
201 }
202}
203EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_device_remove);
204#define dev_to_hdac(dev) (container_of((dev), \
205 struct hdac_device, dev))
206
207static inline struct hdac_ext_driver *get_edrv(struct device *dev)
208{
209 struct hdac_driver *hdrv = drv_to_hdac_driver(dev->driver);
210 struct hdac_ext_driver *edrv = to_ehdac_driver(hdrv);
211
212 return edrv;
213}
214
215static inline struct hdac_ext_device *get_edev(struct device *dev)
216{
217 struct hdac_device *hdev = dev_to_hdac_dev(dev);
218 struct hdac_ext_device *edev = to_ehdac_device(hdev);
219
220 return edev;
221}
222
223static int hda_ext_drv_probe(struct device *dev)
224{
225 return (get_edrv(dev))->probe(get_edev(dev));
226}
227
228static int hdac_ext_drv_remove(struct device *dev)
229{
230 return (get_edrv(dev))->remove(get_edev(dev));
231}
232
233static void hdac_ext_drv_shutdown(struct device *dev)
234{
235 return (get_edrv(dev))->shutdown(get_edev(dev));
236}
237
238
239
240
241
242
243int snd_hda_ext_driver_register(struct hdac_ext_driver *drv)
244{
245 drv->hdac.type = HDA_DEV_ASOC;
246 drv->hdac.driver.bus = &snd_hda_bus_type;
247
248
249 if (drv->probe)
250 drv->hdac.driver.probe = hda_ext_drv_probe;
251 if (drv->remove)
252 drv->hdac.driver.remove = hdac_ext_drv_remove;
253 if (drv->shutdown)
254 drv->hdac.driver.shutdown = hdac_ext_drv_shutdown;
255
256 return driver_register(&drv->hdac.driver);
257}
258EXPORT_SYMBOL_GPL(snd_hda_ext_driver_register);
259
260
261
262
263
264
265void snd_hda_ext_driver_unregister(struct hdac_ext_driver *drv)
266{
267 driver_unregister(&drv->hdac.driver);
268}
269EXPORT_SYMBOL_GPL(snd_hda_ext_driver_unregister);
270