sound/pci/asihpi/asihpi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  Asihpi soundcard
   4  *  Copyright (c) by AudioScience Inc <support@audioscience.com>
   5  *
   6  *  The following is not a condition of use, merely a request:
   7  *  If you modify this program, particularly if you fix errors, AudioScience Inc
   8  *  would appreciate it if you grant us the right to use those modifications
   9  *  for any purpose including commercial applications.
  10  */
  11
  12 #include "hpi_internal.h"
  13 #include "hpi_version.h"
  14 #include "hpimsginit.h"
  15 #include "hpioctl.h"
  16 #include "hpicmn.h"
  17
  18 #include <linux/pci.h>
  19 #include <linux/init.h>
  20 #include <linux/jiffies.h>
  21 #include <linux/slab.h>
  22 #include <linux/time.h>
  23 #include <linux/wait.h>
  24 #include <linux/module.h>
  25 #include <sound/core.h>
  26 #include <sound/control.h>
  27 #include <sound/pcm.h>
  28 #include <sound/pcm_params.h>
  29 #include <sound/info.h>
  30 #include <sound/initval.h>
  31 #include <sound/tlv.h>
  32 #include <sound/hwdep.h>
  33
  34 MODULE_LICENSE("GPL");
  35 MODULE_AUTHOR("AudioScience inc. <support@audioscience.com>");
  36 MODULE_DESCRIPTION("AudioScience ALSA ASI5xxx ASI6xxx ASI87xx ASI89xx "
  37                         HPI_VER_STRING);
  38
  39 #if defined CONFIG_SND_DEBUG_VERBOSE
  40 /**
  41  * snd_printddd - very verbose debug printk
  42  * @format: format string
  43  *
  44  * Works like snd_printk() for debugging purposes.
  45  * Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
  46  * Must set snd module debug parameter to 3 to enable at runtime.
  47  */
  48 #define snd_printddd(format, args...) \
  49         __snd_printk(3, __FILE__, __LINE__, format, ##args)
  50 #else
  51 #define snd_printddd(format, args...) do { } while (0)
  52 #endif
  53
  54 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* index 0-MAX */
  55 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  56 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  57 static bool enable_hpi_hwdep = 1;
  58
  59 module_param_array(index, int, NULL, 0444);
  60 MODULE_PARM_DESC(index, "ALSA index value for AudioScience soundcard.");
  61
  62 module_param_array(id, charp, NULL, 0444);
  63 MODULE_PARM_DESC(id, "ALSA ID string for AudioScience soundcard.");
  64
  65 module_param_array(enable, bool, NULL, 0444);
  66 MODULE_PARM_DESC(enable, "ALSA enable AudioScience soundcard.");
  67
  68 module_param(enable_hpi_hwdep, bool, 0644);
  69 MODULE_PARM_DESC(enable_hpi_hwdep,
  70                 "ALSA enable HPI hwdep for AudioScience soundcard ");
  71
  72 /* identify driver */
  73 #ifdef KERNEL_ALSA_BUILD
  74 static char *build_info = "Built using headers from kernel source";
  75 module_param(build_info, charp, 0444);
  76 MODULE_PARM_DESC(build_info, "Built using headers from kernel source");
  77 #else
  78 static char *build_info = "Built within ALSA source";
  79 module_param(build_info, charp, 0444);
  80 MODULE_PARM_DESC(build_info, "Built within ALSA source");
  81 #endif
  82
  83 /* set to 1 to dump every control from adapter to log */
  84 static const int mixer_dump;
  85
  86 #define DEFAULT_SAMPLERATE 44100
  87 static int adapter_fs = DEFAULT_SAMPLERATE;
  88
  89 /* defaults */
  90 #define PERIODS_MIN 2
  91 #define PERIOD_BYTES_MIN  2048
  92 #define BUFFER_BYTES_MAX (512 * 1024)
  93
  94 #define MAX_CLOCKSOURCES (HPI_SAMPLECLOCK_SOURCE_LAST + 1 + 7)
  95
  96 struct clk_source {
  97         int source;
  98         int index;
  99         const char *name;
 100 };
 101
 102 struct clk_cache {
 103         int count;
 104         int has_local;
 105         struct clk_source s[MAX_CLOCKSOURCES];
 106 };
 107
 108 /* Per card data */
 109 struct snd_card_asihpi {
 110         struct snd_card *card;
 111         struct pci_dev *pci;
 112         struct hpi_adapter *hpi;
 113
 114         /* In low latency mode there is only one stream, a pointer to its
 115          * private data is stored here on trigger and cleared on stop.
 116          * The interrupt handler uses it as a parameter when calling
 117          * snd_card_asihpi_timer_function().
 118          */
 119         struct snd_card_asihpi_pcm *llmode_streampriv;
 120         void (*pcm_start)(struct snd_pcm_substream *substream);
 121         void (*pcm_stop)(struct snd_pcm_substream *substream);
 122
 123         u32 h_mixer;
 124         struct clk_cache cc;
 125
 126         u16 can_dma;
 127         u16 support_grouping;
 128         u16 support_mrx;
 129         u16 update_interval_frames;
 130         u16 in_max_chans;
 131         u16 out_max_chans;
 132         u16 in_min_chans;
 133         u16 out_min_chans;
 134 };
 135
 136 /* Per stream data */
 137 struct snd_card_asihpi_pcm {
 138         struct timer_list timer;
 139         unsigned int respawn_timer;
 140         unsigned int hpi_buffer_attached;
 141         unsigned int buffer_bytes;
 142         unsigned int period_bytes;
 143         unsigned int bytes_per_sec;
 144         unsigned int pcm_buf_host_rw_ofs; /* Host R/W pos */
 145         unsigned int pcm_buf_dma_ofs;   /* DMA R/W offset in buffer */
 146         unsigned int pcm_buf_elapsed_dma_ofs;   /* DMA R/W offset in buffer */
 147         unsigned int drained_count;
 148         struct snd_pcm_substream *substream;
 149         u32 h_stream;
 150         struct hpi_format format;
 151 };
 152
 153 /* universal stream verbs work with out or in stream handles */
 154
 155 /* Functions to allow driver to give a buffer to HPI for busmastering */
 156
 157 static u16 hpi_stream_host_buffer_attach(
 158         u32 h_stream,   /* handle to outstream. */
 159         u32 size_in_bytes, /* size in bytes of bus mastering buffer */
 160         u32 pci_address
 161 )
 162 {
 163         struct hpi_message hm;
 164         struct hpi_response hr;
 165         unsigned int obj = hpi_handle_object(h_stream);
 166
 167         if (!h_stream)
 168                 return HPI_ERROR_INVALID_OBJ;
 169         hpi_init_message_response(&hm, &hr, obj,
 170                         obj == HPI_OBJ_OSTREAM ?
 171                                 HPI_OSTREAM_HOSTBUFFER_ALLOC :
 172                                 HPI_ISTREAM_HOSTBUFFER_ALLOC);
 173
 174         hpi_handle_to_indexes(h_stream, &hm.adapter_index,
 175                                 &hm.obj_index);
 176
 177         hm.u.d.u.buffer.buffer_size = size_in_bytes;
 178         hm.u.d.u.buffer.pci_address = pci_address;
 179         hm.u.d.u.buffer.command = HPI_BUFFER_CMD_INTERNAL_GRANTADAPTER;
 180         hpi_send_recv(&hm, &hr);
 181         return hr.error;
 182 }
 183
 184 static u16 hpi_stream_host_buffer_detach(u32  h_stream)
 185 {
 186         struct hpi_message hm;
 187         struct hpi_response hr;
 188         unsigned int obj = hpi_handle_object(h_stream);
 189
 190         if (!h_stream)
 191                 return HPI_ERROR_INVALID_OBJ;
 192
 193         hpi_init_message_response(&hm, &hr,  obj,
 194                         obj == HPI_OBJ_OSTREAM ?
 195                                 HPI_OSTREAM_HOSTBUFFER_FREE :
 196                                 HPI_ISTREAM_HOSTBUFFER_FREE);
 197
 198         hpi_handle_to_indexes(h_stream, &hm.adapter_index,
 199                                 &hm.obj_index);
 200         hm.u.d.u.buffer.command = HPI_BUFFER_CMD_INTERNAL_REVOKEADAPTER;
 201         hpi_send_recv(&hm, &hr);
 202         return hr.error;
 203 }
 204
 205 static inline u16 hpi_stream_start(u32 h_stream)
 206 {
 207         if (hpi_handle_object(h_stream) ==  HPI_OBJ_OSTREAM)
 208                 return hpi_outstream_start(h_stream);
 209         else
 210                 return hpi_instream_start(h_stream);
 211 }
 212
 213 static inline u16 hpi_stream_stop(u32 h_stream)
 214 {
 215         if (hpi_handle_object(h_stream) ==  HPI_OBJ_OSTREAM)
 216                 return hpi_outstream_stop(h_stream);
 217         else
 218                 return hpi_instream_stop(h_stream);
 219 }
 220
 221 static inline u16 hpi_stream_get_info_ex(
 222     u32 h_stream,
 223     u16        *pw_state,
 224     u32        *pbuffer_size,
 225     u32        *pdata_in_buffer,
 226     u32        *psample_count,
 227     u32        *pauxiliary_data
 228 )
 229 {
 230         u16 e;
 231         if (hpi_handle_object(h_stream)  ==  HPI_OBJ_OSTREAM)
 232                 e = hpi_outstream_get_info_ex(h_stream, pw_state,
 233                                         pbuffer_size, pdata_in_buffer,
 234                                         psample_count, pauxiliary_data);
 235         else
 236                 e = hpi_instream_get_info_ex(h_stream, pw_state,
 237                                         pbuffer_size, pdata_in_buffer,
 238                                         psample_count, pauxiliary_data);
 239         return e;
 240 }
 241
 242 static inline u16 hpi_stream_group_add(
 243                                         u32 h_master,
 244                                         u32 h_stream)
 245 {
 246         if (hpi_handle_object(h_master) ==  HPI_OBJ_OSTREAM)
 247                 return hpi_outstream_group_add(h_master, h_stream);
 248         else
 249                 return hpi_instream_group_add(h_master, h_stream);
 250 }
 251
 252 static inline u16 hpi_stream_group_reset(u32 h_stream)
 253 {
 254         if (hpi_handle_object(h_stream) ==  HPI_OBJ_OSTREAM)
 255                 return hpi_outstream_group_reset(h_stream);
 256         else
 257                 return hpi_instream_group_reset(h_stream);
 258 }
 259
 260 static u16 handle_error(u16 err, int line, char *filename)
 261 {
 262         if (err)
 263                 printk(KERN_WARNING
 264                         "in file %s, line %d: HPI error %d\n",
 265                         filename, line, err);
 266         return err;
 267 }
 268
 269 #define hpi_handle_error(x)  handle_error(x, __LINE__, __FILE__)
 270
 271 /***************************** GENERAL PCM ****************/
 272
 273 static void print_hwparams(struct snd_pcm_substream *substream,
 274                                 struct snd_pcm_hw_params *p)
 275 {
 276         char name[16];
 277         snd_pcm_debug_name(substream, name, sizeof(name));
 278         snd_printdd("%s HWPARAMS\n", name);
 279         snd_printdd(" samplerate=%dHz channels=%d format=%d subformat=%d\n",
 280                 params_rate(p), params_channels(p),
 281                 params_format(p), params_subformat(p));
 282         snd_printdd(" buffer=%dB period=%dB period_size=%dB periods=%d\n",
 283                 params_buffer_bytes(p), params_period_bytes(p),
 284                 params_period_size(p), params_periods(p));
 285         snd_printdd(" buffer_size=%d access=%d data_rate=%dB/s\n",
 286                 params_buffer_size(p), params_access(p),
 287                 params_rate(p) * params_channels(p) *
 288                 snd_pcm_format_width(params_format(p)) / 8);
 289 }
 290
 291 #define INVALID_FORMAT  (__force snd_pcm_format_t)(-1)
 292
 293 static const snd_pcm_format_t hpi_to_alsa_formats[] = {
 294         INVALID_FORMAT,         /* INVALID */
 295         SNDRV_PCM_FORMAT_U8,    /* HPI_FORMAT_PCM8_UNSIGNED        1 */
 296         SNDRV_PCM_FORMAT_S16,   /* HPI_FORMAT_PCM16_SIGNED         2 */
 297         INVALID_FORMAT,         /* HPI_FORMAT_MPEG_L1              3 */
 298         SNDRV_PCM_FORMAT_MPEG,  /* HPI_FORMAT_MPEG_L2              4 */
 299         SNDRV_PCM_FORMAT_MPEG,  /* HPI_FORMAT_MPEG_L3              5 */
 300         INVALID_FORMAT,         /* HPI_FORMAT_DOLBY_AC2            6 */
 301         INVALID_FORMAT,         /* HPI_FORMAT_DOLBY_AC3            7 */
 302         SNDRV_PCM_FORMAT_S16_BE,/* HPI_FORMAT_PCM16_BIGENDIAN      8 */
 303         INVALID_FORMAT,         /* HPI_FORMAT_AA_TAGIT1_HITS       9 */
 304         INVALID_FORMAT,         /* HPI_FORMAT_AA_TAGIT1_INSERTS   10 */
 305         SNDRV_PCM_FORMAT_S32,   /* HPI_FORMAT_PCM32_SIGNED        11 */
 306         INVALID_FORMAT,         /* HPI_FORMAT_RAW_BITSTREAM       12 */
 307         INVALID_FORMAT,         /* HPI_FORMAT_AA_TAGIT1_HITS_EX1  13 */
 308         SNDRV_PCM_FORMAT_FLOAT, /* HPI_FORMAT_PCM32_FLOAT         14 */
 309 #if 1
 310         /* ALSA can't handle 3 byte sample size together with power-of-2
 311          *  constraint on buffer_bytes, so disable this format
 312          */
 313         INVALID_FORMAT
 314 #else
 315         /* SNDRV_PCM_FORMAT_S24_3LE */ /* HPI_FORMAT_PCM24_SIGNED 15 */
 316 #endif
 317 };
 318
 319
 320 static int snd_card_asihpi_format_alsa2hpi(snd_pcm_format_t alsa_format,
 321                                            u16 *hpi_format)
 322 {
 323         u16 format;
 324
 325         for (format = HPI_FORMAT_PCM8_UNSIGNED;
 326              format <= HPI_FORMAT_PCM24_SIGNED; format++) {
 327                 if (hpi_to_alsa_formats[format] == alsa_format) {
 328                         *hpi_format = format;
 329                         return 0;
 330                 }
 331         }
 332
 333         snd_printd(KERN_WARNING "failed match for alsa format %d\n",
 334                    alsa_format);
 335         *hpi_format = 0;
 336         return -EINVAL;
 337 }
 338
 339 static void snd_card_asihpi_pcm_samplerates(struct snd_card_asihpi *asihpi,
 340                                          struct snd_pcm_hardware *pcmhw)
 341 {
 342         u16 err;
 343         u32 h_control;
 344         u32 sample_rate;
 345         int idx;
 346         unsigned int rate_min = 200000;
 347         unsigned int rate_max = 0;
 348         unsigned int rates = 0;
 349
 350         if (asihpi->support_mrx) {
 351                 rates |= SNDRV_PCM_RATE_CONTINUOUS;
 352                 rates |= SNDRV_PCM_RATE_8000_96000;
 353                 rate_min = 8000;
 354                 rate_max = 100000;
 355         } else {
 356                 /* on cards without SRC,
 357                    valid rates are determined by sampleclock */
 358                 err = hpi_mixer_get_control(asihpi->h_mixer,
 359                                           HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
 360                                           HPI_CONTROL_SAMPLECLOCK, &h_control);
 361                 if (err) {
 362                         dev_err(&asihpi->pci->dev,
 363                                 "No local sampleclock, err %d\n", err);
 364                 }
 365
 366                 for (idx = -1; idx < 100; idx++) {
 367                         if (idx == -1) {
 368                                 if (hpi_sample_clock_get_sample_rate(h_control,
 369                                                                 &sample_rate))
 370                                         continue;
 371                         } else if (hpi_sample_clock_query_local_rate(h_control,
 372                                                         idx, &sample_rate)) {
 373                                 break;
 374                         }
 375
 376                         rate_min = min(rate_min, sample_rate);
 377                         rate_max = max(rate_max, sample_rate);
 378
 379                         switch (sample_rate) {
 380                         case 5512:
 381                                 rates |= SNDRV_PCM_RATE_5512;
 382                                 break;
 383                         case 8000:
 384                                 rates |= SNDRV_PCM_RATE_8000;
 385                                 break;
 386                         case 11025:
 387                                 rates |= SNDRV_PCM_RATE_11025;
 388                                 break;
 389                         case 16000:
 390                                 rates |= SNDRV_PCM_RATE_16000;
 391                                 break;
 392                         case 22050:
 393                                 rates |= SNDRV_PCM_RATE_22050;
 394                                 break;
 395                         case 32000:
 396                                 rates |= SNDRV_PCM_RATE_32000;
 397                                 break;
 398                         case 44100:
 399                                 rates |= SNDRV_PCM_RATE_44100;
 400                                 break;
 401                         case 48000:
 402                                 rates |= SNDRV_PCM_RATE_48000;
 403                                 break;
 404                         case 64000:
 405                                 rates |= SNDRV_PCM_RATE_64000;
 406                                 break;
 407                         case 88200:
 408                                 rates |= SNDRV_PCM_RATE_88200;
 409                                 break;
 410                         case 96000:
 411                                 rates |= SNDRV_PCM_RATE_96000;
 412                                 break;
 413                         case 176400:
 414                                 rates |= SNDRV_PCM_RATE_176400;
 415                                 break;
 416                         case 192000:
 417                                 rates |= SNDRV_PCM_RATE_192000;
 418                                 break;
 419                         default: /* some other rate */
 420                                 rates |= SNDRV_PCM_RATE_KNOT;
 421                         }
 422                 }
 423         }
 424
 425         pcmhw->rates = rates;
 426         pcmhw->rate_min = rate_min;
 427         pcmhw->rate_max = rate_max;
 428 }
 429
 430 static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
 431                                          struct snd_pcm_hw_params *params)
 432 {
 433         struct snd_pcm_runtime *runtime = substream->runtime;
 434         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 435         struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
 436         int err;
 437         u16 format;
 438         int width;
 439         unsigned int bytes_per_sec;
 440
 441         print_hwparams(substream, params);
 442         err = snd_card_asihpi_format_alsa2hpi(params_format(params), &format);
 443         if (err)
 444                 return err;
 445
 446         hpi_handle_error(hpi_format_create(&dpcm->format,
 447                         params_channels(params),
 448                         format, params_rate(params), 0, 0));
 449
 450         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
 451                 if (hpi_instream_reset(dpcm->h_stream) != 0)
 452                         return -EINVAL;
 453
 454                 if (hpi_instream_set_format(
 455                         dpcm->h_stream, &dpcm->format) != 0)
 456                         return -EINVAL;
 457         }
 458
 459         dpcm->hpi_buffer_attached = 0;
 460         if (card->can_dma) {
 461                 err = hpi_stream_host_buffer_attach(dpcm->h_stream,
 462                         params_buffer_bytes(params),  runtime->dma_addr);
 463                 if (err == 0) {
 464                         snd_printdd(
 465                                 "stream_host_buffer_attach success %u %lu\n",
 466                                 params_buffer_bytes(params),
 467                                 (unsigned long)runtime->dma_addr);
 468                 } else {
 469                         snd_printd("stream_host_buffer_attach error %d\n",
 470                                         err);
 471                         return -ENOMEM;
 472                 }
 473
 474                 err = hpi_stream_get_info_ex(dpcm->h_stream, NULL,
 475                                 &dpcm->hpi_buffer_attached, NULL, NULL, NULL);
 476         }
 477         bytes_per_sec = params_rate(params) * params_channels(params);
 478         width = snd_pcm_format_width(params_format(params));
 479         bytes_per_sec *= width;
 480         bytes_per_sec /= 8;
 481         if (width < 0 || bytes_per_sec == 0)
 482                 return -EINVAL;
 483
 484         dpcm->bytes_per_sec = bytes_per_sec;
 485         dpcm->buffer_bytes = params_buffer_bytes(params);
 486         dpcm->period_bytes = params_period_bytes(params);
 487
 488         return 0;
 489 }
 490
 491 static int
 492 snd_card_asihpi_hw_free(struct snd_pcm_substream *substream)
 493 {
 494         struct snd_pcm_runtime *runtime = substream->runtime;
 495         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 496         if (dpcm->hpi_buffer_attached)
 497                 hpi_stream_host_buffer_detach(dpcm->h_stream);
 498
 499         return 0;
 500 }
 501
 502 static void snd_card_asihpi_runtime_free(struct snd_pcm_runtime *runtime)
 503 {
 504         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 505         kfree(dpcm);
 506 }
 507
 508 static void snd_card_asihpi_pcm_timer_start(struct snd_pcm_substream *
 509                                             substream)
 510 {
 511         struct snd_pcm_runtime *runtime = substream->runtime;
 512         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 513         int expiry;
 514
 515         expiry = HZ / 200;
 516
 517         expiry = max(expiry, 1); /* don't let it be zero! */
 518         mod_timer(&dpcm->timer, jiffies + expiry);
 519         dpcm->respawn_timer = 1;
 520 }
 521
 522 static void snd_card_asihpi_pcm_timer_stop(struct snd_pcm_substream *substream)
 523 {
 524         struct snd_pcm_runtime *runtime = substream->runtime;
 525         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 526
 527         dpcm->respawn_timer = 0;
 528         del_timer(&dpcm->timer);
 529 }
 530
 531 static void snd_card_asihpi_pcm_int_start(struct snd_pcm_substream *substream)
 532 {
 533         struct snd_card_asihpi_pcm *dpcm;
 534         struct snd_card_asihpi *card;
 535
 536         dpcm = (struct snd_card_asihpi_pcm *)substream->runtime->private_data;
 537         card = snd_pcm_substream_chip(substream);
 538
 539         WARN_ON(in_interrupt());
 540         card->llmode_streampriv = dpcm;
 541
 542         hpi_handle_error(hpi_adapter_set_property(card->hpi->adapter->index,
 543                 HPI_ADAPTER_PROPERTY_IRQ_RATE,
 544                 card->update_interval_frames, 0));
 545 }
 546
 547 static void snd_card_asihpi_pcm_int_stop(struct snd_pcm_substream *substream)
 548 {
 549         struct snd_card_asihpi *card;
 550
 551         card = snd_pcm_substream_chip(substream);
 552
 553         hpi_handle_error(hpi_adapter_set_property(card->hpi->adapter->index,
 554                 HPI_ADAPTER_PROPERTY_IRQ_RATE, 0, 0));
 555
 556         card->llmode_streampriv = NULL;
 557 }
 558
 559 static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
 560                                            int cmd)
 561 {
 562         struct snd_card_asihpi_pcm *dpcm = substream->runtime->private_data;
 563         struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
 564         struct snd_pcm_substream *s;
 565         u16 e;
 566         char name[16];
 567
 568         snd_pcm_debug_name(substream, name, sizeof(name));
 569
 570         switch (cmd) {
 571         case SNDRV_PCM_TRIGGER_START:
 572                 snd_printdd("%s trigger start\n", name);
 573                 snd_pcm_group_for_each_entry(s, substream) {
 574                         struct snd_pcm_runtime *runtime = s->runtime;
 575                         struct snd_card_asihpi_pcm *ds = runtime->private_data;
 576
 577                         if (snd_pcm_substream_chip(s) != card)
 578                                 continue;
 579
 580                         /* don't link Cap and Play */
 581                         if (substream->stream != s->stream)
 582                                 continue;
 583
 584                         ds->drained_count = 0;
 585                         if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 586                                 /* How do I know how much valid data is present
 587                                 * in buffer? Must be at least one period!
 588                                 * Guessing 2 periods, but if
 589                                 * buffer is bigger it may contain even more
 590                                 * data??
 591                                 */
 592                                 unsigned int preload = ds->period_bytes * 1;
 593                                 snd_printddd("%d preload %d\n", s->number, preload);
 594                                 hpi_handle_error(hpi_outstream_write_buf(
 595                                                 ds->h_stream,
 596                                                 &runtime->dma_area[0],
 597                                                 preload,
 598                                                 &ds->format));
 599                                 ds->pcm_buf_host_rw_ofs = preload;
 600                         }
 601
 602                         if (card->support_grouping) {
 603                                 snd_printdd("%d group\n", s->number);
 604                                 e = hpi_stream_group_add(
 605                                         dpcm->h_stream,
 606                                         ds->h_stream);
 607                                 if (!e) {
 608                                         snd_pcm_trigger_done(s, substream);
 609                                 } else {
 610                                         hpi_handle_error(e);
 611                                         break;
 612                                 }
 613                         } else
 614                                 break;
 615                 }
 616                 /* start the master stream */
 617                 card->pcm_start(substream);
 618                 if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) ||
 619                         !card->can_dma)
 620                         hpi_handle_error(hpi_stream_start(dpcm->h_stream));
 621                 break;
 622
 623         case SNDRV_PCM_TRIGGER_STOP:
 624                 snd_printdd("%s trigger stop\n", name);
 625                 card->pcm_stop(substream);
 626                 snd_pcm_group_for_each_entry(s, substream) {
 627                         if (snd_pcm_substream_chip(s) != card)
 628                                 continue;
 629                         /* don't link Cap and Play */
 630                         if (substream->stream != s->stream)
 631                                 continue;
 632
 633                         /*? workaround linked streams don't
 634                         transition to SETUP 20070706*/
 635                         __snd_pcm_set_state(s->runtime, SNDRV_PCM_STATE_SETUP);
 636
 637                         if (card->support_grouping) {
 638                                 snd_printdd("%d group\n", s->number);
 639                                 snd_pcm_trigger_done(s, substream);
 640                         } else
 641                                 break;
 642                 }
 643
 644                 /* _prepare and _hwparams reset the stream */
 645                 hpi_handle_error(hpi_stream_stop(dpcm->h_stream));
 646                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 647                         hpi_handle_error(
 648                                 hpi_outstream_reset(dpcm->h_stream));
 649
 650                 if (card->support_grouping)
 651                         hpi_handle_error(hpi_stream_group_reset(dpcm->h_stream));
 652                 break;
 653
 654         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 655                 snd_printdd("%s trigger pause release\n", name);
 656                 card->pcm_start(substream);
 657                 hpi_handle_error(hpi_stream_start(dpcm->h_stream));
 658                 break;
 659         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 660                 snd_printdd("%s trigger pause push\n", name);
 661                 card->pcm_stop(substream);
 662                 hpi_handle_error(hpi_stream_stop(dpcm->h_stream));
 663                 break;
 664         default:
 665                 snd_printd(KERN_ERR "\tINVALID\n");
 666                 return -EINVAL;
 667         }
 668
 669         return 0;
 670 }
 671
 672 /*algorithm outline
 673  Without linking degenerates to getting single stream pos etc
 674  Without mmap 2nd loop degenerates to snd_pcm_period_elapsed
 675 */
 676 /*
 677 pcm_buf_dma_ofs=get_buf_pos(s);
 678 for_each_linked_stream(s) {
 679         pcm_buf_dma_ofs=get_buf_pos(s);
 680         min_buf_pos = modulo_min(min_buf_pos, pcm_buf_dma_ofs, buffer_bytes)
 681         new_data = min(new_data, calc_new_data(pcm_buf_dma_ofs,irq_pos)
 682 }
 683 timer.expires = jiffies + predict_next_period_ready(min_buf_pos);
 684 for_each_linked_stream(s) {
 685         s->pcm_buf_dma_ofs = min_buf_pos;
 686         if (new_data > period_bytes) {
 687                 if (mmap) {
 688                         irq_pos = (irq_pos + period_bytes) % buffer_bytes;
 689                         if (playback) {
 690                                 write(period_bytes);
 691                         } else {
 692                                 read(period_bytes);
 693                         }
 694                 }
 695                 snd_pcm_period_elapsed(s);
 696         }
 697 }
 698 */
 699
 700 /** Minimum of 2 modulo values.  Works correctly when the difference between
 701 * the values is less than half the modulus
 702 */
 703 static inline unsigned int modulo_min(unsigned int a, unsigned int b,
 704                                         unsigned long int modulus)
 705 {
 706         unsigned int result;
 707         if (((a-b) % modulus) < (modulus/2))
 708                 result = b;
 709         else
 710                 result = a;
 711
 712         return result;
 713 }
 714
 715 /** Timer function, equivalent to interrupt service routine for cards
 716 */
 717 static void snd_card_asihpi_timer_function(struct timer_list *t)
 718 {
 719         struct snd_card_asihpi_pcm *dpcm = from_timer(dpcm, t, timer);
 720         struct snd_pcm_substream *substream = dpcm->substream;
 721         struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
 722         struct snd_pcm_runtime *runtime;
 723         struct snd_pcm_substream *s;
 724         unsigned int newdata = 0;
 725         unsigned int pcm_buf_dma_ofs, min_buf_pos = 0;
 726         unsigned int remdata, xfercount, next_jiffies;
 727         int first = 1;
 728         u16 state;
 729         u32 buffer_size, bytes_avail, samples_played, on_card_bytes;
 730         char name[16];
 731
 732
 733         snd_pcm_debug_name(substream, name, sizeof(name));
 734
 735         /* find minimum newdata and buffer pos in group */
 736         snd_pcm_group_for_each_entry(s, substream) {
 737                 struct snd_card_asihpi_pcm *ds = s->runtime->private_data;
 738                 runtime = s->runtime;
 739
 740                 if (snd_pcm_substream_chip(s) != card)
 741                         continue;
 742
 743                 /* don't link Cap and Play */
 744                 if (substream->stream != s->stream)
 745                         continue;
 746
 747                 hpi_handle_error(hpi_stream_get_info_ex(
 748                                         ds->h_stream, &state,
 749                                         &buffer_size, &bytes_avail,
 750                                         &samples_played, &on_card_bytes));
 751
 752                 /* number of bytes in on-card buffer */
 753                 runtime->delay = on_card_bytes;
 754
 755                 if (!card->can_dma)
 756                         on_card_bytes = bytes_avail;
 757
 758                 if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 759                         pcm_buf_dma_ofs = ds->pcm_buf_host_rw_ofs - bytes_avail;
 760                         if (state == HPI_STATE_STOPPED) {
 761                                 if (bytes_avail == 0) {
 762                                         hpi_handle_error(hpi_stream_start(ds->h_stream));
 763                                         snd_printdd("P%d start\n", s->number);
 764                                         ds->drained_count = 0;
 765                                 }
 766                         } else if (state == HPI_STATE_DRAINED) {
 767                                 snd_printd(KERN_WARNING "P%d drained\n",
 768                                                 s->number);
 769                                 ds->drained_count++;
 770                                 if (ds->drained_count > 20) {
 771                                         snd_pcm_stop_xrun(s);
 772                                         continue;
 773                                 }
 774                         } else {
 775                                 ds->drained_count = 0;
 776                         }
 777                 } else
 778                         pcm_buf_dma_ofs = bytes_avail + ds->pcm_buf_host_rw_ofs;
 779
 780                 if (first) {
 781                         /* can't statically init min when wrap is involved */
 782                         min_buf_pos = pcm_buf_dma_ofs;
 783                         newdata = (pcm_buf_dma_ofs - ds->pcm_buf_elapsed_dma_ofs) % ds->buffer_bytes;
 784                         first = 0;
 785                 } else {
 786                         min_buf_pos =
 787                                 modulo_min(min_buf_pos, pcm_buf_dma_ofs, UINT_MAX+1L);
 788                         newdata = min(
 789                                 (pcm_buf_dma_ofs - ds->pcm_buf_elapsed_dma_ofs) % ds->buffer_bytes,
 790                                 newdata);
 791                 }
 792
 793                 snd_printddd(
 794                         "timer1, %s, %d, S=%d, elap=%d, rw=%d, dsp=%d, left=%d, aux=%d, space=%d, hw_ptr=%ld, appl_ptr=%ld\n",
 795                         name, s->number, state,
 796                         ds->pcm_buf_elapsed_dma_ofs,
 797                         ds->pcm_buf_host_rw_ofs,
 798                         pcm_buf_dma_ofs,
 799                         (int)bytes_avail,
 800
 801                         (int)on_card_bytes,
 802                         buffer_size-bytes_avail,
 803                         (unsigned long)frames_to_bytes(runtime,
 804                                                 runtime->status->hw_ptr),
 805                         (unsigned long)frames_to_bytes(runtime,
 806                                                 runtime->control->appl_ptr)
 807                 );
 808         }
 809         pcm_buf_dma_ofs = min_buf_pos;
 810
 811         remdata = newdata % dpcm->period_bytes;
 812         xfercount = newdata - remdata; /* a multiple of period_bytes */
 813         /* come back when on_card_bytes has decreased enough to allow
 814            write to happen, or when data has been consumed to make another
 815            period
 816         */
 817         if (xfercount && (on_card_bytes  > dpcm->period_bytes))
 818                 next_jiffies = ((on_card_bytes - dpcm->period_bytes) * HZ / dpcm->bytes_per_sec);
 819         else
 820                 next_jiffies = ((dpcm->period_bytes - remdata) * HZ / dpcm->bytes_per_sec);
 821
 822         next_jiffies = max(next_jiffies, 1U);
 823         dpcm->timer.expires = jiffies + next_jiffies;
 824         snd_printddd("timer2, jif=%d, buf_pos=%d, newdata=%d, xfer=%d\n",
 825                         next_jiffies, pcm_buf_dma_ofs, newdata, xfercount);
 826
 827         snd_pcm_group_for_each_entry(s, substream) {
 828                 struct snd_card_asihpi_pcm *ds = s->runtime->private_data;
 829
 830                 /* don't link Cap and Play */
 831                 if (substream->stream != s->stream)
 832                         continue;
 833
 834                 /* Store dma offset for use by pointer callback */
 835                 ds->pcm_buf_dma_ofs = pcm_buf_dma_ofs;
 836
 837                 if (xfercount &&
 838                         /* Limit use of on card fifo for playback */
 839                         ((on_card_bytes <= ds->period_bytes) ||
 840                         (s->stream == SNDRV_PCM_STREAM_CAPTURE)))
 841
 842                 {
 843
 844                         unsigned int buf_ofs = ds->pcm_buf_host_rw_ofs % ds->buffer_bytes;
 845                         unsigned int xfer1, xfer2;
 846                         char *pd = &s->runtime->dma_area[buf_ofs];
 847
 848                         if (card->can_dma) { /* buffer wrap is handled at lower level */
 849                                 xfer1 = xfercount;
 850                                 xfer2 = 0;
 851                         } else {
 852                                 xfer1 = min(xfercount, ds->buffer_bytes - buf_ofs);
 853                                 xfer2 = xfercount - xfer1;
 854                         }
 855
 856                         if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 857                                 snd_printddd("write1, P=%d, xfer=%d, buf_ofs=%d\n",
 858                                         s->number, xfer1, buf_ofs);
 859                                 hpi_handle_error(
 860                                         hpi_outstream_write_buf(
 861                                                 ds->h_stream, pd, xfer1,
 862                                                 &ds->format));
 863
 864                                 if (xfer2) {
 865                                         pd = s->runtime->dma_area;
 866
 867                                         snd_printddd("write2, P=%d, xfer=%d, buf_ofs=%d\n",
 868                                                         s->number,
 869                                                         xfercount - xfer1, buf_ofs);
 870                                         hpi_handle_error(
 871                                                 hpi_outstream_write_buf(
 872                                                         ds->h_stream, pd,
 873                                                         xfercount - xfer1,
 874                                                         &ds->format));
 875                                 }
 876                         } else {
 877                                 snd_printddd("read1, C=%d, xfer=%d\n",
 878                                         s->number, xfer1);
 879                                 hpi_handle_error(
 880                                         hpi_instream_read_buf(
 881                                                 ds->h_stream,
 882                                                 pd, xfer1));
 883                                 if (xfer2) {
 884                                         pd = s->runtime->dma_area;
 885                                         snd_printddd("read2, C=%d, xfer=%d\n",
 886                                                 s->number, xfer2);
 887                                         hpi_handle_error(
 888                                                 hpi_instream_read_buf(
 889                                                         ds->h_stream,
 890                                                         pd, xfer2));
 891                                 }
 892                         }
 893                         /* ? host_rw_ofs always ahead of elapsed_dma_ofs by preload size? */
 894                         ds->pcm_buf_host_rw_ofs += xfercount;
 895                         ds->pcm_buf_elapsed_dma_ofs += xfercount;
 896                         snd_pcm_period_elapsed(s);
 897                 }
 898         }
 899
 900         if (!card->hpi->interrupt_mode && dpcm->respawn_timer)
 901                 add_timer(&dpcm->timer);
 902 }
 903
 904 static void snd_card_asihpi_isr(struct hpi_adapter *a)
 905 {
 906         struct snd_card_asihpi *asihpi;
 907
 908         WARN_ON(!a || !a->snd_card || !a->snd_card->private_data);
 909         asihpi = (struct snd_card_asihpi *)a->snd_card->private_data;
 910         if (asihpi->llmode_streampriv)
 911                 snd_card_asihpi_timer_function(
 912                         &asihpi->llmode_streampriv->timer);
 913 }
 914
 915 /***************************** PLAYBACK OPS ****************/
 916 static int snd_card_asihpi_playback_prepare(struct snd_pcm_substream *
 917                                             substream)
 918 {
 919         struct snd_pcm_runtime *runtime = substream->runtime;
 920         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 921
 922         snd_printdd("P%d prepare\n", substream->number);
 923
 924         hpi_handle_error(hpi_outstream_reset(dpcm->h_stream));
 925         dpcm->pcm_buf_host_rw_ofs = 0;
 926         dpcm->pcm_buf_dma_ofs = 0;
 927         dpcm->pcm_buf_elapsed_dma_ofs = 0;
 928         return 0;
 929 }
 930
 931 static snd_pcm_uframes_t
 932 snd_card_asihpi_playback_pointer(struct snd_pcm_substream *substream)
 933 {
 934         struct snd_pcm_runtime *runtime = substream->runtime;
 935         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
 936         snd_pcm_uframes_t ptr;
 937         char name[16];
 938         snd_pcm_debug_name(substream, name, sizeof(name));
 939
 940         ptr = bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs  % dpcm->buffer_bytes);
 941         snd_printddd("%s, pointer=%ld\n", name, (unsigned long)ptr);
 942         return ptr;
 943 }
 944
 945 static u64 snd_card_asihpi_playback_formats(struct snd_card_asihpi *asihpi,
 946                                                 u32 h_stream)
 947 {
 948         struct hpi_format hpi_format;
 949         u16 format;
 950         u16 err;
 951         u32 h_control;
 952         u32 sample_rate = 48000;
 953         u64 formats = 0;
 954
 955         /* on cards without SRC, must query at valid rate,
 956         * maybe set by external sync
 957         */
 958         err = hpi_mixer_get_control(asihpi->h_mixer,
 959                                   HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
 960                                   HPI_CONTROL_SAMPLECLOCK, &h_control);
 961
 962         if (!err)
 963                 err = hpi_sample_clock_get_sample_rate(h_control,
 964                                 &sample_rate);
 965
 966         for (format = HPI_FORMAT_PCM8_UNSIGNED;
 967              format <= HPI_FORMAT_PCM24_SIGNED; format++) {
 968                 err = hpi_format_create(&hpi_format, asihpi->out_max_chans,
 969                                         format, sample_rate, 128000, 0);
 970                 if (!err)
 971                         err = hpi_outstream_query_format(h_stream, &hpi_format);
 972                 if (!err && (hpi_to_alsa_formats[format] != INVALID_FORMAT))
 973                         formats |= pcm_format_to_bits(hpi_to_alsa_formats[format]);
 974         }
 975         return formats;
 976 }
 977
 978 static int snd_card_asihpi_playback_open(struct snd_pcm_substream *substream)
 979 {
 980         struct snd_pcm_runtime *runtime = substream->runtime;
 981         struct snd_card_asihpi_pcm *dpcm;
 982         struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
 983         struct snd_pcm_hardware snd_card_asihpi_playback;
 984         int err;
 985
 986         dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
 987         if (dpcm == NULL)
 988                 return -ENOMEM;
 989
 990         err = hpi_outstream_open(card->hpi->adapter->index,
 991                               substream->number, &dpcm->h_stream);
 992         hpi_handle_error(err);
 993         if (err)
 994                 kfree(dpcm);
 995         if (err == HPI_ERROR_OBJ_ALREADY_OPEN)
 996                 return -EBUSY;
 997         if (err)
 998                 return -EIO;
 999
1000         /*? also check ASI5000 samplerate source
1001             If external, only support external rate.
1002             If internal and other stream playing, can't switch
1003         */
1004
1005         timer_setup(&dpcm->timer, snd_card_asihpi_timer_function, 0);
1006         dpcm->substream = substream;
1007         runtime->private_data = dpcm;
1008         runtime->private_free = snd_card_asihpi_runtime_free;
1009
1010         memset(&snd_card_asihpi_playback, 0, sizeof(snd_card_asihpi_playback));
1011         if (!card->hpi->interrupt_mode) {
1012                 snd_card_asihpi_playback.buffer_bytes_max = BUFFER_BYTES_MAX;
1013                 snd_card_asihpi_playback.period_bytes_min = PERIOD_BYTES_MIN;
1014                 snd_card_asihpi_playback.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1015                 snd_card_asihpi_playback.periods_min = PERIODS_MIN;
1016                 snd_card_asihpi_playback.periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN;
1017         } else {
1018                 size_t pbmin = card->update_interval_frames *
1019                         card->out_max_chans;
1020                 snd_card_asihpi_playback.buffer_bytes_max = BUFFER_BYTES_MAX;
1021                 snd_card_asihpi_playback.period_bytes_min = pbmin;
1022                 snd_card_asihpi_playback.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1023                 snd_card_asihpi_playback.periods_min = PERIODS_MIN;
1024                 snd_card_asihpi_playback.periods_max = BUFFER_BYTES_MAX / pbmin;
1025         }
1026
1027         /* snd_card_asihpi_playback.fifo_size = 0; */
1028         snd_card_asihpi_playback.channels_max = card->out_max_chans;
1029         snd_card_asihpi_playback.channels_min = card->out_min_chans;
1030         snd_card_asihpi_playback.formats =
1031                         snd_card_asihpi_playback_formats(card, dpcm->h_stream);
1032
1033         snd_card_asihpi_pcm_samplerates(card,  &snd_card_asihpi_playback);
1034
1035         snd_card_asihpi_playback.info = SNDRV_PCM_INFO_INTERLEAVED |
1036                                         SNDRV_PCM_INFO_DOUBLE |
1037                                         SNDRV_PCM_INFO_BATCH |
1038                                         SNDRV_PCM_INFO_BLOCK_TRANSFER |
1039                                         SNDRV_PCM_INFO_PAUSE |
1040                                         SNDRV_PCM_INFO_MMAP |
1041                                         SNDRV_PCM_INFO_MMAP_VALID;
1042
1043         if (card->support_grouping) {
1044                 snd_card_asihpi_playback.info |= SNDRV_PCM_INFO_SYNC_START;
1045                 snd_pcm_set_sync(substream);
1046         }
1047
1048         /* struct is copied, so can create initializer dynamically */
1049         runtime->hw = snd_card_asihpi_playback;
1050
1051         if (card->can_dma)
1052                 err = snd_pcm_hw_constraint_pow2(runtime, 0,
1053                                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1054         if (err < 0)
1055                 return err;
1056
1057         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1058                 card->update_interval_frames);
1059
1060         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1061                 card->update_interval_frames, UINT_MAX);
1062
1063         snd_printdd("playback open\n");
1064
1065         return 0;
1066 }
1067
1068 static int snd_card_asihpi_playback_close(struct snd_pcm_substream *substream)
1069 {
1070         struct snd_pcm_runtime *runtime = substream->runtime;
1071         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1072
1073         hpi_handle_error(hpi_outstream_close(dpcm->h_stream));
1074         snd_printdd("playback close\n");
1075
1076         return 0;
1077 }
1078
1079 static const struct snd_pcm_ops snd_card_asihpi_playback_mmap_ops = {
1080         .open = snd_card_asihpi_playback_open,
1081         .close = snd_card_asihpi_playback_close,
1082         .hw_params = snd_card_asihpi_pcm_hw_params,
1083         .hw_free = snd_card_asihpi_hw_free,
1084         .prepare = snd_card_asihpi_playback_prepare,
1085         .trigger = snd_card_asihpi_trigger,
1086         .pointer = snd_card_asihpi_playback_pointer,
1087 };
1088
1089 /***************************** CAPTURE OPS ****************/
1090 static snd_pcm_uframes_t
1091 snd_card_asihpi_capture_pointer(struct snd_pcm_substream *substream)
1092 {
1093         struct snd_pcm_runtime *runtime = substream->runtime;
1094         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1095         char name[16];
1096         snd_pcm_debug_name(substream, name, sizeof(name));
1097
1098         snd_printddd("%s, pointer=%d\n", name, dpcm->pcm_buf_dma_ofs);
1099         /* NOTE Unlike playback can't use actual samples_played
1100                 for the capture position, because those samples aren't yet in
1101                 the local buffer available for reading.
1102         */
1103         return bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes);
1104 }
1105
1106 static int snd_card_asihpi_capture_prepare(struct snd_pcm_substream *substream)
1107 {
1108         struct snd_pcm_runtime *runtime = substream->runtime;
1109         struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1110
1111         hpi_handle_error(hpi_instream_reset(dpcm->h_stream));
1112         dpcm->pcm_buf_host_rw_ofs = 0;
1113         dpcm->pcm_buf_dma_ofs = 0;
1114         dpcm->pcm_buf_elapsed_dma_ofs = 0;
1115
1116         snd_printdd("Capture Prepare %d\n", substream->number);
1117         return 0;
1118 }
1119
1120 static u64 snd_card_asihpi_capture_formats(struct snd_card_asihpi *asihpi,
1121                                         u32 h_stream)
1122 {
1123         struct hpi_format hpi_format;
1124         u16 format;
1125         u16 err;
1126         u32 h_control;
1127         u32 sample_rate = 48000;
1128         u64 formats = 0;
1129
1130         /* on cards without SRC, must query at valid rate,
1131                 maybe set by external sync */
1132         err = hpi_mixer_get_control(asihpi->h_mixer,
1133                                   HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
1134                                   HPI_CONTROL_SAMPLECLOCK, &h_control);
1135
1136         if (!err)
1137                 err = hpi_sample_clock_get_sample_rate(h_control,
1138                         &sample_rate);
1139
1140         for (format = HPI_FORMAT_PCM8_UNSIGNED;
1141                 format <= HPI_FORMAT_PCM24_SIGNED; format++) {
1142
1143                 err = hpi_format_create(&hpi_format, asihpi->in_max_chans,
1144                                         format, sample_rate, 128000, 0);
1145                 if (!err)
1146                         err = hpi_instream_query_format(h_stream, &hpi_format);
1147                 if (!err && (hpi_to_alsa_formats[format] != INVALID_FORMAT))
1148                         formats |= pcm_format_to_bits(hpi_to_alsa_formats[format]);
1149         }
1150         return formats;
1151 }
1152
1153 static int snd_card_asihpi_capture_open(struct snd_pcm_substream *substream)
1154 {
1155         struct snd_pcm_runtime *runtime = substream->runtime;
1156         struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
1157         struct snd_card_asihpi_pcm *dpcm;
1158         struct snd_pcm_hardware snd_card_asihpi_capture;
1159         int err;
1160
1161         dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
1162         if (dpcm == NULL)
1163                 return -ENOMEM;
1164
1165         snd_printdd("capture open adapter %d stream %d\n",
1166                         card->hpi->adapter->index, substream->number);
1167
1168         err = hpi_handle_error(
1169             hpi_instream_open(card->hpi->adapter->index,
1170                              substream->number, &dpcm->h_stream));
1171         if (err)
1172                 kfree(dpcm);
1173         if (err == HPI_ERROR_OBJ_ALREADY_OPEN)
1174                 return -EBUSY;
1175         if (err)
1176                 return -EIO;
1177
1178         timer_setup(&dpcm->timer, snd_card_asihpi_timer_function, 0);
1179         dpcm->substream = substream;
1180         runtime->private_data = dpcm;
1181         runtime->private_free = snd_card_asihpi_runtime_free;
1182
1183         memset(&snd_card_asihpi_capture, 0, sizeof(snd_card_asihpi_capture));
1184         if (!card->hpi->interrupt_mode) {
1185                 snd_card_asihpi_capture.buffer_bytes_max = BUFFER_BYTES_MAX;
1186                 snd_card_asihpi_capture.period_bytes_min = PERIOD_BYTES_MIN;
1187                 snd_card_asihpi_capture.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1188                 snd_card_asihpi_capture.periods_min = PERIODS_MIN;
1189                 snd_card_asihpi_capture.periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN;
1190         } else {
1191                 size_t pbmin = card->update_interval_frames *
1192                         card->out_max_chans;
1193                 snd_card_asihpi_capture.buffer_bytes_max = BUFFER_BYTES_MAX;
1194                 snd_card_asihpi_capture.period_bytes_min = pbmin;
1195                 snd_card_asihpi_capture.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1196                 snd_card_asihpi_capture.periods_min = PERIODS_MIN;
1197                 snd_card_asihpi_capture.periods_max = BUFFER_BYTES_MAX / pbmin;
1198         }
1199         /* snd_card_asihpi_capture.fifo_size = 0; */
1200         snd_card_asihpi_capture.channels_max = card->in_max_chans;
1201         snd_card_asihpi_capture.channels_min = card->in_min_chans;
1202         snd_card_asihpi_capture.formats =
1203                 snd_card_asihpi_capture_formats(card, dpcm->h_stream);
1204         snd_card_asihpi_pcm_samplerates(card,  &snd_card_asihpi_capture);
1205         snd_card_asihpi_capture.info = SNDRV_PCM_INFO_INTERLEAVED |
1206                                         SNDRV_PCM_INFO_MMAP |
1207                                         SNDRV_PCM_INFO_MMAP_VALID;
1208
1209         if (card->support_grouping)
1210                 snd_card_asihpi_capture.info |= SNDRV_PCM_INFO_SYNC_START;
1211
1212         runtime->hw = snd_card_asihpi_capture;
1213
1214         if (card->can_dma)
1215                 err = snd_pcm_hw_constraint_pow2(runtime, 0,
1216                                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1217         if (err < 0)
1218                 return err;
1219
1220         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1221                 card->update_interval_frames);
1222         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1223                 card->update_interval_frames, UINT_MAX);
1224
1225         snd_pcm_set_sync(substream);
1226
1227         return 0;
1228 }
1229
1230 static int snd_card_asihpi_capture_close(struct snd_pcm_substream *substream)
1231 {
1232         struct snd_card_asihpi_pcm *dpcm = substream->runtime->private_data;
1233
1234         hpi_handle_error(hpi_instream_close(dpcm->h_stream));
1235         return 0;
1236 }
1237
1238 static const struct snd_pcm_ops snd_card_asihpi_capture_mmap_ops = {
1239         .open = snd_card_asihpi_capture_open,
1240         .close = snd_card_asihpi_capture_close,
1241         .hw_params = snd_card_asihpi_pcm_hw_params,
1242         .hw_free = snd_card_asihpi_hw_free,
1243         .prepare = snd_card_asihpi_capture_prepare,
1244         .trigger = snd_card_asihpi_trigger,
1245         .pointer = snd_card_asihpi_capture_pointer,
1246 };
1247
1248 static int snd_card_asihpi_pcm_new(struct snd_card_asihpi *asihpi, int device)
1249 {
1250         struct snd_pcm *pcm;
1251         int err;
1252         u16 num_instreams, num_outstreams, x16;
1253         u32 x32;
1254
1255         err = hpi_adapter_get_info(asihpi->hpi->adapter->index,
1256                         &num_outstreams, &num_instreams,
1257                         &x16, &x32, &x16);
1258
1259         err = snd_pcm_new(asihpi->card, "Asihpi PCM", device,
1260                         num_outstreams, num_instreams, &pcm);
1261         if (err < 0)
1262                 return err;
1263
1264         /* pointer to ops struct is stored, dont change ops afterwards! */
1265         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1266                         &snd_card_asihpi_playback_mmap_ops);
1267         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1268                         &snd_card_asihpi_capture_mmap_ops);
1269
1270         pcm->private_data = asihpi;
1271         pcm->info_flags = 0;
1272         strcpy(pcm->name, "Asihpi PCM");
1273
1274         /*? do we want to emulate MMAP for non-BBM cards?
1275         Jack doesn't work with ALSAs MMAP emulation - WHY NOT? */
1276         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
1277                                        &asihpi->pci->dev,
1278                                        64*1024, BUFFER_BYTES_MAX);
1279
1280         return 0;
1281 }
1282
1283 /***************************** MIXER CONTROLS ****************/
1284 struct hpi_control {
1285         u32 h_control;
1286         u16 control_type;
1287         u16 src_node_type;
1288         u16 src_node_index;
1289         u16 dst_node_type;
1290         u16 dst_node_index;
1291         u16 band;
1292         char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* copied to snd_ctl_elem_id.name[44]; */
1293 };
1294
1295 static const char * const asihpi_tuner_band_names[] = {
1296         "invalid",
1297         "AM",
1298         "FM mono",
1299         "TV NTSC-M",
1300         "FM stereo",
1301         "AUX",
1302         "TV PAL BG",
1303         "TV PAL I",
1304         "TV PAL DK",
1305         "TV SECAM",
1306         "TV DAB",
1307 };
1308 /* Number of strings must match the enumerations for HPI_TUNER_BAND in hpi.h */
1309 compile_time_assert(
1310         (ARRAY_SIZE(asihpi_tuner_band_names) ==
1311                 (HPI_TUNER_BAND_LAST+1)),
1312         assert_tuner_band_names_size);
1313
1314 static const char * const asihpi_src_names[] = {
1315         "no source",
1316         "PCM",
1317         "Line",
1318         "Digital",
1319         "Tuner",
1320         "RF",
1321         "Clock",
1322         "Bitstream",
1323         "Mic",
1324         "Net",
1325         "Analog",
1326         "Adapter",
1327         "RTP",
1328         "Internal",
1329         "AVB",
1330         "BLU-Link"
1331 };
1332 /* Number of strings must match the enumerations for HPI_SOURCENODES in hpi.h */
1333 compile_time_assert(
1334         (ARRAY_SIZE(asihpi_src_names) ==
1335                 (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_NONE+1)),
1336         assert_src_names_size);
1337
1338 static const char * const asihpi_dst_names[] = {
1339         "no destination",
1340         "PCM",
1341         "Line",
1342         "Digital",
1343         "RF",
1344         "Speaker",
1345         "Net",
1346         "Analog",
1347         "RTP",
1348         "AVB",
1349         "Internal",
1350         "BLU-Link"
1351 };
1352 /* Number of strings must match the enumerations for HPI_DESTNODES in hpi.h */
1353 compile_time_assert(
1354         (ARRAY_SIZE(asihpi_dst_names) ==
1355                 (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_NONE+1)),
1356         assert_dst_names_size);
1357
1358 static inline int ctl_add(struct snd_card *card, struct snd_kcontrol_new *ctl,
1359                                 struct snd_card_asihpi *asihpi)
1360 {
1361         int err;
1362
1363         err = snd_ctl_add(card, snd_ctl_new1(ctl, asihpi));
1364         if (err < 0)
1365                 return err;
1366         else if (mixer_dump)
1367                 dev_info(&asihpi->pci->dev, "added %s(%d)\n", ctl->name, ctl->index);
1368
1369         return 0;
1370 }
1371
1372 /* Convert HPI control name and location into ALSA control name */
1373 static void asihpi_ctl_init(struct snd_kcontrol_new *snd_control,
1374                                 struct hpi_control *hpi_ctl,
1375                                 char *name)
1376 {
1377         char *dir;
1378         memset(snd_control, 0, sizeof(*snd_control));
1379         snd_control->name = hpi_ctl->name;
1380         snd_control->private_value = hpi_ctl->h_control;
1381         snd_control->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1382         snd_control->index = 0;
1383
1384         if (hpi_ctl->src_node_type + HPI_SOURCENODE_NONE == HPI_SOURCENODE_CLOCK_SOURCE)
1385                 dir = ""; /* clock is neither capture nor playback */
1386         else if (hpi_ctl->dst_node_type + HPI_DESTNODE_NONE == HPI_DESTNODE_ISTREAM)
1387                 dir = "Capture ";  /* On or towards a PCM capture destination*/
1388         else if ((hpi_ctl->src_node_type + HPI_SOURCENODE_NONE != HPI_SOURCENODE_OSTREAM) &&
1389                 (!hpi_ctl->dst_node_type))
1390                 dir = "Capture "; /* On a source node that is not PCM playback */
1391         else if (hpi_ctl->src_node_type &&
1392                 (hpi_ctl->src_node_type + HPI_SOURCENODE_NONE != HPI_SOURCENODE_OSTREAM) &&
1393                 (hpi_ctl->dst_node_type))
1394                 dir = "Monitor Playback "; /* Between an input and an output */
1395         else
1396                 dir = "Playback "; /* PCM Playback source, or  output node */
1397
1398         if (hpi_ctl->src_node_type && hpi_ctl->dst_node_type)
1399                 sprintf(hpi_ctl->name, "%s %d %s %d %s%s",
1400                         asihpi_src_names[hpi_ctl->src_node_type],
1401                         hpi_ctl->src_node_index,
1402                         asihpi_dst_names[hpi_ctl->dst_node_type],
1403                         hpi_ctl->dst_node_index,
1404                         dir, name);
1405         else if (hpi_ctl->dst_node_type) {
1406                 sprintf(hpi_ctl->name, "%s %d %s%s",
1407                 asihpi_dst_names[hpi_ctl->dst_node_type],
1408                 hpi_ctl->dst_node_index,
1409                 dir, name);
1410         } else {
1411                 sprintf(hpi_ctl->name, "%s %d %s%s",
1412                 asihpi_src_names[hpi_ctl->src_node_type],
1413                 hpi_ctl->src_node_index,
1414                 dir, name);
1415         }
1416         /* printk(KERN_INFO "Adding %s %d to %d ",  hpi_ctl->name,
1417                 hpi_ctl->wSrcNodeType, hpi_ctl->wDstNodeType); */
1418 }
1419
1420 /*------------------------------------------------------------
1421    Volume controls
1422  ------------------------------------------------------------*/
1423 #define VOL_STEP_mB 1
1424 static int snd_asihpi_volume_info(struct snd_kcontrol *kcontrol,
1425                                   struct snd_ctl_elem_info *uinfo)
1426 {
1427         u32 h_control = kcontrol->private_value;
1428         u32 count;
1429         u16 err;
1430         /* native gains are in millibels */
1431         short min_gain_mB;
1432         short max_gain_mB;
1433         short step_gain_mB;
1434
1435         err = hpi_volume_query_range(h_control,
1436                         &min_gain_mB, &max_gain_mB, &step_gain_mB);
1437         if (err) {
1438                 max_gain_mB = 0;
1439                 min_gain_mB = -10000;
1440                 step_gain_mB = VOL_STEP_mB;
1441         }
1442
1443         err = hpi_meter_query_channels(h_control, &count);
1444         if (err)
1445                 count = HPI_MAX_CHANNELS;
1446
1447         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1448         uinfo->count = count;
1449         uinfo->value.integer.min = min_gain_mB / VOL_STEP_mB;
1450         uinfo->value.integer.max = max_gain_mB / VOL_STEP_mB;
1451         uinfo->value.integer.step = step_gain_mB / VOL_STEP_mB;
1452         return 0;
1453 }
1454
1455 static int snd_asihpi_volume_get(struct snd_kcontrol *kcontrol,
1456                                  struct snd_ctl_elem_value *ucontrol)
1457 {
1458         u32 h_control = kcontrol->private_value;
1459         short an_gain_mB[HPI_MAX_CHANNELS];
1460
1461         hpi_handle_error(hpi_volume_get_gain(h_control, an_gain_mB));
1462         ucontrol->value.integer.value[0] = an_gain_mB[0] / VOL_STEP_mB;
1463         ucontrol->value.integer.value[1] = an_gain_mB[1] / VOL_STEP_mB;
1464
1465         return 0;
1466 }
1467
1468 static int snd_asihpi_volume_put(struct snd_kcontrol *kcontrol,
1469                                  struct snd_ctl_elem_value *ucontrol)
1470 {
1471         u32 h_control = kcontrol->private_value;
1472         short an_gain_mB[HPI_MAX_CHANNELS];
1473
1474         an_gain_mB[0] =
1475             (ucontrol->value.integer.value[0]) * VOL_STEP_mB;
1476         an_gain_mB[1] =
1477             (ucontrol->value.integer.value[1]) * VOL_STEP_mB;
1478         /*  change = asihpi->mixer_volume[addr][0] != left ||
1479            asihpi->mixer_volume[addr][1] != right;
1480          */
1481         hpi_handle_error(hpi_volume_set_gain(h_control, an_gain_mB));
1482         return 1;
1483 }
1484
1485 static const DECLARE_TLV_DB_SCALE(db_scale_100, -10000, VOL_STEP_mB, 0);
1486
1487 #define snd_asihpi_volume_mute_info     snd_ctl_boolean_mono_info
1488
1489 static int snd_asihpi_volume_mute_get(struct snd_kcontrol *kcontrol,
1490                                  struct snd_ctl_elem_value *ucontrol)
1491 {
1492         u32 h_control = kcontrol->private_value;
1493         u32 mute;
1494
1495         hpi_handle_error(hpi_volume_get_mute(h_control, &mute));
1496         ucontrol->value.integer.value[0] = mute ? 0 : 1;
1497
1498         return 0;
1499 }
1500
1501 static int snd_asihpi_volume_mute_put(struct snd_kcontrol *kcontrol,
1502                                  struct snd_ctl_elem_value *ucontrol)
1503 {
1504         u32 h_control = kcontrol->private_value;
1505         /* HPI currently only supports all or none muting of multichannel volume
1506         ALSA Switch element has opposite sense to HPI mute: on==unmuted, off=muted
1507         */
1508         int mute =  ucontrol->value.integer.value[0] ? 0 : HPI_BITMASK_ALL_CHANNELS;
1509         hpi_handle_error(hpi_volume_set_mute(h_control, mute));
1510         return 1;
1511 }
1512
1513 static int snd_asihpi_volume_add(struct snd_card_asihpi *asihpi,
1514                                  struct hpi_control *hpi_ctl)
1515 {
1516         struct snd_card *card = asihpi->card;
1517         struct snd_kcontrol_new snd_control;
1518         int err;
1519         u32 mute;
1520
1521         asihpi_ctl_init(&snd_control, hpi_ctl, "Volume");
1522         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1523                                 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1524         snd_control.info = snd_asihpi_volume_info;
1525         snd_control.get = snd_asihpi_volume_get;
1526         snd_control.put = snd_asihpi_volume_put;
1527         snd_control.tlv.p = db_scale_100;
1528
1529         err = ctl_add(card, &snd_control, asihpi);
1530         if (err)
1531                 return err;
1532
1533         if (hpi_volume_get_mute(hpi_ctl->h_control, &mute) == 0) {
1534                 asihpi_ctl_init(&snd_control, hpi_ctl, "Switch");
1535                 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1536                 snd_control.info = snd_asihpi_volume_mute_info;
1537                 snd_control.get = snd_asihpi_volume_mute_get;
1538                 snd_control.put = snd_asihpi_volume_mute_put;
1539                 err = ctl_add(card, &snd_control, asihpi);
1540         }
1541         return err;
1542 }
1543
1544 /*------------------------------------------------------------
1545    Level controls
1546  ------------------------------------------------------------*/
1547 static int snd_asihpi_level_info(struct snd_kcontrol *kcontrol,
1548                                  struct snd_ctl_elem_info *uinfo)
1549 {
1550         u32 h_control = kcontrol->private_value;
1551         u16 err;
1552         short min_gain_mB;
1553         short max_gain_mB;
1554         short step_gain_mB;
1555
1556         err =
1557             hpi_level_query_range(h_control, &min_gain_mB,
1558                                &max_gain_mB, &step_gain_mB);
1559         if (err) {
1560                 max_gain_mB = 2400;
1561                 min_gain_mB = -1000;
1562                 step_gain_mB = 100;
1563         }
1564
1565         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1566         uinfo->count = 2;
1567         uinfo->value.integer.min = min_gain_mB / HPI_UNITS_PER_dB;
1568         uinfo->value.integer.max = max_gain_mB / HPI_UNITS_PER_dB;
1569         uinfo->value.integer.step = step_gain_mB / HPI_UNITS_PER_dB;
1570         return 0;
1571 }
1572
1573 static int snd_asihpi_level_get(struct snd_kcontrol *kcontrol,
1574                                 struct snd_ctl_elem_value *ucontrol)
1575 {
1576         u32 h_control = kcontrol->private_value;
1577         short an_gain_mB[HPI_MAX_CHANNELS];
1578
1579         hpi_handle_error(hpi_level_get_gain(h_control, an_gain_mB));
1580         ucontrol->value.integer.value[0] =
1581             an_gain_mB[0] / HPI_UNITS_PER_dB;
1582         ucontrol->value.integer.value[1] =
1583             an_gain_mB[1] / HPI_UNITS_PER_dB;
1584
1585         return 0;
1586 }
1587
1588 static int snd_asihpi_level_put(struct snd_kcontrol *kcontrol,
1589                                 struct snd_ctl_elem_value *ucontrol)
1590 {
1591         int change;
1592         u32 h_control = kcontrol->private_value;
1593         short an_gain_mB[HPI_MAX_CHANNELS];
1594
1595         an_gain_mB[0] =
1596             (ucontrol->value.integer.value[0]) * HPI_UNITS_PER_dB;
1597         an_gain_mB[1] =
1598             (ucontrol->value.integer.value[1]) * HPI_UNITS_PER_dB;
1599         /*  change = asihpi->mixer_level[addr][0] != left ||
1600            asihpi->mixer_level[addr][1] != right;
1601          */
1602         change = 1;
1603         hpi_handle_error(hpi_level_set_gain(h_control, an_gain_mB));
1604         return change;
1605 }
1606
1607 static const DECLARE_TLV_DB_SCALE(db_scale_level, -1000, 100, 0);
1608
1609 static int snd_asihpi_level_add(struct snd_card_asihpi *asihpi,
1610                                 struct hpi_control *hpi_ctl)
1611 {
1612         struct snd_card *card = asihpi->card;
1613         struct snd_kcontrol_new snd_control;
1614
1615         /* can't use 'volume' cos some nodes have volume as well */
1616         asihpi_ctl_init(&snd_control, hpi_ctl, "Level");
1617         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1618                                 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1619         snd_control.info = snd_asihpi_level_info;
1620         snd_control.get = snd_asihpi_level_get;
1621         snd_control.put = snd_asihpi_level_put;
1622         snd_control.tlv.p = db_scale_level;
1623
1624         return ctl_add(card, &snd_control, asihpi);
1625 }
1626
1627 /*------------------------------------------------------------
1628    AESEBU controls
1629  ------------------------------------------------------------*/
1630
1631 /* AESEBU format */
1632 static const char * const asihpi_aesebu_format_names[] = {
1633         "N/A", "S/PDIF", "AES/EBU" };
1634
1635 static int snd_asihpi_aesebu_format_info(struct snd_kcontrol *kcontrol,
1636                                   struct snd_ctl_elem_info *uinfo)
1637 {
1638         return snd_ctl_enum_info(uinfo, 1, 3, asihpi_aesebu_format_names);
1639 }
1640
1641 static int snd_asihpi_aesebu_format_get(struct snd_kcontrol *kcontrol,
1642                         struct snd_ctl_elem_value *ucontrol,
1643                         u16 (*func)(u32, u16 *))
1644 {
1645         u32 h_control = kcontrol->private_value;
1646         u16 source, err;
1647
1648         err = func(h_control, &source);
1649
1650         /* default to N/A */
1651         ucontrol->value.enumerated.item[0] = 0;
1652         /* return success but set the control to N/A */
1653         if (err)
1654                 return 0;
1655         if (source == HPI_AESEBU_FORMAT_SPDIF)
1656                 ucontrol->value.enumerated.item[0] = 1;
1657         if (source == HPI_AESEBU_FORMAT_AESEBU)
1658                 ucontrol->value.enumerated.item[0] = 2;
1659
1660         return 0;
1661 }
1662
1663 static int snd_asihpi_aesebu_format_put(struct snd_kcontrol *kcontrol,
1664                         struct snd_ctl_elem_value *ucontrol,
1665                          u16 (*func)(u32, u16))
1666 {
1667         u32 h_control = kcontrol->private_value;
1668
1669         /* default to S/PDIF */
1670         u16 source = HPI_AESEBU_FORMAT_SPDIF;
1671
1672         if (ucontrol->value.enumerated.item[0] == 1)
1673                 source = HPI_AESEBU_FORMAT_SPDIF;
1674         if (ucontrol->value.enumerated.item[0] == 2)
1675                 source = HPI_AESEBU_FORMAT_AESEBU;
1676
1677         if (func(h_control, source) != 0)
1678                 return -EINVAL;
1679
1680         return 1;
1681 }
1682
1683 static int snd_asihpi_aesebu_rx_format_get(struct snd_kcontrol *kcontrol,
1684                                  struct snd_ctl_elem_value *ucontrol) {
1685         return snd_asihpi_aesebu_format_get(kcontrol, ucontrol,
1686                                         hpi_aesebu_receiver_get_format);
1687 }
1688
1689 static int snd_asihpi_aesebu_rx_format_put(struct snd_kcontrol *kcontrol,
1690                                  struct snd_ctl_elem_value *ucontrol) {
1691         return snd_asihpi_aesebu_format_put(kcontrol, ucontrol,
1692                                         hpi_aesebu_receiver_set_format);
1693 }
1694
1695 static int snd_asihpi_aesebu_rxstatus_info(struct snd_kcontrol *kcontrol,
1696                                   struct snd_ctl_elem_info *uinfo)
1697 {
1698         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1699         uinfo->count = 1;
1700
1701         uinfo->value.integer.min = 0;
1702         uinfo->value.integer.max = 0X1F;
1703         uinfo->value.integer.step = 1;
1704
1705         return 0;
1706 }
1707
1708 static int snd_asihpi_aesebu_rxstatus_get(struct snd_kcontrol *kcontrol,
1709                                  struct snd_ctl_elem_value *ucontrol) {
1710
1711         u32 h_control = kcontrol->private_value;
1712         u16 status;
1713
1714         hpi_handle_error(hpi_aesebu_receiver_get_error_status(
1715                                          h_control, &status));
1716         ucontrol->value.integer.value[0] = status;
1717         return 0;
1718 }
1719
1720 static int snd_asihpi_aesebu_rx_add(struct snd_card_asihpi *asihpi,
1721                                     struct hpi_control *hpi_ctl)
1722 {
1723         struct snd_card *card = asihpi->card;
1724         struct snd_kcontrol_new snd_control;
1725
1726         asihpi_ctl_init(&snd_control, hpi_ctl, "Format");
1727         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1728         snd_control.info = snd_asihpi_aesebu_format_info;
1729         snd_control.get = snd_asihpi_aesebu_rx_format_get;
1730         snd_control.put = snd_asihpi_aesebu_rx_format_put;
1731
1732
1733         if (ctl_add(card, &snd_control, asihpi) < 0)
1734                 return -EINVAL;
1735
1736         asihpi_ctl_init(&snd_control, hpi_ctl, "Status");
1737         snd_control.access =
1738             SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
1739         snd_control.info = snd_asihpi_aesebu_rxstatus_info;
1740         snd_control.get = snd_asihpi_aesebu_rxstatus_get;
1741
1742         return ctl_add(card, &snd_control, asihpi);
1743 }
1744
1745 static int snd_asihpi_aesebu_tx_format_get(struct snd_kcontrol *kcontrol,
1746                                  struct snd_ctl_elem_value *ucontrol) {
1747         return snd_asihpi_aesebu_format_get(kcontrol, ucontrol,
1748                                         hpi_aesebu_transmitter_get_format);
1749 }
1750
1751 static int snd_asihpi_aesebu_tx_format_put(struct snd_kcontrol *kcontrol,
1752                                  struct snd_ctl_elem_value *ucontrol) {
1753         return snd_asihpi_aesebu_format_put(kcontrol, ucontrol,
1754                                         hpi_aesebu_transmitter_set_format);
1755 }
1756
1757
1758 static int snd_asihpi_aesebu_tx_add(struct snd_card_asihpi *asihpi,
1759                                     struct hpi_control *hpi_ctl)
1760 {
1761         struct snd_card *card = asihpi->card;
1762         struct snd_kcontrol_new snd_control;
1763
1764         asihpi_ctl_init(&snd_control, hpi_ctl, "Format");
1765         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1766         snd_control.info = snd_asihpi_aesebu_format_info;
1767         snd_control.get = snd_asihpi_aesebu_tx_format_get;
1768         snd_control.put = snd_asihpi_aesebu_tx_format_put;
1769
1770         return ctl_add(card, &snd_control, asihpi);
1771 }
1772
1773 /*------------------------------------------------------------
1774    Tuner controls
1775  ------------------------------------------------------------*/
1776
1777 /* Gain */
1778
1779 static int snd_asihpi_tuner_gain_info(struct snd_kcontrol *kcontrol,
1780                                   struct snd_ctl_elem_info *uinfo)
1781 {
1782         u32 h_control = kcontrol->private_value;
1783         u16 err;
1784         short idx;
1785         u16 gain_range[3];
1786
1787         for (idx = 0; idx < 3; idx++) {
1788                 err = hpi_tuner_query_gain(h_control,
1789                                           idx, &gain_range[idx]);
1790                 if (err != 0)
1791                         return err;
1792         }
1793
1794         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1795         uinfo->count = 1;
1796         uinfo->value.integer.min = ((int)gain_range[0]) / HPI_UNITS_PER_dB;
1797         uinfo->value.integer.max = ((int)gain_range[1]) / HPI_UNITS_PER_dB;
1798         uinfo->value.integer.step = ((int) gain_range[2]) / HPI_UNITS_PER_dB;
1799         return 0;
1800 }
1801
1802 static int snd_asihpi_tuner_gain_get(struct snd_kcontrol *kcontrol,
1803                                  struct snd_ctl_elem_value *ucontrol)
1804 {
1805         /*
1806         struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1807         */
1808         u32 h_control = kcontrol->private_value;
1809         short gain;
1810
1811         hpi_handle_error(hpi_tuner_get_gain(h_control, &gain));
1812         ucontrol->value.integer.value[0] = gain / HPI_UNITS_PER_dB;
1813
1814         return 0;
1815 }
1816
1817 static int snd_asihpi_tuner_gain_put(struct snd_kcontrol *kcontrol,
1818                                  struct snd_ctl_elem_value *ucontrol)
1819 {
1820         /*
1821         struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1822         */
1823         u32 h_control = kcontrol->private_value;
1824         short gain;
1825
1826         gain = (ucontrol->value.integer.value[0]) * HPI_UNITS_PER_dB;
1827         hpi_handle_error(hpi_tuner_set_gain(h_control, gain));
1828
1829         return 1;
1830 }
1831
1832 /* Band  */
1833
1834 static int asihpi_tuner_band_query(struct snd_kcontrol *kcontrol,
1835                                         u16 *band_list, u32 len) {
1836         u32 h_control = kcontrol->private_value;
1837         u16 err = 0;
1838         u32 i;
1839
1840         for (i = 0; i < len; i++) {
1841                 err = hpi_tuner_query_band(
1842                                 h_control, i, &band_list[i]);
1843                 if (err != 0)
1844                         break;
1845         }
1846
1847         if (err && (err != HPI_ERROR_INVALID_OBJ_INDEX))
1848                 return -EIO;
1849
1850         return i;
1851 }
1852
1853 static int snd_asihpi_tuner_band_info(struct snd_kcontrol *kcontrol,
1854                                   struct snd_ctl_elem_info *uinfo)
1855 {
1856         u16 tuner_bands[HPI_TUNER_BAND_LAST];
1857         int num_bands = 0;
1858
1859         num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1860                                 HPI_TUNER_BAND_LAST);
1861
1862         if (num_bands < 0)
1863                 return num_bands;
1864
1865         return snd_ctl_enum_info(uinfo, 1, num_bands, asihpi_tuner_band_names);
1866 }
1867
1868 static int snd_asihpi_tuner_band_get(struct snd_kcontrol *kcontrol,
1869                                  struct snd_ctl_elem_value *ucontrol)
1870 {
1871         u32 h_control = kcontrol->private_value;
1872         /*
1873         struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1874         */
1875         u16 band, idx;
1876         u16 tuner_bands[HPI_TUNER_BAND_LAST];
1877         __always_unused u32 num_bands;
1878
1879         num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1880                                 HPI_TUNER_BAND_LAST);
1881
1882         hpi_handle_error(hpi_tuner_get_band(h_control, &band));
1883
1884         ucontrol->value.enumerated.item[0] = -1;
1885         for (idx = 0; idx < HPI_TUNER_BAND_LAST; idx++)
1886                 if (tuner_bands[idx] == band) {
1887                         ucontrol->value.enumerated.item[0] = idx;
1888                         break;
1889                 }
1890
1891         return 0;
1892 }
1893
1894 static int snd_asihpi_tuner_band_put(struct snd_kcontrol *kcontrol,
1895                                  struct snd_ctl_elem_value *ucontrol)
1896 {
1897         /*
1898         struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1899         */
1900         u32 h_control = kcontrol->private_value;
1901         unsigned int idx;
1902         u16 band;
1903         u16 tuner_bands[HPI_TUNER_BAND_LAST];
1904         __always_unused u32 num_bands;
1905
1906         num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1907                         HPI_TUNER_BAND_LAST);
1908
1909         idx = ucontrol->value.enumerated.item[0];
1910         if (idx >= ARRAY_SIZE(tuner_bands))
1911                 idx = ARRAY_SIZE(tuner_bands) - 1;
1912         band = tuner_bands[idx];
1913         hpi_handle_error(hpi_tuner_set_band(h_control, band));
1914
1915         return 1;
1916 }
1917
1918 /* Freq */
1919
1920 static int snd_asihpi_tuner_freq_info(struct snd_kcontrol *kcontrol,
1921                                   struct snd_ctl_elem_info *uinfo)
1922 {
1923         u32 h_control = kcontrol->private_value;
1924         u16 err;
1925         u16 tuner_bands[HPI_TUNER_BAND_LAST];
1926         u16 num_bands = 0, band_iter, idx;
1927         u32 freq_range[3], temp_freq_range[3];
1928
1929         num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1930                         HPI_TUNER_BAND_LAST);
1931
1932         freq_range[0] = INT_MAX;
1933         freq_range[1] = 0;
1934         freq_range[2] = INT_MAX;
1935
1936         for (band_iter = 0; band_iter < num_bands; band_iter++) {
1937                 for (idx = 0; idx < 3; idx++) {
1938                         err = hpi_tuner_query_frequency(h_control,
1939                                 idx, tuner_bands[band_iter],
1940                                 &temp_freq_range[idx]);
1941                         if (err != 0)
1942                                 return err;
1943                 }
1944
1945                 /* skip band with bogus stepping */
1946                 if (temp_freq_range[2] <= 0)
1947                         continue;
1948
1949                 if (temp_freq_range[0] < freq_range[0])
1950                         freq_range[0] = temp_freq_range[0];
1951                 if (temp_freq_range[1] > freq_range[1])
1952                         freq_range[1] = temp_freq_range[1];
1953                 if (temp_freq_range[2] < freq_range[2])
1954                         freq_range[2] = temp_freq_range[2];
1955         }
1956
1957         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1958         uinfo->count = 1;
1959         uinfo->value.integer.min = ((int)freq_range[0]);
1960         uinfo->value.integer.max = ((int)freq_range[1]);
1961         uinfo->value.integer.step = ((int)freq_range[2]);
1962         return 0;
1963 }
1964
1965 static int snd_asihpi_tuner_freq_get(struct snd_kcontrol *kcontrol,
1966                                  struct snd_ctl_elem_value *ucontrol)
1967 {
1968         u32 h_control = kcontrol->private_value;
1969         u32 freq;
1970
1971         hpi_handle_error(hpi_tuner_get_frequency(h_control, &freq));
1972         ucontrol->value.integer.value[0] = freq;
1973
1974         return 0;
1975 }
1976
1977 static int snd_asihpi_tuner_freq_put(struct snd_kcontrol *kcontrol,
1978                                  struct snd_ctl_elem_value *ucontrol)
1979 {
1980         u32 h_control = kcontrol->private_value;
1981         u32 freq;
1982
1983         freq = ucontrol->value.integer.value[0];
1984         hpi_handle_error(hpi_tuner_set_frequency(h_control, freq));
1985
1986         return 1;
1987 }
1988
1989 /* Tuner control group initializer  */
1990 static int snd_asihpi_tuner_add(struct snd_card_asihpi *asihpi,
1991                                 struct hpi_control *hpi_ctl)
1992 {
1993         struct snd_card *card = asihpi->card;
1994         struct snd_kcontrol_new snd_control;
1995
1996         snd_control.private_value = hpi_ctl->h_control;
1997         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1998
1999         if (!hpi_tuner_get_gain(hpi_ctl->h_control, NULL)) {
2000                 asihpi_ctl_init(&snd_control, hpi_ctl, "Gain");
2001                 snd_control.info = snd_asihpi_tuner_gain_info;
2002                 snd_control.get = snd_asihpi_tuner_gain_get;
2003                 snd_control.put = snd_asihpi_tuner_gain_put;
2004
2005                 if (ctl_add(card, &snd_control, asihpi) < 0)
2006                         return -EINVAL;
2007         }
2008
2009         asihpi_ctl_init(&snd_control, hpi_ctl, "Band");
2010         snd_control.info = snd_asihpi_tuner_band_info;
2011         snd_control.get = snd_asihpi_tuner_band_get;
2012         snd_control.put = snd_asihpi_tuner_band_put;
2013
2014         if (ctl_add(card, &snd_control, asihpi) < 0)
2015                 return -EINVAL;
2016
2017         asihpi_ctl_init(&snd_control, hpi_ctl, "Freq");
2018         snd_control.info = snd_asihpi_tuner_freq_info;
2019         snd_control.get = snd_asihpi_tuner_freq_get;
2020         snd_control.put = snd_asihpi_tuner_freq_put;
2021
2022         return ctl_add(card, &snd_control, asihpi);
2023 }
2024
2025 /*------------------------------------------------------------
2026    Meter controls
2027  ------------------------------------------------------------*/
2028 static int snd_asihpi_meter_info(struct snd_kcontrol *kcontrol,
2029                                  struct snd_ctl_elem_info *uinfo)
2030 {
2031         u32 h_control = kcontrol->private_value;
2032         u32 count;
2033         u16 err;
2034         err = hpi_meter_query_channels(h_control, &count);
2035         if (err)
2036                 count = HPI_MAX_CHANNELS;
2037
2038         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2039         uinfo->count = count;
2040         uinfo->value.integer.min = 0;
2041         uinfo->value.integer.max = 0x7FFFFFFF;
2042         return 0;
2043 }
2044
2045 /* linear values for 10dB steps */
2046 static const int log2lin[] = {
2047         0x7FFFFFFF, /* 0dB */
2048         679093956,
2049         214748365,
2050          67909396,
2051          21474837,
2052           6790940,
2053           2147484, /* -60dB */
2054            679094,
2055            214748, /* -80 */
2056             67909,
2057             21475, /* -100 */
2058              6791,
2059              2147,
2060               679,
2061               214,
2062                68,
2063                21,
2064                 7,
2065                 2
2066 };
2067
2068 static int snd_asihpi_meter_get(struct snd_kcontrol *kcontrol,
2069                                 struct snd_ctl_elem_value *ucontrol)
2070 {
2071         u32 h_control = kcontrol->private_value;
2072         short an_gain_mB[HPI_MAX_CHANNELS], i;
2073         u16 err;
2074
2075         err = hpi_meter_get_peak(h_control, an_gain_mB);
2076
2077         for (i = 0; i < HPI_MAX_CHANNELS; i++) {
2078                 if (err) {
2079                         ucontrol->value.integer.value[i] = 0;
2080                 } else if (an_gain_mB[i] >= 0) {
2081                         ucontrol->value.integer.value[i] =
2082                                 an_gain_mB[i] << 16;
2083                 } else {
2084                         /* -ve is log value in millibels < -60dB,
2085                         * convert to (roughly!) linear,
2086                         */
2087                         ucontrol->value.integer.value[i] =
2088                                         log2lin[an_gain_mB[i] / -1000];
2089                 }
2090         }
2091         return 0;
2092 }
2093
2094 static int snd_asihpi_meter_add(struct snd_card_asihpi *asihpi,
2095                                 struct hpi_control *hpi_ctl, int subidx)
2096 {
2097         struct snd_card *card = asihpi->card;
2098         struct snd_kcontrol_new snd_control;
2099
2100         asihpi_ctl_init(&snd_control, hpi_ctl, "Meter");
2101         snd_control.access =
2102             SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
2103         snd_control.info = snd_asihpi_meter_info;
2104         snd_control.get = snd_asihpi_meter_get;
2105
2106         snd_control.index = subidx;
2107
2108         return ctl_add(card, &snd_control, asihpi);
2109 }
2110
2111 /*------------------------------------------------------------
2112    Multiplexer controls
2113  ------------------------------------------------------------*/
2114 static int snd_card_asihpi_mux_count_sources(struct snd_kcontrol *snd_control)
2115 {
2116         u32 h_control = snd_control->private_value;
2117         struct hpi_control hpi_ctl;
2118         int s, err;
2119         for (s = 0; s < 32; s++) {
2120                 err = hpi_multiplexer_query_source(h_control, s,
2121                                                   &hpi_ctl.
2122                                                   src_node_type,
2123                                                   &hpi_ctl.
2124                                                   src_node_index);
2125                 if (err)
2126                         break;
2127         }
2128         return s;
2129 }
2130
2131 static int snd_asihpi_mux_info(struct snd_kcontrol *kcontrol,
2132                                struct snd_ctl_elem_info *uinfo)
2133 {
2134         u16 src_node_type, src_node_index;
2135         u32 h_control = kcontrol->private_value;
2136
2137         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2138         uinfo->count = 1;
2139         uinfo->value.enumerated.items =
2140             snd_card_asihpi_mux_count_sources(kcontrol);
2141
2142         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2143                 uinfo->value.enumerated.item =
2144                     uinfo->value.enumerated.items - 1;
2145
2146         hpi_multiplexer_query_source(h_control,
2147                                      uinfo->value.enumerated.item,
2148                                      &src_node_type, &src_node_index);
2149
2150         sprintf(uinfo->value.enumerated.name, "%s %d",
2151                 asihpi_src_names[src_node_type - HPI_SOURCENODE_NONE],
2152                 src_node_index);
2153         return 0;
2154 }
2155
2156 static int snd_asihpi_mux_get(struct snd_kcontrol *kcontrol,
2157                               struct snd_ctl_elem_value *ucontrol)
2158 {
2159         u32 h_control = kcontrol->private_value;
2160         u16 source_type, source_index;
2161         u16 src_node_type, src_node_index;
2162         int s;
2163
2164         hpi_handle_error(hpi_multiplexer_get_source(h_control,
2165                                 &source_type, &source_index));
2166         /* Should cache this search result! */
2167         for (s = 0; s < 256; s++) {
2168                 if (hpi_multiplexer_query_source(h_control, s,
2169                                             &src_node_type, &src_node_index))
2170                         break;
2171
2172                 if ((source_type == src_node_type)
2173                     && (source_index == src_node_index)) {
2174                         ucontrol->value.enumerated.item[0] = s;
2175                         return 0;
2176                 }
2177         }
2178         snd_printd(KERN_WARNING
2179                 "Control %x failed to match mux source %hu %hu\n",
2180                 h_control, source_type, source_index);
2181         ucontrol->value.enumerated.item[0] = 0;
2182         return 0;
2183 }
2184
2185 static int snd_asihpi_mux_put(struct snd_kcontrol *kcontrol,
2186                               struct snd_ctl_elem_value *ucontrol)
2187 {
2188         int change;
2189         u32 h_control = kcontrol->private_value;
2190         u16 source_type, source_index;
2191         u16 e;
2192
2193         change = 1;
2194
2195         e = hpi_multiplexer_query_source(h_control,
2196                                     ucontrol->value.enumerated.item[0],
2197                                     &source_type, &source_index);
2198         if (!e)
2199                 hpi_handle_error(
2200                         hpi_multiplexer_set_source(h_control,
2201                                                 source_type, source_index));
2202         return change;
2203 }
2204
2205
2206 static int  snd_asihpi_mux_add(struct snd_card_asihpi *asihpi,
2207                                struct hpi_control *hpi_ctl)
2208 {
2209         struct snd_card *card = asihpi->card;
2210         struct snd_kcontrol_new snd_control;
2211
2212         asihpi_ctl_init(&snd_control, hpi_ctl, "Route");
2213         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2214         snd_control.info = snd_asihpi_mux_info;
2215         snd_control.get = snd_asihpi_mux_get;
2216         snd_control.put = snd_asihpi_mux_put;
2217
2218         return ctl_add(card, &snd_control, asihpi);
2219
2220 }
2221
2222 /*------------------------------------------------------------
2223    Channel mode controls
2224  ------------------------------------------------------------*/
2225 static int snd_asihpi_cmode_info(struct snd_kcontrol *kcontrol,
2226                                  struct snd_ctl_elem_info *uinfo)
2227 {
2228         static const char * const mode_names[HPI_CHANNEL_MODE_LAST + 1] = {
2229                 "invalid",
2230                 "Normal", "Swap",
2231                 "From Left", "From Right",
2232                 "To Left", "To Right"
2233         };
2234
2235         u32 h_control = kcontrol->private_value;
2236         u16 mode;
2237         int i;
2238         const char *mapped_names[6];
2239         int valid_modes = 0;
2240
2241         /* HPI channel mode values can be from 1 to 6
2242         Some adapters only support a contiguous subset
2243         */
2244         for (i = 0; i < HPI_CHANNEL_MODE_LAST; i++)
2245                 if (!hpi_channel_mode_query_mode(
2246                         h_control, i, &mode)) {
2247                         mapped_names[valid_modes] = mode_names[mode];
2248                         valid_modes++;
2249                         }
2250
2251         if (!valid_modes)
2252                 return -EINVAL;
2253
2254         return snd_ctl_enum_info(uinfo, 1, valid_modes, mapped_names);
2255 }
2256
2257 static int snd_asihpi_cmode_get(struct snd_kcontrol *kcontrol,
2258                                 struct snd_ctl_elem_value *ucontrol)
2259 {
2260         u32 h_control = kcontrol->private_value;
2261         u16 mode;
2262
2263         if (hpi_channel_mode_get(h_control, &mode))
2264                 mode = 1;
2265
2266         ucontrol->value.enumerated.item[0] = mode - 1;
2267
2268         return 0;
2269 }
2270
2271 static int snd_asihpi_cmode_put(struct snd_kcontrol *kcontrol,
2272                                 struct snd_ctl_elem_value *ucontrol)
2273 {
2274         int change;
2275         u32 h_control = kcontrol->private_value;
2276
2277         change = 1;
2278
2279         hpi_handle_error(hpi_channel_mode_set(h_control,
2280                            ucontrol->value.enumerated.item[0] + 1));
2281         return change;
2282 }
2283
2284
2285 static int snd_asihpi_cmode_add(struct snd_card_asihpi *asihpi,
2286                                 struct hpi_control *hpi_ctl)
2287 {
2288         struct snd_card *card = asihpi->card;
2289         struct snd_kcontrol_new snd_control;
2290
2291         asihpi_ctl_init(&snd_control, hpi_ctl, "Mode");
2292         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2293         snd_control.info = snd_asihpi_cmode_info;
2294         snd_control.get = snd_asihpi_cmode_get;
2295         snd_control.put = snd_asihpi_cmode_put;
2296
2297         return ctl_add(card, &snd_control, asihpi);
2298 }
2299
2300 /*------------------------------------------------------------
2301    Sampleclock source  controls
2302  ------------------------------------------------------------*/
2303 static const char * const sampleclock_sources[] = {
2304         "N/A", "Local PLL", "Digital Sync", "Word External", "Word Header",
2305         "SMPTE", "Digital1", "Auto", "Network", "Invalid",
2306         "Prev Module", "BLU-Link",
2307         "Digital2", "Digital3", "Digital4", "Digital5",
2308         "Digital6", "Digital7", "Digital8"};
2309
2310         /* Number of strings must match expected enumerated values */
2311         compile_time_assert(
2312                 (ARRAY_SIZE(sampleclock_sources) == MAX_CLOCKSOURCES),
2313                 assert_sampleclock_sources_size);
2314
2315 static int snd_asihpi_clksrc_info(struct snd_kcontrol *kcontrol,
2316                                   struct snd_ctl_elem_info *uinfo)
2317 {
2318         struct snd_card_asihpi *asihpi =
2319                         (struct snd_card_asihpi *)(kcontrol->private_data);
2320         struct clk_cache *clkcache = &asihpi->cc;
2321         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2322         uinfo->count = 1;
2323         uinfo->value.enumerated.items = clkcache->count;
2324
2325         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2326                 uinfo->value.enumerated.item =
2327                                 uinfo->value.enumerated.items - 1;
2328
2329         strcpy(uinfo->value.enumerated.name,
2330                clkcache->s[uinfo->value.enumerated.item].name);
2331         return 0;
2332 }
2333
2334 static int snd_asihpi_clksrc_get(struct snd_kcontrol *kcontrol,
2335                                  struct snd_ctl_elem_value *ucontrol)
2336 {
2337         struct snd_card_asihpi *asihpi =
2338                         (struct snd_card_asihpi *)(kcontrol->private_data);
2339         struct clk_cache *clkcache = &asihpi->cc;
2340         u32 h_control = kcontrol->private_value;
2341         u16 source, srcindex = 0;
2342         int i;
2343
2344         ucontrol->value.enumerated.item[0] = 0;
2345         if (hpi_sample_clock_get_source(h_control, &source))
2346                 source = 0;
2347
2348         if (source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2349                 if (hpi_sample_clock_get_source_index(h_control, &srcindex))
2350                         srcindex = 0;
2351
2352         for (i = 0; i < clkcache->count; i++)
2353                 if ((clkcache->s[i].source == source) &&
2354                         (clkcache->s[i].index == srcindex))
2355                         break;
2356
2357         ucontrol->value.enumerated.item[0] = i;
2358
2359         return 0;
2360 }
2361
2362 static int snd_asihpi_clksrc_put(struct snd_kcontrol *kcontrol,
2363                                  struct snd_ctl_elem_value *ucontrol)
2364 {
2365         struct snd_card_asihpi *asihpi =
2366                         (struct snd_card_asihpi *)(kcontrol->private_data);
2367         struct clk_cache *clkcache = &asihpi->cc;
2368         unsigned int item;
2369         int change;
2370         u32 h_control = kcontrol->private_value;
2371
2372         change = 1;
2373         item = ucontrol->value.enumerated.item[0];
2374         if (item >= clkcache->count)
2375                 item = clkcache->count-1;
2376
2377         hpi_handle_error(hpi_sample_clock_set_source(
2378                                 h_control, clkcache->s[item].source));
2379
2380         if (clkcache->s[item].source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2381                 hpi_handle_error(hpi_sample_clock_set_source_index(
2382                                 h_control, clkcache->s[item].index));
2383         return change;
2384 }
2385
2386 /*------------------------------------------------------------
2387    Clkrate controls
2388  ------------------------------------------------------------*/
2389 /* Need to change this to enumerated control with list of rates */
2390 static int snd_asihpi_clklocal_info(struct snd_kcontrol *kcontrol,
2391                                    struct snd_ctl_elem_info *uinfo)
2392 {
2393         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2394         uinfo->count = 1;
2395         uinfo->value.integer.min = 8000;
2396         uinfo->value.integer.max = 192000;
2397         uinfo->value.integer.step = 100;
2398
2399         return 0;
2400 }
2401
2402 static int snd_asihpi_clklocal_get(struct snd_kcontrol *kcontrol,
2403                                   struct snd_ctl_elem_value *ucontrol)
2404 {
2405         u32 h_control = kcontrol->private_value;
2406         u32 rate;
2407         u16 e;
2408
2409         e = hpi_sample_clock_get_local_rate(h_control, &rate);
2410         if (!e)
2411                 ucontrol->value.integer.value[0] = rate;
2412         else
2413                 ucontrol->value.integer.value[0] = 0;
2414         return 0;
2415 }
2416
2417 static int snd_asihpi_clklocal_put(struct snd_kcontrol *kcontrol,
2418                                   struct snd_ctl_elem_value *ucontrol)
2419 {
2420         int change;
2421         u32 h_control = kcontrol->private_value;
2422
2423         /*  change = asihpi->mixer_clkrate[addr][0] != left ||
2424            asihpi->mixer_clkrate[addr][1] != right;
2425          */
2426         change = 1;
2427         hpi_handle_error(hpi_sample_clock_set_local_rate(h_control,
2428                                       ucontrol->value.integer.value[0]));
2429         return change;
2430 }
2431
2432 static int snd_asihpi_clkrate_info(struct snd_kcontrol *kcontrol,
2433                                    struct snd_ctl_elem_info *uinfo)
2434 {
2435         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2436         uinfo->count = 1;
2437         uinfo->value.integer.min = 8000;
2438         uinfo->value.integer.max = 192000;
2439         uinfo->value.integer.step = 100;
2440
2441         return 0;
2442 }
2443
2444 static int snd_asihpi_clkrate_get(struct snd_kcontrol *kcontrol,
2445                                   struct snd_ctl_elem_value *ucontrol)
2446 {
2447         u32 h_control = kcontrol->private_value;
2448         u32 rate;
2449         u16 e;
2450
2451         e = hpi_sample_clock_get_sample_rate(h_control, &rate);
2452         if (!e)
2453                 ucontrol->value.integer.value[0] = rate;
2454         else
2455                 ucontrol->value.integer.value[0] = 0;
2456         return 0;
2457 }
2458
2459 static int snd_asihpi_sampleclock_add(struct snd_card_asihpi *asihpi,
2460                                       struct hpi_control *hpi_ctl)
2461 {
2462         struct snd_card *card;
2463         struct snd_kcontrol_new snd_control;
2464
2465         struct clk_cache *clkcache;
2466         u32 hSC =  hpi_ctl->h_control;
2467         int has_aes_in = 0;
2468         int i, j;
2469         u16 source;
2470
2471         if (snd_BUG_ON(!asihpi))
2472                 return -EINVAL;
2473         card = asihpi->card;
2474         clkcache = &asihpi->cc;
2475         snd_control.private_value = hpi_ctl->h_control;
2476
2477         clkcache->has_local = 0;
2478
2479         for (i = 0; i <= HPI_SAMPLECLOCK_SOURCE_LAST; i++) {
2480                 if  (hpi_sample_clock_query_source(hSC,
2481                                 i, &source))
2482                         break;
2483                 clkcache->s[i].source = source;
2484                 clkcache->s[i].index = 0;
2485                 clkcache->s[i].name = sampleclock_sources[source];
2486                 if (source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2487                         has_aes_in = 1;
2488                 if (source == HPI_SAMPLECLOCK_SOURCE_LOCAL)
2489                         clkcache->has_local = 1;
2490         }
2491         if (has_aes_in)
2492                 /* already will have picked up index 0 above */
2493                 for (j = 1; j < 8; j++) {
2494                         if (hpi_sample_clock_query_source_index(hSC,
2495                                 j, HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT,
2496                                 &source))
2497                                 break;
2498                         clkcache->s[i].source =
2499                                 HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT;
2500                         clkcache->s[i].index = j;
2501                         clkcache->s[i].name = sampleclock_sources[
2502                                         j+HPI_SAMPLECLOCK_SOURCE_LAST];
2503                         i++;
2504                 }
2505         clkcache->count = i;
2506
2507         asihpi_ctl_init(&snd_control, hpi_ctl, "Source");
2508         snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE ;
2509         snd_control.info = snd_asihpi_clksrc_info;
2510         snd_control.get = snd_asihpi_clksrc_get;
2511         snd_control.put = snd_asihpi_clksrc_put;
2512         if (ctl_add(card, &snd_control, asihpi) < 0)
2513                 return -EINVAL;
2514
2515
2516         if (clkcache->has_local) {
2517                 asihpi_ctl_init(&snd_control, hpi_ctl, "Localrate");
2518                 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE ;
2519                 snd_control.info = snd_asihpi_clklocal_info;
2520                 snd_control.get = snd_asihpi_clklocal_get;
2521                 snd_control.put = snd_asihpi_clklocal_put;
2522
2523
2524                 if (ctl_add(card, &snd_control, asihpi) < 0)
2525                         return -EINVAL;
2526         }
2527
2528         asihpi_ctl_init(&snd_control, hpi_ctl, "Rate");
2529         snd_control.access =
2530             SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
2531         snd_control.info = snd_asihpi_clkrate_info;
2532         snd_control.get = snd_asihpi_clkrate_get;
2533
2534         return ctl_add(card, &snd_control, asihpi);
2535 }
2536 /*------------------------------------------------------------
2537    Mixer
2538  ------------------------------------------------------------*/
2539
2540 static int snd_card_asihpi_mixer_new(struct snd_card_asihpi *asihpi)
2541 {
2542         struct snd_card *card;
2543         unsigned int idx = 0;
2544         unsigned int subindex = 0;
2545         int err;
2546         struct hpi_control hpi_ctl, prev_ctl;
2547
2548         if (snd_BUG_ON(!asihpi))
2549                 return -EINVAL;
2550         card = asihpi->card;
2551         strcpy(card->mixername, "Asihpi Mixer");
2552
2553         err =
2554             hpi_mixer_open(asihpi->hpi->adapter->index,
2555                           &asihpi->h_mixer);
2556         hpi_handle_error(err);
2557         if (err)
2558                 return -err;
2559
2560         memset(&prev_ctl, 0, sizeof(prev_ctl));
2561         prev_ctl.control_type = -1;
2562
2563         for (idx = 0; idx < 2000; idx++) {
2564                 err = hpi_mixer_get_control_by_index(
2565                                 asihpi->h_mixer,
2566                                 idx,
2567                                 &hpi_ctl.src_node_type,
2568                                 &hpi_ctl.src_node_index,
2569                                 &hpi_ctl.dst_node_type,
2570                                 &hpi_ctl.dst_node_index,
2571                                 &hpi_ctl.control_type,
2572                                 &hpi_ctl.h_control);
2573                 if (err) {
2574                         if (err == HPI_ERROR_CONTROL_DISABLED) {
2575                                 if (mixer_dump)
2576                                         dev_info(&asihpi->pci->dev,
2577                                                    "Disabled HPI Control(%d)\n",
2578                                                    idx);
2579                                 continue;
2580                         } else
2581                                 break;
2582
2583                 }
2584
2585                 hpi_ctl.src_node_type -= HPI_SOURCENODE_NONE;
2586                 hpi_ctl.dst_node_type -= HPI_DESTNODE_NONE;
2587
2588                 /* ASI50xx in SSX mode has multiple meters on the same node.
2589                    Use subindex to create distinct ALSA controls
2590                    for any duplicated controls.
2591                 */
2592                 if ((hpi_ctl.control_type == prev_ctl.control_type) &&
2593                     (hpi_ctl.src_node_type == prev_ctl.src_node_type) &&
2594                     (hpi_ctl.src_node_index == prev_ctl.src_node_index) &&
2595                     (hpi_ctl.dst_node_type == prev_ctl.dst_node_type) &&
2596                     (hpi_ctl.dst_node_index == prev_ctl.dst_node_index))
2597                         subindex++;
2598                 else
2599                         subindex = 0;
2600
2601                 prev_ctl = hpi_ctl;
2602
2603                 switch (hpi_ctl.control_type) {
2604                 case HPI_CONTROL_VOLUME:
2605                         err = snd_asihpi_volume_add(asihpi, &hpi_ctl);
2606                         break;
2607                 case HPI_CONTROL_LEVEL:
2608                         err = snd_asihpi_level_add(asihpi, &hpi_ctl);
2609                         break;
2610                 case HPI_CONTROL_MULTIPLEXER:
2611                         err = snd_asihpi_mux_add(asihpi, &hpi_ctl);
2612                         break;
2613                 case HPI_CONTROL_CHANNEL_MODE:
2614                         err = snd_asihpi_cmode_add(asihpi, &hpi_ctl);
2615                         break;
2616                 case HPI_CONTROL_METER:
2617                         err = snd_asihpi_meter_add(asihpi, &hpi_ctl, subindex);
2618                         break;
2619                 case HPI_CONTROL_SAMPLECLOCK:
2620                         err = snd_asihpi_sampleclock_add(
2621                                                 asihpi, &hpi_ctl);
2622                         break;
2623                 case HPI_CONTROL_CONNECTION:    /* ignore these */
2624                         continue;
2625                 case HPI_CONTROL_TUNER:
2626                         err = snd_asihpi_tuner_add(asihpi, &hpi_ctl);
2627                         break;
2628                 case HPI_CONTROL_AESEBU_TRANSMITTER:
2629                         err = snd_asihpi_aesebu_tx_add(asihpi, &hpi_ctl);
2630                         break;
2631                 case HPI_CONTROL_AESEBU_RECEIVER:
2632                         err = snd_asihpi_aesebu_rx_add(asihpi, &hpi_ctl);
2633                         break;
2634                 case HPI_CONTROL_VOX:
2635                 case HPI_CONTROL_BITSTREAM:
2636                 case HPI_CONTROL_MICROPHONE:
2637                 case HPI_CONTROL_PARAMETRIC_EQ:
2638                 case HPI_CONTROL_COMPANDER:
2639                 default:
2640                         if (mixer_dump)
2641                                 dev_info(&asihpi->pci->dev,
2642                                         "Untranslated HPI Control (%d) %d %d %d %d %d\n",
2643                                         idx,
2644                                         hpi_ctl.control_type,
2645                                         hpi_ctl.src_node_type,
2646                                         hpi_ctl.src_node_index,
2647                                         hpi_ctl.dst_node_type,
2648                                         hpi_ctl.dst_node_index);
2649                         continue;
2650                 }
2651                 if (err < 0)
2652                         return err;
2653         }
2654         if (HPI_ERROR_INVALID_OBJ_INDEX != err)
2655                 hpi_handle_error(err);
2656
2657         dev_info(&asihpi->pci->dev, "%d mixer controls found\n", idx);
2658
2659         return 0;
2660 }
2661
2662 /*------------------------------------------------------------
2663    /proc interface
2664  ------------------------------------------------------------*/
2665
2666 static void
2667 snd_asihpi_proc_read(struct snd_info_entry *entry,
2668                         struct snd_info_buffer *buffer)
2669 {
2670         struct snd_card_asihpi *asihpi = entry->private_data;
2671         u32 h_control;
2672         u32 rate = 0;
2673         u16 source = 0;
2674
2675         u16 num_outstreams;
2676         u16 num_instreams;
2677         u16 version;
2678         u32 serial_number;
2679         u16 type;
2680
2681         int err;
2682
2683         snd_iprintf(buffer, "ASIHPI driver proc file\n");
2684
2685         hpi_handle_error(hpi_adapter_get_info(asihpi->hpi->adapter->index,
2686                         &num_outstreams, &num_instreams,
2687                         &version, &serial_number, &type));
2688
2689         snd_iprintf(buffer,
2690                         "Adapter type ASI%4X\nHardware Index %d\n"
2691                         "%d outstreams\n%d instreams\n",
2692                         type, asihpi->hpi->adapter->index,
2693                         num_outstreams, num_instreams);
2694
2695         snd_iprintf(buffer,
2696                 "Serial#%d\nHardware version %c%d\nDSP code version %03d\n",
2697                 serial_number, ((version >> 3) & 0xf) + 'A', version & 0x7,
2698                 ((version >> 13) * 100) + ((version >> 7) & 0x3f));
2699
2700         err = hpi_mixer_get_control(asihpi->h_mixer,
2701                                   HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
2702                                   HPI_CONTROL_SAMPLECLOCK, &h_control);
2703
2704         if (!err) {
2705                 err = hpi_sample_clock_get_sample_rate(h_control, &rate);
2706                 err += hpi_sample_clock_get_source(h_control, &source);
2707
2708                 if (!err)
2709                         snd_iprintf(buffer, "Sample Clock %dHz, source %s\n",
2710                         rate, sampleclock_sources[source]);
2711         }
2712 }
2713
2714 static void snd_asihpi_proc_init(struct snd_card_asihpi *asihpi)
2715 {
2716         snd_card_ro_proc_new(asihpi->card, "info", asihpi,
2717                              snd_asihpi_proc_read);
2718 }
2719
2720 /*------------------------------------------------------------
2721    HWDEP
2722  ------------------------------------------------------------*/
2723
2724 static int snd_asihpi_hpi_open(struct snd_hwdep *hw, struct file *file)
2725 {
2726         if (enable_hpi_hwdep)
2727                 return 0;
2728         else
2729                 return -ENODEV;
2730
2731 }
2732
2733 static int snd_asihpi_hpi_release(struct snd_hwdep *hw, struct file *file)
2734 {
2735         if (enable_hpi_hwdep)
2736                 return asihpi_hpi_release(file);
2737         else
2738                 return -ENODEV;
2739 }
2740
2741 static int snd_asihpi_hpi_ioctl(struct snd_hwdep *hw, struct file *file,
2742                                 unsigned int cmd, unsigned long arg)
2743 {
2744         if (enable_hpi_hwdep)
2745                 return asihpi_hpi_ioctl(file, cmd, arg);
2746         else
2747                 return -ENODEV;
2748 }
2749
2750
2751 /* results in /dev/snd/hwC#D0 file for each card with index #
2752    also /proc/asound/hwdep will contain '#-00: asihpi (HPI) for each card'
2753 */
2754 static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi, int device)
2755 {
2756         struct snd_hwdep *hw;
2757         int err;
2758
2759         err = snd_hwdep_new(asihpi->card, "HPI", device, &hw);
2760         if (err < 0)
2761                 return err;
2762         strcpy(hw->name, "asihpi (HPI)");
2763         hw->iface = SNDRV_HWDEP_IFACE_LAST;
2764         hw->ops.open = snd_asihpi_hpi_open;
2765         hw->ops.ioctl = snd_asihpi_hpi_ioctl;
2766         hw->ops.release = snd_asihpi_hpi_release;
2767         hw->private_data = asihpi;
2768         return 0;
2769 }
2770
2771 /*------------------------------------------------------------
2772    CARD
2773  ------------------------------------------------------------*/
2774 static int snd_asihpi_probe(struct pci_dev *pci_dev,
2775                             const struct pci_device_id *pci_id)
2776 {
2777         int err;
2778         struct hpi_adapter *hpi;
2779         struct snd_card *card;
2780         struct snd_card_asihpi *asihpi;
2781
2782         u32 h_control;
2783         u32 h_stream;
2784         u32 adapter_index;
2785
2786         static int dev;
2787         if (dev >= SNDRV_CARDS)
2788                 return -ENODEV;
2789
2790         /* Should this be enable[hpi->index] ? */
2791         if (!enable[dev]) {
2792                 dev++;
2793                 return -ENOENT;
2794         }
2795
2796         /* Initialise low-level HPI driver */
2797         err = asihpi_adapter_probe(pci_dev, pci_id);
2798         if (err < 0)
2799                 return err;
2800
2801         hpi = pci_get_drvdata(pci_dev);
2802         adapter_index = hpi->adapter->index;
2803         /* first try to give the card the same index as its hardware index */
2804         err = snd_card_new(&pci_dev->dev, adapter_index, id[adapter_index],
2805                            THIS_MODULE, sizeof(struct snd_card_asihpi), &card);
2806         if (err < 0) {
2807                 /* if that fails, try the default index==next available */
2808                 err = snd_card_new(&pci_dev->dev, index[dev], id[dev],
2809                                    THIS_MODULE, sizeof(struct snd_card_asihpi),
2810                                    &card);
2811                 if (err < 0)
2812                         return err;
2813                 dev_warn(&pci_dev->dev, "Adapter index %d->ALSA index %d\n",
2814                         adapter_index, card->number);
2815         }
2816
2817         asihpi = card->private_data;
2818         asihpi->card = card;
2819         asihpi->pci = pci_dev;
2820         asihpi->hpi = hpi;
2821         hpi->snd_card = card;
2822
2823         err = hpi_adapter_get_property(adapter_index,
2824                 HPI_ADAPTER_PROPERTY_CAPS1,
2825                 NULL, &asihpi->support_grouping);
2826         if (err)
2827                 asihpi->support_grouping = 0;
2828
2829         err = hpi_adapter_get_property(adapter_index,
2830                 HPI_ADAPTER_PROPERTY_CAPS2,
2831                 &asihpi->support_mrx, NULL);
2832         if (err)
2833                 asihpi->support_mrx = 0;
2834
2835         err = hpi_adapter_get_property(adapter_index,
2836                 HPI_ADAPTER_PROPERTY_INTERVAL,
2837                 NULL, &asihpi->update_interval_frames);
2838         if (err)
2839                 asihpi->update_interval_frames = 512;
2840
2841         if (hpi->interrupt_mode) {
2842                 asihpi->pcm_start = snd_card_asihpi_pcm_int_start;
2843                 asihpi->pcm_stop = snd_card_asihpi_pcm_int_stop;
2844                 hpi->interrupt_callback = snd_card_asihpi_isr;
2845         } else {
2846                 asihpi->pcm_start = snd_card_asihpi_pcm_timer_start;
2847                 asihpi->pcm_stop = snd_card_asihpi_pcm_timer_stop;
2848         }
2849
2850         hpi_handle_error(hpi_instream_open(adapter_index,
2851                              0, &h_stream));
2852
2853         err = hpi_instream_host_buffer_free(h_stream);
2854         asihpi->can_dma = (!err);
2855
2856         hpi_handle_error(hpi_instream_close(h_stream));
2857
2858         if (!asihpi->can_dma)
2859                 asihpi->update_interval_frames *= 2;
2860
2861         err = hpi_adapter_get_property(adapter_index,
2862                 HPI_ADAPTER_PROPERTY_CURCHANNELS,
2863                 &asihpi->in_max_chans, &asihpi->out_max_chans);
2864         if (err) {
2865                 asihpi->in_max_chans = 2;
2866                 asihpi->out_max_chans = 2;
2867         }
2868
2869         if (asihpi->out_max_chans > 2) { /* assume LL mode */
2870                 asihpi->out_min_chans = asihpi->out_max_chans;
2871                 asihpi->in_min_chans = asihpi->in_max_chans;
2872                 asihpi->support_grouping = 0;
2873         } else {
2874                 asihpi->out_min_chans = 1;
2875                 asihpi->in_min_chans = 1;
2876         }
2877
2878         dev_info(&pci_dev->dev, "Has dma:%d, grouping:%d, mrx:%d, uif:%d\n",
2879                         asihpi->can_dma,
2880                         asihpi->support_grouping,
2881                         asihpi->support_mrx,
2882                         asihpi->update_interval_frames
2883               );
2884
2885         err = snd_card_asihpi_pcm_new(asihpi, 0);
2886         if (err < 0) {
2887                 dev_err(&pci_dev->dev, "pcm_new failed\n");
2888                 goto __nodev;
2889         }
2890         err = snd_card_asihpi_mixer_new(asihpi);
2891         if (err < 0) {
2892                 dev_err(&pci_dev->dev, "mixer_new failed\n");
2893                 goto __nodev;
2894         }
2895
2896         err = hpi_mixer_get_control(asihpi->h_mixer,
2897                                   HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
2898                                   HPI_CONTROL_SAMPLECLOCK, &h_control);
2899
2900         if (!err)
2901                 err = hpi_sample_clock_set_local_rate(
2902                         h_control, adapter_fs);
2903
2904         snd_asihpi_proc_init(asihpi);
2905
2906         /* always create, can be enabled or disabled dynamically
2907             by enable_hwdep  module param*/
2908         snd_asihpi_hpi_new(asihpi, 0);
2909
2910         strcpy(card->driver, "ASIHPI");
2911
2912         sprintf(card->shortname, "AudioScience ASI%4X",
2913                         asihpi->hpi->adapter->type);
2914         sprintf(card->longname, "%s %i",
2915                         card->shortname, adapter_index);
2916         err = snd_card_register(card);
2917
2918         if (!err) {
2919                 dev++;
2920                 return 0;
2921         }
2922 __nodev:
2923         snd_card_free(card);
2924         dev_err(&pci_dev->dev, "snd_asihpi_probe error %d\n", err);
2925         return err;
2926
2927 }
2928
2929 static void snd_asihpi_remove(struct pci_dev *pci_dev)
2930 {
2931         struct hpi_adapter *hpi = pci_get_drvdata(pci_dev);
2932
2933         /* Stop interrupts */
2934         if (hpi->interrupt_mode) {
2935                 hpi->interrupt_callback = NULL;
2936                 hpi_handle_error(hpi_adapter_set_property(hpi->adapter->index,
2937                         HPI_ADAPTER_PROPERTY_IRQ_RATE, 0, 0));
2938         }
2939
2940         snd_card_free(hpi->snd_card);
2941         hpi->snd_card = NULL;
2942         asihpi_adapter_remove(pci_dev);
2943 }
2944
2945 static const struct pci_device_id asihpi_pci_tbl[] = {
2946         {HPI_PCI_VENDOR_ID_TI, HPI_PCI_DEV_ID_DSP6205,
2947                 HPI_PCI_VENDOR_ID_AUDIOSCIENCE, PCI_ANY_ID, 0, 0,
2948                 (kernel_ulong_t)HPI_6205},
2949         {HPI_PCI_VENDOR_ID_TI, HPI_PCI_DEV_ID_PCI2040,
2950                 HPI_PCI_VENDOR_ID_AUDIOSCIENCE, PCI_ANY_ID, 0, 0,
2951                 (kernel_ulong_t)HPI_6000},
2952         {0,}
2953 };
2954 MODULE_DEVICE_TABLE(pci, asihpi_pci_tbl);
2955
2956 static struct pci_driver driver = {
2957         .name = KBUILD_MODNAME,
2958         .id_table = asihpi_pci_tbl,
2959         .probe = snd_asihpi_probe,
2960         .remove = snd_asihpi_remove,
2961 };
2962
2963 static int __init snd_asihpi_init(void)
2964 {
2965         asihpi_init();
2966         return pci_register_driver(&driver);
2967 }
2968
2969 static void __exit snd_asihpi_exit(void)
2970 {
2971
2972         pci_unregister_driver(&driver);
2973         asihpi_exit();
2974 }
2975
2976 module_init(snd_asihpi_init)
2977 module_exit(snd_asihpi_exit)
2978