Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-3.16-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"The significant part here is a few security fixes for ALSA core
control API by Lars. Besides that, there are a few fixes for ASoC
sigmadsp (again by Lars) for building properly, and small fixes for
ASoC rsnd, MMP, PXA and FSL, in addition to a fix for bogus WARNING in
i915/HD-audio binding"
* tag 'sound-3.16-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
ALSA: control: Make sure that id->index does not overflow
ALSA: control: Handle numid overflow
ALSA: control: Don't access controls outside of protected regions
ALSA: control: Fix replacing user controls
ALSA: control: Protect user controls against concurrent access
drm/i915, HD-audio: Don't continue probing when nomodeset is given
ASoC: fsl: Fix build problem
ASoC: rsnd: fixup index of src/dst mod when capture
ASoC: fsl_spdif: Fix integer overflow when calculating divisors
ASoC: fsl_spdif: Fix incorrect usage of regmap_read()
ASoC: dapm: Make sure register value is in sync with DAPM kcontrol state
ASoC: sigmadsp: Split regmap and I2C support into separate modules
ASoC: MMP audio needs sram support
ASoC: pxa: add I2C dependencies as needed
+212
-132
+8
-6
drivers/gpu/drm/i915/intel_pm.c
+8
-6
drivers/gpu/drm/i915/intel_pm.c
···
6019
6019
static struct i915_power_domains *hsw_pwr;
6020
6020
6021
6021
/* Display audio driver power well request */
6022
-
void i915_request_power_well(void)
6022
+
int i915_request_power_well(void)
6023
6023
{
6024
6024
struct drm_i915_private *dev_priv;
6025
6025
6026
-
if (WARN_ON(!hsw_pwr))
6027
-
return;
6026
+
if (!hsw_pwr)
6027
+
return -ENODEV;
6028
6028
6029
6029
dev_priv = container_of(hsw_pwr, struct drm_i915_private,
6030
6030
power_domains);
6031
6031
intel_display_power_get(dev_priv, POWER_DOMAIN_AUDIO);
6032
+
return 0;
6032
6033
}
6033
6034
EXPORT_SYMBOL_GPL(i915_request_power_well);
6034
6035
6035
6036
/* Display audio driver power well release */
6036
-
void i915_release_power_well(void)
6037
+
int i915_release_power_well(void)
6037
6038
{
6038
6039
struct drm_i915_private *dev_priv;
6039
6040
6040
-
if (WARN_ON(!hsw_pwr))
6041
-
return;
6041
+
if (!hsw_pwr)
6042
+
return -ENODEV;
6042
6043
6043
6044
dev_priv = container_of(hsw_pwr, struct drm_i915_private,
6044
6045
power_domains);
6045
6046
intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO);
6047
+
return 0;
6046
6048
}
6047
6049
EXPORT_SYMBOL_GPL(i915_release_power_well);
6048
6050
+2
-2
include/drm/i915_powerwell.h
+2
-2
include/drm/i915_powerwell.h
···
30
30
#define _I915_POWERWELL_H_
31
31
32
32
/* For use by hda_i915 driver */
33
-
extern void i915_request_power_well(void);
34
-
extern void i915_release_power_well(void);
33
+
extern int i915_request_power_well(void);
34
+
extern int i915_release_power_well(void);
35
35
36
36
#endif /* _I915_POWERWELL_H_ */
+2
include/sound/core.h
+2
include/sound/core.h
···
116
116
int user_ctl_count; /* count of all user controls */
117
117
struct list_head controls; /* all controls for this card */
118
118
struct list_head ctl_files; /* active control files */
119
+
struct mutex user_ctl_lock; /* protects user controls against
120
+
concurrent access */
119
121
120
122
struct snd_info_entry *proc_root; /* root for soundcard specific files */
121
123
struct snd_info_entry *proc_id; /* the card id */
+51
-27
sound/core/control.c
+51
-27
sound/core/control.c
···
288
288
{
289
289
struct snd_kcontrol *kctl;
290
290
291
+
/* Make sure that the ids assigned to the control do not wrap around */
292
+
if (card->last_numid >= UINT_MAX - count)
293
+
card->last_numid = 0;
294
+
291
295
list_for_each_entry(kctl, &card->controls, list) {
292
296
if (kctl->id.numid < card->last_numid + 1 + count &&
293
297
kctl->id.numid + kctl->count > card->last_numid + 1) {
···
334
330
{
335
331
struct snd_ctl_elem_id id;
336
332
unsigned int idx;
333
+
unsigned int count;
337
334
int err = -EINVAL;
338
335
339
336
if (! kcontrol)
···
342
337
if (snd_BUG_ON(!card || !kcontrol->info))
343
338
goto error;
344
339
id = kcontrol->id;
340
+
if (id.index > UINT_MAX - kcontrol->count)
341
+
goto error;
342
+
345
343
down_write(&card->controls_rwsem);
346
344
if (snd_ctl_find_id(card, &id)) {
347
345
up_write(&card->controls_rwsem);
···
366
358
card->controls_count += kcontrol->count;
367
359
kcontrol->id.numid = card->last_numid + 1;
368
360
card->last_numid += kcontrol->count;
361
+
count = kcontrol->count;
369
362
up_write(&card->controls_rwsem);
370
-
for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
363
+
for (idx = 0; idx < count; idx++, id.index++, id.numid++)
371
364
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
372
365
return 0;
373
366
···
397
388
bool add_on_replace)
398
389
{
399
390
struct snd_ctl_elem_id id;
391
+
unsigned int count;
400
392
unsigned int idx;
401
393
struct snd_kcontrol *old;
402
394
int ret;
···
433
423
card->controls_count += kcontrol->count;
434
424
kcontrol->id.numid = card->last_numid + 1;
435
425
card->last_numid += kcontrol->count;
426
+
count = kcontrol->count;
436
427
up_write(&card->controls_rwsem);
437
-
for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
428
+
for (idx = 0; idx < count; idx++, id.index++, id.numid++)
438
429
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
439
430
return 0;
440
431
···
908
897
result = kctl->put(kctl, control);
909
898
}
910
899
if (result > 0) {
900
+
struct snd_ctl_elem_id id = control->id;
911
901
up_read(&card->controls_rwsem);
912
-
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
913
-
&control->id);
902
+
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &id);
914
903
return 0;
915
904
}
916
905
}
···
1002
991
1003
992
struct user_element {
1004
993
struct snd_ctl_elem_info info;
994
+
struct snd_card *card;
1005
995
void *elem_data; /* element data */
1006
996
unsigned long elem_data_size; /* size of element data in bytes */
1007
997
void *tlv_data; /* TLV data */
···
1046
1034
{
1047
1035
struct user_element *ue = kcontrol->private_data;
1048
1036
1037
+
mutex_lock(&ue->card->user_ctl_lock);
1049
1038
memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
1039
+
mutex_unlock(&ue->card->user_ctl_lock);
1050
1040
return 0;
1051
1041
}
1052
1042
···
1057
1043
{
1058
1044
int change;
1059
1045
struct user_element *ue = kcontrol->private_data;
1060
-
1046
+
1047
+
mutex_lock(&ue->card->user_ctl_lock);
1061
1048
change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
1062
1049
if (change)
1063
1050
memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
1051
+
mutex_unlock(&ue->card->user_ctl_lock);
1064
1052
return change;
1065
1053
}
1066
1054
···
1082
1066
new_data = memdup_user(tlv, size);
1083
1067
if (IS_ERR(new_data))
1084
1068
return PTR_ERR(new_data);
1069
+
mutex_lock(&ue->card->user_ctl_lock);
1085
1070
change = ue->tlv_data_size != size;
1086
1071
if (!change)
1087
1072
change = memcmp(ue->tlv_data, new_data, size);
1088
1073
kfree(ue->tlv_data);
1089
1074
ue->tlv_data = new_data;
1090
1075
ue->tlv_data_size = size;
1076
+
mutex_unlock(&ue->card->user_ctl_lock);
1091
1077
} else {
1092
-
if (! ue->tlv_data_size || ! ue->tlv_data)
1093
-
return -ENXIO;
1094
-
if (size < ue->tlv_data_size)
1095
-
return -ENOSPC;
1078
+
int ret = 0;
1079
+
1080
+
mutex_lock(&ue->card->user_ctl_lock);
1081
+
if (!ue->tlv_data_size || !ue->tlv_data) {
1082
+
ret = -ENXIO;
1083
+
goto err_unlock;
1084
+
}
1085
+
if (size < ue->tlv_data_size) {
1086
+
ret = -ENOSPC;
1087
+
goto err_unlock;
1088
+
}
1096
1089
if (copy_to_user(tlv, ue->tlv_data, ue->tlv_data_size))
1097
-
return -EFAULT;
1090
+
ret = -EFAULT;
1091
+
err_unlock:
1092
+
mutex_unlock(&ue->card->user_ctl_lock);
1093
+
if (ret)
1094
+
return ret;
1098
1095
}
1099
1096
return change;
1100
1097
}
···
1165
1136
struct user_element *ue;
1166
1137
int idx, err;
1167
1138
1168
-
if (!replace && card->user_ctl_count >= MAX_USER_CONTROLS)
1169
-
return -ENOMEM;
1170
1139
if (info->count < 1)
1171
1140
return -EINVAL;
1172
1141
access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
···
1173
1146
SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE));
1174
1147
info->id.numid = 0;
1175
1148
memset(&kctl, 0, sizeof(kctl));
1176
-
down_write(&card->controls_rwsem);
1177
-
_kctl = snd_ctl_find_id(card, &info->id);
1178
-
err = 0;
1179
-
if (_kctl) {
1180
-
if (replace)
1181
-
err = snd_ctl_remove(card, _kctl);
1182
-
else
1183
-
err = -EBUSY;
1184
-
} else {
1185
-
if (replace)
1186
-
err = -ENOENT;
1149
+
1150
+
if (replace) {
1151
+
err = snd_ctl_remove_user_ctl(file, &info->id);
1152
+
if (err)
1153
+
return err;
1187
1154
}
1188
-
up_write(&card->controls_rwsem);
1189
-
if (err < 0)
1190
-
return err;
1155
+
1156
+
if (card->user_ctl_count >= MAX_USER_CONTROLS)
1157
+
return -ENOMEM;
1158
+
1191
1159
memcpy(&kctl.id, &info->id, sizeof(info->id));
1192
1160
kctl.count = info->owner ? info->owner : 1;
1193
1161
access |= SNDRV_CTL_ELEM_ACCESS_USER;
···
1232
1210
ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
1233
1211
if (ue == NULL)
1234
1212
return -ENOMEM;
1213
+
ue->card = card;
1235
1214
ue->info = *info;
1236
1215
ue->info.access = 0;
1237
1216
ue->elem_data = (char *)ue + sizeof(*ue);
···
1344
1321
}
1345
1322
err = kctl->tlv.c(kctl, op_flag, tlv.length, _tlv->tlv);
1346
1323
if (err > 0) {
1324
+
struct snd_ctl_elem_id id = kctl->id;
1347
1325
up_read(&card->controls_rwsem);
1348
-
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &kctl->id);
1326
+
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &id);
1349
1327
return 0;
1350
1328
}
1351
1329
} else {
+1
sound/core/init.c
+1
sound/core/init.c
+6
-6
sound/pci/hda/hda_i915.c
+6
-6
sound/pci/hda/hda_i915.c
···
22
22
#include <drm/i915_powerwell.h>
23
23
#include "hda_i915.h"
24
24
25
-
static void (*get_power)(void);
26
-
static void (*put_power)(void);
25
+
static int (*get_power)(void);
26
+
static int (*put_power)(void);
27
27
28
-
void hda_display_power(bool enable)
28
+
int hda_display_power(bool enable)
29
29
{
30
30
if (!get_power || !put_power)
31
-
return;
31
+
return -ENODEV;
32
32
33
33
pr_debug("HDA display power %s \n",
34
34
enable ? "Enable" : "Disable");
35
35
if (enable)
36
-
get_power();
36
+
return get_power();
37
37
else
38
-
put_power();
38
+
return put_power();
39
39
}
40
40
41
41
int hda_i915_init(void)
+2
-2
sound/pci/hda/hda_i915.h
+2
-2
sound/pci/hda/hda_i915.h
···
17
17
#define __SOUND_HDA_I915_H
18
18
19
19
#ifdef CONFIG_SND_HDA_I915
20
-
void hda_display_power(bool enable);
20
+
int hda_display_power(bool enable);
21
21
int hda_i915_init(void);
22
22
int hda_i915_exit(void);
23
23
#else
24
-
static inline void hda_display_power(bool enable) {}
24
+
static inline int hda_display_power(bool enable) { return 0; }
25
25
static inline int hda_i915_init(void)
26
26
{
27
27
return -ENODEV;
+6
-1
sound/pci/hda/hda_intel.c
+6
-1
sound/pci/hda/hda_intel.c
···
1656
1656
"Error request power-well from i915\n");
1657
1657
goto out_free;
1658
1658
}
1659
+
err = hda_display_power(true);
1660
+
if (err < 0) {
1661
+
dev_err(chip->card->dev,
1662
+
"Cannot turn on display power on i915\n");
1663
+
goto out_free;
1664
+
}
1659
1665
#endif
1660
-
hda_display_power(true);
1661
1666
}
1662
1667
1663
1668
err = azx_first_init(chip);
+10
-2
sound/soc/codecs/Kconfig
+10
-2
sound/soc/codecs/Kconfig
···
225
225
config SND_SOC_ADAU1701
226
226
tristate "Analog Devices ADAU1701 CODEC"
227
227
depends on I2C
228
-
select SND_SOC_SIGMADSP
228
+
select SND_SOC_SIGMADSP_I2C
229
229
230
230
config SND_SOC_ADAU17X1
231
231
tristate
232
-
select SND_SOC_SIGMADSP
232
+
select SND_SOC_SIGMADSP_REGMAP
233
233
234
234
config SND_SOC_ADAU1761
235
235
tristate
···
475
475
config SND_SOC_SIGMADSP
476
476
tristate
477
477
select CRC32
478
+
479
+
config SND_SOC_SIGMADSP_I2C
480
+
tristate
481
+
select SND_SOC_SIGMADSP
482
+
483
+
config SND_SOC_SIGMADSP_REGMAP
484
+
tristate
485
+
select SND_SOC_SIGMADSP
478
486
479
487
config SND_SOC_SIRF_AUDIO_CODEC
480
488
tristate "SiRF SoC internal audio codec"
+4
sound/soc/codecs/Makefile
+4
sound/soc/codecs/Makefile
···
77
77
snd-soc-alc5623-objs := alc5623.o
78
78
snd-soc-alc5632-objs := alc5632.o
79
79
snd-soc-sigmadsp-objs := sigmadsp.o
80
+
snd-soc-sigmadsp-i2c-objs := sigmadsp-i2c.o
81
+
snd-soc-sigmadsp-regmap-objs := sigmadsp-regmap.o
80
82
snd-soc-si476x-objs := si476x.o
81
83
snd-soc-sirf-audio-codec-objs := sirf-audio-codec.o
82
84
snd-soc-sn95031-objs := sn95031.o
···
242
240
obj-$(CONFIG_SND_SOC_RT5677) += snd-soc-rt5677.o
243
241
obj-$(CONFIG_SND_SOC_SGTL5000) += snd-soc-sgtl5000.o
244
242
obj-$(CONFIG_SND_SOC_SIGMADSP) += snd-soc-sigmadsp.o
243
+
obj-$(CONFIG_SND_SOC_SIGMADSP_I2C) += snd-soc-sigmadsp-i2c.o
244
+
obj-$(CONFIG_SND_SOC_SIGMADSP_REGMAP) += snd-soc-sigmadsp-regmap.o
245
245
obj-$(CONFIG_SND_SOC_SI476X) += snd-soc-si476x.o
246
246
obj-$(CONFIG_SND_SOC_SN95031) +=snd-soc-sn95031.o
247
247
obj-$(CONFIG_SND_SOC_SPDIF) += snd-soc-spdif-rx.o snd-soc-spdif-tx.o
+35
sound/soc/codecs/sigmadsp-i2c.c
+35
sound/soc/codecs/sigmadsp-i2c.c
···
1
+
/*
2
+
* Load Analog Devices SigmaStudio firmware files
3
+
*
4
+
* Copyright 2009-2011 Analog Devices Inc.
5
+
*
6
+
* Licensed under the GPL-2 or later.
7
+
*/
8
+
9
+
#include <linux/i2c.h>
10
+
#include <linux/export.h>
11
+
#include <linux/module.h>
12
+
13
+
#include "sigmadsp.h"
14
+
15
+
static int sigma_action_write_i2c(void *control_data,
16
+
const struct sigma_action *sa, size_t len)
17
+
{
18
+
return i2c_master_send(control_data, (const unsigned char *)&sa->addr,
19
+
len);
20
+
}
21
+
22
+
int process_sigma_firmware(struct i2c_client *client, const char *name)
23
+
{
24
+
struct sigma_firmware ssfw;
25
+
26
+
ssfw.control_data = client;
27
+
ssfw.write = sigma_action_write_i2c;
28
+
29
+
return _process_sigma_firmware(&client->dev, &ssfw, name);
30
+
}
31
+
EXPORT_SYMBOL(process_sigma_firmware);
32
+
33
+
MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
34
+
MODULE_DESCRIPTION("SigmaDSP I2C firmware loader");
35
+
MODULE_LICENSE("GPL");
+36
sound/soc/codecs/sigmadsp-regmap.c
+36
sound/soc/codecs/sigmadsp-regmap.c
···
1
+
/*
2
+
* Load Analog Devices SigmaStudio firmware files
3
+
*
4
+
* Copyright 2009-2011 Analog Devices Inc.
5
+
*
6
+
* Licensed under the GPL-2 or later.
7
+
*/
8
+
9
+
#include <linux/regmap.h>
10
+
#include <linux/export.h>
11
+
#include <linux/module.h>
12
+
13
+
#include "sigmadsp.h"
14
+
15
+
static int sigma_action_write_regmap(void *control_data,
16
+
const struct sigma_action *sa, size_t len)
17
+
{
18
+
return regmap_raw_write(control_data, be16_to_cpu(sa->addr),
19
+
sa->payload, len - 2);
20
+
}
21
+
22
+
int process_sigma_firmware_regmap(struct device *dev, struct regmap *regmap,
23
+
const char *name)
24
+
{
25
+
struct sigma_firmware ssfw;
26
+
27
+
ssfw.control_data = regmap;
28
+
ssfw.write = sigma_action_write_regmap;
29
+
30
+
return _process_sigma_firmware(dev, &ssfw, name);
31
+
}
32
+
EXPORT_SYMBOL(process_sigma_firmware_regmap);
33
+
34
+
MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
35
+
MODULE_DESCRIPTION("SigmaDSP regmap firmware loader");
36
+
MODULE_LICENSE("GPL");
+2
-63
sound/soc/codecs/sigmadsp.c
+2
-63
sound/soc/codecs/sigmadsp.c
···
34
34
SIGMA_ACTION_END,
35
35
};
36
36
37
-
struct sigma_action {
38
-
u8 instr;
39
-
u8 len_hi;
40
-
__le16 len;
41
-
__be16 addr;
42
-
unsigned char payload[];
43
-
} __packed;
44
-
45
-
struct sigma_firmware {
46
-
const struct firmware *fw;
47
-
size_t pos;
48
-
49
-
void *control_data;
50
-
int (*write)(void *control_data, const struct sigma_action *sa,
51
-
size_t len);
52
-
};
53
-
54
37
static inline u32 sigma_action_len(struct sigma_action *sa)
55
38
{
56
39
return (sa->len_hi << 16) | le16_to_cpu(sa->len);
···
121
138
return 0;
122
139
}
123
140
124
-
static int _process_sigma_firmware(struct device *dev,
141
+
int _process_sigma_firmware(struct device *dev,
125
142
struct sigma_firmware *ssfw, const char *name)
126
143
{
127
144
int ret;
···
180
197
181
198
return ret;
182
199
}
183
-
184
-
#if IS_ENABLED(CONFIG_I2C)
185
-
186
-
static int sigma_action_write_i2c(void *control_data,
187
-
const struct sigma_action *sa, size_t len)
188
-
{
189
-
return i2c_master_send(control_data, (const unsigned char *)&sa->addr,
190
-
len);
191
-
}
192
-
193
-
int process_sigma_firmware(struct i2c_client *client, const char *name)
194
-
{
195
-
struct sigma_firmware ssfw;
196
-
197
-
ssfw.control_data = client;
198
-
ssfw.write = sigma_action_write_i2c;
199
-
200
-
return _process_sigma_firmware(&client->dev, &ssfw, name);
201
-
}
202
-
EXPORT_SYMBOL(process_sigma_firmware);
203
-
204
-
#endif
205
-
206
-
#if IS_ENABLED(CONFIG_REGMAP)
207
-
208
-
static int sigma_action_write_regmap(void *control_data,
209
-
const struct sigma_action *sa, size_t len)
210
-
{
211
-
return regmap_raw_write(control_data, be16_to_cpu(sa->addr),
212
-
sa->payload, len - 2);
213
-
}
214
-
215
-
int process_sigma_firmware_regmap(struct device *dev, struct regmap *regmap,
216
-
const char *name)
217
-
{
218
-
struct sigma_firmware ssfw;
219
-
220
-
ssfw.control_data = regmap;
221
-
ssfw.write = sigma_action_write_regmap;
222
-
223
-
return _process_sigma_firmware(dev, &ssfw, name);
224
-
}
225
-
EXPORT_SYMBOL(process_sigma_firmware_regmap);
226
-
227
-
#endif
200
+
EXPORT_SYMBOL_GPL(_process_sigma_firmware);
228
201
229
202
MODULE_LICENSE("GPL");
+20
sound/soc/codecs/sigmadsp.h
+20
sound/soc/codecs/sigmadsp.h
···
12
12
#include <linux/device.h>
13
13
#include <linux/regmap.h>
14
14
15
+
struct sigma_action {
16
+
u8 instr;
17
+
u8 len_hi;
18
+
__le16 len;
19
+
__be16 addr;
20
+
unsigned char payload[];
21
+
} __packed;
22
+
23
+
struct sigma_firmware {
24
+
const struct firmware *fw;
25
+
size_t pos;
26
+
27
+
void *control_data;
28
+
int (*write)(void *control_data, const struct sigma_action *sa,
29
+
size_t len);
30
+
};
31
+
32
+
int _process_sigma_firmware(struct device *dev,
33
+
struct sigma_firmware *ssfw, const char *name);
34
+
15
35
struct i2c_client;
16
36
17
37
extern int process_sigma_firmware(struct i2c_client *client, const char *name);
+2
-2
sound/soc/fsl/fsl_dma.c
+2
-2
sound/soc/fsl/fsl_dma.c
···
923
923
dma->dai.pcm_free = fsl_dma_free_dma_buffers;
924
924
925
925
/* Store the SSI-specific information that we need */
926
-
dma->ssi_stx_phys = res.start + offsetof(struct ccsr_ssi, stx0);
927
-
dma->ssi_srx_phys = res.start + offsetof(struct ccsr_ssi, srx0);
926
+
dma->ssi_stx_phys = res.start + CCSR_SSI_STX0;
927
+
dma->ssi_srx_phys = res.start + CCSR_SSI_SRX0;
928
928
929
929
iprop = of_get_property(ssi_np, "fsl,fifo-depth", NULL);
930
930
if (iprop)
+3
-3
sound/soc/fsl/fsl_spdif.c
+3
-3
sound/soc/fsl/fsl_spdif.c
···
762
762
struct regmap *regmap = spdif_priv->regmap;
763
763
u32 val;
764
764
765
-
val = regmap_read(regmap, REG_SPDIF_SIS, &val);
765
+
regmap_read(regmap, REG_SPDIF_SIS, &val);
766
766
ucontrol->value.integer.value[0] = (val & INT_VAL_NOGOOD) != 0;
767
767
regmap_write(regmap, REG_SPDIF_SIC, INT_VAL_NOGOOD);
768
768
···
1076
1076
goto out;
1077
1077
} else if (arate / rate[index] == 1) {
1078
1078
/* A little bigger than expect */
1079
-
sub = (arate - rate[index]) * 100000;
1079
+
sub = (u64)(arate - rate[index]) * 100000;
1080
1080
do_div(sub, rate[index]);
1081
1081
if (sub >= savesub)
1082
1082
continue;
···
1086
1086
spdif_priv->txrate[index] = arate;
1087
1087
} else if (rate[index] / arate == 1) {
1088
1088
/* A little smaller than expect */
1089
-
sub = (rate[index] - arate) * 100000;
1089
+
sub = (u64)(rate[index] - arate) * 100000;
1090
1090
do_div(sub, rate[index]);
1091
1091
if (sub >= savesub)
1092
1092
continue;
+6
-5
sound/soc/pxa/Kconfig
+6
-5
sound/soc/pxa/Kconfig
···
11
11
config SND_MMP_SOC
12
12
bool "Soc Audio for Marvell MMP chips"
13
13
depends on ARCH_MMP
14
+
select MMP_SRAM
14
15
select SND_SOC_GENERIC_DMAENGINE_PCM
15
16
select SND_ARM
16
17
help
···
41
40
42
41
config SND_PXA2XX_SOC_CORGI
43
42
tristate "SoC Audio support for Sharp Zaurus SL-C7x0"
44
-
depends on SND_PXA2XX_SOC && PXA_SHARP_C7xx
43
+
depends on SND_PXA2XX_SOC && PXA_SHARP_C7xx && I2C
45
44
select SND_PXA2XX_SOC_I2S
46
45
select SND_SOC_WM8731
47
46
help
···
50
49
51
50
config SND_PXA2XX_SOC_SPITZ
52
51
tristate "SoC Audio support for Sharp Zaurus SL-Cxx00"
53
-
depends on SND_PXA2XX_SOC && PXA_SHARP_Cxx00
52
+
depends on SND_PXA2XX_SOC && PXA_SHARP_Cxx00 && I2C
54
53
select SND_PXA2XX_SOC_I2S
55
54
select SND_SOC_WM8750
56
55
help
···
59
58
60
59
config SND_PXA2XX_SOC_Z2
61
60
tristate "SoC Audio support for Zipit Z2"
62
-
depends on SND_PXA2XX_SOC && MACH_ZIPIT2
61
+
depends on SND_PXA2XX_SOC && MACH_ZIPIT2 && I2C
63
62
select SND_PXA2XX_SOC_I2S
64
63
select SND_SOC_WM8750
65
64
help
···
67
66
68
67
config SND_PXA2XX_SOC_POODLE
69
68
tristate "SoC Audio support for Poodle"
70
-
depends on SND_PXA2XX_SOC && MACH_POODLE
69
+
depends on SND_PXA2XX_SOC && MACH_POODLE && I2C
71
70
select SND_PXA2XX_SOC_I2S
72
71
select SND_SOC_WM8731
73
72
help
···
182
181
183
182
config SND_PXA2XX_SOC_MAGICIAN
184
183
tristate "SoC Audio support for HTC Magician"
185
-
depends on SND_PXA2XX_SOC && MACH_MAGICIAN
184
+
depends on SND_PXA2XX_SOC && MACH_MAGICIAN && I2C
186
185
select SND_PXA2XX_SOC_I2S
187
186
select SND_PXA_SOC_SSP
188
187
select SND_SOC_UDA1380
+1
-1
sound/soc/sh/rcar/core.c
+1
-1
sound/soc/sh/rcar/core.c
+15
-12
sound/soc/soc-dapm.c
+15
-12
sound/soc/soc-dapm.c
···
2755
2755
unsigned int mask = (1 << fls(max)) - 1;
2756
2756
unsigned int invert = mc->invert;
2757
2757
unsigned int val;
2758
-
int connect, change;
2758
+
int connect, change, reg_change = 0;
2759
2759
struct snd_soc_dapm_update update;
2760
2760
int ret = 0;
2761
2761
···
2773
2773
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2774
2774
2775
2775
change = dapm_kcontrol_set_value(kcontrol, val);
2776
-
if (change) {
2777
-
if (reg != SND_SOC_NOPM) {
2778
-
mask = mask << shift;
2779
-
val = val << shift;
2780
2776
2781
-
if (snd_soc_test_bits(codec, reg, mask, val)) {
2782
-
update.kcontrol = kcontrol;
2783
-
update.reg = reg;
2784
-
update.mask = mask;
2785
-
update.val = val;
2786
-
card->update = &update;
2787
-
}
2777
+
if (reg != SND_SOC_NOPM) {
2778
+
mask = mask << shift;
2779
+
val = val << shift;
2788
2780
2781
+
reg_change = snd_soc_test_bits(codec, reg, mask, val);
2782
+
}
2783
+
2784
+
if (change || reg_change) {
2785
+
if (reg_change) {
2786
+
update.kcontrol = kcontrol;
2787
+
update.reg = reg;
2788
+
update.mask = mask;
2789
+
update.val = val;
2790
+
card->update = &update;
2789
2791
}
2792
+
change |= reg_change;
2790
2793
2791
2794
ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
2792
2795