← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to sound/soc/codecs/twl6040.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
sound/soc/codecs/twl6040.c
24
24
#include <linux/init.h>
25
25
#include <linux/delay.h>
26
26
#include <linux/pm.h>
27
 
#include <linux/i2c.h>
28
 
#include <linux/gpio.h>
29
27
#include <linux/platform_device.h>
30
28
#include <linux/slab.h>
31
29
#include <linux/i2c/twl.h>
 
30
#include <linux/mfd/twl6040.h>
32
31
 
33
32
#include <sound/core.h>
34
33
#include <sound/pcm.h>
58
57
#define TWL6040_HF_VOL_MASK     0x1F
59
58
#define TWL6040_HF_VOL_SHIFT    0
60
59
 
 
60
/* Shadow register used by the driver */
 
61
#define TWL6040_REG_SW_SHADOW   0x2F
 
62
#define TWL6040_CACHEREGNUM     (TWL6040_REG_SW_SHADOW + 1)
 
63
 
 
64
/* TWL6040_REG_SW_SHADOW (0x2F) fields */
 
65
#define TWL6040_EAR_PATH_ENABLE 0x01
 
66
 
61
67
struct twl6040_output {
62
68
        u16 active;
63
69
        u16 left_vol;
66
72
        u16 right_step;
67
73
        unsigned int step_delay;
68
74
        u16 ramp;
69
 
        u16 mute;
 
75
        struct delayed_work work;
70
76
        struct completion ramp_done;
71
77
};
72
78
 
73
79
struct twl6040_jack_data {
74
80
        struct snd_soc_jack *jack;
 
81
        struct delayed_work work;
75
82
        int report;
76
83
};
77
84
 
78
85
/* codec private data */
79
86
struct twl6040_data {
80
 
        int audpwron;
81
 
        int naudint;
 
87
        int plug_irq;
82
88
        int codec_powered;
83
89
        int pll;
84
 
        int non_lp;
 
90
        int pll_power_mode;
 
91
        int hs_power_mode;
 
92
        int hs_power_mode_locked;
 
93
        unsigned int clk_in;
85
94
        unsigned int sysclk;
86
 
        struct snd_pcm_hw_constraint_list *sysclk_constraints;
87
 
        struct completion ready;
 
95
        u16 hs_left_step;
 
96
        u16 hs_right_step;
 
97
        u16 hf_left_step;
 
98
        u16 hf_right_step;
88
99
        struct twl6040_jack_data hs_jack;
89
100
        struct snd_soc_codec *codec;
90
101
        struct workqueue_struct *workqueue;
91
 
        struct delayed_work delayed_work;
92
102
        struct mutex mutex;
93
103
        struct twl6040_output headset;
94
104
        struct twl6040_output handsfree;
95
 
        struct workqueue_struct *hf_workqueue;
96
 
        struct workqueue_struct *hs_workqueue;
97
 
        struct delayed_work hs_delayed_work;
98
 
        struct delayed_work hf_delayed_work;
99
105
};
100
106
 
101
107
/*
102
108
 * twl6040 register cache & default register settings
103
109
 */
104
110
static const u8 twl6040_reg[TWL6040_CACHEREGNUM] = {
105
 
        0x00, /* not used               0x00    */
106
 
        0x4B, /* TWL6040_ASICID (ro)    0x01    */
107
 
        0x00, /* TWL6040_ASICREV (ro)   0x02    */
108
 
        0x00, /* TWL6040_INTID          0x03    */
109
 
        0x00, /* TWL6040_INTMR          0x04    */
110
 
        0x00, /* TWL6040_NCPCTRL        0x05    */
111
 
        0x00, /* TWL6040_LDOCTL         0x06    */
112
 
        0x60, /* TWL6040_HPPLLCTL       0x07    */
113
 
        0x00, /* TWL6040_LPPLLCTL       0x08    */
114
 
        0x4A, /* TWL6040_LPPLLDIV       0x09    */
115
 
        0x00, /* TWL6040_AMICBCTL       0x0A    */
116
 
        0x00, /* TWL6040_DMICBCTL       0x0B    */
117
 
        0x18, /* TWL6040_MICLCTL        0x0C    - No input selected on Left Mic */
118
 
        0x18, /* TWL6040_MICRCTL        0x0D    - No input selected on Right Mic */
119
 
        0x00, /* TWL6040_MICGAIN        0x0E    */
120
 
        0x1B, /* TWL6040_LINEGAIN       0x0F    */
121
 
        0x00, /* TWL6040_HSLCTL         0x10    */
122
 
        0x00, /* TWL6040_HSRCTL         0x11    */
123
 
        0x00, /* TWL6040_HSGAIN         0x12    */
124
 
        0x00, /* TWL6040_EARCTL         0x13    */
125
 
        0x00, /* TWL6040_HFLCTL         0x14    */
126
 
        0x00, /* TWL6040_HFLGAIN        0x15    */
127
 
        0x00, /* TWL6040_HFRCTL         0x16    */
128
 
        0x00, /* TWL6040_HFRGAIN        0x17    */
129
 
        0x00, /* TWL6040_VIBCTLL        0x18    */
130
 
        0x00, /* TWL6040_VIBDATL        0x19    */
131
 
        0x00, /* TWL6040_VIBCTLR        0x1A    */
132
 
        0x00, /* TWL6040_VIBDATR        0x1B    */
133
 
        0x00, /* TWL6040_HKCTL1         0x1C    */
134
 
        0x00, /* TWL6040_HKCTL2         0x1D    */
135
 
        0x00, /* TWL6040_GPOCTL         0x1E    */
136
 
        0x00, /* TWL6040_ALB            0x1F    */
137
 
        0x00, /* TWL6040_DLB            0x20    */
138
 
        0x00, /* not used               0x21    */
139
 
        0x00, /* not used               0x22    */
140
 
        0x00, /* not used               0x23    */
141
 
        0x00, /* not used               0x24    */
142
 
        0x00, /* not used               0x25    */
143
 
        0x00, /* not used               0x26    */
144
 
        0x00, /* not used               0x27    */
145
 
        0x00, /* TWL6040_TRIM1          0x28    */
146
 
        0x00, /* TWL6040_TRIM2          0x29    */
147
 
        0x00, /* TWL6040_TRIM3          0x2A    */
148
 
        0x00, /* TWL6040_HSOTRIM        0x2B    */
149
 
        0x00, /* TWL6040_HFOTRIM        0x2C    */
150
 
        0x09, /* TWL6040_ACCCTL         0x2D    */
151
 
        0x00, /* TWL6040_STATUS (ro)    0x2E    */
152
 
};
153
 
 
154
 
/*
155
 
 * twl6040 vio/gnd registers:
156
 
 * registers under vio/gnd supply can be accessed
157
 
 * before the power-up sequence, after NRESPWRON goes high
158
 
 */
159
 
static const int twl6040_vio_reg[TWL6040_VIOREGNUM] = {
160
 
        TWL6040_REG_ASICID,
161
 
        TWL6040_REG_ASICREV,
162
 
        TWL6040_REG_INTID,
163
 
        TWL6040_REG_INTMR,
164
 
        TWL6040_REG_NCPCTL,
165
 
        TWL6040_REG_LDOCTL,
166
 
        TWL6040_REG_AMICBCTL,
167
 
        TWL6040_REG_DMICBCTL,
168
 
        TWL6040_REG_HKCTL1,
169
 
        TWL6040_REG_HKCTL2,
170
 
        TWL6040_REG_GPOCTL,
171
 
        TWL6040_REG_TRIM1,
172
 
        TWL6040_REG_TRIM2,
173
 
        TWL6040_REG_TRIM3,
174
 
        TWL6040_REG_HSOTRIM,
175
 
        TWL6040_REG_HFOTRIM,
176
 
        TWL6040_REG_ACCCTL,
177
 
        TWL6040_REG_STATUS,
178
 
};
179
 
 
180
 
/*
181
 
 * twl6040 vdd/vss registers:
182
 
 * registers under vdd/vss supplies can only be accessed
183
 
 * after the power-up sequence
184
 
 */
185
 
static const int twl6040_vdd_reg[TWL6040_VDDREGNUM] = {
186
 
        TWL6040_REG_HPPLLCTL,
187
 
        TWL6040_REG_LPPLLCTL,
188
 
        TWL6040_REG_LPPLLDIV,
 
111
        0x00, /* not used       0x00    */
 
112
        0x4B, /* REG_ASICID     0x01 (ro) */
 
113
        0x00, /* REG_ASICREV    0x02 (ro) */
 
114
        0x00, /* REG_INTID      0x03    */
 
115
        0x00, /* REG_INTMR      0x04    */
 
116
        0x00, /* REG_NCPCTRL    0x05    */
 
117
        0x00, /* REG_LDOCTL     0x06    */
 
118
        0x60, /* REG_HPPLLCTL   0x07    */
 
119
        0x00, /* REG_LPPLLCTL   0x08    */
 
120
        0x4A, /* REG_LPPLLDIV   0x09    */
 
121
        0x00, /* REG_AMICBCTL   0x0A    */
 
122
        0x00, /* REG_DMICBCTL   0x0B    */
 
123
        0x00, /* REG_MICLCTL    0x0C    */
 
124
        0x00, /* REG_MICRCTL    0x0D    */
 
125
        0x00, /* REG_MICGAIN    0x0E    */
 
126
        0x1B, /* REG_LINEGAIN   0x0F    */
 
127
        0x00, /* REG_HSLCTL     0x10    */
 
128
        0x00, /* REG_HSRCTL     0x11    */
 
129
        0x00, /* REG_HSGAIN     0x12    */
 
130
        0x00, /* REG_EARCTL     0x13    */
 
131
        0x00, /* REG_HFLCTL     0x14    */
 
132
        0x00, /* REG_HFLGAIN    0x15    */
 
133
        0x00, /* REG_HFRCTL     0x16    */
 
134
        0x00, /* REG_HFRGAIN    0x17    */
 
135
        0x00, /* REG_VIBCTLL    0x18    */
 
136
        0x00, /* REG_VIBDATL    0x19    */
 
137
        0x00, /* REG_VIBCTLR    0x1A    */
 
138
        0x00, /* REG_VIBDATR    0x1B    */
 
139
        0x00, /* REG_HKCTL1     0x1C    */
 
140
        0x00, /* REG_HKCTL2     0x1D    */
 
141
        0x00, /* REG_GPOCTL     0x1E    */
 
142
        0x00, /* REG_ALB        0x1F    */
 
143
        0x00, /* REG_DLB        0x20    */
 
144
        0x00, /* not used       0x21    */
 
145
        0x00, /* not used       0x22    */
 
146
        0x00, /* not used       0x23    */
 
147
        0x00, /* not used       0x24    */
 
148
        0x00, /* not used       0x25    */
 
149
        0x00, /* not used       0x26    */
 
150
        0x00, /* not used       0x27    */
 
151
        0x00, /* REG_TRIM1      0x28    */
 
152
        0x00, /* REG_TRIM2      0x29    */
 
153
        0x00, /* REG_TRIM3      0x2A    */
 
154
        0x00, /* REG_HSOTRIM    0x2B    */
 
155
        0x00, /* REG_HFOTRIM    0x2C    */
 
156
        0x09, /* REG_ACCCTL     0x2D    */
 
157
        0x00, /* REG_STATUS     0x2E (ro) */
 
158
 
 
159
        0x00, /* REG_SW_SHADOW  0x2F - Shadow, non HW register */
 
160
};
 
161
 
 
162
/* List of registers to be restored after power up */
 
163
static const int twl6040_restore_list[] = {
189
164
        TWL6040_REG_MICLCTL,
190
165
        TWL6040_REG_MICRCTL,
191
166
        TWL6040_REG_MICGAIN,
198
173
        TWL6040_REG_HFLGAIN,
199
174
        TWL6040_REG_HFRCTL,
200
175
        TWL6040_REG_HFRGAIN,
201
 
        TWL6040_REG_VIBCTLL,
202
 
        TWL6040_REG_VIBDATL,
203
 
        TWL6040_REG_VIBCTLR,
204
 
        TWL6040_REG_VIBDATR,
205
 
        TWL6040_REG_ALB,
206
 
        TWL6040_REG_DLB,
 
176
};
 
