sound/pci/asihpi/asihpi.c

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