Merge tag 'sound-6.10' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

+164 -67

drivers/firmware/cirrus/cs_dsp.c

··· 1107 1107 int len; 1108 1108 }; 1109 1109 1110 - static int cs_dsp_coeff_parse_string(int bytes, const u8 **pos, const u8 **str) 1110 + static int cs_dsp_coeff_parse_string(int bytes, const u8 **pos, unsigned int avail, 1111 + const u8 **str) 1111 1112 { 1112 - int length; 1113 + int length, total_field_len; 1114 + 1115 + /* String fields are at least one __le32 */ 1116 + if (sizeof(__le32) > avail) { 1117 + *pos = NULL; 1118 + return 0; 1119 + } 1113 1120 1114 1121 switch (bytes) { 1115 1122 case 1: ··· 1129 1122 return 0; 1130 1123 } 1131 1124 1125 + total_field_len = ((length + bytes) + 3) & ~0x03; 1126 + if ((unsigned int)total_field_len > avail) { 1127 + *pos = NULL; 1128 + return 0; 1129 + } 1130 + 1132 1131 if (str) 1133 1132 *str = *pos + bytes; 1134 1133 1135 - *pos += ((length + bytes) + 3) & ~0x03; 1134 + *pos += total_field_len; 1136 1135 1137 1136 return length; 1138 1137 } ··· 1163 1150 return val; 1164 1151 } 1165 1152 1166 - static inline void cs_dsp_coeff_parse_alg(struct cs_dsp *dsp, const u8 **data, 1167 - struct cs_dsp_coeff_parsed_alg *blk) 1153 + static int cs_dsp_coeff_parse_alg(struct cs_dsp *dsp, 1154 + const struct wmfw_region *region, 1155 + struct cs_dsp_coeff_parsed_alg *blk) 1168 1156 { 1169 1157 const struct wmfw_adsp_alg_data *raw; 1158 + unsigned int data_len = le32_to_cpu(region->len); 1159 + unsigned int pos; 1160 + const u8 *tmp; 1161 + 1162 + raw = (const struct wmfw_adsp_alg_data *)region->data; 1170 1163 1171 1164 switch (dsp->fw_ver) { 1172 1165 case 0: 1173 1166 case 1: 1174 - raw = (const struct wmfw_adsp_alg_data *)*data; 1175 - *data = raw->data; 1167 + if (sizeof(*raw) > data_len) 1168 + return -EOVERFLOW; 1176 1169 1177 1170 blk->id = le32_to_cpu(raw->id); 1178 1171 blk->name = raw->name; 1179 - blk->name_len = strlen(raw->name); 1172 + blk->name_len = strnlen(raw->name, ARRAY_SIZE(raw->name)); 1180 1173 blk->ncoeff = le32_to_cpu(raw->ncoeff); 1174 + 1175 + pos = sizeof(*raw); 1181 1176 break; 1182 1177 default: 1183 - blk->id = cs_dsp_coeff_parse_int(sizeof(raw->id), data); 1184 - blk->name_len = cs_dsp_coeff_parse_string(sizeof(u8), data, 1178 + if (sizeof(raw->id) > data_len) 1179 + return -EOVERFLOW; 1180 + 1181 + tmp = region->data; 1182 + blk->id = cs_dsp_coeff_parse_int(sizeof(raw->id), &tmp); 1183 + pos = tmp - region->data; 1184 + 1185 + tmp = &region->data[pos]; 1186 + blk->name_len = cs_dsp_coeff_parse_string(sizeof(u8), &tmp, data_len - pos, 1185 1187 &blk->name); 1186 - cs_dsp_coeff_parse_string(sizeof(u16), data, NULL); 1187 - blk->ncoeff = cs_dsp_coeff_parse_int(sizeof(raw->ncoeff), data); 1188 + if (!tmp) 1189 + return -EOVERFLOW; 1190 + 1191 + pos = tmp - region->data; 1192 + cs_dsp_coeff_parse_string(sizeof(u16), &tmp, data_len - pos, NULL); 1193 + if (!tmp) 1194 + return -EOVERFLOW; 1195 + 1196 + pos = tmp - region->data; 1197 + if (sizeof(raw->ncoeff) > (data_len - pos)) 1198 + return -EOVERFLOW; 1199 + 1200 + blk->ncoeff = cs_dsp_coeff_parse_int(sizeof(raw->ncoeff), &tmp); 1201 + pos += sizeof(raw->ncoeff); 1188 1202 break; 1189 1203 } 1204 + 1205 + if ((int)blk->ncoeff < 0) 1206 + return -EOVERFLOW; 1190 1207 1191 1208 cs_dsp_dbg(dsp, "Algorithm ID: %#x\n", blk->id); 1192 1209 cs_dsp_dbg(dsp, "Algorithm name: %.*s\n", blk->name_len, blk->name); 1193 1210 cs_dsp_dbg(dsp, "# of coefficient descriptors: %#x\n", blk->ncoeff); 1211 + 1212 + return pos; 1194 1213 } 1195 1214 1196 - static inline void cs_dsp_coeff_parse_coeff(struct cs_dsp *dsp, const u8 **data, 1197 - struct cs_dsp_coeff_parsed_coeff *blk) 1215 + static int cs_dsp_coeff_parse_coeff(struct cs_dsp *dsp, 1216 + const struct wmfw_region *region, 1217 + unsigned int pos, 1218 + struct cs_dsp_coeff_parsed_coeff *blk) 1198 1219 { 1199 1220 const struct wmfw_adsp_coeff_data *raw; 1221 + unsigned int data_len = le32_to_cpu(region->len); 1222 + unsigned int blk_len, blk_end_pos; 1200 1223 const u8 *tmp; 1201 - int length; 1224 + 1225 + raw = (const struct wmfw_adsp_coeff_data *)&region->data[pos]; 1226 + if (sizeof(raw->hdr) > (data_len - pos)) 1227 + return -EOVERFLOW; 1228 + 1229 + blk_len = le32_to_cpu(raw->hdr.size); 1230 + if (blk_len > S32_MAX) 1231 + return -EOVERFLOW; 1232 + 1233 + if (blk_len > (data_len - pos - sizeof(raw->hdr))) 1234 + return -EOVERFLOW; 1235 + 1236 + blk_end_pos = pos + sizeof(raw->hdr) + blk_len; 1237 + 1238 + blk->offset = le16_to_cpu(raw->hdr.offset); 1239 + blk->mem_type = le16_to_cpu(raw->hdr.type); 1202 1240 1203 1241 switch (dsp->fw_ver) { 1204 1242 case 0: 1205 1243 case 1: 1206 - raw = (const struct wmfw_adsp_coeff_data *)*data; 1207 - *data = *data + sizeof(raw->hdr) + le32_to_cpu(raw->hdr.size); 1244 + if (sizeof(*raw) > (data_len - pos)) 1245 + return -EOVERFLOW; 1208 1246 1209 - blk->offset = le16_to_cpu(raw->hdr.offset); 1210 - blk->mem_type = le16_to_cpu(raw->hdr.type); 1211 1247 blk->name = raw->name; 1212 - blk->name_len = strlen(raw->name); 1248 + blk->name_len = strnlen(raw->name, ARRAY_SIZE(raw->name)); 1213 1249 blk->ctl_type = le16_to_cpu(raw->ctl_type); 1214 1250 blk->flags = le16_to_cpu(raw->flags); 1215 1251 blk->len = le32_to_cpu(raw->len); 1216 1252 break; 1217 1253 default: 1218 - tmp = *data; 1219 - blk->offset = cs_dsp_coeff_parse_int(sizeof(raw->hdr.offset), &tmp); 1220 - blk->mem_type = cs_dsp_coeff_parse_int(sizeof(raw->hdr.type), &tmp); 1221 - length = cs_dsp_coeff_parse_int(sizeof(raw->hdr.size), &tmp); 1222 - blk->name_len = cs_dsp_coeff_parse_string(sizeof(u8), &tmp, 1254 + pos += sizeof(raw->hdr); 1255 + tmp = &region->data[pos]; 1256 + blk->name_len = cs_dsp_coeff_parse_string(sizeof(u8), &tmp, data_len - pos, 1223 1257 &blk->name); 1224 - cs_dsp_coeff_parse_string(sizeof(u8), &tmp, NULL); 1225 - cs_dsp_coeff_parse_string(sizeof(u16), &tmp, NULL); 1226 - blk->ctl_type = cs_dsp_coeff_parse_int(sizeof(raw->ctl_type), &tmp); 1227 - blk->flags = cs_dsp_coeff_parse_int(sizeof(raw->flags), &tmp); 1228 - blk->len = cs_dsp_coeff_parse_int(sizeof(raw->len), &tmp); 1258 + if (!tmp) 1259 + return -EOVERFLOW; 1229 1260 1230 - *data = *data + sizeof(raw->hdr) + length; 1261 + pos = tmp - region->data; 1262 + cs_dsp_coeff_parse_string(sizeof(u8), &tmp, data_len - pos, NULL); 1263 + if (!tmp) 1264 + return -EOVERFLOW; 1265 + 1266 + pos = tmp - region->data; 1267 + cs_dsp_coeff_parse_string(sizeof(u16), &tmp, data_len - pos, NULL); 1268 + if (!tmp) 1269 + return -EOVERFLOW; 1270 + 1271 + pos = tmp - region->data; 1272 + if (sizeof(raw->ctl_type) + sizeof(raw->flags) + sizeof(raw->len) > 1273 + (data_len - pos)) 1274 + return -EOVERFLOW; 1275 + 1276 + blk->ctl_type = cs_dsp_coeff_parse_int(sizeof(raw->ctl_type), &tmp); 1277 + pos += sizeof(raw->ctl_type); 1278 + blk->flags = cs_dsp_coeff_parse_int(sizeof(raw->flags), &tmp); 1279 + pos += sizeof(raw->flags); 1280 + blk->len = cs_dsp_coeff_parse_int(sizeof(raw->len), &tmp); 1231 1281 break; 1232 1282 } 1233 1283 ··· 1300 1224 cs_dsp_dbg(dsp, "\tCoefficient flags: %#x\n", blk->flags); 1301 1225 cs_dsp_dbg(dsp, "\tALSA control type: %#x\n", blk->ctl_type); 1302 1226 cs_dsp_dbg(dsp, "\tALSA control len: %#x\n", blk->len); 1227 + 1228 + return blk_end_pos; 1303 1229 } 1304 1230 1305 1231 static int cs_dsp_check_coeff_flags(struct cs_dsp *dsp, ··· 1325 1247 struct cs_dsp_alg_region alg_region = {}; 1326 1248 struct cs_dsp_coeff_parsed_alg alg_blk; 1327 1249 struct cs_dsp_coeff_parsed_coeff coeff_blk; 1328 - const u8 *data = region->data; 1329 - int i, ret; 1250 + int i, pos, ret; 1330 1251 1331 - cs_dsp_coeff_parse_alg(dsp, &data, &alg_blk); 1252 + pos = cs_dsp_coeff_parse_alg(dsp, region, &alg_blk); 1253 + if (pos < 0) 1254 + return pos; 1255 + 1332 1256 for (i = 0; i < alg_blk.ncoeff; i++) { 1333 - cs_dsp_coeff_parse_coeff(dsp, &data, &coeff_blk); 1257 + pos = cs_dsp_coeff_parse_coeff(dsp, region, pos, &coeff_blk); 1258 + if (pos < 0) 1259 + return pos; 1334 1260 1335 1261 switch (coeff_blk.ctl_type) { 1336 1262 case WMFW_CTL_TYPE_BYTES: ··· 1403 1321 const struct wmfw_adsp1_sizes *adsp1_sizes; 1404 1322 1405 1323 adsp1_sizes = (void *)&firmware->data[pos]; 1324 + if (sizeof(*adsp1_sizes) > firmware->size - pos) { 1325 + cs_dsp_err(dsp, "%s: file truncated\n", file); 1326 + return 0; 1327 + } 1406 1328 1407 1329 cs_dsp_dbg(dsp, "%s: %d DM, %d PM, %d ZM\n", file, 1408 1330 le32_to_cpu(adsp1_sizes->dm), le32_to_cpu(adsp1_sizes->pm), ··· 1423 1337 const struct wmfw_adsp2_sizes *adsp2_sizes; 1424 1338 1425 1339 adsp2_sizes = (void *)&firmware->data[pos]; 1340 + if (sizeof(*adsp2_sizes) > firmware->size - pos) { 1341 + cs_dsp_err(dsp, "%s: file truncated\n", file); 1342 + return 0; 1343 + } 1426 1344 1427 1345 cs_dsp_dbg(dsp, "%s: %d XM, %d YM %d PM, %d ZM\n", file, 1428 1346 le32_to_cpu(adsp2_sizes->xm), le32_to_cpu(adsp2_sizes->ym), ··· 1466 1376 struct regmap *regmap = dsp->regmap; 1467 1377 unsigned int pos = 0; 1468 1378 const struct wmfw_header *header; 1469 - const struct wmfw_adsp1_sizes *adsp1_sizes; 1470 1379 const struct wmfw_footer *footer; 1471 1380 const struct wmfw_region *region; 1472 1381 const struct cs_dsp_region *mem; ··· 1481 1392 1482 1393 ret = -EINVAL; 1483 1394 1484 - pos = sizeof(*header) + sizeof(*adsp1_sizes) + sizeof(*footer); 1485 - if (pos >= firmware->size) { 1486 - cs_dsp_err(dsp, "%s: file too short, %zu bytes\n", 1487 - file, firmware->size); 1395 + if (sizeof(*header) >= firmware->size) { 1396 + ret = -EOVERFLOW; 1488 1397 goto out_fw; 1489 1398 } 1490 1399 ··· 1510 1423 1511 1424 pos = sizeof(*header); 1512 1425 pos = dsp->ops->parse_sizes(dsp, file, pos, firmware); 1426 + if ((pos == 0) || (sizeof(*footer) > firmware->size - pos)) { 1427 + ret = -EOVERFLOW; 1428 + goto out_fw; 1429 + } 1513 1430 1514 1431 footer = (void *)&firmware->data[pos]; 1515 1432 pos += sizeof(*footer); 1516 1433 1517 1434 if (le32_to_cpu(header->len) != pos) { 1518 - cs_dsp_err(dsp, "%s: unexpected header length %d\n", 1519 - file, le32_to_cpu(header->len)); 1435 + ret = -EOVERFLOW; 1520 1436 goto out_fw; 1521 1437 } 1522 1438 1523 1439 cs_dsp_dbg(dsp, "%s: timestamp %llu\n", file, 1524 1440 le64_to_cpu(footer->timestamp)); 1525 1441 1526 - while (pos < firmware->size && 1527 - sizeof(*region) < firmware->size - pos) { 1442 + while (pos < firmware->size) { 1443 + /* Is there enough data for a complete block header? */ 1444 + if (sizeof(*region) > firmware->size - pos) { 1445 + ret = -EOVERFLOW; 1446 + goto out_fw; 1447 + } 1448 + 1528 1449 region = (void *)&(firmware->data[pos]); 1450 + 1451 + if (le32_to_cpu(region->len) > firmware->size - pos - sizeof(*region)) { 1452 + ret = -EOVERFLOW; 1453 + goto out_fw; 1454 + } 1455 + 1529 1456 region_name = "Unknown"; 1530 1457 reg = 0; 1531 1458 text = NULL; ··· 1596 1495 regions, le32_to_cpu(region->len), offset, 1597 1496 region_name); 1598 1497 1599 - if (le32_to_cpu(region->len) > 1600 - firmware->size - pos - sizeof(*region)) { 1601 - cs_dsp_err(dsp, 1602 - "%s.%d: %s region len %d bytes exceeds file length %zu\n", 1603 - file, regions, region_name, 1604 - le32_to_cpu(region->len), firmware->size); 1605 - ret = -EINVAL; 1606 - goto out_fw; 1607 - } 1608 - 1609 1498 if (text) { 1610 1499 memcpy(text, region->data, le32_to_cpu(region->len)); 1611 1500 cs_dsp_info(dsp, "%s: %s\n", file, text); ··· 1645 1554 regmap_async_complete(regmap); 1646 1555 cs_dsp_buf_free(&buf_list); 1647 1556 kfree(text); 1557 + 1558 + if (ret == -EOVERFLOW) 1559 + cs_dsp_err(dsp, "%s: file content overflows file data\n", file); 1648 1560 1649 1561 return ret; 1650 1562 } ··· 2216 2122 pos = le32_to_cpu(hdr->len); 2217 2123 2218 2124 blocks = 0; 2219 - while (pos < firmware->size && 2220 - sizeof(*blk) < firmware->size - pos) { 2125 + while (pos < firmware->size) { 2126 + /* Is there enough data for a complete block header? */ 2127 + if (sizeof(*blk) > firmware->size - pos) { 2128 + ret = -EOVERFLOW; 2129 + goto out_fw; 2130 + } 2131 + 2221 2132 blk = (void *)(&firmware->data[pos]); 2133 + 2134 + if (le32_to_cpu(blk->len) > firmware->size - pos - sizeof(*blk)) { 2135 + ret = -EOVERFLOW; 2136 + goto out_fw; 2137 + } 2222 2138 2223 2139 type = le16_to_cpu(blk->type); 2224 2140 offset = le16_to_cpu(blk->offset); ··· 2326 2222 } 2327 2223 2328 2224 if (reg) { 2329 - if (le32_to_cpu(blk->len) > 2330 - firmware->size - pos - sizeof(*blk)) { 2331 - cs_dsp_err(dsp, 2332 - "%s.%d: %s region len %d bytes exceeds file length %zu\n", 2333 - file, blocks, region_name, 2334 - le32_to_cpu(blk->len), 2335 - firmware->size); 2336 - ret = -EINVAL; 2337 - goto out_fw; 2338 - } 2339 - 2340 2225 buf = cs_dsp_buf_alloc(blk->data, 2341 2226 le32_to_cpu(blk->len), 2342 2227 &buf_list); ··· 2365 2272 regmap_async_complete(regmap); 2366 2273 cs_dsp_buf_free(&buf_list); 2367 2274 kfree(text); 2275 + 2276 + if (ret == -EOVERFLOW) 2277 + cs_dsp_err(dsp, "%s: file content overflows file data\n", file); 2278 + 2368 2279 return ret; 2369 2280 } 2370 2281

+2 -2

sound/pci/hda/cs35l41_hda_property.c

··· 128 128 { "17AA38B5", 2, EXTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, 0, 0 }, 0, 1, -1, 0, 0, 0 }, 129 129 { "17AA38B6", 2, EXTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, 0, 0 }, 0, 1, -1, 0, 0, 0 }, 130 130 { "17AA38B7", 2, EXTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, 0, 0 }, 0, 1, -1, 0, 0, 0 }, 131 - { "17AA38C7", 4, INTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, CS35L41_LEFT, CS35L41_RIGHT }, 0, 2, -1, 1000, 4500, 24 }, 132 - { "17AA38C8", 4, INTERNAL, { CS35L41_LEFT, CS35L41_RIGHT, CS35L41_LEFT, CS35L41_RIGHT }, 0, 2, -1, 1000, 4500, 24 }, 131 + { "17AA38C7", 4, INTERNAL, { CS35L41_RIGHT, CS35L41_LEFT, CS35L41_RIGHT, CS35L41_LEFT }, 0, 2, -1, 1000, 4500, 24 }, 132 + { "17AA38C8", 4, INTERNAL, { CS35L41_RIGHT, CS35L41_LEFT, CS35L41_RIGHT, CS35L41_LEFT }, 0, 2, -1, 1000, 4500, 24 }, 133 133 { "17AA38F9", 2, EXTERNAL, { CS35L41_RIGHT, CS35L41_LEFT, 0, 0 }, 0, 2, -1, 0, 0, 0 }, 134 134 { "17AA38FA", 2, EXTERNAL, { CS35L41_RIGHT, CS35L41_LEFT, 0, 0 }, 0, 2, -1, 0, 0, 0 }, 135 135 {}

+4

sound/pci/hda/patch_realtek.c

··· 10053 10053 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10054 10054 SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10055 10055 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10056 + SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10056 10057 SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10057 10058 SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN), 10058 10059 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), ··· 10384 10383 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 10385 10384 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), 10386 10385 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), 10386 + SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10387 10387 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10388 10388 SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10389 10389 SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), ··· 10482 10480 SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10483 10481 SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10484 10482 SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10483 + SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10485 10484 SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10486 10485 SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10487 10486 SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), ··· 10658 10655 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), 10659 10656 SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC), 10660 10657 SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 10658 + SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10661 10659 SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO), 10662 10660 SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME), 10663 10661 SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),

