?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.24.5
[linux/fpc-iii.git] / sound / pci / ice1712 / ews.c
blob75e4e5e0f1e46b93429b51ca3e57330faa1ef5e4
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 };
Linux with added FPC-III support