← Back to branch summary

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

« back to all changes in this revision

Viewing changes to alsa-kernel/soc/sh/fsi-ak4642.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/sh/fsi-ak4642.c
9
9
 * for more details.
10
10
 */
11
11
 
12
 
#include <linux/module.h>
13
 
#include <linux/moduleparam.h>
14
12
#include <linux/platform_device.h>
15
 
#include <linux/i2c.h>
16
 
#include <linux/io.h>
17
 
#include <sound/core.h>
18
 
#include <sound/pcm.h>
19
 
#include <sound/soc.h>
20
 
#include <sound/soc-dapm.h>
21
 
 
22
13
#include <sound/sh_fsi.h>
23
 
#include <../sound/soc/codecs/ak4642.h>
24
 
 
25
 
static int fsi_ak4642_dai_init(struct snd_soc_codec *codec)
 
14
 
 
15
struct fsi_ak4642_data {
 
16
        const char *name;
 
17
        const char *card;
 
18
        const char *cpu_dai;
 
19
        const char *codec;
 
20
        const char *platform;
 
21
        int id;
 
22
};
 
23
 
 
24
static int fsi_ak4642_dai_init(struct snd_soc_pcm_runtime *rtd)
26
25
{
 
26
        struct snd_soc_dai *dai = rtd->codec_dai;
27
27
        int ret;
28
28
 
29
 
        ret = snd_soc_dai_set_fmt(&ak4642_dai, SND_SOC_DAIFMT_CBM_CFM);
 
29
        ret = snd_soc_dai_set_fmt(dai, SND_SOC_DAIFMT_CBM_CFM);
30
30
        if (ret < 0)
31
31
                return ret;
32
32
 
33
 
        ret = snd_soc_dai_set_sysclk(&ak4642_dai, 0, 11289600, 0);
 
33
        ret = snd_soc_dai_set_sysclk(dai, 0, 11289600, 0);
34
34
 
35
35
        return ret;
36
36
}
37
37
 
38
38
static struct snd_soc_dai_link fsi_dai_link = {
39
 
        .name           = "AK4642",
40
 
        .stream_name    = "AK4642",
41
 
        .cpu_dai        = &fsi_soc_dai[0], /* fsi */
42
 
        .codec_dai      = &ak4642_dai,
 
39
        .codec_dai_name = "ak4642-hifi",
43
40
        .init           = fsi_ak4642_dai_init,
44
 
        .ops            = NULL,
45
41
};
46
42
 
47
43
static struct snd_soc_card fsi_soc_card  = {
48
 
        .name           = "FSI",
49
 
        .platform       = &fsi_soc_platform,
50
44
        .dai_link       = &fsi_dai_link,
51
45
        .num_links      = 1,
52
46
};
53
47
 
54
 
static struct snd_soc_device fsi_snd_devdata = {
55
 
        .card           = &fsi_soc_card,
56
 
        .codec_dev      = &soc_codec_dev_ak4642,
57
 
};
58
 
 
59
48
static struct platform_device *fsi_snd_device;
60
49
 
61
 
static int __init fsi_ak4642_init(void)
 
50
static int fsi_ak4642_probe(struct platform_device *pdev)
62
51
{
63
52
        int ret = -ENOMEM;
64
 
 
65
 
        fsi_snd_device = platform_device_alloc("soc-audio", -1);
 
53
        const struct platform_device_id *id_entry;
 
54
        struct fsi_ak4642_data *pdata;
 
55
 
 
56
        id_entry = pdev->id_entry;
 
57
        if (!id_entry) {
 
58
                dev_err(&pdev->dev, "unknown fsi ak4642\n");
 
59
                return -ENODEV;
 
60
        }
 
61
 
 
62
        pdata = (struct fsi_ak4642_data *)id_entry->driver_data;
 
63
 
 
64
        fsi_snd_device = platform_device_alloc("soc-audio", pdata->id);
66
65
        if (!fsi_snd_device)
67
66
                goto out;
68
67
 
69
 
        platform_set_drvdata(fsi_snd_device,
70
 
                             &fsi_snd_devdata);
71
 
        fsi_snd_devdata.dev = &fsi_snd_device->dev;
 
68
        fsi_dai_link.name               = pdata->name;
 
69
        fsi_dai_link.stream_name        = pdata->name;
 
70
        fsi_dai_link.cpu_dai_name       = pdata->cpu_dai;
 
71
        fsi_dai_link.platform_name      = pdata->platform;
 
72
        fsi_dai_link.codec_name         = pdata->codec;
 
73
        fsi_soc_card.name               = pdata->card;
 
74
 
 
75
        platform_set_drvdata(fsi_snd_device, &fsi_soc_card);
72
76
        ret = platform_device_add(fsi_snd_device);
73
77
 
74
78
        if (ret)
78
82
        return ret;
79
83
}
80
84
 
 
85
static int fsi_ak4642_remove(struct platform_device *pdev)
 
86
{
 
87
        platform_device_unregister(fsi_snd_device);
 
88
        return 0;
 
89
}
 