+2

sound/soc/codecs/rt711-sdw.c

··· 38 38 case 0x8300 ... 0x83ff: 39 39 case 0x9c00 ... 0x9cff: 40 40 case 0xb900 ... 0xb9ff: 41 + case 0x752008: 41 42 case 0x752009: 43 + case 0x75200b: 42 44 case 0x752011: 43 45 case 0x75201a: 44 46 case 0x752045:

+6 -6

sound/soc/sof/intel/hda-dai.c

··· 617 617 sdai = swidget->private; 618 618 ops = sdai->platform_private; 619 619 620 - ret = hda_link_dma_cleanup(hext_stream->link_substream, 621 - hext_stream, 622 - cpu_dai); 623 - if (ret < 0) 624 - return ret; 625 - 626 620 /* for consistency with TRIGGER_SUSPEND */ 627 621 if (ops->post_trigger) { 628 622 ret = ops->post_trigger(sdev, cpu_dai, ··· 625 631 if (ret < 0) 626 632 return ret; 627 633 } 634 + 635 + ret = hda_link_dma_cleanup(hext_stream->link_substream, 636 + hext_stream, 637 + cpu_dai); 638 + if (ret < 0) 639 + return ret; 628 640 } 629 641 } 630 642

+6

sound/soc/sof/intel/hda-pcm.c

··· 258 258 snd_pcm_hw_constraint_integer(substream->runtime, 259 259 SNDRV_PCM_HW_PARAM_PERIODS); 260 260 261 + /* Limit the maximum number of periods to not exceed the BDL entries count */ 262 + if (runtime->hw.periods_max > HDA_DSP_MAX_BDL_ENTRIES) 263 + snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS, 264 + runtime->hw.periods_min, 265 + HDA_DSP_MAX_BDL_ENTRIES); 266 + 261 267 /* Only S16 and S32 supported by HDA hardware when used without DSP */ 262 268 if (sdev->dspless_mode_selected) 263 269 snd_pcm_hw_constraint_mask64(substream->runtime, SNDRV_PCM_HW_PARAM_FORMAT,

Configure Feed

Configure Feed