[ALSA] Changed Jaroslav Kysela's e-mail from perex@suse.cz to perex@perex.cz
[linux-2.6.git] / sound / pci / ice1712 / ews.c
1 /*
2  *   ALSA driver for ICEnsemble ICE1712 (Envy24)
3  *
4  *   Lowlevel functions for Terratec EWS88MT/D, EWX24/96, DMX 6Fire
5  *
6  *      Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz>
7  *                    2002 Takashi Iwai <tiwai@suse.de>
8  *
9  *   This program is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU General Public License as published by
11  *   the Free Software Foundation; either version 2 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This program is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with this program; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22  *
23  */      
24
25 #include <sound/driver.h>
26 #include <asm/io.h>
27 #include <linux/delay.h>
28 #include <linux/interrupt.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <sound/core.h>
32 #include <sound/cs8427.h>
33 #include <sound/asoundef.h>
34
35 #include "ice1712.h"
36 #include "ews.h"
37
38 #define SND_CS8404
39 #include <sound/cs8403.h>
40
41 enum {
42         EWS_I2C_CS8404 = 0, EWS_I2C_PCF1, EWS_I2C_PCF2,
43         EWS_I2C_88D = 0,
44         EWS_I2C_6FIRE = 0
45 };
46         
47
48 /*
49  * access via i2c mode (for EWX 24/96, EWS 88MT&D)
50  */
51
52 /* send SDA and SCL */
53 static void ewx_i2c_setlines(struct snd_i2c_bus *bus, int clk, int data)
54 {
55         struct snd_ice1712 *ice = bus->private_data;
56         unsigned char tmp = 0;
57         if (clk)
58                 tmp |= ICE1712_EWX2496_SERIAL_CLOCK;
59         if (data)
60                 tmp |= ICE1712_EWX2496_SERIAL_DATA;
61         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
62         udelay(5);
63 }
64
65 static int ewx_i2c_getclock(struct snd_i2c_bus *bus)
66 {
67         struct snd_ice1712 *ice = bus->private_data;
68         return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_CLOCK ? 1 : 0;
69 }
70
71 static int ewx_i2c_getdata(struct snd_i2c_bus *bus, int ack)
72 {
73         struct snd_ice1712 *ice = bus->private_data;
74         int bit;
75         /* set RW pin to low */
76         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~ICE1712_EWX2496_RW);
77         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, 0);
78         if (ack)
79                 udelay(5);
80         bit = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_DATA ? 1 : 0;
81         /* set RW pin to high */
82         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ICE1712_EWX2496_RW);
83         /* reset write mask */
84         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~ICE1712_EWX2496_SERIAL_CLOCK);
85         return bit;
86 }
87
88 static void ewx_i2c_start(struct snd_i2c_bus *bus)
89 {
90         struct snd_ice1712 *ice = bus->private_data;
91         unsigned char mask;
92
93         snd_ice1712_save_gpio_status(ice);
94         /* set RW high */
95         mask = ICE1712_EWX2496_RW;
96         switch (ice->eeprom.subvendor) {
97         case ICE1712_SUBDEVICE_EWX2496:
98                 mask |= ICE1712_EWX2496_AK4524_CS; /* CS high also */
99                 break;
100         case ICE1712_SUBDEVICE_DMX6FIRE:
101                 mask |= ICE1712_6FIRE_AK4524_CS_MASK; /* CS high also */
102                 break;
103         }
104         snd_ice1712_gpio_write_bits(ice, mask, mask);
105 }
106
107 static void ewx_i2c_stop(struct snd_i2c_bus *bus)
108 {
109         struct snd_ice1712 *ice = bus->private_data;
110         snd_ice1712_restore_gpio_status(ice);
111 }
112
113 static void ewx_i2c_direction(struct snd_i2c_bus *bus, int clock, int data)
114 {
115         struct snd_ice1712 *ice = bus->private_data;
116         unsigned char mask = 0;
117
118         if (clock)
119                 mask |= ICE1712_EWX2496_SERIAL_CLOCK; /* write SCL */
120         if (data)
121                 mask |= ICE1712_EWX2496_SERIAL_DATA; /* write SDA */
122         ice->gpio.direction &= ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA);
123         ice->gpio.direction |= mask;
124         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio.direction);
125         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask);
126 }
127
128 static struct snd_i2c_bit_ops snd_ice1712_ewx_cs8427_bit_ops = {
129         .start = ewx_i2c_start,
130         .stop = ewx_i2c_stop,
131         .direction = ewx_i2c_direction,
132         .setlines = ewx_i2c_setlines,
133         .getclock = ewx_i2c_getclock,
134         .getdata = ewx_i2c_getdata,
135 };
136
137
138 /*
139  * AK4524 access
140  */
141
142 /* AK4524 chip select; address 0x48 bit 0-3 */
143 static int snd_ice1712_ews88mt_chip_select(struct snd_ice1712 *ice, int chip_mask)
144 {
145         unsigned char data, ndata;
146
147         snd_assert(chip_mask >= 0 && chip_mask <= 0x0f, return -EINVAL);
148         snd_i2c_lock(ice->i2c);
149         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_PCF2], &data, 1) != 1)
150                 goto __error;
151         ndata = (data & 0xf0) | chip_mask;
152         if (ndata != data)
153                 if (snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_PCF2], &ndata, 1) != 1)
154                         goto __error;
155         snd_i2c_unlock(ice->i2c);
156         return 0;
157
158      __error:
159         snd_i2c_unlock(ice->i2c);
160         snd_printk(KERN_ERR "AK4524 chip select failed, check cable to the front module\n");
161         return -EIO;
162 }
163
164 /* start callback for EWS88MT, needs to select a certain chip mask */
165 static void ews88mt_ak4524_lock(struct snd_akm4xxx *ak, int chip)
166 {
167         struct snd_ice1712 *ice = ak->private_data[0];
168         unsigned char tmp;
169         /* assert AK4524 CS */
170         if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0)
171                 snd_printk(KERN_ERR "fatal error (ews88mt chip select)\n");
172         snd_ice1712_save_gpio_status(ice);
173         tmp = ICE1712_EWS88_SERIAL_DATA |
174                 ICE1712_EWS88_SERIAL_CLOCK |
175                 ICE1712_EWS88_RW;
176         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
177                           ice->gpio.direction | tmp);
178         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
179 }
180
181 /* stop callback for EWS88MT, needs to deselect chip mask */
182 static void ews88mt_ak4524_unlock(struct snd_akm4xxx *ak, int chip)
183 {
184         struct snd_ice1712 *ice = ak->private_data[0];
185         snd_ice1712_restore_gpio_status(ice);
186         udelay(1);
187         snd_ice1712_ews88mt_chip_select(ice, 0x0f);
188 }
189
190 /* start callback for EWX24/96 */
191 static void ewx2496_ak4524_lock(struct snd_akm4xxx *ak, int chip)
192 {
193         struct snd_ice1712 *ice = ak->private_data[0];
194         unsigned char tmp;
195         snd_ice1712_save_gpio_status(ice);
196         tmp =  ICE1712_EWX2496_SERIAL_DATA |
197                 ICE1712_EWX2496_SERIAL_CLOCK |
198                 ICE1712_EWX2496_AK4524_CS |
199                 ICE1712_EWX2496_RW;
200         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
201                           ice->gpio.direction | tmp);
202         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
203 }
204
205 /* start callback for DMX 6fire */
206 static void dmx6fire_ak4524_lock(struct snd_akm4xxx *ak, int chip)
207 {
208         struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
209         struct snd_ice1712 *ice = ak->private_data[0];
210         unsigned char tmp;
211         snd_ice1712_save_gpio_status(ice);
212         tmp = priv->cs_mask = priv->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
213         tmp |= ICE1712_6FIRE_SERIAL_DATA |
214                 ICE1712_6FIRE_SERIAL_CLOCK |
215                 ICE1712_6FIRE_RW;
216         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
217                           ice->gpio.direction | tmp);
218         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
219 }
220
221 /*
222  * CS8404 interface on EWS88MT/D
223  */
224
225 static void snd_ice1712_ews_cs8404_spdif_write(struct snd_ice1712 *ice, unsigned char bits)
226 {
227         unsigned char bytes[2];
228
229         snd_i2c_lock(ice->i2c);
230         switch (ice->eeprom.subvendor) {
231         case ICE1712_SUBDEVICE_EWS88MT:
232         case ICE1712_SUBDEVICE_EWS88MT_NEW:
233         case ICE1712_SUBDEVICE_PHASE88:
234                 if (snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_CS8404], &bits, 1) != 1)
235                         goto _error;
236                 break;
237         case ICE1712_SUBDEVICE_EWS88D:
238                 if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_88D], bytes, 2) != 2)
239                         goto _error;
240                 if (bits != bytes[1]) {
241                         bytes[1] = bits;
242                         if (snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_88D], bytes, 2) != 2)
243                                 goto _error;
244                 }
245                 break;
246         }
247  _error:
248         snd_i2c_unlock(ice->i2c);
249 }
250
251 /*
252  */
253
254 static void ews88_spdif_default_get(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol)
255 {
256         snd_cs8404_decode_spdif_bits(&ucontrol->value.iec958, ice->spdif.cs8403_bits);
257 }
258
259 static int ews88_spdif_default_put(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol)
260 {
261         unsigned int val;
262         int change;
263
264         val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
265         spin_lock_irq(&ice->reg_lock);
266         change = ice->spdif.cs8403_bits != val;
267         ice->spdif.cs8403_bits = val;
268         if (change && ice->playback_pro_substream == NULL) {
269                 spin_unlock_irq(&ice->reg_lock);
270                 snd_ice1712_ews_cs8404_spdif_write(ice, val);
271         } else {
272                 spin_unlock_irq(&ice->reg_lock);
273         }
274         return change;
275 }
276
277 static void ews88_spdif_stream_get(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol)
278 {
279         snd_cs8404_decode_spdif_bits(&ucontrol->value.iec958, ice->spdif.cs8403_stream_bits);
280 }
281
282 static int ews88_spdif_stream_put(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol)
283 {
284         unsigned int val;
285         int change;
286
287         val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
288         spin_lock_irq(&ice->reg_lock);
289         change = ice->spdif.cs8403_stream_bits != val;
290         ice->spdif.cs8403_stream_bits = val;
291         if (change && ice->playback_pro_substream != NULL) {
292                 spin_unlock_irq(&ice->reg_lock);
293                 snd_ice1712_ews_cs8404_spdif_write(ice, val);
294         } else {
295                 spin_unlock_irq(&ice->reg_lock);
296         }
297         return change;
298 }
299
300
301 /* open callback */
302 static void ews88_open_spdif(struct snd_ice1712 *ice, struct snd_pcm_substream *substream)
303 {
304         ice->spdif.cs8403_stream_bits = ice->spdif.cs8403_bits;
305 }
306
307 /* set up SPDIF for EWS88MT / EWS88D */
308 static void ews88_setup_spdif(struct snd_ice1712 *ice, int rate)
309 {
310         unsigned long flags;
311         unsigned char tmp;
312         int change;
313
314         spin_lock_irqsave(&ice->reg_lock, flags);
315         tmp = ice->spdif.cs8403_stream_bits;
316         if (tmp & 0x10)         /* consumer */
317                 tmp &= (tmp & 0x01) ? ~0x06 : ~0x60;
318         switch (rate) {
319         case 32000: tmp |= (tmp & 0x01) ? 0x02 : 0x00; break;
320         case 44100: tmp |= (tmp & 0x01) ? 0x06 : 0x40; break;
321         case 48000: tmp |= (tmp & 0x01) ? 0x04 : 0x20; break;
322         default: tmp |= (tmp & 0x01) ? 0x06 : 0x40; break;
323         }
324         change = ice->spdif.cs8403_stream_bits != tmp;
325         ice->spdif.cs8403_stream_bits = tmp;
326         spin_unlock_irqrestore(&ice->reg_lock, flags);
327         if (change)
328                 snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE, &ice->spdif.stream_ctl->id);
329         snd_ice1712_ews_cs8404_spdif_write(ice, tmp);
330 }
331
332
333 /*
334  */
335 static struct snd_akm4xxx akm_ews88mt __devinitdata = {
336         .num_adcs = 8,
337         .num_dacs = 8,
338         .type = SND_AK4524,
339         .ops = {
340                 .lock = ews88mt_ak4524_lock,
341                 .unlock = ews88mt_ak4524_unlock
342         }
343 };
344
345 static struct snd_ak4xxx_private akm_ews88mt_priv __devinitdata = {
346         .caddr = 2,
347         .cif = 1, /* CIF high */
348         .data_mask = ICE1712_EWS88_SERIAL_DATA,
349         .clk_mask = ICE1712_EWS88_SERIAL_CLOCK,
350         .cs_mask = 0,
351         .cs_addr = 0,
352         .cs_none = 0, /* no chip select on gpio */
353         .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
354         .mask_flags = 0,
355 };
356
357 static struct snd_akm4xxx akm_ewx2496 __devinitdata = {
358         .num_adcs = 2,
359         .num_dacs = 2,
360         .type = SND_AK4524,
361         .ops = {
362                 .lock = ewx2496_ak4524_lock
363         }
364 };
365
366 static struct snd_ak4xxx_private akm_ewx2496_priv __devinitdata = {
367         .caddr = 2,
368         .cif = 1, /* CIF high */
369         .data_mask = ICE1712_EWS88_SERIAL_DATA,
370         .clk_mask = ICE1712_EWS88_SERIAL_CLOCK,
371         .cs_mask = ICE1712_EWX2496_AK4524_CS,
372         .cs_addr = ICE1712_EWX2496_AK4524_CS,
373         .cs_none = 0,
374         .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
375         .mask_flags = 0,
376 };
377
378 static struct snd_akm4xxx akm_6fire __devinitdata = {
379         .num_adcs = 6,
380         .num_dacs = 6,
381         .type = SND_AK4524,
382         .ops = {
383                 .lock = dmx6fire_ak4524_lock
384         }
385 };
386
387 static struct snd_ak4xxx_private akm_6fire_priv __devinitdata = {
388         .caddr = 2,
389         .cif = 1, /* CIF high */
390         .data_mask = ICE1712_6FIRE_SERIAL_DATA,
391         .clk_mask = ICE1712_6FIRE_SERIAL_CLOCK,
392         .cs_mask = 0,
393         .cs_addr = 0, /* set later */
394         .cs_none = 0,
395         .add_flags = ICE1712_6FIRE_RW, /* set rw bit high */
396         .mask_flags = 0,
397 };
398
399 /*
400  * initialize the chip
401  */
402
403 /* 6fire specific */
404 #define PCF9554_REG_INPUT      0
405 #define PCF9554_REG_OUTPUT     1
406 #define PCF9554_REG_POLARITY   2
407 #define PCF9554_REG_CONFIG     3
408
409 static int snd_ice1712_6fire_write_pca(struct snd_ice1712 *ice, unsigned char reg, unsigned char data);
410
411 static int __devinit snd_ice1712_ews_init(struct snd_ice1712 *ice)
412 {
413         int err;
414         struct snd_akm4xxx *ak;
415
416         /* set the analog DACs */
417         switch (ice->eeprom.subvendor) {
418         case ICE1712_SUBDEVICE_EWX2496:
419                 ice->num_total_dacs = 2;
420                 ice->num_total_adcs = 2;
421                 break;  
422         case ICE1712_SUBDEVICE_EWS88MT:
423         case ICE1712_SUBDEVICE_EWS88MT_NEW:
424         case ICE1712_SUBDEVICE_PHASE88:
425                 ice->num_total_dacs = 8;
426                 ice->num_total_adcs = 8;
427                 break;
428         case ICE1712_SUBDEVICE_EWS88D:
429                 /* Note: not analog but ADAT I/O */
430                 ice->num_total_dacs = 8;
431                 ice->num_total_adcs = 8;
432                 break;
433         case ICE1712_SUBDEVICE_DMX6FIRE:
434                 ice->num_total_dacs = 6;
435                 ice->num_total_adcs = 6;
436                 break;
437         }
438
439         /* create i2c */
440         if ((err = snd_i2c_bus_create(ice->card, "ICE1712 GPIO 1", NULL, &ice->i2c)) < 0) {
441                 snd_printk(KERN_ERR "unable to create I2C bus\n");
442                 return err;
443         }
444         ice->i2c->private_data = ice;
445         ice->i2c->hw_ops.bit = &snd_ice1712_ewx_cs8427_bit_ops;
446
447         /* create i2c devices */
448         switch (ice->eeprom.subvendor) {
449         case ICE1712_SUBDEVICE_DMX6FIRE:
450                 if ((err = snd_i2c_device_create(ice->i2c, "PCF9554", ICE1712_6FIRE_PCF9554_ADDR, &ice->spec.i2cdevs[EWS_I2C_6FIRE])) < 0) {
451                         snd_printk(KERN_ERR "PCF9554 initialization failed\n");
452                         return err;
453                 }
454                 snd_ice1712_6fire_write_pca(ice, PCF9554_REG_CONFIG, 0x80);
455                 break;
456         case ICE1712_SUBDEVICE_EWS88MT:
457         case ICE1712_SUBDEVICE_EWS88MT_NEW:
458         case ICE1712_SUBDEVICE_PHASE88:
459                 if ((err = snd_i2c_device_create(ice->i2c, "CS8404", ICE1712_EWS88MT_CS8404_ADDR, &ice->spec.i2cdevs[EWS_I2C_CS8404])) < 0)
460                         return err;
461                 if ((err = snd_i2c_device_create(ice->i2c, "PCF8574 (1st)", ICE1712_EWS88MT_INPUT_ADDR, &ice->spec.i2cdevs[EWS_I2C_PCF1])) < 0)
462                         return err;
463                 if ((err = snd_i2c_device_create(ice->i2c, "PCF8574 (2nd)", ICE1712_EWS88MT_OUTPUT_ADDR, &ice->spec.i2cdevs[EWS_I2C_PCF2])) < 0)
464                         return err;
465                 /* Check if the front module is connected */
466                 if ((err = snd_ice1712_ews88mt_chip_select(ice, 0x0f)) < 0)
467                         return err;
468                 break;
469         case ICE1712_SUBDEVICE_EWS88D:
470                 if ((err = snd_i2c_device_create(ice->i2c, "PCF8575", ICE1712_EWS88D_PCF_ADDR, &ice->spec.i2cdevs[EWS_I2C_88D])) < 0)
471                         return err;
472                 break;
473         }
474
475         /* set up SPDIF interface */
476         switch (ice->eeprom.subvendor) {
477         case ICE1712_SUBDEVICE_EWX2496:
478                 if ((err = snd_ice1712_init_cs8427(ice, CS8427_BASE_ADDR)) < 0)
479                         return err;
480                 snd_cs8427_reg_write(ice->cs8427, CS8427_REG_RECVERRMASK, CS8427_UNLOCK | CS8427_CONF | CS8427_BIP | CS8427_PAR);
481                 break;
482         case ICE1712_SUBDEVICE_DMX6FIRE:
483                 if ((err = snd_ice1712_init_cs8427(ice, ICE1712_6FIRE_CS8427_ADDR)) < 0)
484                         return err;
485                 snd_cs8427_reg_write(ice->cs8427, CS8427_REG_RECVERRMASK, CS8427_UNLOCK | CS8427_CONF | CS8427_BIP | CS8427_PAR);
486                 break;
487         case ICE1712_SUBDEVICE_EWS88MT:
488         case ICE1712_SUBDEVICE_EWS88MT_NEW:
489         case ICE1712_SUBDEVICE_PHASE88:
490         case ICE1712_SUBDEVICE_EWS88D:
491                 /* set up CS8404 */
492                 ice->spdif.ops.open = ews88_open_spdif;
493                 ice->spdif.ops.setup_rate = ews88_setup_spdif;
494                 ice->spdif.ops.default_get = ews88_spdif_default_get;
495                 ice->spdif.ops.default_put = ews88_spdif_default_put;
496                 ice->spdif.ops.stream_get = ews88_spdif_stream_get;
497                 ice->spdif.ops.stream_put = ews88_spdif_stream_put;
498                 /* Set spdif defaults */
499                 snd_ice1712_ews_cs8404_spdif_write(ice, ice->spdif.cs8403_bits);
500                 break;
501         }
502
503         /* no analog? */
504         switch (ice->eeprom.subvendor) {
505         case ICE1712_SUBDEVICE_EWS88D:
506                 return 0;
507         }
508
509         /* analog section */
510         ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
511         if (! ak)
512                 return -ENOMEM;
513         ice->akm_codecs = 1;
514
515         switch (ice->eeprom.subvendor) {
516         case ICE1712_SUBDEVICE_EWS88MT:
517         case ICE1712_SUBDEVICE_EWS88MT_NEW:
518         case ICE1712_SUBDEVICE_PHASE88:
519                 err = snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, &akm_ews88mt_priv, ice);
520                 break;
521         case ICE1712_SUBDEVICE_EWX2496:
522                 err = snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, &akm_ewx2496_priv, ice);
523                 break;
524         case ICE1712_SUBDEVICE_DMX6FIRE:
525                 err = snd_ice1712_akm4xxx_init(ak, &akm_6fire, &akm_6fire_priv, ice);
526                 break;
527         default:
528                 err = 0;
529         }
530
531         return err;
532 }
533
534 /*
535  * EWX 24/96 specific controls
536  */
537
538 /* i/o sensitivity - this callback is shared among other devices, too */
539 static int snd_ice1712_ewx_io_sense_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo){
540
541         static char *texts[2] = {
542                 "+4dBu", "-10dBV",
543         };
544         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
545         uinfo->count = 1;
546         uinfo->value.enumerated.items = 2;
547         if (uinfo->value.enumerated.item >= 2)
548                 uinfo->value.enumerated.item = 1;
549         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
550         return 0;
551 }
552
553 static int snd_ice1712_ewx_io_sense_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
554 {
555         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
556         unsigned char mask = kcontrol->private_value & 0xff;
557         
558         snd_ice1712_save_gpio_status(ice);
559         ucontrol->value.enumerated.item[0] = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0;
560         snd_ice1712_restore_gpio_status(ice);
561         return 0;
562 }
563
564 static int snd_ice1712_ewx_io_sense_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
565 {
566         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
567         unsigned char mask = kcontrol->private_value & 0xff;
568         int val, nval;
569
570         if (kcontrol->private_value & (1 << 31))
571                 return -EPERM;
572         nval = ucontrol->value.enumerated.item[0] ? mask : 0;
573         snd_ice1712_save_gpio_status(ice);
574         val = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
575         nval |= val & ~mask;
576         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, nval);
577         snd_ice1712_restore_gpio_status(ice);
578         return val != nval;
579 }
580
581 static struct snd_kcontrol_new snd_ice1712_ewx2496_controls[] __devinitdata = {
582         {
583                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
584                 .name = "Input Sensitivity Switch",
585                 .info = snd_ice1712_ewx_io_sense_info,
586                 .get = snd_ice1712_ewx_io_sense_get,
587                 .put = snd_ice1712_ewx_io_sense_put,
588                 .private_value = ICE1712_EWX2496_AIN_SEL,
589         },
590         {
591                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
592                 .name = "Output Sensitivity Switch",
593                 .info = snd_ice1712_ewx_io_sense_info,
594                 .get = snd_ice1712_ewx_io_sense_get,
595                 .put = snd_ice1712_ewx_io_sense_put,
596                 .private_value = ICE1712_EWX2496_AOUT_SEL,
597         },
598 };
599
600
601 /*
602  * EWS88MT specific controls
603  */
604 /* analog output sensitivity;; address 0x48 bit 6 */
605 static int snd_ice1712_ews88mt_output_sense_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
606 {
607         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
608         unsigned char data;
609
610         snd_i2c_lock(ice->i2c);
611         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_PCF2], &data, 1) != 1) {
612                 snd_i2c_unlock(ice->i2c);
613                 return -EIO;
614         }
615         snd_i2c_unlock(ice->i2c);
616         ucontrol->value.enumerated.item[0] = data & ICE1712_EWS88MT_OUTPUT_SENSE ? 1 : 0; /* high = -10dBV, low = +4dBu */
617         return 0;
618 }
619
620 /* analog output sensitivity;; address 0x48 bit 6 */
621 static int snd_ice1712_ews88mt_output_sense_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
622 {
623         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
624         unsigned char data, ndata;
625
626         snd_i2c_lock(ice->i2c);
627         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_PCF2], &data, 1) != 1) {
628                 snd_i2c_unlock(ice->i2c);
629                 return -EIO;
630         }
631         ndata = (data & ~ICE1712_EWS88MT_OUTPUT_SENSE) | (ucontrol->value.enumerated.item[0] ? ICE1712_EWS88MT_OUTPUT_SENSE : 0);
632         if (ndata != data && snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_PCF2], &ndata, 1) != 1) {
633                 snd_i2c_unlock(ice->i2c);
634                 return -EIO;
635         }
636         snd_i2c_unlock(ice->i2c);
637         return ndata != data;
638 }
639
640 /* analog input sensitivity; address 0x46 */
641 static int snd_ice1712_ews88mt_input_sense_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
642 {
643         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
644         int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
645         unsigned char data;
646
647         snd_assert(channel >= 0 && channel <= 7, return 0);
648         snd_i2c_lock(ice->i2c);
649         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_PCF1], &data, 1) != 1) {
650                 snd_i2c_unlock(ice->i2c);
651                 return -EIO;
652         }
653         /* reversed; high = +4dBu, low = -10dBV */
654         ucontrol->value.enumerated.item[0] = data & (1 << channel) ? 0 : 1;
655         snd_i2c_unlock(ice->i2c);
656         return 0;
657 }
658
659 /* analog output sensitivity; address 0x46 */
660 static int snd_ice1712_ews88mt_input_sense_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
661 {
662         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
663         int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
664         unsigned char data, ndata;
665
666         snd_assert(channel >= 0 && channel <= 7, return 0);
667         snd_i2c_lock(ice->i2c);
668         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_PCF1], &data, 1) != 1) {
669                 snd_i2c_unlock(ice->i2c);
670                 return -EIO;
671         }
672         ndata = (data & ~(1 << channel)) | (ucontrol->value.enumerated.item[0] ? 0 : (1 << channel));
673         if (ndata != data && snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_PCF1], &ndata, 1) != 1) {
674                 snd_i2c_unlock(ice->i2c);
675                 return -EIO;
676         }
677         snd_i2c_unlock(ice->i2c);
678         return ndata != data;
679 }
680
681 static struct snd_kcontrol_new snd_ice1712_ews88mt_input_sense __devinitdata = {
682         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
683         .name = "Input Sensitivity Switch",
684         .info = snd_ice1712_ewx_io_sense_info,
685         .get = snd_ice1712_ews88mt_input_sense_get,
686         .put = snd_ice1712_ews88mt_input_sense_put,
687         .count = 8,
688 };
689
690 static struct snd_kcontrol_new snd_ice1712_ews88mt_output_sense __devinitdata = {
691         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
692         .name = "Output Sensitivity Switch",
693         .info = snd_ice1712_ewx_io_sense_info,
694         .get = snd_ice1712_ews88mt_output_sense_get,
695         .put = snd_ice1712_ews88mt_output_sense_put,
696 };
697
698
699 /*
700  * EWS88D specific controls
701  */
702
703 #define snd_ice1712_ews88d_control_info         snd_ctl_boolean_mono_info
704
705 static int snd_ice1712_ews88d_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
706 {
707         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
708         int shift = kcontrol->private_value & 0xff;
709         int invert = (kcontrol->private_value >> 8) & 1;
710         unsigned char data[2];
711         
712         snd_i2c_lock(ice->i2c);
713         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_88D], data, 2) != 2) {
714                 snd_i2c_unlock(ice->i2c);
715                 return -EIO;
716         }
717         snd_i2c_unlock(ice->i2c);
718         data[0] = (data[shift >> 3] >> (shift & 7)) & 0x01;
719         if (invert)
720                 data[0] ^= 0x01;
721         ucontrol->value.integer.value[0] = data[0];
722         return 0;
723 }
724
725 static int snd_ice1712_ews88d_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
726 {
727         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
728         int shift = kcontrol->private_value & 0xff;
729         int invert = (kcontrol->private_value >> 8) & 1;
730         unsigned char data[2], ndata[2];
731         int change;
732
733         snd_i2c_lock(ice->i2c);
734         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_88D], data, 2) != 2) {
735                 snd_i2c_unlock(ice->i2c);
736                 return -EIO;
737         }
738         ndata[shift >> 3] = data[shift >> 3] & ~(1 << (shift & 7));
739         if (invert) {
740                 if (! ucontrol->value.integer.value[0])
741                         ndata[shift >> 3] |= (1 << (shift & 7));
742         } else {
743                 if (ucontrol->value.integer.value[0])
744                         ndata[shift >> 3] |= (1 << (shift & 7));
745         }
746         change = (data[shift >> 3] != ndata[shift >> 3]);
747         if (change && snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_88D], data, 2) != 2) {
748                 snd_i2c_unlock(ice->i2c);
749                 return -EIO;
750         }
751         snd_i2c_unlock(ice->i2c);
752         return change;
753 }
754
755 #define EWS88D_CONTROL(xiface, xname, xshift, xinvert, xaccess) \
756 { .iface = xiface,\
757   .name = xname,\
758   .access = xaccess,\
759   .info = snd_ice1712_ews88d_control_info,\
760   .get = snd_ice1712_ews88d_control_get,\
761   .put = snd_ice1712_ews88d_control_put,\
762   .private_value = xshift | (xinvert << 8),\
763 }
764
765 static struct snd_kcontrol_new snd_ice1712_ews88d_controls[] __devinitdata = {
766         EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "IEC958 Input Optical", 0, 1, 0), /* inverted */
767         EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Output Optical", 1, 0, 0),
768         EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT External Master Clock", 2, 0, 0),
769         EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "Enable ADAT", 3, 0, 0),
770         EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Through", 4, 1, 0),
771 };
772
773
774 /*
775  * DMX 6Fire specific controls
776  */
777
778 static int snd_ice1712_6fire_read_pca(struct snd_ice1712 *ice, unsigned char reg)
779 {
780         unsigned char byte;
781         snd_i2c_lock(ice->i2c);
782         byte = reg;
783         snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_6FIRE], &byte, 1);
784         byte = 0;
785         if (snd_i2c_readbytes(ice->spec.i2cdevs[EWS_I2C_6FIRE], &byte, 1) != 1) {
786                 snd_i2c_unlock(ice->i2c);
787                 printk(KERN_ERR "cannot read pca\n");
788                 return -EIO;
789         }
790         snd_i2c_unlock(ice->i2c);
791         return byte;
792 }
793
794 static int snd_ice1712_6fire_write_pca(struct snd_ice1712 *ice, unsigned char reg, unsigned char data)
795 {
796         unsigned char bytes[2];
797         snd_i2c_lock(ice->i2c);
798         bytes[0] = reg;
799         bytes[1] = data;
800         if (snd_i2c_sendbytes(ice->spec.i2cdevs[EWS_I2C_6FIRE], bytes, 2) != 2) {
801                 snd_i2c_unlock(ice->i2c);
802                 return -EIO;
803         }
804         snd_i2c_unlock(ice->i2c);
805         return 0;
806 }
807
808 #define snd_ice1712_6fire_control_info          snd_ctl_boolean_mono_info
809
810 static int snd_ice1712_6fire_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
811 {
812         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
813         int shift = kcontrol->private_value & 0xff;
814         int invert = (kcontrol->private_value >> 8) & 1;
815         int data;
816         
817         if ((data = snd_ice1712_6fire_read_pca(ice, PCF9554_REG_OUTPUT)) < 0)
818                 return data;
819         data = (data >> shift) & 1;
820         if (invert)
821                 data ^= 1;
822         ucontrol->value.integer.value[0] = data;
823         return 0;
824 }
825
826 static int snd_ice1712_6fire_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
827 {
828         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
829         int shift = kcontrol->private_value & 0xff;
830         int invert = (kcontrol->private_value >> 8) & 1;
831         int data, ndata;
832         
833         if ((data = snd_ice1712_6fire_read_pca(ice, PCF9554_REG_OUTPUT)) < 0)
834                 return data;
835         ndata = data & ~(1 << shift);
836         if (ucontrol->value.integer.value[0])
837                 ndata |= (1 << shift);
838         if (invert)
839                 ndata ^= (1 << shift);
840         if (data != ndata) {
841                 snd_ice1712_6fire_write_pca(ice, PCF9554_REG_OUTPUT, (unsigned char)ndata);
842                 return 1;
843         }
844         return 0;
845 }
846
847 static int snd_ice1712_6fire_select_input_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
848 {
849         static char *texts[4] = {
850                 "Internal", "Front Input", "Rear Input", "Wave Table"
851         };
852         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
853         uinfo->count = 1;
854         uinfo->value.enumerated.items = 4;
855         if (uinfo->value.enumerated.item >= 4)
856                 uinfo->value.enumerated.item = 1;
857         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
858         return 0;
859 }
860      
861 static int snd_ice1712_6fire_select_input_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
862 {
863         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
864         int data;
865         
866         if ((data = snd_ice1712_6fire_read_pca(ice, PCF9554_REG_OUTPUT)) < 0)
867                 return data;
868         ucontrol->value.integer.value[0] = data & 3;
869         return 0;
870 }
871
872 static int snd_ice1712_6fire_select_input_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
873 {
874         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
875         int data, ndata;
876         
877         if ((data = snd_ice1712_6fire_read_pca(ice, PCF9554_REG_OUTPUT)) < 0)
878                 return data;
879         ndata = data & ~3;
880         ndata |= (ucontrol->value.integer.value[0] & 3);
881         if (data != ndata) {
882                 snd_ice1712_6fire_write_pca(ice, PCF9554_REG_OUTPUT, (unsigned char)ndata);
883                 return 1;
884         }
885         return 0;
886 }
887
888
889 #define DMX6FIRE_CONTROL(xname, xshift, xinvert) \
890 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
891   .name = xname,\
892   .info = snd_ice1712_6fire_control_info,\
893   .get = snd_ice1712_6fire_control_get,\
894   .put = snd_ice1712_6fire_control_put,\
895   .private_value = xshift | (xinvert << 8),\
896 }
897
898 static struct snd_kcontrol_new snd_ice1712_6fire_controls[] __devinitdata = {
899         {
900                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
901                 .name = "Analog Input Select",
902                 .info = snd_ice1712_6fire_select_input_info,
903                 .get = snd_ice1712_6fire_select_input_get,
904                 .put = snd_ice1712_6fire_select_input_put,
905         },
906         DMX6FIRE_CONTROL("Front Digital Input Switch", 2, 1),
907         // DMX6FIRE_CONTROL("Master Clock Select", 3, 0),
908         DMX6FIRE_CONTROL("Optical Digital Input Switch", 4, 0),
909         DMX6FIRE_CONTROL("Phono Analog Input Switch", 5, 0),
910         DMX6FIRE_CONTROL("Breakbox LED", 6, 0),
911 };
912
913
914 static int __devinit snd_ice1712_ews_add_controls(struct snd_ice1712 *ice)
915 {
916         unsigned int idx;
917         int err;
918         
919         /* all terratec cards have spdif, but cs8427 module builds it's own controls */
920         if (ice->cs8427 == NULL) {
921                 err = snd_ice1712_spdif_build_controls(ice);
922                 if (err < 0)
923                         return err;
924         }
925
926         /* ak4524 controls */
927         switch (ice->eeprom.subvendor) {
928         case ICE1712_SUBDEVICE_EWX2496:
929         case ICE1712_SUBDEVICE_EWS88MT:
930         case ICE1712_SUBDEVICE_EWS88MT_NEW:
931         case ICE1712_SUBDEVICE_PHASE88:
932         case ICE1712_SUBDEVICE_DMX6FIRE:
933                 err = snd_ice1712_akm4xxx_build_controls(ice);
934                 if (err < 0)
935                         return err;
936                 break;
937         }
938
939         /* card specific controls */
940         switch (ice->eeprom.subvendor) {
941         case ICE1712_SUBDEVICE_EWX2496:
942                 for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_ewx2496_controls); idx++) {
943                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ewx2496_controls[idx], ice));
944                         if (err < 0)
945                                 return err;
946                 }
947                 break;
948         case ICE1712_SUBDEVICE_EWS88MT:
949         case ICE1712_SUBDEVICE_EWS88MT_NEW:
950         case ICE1712_SUBDEVICE_PHASE88:
951                 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88mt_input_sense, ice));
952                 if (err < 0)
953                         return err;
954                 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88mt_output_sense, ice));
955                 if (err < 0)
956                         return err;
957                 break;
958         case ICE1712_SUBDEVICE_EWS88D:
959                 for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_ews88d_controls); idx++) {
960                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_controls[idx], ice));
961                         if (err < 0)
962                                 return err;
963                 }
964                 break;
965         case ICE1712_SUBDEVICE_DMX6FIRE:
966                 for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_6fire_controls); idx++) {
967                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_6fire_controls[idx], ice));
968                         if (err < 0)
969                                 return err;
970                 }
971                 break;
972         }
973         return 0;
974 }
975
976
977 /* entry point */
978 struct snd_ice1712_card_info snd_ice1712_ews_cards[] __devinitdata = {
979         {
980                 .subvendor = ICE1712_SUBDEVICE_EWX2496,
981                 .name = "TerraTec EWX24/96",
982                 .model = "ewx2496",
983                 .chip_init = snd_ice1712_ews_init,
984                 .build_controls = snd_ice1712_ews_add_controls,
985         },
986         {
987                 .subvendor = ICE1712_SUBDEVICE_EWS88MT,
988                 .name = "TerraTec EWS88MT",
989                 .model = "ews88mt",
990                 .chip_init = snd_ice1712_ews_init,
991                 .build_controls = snd_ice1712_ews_add_controls,
992         },
993         {
994                 .subvendor = ICE1712_SUBDEVICE_EWS88MT_NEW,
995                 .name = "TerraTec EWS88MT",
996                 .model = "ews88mt_new",
997                 .chip_init = snd_ice1712_ews_init,
998                 .build_controls = snd_ice1712_ews_add_controls,
999         },
1000         {
1001                 .subvendor = ICE1712_SUBDEVICE_PHASE88,
1002                 .name = "TerraTec Phase88",
1003                 .model = "phase88",
1004                 .chip_init = snd_ice1712_ews_init,
1005                 .build_controls = snd_ice1712_ews_add_controls,
1006         },
1007         {
1008                 .subvendor = ICE1712_SUBDEVICE_EWS88D,
1009                 .name = "TerraTec EWS88D",
1010                 .model = "ews88d",
1011                 .chip_init = snd_ice1712_ews_init,
1012                 .build_controls = snd_ice1712_ews_add_controls,
1013         },
1014         {
1015                 .subvendor = ICE1712_SUBDEVICE_DMX6FIRE,
1016                 .name = "TerraTec DMX6Fire",
1017                 .model = "dmx6fire",
1018                 .chip_init = snd_ice1712_ews_init,
1019                 .build_controls = snd_ice1712_ews_add_controls,
1020                 .mpu401_1_name = "MIDI-Front DMX6fire",
1021                 .mpu401_2_name = "Wavetable DMX6fire",
1022                 .mpu401_2_info_flags = MPU401_INFO_OUTPUT,
1023         },
1024         { } /* terminator */
1025 };