Merge tag 'powerpc-5.2-1' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/power...
[sfrench/cifs-2.6.git] / sound / hda / hdac_regmap.c
1 /*
2  * Regmap support for HD-audio verbs
3  *
4  * A virtual register is translated to one or more hda verbs for write,
5  * vice versa for read.
6  *
7  * A few limitations:
8  * - Provided for not all verbs but only subset standard non-volatile verbs.
9  * - For reading, only AC_VERB_GET_* variants can be used.
10  * - For writing, mapped to the *corresponding* AC_VERB_SET_* variants,
11  *   so can't handle asymmetric verbs for read and write
12  */
13
14 #include <linux/slab.h>
15 #include <linux/device.h>
16 #include <linux/regmap.h>
17 #include <linux/export.h>
18 #include <linux/pm.h>
19 #include <linux/pm_runtime.h>
20 #include <sound/core.h>
21 #include <sound/hdaudio.h>
22 #include <sound/hda_regmap.h>
23
24 static int codec_pm_lock(struct hdac_device *codec)
25 {
26         return snd_hdac_keep_power_up(codec);
27 }
28
29 static void codec_pm_unlock(struct hdac_device *codec, int lock)
30 {
31         if (lock == 1)
32                 snd_hdac_power_down_pm(codec);
33 }
34
35 #define get_verb(reg)   (((reg) >> 8) & 0xfff)
36
37 static bool hda_volatile_reg(struct device *dev, unsigned int reg)
38 {
39         struct hdac_device *codec = dev_to_hdac_dev(dev);
40         unsigned int verb = get_verb(reg);
41
42         switch (verb) {
43         case AC_VERB_GET_PROC_COEF:
44                 return !codec->cache_coef;
45         case AC_VERB_GET_COEF_INDEX:
46         case AC_VERB_GET_PROC_STATE:
47         case AC_VERB_GET_POWER_STATE:
48         case AC_VERB_GET_PIN_SENSE:
49         case AC_VERB_GET_HDMI_DIP_SIZE:
50         case AC_VERB_GET_HDMI_ELDD:
51         case AC_VERB_GET_HDMI_DIP_INDEX:
52         case AC_VERB_GET_HDMI_DIP_DATA:
53         case AC_VERB_GET_HDMI_DIP_XMIT:
54         case AC_VERB_GET_HDMI_CP_CTRL:
55         case AC_VERB_GET_HDMI_CHAN_SLOT:
56         case AC_VERB_GET_DEVICE_SEL:
57         case AC_VERB_GET_DEVICE_LIST:   /* read-only volatile */
58                 return true;
59         }
60
61         return false;
62 }
63
64 static bool hda_writeable_reg(struct device *dev, unsigned int reg)
65 {
66         struct hdac_device *codec = dev_to_hdac_dev(dev);
67         unsigned int verb = get_verb(reg);
68         const unsigned int *v;
69         int i;
70
71         snd_array_for_each(&codec->vendor_verbs, i, v) {
72                 if (verb == *v)
73                         return true;
74         }
75
76         if (codec->caps_overwriting)
77                 return true;
78
79         switch (verb & 0xf00) {
80         case AC_VERB_GET_STREAM_FORMAT:
81         case AC_VERB_GET_AMP_GAIN_MUTE:
82                 return true;
83         case AC_VERB_GET_PROC_COEF:
84                 return codec->cache_coef;
85         case 0xf00:
86                 break;
87         default:
88                 return false;
89         }
90
91         switch (verb) {
92         case AC_VERB_GET_CONNECT_SEL:
93         case AC_VERB_GET_SDI_SELECT:
94         case AC_VERB_GET_PIN_WIDGET_CONTROL:
95         case AC_VERB_GET_UNSOLICITED_RESPONSE: /* only as SET_UNSOLICITED_ENABLE */
96         case AC_VERB_GET_BEEP_CONTROL:
97         case AC_VERB_GET_EAPD_BTLENABLE:
98         case AC_VERB_GET_DIGI_CONVERT_1:
99         case AC_VERB_GET_DIGI_CONVERT_2: /* only for beep control */
100         case AC_VERB_GET_VOLUME_KNOB_CONTROL:
101         case AC_VERB_GET_GPIO_MASK:
102         case AC_VERB_GET_GPIO_DIRECTION:
103         case AC_VERB_GET_GPIO_DATA: /* not for volatile read */
104         case AC_VERB_GET_GPIO_WAKE_MASK:
105         case AC_VERB_GET_GPIO_UNSOLICITED_RSP_MASK:
106         case AC_VERB_GET_GPIO_STICKY_MASK:
107                 return true;
108         }
109
110         return false;
111 }
112
113 static bool hda_readable_reg(struct device *dev, unsigned int reg)
114 {
115         struct hdac_device *codec = dev_to_hdac_dev(dev);
116         unsigned int verb = get_verb(reg);
117
118         if (codec->caps_overwriting)
119                 return true;
120
121         switch (verb) {
122         case AC_VERB_PARAMETERS:
123         case AC_VERB_GET_CONNECT_LIST:
124         case AC_VERB_GET_SUBSYSTEM_ID:
125                 return true;
126         /* below are basically writable, but disabled for reducing unnecessary
127          * writes at sync
128          */
129         case AC_VERB_GET_CONFIG_DEFAULT: /* usually just read */
130         case AC_VERB_GET_CONV: /* managed in PCM code */
131         case AC_VERB_GET_CVT_CHAN_COUNT: /* managed in HDMI CA code */
132                 return true;
133         }
134
135         return hda_writeable_reg(dev, reg);
136 }
137
138 /*
139  * Stereo amp pseudo register:
140  * for making easier to handle the stereo volume control, we provide a
141  * fake register to deal both left and right channels by a single
142  * (pseudo) register access.  A verb consisting of SET_AMP_GAIN with
143  * *both* SET_LEFT and SET_RIGHT bits takes a 16bit value, the lower 8bit
144  * for the left and the upper 8bit for the right channel.
145  */
146 static bool is_stereo_amp_verb(unsigned int reg)
147 {
148         if (((reg >> 8) & 0x700) != AC_VERB_SET_AMP_GAIN_MUTE)
149                 return false;
150         return (reg & (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT)) ==
151                 (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT);
152 }
153
154 /* read a pseudo stereo amp register (16bit left+right) */
155 static int hda_reg_read_stereo_amp(struct hdac_device *codec,
156                                    unsigned int reg, unsigned int *val)
157 {
158         unsigned int left, right;
159         int err;
160
161         reg &= ~(AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT);
162         err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_LEFT, 0, &left);
163         if (err < 0)
164                 return err;
165         err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_RIGHT, 0, &right);
166         if (err < 0)
167                 return err;
168         *val = left | (right << 8);
169         return 0;
170 }
171
172 /* write a pseudo stereo amp register (16bit left+right) */
173 static int hda_reg_write_stereo_amp(struct hdac_device *codec,
174                                     unsigned int reg, unsigned int val)
175 {
176         int err;
177         unsigned int verb, left, right;
178
179         verb = AC_VERB_SET_AMP_GAIN_MUTE << 8;
180         if (reg & AC_AMP_GET_OUTPUT)
181                 verb |= AC_AMP_SET_OUTPUT;
182         else
183                 verb |= AC_AMP_SET_INPUT | ((reg & 0xf) << 8);
184         reg = (reg & ~0xfffff) | verb;
185
186         left = val & 0xff;
187         right = (val >> 8) & 0xff;
188         if (left == right) {
189                 reg |= AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT;
190                 return snd_hdac_exec_verb(codec, reg | left, 0, NULL);
191         }
192
193         err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_LEFT | left, 0, NULL);
194         if (err < 0)
195                 return err;
196         err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_RIGHT | right, 0, NULL);
197         if (err < 0)
198                 return err;
199         return 0;
200 }
201
202 /* read a pseudo coef register (16bit) */
203 static int hda_reg_read_coef(struct hdac_device *codec, unsigned int reg,
204                              unsigned int *val)
205 {
206         unsigned int verb;
207         int err;
208
209         if (!codec->cache_coef)
210                 return -EINVAL;
211         /* LSB 8bit = coef index */
212         verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8);
213         err = snd_hdac_exec_verb(codec, verb, 0, NULL);
214         if (err < 0)
215                 return err;
216         verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8);
217         return snd_hdac_exec_verb(codec, verb, 0, val);
218 }
219
220 /* write a pseudo coef register (16bit) */
221 static int hda_reg_write_coef(struct hdac_device *codec, unsigned int reg,
222                               unsigned int val)
223 {
224         unsigned int verb;
225         int err;
226
227         if (!codec->cache_coef)
228                 return -EINVAL;
229         /* LSB 8bit = coef index */
230         verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8);
231         err = snd_hdac_exec_verb(codec, verb, 0, NULL);
232         if (err < 0)
233                 return err;
234         verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8) |
235                 (val & 0xffff);
236         return snd_hdac_exec_verb(codec, verb, 0, NULL);
237 }
238
239 static int hda_reg_read(void *context, unsigned int reg, unsigned int *val)
240 {
241         struct hdac_device *codec = context;
242         int verb = get_verb(reg);
243         int err;
244         int pm_lock = 0;
245
246         if (verb != AC_VERB_GET_POWER_STATE) {
247                 pm_lock = codec_pm_lock(codec);
248                 if (pm_lock < 0)
249                         return -EAGAIN;
250         }
251         reg |= (codec->addr << 28);
252         if (is_stereo_amp_verb(reg)) {
253                 err = hda_reg_read_stereo_amp(codec, reg, val);
254                 goto out;
255         }
256         if (verb == AC_VERB_GET_PROC_COEF) {
257                 err = hda_reg_read_coef(codec, reg, val);
258                 goto out;
259         }
260         if ((verb & 0x700) == AC_VERB_SET_AMP_GAIN_MUTE)
261                 reg &= ~AC_AMP_FAKE_MUTE;
262
263         err = snd_hdac_exec_verb(codec, reg, 0, val);
264         if (err < 0)
265                 goto out;
266         /* special handling for asymmetric reads */
267         if (verb == AC_VERB_GET_POWER_STATE) {
268                 if (*val & AC_PWRST_ERROR)
269                         *val = -1;
270                 else /* take only the actual state */
271                         *val = (*val >> 4) & 0x0f;
272         }
273  out:
274         codec_pm_unlock(codec, pm_lock);
275         return err;
276 }
277
278 static int hda_reg_write(void *context, unsigned int reg, unsigned int val)
279 {
280         struct hdac_device *codec = context;
281         unsigned int verb;
282         int i, bytes, err;
283         int pm_lock = 0;
284
285         if (codec->caps_overwriting)
286                 return 0;
287
288         reg &= ~0x00080000U; /* drop GET bit */
289         reg |= (codec->addr << 28);
290         verb = get_verb(reg);
291
292         if (verb != AC_VERB_SET_POWER_STATE) {
293                 pm_lock = codec_pm_lock(codec);
294                 if (pm_lock < 0)
295                         return codec->lazy_cache ? 0 : -EAGAIN;
296         }
297
298         if (is_stereo_amp_verb(reg)) {
299                 err = hda_reg_write_stereo_amp(codec, reg, val);
300                 goto out;
301         }
302
303         if (verb == AC_VERB_SET_PROC_COEF) {
304                 err = hda_reg_write_coef(codec, reg, val);
305                 goto out;
306         }
307
308         switch (verb & 0xf00) {
309         case AC_VERB_SET_AMP_GAIN_MUTE:
310                 if ((reg & AC_AMP_FAKE_MUTE) && (val & AC_AMP_MUTE))
311                         val = 0;
312                 verb = AC_VERB_SET_AMP_GAIN_MUTE;
313                 if (reg & AC_AMP_GET_LEFT)
314                         verb |= AC_AMP_SET_LEFT >> 8;
315                 else
316                         verb |= AC_AMP_SET_RIGHT >> 8;
317                 if (reg & AC_AMP_GET_OUTPUT) {
318                         verb |= AC_AMP_SET_OUTPUT >> 8;
319                 } else {
320                         verb |= AC_AMP_SET_INPUT >> 8;
321                         verb |= reg & 0xf;
322                 }
323                 break;
324         }
325
326         switch (verb) {
327         case AC_VERB_SET_DIGI_CONVERT_1:
328                 bytes = 2;
329                 break;
330         case AC_VERB_SET_CONFIG_DEFAULT_BYTES_0:
331                 bytes = 4;
332                 break;
333         default:
334                 bytes = 1;
335                 break;
336         }
337
338         for (i = 0; i < bytes; i++) {
339                 reg &= ~0xfffff;
340                 reg |= (verb + i) << 8 | ((val >> (8 * i)) & 0xff);
341                 err = snd_hdac_exec_verb(codec, reg, 0, NULL);
342                 if (err < 0)
343                         goto out;
344         }
345
346  out:
347         codec_pm_unlock(codec, pm_lock);
348         return err;
349 }
350
351 static const struct regmap_config hda_regmap_cfg = {
352         .name = "hdaudio",
353         .reg_bits = 32,
354         .val_bits = 32,
355         .max_register = 0xfffffff,
356         .writeable_reg = hda_writeable_reg,
357         .readable_reg = hda_readable_reg,
358         .volatile_reg = hda_volatile_reg,
359         .cache_type = REGCACHE_RBTREE,
360         .reg_read = hda_reg_read,
361         .reg_write = hda_reg_write,
362         .use_single_read = true,
363         .use_single_write = true,
364 };
365
366 /**
367  * snd_hdac_regmap_init - Initialize regmap for HDA register accesses
368  * @codec: the codec object
369  *
370  * Returns zero for success or a negative error code.
371  */
372 int snd_hdac_regmap_init(struct hdac_device *codec)
373 {
374         struct regmap *regmap;
375
376         regmap = regmap_init(&codec->dev, NULL, codec, &hda_regmap_cfg);
377         if (IS_ERR(regmap))
378                 return PTR_ERR(regmap);
379         codec->regmap = regmap;
380         snd_array_init(&codec->vendor_verbs, sizeof(unsigned int), 8);
381         return 0;
382 }
383 EXPORT_SYMBOL_GPL(snd_hdac_regmap_init);
384
385 /**
386  * snd_hdac_regmap_init - Release the regmap from HDA codec
387  * @codec: the codec object
388  */
389 void snd_hdac_regmap_exit(struct hdac_device *codec)
390 {
391         if (codec->regmap) {
392                 regmap_exit(codec->regmap);
393                 codec->regmap = NULL;
394                 snd_array_free(&codec->vendor_verbs);
395         }
396 }
397 EXPORT_SYMBOL_GPL(snd_hdac_regmap_exit);
398
399 /**
400  * snd_hdac_regmap_add_vendor_verb - add a vendor-specific verb to regmap
401  * @codec: the codec object
402  * @verb: verb to allow accessing via regmap
403  *
404  * Returns zero for success or a negative error code.
405  */
406 int snd_hdac_regmap_add_vendor_verb(struct hdac_device *codec,
407                                     unsigned int verb)
408 {
409         unsigned int *p = snd_array_new(&codec->vendor_verbs);
410
411         if (!p)
412                 return -ENOMEM;
413         *p = verb | 0x800; /* set GET bit */
414         return 0;
415 }
416 EXPORT_SYMBOL_GPL(snd_hdac_regmap_add_vendor_verb);
417
418 /*
419  * helper functions
420  */
421
422 /* write a pseudo-register value (w/o power sequence) */
423 static int reg_raw_write(struct hdac_device *codec, unsigned int reg,
424                          unsigned int val)
425 {
426         if (!codec->regmap)
427                 return hda_reg_write(codec, reg, val);
428         else
429                 return regmap_write(codec->regmap, reg, val);
430 }
431
432 /**
433  * snd_hdac_regmap_write_raw - write a pseudo register with power mgmt
434  * @codec: the codec object
435  * @reg: pseudo register
436  * @val: value to write
437  *
438  * Returns zero if successful or a negative error code.
439  */
440 int snd_hdac_regmap_write_raw(struct hdac_device *codec, unsigned int reg,
441                               unsigned int val)
442 {
443         int err;
444
445         err = reg_raw_write(codec, reg, val);
446         if (err == -EAGAIN) {
447                 err = snd_hdac_power_up_pm(codec);
448                 if (err >= 0)
449                         err = reg_raw_write(codec, reg, val);
450                 snd_hdac_power_down_pm(codec);
451         }
452         return err;
453 }
454 EXPORT_SYMBOL_GPL(snd_hdac_regmap_write_raw);
455
456 static int reg_raw_read(struct hdac_device *codec, unsigned int reg,
457                         unsigned int *val, bool uncached)
458 {
459         if (uncached || !codec->regmap)
460                 return hda_reg_read(codec, reg, val);
461         else
462                 return regmap_read(codec->regmap, reg, val);
463 }
464
465 static int __snd_hdac_regmap_read_raw(struct hdac_device *codec,
466                                       unsigned int reg, unsigned int *val,
467                                       bool uncached)
468 {
469         int err;
470
471         err = reg_raw_read(codec, reg, val, uncached);
472         if (err == -EAGAIN) {
473                 err = snd_hdac_power_up_pm(codec);
474                 if (err >= 0)
475                         err = reg_raw_read(codec, reg, val, uncached);
476                 snd_hdac_power_down_pm(codec);
477         }
478         return err;
479 }
480
481 /**
482  * snd_hdac_regmap_read_raw - read a pseudo register with power mgmt
483  * @codec: the codec object
484  * @reg: pseudo register
485  * @val: pointer to store the read value
486  *
487  * Returns zero if successful or a negative error code.
488  */
489 int snd_hdac_regmap_read_raw(struct hdac_device *codec, unsigned int reg,
490                              unsigned int *val)
491 {
492         return __snd_hdac_regmap_read_raw(codec, reg, val, false);
493 }
494 EXPORT_SYMBOL_GPL(snd_hdac_regmap_read_raw);
495
496 /* Works like snd_hdac_regmap_read_raw(), but this doesn't read from the
497  * cache but always via hda verbs.
498  */
499 int snd_hdac_regmap_read_raw_uncached(struct hdac_device *codec,
500                                       unsigned int reg, unsigned int *val)
501 {
502         return __snd_hdac_regmap_read_raw(codec, reg, val, true);
503 }
504
505 /**
506  * snd_hdac_regmap_update_raw - update a pseudo register with power mgmt
507  * @codec: the codec object
508  * @reg: pseudo register
509  * @mask: bit mask to udpate
510  * @val: value to update
511  *
512  * Returns zero if successful or a negative error code.
513  */
514 int snd_hdac_regmap_update_raw(struct hdac_device *codec, unsigned int reg,
515                                unsigned int mask, unsigned int val)
516 {
517         unsigned int orig;
518         int err;
519
520         val &= mask;
521         err = snd_hdac_regmap_read_raw(codec, reg, &orig);
522         if (err < 0)
523                 return err;
524         val |= orig & ~mask;
525         if (val == orig)
526                 return 0;
527         err = snd_hdac_regmap_write_raw(codec, reg, val);
528         if (err < 0)
529                 return err;
530         return 1;
531 }
532 EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw);