1 // SPDX-License-Identifier: GPL-2.0 OR MIT 2 3 /* 4 * Xen para-virtual sound device 5 * 6 * Copyright (C) 2016-2018 EPAM Systems Inc. 7 * 8 * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com> 9 */ 10 11 #include <xen/xenbus.h> 12 13 #include <xen/interface/io/sndif.h> 14 15 #include "xen_snd_front.h" 16 #include "xen_snd_front_cfg.h" 17 18 /* Maximum number of supported streams. */ 19 #define VSND_MAX_STREAM 8 20 21 struct cfg_hw_sample_rate { 22 const char *name; 23 unsigned int mask; 24 unsigned int value; 25 }; 26 27 static const struct cfg_hw_sample_rate CFG_HW_SUPPORTED_RATES[] = { 28 { .name = "5512", .mask = SNDRV_PCM_RATE_5512, .value = 5512 }, 29 { .name = "8000", .mask = SNDRV_PCM_RATE_8000, .value = 8000 }, 30 { .name = "11025", .mask = SNDRV_PCM_RATE_11025, .value = 11025 }, 31 { .name = "16000", .mask = SNDRV_PCM_RATE_16000, .value = 16000 }, 32 { .name = "22050", .mask = SNDRV_PCM_RATE_22050, .value = 22050 }, 33 { .name = "32000", .mask = SNDRV_PCM_RATE_32000, .value = 32000 }, 34 { .name = "44100", .mask = SNDRV_PCM_RATE_44100, .value = 44100 }, 35 { .name = "48000", .mask = SNDRV_PCM_RATE_48000, .value = 48000 }, 36 { .name = "64000", .mask = SNDRV_PCM_RATE_64000, .value = 64000 }, 37 { .name = "96000", .mask = SNDRV_PCM_RATE_96000, .value = 96000 }, 38 { .name = "176400", .mask = SNDRV_PCM_RATE_176400, .value = 176400 }, 39 { .name = "192000", .mask = SNDRV_PCM_RATE_192000, .value = 192000 }, 40 }; 41 42 struct cfg_hw_sample_format { 43 const char *name; 44 u64 mask; 45 }; 46 47 static const struct cfg_hw_sample_format CFG_HW_SUPPORTED_FORMATS[] = { 48 { 49 .name = XENSND_PCM_FORMAT_U8_STR, 50 .mask = SNDRV_PCM_FMTBIT_U8 51 }, 52 { 53 .name = XENSND_PCM_FORMAT_S8_STR, 54 .mask = SNDRV_PCM_FMTBIT_S8 55 }, 56 { 57 .name = XENSND_PCM_FORMAT_U16_LE_STR, 58 .mask = SNDRV_PCM_FMTBIT_U16_LE 59 }, 60 { 61 .name = XENSND_PCM_FORMAT_U16_BE_STR, 62 .mask = SNDRV_PCM_FMTBIT_U16_BE 63 }, 64 { 65 .name = XENSND_PCM_FORMAT_S16_LE_STR, 66 .mask = SNDRV_PCM_FMTBIT_S16_LE 67 }, 68 { 69 .name = XENSND_PCM_FORMAT_S16_BE_STR, 70 .mask = SNDRV_PCM_FMTBIT_S16_BE 71 }, 72 { 73 .name = XENSND_PCM_FORMAT_U24_LE_STR, 74 .mask = SNDRV_PCM_FMTBIT_U24_LE 75 }, 76 { 77 .name = XENSND_PCM_FORMAT_U24_BE_STR, 78 .mask = SNDRV_PCM_FMTBIT_U24_BE 79 }, 80 { 81 .name = XENSND_PCM_FORMAT_S24_LE_STR, 82 .mask = SNDRV_PCM_FMTBIT_S24_LE 83 }, 84 { 85 .name = XENSND_PCM_FORMAT_S24_BE_STR, 86 .mask = SNDRV_PCM_FMTBIT_S24_BE 87 }, 88 { 89 .name = XENSND_PCM_FORMAT_U32_LE_STR, 90 .mask = SNDRV_PCM_FMTBIT_U32_LE 91 }, 92 { 93 .name = XENSND_PCM_FORMAT_U32_BE_STR, 94 .mask = SNDRV_PCM_FMTBIT_U32_BE 95 }, 96 { 97 .name = XENSND_PCM_FORMAT_S32_LE_STR, 98 .mask = SNDRV_PCM_FMTBIT_S32_LE 99 }, 100 { 101 .name = XENSND_PCM_FORMAT_S32_BE_STR, 102 .mask = SNDRV_PCM_FMTBIT_S32_BE 103 }, 104 { 105 .name = XENSND_PCM_FORMAT_A_LAW_STR, 106 .mask = SNDRV_PCM_FMTBIT_A_LAW 107 }, 108 { 109 .name = XENSND_PCM_FORMAT_MU_LAW_STR, 110 .mask = SNDRV_PCM_FMTBIT_MU_LAW 111 }, 112 { 113 .name = XENSND_PCM_FORMAT_F32_LE_STR, 114 .mask = SNDRV_PCM_FMTBIT_FLOAT_LE 115 }, 116 { 117 .name = XENSND_PCM_FORMAT_F32_BE_STR, 118 .mask = SNDRV_PCM_FMTBIT_FLOAT_BE 119 }, 120 { 121 .name = XENSND_PCM_FORMAT_F64_LE_STR, 122 .mask = SNDRV_PCM_FMTBIT_FLOAT64_LE 123 }, 124 { 125 .name = XENSND_PCM_FORMAT_F64_BE_STR, 126 .mask = SNDRV_PCM_FMTBIT_FLOAT64_BE 127 }, 128 { 129 .name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_LE_STR, 130 .mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE 131 }, 132 { 133 .name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_BE_STR, 134 .mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE 135 }, 136 { 137 .name = XENSND_PCM_FORMAT_IMA_ADPCM_STR, 138 .mask = SNDRV_PCM_FMTBIT_IMA_ADPCM 139 }, 140 { 141 .name = XENSND_PCM_FORMAT_MPEG_STR, 142 .mask = SNDRV_PCM_FMTBIT_MPEG 143 }, 144 { 145 .name = XENSND_PCM_FORMAT_GSM_STR, 146 .mask = SNDRV_PCM_FMTBIT_GSM 147 }, 148 }; 149 150 static void cfg_hw_rates(char *list, unsigned int len, 151 const char *path, struct snd_pcm_hardware *pcm_hw) 152 { 153 char *cur_rate; 154 unsigned int cur_mask; 155 unsigned int cur_value; 156 unsigned int rates; 157 unsigned int rate_min; 158 unsigned int rate_max; 159 int i; 160 161 rates = 0; 162 rate_min = -1; 163 rate_max = 0; 164 while ((cur_rate = strsep(&list, XENSND_LIST_SEPARATOR))) { 165 for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_RATES); i++) 166 if (!strncasecmp(cur_rate, 167 CFG_HW_SUPPORTED_RATES[i].name, 168 XENSND_SAMPLE_RATE_MAX_LEN)) { 169 cur_mask = CFG_HW_SUPPORTED_RATES[i].mask; 170 cur_value = CFG_HW_SUPPORTED_RATES[i].value; 171 rates |= cur_mask; 172 if (rate_min > cur_value) 173 rate_min = cur_value; 174 if (rate_max < cur_value) 175 rate_max = cur_value; 176 } 177 } 178 179 if (rates) { 180 pcm_hw->rates = rates; 181 pcm_hw->rate_min = rate_min; 182 pcm_hw->rate_max = rate_max; 183 } 184 } 185 186 static void cfg_formats(char *list, unsigned int len, 187 const char *path, struct snd_pcm_hardware *pcm_hw) 188 { 189 u64 formats; 190 char *cur_format; 191 int i; 192 193 formats = 0; 194 while ((cur_format = strsep(&list, XENSND_LIST_SEPARATOR))) { 195 for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_FORMATS); i++) 196 if (!strncasecmp(cur_format, 197 CFG_HW_SUPPORTED_FORMATS[i].name, 198 XENSND_SAMPLE_FORMAT_MAX_LEN)) 199 formats |= CFG_HW_SUPPORTED_FORMATS[i].mask; 200 } 201 202 if (formats) 203 pcm_hw->formats = formats; 204 } 205 206 #define MAX_BUFFER_SIZE (64 * 1024) 207 #define MIN_PERIOD_SIZE 64 208 #define MAX_PERIOD_SIZE MAX_BUFFER_SIZE 209 #define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | \ 210 SNDRV_PCM_FMTBIT_S16_LE) 211 #define USE_RATE (SNDRV_PCM_RATE_CONTINUOUS | \ 212 SNDRV_PCM_RATE_8000_48000) 213 #define USE_RATE_MIN 5512 214 #define USE_RATE_MAX 48000 215 #define USE_CHANNELS_MIN 1 216 #define USE_CHANNELS_MAX 2 217 #define USE_PERIODS_MIN 2 218 #define USE_PERIODS_MAX (MAX_BUFFER_SIZE / MIN_PERIOD_SIZE) 219 220 static const struct snd_pcm_hardware SND_DRV_PCM_HW_DEFAULT = { 221 .info = (SNDRV_PCM_INFO_MMAP | 222 SNDRV_PCM_INFO_INTERLEAVED | 223 SNDRV_PCM_INFO_RESUME | 224 SNDRV_PCM_INFO_MMAP_VALID), 225 .formats = USE_FORMATS, 226 .rates = USE_RATE, 227 .rate_min = USE_RATE_MIN, 228 .rate_max = USE_RATE_MAX, 229 .channels_min = USE_CHANNELS_MIN, 230 .channels_max = USE_CHANNELS_MAX, 231 .buffer_bytes_max = MAX_BUFFER_SIZE, 232 .period_bytes_min = MIN_PERIOD_SIZE, 233 .period_bytes_max = MAX_PERIOD_SIZE, 234 .periods_min = USE_PERIODS_MIN, 235 .periods_max = USE_PERIODS_MAX, 236 .fifo_size = 0, 237 }; 238 239 static void cfg_read_pcm_hw(const char *path, 240 struct snd_pcm_hardware *parent_pcm_hw, 241 struct snd_pcm_hardware *pcm_hw) 242 { 243 char *list; 244 int val; 245 size_t buf_sz; 246 unsigned int len; 247 248 /* Inherit parent's PCM HW and read overrides from XenStore. */ 249 if (parent_pcm_hw) 250 *pcm_hw = *parent_pcm_hw; 251 else 252 *pcm_hw = SND_DRV_PCM_HW_DEFAULT; 253 254 val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MIN, 0); 255 if (val) 256 pcm_hw->channels_min = val; 257 258 val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MAX, 0); 259 if (val) 260 pcm_hw->channels_max = val; 261 262 list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_RATES, &len); 263 if (!IS_ERR(list)) { 264 cfg_hw_rates(list, len, path, pcm_hw); 265 kfree(list); 266 } 267 268 list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_FORMATS, &len); 269 if (!IS_ERR(list)) { 270 cfg_formats(list, len, path, pcm_hw); 271 kfree(list); 272 } 273 274 buf_sz = xenbus_read_unsigned(path, XENSND_FIELD_BUFFER_SIZE, 0); 275 if (buf_sz) 276 pcm_hw->buffer_bytes_max = buf_sz; 277 278 /* Update configuration to match new values. */ 279 if (pcm_hw->channels_min > pcm_hw->channels_max) 280 pcm_hw->channels_min = pcm_hw->channels_max; 281 282 if (pcm_hw->rate_min > pcm_hw->rate_max) 283 pcm_hw->rate_min = pcm_hw->rate_max; 284 285 pcm_hw->period_bytes_max = pcm_hw->buffer_bytes_max; 286 287 pcm_hw->periods_max = pcm_hw->period_bytes_max / 288 pcm_hw->period_bytes_min; 289 } 290 291 static int cfg_get_stream_type(const char *path, int index, 292 int *num_pb, int *num_cap) 293 { 294 char *str = NULL; 295 char *stream_path; 296 int ret; 297 298 *num_pb = 0; 299 *num_cap = 0; 300 stream_path = kasprintf(GFP_KERNEL, "%s/%d", path, index); 301 if (!stream_path) { 302 ret = -ENOMEM; 303 goto fail; 304 } 305 306 str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL); 307 if (IS_ERR(str)) { 308 ret = PTR_ERR(str); 309 str = NULL; 310 goto fail; 311 } 312 313 if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK, 314 sizeof(XENSND_STREAM_TYPE_PLAYBACK))) { 315 (*num_pb)++; 316 } else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE, 317 sizeof(XENSND_STREAM_TYPE_CAPTURE))) { 318 (*num_cap)++; 319 } else { 320 ret = -EINVAL; 321 goto fail; 322 } 323 ret = 0; 324 325 fail: 326 kfree(stream_path); 327 kfree(str); 328 return ret; 329 } 330 331 static int cfg_stream(struct xen_snd_front_info *front_info, 332 struct xen_front_cfg_pcm_instance *pcm_instance, 333 const char *path, int index, int *cur_pb, int *cur_cap, 334 int *stream_cnt) 335 { 336 char *str = NULL; 337 char *stream_path; 338 struct xen_front_cfg_stream *stream; 339 int ret; 340 341 stream_path = devm_kasprintf(&front_info->xb_dev->dev, 342 GFP_KERNEL, "%s/%d", path, index); 343 if (!stream_path) { 344 ret = -ENOMEM; 345 goto fail; 346 } 347 348 str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL); 349 if (IS_ERR(str)) { 350 ret = PTR_ERR(str); 351 str = NULL; 352 goto fail; 353 } 354 355 if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK, 356 sizeof(XENSND_STREAM_TYPE_PLAYBACK))) { 357 stream = &pcm_instance->streams_pb[(*cur_pb)++]; 358 } else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE, 359 sizeof(XENSND_STREAM_TYPE_CAPTURE))) { 360 stream = &pcm_instance->streams_cap[(*cur_cap)++]; 361 } else { 362 ret = -EINVAL; 363 goto fail; 364 } 365 366 /* Get next stream index. */ 367 stream->index = (*stream_cnt)++; 368 stream->xenstore_path = stream_path; 369 /* 370 * Check XenStore if PCM HW configuration exists for this stream 371 * and update if so, e.g. we inherit all values from device's PCM HW, 372 * but can still override some of the values for the stream. 373 */ 374 cfg_read_pcm_hw(stream->xenstore_path, 375 &pcm_instance->pcm_hw, &stream->pcm_hw); 376 ret = 0; 377 378 fail: 379 kfree(str); 380 return ret; 381 } 382 383 static int cfg_device(struct xen_snd_front_info *front_info, 384 struct xen_front_cfg_pcm_instance *pcm_instance, 385 struct snd_pcm_hardware *parent_pcm_hw, 386 const char *path, int node_index, int *stream_cnt) 387 { 388 char *str; 389 char *device_path; 390 int ret, i, num_streams; 391 int num_pb, num_cap; 392 int cur_pb, cur_cap; 393 char node[3]; 394 395 device_path = kasprintf(GFP_KERNEL, "%s/%d", path, node_index); 396 if (!device_path) 397 return -ENOMEM; 398 399 str = xenbus_read(XBT_NIL, device_path, XENSND_FIELD_DEVICE_NAME, NULL); 400 if (!IS_ERR(str)) { 401 strscpy(pcm_instance->name, str, sizeof(pcm_instance->name)); 402 kfree(str); 403 } 404 405 pcm_instance->device_id = node_index; 406 407 /* 408 * Check XenStore if PCM HW configuration exists for this device 409 * and update if so, e.g. we inherit all values from card's PCM HW, 410 * but can still override some of the values for the device. 411 */ 412 cfg_read_pcm_hw(device_path, parent_pcm_hw, &pcm_instance->pcm_hw); 413 414 /* Find out how many streams were configured in Xen store. */ 415 num_streams = 0; 416 do { 417 snprintf(node, sizeof(node), "%d", num_streams); 418 if (!xenbus_exists(XBT_NIL, device_path, node)) 419 break; 420 421 num_streams++; 422 } while (num_streams < VSND_MAX_STREAM); 423 424 pcm_instance->num_streams_pb = 0; 425 pcm_instance->num_streams_cap = 0; 426 /* Get number of playback and capture streams. */ 427 for (i = 0; i < num_streams; i++) { 428 ret = cfg_get_stream_type(device_path, i, &num_pb, &num_cap); 429 if (ret < 0) 430 goto fail; 431 432 pcm_instance->num_streams_pb += num_pb; 433 pcm_instance->num_streams_cap += num_cap; 434 } 435 436 if (pcm_instance->num_streams_pb) { 437 pcm_instance->streams_pb = 438 devm_kcalloc(&front_info->xb_dev->dev, 439 pcm_instance->num_streams_pb, 440 sizeof(struct xen_front_cfg_stream), 441 GFP_KERNEL); 442 if (!pcm_instance->streams_pb) { 443 ret = -ENOMEM; 444 goto fail; 445 } 446 } 447 448 if (pcm_instance->num_streams_cap) { 449 pcm_instance->streams_cap = 450 devm_kcalloc(&front_info->xb_dev->dev, 451 pcm_instance->num_streams_cap, 452 sizeof(struct xen_front_cfg_stream), 453 GFP_KERNEL); 454 if (!pcm_instance->streams_cap) { 455 ret = -ENOMEM; 456 goto fail; 457 } 458 } 459 460 cur_pb = 0; 461 cur_cap = 0; 462 for (i = 0; i < num_streams; i++) { 463 ret = cfg_stream(front_info, pcm_instance, device_path, i, 464 &cur_pb, &cur_cap, stream_cnt); 465 if (ret < 0) 466 goto fail; 467 } 468 ret = 0; 469 470 fail: 471 kfree(device_path); 472 return ret; 473 } 474 475 int xen_snd_front_cfg_card(struct xen_snd_front_info *front_info, 476 int *stream_cnt) 477 { 478 struct xenbus_device *xb_dev = front_info->xb_dev; 479 struct xen_front_cfg_card *cfg = &front_info->cfg; 480 int ret, num_devices, i; 481 char node[3]; 482 483 *stream_cnt = 0; 484 num_devices = 0; 485 do { 486 scnprintf(node, sizeof(node), "%d", num_devices); 487 if (!xenbus_exists(XBT_NIL, xb_dev->nodename, node)) 488 break; 489 490 num_devices++; 491 } while (num_devices < SNDRV_PCM_DEVICES); 492 493 if (!num_devices) { 494 dev_warn(&xb_dev->dev, 495 "No devices configured for sound card at %s\n", 496 xb_dev->nodename); 497 return -ENODEV; 498 } 499 500 /* Start from default PCM HW configuration for the card. */ 501 cfg_read_pcm_hw(xb_dev->nodename, NULL, &cfg->pcm_hw); 502 503 cfg->pcm_instances = 504 devm_kcalloc(&front_info->xb_dev->dev, num_devices, 505 sizeof(struct xen_front_cfg_pcm_instance), 506 GFP_KERNEL); 507 if (!cfg->pcm_instances) 508 return -ENOMEM; 509 510 for (i = 0; i < num_devices; i++) { 511 ret = cfg_device(front_info, &cfg->pcm_instances[i], 512 &cfg->pcm_hw, xb_dev->nodename, i, stream_cnt); 513 if (ret < 0) 514 return ret; 515 } 516 cfg->num_pcm_instances = num_devices; 517 return 0; 518 } 519 520