aboutsummaryrefslogtreecommitdiffstats
path: root/sound/soc/blackfin
diff options
context:
space:
mode:
Diffstat (limited to 'sound/soc/blackfin')
-rw-r--r--sound/soc/blackfin/Kconfig11
-rw-r--r--sound/soc/blackfin/bf5xx-ac97-pcm.c54
-rw-r--r--sound/soc/blackfin/bf5xx-ac97-pcm.h3
-rw-r--r--sound/soc/blackfin/bf5xx-ac97.c181
-rw-r--r--sound/soc/blackfin/bf5xx-ac97.h2
-rw-r--r--sound/soc/blackfin/bf5xx-ad1836.c54
-rw-r--r--sound/soc/blackfin/bf5xx-ad193x.c68
-rw-r--r--sound/soc/blackfin/bf5xx-ad1980.c52
-rw-r--r--sound/soc/blackfin/bf5xx-ad73311.c53
-rw-r--r--sound/soc/blackfin/bf5xx-i2s-pcm.c78
-rw-r--r--sound/soc/blackfin/bf5xx-i2s-pcm.h3
-rw-r--r--sound/soc/blackfin/bf5xx-i2s.c197
-rw-r--r--sound/soc/blackfin/bf5xx-i2s.h14
-rw-r--r--sound/soc/blackfin/bf5xx-sport.c159
-rw-r--r--sound/soc/blackfin/bf5xx-sport.h16
-rw-r--r--sound/soc/blackfin/bf5xx-ssm2602.c69
-rw-r--r--sound/soc/blackfin/bf5xx-tdm-pcm.c64
-rw-r--r--sound/soc/blackfin/bf5xx-tdm-pcm.h3
-rw-r--r--sound/soc/blackfin/bf5xx-tdm.c133
-rw-r--r--sound/soc/blackfin/bf5xx-tdm.h2
20 files changed, 615 insertions, 601 deletions
diff --git a/sound/soc/blackfin/Kconfig b/sound/soc/blackfin/Kconfig
index 3abeeddc67d3..ae403597fd31 100644
--- a/sound/soc/blackfin/Kconfig
+++ b/sound/soc/blackfin/Kconfig
@@ -1,6 +1,7 @@
1config SND_BF5XX_I2S 1config SND_BF5XX_I2S
2 tristate "SoC I2S Audio for the ADI BF5xx chip" 2 tristate "SoC I2S Audio for the ADI BF5xx chip"
3 depends on BLACKFIN 3 depends on BLACKFIN
4 select SND_BF5XX_SOC_SPORT
4 help 5 help
5 Say Y or M if you want to add support for codecs attached to 6 Say Y or M if you want to add support for codecs attached to
6 the Blackfin SPORT (synchronous serial ports) interface in I2S 7 the Blackfin SPORT (synchronous serial ports) interface in I2S
@@ -35,6 +36,7 @@ config SND_BFIN_AD73311_SE
35config SND_BF5XX_TDM 36config SND_BF5XX_TDM
36 tristate "SoC I2S(TDM mode) Audio for the ADI BF5xx chip" 37 tristate "SoC I2S(TDM mode) Audio for the ADI BF5xx chip"
37 depends on (BLACKFIN && SND_SOC) 38 depends on (BLACKFIN && SND_SOC)
39 select SND_BF5XX_SOC_SPORT
38 help 40 help
39 Say Y or M if you want to add support for codecs attached to 41 Say Y or M if you want to add support for codecs attached to
40 the Blackfin SPORT (synchronous serial ports) interface in TDM 42 the Blackfin SPORT (synchronous serial ports) interface in TDM
@@ -61,6 +63,10 @@ config SND_BF5XX_SOC_AD193X
61config SND_BF5XX_AC97 63config SND_BF5XX_AC97
62 tristate "SoC AC97 Audio for the ADI BF5xx chip" 64 tristate "SoC AC97 Audio for the ADI BF5xx chip"
63 depends on BLACKFIN 65 depends on BLACKFIN
66 select AC97_BUS
67 select SND_SOC_AC97_BUS
68 select SND_BF5XX_SOC_SPORT
69 select SND_BF5XX_SOC_AC97
64 help 70 help
65 Say Y or M if you want to add support for codecs attached to 71 Say Y or M if you want to add support for codecs attached to
66 the Blackfin SPORT (synchronous serial ports) interface in slot 16 72 the Blackfin SPORT (synchronous serial ports) interface in slot 16
@@ -122,17 +128,12 @@ config SND_BF5XX_SOC_SPORT
122 128
123config SND_BF5XX_SOC_I2S 129config SND_BF5XX_SOC_I2S
124 tristate 130 tristate
125 select SND_BF5XX_SOC_SPORT
126 131
127config SND_BF5XX_SOC_TDM 132config SND_BF5XX_SOC_TDM
128 tristate 133 tristate
129 select SND_BF5XX_SOC_SPORT
130 134
131config SND_BF5XX_SOC_AC97 135config SND_BF5XX_SOC_AC97
132 tristate 136 tristate
133 select AC97_BUS
134 select SND_SOC_AC97_BUS
135 select SND_BF5XX_SOC_SPORT
136 137
137config SND_BF5XX_SPORT_NUM 138config SND_BF5XX_SPORT_NUM
138 int "Set a SPORT for Sound chip" 139 int "Set a SPORT for Sound chip"
diff --git a/sound/soc/blackfin/bf5xx-ac97-pcm.c b/sound/soc/blackfin/bf5xx-ac97-pcm.c
index 5e7aacf3bb5a..98b44b316e78 100644
--- a/sound/soc/blackfin/bf5xx-ac97-pcm.c
+++ b/sound/soc/blackfin/bf5xx-ac97-pcm.c
@@ -243,6 +243,9 @@ static snd_pcm_uframes_t bf5xx_pcm_pointer(struct snd_pcm_substream *substream)
243 243
244static int bf5xx_pcm_open(struct snd_pcm_substream *substream) 244static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
245{ 245{
246 struct snd_soc_pcm_runtime *rtd = substream->private_data;
247 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
248 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
246 struct snd_pcm_runtime *runtime = substream->runtime; 249 struct snd_pcm_runtime *runtime = substream->runtime;
247 int ret; 250 int ret;
248 251
@@ -314,6 +317,9 @@ static struct snd_pcm_ops bf5xx_pcm_ac97_ops = {
314 317
315static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream) 318static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
316{ 319{
320 struct snd_soc_pcm_runtime *rtd = pcm->private_data;
321 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
322 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
317 struct snd_pcm_substream *substream = pcm->streams[stream].substream; 323 struct snd_pcm_substream *substream = pcm->streams[stream].substream;
318 struct snd_dma_buffer *buf = &substream->dma_buffer; 324 struct snd_dma_buffer *buf = &substream->dma_buffer;
319 size_t size = bf5xx_pcm_hardware.buffer_bytes_max 325 size_t size = bf5xx_pcm_hardware.buffer_bytes_max
@@ -377,6 +383,9 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
377 struct snd_dma_buffer *buf; 383 struct snd_dma_buffer *buf;
378 int stream; 384 int stream;
379#if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT) 385#if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
386 struct snd_soc_pcm_runtime *rtd = pcm->private_data;
387 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
388 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
380 size_t size = bf5xx_pcm_hardware.buffer_bytes_max * 389 size_t size = bf5xx_pcm_hardware.buffer_bytes_max *
381 sizeof(struct ac97_frame) / 4; 390 sizeof(struct ac97_frame) / 4;
382#endif 391#endif
@@ -405,8 +414,6 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
405 } 414 }
406#endif 415#endif
407 } 416 }
408 if (sport_handle)
409 sport_done(sport_handle);
410} 417}
411 418
412static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32); 419static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
@@ -422,14 +429,14 @@ int bf5xx_pcm_ac97_new(struct snd_card *card, struct snd_soc_dai *dai,
422 if (!card->dev->coherent_dma_mask) 429 if (!card->dev->coherent_dma_mask)
423 card->dev->coherent_dma_mask = DMA_BIT_MASK(32); 430 card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
424 431
425 if (dai->playback.channels_min) { 432 if (dai->driver->playback.channels_min) {
426 ret = bf5xx_pcm_preallocate_dma_buffer(pcm, 433 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
427 SNDRV_PCM_STREAM_PLAYBACK); 434 SNDRV_PCM_STREAM_PLAYBACK);
428 if (ret) 435 if (ret)
429 goto out; 436 goto out;
430 } 437 }
431 438
432 if (dai->capture.channels_min) { 439 if (dai->driver->capture.channels_min) {
433 ret = bf5xx_pcm_preallocate_dma_buffer(pcm, 440 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
434 SNDRV_PCM_STREAM_CAPTURE); 441 SNDRV_PCM_STREAM_CAPTURE);
435 if (ret) 442 if (ret)
@@ -439,25 +446,44 @@ int bf5xx_pcm_ac97_new(struct snd_card *card, struct snd_soc_dai *dai,
439 return ret; 446 return ret;
440} 447}
441 448
442struct snd_soc_platform bf5xx_ac97_soc_platform = { 449static struct snd_soc_platform_driver bf5xx_ac97_soc_platform = {
443 .name = "bf5xx-audio", 450 .ops = &bf5xx_pcm_ac97_ops,
444 .pcm_ops = &bf5xx_pcm_ac97_ops,
445 .pcm_new = bf5xx_pcm_ac97_new, 451 .pcm_new = bf5xx_pcm_ac97_new,
446 .pcm_free = bf5xx_pcm_free_dma_buffers, 452 .pcm_free = bf5xx_pcm_free_dma_buffers,
447}; 453};
448EXPORT_SYMBOL_GPL(bf5xx_ac97_soc_platform);
449 454
450static int __init bfin_ac97_init(void) 455static int __devinit bf5xx_soc_platform_probe(struct platform_device *pdev)
451{ 456{
452 return snd_soc_register_platform(&bf5xx_ac97_soc_platform); 457 return snd_soc_register_platform(&pdev->dev, &bf5xx_ac97_soc_platform);
453} 458}
454module_init(bfin_ac97_init);
455 459
456static void __exit bfin_ac97_exit(void) 460static int __devexit bf5xx_soc_platform_remove(struct platform_device *pdev)
457{ 461{
458 snd_soc_unregister_platform(&bf5xx_ac97_soc_platform); 462 snd_soc_unregister_platform(&pdev->dev);
463 return 0;
464}
465
466static struct platform_driver bf5xx_pcm_driver = {
467 .driver = {
468 .name = "bfin-ac97-pcm-audio",
469 .owner = THIS_MODULE,
470 },
471
472 .probe = bf5xx_soc_platform_probe,
473 .remove = __devexit_p(bf5xx_soc_platform_remove),
474};
475
476static int __init snd_bf5xx_pcm_init(void)
477{
478 return platform_driver_register(&bf5xx_pcm_driver);
479}
480module_init(snd_bf5xx_pcm_init);
481
482static void __exit snd_bf5xx_pcm_exit(void)
483{
484 platform_driver_unregister(&bf5xx_pcm_driver);
459} 485}
460module_exit(bfin_ac97_exit); 486module_exit(snd_bf5xx_pcm_exit);
461 487
462MODULE_AUTHOR("Cliff Cai"); 488MODULE_AUTHOR("Cliff Cai");
463MODULE_DESCRIPTION("ADI Blackfin AC97 PCM DMA module"); 489MODULE_DESCRIPTION("ADI Blackfin AC97 PCM DMA module");
diff --git a/sound/soc/blackfin/bf5xx-ac97-pcm.h b/sound/soc/blackfin/bf5xx-ac97-pcm.h
index 350125a0ae21..d324d5826a9b 100644
--- a/sound/soc/blackfin/bf5xx-ac97-pcm.h
+++ b/sound/soc/blackfin/bf5xx-ac97-pcm.h
@@ -23,7 +23,4 @@ struct bf5xx_gpio {
23 u32 frm; 23 u32 frm;
24}; 24};
25 25
26/* platform data */
27extern struct snd_soc_platform bf5xx_ac97_soc_platform;
28
29#endif 26#endif
diff --git a/sound/soc/blackfin/bf5xx-ac97.c b/sound/soc/blackfin/bf5xx-ac97.c
index c0eba5109980..6d2162590889 100644
--- a/sound/soc/blackfin/bf5xx-ac97.c
+++ b/sound/soc/blackfin/bf5xx-ac97.c
@@ -41,48 +41,7 @@
41 * anomaly does not affect blackfin sound drivers. 41 * anomaly does not affect blackfin sound drivers.
42*/ 42*/
43 43
44static int *cmd_count; 44static struct sport_device *ac97_sport_handle;
45static int sport_num = CONFIG_SND_BF5XX_SPORT_NUM;
46
47#define SPORT_REQ(x) \
48 [x] = {P_SPORT##x##_TFS, P_SPORT##x##_DTPRI, P_SPORT##x##_TSCLK, \
49 P_SPORT##x##_RFS, P_SPORT##x##_DRPRI, P_SPORT##x##_RSCLK, 0}
50static u16 sport_req[][7] = {
51#ifdef SPORT0_TCR1
52 SPORT_REQ(0),
53#endif
54#ifdef SPORT1_TCR1
55 SPORT_REQ(1),
56#endif
57#ifdef SPORT2_TCR1
58 SPORT_REQ(2),
59#endif
60#ifdef SPORT3_TCR1
61 SPORT_REQ(3),
62#endif
63};
64
65#define SPORT_PARAMS(x) \
66 [x] = { \
67 .dma_rx_chan = CH_SPORT##x##_RX, \
68 .dma_tx_chan = CH_SPORT##x##_TX, \
69 .err_irq = IRQ_SPORT##x##_ERROR, \
70 .regs = (struct sport_register *)SPORT##x##_TCR1, \
71 }
72static struct sport_param sport_params[4] = {
73#ifdef SPORT0_TCR1
74 SPORT_PARAMS(0),
75#endif
76#ifdef SPORT1_TCR1
77 SPORT_PARAMS(1),
78#endif
79#ifdef SPORT2_TCR1
80 SPORT_PARAMS(2),
81#endif
82#ifdef SPORT3_TCR1
83 SPORT_PARAMS(3),
84#endif
85};
86 45
87void bf5xx_pcm_to_ac97(struct ac97_frame *dst, const __u16 *src, 46void bf5xx_pcm_to_ac97(struct ac97_frame *dst, const __u16 *src,
88 size_t count, unsigned int chan_mask) 47 size_t count, unsigned int chan_mask)
@@ -140,7 +99,8 @@ static unsigned int sport_tx_curr_frag(struct sport_device *sport)
140 99
141static void enqueue_cmd(struct snd_ac97 *ac97, __u16 addr, __u16 data) 100static void enqueue_cmd(struct snd_ac97 *ac97, __u16 addr, __u16 data)
142{ 101{
143 struct sport_device *sport = sport_handle; 102 struct sport_device *sport = ac97_sport_handle;
103 int *cmd_count = sport->private_data;
144 int nextfrag = sport_tx_curr_frag(sport); 104 int nextfrag = sport_tx_curr_frag(sport);
145 struct ac97_frame *nextwrite; 105 struct ac97_frame *nextwrite;
146 106
@@ -161,6 +121,7 @@ static void enqueue_cmd(struct snd_ac97 *ac97, __u16 addr, __u16 data)
161static unsigned short bf5xx_ac97_read(struct snd_ac97 *ac97, 121static unsigned short bf5xx_ac97_read(struct snd_ac97 *ac97,
162 unsigned short reg) 122 unsigned short reg)
163{ 123{
124 struct sport_device *sport_handle = ac97_sport_handle;
164 struct ac97_frame out_frame[2], in_frame[2]; 125 struct ac97_frame out_frame[2], in_frame[2];
165 126
166 pr_debug("%s enter 0x%x\n", __func__, reg); 127 pr_debug("%s enter 0x%x\n", __func__, reg);
@@ -185,6 +146,8 @@ static unsigned short bf5xx_ac97_read(struct snd_ac97 *ac97,
185void bf5xx_ac97_write(struct snd_ac97 *ac97, unsigned short reg, 146void bf5xx_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
186 unsigned short val) 147 unsigned short val)
187{ 148{
149 struct sport_device *sport_handle = ac97_sport_handle;
150
188 pr_debug("%s enter 0x%x:0x%04x\n", __func__, reg, val); 151 pr_debug("%s enter 0x%x:0x%04x\n", __func__, reg, val);
189 152
190 if (sport_handle->tx_run) { 153 if (sport_handle->tx_run) {
@@ -203,28 +166,19 @@ void bf5xx_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
203 166
204static void bf5xx_ac97_warm_reset(struct snd_ac97 *ac97) 167static void bf5xx_ac97_warm_reset(struct snd_ac97 *ac97)
205{ 168{
206#if defined(CONFIG_BF54x) || defined(CONFIG_BF561) || \ 169 struct sport_device *sport_handle = ac97_sport_handle;
207 (defined(BF537_FAMILY) && (CONFIG_SND_BF5XX_SPORT_NUM == 1)) 170 u16 gpio = P_IDENT(sport_handle->pin_req[3]);
208
209#define CONCAT(a, b, c) a ## b ## c
210#define BFIN_SPORT_RFS(x) CONCAT(P_SPORT, x, _RFS)
211
212 u16 per = BFIN_SPORT_RFS(CONFIG_SND_BF5XX_SPORT_NUM);
213 u16 gpio = P_IDENT(BFIN_SPORT_RFS(CONFIG_SND_BF5XX_SPORT_NUM));
214 171
215 pr_debug("%s enter\n", __func__); 172 pr_debug("%s enter\n", __func__);
216 173
217 peripheral_free(per); 174 peripheral_free_list(sport_handle->pin_req);
218 gpio_request(gpio, "bf5xx-ac97"); 175 gpio_request(gpio, "bf5xx-ac97");
219 gpio_direction_output(gpio, 1); 176 gpio_direction_output(gpio, 1);
220 udelay(2); 177 udelay(2);
221 gpio_set_value(gpio, 0); 178 gpio_set_value(gpio, 0);
222 udelay(1); 179 udelay(1);
223 gpio_free(gpio); 180 gpio_free(gpio);
224 peripheral_request(per, "soc-audio"); 181 peripheral_request_list(sport_handle->pin_req, "soc-audio");
225#else
226 pr_info("%s: Not implemented\n", __func__);
227#endif
228} 182}
229 183
230static void bf5xx_ac97_cold_reset(struct snd_ac97 *ac97) 184static void bf5xx_ac97_cold_reset(struct snd_ac97 *ac97)
@@ -255,14 +209,14 @@ EXPORT_SYMBOL_GPL(soc_ac97_ops);
255#ifdef CONFIG_PM 209#ifdef CONFIG_PM
256static int bf5xx_ac97_suspend(struct snd_soc_dai *dai) 210static int bf5xx_ac97_suspend(struct snd_soc_dai *dai)
257{ 211{
258 struct sport_device *sport = dai->private_data; 212 struct sport_device *sport = snd_soc_dai_get_drvdata(dai);
259 213
260 pr_debug("%s : sport %d\n", __func__, dai->id); 214 pr_debug("%s : sport %d\n", __func__, dai->id);
261 if (!dai->active) 215 if (!dai->active)
262 return 0; 216 return 0;
263 if (dai->capture.active) 217 if (dai->capture_active)
264 sport_rx_stop(sport); 218 sport_rx_stop(sport);
265 if (dai->playback.active) 219 if (dai->playback_active)
266 sport_tx_stop(sport); 220 sport_tx_stop(sport);
267 return 0; 221 return 0;
268} 222}
@@ -270,7 +224,7 @@ static int bf5xx_ac97_suspend(struct snd_soc_dai *dai)
270static int bf5xx_ac97_resume(struct snd_soc_dai *dai) 224static int bf5xx_ac97_resume(struct snd_soc_dai *dai)
271{ 225{
272 int ret; 226 int ret;
273 struct sport_device *sport = dai->private_data; 227 struct sport_device *sport = snd_soc_dai_get_drvdata(dai);
274 228
275 pr_debug("%s : sport %d\n", __func__, dai->id); 229 pr_debug("%s : sport %d\n", __func__, dai->id);
276 if (!dai->active) 230 if (!dai->active)
@@ -306,19 +260,32 @@ static int bf5xx_ac97_resume(struct snd_soc_dai *dai)
306#define bf5xx_ac97_resume NULL 260#define bf5xx_ac97_resume NULL
307#endif 261#endif
308 262
309static int bf5xx_ac97_probe(struct platform_device *pdev, 263static struct snd_soc_dai_driver bfin_ac97_dai = {
310 struct snd_soc_dai *dai) 264 .ac97_control = 1,
265 .suspend = bf5xx_ac97_suspend,
266 .resume = bf5xx_ac97_resume,
267 .playback = {
268 .stream_name = "AC97 Playback",
269 .channels_min = 2,
270#if defined(CONFIG_SND_BF5XX_MULTICHAN_SUPPORT)
271 .channels_max = 6,
272#else
273 .channels_max = 2,
274#endif
275 .rates = SNDRV_PCM_RATE_48000,
276 .formats = SNDRV_PCM_FMTBIT_S16_LE, },
277 .capture = {
278 .stream_name = "AC97 Capture",
279 .channels_min = 2,
280 .channels_max = 2,
281 .rates = SNDRV_PCM_RATE_48000,
282 .formats = SNDRV_PCM_FMTBIT_S16_LE, },
283};
284
285static int __devinit asoc_bfin_ac97_probe(struct platform_device *pdev)
311{ 286{
312 int ret = 0; 287 struct sport_device *sport_handle;
313 cmd_count = (int *)get_zeroed_page(GFP_KERNEL); 288 int ret;
314 if (cmd_count == NULL)
315 return -ENOMEM;
316
317 if (peripheral_request_list(sport_req[sport_num], "soc-audio")) {
318 pr_err("Requesting Peripherals failed\n");
319 ret = -EFAULT;
320 goto peripheral_err;
321 }
322 289
323#ifdef CONFIG_SND_BF5XX_HAVE_COLD_RESET 290#ifdef CONFIG_SND_BF5XX_HAVE_COLD_RESET
324 /* Request PB3 as reset pin */ 291 /* Request PB3 as reset pin */
@@ -330,12 +297,14 @@ static int bf5xx_ac97_probe(struct platform_device *pdev,
330 } 297 }
331 gpio_direction_output(CONFIG_SND_BF5XX_RESET_GPIO_NUM, 1); 298 gpio_direction_output(CONFIG_SND_BF5XX_RESET_GPIO_NUM, 1);
332#endif 299#endif
333 sport_handle = sport_init(&sport_params[sport_num], 2, \ 300
334 sizeof(struct ac97_frame), NULL); 301 sport_handle = sport_init(pdev, 2, sizeof(struct ac97_frame),
302 PAGE_SIZE);
335 if (!sport_handle) { 303 if (!sport_handle) {
336 ret = -ENODEV; 304 ret = -ENODEV;
337 goto sport_err; 305 goto sport_err;
338 } 306 }
307
339 /*SPORT works in TDM mode to simulate AC97 transfers*/ 308 /*SPORT works in TDM mode to simulate AC97 transfers*/
340#if defined(CONFIG_SND_BF5XX_MULTICHAN_SUPPORT) 309#if defined(CONFIG_SND_BF5XX_MULTICHAN_SUPPORT)
341 ret = sport_set_multichannel(sport_handle, 16, 0x3FF, 1); 310 ret = sport_set_multichannel(sport_handle, 16, 0x3FF, 1);
@@ -362,73 +331,63 @@ static int bf5xx_ac97_probe(struct platform_device *pdev,
362 goto sport_config_err; 331 goto sport_config_err;
363 } 332 }
364 333
334 ret = snd_soc_register_dai(&pdev->dev, &bfin_ac97_dai);
335 if (ret) {
336 pr_err("Failed to register DAI: %d\n", ret);
337 goto sport_config_err;
338 }
339
340 ac97_sport_handle = sport_handle;
341
365 return 0; 342 return 0;
366 343
367sport_config_err: 344sport_config_err:
368 kfree(sport_handle); 345 sport_done(sport_handle);
369sport_err: 346sport_err:
370#ifdef CONFIG_SND_BF5XX_HAVE_COLD_RESET 347#ifdef CONFIG_SND_BF5XX_HAVE_COLD_RESET
371 gpio_free(CONFIG_SND_BF5XX_RESET_GPIO_NUM); 348 gpio_free(CONFIG_SND_BF5XX_RESET_GPIO_NUM);
372gpio_err: 349gpio_err:
373#endif 350#endif
374 peripheral_free_list(sport_req[sport_num]);
375peripheral_err:
376 free_page((unsigned long)cmd_count);
377 cmd_count = NULL;
378 351
379 return ret; 352 return ret;
380} 353}
381 354
382static void bf5xx_ac97_remove(struct platform_device *pdev, 355static int __devexit asoc_bfin_ac97_remove(struct platform_device *pdev)
383 struct snd_soc_dai *dai)
384{ 356{
385 free_page((unsigned long)cmd_count); 357 struct sport_device *sport_handle = platform_get_drvdata(pdev);
386 cmd_count = NULL; 358
387 peripheral_free_list(sport_req[sport_num]); 359 snd_soc_unregister_dai(&pdev->dev);
360 sport_done(sport_handle);
388#ifdef CONFIG_SND_BF5XX_HAVE_COLD_RESET 361#ifdef CONFIG_SND_BF5XX_HAVE_COLD_RESET
389 gpio_free(CONFIG_SND_BF5XX_RESET_GPIO_NUM); 362 gpio_free(CONFIG_SND_BF5XX_RESET_GPIO_NUM);
390#endif 363#endif
364
365 return 0;
391} 366}
392 367
393struct snd_soc_dai bfin_ac97_dai = { 368static struct platform_driver asoc_bfin_ac97_driver = {
394 .name = "bf5xx-ac97", 369 .driver = {
395 .id = 0, 370 .name = "bfin-ac97",
396 .ac97_control = 1, 371 .owner = THIS_MODULE,
397 .probe = bf5xx_ac97_probe, 372 },
398 .remove = bf5xx_ac97_remove, 373
399 .suspend = bf5xx_ac97_suspend, 374 .probe = asoc_bfin_ac97_probe,
400 .resume = bf5xx_ac97_resume, 375 .remove = __devexit_p(asoc_bfin_ac97_remove),
401 .playback = {
402 .stream_name = "AC97 Playback",
403 .channels_min = 2,
404#if defined(CONFIG_SND_BF5XX_MULTICHAN_SUPPORT)
405 .channels_max = 6,
406#else
407 .channels_max = 2,
408#endif
409 .rates = SNDRV_PCM_RATE_48000,
410 .formats = SNDRV_PCM_FMTBIT_S16_LE, },
411 .capture = {
412 .stream_name = "AC97 Capture",
413 .channels_min = 2,
414 .channels_max = 2,
415 .rates = SNDRV_PCM_RATE_48000,
416 .formats = SNDRV_PCM_FMTBIT_S16_LE, },
417}; 376};
418EXPORT_SYMBOL_GPL(bfin_ac97_dai);
419 377
420static int __init bfin_ac97_init(void) 378static int __init bfin_ac97_init(void)
421{ 379{
422 return snd_soc_register_dai(&bfin_ac97_dai); 380 return platform_driver_register(&asoc_bfin_ac97_driver);
423} 381}
424module_init(bfin_ac97_init); 382module_init(bfin_ac97_init);
425 383
426static void __exit bfin_ac97_exit(void) 384static void __exit bfin_ac97_exit(void)
427{ 385{
428 snd_soc_unregister_dai(&bfin_ac97_dai); 386 platform_driver_unregister(&asoc_bfin_ac97_driver);
429} 387}
430module_exit(bfin_ac97_exit); 388module_exit(bfin_ac97_exit);
431 389
390
432MODULE_AUTHOR("Roy Huang"); 391MODULE_AUTHOR("Roy Huang");
433MODULE_DESCRIPTION("AC97 driver for ADI Blackfin"); 392MODULE_DESCRIPTION("AC97 driver for ADI Blackfin");
434MODULE_LICENSE("GPL"); 393MODULE_LICENSE("GPL");
diff --git a/sound/soc/blackfin/bf5xx-ac97.h b/sound/soc/blackfin/bf5xx-ac97.h
index a1f97dd809d6..15c635e33f4d 100644
--- a/sound/soc/blackfin/bf5xx-ac97.h
+++ b/sound/soc/blackfin/bf5xx-ac97.h
@@ -50,8 +50,6 @@ struct ac97_frame {
50#define TAG_PCM_SR 0x0080 50#define TAG_PCM_SR 0x0080
51#define TAG_PCM_LFE 0x0040 51#define TAG_PCM_LFE 0x0040
52 52
53extern struct snd_soc_dai bfin_ac97_dai;
54
55void bf5xx_pcm_to_ac97(struct ac97_frame *dst, const __u16 *src, \ 53void bf5xx_pcm_to_ac97(struct ac97_frame *dst, const __u16 *src, \
56 size_t count, unsigned int chan_mask); 54 size_t count, unsigned int chan_mask);
57 55
diff --git a/sound/soc/blackfin/bf5xx-ad1836.c b/sound/soc/blackfin/bf5xx-ad1836.c
index 0f45a3f56be8..f79d1655e035 100644
--- a/sound/soc/blackfin/bf5xx-ad1836.c
+++ b/sound/soc/blackfin/bf5xx-ad1836.c
@@ -20,7 +20,6 @@
20#include <sound/core.h> 20#include <sound/core.h>
21#include <sound/pcm.h> 21#include <sound/pcm.h>
22#include <sound/soc.h> 22#include <sound/soc.h>
23#include <sound/soc-dapm.h>
24#include <sound/pcm_params.h> 23#include <sound/pcm_params.h>
25 24
26#include <asm/blackfin.h> 25#include <asm/blackfin.h>
@@ -30,28 +29,18 @@
30#include <asm/portmux.h> 29#include <asm/portmux.h>
31 30
32#include "../codecs/ad1836.h" 31#include "../codecs/ad1836.h"
33#include "bf5xx-sport.h"
34 32
35#include "bf5xx-tdm-pcm.h" 33#include "bf5xx-tdm-pcm.h"
36#include "bf5xx-tdm.h" 34#include "bf5xx-tdm.h"
37 35
38static struct snd_soc_card bf5xx_ad1836; 36static struct snd_soc_card bf5xx_ad1836;
39 37
40static int bf5xx_ad1836_startup(struct snd_pcm_substream *substream)
41{
42 struct snd_soc_pcm_runtime *rtd = substream->private_data;
43 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
44
45 cpu_dai->private_data = sport_handle;
46 return 0;
47}
48
49static int bf5xx_ad1836_hw_params(struct snd_pcm_substream *substream, 38static int bf5xx_ad1836_hw_params(struct snd_pcm_substream *substream,
50 struct snd_pcm_hw_params *params) 39 struct snd_pcm_hw_params *params)
51{ 40{
52 struct snd_soc_pcm_runtime *rtd = substream->private_data; 41 struct snd_soc_pcm_runtime *rtd = substream->private_data;
53 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; 42 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
54 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai; 43 struct snd_soc_dai *codec_dai = rtd->codec_dai;
55 unsigned int channel_map[] = {0, 4, 1, 5, 2, 6, 3, 7}; 44 unsigned int channel_map[] = {0, 4, 1, 5, 2, 6, 3, 7};
56 int ret = 0; 45 int ret = 0;
57 /* set cpu DAI configuration */ 46 /* set cpu DAI configuration */
@@ -76,30 +65,36 @@ static int bf5xx_ad1836_hw_params(struct snd_pcm_substream *substream,
76} 65}
77 66
78static struct snd_soc_ops bf5xx_ad1836_ops = { 67static struct snd_soc_ops bf5xx_ad1836_ops = {
79 .startup = bf5xx_ad1836_startup,
80 .hw_params = bf5xx_ad1836_hw_params, 68 .hw_params = bf5xx_ad1836_hw_params,
81}; 69};
82 70
83static struct snd_soc_dai_link bf5xx_ad1836_dai = { 71static struct snd_soc_dai_link bf5xx_ad1836_dai[] = {
84 .name = "ad1836", 72 {
85 .stream_name = "AD1836", 73 .name = "ad1836",
86 .cpu_dai = &bf5xx_tdm_dai, 74 .stream_name = "AD1836",
87 .codec_dai = &ad1836_dai, 75 .cpu_dai_name = "bfin-tdm.0",
88 .ops = &bf5xx_ad1836_ops, 76 .codec_dai_name = "ad1836-hifi",
77 .platform_name = "bfin-tdm-pcm-audio",
78 .codec_name = "spi0.4",
79 .ops = &bf5xx_ad1836_ops,
80 },
81 {
82 .name = "ad1836",
83 .stream_name = "AD1836",
84 .cpu_dai_name = "bfin-tdm.1",
85 .codec_dai_name = "ad1836-hifi",
86 .platform_name = "bfin-tdm-pcm-audio",
87 .codec_name = "spi0.4",
88 .ops = &bf5xx_ad1836_ops,
89 },
89}; 90};
90 91
91static struct snd_soc_card bf5xx_ad1836 = { 92static struct snd_soc_card bf5xx_ad1836 = {
92 .name = "bf5xx_ad1836", 93 .name = "bfin-ad1836",
93 .platform = &bf5xx_tdm_soc_platform, 94 .dai_link = &bf5xx_ad1836_dai[CONFIG_SND_BF5XX_SPORT_NUM],
94 .dai_link = &bf5xx_ad1836_dai,
95 .num_links = 1, 95 .num_links = 1,
96}; 96};
97 97
98static struct snd_soc_device bf5xx_ad1836_snd_devdata = {
99 .card = &bf5xx_ad1836,
100 .codec_dev = &soc_codec_dev_ad1836,
101};
102
103static struct platform_device *bfxx_ad1836_snd_device; 98static struct platform_device *bfxx_ad1836_snd_device;
104 99
105static int __init bf5xx_ad1836_init(void) 100static int __init bf5xx_ad1836_init(void)
@@ -110,8 +105,7 @@ static int __init bf5xx_ad1836_init(void)
110 if (!bfxx_ad1836_snd_device) 105 if (!bfxx_ad1836_snd_device)
111 return -ENOMEM; 106 return -ENOMEM;
112 107
113 platform_set_drvdata(bfxx_ad1836_snd_device, &bf5xx_ad1836_snd_devdata); 108 platform_set_drvdata(bfxx_ad1836_snd_device, &bf5xx_ad1836);
114 bf5xx_ad1836_snd_devdata.dev = &bfxx_ad1836_snd_device->dev;
115 ret = platform_device_add(bfxx_ad1836_snd_device); 109 ret = platform_device_add(bfxx_ad1836_snd_device);
116 110
117 if (ret) 111 if (ret)
diff --git a/sound/soc/blackfin/bf5xx-ad193x.c b/sound/soc/blackfin/bf5xx-ad193x.c
index b8c9060cfd8e..d6651c033cb7 100644
--- a/sound/soc/blackfin/bf5xx-ad193x.c
+++ b/sound/soc/blackfin/bf5xx-ad193x.c
@@ -29,7 +29,6 @@
29#include <sound/core.h> 29#include <sound/core.h>
30#include <sound/pcm.h> 30#include <sound/pcm.h>
31#include <sound/soc.h> 31#include <sound/soc.h>
32#include <sound/soc-dapm.h>
33#include <sound/pcm_params.h> 32#include <sound/pcm_params.h>
34 33
35#include <asm/blackfin.h> 34#include <asm/blackfin.h>
@@ -39,30 +38,28 @@
39#include <asm/portmux.h> 38#include <asm/portmux.h>
40 39
41#include "../codecs/ad193x.h" 40#include "../codecs/ad193x.h"
42#include "bf5xx-sport.h"
43 41
44#include "bf5xx-tdm-pcm.h" 42#include "bf5xx-tdm-pcm.h"
45#include "bf5xx-tdm.h" 43#include "bf5xx-tdm.h"
46 44
47static struct snd_soc_card bf5xx_ad193x; 45static struct snd_soc_card bf5xx_ad193x;
48 46
49static int bf5xx_ad193x_startup(struct snd_pcm_substream *substream)
50{
51 struct snd_soc_pcm_runtime *rtd = substream->private_data;
52 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
53
54 cpu_dai->private_data = sport_handle;
55 return 0;
56}
57
58static int bf5xx_ad193x_hw_params(struct snd_pcm_substream *substream, 47static int bf5xx_ad193x_hw_params(struct snd_pcm_substream *substream,
59 struct snd_pcm_hw_params *params) 48 struct snd_pcm_hw_params *params)
60{ 49{
61 struct snd_soc_pcm_runtime *rtd = substream->private_data; 50 struct snd_soc_pcm_runtime *rtd = substream->private_data;
62 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; 51 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
63 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai; 52 struct snd_soc_dai *codec_dai = rtd->codec_dai;
53 unsigned int clk = 0;
64 unsigned int channel_map[] = {0, 1, 2, 3, 4, 5, 6, 7}; 54 unsigned int channel_map[] = {0, 1, 2, 3, 4, 5, 6, 7};
65 int ret = 0; 55 int ret = 0;
56
57 switch (params_rate(params)) {
58 case 48000:
59 clk = 12288000;
60 break;
61 }
62
66 /* set cpu DAI configuration */ 63 /* set cpu DAI configuration */
67 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_DSP_A | 64 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_DSP_A |
68 SND_SOC_DAIFMT_IB_IF | SND_SOC_DAIFMT_CBM_CFM); 65 SND_SOC_DAIFMT_IB_IF | SND_SOC_DAIFMT_CBM_CFM);
@@ -75,6 +72,12 @@ static int bf5xx_ad193x_hw_params(struct snd_pcm_substream *substream,
75 if (ret < 0) 72 if (ret < 0)
76 return ret; 73 return ret;
77 74
75 /* set the codec system clock for DAC and ADC */
76 ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk,
77 SND_SOC_CLOCK_IN);
78 if (ret < 0)
79 return ret;
80
78 /* set codec DAI slots, 8 channels, all channels are enabled */ 81 /* set codec DAI slots, 8 channels, all channels are enabled */
79 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xFF, 0xFF, 8, 32); 82 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xFF, 0xFF, 8, 32);
80 if (ret < 0) 83 if (ret < 0)
@@ -90,30 +93,36 @@ static int bf5xx_ad193x_hw_params(struct snd_pcm_substream *substream,
90} 93}
91 94
92static struct snd_soc_ops bf5xx_ad193x_ops = { 95static struct snd_soc_ops bf5xx_ad193x_ops = {
93 .startup = bf5xx_ad193x_startup,
94 .hw_params = bf5xx_ad193x_hw_params, 96 .hw_params = bf5xx_ad193x_hw_params,
95}; 97};
96 98
97static struct snd_soc_dai_link bf5xx_ad193x_dai = { 99static struct snd_soc_dai_link bf5xx_ad193x_dai[] = {
98 .name = "ad193x", 100 {
99 .stream_name = "AD193X", 101 .name = "ad193x",
100 .cpu_dai = &bf5xx_tdm_dai, 102 .stream_name = "AD193X",
101 .codec_dai = &ad193x_dai, 103 .cpu_dai_name = "bfin-tdm.0",
102 .ops = &bf5xx_ad193x_ops, 104 .codec_dai_name ="ad193x-hifi",
105 .platform_name = "bfin-tdm-pcm-audio",
106 .codec_name = "ad193x.5",
107 .ops = &bf5xx_ad193x_ops,
108 },
109 {
110 .name = "ad193x",
111 .stream_name = "AD193X",
112 .cpu_dai_name = "bfin-tdm.1",
113 .codec_dai_name ="ad193x-hifi",
114 .platform_name = "bfin-tdm-pcm-audio",
115 .codec_name = "ad193x.5",
116 .ops = &bf5xx_ad193x_ops,
117 },
103}; 118};
104 119
105static struct snd_soc_card bf5xx_ad193x = { 120static struct snd_soc_card bf5xx_ad193x = {
106 .name = "bf5xx_ad193x", 121 .name = "bfin-ad193x",
107 .platform = &bf5xx_tdm_soc_platform, 122 .dai_link = &bf5xx_ad193x_dai[CONFIG_SND_BF5XX_SPORT_NUM],
108 .dai_link = &bf5xx_ad193x_dai,
109 .num_links = 1, 123 .num_links = 1,
110}; 124};
111 125
112static struct snd_soc_device bf5xx_ad193x_snd_devdata = {
113 .card = &bf5xx_ad193x,
114 .codec_dev = &soc_codec_dev_ad193x,
115};
116
117static struct platform_device *bfxx_ad193x_snd_device; 126static struct platform_device *bfxx_ad193x_snd_device;
118 127
119static int __init bf5xx_ad193x_init(void) 128static int __init bf5xx_ad193x_init(void)
@@ -124,8 +133,7 @@ static int __init bf5xx_ad193x_init(void)
124 if (!bfxx_ad193x_snd_device) 133 if (!bfxx_ad193x_snd_device)
125 return -ENOMEM; 134 return -ENOMEM;
126 135
127 platform_set_drvdata(bfxx_ad193x_snd_device, &bf5xx_ad193x_snd_devdata); 136 platform_set_drvdata(bfxx_ad193x_snd_device, &bf5xx_ad193x);
128 bf5xx_ad193x_snd_devdata.dev = &bfxx_ad193x_snd_device->dev;
129 ret = platform_device_add(bfxx_ad193x_snd_device); 137 ret = platform_device_add(bfxx_ad193x_snd_device);
130 138
131 if (ret) 139 if (ret)
diff --git a/sound/soc/blackfin/bf5xx-ad1980.c b/sound/soc/blackfin/bf5xx-ad1980.c
index 92f7c327bb7a..06a84b211b52 100644
--- a/sound/soc/blackfin/bf5xx-ad1980.c
+++ b/sound/soc/blackfin/bf5xx-ad1980.c
@@ -47,46 +47,37 @@
47#include <asm/portmux.h> 47#include <asm/portmux.h>
48 48
49#include "../codecs/ad1980.h" 49#include "../codecs/ad1980.h"
50#include "bf5xx-sport.h" 50
51#include "bf5xx-ac97-pcm.h" 51#include "bf5xx-ac97-pcm.h"
52#include "bf5xx-ac97.h" 52#include "bf5xx-ac97.h"
53 53
54static struct snd_soc_card bf5xx_board; 54static struct snd_soc_card bf5xx_board;
55 55
56static int bf5xx_board_startup(struct snd_pcm_substream *substream) 56static struct snd_soc_dai_link bf5xx_board_dai[] = {
57{ 57 {
58 struct snd_soc_pcm_runtime *rtd = substream->private_data; 58 .name = "AC97",
59 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; 59 .stream_name = "AC97 HiFi",
60 60 .cpu_dai_name = "bfin-ac97.0",
61 pr_debug("%s enter\n", __func__); 61 .codec_dai_name = "ad1980-hifi",
62 cpu_dai->private_data = sport_handle; 62 .platform_name = "bfin-ac97-pcm-audio",
63 return 0; 63 .codec_name = "ad1980",
64} 64 },
65 65 {
66static struct snd_soc_ops bf5xx_board_ops = { 66 .name = "AC97",
67 .startup = bf5xx_board_startup, 67 .stream_name = "AC97 HiFi",
68}; 68 .cpu_dai_name = "bfin-ac97.1",
69 69 .codec_dai_name = "ad1980-hifi",
70static struct snd_soc_dai_link bf5xx_board_dai = { 70 .platform_name = "bfin-ac97-pcm-audio",
71 .name = "AC97", 71 .codec_name = "ad1980",
72 .stream_name = "AC97 HiFi", 72 },
73 .cpu_dai = &bfin_ac97_dai,
74 .codec_dai = &ad1980_dai,
75 .ops = &bf5xx_board_ops,
76}; 73};
77 74
78static struct snd_soc_card bf5xx_board = { 75static struct snd_soc_card bf5xx_board = {
79 .name = "bf5xx-board", 76 .name = "bfin-ad1980",
80 .platform = &bf5xx_ac97_soc_platform, 77 .dai_link = &bf5xx_board_dai[CONFIG_SND_BF5XX_SPORT_NUM],
81 .dai_link = &bf5xx_board_dai,
82 .num_links = 1, 78 .num_links = 1,
83}; 79};
84 80
85static struct snd_soc_device bf5xx_board_snd_devdata = {
86 .card = &bf5xx_board,
87 .codec_dev = &soc_codec_dev_ad1980,
88};
89
90static struct platform_device *bf5xx_board_snd_device; 81static struct platform_device *bf5xx_board_snd_device;
91 82
92static int __init bf5xx_board_init(void) 83static int __init bf5xx_board_init(void)
@@ -97,8 +88,7 @@ static int __init bf5xx_board_init(void)
97 if (!bf5xx_board_snd_device) 88 if (!bf5xx_board_snd_device)
98 return -ENOMEM; 89 return -ENOMEM;
99 90
100 platform_set_drvdata(bf5xx_board_snd_device, &bf5xx_board_snd_devdata); 91 platform_set_drvdata(bf5xx_board_snd_device, &bf5xx_board);
101 bf5xx_board_snd_devdata.dev = &bf5xx_board_snd_device->dev;
102 ret = platform_device_add(bf5xx_board_snd_device); 92 ret = platform_device_add(bf5xx_board_snd_device);
103 93
104 if (ret) 94 if (ret)
diff --git a/sound/soc/blackfin/bf5xx-ad73311.c b/sound/soc/blackfin/bf5xx-ad73311.c
index 9825b71d0e28..732a247f2527 100644
--- a/sound/soc/blackfin/bf5xx-ad73311.c
+++ b/sound/soc/blackfin/bf5xx-ad73311.c
@@ -35,7 +35,6 @@
35#include <sound/core.h> 35#include <sound/core.h>
36#include <sound/pcm.h> 36#include <sound/pcm.h>
37#include <sound/soc.h> 37#include <sound/soc.h>
38#include <sound/soc-dapm.h>
39#include <sound/pcm_params.h> 38#include <sound/pcm_params.h>
40 39
41#include <asm/blackfin.h> 40#include <asm/blackfin.h>
@@ -47,7 +46,6 @@
47#include "../codecs/ad73311.h" 46#include "../codecs/ad73311.h"
48#include "bf5xx-sport.h" 47#include "bf5xx-sport.h"
49#include "bf5xx-i2s-pcm.h" 48#include "bf5xx-i2s-pcm.h"
50#include "bf5xx-i2s.h"
51 49
52#if CONFIG_SND_BF5XX_SPORT_NUM == 0 50#if CONFIG_SND_BF5XX_SPORT_NUM == 0
53#define bfin_write_SPORT_TCR1 bfin_write_SPORT0_TCR1 51#define bfin_write_SPORT_TCR1 bfin_write_SPORT0_TCR1
@@ -147,21 +145,11 @@ static int bf5xx_probe(struct platform_device *pdev)
147 return 0; 145 return 0;
148} 146}
149 147
150static int bf5xx_ad73311_startup(struct snd_pcm_substream *substream)
151{
152 struct snd_soc_pcm_runtime *rtd = substream->private_data;
153 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
154
155 pr_debug("%s enter\n", __func__);
156 cpu_dai->private_data = sport_handle;
157 return 0;
158}
159
160static int bf5xx_ad73311_hw_params(struct snd_pcm_substream *substream, 148static int bf5xx_ad73311_hw_params(struct snd_pcm_substream *substream,
161 struct snd_pcm_hw_params *params) 149 struct snd_pcm_hw_params *params)
162{ 150{
163 struct snd_soc_pcm_runtime *rtd = substream->private_data; 151 struct snd_soc_pcm_runtime *rtd = substream->private_data;
164 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; 152 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
165 int ret = 0; 153 int ret = 0;
166 154
167 pr_debug("%s rate %d format %x\n", __func__, params_rate(params), 155 pr_debug("%s rate %d format %x\n", __func__, params_rate(params),
@@ -178,31 +166,37 @@ static int bf5xx_ad73311_hw_params(struct snd_pcm_substream *substream,
178 166
179 167
180static struct snd_soc_ops bf5xx_ad73311_ops = { 168static struct snd_soc_ops bf5xx_ad73311_ops = {
181 .startup = bf5xx_ad73311_startup,
182 .hw_params = bf5xx_ad73311_hw_params, 169 .hw_params = bf5xx_ad73311_hw_params,
183}; 170};
184 171
185static struct snd_soc_dai_link bf5xx_ad73311_dai = { 172static struct snd_soc_dai_link bf5xx_ad73311_dai[] = {
186 .name = "ad73311", 173 {
187 .stream_name = "AD73311", 174 .name = "ad73311",
188 .cpu_dai = &bf5xx_i2s_dai, 175 .stream_name = "AD73311",
189 .codec_dai = &ad73311_dai, 176 .cpu_dai_name = "bfin-i2s.0",
190 .ops = &bf5xx_ad73311_ops, 177 .codec_dai_name = "ad73311-hifi",
178 .platform_name = "bfin-i2s-pcm-audio",
179 .codec_name = "ad73311",
180 .ops = &bf5xx_ad73311_ops,
181 },
182 {
183 .name = "ad73311",
184 .stream_name = "AD73311",
185 .cpu_dai_name = "bfin-i2s.1",
186 .codec_dai_name = "ad73311-hifi",
187 .platform_name = "bfin-i2s-pcm-audio",
188 .codec_name = "ad73311",
189 .ops = &bf5xx_ad73311_ops,
190 },
191}; 191};
192 192
193static struct snd_soc_card bf5xx_ad73311 = { 193static struct snd_soc_card bf5xx_ad73311 = {
194 .name = "bf5xx_ad73311", 194 .name = "bfin-ad73311",
195 .platform = &bf5xx_i2s_soc_platform,
196 .probe = bf5xx_probe, 195 .probe = bf5xx_probe,
197 .dai_link = &bf5xx_ad73311_dai, 196 .dai_link = &bf5xx_ad73311_dai[CONFIG_SND_BF5XX_SPORT_NUM],
198 .num_links = 1, 197 .num_links = 1,
199}; 198};
200 199
201static struct snd_soc_device bf5xx_ad73311_snd_devdata = {
202 .card = &bf5xx_ad73311,
203 .codec_dev = &soc_codec_dev_ad73311,
204};
205
206static struct platform_device *bf5xx_ad73311_snd_device; 200static struct platform_device *bf5xx_ad73311_snd_device;
207 201
208static int __init bf5xx_ad73311_init(void) 202static int __init bf5xx_ad73311_init(void)
@@ -214,8 +208,7 @@ static int __init bf5xx_ad73311_init(void)
214 if (!bf5xx_ad73311_snd_device) 208 if (!bf5xx_ad73311_snd_device)
215 return -ENOMEM; 209 return -ENOMEM;
216 210
217 platform_set_drvdata(bf5xx_ad73311_snd_device, &bf5xx_ad73311_snd_devdata); 211 platform_set_drvdata(bf5xx_ad73311_snd_device, &bf5xx_ad73311);
218 bf5xx_ad73311_snd_devdata.dev = &bf5xx_ad73311_snd_device->dev;
219 ret = platform_device_add(bf5xx_ad73311_snd_device); 212 ret = platform_device_add(bf5xx_ad73311_snd_device);
220 213
221 if (ret) 214 if (ret)
diff --git a/sound/soc/blackfin/bf5xx-i2s-pcm.c b/sound/soc/blackfin/bf5xx-i2s-pcm.c
index 1d2a1adf2575..f1fd95bb6416 100644
--- a/sound/soc/blackfin/bf5xx-i2s-pcm.c
+++ b/sound/soc/blackfin/bf5xx-i2s-pcm.c
@@ -40,7 +40,6 @@
40#include <asm/dma.h> 40#include <asm/dma.h>
41 41
42#include "bf5xx-i2s-pcm.h" 42#include "bf5xx-i2s-pcm.h"
43#include "bf5xx-i2s.h"
44#include "bf5xx-sport.h" 43#include "bf5xx-sport.h"
45 44
46static void bf5xx_dma_irq(void *data) 45static void bf5xx_dma_irq(void *data)
@@ -139,20 +138,34 @@ static snd_pcm_uframes_t bf5xx_pcm_pointer(struct snd_pcm_substream *substream)
139 pr_debug("%s enter\n", __func__); 138 pr_debug("%s enter\n", __func__);
140 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 139 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
141 diff = sport_curr_offset_tx(sport); 140 diff = sport_curr_offset_tx(sport);
142 frames = bytes_to_frames(substream->runtime, diff);
143 } else { 141 } else {
144 diff = sport_curr_offset_rx(sport); 142 diff = sport_curr_offset_rx(sport);
145 frames = bytes_to_frames(substream->runtime, diff);
146 } 143 }
144
145 /*
146 * TX at least can report one frame beyond the end of the
147 * buffer if we hit the wraparound case - clamp to within the
148 * buffer as the ALSA APIs require.
149 */
150 if (diff == snd_pcm_lib_buffer_bytes(substream))
151 diff = 0;
152
153 frames = bytes_to_frames(substream->runtime, diff);
154
147 return frames; 155 return frames;
148} 156}
149 157
150static int bf5xx_pcm_open(struct snd_pcm_substream *substream) 158static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
151{ 159{
160 struct snd_soc_pcm_runtime *rtd = substream->private_data;
161 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
162 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
152 struct snd_pcm_runtime *runtime = substream->runtime; 163 struct snd_pcm_runtime *runtime = substream->runtime;
164 struct snd_dma_buffer *buf = &substream->dma_buffer;
153 int ret; 165 int ret;
154 166
155 pr_debug("%s enter\n", __func__); 167 pr_debug("%s enter\n", __func__);
168
156 snd_soc_set_runtime_hwparams(substream, &bf5xx_pcm_hardware); 169 snd_soc_set_runtime_hwparams(substream, &bf5xx_pcm_hardware);
157 170
158 ret = snd_pcm_hw_constraint_integer(runtime, \ 171 ret = snd_pcm_hw_constraint_integer(runtime, \
@@ -160,9 +173,14 @@ static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
160 if (ret < 0) 173 if (ret < 0)
161 goto out; 174 goto out;
162 175
163 if (sport_handle != NULL) 176 if (sport_handle != NULL) {
177 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
178 sport_handle->tx_buf = buf->area;
179 else
180 sport_handle->rx_buf = buf->area;
181
164 runtime->private_data = sport_handle; 182 runtime->private_data = sport_handle;
165 else { 183 } else {
166 pr_err("sport_handle is NULL\n"); 184 pr_err("sport_handle is NULL\n");
167 return -1; 185 return -1;
168 } 186 }
@@ -215,11 +233,6 @@ static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
215 pr_debug("%s, area:%p, size:0x%08lx\n", __func__, 233 pr_debug("%s, area:%p, size:0x%08lx\n", __func__,
216 buf->area, buf->bytes); 234 buf->area, buf->bytes);
217 235
218 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
219 sport_handle->tx_buf = buf->area;
220 else
221 sport_handle->rx_buf = buf->area;
222
223 return 0; 236 return 0;
224} 237}
225 238
@@ -240,8 +253,6 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
240 dma_free_coherent(NULL, buf->bytes, buf->area, 0); 253 dma_free_coherent(NULL, buf->bytes, buf->area, 0);
241 buf->area = NULL; 254 buf->area = NULL;
242 } 255 }
243 if (sport_handle)
244 sport_done(sport_handle);
245} 256}
246 257
247static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32); 258static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
@@ -257,14 +268,14 @@ int bf5xx_pcm_i2s_new(struct snd_card *card, struct snd_soc_dai *dai,
257 if (!card->dev->coherent_dma_mask) 268 if (!card->dev->coherent_dma_mask)
258 card->dev->coherent_dma_mask = DMA_BIT_MASK(32); 269 card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
259 270
260 if (dai->playback.channels_min) { 271 if (dai->driver->playback.channels_min) {
261 ret = bf5xx_pcm_preallocate_dma_buffer(pcm, 272 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
262 SNDRV_PCM_STREAM_PLAYBACK); 273 SNDRV_PCM_STREAM_PLAYBACK);
263 if (ret) 274 if (ret)
264 goto out; 275 goto out;
265 } 276 }
266 277
267 if (dai->capture.channels_min) { 278 if (dai->driver->capture.channels_min) {
268 ret = bf5xx_pcm_preallocate_dma_buffer(pcm, 279 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
269 SNDRV_PCM_STREAM_CAPTURE); 280 SNDRV_PCM_STREAM_CAPTURE);
270 if (ret) 281 if (ret)
@@ -274,25 +285,44 @@ int bf5xx_pcm_i2s_new(struct snd_card *card, struct snd_soc_dai *dai,
274 return ret; 285 return ret;
275} 286}
276 287
277struct snd_soc_platform bf5xx_i2s_soc_platform = { 288static struct snd_soc_platform_driver bf5xx_i2s_soc_platform = {
278 .name = "bf5xx-audio", 289 .ops = &bf5xx_pcm_i2s_ops,
279 .pcm_ops = &bf5xx_pcm_i2s_ops,
280 .pcm_new = bf5xx_pcm_i2s_new, 290 .pcm_new = bf5xx_pcm_i2s_new,
281 .pcm_free = bf5xx_pcm_free_dma_buffers, 291 .pcm_free = bf5xx_pcm_free_dma_buffers,
282}; 292};
283EXPORT_SYMBOL_GPL(bf5xx_i2s_soc_platform);
284 293
285static int __init bfin_i2s_init(void) 294static int __devinit bfin_i2s_soc_platform_probe(struct platform_device *pdev)
295{
296 return snd_soc_register_platform(&pdev->dev, &bf5xx_i2s_soc_platform);
297}
298
299static int __devexit bfin_i2s_soc_platform_remove(struct platform_device *pdev)
300{
301 snd_soc_unregister_platform(&pdev->dev);
302 return 0;
303}
304
305static struct platform_driver bfin_i2s_pcm_driver = {
306 .driver = {
307 .name = "bfin-i2s-pcm-audio",
308 .owner = THIS_MODULE,
309 },
310
311 .probe = bfin_i2s_soc_platform_probe,
312 .remove = __devexit_p(bfin_i2s_soc_platform_remove),
313};
314
315static int __init snd_bfin_i2s_pcm_init(void)
286{ 316{
287 return snd_soc_register_platform(&bf5xx_i2s_soc_platform); 317 return platform_driver_register(&bfin_i2s_pcm_driver);
288} 318}
289module_init(bfin_i2s_init); 319module_init(snd_bfin_i2s_pcm_init);
290 320
291static void __exit bfin_i2s_exit(void) 321static void __exit snd_bfin_i2s_pcm_exit(void)
292{ 322{
293 snd_soc_unregister_platform(&bf5xx_i2s_soc_platform); 323 platform_driver_unregister(&bfin_i2s_pcm_driver);
294} 324}
295module_exit(bfin_i2s_exit); 325module_exit(snd_bfin_i2s_pcm_exit);
296 326
297MODULE_AUTHOR("Cliff Cai"); 327MODULE_AUTHOR("Cliff Cai");
298MODULE_DESCRIPTION("ADI Blackfin I2S PCM DMA module"); 328MODULE_DESCRIPTION("ADI Blackfin I2S PCM DMA module");
diff --git a/sound/soc/blackfin/bf5xx-i2s-pcm.h b/sound/soc/blackfin/bf5xx-i2s-pcm.h
index 4d4609a97c59..0c2c5a68d4ff 100644
--- a/sound/soc/blackfin/bf5xx-i2s-pcm.h
+++ b/sound/soc/blackfin/bf5xx-i2s-pcm.h
@@ -23,7 +23,4 @@ struct bf5xx_gpio {
23 u32 frm; 23 u32 frm;
24}; 24};
25 25
26/* platform data */
27extern struct snd_soc_platform bf5xx_i2s_soc_platform;
28
29#endif 26#endif
diff --git a/sound/soc/blackfin/bf5xx-i2s.c b/sound/soc/blackfin/bf5xx-i2s.c
index 3e6ada0dd1c4..00cc3e00b2fe 100644
--- a/sound/soc/blackfin/bf5xx-i2s.c
+++ b/sound/soc/blackfin/bf5xx-i2s.c
@@ -42,7 +42,6 @@
42#include <linux/gpio.h> 42#include <linux/gpio.h>
43 43
44#include "bf5xx-sport.h" 44#include "bf5xx-sport.h"
45#include "bf5xx-i2s.h"
46 45
47struct bf5xx_i2s_port { 46struct bf5xx_i2s_port {
48 u16 tcr1; 47 u16 tcr1;
@@ -52,59 +51,24 @@ struct bf5xx_i2s_port {
52 int configured; 51 int configured;
53}; 52};
54 53
55static struct bf5xx_i2s_port bf5xx_i2s;
56static int sport_num = CONFIG_SND_BF5XX_SPORT_NUM;
57
58static struct sport_param sport_params[2] = {
59 {
60 .dma_rx_chan = CH_SPORT0_RX,
61 .dma_tx_chan = CH_SPORT0_TX,
62 .err_irq = IRQ_SPORT0_ERROR,
63 .regs = (struct sport_register *)SPORT0_TCR1,
64 },
65 {
66 .dma_rx_chan = CH_SPORT1_RX,
67 .dma_tx_chan = CH_SPORT1_TX,
68 .err_irq = IRQ_SPORT1_ERROR,
69 .regs = (struct sport_register *)SPORT1_TCR1,
70 }
71};
72
73/*
74 * Setting the TFS pin selector for SPORT 0 based on whether the selected
75 * port id F or G. If the port is F then no conflict should exist for the
76 * TFS. When Port G is selected and EMAC then there is a conflict between
77 * the PHY interrupt line and TFS. Current settings prevent the conflict
78 * by ignoring the TFS pin when Port G is selected. This allows both
79 * codecs and EMAC using Port G concurrently.
80 */
81#ifdef CONFIG_BF527_SPORT0_PORTG
82#define LOCAL_SPORT0_TFS (0)
83#else
84#define LOCAL_SPORT0_TFS (P_SPORT0_TFS)
85#endif
86
87static u16 sport_req[][7] = { {P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS,
88 P_SPORT0_DRPRI, P_SPORT0_RSCLK, LOCAL_SPORT0_TFS, 0},
89 {P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, P_SPORT1_DRPRI,
90 P_SPORT1_RSCLK, P_SPORT1_TFS, 0} };
91
92static int bf5xx_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai, 54static int bf5xx_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
93 unsigned int fmt) 55 unsigned int fmt)
94{ 56{
57 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
58 struct bf5xx_i2s_port *bf5xx_i2s = sport_handle->private_data;
95 int ret = 0; 59 int ret = 0;
96 60
97 /* interface format:support I2S,slave mode */ 61 /* interface format:support I2S,slave mode */
98 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 62 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
99 case SND_SOC_DAIFMT_I2S: 63 case SND_SOC_DAIFMT_I2S:
100 bf5xx_i2s.tcr1 |= TFSR | TCKFE; 64 bf5xx_i2s->tcr1 |= TFSR | TCKFE;
101 bf5xx_i2s.rcr1 |= RFSR | RCKFE; 65 bf5xx_i2s->rcr1 |= RFSR | RCKFE;
102 bf5xx_i2s.tcr2 |= TSFSE; 66 bf5xx_i2s->tcr2 |= TSFSE;
103 bf5xx_i2s.rcr2 |= RSFSE; 67 bf5xx_i2s->rcr2 |= RSFSE;
104 break; 68 break;
105 case SND_SOC_DAIFMT_DSP_A: 69 case SND_SOC_DAIFMT_DSP_A:
106 bf5xx_i2s.tcr1 |= TFSR; 70 bf5xx_i2s->tcr1 |= TFSR;
107 bf5xx_i2s.rcr1 |= RFSR; 71 bf5xx_i2s->rcr1 |= RFSR;
108 break; 72 break;
109 case SND_SOC_DAIFMT_LEFT_J: 73 case SND_SOC_DAIFMT_LEFT_J:
110 ret = -EINVAL; 74 ret = -EINVAL;
@@ -136,29 +100,35 @@ static int bf5xx_i2s_hw_params(struct snd_pcm_substream *substream,
136 struct snd_pcm_hw_params *params, 100 struct snd_pcm_hw_params *params,
137 struct snd_soc_dai *dai) 101 struct snd_soc_dai *dai)
138{ 102{
103 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
104 struct bf5xx_i2s_port *bf5xx_i2s = sport_handle->private_data;
139 int ret = 0; 105 int ret = 0;
140 106
141 bf5xx_i2s.tcr2 &= ~0x1f; 107 bf5xx_i2s->tcr2 &= ~0x1f;
142 bf5xx_i2s.rcr2 &= ~0x1f; 108 bf5xx_i2s->rcr2 &= ~0x1f;
143 switch (params_format(params)) { 109 switch (params_format(params)) {
110 case SNDRV_PCM_FORMAT_S8:
111 bf5xx_i2s->tcr2 |= 7;
112 bf5xx_i2s->rcr2 |= 7;
113 sport_handle->wdsize = 1;
144 case SNDRV_PCM_FORMAT_S16_LE: 114 case SNDRV_PCM_FORMAT_S16_LE:
145 bf5xx_i2s.tcr2 |= 15; 115 bf5xx_i2s->tcr2 |= 15;
146 bf5xx_i2s.rcr2 |= 15; 116 bf5xx_i2s->rcr2 |= 15;
147 sport_handle->wdsize = 2; 117 sport_handle->wdsize = 2;
148 break; 118 break;
149 case SNDRV_PCM_FORMAT_S24_LE: 119 case SNDRV_PCM_FORMAT_S24_LE:
150 bf5xx_i2s.tcr2 |= 23; 120 bf5xx_i2s->tcr2 |= 23;
151 bf5xx_i2s.rcr2 |= 23; 121 bf5xx_i2s->rcr2 |= 23;
152 sport_handle->wdsize = 3; 122 sport_handle->wdsize = 3;
153 break; 123 break;
154 case SNDRV_PCM_FORMAT_S32_LE: 124 case SNDRV_PCM_FORMAT_S32_LE:
155 bf5xx_i2s.tcr2 |= 31; 125 bf5xx_i2s->tcr2 |= 31;
156 bf5xx_i2s.rcr2 |= 31; 126 bf5xx_i2s->rcr2 |= 31;
157 sport_handle->wdsize = 4; 127 sport_handle->wdsize = 4;
158 break; 128 break;
159 } 129 }
160 130
161 if (!bf5xx_i2s.configured) { 131 if (!bf5xx_i2s->configured) {
162 /* 132 /*
163 * TX and RX are not independent,they are enabled at the 133 * TX and RX are not independent,they are enabled at the
164 * same time, even if only one side is running. So, we 134 * same time, even if only one side is running. So, we
@@ -167,16 +137,16 @@ static int bf5xx_i2s_hw_params(struct snd_pcm_substream *substream,
167 * 137 *
168 * CPU DAI:slave mode. 138 * CPU DAI:slave mode.
169 */ 139 */
170 bf5xx_i2s.configured = 1; 140 bf5xx_i2s->configured = 1;
171 ret = sport_config_rx(sport_handle, bf5xx_i2s.rcr1, 141 ret = sport_config_rx(sport_handle, bf5xx_i2s->rcr1,
172 bf5xx_i2s.rcr2, 0, 0); 142 bf5xx_i2s->rcr2, 0, 0);
173 if (ret) { 143 if (ret) {
174 pr_err("SPORT is busy!\n"); 144 pr_err("SPORT is busy!\n");
175 return -EBUSY; 145 return -EBUSY;
176 } 146 }
177 147
178 ret = sport_config_tx(sport_handle, bf5xx_i2s.tcr1, 148 ret = sport_config_tx(sport_handle, bf5xx_i2s->tcr1,
179 bf5xx_i2s.tcr2, 0, 0); 149 bf5xx_i2s->tcr2, 0, 0);
180 if (ret) { 150 if (ret) {
181 pr_err("SPORT is busy!\n"); 151 pr_err("SPORT is busy!\n");
182 return -EBUSY; 152 return -EBUSY;
@@ -189,67 +159,46 @@ static int bf5xx_i2s_hw_params(struct snd_pcm_substream *substream,
189static void bf5xx_i2s_shutdown(struct snd_pcm_substream *substream, 159static void bf5xx_i2s_shutdown(struct snd_pcm_substream *substream,
190 struct snd_soc_dai *dai) 160 struct snd_soc_dai *dai)
191{ 161{
162 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
163 struct bf5xx_i2s_port *bf5xx_i2s = sport_handle->private_data;
164
192 pr_debug("%s enter\n", __func__); 165 pr_debug("%s enter\n", __func__);
193 /* No active stream, SPORT is allowed to be configured again. */ 166 /* No active stream, SPORT is allowed to be configured again. */
194 if (!dai->active) 167 if (!dai->active)
195 bf5xx_i2s.configured = 0; 168 bf5xx_i2s->configured = 0;
196}
197
198static int bf5xx_i2s_probe(struct platform_device *pdev,
199 struct snd_soc_dai *dai)
200{
201 pr_debug("%s enter\n", __func__);
202 if (peripheral_request_list(&sport_req[sport_num][0], "soc-audio")) {
203 pr_err("Requesting Peripherals failed\n");
204 return -EFAULT;
205 }
206
207 /* request DMA for SPORT */
208 sport_handle = sport_init(&sport_params[sport_num], 4, \
209 2 * sizeof(u32), NULL);
210 if (!sport_handle) {
211 peripheral_free_list(&sport_req[sport_num][0]);
212 return -ENODEV;
213 }
214
215 return 0;
216}
217
218static void bf5xx_i2s_remove(struct platform_device *pdev,
219 struct snd_soc_dai *dai)
220{
221 pr_debug("%s enter\n", __func__);
222 peripheral_free_list(&sport_req[sport_num][0]);
223} 169}
224 170
225#ifdef CONFIG_PM 171#ifdef CONFIG_PM
226static int bf5xx_i2s_suspend(struct snd_soc_dai *dai) 172static int bf5xx_i2s_suspend(struct snd_soc_dai *dai)
227{ 173{
174 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
228 175
229 pr_debug("%s : sport %d\n", __func__, dai->id); 176 pr_debug("%s : sport %d\n", __func__, dai->id);
230 177
231 if (dai->capture.active) 178 if (dai->capture_active)
232 sport_rx_stop(sport_handle); 179 sport_rx_stop(sport_handle);
233 if (dai->playback.active) 180 if (dai->playback_active)
234 sport_tx_stop(sport_handle); 181 sport_tx_stop(sport_handle);
235 return 0; 182 return 0;
236} 183}
237 184
238static int bf5xx_i2s_resume(struct snd_soc_dai *dai) 185static int bf5xx_i2s_resume(struct snd_soc_dai *dai)
239{ 186{
187 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
188 struct bf5xx_i2s_port *bf5xx_i2s = sport_handle->private_data;
240 int ret; 189 int ret;
241 190
242 pr_debug("%s : sport %d\n", __func__, dai->id); 191 pr_debug("%s : sport %d\n", __func__, dai->id);
243 192
244 ret = sport_config_rx(sport_handle, bf5xx_i2s.rcr1, 193 ret = sport_config_rx(sport_handle, bf5xx_i2s->rcr1,
245 bf5xx_i2s.rcr2, 0, 0); 194 bf5xx_i2s->rcr2, 0, 0);
246 if (ret) { 195 if (ret) {
247 pr_err("SPORT is busy!\n"); 196 pr_err("SPORT is busy!\n");
248 return -EBUSY; 197 return -EBUSY;
249 } 198 }
250 199
251 ret = sport_config_tx(sport_handle, bf5xx_i2s.tcr1, 200 ret = sport_config_tx(sport_handle, bf5xx_i2s->tcr1,
252 bf5xx_i2s.tcr2, 0, 0); 201 bf5xx_i2s->tcr2, 0, 0);
253 if (ret) { 202 if (ret) {
254 pr_err("SPORT is busy!\n"); 203 pr_err("SPORT is busy!\n");
255 return -EBUSY; 204 return -EBUSY;
@@ -268,8 +217,11 @@ static int bf5xx_i2s_resume(struct snd_soc_dai *dai)
268 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | \ 217 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | \
269 SNDRV_PCM_RATE_96000) 218 SNDRV_PCM_RATE_96000)
270 219
271#define BF5XX_I2S_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE |\ 220#define BF5XX_I2S_FORMATS \
272 SNDRV_PCM_FMTBIT_S32_LE) 221 (SNDRV_PCM_FMTBIT_S8 | \
222 SNDRV_PCM_FMTBIT_S16_LE | \
223 SNDRV_PCM_FMTBIT_S24_LE | \
224 SNDRV_PCM_FMTBIT_S32_LE)
273 225
274static struct snd_soc_dai_ops bf5xx_i2s_dai_ops = { 226static struct snd_soc_dai_ops bf5xx_i2s_dai_ops = {
275 .shutdown = bf5xx_i2s_shutdown, 227 .shutdown = bf5xx_i2s_shutdown,
@@ -277,11 +229,7 @@ static struct snd_soc_dai_ops bf5xx_i2s_dai_ops = {
277 .set_fmt = bf5xx_i2s_set_dai_fmt, 229 .set_fmt = bf5xx_i2s_set_dai_fmt,
278}; 230};
279 231
280struct snd_soc_dai bf5xx_i2s_dai = { 232static struct snd_soc_dai_driver bf5xx_i2s_dai = {
281 .name = "bf5xx-i2s",
282 .id = 0,
283 .probe = bf5xx_i2s_probe,
284 .remove = bf5xx_i2s_remove,
285 .suspend = bf5xx_i2s_suspend, 233 .suspend = bf5xx_i2s_suspend,
286 .resume = bf5xx_i2s_resume, 234 .resume = bf5xx_i2s_resume,
287 .playback = { 235 .playback = {
@@ -296,18 +244,61 @@ struct snd_soc_dai bf5xx_i2s_dai = {
296 .formats = BF5XX_I2S_FORMATS,}, 244 .formats = BF5XX_I2S_FORMATS,},
297 .ops = &bf5xx_i2s_dai_ops, 245 .ops = &bf5xx_i2s_dai_ops,
298}; 246};
299EXPORT_SYMBOL_GPL(bf5xx_i2s_dai); 247
248static int __devinit bf5xx_i2s_probe(struct platform_device *pdev)
249{
250 struct sport_device *sport_handle;
251 int ret;
252
253 /* configure SPORT for I2S */
254 sport_handle = sport_init(pdev, 4, 2 * sizeof(u32),
255 sizeof(struct bf5xx_i2s_port));
256 if (!sport_handle)
257 return -ENODEV;
258
259 /* register with the ASoC layers */
260 ret = snd_soc_register_dai(&pdev->dev, &bf5xx_i2s_dai);
261 if (ret) {
262 pr_err("Failed to register DAI: %d\n", ret);
263 sport_done(sport_handle);
264 return ret;
265 }
266
267 return 0;
268}
269
270static int __devexit bf5xx_i2s_remove(struct platform_device *pdev)
271{
272 struct sport_device *sport_handle = platform_get_drvdata(pdev);
273
274 pr_debug("%s enter\n", __func__);
275
276 snd_soc_unregister_dai(&pdev->dev);
277 sport_done(sport_handle);
278
279 return 0;
280}
281
282static struct platform_driver bfin_i2s_driver = {
283 .probe = bf5xx_i2s_probe,
284 .remove = __devexit_p(bf5xx_i2s_remove),
285 .driver = {
286 .name = "bfin-i2s",
287 .owner = THIS_MODULE,
288 },
289};
300 290
301static int __init bfin_i2s_init(void) 291static int __init bfin_i2s_init(void)
302{ 292{
303 return snd_soc_register_dai(&bf5xx_i2s_dai); 293 return platform_driver_register(&bfin_i2s_driver);
304} 294}
305module_init(bfin_i2s_init);
306 295
307static void __exit bfin_i2s_exit(void) 296static void __exit bfin_i2s_exit(void)
308{ 297{
309 snd_soc_unregister_dai(&bf5xx_i2s_dai); 298 platform_driver_unregister(&bfin_i2s_driver);
310} 299}
300
301module_init(bfin_i2s_init);
311module_exit(bfin_i2s_exit); 302module_exit(bfin_i2s_exit);
312 303
313/* Module information */ 304/* Module information */
diff --git a/sound/soc/blackfin/bf5xx-i2s.h b/sound/soc/blackfin/bf5xx-i2s.h
deleted file mode 100644
index 264ecdcba35a..000000000000
--- a/sound/soc/blackfin/bf5xx-i2s.h
+++ /dev/null
@@ -1,14 +0,0 @@
1/*
2 * sound/soc/blackfin/bf5xx-i2s.h
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 */
8
9#ifndef _BF5XX_I2S_H
10#define _BF5XX_I2S_H
11
12extern struct snd_soc_dai bf5xx_i2s_dai;
13
14#endif
diff --git a/sound/soc/blackfin/bf5xx-sport.c b/sound/soc/blackfin/bf5xx-sport.c
index 99051ff0954e..a2d40349fcc4 100644
--- a/sound/soc/blackfin/bf5xx-sport.c
+++ b/sound/soc/blackfin/bf5xx-sport.c
@@ -42,8 +42,6 @@
42/* delay between frame sync pulse and first data bit in multichannel mode */ 42/* delay between frame sync pulse and first data bit in multichannel mode */
43#define FRAME_DELAY (1<<12) 43#define FRAME_DELAY (1<<12)
44 44
45struct sport_device *sport_handle;
46EXPORT_SYMBOL(sport_handle);
47/* note: multichannel is in units of 8 channels, 45/* note: multichannel is in units of 8 channels,
48 * tdm_count is # channels NOT / 8 ! */ 46 * tdm_count is # channels NOT / 8 ! */
49int sport_set_multichannel(struct sport_device *sport, 47int sport_set_multichannel(struct sport_device *sport,
@@ -798,86 +796,164 @@ int sport_set_err_callback(struct sport_device *sport,
798} 796}
799EXPORT_SYMBOL(sport_set_err_callback); 797EXPORT_SYMBOL(sport_set_err_callback);
800 798
801struct sport_device *sport_init(struct sport_param *param, unsigned wdsize, 799static int sport_config_pdev(struct platform_device *pdev, struct sport_param *param)
802 unsigned dummy_count, void *private_data)
803{ 800{
804 int ret; 801 /* Extract settings from platform data */
802 struct device *dev = &pdev->dev;
803 struct bfin_snd_platform_data *pdata = dev->platform_data;
804 struct resource *res;
805
806 param->num = pdev->id;
807
808 if (!pdata) {
809 dev_err(dev, "no platform_data\n");
810 return -ENODEV;
811 }
812 param->pin_req = pdata->pin_req;
813
814 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
815 if (!res) {
816 dev_err(dev, "no MEM resource\n");
817 return -ENODEV;
818 }
819 param->regs = (struct sport_register *)res->start;
820
821 /* first RX, then TX */
822 res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
823 if (!res) {
824 dev_err(dev, "no rx DMA resource\n");
825 return -ENODEV;
826 }
827 param->dma_rx_chan = res->start;
828
829 res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
830 if (!res) {
831 dev_err(dev, "no tx DMA resource\n");
832 return -ENODEV;
833 }
834 param->dma_tx_chan = res->start;
835
836 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
837 if (!res) {
838 dev_err(dev, "no irq resource\n");
839 return -ENODEV;
840 }
841 param->err_irq = res->start;
842
843 return 0;
844}
845
846struct sport_device *sport_init(struct platform_device *pdev,
847 unsigned int wdsize, unsigned int dummy_count, size_t priv_size)
848{
849 struct device *dev = &pdev->dev;
850 struct sport_param param;
805 struct sport_device *sport; 851 struct sport_device *sport;
806 pr_debug("%s enter\n", __func__); 852 int ret;
807 BUG_ON(param == NULL); 853
808 BUG_ON(wdsize == 0 || dummy_count == 0); 854 dev_dbg(dev, "%s enter\n", __func__);
809 sport = kmalloc(sizeof(struct sport_device), GFP_KERNEL); 855
810 if (!sport) { 856 param.wdsize = wdsize;
811 pr_err("Failed to allocate for sport device\n"); 857 param.dummy_count = dummy_count;
858 BUG_ON(param.wdsize == 0 || param.dummy_count == 0);
859
860 ret = sport_config_pdev(pdev, &param);
861 if (ret)
862 return NULL;
863
864 if (peripheral_request_list(param.pin_req, "soc-audio")) {
865 dev_err(dev, "requesting Peripherals failed\n");
812 return NULL; 866 return NULL;
813 } 867 }
814 868
815 memset(sport, 0, sizeof(struct sport_device)); 869 sport = kzalloc(sizeof(*sport), GFP_KERNEL);
816 sport->dma_rx_chan = param->dma_rx_chan; 870 if (!sport) {
817 sport->dma_tx_chan = param->dma_tx_chan; 871 dev_err(dev, "failed to allocate for sport device\n");
818 sport->err_irq = param->err_irq; 872 goto __init_err0;
819 sport->regs = param->regs; 873 }
820 sport->private_data = private_data; 874
875 sport->num = param.num;
876 sport->dma_rx_chan = param.dma_rx_chan;
877 sport->dma_tx_chan = param.dma_tx_chan;
878 sport->err_irq = param.err_irq;
879 sport->regs = param.regs;
880 sport->pin_req = param.pin_req;
821 881
822 if (request_dma(sport->dma_rx_chan, "SPORT RX Data") == -EBUSY) { 882 if (request_dma(sport->dma_rx_chan, "SPORT RX Data") == -EBUSY) {
823 pr_err("Failed to request RX dma %d\n", \ 883 dev_err(dev, "failed to request RX dma %d\n", sport->dma_rx_chan);
824 sport->dma_rx_chan);
825 goto __init_err1; 884 goto __init_err1;
826 } 885 }
827 if (set_dma_callback(sport->dma_rx_chan, rx_handler, sport) != 0) { 886 if (set_dma_callback(sport->dma_rx_chan, rx_handler, sport) != 0) {
828 pr_err("Failed to request RX irq %d\n", \ 887 dev_err(dev, "failed to request RX irq %d\n", sport->dma_rx_chan);
829 sport->dma_rx_chan);
830 goto __init_err2; 888 goto __init_err2;
831 } 889 }
832 890
833 if (request_dma(sport->dma_tx_chan, "SPORT TX Data") == -EBUSY) { 891 if (request_dma(sport->dma_tx_chan, "SPORT TX Data") == -EBUSY) {
834 pr_err("Failed to request TX dma %d\n", \ 892 dev_err(dev, "failed to request TX dma %d\n", sport->dma_tx_chan);
835 sport->dma_tx_chan);
836 goto __init_err2; 893 goto __init_err2;
837 } 894 }
838 895
839 if (set_dma_callback(sport->dma_tx_chan, tx_handler, sport) != 0) { 896 if (set_dma_callback(sport->dma_tx_chan, tx_handler, sport) != 0) {
840 pr_err("Failed to request TX irq %d\n", \ 897 dev_err(dev, "failed to request TX irq %d\n", sport->dma_tx_chan);
841 sport->dma_tx_chan);
842 goto __init_err3; 898 goto __init_err3;
843 } 899 }
844 900
845 if (request_irq(sport->err_irq, err_handler, IRQF_SHARED, "SPORT err", 901 if (request_irq(sport->err_irq, err_handler, IRQF_SHARED, "SPORT err",
846 sport) < 0) { 902 sport) < 0) {
847 pr_err("Failed to request err irq:%d\n", \ 903 dev_err(dev, "failed to request err irq %d\n", sport->err_irq);
848 sport->err_irq);
849 goto __init_err3; 904 goto __init_err3;
850 } 905 }
851 906
852 pr_err("dma rx:%d tx:%d, err irq:%d, regs:%p\n", 907 dev_info(dev, "dma rx:%d tx:%d, err irq:%d, regs:%p\n",
853 sport->dma_rx_chan, sport->dma_tx_chan, 908 sport->dma_rx_chan, sport->dma_tx_chan,
854 sport->err_irq, sport->regs); 909 sport->err_irq, sport->regs);
855 910
856 sport->wdsize = wdsize; 911 sport->wdsize = param.wdsize;
857 sport->dummy_count = dummy_count; 912 sport->dummy_count = param.dummy_count;
913
914 sport->private_data = kzalloc(priv_size, GFP_KERNEL);
915 if (!sport->private_data) {
916 dev_err(dev, "could not alloc priv data %zu bytes\n", priv_size);
917 goto __init_err4;
918 }
858 919
859 if (L1_DATA_A_LENGTH) 920 if (L1_DATA_A_LENGTH)
860 sport->dummy_buf = l1_data_sram_zalloc(dummy_count * 2); 921 sport->dummy_buf = l1_data_sram_zalloc(param.dummy_count * 2);
861 else 922 else
862 sport->dummy_buf = kzalloc(dummy_count * 2, GFP_KERNEL); 923 sport->dummy_buf = kzalloc(param.dummy_count * 2, GFP_KERNEL);
863 if (sport->dummy_buf == NULL) { 924 if (sport->dummy_buf == NULL) {
864 pr_err("Failed to allocate dummy buffer\n"); 925 dev_err(dev, "failed to allocate dummy buffer\n");
865 goto __error; 926 goto __error1;
866 } 927 }
867 928
868 ret = sport_config_rx_dummy(sport); 929 ret = sport_config_rx_dummy(sport);
869 if (ret) { 930 if (ret) {
870 pr_err("Failed to config rx dummy ring\n"); 931 dev_err(dev, "failed to config rx dummy ring\n");
871 goto __error; 932 goto __error2;
872 } 933 }
873 ret = sport_config_tx_dummy(sport); 934 ret = sport_config_tx_dummy(sport);
874 if (ret) { 935 if (ret) {
875 pr_err("Failed to config tx dummy ring\n"); 936 dev_err(dev, "failed to config tx dummy ring\n");
876 goto __error; 937 goto __error3;
877 } 938 }
878 939
940 platform_set_drvdata(pdev, sport);
941
879 return sport; 942 return sport;
880__error: 943__error3:
944 if (L1_DATA_A_LENGTH)
945 l1_data_sram_free(sport->dummy_rx_desc);
946 else
947 dma_free_coherent(NULL, 2*sizeof(struct dmasg),
948 sport->dummy_rx_desc, 0);
949__error2:
950 if (L1_DATA_A_LENGTH)
951 l1_data_sram_free(sport->dummy_buf);
952 else
953 kfree(sport->dummy_buf);
954__error1:
955 kfree(sport->private_data);
956__init_err4:
881 free_irq(sport->err_irq, sport); 957 free_irq(sport->err_irq, sport);
882__init_err3: 958__init_err3:
883 free_dma(sport->dma_tx_chan); 959 free_dma(sport->dma_tx_chan);
@@ -885,6 +961,8 @@ __init_err2:
885 free_dma(sport->dma_rx_chan); 961 free_dma(sport->dma_rx_chan);
886__init_err1: 962__init_err1:
887 kfree(sport); 963 kfree(sport);
964__init_err0:
965 peripheral_free_list(param.pin_req);
888 return NULL; 966 return NULL;
889} 967}
890EXPORT_SYMBOL(sport_init); 968EXPORT_SYMBOL(sport_init);
@@ -917,8 +995,9 @@ void sport_done(struct sport_device *sport)
917 free_dma(sport->dma_tx_chan); 995 free_dma(sport->dma_tx_chan);
918 free_irq(sport->err_irq, sport); 996 free_irq(sport->err_irq, sport);
919 997
998 kfree(sport->private_data);
999 peripheral_free_list(sport->pin_req);
920 kfree(sport); 1000 kfree(sport);
921 sport = NULL;
922} 1001}
923EXPORT_SYMBOL(sport_done); 1002EXPORT_SYMBOL(sport_done);
924 1003
diff --git a/sound/soc/blackfin/bf5xx-sport.h b/sound/soc/blackfin/bf5xx-sport.h
index a86e8cc0b2d3..5ab60bd613ea 100644
--- a/sound/soc/blackfin/bf5xx-sport.h
+++ b/sound/soc/blackfin/bf5xx-sport.h
@@ -1,5 +1,5 @@
1/* 1/*
2 * File: bf5xx_ac97_sport.h 2 * File: bf5xx_sport.h
3 * Based on: 3 * Based on:
4 * Author: Roy Huang <roy.huang@analog.com> 4 * Author: Roy Huang <roy.huang@analog.com>
5 * 5 *
@@ -33,15 +33,18 @@
33#include <linux/types.h> 33#include <linux/types.h>
34#include <linux/wait.h> 34#include <linux/wait.h>
35#include <linux/workqueue.h> 35#include <linux/workqueue.h>
36#include <linux/platform_device.h>
36#include <asm/dma.h> 37#include <asm/dma.h>
37#include <asm/bfin_sport.h> 38#include <asm/bfin_sport.h>
38 39
39#define DESC_ELEMENT_COUNT 9 40#define DESC_ELEMENT_COUNT 9
40 41
41struct sport_device { 42struct sport_device {
43 int num;
42 int dma_rx_chan; 44 int dma_rx_chan;
43 int dma_tx_chan; 45 int dma_tx_chan;
44 int err_irq; 46 int err_irq;
47 const unsigned short *pin_req;
45 struct sport_register *regs; 48 struct sport_register *regs;
46 49
47 unsigned char *rx_buf; 50 unsigned char *rx_buf;
@@ -103,17 +106,20 @@ struct sport_device {
103 void *private_data; 106 void *private_data;
104}; 107};
105 108
106extern struct sport_device *sport_handle;
107
108struct sport_param { 109struct sport_param {
110 int num;
109 int dma_rx_chan; 111 int dma_rx_chan;
110 int dma_tx_chan; 112 int dma_tx_chan;
111 int err_irq; 113 int err_irq;
114 const unsigned short *pin_req;
112 struct sport_register *regs; 115 struct sport_register *regs;
116 unsigned int wdsize;
117 unsigned int dummy_count;
118 void *private_data;
113}; 119};
114 120
115struct sport_device *sport_init(struct sport_param *param, unsigned wdsize, 121struct sport_device *sport_init(struct platform_device *pdev,
116 unsigned dummy_count, void *private_data); 122 unsigned int wdsize, unsigned int dummy_count, size_t priv_size);
117 123
118void sport_done(struct sport_device *sport); 124void sport_done(struct sport_device *sport);
119 125
diff --git a/sound/soc/blackfin/bf5xx-ssm2602.c b/sound/soc/blackfin/bf5xx-ssm2602.c
index 3a00fa4dbe6d..767e772a815d 100644
--- a/sound/soc/blackfin/bf5xx-ssm2602.c
+++ b/sound/soc/blackfin/bf5xx-ssm2602.c
@@ -33,7 +33,6 @@
33#include <sound/core.h> 33#include <sound/core.h>
34#include <sound/pcm.h> 34#include <sound/pcm.h>
35#include <sound/soc.h> 35#include <sound/soc.h>
36#include <sound/soc-dapm.h>
37#include <sound/pcm_params.h> 36#include <sound/pcm_params.h>
38 37
39#include <asm/dma.h> 38#include <asm/dma.h>
@@ -42,26 +41,15 @@
42#include "../codecs/ssm2602.h" 41#include "../codecs/ssm2602.h"
43#include "bf5xx-sport.h" 42#include "bf5xx-sport.h"
44#include "bf5xx-i2s-pcm.h" 43#include "bf5xx-i2s-pcm.h"
45#include "bf5xx-i2s.h"
46 44
47static struct snd_soc_card bf5xx_ssm2602; 45static struct snd_soc_card bf5xx_ssm2602;
48 46
49static int bf5xx_ssm2602_startup(struct snd_pcm_substream *substream)
50{
51 struct snd_soc_pcm_runtime *rtd = substream->private_data;
52 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
53
54 pr_debug("%s enter\n", __func__);
55 cpu_dai->private_data = sport_handle;
56 return 0;
57}
58
59static int bf5xx_ssm2602_hw_params(struct snd_pcm_substream *substream, 47static int bf5xx_ssm2602_hw_params(struct snd_pcm_substream *substream,
60 struct snd_pcm_hw_params *params) 48 struct snd_pcm_hw_params *params)
61{ 49{
62 struct snd_soc_pcm_runtime *rtd = substream->private_data; 50 struct snd_soc_pcm_runtime *rtd = substream->private_data;
63 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai; 51 struct snd_soc_dai *codec_dai = rtd->codec_dai;
64 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; 52 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
65 unsigned int clk = 0; 53 unsigned int clk = 0;
66 int ret = 0; 54 int ret = 0;
67 55
@@ -111,43 +99,36 @@ static int bf5xx_ssm2602_hw_params(struct snd_pcm_substream *substream,
111} 99}
112 100
113static struct snd_soc_ops bf5xx_ssm2602_ops = { 101static struct snd_soc_ops bf5xx_ssm2602_ops = {
114 .startup = bf5xx_ssm2602_startup,
115 .hw_params = bf5xx_ssm2602_hw_params, 102 .hw_params = bf5xx_ssm2602_hw_params,
116}; 103};
117 104
118static struct snd_soc_dai_link bf5xx_ssm2602_dai = { 105static struct snd_soc_dai_link bf5xx_ssm2602_dai[] = {
119 .name = "ssm2602", 106 {
120 .stream_name = "SSM2602", 107 .name = "ssm2602",
121 .cpu_dai = &bf5xx_i2s_dai, 108 .stream_name = "SSM2602",
122 .codec_dai = &ssm2602_dai, 109 .cpu_dai_name = "bfin-i2s.0",
123 .ops = &bf5xx_ssm2602_ops, 110 .codec_dai_name = "ssm2602-hifi",
124}; 111 .platform_name = "bfin-i2s-pcm-audio",
125 112 .codec_name = "ssm2602.0-001b",
126/* 113 .ops = &bf5xx_ssm2602_ops,
127 * SSM2602 2 wire address is determined by CSB 114 },
128 * state during powerup. 115 {
129 * low = 0x1a 116 .name = "ssm2602",
130 * high = 0x1b 117 .stream_name = "SSM2602",
131 */ 118 .cpu_dai_name = "bfin-i2s.1",
132 119 .codec_dai_name = "ssm2602-hifi",
133static struct ssm2602_setup_data bf5xx_ssm2602_setup = { 120 .platform_name = "bfin-i2s-pcm-audio",
134 .i2c_bus = 0, 121 .codec_name = "ssm2602.0-001b",
135 .i2c_address = 0x1b, 122 .ops = &bf5xx_ssm2602_ops,
123 },
136}; 124};
137 125
138static struct snd_soc_card bf5xx_ssm2602 = { 126static struct snd_soc_card bf5xx_ssm2602 = {
139 .name = "bf5xx_ssm2602", 127 .name = "bfin-ssm2602",
140 .platform = &bf5xx_i2s_soc_platform, 128 .dai_link = &bf5xx_ssm2602_dai[CONFIG_SND_BF5XX_SPORT_NUM],
141 .dai_link = &bf5xx_ssm2602_dai,
142 .num_links = 1, 129 .num_links = 1,
143}; 130};
144 131
145static struct snd_soc_device bf5xx_ssm2602_snd_devdata = {
146 .card = &bf5xx_ssm2602,
147 .codec_dev = &soc_codec_dev_ssm2602,
148 .codec_data = &bf5xx_ssm2602_setup,
149};
150
151static struct platform_device *bf5xx_ssm2602_snd_device; 132static struct platform_device *bf5xx_ssm2602_snd_device;
152 133
153static int __init bf5xx_ssm2602_init(void) 134static int __init bf5xx_ssm2602_init(void)
@@ -159,9 +140,7 @@ static int __init bf5xx_ssm2602_init(void)
159 if (!bf5xx_ssm2602_snd_device) 140 if (!bf5xx_ssm2602_snd_device)
160 return -ENOMEM; 141 return -ENOMEM;
161 142
162 platform_set_drvdata(bf5xx_ssm2602_snd_device, 143 platform_set_drvdata(bf5xx_ssm2602_snd_device, &bf5xx_ssm2602);
163 &bf5xx_ssm2602_snd_devdata);
164 bf5xx_ssm2602_snd_devdata.dev = &bf5xx_ssm2602_snd_device->dev;
165 ret = platform_device_add(bf5xx_ssm2602_snd_device); 144 ret = platform_device_add(bf5xx_ssm2602_snd_device);
166 145
167 if (ret) 146 if (ret)
diff --git a/sound/soc/blackfin/bf5xx-tdm-pcm.c b/sound/soc/blackfin/bf5xx-tdm-pcm.c
index 6bac1ac1a315..07cfc7a9e49a 100644
--- a/sound/soc/blackfin/bf5xx-tdm-pcm.c
+++ b/sound/soc/blackfin/bf5xx-tdm-pcm.c
@@ -154,7 +154,12 @@ static snd_pcm_uframes_t bf5xx_pcm_pointer(struct snd_pcm_substream *substream)
154 154
155static int bf5xx_pcm_open(struct snd_pcm_substream *substream) 155static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
156{ 156{
157 struct snd_soc_pcm_runtime *rtd = substream->private_data;
158 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
159 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
157 struct snd_pcm_runtime *runtime = substream->runtime; 160 struct snd_pcm_runtime *runtime = substream->runtime;
161 struct snd_dma_buffer *buf = &substream->dma_buffer;
162
158 int ret = 0; 163 int ret = 0;
159 164
160 snd_soc_set_runtime_hwparams(substream, &bf5xx_pcm_hardware); 165 snd_soc_set_runtime_hwparams(substream, &bf5xx_pcm_hardware);
@@ -164,9 +169,14 @@ static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
164 if (ret < 0) 169 if (ret < 0)
165 goto out; 170 goto out;
166 171
167 if (sport_handle != NULL) 172 if (sport_handle != NULL) {
173 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
174 sport_handle->tx_buf = buf->area;
175 else
176 sport_handle->rx_buf = buf->area;
177
168 runtime->private_data = sport_handle; 178 runtime->private_data = sport_handle;
169 else { 179 } else {
170 pr_err("sport_handle is NULL\n"); 180 pr_err("sport_handle is NULL\n");
171 ret = -ENODEV; 181 ret = -ENODEV;
172 } 182 }
@@ -249,11 +259,6 @@ static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
249 } 259 }
250 buf->bytes = size; 260 buf->bytes = size;
251 261
252 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
253 sport_handle->tx_buf = buf->area;
254 else
255 sport_handle->rx_buf = buf->area;
256
257 return 0; 262 return 0;
258} 263}
259 264
@@ -274,8 +279,6 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
274 dma_free_coherent(NULL, buf->bytes, buf->area, 0); 279 dma_free_coherent(NULL, buf->bytes, buf->area, 0);
275 buf->area = NULL; 280 buf->area = NULL;
276 } 281 }
277 if (sport_handle)
278 sport_done(sport_handle);
279} 282}
280 283
281static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32); 284static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
@@ -290,14 +293,14 @@ static int bf5xx_pcm_tdm_new(struct snd_card *card, struct snd_soc_dai *dai,
290 if (!card->dev->coherent_dma_mask) 293 if (!card->dev->coherent_dma_mask)
291 card->dev->coherent_dma_mask = DMA_BIT_MASK(32); 294 card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
292 295
293 if (dai->playback.channels_min) { 296 if (dai->driver->playback.channels_min) {
294 ret = bf5xx_pcm_preallocate_dma_buffer(pcm, 297 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
295 SNDRV_PCM_STREAM_PLAYBACK); 298 SNDRV_PCM_STREAM_PLAYBACK);
296 if (ret) 299 if (ret)
297 goto out; 300 goto out;
298 } 301 }
299 302
300 if (dai->capture.channels_min) { 303 if (dai->driver->capture.channels_min) {
301 ret = bf5xx_pcm_preallocate_dma_buffer(pcm, 304 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
302 SNDRV_PCM_STREAM_CAPTURE); 305 SNDRV_PCM_STREAM_CAPTURE);
303 if (ret) 306 if (ret)
@@ -307,25 +310,44 @@ out:
307 return ret; 310 return ret;
308} 311}
309 312
310struct snd_soc_platform bf5xx_tdm_soc_platform = { 313static struct snd_soc_platform_driver bf5xx_tdm_soc_platform = {
311 .name = "bf5xx-audio", 314 .ops = &bf5xx_pcm_tdm_ops,
312 .pcm_ops = &bf5xx_pcm_tdm_ops,
313 .pcm_new = bf5xx_pcm_tdm_new, 315 .pcm_new = bf5xx_pcm_tdm_new,
314 .pcm_free = bf5xx_pcm_free_dma_buffers, 316 .pcm_free = bf5xx_pcm_free_dma_buffers,
315}; 317};
316EXPORT_SYMBOL_GPL(bf5xx_tdm_soc_platform);
317 318
318static int __init bfin_pcm_tdm_init(void) 319static int __devinit bf5xx_soc_platform_probe(struct platform_device *pdev)
320{
321 return snd_soc_register_platform(&pdev->dev, &bf5xx_tdm_soc_platform);
322}
323
324static int __devexit bf5xx_soc_platform_remove(struct platform_device *pdev)
325{
326 snd_soc_unregister_platform(&pdev->dev);
327 return 0;
328}
329
330static struct platform_driver bfin_tdm_driver = {
331 .driver = {
332 .name = "bfin-tdm-pcm-audio",
333 .owner = THIS_MODULE,
334 },
335
336 .probe = bf5xx_soc_platform_probe,
337 .remove = __devexit_p(bf5xx_soc_platform_remove),
338};
339
340static int __init snd_bfin_tdm_init(void)
319{ 341{
320 return snd_soc_register_platform(&bf5xx_tdm_soc_platform); 342 return platform_driver_register(&bfin_tdm_driver);
321} 343}
322module_init(bfin_pcm_tdm_init); 344module_init(snd_bfin_tdm_init);
323 345
324static void __exit bfin_pcm_tdm_exit(void) 346static void __exit snd_bfin_tdm_exit(void)
325{ 347{
326 snd_soc_unregister_platform(&bf5xx_tdm_soc_platform); 348 platform_driver_unregister(&bfin_tdm_driver);
327} 349}
328module_exit(bfin_pcm_tdm_exit); 350module_exit(snd_bfin_tdm_exit);
329 351
330MODULE_AUTHOR("Barry Song"); 352MODULE_AUTHOR("Barry Song");
331MODULE_DESCRIPTION("ADI Blackfin TDM PCM DMA module"); 353MODULE_DESCRIPTION("ADI Blackfin TDM PCM DMA module");
diff --git a/sound/soc/blackfin/bf5xx-tdm-pcm.h b/sound/soc/blackfin/bf5xx-tdm-pcm.h
index ddc5047df88c..7f8cc01c4477 100644
--- a/sound/soc/blackfin/bf5xx-tdm-pcm.h
+++ b/sound/soc/blackfin/bf5xx-tdm-pcm.h
@@ -15,7 +15,4 @@ struct bf5xx_pcm_dma_params {
15 char *name; /* stream identifier */ 15 char *name; /* stream identifier */
16}; 16};
17 17
18/* platform data */
19extern struct snd_soc_platform bf5xx_tdm_soc_platform;
20
21#endif 18#endif
diff --git a/sound/soc/blackfin/bf5xx-tdm.c b/sound/soc/blackfin/bf5xx-tdm.c
index 24c14269f4bc..a822d1ee1380 100644
--- a/sound/soc/blackfin/bf5xx-tdm.c
+++ b/sound/soc/blackfin/bf5xx-tdm.c
@@ -46,43 +46,6 @@
46#include "bf5xx-sport.h" 46#include "bf5xx-sport.h"
47#include "bf5xx-tdm.h" 47#include "bf5xx-tdm.h"
48 48
49static struct bf5xx_tdm_port bf5xx_tdm;
50static int sport_num = CONFIG_SND_BF5XX_SPORT_NUM;
51
52static struct sport_param sport_params[2] = {
53 {
54 .dma_rx_chan = CH_SPORT0_RX,
55 .dma_tx_chan = CH_SPORT0_TX,
56 .err_irq = IRQ_SPORT0_ERROR,
57 .regs = (struct sport_register *)SPORT0_TCR1,
58 },
59 {
60 .dma_rx_chan = CH_SPORT1_RX,
61 .dma_tx_chan = CH_SPORT1_TX,
62 .err_irq = IRQ_SPORT1_ERROR,
63 .regs = (struct sport_register *)SPORT1_TCR1,
64 }
65};
66
67/*
68 * Setting the TFS pin selector for SPORT 0 based on whether the selected
69 * port id F or G. If the port is F then no conflict should exist for the
70 * TFS. When Port G is selected and EMAC then there is a conflict between
71 * the PHY interrupt line and TFS. Current settings prevent the conflict
72 * by ignoring the TFS pin when Port G is selected. This allows both
73 * codecs and EMAC using Port G concurrently.
74 */
75#ifdef CONFIG_BF527_SPORT0_PORTG
76#define LOCAL_SPORT0_TFS (0)
77#else
78#define LOCAL_SPORT0_TFS (P_SPORT0_TFS)
79#endif
80
81static u16 sport_req[][7] = { {P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS,
82 P_SPORT0_DRPRI, P_SPORT0_RSCLK, LOCAL_SPORT0_TFS, 0},
83 {P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, P_SPORT1_DRPRI,
84 P_SPORT1_RSCLK, P_SPORT1_TFS, 0} };
85
86static int bf5xx_tdm_set_dai_fmt(struct snd_soc_dai *cpu_dai, 49static int bf5xx_tdm_set_dai_fmt(struct snd_soc_dai *cpu_dai,
87 unsigned int fmt) 50 unsigned int fmt)
88{ 51{
@@ -119,14 +82,16 @@ static int bf5xx_tdm_hw_params(struct snd_pcm_substream *substream,
119 struct snd_pcm_hw_params *params, 82 struct snd_pcm_hw_params *params,
120 struct snd_soc_dai *dai) 83 struct snd_soc_dai *dai)
121{ 84{
85 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
86 struct bf5xx_tdm_port *bf5xx_tdm = sport_handle->private_data;
122 int ret = 0; 87 int ret = 0;
123 88
124 bf5xx_tdm.tcr2 &= ~0x1f; 89 bf5xx_tdm->tcr2 &= ~0x1f;
125 bf5xx_tdm.rcr2 &= ~0x1f; 90 bf5xx_tdm->rcr2 &= ~0x1f;
126 switch (params_format(params)) { 91 switch (params_format(params)) {
127 case SNDRV_PCM_FORMAT_S32_LE: 92 case SNDRV_PCM_FORMAT_S32_LE:
128 bf5xx_tdm.tcr2 |= 31; 93 bf5xx_tdm->tcr2 |= 31;
129 bf5xx_tdm.rcr2 |= 31; 94 bf5xx_tdm->rcr2 |= 31;
130 sport_handle->wdsize = 4; 95 sport_handle->wdsize = 4;
131 break; 96 break;
132 /* at present, we only support 32bit transfer */ 97 /* at present, we only support 32bit transfer */
@@ -136,7 +101,7 @@ static int bf5xx_tdm_hw_params(struct snd_pcm_substream *substream,
136 break; 101 break;
137 } 102 }
138 103
139 if (!bf5xx_tdm.configured) { 104 if (!bf5xx_tdm->configured) {
140 /* 105 /*
141 * TX and RX are not independent,they are enabled at the 106 * TX and RX are not independent,they are enabled at the
142 * same time, even if only one side is running. So, we 107 * same time, even if only one side is running. So, we
@@ -145,21 +110,21 @@ static int bf5xx_tdm_hw_params(struct snd_pcm_substream *substream,
145 * 110 *
146 * CPU DAI:slave mode. 111 * CPU DAI:slave mode.
147 */ 112 */
148 ret = sport_config_rx(sport_handle, bf5xx_tdm.rcr1, 113 ret = sport_config_rx(sport_handle, bf5xx_tdm->rcr1,
149 bf5xx_tdm.rcr2, 0, 0); 114 bf5xx_tdm->rcr2, 0, 0);
150 if (ret) { 115 if (ret) {
151 pr_err("SPORT is busy!\n"); 116 pr_err("SPORT is busy!\n");
152 return -EBUSY; 117 return -EBUSY;
153 } 118 }
154 119
155 ret = sport_config_tx(sport_handle, bf5xx_tdm.tcr1, 120 ret = sport_config_tx(sport_handle, bf5xx_tdm->tcr1,
156 bf5xx_tdm.tcr2, 0, 0); 121 bf5xx_tdm->tcr2, 0, 0);
157 if (ret) { 122 if (ret) {
158 pr_err("SPORT is busy!\n"); 123 pr_err("SPORT is busy!\n");
159 return -EBUSY; 124 return -EBUSY;
160 } 125 }
161 126
162 bf5xx_tdm.configured = 1; 127 bf5xx_tdm->configured = 1;
163 } 128 }
164 129
165 return 0; 130 return 0;
@@ -168,15 +133,20 @@ static int bf5xx_tdm_hw_params(struct snd_pcm_substream *substream,
168static void bf5xx_tdm_shutdown(struct snd_pcm_substream *substream, 133static void bf5xx_tdm_shutdown(struct snd_pcm_substream *substream,
169 struct snd_soc_dai *dai) 134 struct snd_soc_dai *dai)
170{ 135{
136 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
137 struct bf5xx_tdm_port *bf5xx_tdm = sport_handle->private_data;
138
171 /* No active stream, SPORT is allowed to be configured again. */ 139 /* No active stream, SPORT is allowed to be configured again. */
172 if (!dai->active) 140 if (!dai->active)
173 bf5xx_tdm.configured = 0; 141 bf5xx_tdm->configured = 0;
174} 142}
175 143
176static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai, 144static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai,
177 unsigned int tx_num, unsigned int *tx_slot, 145 unsigned int tx_num, unsigned int *tx_slot,
178 unsigned int rx_num, unsigned int *rx_slot) 146 unsigned int rx_num, unsigned int *rx_slot)
179{ 147{
148 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(dai);
149 struct bf5xx_tdm_port *bf5xx_tdm = sport_handle->private_data;
180 int i; 150 int i;
181 unsigned int slot; 151 unsigned int slot;
182 unsigned int tx_mapped = 0, rx_mapped = 0; 152 unsigned int tx_mapped = 0, rx_mapped = 0;
@@ -189,7 +159,7 @@ static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai,
189 slot = tx_slot[i]; 159 slot = tx_slot[i];
190 if ((slot < BFIN_TDM_DAI_MAX_SLOTS) && 160 if ((slot < BFIN_TDM_DAI_MAX_SLOTS) &&
191 (!(tx_mapped & (1 << slot)))) { 161 (!(tx_mapped & (1 << slot)))) {
192 bf5xx_tdm.tx_map[i] = slot; 162 bf5xx_tdm->tx_map[i] = slot;
193 tx_mapped |= 1 << slot; 163 tx_mapped |= 1 << slot;
194 } else 164 } else
195 return -EINVAL; 165 return -EINVAL;
@@ -198,7 +168,7 @@ static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai,
198 slot = rx_slot[i]; 168 slot = rx_slot[i];
199 if ((slot < BFIN_TDM_DAI_MAX_SLOTS) && 169 if ((slot < BFIN_TDM_DAI_MAX_SLOTS) &&
200 (!(rx_mapped & (1 << slot)))) { 170 (!(rx_mapped & (1 << slot)))) {
201 bf5xx_tdm.rx_map[i] = slot; 171 bf5xx_tdm->rx_map[i] = slot;
202 rx_mapped |= 1 << slot; 172 rx_mapped |= 1 << slot;
203 } else 173 } else
204 return -EINVAL; 174 return -EINVAL;
@@ -210,24 +180,23 @@ static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai,
210#ifdef CONFIG_PM 180#ifdef CONFIG_PM
211static int bf5xx_tdm_suspend(struct snd_soc_dai *dai) 181static int bf5xx_tdm_suspend(struct snd_soc_dai *dai)
212{ 182{
213 struct sport_device *sport = dai->private_data; 183 struct sport_device *sport = snd_soc_dai_get_drvdata(dai);
214 184
215 if (!dai->active) 185 if (dai->playback_active)
216 return 0;
217 if (dai->capture.active)
218 sport_rx_stop(sport);
219 if (dai->playback.active)
220 sport_tx_stop(sport); 186 sport_tx_stop(sport);
187 if (dai->capture_active)
188 sport_rx_stop(sport);
189
190 /* isolate sync/clock pins from codec while sports resume */
191 peripheral_free_list(sport->pin_req);
192
221 return 0; 193 return 0;
222} 194}
223 195
224static int bf5xx_tdm_resume(struct snd_soc_dai *dai) 196static int bf5xx_tdm_resume(struct snd_soc_dai *dai)
225{ 197{
226 int ret; 198 int ret;
227 struct sport_device *sport = dai->private_data; 199 struct sport_device *sport = snd_soc_dai_get_drvdata(dai);
228
229 if (!dai->active)
230 return 0;
231 200
232 ret = sport_set_multichannel(sport, 8, 0xFF, 1); 201 ret = sport_set_multichannel(sport, 8, 0xFF, 1);
233 if (ret) { 202 if (ret) {
@@ -235,18 +204,20 @@ static int bf5xx_tdm_resume(struct snd_soc_dai *dai)
235 ret = -EBUSY; 204 ret = -EBUSY;
236 } 205 }
237 206
238 ret = sport_config_rx(sport, IRFS, 0x1F, 0, 0); 207 ret = sport_config_rx(sport, 0, 0x1F, 0, 0);
239 if (ret) { 208 if (ret) {
240 pr_err("SPORT is busy!\n"); 209 pr_err("SPORT is busy!\n");
241 ret = -EBUSY; 210 ret = -EBUSY;
242 } 211 }
243 212
244 ret = sport_config_tx(sport, ITFS, 0x1F, 0, 0); 213 ret = sport_config_tx(sport, 0, 0x1F, 0, 0);
245 if (ret) { 214 if (ret) {
246 pr_err("SPORT is busy!\n"); 215 pr_err("SPORT is busy!\n");
247 ret = -EBUSY; 216 ret = -EBUSY;
248 } 217 }
249 218
219 peripheral_request_list(sport->pin_req, "soc-audio");
220
250 return 0; 221 return 0;
251} 222}
252 223
@@ -262,9 +233,7 @@ static struct snd_soc_dai_ops bf5xx_tdm_dai_ops = {
262 .set_channel_map = bf5xx_tdm_set_channel_map, 233 .set_channel_map = bf5xx_tdm_set_channel_map,
263}; 234};
264 235
265struct snd_soc_dai bf5xx_tdm_dai = { 236static struct snd_soc_dai_driver bf5xx_tdm_dai = {
266 .name = "bf5xx-tdm",
267 .id = 0,
268 .suspend = bf5xx_tdm_suspend, 237 .suspend = bf5xx_tdm_suspend,
269 .resume = bf5xx_tdm_resume, 238 .resume = bf5xx_tdm_resume,
270 .playback = { 239 .playback = {
@@ -279,24 +248,17 @@ struct snd_soc_dai bf5xx_tdm_dai = {
279 .formats = SNDRV_PCM_FMTBIT_S32_LE,}, 248 .formats = SNDRV_PCM_FMTBIT_S32_LE,},
280 .ops = &bf5xx_tdm_dai_ops, 249 .ops = &bf5xx_tdm_dai_ops,
281}; 250};
282EXPORT_SYMBOL_GPL(bf5xx_tdm_dai);
283 251
284static int __devinit bfin_tdm_probe(struct platform_device *pdev) 252static int __devinit bfin_tdm_probe(struct platform_device *pdev)
285{ 253{
286 int ret = 0; 254 struct sport_device *sport_handle;
287 255 int ret;
288 if (peripheral_request_list(&sport_req[sport_num][0], "soc-audio")) {
289 pr_err("Requesting Peripherals failed\n");
290 return -EFAULT;
291 }
292 256
293 /* request DMA for SPORT */ 257 /* configure SPORT for TDM */
294 sport_handle = sport_init(&sport_params[sport_num], 4, \ 258 sport_handle = sport_init(pdev, 4, 8 * sizeof(u32),
295 8 * sizeof(u32), NULL); 259 sizeof(struct bf5xx_tdm_port));
296 if (!sport_handle) { 260 if (!sport_handle)
297 peripheral_free_list(&sport_req[sport_num][0]);
298 return -ENODEV; 261 return -ENODEV;
299 }
300 262
301 /* SPORT works in TDM mode */ 263 /* SPORT works in TDM mode */
302 ret = sport_set_multichannel(sport_handle, 8, 0xFF, 1); 264 ret = sport_set_multichannel(sport_handle, 8, 0xFF, 1);
@@ -306,38 +268,39 @@ static int __devinit bfin_tdm_probe(struct platform_device *pdev)
306 goto sport_config_err; 268 goto sport_config_err;
307 } 269 }
308 270
309 ret = sport_config_rx(sport_handle, IRFS, 0x1F, 0, 0); 271 ret = sport_config_rx(sport_handle, 0, 0x1F, 0, 0);
310 if (ret) { 272 if (ret) {
311 pr_err("SPORT is busy!\n"); 273 pr_err("SPORT is busy!\n");
312 ret = -EBUSY; 274 ret = -EBUSY;
313 goto sport_config_err; 275 goto sport_config_err;
314 } 276 }
315 277
316 ret = sport_config_tx(sport_handle, ITFS, 0x1F, 0, 0); 278 ret = sport_config_tx(sport_handle, 0, 0x1F, 0, 0);
317 if (ret) { 279 if (ret) {
318 pr_err("SPORT is busy!\n"); 280 pr_err("SPORT is busy!\n");
319 ret = -EBUSY; 281 ret = -EBUSY;
320 goto sport_config_err; 282 goto sport_config_err;
321 } 283 }
322 284
323 ret = snd_soc_register_dai(&bf5xx_tdm_dai); 285 ret = snd_soc_register_dai(&pdev->dev, &bf5xx_tdm_dai);
324 if (ret) { 286 if (ret) {
325 pr_err("Failed to register DAI: %d\n", ret); 287 pr_err("Failed to register DAI: %d\n", ret);
326 goto sport_config_err; 288 goto sport_config_err;
327 } 289 }
328 290
329 sport_handle->private_data = &bf5xx_tdm;
330 return 0; 291 return 0;
331 292
332sport_config_err: 293sport_config_err:
333 peripheral_free_list(&sport_req[sport_num][0]); 294 sport_done(sport_handle);
334 return ret; 295 return ret;
335} 296}
336 297
337static int __devexit bfin_tdm_remove(struct platform_device *pdev) 298static int __devexit bfin_tdm_remove(struct platform_device *pdev)
338{ 299{
339 peripheral_free_list(&sport_req[sport_num][0]); 300 struct sport_device *sport_handle = platform_get_drvdata(pdev);
340 snd_soc_unregister_dai(&bf5xx_tdm_dai); 301
302 snd_soc_unregister_dai(&pdev->dev);
303 sport_done(sport_handle);
341 304
342 return 0; 305 return 0;
343} 306}
diff --git a/sound/soc/blackfin/bf5xx-tdm.h b/sound/soc/blackfin/bf5xx-tdm.h
index 04189a18c1ba..e986a3ea3315 100644
--- a/sound/soc/blackfin/bf5xx-tdm.h
+++ b/sound/soc/blackfin/bf5xx-tdm.h
@@ -20,6 +20,4 @@ struct bf5xx_tdm_port {
20 int configured; 20 int configured;
21}; 21};
22 22
23extern struct snd_soc_dai bf5xx_tdm_dai;
24
25#endif 23#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-06 03:39:23 -0400