90
 
 
91
static struct fsi_ak4642_data fsi_a_ak4642 = {
 
92
        .name           = "AK4642",
 
93
        .card           = "FSIA (AK4642)",
 
94
        .cpu_dai        = "fsia-dai",
 
95
        .codec          = "ak4642-codec.0-0012",
 
96
        .platform       = "sh_fsi.0",
 
97
        .id             = FSI_PORT_A,
 
98
};
 
99
 
 
100
static struct fsi_ak4642_data fsi_b_ak4642 = {
 
101
        .name           = "AK4642",
 
102
        .card           = "FSIB (AK4642)",
 
103
        .cpu_dai        = "fsib-dai",
 
104
        .codec          = "ak4642-codec.0-0012",
 
105
        .platform       = "sh_fsi.0",
 
106
        .id             = FSI_PORT_B,
 
107
};
 
108
 
 
109
static struct fsi_ak4642_data fsi_a_ak4643 = {
 
110
        .name           = "AK4643",
 
111
        .card           = "FSIA (AK4643)",
 
112
        .cpu_dai        = "fsia-dai",
 
113
        .codec          = "ak4642-codec.0-0013",
 
114
        .platform       = "sh_fsi.0",
 
115
        .id             = FSI_PORT_A,
 
116
};
 
117
 
 
118
static struct fsi_ak4642_data fsi_b_ak4643 = {
 
119
        .name           = "AK4643",
 
120
        .card           = "FSIB (AK4643)",
 
121
        .cpu_dai        = "fsib-dai",
 
122
        .codec          = "ak4642-codec.0-0013",
 
123
        .platform       = "sh_fsi.0",
 
124
        .id             = FSI_PORT_B,
 
125
};
 
126
 
 
127
static struct fsi_ak4642_data fsi2_a_ak4642 = {
 
128
        .name           = "AK4642",
 
129
        .card           = "FSI2A (AK4642)",
 
130
        .cpu_dai        = "fsia-dai",
 
131
        .codec          = "ak4642-codec.0-0012",
 
132
        .platform       = "sh_fsi2",
 
133
        .id             = FSI_PORT_A,
 
134
};
 
135
 
 
136
static struct fsi_ak4642_data fsi2_b_ak4642 = {
 
137
        .name           = "AK4642",
 
138
        .card           = "FSI2B (AK4642)",
 
139
        .cpu_dai        = "fsib-dai",
 
140
        .codec          = "ak4642-codec.0-0012",
 
141
        .platform       = "sh_fsi2",
 
142
        .id             = FSI_PORT_B,
 
143
};
 
144
 
 
145
static struct fsi_ak4642_data fsi2_a_ak4643 = {
 
146
        .name           = "AK4643",
 
147
        .card           = "FSI2A (AK4643)",
 
148
        .cpu_dai        = "fsia-dai",
 
149
        .codec          = "ak4642-codec.0-0013",
 
150
        .platform       = "sh_fsi2",
 
151
        .id             = FSI_PORT_A,
 
152
};
 
153
 
 
154
static struct fsi_ak4642_data fsi2_b_ak4643 = {
 
155
        .name           = "AK4643",
 
156
        .card           = "FSI2B (AK4643)",
 
157
        .cpu_dai        = "fsib-dai",
 
158
        .codec          = "ak4642-codec.0-0013",
 
159
        .platform       = "sh_fsi2",
 
160
        .id             = FSI_PORT_B,
 
161
};
 
162
 
 
163
static struct platform_device_id fsi_id_table[] = {
 
164
        /* FSI */
 
165
        { "sh_fsi_a_ak4642",    (kernel_ulong_t)&fsi_a_ak4642 },
 
166
        { "sh_fsi_b_ak4642",    (kernel_ulong_t)&fsi_b_ak4642 },
 
167
        { "sh_fsi_a_ak4643",    (kernel_ulong_t)&fsi_a_ak4643 },
 
168
        { "sh_fsi_b_ak4643",    (kernel_ulong_t)&fsi_b_ak4643 },
 
169
 
 
170
        /* FSI 2 */
 
171
        { "sh_fsi2_a_ak4642",   (kernel_ulong_t)&fsi2_a_ak4642 },
 
172
        { "sh_fsi2_b_ak4642",   (kernel_ulong_t)&fsi2_b_ak4642 },
 
173
        { "sh_fsi2_a_ak4643",   (kernel_ulong_t)&fsi2_a_ak4643 },
 
174
        { "sh_fsi2_b_ak4643",   (kernel_ulong_t)&fsi2_b_ak4643 },
 
175
        {},
 
176
};
 
177
 
 
178
static struct platform_driver fsi_ak4642 = {
 
179
        .driver = {
 
180
                .name   = "fsi-ak4642-audio",
 
181
        },
 
182
        .probe          = fsi_ak4642_probe,
 
183
        .remove         = fsi_ak4642_remove,
 
184
        .id_table       = fsi_id_table,
 
185
};
 
186
 
 
187
static int __init fsi_ak4642_init(void)
 
188
{
 
189
        return platform_driver_register(&fsi_ak4642);
 
190
}
 
191
 
81
192
static void __exit fsi_ak4642_exit(void)
82
193
{
83
 
        platform_device_unregister(fsi_snd_device);
 
194
        platform_driver_unregister(&fsi_ak4642);
84
195
}
85
196
 
86
197
module_init(fsi_ak4642_init);