Lines Matching refs:chip
99 void snd_ad1848_out(struct snd_ad1848 *chip,
105 for (timeout = 250; timeout > 0 && (inb(AD1848P(chip, REGSEL)) & AD1848_INIT); timeout--)
108 if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
111 outb(chip->mce_bit | reg, AD1848P(chip, REGSEL));
112 outb(chip->image[reg] = value, AD1848P(chip, REG));
118 static void snd_ad1848_dout(struct snd_ad1848 *chip,
123 for (timeout = 250; timeout > 0 && (inb(AD1848P(chip, REGSEL)) & AD1848_INIT); timeout--)
125 outb(chip->mce_bit | reg, AD1848P(chip, REGSEL));
126 outb(value, AD1848P(chip, REG));
130 static unsigned char snd_ad1848_in(struct snd_ad1848 *chip, unsigned char reg)
134 for (timeout = 250; timeout > 0 && (inb(AD1848P(chip, REGSEL)) & AD1848_INIT); timeout--)
137 if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
140 outb(chip->mce_bit | reg, AD1848P(chip, REGSEL));
142 return inb(AD1848P(chip, REG));
150 static void snd_ad1848_mce_up(struct snd_ad1848 *chip)
155 for (timeout = 250; timeout > 0 && (inb(AD1848P(chip, REGSEL)) & AD1848_INIT); timeout--)
158 if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
161 spin_lock_irqsave(&chip->reg_lock, flags);
162 chip->mce_bit |= AD1848_MCE;
163 timeout = inb(AD1848P(chip, REGSEL));
165 snd_printk(KERN_WARNING "mce_up [0x%lx]: serious init problem - codec still busy\n", chip->port);
167 outb(chip->mce_bit | (timeout & 0x1f), AD1848P(chip, REGSEL));
168 spin_unlock_irqrestore(&chip->reg_lock, flags);
171 static void snd_ad1848_mce_down(struct snd_ad1848 *chip)
177 spin_lock_irqsave(&chip->reg_lock, flags);
179 inb(AD1848P(chip, REGSEL));
181 for (timeout = 12000; timeout > 0 && (inb(AD1848P(chip, REGSEL)) & AD1848_INIT); timeout--)
184 if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
185 snd_printk(KERN_WARNING "mce_down [0x%lx] - auto calibration time out (0)\n", AD1848P(chip, REGSEL));
187 chip->mce_bit &= ~AD1848_MCE;
188 timeout = inb(AD1848P(chip, REGSEL));
189 outb(chip->mce_bit | (timeout & 0x1f), AD1848P(chip, REGSEL));
191 snd_printk(KERN_WARNING "mce_down [0x%lx]: serious init problem - codec still busy\n", chip->port);
193 spin_unlock_irqrestore(&chip->reg_lock, flags);
198 for (timeout = 500; timeout > 0 && (snd_ad1848_in(chip, AD1848_TEST_INIT) & AD1848_CALIB_IN_PROGRESS) == 0; timeout--);
199 if ((snd_ad1848_in(chip, AD1848_TEST_INIT) & AD1848_CALIB_IN_PROGRESS) == 0) {
201 spin_unlock_irqrestore(&chip->reg_lock, flags);
205 while (snd_ad1848_in(chip, AD1848_TEST_INIT) & AD1848_CALIB_IN_PROGRESS) {
206 spin_unlock_irqrestore(&chip->reg_lock, flags);
212 spin_lock_irqsave(&chip->reg_lock, flags);
215 while (inb(AD1848P(chip, REGSEL)) & AD1848_INIT) {
216 spin_unlock_irqrestore(&chip->reg_lock, flags);
222 spin_lock_irqsave(&chip->reg_lock, flags);
224 spin_unlock_irqrestore(&chip->reg_lock, flags);
240 static int snd_ad1848_trigger(struct snd_ad1848 *chip, unsigned char what,
245 spin_lock(&chip->reg_lock);
247 if (chip->image[AD1848_IFACE_CTRL] & what) {
248 spin_unlock(&chip->reg_lock);
251 snd_ad1848_out(chip, AD1848_IFACE_CTRL, chip->image[AD1848_IFACE_CTRL] |= what);
252 chip->mode |= AD1848_MODE_RUNNING;
254 if (!(chip->image[AD1848_IFACE_CTRL] & what)) {
255 spin_unlock(&chip->reg_lock);
258 snd_ad1848_out(chip, AD1848_IFACE_CTRL, chip->image[AD1848_IFACE_CTRL] &= ~what);
259 chip->mode &= ~AD1848_MODE_RUNNING;
263 spin_unlock(&chip->reg_lock);
303 static void snd_ad1848_calibrate_mute(struct snd_ad1848 *chip, int mute)
308 spin_lock_irqsave(&chip->reg_lock, flags);
309 if (chip->calibrate_mute == mute) {
310 spin_unlock_irqrestore(&chip->reg_lock, flags);
314 snd_ad1848_dout(chip, AD1848_LEFT_INPUT, chip->image[AD1848_LEFT_INPUT]);
315 snd_ad1848_dout(chip, AD1848_RIGHT_INPUT, chip->image[AD1848_RIGHT_INPUT]);
317 snd_ad1848_dout(chip, AD1848_AUX1_LEFT_INPUT, mute ? 0x80 : chip->image[AD1848_AUX1_LEFT_INPUT]);
318 snd_ad1848_dout(chip, AD1848_AUX1_RIGHT_INPUT, mute ? 0x80 : chip->image[AD1848_AUX1_RIGHT_INPUT]);
319 snd_ad1848_dout(chip, AD1848_AUX2_LEFT_INPUT, mute ? 0x80 : chip->image[AD1848_AUX2_LEFT_INPUT]);
320 snd_ad1848_dout(chip, AD1848_AUX2_RIGHT_INPUT, mute ? 0x80 : chip->image[AD1848_AUX2_RIGHT_INPUT]);
321 snd_ad1848_dout(chip, AD1848_LEFT_OUTPUT, mute ? 0x80 : chip->image[AD1848_LEFT_OUTPUT]);
322 snd_ad1848_dout(chip, AD1848_RIGHT_OUTPUT, mute ? 0x80 : chip->image[AD1848_RIGHT_OUTPUT]);
323 chip->calibrate_mute = mute;
324 spin_unlock_irqrestore(&chip->reg_lock, flags);
327 static void snd_ad1848_set_data_format(struct snd_ad1848 *chip, struct snd_pcm_hw_params *hw_params)
330 chip->image[AD1848_DATA_FORMAT] = 0x20;
332 chip->image[AD1848_DATA_FORMAT] =
336 // snd_printk(">>> pmode = 0x%x, dfr = 0x%x\n", pstr->mode, chip->image[AD1848_DATA_FORMAT]);
339 static int snd_ad1848_open(struct snd_ad1848 *chip, unsigned int mode)
343 mutex_lock(&chip->open_mutex);
344 if (chip->mode & AD1848_MODE_OPEN) {
345 mutex_unlock(&chip->open_mutex);
348 snd_ad1848_mce_down(chip);
353 snd_ad1848_mce_up(chip);
354 spin_lock_irqsave(&chip->reg_lock, flags);
355 chip->image[AD1848_IFACE_CTRL] &= ~(AD1848_PLAYBACK_ENABLE | AD1848_PLAYBACK_PIO |
358 chip->image[AD1848_IFACE_CTRL] |= AD1848_AUTOCALIB;
359 snd_ad1848_out(chip, AD1848_IFACE_CTRL, chip->image[AD1848_IFACE_CTRL]);
360 spin_unlock_irqrestore(&chip->reg_lock, flags);
361 snd_ad1848_mce_down(chip);
367 snd_ad1848_set_data_format(chip, NULL);
369 snd_ad1848_mce_up(chip);
370 spin_lock_irqsave(&chip->reg_lock, flags);
371 snd_ad1848_out(chip, AD1848_DATA_FORMAT, chip->image[AD1848_DATA_FORMAT]);
372 spin_unlock_irqrestore(&chip->reg_lock, flags);
373 snd_ad1848_mce_down(chip);
380 spin_lock_irqsave(&chip->reg_lock, flags);
381 outb(0, AD1848P(chip, STATUS)); /* clear IRQ */
382 outb(0, AD1848P(chip, STATUS)); /* clear IRQ */
383 chip->image[AD1848_PIN_CTRL] |= AD1848_IRQ_ENABLE;
384 snd_ad1848_out(chip, AD1848_PIN_CTRL, chip->image[AD1848_PIN_CTRL]);
385 spin_unlock_irqrestore(&chip->reg_lock, flags);
387 chip->mode = mode;
388 mutex_unlock(&chip->open_mutex);
393 static void snd_ad1848_close(struct snd_ad1848 *chip)
397 mutex_lock(&chip->open_mutex);
398 if (!chip->mode) {
399 mutex_unlock(&chip->open_mutex);
403 spin_lock_irqsave(&chip->reg_lock, flags);
404 outb(0, AD1848P(chip, STATUS)); /* clear IRQ */
405 outb(0, AD1848P(chip, STATUS)); /* clear IRQ */
406 chip->image[AD1848_PIN_CTRL] &= ~AD1848_IRQ_ENABLE;
407 snd_ad1848_out(chip, AD1848_PIN_CTRL, chip->image[AD1848_PIN_CTRL]);
408 spin_unlock_irqrestore(&chip->reg_lock, flags);
412 snd_ad1848_mce_up(chip);
413 spin_lock_irqsave(&chip->reg_lock, flags);
414 chip->image[AD1848_IFACE_CTRL] &= ~(AD1848_PLAYBACK_ENABLE | AD1848_PLAYBACK_PIO |
416 snd_ad1848_out(chip, AD1848_IFACE_CTRL, chip->image[AD1848_IFACE_CTRL]);
417 spin_unlock_irqrestore(&chip->reg_lock, flags);
418 snd_ad1848_mce_down(chip);
421 spin_lock_irqsave(&chip->reg_lock, flags);
422 outb(0, AD1848P(chip, STATUS)); /* clear IRQ */
423 outb(0, AD1848P(chip, STATUS)); /* clear IRQ */
424 spin_unlock_irqrestore(&chip->reg_lock, flags);
426 chip->mode = 0;
427 mutex_unlock(&chip->open_mutex);
437 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
438 return snd_ad1848_trigger(chip, AD1848_PLAYBACK_ENABLE, SNDRV_PCM_STREAM_PLAYBACK, cmd);
444 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
445 return snd_ad1848_trigger(chip, AD1848_CAPTURE_ENABLE, SNDRV_PCM_STREAM_CAPTURE, cmd);
451 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
457 snd_ad1848_calibrate_mute(chip, 1);
458 snd_ad1848_set_data_format(chip, hw_params);
459 snd_ad1848_mce_up(chip);
460 spin_lock_irqsave(&chip->reg_lock, flags);
461 snd_ad1848_out(chip, AD1848_DATA_FORMAT, chip->image[AD1848_DATA_FORMAT]);
462 spin_unlock_irqrestore(&chip->reg_lock, flags);
463 snd_ad1848_mce_down(chip);
464 snd_ad1848_calibrate_mute(chip, 0);
475 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
481 chip->dma_size = size;
482 chip->image[AD1848_IFACE_CTRL] &= ~(AD1848_PLAYBACK_ENABLE | AD1848_PLAYBACK_PIO);
483 snd_dma_program(chip->dma, runtime->dma_addr, size, DMA_MODE_WRITE | DMA_AUTOINIT);
484 count = snd_ad1848_get_count(chip->image[AD1848_DATA_FORMAT], count) - 1;
485 spin_lock_irqsave(&chip->reg_lock, flags);
486 snd_ad1848_out(chip, AD1848_DATA_LWR_CNT, (unsigned char) count);
487 snd_ad1848_out(chip, AD1848_DATA_UPR_CNT, (unsigned char) (count >> 8));
488 spin_unlock_irqrestore(&chip->reg_lock, flags);
495 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
501 snd_ad1848_calibrate_mute(chip, 1);
502 snd_ad1848_set_data_format(chip, hw_params);
503 snd_ad1848_mce_up(chip);
504 spin_lock_irqsave(&chip->reg_lock, flags);
505 snd_ad1848_out(chip, AD1848_DATA_FORMAT, chip->image[AD1848_DATA_FORMAT]);
506 spin_unlock_irqrestore(&chip->reg_lock, flags);
507 snd_ad1848_mce_down(chip);
508 snd_ad1848_calibrate_mute(chip, 0);
519 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
525 chip->dma_size = size;
526 chip->image[AD1848_IFACE_CTRL] &= ~(AD1848_CAPTURE_ENABLE | AD1848_CAPTURE_PIO);
527 snd_dma_program(chip->dma, runtime->dma_addr, size, DMA_MODE_READ | DMA_AUTOINIT);
528 count = snd_ad1848_get_count(chip->image[AD1848_DATA_FORMAT], count) - 1;
529 spin_lock_irqsave(&chip->reg_lock, flags);
530 snd_ad1848_out(chip, AD1848_DATA_LWR_CNT, (unsigned char) count);
531 snd_ad1848_out(chip, AD1848_DATA_UPR_CNT, (unsigned char) (count >> 8));
532 spin_unlock_irqrestore(&chip->reg_lock, flags);
538 struct snd_ad1848 *chip = dev_id;
540 if ((chip->mode & AD1848_MODE_PLAY) && chip->playback_substream &&
541 (chip->mode & AD1848_MODE_RUNNING))
542 snd_pcm_period_elapsed(chip->playback_substream);
543 if ((chip->mode & AD1848_MODE_CAPTURE) && chip->capture_substream &&
544 (chip->mode & AD1848_MODE_RUNNING))
545 snd_pcm_period_elapsed(chip->capture_substream);
546 outb(0, AD1848P(chip, STATUS)); /* clear global interrupt bit */
552 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
555 if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_PLAYBACK_ENABLE))
557 ptr = snd_dma_pointer(chip->dma, chip->dma_size);
563 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
566 if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_CAPTURE_ENABLE))
568 ptr = snd_dma_pointer(chip->dma, chip->dma_size);
576 static void snd_ad1848_thinkpad_twiddle(struct snd_ad1848 *chip, int on) {
580 if (!chip->thinkpad_flag) return;
597 static void snd_ad1848_suspend(struct snd_ad1848 *chip)
599 snd_pcm_suspend_all(chip->pcm);
600 if (chip->thinkpad_flag)
601 snd_ad1848_thinkpad_twiddle(chip, 0);
604 static void snd_ad1848_resume(struct snd_ad1848 *chip)
608 if (chip->thinkpad_flag)
609 snd_ad1848_thinkpad_twiddle(chip, 1);
612 inb(AD1848P(chip, STATUS));
613 outb(0, AD1848P(chip, STATUS));
616 snd_ad1848_mce_down(chip);
618 snd_ad1848_out(chip, i, chip->image[i]);
619 snd_ad1848_mce_up(chip);
620 snd_ad1848_mce_down(chip);
624 static int snd_ad1848_probe(struct snd_ad1848 * chip)
633 if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
636 spin_lock_irqsave(&chip->reg_lock, flags);
637 snd_ad1848_out(chip, AD1848_MISC_INFO, 0x00);
638 snd_ad1848_out(chip, AD1848_LEFT_INPUT, 0xaa);
639 snd_ad1848_out(chip, AD1848_RIGHT_INPUT, 0x45);
640 rev = snd_ad1848_in(chip, AD1848_RIGHT_INPUT);
642 spin_unlock_irqrestore(&chip->reg_lock, flags);
647 if (snd_ad1848_in(chip, AD1848_LEFT_INPUT) == 0xaa && rev == 0x45) {
648 spin_unlock_irqrestore(&chip->reg_lock, flags);
652 spin_unlock_irqrestore(&chip->reg_lock, flags);
657 if (chip->hardware == AD1848_HW_DETECT) {
659 chip->hardware = AD1848_HW_AD1847;
661 chip->hardware = AD1848_HW_AD1848;
662 rev = snd_ad1848_in(chip, AD1848_MISC_INFO);
664 chip->hardware = AD1848_HW_CS4248;
666 snd_ad1848_out(chip, AD1848_MISC_INFO, 0x40);
668 if (snd_ad1848_in(chip, i) != snd_ad1848_in(chip, i + 16)) {
669 chip->hardware = AD1848_HW_CMI8330;
673 snd_ad1848_out(chip, AD1848_MISC_INFO, 0x00);
677 spin_lock_irqsave(&chip->reg_lock, flags);
678 inb(AD1848P(chip, STATUS)); /* clear any pendings IRQ */
679 outb(0, AD1848P(chip, STATUS));
681 spin_unlock_irqrestore(&chip->reg_lock, flags);
683 chip->image[AD1848_MISC_INFO] = 0x00;
684 chip->image[AD1848_IFACE_CTRL] =
685 (chip->image[AD1848_IFACE_CTRL] & ~AD1848_SINGLE_DMA) | AD1848_SINGLE_DMA;
686 ptr = (unsigned char *) &chip->image;
687 snd_ad1848_mce_down(chip);
688 spin_lock_irqsave(&chip->reg_lock, flags);
690 snd_ad1848_out(chip, i, *ptr++);
691 spin_unlock_irqrestore(&chip->reg_lock, flags);
692 snd_ad1848_mce_up(chip);
693 snd_ad1848_mce_down(chip);
745 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
749 if ((err = snd_ad1848_open(chip, AD1848_MODE_PLAY)) < 0)
751 chip->playback_substream = substream;
753 snd_pcm_limit_isa_dma_size(chip->dma, &runtime->hw.buffer_bytes_max);
754 snd_pcm_limit_isa_dma_size(chip->dma, &runtime->hw.period_bytes_max);
761 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
765 if ((err = snd_ad1848_open(chip, AD1848_MODE_CAPTURE)) < 0)
767 chip->capture_substream = substream;
769 snd_pcm_limit_isa_dma_size(chip->dma, &runtime->hw.buffer_bytes_max);
770 snd_pcm_limit_isa_dma_size(chip->dma, &runtime->hw.period_bytes_max);
777 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
779 chip->mode &= ~AD1848_MODE_PLAY;
780 chip->playback_substream = NULL;
781 snd_ad1848_close(chip);
787 struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
789 chip->mode &= ~AD1848_MODE_CAPTURE;
790 chip->capture_substream = NULL;
791 snd_ad1848_close(chip);
795 static int snd_ad1848_free(struct snd_ad1848 *chip)
797 release_and_free_resource(chip->res_port);
798 if (chip->irq >= 0)
799 free_irq(chip->irq, (void *) chip);
800 if (chip->dma >= 0) {
801 snd_dma_disable(chip->dma);
802 free_dma(chip->dma);
804 kfree(chip);
810 struct snd_ad1848 *chip = device->device_data;
811 return snd_ad1848_free(chip);
814 static const char *snd_ad1848_chip_id(struct snd_ad1848 *chip)
816 switch (chip->hardware) {
834 struct snd_ad1848 *chip;
838 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
839 if (chip == NULL)
841 spin_lock_init(&chip->reg_lock);
842 mutex_init(&chip->open_mutex);
843 chip->card = card;
844 chip->port = port;
845 chip->irq = -1;
846 chip->dma = -1;
847 chip->hardware = hardware;
848 memcpy(&chip->image, &snd_ad1848_original_image, sizeof(snd_ad1848_original_image));
850 if ((chip->res_port = request_region(port, 4, "AD1848")) == NULL) {
852 snd_ad1848_free(chip);
855 if (request_irq(irq, snd_ad1848_interrupt, IRQF_DISABLED, "AD1848", (void *) chip)) {
857 snd_ad1848_free(chip);
860 chip->irq = irq;
863 snd_ad1848_free(chip);
866 chip->dma = dma;
869 chip->thinkpad_flag = 1;
870 chip->hardware = AD1848_HW_DETECT; /* reset */
871 snd_ad1848_thinkpad_twiddle(chip, 1);
874 if (snd_ad1848_probe(chip) < 0) {
875 snd_ad1848_free(chip);
880 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
881 snd_ad1848_free(chip);
886 chip->suspend = snd_ad1848_suspend;
887 chip->resume = snd_ad1848_resume;
890 *rchip = chip;
918 int snd_ad1848_pcm(struct snd_ad1848 *chip, int device, struct snd_pcm **rpcm)
923 if ((err = snd_pcm_new(chip->card, "AD1848", device, 1, 1, &pcm)) < 0)
929 pcm->private_data = chip;
931 strcpy(pcm->name, snd_ad1848_chip_id(chip));
935 64*1024, chip->dma > 3 ? 128*1024 : 64*1024);
937 chip->pcm = pcm;
974 struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
977 spin_lock_irqsave(&chip->reg_lock, flags);
978 ucontrol->value.enumerated.item[0] = (chip->image[AD1848_LEFT_INPUT] & AD1848_MIXS_ALL) >> 6;
979 ucontrol->value.enumerated.item[1] = (chip->image[AD1848_RIGHT_INPUT] & AD1848_MIXS_ALL) >> 6;
980 spin_unlock_irqrestore(&chip->reg_lock, flags);
986 struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
996 spin_lock_irqsave(&chip->reg_lock, flags);
997 left = (chip->image[AD1848_LEFT_INPUT] & ~AD1848_MIXS_ALL) | left;
998 right = (chip->image[AD1848_RIGHT_INPUT] & ~AD1848_MIXS_ALL) | right;
999 change = left != chip->image[AD1848_LEFT_INPUT] ||
1000 right != chip->image[AD1848_RIGHT_INPUT];
1001 snd_ad1848_out(chip, AD1848_LEFT_INPUT, left);
1002 snd_ad1848_out(chip, AD1848_RIGHT_INPUT, right);
1003 spin_unlock_irqrestore(&chip->reg_lock, flags);
1020 struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
1027 spin_lock_irqsave(&chip->reg_lock, flags);
1028 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
1029 spin_unlock_irqrestore(&chip->reg_lock, flags);
1037 struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
1050 spin_lock_irqsave(&chip->reg_lock, flags);
1051 val = (chip->image[reg] & ~(mask << shift)) | val;
1052 change = val != chip->image[reg];
1053 snd_ad1848_out(chip, reg, val);
1054 spin_unlock_irqrestore(&chip->reg_lock, flags);
1071 struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
1080 spin_lock_irqsave(&chip->reg_lock, flags);
1081 ucontrol->value.integer.value[0] = (chip->image[left_reg] >> shift_left) & mask;
1082 ucontrol->value.integer.value[1] = (chip->image[right_reg] >> shift_right) & mask;
1083 spin_unlock_irqrestore(&chip->reg_lock, flags);
1093 struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
1112 spin_lock_irqsave(&chip->reg_lock, flags);
1114 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
1115 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
1116 change = val1 != chip->image[left_reg] || val2 != chip->image[right_reg];
1117 snd_ad1848_out(chip, left_reg, val1);
1118 snd_ad1848_out(chip, right_reg, val2);
1120 val1 = (chip->image[left_reg] & ~((mask << shift_left) | (mask << shift_right))) | val1 | val2;
1121 change = val1 != chip->image[left_reg];
1122 snd_ad1848_out(chip, left_reg, val1);
1124 spin_unlock_irqrestore(&chip->reg_lock, flags);
1130 int snd_ad1848_add_ctl_elem(struct snd_ad1848 *chip,
1156 ctl = snd_ctl_new1(&newctls[c->type], chip);
1166 if ((err = snd_ctl_add(chip->card, ctl)) < 0)
1198 int snd_ad1848_mixer(struct snd_ad1848 *chip)
1205 snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL);
1207 pcm = chip->pcm;
1208 card = chip->card;
1213 if ((err = snd_ad1848_add_ctl_elem(chip, &snd_ad1848_controls[idx])) < 0)