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