← Back to branch summary

~ubuntu-branches/ubuntu/precise/alsa-driver/precise

« back to all changes in this revision

Viewing changes to alsa-kernel/soc/soc-core.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2011-02-21 18:06:40 UTC
  • mfrom: (1.1.15 upstream)
  • Revision ID: james.westby@ubuntu.com-20110221180640-a8p2yxtvgf7xbxub
Tags: 1.0.24+dfsg-0ubuntu1
* New upstream release
* Refreshed patches:
  - distinguish_kernel_makefile_and_source_dirs.patch
  - debian_dfsg_configure.patch
* debian/control: Update Vcs-bzr field to point to new branch location

Show diffs side-by-side

added added

removed removed

Lines of Context:
alsa-kernel/soc/soc-core.c
3
3
 *
4
4
 * Copyright 2005 Wolfson Microelectronics PLC.
5
5
 * Copyright 2005 Openedhand Ltd.
 
6
 * Copyright (C) 2010 Slimlogic Ltd.
 
7
 * Copyright (C) 2010 Texas Instruments Inc.
6
8
 *
7
9
 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8
10
 *         with code, comments and ideas from :-
31
33
#include <linux/slab.h>
32
34
#include <sound/ac97_codec.h>
33
35
#include <sound/core.h>
 
36
#include <sound/jack.h>
34
37
#include <sound/pcm.h>
35
38
#include <sound/pcm_params.h>
36
39
#include <sound/soc.h>
37
 
#include <sound/soc-dapm.h>
38
40
#include <sound/initval.h>
39
41
 
 
42
#define CREATE_TRACE_POINTS
 
43
#include <trace/events/asoc.h>
 
44
 
 
45
#define NAME_SIZE       32
 
46
 
40
47
static DEFINE_MUTEX(pcm_mutex);
41
48
static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
42
49
 
43
50
#ifdef CONFIG_DEBUG_FS
44
 
static struct dentry *debugfs_root;
 
51
struct dentry *snd_soc_debugfs_root;
 
52
EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
45
53
#endif
46
54
 
47
55
static DEFINE_MUTEX(client_mutex);
50
58
static LIST_HEAD(platform_list);
51
59
static LIST_HEAD(codec_list);
52
60
 
53
 
static int snd_soc_register_card(struct snd_soc_card *card);
54
 
static int snd_soc_unregister_card(struct snd_soc_card *card);
 
61
static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
55
62
 
56
63
/*
57
64
 * This is a timeout to do a DAPM powerdown after a stream is closed().
62
69
module_param(pmdown_time, int, 0);
63
70
MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
64
71
 
65
 
/*
66
 
 * This function forces any delayed work to be queued and run.
67
 
 */
68
 
static int run_delayed_work(struct delayed_work *dwork)
69
 
{
70
 
        int ret;
71
 
 
72
 
        /* cancel any work waiting to be queued. */
73
 
        ret = cancel_delayed_work(dwork);
74
 
 
75
 
        /* if there was any work waiting then we run it now and
76
 
         * wait for it's completion */
77
 
        if (ret) {
78
 
                schedule_delayed_work(dwork, 0);
79
 
                flush_scheduled_work();
80
 
        }
81
 
        return ret;
82
 
}
83
 
 
84
72
/* codec register dump */
85
73
static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
86
74
{
87
 
        int i, step = 1, count = 0;
 
75
        int ret, i, step = 1, count = 0;
88
76
 
89
 
        if (!codec->reg_cache_size)
 
77
        if (!codec->driver->reg_cache_size)
90
78
                return 0;
91
79
 
92
 
        if (codec->reg_cache_step)
93
 
                step = codec->reg_cache_step;
 
80
        if (codec->driver->reg_cache_step)
 
81
                step = codec->driver->reg_cache_step;
94
82
 
95
83
        count += sprintf(buf, "%s registers\n", codec->name);
96
 
        for (i = 0; i < codec->reg_cache_size; i += step) {
97
 
                if (codec->readable_register && !codec->readable_register(i))
 
84
        for (i = 0; i < codec->driver->reg_cache_size; i += step) {
 
85
                if (codec->readable_register && !codec->readable_register(codec, i))
98
86
                        continue;
99
87
 
100
88
                count += sprintf(buf + count, "%2x: ", i);
101
89
                if (count >= PAGE_SIZE - 1)
102
90
                        break;
103
91
 
104
 
                if (codec->display_register)
105
 
                        count += codec->display_register(codec, buf + count,
 
92
                if (codec->driver->display_register) {
 
93
                        count += codec->driver->display_register(codec, buf + count,
106
94
                                                         PAGE_SIZE - count, i);
107
 
                else
108
 
                        count += snprintf(buf + count, PAGE_SIZE - count,
109
 
                                          "%4x", codec->read(codec, i));
 
95
                } else {
 
96
                        /* If the read fails it's almost certainly due to
 
97
                         * the register being volatile and the device being
 
98
                         * powered off.
 
99
                         */
 
100
                        ret = snd_soc_read(codec, i);
 
101
                        if (ret >= 0)
 
102
                                count += snprintf(buf + count,
 
103
                                                  PAGE_SIZE - count,
 
104
                                                  "%4x", ret);
 
105
                        else
 
106
                                count += snprintf(buf + count,
 
107
                                                  PAGE_SIZE - count,
 
108
                                                  "<no data: %d>", ret);
 
109
                }
110
110
 
111
111
                if (count >= PAGE_SIZE - 1)
112
112
                        break;
125
125
static ssize_t codec_reg_show(struct device *dev,
126
126
        struct device_attribute *attr, char *buf)
127
127
{
128
 
        struct snd_soc_device *devdata = dev_get_drvdata(dev);
129
 
        return soc_codec_reg_show(devdata->card->codec, buf);
 
128
        struct snd_soc_pcm_runtime *rtd =
 
129
                        container_of(dev, struct snd_soc_pcm_runtime, dev);
 
130
 
 
131
        return soc_codec_reg_show(rtd->codec, buf);
130
132
}
131
133
 
132
134
static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
134
136
static ssize_t pmdown_time_show(struct device *dev,
135
137
                                struct device_attribute *attr, char *buf)
136
138
{
137
 
        struct snd_soc_device *socdev = dev_get_drvdata(dev);
138
 
        struct snd_soc_card *card = socdev->card;
 
139
        struct snd_soc_pcm_runtime *rtd =
 
140
                        container_of(dev, struct snd_soc_pcm_runtime, dev);
139
141
 
140
 
        return sprintf(buf, "%ld\n", card->pmdown_time);
 
142
        return sprintf(buf, "%ld\n", rtd->pmdown_time);
141
143
}
142
144
 
143
145
static ssize_t pmdown_time_set(struct device *dev,
144
146
                               struct device_attribute *attr,
145
147
                               const char *buf, size_t count)
146
148
{
147
 
        struct snd_soc_device *socdev = dev_get_drvdata(dev);
148
 
        struct snd_soc_card *card = socdev->card;
 
149
        struct snd_soc_pcm_runtime *rtd =
 
150
                        container_of(dev, struct snd_soc_pcm_runtime, dev);
 
151
        int ret;
149
152
 
150
 
        strict_strtol(buf, 10, &card->pmdown_time);
 
153
        ret = strict_strtol(buf, 10, &rtd->pmdown_time);
 
154
        if (ret)
 
155
                return ret;
151
156
 
152
157
        return count;
153
158
}
191
196
                return -EFAULT;
192
197
        buf[buf_size] = 0;
193
198
 
194
 
        if (codec->reg_cache_step)
195
 
                step = codec->reg_cache_step;
 
199
        if (codec->driver->reg_cache_step)
 
200
                step = codec->driver->reg_cache_step;
196
201
 
197
202
        while (*start == ' ')
198
203
                start++;
199
204
        reg = simple_strtoul(start, &start, 16);
200
 
        if ((reg >= codec->reg_cache_size) || (reg % step))
 
205
        if ((reg >= codec->driver->reg_cache_size) || (reg % step))
201
206
                return -EINVAL;
202
207
        while (*start == ' ')
203
208
                start++;
204
209
        if (strict_strtoul(start, 16, &value))
205
210
                return -EINVAL;
206
 
        codec->write(codec, reg, value);
 
211
 
 
212
        /* Userspace has been fiddling around behind the kernel's back */
 
213
        add_taint(TAINT_USER);
 
214
 
 
215
        snd_soc_write(codec, reg, value);
207
216
        return buf_size;
208
217
}
209
218
 
211
220
        .open = codec_reg_open_file,
212
221
        .read = codec_reg_read_file,
213
222
        .write = codec_reg_write_file,
 
223
        .llseek = default_llseek,
214
224
};
215
225
 
216
226
static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
217
227
{
218
 
        char codec_root[128];
219
 
 
220
 
        if (codec->dev)
221
 
                snprintf(codec_root, sizeof(codec_root),
222
 
                        "%s.%s", codec->name, dev_name(codec->dev));
223
 
        else
224
 
                snprintf(codec_root, sizeof(codec_root),
225
 
                        "%s", codec->name);
226
 
 
227
 
        codec->debugfs_codec_root = debugfs_create_dir(codec_root,
228
 
                                                       debugfs_root);
 
228
        struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
 
229
 
 
230
        codec->debugfs_codec_root = debugfs_create_dir(codec->name,
 
231
                                                       debugfs_card_root);
229
232
        if (!codec->debugfs_codec_root) {
230
233
                printk(KERN_WARNING
231
234
                       "ASoC: Failed to create codec debugfs directory\n");
239
242
                printk(KERN_WARNING
240
243
                       "ASoC: Failed to create codec register debugfs file\n");
241
244
 
242
 
        codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744,
243
 
                                                     codec->debugfs_codec_root,
244
 
                                                     &codec->pop_time);
245
 
        if (!codec->debugfs_pop_time)
246
 
                printk(KERN_WARNING
247
 
                       "Failed to create pop time debugfs file\n");
248
 
 
249
 
        codec->debugfs_dapm = debugfs_create_dir("dapm",
 
245
        codec->dapm.debugfs_dapm = debugfs_create_dir("dapm",
250
246
                                                 codec->debugfs_codec_root);
251
 
        if (!codec->debugfs_dapm)
 
247
        if (!codec->dapm.debugfs_dapm)
252
248
                printk(KERN_WARNING
253
249
                       "Failed to create DAPM debugfs directory\n");
254
250
 
255
 
        snd_soc_dapm_debugfs_init(codec);
 
251
        snd_soc_dapm_debugfs_init(&codec->dapm);
256
252
}
257
253
 
258
254
static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
260
256
        debugfs_remove_recursive(codec->debugfs_codec_root);
261
257
}
262
258
 
 
259
static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
 
260
                                    size_t count, loff_t *ppos)
 
261
{
 
262
        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 
263
        ssize_t len, ret = 0;
 
264
        struct snd_soc_codec *codec;
 
265
 
 
266
        if (!buf)
 
267
                return -ENOMEM;
 
268
 
 
269
        list_for_each_entry(codec, &codec_list, list) {
 
270
                len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 
271
                               codec->name);
 
272
                if (len >= 0)
 
273
                        ret += len;
 
274
                if (ret > PAGE_SIZE) {
 
275
                        ret = PAGE_SIZE;
 
276
                        break;
 
277
                }
 
278
        }
 
279
 
 
280
        if (ret >= 0)
 
281
                ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 
282
 
 
283
        kfree(buf);
 
284
 
 
285
        return ret;
 
286
}
 
287
 
 
288
static const struct file_operations codec_list_fops = {
 
289
        .read = codec_list_read_file,
 
290
        .llseek = default_llseek,/* read accesses f_pos */
 
291
};
 
292
 
 
293
static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
 
294
                                  size_t count, loff_t *ppos)
 
295
{
 
296
        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 
297
        ssize_t len, ret = 0;
 
298
        struct snd_soc_dai *dai;
 
299
 
 
300
        if (!buf)
 
301
                return -ENOMEM;
 
302
 
 
303
        list_for_each_entry(dai, &dai_list, list) {
 
304
                len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name);
 
305
                if (len >= 0)
 
306
                        ret += len;
 
307
                if (ret > PAGE_SIZE) {
 
308
                        ret = PAGE_SIZE;
 
309
                        break;
 
310
                }
 
311
        }
 
312
 
 
313
        ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 
314
 
 
315
        kfree(buf);
 
316
 
 
317
        return ret;
 
318
}
 
319
 
 
320
static const struct file_operations dai_list_fops = {
 
321
        .read = dai_list_read_file,
 
322
        .llseek = default_llseek,/* read accesses f_pos */
 
323
};
 
324
 
 
325
static ssize_t platform_list_read_file(struct file *file,
 
326
                                       char __user *user_buf,
 
327
                                       size_t count, loff_t *ppos)
 
328
{
 
329
        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 
330
        ssize_t len, ret = 0;
 
331
        struct snd_soc_platform *platform;
 
332
 
 
333
        if (!buf)
 
334
                return -ENOMEM;
 
335
 
 
336
        list_for_each_entry(platform, &platform_list, list) {
 
337
                len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
 
338
                               platform->name);
 
339
                if (len >= 0)
 
340
                        ret += len;
 
341
                if (ret > PAGE_SIZE) {
 
342
                        ret = PAGE_SIZE;
 
343
                        break;
 
344
                }
 
345
        }
 
346
 
 
347
        ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 
348
 
 
349
        kfree(buf);
 
350
 
 
351
        return ret;
 
352
}
 
353
 
 
354
static const struct file_operations platform_list_fops = {
 
355
        .read = platform_list_read_file,
 
356
        .llseek = default_llseek,/* read accesses f_pos */
 
357
};
 
358
 
 
359
static void soc_init_card_debugfs(struct snd_soc_card *card)
 
360
{
 
361
        card->debugfs_card_root = debugfs_create_dir(card->name,
 
362
                                                     snd_soc_debugfs_root);
 
363
        if (!card->debugfs_card_root) {
 
364
                dev_warn(card->dev,
 
365
                         "ASoC: Failed to create codec debugfs directory\n");
 
366
                return;
 
367
        }
 
368
 
 
369
        card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
 
370
                                                    card->debugfs_card_root,
 
371
                                                    &card->pop_time);
 
372
        if (!card->debugfs_pop_time)
 
373
                dev_warn(card->dev,
 
374
                       "Failed to create pop time debugfs file\n");
 
375
}
 
376
 
 
377
static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 
378
{
 
379
        debugfs_remove_recursive(card->debugfs_card_root);
 
380
}
 
381
 
263
382
#else
264
383
 
265
384
static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
269
388
static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
270
389
{
271
390
}
 
391
 
 
392
static inline void soc_init_card_debugfs(struct snd_soc_card *card)
 
393
{
 
394
}
 
395
 
 
396
static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 
397
{
 
398
}
272
399
#endif
273
400
 
274
401
#ifdef CONFIG_SND_SOC_AC97_BUS
293
420
        codec->ac97->dev.release = soc_ac97_device_release;
294
421
 
295
422
        dev_set_name(&codec->ac97->dev, "%d-%d:%s",
296
 
                     codec->card->number, 0, codec->name);
 
423
                     codec->card->snd_card->number, 0, codec->name);
297
424
        err = device_register(&codec->ac97->dev);