177
 
 
178
/* set of rates for each pll: low-power and high-performance */
 
179
static unsigned int lp_rates[] = {
 
180
        8000,
 
181
        11250,
 
182
        16000,
 
183
        22500,
 
184
        32000,
 
185
        44100,
 
186
        48000,
 
187
        88200,
 
188
        96000,
 
189
};
 
190
 
 
191
static unsigned int hp_rates[] = {
 
192
        8000,
 
193
        16000,
 
194
        32000,
 
195
        48000,
 
196
        96000,
 
197
};
 
198
 
 
199
static struct snd_pcm_hw_constraint_list sysclk_constraints[] = {
 
200
        { .count = ARRAY_SIZE(lp_rates), .list = lp_rates, },
 
201
        { .count = ARRAY_SIZE(hp_rates), .list = hp_rates, },
207
202
};
208
203
 
209
204
/*
239
234
static int twl6040_read_reg_volatile(struct snd_soc_codec *codec,
240
235
                        unsigned int reg)
241
236
{
 
237
        struct twl6040 *twl6040 = codec->control_data;
242
238
        u8 value;
243
239
 
244
240
        if (reg >= TWL6040_CACHEREGNUM)
245
241
                return -EIO;
246
242
 
247
 
        twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &value, reg);
248
 
        twl6040_write_reg_cache(codec, reg, value);
 
243
        if (likely(reg < TWL6040_REG_SW_SHADOW)) {
 
244
                value = twl6040_reg_read(twl6040, reg);
 
245
                twl6040_write_reg_cache(codec, reg, value);
 
246
        } else {
 
247
                value = twl6040_read_reg_cache(codec, reg);
 
248
        }
249
249
 
250
250
        return value;
251
251
}
256
256
static int twl6040_write(struct snd_soc_codec *codec,
257
257
                        unsigned int reg, unsigned int value)
258
258
{
 
259
        struct twl6040 *twl6040 = codec->control_data;
 
260
 
259
261
        if (reg >= TWL6040_CACHEREGNUM)
260
262
                return -EIO;
261
263
 
262
264
        twl6040_write_reg_cache(codec, reg, value);
263
 
        return twl_i2c_write_u8(TWL_MODULE_AUDIO_VOICE, value, reg);
264
 
}
265
 
 
266
 
static void twl6040_init_vio_regs(struct snd_soc_codec *codec)
267
 
{
268
 
        u8 *cache = codec->reg_cache;
269
 
        int reg, i;
270
 
 
271
 
        /* allow registers to be accessed by i2c */
272
 
        twl6040_write(codec, TWL6040_REG_ACCCTL, cache[TWL6040_REG_ACCCTL]);
273
 
 
274
 
        for (i = 0; i < TWL6040_VIOREGNUM; i++) {
275
 
                reg = twl6040_vio_reg[i];
276
 
                /* skip read-only registers (ASICID, ASICREV, STATUS) */
277
 
                switch (reg) {
278
 
                case TWL6040_REG_ASICID:
279
 
                case TWL6040_REG_ASICREV:
280
 
                case TWL6040_REG_STATUS:
281
 
                        continue;
282
 
                default:
283
 
                        break;
284
 
                }
285
 
                twl6040_write(codec, reg, cache[reg]);
286
 
        }
287
 
}
288
 
 
289
 
static void twl6040_init_vdd_regs(struct snd_soc_codec *codec)
290
 
