Ventana: KBC: Removing the KBC usage on ventana
[linux-2.6.git] / arch / arm / mach-tegra / tegra_spdif_audio.c
1 /*
2  * arch/arm/mach-tegra/tegra_spdif_audio.c
3  *
4  * S/PDIF audio driver for NVIDIA Tegra SoCs
5  *
6  * Copyright (c) 2008-2009, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/miscdevice.h>
26 #include <linux/fs.h>
27 #include <linux/mutex.h>
28 #include <linux/clk.h>
29 #include <linux/interrupt.h>
30 #include <linux/slab.h>
31 #include <linux/list.h>
32 #include <linux/spinlock.h>
33 #include <linux/uaccess.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/dmapool.h>
36 #include <linux/err.h>
37 #include <linux/spi/spi.h>
38 #include <linux/kfifo.h>
39 #include <linux/debugfs.h>
40 #include <linux/completion.h>
41 #include <linux/platform_device.h>
42 #include <linux/device.h>
43 #include <linux/io.h>
44 #include <linux/ktime.h>
45 #include <linux/sysfs.h>
46 #include <linux/delay.h>
47 #include <linux/tegra_audio.h>
48 #include <linux/pm.h>
49 #include <linux/workqueue.h>
50
51 #include <mach/dma.h>
52 #include <mach/iomap.h>
53 #include <mach/spdif.h>
54 #include <mach/audio.h>
55 #include <mach/irqs.h>
56
57 #include "clock.h"
58
59 #define PCM_BUFFER_MAX_SIZE_ORDER       (PAGE_SHIFT)
60
61 #define SPDIF_MAX_NUM_BUFS 4
62 /* Todo: Add IOCTL to configure the number of buffers. */
63 #define SPDIF_DEFAULT_TX_NUM_BUFS 2
64 #define SPDIF_DEFAULT_RX_NUM_BUFS 2
65 /* per stream (input/output) */
66 struct audio_stream {
67         int opened;
68         struct mutex lock;
69
70         bool active; /* is DMA in progress? */
71         int num_bufs;
72         void *buffer[SPDIF_MAX_NUM_BUFS];
73         dma_addr_t buf_phy[SPDIF_MAX_NUM_BUFS];
74         struct completion comp[SPDIF_MAX_NUM_BUFS];
75         struct tegra_dma_req dma_req[SPDIF_MAX_NUM_BUFS];
76         int last_queued;
77
78         int spdif_fifo_atn_level;
79
80         struct tegra_dma_channel *dma_chan;
81         bool stop;
82         struct completion stop_completion;
83         spinlock_t dma_req_lock;
84
85         struct work_struct allow_suspend_work;
86 };
87
88 struct audio_driver_state {
89         struct list_head next;
90
91         struct platform_device *pdev;
92         struct tegra_audio_platform_data *pdata;
93         phys_addr_t spdif_phys;
94         unsigned long spdif_base;
95
96         unsigned long dma_req_sel;
97         bool fifo_init;
98
99         int irq;
100
101         struct miscdevice misc_out;
102         struct miscdevice misc_out_ctl;
103         struct audio_stream out;
104 };
105
106 static inline bool pending_buffer_requests(struct audio_stream *stream)
107 {
108         int i;
109         for (i = 0; i < stream->num_bufs; i++)
110                 if (!completion_done(&stream->comp[i]))
111                         return true;
112         return false;
113 }
114
115 static inline int buf_size(struct audio_stream *s __attribute__((unused)))
116 {
117         return 1 << PCM_BUFFER_MAX_SIZE_ORDER;
118 }
119
120 static inline struct audio_driver_state *ads_from_misc_out(struct file *file)
121 {
122         struct miscdevice *m = file->private_data;
123         struct audio_driver_state *ads =
124                         container_of(m, struct audio_driver_state, misc_out);
125         BUG_ON(!ads);
126         return ads;
127 }
128
129 static inline struct audio_driver_state *ads_from_misc_out_ctl(
130                 struct file *file)
131 {
132         struct miscdevice *m = file->private_data;
133         struct audio_driver_state *ads =
134                         container_of(m, struct audio_driver_state,
135                                         misc_out_ctl);
136         BUG_ON(!ads);
137         return ads;
138 }
139
140 static inline struct audio_driver_state *ads_from_out(
141                         struct audio_stream *aos)
142 {
143         return container_of(aos, struct audio_driver_state, out);
144 }
145
146 static inline void prevent_suspend(struct audio_stream *as)
147 {
148         pr_debug("%s\n", __func__);
149         cancel_work_sync(&as->allow_suspend_work);
150 }
151
152 static void allow_suspend_worker(struct work_struct *w)
153 {
154         struct audio_stream *as = container_of(w,
155                         struct audio_stream, allow_suspend_work);
156         pr_debug("%s\n", __func__);
157 }
158
159 static inline void allow_suspend(struct audio_stream *as)
160 {
161         schedule_work(&as->allow_suspend_work);
162 }
163
164 #define I2S_I2S_FIFO_TX_BUSY    I2S_I2S_STATUS_FIFO1_BSY
165 #define I2S_I2S_FIFO_TX_QS      I2S_I2S_STATUS_QS_FIFO1
166 #define I2S_I2S_FIFO_TX_ERR     I2S_I2S_STATUS_FIFO1_ERR
167
168 #define I2S_I2S_FIFO_RX_BUSY    I2S_I2S_STATUS_FIFO2_BSY
169 #define I2S_I2S_FIFO_RX_QS      I2S_I2S_STATUS_QS_FIFO2
170 #define I2S_I2S_FIFO_RX_ERR     I2S_I2S_STATUS_FIFO2_ERR
171
172 #define I2S_FIFO_ERR (I2S_I2S_STATUS_FIFO1_ERR | I2S_I2S_STATUS_FIFO2_ERR)
173
174
175 static inline void spdif_writel(unsigned long base, u32 val, u32 reg)
176 {
177         writel(val, base + reg);
178 }
179
180 static inline u32 spdif_readl(unsigned long base, u32 reg)
181 {
182         return readl(base + reg);
183 }
184
185 static inline void spdif_fifo_write(unsigned long base, u32 data)
186 {
187         spdif_writel(base, data, SPDIF_DATA_OUT_0);
188 }
189
190 static int spdif_fifo_set_attention_level(unsigned long base,
191                         unsigned level)
192 {
193         u32 val;
194
195         if (level > SPDIF_FIFO_ATN_LVL_TWELVE_SLOTS) {
196                 pr_err("%s: invalid fifo level selector %d\n", __func__,
197                         level);
198                 return -EINVAL;
199         }
200
201         val = spdif_readl(base, SPDIF_DATA_FIFO_CSR_0);
202
203         val &= ~SPDIF_DATA_FIFO_CSR_0_TX_ATN_LVL_MASK;
204         val |= level << SPDIF_DATA_FIFO_CSR_0_TX_ATN_LVL_SHIFT;
205
206
207         spdif_writel(base, val, SPDIF_DATA_FIFO_CSR_0);
208         return 0;
209 }
210
211 static void spdif_fifo_enable(unsigned long base, int on)
212 {
213         u32 val = spdif_readl(base, SPDIF_CTRL_0);
214         val &= ~(SPDIF_CTRL_0_TX_EN | SPDIF_CTRL_0_TC_EN | SPDIF_CTRL_0_TU_EN);
215         val |= on ? (SPDIF_CTRL_0_TX_EN) : 0;
216         val |= on ? (SPDIF_CTRL_0_TC_EN) : 0;
217
218         spdif_writel(base, val, SPDIF_CTRL_0);
219 }
220 #if 0
221 static bool spdif_is_fifo_enabled(unsigned long base)
222 {
223         u32 val = spdif_readl(base, SPDIF_CTRL_0);
224         return !!(val & SPDIF_CTRL_0_TX_EN);
225 }
226 #endif
227
228 static void spdif_fifo_clear(unsigned long base)
229 {
230         u32 val = spdif_readl(base, SPDIF_DATA_FIFO_CSR_0);
231         val &= ~(SPDIF_DATA_FIFO_CSR_0_TX_CLR | SPDIF_DATA_FIFO_CSR_0_TU_CLR);
232         val |= SPDIF_DATA_FIFO_CSR_0_TX_CLR | SPDIF_DATA_FIFO_CSR_0_TU_CLR;
233         spdif_writel(base, val, SPDIF_DATA_FIFO_CSR_0);
234 }
235
236
237 static int spdif_set_bit_mode(unsigned long base, unsigned mode)
238 {
239         u32 val = spdif_readl(base, SPDIF_CTRL_0);
240         val &= ~SPDIF_CTRL_0_BIT_MODE_MASK;
241
242         if (mode > SPDIF_BIT_MODE_MODERAW) {
243                 pr_err("%s: invalid bit_size selector %d\n", __func__,
244                         mode);
245                 return -EINVAL;
246         }
247
248         val |= mode << SPDIF_CTRL_0_BIT_MODE_SHIFT;
249
250         spdif_writel(base, val, SPDIF_CTRL_0);
251         return 0;
252 }
253
254 static int spdif_set_fifo_packed(unsigned long base, unsigned on)
255 {
256         u32 val = spdif_readl(base, SPDIF_CTRL_0);
257         val &= ~SPDIF_CTRL_0_PACK;
258         val |= on ? SPDIF_CTRL_0_PACK : 0;
259         spdif_writel(base, val, SPDIF_CTRL_0);
260         return 0;
261 }
262
263 #if 0
264 static void spdif_set_fifo_irq_on_err(unsigned long base, int on)
265 {
266         u32 val = spdif_readl(base, SPDIF_CTRL_0);
267         val &= ~SPDIF_CTRL_0_IE_TXE;
268         val |= on ? SPDIF_CTRL_0_IE_TXE : 0;
269         spdif_writel(base, val, SPDIF_CTRL_0);
270 }
271 #endif
272
273
274 static void spdif_enable_fifos(unsigned long base, int on)
275 {
276         u32 val = spdif_readl(base, SPDIF_CTRL_0);
277         if (on)
278                 val |= SPDIF_CTRL_0_TX_EN | SPDIF_CTRL_0_TC_EN |
279                        SPDIF_CTRL_0_IE_TXE;
280         else
281                 val &= ~(SPDIF_CTRL_0_TX_EN | SPDIF_CTRL_0_TC_EN |
282                          SPDIF_CTRL_0_IE_TXE);
283
284         spdif_writel(base, val, SPDIF_CTRL_0);
285 }
286
287 static inline u32 spdif_get_status(unsigned long base)
288 {
289         return spdif_readl(base, SPDIF_STATUS_0);
290 }
291
292 static inline u32 spdif_get_control(unsigned long base)
293 {
294         return spdif_readl(base, SPDIF_CTRL_0);
295 }
296
297 static inline void spdif_ack_status(unsigned long base)
298 {
299         return spdif_writel(base, spdif_readl(base, SPDIF_STATUS_0),
300                                 SPDIF_STATUS_0);
301 }
302
303 static inline u32 spdif_get_fifo_scr(unsigned long base)
304 {
305         return spdif_readl(base, SPDIF_DATA_FIFO_CSR_0);
306 }
307
308 static inline phys_addr_t spdif_get_fifo_phy_base(unsigned long phy_base)
309 {
310         return phy_base + SPDIF_DATA_OUT_0;
311 }
312
313 static inline u32 spdif_get_fifo_full_empty_count(unsigned long base)
314 {
315         u32 val = spdif_readl(base, SPDIF_DATA_FIFO_CSR_0);
316         val = val >> SPDIF_DATA_FIFO_CSR_0_TD_EMPTY_COUNT_SHIFT;
317         return val & SPDIF_DATA_FIFO_CSR_0_TD_EMPTY_COUNT_MASK;
318 }
319
320
321 static int spdif_set_sample_rate(struct audio_driver_state *state,
322                                 unsigned int sample_rate)
323 {
324         unsigned int clock_freq = 0;
325         struct clk *spdif_clk;
326
327         unsigned int ch_sta[] = {
328                 0x0, /* 44.1, default values */
329                 0x0,
330                 0x0,
331                 0x0,
332                 0x0,
333                 0x0,
334         };
335
336         switch (sample_rate) {
337         case 32000:
338                 clock_freq = 4096000; /* 4.0960 MHz */
339                 ch_sta[0] = 0x3 << 24;
340                 ch_sta[1] = 0xC << 4;
341                 break;
342         case 44100:
343                 clock_freq = 5644800; /* 5.6448 MHz */
344                 ch_sta[0] = 0x0;
345                 ch_sta[1] = 0xF << 4;
346                 break;
347         case 48000:
348                 clock_freq = 6144000; /* 6.1440MHz */
349                 ch_sta[0] = 0x2 << 24;
350                 ch_sta[1] = 0xD << 4;
351                 break;
352         case 88200:
353                 clock_freq = 11289600; /* 11.2896 MHz */
354                 break;
355         case 96000:
356                 clock_freq = 12288000; /* 12.288 MHz */
357                 break;
358         case 176400:
359                 clock_freq = 22579200; /* 22.5792 MHz */
360                 break;
361         case 192000:
362                 clock_freq = 24576000; /* 24.5760 MHz */
363                 break;
364         default:
365                 return -1;
366         }
367
368         spdif_clk = clk_get(&state->pdev->dev, NULL);
369         if (!spdif_clk) {
370                 dev_err(&state->pdev->dev, "%s: could not get spdif clock\n",
371                                 __func__);
372                 return -EIO;
373         }
374
375         clk_set_rate(spdif_clk, clock_freq);
376         if (clk_enable(spdif_clk)) {
377                 dev_err(&state->pdev->dev,
378                         "%s: failed to enable spdif_clk clock\n", __func__);
379                 return -EIO;
380         }
381         pr_info("%s: spdif_clk rate %ld\n", __func__, clk_get_rate(spdif_clk));
382
383         spdif_writel(state->spdif_base, ch_sta[0], SPDIF_CH_STA_TX_A_0);
384         spdif_writel(state->spdif_base, ch_sta[1], SPDIF_CH_STA_TX_B_0);
385         spdif_writel(state->spdif_base, ch_sta[2], SPDIF_CH_STA_TX_C_0);
386         spdif_writel(state->spdif_base, ch_sta[3], SPDIF_CH_STA_TX_D_0);
387         spdif_writel(state->spdif_base, ch_sta[4], SPDIF_CH_STA_TX_E_0);
388         spdif_writel(state->spdif_base, ch_sta[5], SPDIF_CH_STA_TX_F_0);
389
390         return 0;
391 }
392
393 static int init_stream_buffer(struct audio_stream *, int);
394
395 static int setup_dma(struct audio_driver_state *);
396 static void tear_down_dma(struct audio_driver_state *);
397 static void stop_dma_playback(struct audio_stream *);
398
399
400 struct sound_ops {
401         int (*setup)(struct audio_driver_state *);
402         void (*tear_down)(struct audio_driver_state *);
403         void (*stop_playback)(struct audio_stream *);
404 };
405
406 static const struct sound_ops dma_sound_ops = {
407         .setup = setup_dma,
408         .tear_down = tear_down_dma,
409         .stop_playback = stop_dma_playback,
410 };
411
412 static const struct sound_ops *sound_ops = &dma_sound_ops;
413
414
415
416 static bool stop_playback_if_necessary(struct audio_stream *aos)
417 {
418         unsigned long flags;
419         spin_lock_irqsave(&aos->dma_req_lock, flags);
420         pr_debug("%s\n", __func__);
421         if (!pending_buffer_requests(aos)) {
422                 pr_debug("%s: no more data to play back\n", __func__);
423                 sound_ops->stop_playback(aos);
424                 spin_unlock_irqrestore(&aos->dma_req_lock, flags);
425                 allow_suspend(aos);
426                 return true;
427         }
428         spin_unlock_irqrestore(&aos->dma_req_lock, flags);
429
430         return false;
431 }
432
433 /* playback */
434 static bool wait_till_stopped(struct audio_stream *as)
435 {
436         int rc;
437         pr_debug("%s: wait for completion\n", __func__);
438         rc = wait_for_completion_timeout(
439                         &as->stop_completion, HZ);
440         if (!rc)
441                 pr_err("%s: wait timed out", __func__);
442         if (rc < 0)
443                 pr_err("%s: wait error %d\n", __func__, rc);
444         allow_suspend(as);
445         pr_debug("%s: done: %d\n", __func__, rc);
446         return true;
447 }
448
449 /* Ask for playback to stop.  The _nosync means that
450  * as->lock has to be locked by the caller.
451  */
452 static void request_stop_nosync(struct audio_stream *as)
453 {
454         int i;
455         pr_debug("%s\n", __func__);
456         if (!as->stop) {
457                 as->stop = true;
458                 if (pending_buffer_requests(as))
459                         wait_till_stopped(as);
460                 for (i = 0; i < as->num_bufs; i++) {
461                         init_completion(&as->comp[i]);
462                         complete(&as->comp[i]);
463                 }
464         }
465         if (!tegra_dma_is_empty(as->dma_chan))
466                 pr_err("%s: DMA not empty!\n", __func__);
467         /* Stop the DMA then dequeue anything that's in progress. */
468         tegra_dma_cancel(as->dma_chan);
469         as->active = false; /* applies to recording only */
470         pr_debug("%s: done\n", __func__);
471 }
472
473 static void setup_dma_tx_request(struct tegra_dma_req *req,
474                 struct audio_stream *aos);
475
476 static int setup_dma(struct audio_driver_state *ads)
477 {
478         int rc, i;
479         pr_info("%s\n", __func__);
480
481         /* setup audio playback */
482         for (i = 0; i < ads->out.num_bufs; i++) {
483                 ads->out.buf_phy[i] = dma_map_single(&ads->pdev->dev,
484                                 ads->out.buffer[i],
485                                 buf_size(&ads->out),
486                                 DMA_TO_DEVICE);
487                 BUG_ON(!ads->out.buf_phy[i]);
488                 setup_dma_tx_request(&ads->out.dma_req[i], &ads->out);
489                 ads->out.dma_req[i].source_addr = ads->out.buf_phy[i];
490         }
491         ads->out.dma_chan =
492                  tegra_dma_allocate_channel(TEGRA_DMA_MODE_CONTINUOUS_SINGLE,
493                         "spdif_tx_req_%d", ads->dma_req_sel);
494         if (!ads->out.dma_chan) {
495                 pr_err("%s: error alloc output DMA channel: %ld\n",
496                         __func__, PTR_ERR(ads->out.dma_chan));
497                 rc = -ENODEV;
498                 goto fail_tx;
499         }
500         return 0;
501
502
503 fail_tx:
504
505         for (i = 0; i < ads->out.num_bufs; i++) {
506                 dma_unmap_single(&ads->pdev->dev, ads->out.buf_phy[i],
507                                 buf_size(&ads->out),
508                                 DMA_TO_DEVICE);
509                 ads->out.buf_phy[i] = 0;
510         }
511         tegra_dma_free_channel(ads->out.dma_chan);
512         ads->out.dma_chan = 0;
513
514
515         return rc;
516 }
517
518 static void tear_down_dma(struct audio_driver_state *ads)
519 {
520         int i;
521         pr_info("%s\n", __func__);
522
523
524         tegra_dma_free_channel(ads->out.dma_chan);
525         for (i = 0; i < ads->out.num_bufs; i++) {
526                 dma_unmap_single(&ads->pdev->dev, ads->out.buf_phy[i],
527                                 buf_size(&ads->out),
528                                 DMA_TO_DEVICE);
529                 ads->out.buf_phy[i] = 0;
530         }
531
532         ads->out.dma_chan = NULL;
533 }
534
535 static void dma_tx_complete_callback(struct tegra_dma_req *req)
536 {
537         struct audio_stream *aos = req->dev;
538         unsigned req_num;
539
540         req_num = req - aos->dma_req;
541         pr_debug("%s: completed buffer %d size %d\n", __func__,
542                         req_num, req->bytes_transferred);
543         BUG_ON(req_num >= aos->num_bufs);
544
545         complete(&aos->comp[req_num]);
546
547         if (!pending_buffer_requests(aos)) {
548                 pr_debug("%s: Playback underflow", __func__);
549                 complete(&aos->stop_completion);
550         }
551 }
552
553
554 static void setup_dma_tx_request(struct tegra_dma_req *req,
555                 struct audio_stream *aos)
556 {
557         struct audio_driver_state *ads = ads_from_out(aos);
558
559         memset(req, 0, sizeof(*req));
560
561         req->complete = dma_tx_complete_callback;
562         req->dev = aos;
563         req->to_memory = false;
564         req->dest_addr = spdif_get_fifo_phy_base(ads->spdif_phys);
565         req->dest_bus_width = 32;
566         req->dest_wrap = 4;
567         req->source_wrap = 0;
568         req->source_bus_width = 32;
569         req->req_sel = ads->dma_req_sel;
570 }
571
572
573 static int start_playback(struct audio_stream *aos,
574                         struct tegra_dma_req *req)
575 {
576         int rc;
577         unsigned long flags;
578         struct audio_driver_state *ads = ads_from_out(aos);
579
580         pr_debug("%s: (writing %d)\n",
581                         __func__, req->size);
582
583         spin_lock_irqsave(&aos->dma_req_lock, flags);
584 #if 0
585         spdif_fifo_clear(ads->spdif_base);
586 #endif
587
588         spdif_fifo_set_attention_level(ads->spdif_base,
589                 ads->out.spdif_fifo_atn_level);
590
591         if (ads->fifo_init) {
592                 spdif_set_bit_mode(ads->spdif_base, SPDIF_BIT_MODE_MODE16BIT);
593                 spdif_set_fifo_packed(ads->spdif_base, 1);
594                 ads->fifo_init = false;
595         }
596
597         spdif_fifo_enable(ads->spdif_base, 1);
598
599         rc = tegra_dma_enqueue_req(aos->dma_chan, req);
600         spin_unlock_irqrestore(&aos->dma_req_lock, flags);
601
602         if (rc)
603                 pr_err("%s: could not enqueue TX DMA req\n", __func__);
604         return rc;
605 }
606
607 /* Called with aos->dma_req_lock taken. */
608 static void stop_dma_playback(struct audio_stream *aos)
609 {
610         int spin = 0;
611         struct audio_driver_state *ads = ads_from_out(aos);
612         pr_debug("%s\n", __func__);
613         spdif_fifo_enable(ads->spdif_base, 0);
614         while ((spdif_get_status(ads->spdif_base) & SPDIF_STATUS_0_TX_BSY) &&
615                         spin < 100) {
616                 udelay(10);
617                 if (spin++ > 50)
618                         pr_info("%s: spin %d\n", __func__, spin);
619         }
620         if (spin == 100)
621                 pr_warn("%s: spinny\n", __func__);
622         ads->fifo_init = true;
623 }
624
625
626
627 static irqreturn_t spdif_interrupt(int irq, void *data)
628 {
629         struct audio_driver_state *ads = data;
630         u32 status = spdif_get_status(ads->spdif_base);
631
632         pr_debug("%s: %08x\n", __func__, status);
633
634 /*      if (status & SPDIF_STATUS_0_TX_ERR) */
635                 spdif_ack_status(ads->spdif_base);
636
637         pr_debug("%s: done %08x\n", __func__,
638                         spdif_get_status(ads->spdif_base));
639         return IRQ_HANDLED;
640 }
641
642 static ssize_t tegra_spdif_write(struct file *file,
643                 const char __user *buf, size_t size, loff_t *off)
644 {
645         ssize_t rc = 0;
646         int out_buf;
647         struct tegra_dma_req *req;
648         struct audio_driver_state *ads = ads_from_misc_out(file);
649
650         mutex_lock(&ads->out.lock);
651
652         if (!IS_ALIGNED(size, 4) || size < 4 || size > buf_size(&ads->out)) {
653                 pr_err("%s: invalid user size %d\n", __func__, size);
654                 rc = -EINVAL;
655                 goto done;
656         }
657
658         pr_debug("%s: write %d bytes\n", __func__, size);
659
660         if (ads->out.stop) {
661                 pr_debug("%s: playback has been cancelled\n", __func__);
662                 goto done;
663         }
664
665         /* Decide which buf is next. */
666         out_buf = (ads->out.last_queued + 1) % ads->out.num_bufs;
667         req = &ads->out.dma_req[out_buf];
668
669         /* Wait for the buffer to be emptied (complete).  The maximum timeout
670          * value could be calculated dynamically based on buf_size(&ads->out).
671          * For a buffer size of 16k, at 44.1kHz/stereo/16-bit PCM, you would
672          * have ~93ms.
673          */
674         pr_debug("%s: waiting for buffer %d\n", __func__, out_buf);
675         rc = wait_for_completion_interruptible_timeout(
676                                 &ads->out.comp[out_buf], HZ);
677         if (!rc) {
678                 pr_err("%s: timeout", __func__);
679                 rc = -ETIMEDOUT;
680                 goto done;
681         } else if (rc < 0) {
682                 pr_err("%s: wait error %d", __func__, rc);
683                 goto done;
684         }
685
686         /* Fill the buffer and enqueue it. */
687         pr_debug("%s: acquired buffer %d, copying data\n", __func__, out_buf);
688         rc = copy_from_user(ads->out.buffer[out_buf], buf, size);
689         if (rc) {
690                 rc = -EFAULT;
691                 goto done;
692         }
693
694         prevent_suspend(&ads->out);
695
696         req->size = size;
697         dma_sync_single_for_device(NULL,
698                         req->source_addr, req->size, DMA_TO_DEVICE);
699         ads->out.last_queued = out_buf;
700         init_completion(&ads->out.stop_completion);
701
702         rc = start_playback(&ads->out, req);
703         if (!rc)
704                 rc = size;
705         else
706                 allow_suspend(&ads->out);
707
708 done:
709         mutex_unlock(&ads->out.lock);
710         return rc;
711 }
712
713 static long tegra_spdif_out_ioctl(struct file *file,
714                         unsigned int cmd, unsigned long arg)
715 {
716         int rc = 0;
717         struct audio_driver_state *ads = ads_from_misc_out_ctl(file);
718         struct audio_stream *aos = &ads->out;
719
720         mutex_lock(&aos->lock);
721
722         switch (cmd) {
723         case TEGRA_AUDIO_OUT_FLUSH:
724                 if (pending_buffer_requests(aos)) {
725                         pr_debug("%s: flushing\n", __func__);
726                         request_stop_nosync(aos);
727                         pr_debug("%s: flushed\n", __func__);
728                 }
729                 if (stop_playback_if_necessary(aos))
730                         pr_debug("%s: done (stopped)\n", __func__);
731                 aos->stop = false;
732                 break;
733         case TEGRA_AUDIO_OUT_SET_NUM_BUFS: {
734                 unsigned int num;
735                 if (copy_from_user(&num, (const void __user *)arg,
736                                         sizeof(num))) {
737                         rc = -EFAULT;
738                         break;
739                 }
740                 if (!num || num > SPDIF_MAX_NUM_BUFS) {
741                         pr_err("%s: invalid buffer count %d\n", __func__, num);
742                         rc = -EINVAL;
743                         break;
744                 }
745                 if (pending_buffer_requests(aos)) {
746                         pr_err("%s: playback in progress\n", __func__);
747                         rc = -EBUSY;
748                         break;
749                 }
750                 rc = init_stream_buffer(aos, num);
751                 if (rc < 0)
752                         break;
753                 aos->num_bufs = num;
754                 sound_ops->setup(ads);
755         }
756                 break;
757         case TEGRA_AUDIO_OUT_GET_NUM_BUFS:
758                 if (copy_to_user((void __user *)arg,
759                                 &aos->num_bufs, sizeof(aos->num_bufs)))
760                         rc = -EFAULT;
761                 break;
762         default:
763                 rc = -EINVAL;
764         }
765
766         mutex_unlock(&aos->lock);
767         return rc;
768 }
769
770
771 static int tegra_spdif_out_open(struct inode *inode, struct file *file)
772 {
773         int rc = 0;
774         int i;
775         struct audio_driver_state *ads = ads_from_misc_out(file);
776
777         pr_debug("%s\n", __func__);
778
779         mutex_lock(&ads->out.lock);
780
781         if (ads->out.opened) {
782                 rc = -EBUSY;
783                 goto done;
784         }
785
786         ads->out.opened = 1;
787         ads->out.stop = false;
788
789         for (i = 0; i < SPDIF_MAX_NUM_BUFS; i++) {
790                 init_completion(&ads->out.comp[i]);
791                 /* TX buf rest state is unqueued, complete. */
792                 complete(&ads->out.comp[i]);
793         }
794
795 done:
796         mutex_unlock(&ads->out.lock);
797         return rc;
798 }
799
800 static int tegra_spdif_out_release(struct inode *inode, struct file *file)
801 {
802         struct audio_driver_state *ads = ads_from_misc_out(file);
803
804         pr_debug("%s\n", __func__);
805
806         mutex_lock(&ads->out.lock);
807         ads->out.opened = 0;
808         request_stop_nosync(&ads->out);
809         if (stop_playback_if_necessary(&ads->out))
810                 pr_debug("%s: done (stopped)\n", __func__);
811         allow_suspend(&ads->out);
812         mutex_unlock(&ads->out.lock);
813         pr_debug("%s: done\n", __func__);
814         return 0;
815 }
816
817
818 static const struct file_operations tegra_spdif_out_fops = {
819         .owner = THIS_MODULE,
820         .open = tegra_spdif_out_open,
821         .release = tegra_spdif_out_release,
822         .write = tegra_spdif_write,
823 };
824
825 static int tegra_spdif_ctl_open(struct inode *inode, struct file *file)
826 {
827         return 0;
828 }
829
830 static int tegra_spdif_ctl_release(struct inode *inode, struct file *file)
831 {
832         return 0;
833 }
834
835 static const struct file_operations tegra_spdif_out_ctl_fops = {
836         .owner = THIS_MODULE,
837         .open = tegra_spdif_ctl_open,
838         .release = tegra_spdif_ctl_release,
839         .unlocked_ioctl = tegra_spdif_out_ioctl,
840 };
841
842 static int init_stream_buffer(struct audio_stream *s, int num)
843 {
844         int i, j;
845         pr_debug("%s (num %d)\n", __func__,  num);
846
847         for (i = 0; i < num; i++) {
848                 kfree(s->buffer[i]);
849                 s->buffer[i] =
850                         kmalloc(buf_size(s), GFP_KERNEL | GFP_DMA);
851                 if (!s->buffer[i]) {
852                         pr_err("%s: could not allocate buffer\n", __func__);
853                         for (j = i - 1; j >= 0; j--) {
854                                 kfree(s->buffer[j]);
855                                 s->buffer[j] = 0;
856                         }
857                         return -ENOMEM;
858                 }
859         }
860         return 0;
861 }
862
863
864 static int setup_misc_device(struct miscdevice *misc,
865                         const struct file_operations  *fops,
866                         const char *fmt, ...)
867 {
868         int rc = 0;
869         va_list args;
870         const int sz = 64;
871
872         va_start(args, fmt);
873
874         memset(misc, 0, sizeof(*misc));
875         misc->minor = MISC_DYNAMIC_MINOR;
876         misc->name  = kmalloc(sz, GFP_KERNEL);
877         if (!misc->name) {
878                 rc = -ENOMEM;
879                 goto done;
880         }
881
882         vsnprintf((char *)misc->name, sz, fmt, args);
883         misc->fops = fops;
884         if (misc_register(misc)) {
885                 pr_err("%s: could not register %s\n", __func__, misc->name);
886                 kfree(misc->name);
887                 rc = -EIO;
888                 goto done;
889         }
890
891 done:
892         va_end(args);
893         return rc;
894 }
895
896 static ssize_t dma_toggle_show(struct device *dev,
897                                 struct device_attribute *attr,
898                                 char *buf)
899 {
900         return sprintf(buf, "dma\n");
901 }
902
903 static ssize_t dma_toggle_store(struct device *dev,
904                         struct device_attribute *attr,
905                         const char *buf, size_t count)
906 {
907         pr_err("%s: Not implemented.", __func__);
908         return 0;
909 }
910
911 static DEVICE_ATTR(dma_toggle, 0644, dma_toggle_show, dma_toggle_store);
912
913 static ssize_t __attr_fifo_atn_read(char *buf, int atn_lvl)
914 {
915         switch (atn_lvl) {
916         case SPDIF_FIFO_ATN_LVL_ONE_SLOT:
917                 strncpy(buf, "1\n", 2);
918                 return 2;
919         case SPDIF_FIFO_ATN_LVL_FOUR_SLOTS:
920                 strncpy(buf, "4\n", 2);
921                 return 2;
922         case SPDIF_FIFO_ATN_LVL_EIGHT_SLOTS:
923                 strncpy(buf, "8\n", 2);
924                 return 2;
925         case SPDIF_FIFO_ATN_LVL_TWELVE_SLOTS:
926                 strncpy(buf, "12\n", 3);
927                 return 3;
928         default:
929                 BUG_ON(1);
930                 return -EIO;
931         }
932 }
933
934 static ssize_t __attr_fifo_atn_write(struct audio_driver_state *ads,
935                 struct audio_stream *as,
936                 int *fifo_lvl,
937                 const char *buf, size_t size)
938 {
939         int lvl;
940
941         if (size > 3) {
942                 pr_err("%s: buffer size %d too big\n", __func__, size);
943                 return -EINVAL;
944         }
945
946         if (sscanf(buf, "%d", &lvl) != 1) {
947                 pr_err("%s: invalid input string [%s]\n", __func__, buf);
948                 return -EINVAL;
949         }
950
951         switch (lvl) {
952         case 1:
953                 lvl = SPDIF_FIFO_ATN_LVL_ONE_SLOT;
954                 break;
955         case 4:
956                 lvl = SPDIF_FIFO_ATN_LVL_FOUR_SLOTS;
957                 break;
958         case 8:
959                 lvl = SPDIF_FIFO_ATN_LVL_EIGHT_SLOTS;
960                 break;
961         case 12:
962                 lvl = SPDIF_FIFO_ATN_LVL_TWELVE_SLOTS;
963                 break;
964         default:
965                 pr_err("%s: invalid attention level %d\n", __func__, lvl);
966                 return -EINVAL;
967         }
968
969         *fifo_lvl = lvl;
970         pr_info("%s: fifo level %d\n", __func__, *fifo_lvl);
971
972         return size;
973 }
974
975 static ssize_t tx_fifo_atn_show(struct device *dev,
976                                 struct device_attribute *attr,
977                                 char *buf)
978 {
979         struct tegra_audio_platform_data *pdata = dev->platform_data;
980         struct audio_driver_state *ads = pdata->driver_data;
981         return __attr_fifo_atn_read(buf, ads->out.spdif_fifo_atn_level);
982 }
983
984 static ssize_t tx_fifo_atn_store(struct device *dev,
985                         struct device_attribute *attr,
986                         const char *buf, size_t count)
987 {
988         ssize_t rc;
989         struct tegra_audio_platform_data *pdata = dev->platform_data;
990         struct audio_driver_state *ads = pdata->driver_data;
991         mutex_lock(&ads->out.lock);
992         if (pending_buffer_requests(&ads->out)) {
993                 pr_err("%s: playback in progress.\n", __func__);
994                 rc = -EBUSY;
995                 goto done;
996         }
997         rc = __attr_fifo_atn_write(ads, &ads->out,
998                         &ads->out.spdif_fifo_atn_level,
999                         buf, count);
1000 done:
1001         mutex_unlock(&ads->out.lock);
1002         return rc;
1003 }
1004
1005 static DEVICE_ATTR(tx_fifo_atn, 0644, tx_fifo_atn_show, tx_fifo_atn_store);
1006
1007
1008 static int spdif_configure(struct platform_device *pdev)
1009 {
1010         struct tegra_audio_platform_data *pdata = pdev->dev.platform_data;
1011         struct audio_driver_state *state = pdata->driver_data;
1012
1013         if (!state)
1014                 return -ENOMEM;
1015
1016         /* disable interrupts from SPDIF */
1017         spdif_writel(state->spdif_base, 0x0, SPDIF_CTRL_0);
1018         spdif_fifo_clear(state->spdif_base);
1019         spdif_enable_fifos(state->spdif_base, 0);
1020
1021         spdif_set_bit_mode(state->spdif_base, SPDIF_BIT_MODE_MODE16BIT);
1022         spdif_set_fifo_packed(state->spdif_base, 1);
1023
1024         spdif_fifo_set_attention_level(state->spdif_base,
1025                 state->out.spdif_fifo_atn_level);
1026
1027         spdif_set_sample_rate(state, 44100);
1028
1029         state->fifo_init = true;
1030         return 0;
1031 }
1032
1033 static int tegra_spdif_probe(struct platform_device *pdev)
1034 {
1035         int rc, i;
1036         struct resource *res;
1037         struct audio_driver_state *state;
1038
1039         pr_info("%s\n", __func__);
1040
1041         state = kzalloc(sizeof(*state), GFP_KERNEL);
1042         if (!state)
1043                 return -ENOMEM;
1044
1045         state->pdev = pdev;
1046         state->pdata = pdev->dev.platform_data;
1047         state->pdata->driver_data = state;
1048         BUG_ON(!state->pdata);
1049
1050         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1051         if (!res) {
1052                 dev_err(&pdev->dev, "no mem resource!\n");
1053                 return -ENODEV;
1054         }
1055
1056         if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
1057                 dev_err(&pdev->dev, "memory region already claimed!\n");
1058                 return -ENOMEM;
1059         }
1060
1061         state->spdif_phys = res->start;
1062         state->spdif_base = (unsigned long)ioremap(res->start,
1063                         res->end - res->start + 1);
1064         if (!state->spdif_base) {
1065                 dev_err(&pdev->dev, "cannot remap iomem!\n");
1066                 return -EIO;
1067         }
1068
1069         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1070         if (!res) {
1071                 dev_err(&pdev->dev, "no dma resource!\n");
1072                 return -ENODEV;
1073         }
1074         state->dma_req_sel = res->start;
1075
1076         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1077         if (!res) {
1078                 dev_err(&pdev->dev, "no irq resource!\n");
1079                 return -ENODEV;
1080         }
1081         state->irq = res->start;
1082
1083         rc = spdif_configure(pdev);
1084         if (rc < 0)
1085                 return rc;
1086
1087         state->out.opened = 0;
1088         state->out.active = false;
1089         mutex_init(&state->out.lock);
1090         init_completion(&state->out.stop_completion);
1091         spin_lock_init(&state->out.dma_req_lock);
1092         state->out.dma_chan = NULL;
1093         state->out.num_bufs = SPDIF_DEFAULT_TX_NUM_BUFS;
1094         for (i = 0; i < SPDIF_MAX_NUM_BUFS; i++) {
1095                 init_completion(&state->out.comp[i]);
1096                         /* TX buf rest state is unqueued, complete. */
1097                 complete(&state->out.comp[i]);
1098                 state->out.buffer[i] = 0;
1099                 state->out.buf_phy[i] = 0;
1100         }
1101         state->out.last_queued = 0;
1102         rc = init_stream_buffer(&state->out, state->out.num_bufs);
1103         if (rc < 0)
1104                 return rc;
1105
1106         INIT_WORK(&state->out.allow_suspend_work, allow_suspend_worker);
1107
1108         if (request_irq(state->irq, spdif_interrupt,
1109                         IRQF_DISABLED, state->pdev->name, state) < 0) {
1110                 dev_err(&pdev->dev,
1111                         "%s: could not register handler for irq %d\n",
1112                         __func__, state->irq);
1113                 return -EIO;
1114         }
1115
1116         rc = setup_misc_device(&state->misc_out,
1117                         &tegra_spdif_out_fops,
1118                         "spdif_out");
1119         if (rc < 0)
1120                 return rc;
1121
1122         rc = setup_misc_device(&state->misc_out_ctl,
1123                         &tegra_spdif_out_ctl_fops,
1124                         "spdif_out_ctl");
1125         if (rc < 0)
1126                 return rc;
1127
1128         sound_ops->setup(state);
1129
1130         rc = device_create_file(&pdev->dev, &dev_attr_dma_toggle);
1131         if (rc < 0) {
1132                 dev_err(&pdev->dev, "%s: could not create sysfs entry %s: %d\n",
1133                         __func__, dev_attr_dma_toggle.attr.name, rc);
1134                 return rc;
1135         }
1136
1137         rc = device_create_file(&pdev->dev, &dev_attr_tx_fifo_atn);
1138         if (rc < 0) {
1139                 dev_err(&pdev->dev, "%s: could not create sysfs entry %s: %d\n",
1140                         __func__, dev_attr_tx_fifo_atn.attr.name, rc);
1141                 return rc;
1142         }
1143
1144         return 0;
1145 }
1146
1147 #ifdef CONFIG_PM_SLEEP
1148 static int tegra_spdif_suspend(struct platform_device *pdev, pm_message_t mesg)
1149 {
1150         /* dev_info(&pdev->dev, "%s\n", __func__); */
1151         return 0;
1152 }
1153
1154 static int tegra_spdif_resume(struct platform_device *pdev)
1155 {
1156         return spdif_configure(pdev);
1157 }
1158 #endif /* CONFIG_PM_SLEEP */
1159
1160 static struct platform_driver tegra_spdif_driver = {
1161         .driver = {
1162                 .name = "spdif_out",
1163                 .owner = THIS_MODULE,
1164         },
1165         .probe = tegra_spdif_probe,
1166 #ifdef CONFIG_PM_SLEEP
1167         .suspend = tegra_spdif_suspend,
1168         .resume = tegra_spdif_resume,
1169 #endif
1170 };
1171
1172 static int __init tegra_spdif_init(void)
1173 {
1174         return platform_driver_register(&tegra_spdif_driver);
1175 }
1176
1177 module_init(tegra_spdif_init);
1178 MODULE_LICENSE("GPL");