298
425
        if (err < 0) {
299
426
                snd_printk(KERN_ERR "Can't register ac97 bus\n");
307
434
static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream)
308
435
{
309
436
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
310
 
        struct snd_soc_device *socdev = rtd->socdev;
311
 
        struct snd_soc_card *card = socdev->card;
312
 
        struct snd_soc_dai_link *machine = rtd->dai;
313
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
314
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
 
437
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
438
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
315
439
        int ret;
316
440
 
317
 
        if (codec_dai->symmetric_rates || cpu_dai->symmetric_rates ||
318
 
            machine->symmetric_rates) {
319
 
                dev_dbg(card->dev, "Symmetry forces %dHz rate\n",
320
 
                        machine->rate);
 
441
        if (codec_dai->driver->symmetric_rates || cpu_dai->driver->symmetric_rates ||
 
442
                        rtd->dai_link->symmetric_rates) {
 
443
                dev_dbg(&rtd->dev, "Symmetry forces %dHz rate\n",
 
444
                                rtd->rate);
321
445
 
322
446
                ret = snd_pcm_hw_constraint_minmax(substream->runtime,
323
447
                                                   SNDRV_PCM_HW_PARAM_RATE,
324
 
                                                   machine->rate,
325
 
                                                   machine->rate);
 
448
                                                   rtd->rate,
 
449
                                                   rtd->rate);
326
450
                if (ret < 0) {
327
 
                        dev_err(card->dev,
 
451
                        dev_err(&rtd->dev,
328
452
                                "Unable to apply rate symmetry constraint: %d\n", ret);
329
453
                        return ret;
330
454
                }
341
465
static int soc_pcm_open(struct snd_pcm_substream *substream)
342
466
{
343
467
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
344
 
        struct snd_soc_device *socdev = rtd->socdev;
345
 
        struct snd_soc_card *card = socdev->card;
346
468
        struct snd_pcm_runtime *runtime = substream->runtime;
347
 
        struct snd_soc_dai_link *machine = rtd->dai;
348
 
        struct snd_soc_platform *platform = card->platform;
349
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
350
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
 
469
        struct snd_soc_platform *platform = rtd->platform;
 
470
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
471
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 
472
        struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
 
473
        struct snd_soc_dai_driver *codec_dai_drv = codec_dai->driver;
351
474
        int ret = 0;
352
475
 
353
476
        mutex_lock(&pcm_mutex);
354
477
 
355
478
        /* startup the audio subsystem */
356
 
        if (cpu_dai->ops->startup) {
357
 
                ret = cpu_dai->ops->startup(substream, cpu_dai);
 
479
        if (cpu_dai->driver->ops->startup) {
 
480
                ret = cpu_dai->driver->ops->startup(substream, cpu_dai);
358
481
                if (ret < 0) {
359
482
                        printk(KERN_ERR "asoc: can't open interface %s\n",
360
483
                                cpu_dai->name);
362
485
                }
363
486
        }
364
487
 
365
 
        if (platform->pcm_ops->open) {
366
 
                ret = platform->pcm_ops->open(substream);
 
488
        if (platform->driver->ops->open) {
 
489
                ret = platform->driver->ops->open(substream);
367
490
                if (ret < 0) {
368
491
                        printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
369
492
                        goto platform_err;
370
493
                }
371
494
        }
372
495
 
373
 
        if (codec_dai->ops->startup) {
374
 
                ret = codec_dai->ops->startup(substream, codec_dai);
 
496
        if (codec_dai->driver->ops->startup) {
 
497
                ret = codec_dai->driver->ops->startup(substream, codec_dai);
375
498
                if (ret < 0) {
376
499
                        printk(KERN_ERR "asoc: can't open codec %s\n",
377
500
                                codec_dai->name);
379
502
                }
380
503
        }
381
504
 
382
 
        if (machine->ops && machine->ops->startup) {
383
 
                ret = machine->ops->startup(substream);
 
505
        if (rtd->dai_link->ops && rtd->dai_link->ops->startup) {
 
506
                ret = rtd->dai_link->ops->startup(substream);
384
507
                if (ret < 0) {
385
 
                        printk(KERN_ERR "asoc: %s startup failed\n", machine->name);
 
508
                        printk(KERN_ERR "asoc: %s startup failed\n", rtd->dai_link->name);
386
509
                        goto machine_err;
387
510
                }
388
511
        }
389
512
 
390
 
        /* Check that the codec and cpu DAI's are compatible */
 
513
        /* Check that the codec and cpu DAIs are compatible */
391
514
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
392
515
                runtime->hw.rate_min =
393
 
                        max(codec_dai->playback.rate_min,
394
 
                            cpu_dai->playback.rate_min);
 
516
                        max(codec_dai_drv->playback.rate_min,
 
517
                            cpu_dai_drv->playback.rate_min);
395
518
                runtime->hw.rate_max =
396
 
                        min(codec_dai->playback.rate_max,
397
 
                            cpu_dai->playback.rate_max);
 
519
                        min(codec_dai_drv->playback.rate_max,
 
520
                            cpu_dai_drv->playback.rate_max);
398
521
                runtime->hw.channels_min =
399
 
                        max(codec_dai->playback.channels_min,
400
 
                                cpu_dai->playback.channels_min);
 
522
                        max(codec_dai_drv->playback.channels_min,
 
523
                                cpu_dai_drv->playback.channels_min);
401
524
                runtime->hw.channels_max =
402
 
                        min(codec_dai->playback.channels_max,
403
 
                                cpu_dai->playback.channels_max);
 
525
                        min(codec_dai_drv->playback.channels_max,
 
526
                                cpu_dai_drv->playback.channels_max);
404
527
                runtime->hw.formats =
405
 
                        codec_dai->playback.formats & cpu_dai->playback.formats;
 
528
                        codec_dai_drv->playback.formats & cpu_dai_drv->playback.formats;
406
529
                runtime->hw.rates =
407
 
                        codec_dai->playback.rates & cpu_dai->playback.rates;
408
 
                if (codec_dai->playback.rates
409
 
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
410
 
                        runtime->hw.rates |= cpu_dai->playback.rates;
411
 
                if (cpu_dai->playback.rates
412
 
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
413
 
                        runtime->hw.rates |= codec_dai->playback.rates;
 
530
                        codec_dai_drv->playback.rates & cpu_dai_drv->playback.rates;
 
531
                if (codec_dai_drv->playback.rates
 
532
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 
533
                        runtime->hw.rates |= cpu_dai_drv->playback.rates;
 
534
                if (cpu_dai_drv->playback.rates
 
535
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 
536
                        runtime->hw.rates |= codec_dai_drv->playback.rates;
414
537
        } else {
415
538
                runtime->hw.rate_min =
416
 
                        max(codec_dai->capture.rate_min,
417
 
                            cpu_dai->capture.rate_min);
 
539
                        max(codec_dai_drv->capture.rate_min,
 
540
                            cpu_dai_drv->capture.rate_min);
418
541
                runtime->hw.rate_max =
419
 
                        min(codec_dai->capture.rate_max,
420
 
                            cpu_dai->capture.rate_max);
 
542
                        min(codec_dai_drv->capture.rate_max,
 
543
                            cpu_dai_drv->capture.rate_max);
421
544
                runtime->hw.channels_min =
422
 
                        max(codec_dai->capture.channels_min,
423
 
                                cpu_dai->capture.channels_min);
 
545
                        max(codec_dai_drv->capture.channels_min,
 
546
                                cpu_dai_drv->capture.channels_min);
424
547
                runtime->hw.channels_max =
425
 
                        min(codec_dai->capture.channels_max,
426
 
                                cpu_dai->capture.channels_max);
 
548
                        min(codec_dai_drv->capture.channels_max,
 
549
                                cpu_dai_drv->capture.channels_max);
427
550
                runtime->hw.formats =
428
 
                        codec_dai->capture.formats & cpu_dai->capture.formats;
 
551
                        codec_dai_drv->capture.formats & cpu_dai_drv->capture.formats;
429
552
                runtime->hw.rates =
430
 
                        codec_dai->capture.rates & cpu_dai->capture.rates;
431
 
                if (codec_dai->capture.rates
432
 
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
433
 
                        runtime->hw.rates |= cpu_dai->capture.rates;
434
 
                if (cpu_dai->capture.rates
435
 
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
436
 
                        runtime->hw.rates |= codec_dai->capture.rates;
 
553
                        codec_dai_drv->capture.rates & cpu_dai_drv->capture.rates;
 
554
                if (codec_dai_drv->capture.rates
 
555
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 
556
                        runtime->hw.rates |= cpu_dai_drv->capture.rates;
 
557
                if (cpu_dai_drv->capture.rates
 
558
                           & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
 
559
                        runtime->hw.rates |= codec_dai_drv->capture.rates;
437
560
        }
438
561
 
439
562
        snd_pcm_limit_hw_rates(runtime);
449
572
        }
450
573
        if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
451
574
                printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
452
 
                        codec_dai->name, cpu_dai->name);
 
575
                                codec_dai->name, cpu_dai->name);
453
576
                goto config_err;
454
577
        }
455
578
 
460
583
                        goto config_err;
461
584
        }
462
585
 
463
 
        pr_debug("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
 
586
        pr_debug("asoc: %s <-> %s info:\n",
 
587
                        codec_dai->name, cpu_dai->name);
464
588
        pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
465
589
        pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
466
590
                 runtime->hw.channels_max);
468
592
                 runtime->hw.rate_max);
469
593
 
470
594
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
471
 
                cpu_dai->playback.active++;
472
 
                codec_dai->playback.active++;
 
595
                cpu_dai->playback_active++;
 
596
                codec_dai->playback_active++;
473
597
        } else {
474
 
                cpu_dai->capture.active++;
475
 
                codec_dai->capture.active++;
 
598
                cpu_dai->capture_active++;
 
599
                codec_dai->capture_active++;
476
600
        }
477
601
        cpu_dai->active++;
478
602
        codec_dai->active++;
479
 
        card->codec->active++;
 
603
        rtd->codec->active++;
480
604
        mutex_unlock(&pcm_mutex);
481
605
        return 0;
482
606
 
483
607
config_err:
484
 
        if (machine->ops && machine->ops->shutdown)
485
 
                machine->ops->shutdown(substream);
 
608
        if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
 
609
                rtd->dai_link->ops->shutdown(substream);
486
610
 
487
611
machine_err:
488
 
        if (codec_dai->ops->shutdown)
489
 
                codec_dai->ops->shutdown(substream, codec_dai);
 
612
        if (codec_dai->driver->ops->shutdown)
 
613
                codec_dai->driver->ops->shutdown(substream, codec_dai);
490
614
 
491
615
codec_dai_err:
492
 
        if (platform->pcm_ops->close)
493
 
                platform->pcm_ops->close(substream);
 
616
        if (platform->driver->ops->close)
 
617
                platform->driver->ops->close(substream);
494
618
 
495
619
platform_err:
496
 
        if (cpu_dai->ops->shutdown)
497
 
                cpu_dai->ops->shutdown(substream, cpu_dai);
 
620
        if (cpu_dai->driver->ops->shutdown)
 
621
                cpu_dai->driver->ops->shutdown(substream, cpu_dai);
498
622
out:
499
623
        mutex_unlock(&pcm_mutex);
500
624
        return ret;
507
631
 */
508
632
static void close_delayed_work(struct work_struct *work)
509
633
{
510
 
        struct snd_soc_card *card = container_of(work, struct snd_soc_card,
511
 
                                                 delayed_work.work);
512
 
        struct snd_soc_codec *codec = card->codec;
513
 
        struct snd_soc_dai *codec_dai;
514
 
        int i;
 
634
        struct snd_soc_pcm_runtime *rtd =
 
635
                        container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
 
636
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
515
637
 
516
638
        mutex_lock(&pcm_mutex);
517
 
        for (i = 0; i < codec->num_dai; i++) {
518
 
                codec_dai = &codec->dai[i];
519
 
 
520
 
                pr_debug("pop wq checking: %s status: %s waiting: %s\n",
521
 
                         codec_dai->playback.stream_name,
522
 
                         codec_dai->playback.active ? "active" : "inactive",
523
 
                         codec_dai->pop_wait ? "yes" : "no");
524
 
 
525
 
                /* are we waiting on this codec DAI stream */
526
 
                if (codec_dai->pop_wait == 1) {
527
 
                        codec_dai->pop_wait = 0;
528
 
                        snd_soc_dapm_stream_event(codec,
529
 
                                codec_dai->playback.stream_name,
530
 
                                SND_SOC_DAPM_STREAM_STOP);
531
 
                }
 
639
 
 
640
        pr_debug("pop wq checking: %s status: %s waiting: %s\n",
 
641
                 codec_dai->driver->playback.stream_name,
 
642
                 codec_dai->playback_active ? "active" : "inactive",
 
643
                 codec_dai->pop_wait ? "yes" : "no");
 
644
 
 
645
        /* are we waiting on this codec DAI stream */
 
646
        if (codec_dai->pop_wait == 1) {
 
647
                codec_dai->pop_wait = 0;
 
648
                snd_soc_dapm_stream_event(rtd,
 
649
                        codec_dai->driver->playback.stream_name,
 
650
                        SND_SOC_DAPM_STREAM_STOP);
532
651
        }
 
652
 
533
653
        mutex_unlock(&pcm_mutex);
534
654
}
535
655
 
541
661
static int soc_codec_close(struct snd_pcm_substream *substream)
542
662
{
543
663
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
544
 
        struct snd_soc_device *socdev = rtd->socdev;
545
 
        struct snd_soc_card *card = socdev->card;
546
 
        struct snd_soc_dai_link *machine = rtd->dai;
547
 
        struct snd_soc_platform *platform = card->platform;
548
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
549
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
550
 
        struct snd_soc_codec *codec = card->codec;
 
664
        struct snd_soc_platform *platform = rtd->platform;
 
665
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
666
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 
667
        struct snd_soc_codec *codec = rtd->codec;
551
668
 
552
669
        mutex_lock(&pcm_mutex);
553
670
 
554
671
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
555
 
                cpu_dai->playback.active--;
556
 
                codec_dai->playback.active--;
 
672
                cpu_dai->playback_active--;
 
673
                codec_dai->playback_active--;
557
674
        } else {
558
 
                cpu_dai->capture.active--;
559
 
                codec_dai->capture.active--;
 
675
                cpu_dai->capture_active--;
 
676
                codec_dai->capture_active--;
560
677
        }
561
678
 
562
679
        cpu_dai->active--;
569
686
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
570
687
                snd_soc_dai_digital_mute(codec_dai, 1);
571
688
 
572
 
        if (cpu_dai->ops->shutdown)
573
 
                cpu_dai->ops->shutdown(substream, cpu_dai);
574
 
 
575
 
        if (codec_dai->ops->shutdown)
576
 
                codec_dai->ops->shutdown(substream, codec_dai);
577
 
 
578
 
        if (machine->ops && machine->ops->shutdown)
579
 
                machine->ops->shutdown(substream);
580
 
 
581
 
        if (platform->pcm_ops->close)
582
 
                platform->pcm_ops->close(substream);
 
689
        if (cpu_dai->driver->ops->shutdown)
 
690
                cpu_dai->driver->ops->shutdown(substream, cpu_dai);
 
691
 
 
692
        if (codec_dai->driver->ops->shutdown)
 
693
                codec_dai->driver->ops->shutdown(substream, codec_dai);
 
694
 
 
695
        if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
 
696
                rtd->dai_link->ops->shutdown(substream);
 
697
 
 
698
        if (platform->driver->ops->close)
 
699
                platform->driver->ops->close(substream);
 
700
        cpu_dai->runtime = NULL;
583
701
 
584
702
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
585
703
                /* start delayed pop wq here for playback streams */
586
704
                codec_dai->pop_wait = 1;
587
 
                schedule_delayed_work(&card->delayed_work,
588
 
                        msecs_to_jiffies(card->pmdown_time));
 
705
                schedule_delayed_work(&rtd->delayed_work,
 
706
                        msecs_to_jiffies(rtd->pmdown_time));
589
707
        } else {
590
708
                /* capture streams can be powered down now */
591
 
                snd_soc_dapm_stream_event(codec,
592
 
                        codec_dai->capture.stream_name,
 
709
                snd_soc_dapm_stream_event(rtd,
 
710
                        codec_dai->driver->capture.stream_name,
593
711
                        SND_SOC_DAPM_STREAM_STOP);
594
712
        }
595
713
 
605
723
static int soc_pcm_prepare(struct snd_pcm_substream *substream)
606
724
{
607
725
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
608
 
        struct snd_soc_device *socdev = rtd->socdev;
609
 
        struct snd_soc_card *card = socdev->card;
610
 
        struct snd_soc_dai_link *machine = rtd->dai;
611
 
        struct snd_soc_platform *platform = card->platform;
612
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
613
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
614
 
        struct snd_soc_codec *codec = card->codec;
 
726
        struct snd_soc_platform *platform = rtd->platform;
 
727
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
728
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
615
729
        int ret = 0;
616
730
 
617
731
        mutex_lock(&pcm_mutex);
618
732
 
619
 
        if (machine->ops && machine->ops->prepare) {
620
 
                ret = machine->ops->prepare(substream);
 
733
        if (rtd->dai_link->ops && rtd->dai_link->ops->prepare) {
 
734
                ret = rtd->dai_link->ops->prepare(substream);
621
735
                if (ret < 0) {
622
736
                        printk(KERN_ERR "asoc: machine prepare error\n");
623
737
                        goto out;
624
738
                }
625
739
        }
626
740
 
627
 
        if (platform->pcm_ops->prepare) {
628
 
                ret = platform->pcm_ops->prepare(substream);
 
741
        if (platform->driver->ops->prepare) {
 
742
                ret = platform->driver->ops->prepare(substream);
629
743
                if (ret < 0) {
630
744
                        printk(KERN_ERR "asoc: platform prepare error\n");
631
745
                        goto out;
632
746
                }
633
747
        }
634
748
 
635
 
        if (codec_dai->ops->prepare) {
636
 
                ret = codec_dai->ops->prepare(substream, codec_dai);
 
749
        if (codec_dai->driver->ops->prepare) {
 
750
                ret = codec_dai->driver->ops->prepare(substream, codec_dai);
637
751
                if (ret < 0) {
638
752
                        printk(KERN_ERR "asoc: codec DAI prepare error\n");
639
753
                        goto out;
640
754
                }
641
755
        }
642
756
 
643
 
        if (cpu_dai->ops->prepare) {
644
 
                ret = cpu_dai->ops->prepare(substream, cpu_dai);
 
757
        if (cpu_dai->driver->ops->prepare) {
 
758
                ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
645
759
                if (ret < 0) {
646
760
                        printk(KERN_ERR "asoc: cpu DAI prepare error\n");
647
761
                        goto out;
652
766
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
653
767
            codec_dai->pop_wait) {
654
768
                codec_dai->pop_wait = 0;
655
 
                cancel_delayed_work(&card->delayed_work);
 
769
                cancel_delayed_work(&rtd->delayed_work);
656
770
        }
657
771
 
658
772
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
659
 
                snd_soc_dapm_stream_event(codec,
660
 
                                          codec_dai->playback.stream_name,
 
773
                snd_soc_dapm_stream_event(rtd,
 
774
                                          codec_dai->driver->playback.stream_name,
661
775
                                          SND_SOC_DAPM_STREAM_START);
662
776
        else
663
 
                snd_soc_dapm_stream_event(codec,
664
 
                                          codec_dai->capture.stream_name,
 
777
                snd_soc_dapm_stream_event(rtd,
 
778
                                          codec_dai->driver->capture.stream_name,
665
779
                                          SND_SOC_DAPM_STREAM_START);
666
780
 
667
781
        snd_soc_dai_digital_mute(codec_dai, 0);
680
794
                                struct snd_pcm_hw_params *params)
681
795
{
682
796
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
683
 
        struct snd_soc_device *socdev = rtd->socdev;
684
 
        struct snd_soc_dai_link *machine = rtd->dai;
685
 
        struct snd_soc_card *card = socdev->card;
686
 
        struct snd_soc_platform *platform = card->platform;
687
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
688
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
 
797
        struct snd_soc_platform *platform = rtd->platform;
 
798
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
799
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
689
800
        int ret = 0;
690
801
 
691
802
        mutex_lock(&pcm_mutex);
692
803
 
693
 
        if (machine->ops && machine->ops->hw_params) {
694
 
                ret = machine->ops->hw_params(substream, params);
 
804
        if (rtd->dai_link->ops && rtd->dai_link->ops->hw_params) {
 
805
                ret = rtd->dai_link->ops->hw_params(substream, params);
695
806
                if (ret < 0) {
696
807
                        printk(KERN_ERR "asoc: machine hw_params failed\n");
697
808
                        goto out;
698
809
                }
699
810
        }
700
811
 
701
 
        if (codec_dai->ops->hw_params) {
702
 
                ret = codec_dai->ops->hw_params(substream, params, codec_dai);
 
812
        if (codec_dai->driver->ops->hw_params) {
 
813
                ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
703
814
                if (ret < 0) {
704
815
                        printk(KERN_ERR "asoc: can't set codec %s hw params\n",
705
816
                                codec_dai->name);
707
818
                }
708
819
        }
709
820
 
710
 
        if (cpu_dai->ops->hw_params) {
711
 
                ret = cpu_dai->ops->hw_params(substream, params, cpu_dai);
 
821
        if (cpu_dai->driver->ops->hw_params) {
 
822
                ret = cpu_dai->driver->ops->hw_params(substream, params, cpu_dai);
712
823
                if (ret < 0) {
713
824
                        printk(KERN_ERR "asoc: interface %s hw params failed\n",
714
825
                                cpu_dai->name);
716
827
                }
717
828
        }
718
829
 
719
 
        if (platform->pcm_ops->hw_params) {
720
 
                ret = platform->pcm_ops->hw_params(substream, params);
 
830
        if (platform->driver->ops->hw_params) {
 
831
                ret = platform->driver->ops->hw_params(substream, params);
721
832
                if (ret < 0) {
722
833
                        printk(KERN_ERR "asoc: platform %s hw params failed\n",
723
834
                                platform->name);
725
836
                }
726
837
        }
727
838
 
728
 
        machine->rate = params_rate(params);
 
839
        rtd->rate = params_rate(params);
729
840
 
730
841
out:
731
842
        mutex_unlock(&pcm_mutex);
732
843
        return ret;
733
844
 
734
845
platform_err:
735
 
        if (cpu_dai->ops->hw_free)
736
 
                cpu_dai->ops->hw_free(substream, cpu_dai);
 
846
        if (cpu_dai->driver->ops->hw_free)
 
847
                cpu_dai->driver->ops->hw_free(substream, cpu_dai);
737
848
 
738
849
interface_err:
739
 
        if (codec_dai->ops->hw_free)
740
 
                codec_dai->ops->hw_free(substream, codec_dai);
 
850
        if (codec_dai->driver->ops->hw_free)
 
851
                codec_dai->driver->ops->hw_free(substream, codec_dai);
741
852
 
742
853
codec_err:
743
 
        if (machine->ops && machine->ops->hw_free)
744
 
                machine->ops->hw_free(substream);
 
854
        if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
 
855
                rtd->dai_link->ops->hw_free(substream);
745
856
 
746
857
        mutex_unlock(&pcm_mutex);
747
858
        return ret;
748
859
}
749
860
 
750
861
/*
751
 
 * Free's resources allocated by hw_params, can be called multiple times
 
862
 * Frees resources allocated by hw_params, can be called multiple times
752
863
 */
753
864
static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
754
865
{
755
866
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
756
 
        struct snd_soc_device *socdev = rtd->socdev;
757
 
        struct snd_soc_dai_link *machine = rtd->dai;
758
 
        struct snd_soc_card *card = socdev->card;
759
 
        struct snd_soc_platform *platform = card->platform;
760
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
761
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
762
 
        struct snd_soc_codec *codec = card->codec;
 
867
        struct snd_soc_platform *platform = rtd->platform;
 
868
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
869
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 
870
        struct snd_soc_codec *codec = rtd->codec;
763
871
 
764
872
        mutex_lock(&pcm_mutex);
765
873
 
768
876
                snd_soc_dai_digital_mute(codec_dai, 1);
769
877
 
770
878
        /* free any machine hw params */
771
 
        if (machine->ops && machine->ops->hw_free)
772
 
                machine->ops->hw_free(substream);
 
879
        if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
 
880
                rtd->dai_link->ops->hw_free(substream);
773
881
 
774
882
        /* free any DMA resources */
775
 
        if (platform->pcm_ops->hw_free)
776
 
                platform->pcm_ops->hw_free(substream);
777
 
 
778
 
        /* now free hw params for the DAI's  */
779
 
        if (codec_dai->ops->hw_free)
780
 
                codec_dai->ops->hw_free(substream, codec_dai);
781
 
 
782
 
        if (cpu_dai->ops->hw_free)
783
 
                cpu_dai->ops->hw_free(substream, cpu_dai);
 
883
        if (platform->driver->ops->hw_free)
 
884
                platform->driver->ops->hw_free(substream);
 
885
 
 
886
        /* now free hw params for the DAIs  */
 
887
        if (codec_dai->driver->ops->hw_free)
 
888
                codec_dai->driver->ops->hw_free(substream, codec_dai);
 
889
 
 
890
        if (cpu_dai->driver->ops->hw_free)
 
891
                cpu_dai->driver->ops->hw_free(substream, cpu_dai);
784
892
 
785
893
        mutex_unlock(&pcm_mutex);
786
894
        return 0;
789
897
static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
790
898
{
791
899
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
792
 
        struct snd_soc_device *socdev = rtd->socdev;
793
 
        struct snd_soc_card *card= socdev->card;
794
 
        struct snd_soc_dai_link *machine = rtd->dai;
795
 
        struct snd_soc_platform *platform = card->platform;
796
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
797
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
 
900
        struct snd_soc_platform *platform = rtd->platform;
 
901
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
902
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
798
903
        int ret;
799
904
 
800
 
        if (codec_dai->ops->trigger) {
801
 
                ret = codec_dai->ops->trigger(substream, cmd, codec_dai);
802
 
                if (ret < 0)
803
 
                        return ret;
804
 
        }
805
 
 
806
 
        if (platform->pcm_ops->trigger) {
807
 
                ret = platform->pcm_ops->trigger(substream, cmd);
808
 
                if (ret < 0)
809
 
                        return ret;
810
 
        }
811
 
 
812
 
        if (cpu_dai->ops->trigger) {
813
 
                ret = cpu_dai->ops->trigger(substream, cmd, cpu_dai);
 
905
        if (codec_dai->driver->ops->trigger) {
 
906
                ret = codec_dai->driver->ops->trigger(substream, cmd, codec_dai);
 
907
                if (ret < 0)
 
908
                        return ret;
 
909
        }
 
910
 
 
911
        if (platform->driver->ops->trigger) {
 
912
                ret = platform->driver->ops->trigger(substream, cmd);
 
913
                if (ret < 0)
 
914
                        return ret;
 
915
        }
 
916
 
 
917
        if (cpu_dai->driver->ops->trigger) {
 
918
                ret = cpu_dai->driver->ops->trigger(substream, cmd, cpu_dai);
814
919
                if (ret < 0)
815
920
                        return ret;
816
921
        }
825
930
static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
826
931
{
827
932
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
828
 
        struct snd_soc_device *socdev = rtd->socdev;
829
 
        struct snd_soc_card *card = socdev->card;
830
 
        struct snd_soc_platform *platform = card->platform;
831
 
        struct snd_soc_dai_link *machine = rtd->dai;
832
 
        struct snd_soc_dai *cpu_dai = machine->cpu_dai;
833
 
        struct snd_soc_dai *codec_dai = machine->codec_dai;
 
933
        struct snd_soc_platform *platform = rtd->platform;
 
934
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
935
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
834
936
        struct snd_pcm_runtime *runtime = substream->runtime;
835
937
        snd_pcm_uframes_t offset = 0;
836
938
        snd_pcm_sframes_t delay = 0;
837
939
 
838
 
        if (platform->pcm_ops->pointer)
839
 
                offset = platform->pcm_ops->pointer(substream);
840
 
 
841
 
        if (cpu_dai->ops->delay)
842
 
                delay += cpu_dai->ops->delay(substream, cpu_dai);
843
 
 
844
 
        if (codec_dai->ops->delay)
845
 
                delay += codec_dai->ops->delay(substream, codec_dai);
846
 
 
847
 
        if (platform->delay)
848
 
                delay += platform->delay(substream, codec_dai);
 
940
        if (platform->driver->ops->pointer)
 
941
                offset = platform->driver->ops->pointer(substream);
 
942
 
 
943
        if (cpu_dai->driver->ops->delay)
 
944
                delay += cpu_dai->driver->ops->delay(substream, cpu_dai);
 
945
 
 
946
        if (codec_dai->driver->ops->delay)
 
947
                delay += codec_dai->driver->ops->delay(substream, codec_dai);
 
948
 
 
949
        if (platform->driver->delay)
 
950
                delay += platform->driver->delay(substream, codec_dai);
849
951
 
850
952
        runtime->delay = delay;
851
953
 
868
970
static int soc_suspend(struct device *dev)
869
971
{
870
972
        struct platform_device *pdev = to_platform_device(dev);
871
 
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
872
 
        struct snd_soc_card *card = socdev->card;
873
 
        struct snd_soc_platform *platform = card->platform;
874
 
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
875
 
        struct snd_soc_codec *codec = card->codec;
 
973
        struct snd_soc_card *card = platform_get_drvdata(pdev);
 
974
        struct snd_soc_codec *codec;
876
975
        int i;
877
976
 
878
977
        /* If the initialization of this soc device failed, there is no codec
879
978
         * associated with it. Just bail out in this case.
880
979
         */
881
 
        if (!codec)
 
980
        if (list_empty(&card->codec_dev_list))
882
981
                return 0;
883
982
 
884
983
        /* Due to the resume being scheduled into a workqueue we could
885
984
        * suspend before that's finished - wait for it to complete.
886
985
         */
887
 
        snd_power_lock(codec->card);
888
 
        snd_power_wait(codec->card, SNDRV_CTL_POWER_D0);
889
 
        snd_power_unlock(codec->card);
 
986
        snd_power_lock(card->snd_card);
 
987
        snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
 
988
        snd_power_unlock(card->snd_card);
890
989
 
891
990
        /* we're going to block userspace touching us until resume completes */
892
 
        snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
893
 
 
894
 
        /* mute any active DAC's */
895
 
        for (i = 0; i < card->num_links; i++) {
896
 
                struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
897
 
                if (dai->ops->digital_mute && dai->playback.active)
898
 
                        dai->ops->digital_mute(dai, 1);
 
991
        snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
 
992
 
 
993
        /* mute any active DACs */
 
994
        for (i = 0; i < card->num_rtd; i++) {
 
995
                struct snd_soc_dai *dai = card->rtd[i].codec_dai;
 
996
                struct snd_soc_dai_driver *drv = dai->driver;
 
997
 
 
998
                if (card->rtd[i].dai_link->ignore_suspend)
 
999
                        continue;
 
1000
 
 
1001
                if (drv->ops->digital_mute && dai->playback_active)
 
1002
                        drv->ops->digital_mute(dai, 1);
899
1003
        }
900
1004
 
901
1005
        /* suspend all pcms */
902
 
        for (i = 0; i < card->num_links; i++)
903
 
                snd_pcm_suspend_all(card->dai_link[i].pcm);
 
1006
        for (i = 0; i < card->num_rtd; i++) {
 
1007
                if (card->rtd[i].dai_link->ignore_suspend)
 
1008
                        continue;
 
1009
 
 
1010
                snd_pcm_suspend_all(card->rtd[i].pcm);
 
1011
        }
904
1012
 
905
1013
        if (card->suspend_pre)
906
1014
                card->suspend_pre(pdev, PMSG_SUSPEND);
907
1015
 
908
 
        for (i = 0; i < card->num_links; i++) {
909
 
                struct snd_soc_dai  *cpu_dai = card->dai_link[i].cpu_dai;
910
 
                if (cpu_dai->suspend && !cpu_dai->ac97_control)
911
 
                        cpu_dai->suspend(cpu_dai);
912
 
                if (platform->suspend)
913
 
                        platform->suspend(&card->dai_link[i]);
 
1016
        for (i = 0; i < card->num_rtd; i++) {
 
1017
                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
 
1018
                struct snd_soc_platform *platform = card->rtd[i].platform;
 
1019
 
 
1020
                if (card->rtd[i].dai_link->ignore_suspend)
 
1021
                        continue;
 
1022
 
 
1023
                if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
 
1024
                        cpu_dai->driver->suspend(cpu_dai);
 
1025
                if (platform->driver->suspend && !platform->suspended) {
 
1026
                        platform->driver->suspend(cpu_dai);
 
1027
                        platform->suspended = 1;
 
1028
                }
914
1029
        }
915
1030
 
916
1031
        /* close any waiting streams and save state */
917
 
        run_delayed_work(&card->delayed_work);
918
 
        codec->suspend_bias_level = codec->bias_level;
919
 
 
920
 
        for (i = 0; i < codec->num_dai; i++) {
921
 
                char *stream = codec->dai[i].playback.stream_name;
922
 
                if (stream != NULL)
923
 
                        snd_soc_dapm_stream_event(codec, stream,
924
 
                                SND_SOC_DAPM_STREAM_SUSPEND);
925
 
                stream = codec->dai[i].capture.stream_name;
926
 
                if (stream != NULL)
927
 
                        snd_soc_dapm_stream_event(codec, stream,
928
 
                                SND_SOC_DAPM_STREAM_SUSPEND);
929
 
        }
930
 
 
931
 
        if (codec_dev->suspend)
932
 
                codec_dev->suspend(pdev, PMSG_SUSPEND);
933
 
 
934
 
        for (i = 0; i < card->num_links; i++) {
935
 
                struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
936
 
                if (cpu_dai->suspend && cpu_dai->ac97_control)
937
 
                        cpu_dai->suspend(cpu_dai);
 
1032
        for (i = 0; i < card->num_rtd; i++) {
 
1033
                flush_delayed_work_sync(&card->rtd[i].delayed_work);
 
1034
                card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
 
1035
        }
 
1036
 
 
1037
        for (i = 0; i < card->num_rtd; i++) {
 
1038
                struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
 
1039
 
 
1040
                if (card->rtd[i].dai_link->ignore_suspend)
 
1041
                        continue;
 
1042
 
 
1043
                if (driver->playback.stream_name != NULL)
 
1044
                        snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
 
1045
                                SND_SOC_DAPM_STREAM_SUSPEND);
 
1046
 
 
1047
                if (driver->capture.stream_name != NULL)
 
1048
                        snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
 
1049
                                SND_SOC_DAPM_STREAM_SUSPEND);
 
1050
        }
 
1051
 
 
1052
        /* suspend all CODECs */
 
1053
        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
 
1054
                /* If there are paths active then the CODEC will be held with
 
1055
                 * bias _ON and should not be suspended. */
 
1056
                if (!codec->suspended && codec->driver->suspend) {
 
1057
                        switch (codec->dapm.bias_level) {
 
1058
                        case SND_SOC_BIAS_STANDBY:
 
1059
                        case SND_SOC_BIAS_OFF:
 
1060
                                codec->driver->suspend(codec, PMSG_SUSPEND);
 
1061
                                codec->suspended = 1;
 
1062
                                break;
 
1063
                        default:
 
1064
                                dev_dbg(codec->dev, "CODEC is on over suspend\n");
 
1065
                                break;
 
1066
                        }
 
1067
                }
 
1068
        }
 
1069
 
 
1070
        for (i = 0; i < card->num_rtd; i++) {
 
1071
                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
 
1072
 
 
1073
                if (card->rtd[i].dai_link->ignore_suspend)
 
1074
                        continue;
 
1075
 
 
1076
                if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
 
1077
                        cpu_dai->driver->suspend(cpu_dai);
938
1078
        }
939
1079
 
940
1080
        if (card->suspend_post)
948
1088
 */
949
1089
static void soc_resume_deferred(struct work_struct *work)
950
1090
{
951
 
        struct snd_soc_card *card = container_of(work,
952
 
                                                 struct snd_soc_card,
953
 
                                                 deferred_resume_work);
954
 
        struct snd_soc_device *socdev = card->socdev;
955
 
        struct snd_soc_platform *platform = card->platform;
956
 
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
957
 
        struct snd_soc_codec *codec = card->codec;
958
 
        struct platform_device *pdev = to_platform_device(socdev->dev);
 
1091
        struct snd_soc_card *card =
 
1092
                        container_of(work, struct snd_soc_card, deferred_resume_work);
 
1093
        struct platform_device *pdev = to_platform_device(card->dev);
 
1094
        struct snd_soc_codec *codec;
959
1095
        int i;
960
1096
 
961
1097
        /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
962
1098
         * so userspace apps are blocked from touching us
963
1099
         */
964
1100
 
965
 
        dev_dbg(socdev->dev, "starting resume work\n");
 
1101
        dev_dbg(card->dev, "starting resume work\n");
 
1102
 
 
1103
        /* Bring us up into D2 so that DAPM starts enabling things */
 
1104
        snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
966
1105
 
967
1106
        if (card->resume_pre)
968
1107
                card->resume_pre(pdev);
969
1108
 
970
 
        for (i = 0; i < card->num_links; i++) {
971
 
                struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
972
 
                if (cpu_dai->resume && cpu_dai->ac97_control)
973
 
                        cpu_dai->resume(cpu_dai);
974
 
        }
975
 
 
976
 
        if (codec_dev->resume)
977
 
                codec_dev->resume(pdev);
978
 
 
979
 
        for (i = 0; i < codec->num_dai; i++) {
980
 
                char *stream = codec->dai[i].playback.stream_name;
981
 
                if (stream != NULL)
982
 
                        snd_soc_dapm_stream_event(codec, stream,
 
1109
        /* resume AC97 DAIs */
 
1110
        for (i = 0; i < card->num_rtd; i++) {
 
1111
                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
 
1112
 
 
1113
                if (card->rtd[i].dai_link->ignore_suspend)
 
1114
                        continue;
 
1115
 
 
1116
                if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
 
1117
                        cpu_dai->driver->resume(cpu_dai);
 
1118
        }
 
1119
 
 
1120
        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
 
1121
                /* If the CODEC was idle over suspend then it will have been
 
1122
                 * left with bias OFF or STANDBY and suspended so we must now
 
1123
                 * resume.  Otherwise the suspend was suppressed.
 
1124
                 */
 
1125
                if (codec->driver->resume && codec->suspended) {
 
1126
                        switch (codec->dapm.bias_level) {
 
1127
                        case SND_SOC_BIAS_STANDBY:
 
1128
                        case SND_SOC_BIAS_OFF:
 
1129
                                codec->driver->resume(codec);
 
1130
                                codec->suspended = 0;
 
1131
                                break;
 
1132
                        default:
 
1133
                                dev_dbg(codec->dev, "CODEC was on over suspend\n");
 
1134
                                break;
 
1135
                        }
 
1136
                }
 
1137
        }
 
1138
 
 
1139
        for (i = 0; i < card->num_rtd; i++) {
 
1140
                struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
 
1141
 
 
1142
                if (card->rtd[i].dai_link->ignore_suspend)
 
1143
                        continue;
 
1144
 
 
1145
                if (driver->playback.stream_name != NULL)
 
1146
                        snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
983
1147
                                SND_SOC_DAPM_STREAM_RESUME);
984
 
                stream = codec->dai[i].capture.stream_name;
985
 
                if (stream != NULL)
986
 
                        snd_soc_dapm_stream_event(codec, stream,
 
1148
 
 
1149
                if (driver->capture.stream_name != NULL)
 
1150
                        snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
987
1151
                                SND_SOC_DAPM_STREAM_RESUME);
988
1152
        }
989
1153
 
990
1154
        /* unmute any active DACs */
991
 
        for (i = 0; i < card->num_links; i++) {
992
 
                struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
993
 
                if (dai->ops->digital_mute && dai->playback.active)
994
 
                        dai->ops->digital_mute(dai, 0);
 
1155
        for (i = 0; i < card->num_rtd; i++) {
 
1156
                struct snd_soc_dai *dai = card->rtd[i].codec_dai;
 
1157
                struct snd_soc_dai_driver *drv = dai->driver;
 
1158
 
 
1159
                if (card->rtd[i].dai_link->ignore_suspend)
 
1160
                        continue;
 
1161
 
 
1162
                if (drv->ops->digital_mute && dai->playback_active)
 
1163
                        drv->ops->digital_mute(dai, 0);
995
1164
        }
996
1165
 
997
 
        for (i = 0; i < card->num_links; i++) {
998
 
                struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
999
 
                if (cpu_dai->resume && !cpu_dai->ac97_control)
1000
 
                        cpu_dai->resume(cpu_dai);
1001
 
                if (platform->resume)
1002
 
                        platform->resume(&card->dai_link[i]);
 
1166
        for (i = 0; i < card->num_rtd; i++) {
 
1167
                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
 
1168
                struct snd_soc_platform *platform = card->rtd[i].platform;
 
1169
 
 
1170
                if (card->rtd[i].dai_link->ignore_suspend)
 
1171
                        continue;
 
1172
 
 
1173
                if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
 
1174
                        cpu_dai->driver->resume(cpu_dai);
 
1175
                if (platform->driver->resume && platform->suspended) {
 
1176
                        platform->driver->resume(cpu_dai);
 
1177
                        platform->suspended = 0;
 
1178
                }
1003
1179
        }
1004
1180
 
1005
1181
        if (card->resume_post)
1006
1182
                card->resume_post(pdev);
1007
1183
 
1008
 
        dev_dbg(socdev->dev, "resume work completed\n");
 
1184
        dev_dbg(card->dev, "resume work completed\n");
1009
1185
 
1010
1186
        /* userspace can access us now we are back as we were before */
1011
 
        snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
 
1187
        snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
1012
1188
}
1013
1189
 
1014
1190
/* powers up audio subsystem after a suspend */
1015
1191
static int soc_resume(struct device *dev)
1016
1192
{
1017
1193
        struct platform_device *pdev = to_platform_device(dev);
1018
 
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1019
 
        struct snd_soc_card *card = socdev->card;
1020
 
        struct snd_soc_dai *cpu_dai = card->dai_link[0].cpu_dai;
1021
 
 
1022
 
        /* If the initialization of this soc device failed, there is no codec
1023
 
         * associated with it. Just bail out in this case.
1024
 
         */
1025
 
        if (!card->codec)
1026
 
                return 0;
 
1194
        struct snd_soc_card *card = platform_get_drvdata(pdev);
 
1195
        int i;
1027
1196
 
1028
1197
        /* AC97 devices might have other drivers hanging off them so
1029
1198
         * need to resume immediately.  Other drivers don't have that
1030
1199
         * problem and may take a substantial amount of time to resume
1031
1200
         * due to I/O costs and anti-pop so handle them out of line.
1032
1201
         */
1033
 
        if (cpu_dai->ac97_control) {
1034
 
                dev_dbg(socdev->dev, "Resuming AC97 immediately\n");
1035
 
                soc_resume_deferred(&card->deferred_resume_work);
1036
 
        } else {
1037
 
                dev_dbg(socdev->dev, "Scheduling resume work\n");
1038
 
                if (!schedule_work(&card->deferred_resume_work))
1039
 
                        dev_err(socdev->dev, "resume work item may be lost\n");
 
1202
        for (i = 0; i < card->num_rtd; i++) {
 
1203
                struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
 
1204
                if (cpu_dai->driver->ac97_control) {
 
1205
                        dev_dbg(dev, "Resuming AC97 immediately\n");
 
1206
                        soc_resume_deferred(&card->deferred_resume_work);
 
1207
                } else {
 
1208
                        dev_dbg(dev, "Scheduling resume work\n");
 
1209
                        if (!schedule_work(&card->deferred_resume_work))
 
1210
                                dev_err(dev, "resume work item may be lost\n");
 
1211
                }
1040
1212
        }
1041
1213
 
1042
1214
        return 0;
1049
1221
static struct snd_soc_dai_ops null_dai_ops = {
1050
1222
};
1051
1223
 
 
1224
static int soc_bind_dai_link(struct snd_soc_card *card, int num)
 
1225
{
 
1226
        struct snd_soc_dai_link *dai_link = &card->dai_link[num];
 
1227
        struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
 
1228
        struct snd_soc_codec *codec;
 
1229
        struct snd_soc_platform *platform;
 
1230
        struct snd_soc_dai *codec_dai, *cpu_dai;
 
1231
 
 
1232
        if (rtd->complete)
 
1233
                return 1;
 
1234
        dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
 
1235
 
 
1236
        /* do we already have the CPU DAI for this link ? */
 
1237
        if (rtd->cpu_dai) {
 
1238
                goto find_codec;
 
1239
        }
 
1240
        /* no, then find CPU DAI from registered DAIs*/
 
1241
        list_for_each_entry(cpu_dai, &dai_list, list) {
 
1242
                if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {
 
1243
 
 
1244
                        if (!try_module_get(cpu_dai->dev->driver->owner))
 
1245
                                return -ENODEV;
 
1246
 
 
1247
                        rtd->cpu_dai = cpu_dai;
 
1248
                        goto find_codec;
 
1249
                }
 
1250
        }
 
1251
        dev_dbg(card->dev, "CPU DAI %s not registered\n",
 
1252
                        dai_link->cpu_dai_name);
 
1253
 
 
1254
find_codec:
 
1255
        /* do we already have the CODEC for this link ? */
 
1256
        if (rtd->codec) {
 
1257
                goto find_platform;
 
1258
        }
 
1259
 
 
1260
        /* no, then find CODEC from registered CODECs*/
 
1261
        list_for_each_entry(codec, &codec_list, list) {
 
1262
                if (!strcmp(codec->name, dai_link->codec_name)) {
 
1263
                        rtd->codec = codec;
 
1264
 
 
1265
                        /* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
 
1266
                        list_for_each_entry(codec_dai, &dai_list, list) {
 
1267
                                if (codec->dev == codec_dai->dev &&
 
1268
                                                !strcmp(codec_dai->name, dai_link->codec_dai_name)) {
 
1269
                                        rtd->codec_dai = codec_dai;
 
1270
                                        goto find_platform;
 
1271
                                }
 
1272
                        }
 
1273
                        dev_dbg(card->dev, "CODEC DAI %s not registered\n",
 
1274
                                        dai_link->codec_dai_name);
 
1275
 
 
1276
                        goto find_platform;
 
1277
                }
 
1278
        }
 
1279
        dev_dbg(card->dev, "CODEC %s not registered\n",
 
1280
                        dai_link->codec_name);
 
1281
 
 
1282
find_platform:
 
1283
        /* do we already have the CODEC DAI for this link ? */
 
1284
        if (rtd->platform) {
 
1285
                goto out;
 
1286
        }
 
1287
        /* no, then find CPU DAI from registered DAIs*/
 
1288
        list_for_each_entry(platform, &platform_list, list) {
 
1289
                if (!strcmp(platform->name, dai_link->platform_name)) {
 
1290
                        rtd->platform = platform;
 
1291
                        goto out;
 
1292
                }
 
1293
        }
 
1294
 
 
1295
        dev_dbg(card->dev, "platform %s not registered\n",
 
1296
                        dai_link->platform_name);
 
1297
        return 0;
 
1298
 
 
1299
out:
 
1300
        /* mark rtd as complete if we found all 4 of our client devices */
 
1301
        if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
 
1302
                rtd->complete = 1;
 
1303
                card->num_rtd++;
 
1304
        }
 
1305
        return 1;
 
1306
}
 
1307
 
 
1308
static void soc_remove_codec(struct snd_soc_codec *codec)
 
1309
{
 
1310
        int err;
 
1311
 
 
1312
        if (codec->driver->remove) {
 
1313
                err = codec->driver->remove(codec);
 
1314
                if (err < 0)
 
1315
                        dev_err(codec->dev,
 
1316
                                "asoc: failed to remove %s: %d\n",
 
1317
                                codec->name, err);
 
1318
        }
 
1319
 
 
1320
        /* Make sure all DAPM widgets are freed */
 
1321
        snd_soc_dapm_free(&codec->dapm);
 
1322
 
 
1323
        soc_cleanup_codec_debugfs(codec);
 
1324
        codec->probed = 0;
 
1325
        list_del(&codec->card_list);
 
1326
        module_put(codec->dev->driver->owner);
 
1327
}
 
1328
 
 
1329
static void soc_remove_dai_link(struct snd_soc_card *card, int num)
 
1330
{
 
1331
        struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
 
1332
        struct snd_soc_codec *codec = rtd->codec;
 
1333
        struct snd_soc_platform *platform = rtd->platform;
 
1334
        struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
 
1335
        int err;
 
1336
 
 
1337
        /* unregister the rtd device */
 
1338
        if (rtd->dev_registered) {
 
1339
                device_remove_file(&rtd->dev, &dev_attr_pmdown_time);
 
1340
                device_remove_file(&rtd->dev, &dev_attr_codec_reg);
 
1341
                device_unregister(&rtd->dev);
 
1342
                rtd->dev_registered = 0;
 
1343
        }
 
1344
 
 
1345
        /* remove the CODEC DAI */
 
1346
        if (codec_dai && codec_dai->probed) {
 
1347
                if (codec_dai->driver->remove) {
 
1348
                        err = codec_dai->driver->remove(codec_dai);
 
1349
                        if (err < 0)
 
1350
                                printk(KERN_ERR "asoc: failed to remove %s\n", codec_dai->name);
 
1351
                }
 
1352
                codec_dai->probed = 0;
 
1353
                list_del(&codec_dai->card_list);
 
1354
        }
 
1355
 
 
1356
        /* remove the platform */
 
1357
        if (platform && platform->probed) {
 
1358
                if (platform->driver->remove) {
 
1359
                        err = platform->driver->remove(platform);
 
1360
                        if (err < 0)
 
1361
                                printk(KERN_ERR "asoc: failed to remove %s\n", platform->name);
 
1362
                }
 
1363
                platform->probed = 0;
 
1364
                list_del(&platform->card_list);
 
1365
                module_put(platform->dev->driver->owner);
 
1366
        }
 
1367
 
 
1368
        /* remove the CODEC */
 
1369
        if (codec && codec->probed)
 
1370
                soc_remove_codec(codec);
 
1371
 
 
1372
        /* remove the cpu_dai */
 
1373
        if (cpu_dai && cpu_dai->probed) {
 
1374
                if (cpu_dai->driver->remove) {
 
1375
                        err = cpu_dai->driver->remove(cpu_dai);
 
1376
                        if (err < 0)
 
1377
                                printk(KERN_ERR "asoc: failed to remove %s\n", cpu_dai->name);
 
1378
                }
 
1379
                cpu_dai->probed = 0;
 
1380
                list_del(&cpu_dai->card_list);
 
1381
                module_put(cpu_dai->dev->driver->owner);
 
1382
        }
 
1383
}
 
1384
 
 
1385
static void soc_set_name_prefix(struct snd_soc_card *card,
 
1386
                                struct snd_soc_codec *codec)
 
1387
{
 
1388
        int i;
 
1389
 
 
1390
        if (card->codec_conf == NULL)
 
1391
                return;
 
1392
 
 
1393
        for (i = 0; i < card->num_configs; i++) {
 
1394
                struct snd_soc_codec_conf *map = &card->codec_conf[i];
 
1395
                if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
 
1396
                        codec->name_prefix = map->name_prefix;
 
1397
                        break;
 
1398
                }
 
1399
        }
 
1400
}
 
1401
 
 
1402
static int soc_probe_codec(struct snd_soc_card *card,
 
1403
                           struct snd_soc_codec *codec)
 
1404
{
 
1405
        int ret = 0;
 
1406
 
 
1407
        codec->card = card;
 
1408
        codec->dapm.card = card;
 
1409
        soc_set_name_prefix(card, codec);
 
1410
 
 
1411
        if (codec->driver->probe) {
 
1412
                ret = codec->driver->probe(codec);
 
1413
                if (ret < 0) {
 
1414
                        dev_err(codec->dev,
 
1415
                                "asoc: failed to probe CODEC %s: %d\n",
 
1416
                                codec->name, ret);
 
1417
                        return ret;
 
1418
                }
 
1419
        }
 
1420
 
 
1421
        soc_init_codec_debugfs(codec);
 
1422
 
 
1423
        /* mark codec as probed and add to card codec list */
 
1424
        if (!try_module_get(codec->dev->driver->owner))
 
1425
                return -ENODEV;
 
1426
 
 
1427
        codec->probed = 1;
 
1428
        list_add(&codec->card_list, &card->codec_dev_list);
 
1429
        list_add(&codec->dapm.list, &card->dapm_list);
 
1430
 
 
1431
        return ret;
 
1432
}
 
1433
 
 
1434
static void rtd_release(struct device *dev) {}
 
1435
 
 
1436
static int soc_post_component_init(struct snd_soc_card *card,
 
1437
                                   struct snd_soc_codec *codec,
 
1438
                                   int num, int dailess)
 
1439
{
 
1440
        struct snd_soc_dai_link *dai_link = NULL;
 
1441
        struct snd_soc_aux_dev *aux_dev = NULL;
 
1442
        struct snd_soc_pcm_runtime *rtd;
 
1443
        const char *temp, *name;
 
1444
        int ret = 0;
 
1445
 
 
1446
        if (!dailess) {
 
1447
                dai_link = &card->dai_link[num];
 
1448
                rtd = &card->rtd[num];
 
1449
                name = dai_link->name;
 
1450
        } else {
 
1451
                aux_dev = &card->aux_dev[num];
 
1452
                rtd = &card->rtd_aux[num];
 
1453
                name = aux_dev->name;
 
1454
        }
 
1455
 
 
1456
        /* machine controls, routes and widgets are not prefixed */
 
1457
        temp = codec->name_prefix;
 
1458
        codec->name_prefix = NULL;
 
1459
 
 
1460
        /* do machine specific initialization */
 
1461
        if (!dailess && dai_link->init)
 
1462
                ret = dai_link->init(rtd);
 
1463
        else if (dailess && aux_dev->init)
 
1464
                ret = aux_dev->init(&codec->dapm);
 
1465
        if (ret < 0) {
 
1466
                dev_err(card->dev, "asoc: failed to init %s: %d\n", name, ret);
 
1467
                return ret;
 
1468
        }
 
1469
        codec->name_prefix = temp;
 
1470
 
 
1471
        /* Make sure all DAPM widgets are instantiated */
 
1472
        snd_soc_dapm_new_widgets(&codec->dapm);
 
1473
 
 
1474
        /* register the rtd device */
 
1475
        rtd->codec = codec;
 
1476
        rtd->card = card;
 
1477
        rtd->dev.parent = card->dev;
 
1478
        rtd->dev.release = rtd_release;
 
1479
        rtd->dev.init_name = name;
 
1480
        ret = device_register(&rtd->dev);
 
1481
        if (ret < 0) {
 
1482
                dev_err(card->dev,
 
1483
                        "asoc: failed to register runtime device: %d\n", ret);
 
1484
                return ret;
 
1485
        }
 
1486
        rtd->dev_registered = 1;
 
1487
 
 
1488
        /* add DAPM sysfs entries for this codec */
 
1489
        ret = snd_soc_dapm_sys_add(&rtd->dev);
 
1490
        if (ret < 0)
 
1491
                dev_err(codec->dev,
 
1492
                        "asoc: failed to add codec dapm sysfs entries: %d\n",
 
1493
                        ret);
 
1494
 
 
1495
        /* add codec sysfs entries */
 
1496
        ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
 
1497
        if (ret < 0)
 
1498
                dev_err(codec->dev,
 
1499
                        "asoc: failed to add codec sysfs files: %d\n", ret);
 
1500
 
 
1501
        return 0;
 
1502
}
 
1503
 
 
1504
static int soc_probe_dai_link(struct snd_soc_card *card, int num)
 
1505
{
 
1506
        struct snd_soc_dai_link *dai_link = &card->dai_link[num];
 
1507
        struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
 
1508
        struct snd_soc_codec *codec = rtd->codec;
 
1509
        struct snd_soc_platform *platform = rtd->platform;
 
1510
        struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
 
1511
        int ret;
 
1512
 
 
1513
        dev_dbg(card->dev, "probe %s dai link %d\n", card->name, num);
 
1514
 
 
1515
        /* config components */
 
1516
        codec_dai->codec = codec;
 
1517
        cpu_dai->platform = platform;
 
1518
        codec_dai->card = card;
 
1519
        cpu_dai->card = card;
 
1520
 
 
1521
        /* set default power off timeout */
 
1522
        rtd->pmdown_time = pmdown_time;
 
1523
 
 
1524
        /* probe the cpu_dai */
 
1525
        if (!cpu_dai->probed) {
 
1526
                if (cpu_dai->driver->probe) {
 
1527
                        ret = cpu_dai->driver->probe(cpu_dai);
 
1528
                        if (ret < 0) {
 
1529
                                printk(KERN_ERR "asoc: failed to probe CPU DAI %s\n",
 
1530
                                                cpu_dai->name);
 
1531
                                return ret;
 
1532
                        }
 
1533
                }
 
1534
                cpu_dai->probed = 1;
 
1535
                /* mark cpu_dai as probed and add to card cpu_dai list */
 
1536
                list_add(&cpu_dai->card_list, &card->dai_dev_list);
 
1537
        }
 
1538
 
 
1539
        /* probe the CODEC */
 
1540
        if (!codec->probed) {
 
1541
                ret = soc_probe_codec(card, codec);
 
1542
                if (ret < 0)
 
1543
                        return ret;
 
1544
        }
 
1545
 
 
1546
        /* probe the platform */
 
1547
        if (!platform->probed) {
 
1548
                if (platform->driver->probe) {
 
1549
                        ret = platform->driver->probe(platform);
 
1550
                        if (ret < 0) {
 
1551
                                printk(KERN_ERR "asoc: failed to probe platform %s\n",
 
1552
                                                platform->name);
 
1553
                                return ret;
 
1554
                        }
 
1555
                }
 
1556
                /* mark platform as probed and add to card platform list */
 
1557
 
 
1558
                if (!try_module_get(platform->dev->driver->owner))
 
1559
                        return -ENODEV;
 
1560
 
 
1561
                platform->probed = 1;
 
1562
                list_add(&platform->card_list, &card->platform_dev_list);
 
1563
        }
 
1564
 
 
1565
        /* probe the CODEC DAI */
 
1566
        if (!codec_dai->probed) {
 
1567
                if (codec_dai->driver->probe) {
 
1568
                        ret = codec_dai->driver->probe(codec_dai);
 
1569
                        if (ret < 0) {
 
1570
                                printk(KERN_ERR "asoc: failed to probe CODEC DAI %s\n",
 
1571
                                                codec_dai->name);
 
1572
                                return ret;
 
1573
                        }
 
1574
                }
 
1575
 
 
1576
                /* mark cpu_dai as probed and add to card cpu_dai list */
 
1577
                codec_dai->probed = 1;
 
1578
                list_add(&codec_dai->card_list, &card->dai_dev_list);
 
1579
        }
 
1580
 
 
1581
        /* DAPM dai link stream work */
 
1582
        INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
 
1583
 
 
1584
        ret = soc_post_component_init(card, codec, num, 0);
 
1585
        if (ret)
 
1586
                return ret;
 
1587
 
 
1588
        ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
 
1589
        if (ret < 0)
 
1590
                printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
 
1591
 
 
1592
        /* create the pcm */
 
1593
        ret = soc_new_pcm(rtd, num);
 
1594
        if (ret < 0) {
 
1595
                printk(KERN_ERR "asoc: can't create pcm %s\n", dai_link->stream_name);
 
1596
                return ret;
 
1597
        }
 
1598
 
 
1599
        /* add platform data for AC97 devices */
 
1600
        if (rtd->codec_dai->driver->ac97_control)
 
1601
                snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
 
1602
 
 
1603
        return 0;
 
1604
}
 
1605
 
 
1606
#ifdef CONFIG_SND_SOC_AC97_BUS
 
1607
static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
 
1608
{
 
1609
        int ret;
 
1610
 
 
1611
        /* Only instantiate AC97 if not already done by the adaptor
 
1612
         * for the generic AC97 subsystem.
 
1613
         */
 
1614
        if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
 
1615
                /*
 
1616
                 * It is possible that the AC97 device is already registered to
 
1617
                 * the device subsystem. This happens when the device is created
 
1618
                 * via snd_ac97_mixer(). Currently only SoC codec that does so
 
1619
                 * is the generic AC97 glue but others migh emerge.
 
1620
                 *
 
1621
                 * In those cases we don't try to register the device again.
 
1622
                 */
 
1623
                if (!rtd->codec->ac97_created)
 
1624
                        return 0;
 
1625
 
 
1626
                ret = soc_ac97_dev_register(rtd->codec);
 
1627
                if (ret < 0) {
 
1628
                        printk(KERN_ERR "asoc: AC97 device register failed\n");
 
1629
                        return ret;
 
1630
                }
 
1631
 
 
1632
                rtd->codec->ac97_registered = 1;
 
1633
        }
 
1634
        return 0;
 
1635
}
 
1636
 
 
1637
static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
 
1638
{
 
1639
        if (codec->ac97_registered) {
 
1640
                soc_ac97_dev_unregister(codec);
 
1641
                codec->ac97_registered = 0;
 
1642
        }
 
1643
}
 
1644
#endif
 
1645
 
 
1646
static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
 
1647
{
 
1648
        struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
 
1649
        struct snd_soc_codec *codec;
 
1650
        int ret = -ENODEV;
 
1651
 
 
1652
        /* find CODEC from registered CODECs*/
 
1653
        list_for_each_entry(codec, &codec_list, list) {
 
1654
                if (!strcmp(codec->name, aux_dev->codec_name)) {
 
1655
                        if (codec->probed) {
 
1656
                                dev_err(codec->dev,
 
1657
                                        "asoc: codec already probed");
 
1658
                                ret = -EBUSY;
 
1659
                                goto out;
 
1660
                        }
 
1661
                        goto found;
 
1662
                }
 
1663
        }
 
1664
        /* codec not found */
 
1665
        dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
 
1666
        goto out;
 
1667
 
 
1668
found:
 
1669
        if (!try_module_get(codec->dev->driver->owner))
 
1670
                return -ENODEV;
 
1671
 
 
1672
        ret = soc_probe_codec(card, codec);
 
1673
        if (ret < 0)
 
1674
                return ret;
 
1675
 
 
1676
        ret = soc_post_component_init(card, codec, num, 1);
 
1677
 
 
1678
out:
 
1679
        return ret;
 
1680
}
 
1681
 
 
1682
static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
 
1683
{
 
1684
        struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
 
1685
        struct snd_soc_codec *codec = rtd->codec;
 
1686
 
 
1687
        /* unregister the rtd device */
 
1688
        if (rtd->dev_registered) {
 
1689
                device_remove_file(&rtd->dev, &dev_attr_codec_reg);
 
1690
                device_unregister(&rtd->dev);
 
1691
                rtd->dev_registered = 0;
 
1692
        }
 
1693
 
 
1694
        if (codec && codec->probed)
 
1695
                soc_remove_codec(codec);
 
1696
}
 
1697
 
 
1698
static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
 
1699
                                    enum snd_soc_compress_type compress_type)
 
1700
{
 
1701
        int ret;
 
1702
 
 
1703
        if (codec->cache_init)
 
1704
                return 0;
 
1705
 
 
1706
        /* override the compress_type if necessary */
 
1707
        if (compress_type && codec->compress_type != compress_type)
 
1708
                codec->compress_type = compress_type;
 
1709
        ret = snd_soc_cache_init(codec);
 
1710
        if (ret < 0) {
 
1711
                dev_err(codec->dev, "Failed to set cache compression type: %d\n",
 
1712
                        ret);
 
1713
                return ret;
 
1714
        }
 
1715
        codec->cache_init = 1;
 
1716
        return 0;
 
1717
}
 
1718
 
1052
1719
static void snd_soc_instantiate_card(struct snd_soc_card *card)
1053
1720
{
1054
 
        struct platform_device *pdev = container_of(card->dev,
1055
 
                                                    struct platform_device,
1056
 
                                                    dev);
1057
 
        struct snd_soc_codec_device *codec_dev = card->socdev->codec_dev;
 
1721
        struct platform_device *pdev = to_platform_device(card->dev);
1058
1722
        struct snd_soc_codec *codec;
1059
 
        struct snd_soc_platform *platform;
1060
 
        struct snd_soc_dai *dai;
1061
 
        int i, found, ret, ac97;
1062
 
 
1063
 
        if (card->instantiated)
1064
 
                return;
1065
 
 
1066
 
        found = 0;
1067
 
        list_for_each_entry(platform, &platform_list, list)
1068
 
                if (card->platform == platform) {
1069
 
                        found = 1;
1070
 
                        break;
1071
 
                }
1072
 
        if (!found) {
1073
 
                dev_dbg(card->dev, "Platform %s not registered\n",
1074
 
                        card->platform->name);
1075
 
                return;
1076
 
        }
1077
 
 
1078
 
        ac97 = 0;
1079
 
        for (i = 0; i < card->num_links; i++) {
1080
 
                found = 0;
1081
 
                list_for_each_entry(dai, &dai_list, list)
1082
 
                        if (card->dai_link[i].cpu_dai == dai) {
1083
 
                                found = 1;
1084
 
                                break;
1085
 
                        }
1086
 
                if (!found) {
1087
 
                        dev_dbg(card->dev, "DAI %s not registered\n",
1088
 
                                card->dai_link[i].cpu_dai->name);
1089
 
                        return;
1090
 
                }
1091
 
 
1092
 
                if (card->dai_link[i].cpu_dai->ac97_control)
1093
 
                        ac97 = 1;
1094
 
        }
1095
 
 
1096
 
        for (i = 0; i < card->num_links; i++) {
1097
 
                if (!card->dai_link[i].codec_dai->ops)
1098
 
                        card->dai_link[i].codec_dai->ops = &null_dai_ops;
1099
 
        }
1100
 
 
1101
 
        /* If we have AC97 in the system then don't wait for the
1102
 
         * codec.  This will need revisiting if we have to handle
1103
 
         * systems with mixed AC97 and non-AC97 parts.  Only check for
1104
 
         * DAIs currently; we can't do this per link since some AC97
1105
 
         * codecs have non-AC97 DAIs.
1106
 
         */
1107
 
        if (!ac97)
1108
 
                for (i = 0; i < card->num_links; i++) {
1109
 
                        found = 0;
1110
 
                        list_for_each_entry(dai, &dai_list, list)
1111
 
                                if (card->dai_link[i].codec_dai == dai) {
1112
 
                                        found = 1;
 
1723
        struct snd_soc_codec_conf *codec_conf;
 
1724
        enum snd_soc_compress_type compress_type;
 
1725
        int ret, i;
 
1726
 
 
1727
        mutex_lock(&card->mutex);
 
1728
 
 
1729
        if (card->instantiated) {
 
1730
                mutex_unlock(&card->mutex);
 
1731
                return;
 
1732
        }
 
1733
 
 
1734
        /* bind DAIs */
 
1735
        for (i = 0; i < card->num_links; i++)
 
1736
                soc_bind_dai_link(card, i);
 
1737
 
 
1738
        /* bind completed ? */
 
1739
        if (card->num_rtd != card->num_links) {
 
1740
                mutex_unlock(&card->mutex);
 
1741
                return;
 
1742
        }
 
1743
 
 
1744
        /* initialize the register cache for each available codec */
 
1745
        list_for_each_entry(codec, &codec_list, list) {
 
1746
                if (codec->cache_init)
 
1747
                        continue;
 
1748
                /* by default we don't override the compress_type */
 
1749
                compress_type = 0;
 
1750
                /* check to see if we need to override the compress_type */
 
1751
                for (i = 0; i < card->num_configs; ++i) {
 
1752
                        codec_conf = &card->codec_conf[i];
 
1753
                        if (!strcmp(codec->name, codec_conf->dev_name)) {
 
1754
                                compress_type = codec_conf->compress_type;
 
1755
                                if (compress_type && compress_type
 
1756
                                    != codec->compress_type)
1113
1757
                                        break;
1114
 
                                }
1115
 
                        if (!found) {
1116
 
                                dev_dbg(card->dev, "DAI %s not registered\n",
1117
 
                                        card->dai_link[i].codec_dai->name);
1118
 
                                return;
1119
1758
                        }
1120
1759
                }
1121
 
 
1122
 
        /* Note that we do not current check for codec components */
1123
 
 
1124
 
        dev_dbg(card->dev, "All components present, instantiating\n");
1125
 
 
1126
 
        /* Found everything, bring it up */
1127
 
        card->pmdown_time = pmdown_time;
1128
 
 
 
1760
                ret = snd_soc_init_codec_cache(codec, compress_type);
 
1761
                if (ret < 0) {
 
1762
                        mutex_unlock(&card->mutex);
 
1763
                        return;
 
1764
                }
 
1765
        }
 
1766
 
 
1767
        /* card bind complete so register a sound card */
 
1768
        ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
 
1769
                        card->owner, 0, &card->snd_card);
 
1770
        if (ret < 0) {
 
1771
                printk(KERN_ERR "asoc: can't create sound card for card %s\n",
 
1772
                        card->name);
 
1773
                mutex_unlock(&card->mutex);
 
1774
                return;
 
1775
        }
 
1776
        card->snd_card->dev = card->dev;
 
1777
 
 
1778
#ifdef CONFIG_PM
 
1779
        /* deferred resume work */
 
1780
        INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
 
1781
#endif
 
1782
 
 
1783
        /* initialise the sound card only once */
1129
1784
        if (card->probe) {
1130
1785
                ret = card->probe(pdev);
1131
1786
                if (ret < 0)
1132
 
                        return;
1133
 
        }
1134
 
 
1135
 
        for (i = 0; i < card->num_links; i++) {
1136
 
                struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
1137
 
                if (cpu_dai->probe) {
1138
 
                        ret = cpu_dai->probe(pdev, cpu_dai);
1139
 
                        if (ret < 0)
1140
 
                                goto cpu_dai_err;
1141
 
                }
1142
 
        }
1143
 
 
1144
 
        if (codec_dev->probe) {
1145
 
                ret = codec_dev->probe(pdev);
1146
 
                if (ret < 0)
1147
 
                        goto cpu_dai_err;
1148
 
        }
1149
 
        codec = card->codec;
1150
 
 
1151
 
        if (platform->probe) {
1152
 
                ret = platform->probe(pdev);
1153
 
                if (ret < 0)
1154
 
                        goto platform_err;
1155
 
        }
1156
 
 
1157
 
        /* DAPM stream work */
1158
 
        INIT_DELAYED_WORK(&card->delayed_work, close_delayed_work);
1159
 
#ifdef CONFIG_PM
1160
 
        /* deferred resume work */
1161
 
        INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
1162
 
#endif
1163
 
 
1164
 
        for (i = 0; i < card->num_links; i++) {
1165
 
                if (card->dai_link[i].init) {
1166
 
                        ret = card->dai_link[i].init(codec);
1167
 
                        if (ret < 0) {
1168
 
                                printk(KERN_ERR "asoc: failed to init %s\n",
1169
 
                                        card->dai_link[i].stream_name);
1170
 
                                continue;
1171
 
                        }
1172
 
                }
1173
 
                if (card->dai_link[i].codec_dai->ac97_control)
1174
 
                        ac97 = 1;
1175
 
        }
1176
 
 
1177
 
        snprintf(codec->card->shortname, sizeof(codec->card->shortname),
 
1787
                        goto card_probe_error;
 
1788
        }
 
1789
 
 
1790
        for (i = 0; i < card->num_links; i++) {
 
1791
                ret = soc_probe_dai_link(card, i);
 
1792
                if (ret < 0) {
 
1793
                        pr_err("asoc: failed to instantiate card %s: %d\n",
 
1794
                               card->name, ret);
 
1795
                        goto probe_dai_err;
 
1796
                }
 
1797
        }
 
1798
 
 
1799
        for (i = 0; i < card->num_aux_devs; i++) {
 
1800
                ret = soc_probe_aux_dev(card, i);
 
1801
                if (ret < 0) {
 
1802
                        pr_err("asoc: failed to add auxiliary devices %s: %d\n",
 
1803
                               card->name, ret);
 
1804
                        goto probe_aux_dev_err;
 
1805
                }
 
1806
        }
 
1807
 
 
1808
        snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
1178
1809
                 "%s",  card->name);
1179
 
        snprintf(codec->card->longname, sizeof(codec->card->longname),
1180
 
                 "%s (%s)", card->name, codec->name);
1181
 
 
1182
 
        /* Make sure all DAPM widgets are instantiated */
1183
 
        snd_soc_dapm_new_widgets(codec);
1184
 
 
1185
 
        ret = snd_card_register(codec->card);
 
1810
        snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
 
1811
                 "%s", card->name);
 
1812
 
 
1813
        ret = snd_card_register(card->snd_card);
1186
1814
        if (ret < 0) {
1187
 
                printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
1188
 
                                codec->name);
1189
 
                goto card_err;
 
1815
                printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);
 
1816
                goto probe_aux_dev_err;
1190
1817
        }
1191
1818
 
1192
 
        mutex_lock(&codec->mutex);
1193
1819
#ifdef CONFIG_SND_SOC_AC97_BUS
1194
 
        /* Only instantiate AC97 if not already done by the adaptor
1195
 
         * for the generic AC97 subsystem.
1196
 
         */
1197
 
        if (ac97 && strcmp(codec->name, "AC97") != 0) {
1198
 
                ret = soc_ac97_dev_register(codec);
 
1820
        /* register any AC97 codecs */
 
1821
        for (i = 0; i < card->num_rtd; i++) {
 
1822
                ret = soc_register_ac97_dai_link(&card->rtd[i]);
1199
1823
                if (ret < 0) {
1200
 
                        printk(KERN_ERR "asoc: AC97 device register failed\n");
1201
 
                        snd_card_free(codec->card);
1202
 
                        mutex_unlock(&codec->mutex);
1203
 
                        goto card_err;
 
1824
                        printk(KERN_ERR "asoc: failed to register AC97 %s\n", card->name);
 
1825
                        while (--i >= 0)
 
1826
                                soc_unregister_ac97_dai_link(card->rtd[i].codec);
 
1827
                        goto probe_aux_dev_err;
1204
1828
                }
1205
1829
        }
1206
1830
#endif
1207
1831
 
1208
 
        ret = snd_soc_dapm_sys_add(card->socdev->dev);
1209
 
        if (ret < 0)
1210
 
                printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1211
 
 
1212
 
        ret = device_create_file(card->socdev->dev, &dev_attr_pmdown_time);
1213
 
        if (ret < 0)
1214
 
                printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
1215
 
 
1216
 
        ret = device_create_file(card->socdev->dev, &dev_attr_codec_reg);
1217
 
        if (ret < 0)
1218
 
                printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1219
 
 
1220
 
        soc_init_codec_debugfs(codec);
1221
 
        mutex_unlock(&codec->mutex);
1222
 
 
1223
1832
        card->instantiated = 1;
1224
 
 
 
1833
        mutex_unlock(&card->mutex);
1225
1834
        return;
1226
1835
 
1227
 
card_err:
1228
 
        if (platform->remove)
1229
 
                platform->remove(pdev);
1230
 
 
1231
 
platform_err:
1232
 
        if (codec_dev->remove)
1233
 
                codec_dev->remove(pdev);
1234
 
 
1235
 
cpu_dai_err:
1236
 
        for (i--; i >= 0; i--) {
1237
 
                struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
1238
 
                if (cpu_dai->remove)
1239
 
                        cpu_dai->remove(pdev, cpu_dai);
1240
 
        }
1241
 
 
 
1836
probe_aux_dev_err:
 
1837
        for (i = 0; i < card->num_aux_devs; i++)
 
1838
                soc_remove_aux_dev(card, i);
 
1839
 
 
1840
probe_dai_err:
 
1841
        for (i = 0; i < card->num_links; i++)
 
1842
                soc_remove_dai_link(card, i);
 
1843
 
 
1844
card_probe_error:
1242
1845
        if (card->remove)
1243
1846
                card->remove(pdev);
 
1847
 
 
1848
        snd_card_free(card->snd_card);
 
1849
 
 
1850
        mutex_unlock(&card->mutex);
1244
1851
}
1245
1852
 
1246
1853
/*
1247
 
 * Attempt to initialise any uninitalised cards.  Must be called with
 
1854
 * Attempt to initialise any uninitialised cards.  Must be called with
1248
1855
 * client_mutex.
1249
1856
 */
1250
1857
static void snd_soc_instantiate_cards(void)
1257
1864
/* probes a new socdev */
1258
1865
static int soc_probe(struct platform_device *pdev)
1259
1866
{
 
1867
        struct snd_soc_card *card = platform_get_drvdata(pdev);
1260
1868
        int ret = 0;
1261
 
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1262
 
        struct snd_soc_card *card = socdev->card;
1263
1869
 
1264
 
        /* Bodge while we push things out of socdev */
1265
 
        card->socdev = socdev;
 
1870
        /*
 
1871
         * no card, so machine driver should be registering card
 
1872
         * we should not be here in that case so ret error
 
1873
         */
 
1874
        if (!card)
 
1875
                return -EINVAL;
1266
1876
 
1267
1877
        /* Bodge while we unpick instantiation */
1268
1878
        card->dev = &pdev->dev;
 
1879
        snd_soc_initialize_card_lists(card);
 
1880
 
1269
1881
        ret = snd_soc_register_card(card);
1270
1882
        if (ret != 0) {
1271
1883
                dev_err(&pdev->dev, "Failed to register card\n");
1275
1887
        return 0;
1276
1888
}
1277
1889
 
 
1890
static int soc_cleanup_card_resources(struct snd_soc_card *card)
 
1891
{
 
1892
        struct platform_device *pdev = to_platform_device(card->dev);
 
1893
        int i;
 
1894
 
 
1895
        /* make sure any delayed work runs */
 
1896
        for (i = 0; i < card->num_rtd; i++) {
 
1897
                struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
 
1898
                flush_delayed_work_sync(&rtd->delayed_work);
 
1899
        }
 
1900
 
 
1901
        /* remove auxiliary devices */
 
1902
        for (i = 0; i < card->num_aux_devs; i++)
 
1903
                soc_remove_aux_dev(card, i);
 
1904
 
 
1905
        /* remove and free each DAI */
 
1906
        for (i = 0; i < card->num_rtd; i++)
 
1907
                soc_remove_dai_link(card, i);
 
1908
 
 
1909
        soc_cleanup_card_debugfs(card);
 
1910
 
 
1911
        /* remove the card */
 
1912
        if (card->remove)
 
1913
                card->remove(pdev);
 
1914
 
 
1915
        kfree(card->rtd);
 
1916
        snd_card_free(card->snd_card);
 
1917
        return 0;
 
1918
 
 
1919
}
 
1920
 
1278
1921
/* removes a socdev */
1279
1922
static int soc_remove(struct platform_device *pdev)
1280
1923
{
1281
 
        int i;
1282
 
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1283
 
        struct snd_soc_card *card = socdev->card;
1284
 
        struct snd_soc_platform *platform = card->platform;
1285
 
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
1286
 
 
1287
 
        if (card->instantiated) {
1288
 
                run_delayed_work(&card->delayed_work);
1289
 
 
1290
 
                if (platform->remove)
1291
 
                        platform->remove(pdev);
1292
 
 
1293
 
                if (codec_dev->remove)
1294
 
                        codec_dev->remove(pdev);
1295
 
 
1296
 
                for (i = 0; i < card->num_links; i++) {
1297
 
                        struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
1298
 
                        if (cpu_dai->remove)
1299
 
                                cpu_dai->remove(pdev, cpu_dai);
1300
 
                }
1301
 
 
1302
 
                if (card->remove)
1303
 
                        card->remove(pdev);
1304
 
        }
 
1924
        struct snd_soc_card *card = platform_get_drvdata(pdev);
1305
1925
 
1306
1926
        snd_soc_unregister_card(card);
1307
 
 
1308
1927
        return 0;
1309
1928
}
1310
1929
 
1311
1930
static int soc_poweroff(struct device *dev)
1312
1931
{
1313
1932
        struct platform_device *pdev = to_platform_device(dev);
1314
 
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1315
 
        struct snd_soc_card *card = socdev->card;
 
1933
        struct snd_soc_card *card = platform_get_drvdata(pdev);
 
1934
        int i;
1316
1935
 
1317
1936
        if (!card->instantiated)
1318
1937
                return 0;
1319
1938
 
1320
1939
        /* Flush out pmdown_time work - we actually do want to run it
1321
1940
         * now, we're shutting down so no imminent restart. */
1322
 
        run_delayed_work(&card->delayed_work);
 
1941
        for (i = 0; i < card->num_rtd; i++) {
 
1942
                struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
 
1943
                flush_delayed_work_sync(&rtd->delayed_work);
 
1944
        }
1323
1945
 
1324
 
        snd_soc_dapm_shutdown(socdev);
 
1946
        snd_soc_dapm_shutdown(card);
1325
1947
 
1326
1948
        return 0;
1327
1949
}
1344
1966
};
1345
1967
 
1346
1968
/* create a new pcm */
1347
 
static int soc_new_pcm(struct snd_soc_device *socdev,
1348
 
        struct snd_soc_dai_link *dai_link, int num)
 
1969
static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
1349
1970
{
1350
 
        struct snd_soc_card *card = socdev->card;
1351
 
        struct snd_soc_codec *codec = card->codec;
1352
 
        struct snd_soc_platform *platform = card->platform;
1353
 
        struct snd_soc_dai *codec_dai = dai_link->codec_dai;
1354
 
        struct snd_soc_dai *cpu_dai = dai_link->cpu_dai;
1355
 
        struct snd_soc_pcm_runtime *rtd;
 
1971
        struct snd_soc_codec *codec = rtd->codec;
 
1972
        struct snd_soc_platform *platform = rtd->platform;
 
1973
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
 
1974
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1356
1975
        struct snd_pcm *pcm;
1357
1976
        char new_name[64];
1358
1977
        int ret = 0, playback = 0, capture = 0;
1359
1978
 
1360
 
        rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
1361
 
        if (rtd == NULL)
1362
 
                return -ENOMEM;
1363
 
 
1364
 
        rtd->dai = dai_link;
1365
 
        rtd->socdev = socdev;
1366
 
        codec_dai->codec = card->codec;
1367
 
 
1368
1979
        /* check client and interface hw capabilities */
1369
1980
        snprintf(new_name, sizeof(new_name), "%s %s-%d",
1370
 
                 dai_link->stream_name, codec_dai->name, num);
 
1981
                        rtd->dai_link->stream_name, codec_dai->name, num);
1371
1982
 
1372
 
        if (codec_dai->playback.channels_min)
 
1983
        if (codec_dai->driver->playback.channels_min)
1373
1984
                playback = 1;
1374
 
        if (codec_dai->capture.channels_min)
 
1985
        if (codec_dai->driver->capture.channels_min)
1375
1986
                capture = 1;
1376
1987
 
1377
 
        ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
1378
 
                capture, &pcm);
 
1988
        dev_dbg(rtd->card->dev, "registered pcm #%d %s\n",num,new_name);
 
1989
        ret = snd_pcm_new(rtd->card->snd_card, new_name,
 
1990
                        num, playback, capture, &pcm);
1379
1991
        if (ret < 0) {
1380
 
                printk(KERN_ERR "asoc: can't create pcm for codec %s\n",
1381
 
                        codec->name);
1382
 
                kfree(rtd);
 
1992
                printk(KERN_ERR "asoc: can't create pcm for codec %s\n", codec->name);
1383
1993
                return ret;
1384
1994
        }
1385
1995
 
1386
 
        dai_link->pcm = pcm;
 
1996
        rtd->pcm = pcm;
1387
1997
        pcm->private_data = rtd;
1388
 
        soc_pcm_ops.mmap = platform->pcm_ops->mmap;
1389
 
        soc_pcm_ops.ioctl = platform->pcm_ops->ioctl;
1390
 
        soc_pcm_ops.copy = platform->pcm_ops->copy;
1391
 
        soc_pcm_ops.silence = platform->pcm_ops->silence;
1392
 
        soc_pcm_ops.ack = platform->pcm_ops->ack;
1393
 
        soc_pcm_ops.page = platform->pcm_ops->page;
 
1998
        soc_pcm_ops.mmap = platform->driver->ops->mmap;
 
1999
        soc_pcm_ops.pointer = platform->driver->ops->pointer;
 
2000
        soc_pcm_ops.ioctl = platform->driver->ops->ioctl;
 
2001
        soc_pcm_ops.copy = platform->driver->ops->copy;
 
2002
        soc_pcm_ops.silence = platform->driver->ops->silence;
 
2003
        soc_pcm_ops.ack = platform->driver->ops->ack;
 
2004
        soc_pcm_ops.page = platform->driver->ops->page;
1394
2005
 
1395
2006
        if (playback)
1396
2007
                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
1398
2009
        if (capture)
1399
2010
                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
1400
2011
 
1401
 
        ret = platform->pcm_new(codec->card, codec_dai, pcm);
 
2012
        ret = platform->driver->pcm_new(rtd->card->snd_card, codec_dai, pcm);
1402
2013
        if (ret < 0) {
1403
2014
                printk(KERN_ERR "asoc: platform pcm constructor failed\n");
1404
 
                kfree(rtd);
1405
2015
                return ret;
1406
2016
        }
1407
2017
 
1408
 
        pcm->private_free = platform->pcm_free;
 
2018
        pcm->private_free = platform->driver->pcm_free;
1409
2019
        printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
1410
2020
                cpu_dai->name);
1411
2021
        return ret;
1422
2032
int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg)
1423
2033
{
1424
2034
        if (codec->volatile_register)
1425
 
                return codec->volatile_register(reg);
 
2035
                return codec->volatile_register(codec, reg);
1426
2036
        else
1427
2037
                return 0;
1428
2038
}
1457
2067
 
1458
2068
        codec->ac97->bus->ops = ops;
1459
2069
        codec->ac97->num = num;
1460
 
        codec->dev = &codec->ac97->dev;
 
2070
 
 
2071
        /*
 
2072
         * Mark the AC97 device to be created by us. This way we ensure that the
 
2073
         * device will be registered with the device subsystem later on.
 
2074
         */
 
2075
        codec->ac97_created = 1;
 
2076
 
1461
2077
        mutex_unlock(&codec->mutex);
1462
2078
        return 0;
1463
2079
}
1472
2088
void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1473
2089
{
1474
2090
        mutex_lock(&codec->mutex);
 
2091
#ifdef CONFIG_SND_SOC_AC97_BUS
 
2092
        soc_unregister_ac97_dai_link(codec);
 
2093
#endif
1475
2094
        kfree(codec->ac97->bus);
1476
2095
        kfree(codec->ac97);
1477
2096
        codec->ac97 = NULL;
 
2097
        codec->ac97_created = 0;
1478
2098
        mutex_unlock(&codec->mutex);
1479
2099
}
1480
2100
EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1481
2101
 
 
2102
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
 
2103
{
 
2104
        unsigned int ret;
 
2105
 
 
2106
        ret = codec->read(codec, reg);
 
2107
        dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
 
2108
        trace_snd_soc_reg_read(codec, reg, ret);
 
2109
 
 
2110
        return ret;
 
2111
}
 
2112
EXPORT_SYMBOL_GPL(snd_soc_read);
 
2113
 
 
2114
unsigned int snd_soc_write(struct snd_soc_codec *codec,
 
2115
                           unsigned int reg, unsigned int val)
 
2116
{
 
2117
        dev_dbg(codec->dev, "write %x = %x\n", reg, val);
 
2118
        trace_snd_soc_reg_write(codec, reg, val);
 
2119
        return codec->write(codec, reg, val);
 
2120
}
 
2121
EXPORT_SYMBOL_GPL(snd_soc_write);
 
2122
 
1482
2123
/**
1483
2124
 * snd_soc_update_bits - update codec register bits
1484
2125
 * @codec: audio codec
1488
2129
 *
1489
2130
 * Writes new register value.
1490
2131
 *
1491
 
 * Returns 1 for change else 0.
 
2132
 * Returns 1 for change, 0 for no change, or negative error code.
1492
2133
 */
1493
2134
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
1494
2135
                                unsigned int mask, unsigned int value)
1495
2136
{
1496
2137
        int change;
1497
2138
        unsigned int old, new;
1498
 
 
1499
 
        old = snd_soc_read(codec, reg);
 
2139
        int ret;
 
2140
 
 
2141
        ret = snd_soc_read(codec, reg);
 
2142
        if (ret < 0)
 
2143
                return ret;
 
2144
 
 
2145
        old = ret;
1500
2146
        new = (old & ~mask) | value;
1501
2147
        change = old != new;
1502
 
        if (change)
1503
 
                snd_soc_write(codec, reg, new);
 
2148
        if (change) {
 
2149
                ret = snd_soc_write(codec, reg, new);
 
2150
                if (ret < 0)
 
2151
                        return ret;
 
2152
        }
1504
2153
 
1505
2154
        return change;
1506
2155
}
1558
2207
EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1559
2208
 
1560
2209
/**
1561
 
 * snd_soc_new_pcms - create new sound card and pcms
1562
 
 * @socdev: the SoC audio device
1563
 
 * @idx: ALSA card index
1564
 
 * @xid: card identification
1565
 
 *
1566
 
 * Create a new sound card based upon the codec and interface pcms.
1567
 
 *
1568
 
 * Returns 0 for success, else error.
1569
 
 */
1570
 
int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
1571
 
{
1572
 
        struct snd_soc_card *card = socdev->card;
1573
 
        struct snd_soc_codec *codec = card->codec;
1574
 
        int ret, i;
1575
 
 
1576
 
        mutex_lock(&codec->mutex);
1577
 
 
1578
 
        /* register a sound card */
1579
 
        ret = snd_card_create(idx, xid, codec->owner, 0, &codec->card);
1580
 
        if (ret < 0) {
1581
 
                printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1582
 
                        codec->name);
1583
 
                mutex_unlock(&codec->mutex);
1584
 
                return ret;
1585
 
        }
1586
 
 
1587
 
        codec->socdev = socdev;
1588
 
        codec->card->dev = socdev->dev;
1589
 
        codec->card->private_data = codec;
1590
 
        strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1591
 
 
1592
 
        /* create the pcms */
1593
 
        for (i = 0; i < card->num_links; i++) {
1594
 
                ret = soc_new_pcm(socdev, &card->dai_link[i], i);
1595
 
                if (ret < 0) {
1596
 
                        printk(KERN_ERR "asoc: can't create pcm %s\n",
1597
 
                                card->dai_link[i].stream_name);
1598
 
                        mutex_unlock(&codec->mutex);
1599
 
                        return ret;
1600
 
                }
1601
 
                /* Check for codec->ac97 to handle the ac97.c fun */
1602
 
                if (card->dai_link[i].codec_dai->ac97_control && codec->ac97) {
1603
 
                        snd_ac97_dev_add_pdata(codec->ac97,
1604
 
                                card->dai_link[i].cpu_dai->ac97_pdata);
1605
 
                }
1606
 
        }
1607
 
 
1608
 
        mutex_unlock(&codec->mutex);
1609
 
        return ret;
1610
 
}
1611
 
EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1612
 
 
1613
 
/**
1614
 
 * snd_soc_free_pcms - free sound card and pcms
1615
 
 * @socdev: the SoC audio device
1616
 
 *
1617
 
 * Frees sound card and pcms associated with the socdev.
1618
 
 * Also unregister the codec if it is an AC97 device.
1619
 
 */
1620
 
void snd_soc_free_pcms(struct snd_soc_device *socdev)
1621
 
{
1622
 
        struct snd_soc_codec *codec = socdev->card->codec;
1623
 
#ifdef CONFIG_SND_SOC_AC97_BUS
1624
 
        struct snd_soc_dai *codec_dai;
1625
 
        int i;
1626
 
#endif
1627
 
 
1628
 
        mutex_lock(&codec->mutex);
1629
 
        soc_cleanup_codec_debugfs(codec);
1630
 
#ifdef CONFIG_SND_SOC_AC97_BUS
1631
 
        for (i = 0; i < codec->num_dai; i++) {
1632
 
                codec_dai = &codec->dai[i];
1633
 
                if (codec_dai->ac97_control && codec->ac97 &&
1634
 
                    strcmp(codec->name, "AC97") != 0) {
1635
 
                        soc_ac97_dev_unregister(codec);
1636
 
                        goto free_card;
1637
 
                }
1638
 
        }
1639
 
free_card:
1640
 
#endif
1641
 
 
1642
 
        if (codec->card)
1643
 
                snd_card_free(codec->card);
1644
 
        device_remove_file(socdev->dev, &dev_attr_codec_reg);
1645
 
        mutex_unlock(&codec->mutex);
1646
 
}
1647
 
EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1648
 
 
1649
 
/**
1650
2210
 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1651
2211
 * @substream: the pcm substream
1652
2212
 * @hw: the hardware parameters
1707
2267
int snd_soc_add_controls(struct snd_soc_codec *codec,
1708
2268
        const struct snd_kcontrol_new *controls, int num_controls)
1709
2269
{
1710
 
        struct snd_card *card = codec->card;
 
2270
        struct snd_card *card = codec->card->snd_card;
 
2271
        char prefixed_name[44], *name;
1711
2272
        int err, i;
1712
2273
 
1713
2274
        for (i = 0; i < num_controls; i++) {
1714
2275
                const struct snd_kcontrol_new *control = &controls[i];
1715
 
                err = snd_ctl_add(card, snd_soc_cnew(control, codec, NULL));
 
2276
                if (codec->name_prefix) {
 
2277
                        snprintf(prefixed_name, sizeof(prefixed_name), "%s %s",
 
2278
                                 codec->name_prefix, control->name);
 
2279
                        name = prefixed_name;
 
2280
                } else {
 
2281
                        name = control->name;
 
2282
                }
 
2283
                err = snd_ctl_add(card, snd_soc_cnew(control, codec, name));
1716
2284
                if (err < 0) {
1717
 
                        dev_err(codec->dev, "%s: Failed to add %s\n",
1718
 
                                codec->name, control->name);
 
2285
                        dev_err(codec->dev, "%s: Failed to add %s: %d\n",
 
2286
                                codec->name, name, err);
1719
2287
                        return err;
1720
2288
                }
1721
2289
        }
1955
2523
{
1956
2524
        struct soc_mixer_control *mc =
1957
2525
                (struct soc_mixer_control *)kcontrol->private_value;
1958
 
        int max = mc->max;
 
2526
        int platform_max;
1959
2527
        unsigned int shift = mc->shift;
1960
2528
        unsigned int rshift = mc->rshift;
1961
2529
 
1962
 
        if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
 
2530
        if (!mc->platform_max)
 
2531
                mc->platform_max = mc->max;
 
2532
        platform_max = mc->platform_max;
 
2533
 
 
2534
        if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
1963
2535
                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1964
2536
        else
1965
2537
                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1966
2538
 
1967
2539
        uinfo->count = shift == rshift ? 1 : 2;
1968
2540
        uinfo->value.integer.min = 0;
1969
 
        uinfo->value.integer.max = max;
 
2541
        uinfo->value.integer.max = platform_max;
1970
2542
        return 0;
1971
2543
}
1972
2544
EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2064
2636
{
2065
2637
        struct soc_mixer_control *mc =
2066
2638
                (struct soc_mixer_control *)kcontrol->private_value;
2067
 
        int max = mc->max;
2068
 
 
2069
 
        if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
 
2639
        int platform_max;
 
2640
 
 
2641
        if (!mc->platform_max)
 
2642
                mc->platform_max = mc->max;
 
2643
        platform_max = mc->platform_max;
 
2644
 
 
2645
        if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
2070
2646
                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2071
2647
        else
2072
2648
                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2073
2649
 
2074
2650
        uinfo->count = 2;
2075
2651
        uinfo->value.integer.min = 0;
2076
 
        uinfo->value.integer.max = max;
 
2652
        uinfo->value.integer.max = platform_max;
2077
2653
        return 0;
2078
2654
}
2079
2655
EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
2174
2750
{
2175
2751
        struct soc_mixer_control *mc =
2176
2752
                (struct soc_mixer_control *)kcontrol->private_value;
2177
 
        int max = mc->max;
 
2753
        int platform_max;
2178
2754
        int min = mc->min;
2179
2755
 
 
2756
        if (!mc->platform_max)
 
2757
                mc->platform_max = mc->max;
 
2758
        platform_max = mc->platform_max;
 
2759
 
2180
2760
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2181
2761
        uinfo->count = 2;
2182
2762
        uinfo->value.integer.min = 0;
2183
 
        uinfo->value.integer.max = max-min;
 
2763
        uinfo->value.integer.max = platform_max - min;
2184
2764
        return 0;
2185
2765
}
2186
2766
EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2239
2819
EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2240
2820
 
2241
2821
/**
 
2822
 * snd_soc_limit_volume - Set new limit to an existing volume control.
 
2823
 *
 
2824
 * @codec: where to look for the control
 
2825
 * @name: Name of the control
 
2826
 * @max: new maximum limit
 
2827
 *
 
2828
 * Return 0 for success, else error.
 
2829
 */
 
2830
int snd_soc_limit_volume(struct snd_soc_codec *codec,
 
2831
        const char *name, int max)
 
2832
{
 
2833
        struct snd_card *card = codec->card->snd_card;
 
2834
        struct snd_kcontrol *kctl;
 
2835
        struct soc_mixer_control *mc;
 
2836
        int found = 0;
 
2837
        int ret = -EINVAL;
 
2838
 
 
2839
        /* Sanity check for name and max */
 
2840
        if (unlikely(!name || max <= 0))
 
2841
                return -EINVAL;
 
2842
 
 
2843
        list_for_each_entry(kctl, &card->controls, list) {
 
2844
                if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
 
2845
                        found = 1;
 
2846
                        break;
 
2847
                }
 
2848
        }
 
2849
        if (found) {
 
2850
                mc = (struct soc_mixer_control *)kctl->private_value;
 
2851
                if (max <= mc->max) {
 
2852
                        mc->platform_max = max;
 
2853
                        ret = 0;
 
2854
                }
 
2855
        }
 
2856
        return ret;
 
2857
}
 
2858
EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
 
2859
 
 
2860
/**
 
2861
 * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
 
2862
 *  mixer info callback
 
2863
 * @kcontrol: mixer control
 
2864
 * @uinfo: control element information
 
2865
 *
 
2866
 * Returns 0 for success.
 
2867
 */
 
2868
int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
 
2869
                        struct snd_ctl_elem_info *uinfo)
 
2870
{
 
2871
        struct soc_mixer_control *mc =
 
2872
                (struct soc_mixer_control *)kcontrol->private_value;
 
2873
        int max = mc->max;
 
2874
        int min = mc->min;
 
2875
 
 
2876
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 
2877
        uinfo->count = 2;
 
2878
        uinfo->value.integer.min = 0;
 
2879
        uinfo->value.integer.max = max-min;
 
2880
 
 
2881
        return 0;
 
2882
}
 
2883
EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
 
2884
 
 
2885
/**
 
2886
 * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
 
2887
 *  mixer get callback
 
2888
 * @kcontrol: mixer control
 
2889
 * @uinfo: control element information
 
2890
 *
 
2891
 * Returns 0 for success.
 
2892
 */
 
2893
int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
 
2894
                        struct snd_ctl_elem_value *ucontrol)
 
2895
{
 
2896
        struct soc_mixer_control *mc =
 
2897
                (struct soc_mixer_control *)kcontrol->private_value;
 
2898
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 
2899
        unsigned int mask = (1<<mc->shift)-1;
 
2900
        int min = mc->min;
 
2901
        int val = snd_soc_read(codec, mc->reg) & mask;
 
2902
        int valr = snd_soc_read(codec, mc->rreg) & mask;
 
2903
 
 
2904
        ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
 
2905
        ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
 
2906
        return 0;
 
2907
}
 
2908
EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
 
2909
 
 
2910
/**
 
2911
 * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
 
2912
 *  mixer put callback
 
2913
 * @kcontrol: mixer control
 
2914
 * @uinfo: control element information
 
2915
 *
 
2916
 * Returns 0 for success.
 
2917
 */
 
2918
int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
 
2919
                        struct snd_ctl_elem_value *ucontrol)
 
2920
{
 
2921
        struct soc_mixer_control *mc =
 
2922
                (struct soc_mixer_control *)kcontrol->private_value;
 
2923
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 
2924
        unsigned int mask = (1<<mc->shift)-1;
 
2925
        int min = mc->min;
 
2926
        int ret;
 
2927
        unsigned int val, valr, oval, ovalr;
 
2928
 
 
2929
        val = ((ucontrol->value.integer.value[0]+min) & 0xff);
 
2930
        val &= mask;
 
2931
        valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
 
2932
        valr &= mask;
 
2933
 
 
2934
        oval = snd_soc_read(codec, mc->reg) & mask;
 
2935
        ovalr = snd_soc_read(codec, mc->rreg) & mask;
 
2936
 
 
2937
        ret = 0;
 
2938
        if (oval != val) {
 
2939
                ret = snd_soc_write(codec, mc->reg, val);
 
2940
                if (ret < 0)
 
2941
                        return ret;
 
2942
        }
 
2943
        if (ovalr != valr) {
 
2944
                ret = snd_soc_write(codec, mc->rreg, valr);
 
2945
                if (ret < 0)
 
2946
                        return ret;
 
2947
        }
 
2948
 
 
2949
        return 0;
 
2950
}
 
2951
EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
 
2952
 
 
2953
/**
2242
2954
 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2243
2955
 * @dai: DAI
2244
2956
 * @clk_id: DAI specific clock ID
2250
2962
int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2251
2963
        unsigned int freq, int dir)
2252
2964
{
2253
 
        if (dai->ops && dai->ops->set_sysclk)
2254
 
                return dai->ops->set_sysclk(dai, clk_id, freq, dir);
 
2965
        if (dai->driver && dai->driver->ops->set_sysclk)
 
2966
                return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
2255
2967
        else
2256
2968
                return -EINVAL;
2257
2969
}
2270
2982
int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2271
2983
        int div_id, int div)
2272
2984
{
2273
 
        if (dai->ops && dai->ops->set_clkdiv)
2274
 
                return dai->ops->set_clkdiv(dai, div_id, div);
 
2985
        if (dai->driver && dai->driver->ops->set_clkdiv)
 
2986
                return dai->driver->ops->set_clkdiv(dai, div_id, div);
2275
2987
        else
2276
2988
                return -EINVAL;
2277
2989
}
2290
3002
int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2291
3003
        unsigned int freq_in, unsigned int freq_out)
2292
3004
{
2293
 
        if (dai->ops && dai->ops->set_pll)
2294
 
                return dai->ops->set_pll(dai, pll_id, source,
 
3005
        if (dai->driver && dai->driver->ops->set_pll)
 
3006
                return dai->driver->ops->set_pll(dai, pll_id, source,
2295
3007
                                         freq_in, freq_out);
2296
3008
        else
2297
3009
                return -EINVAL;
2307
3019
 */
2308
3020
int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2309
3021
{
2310
 
        if (dai->ops && dai->ops->set_fmt)
2311
 
                return dai->ops->set_fmt(dai, fmt);
 
3022
        if (dai->driver && dai->driver->ops->set_fmt)
 
3023
                return dai->driver->ops->set_fmt(dai, fmt);
2312
3024
        else
2313
3025
                return -EINVAL;
2314
3026
}
2328
3040
int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
2329
3041
        unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2330
3042
{
2331
 
        if (dai->ops && dai->ops->set_tdm_slot)
2332
 
                return dai->ops->set_tdm_slot(dai, tx_mask, rx_mask,
 
3043
        if (dai->driver && dai->driver->ops->set_tdm_slot)
 
3044
                return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2333
3045
                                slots, slot_width);
2334
3046
        else
2335
3047
                return -EINVAL;
2352
3064
        unsigned int tx_num, unsigned int *tx_slot,
2353
3065
        unsigned int rx_num, unsigned int *rx_slot)
2354
3066
{
2355
 
        if (dai->ops && dai->ops->set_channel_map)
2356
 
                return dai->ops->set_channel_map(dai, tx_num, tx_slot,
 
3067
        if (dai->driver && dai->driver->ops->set_channel_map)
 
3068
                return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
2357
3069
                        rx_num, rx_slot);
2358
3070
        else
2359
3071
                return -EINVAL;
2369
3081
 */
2370
3082
int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2371
3083
{
2372
 
        if (dai->ops && dai->ops->set_tristate)
2373
 
                return dai->ops->set_tristate(dai, tristate);
 
3084
        if (dai->driver && dai->driver->ops->set_tristate)
 
3085
                return dai->driver->ops->set_tristate(dai, tristate);
2374
3086
        else
2375
3087
                return -EINVAL;
2376
3088
}
2385
3097
 */
2386
3098
int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
2387
3099
{
2388
 
        if (dai->ops && dai->ops->digital_mute)
2389
 
                return dai->ops->digital_mute(dai, mute);
 
3100
        if (dai->driver && dai->driver->ops->digital_mute)
 
3101
                return dai->driver->ops->digital_mute(dai, mute);
2390
3102
        else
2391
3103
                return -EINVAL;
2392
3104
}
2397
3109
 *
2398
3110
 * @card: Card to register
2399
3111
 *
2400
 
 * Note that currently this is an internal only function: it will be
2401
 
 * exposed to machine drivers after further backporting of ASoC v2
2402
 
 * registration APIs.
2403
3112
 */
2404
 
static int snd_soc_register_card(struct snd_soc_card *card)
 
3113
int snd_soc_register_card(struct snd_soc_card *card)
2405
3114
{
 
3115
        int i;
 
3116
 
2406
3117
        if (!card->name || !card->dev)
2407
3118
                return -EINVAL;
2408
3119
 
 
3120
        soc_init_card_debugfs(card);
 
3121
 
 
3122
        card->rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime) *
 
3123
                            (card->num_links + card->num_aux_devs),
 
3124
                            GFP_KERNEL);
 
3125
        if (card->rtd == NULL)
 
3126
                return -ENOMEM;
 
3127
        card->rtd_aux = &card->rtd[card->num_links];
 
3128
 
 
3129
        for (i = 0; i < card->num_links; i++)
 
3130
                card->rtd[i].dai_link = &card->dai_link[i];
 
3131
 
2409
3132
        INIT_LIST_HEAD(&card->list);
2410
3133
        card->instantiated = 0;
 
3134
        mutex_init(&card->mutex);
2411
3135
 
2412
3136
        mutex_lock(&client_mutex);
2413
3137
        list_add(&card->list, &card_list);
2418
3142
 
2419
3143
        return 0;
2420
3144
}
 
3145
EXPORT_SYMBOL_GPL(snd_soc_register_card);
2421
3146
 
2422
3147
/**
2423
3148
 * snd_soc_unregister_card - Unregister a card with the ASoC core
2424
3149
 *
2425
3150
 * @card: Card to unregister
2426
3151
 *
2427
 
 * Note that currently this is an internal only function: it will be
2428
 
 * exposed to machine drivers after further backporting of ASoC v2
2429
 
 * registration APIs.
2430
3152
 */
2431
 
static int snd_soc_unregister_card(struct snd_soc_card *card)
 
3153
int snd_soc_unregister_card(struct snd_soc_card *card)
2432
3154
{
 
3155
        if (card->instantiated)
 
3156
                soc_cleanup_card_resources(card);
2433
3157
        mutex_lock(&client_mutex);
2434
3158
        list_del(&card->list);
2435
3159
        mutex_unlock(&client_mutex);
2436
 
 
2437
3160
        dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
2438
3161
 
2439
3162
        return 0;
2440
3163
}
 
3164
EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
 
3165
 
 
3166
/*
 
3167
 * Simplify DAI link configuration by removing ".-1" from device names
 
3168
 * and sanitizing names.
 
3169
 */
 
3170
static char *fmt_single_name(struct device *dev, int *id)
 
3171
{
 
3172
        char *found, name[NAME_SIZE];
 
3173
        int id1, id2;
 
3174
 
 
3175
        if (dev_name(dev) == NULL)
 
3176
                return NULL;
 
3177
 
 
3178
        strlcpy(name, dev_name(dev), NAME_SIZE);
 
3179
 
 
3180
        /* are we a "%s.%d" name (platform and SPI components) */
 
3181
        found = strstr(name, dev->driver->name);
 
3182
        if (found) {
 
3183
                /* get ID */
 
3184
                if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
 
3185
 
 
3186
                        /* discard ID from name if ID == -1 */
 
3187
                        if (*id == -1)
 
3188
                                found[strlen(dev->driver->name)] = '\0';
 
3189
                }
 
3190
 
 
3191
        } else {
 
3192
                /* I2C component devices are named "bus-addr"  */
 
3193
                if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
 
3194
                        char tmp[NAME_SIZE];
 
3195
 
 
3196
                        /* create unique ID number from I2C addr and bus */
 
3197
                        *id = ((id1 & 0xffff) << 16) + id2;
 
3198
 
 
3199
                        /* sanitize component name for DAI link creation */
 
3200
                        snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
 
3201
                        strlcpy(name, tmp, NAME_SIZE);
 
3202
                } else
 
3203
                        *id = 0;
 
3204
        }
 
3205
 
 
3206
        return kstrdup(name, GFP_KERNEL);
 
3207
}
 
3208
 
 
3209
/*
 
3210
 * Simplify DAI link naming for single devices with multiple DAIs by removing
 
3211
 * any ".-1" and using the DAI name (instead of device name).
 
3212
 */
 
3213
static inline char *fmt_multiple_name(struct device *dev,
 
3214
                struct snd_soc_dai_driver *dai_drv)
 
3215
{
 
3216
        if (dai_drv->name == NULL) {
 
3217
                printk(KERN_ERR "asoc: error - multiple DAI %s registered with no name\n",
 
3218
                                dev_name(dev));
 
3219
                return NULL;
 
3220
        }
 
3221
 
 
3222
        return kstrdup(dai_drv->name, GFP_KERNEL);
 
3223
}
2441
3224
 
2442
3225
/**
2443
3226
 * snd_soc_register_dai - Register a DAI with the ASoC core
2444
3227
 *
2445
3228
 * @dai: DAI to register
2446
3229
 */
2447
 
int snd_soc_register_dai(struct snd_soc_dai *dai)
 
3230
int snd_soc_register_dai(struct device *dev,
 
3231
                struct snd_soc_dai_driver *dai_drv)
2448
3232
{
2449
 
        if (!dai->name)
2450
 
                return -EINVAL;
2451
 
 
2452
 
        /* The device should become mandatory over time */
2453
 
        if (!dai->dev)
2454
 
                printk(KERN_WARNING "No device for DAI %s\n", dai->name);
2455
 
 
2456
 
        if (!dai->ops)
2457
 
                dai->ops = &null_dai_ops;
2458
 
 
2459
 
        INIT_LIST_HEAD(&dai->list);
 
3233
        struct snd_soc_dai *dai;
 
3234
 
 
3235
        dev_dbg(dev, "dai register %s\n", dev_name(dev));
 
3236
 
 
3237
        dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
 
3238
        if (dai == NULL)
 
3239
                        return -ENOMEM;
 
3240
 
 
3241
        /* create DAI component name */
 
3242
        dai->name = fmt_single_name(dev, &dai->id);
 
3243
        if (dai->name == NULL) {
 
3244
                kfree(dai);
 
3245
                return -ENOMEM;
 
3246
        }
 
3247
 
 
3248
        dai->dev = dev;
 
3249
        dai->driver = dai_drv;
 
3250
        if (!dai->driver->ops)
 
3251
                dai->driver->ops = &null_dai_ops;
2460
3252
 
2461
3253
        mutex_lock(&client_mutex);
2462
3254
        list_add(&dai->list, &dai_list);
2474
3266
 *
2475
3267
 * @dai: DAI to unregister
2476
3268
 */
2477
 
void snd_soc_unregister_dai(struct snd_soc_dai *dai)
 
3269
void snd_soc_unregister_dai(struct device *dev)
2478
3270
{
 
3271
        struct snd_soc_dai *dai;
 
3272
 
 
3273
        list_for_each_entry(dai, &dai_list, list) {
 
3274
                if (dev == dai->dev)
 
3275
                        goto found;
 
3276
        }
 
3277
        return;
 
3278
 
 
3279
found:
2479
3280
        mutex_lock(&client_mutex);
2480
3281
        list_del(&dai->list);
2481
3282
        mutex_unlock(&client_mutex);
2482
3283
 
2483
3284
        pr_debug("Unregistered DAI '%s'\n", dai->name);
 
3285
        kfree(dai->name);
 
3286
        kfree(dai);
2484
3287
}
2485
3288
EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
2486
3289
 
2490
3293
 * @dai: Array of DAIs to register
2491
3294
 * @count: Number of DAIs
2492
3295
 */
2493
 
int snd_soc_register_dais(struct snd_soc_dai *dai, size_t count)
 
3296
int snd_soc_register_dais(struct device *dev,
 
3297
                struct snd_soc_dai_driver *dai_drv, size_t count)
2494
3298
{
2495
 
        int i, ret;
 
3299
        struct snd_soc_dai *dai;
 
3300
        int i, ret = 0;
 
3301
 
 
3302
        dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
2496
3303
 
2497
3304
        for (i = 0; i < count; i++) {
2498
 
                ret = snd_soc_register_dai(&dai[i]);
2499
 
                if (ret != 0)
2500
 
                        goto err;
 
3305
 
 
3306
                dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
 
3307
                if (dai == NULL) {
 
3308
                        ret = -ENOMEM;
 
3309
                        goto err;
 
3310
                }
 
3311
 
 
3312
                /* create DAI component name */
 
3313
                dai->name = fmt_multiple_name(dev, &dai_drv[i]);
 
3314
                if (dai->name == NULL) {
 
3315
                        kfree(dai);
 
3316
                        ret = -EINVAL;
 
3317
                        goto err;
 
3318
                }
 
3319
 
 
3320
                dai->dev = dev;
 
3321
                dai->driver = &dai_drv[i];
 
3322
                if (dai->driver->id)
 
3323
                        dai->id = dai->driver->id;
 
3324
                else
 
3325
                        dai->id = i;
 
3326
                if (!dai->driver->ops)
 
3327
                        dai->driver->ops = &null_dai_ops;
 
3328
 
 
3329
                mutex_lock(&client_mutex);
 
3330
                list_add(&dai->list, &dai_list);
 
3331
                mutex_unlock(&client_mutex);
 
3332
 
 
3333
                pr_debug("Registered DAI '%s'\n", dai->name);
2501
3334
        }
2502
3335
 
 
3336
        mutex_lock(&client_mutex);
 
3337
        snd_soc_instantiate_cards();
 
3338
        mutex_unlock(&client_mutex);
2503
3339
        return 0;
2504
3340
 
2505
3341
err:
2506
3342
        for (i--; i >= 0; i--)
2507
 
                snd_soc_unregister_dai(&dai[i]);
 
3343
                snd_soc_unregister_dai(dev);
2508
3344
 
2509
3345
        return ret;
2510
3346
}
2516
3352
 * @dai: Array of DAIs to unregister
2517
3353
 * @count: Number of DAIs
2518
3354
 */
2519
 
void snd_soc_unregister_dais(struct snd_soc_dai *dai, size_t count)
 
3355
void snd_soc_unregister_dais(struct device *dev, size_t count)
2520
3356
{
2521
3357
        int i;
2522
3358
 
2523
3359
        for (i = 0; i < count; i++)
2524
 
                snd_soc_unregister_dai(&dai[i]);
 
3360
                snd_soc_unregister_dai(dev);
2525
3361
}
2526
3362
EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
2527
3363
 
2530
3366
 *
2531
3367
 * @platform: platform to register
2532
3368
 */
2533
 
int snd_soc_register_platform(struct snd_soc_platform *platform)
 
3369
int snd_soc_register_platform(struct device *dev,
 
3370
                struct snd_soc_platform_driver *platform_drv)
2534
3371
{
2535
 
        if (!platform->name)
2536
 
                return -EINVAL;
2537
 
 
2538
 
        INIT_LIST_HEAD(&platform->list);
 
3372
        struct snd_soc_platform *platform;
 
3373
 
 
3374
        dev_dbg(dev, "platform register %s\n", dev_name(dev));
 
3375
 
 
3376
        platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
 
3377
        if (platform == NULL)
 
3378
                        return -ENOMEM;
 
3379
 
 
3380
        /* create platform component name */
 
3381
        platform->name = fmt_single_name(dev, &platform->id);
 
3382
        if (platform->name == NULL) {
 
3383
                kfree(platform);
 
3384
                return -ENOMEM;
 
3385
        }
 
3386
 
 
3387
        platform->dev = dev;
 
3388
        platform->driver = platform_drv;
2539
3389
 
2540
3390
        mutex_lock(&client_mutex);
2541
3391
        list_add(&platform->list, &platform_list);
2553
3403
 *
2554
3404
 * @platform: platform to unregister
2555
3405
 */
2556
 
void snd_soc_unregister_platform(struct snd_soc_platform *platform)
 
3406
void snd_soc_unregister_platform(struct device *dev)
2557
3407
{
 
3408
        struct snd_soc_platform *platform;
 
3409
 
 
3410
        list_for_each_entry(platform, &platform_list, list) {
 
3411
                if (dev == platform->dev)
 
3412
                        goto found;
 
3413
        }
 
3414
        return;
 
3415
 
 
3416
found:
2558
3417
        mutex_lock(&client_mutex);
2559
3418
        list_del(&platform->list);
2560
3419
        mutex_unlock(&client_mutex);
2561
3420
 
2562
3421
        pr_debug("Unregistered platform '%s'\n", platform->name);
 
3422
        kfree(platform->name);
 
3423
        kfree(platform);
2563
3424
}
2564
3425
EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
2565
3426
 
2601
3462
 *
2602
3463
 * @codec: codec to register
2603
3464
 */
2604
 
int snd_soc_register_codec(struct snd_soc_codec *codec)
 
3465
int snd_soc_register_codec(struct device *dev,
 
3466
                           const struct snd_soc_codec_driver *codec_drv,
 
3467
                           struct snd_soc_dai_driver *dai_drv,
 
3468
                           int num_dai)
2605
3469
{
2606
 
        int i;
2607
 
 
2608
 
        if (!codec->name)
2609
 
                return -EINVAL;
2610
 
 
2611
 
        /* The device should become mandatory over time */
2612
 
        if (!codec->dev)
2613
 
                printk(KERN_WARNING "No device for codec %s\n", codec->name);
2614
 
 
2615
 
        INIT_LIST_HEAD(&codec->list);
2616
 
 
2617
 
        for (i = 0; i < codec->num_dai; i++) {
2618
 
                fixup_codec_formats(&codec->dai[i].playback);
2619
 
                fixup_codec_formats(&codec->dai[i].capture);
 
3470
        size_t reg_size;
 
3471
        struct snd_soc_codec *codec;
 
3472
        int ret, i;
 
3473
 
 
3474
        dev_dbg(dev, "codec register %s\n", dev_name(dev));
 
3475
 
 
3476
        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
 
3477
        if (codec == NULL)
 
3478
                return -ENOMEM;
 
3479
 
 
3480
        /* create CODEC component name */
 
3481
        codec->name = fmt_single_name(dev, &codec->id);
 
3482
        if (codec->name == NULL) {
 
3483
                kfree(codec);
 
3484
                return -ENOMEM;
 
3485
        }
 
3486
 
 
3487
        if (codec_drv->compress_type)
 
3488
                codec->compress_type = codec_drv->compress_type;
 
3489
        else
 
3490
                codec->compress_type = SND_SOC_FLAT_COMPRESSION;
 
3491
 
 
3492
        codec->write = codec_drv->write;
 
3493
        codec->read = codec_drv->read;
 
3494
        codec->volatile_register = codec_drv->volatile_register;
 
3495
        codec->readable_register = codec_drv->readable_register;
 
3496
        codec->dapm.bias_level = SND_SOC_BIAS_OFF;
 
3497
        codec->dapm.dev = dev;
 
3498
        codec->dapm.codec = codec;
 
3499
        codec->dev = dev;
 
3500
        codec->driver = codec_drv;
 
3501
        codec->num_dai = num_dai;
 
3502
        mutex_init(&codec->mutex);
 
3503
 
 
3504
        /* allocate CODEC register cache */
 
3505
        if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
 
3506
                reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
 
3507
                codec->reg_size = reg_size;
 
3508
                /* it is necessary to make a copy of the default register cache
 
3509
                 * because in the case of using a compression type that requires
 
3510
                 * the default register cache to be marked as __devinitconst the
 
3511
                 * kernel might have freed the array by the time we initialize
 
3512
                 * the cache.
 
3513
                 */
 
3514
                if (codec_drv->reg_cache_default) {
 
3515
                        codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
 
3516
                                                      reg_size, GFP_KERNEL);
 
3517
                        if (!codec->reg_def_copy) {
 
3518
                                ret = -ENOMEM;
 
3519
                                goto fail;
 
3520
                        }
 
3521
                }
 
3522
        }
 
3523
 
 
3524
        if (codec_drv->reg_access_size && codec_drv->reg_access_default) {
 
3525
                if (!codec->volatile_register)
 
3526
                        codec->volatile_register = snd_soc_default_volatile_register;
 
3527
                if (!codec->readable_register)
 
3528
                        codec->readable_register = snd_soc_default_readable_register;
 
3529
        }
 
3530
 
 
3531
        for (i = 0; i < num_dai; i++) {
 
3532
                fixup_codec_formats(&dai_drv[i].playback);
 
3533
                fixup_codec_formats(&dai_drv[i].capture);
 
3534
        }
 
3535
 
 
3536
        /* register any DAIs */
 
3537
        if (num_dai) {
 
3538
                ret = snd_soc_register_dais(dev, dai_drv, num_dai);
 
3539
                if (ret < 0)
 
3540
                        goto fail;
2620
3541
        }
2621
3542
 
2622
3543
        mutex_lock(&client_mutex);
2625
3546
        mutex_unlock(&client_mutex);
2626
3547
 
2627
3548
        pr_debug("Registered codec '%s'\n", codec->name);
 
3549
        return 0;
2628
3550
 
2629
 
        return 0;
 
3551
fail:
 
3552
        kfree(codec->reg_def_copy);
 
3553
        codec->reg_def_copy = NULL;
 
3554
        kfree(codec->name);
 
3555
        kfree(codec);
 
3556
        return ret;
2630
3557
}
2631
3558
EXPORT_SYMBOL_GPL(snd_soc_register_codec);
2632
3559
 
2635
3562
 *
2636
3563
 * @codec: codec to unregister
2637
3564
 */
2638
 
void snd_soc_unregister_codec(struct snd_soc_codec *codec)
 
3565
void snd_soc_unregister_codec(struct device *dev)
2639
3566
{
 
3567
        struct snd_soc_codec *codec;
 
3568
        int i;
 
3569
 
 
3570
        list_for_each_entry(codec, &codec_list, list) {
 
3571
                if (dev == codec->dev)
 
3572
                        goto found;
 
3573
        }
 
3574
        return;
 
3575
 
 
3576
found:
 
3577
        if (codec->num_dai)
 
3578
                for (i = 0; i < codec->num_dai; i++)
 
3579
                        snd_soc_unregister_dai(dev);
 
3580
 
2640
3581
        mutex_lock(&client_mutex);
2641
3582
        list_del(&codec->list);
2642
3583
        mutex_unlock(&client_mutex);
2643
3584
 
2644
3585
        pr_debug("Unregistered codec '%s'\n", codec->name);
 
3586
 
 
3587
        snd_soc_cache_exit(codec);
 
3588
        kfree(codec->reg_def_copy);
 
3589
        kfree(codec->name);
 
3590
        kfree(codec);
2645
3591
}
2646
3592
EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
2647
3593
 
2648
3594
static int __init snd_soc_init(void)
2649
3595
{
2650
3596
#ifdef CONFIG_DEBUG_FS
2651
 
        debugfs_root = debugfs_create_dir("asoc", NULL);
2652
 
        if (IS_ERR(debugfs_root) || !debugfs_root) {
 
3597
        snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
 
3598
        if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
2653
3599
                printk(KERN_WARNING
2654
3600
                       "ASoC: Failed to create debugfs directory\n");
2655
 
                debugfs_root = NULL;
 
3601
                snd_soc_debugfs_root = NULL;
2656
3602
        }
 
3603
 
 
3604
        if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
 
3605
                                 &codec_list_fops))
 
3606
                pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
 
3607
 
 
3608
        if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
 
3609
                                 &dai_list_fops))
 
3610
                pr_warn("ASoC: Failed to create DAI list debugfs file\n");
 
3611
 
 
3612
        if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
 
3613
                                 &platform_list_fops))
 
3614
                pr_warn("ASoC: Failed to create platform list debugfs file\n");
2657
3615
#endif
2658
3616
 
2659
3617
        return platform_driver_register(&soc_driver);
2660
3618
}
 
3619
module_init(snd_soc_init);
2661
3620
 
2662
3621
static void __exit snd_soc_exit(void)
2663
3622
{
2664
3623
#ifdef CONFIG_DEBUG_FS
2665
 
        debugfs_remove_recursive(debugfs_root);
 
3624
        debugfs_remove_recursive(snd_soc_debugfs_root);
2666
3625
#endif
2667
3626
        platform_driver_unregister(&soc_driver);
2668
3627
}
2669
 
 
2670
 
module_init(snd_soc_init);
2671
3628
module_exit(snd_soc_exit);
2672
3629
 
2673
3630
/* Module information */