{
291
 
        u8 *cache = codec->reg_cache;
292
 
        int reg, i;
293
 
 
294
 
        for (i = 0; i < TWL6040_VDDREGNUM; i++) {
295
 
                reg = twl6040_vdd_reg[i];
 
265
        if (likely(reg < TWL6040_REG_SW_SHADOW))
 
266
                return twl6040_reg_write(twl6040, reg, value);
 
267
        else
 
268
                return 0;
 
269
}
 
270
 
 
271
static void twl6040_init_chip(struct snd_soc_codec *codec)
 
272
{
 
273
        struct twl6040 *twl6040 = codec->control_data;
 
274
        u8 val;
 
275
 
 
276
        /* Update reg_cache: ASICREV, and TRIM values */
 
277
        val = twl6040_get_revid(twl6040);
 
278
        twl6040_write_reg_cache(codec, TWL6040_REG_ASICREV, val);
 
279
 
 
280
        twl6040_read_reg_volatile(codec, TWL6040_REG_TRIM1);
 
281
        twl6040_read_reg_volatile(codec, TWL6040_REG_TRIM2);
 
282
        twl6040_read_reg_volatile(codec, TWL6040_REG_TRIM3);
 
283
        twl6040_read_reg_volatile(codec, TWL6040_REG_HSOTRIM);
 
284
        twl6040_read_reg_volatile(codec, TWL6040_REG_HFOTRIM);
 
285
 
 
286
        /* Change chip defaults */
 
287
        /* No imput selected for microphone amplifiers */
 
288
        twl6040_write_reg_cache(codec, TWL6040_REG_MICLCTL, 0x18);
 
289
        twl6040_write_reg_cache(codec, TWL6040_REG_MICRCTL, 0x18);
 
290
 
 
291
        /*
 
292
         * We need to lower the default gain values, so the ramp code
 
293
         * can work correctly for the first playback.
 
294
         * This reduces the pop noise heard at the first playback.
 
295
         */
 
296
        twl6040_write_reg_cache(codec, TWL6040_REG_HSGAIN, 0xff);
 
297
        twl6040_write_reg_cache(codec, TWL6040_REG_EARCTL, 0x1e);
 
298
        twl6040_write_reg_cache(codec, TWL6040_REG_HFLGAIN, 0x1d);
 
299
        twl6040_write_reg_cache(codec, TWL6040_REG_HFRGAIN, 0x1d);
 
300
        twl6040_write_reg_cache(codec, TWL6040_REG_LINEGAIN, 0);
 
301
}
 
302
 
 
303
static void twl6040_restore_regs(struct snd_soc_codec *codec)
 
304
{
 
305
        u8 *cache = codec->reg_cache;
 
306
        int reg, i;
 
307
 
 
308
        for (i = 0; i < ARRAY_SIZE(twl6040_restore_list); i++) {
 
309
                reg = twl6040_restore_list[i];
296
310
                twl6040_write(codec, reg, cache[reg]);
297
311
        }
298
312
}
317
331
        if (headset->ramp == TWL6040_RAMP_UP) {
318
332
                /* ramp step up */
319
333
                if (val < headset->left_vol) {
320
 
                        val += left_step;
 
334
                        if (val + left_step > headset->left_vol)
 
335
                                val = headset->left_vol;
 
336
                        else
 
337
                                val += left_step;
 
338
 
321
339
                        reg &= ~TWL6040_HSL_VOL_MASK;
322
340
                        twl6040_write(codec, TWL6040_REG_HSGAIN,
323
341
                                        (reg | (~val & TWL6040_HSL_VOL_MASK)));
327
345
        } else if (headset->ramp == TWL6040_RAMP_DOWN) {
328
346
                /* ramp step down */
329
347
                if (val > 0x0) {
330
 
                        val -= left_step;
 
348
                        if ((int)val - (int)left_step < 0)
 
349
                                val = 0;
 
350
                        else
 
351
                                val -= left_step;
 
352
 
331
353
                        reg &= ~TWL6040_HSL_VOL_MASK;
332
354
                        twl6040_write(codec, TWL6040_REG_HSGAIN, reg |
333
355
                                                (~val & TWL6040_HSL_VOL_MASK));
344
366
        if (headset->ramp == TWL6040_RAMP_UP) {
345
367
                /* ramp step up */
346
368
                if (val < headset->right_vol) {
347
 
                        val += right_step;
 
369
                        if (val + right_step > headset->right_vol)
 
370
                                val = headset->right_vol;
 
371
                        else
 
372
                                val += right_step;
 
373
 
348
374
                        reg &= ~TWL6040_HSR_VOL_MASK;
349
375
                        twl6040_write(codec, TWL6040_REG_HSGAIN,
350
376
                                (reg | (~val << TWL6040_HSR_VOL_SHIFT)));
354
380
        } else if (headset->ramp == TWL6040_RAMP_DOWN) {
355
381
                /* ramp step down */
356
382
                if (val > 0x0) {
357
 
                        val -= right_step;
 
383
                        if ((int)val - (int)right_step < 0)
 
384
                                val = 0;
 
385
                        else
 
386
                                val -= right_step;
 
387
 
358
388
                        reg &= ~TWL6040_HSR_VOL_MASK;
359
389
                        twl6040_write(codec, TWL6040_REG_HSGAIN,
360
390
                                         reg | (~val << TWL6040_HSR_VOL_SHIFT));
385
415
        if (handsfree->ramp == TWL6040_RAMP_UP) {
386
416
                /* ramp step up */
387
417
                if (val < handsfree->left_vol) {
388
 
                        val += left_step;
 
418
                        if (val + left_step > handsfree->left_vol)
 
419
                                val = handsfree->left_vol;
 
420
                        else
 
421
                                val += left_step;
 
422
 
389
423
                        reg &= ~TWL6040_HF_VOL_MASK;
390
424
                        twl6040_write(codec, TWL6040_REG_HFLGAIN,
391
425
                                                reg | (0x1D - val));
395
429
        } else if (handsfree->ramp == TWL6040_RAMP_DOWN) {
396
430
                /* ramp step down */
397
431
                if (val > 0) {
398
 
                        val -= left_step;
 
432
                        if ((int)val - (int)left_step < 0)
 
433
                                val = 0;
 
434
                        else
 
435
                                val -= left_step;
 
436
 
399
437
                        reg &= ~TWL6040_HF_VOL_MASK;
400
438
                        twl6040_write(codec, TWL6040_REG_HFLGAIN,
401
439
                                                reg | (0x1D - val));
412
450
        if (handsfree->ramp == TWL6040_RAMP_UP) {
413
451
                /* ramp step up */
414
452
                if (val < handsfree->right_vol) {
415
 
                        val += right_step;
 
453
                        if (val + right_step > handsfree->right_vol)
 
454
                                val = handsfree->right_vol;
 
455
                        else
 
456
                                val += right_step;
 
457
 
416
458
                        reg &= ~TWL6040_HF_VOL_MASK;
417
459
                        twl6040_write(codec, TWL6040_REG_HFRGAIN,
418
460
                                                reg | (0x1D - val));
422
464
        } else if (handsfree->ramp == TWL6040_RAMP_DOWN) {
423
465
                /* ramp step down */
424
466
                if (val > 0) {
425
 
                        val -= right_step;
 
467
                        if ((int)val - (int)right_step < 0)
 
468
                                val = 0;
 
469
                        else
 
470
                                val -= right_step;
 
471
 
426
472
                        reg &= ~TWL6040_HF_VOL_MASK;
427
473
                        twl6040_write(codec, TWL6040_REG_HFRGAIN,
428
474
                                                reg | (0x1D - val));
439
485
static void twl6040_pga_hs_work(struct work_struct *work)
440
486
{
441
487
        struct twl6040_data *priv =
442
 
                container_of(work, struct twl6040_data, hs_delayed_work.work);
 
488
                container_of(work, struct twl6040_data, headset.work.work);
443
489
        struct snd_soc_codec *codec = priv->codec;
444
490
        struct twl6040_output *headset = &priv->headset;
445
 
        unsigned int delay = headset->step_delay;
446
491
        int i, headset_complete;
447
492
 
448
493
        /* do we need to ramp at all ? */
449
494
        if (headset->ramp == TWL6040_RAMP_NONE)
450
495
                return;
451
496
 
452
 
        /* HS PGA volumes have 4 bits of resolution to ramp */
453
 
        for (i = 0; i <= 16; i++) {
454
 
                headset_complete = 1;
455
 
                if (headset->ramp != TWL6040_RAMP_NONE)
456
 
                        headset_complete = twl6040_hs_ramp_step(codec,
457
 
                                                        headset->left_step,
458
 
                                                        headset->right_step);
 
497
        /* HS PGA gain range: 0x0 - 0xf (0 - 15) */
 
498
        for (i = 0; i < 16; i++) {
 
499
                headset_complete = twl6040_hs_ramp_step(codec,
 
500
                                                headset->left_step,
 
501
                                                headset->right_step);
459
502
 
460
503
                /* ramp finished ? */
461
504
                if (headset_complete)
462
505
                        break;
463
506
 
464
 
                /*
465
 
                 * TODO: tune: delay is longer over 0dB
466
 
                 * as increases are larger.
467
 
                 */
468
 
                if (i >= 8)
469
 
                        schedule_timeout_interruptible(msecs_to_jiffies(delay +
470
 
                                                        (delay >> 1)));
471
 
                else
472
 
                        schedule_timeout_interruptible(msecs_to_jiffies(delay));
 
507
                schedule_timeout_interruptible(
 
508
                                msecs_to_jiffies(headset->step_delay));
473
509
        }
474
510
 
475
511
        if (headset->ramp == TWL6040_RAMP_DOWN) {
484
520
static void twl6040_pga_hf_work(struct work_struct *work)
485
521
{
486
522
        struct twl6040_data *priv =
487
 
                container_of(work, struct twl6040_data, hf_delayed_work.work);
 
523
                container_of(work, struct twl6040_data, handsfree.work.work);
488
524
        struct snd_soc_codec *codec = priv->codec;
489
525
        struct twl6040_output *handsfree = &priv->handsfree;
490
 
        unsigned int delay = handsfree->step_delay;
491
526
        int i, handsfree_complete;
492
527
 
493
528
        /* do we need to ramp at all ? */
494
529
        if (handsfree->ramp == TWL6040_RAMP_NONE)
495
530
                return;
496
531
 
497
 
        /* HF PGA volumes have 5 bits of resolution to ramp */
498
 
        for (i = 0; i <= 32; i++) {
499
 
                handsfree_complete = 1;
500
 
                if (handsfree->ramp != TWL6040_RAMP_NONE)
501
 
                        handsfree_complete = twl6040_hf_ramp_step(codec,
502
 
                                                        handsfree->left_step,
503
 
                                                        handsfree->right_step);
 
532
        /*
 
533
         * HF PGA gain range: 0x00 - 0x1d (0 - 29) */
 
534
        for (i = 0; i < 30; i++) {
 
535
                handsfree_complete = twl6040_hf_ramp_step(codec,
 
536
                                                handsfree->left_step,
 
537
                                                handsfree->right_step);
504
538
 
505
539
                /* ramp finished ? */
506
540
                if (handsfree_complete)
507
541
                        break;
508
542
 
509
 
                /*
510
 
                 * TODO: tune: delay is longer over 0dB
511
 
                 * as increases are larger.
512
 
                 */
513
 
                if (i >= 16)
514
 
                        schedule_timeout_interruptible(msecs_to_jiffies(delay +
515
 
                                                       (delay >> 1)));
516
 
                else
517
 
                        schedule_timeout_interruptible(msecs_to_jiffies(delay));
 
543
                schedule_timeout_interruptible(
 
544
                                msecs_to_jiffies(handsfree->step_delay));
518
545
        }
519
546
 
520
547
 
526
553
        handsfree->ramp = TWL6040_RAMP_NONE;
527
554
}
528
555
 
529
 
static int pga_event(struct snd_soc_dapm_widget *w,
 
556
static int out_drv_event(struct snd_soc_dapm_widget *w,
530
557
                        struct snd_kcontrol *kcontrol, int event)
531
558
{
532
559
        struct snd_soc_codec *codec = w->codec;
533
560
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
534
561
        struct twl6040_output *out;
535
562
        struct delayed_work *work;
536
 
        struct workqueue_struct *queue;
537
563
 
538
564
        switch (w->shift) {
539
 
        case 2:
540
 
        case 3:
 
565
        case 2: /* Headset output driver */
541
566
                out = &priv->headset;
542
 
                work = &priv->hs_delayed_work;
543
 
                queue = priv->hs_workqueue;
 
567
                work = &out->work;
 
568
                /*
 
569
                 * Make sure, that we do not mess up variables for already
 
570
                 * executing work.
 
571
                 */
 
572
                cancel_delayed_work_sync(work);
 
573
 
 
574
                out->left_step = priv->hs_left_step;
 
575
                out->right_step = priv->hs_right_step;
544
576
                out->step_delay = 5;    /* 5 ms between volume ramp steps */
545
577
                break;
546
 
        case 4:
 
578
        case 4: /* Handsfree output driver */
547
579
                out = &priv->handsfree;
548
 
                work = &priv->hf_delayed_work;
549
 
                queue = priv->hf_workqueue;
 
580
                work = &out->work;
 
581
                /*
 
582
                 * Make sure, that we do not mess up variables for already
 
583
                 * executing work.
 
584
                 */
 
585
                cancel_delayed_work_sync(work);
 
586
 
 
587
                out->left_step = priv->hf_left_step;
 
588
                out->right_step = priv->hf_right_step;
550
589
                out->step_delay = 5;    /* 5 ms between volume ramp steps */
551
 
                if (SND_SOC_DAPM_EVENT_ON(event))
552
 
                        priv->non_lp++;
553
 
                else
554
 
                        priv->non_lp--;
555
590
                break;
556
591
        default:
557
592
                return -1;
563
598
                        break;
564
599
 
565
600
                /* don't use volume ramp for power-up */
 
601
                out->ramp = TWL6040_RAMP_UP;
566
602
                out->left_step = out->left_vol;
567
603
                out->right_step = out->right_vol;
568
604
 
569
 
                if (!delayed_work_pending(work)) {
570
 
                        out->ramp = TWL6040_RAMP_UP;
571
 
                        queue_delayed_work(queue, work,
572
 
                                        msecs_to_jiffies(1));
573
 
                }
 
605
                queue_delayed_work(priv->workqueue, work, msecs_to_jiffies(1));
574
606
                break;
575
607
 
576
608
        case SND_SOC_DAPM_PRE_PMD:
577
609
                if (!out->active)
578
610
                        break;
579
611
 
580
 
                if (!delayed_work_pending(work)) {
581
 
                        /* use volume ramp for power-down */
582
 
                        out->left_step = 1;
583
 
                        out->right_step = 1;
584
 
                        out->ramp = TWL6040_RAMP_DOWN;
585
 
                        INIT_COMPLETION(out->ramp_done);
586
 
 
587
 
                        queue_delayed_work(queue, work,
588
 
                                        msecs_to_jiffies(1));
589
 
 
590
 
                        wait_for_completion_timeout(&out->ramp_done,
591
 
                                        msecs_to_jiffies(2000));
592
 
                }
 
612
                /* use volume ramp for power-down */
 
613
                out->ramp = TWL6040_RAMP_DOWN;
 
614
                INIT_COMPLETION(out->ramp_done);
 
615
 
 
616
                queue_delayed_work(priv->workqueue, work, msecs_to_jiffies(1));
 
617
 
 
618
                wait_for_completion_timeout(&out->ramp_done,
 
619
                                            msecs_to_jiffies(2000));
593
620
                break;
594
621
        }
595
622
 
596
623
        return 0;
597
624
}
598
625
 
599
 
/* twl6040 codec manual power-up sequence */
600
 
static void twl6040_power_up(struct snd_soc_codec *codec)
601
 
{
602
 
        u8 ncpctl, ldoctl, lppllctl, accctl;
603
 
 
604
 
        ncpctl = twl6040_read_reg_cache(codec, TWL6040_REG_NCPCTL);
605
 
        ldoctl = twl6040_read_reg_cache(codec, TWL6040_REG_LDOCTL);
606
 
        lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
607
 
        accctl = twl6040_read_reg_cache(codec, TWL6040_REG_ACCCTL);
608
 
 
609
 
        /* enable reference system */
610
 
        ldoctl |= TWL6040_REFENA;
611
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
612
 
        msleep(10);
613
 
        /* enable internal oscillator */
614
 
        ldoctl |= TWL6040_OSCENA;
615
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
616
 
        udelay(10);
617
 
        /* enable high-side ldo */
618
 
        ldoctl |= TWL6040_HSLDOENA;
619
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
620
 
        udelay(244);
621
 
        /* enable negative charge pump */
622
 
        ncpctl |= TWL6040_NCPENA | TWL6040_NCPOPEN;
623
 
        twl6040_write(codec, TWL6040_REG_NCPCTL, ncpctl);
624
 
        udelay(488);
625
 
        /* enable low-side ldo */
626
 
        ldoctl |= TWL6040_LSLDOENA;
627
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
628
 
        udelay(244);
629
 
        /* enable low-power pll */
630
 
        lppllctl |= TWL6040_LPLLENA;
631
 
        twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
632
 
        /* reset state machine */
633
 
        accctl |= TWL6040_RESETSPLIT;
634
 
        twl6040_write(codec, TWL6040_REG_ACCCTL, accctl);
635
 
        mdelay(5);
636
 
        accctl &= ~TWL6040_RESETSPLIT;
637
 
        twl6040_write(codec, TWL6040_REG_ACCCTL, accctl);
638
 
        /* disable internal oscillator */
639
 
        ldoctl &= ~TWL6040_OSCENA;
640
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
641
 
}
642
 
 
643
 
/* twl6040 codec manual power-down sequence */
644
 
static void twl6040_power_down(struct snd_soc_codec *codec)
645
 
{
646
 
        u8 ncpctl, ldoctl, lppllctl, accctl;
647
 
 
648
 
        ncpctl = twl6040_read_reg_cache(codec, TWL6040_REG_NCPCTL);
649
 
        ldoctl = twl6040_read_reg_cache(codec, TWL6040_REG_LDOCTL);
650
 
        lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
651
 
        accctl = twl6040_read_reg_cache(codec, TWL6040_REG_ACCCTL);
652
 
 
653
 
        /* enable internal oscillator */
654
 
        ldoctl |= TWL6040_OSCENA;
655
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
656
 
        udelay(10);
657
 
        /* disable low-power pll */
658
 
        lppllctl &= ~TWL6040_LPLLENA;
659
 
        twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
660
 
        /* disable low-side ldo */
661
 
        ldoctl &= ~TWL6040_LSLDOENA;
662
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
663
 
        udelay(244);
664
 
        /* disable negative charge pump */
665
 
        ncpctl &= ~(TWL6040_NCPENA | TWL6040_NCPOPEN);
666
 
        twl6040_write(codec, TWL6040_REG_NCPCTL, ncpctl);
667
 
        udelay(488);
668
 
        /* disable high-side ldo */
669
 
        ldoctl &= ~TWL6040_HSLDOENA;
670
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
671
 
        udelay(244);
672
 
        /* disable internal oscillator */
673
 
        ldoctl &= ~TWL6040_OSCENA;
674
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
675
 
        /* disable reference system */
676
 
        ldoctl &= ~TWL6040_REFENA;
677
 
        twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
678
 
        msleep(10);
679
 
}
680
 
 
681
626
/* set headset dac and driver power mode */
682
627
static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
683
628
{
684
629
        int hslctl, hsrctl;
685
 
        int mask = TWL6040_HSDRVMODEL | TWL6040_HSDACMODEL;
 
630
        int mask = TWL6040_HSDRVMODE | TWL6040_HSDACMODE;
686
631
 
687
632
        hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL);
688
633
        hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL);
704
649
static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
705
650
                        struct snd_kcontrol *kcontrol, int event)
706
651
{
 
652
        struct snd_soc_codec *codec = w->codec;
 
653
        u8 hslctl, hsrctl;
 
654
 
 
655
        /*
 
656
         * Workaround for Headset DC offset caused pop noise:
 
657
         * Both HS DAC need to be turned on (before the HS driver) and off at
 
658
         * the same time.
 
659
         */
 
660
        hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL);
 
661
        hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL);
 
662
        if (SND_SOC_DAPM_EVENT_ON(event)) {
 
663
                hslctl |= TWL6040_HSDACENA;
 
664
                hsrctl |= TWL6040_HSDACENA;
 
665
        } else {
 
666
                hslctl &= ~TWL6040_HSDACENA;
 
667
                hsrctl &= ~TWL6040_HSDACENA;
 
668
        }
 
669
        twl6040_write(codec, TWL6040_REG_HSLCTL, hslctl);
 
670
        twl6040_write(codec, TWL6040_REG_HSRCTL, hsrctl);
 
671
 
707
672
        msleep(1);
708
673
        return 0;
709
674
}
710
675
 
711
 
static int twl6040_power_mode_event(struct snd_soc_dapm_widget *w,
 
676
static int twl6040_ep_drv_event(struct snd_soc_dapm_widget *w,
712
677
                        struct snd_kcontrol *kcontrol, int event)
713
678
{
714
679
        struct snd_soc_codec *codec = w->codec;
715
680
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
681
        int ret = 0;
716
682
 
717
 
        if (SND_SOC_DAPM_EVENT_ON(event))
718
 
                priv->non_lp++;
719
 
        else
720
 
                priv->non_lp--;
 
683
        if (SND_SOC_DAPM_EVENT_ON(event)) {
 
684
                /* Earphone doesn't support low power mode */
 
685
                priv->hs_power_mode_locked = 1;
 
686
                ret = headset_power_mode(codec, 1);
 
687
        } else {
 
688
                priv->hs_power_mode_locked = 0;
 
689
                ret = headset_power_mode(codec, priv->hs_power_mode);
 
690
        }
721
691
 
722
692
        msleep(1);
723
693
 
724
 
        return 0;
 
694
        return ret;
725
695
}
726
696
 
727
697
static void twl6040_hs_jack_report(struct snd_soc_codec *codec,
758
728
static void twl6040_accessory_work(struct work_struct *work)
759
729
{
760
730
        struct twl6040_data *priv = container_of(work,
761
 
                                        struct twl6040_data, delayed_work.work);
 
731
                                        struct twl6040_data, hs_jack.work.work);
762
732
        struct snd_soc_codec *codec = priv->codec;
763
733
        struct twl6040_jack_data *hs_jack = &priv->hs_jack;
764
734
 
766
736
}
767
737
 
768
738
/* audio interrupt handler */
769
 
static irqreturn_t twl6040_naudint_handler(int irq, void *data)
 
739
static irqreturn_t twl6040_audio_handler(int irq, void *data)
770
740
{
771
741
        struct snd_soc_codec *codec = data;
772
742
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
773
 
        u8 intid;
774
 
 
775
 
        twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &intid, TWL6040_REG_INTID);
776
 
 
777
 
        if (intid & TWL6040_THINT)
778
 
                dev_alert(codec->dev, "die temp over-limit detection\n");
779
 
 
780
 
        if ((intid & TWL6040_PLUGINT) || (intid & TWL6040_UNPLUGINT))
781
 
                queue_delayed_work(priv->workqueue, &priv->delayed_work,
782
 
                                                        msecs_to_jiffies(200));
783
 
 
784
 
        if (intid & TWL6040_HOOKINT)
785
 
                dev_info(codec->dev, "hook detection\n");
786
 
 
787
 
        if (intid & TWL6040_HFINT)
788
 
                dev_alert(codec->dev, "hf drivers over current detection\n");
789
 
 
790
 
        if (intid & TWL6040_VIBINT)
791
 
                dev_alert(codec->dev, "vib drivers over current detection\n");
792
 
 
793
 
        if (intid & TWL6040_READYINT)
794
 
                complete(&priv->ready);
 
743
 
 
744
        queue_delayed_work(priv->workqueue, &priv->hs_jack.work,
 
745
                           msecs_to_jiffies(200));
795
746
 
796
747
        return IRQ_HANDLED;
797
748
}
805
756
        struct soc_mixer_control *mc =
806
757
                (struct soc_mixer_control *)kcontrol->private_value;
807
758
        int ret;
808
 
        unsigned int reg = mc->reg;
809
759
 
810
760
        /* For HS and HF we shadow the values and only actually write
811
761
         * them out when active in order to ensure the amplifier comes on
812
762
         * as quietly as possible. */
813
 
        switch (reg) {
 
763
        switch (mc->reg) {
814
764
        case TWL6040_REG_HSGAIN:
815
765
                out = &twl6040_priv->headset;
816
766
                break;
 
767
        case TWL6040_REG_HFLGAIN:
 
768
                out = &twl6040_priv->handsfree;
 
769
                break;
817
770
        default:
818
 
                break;
 
771
                dev_warn(codec->dev, "%s: Unexpected register: 0x%02x\n",
 
772
                                        __func__, mc->reg);
 
773
                return -EINVAL;
819
774
        }
820
775
 
821
 
        if (out) {
822
 
                out->left_vol = ucontrol->value.integer.value[0];
823
 
                out->right_vol = ucontrol->value.integer.value[1];
824
 
                if (!out->active)
825
 
                        return 1;
826
 
        }
 
776
        out->left_vol = ucontrol->value.integer.value[0];
 
777
        out->right_vol = ucontrol->value.integer.value[1];
 
778
        if (!out->active)
 
779
                return 1;
827
780
 
828
781
        ret = snd_soc_put_volsw(kcontrol, ucontrol);
829
782
        if (ret < 0)
840
793
        struct twl6040_output *out = &twl6040_priv->headset;
841
794
        struct soc_mixer_control *mc =
842
795
                (struct soc_mixer_control *)kcontrol->private_value;
843
 
        unsigned int reg = mc->reg;
844
796
 
845
 
        switch (reg) {
 
797
        switch (mc->reg) {
846
798
        case TWL6040_REG_HSGAIN:
847
799
                out = &twl6040_priv->headset;
848
 
                ucontrol->value.integer.value[0] = out->left_vol;
849
 
                ucontrol->value.integer.value[1] = out->right_vol;
850
 
                return 0;
851
 
 
852
 
        default:
853
 
                break;
854
 
        }
855
 
 
856
 
        return snd_soc_get_volsw(kcontrol, ucontrol);
857
 
}
858
 
 
859
 
static int twl6040_put_volsw_2r_vu(struct snd_kcontrol *kcontrol,
860
 
                                  struct snd_ctl_elem_value *ucontrol)
861
 
{
862
 
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
863
 
        struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec);
864
 
        struct twl6040_output *out = NULL;
865
 
        struct soc_mixer_control *mc =
866
 
                (struct soc_mixer_control *)kcontrol->private_value;
867
 
        int ret;
868
 
        unsigned int reg = mc->reg;
869
 
 
870
 
        /* For HS and HF we shadow the values and only actually write
871
 
         * them out when active in order to ensure the amplifier comes on
872
 
         * as quietly as possible. */
873
 
        switch (reg) {
874
 
        case TWL6040_REG_HFLGAIN:
875
 
        case TWL6040_REG_HFRGAIN:
876
 
                out = &twl6040_priv->handsfree;
877
 
                break;
878
 
        default:
879
 
                break;
880
 
        }
881
 
 
882
 
        if (out) {
883
 
                out->left_vol = ucontrol->value.integer.value[0];
884
 
                out->right_vol = ucontrol->value.integer.value[1];
885
 
                if (!out->active)
886
 
                        return 1;
887
 
        }
888
 
 
889
 
        ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
890
 
        if (ret < 0)
891
 
                return ret;
892
 
 
893
 
        return 1;
894
 
}
895
 
 
896
 
static int twl6040_get_volsw_2r(struct snd_kcontrol *kcontrol,
897
 
                                struct snd_ctl_elem_value *ucontrol)
898
 
{
899
 
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
900
 
        struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec);
901
 
        struct twl6040_output *out = &twl6040_priv->handsfree;
902
 
        struct soc_mixer_control *mc =
903
 
                (struct soc_mixer_control *)kcontrol->private_value;
904
 
        unsigned int reg = mc->reg;
905
 
 
906
 
        /* If these are cached registers use the cache */
907
 
        switch (reg) {
908
 
        case TWL6040_REG_HFLGAIN:
909
 
        case TWL6040_REG_HFRGAIN:
910
 
                out = &twl6040_priv->handsfree;
911
 
                ucontrol->value.integer.value[0] = out->left_vol;
912
 
                ucontrol->value.integer.value[1] = out->right_vol;
913
 
                return 0;
914
 
 
915
 
        default:
916
 
                break;
917
 
        }
918
 
 
919
 
        return snd_soc_get_volsw_2r(kcontrol, ucontrol);
920
 
}
921
 
 
922
 
/* double control with volume update */
923
 
#define SOC_TWL6040_DOUBLE_TLV(xname, xreg, shift_left, shift_right, xmax,\
924
 
                                                        xinvert, tlv_array)\
925
 
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
926
 
        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
927
 
                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
928
 
        .tlv.p = (tlv_array), \
929
 
        .info = snd_soc_info_volsw, .get = twl6040_get_volsw, \
930
 
        .put = twl6040_put_volsw, \
931
 
        .private_value = (unsigned long)&(struct soc_mixer_control) \
932
 
                {.reg = xreg, .shift = shift_left, .rshift = shift_right,\
933
 
                 .max = xmax, .platform_max = xmax, .invert = xinvert} }
934
 
 
935
 
/* double control with volume update */
936
 
#define SOC_TWL6040_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax,\
937
 
                                xinvert, tlv_array)\
938
 
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
939
 
        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
940
 
                SNDRV_CTL_ELEM_ACCESS_READWRITE | \
941
 
                SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
942
 
        .tlv.p = (tlv_array), \
943
 
        .info = snd_soc_info_volsw_2r, \
944
 
        .get = twl6040_get_volsw_2r, .put = twl6040_put_volsw_2r_vu, \
945
 
        .private_value = (unsigned long)&(struct soc_mixer_control) \
946
 
                {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
947
 
                 .rshift = xshift, .max = xmax, .invert = xinvert}, }
 
800
                break;
 
801
        case TWL6040_REG_HFLGAIN:
 
802
                out = &twl6040_priv->handsfree;
 
803
                break;
 
804
        default:
 
805
                dev_warn(codec->dev, "%s: Unexpected register: 0x%02x\n",
 
806
                                        __func__, mc->reg);
 
807
                return -EINVAL;
 
808
        }
 
809
 
 
810
        ucontrol->value.integer.value[0] = out->left_vol;
 
811
        ucontrol->value.integer.value[1] = out->right_vol;
 
812
        return 0;
 
813
}
 
814
 
 
815
static int twl6040_soc_dapm_put_vibra_enum(struct snd_kcontrol *kcontrol,
 
816
        struct snd_ctl_elem_value *ucontrol)
 
817
{
 
818
        struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
 
819
        struct snd_soc_dapm_widget *widget = wlist->widgets[0];
 
820
        struct snd_soc_codec *codec = widget->codec;
 
821
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 
822
        unsigned int val;
 
823
 
 
824
        /* Do not allow changes while Input/FF efect is running */
 
825
        val = twl6040_read_reg_volatile(codec, e->reg);
 
826
        if (val & TWL6040_VIBENA && !(val & TWL6040_VIBSEL))
 
827
                return -EBUSY;
 
828
 
 
829
        return snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
 
830
}
948
831
 
949
832
/*
950
833
 * MICATT volume control:
954
837
 
955
838
/*
956
839
 * MICGAIN volume control:
957
 
 * from -6 to 30 dB in 6 dB steps
 
840
 * from 6 to 30 dB in 6 dB steps
958
841
 */
959
 
static DECLARE_TLV_DB_SCALE(mic_amp_tlv, -600, 600, 0);
 
842
static DECLARE_TLV_DB_SCALE(mic_amp_tlv, 600, 600, 0);
960
843
 
961
844
/*
962
845
 * AFMGAIN volume control:
1017
900
                        twl6040_hf_texts),
1018
901
};
1019
902
 
 
903
static const char *twl6040_vibrapath_texts[] = {
 
904
        "Input FF", "Audio PDM"
 
905
};
 
906
 
 
907
static const struct soc_enum twl6040_vibra_enum[] = {
 
908
        SOC_ENUM_SINGLE(TWL6040_REG_VIBCTLL, 1,
 
909
                        ARRAY_SIZE(twl6040_vibrapath_texts),
 
910
                        twl6040_vibrapath_texts),
 
911
        SOC_ENUM_SINGLE(TWL6040_REG_VIBCTLR, 1,
 
912
                        ARRAY_SIZE(twl6040_vibrapath_texts),
 
913
                        twl6040_vibrapath_texts),
 
914
};
 
915
 
1020
916
static const struct snd_kcontrol_new amicl_control =
1021
917
        SOC_DAPM_ENUM("Route", twl6040_enum[0]);
1022
918
 
1037
933
static const struct snd_kcontrol_new hfr_mux_controls =
1038
934
        SOC_DAPM_ENUM("Route", twl6040_hf_enum[1]);
1039
935
 
1040
 
static const struct snd_kcontrol_new ep_driver_switch_controls =
1041
 
        SOC_DAPM_SINGLE("Switch", TWL6040_REG_EARCTL, 0, 1, 0);
 
936
static const struct snd_kcontrol_new ep_path_enable_control =
 
937
        SOC_DAPM_SINGLE("Switch", TWL6040_REG_SW_SHADOW, 0, 1, 0);
 
938
 
 
939
static const struct snd_kcontrol_new auxl_switch_control =
 
940
        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFLCTL, 6, 1, 0);
 
941
 
 
942
static const struct snd_kcontrol_new auxr_switch_control =
 
943
        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFRCTL, 6, 1, 0);
 
944
 
 
945
/* Vibra playback switches */
 
946
static const struct snd_kcontrol_new vibral_mux_controls =
 
947
        SOC_DAPM_ENUM_EXT("Route", twl6040_vibra_enum[0],
 
948
                snd_soc_dapm_get_enum_double,
 
949
                twl6040_soc_dapm_put_vibra_enum);
 
950
 
 
951
static const struct snd_kcontrol_new vibrar_mux_controls =
 
952
        SOC_DAPM_ENUM_EXT("Route", twl6040_vibra_enum[1],
 
953
                snd_soc_dapm_get_enum_double,
 
954
                twl6040_soc_dapm_put_vibra_enum);
 
955
 
 
956
/* Headset power mode */
 
957
static const char *twl6040_power_mode_texts[] = {
 
958
        "Low-Power", "High-Perfomance",
 
959
};
 
960
 
 
961
static const struct soc_enum twl6040_power_mode_enum =
 
962
        SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(twl6040_power_mode_texts),
 
963
                        twl6040_power_mode_texts);
 
964
 
 
965
static int twl6040_headset_power_get_enum(struct snd_kcontrol *kcontrol,
 
966
        struct snd_ctl_elem_value *ucontrol)
 
967
{
 
968
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 
969
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
970
 
 
971
        ucontrol->value.enumerated.item[0] = priv->hs_power_mode;
 
972
 
 
973
        return 0;
 
974
}
 
975
 
 
976
static int twl6040_headset_power_put_enum(struct snd_kcontrol *kcontrol,
 
977
        struct snd_ctl_elem_value *ucontrol)
 
978
{
 
979
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 
980
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
981
        int high_perf = ucontrol->value.enumerated.item[0];
 
982
        int ret = 0;
 
983
 
 
984
        if (!priv->hs_power_mode_locked)
 
985
                ret = headset_power_mode(codec, high_perf);
 
986
 
 
987
        if (!ret)
 
988
                priv->hs_power_mode = high_perf;
 
989
 
 
990
        return ret;
 
991
}
 
992
 
 
993
static int twl6040_pll_get_enum(struct snd_kcontrol *kcontrol,
 
994
        struct snd_ctl_elem_value *ucontrol)
 
995
{
 
996
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 
997
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
998
 
 
999
        ucontrol->value.enumerated.item[0] = priv->pll_power_mode;
 
1000
 
 
1001
        return 0;
 
1002
}
 
1003
 
 
1004
static int twl6040_pll_put_enum(struct snd_kcontrol *kcontrol,
 
1005
        struct snd_ctl_elem_value *ucontrol)
 
1006
{
 
1007
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 
1008
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
1009
 
 
1010
        priv->pll_power_mode = ucontrol->value.enumerated.item[0];
 
1011
 
 
1012
        return 0;
 
1013
}
 
1014
 
 
1015
int twl6040_get_clk_id(struct snd_soc_codec *codec)
 
1016
{
 
1017
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
1018
 
 
1019
        return priv->pll_power_mode;
 
1020
}
 
1021
EXPORT_SYMBOL_GPL(twl6040_get_clk_id);
 
1022
 
 
1023
int twl6040_get_trim_value(struct snd_soc_codec *codec, enum twl6040_trim trim)
 
1024
{
 
1025
        if (unlikely(trim >= TWL6040_TRIM_INVAL))
 
1026
                return -EINVAL;
 
1027
 
 
1028
        return twl6040_read_reg_cache(codec, TWL6040_REG_TRIM1 + trim);
 
1029
}
 
1030
EXPORT_SYMBOL_GPL(twl6040_get_trim_value);
1042
1031
 
1043
1032
static const struct snd_kcontrol_new twl6040_snd_controls[] = {
1044
1033
        /* Capture gains */
1052
1041
                TWL6040_REG_LINEGAIN, 0, 3, 7, 0, afm_amp_tlv),
1053
1042
 
1054
1043
        /* Playback gains */
1055
 
        SOC_TWL6040_DOUBLE_TLV("Headset Playback Volume",
1056
 
                TWL6040_REG_HSGAIN, 0, 4, 0xF, 1, hs_tlv),
1057
 
        SOC_TWL6040_DOUBLE_R_TLV("Handsfree Playback Volume",
1058
 
                TWL6040_REG_HFLGAIN, TWL6040_REG_HFRGAIN, 0, 0x1D, 1, hf_tlv),
 
1044
        SOC_DOUBLE_EXT_TLV("Headset Playback Volume",
 
1045
                TWL6040_REG_HSGAIN, 0, 4, 0xF, 1, twl6040_get_volsw,
 
1046
                twl6040_put_volsw, hs_tlv),
 
1047
        SOC_DOUBLE_R_EXT_TLV("Handsfree Playback Volume",
 
1048
                TWL6040_REG_HFLGAIN, TWL6040_REG_HFRGAIN, 0, 0x1D, 1,
 
1049
                twl6040_get_volsw, twl6040_put_volsw, hf_tlv),
1059
1050
        SOC_SINGLE_TLV("Earphone Playback Volume",
1060
1051
                TWL6040_REG_EARCTL, 1, 0xF, 1, ep_tlv),
 
1052
 
 
1053
        SOC_ENUM_EXT("Headset Power Mode", twl6040_power_mode_enum,
 
1054
                twl6040_headset_power_get_enum,
 
1055
                twl6040_headset_power_put_enum),
 
1056
 
 
1057
        SOC_ENUM_EXT("PLL Selection", twl6040_power_mode_enum,
 
1058
                twl6040_pll_get_enum, twl6040_pll_put_enum),
1061
1059
};
1062
1060
 
1063
1061
static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
1074
1072
        SND_SOC_DAPM_OUTPUT("HFL"),
1075
1073
        SND_SOC_DAPM_OUTPUT("HFR"),
1076
1074
        SND_SOC_DAPM_OUTPUT("EP"),
 
1075
        SND_SOC_DAPM_OUTPUT("AUXL"),
 
1076
        SND_SOC_DAPM_OUTPUT("AUXR"),
 
1077
        SND_SOC_DAPM_OUTPUT("VIBRAL"),
 
1078
        SND_SOC_DAPM_OUTPUT("VIBRAR"),
1077
1079
 
1078
1080
        /* Analog input muxes for the capture amplifiers */
1079
1081
        SND_SOC_DAPM_MUX("Analog Left Capture Route",
1110
1112
                        TWL6040_REG_DMICBCTL, 4, 0),
1111
1113
 
1112
1114
        /* DACs */
1113
 
        SND_SOC_DAPM_DAC_E("HSDAC Left", "Headset Playback",
1114
 
                        TWL6040_REG_HSLCTL, 0, 0,
1115
 
                        twl6040_hs_dac_event,
1116
 
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1117
 
        SND_SOC_DAPM_DAC_E("HSDAC Right", "Headset Playback",
1118
 
                        TWL6040_REG_HSRCTL, 0, 0,
1119
 
                        twl6040_hs_dac_event,
1120
 
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1121
 
        SND_SOC_DAPM_DAC_E("HFDAC Left", "Handsfree Playback",
1122
 
                        TWL6040_REG_HFLCTL, 0, 0,
1123
 
                        twl6040_power_mode_event,
1124
 
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1125
 
        SND_SOC_DAPM_DAC_E("HFDAC Right", "Handsfree Playback",
1126
 
                        TWL6040_REG_HFRCTL, 0, 0,
1127
 
                        twl6040_power_mode_event,
1128
 
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
1115
        SND_SOC_DAPM_DAC("HSDAC Left", "Headset Playback", SND_SOC_NOPM, 0, 0),
 
1116
        SND_SOC_DAPM_DAC("HSDAC Right", "Headset Playback", SND_SOC_NOPM, 0, 0),
 
1117
        SND_SOC_DAPM_DAC("HFDAC Left", "Handsfree Playback",
 
1118
                         TWL6040_REG_HFLCTL, 0, 0),
 
1119
        SND_SOC_DAPM_DAC("HFDAC Right", "Handsfree Playback",
 
1120
                         TWL6040_REG_HFRCTL, 0, 0),
 
1121
        /* Virtual DAC for vibra path (DL4 channel) */
 
1122
        SND_SOC_DAPM_DAC("VIBRA DAC", "Vibra Playback",
 
1123
                        SND_SOC_NOPM, 0, 0),
1129
1124
 
1130
 
        SND_SOC_DAPM_MUX("HF Left Playback",
 
1125
        SND_SOC_DAPM_MUX("Handsfree Left Playback",
1131
1126
                        SND_SOC_NOPM, 0, 0, &hfl_mux_controls),
1132
 
        SND_SOC_DAPM_MUX("HF Right Playback",
 
1127
        SND_SOC_DAPM_MUX("Handsfree Right Playback",
1133
1128
                        SND_SOC_NOPM, 0, 0, &hfr_mux_controls),
1134
1129
        /* Analog playback Muxes */
1135
 
        SND_SOC_DAPM_MUX("HS Left Playback",
 
1130
        SND_SOC_DAPM_MUX("Headset Left Playback",
1136
1131
                        SND_SOC_NOPM, 0, 0, &hsl_mux_controls),
1137
 
        SND_SOC_DAPM_MUX("HS Right Playback",
 
1132
        SND_SOC_DAPM_MUX("Headset Right Playback",
1138
1133
                        SND_SOC_NOPM, 0, 0, &hsr_mux_controls),
1139
1134
 
 
1135
        SND_SOC_DAPM_MUX("Vibra Left Playback", SND_SOC_NOPM, 0, 0,
 
1136
                        &vibral_mux_controls),
 
1137
        SND_SOC_DAPM_MUX("Vibra Right Playback", SND_SOC_NOPM, 0, 0,
 
1138
                        &vibrar_mux_controls),
 
1139
 
 
1140
        SND_SOC_DAPM_SWITCH("Earphone Playback", SND_SOC_NOPM, 0, 0,
 
1141
                        &ep_path_enable_control),
 
1142
        SND_SOC_DAPM_SWITCH("AUXL Playback", SND_SOC_NOPM, 0, 0,
 
1143
                        &auxl_switch_control),
 
1144
        SND_SOC_DAPM_SWITCH("AUXR Playback", SND_SOC_NOPM, 0, 0,
 
1145
                        &auxr_switch_control),
 
1146
 
1140
1147
        /* Analog playback drivers */
1141
 
        SND_SOC_DAPM_OUT_DRV_E("Handsfree Left Driver",
 
1148
        SND_SOC_DAPM_OUT_DRV_E("HF Left Driver",
1142
1149
                        TWL6040_REG_HFLCTL, 4, 0, NULL, 0,
1143
 
                        pga_event,
 
1150
                        out_drv_event,
1144
1151
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1145
 
        SND_SOC_DAPM_OUT_DRV_E("Handsfree Right Driver",
 
1152
        SND_SOC_DAPM_OUT_DRV_E("HF Right Driver",
1146
1153
                        TWL6040_REG_HFRCTL, 4, 0, NULL, 0,
1147
 
                        pga_event,
 
1154
                        out_drv_event,
1148
1155
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1149
 
        SND_SOC_DAPM_OUT_DRV_E("Headset Left Driver",
 
1156
        SND_SOC_DAPM_OUT_DRV_E("HS Left Driver",
1150
1157
                        TWL6040_REG_HSLCTL, 2, 0, NULL, 0,
1151
 
                        pga_event,
 
1158
                        out_drv_event,
1152
1159
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1153
 
        SND_SOC_DAPM_OUT_DRV_E("Headset Right Driver",
 
1160
        SND_SOC_DAPM_OUT_DRV_E("HS Right Driver",
1154
1161
                        TWL6040_REG_HSRCTL, 2, 0, NULL, 0,
1155
 
                        pga_event,
 
1162
                        out_drv_event,
1156
1163
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1157
 
        SND_SOC_DAPM_SWITCH_E("Earphone Driver",
1158
 
                        SND_SOC_NOPM, 0, 0, &ep_driver_switch_controls,
1159
 
                        twl6040_power_mode_event,
1160
 
                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
1164
        SND_SOC_DAPM_OUT_DRV_E("Earphone Driver",
 
1165
                        TWL6040_REG_EARCTL, 0, 0, NULL, 0,
 
1166
                        twl6040_ep_drv_event,
 
1167
                        SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
 
1168
        SND_SOC_DAPM_OUT_DRV("Vibra Left Driver",
 
1169
                        TWL6040_REG_VIBCTLL, 0, 0, NULL, 0),
 
1170
        SND_SOC_DAPM_OUT_DRV("Vibra Right Driver",
 
1171
                        TWL6040_REG_VIBCTLR, 0, 0, NULL, 0),
 
1172
 
 
1173
        SND_SOC_DAPM_SUPPLY("Vibra Left Control", TWL6040_REG_VIBCTLL, 2, 0,
 
1174
                            NULL, 0),
 
1175
        SND_SOC_DAPM_SUPPLY("Vibra Right Control", TWL6040_REG_VIBCTLR, 2, 0,
 
1176
                            NULL, 0),
 
1177
        SND_SOC_DAPM_SUPPLY_S("HSDAC Power", 1, SND_SOC_NOPM, 0, 0,
 
1178
                              twl6040_hs_dac_event,
 
1179
                              SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1161
1180
 
1162
1181
        /* Analog playback PGAs */
1163
 
        SND_SOC_DAPM_PGA("HFDAC Left PGA",
 
1182
        SND_SOC_DAPM_PGA("HF Left PGA",
1164
1183
                        TWL6040_REG_HFLCTL, 1, 0, NULL, 0),
1165
 
        SND_SOC_DAPM_PGA("HFDAC Right PGA",
 
1184
        SND_SOC_DAPM_PGA("HF Right PGA",
1166
1185
                        TWL6040_REG_HFRCTL, 1, 0, NULL, 0),
1167
1186
 
1168
1187
};
1184
1203
        {"ADC Right", NULL, "MicAmpR"},
1185
1204
 
1186
1205
        /* AFM path */
1187
 
        {"AFMAmpL", "NULL", "AFML"},
1188
 
        {"AFMAmpR", "NULL", "AFMR"},
1189
 
 
1190
 
        {"HS Left Playback", "HS DAC", "HSDAC Left"},
1191
 
        {"HS Left Playback", "Line-In amp", "AFMAmpL"},
1192
 
 
1193
 
        {"HS Right Playback", "HS DAC", "HSDAC Right"},
1194
 
        {"HS Right Playback", "Line-In amp", "AFMAmpR"},
1195
 
 
1196
 
        {"Headset Left Driver", "NULL", "HS Left Playback"},
1197
 
        {"Headset Right Driver", "NULL", "HS Right Playback"},
1198
 
 
1199
 
        {"HSOL", NULL, "Headset Left Driver"},
1200
 
        {"HSOR", NULL, "Headset Right Driver"},
 
1206
        {"AFMAmpL", NULL, "AFML"},
 
1207
        {"AFMAmpR", NULL, "AFMR"},
 
1208
 
 
1209
        {"HSDAC Left", NULL, "HSDAC Power"},
 
1210
        {"HSDAC Right", NULL, "HSDAC Power"},
 
1211
 
 
1212
        {"Headset Left Playback", "HS DAC", "HSDAC Left"},
 
1213
        {"Headset Left Playback", "Line-In amp", "AFMAmpL"},
 
1214
 
 
1215
        {"Headset Right Playback", "HS DAC", "HSDAC Right"},
 
1216
        {"Headset Right Playback", "Line-In amp", "AFMAmpR"},
 
1217
 
 
1218
        {"HS Left Driver", NULL, "Headset Left Playback"},
 
1219
        {"HS Right Driver", NULL, "Headset Right Playback"},
 
1220
 
 
1221
        {"HSOL", NULL, "HS Left Driver"},
 
1222
        {"HSOR", NULL, "HS Right Driver"},
1201
1223
 
1202
1224
        /* Earphone playback path */
1203
 
        {"Earphone Driver", "Switch", "HSDAC Left"},
 
1225
        {"Earphone Playback", "Switch", "HSDAC Left"},
 
1226
        {"Earphone Driver", NULL, "Earphone Playback"},
1204
1227
        {"EP", NULL, "Earphone Driver"},
1205
1228
 
1206
 
        {"HF Left Playback", "HF DAC", "HFDAC Left"},
1207
 
        {"HF Left Playback", "Line-In amp", "AFMAmpL"},
1208
 
 
1209
 
        {"HF Right Playback", "HF DAC", "HFDAC Right"},
1210
 
        {"HF Right Playback", "Line-In amp", "AFMAmpR"},
1211
 
 
1212
 
        {"HFDAC Left PGA", NULL, "HF Left Playback"},
1213
 
        {"HFDAC Right PGA", NULL, "HF Right Playback"},
1214
 
 
1215
 
        {"Handsfree Left Driver", "Switch", "HFDAC Left PGA"},
1216
 
        {"Handsfree Right Driver", "Switch", "HFDAC Right PGA"},
1217
 
 
1218
 
        {"HFL", NULL, "Handsfree Left Driver"},
1219
 
        {"HFR", NULL, "Handsfree Right Driver"},
 
1229
        {"Handsfree Left Playback", "HF DAC", "HFDAC Left"},
 
1230
        {"Handsfree Left Playback", "Line-In amp", "AFMAmpL"},
 
1231
 
 
1232
        {"Handsfree Right Playback", "HF DAC", "HFDAC Right"},
 
1233
        {"Handsfree Right Playback", "Line-In amp", "AFMAmpR"},
 
1234
 
 
1235
        {"HF Left PGA", NULL, "Handsfree Left Playback"},
 
1236
        {"HF Right PGA", NULL, "Handsfree Right Playback"},
 
1237
 
 
1238
        {"HF Left Driver", NULL, "HF Left PGA"},
 
1239
        {"HF Right Driver", NULL, "HF Right PGA"},
 
1240
 
 
1241
        {"HFL", NULL, "HF Left Driver"},
 
1242
        {"HFR", NULL, "HF Right Driver"},
 
1243
 
 
1244
        {"AUXL Playback", "Switch", "HF Left PGA"},
 
1245
        {"AUXR Playback", "Switch", "HF Right PGA"},
 
1246
 
 
1247
        {"AUXL", NULL, "AUXL Playback"},
 
1248
        {"AUXR", NULL, "AUXR Playback"},
 
1249
 
 
1250
        /* Vibrator paths */
 
1251
        {"Vibra Left Playback", "Audio PDM", "VIBRA DAC"},
 
1252
        {"Vibra Right Playback", "Audio PDM", "VIBRA DAC"},
 
1253
 
 
1254
        {"Vibra Left Driver", NULL, "Vibra Left Playback"},
 
1255
        {"Vibra Right Driver", NULL, "Vibra Right Playback"},
 
1256
        {"Vibra Left Driver", NULL, "Vibra Left Control"},
 
1257
        {"Vibra Right Driver", NULL, "Vibra Right Control"},
 
1258
 
 
1259
        {"VIBRAL", NULL, "Vibra Left Driver"},
 
1260
        {"VIBRAR", NULL, "Vibra Right Driver"},
1220
1261
};
1221
1262
 
1222
 
static int twl6040_add_widgets(struct snd_soc_codec *codec)
1223
 
{
1224
 
        struct snd_soc_dapm_context *dapm = &codec->dapm;
1225
 
 
1226
 
        snd_soc_dapm_new_controls(dapm, twl6040_dapm_widgets,
1227
 
                                 ARRAY_SIZE(twl6040_dapm_widgets));
1228
 
        snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon));
1229
 
        snd_soc_dapm_new_widgets(dapm);
1230
 
 
1231
 
        return 0;
1232
 
}
1233
 
 
1234
 
static int twl6040_power_up_completion(struct snd_soc_codec *codec,
1235
 
                                        int naudint)
1236
 
{
1237
 
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
1238
 
        int time_left;
1239
 
        u8 intid;
1240
 
 
1241
 
        time_left = wait_for_completion_timeout(&priv->ready,
1242
 
                                msecs_to_jiffies(144));
1243
 
 
1244
 
        if (!time_left) {
1245
 
                twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &intid,
1246
 
                                                        TWL6040_REG_INTID);
1247
 
                if (!(intid & TWL6040_READYINT)) {
1248
 
                        dev_err(codec->dev, "timeout waiting for READYINT\n");
1249
 
                        return -ETIMEDOUT;
1250
 
                }
1251
 
        }
1252
 
 
1253
 
        priv->codec_powered = 1;
1254
 
 
1255
 
        return 0;
1256
 
}
1257
 
 
1258
1263
static int twl6040_set_bias_level(struct snd_soc_codec *codec,
1259
1264
                                enum snd_soc_bias_level level)
1260
1265
{
 
1266
        struct twl6040 *twl6040 = codec->control_data;
1261
1267
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
1262
 
        int audpwron = priv->audpwron;
1263
 
        int naudint = priv->naudint;
1264
1268
        int ret;
1265
1269
 
1266
1270
        switch (level) {
1272
1276
                if (priv->codec_powered)
1273
1277
                        break;
1274
1278
 
1275
 
                if (gpio_is_valid(audpwron)) {
1276
 
                        /* use AUDPWRON line */
1277
 
                        gpio_set_value(audpwron, 1);
1278
 
 
1279
 
                        /* wait for power-up completion */
1280
 
                        ret = twl6040_power_up_completion(codec, naudint);
1281
 
                        if (ret)
1282
 
                                return ret;
1283
 
 
1284
 
                        /* sync registers updated during power-up sequence */
1285
 
                        twl6040_read_reg_volatile(codec, TWL6040_REG_NCPCTL);
1286
 
                        twl6040_read_reg_volatile(codec, TWL6040_REG_LDOCTL);
1287
 
                        twl6040_read_reg_volatile(codec, TWL6040_REG_LPPLLCTL);
1288
 
                } else {
1289
 
                        /* use manual power-up sequence */
1290
 
                        twl6040_power_up(codec);
1291
 
                        priv->codec_powered = 1;
1292
 
                }
1293
 
 
1294
 
                /* initialize vdd/vss registers with reg_cache */
1295
 
                twl6040_init_vdd_regs(codec);
 
1279
                ret = twl6040_power(twl6040, 1);
 
1280
                if (ret)
 
1281
                        return ret;
 
1282
 
 
1283
                priv->codec_powered = 1;
 
1284
 
 
1285
                twl6040_restore_regs(codec);
1296
1286
 
1297
1287
                /* Set external boost GPO */
1298
1288
                twl6040_write(codec, TWL6040_REG_GPOCTL, 0x02);
1299
 
 
1300
 
                /* Set initial minimal gain values */
1301
 
                twl6040_write(codec, TWL6040_REG_HSGAIN, 0xFF);
1302
 
                twl6040_write(codec, TWL6040_REG_EARCTL, 0x1E);
1303
 
                twl6040_write(codec, TWL6040_REG_HFLGAIN, 0x1D);
1304
 
                twl6040_write(codec, TWL6040_REG_HFRGAIN, 0x1D);
1305
1289
                break;
1306
1290
        case SND_SOC_BIAS_OFF:
1307
1291
                if (!priv->codec_powered)
1308
1292
                        break;
1309
1293
 
1310
 
                if (gpio_is_valid(audpwron)) {
1311
 
                        /* use AUDPWRON line */
1312
 
                        gpio_set_value(audpwron, 0);
1313
 
 
1314
 
                        /* power-down sequence latency */
1315
 
                        udelay(500);
1316
 
 
1317
 
                        /* sync registers updated during power-down sequence */
1318
 
                        twl6040_read_reg_volatile(codec, TWL6040_REG_NCPCTL);
1319
 
                        twl6040_read_reg_volatile(codec, TWL6040_REG_LDOCTL);
1320
 
                        twl6040_write_reg_cache(codec, TWL6040_REG_LPPLLCTL,
1321
 
                                                0x00);
1322
 
                } else {
1323
 
                        /* use manual power-down sequence */
1324
 
                        twl6040_power_down(codec);
1325
 
                }
1326
 
 
 
1294
                twl6040_power(twl6040, 0);
1327
1295
                priv->codec_powered = 0;
1328
1296
                break;
1329
1297
        }
1333
1301
        return 0;
1334
1302
}
1335
1303
 
1336
 
/* set of rates for each pll: low-power and high-performance */
1337
 
 
1338
 
static unsigned int lp_rates[] = {
1339
 
        88200,
1340
 
        96000,
1341
 
};
1342
 
 
1343
 
static struct snd_pcm_hw_constraint_list lp_constraints = {
1344
 
        .count  = ARRAY_SIZE(lp_rates),
1345
 
        .list   = lp_rates,
1346
 
};
1347
 
 
1348
 
static unsigned int hp_rates[] = {
1349
 
        96000,
1350
 
};
1351
 
 
1352
 
static struct snd_pcm_hw_constraint_list hp_constraints = {
1353
 
        .count  = ARRAY_SIZE(hp_rates),
1354
 
        .list   = hp_rates,
1355
 
};
1356
 
 
1357
1304
static int twl6040_startup(struct snd_pcm_substream *substream,
1358
1305
                        struct snd_soc_dai *dai)
1359
1306
{
1363
1310
 
1364
1311
        snd_pcm_hw_constraint_list(substream->runtime, 0,
1365
1312
                                SNDRV_PCM_HW_PARAM_RATE,
1366
 
                                priv->sysclk_constraints);
 
1313
                                &sysclk_constraints[priv->pll_power_mode]);
1367
1314
 
1368
1315
        return 0;
1369
1316
}
1375
1322
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
1376
1323
        struct snd_soc_codec *codec = rtd->codec;
1377
1324
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
1378
 
        u8 lppllctl;
1379
1325
        int rate;
1380
1326
 
1381
 
        /* nothing to do for high-perf pll, it supports only 48 kHz */
1382
 
        if (priv->pll == TWL6040_HPPLL_ID)
1383
 
                return 0;
1384
 
 
1385
 
        lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
1386
 
 
1387
1327
        rate = params_rate(params);
1388
1328
        switch (rate) {
1389
1329
        case 11250:
1390
1330
        case 22500:
1391
1331
        case 44100:
1392
1332
        case 88200:
1393
 
                lppllctl |= TWL6040_LPLLFIN;
 
1333
                /* These rates are not supported when HPPLL is in use */
 
1334
                if (unlikely(priv->pll == TWL6040_SYSCLK_SEL_HPPLL)) {
 
1335
                        dev_err(codec->dev, "HPPLL does not support rate %d\n",
 
1336
                                rate);
 
1337
                        return -EINVAL;
 
1338
                }
1394
1339
                priv->sysclk = 17640000;
1395
1340
                break;
1396
1341
        case 8000:
1398
1343
        case 32000:
1399
1344
        case 48000:
1400
1345
        case 96000:
1401
 
                lppllctl &= ~TWL6040_LPLLFIN;
1402
1346
                priv->sysclk = 19200000;
1403
1347
                break;
1404
1348
        default:
1406
1350
                return -EINVAL;
1407
1351
        }
1408
1352
 
1409
 
        twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
1410
 
 
1411
1353
        return 0;
1412
1354
}
1413
1355
 
1416
1358
{
1417
1359
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
1418
1360
        struct snd_soc_codec *codec = rtd->codec;
 
1361
        struct twl6040 *twl6040 = codec->control_data;
1419
1362
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
1363
        int ret;
1420
1364
 
1421
1365
        if (!priv->sysclk) {
1422
1366
                dev_err(codec->dev,
1424
1368
                return -EINVAL;
1425
1369
        }
1426
1370
 
1427
 
        /*
1428
 
         * capture is not supported at 17.64 MHz,
1429
 
         * it's reserved for headset low-power playback scenario
1430
 
         */
1431
 
        if ((priv->sysclk == 17640000) &&
1432
 
                        substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
1433
 
                dev_err(codec->dev,
1434
 
                        "capture mode is not supported at %dHz\n",
1435
 
                        priv->sysclk);
1436
 
                return -EINVAL;
 
1371
        ret = twl6040_set_pll(twl6040, priv->pll, priv->clk_in, priv->sysclk);
 
1372
        if (ret) {
 
1373
                dev_err(codec->dev, "Can not set PLL (%d)\n", ret);
 
1374
                return -EPERM;
1437
1375
        }
1438
1376
 
1439
 
        if ((priv->sysclk == 17640000) && priv->non_lp) {
1440
 
                        dev_err(codec->dev,
1441
 
                                "some enabled paths aren't supported at %dHz\n",
1442
 
                                priv->sysclk);
1443
 
                        return -EPERM;
1444
 
        }
1445
1377
        return 0;
1446
1378
}
1447
1379
 
1450
1382
{
1451
1383
        struct snd_soc_codec *codec = codec_dai->codec;
1452
1384
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
1453
 
        u8 hppllctl, lppllctl;
1454
 
 
1455
 
        hppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_HPPLLCTL);
1456
 
        lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
1457
1385
 
1458
1386
        switch (clk_id) {
1459
1387
        case TWL6040_SYSCLK_SEL_LPPLL:
1460
 
                switch (freq) {
1461
 
                case 32768:
1462
 
                        /* headset dac and driver must be in low-power mode */
1463
 
                        headset_power_mode(codec, 0);
1464
 
 
1465
 
                        /* clk32k input requires low-power pll */
1466
 
                        lppllctl |= TWL6040_LPLLENA;
1467
 
                        twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
1468
 
                        mdelay(5);
1469
 
                        lppllctl &= ~TWL6040_HPLLSEL;
1470
 
                        twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
1471
 
                        hppllctl &= ~TWL6040_HPLLENA;
1472
 
                        twl6040_write(codec, TWL6040_REG_HPPLLCTL, hppllctl);
1473
 
                        break;
1474
 
                default:
1475
 
                        dev_err(codec->dev, "unknown mclk freq %d\n", freq);
1476
 
                        return -EINVAL;
1477
 
                }
1478
 
 
1479
 
                /* lppll divider */
1480
 
                switch (priv->sysclk) {
1481
 
                case 17640000:
1482
 
                        lppllctl |= TWL6040_LPLLFIN;
1483
 
                        break;
1484
 
                case 19200000:
1485
 
                        lppllctl &= ~TWL6040_LPLLFIN;
1486
 
                        break;
1487
 
                default:
1488
 
                        /* sysclk not yet configured */
1489
 
                        lppllctl &= ~TWL6040_LPLLFIN;
1490
 
                        priv->sysclk = 19200000;
1491
 
                        break;
1492
 
                }
1493
 
 
1494
 
                twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
1495
 
 
1496
 
                priv->pll = TWL6040_LPPLL_ID;
1497
 
                priv->sysclk_constraints = &lp_constraints;
1498
 
                break;
1499
1388
        case TWL6040_SYSCLK_SEL_HPPLL:
1500
 
                hppllctl &= ~TWL6040_MCLK_MSK;
1501
 
 
1502
 
                switch (freq) {
1503
 
                case 12000000:
1504
 
                        /* mclk input, pll enabled */
1505
 
                        hppllctl |= TWL6040_MCLK_12000KHZ |
1506
 
                                    TWL6040_HPLLSQRBP |
1507
 
                                    TWL6040_HPLLENA;
1508
 
                        break;
1509
 
                case 19200000:
1510
 
                        /* mclk input, pll disabled */
1511
 
                        hppllctl |= TWL6040_MCLK_19200KHZ |
1512
 
                                    TWL6040_HPLLSQRENA |
1513
 
                                    TWL6040_HPLLBP;
1514
 
                        break;
1515
 
                case 26000000:
1516
 
                        /* mclk input, pll enabled */
1517
 
                        hppllctl |= TWL6040_MCLK_26000KHZ |
1518
 
                                    TWL6040_HPLLSQRBP |
1519
 
                                    TWL6040_HPLLENA;
1520
 
                        break;
1521
 
                case 38400000:
1522
 
                        /* clk slicer, pll disabled */
1523
 
                        hppllctl |= TWL6040_MCLK_38400KHZ |
1524
 
                                    TWL6040_HPLLSQRENA |
1525
 
                                    TWL6040_HPLLBP;
1526
 
                        break;
1527
 
                default:
1528
 
                        dev_err(codec->dev, "unknown mclk freq %d\n", freq);
1529
 
                        return -EINVAL;
1530
 
                }
1531
 
 
1532
 
                /* headset dac and driver must be in high-performance mode */
1533
 
                headset_power_mode(codec, 1);
1534
 
 
1535
 
                twl6040_write(codec, TWL6040_REG_HPPLLCTL, hppllctl);
1536
 
                udelay(500);
1537
 
                lppllctl |= TWL6040_HPLLSEL;
1538
 
                twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
1539
 
                lppllctl &= ~TWL6040_LPLLENA;
1540
 
                twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
1541
 
 
1542
 
                /* high-performance pll can provide only 19.2 MHz */
1543
 
                priv->pll = TWL6040_HPPLL_ID;
1544
 
                priv->sysclk = 19200000;
1545
 
                priv->sysclk_constraints = &hp_constraints;
 
1389
                priv->pll = clk_id;
 
1390
                priv->clk_in = freq;
1546
1391
                break;
1547
1392
        default:
1548
1393
                dev_err(codec->dev, "unknown clk_id %d\n", clk_id);
1559
1404
        .set_sysclk     = twl6040_set_dai_sysclk,
1560
1405
};
1561
1406
 
1562
 
static struct snd_soc_dai_driver twl6040_dai = {
1563
 
        .name = "twl6040-hifi",
 
1407
static struct snd_soc_dai_driver twl6040_dai[] = {
 
1408
{
 
1409
        .name = "twl6040-legacy",
1564
1410
        .playback = {
1565
1411
                .stream_name = "Playback",
1566
1412
                .channels_min = 1,
1567
 
                .channels_max = 4,
1568
 
                .rates = TWL6040_RATES,
1569
 
                .formats = TWL6040_FORMATS,
1570
 
        },
1571
 
        .capture = {
1572
 
                .stream_name = "Capture",
1573
 
                .channels_min = 1,
1574
 
                .channels_max = 2,
1575
 
                .rates = TWL6040_RATES,
1576
 
                .formats = TWL6040_FORMATS,
1577
 
        },
1578
 
        .ops = &twl6040_dai_ops,
 
1413
                .channels_max = 5,
 
1414
                .rates = TWL6040_RATES,
 
1415
                .formats = TWL6040_FORMATS,
 
1416
        },
 
1417
        .capture = {
 
1418
                .stream_name = "Capture",
 
1419
                .channels_min = 1,
 
1420
                .channels_max = 2,
 
1421
                .rates = TWL6040_RATES,
 
1422
                .formats = TWL6040_FORMATS,
 
1423
        },
 
1424
        .ops = &twl6040_dai_ops,
 
1425
},
 
1426
{
 
1427
        .name = "twl6040-ul",
 
1428
        .capture = {
 
1429
                .stream_name = "Capture",
 
1430
                .channels_min = 1,
 
1431
                .channels_max = 2,
 
1432
                .rates = TWL6040_RATES,
 
1433
                .formats = TWL6040_FORMATS,
 
1434
        },
 
1435
        .ops = &twl6040_dai_ops,
 
1436
},
 
1437
{
 
1438
        .name = "twl6040-dl1",
 
1439
        .playback = {
 
1440
                .stream_name = "Headset Playback",
 
1441
                .channels_min = 1,
 
1442
                .channels_max = 2,
 
1443
                .rates = TWL6040_RATES,
 
1444
                .formats = TWL6040_FORMATS,
 
1445
        },
 
1446
        .ops = &twl6040_dai_ops,
 
1447
},
 
1448
{
 
1449
        .name = "twl6040-dl2",
 
1450
        .playback = {
 
1451
                .stream_name = "Handsfree Playback",
 
1452
                .channels_min = 1,
 
1453
                .channels_max = 2,
 
1454
                .rates = TWL6040_RATES,
 
1455
                .formats = TWL6040_FORMATS,
 
1456
        },
 
1457
        .ops = &twl6040_dai_ops,
 
1458
},
 
1459
{
 
1460
        .name = "twl6040-vib",
 
1461
        .playback = {
 
1462
                .stream_name = "Vibra Playback",
 
1463
                .channels_min = 1,
 
1464
                .channels_max = 1,
 
1465
                .rates = SNDRV_PCM_RATE_CONTINUOUS,
 
1466
                .formats = TWL6040_FORMATS,
 
1467
        },
 
1468
        .ops = &twl6040_dai_ops,
 
1469
},
1579
1470
};
1580
1471
 
1581
1472
#ifdef CONFIG_PM
1600
1491
 
1601
1492
static int twl6040_probe(struct snd_soc_codec *codec)
1602
1493
{
1603
 
        struct twl4030_codec_data *twl_codec = codec->dev->platform_data;
1604
1494
        struct twl6040_data *priv;
1605
 
        int audpwron, naudint;
 
1495
        struct twl4030_codec_data *pdata = dev_get_platdata(codec->dev);
 
1496
        struct platform_device *pdev = container_of(codec->dev,
 
1497
                                                   struct platform_device, dev);
1606
1498
        int ret = 0;
1607
 
        u8 icrev, intmr = TWL6040_ALLINT_MSK;
1608
1499
 
1609
1500
        priv = kzalloc(sizeof(struct twl6040_data), GFP_KERNEL);
1610
1501
        if (priv == NULL)
1612
1503
        snd_soc_codec_set_drvdata(codec, priv);
1613
1504
 
1614
1505
        priv->codec = codec;
1615
 
 
1616
 
        twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &icrev, TWL6040_REG_ASICREV);
1617
 
 
1618
 
        if (twl_codec && (icrev > 0))
1619
 
                audpwron = twl_codec->audpwron_gpio;
1620
 
        else
1621
 
                audpwron = -EINVAL;
1622
 
 
1623
 
        if (twl_codec)
1624
 
                naudint = twl_codec->naudint_irq;
1625
 
        else
1626
 
                naudint = 0;
1627
 
 
1628
 
        priv->audpwron = audpwron;
1629
 
        priv->naudint = naudint;
1630
 
        priv->workqueue = create_singlethread_workqueue("twl6040-codec");
1631
 
 
 
1506
        codec->control_data = dev_get_drvdata(codec->dev->parent);
 
1507
        codec->ignore_pmdown_time = 1;
 
1508
 
 
1509
        if (pdata && pdata->hs_left_step && pdata->hs_right_step) {
 
1510
                priv->hs_left_step = pdata->hs_left_step;
 
1511
                priv->hs_right_step = pdata->hs_right_step;
 
1512
        } else {
 
1513
                priv->hs_left_step = 1;
 
1514
                priv->hs_right_step = 1;
 
1515
        }
 
1516
 
 
1517
        if (pdata && pdata->hf_left_step && pdata->hf_right_step) {
 
1518
                priv->hf_left_step = pdata->hf_left_step;
 
1519
                priv->hf_right_step = pdata->hf_right_step;
 
1520
        } else {
 
1521
                priv->hf_left_step = 1;
 
1522
                priv->hf_right_step = 1;
 
1523
        }
 
1524
 
 
1525
        priv->plug_irq = platform_get_irq(pdev, 0);
 
1526
        if (priv->plug_irq < 0) {
 
1527
                dev_err(codec->dev, "invalid irq\n");
 
1528
                ret = -EINVAL;
 
1529
                goto work_err;
 
1530
        }
 
1531
 
 
1532
        priv->workqueue = alloc_workqueue("twl6040-codec", 0, 0);
1632
1533
        if (!priv->workqueue) {
1633
1534
                ret = -ENOMEM;
1634
1535
                goto work_err;
1635
1536
        }
1636
1537
 
1637
 
        INIT_DELAYED_WORK(&priv->delayed_work, twl6040_accessory_work);
 
1538
        INIT_DELAYED_WORK(&priv->hs_jack.work, twl6040_accessory_work);
 
1539
        INIT_DELAYED_WORK(&priv->headset.work, twl6040_pga_hs_work);
 
1540
        INIT_DELAYED_WORK(&priv->handsfree.work, twl6040_pga_hf_work);
1638
1541
 
1639
1542
        mutex_init(&priv->mutex);
1640
1543
 
1641
 
        init_completion(&priv->ready);
1642
1544
        init_completion(&priv->headset.ramp_done);
1643
1545
        init_completion(&priv->handsfree.ramp_done);
1644
1546
 
1645
 
        if (gpio_is_valid(audpwron)) {
1646
 
                ret = gpio_request(audpwron, "audpwron");
1647
 
                if (ret)
1648
 
                        goto gpio1_err;
1649
 
 
1650
 
                ret = gpio_direction_output(audpwron, 0);
1651
 
                if (ret)
1652
 
                        goto gpio2_err;
1653
 
 
1654
 
                priv->codec_powered = 0;
1655
 
 
1656
 
                /* enable only codec ready interrupt */
1657
 
                intmr &= ~(TWL6040_READYMSK | TWL6040_PLUGMSK);
1658
 
 
1659
 
                /* reset interrupt status to allow correct power up sequence */
1660
 
                twl6040_read_reg_volatile(codec, TWL6040_REG_INTID);
1661
 
        }
1662
 
        twl6040_write(codec, TWL6040_REG_INTMR, intmr);
1663
 
 
1664
 
        if (naudint) {
1665
 
                /* audio interrupt */
1666
 
                ret = request_threaded_irq(naudint, NULL,
1667
 
                                twl6040_naudint_handler,
1668
 
                                IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1669
 
                                "twl6040_codec", codec);
1670
 
                if (ret)
1671
 
                        goto gpio2_err;
1672
 
        }
1673
 
 
1674
 
        /* init vio registers */
1675
 
        twl6040_init_vio_regs(codec);
1676
 
 
1677
 
        priv->hf_workqueue = create_singlethread_workqueue("twl6040-hf");
1678
 
        if (priv->hf_workqueue == NULL) {
1679
 
                ret = -ENOMEM;
1680
 
                goto irq_err;
1681
 
        }
1682
 
        priv->hs_workqueue = create_singlethread_workqueue("twl6040-hs");
1683
 
        if (priv->hs_workqueue == NULL) {
1684
 
                ret = -ENOMEM;
1685
 
                goto wq_err;
1686
 
        }
1687
 
 
1688
 
        INIT_DELAYED_WORK(&priv->hs_delayed_work, twl6040_pga_hs_work);
1689
 
        INIT_DELAYED_WORK(&priv->hf_delayed_work, twl6040_pga_hf_work);
 
1547
        ret = request_threaded_irq(priv->plug_irq, NULL, twl6040_audio_handler,
 
1548
                                   0, "twl6040_irq_plug", codec);
 
1549
        if (ret) {
 
1550
                dev_err(codec->dev, "PLUG IRQ request failed: %d\n", ret);
 
1551
                goto plugirq_err;
 
1552
        }
 
1553
 
 
1554
        twl6040_init_chip(codec);
1690
1555
 
1691
1556
        /* power on device */
1692
1557
        ret = twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1693
 
        if (ret)
1694
 
                goto bias_err;
1695
 
 
1696
 
        snd_soc_add_controls(codec, twl6040_snd_controls,
1697
 
                                ARRAY_SIZE(twl6040_snd_controls));
1698
 
        twl6040_add_widgets(codec);
1699
 
 
1700
 
        return 0;
1701
 
 
1702
 
bias_err:
1703
 
        destroy_workqueue(priv->hs_workqueue);
1704
 
wq_err:
1705
 
        destroy_workqueue(priv->hf_workqueue);
1706
 
irq_err:
1707
 
        if (naudint)
1708
 
                free_irq(naudint, codec);
1709
 
gpio2_err:
1710
 
        if (gpio_is_valid(audpwron))
1711
 
                gpio_free(audpwron);
1712
 
gpio1_err:
 
1558
        if (!ret)
 
1559
                return 0;
 
1560
 
 
1561
        /* Error path */
 
1562
        free_irq(priv->plug_irq, codec);
 
1563
plugirq_err:
1713
1564
        destroy_workqueue(priv->workqueue);
1714
1565
work_err:
1715
1566
        kfree(priv);
1719
1570
static int twl6040_remove(struct snd_soc_codec *codec)
1720
1571
{
1721
1572
        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
1722
 
        int audpwron = priv->audpwron;
1723
 
        int naudint = priv->naudint;
1724
1573
 
1725
1574
        twl6040_set_bias_level(codec, SND_SOC_BIAS_OFF);
1726
 
 
1727
 
        if (gpio_is_valid(audpwron))
1728
 
                gpio_free(audpwron);
1729
 
 
1730
 
        if (naudint)
1731
 
                free_irq(naudint, codec);
1732
 
 
 
1575
        free_irq(priv->plug_irq, codec);
1733
1576
        destroy_workqueue(priv->workqueue);
1734
 
        destroy_workqueue(priv->hf_workqueue);
1735
 
        destroy_workqueue(priv->hs_workqueue);
1736
1577
        kfree(priv);
1737
1578
 
1738
1579
        return 0;
1749
1590
        .reg_cache_size = ARRAY_SIZE(twl6040_reg),
1750
1591
        .reg_word_size = sizeof(u8),
1751
1592
        .reg_cache_default = twl6040_reg,
 
1593
 
 
1594
        .controls = twl6040_snd_controls,
 
1595
        .num_controls = ARRAY_SIZE(twl6040_snd_controls),
 
1596
        .dapm_widgets = twl6040_dapm_widgets,
 
1597
        .num_dapm_widgets = ARRAY_SIZE(twl6040_dapm_widgets),
 
1598
        .dapm_routes = intercon,
 
1599
        .num_dapm_routes = ARRAY_SIZE(intercon),
1752
1600
};
1753
1601
 
1754
1602
static int __devinit twl6040_codec_probe(struct platform_device *pdev)
1755
1603
{
1756
 
        return snd_soc_register_codec(&pdev->dev,
1757
 
                        &soc_codec_dev_twl6040, &twl6040_dai, 1);
 
1604
        return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_twl6040,
 
1605
                                      twl6040_dai, ARRAY_SIZE(twl6040_dai));
1758
1606
}
1759
1607
 
1760
1608
static int __devexit twl6040_codec_remove(struct platform_device *pdev)