blob: d0db66f24a00cc0ce68f622161bef3b4155a7c82 [file] [log] [blame]
Manuel Lauss4a161d22008-07-09 16:27:56 +02001/*
2 * Au12x0/Au1550 PSC ALSA ASoC audio support.
3 *
Manuel Lausscdc65fb2009-09-08 19:45:17 +02004 * (c) 2007-2009 MSC Vertriebsges.m.b.H.,
5 * Manuel Lauss <manuel.lauss@gmail.com>
Manuel Lauss4a161d22008-07-09 16:27:56 +02006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * Au1xxx-PSC AC97 glue.
12 *
Manuel Lauss4a161d22008-07-09 16:27:56 +020013 */
14
15#include <linux/init.h>
16#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Manuel Lauss4a161d22008-07-09 16:27:56 +020018#include <linux/device.h>
19#include <linux/delay.h>
Manuel Lausscdc65fb2009-09-08 19:45:17 +020020#include <linux/mutex.h>
Manuel Lauss4a161d22008-07-09 16:27:56 +020021#include <linux/suspend.h>
22#include <sound/core.h>
23#include <sound/pcm.h>
24#include <sound/initval.h>
25#include <sound/soc.h>
26#include <asm/mach-au1x00/au1000.h>
27#include <asm/mach-au1x00/au1xxx_psc.h>
28
29#include "psc.h"
30
Manuel Lausscdc65fb2009-09-08 19:45:17 +020031/* how often to retry failed codec register reads/writes */
32#define AC97_RW_RETRIES 5
33
Manuel Lauss4a161d22008-07-09 16:27:56 +020034#define AC97_DIR \
35 (SND_SOC_DAIDIR_PLAYBACK | SND_SOC_DAIDIR_CAPTURE)
36
37#define AC97_RATES \
38 SNDRV_PCM_RATE_8000_48000
39
40#define AC97_FMTS \
41 (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3BE)
42
43#define AC97PCR_START(stype) \
44 ((stype) == PCM_TX ? PSC_AC97PCR_TS : PSC_AC97PCR_RS)
45#define AC97PCR_STOP(stype) \
46 ((stype) == PCM_TX ? PSC_AC97PCR_TP : PSC_AC97PCR_RP)
47#define AC97PCR_CLRFIFO(stype) \
48 ((stype) == PCM_TX ? PSC_AC97PCR_TC : PSC_AC97PCR_RC)
49
Manuel Lausscdc65fb2009-09-08 19:45:17 +020050#define AC97STAT_BUSY(stype) \
51 ((stype) == PCM_TX ? PSC_AC97STAT_TB : PSC_AC97STAT_RB)
52
Manuel Lauss4a161d22008-07-09 16:27:56 +020053/* instance data. There can be only one, MacLeod!!!! */
54static struct au1xpsc_audio_data *au1xpsc_ac97_workdata;
55
Manuel Laussffc4fdb2010-08-26 14:53:51 +020056#if 0
57
58/* this could theoretically work, but ac97->bus->card->private_data can be NULL
59 * when snd_ac97_mixer() is called; I don't know if the rest further down the
60 * chain are always valid either.
61 */
62static inline struct au1xpsc_audio_data *ac97_to_pscdata(struct snd_ac97 *x)
63{
64 struct snd_soc_card *c = x->bus->card->private_data;
65 return snd_soc_dai_get_drvdata(c->rtd->cpu_dai);
66}
67
68#else
69
70#define ac97_to_pscdata(x) au1xpsc_ac97_workdata
71
72#endif
73
Manuel Lauss4a161d22008-07-09 16:27:56 +020074/* AC97 controller reads codec register */
75static unsigned short au1xpsc_ac97_read(struct snd_ac97 *ac97,
76 unsigned short reg)
77{
Manuel Laussffc4fdb2010-08-26 14:53:51 +020078 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
Manuel Lausse697cd42009-10-19 16:10:58 +020079 unsigned short retry, tmo;
80 unsigned long data;
Manuel Lauss4a161d22008-07-09 16:27:56 +020081
82 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
83 au_sync();
84
Manuel Lausscdc65fb2009-09-08 19:45:17 +020085 retry = AC97_RW_RETRIES;
86 do {
87 mutex_lock(&pscdata->lock);
88
89 au_writel(PSC_AC97CDC_RD | PSC_AC97CDC_INDX(reg),
90 AC97_CDC(pscdata));
91 au_sync();
92
Manuel Lauss8d567b62009-10-19 16:10:59 +020093 tmo = 20;
94 do {
95 udelay(21);
96 if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
97 break;
98 } while (--tmo);
Manuel Lausscdc65fb2009-09-08 19:45:17 +020099
Manuel Lausse697cd42009-10-19 16:10:58 +0200100 data = au_readl(AC97_CDC(pscdata));
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200101
102 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
103 au_sync();
104
105 mutex_unlock(&pscdata->lock);
Manuel Lausse697cd42009-10-19 16:10:58 +0200106
107 if (reg != ((data >> 16) & 0x7f))
108 tmo = 1; /* wrong register, try again */
109
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200110 } while (--retry && !tmo);
111
Manuel Lausse697cd42009-10-19 16:10:58 +0200112 return retry ? data & 0xffff : 0xffff;
Manuel Lauss4a161d22008-07-09 16:27:56 +0200113}
114
115/* AC97 controller writes to codec register */
116static void au1xpsc_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
117 unsigned short val)
118{
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200119 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200120 unsigned int tmo, retry;
Manuel Lauss4a161d22008-07-09 16:27:56 +0200121
122 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
123 au_sync();
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200124
125 retry = AC97_RW_RETRIES;
126 do {
127 mutex_lock(&pscdata->lock);
128
129 au_writel(PSC_AC97CDC_INDX(reg) | (val & 0xffff),
130 AC97_CDC(pscdata));
131 au_sync();
132
Manuel Lauss8d567b62009-10-19 16:10:59 +0200133 tmo = 20;
134 do {
135 udelay(21);
136 if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
137 break;
138 } while (--tmo);
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200139
140 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
141 au_sync();
142
143 mutex_unlock(&pscdata->lock);
144 } while (--retry && !tmo);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200145}
146
147/* AC97 controller asserts a warm reset */
148static void au1xpsc_ac97_warm_reset(struct snd_ac97 *ac97)
149{
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200150 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200151
152 au_writel(PSC_AC97RST_SNC, AC97_RST(pscdata));
153 au_sync();
154 msleep(10);
155 au_writel(0, AC97_RST(pscdata));
156 au_sync();
157}
158
159static void au1xpsc_ac97_cold_reset(struct snd_ac97 *ac97)
160{
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200161 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200162 int i;
163
164 /* disable PSC during cold reset */
165 au_writel(0, AC97_CFG(au1xpsc_ac97_workdata));
166 au_sync();
167 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(pscdata));
168 au_sync();
169
170 /* issue cold reset */
171 au_writel(PSC_AC97RST_RST, AC97_RST(pscdata));
172 au_sync();
173 msleep(500);
174 au_writel(0, AC97_RST(pscdata));
175 au_sync();
176
177 /* enable PSC */
178 au_writel(PSC_CTRL_ENABLE, PSC_CTRL(pscdata));
179 au_sync();
180
181 /* wait for PSC to indicate it's ready */
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200182 i = 1000;
Manuel Lauss4a161d22008-07-09 16:27:56 +0200183 while (!((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_SR)) && (--i))
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200184 msleep(1);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200185
186 if (i == 0) {
187 printk(KERN_ERR "au1xpsc-ac97: PSC not ready!\n");
188 return;
189 }
190
191 /* enable the ac97 function */
192 au_writel(pscdata->cfg | PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
193 au_sync();
194
195 /* wait for AC97 core to become ready */
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200196 i = 1000;
Manuel Lauss4a161d22008-07-09 16:27:56 +0200197 while (!((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && (--i))
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200198 msleep(1);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200199 if (i == 0)
200 printk(KERN_ERR "au1xpsc-ac97: AC97 ctrl not ready\n");
201}
202
203/* AC97 controller operations */
204struct snd_ac97_bus_ops soc_ac97_ops = {
205 .read = au1xpsc_ac97_read,
206 .write = au1xpsc_ac97_write,
207 .reset = au1xpsc_ac97_cold_reset,
208 .warm_reset = au1xpsc_ac97_warm_reset,
209};
210EXPORT_SYMBOL_GPL(soc_ac97_ops);
211
212static int au1xpsc_ac97_hw_params(struct snd_pcm_substream *substream,
Mark Browndee89c42008-11-18 22:11:38 +0000213 struct snd_pcm_hw_params *params,
214 struct snd_soc_dai *dai)
Manuel Lauss4a161d22008-07-09 16:27:56 +0200215{
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200216 struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200217 unsigned long r, ro, stat;
Manuel Lauss8d567b62009-10-19 16:10:59 +0200218 int chans, t, stype = SUBSTREAM_TYPE(substream);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200219
220 chans = params_channels(params);
221
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200222 r = ro = au_readl(AC97_CFG(pscdata));
Manuel Lauss4a161d22008-07-09 16:27:56 +0200223 stat = au_readl(AC97_STAT(pscdata));
224
225 /* already active? */
226 if (stat & (PSC_AC97STAT_TB | PSC_AC97STAT_RB)) {
227 /* reject parameters not currently set up */
228 if ((PSC_AC97CFG_GET_LEN(r) != params->msbits) ||
229 (pscdata->rate != params_rate(params)))
230 return -EINVAL;
231 } else {
Manuel Lauss4a161d22008-07-09 16:27:56 +0200232
233 /* set sample bitdepth: REG[24:21]=(BITS-2)/2 */
234 r &= ~PSC_AC97CFG_LEN_MASK;
235 r |= PSC_AC97CFG_SET_LEN(params->msbits);
236
237 /* channels: enable slots for front L/R channel */
238 if (stype == PCM_TX) {
239 r &= ~PSC_AC97CFG_TXSLOT_MASK;
240 r |= PSC_AC97CFG_TXSLOT_ENA(3);
241 r |= PSC_AC97CFG_TXSLOT_ENA(4);
242 } else {
243 r &= ~PSC_AC97CFG_RXSLOT_MASK;
244 r |= PSC_AC97CFG_RXSLOT_ENA(3);
245 r |= PSC_AC97CFG_RXSLOT_ENA(4);
246 }
247
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200248 /* do we need to poke the hardware? */
249 if (!(r ^ ro))
250 goto out;
251
252 /* ac97 engine is about to be disabled */
253 mutex_lock(&pscdata->lock);
254
255 /* disable AC97 device controller first... */
256 au_writel(r & ~PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
257 au_sync();
258
259 /* ...wait for it... */
Manuel Lauss8d567b62009-10-19 16:10:59 +0200260 t = 100;
261 while ((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR) && --t)
262 msleep(1);
263
264 if (!t)
265 printk(KERN_ERR "PSC-AC97: can't disable!\n");
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200266
267 /* ...write config... */
268 au_writel(r, AC97_CFG(pscdata));
269 au_sync();
270
271 /* ...enable the AC97 controller again... */
Manuel Lauss4a161d22008-07-09 16:27:56 +0200272 au_writel(r | PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
273 au_sync();
274
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200275 /* ...and wait for ready bit */
Manuel Lauss8d567b62009-10-19 16:10:59 +0200276 t = 100;
277 while ((!(au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && --t)
278 msleep(1);
279
280 if (!t)
281 printk(KERN_ERR "PSC-AC97: can't enable!\n");
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200282
283 mutex_unlock(&pscdata->lock);
284
Manuel Lauss4a161d22008-07-09 16:27:56 +0200285 pscdata->cfg = r;
286 pscdata->rate = params_rate(params);
287 }
288
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200289out:
Manuel Lauss4a161d22008-07-09 16:27:56 +0200290 return 0;
291}
292
293static int au1xpsc_ac97_trigger(struct snd_pcm_substream *substream,
Mark Browndee89c42008-11-18 22:11:38 +0000294 int cmd, struct snd_soc_dai *dai)
Manuel Lauss4a161d22008-07-09 16:27:56 +0200295{
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200296 struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200297 int ret, stype = SUBSTREAM_TYPE(substream);
298
299 ret = 0;
300
301 switch (cmd) {
302 case SNDRV_PCM_TRIGGER_START:
303 case SNDRV_PCM_TRIGGER_RESUME:
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200304 au_writel(AC97PCR_CLRFIFO(stype), AC97_PCR(pscdata));
305 au_sync();
Manuel Lauss4a161d22008-07-09 16:27:56 +0200306 au_writel(AC97PCR_START(stype), AC97_PCR(pscdata));
307 au_sync();
308 break;
309 case SNDRV_PCM_TRIGGER_STOP:
310 case SNDRV_PCM_TRIGGER_SUSPEND:
311 au_writel(AC97PCR_STOP(stype), AC97_PCR(pscdata));
312 au_sync();
Manuel Lausscdc65fb2009-09-08 19:45:17 +0200313
314 while (au_readl(AC97_STAT(pscdata)) & AC97STAT_BUSY(stype))
315 asm volatile ("nop");
316
317 au_writel(AC97PCR_CLRFIFO(stype), AC97_PCR(pscdata));
318 au_sync();
319
Manuel Lauss4a161d22008-07-09 16:27:56 +0200320 break;
321 default:
322 ret = -EINVAL;
323 }
324 return ret;
325}
326
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000327static int au1xpsc_ac97_probe(struct snd_soc_dai *dai)
Manuel Lauss4a161d22008-07-09 16:27:56 +0200328{
Manuel Lauss0f83d632009-10-31 20:15:08 +0100329 return au1xpsc_ac97_workdata ? 0 : -ENODEV;
Manuel Lauss4a161d22008-07-09 16:27:56 +0200330}
331
Eric Miao6335d052009-03-03 09:41:00 +0800332static struct snd_soc_dai_ops au1xpsc_ac97_dai_ops = {
333 .trigger = au1xpsc_ac97_trigger,
334 .hw_params = au1xpsc_ac97_hw_params,
335};
336
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200337static const struct snd_soc_dai_driver au1xpsc_ac97_dai_template = {
Mark Brown3ba9e10a2008-11-24 18:01:05 +0000338 .ac97_control = 1,
Manuel Lauss4a161d22008-07-09 16:27:56 +0200339 .probe = au1xpsc_ac97_probe,
Manuel Lauss4a161d22008-07-09 16:27:56 +0200340 .playback = {
341 .rates = AC97_RATES,
342 .formats = AC97_FMTS,
343 .channels_min = 2,
344 .channels_max = 2,
345 },
346 .capture = {
347 .rates = AC97_RATES,
348 .formats = AC97_FMTS,
349 .channels_min = 2,
350 .channels_max = 2,
351 },
Eric Miao6335d052009-03-03 09:41:00 +0800352 .ops = &au1xpsc_ac97_dai_ops,
Manuel Lauss4a161d22008-07-09 16:27:56 +0200353};
Manuel Lauss4a161d22008-07-09 16:27:56 +0200354
Manuel Lauss0f83d632009-10-31 20:15:08 +0100355static int __devinit au1xpsc_ac97_drvprobe(struct platform_device *pdev)
356{
357 int ret;
358 struct resource *r;
359 unsigned long sel;
360 struct au1xpsc_audio_data *wd;
361
Manuel Lauss0f83d632009-10-31 20:15:08 +0100362 wd = kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
363 if (!wd)
364 return -ENOMEM;
365
366 mutex_init(&wd->lock);
367
368 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
369 if (!r) {
370 ret = -ENODEV;
371 goto out0;
372 }
373
374 ret = -EBUSY;
Wan ZongShunc0da5502010-06-01 15:16:20 +0800375 if (!request_mem_region(r->start, resource_size(r), pdev->name))
Manuel Lauss0f83d632009-10-31 20:15:08 +0100376 goto out0;
377
Wan ZongShunc0da5502010-06-01 15:16:20 +0800378 wd->mmio = ioremap(r->start, resource_size(r));
Manuel Lauss0f83d632009-10-31 20:15:08 +0100379 if (!wd->mmio)
380 goto out1;
381
382 /* configuration: max dma trigger threshold, enable ac97 */
383 wd->cfg = PSC_AC97CFG_RT_FIFO8 | PSC_AC97CFG_TT_FIFO8 |
384 PSC_AC97CFG_DE_ENABLE;
385
386 /* preserve PSC clock source set up by platform */
387 sel = au_readl(PSC_SEL(wd)) & PSC_SEL_CLK_MASK;
388 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
389 au_sync();
390 au_writel(0, PSC_SEL(wd));
391 au_sync();
392 au_writel(PSC_SEL_PS_AC97MODE | sel, PSC_SEL(wd));
393 au_sync();
394
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200395 /* name the DAI like this device instance ("au1xpsc-ac97.PSCINDEX") */
396 memcpy(&wd->dai_drv, &au1xpsc_ac97_dai_template,
397 sizeof(struct snd_soc_dai_driver));
398 wd->dai_drv.name = dev_name(&pdev->dev);
399
400 platform_set_drvdata(pdev, wd);
401
402 ret = snd_soc_register_dai(&pdev->dev, &wd->dai_drv);
Manuel Lauss0f83d632009-10-31 20:15:08 +0100403 if (ret)
404 goto out1;
405
406 wd->dmapd = au1xpsc_pcm_add(pdev);
407 if (wd->dmapd) {
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200408 au1xpsc_ac97_workdata = wd;
Manuel Lauss0f83d632009-10-31 20:15:08 +0100409 return 0;
410 }
411
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000412 snd_soc_unregister_dai(&pdev->dev);
Manuel Lauss0f83d632009-10-31 20:15:08 +0100413out1:
Wan ZongShunc0da5502010-06-01 15:16:20 +0800414 release_mem_region(r->start, resource_size(r));
Manuel Lauss0f83d632009-10-31 20:15:08 +0100415out0:
416 kfree(wd);
417 return ret;
418}
419
420static int __devexit au1xpsc_ac97_drvremove(struct platform_device *pdev)
421{
422 struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
Wan ZongShunc0da5502010-06-01 15:16:20 +0800423 struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Manuel Lauss0f83d632009-10-31 20:15:08 +0100424
425 if (wd->dmapd)
426 au1xpsc_pcm_destroy(wd->dmapd);
427
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000428 snd_soc_unregister_dai(&pdev->dev);
Manuel Lauss0f83d632009-10-31 20:15:08 +0100429
430 /* disable PSC completely */
431 au_writel(0, AC97_CFG(wd));
432 au_sync();
433 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
434 au_sync();
435
436 iounmap(wd->mmio);
Wan ZongShunc0da5502010-06-01 15:16:20 +0800437 release_mem_region(r->start, resource_size(r));
Manuel Lauss0f83d632009-10-31 20:15:08 +0100438 kfree(wd);
439
440 au1xpsc_ac97_workdata = NULL; /* MDEV */
441
442 return 0;
443}
444
445#ifdef CONFIG_PM
446static int au1xpsc_ac97_drvsuspend(struct device *dev)
447{
448 struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
449
450 /* save interesting registers and disable PSC */
451 wd->pm[0] = au_readl(PSC_SEL(wd));
452
453 au_writel(0, AC97_CFG(wd));
454 au_sync();
455 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
456 au_sync();
457
458 return 0;
459}
460
461static int au1xpsc_ac97_drvresume(struct device *dev)
462{
463 struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
464
465 /* restore PSC clock config */
466 au_writel(wd->pm[0] | PSC_SEL_PS_AC97MODE, PSC_SEL(wd));
467 au_sync();
468
469 /* after this point the ac97 core will cold-reset the codec.
470 * During cold-reset the PSC is reinitialized and the last
471 * configuration set up in hw_params() is restored.
472 */
473 return 0;
474}
475
476static struct dev_pm_ops au1xpscac97_pmops = {
477 .suspend = au1xpsc_ac97_drvsuspend,
478 .resume = au1xpsc_ac97_drvresume,
479};
480
481#define AU1XPSCAC97_PMOPS &au1xpscac97_pmops
482
483#else
484
485#define AU1XPSCAC97_PMOPS NULL
486
487#endif
488
489static struct platform_driver au1xpsc_ac97_driver = {
490 .driver = {
Manuel Laussffc4fdb2010-08-26 14:53:51 +0200491 .name = "au1xpsc_ac97",
Manuel Lauss0f83d632009-10-31 20:15:08 +0100492 .owner = THIS_MODULE,
493 .pm = AU1XPSCAC97_PMOPS,
494 },
495 .probe = au1xpsc_ac97_drvprobe,
496 .remove = __devexit_p(au1xpsc_ac97_drvremove),
497};
498
499static int __init au1xpsc_ac97_load(void)
Manuel Lauss4a161d22008-07-09 16:27:56 +0200500{
501 au1xpsc_ac97_workdata = NULL;
Manuel Lauss0f83d632009-10-31 20:15:08 +0100502 return platform_driver_register(&au1xpsc_ac97_driver);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200503}
504
Manuel Lauss0f83d632009-10-31 20:15:08 +0100505static void __exit au1xpsc_ac97_unload(void)
Manuel Lauss4a161d22008-07-09 16:27:56 +0200506{
Manuel Lauss0f83d632009-10-31 20:15:08 +0100507 platform_driver_unregister(&au1xpsc_ac97_driver);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200508}
509
Manuel Lauss0f83d632009-10-31 20:15:08 +0100510module_init(au1xpsc_ac97_load);
511module_exit(au1xpsc_ac97_unload);
Manuel Lauss4a161d22008-07-09 16:27:56 +0200512
513MODULE_LICENSE("GPL");
514MODULE_DESCRIPTION("Au12x0/Au1550 PSC AC97 ALSA ASoC audio driver");
Manuel Lauss0f83d632009-10-31 20:15:08 +0100515MODULE_AUTHOR("Manuel Lauss");
516