sound/pci/asihpi/asihpi.c

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