gmane.linux.alsa.devel

[PATCH1/1] hda: digital slave support for IDT codecs

Matthew Ranostay — 2008-09-07T18:36:53

Added slave_dig_outs entries for several IDT codecs that have multiple SPDIF outs, and enabled these SPDIF outs in several pin configs. --- Signed-off-by: Matthew Ranostay embeddedalley.com> diff --git a/pci/hda/patch_sigmatel.c b/pci/hda/patch_sigmatel.c index 9968ee4..52b3579 100644 --- a/pci/hda/patch_sigmatel.c +++ b/pci/hda/patch_sigmatel.c < at >< at > -229,6 +229,10 < at >< at > static hda_nid_t stac92hd73xx_pwr_nids[8] = { 0x0f, 0x10, 0x11 }; +static hda_nid_t stac92hd73xx_slave_dig_outs[2] = { +0x26, 0, +}; + static hda_nid_t stac92hd73xx_adc_nids[2] = { 0x1a, 0x1b }; < at >< at > -274,6 +278,10 < at >< at > static hda_nid_t stac92hd83xxx_pwr_nids[4] = { 0xa, 0xb, 0xd, 0xe, }; +static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = { +0x1e, 0, +}; + static unsigned int stac92hd83xxx_pwr_mapping[4] = { 0x03, 0x0c, 0x10, 0x40, }; < at >< at > -303,6 +311,10 < at >< at > static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = { 0x18, 0x19, 0 }; +static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = { +0x22, 0 +}; + static hda_nid_t stac925x_adc_nids[1] = { 0x03, }; < at >< at > -396,9 +408,10 < at >< at > static hda_nid_t stac92hd83xxx_pin_nids[14] = { 0x0f, 0x10, 0x11, 0x12, 0x13, 0x1d, 0x1e, 0x1f, 0x20 }; -static hda_nid_t stac92hd71bxx_pin_nids[10] = { +static hda_nid_t stac92hd71bxx_pin_nids[11] = { 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x14, 0x18, 0x19, 0x1e, +0x1f, }; static hda_nid_t stac927x_pin_nids[14] = { < at >< at > -1424,22 +1437,22 < at >< at > static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = { "DFI LanParty", STAC_92HD71BXX_REF), }; -static unsigned int ref92hd71bxx_pin_configs[10] = { +static unsigned int ref92hd71bxx_pin_configs[11] = { 0x02214030, 0x02a19040, 0x01a19020, 0x01014010, 0x0181302e, 0x01114010, 0x01019020, 0x90a000f0, -0x90a000f0, 0x01452050, +0x90a000f0, 0x01452050, 0x01452050, }; -static unsigned int dell_m4_1_pin_configs[10] = { +static unsigned int dell_m4_1_pin_configs[11] = { 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110, 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0, -0x40f000f0, 0x4f0000f0, +0x40f000f0, 0x4f0000f0, 0x4f0000f0, }; -static unsigned int dell_m4_2_pin_configs[10] = { +static unsigned int dell_m4_2_pin_configs[11] = { 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110, 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0, -0x40f000f0, 0x044413b0, +0x40f000f0, 0x044413b0, 0x044413b0, }; static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = { < at >< at > -3841,8 +3854,9 < at >< at > again: spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids); spec->pwr_nids = stac92hd73xx_pwr_nids; +codec->slave_dig_outs = stac92hd73xx_slave_dig_outs; -err = stac92xx_parse_auto_config(codec, 0x22, 0x24); +err = stac92xx_parse_auto_config(codec, 0x22, 0x25); if (!err) { if (spec->board_config < 0) { < at >< at > -3883,6 +3897,7 < at >< at > static int patch_stac92hd83xxx(struct hda_codec *codec) return -ENOMEM; codec->spec = spec; +codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs; spec->mono_nid = 0x19; spec->digbeep_nid = 0x21; spec->dmic_nids = stac92hd83xxx_dmic_nids; < at >< at > -4033,6 +4048,7 < at >< at > again: case 0x111d76b5: spec->mixer = stac92hd71bxx_mixer; spec->init = stac92hd71bxx_core_init; +codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; break; case 0x111d7608: /* 5 Port with Analog Mixer */ if ((codec->revision_id & 0xf) == 0 || < at >< at > -4065,6 +4081,7 < at >< at > again: default: spec->mixer = stac92hd71bxx_analog_mixer; spec->init = stac92hd71bxx_analog_core_init; +codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; } spec->aloopback_mask = 0x20;

[PATCH0/1] hda: slave digital out support

Matthew Ranostay — 2008-09-07T18:31:40

Added support for playing a stream on multiple digital outs. This is done by defining codec->slave_dig_outs as array of hda_nid_t with a null-terminated entry to set the slave SPDIF outs, in which the slave outs have cloned settings of the master out (e.g. dig_out_nid). --- Signed-off-by: Matthew Ranostay embeddedalley.com> diff --git a/pci/hda/hda_codec.c b/pci/hda/hda_codec.c index 4f32911..696d77e 100644 --- a/pci/hda/hda_codec.c +++ b/pci/hda/hda_codec.c < at >< at > -1454,12 +1454,22 < at >< at > static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, codec->spdif_ctls = val; if (change) { +hda_nid_t *d; snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, val & 0xff); snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_2, val >> 8); + +for (d = codec->slave_dig_outs; *d; d++) { +snd_hda_codec_write_cache(codec, *d, 0, + AC_VERB_SET_DIGI_CONVERT_1, + val & 0xff); +snd_hda_codec_write_cache(codec, *d, 0, + AC_VERB_SET_DIGI_CONVERT_2, + val >> 8); +} } mutex_unlock(&codec->spdif_mutex); < at >< at > -1491,10 +1501,16 < at >< at > static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, val |= AC_DIG1_ENABLE; change = codec->spdif_ctls != val; if (change) { +hda_nid_t *d; codec->spdif_ctls = val; snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, val & 0xff); + +for (d = codec->slave_dig_outs; *d; d++) +snd_hda_codec_write_cache(codec, *d, 0, + AC_VERB_SET_DIGI_CONVERT_1, + val & 0xff); /* unmute amp switch (if any) */ if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) && (val & AC_DIG1_ENABLE)) < at >< at > -1643,9 +1659,14 < at >< at > static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, mutex_lock(&codec->spdif_mutex); change = codec->spdif_in_enable != val; if (change) { +hda_nid_t *d; codec->spdif_in_enable = val; snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, val); + +for (d = codec->slave_dig_outs; *d; d++) +snd_hda_codec_write_cache(codec, *d, 0, + AC_VERB_SET_DIGI_CONVERT_1, val); } mutex_unlock(&codec->spdif_mutex); return change; < at >< at > -2589,15 +2610,30 < at >< at > int snd_hda_input_mux_put(struct hda_codec *codec, static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid, unsigned int stream_tag, unsigned int format) { +hda_nid_t *d; + /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ -if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) +if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) { snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, + codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); + +for (d = codec->slave_dig_outs; *d; d++) +snd_hda_codec_write(codec, *d, 0, +AC_VERB_SET_DIGI_CONVERT_1, codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); +} snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); /* turn on again (if needed) */ -if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) +if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) { snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, codec->spdif_ctls & 0xff); + +for (d = codec->slave_dig_outs; *d; d++) +snd_hda_codec_write(codec, *d, 0, +AC_VERB_SET_DIGI_CONVERT_1, + codec->spdif_ctls & 0xff); +} + } /* < at >< at > -2621,8 +2657,12 < at >< at > int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, unsigned int format, struct snd_pcm_substream *substream) { +hda_nid_t *nid; mutex_lock(&codec->spdif_mutex); setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); +if (codec->slave_dig_outs) +for (nid = codec->slave_dig_outs; *nid; nid++) +setup_dig_out_stream(codec, *nid, stream_tag, format); mutex_unlock(&codec->spdif_mutex); return 0; } < at >< at > -2689,6 +2729,7 < at >< at > int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, struct snd_pcm_substream *substream) { hda_nid_t *nids = mout->dac_nids; +hda_nid_t *d; int chs = substream->runtime->channels; int i; < at >< at > -2702,9 +2743,16 < at >< at > int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, mout->dig_out_used = HDA_DIG_ANALOG_DUP; setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format); +if (codec->slave_dig_outs) +for (d = codec->slave_dig_outs; *d; d++) +setup_dig_out_stream(codec, *d, +stream_tag, format); } else { mout->dig_out_used = 0; snd_hda_codec_cleanup_stream(codec, mout->dig_out_nid); +if (codec->slave_dig_outs) +for (d = codec->slave_dig_outs; *d; d++) +snd_hda_codec_cleanup_stream(codec, *d); } } mutex_unlock(&codec->spdif_mutex); diff --git a/pci/hda/hda_codec.h b/pci/hda/hda_codec.h index 780e2ff..60468f5 100644 --- a/pci/hda/hda_codec.h +++ b/pci/hda/hda_codec.h < at >< at > -725,6 +725,7 < at >< at > struct hda_codec { unsigned int spdif_status;/* IEC958 status bits */ unsigned short spdif_ctls;/* SPDIF control bits */ unsigned int spdif_in_enable;/* SPDIF input enable? */ +hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */ struct snd_hwdep *hwdep;/* assigned hwdep device */

[PATCH] fix section mismatch in the sound_core

Krzysztof Helt — 2008-09-07T15:24:33

From: Krzysztof Helt wp.pl> The __exit cleanup_oss_soundcore() is called from the __init init_soundcore(). This causes section mismatch and breaks kernel's linking on sparc64. Remove the __exit attribute from the cleanup_oss_soundcore(). Signed-off-by: Krzysztof Helt wp.pl> --- Patch against 2.6.27-rc5-mm1. diff -urp linux-ref/sound/sound_core.c linux-2.6.26/sound/sound_core.c --- linux-ref/sound/sound_core.c2008-09-07 18:54:22.800008536 -0400 +++ linux-2.6.26/sound/sound_core.c2008-09-07 18:55:56.805521447 -0400 < at >< at > -13,7 +13,7 < at >< at > #ifdef CONFIG_SOUND_OSS_CORE static int __init init_oss_soundcore(void); -static void __exit cleanup_oss_soundcore(void); +static void cleanup_oss_soundcore(void); #else static inline int init_oss_soundcore(void){ return 0; } static inline void cleanup_oss_soundcore(void){ } < at >< at > -573,7 +573,7 < at >< at > int soundcore_open(struct inode *inode, MODULE_ALIAS_CHARDEV_MAJOR(SOUND_MAJOR); -static void __exit cleanup_oss_soundcore(void) +static void cleanup_oss_soundcore(void) { /* We have nothing to really do here - we know the lists must be empty */ ---------------------------------------------------------------------- Tanie polaczenia z Polska i ze swiatem Sprawdz >> http://link.interia.pl/f1f00

[PATCH] ice1712 drivers coding style fixes (part 2)

Vedran Miletić — 2008-09-07T15:07:39

I started with Takashi's sound-unstable tree as a base: Fixed: * ice1724 compilation error (one { too much) * checkpatch errors along the files sound/pci/ice1712/ak4xxx.c total: 1 errors, 3 warnings, 0 checks, 196 lines checked sound/pci/ice1712/amp.h total: 0 errors, 0 warnings, 1 checks, 51 lines checked sound/pci/ice1712/aureon.c total: 0 errors, 121 warnings, 3 checks, 2284 lines checked sound/pci/ice1712/aureon.h total: 0 errors, 1 warnings, 0 checks, 65 lines checked sound/pci/ice1712/delta.c total: 17 errors, 44 warnings, 1 checks, 817 lines checked sound/pci/ice1712/delta.h total: 0 errors, 8 warnings, 0 checks, 153 lines checked sound/pci/ice1712/envy24ht.h total: 0 errors, 21 warnings, 0 checks, 221 lines checked sound/pci/ice1712/ews.c total: 27 errors, 64 warnings, 2 checks, 1087 lines checked sound/pci/ice1712/ews.h total: 0 errors, 7 warnings, 0 checks, 86 lines checked sound/pci/ice1712/hoontech.c total: 13 errors, 10 warnings, 1 checks, 360 lines checked sound/pci/ice1712/hoontech.h total: 2 errors, 7 warnings, 0 checks, 77 lines checked sound/pci/ice1712/ice1712.c total: 14 errors, 162 warnings, 3 checks, 2799 lines checked sound/pci/ice1712/ice1712.h total: 0 errors, 22 warnings, 3 checks, 511 lines checked sound/pci/ice1712/ice1724.c total: 11 errors, 62 warnings, 8 checks, 2657 lines checked sound/pci/ice1712/juli.c total: 0 errors, 0 warnings, 1 checks, 687 lines checked sound/pci/ice1712/maya44.c total: 6 errors, 0 warnings, 16 checks, 761 lines checked sound/pci/ice1712/pontis.c total: 0 errors, 40 warnings, 3 checks, 836 lines checked sound/pci/ice1712/prodigy192.c total: 12 errors, 21 warnings, 0 checks, 817 lines checked sound/pci/ice1712/prodigy_hifi.c total: 0 errors, 0 warnings, 1 checks, 1215 lines checked sound/pci/ice1712/snd-ice1712.mod.c total: 0 errors, 1 warnings, 0 checks, 113 lines checked sound/pci/ice1712/snd-ice1724.mod.c total: 0 errors, 1 warnings, 0 checks, 126 lines checked sound/pci/ice1712/vt1732.c total: 51 errors, 3 warnings, 5 checks, 2759 lines checked sound/pci/ice1712/vt1732.h total: 9 errors, 0 warnings, 2 checks, 452 lines checked It compiles. At first run ice1724 complained about something info-related (it's likely that it's not related to this patch at all) and generated like 20 or 30 lines of warnings and errors along the lines 890 - 900. On second run there was no errors or warnings anymore.

[PATCH] ice1712.c: fix coding style

Alexander Beregalov — 2008-09-07T10:17:02

before: total: 113 errors, 169 warnings, 2786 lines checked total: 26 errors, 24 warnings, 504 lines checked after: total: 14 errors, 163 warnings, 2799 lines checked total: 0 errors, 24 warnings, 504 lines checked Compile tested only. Signed-off-by: Alexander Beregalov gmail.com> --- sound/pci/ice1712/ice1712.c | 237 +++++++++++++++++++++++-------------------- sound/pci/ice1712/ice1712.h | 52 +++++----- 2 files changed, 151 insertions(+), 138 deletions(-) diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c index 05ffab6..5b44238 100644 --- a/sound/pci/ice1712/ice1712.c +++ b/sound/pci/ice1712/ice1712.c < at >< at > -17,7 +17,7 < at >< at > * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - */ + */ /* NOTES: < at >< at > -35,7 +35,7 < at >< at > * * 2002.11.26James Stafford ampltd.com> *Added support for VT1724 (Envy24HT) - *I have left out support for 176.4 and 192 KHz for the moment. + *I have left out support for 176.4 and 192 KHz for the moment. * I also haven't done anything with the internal S/PDIF transmitter or the MPU-401 * * 2003.02.20 Taksahi Iwai suse.de> < at >< at > -47,7 +47,7 < at >< at > */ -#include +#include #include #include #include < at >< at > -123,7 +123,7 < at >< at > static unsigned int PRO_RATE_DEFAULT = 44100; /* * Basic I/O */ - + /* check whether the clock mode is spdif-in */ static inline int is_spdif_master(struct snd_ice1712 *ice) { < at >< at > -135,13 +135,13 < at >< at > static inline int is_pro_rate_locked(struct snd_ice1712 *ice) return is_spdif_master(ice) || PRO_RATE_LOCKED; } -static inline void snd_ice1712_ds_write(struct snd_ice1712 * ice, u8 channel, u8 addr, u32 data) +static inline void snd_ice1712_ds_write(struct snd_ice1712 *ice, u8 channel, u8 addr, u32 data) { outb((channel << 4) | addr, ICEDS(ice, INDEX)); outl(data, ICEDS(ice, DATA)); } -static inline u32 snd_ice1712_ds_read(struct snd_ice1712 * ice, u8 channel, u8 addr) +static inline u32 snd_ice1712_ds_read(struct snd_ice1712 *ice, u8 channel, u8 addr) { outb((channel << 4) | addr, ICEDS(ice, INDEX)); return inl(ICEDS(ice, DATA)); < at >< at > -260,7 +260,7 < at >< at > static unsigned short snd_ice1712_pro_ac97_read(struct snd_ac97 *ac97, static int snd_ice1712_digmix_route_ac97_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); - + ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_ROUTECTRL)) & ICE1712_ROUTE_AC97 ? 1 : 0; return 0; } < at >< at > -269,11 +269,12 < at >< at > static int snd_ice1712_digmix_route_ac97_put(struct snd_kcontrol *kcontrol, stru { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char val, nval; - + spin_lock_irq(&ice->reg_lock); val = inb(ICEMT(ice, MONITOR_ROUTECTRL)); nval = val & ~ICE1712_ROUTE_AC97; -if (ucontrol->value.integer.value[0]) nval |= ICE1712_ROUTE_AC97; +if (ucontrol->value.integer.value[0]) +nval |= ICE1712_ROUTE_AC97; outb(nval, ICEMT(ice, MONITOR_ROUTECTRL)); spin_unlock_irq(&ice->reg_lock); return val != nval; < at >< at > -329,7 +330,7 < at >< at > static int snd_ice1712_cs8427_set_input_clock(struct snd_ice1712 *ice, int spdif unsigned char reg[2] = { 0x80 | 4, 0 }; /* CS8427 auto increment | register number 4 + data */ unsigned char val, nval; int res = 0; - + snd_i2c_lock(ice->i2c); if (snd_i2c_sendbytes(ice->cs8427, reg, 1) != 1) { snd_i2c_unlock(ice->i2c); < at >< at > -381,9 +382,9 < at >< at > int __devinit snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr) { int err; -if ((err = snd_cs8427_create(ice->i2c, addr, - (ice->cs8427_timeout * HZ) / 1000, - &ice->cs8427)) < 0) { +err = snd_cs8427_create(ice->i2c, addr, +(ice->cs8427_timeout * HZ) / 1000, &ice->cs8427); +if (err < 0) { snd_printk(KERN_ERR "CS8427 initialization failed\n"); return err; } < at >< at > -395,9 +396,9 < at >< at > int __devinit snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr) static void snd_ice1712_set_input_clock_source(struct snd_ice1712 *ice, int spdif_is_master) { - /* change CS8427 clock source too */ - if (ice->cs8427) - snd_ice1712_cs8427_set_input_clock(ice, spdif_is_master); +/* change CS8427 clock source too */ +if (ice->cs8427) +snd_ice1712_cs8427_set_input_clock(ice, spdif_is_master); /* notify ak4524 chip as well */ if (spdif_is_master) { unsigned int i; < at >< at > -457,11 +458,12 < at >< at > static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id) u16 pbkstatus; struct snd_pcm_substream *substream; pbkstatus = inw(ICEDS(ice, INTSTAT)); -//printk("pbkstatus = 0x%x\n", pbkstatus); +/* printk("pbkstatus = 0x%x\n", pbkstatus); */ for (idx = 0; idx < 6; idx++) { if ((pbkstatus & (3 << (idx * 2))) == 0) continue; -if ((substream = ice->playback_con_substream_ds[idx]) != NULL) +substream = ice->playback_con_substream_ds[idx]; +if (substream != NULL) snd_pcm_period_elapsed(substream); outw(3 << (idx * 2), ICEDS(ice, INTSTAT)); } < at >< at > -507,7 +509,7 < at >< at > static int snd_ice1712_playback_trigger(struct snd_pcm_substream *substream, struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); int result = 0; u32 tmp; - + spin_lock(&ice->reg_lock); tmp = snd_ice1712_read(ice, ICE1712_IREG_PBK_CTRL); if (cmd == SNDRV_PCM_TRIGGER_START) { < at >< at > -532,7 +534,7 < at >< at > static int snd_ice1712_playback_ds_trigger(struct snd_pcm_substream *substream, struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); int result = 0; u32 tmp; - + spin_lock(&ice->reg_lock); tmp = snd_ice1712_ds_read(ice, substream->number * 2, ICE1712_DSC_CONTROL); if (cmd == SNDRV_PCM_TRIGGER_START) { < at >< at > -557,7 +559,7 < at >< at > static int snd_ice1712_capture_trigger(struct snd_pcm_substream *substream, struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); int result = 0; u8 tmp; - + spin_lock(&ice->reg_lock); tmp = snd_ice1712_read(ice, ICE1712_IREG_CAP_CTRL); if (cmd == SNDRV_PCM_TRIGGER_START) { < at >< at > -711,8 +713,7 < at >< at > static snd_pcm_uframes_t snd_ice1712_capture_pointer(struct snd_pcm_substream *s return bytes_to_frames(substream->runtime, ptr); } -static const struct snd_pcm_hardware snd_ice1712_playback = -{ +static const struct snd_pcm_hardware snd_ice1712_playback = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -731,8 +732,7 < at >< at > static const struct snd_pcm_hardware snd_ice1712_playback = .fifo_size =0, }; -static const struct snd_pcm_hardware snd_ice1712_playback_ds = -{ +static const struct snd_pcm_hardware snd_ice1712_playback_ds = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -751,8 +751,7 < at >< at > static const struct snd_pcm_hardware snd_ice1712_playback_ds = .fifo_size =0, }; -static const struct snd_pcm_hardware snd_ice1712_capture = -{ +static const struct snd_pcm_hardware snd_ice1712_capture = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), < at >< at > -788,7 +787,7 < at >< at > static int snd_ice1712_playback_ds_open(struct snd_pcm_substream *substream) ice->playback_con_substream_ds[substream->number] = substream; runtime->hw = snd_ice1712_playback_ds; -spin_lock_irq(&ice->reg_lock); +spin_lock_irq(&ice->reg_lock); tmp = inw(ICEDS(ice, INTMASK)) & ~(1 << (substream->number * 2)); outw(tmp, ICEDS(ice, INTMASK)); spin_unlock_irq(&ice->reg_lock); < at >< at > -821,7 +820,7 < at >< at > static int snd_ice1712_playback_ds_close(struct snd_pcm_substream *substream) struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); u32 tmp; -spin_lock_irq(&ice->reg_lock); +spin_lock_irq(&ice->reg_lock); tmp = inw(ICEDS(ice, INTMASK)) | (3 << (substream->number * 2)); outw(tmp, ICEDS(ice, INTMASK)); spin_unlock_irq(&ice->reg_lock); < at >< at > -870,7 +869,7 < at >< at > static struct snd_pcm_ops snd_ice1712_capture_ops = { .pointer =snd_ice1712_capture_pointer, }; -static int __devinit snd_ice1712_pcm(struct snd_ice1712 * ice, int device, struct snd_pcm ** rpcm) +static int __devinit snd_ice1712_pcm(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm) { struct snd_pcm *pcm; int err; < at >< at > -900,7 +899,7 < at >< at > static int __devinit snd_ice1712_pcm(struct snd_ice1712 * ice, int device, struc return 0; } -static int __devinit snd_ice1712_pcm_ds(struct snd_ice1712 * ice, int device, struct snd_pcm ** rpcm) +static int __devinit snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm) { struct snd_pcm *pcm; int err; < at >< at > -1029,14 +1028,14 < at >< at > static void snd_ice1712_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, if (inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW| ICE1712_PLAYBACK_PAUSE| ICE1712_PLAYBACK_START)) { - __out: +__out: spin_unlock_irqrestore(&ice->reg_lock, flags); return; } if (!force && is_pro_rate_locked(ice)) goto __out; - old = inb(ICEMT(ice, RATE)); +old = inb(ICEMT(ice, RATE)); if (!force && old == val) goto __out; outb(val, ICEMT(ice, RATE)); < at >< at > -1123,8 +1122,7 < at >< at > static snd_pcm_uframes_t snd_ice1712_capture_pro_pointer(struct snd_pcm_substrea return bytes_to_frames(substream->runtime, ptr); } -static const struct snd_pcm_hardware snd_ice1712_playback_pro = -{ +static const struct snd_pcm_hardware snd_ice1712_playback_pro = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -1143,8 +1141,7 < at >< at > static const struct snd_pcm_hardware snd_ice1712_playback_pro = .fifo_size =0, }; -static const struct snd_pcm_hardware snd_ice1712_capture_pro = -{ +static const struct snd_pcm_hardware snd_ice1712_capture_pro = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -1238,7 +1235,7 < at >< at > static struct snd_pcm_ops snd_ice1712_capture_pro_ops = { .pointer =snd_ice1712_capture_pro_pointer, }; -static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 * ice, int device, struct snd_pcm ** rpcm) +static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm) { struct snd_pcm *pcm; int err; < at >< at > -1262,7 +1259,7 < at >< at > static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 * ice, int device, ice->pcm_pro = pcm; if (rpcm) *rpcm = pcm; - + if (ice->cs8427) { /* assign channels to iec958 */ err = snd_cs8427_iec958_build(ice->cs8427, < at >< at > -1272,7 +1269,8 < at >< at > static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 * ice, int device, return err; } -if ((err = snd_ice1712_build_pro_mixer(ice)) < 0) +err = snd_ice1712_build_pro_mixer(ice); +if (err < 0) return err; return 0; } < at >< at > -1299,7 +1297,7 < at >< at > static int snd_ice1712_pro_mixer_switch_get(struct snd_kcontrol *kcontrol, struc struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int priv_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value; - + spin_lock_irq(&ice->reg_lock); ucontrol->value.integer.value[0] = !((ice->pro_volumes[priv_idx] >> 15) & 1); < at >< at > -1341,7 +1339,7 < at >< at > static int snd_ice1712_pro_mixer_volume_get(struct snd_kcontrol *kcontrol, struc struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int priv_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value; - + spin_lock_irq(&ice->reg_lock); ucontrol->value.integer.value[0] = (ice->pro_volumes[priv_idx] >> 0) & 127; < at >< at > -1406,7 +1404,7 < at >< at > static struct snd_kcontrol_new snd_ice1712_multi_capture_analog_switch __devinit static struct snd_kcontrol_new snd_ice1712_multi_capture_spdif_switch __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, -.name = SNDRV_CTL_NAME_IEC958("Multi ",CAPTURE,SWITCH), +.name = SNDRV_CTL_NAME_IEC958("Multi ", CAPTURE, SWITCH), .info = snd_ice1712_pro_mixer_switch_info, .get = snd_ice1712_pro_mixer_switch_get, .put = snd_ice1712_pro_mixer_switch_put, < at >< at > -1428,7 +1426,7 < at >< at > static struct snd_kcontrol_new snd_ice1712_multi_capture_analog_volume __devinit static struct snd_kcontrol_new snd_ice1712_multi_capture_spdif_volume __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, -.name = SNDRV_CTL_NAME_IEC958("Multi ",CAPTURE,VOLUME), +.name = SNDRV_CTL_NAME_IEC958("Multi ", CAPTURE, VOLUME), .info = snd_ice1712_pro_mixer_volume_info, .get = snd_ice1712_pro_mixer_volume_get, .put = snd_ice1712_pro_mixer_volume_put, < at >< at > -1448,7 +1446,7 < at >< at > static int __devinit snd_ice1712_build_pro_mixer(struct snd_ice1712 *ice) if (err < 0) return err; } - + if (ice->num_total_adcs > 0) { struct snd_kcontrol_new tmp = snd_ice1712_multi_capture_analog_switch; tmp.count = ice->num_total_adcs; < at >< at > -1495,7 +1493,7 < at >< at > static void snd_ice1712_mixer_free_ac97(struct snd_ac97 *ac97) ice->ac97 = NULL; } -static int __devinit snd_ice1712_ac97_mixer(struct snd_ice1712 * ice) +static int __devinit snd_ice1712_ac97_mixer(struct snd_ice1712 *ice) { int err, bus_num = 0; struct snd_ac97_template ac97; < at >< at > -1510,27 +1508,32 < at >< at > static int __devinit snd_ice1712_ac97_mixer(struct snd_ice1712 * ice) }; if (ice_has_con_ac97(ice)) { -if ((err = snd_ac97_bus(ice->card, bus_num++, &con_ops, NULL, &pbus)) < 0) +err = snd_ac97_bus(ice->card, bus_num++, &con_ops, NULL, &pbus); +if (err < 0) return err; memset(&ac97, 0, sizeof(ac97)); ac97.private_data = ice; ac97.private_free = snd_ice1712_mixer_free_ac97; -if ((err = snd_ac97_mixer(pbus, &ac97, &ice->ac97)) < 0) +err = snd_ac97_mixer(pbus, &ac97, &ice->ac97); +if (err < 0) printk(KERN_WARNING "ice1712: cannot initialize ac97 for consumer, skipped\n"); else { -if ((err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_digmix_route_ac97, ice))) < 0) +err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_digmix_route_ac97, ice)); +if (err < 0) return err; return 0; } } -if (! (ice->eeprom.data[ICE_EEP1_ACLINK] & ICE1712_CFG_PRO_I2S)) { -if ((err = snd_ac97_bus(ice->card, bus_num, &pro_ops, NULL, &pbus)) < 0) +if (!(ice->eeprom.data[ICE_EEP1_ACLINK] & ICE1712_CFG_PRO_I2S)) { +err = snd_ac97_bus(ice->card, bus_num, &pro_ops, NULL, &pbus); +if (err < 0) return err; memset(&ac97, 0, sizeof(ac97)); ac97.private_data = ice; ac97.private_free = snd_ice1712_mixer_free_ac97; -if ((err = snd_ac97_mixer(pbus, &ac97, &ice->ac97)) < 0) +err = snd_ac97_mixer(pbus, &ac97, &ice->ac97); +if (err < 0) printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n"); else return 0; < at >< at > -1549,7 +1552,7 < at >< at > static inline unsigned int eeprom_double(struct snd_ice1712 *ice, int idx) return (unsigned int)ice->eeprom.data[idx] | ((unsigned int)ice->eeprom.data[idx + 1] << 8); } -static void snd_ice1712_proc_read(struct snd_info_entry *entry, +static void snd_ice1712_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_ice1712 *ice = entry->private_data; < at >< at > -1585,15 +1588,15 < at >< at > static void snd_ice1712_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, " SPDOUT : 0x%04x\n", (unsigned)inw(ICEMT(ice, ROUTE_SPDOUT))); snd_iprintf(buffer, " RATE : 0x%02x\n", (unsigned)inb(ICEMT(ice, RATE))); snd_iprintf(buffer, " GPIO_DATA : 0x%02x\n", (unsigned)snd_ice1712_get_gpio_data(ice)); - snd_iprintf(buffer, " GPIO_WRITE_MASK : 0x%02x\n", (unsigned)snd_ice1712_read(ice, ICE1712_IREG_GPIO_WRITE_MASK)); +snd_iprintf(buffer, " GPIO_WRITE_MASK : 0x%02x\n", (unsigned)snd_ice1712_read(ice, ICE1712_IREG_GPIO_WRITE_MASK)); snd_iprintf(buffer, " GPIO_DIRECTION : 0x%02x\n", (unsigned)snd_ice1712_read(ice, ICE1712_IREG_GPIO_DIRECTION)); } -static void __devinit snd_ice1712_proc_init(struct snd_ice1712 * ice) +static void __devinit snd_ice1712_proc_init(struct snd_ice1712 *ice) { struct snd_info_entry *entry; -if (! snd_card_proc_new(ice->card, "ice1712", &entry)) +if (!snd_card_proc_new(ice->card, "ice1712", &entry)) snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read); } < at >< at > -1613,7 +1616,7 < at >< at > static int snd_ice1712_eeprom_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); - + memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom)); return 0; } < at >< at > -1641,7 +1644,7 < at >< at > static int snd_ice1712_spdif_default_get(struct snd_kcontrol *kcontrol, { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.default_get) -ice->spdif.ops.default_get(ice, ucontrol); +ice->spdif.ops.default_get(ice, ucontrol); return 0; } < at >< at > -1657,7 +1660,7 < at >< at > static int snd_ice1712_spdif_default_put(struct snd_kcontrol *kcontrol, static struct snd_kcontrol_new snd_ice1712_spdif_default __devinitdata = { .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), .info =snd_ice1712_spdif_info, .get =snd_ice1712_spdif_default_get, .put =snd_ice1712_spdif_default_put < at >< at > -1709,7 +1712,7 < at >< at > static struct snd_kcontrol_new snd_ice1712_spdif_maskc __devinitdata = { .access =SNDRV_CTL_ELEM_ACCESS_READ, .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK), .info =snd_ice1712_spdif_info, .get =snd_ice1712_spdif_maskc_get, }; < at >< at > -1718,7 +1721,7 < at >< at > static struct snd_kcontrol_new snd_ice1712_spdif_maskp __devinitdata = { .access =SNDRV_CTL_ELEM_ACCESS_READ, .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK), .info =snd_ice1712_spdif_info, .get =snd_ice1712_spdif_maskp_get, }; < at >< at > -1746,7 +1749,7 < at >< at > static struct snd_kcontrol_new snd_ice1712_spdif_stream __devinitdata = .access =(SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE), .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM), .info =snd_ice1712_spdif_info, .get =snd_ice1712_spdif_stream_get, .put =snd_ice1712_spdif_stream_put < at >< at > -1758,7 +1761,7 < at >< at > int snd_ice1712_gpio_get(struct snd_kcontrol *kcontrol, struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char mask = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0; - + snd_ice1712_save_gpio_status(ice); ucontrol->value.integer.value[0] = (snd_ice1712_gpio_read(ice) & mask ? 1 : 0) ^ invert; < at >< at > -1825,7 +1828,7 < at >< at > static int snd_ice1712_pro_internal_clock_get(struct snd_kcontrol *kcontrol, 9, 6, 3, 1, 7, 4, 0, 12, 8, 5, 2, 11, 255, 255, 255, 10 }; unsigned char val; - + spin_lock_irq(&ice->reg_lock); if (is_spdif_master(ice)) { ucontrol->value.enumerated.item[0] = 13; < at >< at > -1867,7 +1870,7 < at >< at > static int snd_ice1712_pro_internal_clock_put(struct snd_kcontrol *kcontrol, if ((oval & ICE1712_SPDIF_MASTER) != (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) - snd_ice1712_set_input_clock_source(ice, is_spdif_master(ice)); +snd_ice1712_set_input_clock_source(ice, is_spdif_master(ice)); return change; } < at >< at > -1897,7 +1900,7 < at >< at > static int snd_ice1712_pro_internal_clock_default_info(struct snd_kcontrol *kcon "64000",/* 10: 15 */ "88200",/* 11: 11 */ "96000",/* 12: 7 */ -// "IEC958 Input",/* 13: -- */ +/* "IEC958 Input",13: -- */ }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; < at >< at > -2026,7 +2029,7 < at >< at > static int snd_ice1712_pro_route_info(struct snd_kcontrol *kcontrol, "IEC958 In L", "IEC958 In R", /* 9-10 */ "Digital Mixer", /* 11 - optional */ }; - + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; uinfo->value.enumerated.items = < at >< at > -2070,7 +2073,7 < at >< at > static int snd_ice1712_pro_route_analog_put(struct snd_kcontrol *kcontrol, int change, shift; int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned int val, old_val, nval; - + /* update PSDOUT */ if (ucontrol->value.enumerated.item[0] >= 11) nval = idx < 2 ? 1 : 0; /* dig mixer (or pcm) */ < at >< at > -2140,7 +2143,7 < at >< at > static int snd_ice1712_pro_route_spdif_put(struct snd_kcontrol *kcontrol, int change, shift; int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned int val, old_val, nval; - + /* update SPDOUT */ spin_lock_irq(&ice->reg_lock); val = old_val = inw(ICEMT(ice, ROUTE_SPDOUT)); < at >< at > -2182,7 +2185,7 < at >< at > static struct snd_kcontrol_new snd_ice1712_mixer_pro_analog_route __devinitdata static struct snd_kcontrol_new snd_ice1712_mixer_pro_spdif_route __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route", +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, NONE) "Route", .info = snd_ice1712_pro_route_info, .get = snd_ice1712_pro_route_spdif_get, .put = snd_ice1712_pro_route_spdif_put, < at >< at > -2204,7 +2207,7 < at >< at > static int snd_ice1712_pro_volume_rate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); - + ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_RATE)); return 0; } < at >< at > -2245,7 +2248,7 < at >< at > static int snd_ice1712_pro_peak_get(struct snd_kcontrol *kcontrol, { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int idx; - + spin_lock_irq(&ice->reg_lock); for (idx = 0; idx < 22; idx++) { outb(idx, ICEMT(ice, MONITOR_PEAKINDEX)); < at >< at > -2296,12 +2299,12 < at >< at > static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, unsigned int i, size; struct snd_ice1712_card_info * const *tbl, *c; -if (! modelname || ! *modelname) { +if (!modelname || !*modelname) { ice->eeprom.subvendor = 0; if ((inb(ICEREG(ice, I2C_CTRL)) & ICE1712_I2C_EEPROM) != 0) ice->eeprom.subvendor = (snd_ice1712_read_i2c(ice, dev, 0x00) << 0) | -(snd_ice1712_read_i2c(ice, dev, 0x01) << 8) | -(snd_ice1712_read_i2c(ice, dev, 0x02) << 16) | +(snd_ice1712_read_i2c(ice, dev, 0x01) << 8) | +(snd_ice1712_read_i2c(ice, dev, 0x02) << 16) | (snd_ice1712_read_i2c(ice, dev, 0x03) << 24); if (ice->eeprom.subvendor == 0 || ice->eeprom.subvendor == (unsigned int)-1) { < at >< at > -2318,12 +2321,12 < at >< at > static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, } for (tbl = card_tables; *tbl; tbl++) { for (c = *tbl; c->subvendor; c++) { -if (modelname && c->model && ! strcmp(modelname, c->model)) { +if (modelname && c->model && !strcmp(modelname, c->model)) { printk(KERN_INFO "ice1712: Using board model %s\n", c->name); ice->eeprom.subvendor = c->subvendor; } else if (c->subvendor != ice->eeprom.subvendor) continue; -if (! c->eeprom_size || ! c->eeprom_data) +if (!c->eeprom_size || !c->eeprom_data) goto found; /* if the EEPROM is given by the driver, use it */ snd_printdd("using the defined eeprom..\n"); < at >< at > -2484,13 +2487,13 < at >< at > static int __devinit snd_ice1712_build_controls(struct snd_ice1712 *ice) static int snd_ice1712_free(struct snd_ice1712 *ice) { -if (! ice->port) +if (!ice->port) goto __hw_end; /* mask all interrupts */ outb(0xc0, ICEMT(ice, IRQ)); outb(0xff, ICEREG(ice, IRQMASK)); /* --- */ - __hw_end: +__hw_end: if (ice->irq >= 0) free_irq(ice->irq, ice); < at >< at > -2515,7 +2518,7 < at >< at > static int __devinit snd_ice1712_create(struct snd_card *card, int omni, int cs8427_timeout, int dxr_enable, -struct snd_ice1712 ** r_ice1712) +struct snd_ice1712 **r_ice1712) { struct snd_ice1712 *ice; int err; < at >< at > -2525,8 +2528,9 < at >< at > static int __devinit snd_ice1712_create(struct snd_card *card, *r_ice1712 = NULL; - /* enable PCI device */ -if ((err = pci_enable_device(pci)) < 0) +/* enable PCI device */ +err = pci_enable_device(pci); +if (err < 0) return err; /* check, if we can restrict PCI DMA transfers to 28 bits */ if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 || < at >< at > -2570,7 +2574,8 < at >< at > static int __devinit snd_ice1712_create(struct snd_card *card, snd_ice1712_proc_init(ice); synchronize_irq(pci->irq); -if ((err = pci_request_regions(pci, "ICE1712")) < 0) { +err = pci_request_regions(pci, "ICE1712"); +if (err < 0) { kfree(ice); pci_disable_device(pci); return err; < at >< at > -2586,7 +2591,7 < at >< at > static int __devinit snd_ice1712_create(struct snd_card *card, snd_ice1712_free(ice); return -EIO; } - + ice->irq = pci->irq; if (snd_ice1712_read_eeprom(ice, modelname) < 0) { < at >< at > -2606,9 +2611,10 < at >< at > static int __devinit snd_ice1712_create(struct snd_card *card, ICEREG(ice, IRQMASK)); outb(0x00, ICEMT(ice, IRQ)); -if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops)) < 0) { +err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops); +if (err < 0) { snd_ice1712_free(ice); - return err; +return err; } snd_card_set_dev(card, &pci->dev); < at >< at > -2648,10 +2654,10 < at >< at > static int __devinit snd_ice1712_probe(struct pci_dev *pci, strcpy(card->driver, "ICE1712"); strcpy(card->shortname, "ICEnsemble ICE1712"); - -if ((err = snd_ice1712_create(card, pci, model[dev], omni[dev], - cs8427_timeout[dev], dxr_enable[dev], - &ice)) < 0) { + +err = snd_ice1712_create(card, pci, model[dev], omni[dev], +cs8427_timeout[dev], dxr_enable[dev], &ice); +if (err < 0) { snd_card_free(card); return err; } < at >< at > -2663,7 +2669,8 < at >< at > static int __devinit snd_ice1712_probe(struct pci_dev *pci, if (c->driver) /* specific driver? */ strcpy(card->driver, c->driver); if (c->chip_init) { -if ((err = c->chip_init(ice)) < 0) { +err = c->chip_init(ice); +if (err < 0) { snd_card_free(card); return err; } < at >< at > -2675,47 +2682,52 < at >< at > static int __devinit snd_ice1712_probe(struct pci_dev *pci, c = &no_matched; __found: -if ((err = snd_ice1712_pcm_profi(ice, pcm_dev++, NULL)) < 0) { +err = snd_ice1712_pcm_profi(ice, pcm_dev++, NULL); +if (err < 0) { snd_card_free(card); return err; } - + if (ice_has_con_ac97(ice)) -if ((err = snd_ice1712_pcm(ice, pcm_dev++, NULL)) < 0) { +err = snd_ice1712_pcm(ice, pcm_dev++, NULL); +if (err < 0) { snd_card_free(card); return err; } -if ((err = snd_ice1712_ac97_mixer(ice)) < 0) { +err = snd_ice1712_ac97_mixer(ice); +if (err < 0) { snd_card_free(card); return err; } -if ((err = snd_ice1712_build_controls(ice)) < 0) { +err = snd_ice1712_build_controls(ice); +if (err < 0) { snd_card_free(card); return err; } if (c->build_controls) { -if ((err = c->build_controls(ice)) < 0) { +err = c->build_controls(ice); +if (err < 0) { snd_card_free(card); return err; } } if (ice_has_con_ac97(ice)) -if ((err = snd_ice1712_pcm_ds(ice, pcm_dev++, NULL)) < 0) { +err = snd_ice1712_pcm_ds(ice, pcm_dev++, NULL); +if (err < 0) { snd_card_free(card); return err; } -if (! c->no_mpu401) { -if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_ICE1712, - ICEREG(ice, MPU1_CTRL), - (c->mpu401_1_info_flags | -MPU401_INFO_INTEGRATED), - ice->irq, 0, - &ice->rmidi[0])) < 0) { +if (!c->no_mpu401) { +err = snd_mpu401_uart_new(card, 0, MPU401_HW_ICE1712, +ICEREG(ice, MPU1_CTRL), +(c->mpu401_1_info_flags | MPU401_INFO_INTEGRATED), +ice->irq, 0, &ice->rmidi[0]); +if (err < 0) { snd_card_free(card); return err; } < at >< at > -2727,12 +2739,12 < at >< at > static int __devinit snd_ice1712_probe(struct pci_dev *pci, if (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401) { /* 2nd port used */ -if ((err = snd_mpu401_uart_new(card, 1, MPU401_HW_ICE1712, - ICEREG(ice, MPU2_CTRL), - (c->mpu401_2_info_flags | -MPU401_INFO_INTEGRATED), - ice->irq, 0, - &ice->rmidi[1])) < 0) { +err = snd_mpu401_uart_new(card, 1, MPU401_HW_ICE1712, +ICEREG(ice, MPU2_CTRL), +(c->mpu401_2_info_flags | MPU401_INFO_INTEGRATED), +ice->irq, 0, &ice->rmidi[1]); + +if (err < 0) { snd_card_free(card); return err; } < at >< at > -2750,7 +2762,8 < at >< at > static int __devinit snd_ice1712_probe(struct pci_dev *pci, sprintf(card->longname, "%s at 0x%lx, irq %i", card->shortname, ice->port, ice->irq); -if ((err = snd_card_register(card)) < 0) { +err = snd_card_register(card); +if (err < 0) { snd_card_free(card); return err; } diff --git a/sound/pci/ice1712/ice1712.h b/sound/pci/ice1712/ice1712.h index 762fbd7..fdae6de 100644 --- a/sound/pci/ice1712/ice1712.h +++ b/sound/pci/ice1712/ice1712.h < at >< at > -20,7 +20,7 < at >< at > * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - */ + */ #include #include < at >< at > -112,7 +112,7 < at >< at > */ #define ICEDS(ice, x) ((ice)->dmapath_port + ICE1712_DS_##x) - + #define ICE1712_DS_INTMASK0x00/* word - interrupt mask */ #define ICE1712_DS_INTSTAT0x02/* word - interrupt status */ #define ICE1712_DS_DATA0x04/* dword - channel data */ < at >< at > -121,7 +121,7 < at >< at > /* * Consumer section channel registers */ - + #define ICE1712_DSC_ADDR00x00/* dword - base address 0 */ #define ICE1712_DSC_COUNT00x01/* word - count 0 */ #define ICE1712_DSC_ADDR10x02/* dword - base address 1 */ < at >< at > -138,7 +138,7 < at >< at > #define ICE1712_DSC_RATE0x05/* dword - rate */ #define ICE1712_DSC_VOLUME0x06/* word - volume control */ -/* +/* * Professional multi-track direct control registers */ < at >< at > -214,7 +214,7 < at >< at > /* - * + * */ struct snd_ice1712; < at >< at > -253,12 +253,12 < at >< at > enum { ICE_EEP1_ADC_ID2, ICE_EEP1_ADC_ID3 }; - + #define ice_has_con_ac97(ice)(!((ice)->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97)) struct snd_ak4xxx_private { -unsigned int cif: 1;/* CIF mode */ +unsigned int cif:1;/* CIF mode */ unsigned char caddr;/* C0 and C1 bits */ unsigned int data_mask;/* DATA gpio bit */ unsigned int clk_mask;/* CLK gpio bit */ < at >< at > -306,11 +306,11 < at >< at > struct snd_ice1712 { struct snd_pcm *pcm; struct snd_pcm *pcm_ds; struct snd_pcm *pcm_pro; - struct snd_pcm_substream *playback_con_substream; - struct snd_pcm_substream *playback_con_substream_ds[6]; - struct snd_pcm_substream *capture_con_substream; - struct snd_pcm_substream *playback_pro_substream; - struct snd_pcm_substream *capture_pro_substream; +struct snd_pcm_substream *playback_con_substream; +struct snd_pcm_substream *playback_con_substream_ds[6]; +struct snd_pcm_substream *capture_con_substream; +struct snd_pcm_substream *playback_pro_substream; +struct snd_pcm_substream *capture_pro_substream; unsigned int playback_pro_size; unsigned int capture_pro_size; unsigned int playback_con_virt_addr[6]; < at >< at > -326,15 +326,15 < at >< at > struct snd_ice1712 { struct snd_ice1712_eeprom eeprom; unsigned int pro_volumes[20]; -unsigned int omni: 1;/* Delta Omni I/O */ -unsigned int dxr_enable: 1;/* Terratec DXR enable for DMX6FIRE */ -unsigned int vt1724: 1; -unsigned int vt1720: 1; -unsigned int has_spdif: 1;/* VT1720/4 - has SPDIF I/O */ -unsigned int force_pdma4: 1;/* VT1720/4 - PDMA4 as non-spdif */ -unsigned int force_rdma1: 1;/* VT1720/4 - RDMA1 as non-spdif */ -unsigned int midi_output: 1;/* VT1720/4: MIDI output triggered */ -unsigned int midi_input: 1;/* VT1720/4: MIDI input triggered */ +unsigned int omni:1;/* Delta Omni I/O */ +unsigned int dxr_enable:1;/* Terratec DXR enable for DMX6FIRE */ +unsigned int vt1724:1; +unsigned int vt1720:1; +unsigned int has_spdif:1;/* VT1720/4 - has SPDIF I/O */ +unsigned int force_pdma4:1;/* VT1720/4 - PDMA4 as non-spdif */ +unsigned int force_rdma1:1;/* VT1720/4 - RDMA1 as non-spdif */ +unsigned int midi_output:1;/* VT1720/4: MIDI output triggered */ +unsigned int midi_input:1;/* VT1720/4: MIDI input triggered */ unsigned int num_total_dacs;/* total DACs */ unsigned int num_total_adcs;/* total ADCs */ unsigned int cur_rate;/* current rate */ < at >< at > -351,7 +351,7 < at >< at > struct snd_ice1712 { struct snd_i2c_bus *i2c;/* I2C bus */ struct snd_i2c_device *cs8427;/* CS8427 I2C device */ unsigned int cs8427_timeout;/* CS8427 reset timeout in HZ/100 */ - + struct ice1712_gpio { unsigned int direction;/* current direction bits */ unsigned int write_mask;/* current mask bits */ < at >< at > -455,7 +455,7 < at >< at > static inline int snd_ice1712_gpio_read_bits(struct snd_ice1712 *ice, { ice->gpio.direction &= ~mask; snd_ice1712_gpio_set_dir(ice, ice->gpio.direction); -return (snd_ice1712_gpio_read(ice) & mask); +return snd_ice1712_gpio_read(ice) & mask; } int snd_ice1712_spdif_build_controls(struct snd_ice1712 *ice); < at >< at > -467,13 +467,13 < at >< at > int snd_ice1712_akm4xxx_build_controls(struct snd_ice1712 *ice); int snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr); -static inline void snd_ice1712_write(struct snd_ice1712 * ice, u8 addr, u8 data) +static inline void snd_ice1712_write(struct snd_ice1712 *ice, u8 addr, u8 data) { outb(addr, ICEREG(ice, INDEX)); outb(data, ICEREG(ice, DATA)); } -static inline u8 snd_ice1712_read(struct snd_ice1712 * ice, u8 addr) +static inline u8 snd_ice1712_read(struct snd_ice1712 *ice, u8 addr) { outb(addr, ICEREG(ice, INDEX)); return inb(ICEREG(ice, DATA)); < at >< at > -491,7 +491,7 < at >< at > struct snd_ice1712_card_info { char *driver; int (*chip_init)(struct snd_ice1712 *); int (*build_controls)(struct snd_ice1712 *); -unsigned int no_mpu401: 1; +unsigned int no_mpu401:1; unsigned int mpu401_1_info_flags; unsigned int mpu401_2_info_flags; const char *mpu401_1_name;

[PATCH] ice1724.c: fix coding style

Alexander Beregalov — 2008-09-07T10:11:04

before: total: 96 errors, 66 warnings, 2612 lines checked after: total: 11 errors, 64 warnings, 2624 lines checked Compile tested only. Signed-off-by: Alexander Beregalov gmail.com> --- sound/pci/ice1712/ice1724.c | 180 +++++++++++++++++++++++-------------------- 1 files changed, 96 insertions(+), 84 deletions(-) diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c index 7bb99df..1b3f117 100644 --- a/sound/pci/ice1712/ice1724.c +++ b/sound/pci/ice1712/ice1724.c < at >< at > -20,9 +20,9 < at >< at > * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - */ + */ -#include +#include #include #include #include < at >< at > -105,7 +105,7 < at >< at > static unsigned int PRO_RATE_DEFAULT = 44100; /* * Basic I/O */ - + /* * default rates, default clock routines */ < at >< at > -198,7 +198,7 < at >< at > static void snd_vt1724_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data) static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) { outw(data, ICEREG1724(ice, GPIO_WRITE_MASK)); -if (! ice->vt1720) /* VT1720 supports only 16 GPIO bits */ +if (!ice->vt1720) /* VT1720 supports only 16 GPIO bits */ outb((data >> 16) & 0xff, ICEREG1724(ice, GPIO_WRITE_MASK_22)); inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */ } < at >< at > -206,7 +206,7 < at >< at > static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) { outw(data, ICEREG1724(ice, GPIO_DATA)); -if (! ice->vt1720) +if (!ice->vt1720) outb(data >> 16, ICEREG1724(ice, GPIO_DATA_22)); inw(ICEREG1724(ice, GPIO_DATA)); /* dummy read for pci-posting */ } < at >< at > -214,7 +214,7 < at >< at > static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) static unsigned int snd_vt1724_get_gpio_data(struct snd_ice1712 *ice) { unsigned int data; -if (! ice->vt1720) +if (!ice->vt1720) data = (unsigned int)inb(ICEREG1724(ice, GPIO_DATA_22)); else data = 0; < at >< at > -399,7 +399,7 < at >< at > static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id) break; } #endif -handled = 1; +handled = 1; if (status & VT1724_IRQ_MPU_TX) { spin_lock(&ice->reg_lock); if (ice->midi_output) < at >< at > -468,8 +468,8 < at >< at > static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id) /* ought to really handle this properly */ if (mtstat & VT1724_MULTI_FIFO_ERR) { unsigned char fstat = inb(ICEMT1724(ice, DMA_FIFO_ERR)); -outb(fstat, ICEMT1724(ice, DMA_FIFO_ERR)); -outb(VT1724_MULTI_FIFO_ERR | inb(ICEMT1724(ice, DMA_INT_MASK)), ICEMT1724(ice, DMA_INT_MASK)); +outb(fstat, ICEMT1724(ice, DMA_FIFO_ERR)); +outb(VT1724_MULTI_FIFO_ERR | inb(ICEMT1724(ice, DMA_INT_MASK)), ICEMT1724(ice, DMA_INT_MASK)); /* If I don't do this, I get machine lockup due to continual interrupts */ } < at >< at > -733,17 +733,17 < at >< at > static int snd_vt1724_playback_pro_prepare(struct snd_pcm_substream *substream) outl(substream->runtime->dma_addr, ICEMT1724(ice, PLAYBACK_ADDR)); size = (snd_pcm_lib_buffer_bytes(substream) >> 2) - 1; -// outl(size, ICEMT1724(ice, PLAYBACK_SIZE)); +/* outl(size, ICEMT1724(ice, PLAYBACK_SIZE)); */ outw(size, ICEMT1724(ice, PLAYBACK_SIZE)); outb(size >> 16, ICEMT1724(ice, PLAYBACK_SIZE) + 2); size = (snd_pcm_lib_period_bytes(substream) >> 2) - 1; -// outl(size, ICEMT1724(ice, PLAYBACK_COUNT)); +/* outl(size, ICEMT1724(ice, PLAYBACK_COUNT)); */ outw(size, ICEMT1724(ice, PLAYBACK_COUNT)); outb(size >> 16, ICEMT1724(ice, PLAYBACK_COUNT) + 2); spin_unlock_irq(&ice->reg_lock); -// printk("pro prepare: ch = %d, addr = 0x%x, buffer = 0x%x, period = 0x%x\n", substream->runtime->channels, (unsigned int)substream->runtime->dma_addr, snd_pcm_lib_buffer_bytes(substream), snd_pcm_lib_period_bytes(substream)); +/* printk("pro prepare: ch = %d, addr = 0x%x, buffer = 0x%x, period = 0x%x\n", substream->runtime->channels, (unsigned int)substream->runtime->dma_addr, snd_pcm_lib_buffer_bytes(substream), snd_pcm_lib_period_bytes(substream)); */ return 0; } < at >< at > -771,7 +771,7 < at >< at > static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substrea ptr = inl(ICEMT1724(ice, PLAYBACK_SIZE)) & 0xffffff; ptr = (ptr + 1) << 2; ptr = bytes_to_frames(substream->runtime, ptr); -if (! ptr) +if (!ptr) ; else if (ptr <= substream->runtime->buffer_size) ptr = substream->runtime->buffer_size - ptr; < at >< at > -815,7 +815,7 < at >< at > static snd_pcm_uframes_t snd_vt1724_pcm_pointer(struct snd_pcm_substream *substr ptr = inw(ice->profi_port + reg->size); ptr = (ptr + 1) << 2; ptr = bytes_to_frames(substream->runtime, ptr); -if (! ptr) +if (!ptr) ; else if (ptr <= substream->runtime->buffer_size) ptr = substream->runtime->buffer_size - ptr; < at >< at > -842,8 +842,7 < at >< at > static const struct vt1724_pcm_reg vt1724_capture_pro_reg = { .start = VT1724_RDMA0_START, }; -static const struct snd_pcm_hardware snd_vt1724_playback_pro = -{ +static const struct snd_pcm_hardware snd_vt1724_playback_pro = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -861,8 +860,7 < at >< at > static const struct snd_pcm_hardware snd_vt1724_playback_pro = .periods_max =1024, }; -static const struct snd_pcm_hardware snd_vt1724_spdif = -{ +static const struct snd_pcm_hardware snd_vt1724_spdif = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -883,8 +881,7 < at >< at > static const struct snd_pcm_hardware snd_vt1724_spdif = .periods_max =1024, }; -static const struct snd_pcm_hardware snd_vt1724_2ch_stereo = -{ +static const struct snd_pcm_hardware snd_vt1724_2ch_stereo = { .info =(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | < at >< at > -1030,7 +1027,7 < at >< at > static struct snd_pcm_ops snd_vt1724_capture_pro_ops = { .pointer =snd_vt1724_pcm_pointer, }; -static int __devinit snd_vt1724_pcm_profi(struct snd_ice1712 * ice, int device) +static int __devinit snd_vt1724_pcm_profi(struct snd_ice1712 *ice, int device) { struct snd_pcm *pcm; int err; < at >< at > -1115,7 +1112,7 < at >< at > static void update_spdif_rate(struct snd_ice1712 *ice, unsigned int rate) static int snd_vt1724_playback_spdif_prepare(struct snd_pcm_substream *substream) { struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); -if (! ice->force_pdma4) +if (!ice->force_pdma4) update_spdif_rate(ice, substream->runtime->rate); return snd_vt1724_pcm_prepare(substream); } < at >< at > -1215,7 +1212,7 < at >< at > static struct snd_pcm_ops snd_vt1724_capture_spdif_ops = { }; -static int __devinit snd_vt1724_pcm_spdif(struct snd_ice1712 * ice, int device) +static int __devinit snd_vt1724_pcm_spdif(struct snd_ice1712 *ice, int device) { char *name; struct snd_pcm *pcm; < at >< at > -1234,7 +1231,7 < at >< at > static int __devinit snd_vt1724_pcm_spdif(struct snd_ice1712 * ice, int device) ice->has_spdif = 1; } else capt = 0; -if (! play && ! capt) +if (!play && !capt) return 0; /* no spdif device */ if (ice->force_pdma4 || ice->force_rdma1) < at >< at > -1349,7 +1346,7 < at >< at > static struct snd_pcm_ops snd_vt1724_playback_indep_ops = { }; -static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 * ice, int device) +static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 *ice, int device) { struct snd_pcm *pcm; int play; < at >< at > -1384,11 +1381,11 < at >< at > static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 * ice, int device) * Mixer section */ -static int __devinit snd_vt1724_ac97_mixer(struct snd_ice1712 * ice) +static int __devinit snd_vt1724_ac97_mixer(struct snd_ice1712 *ice) { int err; -if (! (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S)) { +if (!(ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S)) { struct snd_ac97_bus *pbus; struct snd_ac97_template ac97; static struct snd_ac97_bus_ops ops = { < at >< at > -1401,11 +1398,13 < at >< at > static int __devinit snd_vt1724_ac97_mixer(struct snd_ice1712 * ice) mdelay(5); /* FIXME */ outb(inb(ICEMT1724(ice, AC97_CMD)) & ~0x80, ICEMT1724(ice, AC97_CMD)); -if ((err = snd_ac97_bus(ice->card, 0, &ops, NULL, &pbus)) < 0) +err = snd_ac97_bus(ice->card, 0, &ops, NULL, &pbus); +if (err < 0) return err; memset(&ac97, 0, sizeof(ac97)); ac97.private_data = ice; -if ((err = snd_ac97_mixer(pbus, &ac97, &ice->ac97)) < 0) +err = snd_ac97_mixer(pbus, &ac97, &ice->ac97); +if (err < 0) printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n"); else return 0; < at >< at > -1426,7 +1425,7 < at >< at > static inline unsigned int eeprom_triple(struct snd_ice1712 *ice, int idx) ((unsigned int)ice->eeprom.data[idx + 2] << 16); } -static void snd_vt1724_proc_read(struct snd_info_entry *entry, +static void snd_vt1724_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_ice1712 *ice = entry->private_data; < at >< at > -1468,11 +1467,11 < at >< at > static void snd_vt1724_proc_read(struct snd_info_entry *entry, idx, inb(ice->profi_port+idx)); } -static void __devinit snd_vt1724_proc_init(struct snd_ice1712 * ice) +static void __devinit snd_vt1724_proc_init(struct snd_ice1712 *ice) { struct snd_info_entry *entry; -if (! snd_card_proc_new(ice->card, "ice1724", &entry)) +if (!snd_card_proc_new(ice->card, "ice1724", &entry)) snd_info_set_text_ops(entry, ice, snd_vt1724_proc_read); } < at >< at > -1492,7 +1491,7 < at >< at > static int snd_vt1724_eeprom_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); - + memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom)); return 0; } < at >< at > -1607,13 +1606,13 < at >< at > static int snd_vt1724_spdif_default_put(struct snd_kcontrol *kcontrol, if (val != old) update_spdif_bits(ice, val); spin_unlock_irq(&ice->reg_lock); -return (val != old); +return val != old; } static struct snd_kcontrol_new snd_vt1724_spdif_default __devinitdata = { .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), .info =snd_vt1724_spdif_info, .get =snd_vt1724_spdif_default_get, .put =snd_vt1724_spdif_default_put < at >< at > -1646,7 +1645,7 < at >< at > static struct snd_kcontrol_new snd_vt1724_spdif_maskc __devinitdata = { .access =SNDRV_CTL_ELEM_ACCESS_READ, .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK), .info =snd_vt1724_spdif_info, .get =snd_vt1724_spdif_maskc_get, }; < at >< at > -1655,7 +1654,7 < at >< at > static struct snd_kcontrol_new snd_vt1724_spdif_maskp __devinitdata = { .access =SNDRV_CTL_ELEM_ACCESS_READ, .iface =SNDRV_CTL_ELEM_IFACE_PCM, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK), +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK), .info =snd_vt1724_spdif_info, .get =snd_vt1724_spdif_maskp_get, }; < at >< at > -1692,8 +1691,8 < at >< at > static struct snd_kcontrol_new snd_vt1724_spdif_switch __devinitdata = { .iface =SNDRV_CTL_ELEM_IFACE_MIXER, /* FIXME: the following conflict with IEC958 Playback Route */ -// .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), -.name = SNDRV_CTL_NAME_IEC958("Output ",NONE,SWITCH), +/* .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), */ +.name = SNDRV_CTL_NAME_IEC958("Output ", NONE, SWITCH), .info =snd_vt1724_spdif_sw_info, .get =snd_vt1724_spdif_sw_get, .put =snd_vt1724_spdif_sw_put < at >< at > -1713,7 +1712,7 < at >< at > int snd_vt1724_gpio_get(struct snd_kcontrol *kcontrol, struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0; - + snd_ice1712_save_gpio_status(ice); ucontrol->value.integer.value[0] = (snd_ice1712_gpio_read(ice) & (1 << shift) ? 1 : 0) ^ invert; < at >< at > -1768,7 +1767,7 < at >< at > static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol, { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned int i, rate; - + spin_lock_irq(&ice->reg_lock); if (ice->is_spdif_master(ice)) { ucontrol->value.enumerated.item[0] = ice->hw_rates->count; < at >< at > -1924,7 +1923,7 < at >< at > static int snd_vt1724_pro_route_info(struct snd_kcontrol *kcontrol, "H/W In 0", "H/W In 1", /* 1-2 */ "IEC958 In L", "IEC958 In R", /* 3-4 */ }; - + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; uinfo->value.enumerated.items = 5; < at >< at > -1954,7 +1953,7 < at >< at > static int get_route_val(struct snd_ice1712 *ice, int shift) val = inl(ICEMT1724(ice, ROUTE_PLAYBACK)); val >>= shift; -val &= 7;//we now have 3 bits per output +val &= 7; /* we now have 3 bits per output */ eitem = xlate[val]; if (eitem == 255) { snd_BUG(); < at >< at > -2033,7 +2032,7 < at >< at > static struct snd_kcontrol_new snd_vt1724_mixer_pro_analog_route __devinitdata = static struct snd_kcontrol_new snd_vt1724_mixer_pro_spdif_route __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, -.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route", +.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, NONE) "Route", .info = snd_vt1724_pro_route_info, .get = snd_vt1724_pro_route_spdif_get, .put = snd_vt1724_pro_route_spdif_put, < at >< at > -2056,7 +2055,7 < at >< at > static int snd_vt1724_pro_peak_get(struct snd_kcontrol *kcontrol, { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int idx; - + spin_lock_irq(&ice->reg_lock); for (idx = 0; idx < 22; idx++) { outb(idx, ICEMT1724(ice, MONITOR_PEAKINDEX)); < at >< at > -2083,7 +2082,7 < at >< at > static struct snd_ice1712_card_info no_matched __devinitdata; static struct snd_ice1712_card_info *card_tables[] __devinitdata = { snd_vt1724_revo_cards, -snd_vt1724_amp_cards, +snd_vt1724_amp_cards, snd_vt1724_aureon_cards, snd_vt1720_mobo_cards, snd_vt1720_pontis_cards, < at >< at > -2121,7 +2120,7 < at >< at > unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice, wait_i2c_busy(ice); val = inb(ICEREG1724(ice, I2C_DATA)); mutex_unlock(&ice->i2c_mutex); -//printk("i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val); +/* printk("i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val); */ return val; } < at >< at > -2130,7 +2129,7 < at >< at > void snd_vt1724_write_i2c(struct snd_ice1712 *ice, { mutex_lock(&ice->i2c_mutex); wait_i2c_busy(ice); -//printk("i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data); +/* printk("i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data); */ outb(addr, ICEREG1724(ice, I2C_BYTE_ADDR)); outb(data, ICEREG1724(ice, I2C_DATA)); outb(dev | VT1724_I2C_WRITE, ICEREG1724(ice, I2C_DEV_ADDR)); < at >< at > -2145,13 +2144,13 < at >< at > static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, unsigned int i, size; struct snd_ice1712_card_info * const *tbl, *c; -if (! modelname || ! *modelname) { +if (!modelname || !*modelname) { ice->eeprom.subvendor = 0; if ((inb(ICEREG1724(ice, I2C_CTRL)) & VT1724_I2C_EEPROM) != 0) ice->eeprom.subvendor = (snd_vt1724_read_i2c(ice, dev, 0x00) << 0) | -(snd_vt1724_read_i2c(ice, dev, 0x01) << 8) | -(snd_vt1724_read_i2c(ice, dev, 0x02) << 16) | +(snd_vt1724_read_i2c(ice, dev, 0x01) << 8) | +(snd_vt1724_read_i2c(ice, dev, 0x02) << 16) | (snd_vt1724_read_i2c(ice, dev, 0x03) << 24); if (ice->eeprom.subvendor == 0 || ice->eeprom.subvendor == (unsigned int)-1) { < at >< at > -2174,13 +2173,13 < at >< at > static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, for (tbl = card_tables; *tbl; tbl++) { for (c = *tbl; c->subvendor; c++) { if (modelname && c->model && - ! strcmp(modelname, c->model)) { + !strcmp(modelname, c->model)) { printk(KERN_INFO "ice1724: Using board model %s\n", c->name); ice->eeprom.subvendor = c->subvendor; } else if (c->subvendor != ice->eeprom.subvendor) continue; -if (! c->eeprom_size || ! c->eeprom_data) +if (!c->eeprom_size || !c->eeprom_data) goto found; /* if the EEPROM is given by the driver, use it */ snd_printdd("using the defined eeprom..\n"); < at >< at > -2322,13 +2321,13 < at >< at > static int __devinit snd_vt1724_build_controls(struct snd_ice1712 *ice) static int snd_vt1724_free(struct snd_ice1712 *ice) { -if (! ice->port) +if (!ice->port) goto __hw_end; /* mask all interrupts */ outb(0xff, ICEMT1724(ice, DMA_INT_MASK)); outb(0xff, ICEREG1724(ice, IRQMASK)); /* --- */ - __hw_end: +__hw_end: if (ice->irq >= 0) free_irq(ice->irq, ice); pci_release_regions(ice->pci); < at >< at > -2348,7 +2347,7 < at >< at > static int snd_vt1724_dev_free(struct snd_device *device) static int __devinit snd_vt1724_create(struct snd_card *card, struct pci_dev *pci, const char *modelname, - struct snd_ice1712 ** r_ice1712) + struct snd_ice1712 **r_ice1712) { struct snd_ice1712 *ice; int err; < at >< at > -2359,8 +2358,9 < at >< at > static int __devinit snd_vt1724_create(struct snd_card *card, *r_ice1712 = NULL; - /* enable PCI device */ -if ((err = pci_enable_device(pci)) < 0) +/* enable PCI device */ +err = pci_enable_device(pci); +if (err < 0) return err; ice = kzalloc(sizeof(*ice), GFP_KERNEL); < at >< at > -2384,7 +2384,8 < at >< at > static int __devinit snd_vt1724_create(struct snd_card *card, snd_vt1724_proc_init(ice); synchronize_irq(pci->irq); -if ((err = pci_request_regions(pci, "ICE1724")) < 0) { +err = pci_request_regions(pci, "ICE1724"); +if (err < 0) { kfree(ice); pci_disable_device(pci); return err; < at >< at > -2419,9 +2420,10 < at >< at > static int __devinit snd_vt1724_create(struct snd_card *card, */ outb(VT1724_MULTI_FIFO_ERR, ICEMT1724(ice, DMA_INT_MASK)); -if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops)) < 0) { +err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops); +if (err < 0) { snd_vt1724_free(ice); - return err; +return err; } snd_card_set_dev(card, &pci->dev); < at >< at > -2459,8 +2461,9 < at >< at > static int __devinit snd_vt1724_probe(struct pci_dev *pci, strcpy(card->driver, "ICE1724"); strcpy(card->shortname, "ICEnsemble ICE1724"); - -if ((err = snd_vt1724_create(card, pci, model[dev], &ice)) < 0) { + +err = snd_vt1724_create(card, pci, model[dev], &ice); +if (err < 0) { snd_card_free(card); return err; } < at >< at > -2472,7 +2475,8 < at >< at > static int __devinit snd_vt1724_probe(struct pci_dev *pci, if (c->driver) /* specific driver? */ strcpy(card->driver, c->driver); if (c->chip_init) { -if ((err = c->chip_init(ice)) < 0) { +err = c->chip_init(ice); +if (err < 0) { snd_card_free(card); return err; } < at >< at > -2482,15 +2486,15 < at >< at > static int __devinit snd_vt1724_probe(struct pci_dev *pci, } } c = &no_matched; - __found: - /* - * VT1724 has separate DMAs for the analog and the SPDIF streams while - * ICE1712 has only one for both (mixed up). - * - * Confusingly the analog PCM is named "professional" here because it - * was called so in ice1712 driver, and vt1724 driver is derived from - * ice1712 driver. - */ +__found: +/* +* VT1724 has separate DMAs for the analog and the SPDIF streams while +* ICE1712 has only one for both (mixed up). +* +* Confusingly the analog PCM is named "professional" here because it +* was called so in ice1712 driver, and vt1724 driver is derived from +* ice1712 driver. +*/ ice->pro_rate_default = PRO_RATE_DEFAULT; if (!ice->is_spdif_master) ice->is_spdif_master = stdclock_is_spdif_master; < at >< at > -2505,46 +2509,53 < at >< at > static int __devinit snd_vt1724_probe(struct pci_dev *pci, if (!ice->hw_rates) set_std_hw_rates(ice); -if ((err = snd_vt1724_pcm_profi(ice, pcm_dev++)) < 0) { +err = snd_vt1724_pcm_profi(ice, pcm_dev++); +if (err < 0) { snd_card_free(card); return err; } - -if ((err = snd_vt1724_pcm_spdif(ice, pcm_dev++)) < 0) { + +err = snd_vt1724_pcm_spdif(ice, pcm_dev++); +if (err < 0) { snd_card_free(card); return err; } - -if ((err = snd_vt1724_pcm_indep(ice, pcm_dev++)) < 0) { + +err = snd_vt1724_pcm_indep(ice, pcm_dev++); +if (err < 0) { snd_card_free(card); return err; } -if ((err = snd_vt1724_ac97_mixer(ice)) < 0) { +err = snd_vt1724_ac97_mixer(ice); +if (err < 0) { snd_card_free(card); return err; } -if ((err = snd_vt1724_build_controls(ice)) < 0) { +err = snd_vt1724_build_controls(ice); +if (err < 0) { snd_card_free(card); return err; } if (ice->pcm && ice->has_spdif) { /* has SPDIF I/O */ -if ((err = snd_vt1724_spdif_build_controls(ice)) < 0) { +err = snd_vt1724_spdif_build_controls(ice); +if (err < 0) { snd_card_free(card); return err; } } if (c->build_controls) { -if ((err = c->build_controls(ice)) < 0) { +err = c->build_controls(ice); +if (err < 0) { snd_card_free(card); return err; } } -if (! c->no_mpu401) { +if (!c->no_mpu401) { if (ice->eeprom.data[ICE_EEP2_SYSCONF] & VT1724_CFG_MPU401) { struct snd_rawmidi *rmidi; < at >< at > -2576,7 +2587,8 < at >< at > static int __devinit snd_vt1724_probe(struct pci_dev *pci, sprintf(card->longname, "%s at 0x%lx, irq %i", card->shortname, ice->port, ice->irq); -if ((err = snd_card_register(card)) < 0) { +err = snd_card_register(card); +if (err < 0) { snd_card_free(card); return err; }

[PATCH] phase and juli coding style fixes (more comingup)

Vedran Miletić — 2008-09-07T09:39:10

From my signoff: From b4a282ae0d54087bc152571c250afcd57fa9fa38 Mon Sep 17 00:00:00 2001 From: Vedran Miletic gmail.com> Date: Sun, 7 Sep 2008 11:22:35 +0200 Subject: [PATCH] ALSA: ice1712/ice1724: Coding style fixes part 1 (more coming up) Inspired by Alexander Beregalov's patches for wtm and aureon.c, I decided to run checkpatch on some more files. After some work checkpatch.pl-0.23 --no-tree --file --strict reports 0 errors, 0 warnings, 0 checks, n lines checked for: phase.c phase.h juli.c (1 check about unused code, maybe we should comment it) juli.h (no changes necessary) In other files I have just fixed // comments and long lines along the way (but not all of them), more coming up. Signed-off-by: Vedran Miletic gmail.com> Patch is attached.

[PATCH 0/5] ARM: OMAP2: Add support for GUmstix Overo(rev 3)

2008-09-07T06:41:39

This patch series adds support for the Gumstix Overo board. This is the third submission and incorporates all previous feedback from both linux-omap and alsa-devel. Careful readers will also notice that this version includes nand support rather than onenand.

HP tx2000 and snd-hda-intel

Kory Prince — 2008-09-07T04:26:10

Note: The other message did not go through because it was too big. I can email the schematics I mentioned if anyone is interested ************************************************************** Hello, I have an HP Pavillion TX2000z. This laptop has uses the snd-hda-intel and has the ALC861VD realtek codec. The existing configuration for the codec does not support the tx2000 series laptops fully. There are several configurations that have various levels of support. If you specify for the model to use the existing hp model (made for the tx1000 series) then: 1.Headphones Work 2.Speakers Work 3.Front Mic Works (the jack mic by the headphone jack) 4.The External Mics do not work (There are two mics at the top of the laptop... I am guessing left and right for a stereo Mic) 5.It seems like there is something mapped to an input that does not belong there. The simplest way to explain this is when I open audacity and set it to monitor input that there is significant white noise coming in. The Ext. Mics are not working so it can't come from there (as far as I know) and I have nothing plugged into the front Mic. I cannot find any way to mute this noise. When using the 3-stack model (with the option position_fix): 1. Headphones do not work (in either ports) 2. Speakers Work 3. Front Mic Works 4. The external mics work 5. Same problem as expressed above All other models do not work in any significant way. Also one of the Headphone ports (there are two on the front) has Digital Out (optical) that I have no way of confirming if it works. Now, that being said, I have tried working on the driver. I have virtually no programing experience. I was able to have the driver autodetect the soundcard and apply a certain model (before it had to be applied with a module config file.) And was able to interpret some of how the driver worked. But I am so lost. I am not sure how hard it would be for a programmer to modify the driver to support the tx2000. So I want to put out a call to anyone who could help. I am fully available for testing and some debugging if someone could try and help. I am uploading the codec file and the codec schematic ( I don't think this is actually accurate, but It may help...) Also here is the lspci -nn for the soundcard and other info I found 00:10.1 Audio device [0403]: nVidia Corporation MCP51 High Definition Audio [10de:026c] (rev a2) lshw *-multimedia description: Audio device product: MCP51 High Definition Audio vendor: nVidia Corporation physical id: 10.1 bus info: pci< at >0000:00:10.1 version: a2 width: 32 bits clock: 66MHz capabilities: pm msi ht bus_master cap_list configuration: driver=HDA Intel latency=0 maxlatency=5 mingnt=2 module=snd_hda_intel If anyone could help or use additional information I would appreciate it. Thanks, Kory p.s. if this is the wrong place to post, please redirect me. Codec: Realtek ALC861-VD Address: 0 Vendor Id: 0x10ec0862 Subsystem Id: 0x103c30e5 Revision Id: 0x100001 No Modem Function Group found Default PCM: rates [0x160]: 44100 48000 96000 bits [0xe]: 16 20 24 formats [0x1]: PCM Default Amp-In caps: N/A Default Amp-Out caps: N/A GPIO: io=2, o=0, i=0, unsolicited=1, wake=0 IO[0]: enable=0, dir=0, wake=0, sticky=0, data=0 IO[1]: enable=0, dir=0, wake=0, sticky=0, data=0 Node 0x02 [Audio Output] wcaps 0x1d: Stereo Amp-Out Amp-Out caps: ofs=0x40, nsteps=0x40, stepsize=0x03, mute=0 Amp-Out vals: [0x40 0x40] Converter: stream=0, channel=0 PCM: rates [0x160]: 44100 48000 96000 bits [0xe]: 16 20 24 formats [0x1]: PCM Node 0x03 [Audio Output] wcaps 0x1d: Stereo Amp-Out Amp-Out caps: ofs=0x40, nsteps=0x40, stepsize=0x03, mute=0 Amp-Out vals: [0x00 0x00] Converter: stream=0, channel=0 PCM: rates [0x160]: 44100 48000 96000 bits [0xe]: 16 20 24 formats [0x1]: PCM Node 0x04 [Audio Output] wcaps 0x1d: Stereo Amp-Out Amp-Out caps: ofs=0x40, nsteps=0x40, stepsize=0x03, mute=0 Amp-Out vals: [0x00 0x00] Converter: stream=0, channel=0 PCM: rates [0x160]: 44100 48000 96000 bits [0xe]: 16 20 24 formats [0x1]: PCM Node 0x05 [Audio Output] wcaps 0x1d: Stereo Amp-Out Amp-Out caps: ofs=0x40, nsteps=0x40, stepsize=0x03, mute=0 Amp-Out vals: [0x00 0x00] Converter: stream=0, channel=0 PCM: rates [0x160]: 44100 48000 96000 bits [0xe]: 16 20 24 formats [0x1]: PCM Node 0x06 [Audio Output] wcaps 0x211: Stereo Digital Converter: stream=0, channel=0 Digital: Digital category: 0x0 PCM: rates [0x160]: 44100 48000 96000 bits [0x1e]: 16 20 24 32 formats [0x1]: PCM Node 0x07 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x08 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In Amp-In caps: ofs=0x09, nsteps=0x1f, stepsize=0x05, mute=1 Amp-In vals: [0x1f 0x1f] Converter: stream=0, channel=0 SDI-Select: 0 PCM: rates [0x160]: 44100 48000 96000 bits [0x6]: 16 20 formats [0x1]: PCM Connection: 1 0x22 Node 0x0a [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x0b [Audio Mixer] wcaps 0x20010b: Stereo Amp-In Amp-In caps: ofs=0x17, nsteps=0x1f, stepsize=0x05, mute=1 Amp-In vals: [0x1f 0x1f] [0x1f 0x1f] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] Connection: 6 0x18 0x19 0x1a 0x1b 0x1c 0x1d Node 0x0c [Audio Mixer] wcaps 0x20010b: Stereo Amp-In Amp-In caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-In vals: [0x00 0x00] [0x00 0x00] Connection: 2 0x02 0x0b Node 0x0d [Audio Mixer] wcaps 0x20010b: Stereo Amp-In Amp-In caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-In vals: [0x00 0x00] [0x00 0x00] Connection: 2 0x03 0x0b Node 0x0e [Audio Mixer] wcaps 0x20010b: Stereo Amp-In Amp-In caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-In vals: [0x80 0x80] [0x80 0x80] Connection: 2 0x04 0x0b Node 0x0f [Audio Mixer] wcaps 0x20010b: Stereo Amp-In Amp-In caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-In vals: [0x80 0x80] [0x80 0x80] Connection: 2 0x05 0x0b Node 0x10 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x11 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x12 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x13 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x14 [Pin Complex] wcaps 0x40018d: Stereo Amp-Out Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x00 0x00] Pincap 0x081003c: IN OUT HP EAPD Detect EAPD 0x2: EAPD Pin Default 0x99130110: [Fixed] Speaker at Int ATAPI Conn = ATAPI, Color = Unknown DefAssociation = 0x1, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x40: OUT Unsolicited: tag=00, enabled=0 Connection: 1 0x0c Node 0x15 [Pin Complex] wcaps 0x40018d: Stereo Amp-Out Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x00 0x00] Pincap 0x0810034: IN OUT EAPD Detect EAPD 0x2: EAPD Pin Default 0x02014020: [Jack] Line Out at Ext Front Conn = 1/8, Color = Green DefAssociation = 0x2, Sequence = 0x0 Pin-ctls: 0x40: OUT Unsolicited: tag=04, enabled=1 Connection: 1 0x0d Node 0x16 [Pin Complex] wcaps 0x40018d: Stereo Amp-Out Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x00 0x00] Pincap 0x0834: IN OUT Detect Pin Default 0x411111f0: [N/A] Speaker at Ext Rear Conn = 1/8, Color = Black DefAssociation = 0xf, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x40: OUT Unsolicited: tag=00, enabled=0 Connection: 1 0x0e Node 0x17 [Pin Complex] wcaps 0x40018d: Stereo Amp-Out Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x00 0x00] Pincap 0x0834: IN OUT Detect Pin Default 0x411111f0: [N/A] Speaker at Ext Rear Conn = 1/8, Color = Black DefAssociation = 0xf, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x40: OUT Unsolicited: tag=00, enabled=0 Connection: 1 0x0f Node 0x18 [Pin Complex] wcaps 0x40018f: Stereo Amp-In Amp-Out Amp-In caps: ofs=0x00, nsteps=0x03, stepsize=0x27, mute=0 Amp-In vals: [0x00 0x00] Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x80 0x80] Pincap 0x081734: IN OUT Detect Vref caps: HIZ 50 GRD 80 Pin Default 0x02a19830: [Jack] Mic at Ext Front Conn = 1/8, Color = Pink DefAssociation = 0x3, Sequence = 0x0 Pin-ctls: 0x21: IN VREF_50 Unsolicited: tag=00, enabled=0 Connection: 1 0x0e Node 0x19 [Pin Complex] wcaps 0x40018f: Stereo Amp-In Amp-Out Amp-In caps: ofs=0x00, nsteps=0x03, stepsize=0x27, mute=0 Amp-In vals: [0x00 0x00] Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x80 0x80] Pincap 0x08173c: IN OUT HP Detect Vref caps: HIZ 50 GRD 80 Pin Default 0x99a3013f: [Fixed] Mic at Int ATAPI Conn = ATAPI, Color = Unknown DefAssociation = 0x3, Sequence = 0xf Misc = NO_PRESENCE Pin-ctls: 0x20: IN VREF_HIZ Unsolicited: tag=00, enabled=0 Connection: 2 0x0c* 0x0f Node 0x1a [Pin Complex] wcaps 0x40018d: Stereo Amp-Out Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x80 0x80] Pincap 0x0834: IN OUT Detect Pin Default 0x411111f0: [N/A] Speaker at Ext Rear Conn = 1/8, Color = Black DefAssociation = 0xf, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x20: IN Unsolicited: tag=00, enabled=0 Connection: 1 0x0d Node 0x1b [Pin Complex] wcaps 0x40018f: Stereo Amp-In Amp-Out Amp-In caps: ofs=0x00, nsteps=0x03, stepsize=0x27, mute=0 Amp-In vals: [0x00 0x00] Amp-Out caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-Out vals: [0x80 0x80] Pincap 0x08173c: IN OUT HP Detect Vref caps: HIZ 50 GRD 80 Pin Default 0x411111f0: [N/A] Speaker at Ext Rear Conn = 1/8, Color = Black DefAssociation = 0xf, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x20: IN VREF_HIZ Unsolicited: tag=00, enabled=0 Connection: 2 0x0c* 0x0f Node 0x1c [Pin Complex] wcaps 0x400001: Stereo Pincap 0x0820: IN Pin Default 0x411111f0: [N/A] Speaker at Ext Rear Conn = 1/8, Color = Black DefAssociation = 0xf, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x20: IN Node 0x1d [Pin Complex] wcaps 0x400000: Mono Pincap 0x0820: IN Pin Default 0x411111f0: [N/A] Speaker at Ext Rear Conn = 1/8, Color = Black DefAssociation = 0xf, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x20: IN Node 0x1e [Pin Complex] wcaps 0x400300: Mono Digital Pincap 0x0810: OUT Pin Default 0x99430140: [Fixed] SPDIF Out at Int ATAPI Conn = ATAPI, Color = Unknown DefAssociation = 0x4, Sequence = 0x0 Misc = NO_PRESENCE Pin-ctls: 0x40: OUT Connection: 1 0x06 Node 0x1f [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x20 [Vendor Defined Widget] wcaps 0xf00040: Mono Processing caps: benign=0, ncoeff=17 Node 0x21 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In Amp-In caps: ofs=0x00, nsteps=0x00, stepsize=0x00, mute=1 Amp-In vals: [0x00 0x00] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] [0x80 0x80] Connection: 11 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x14 0x15 0x16 0x17 0x0b Node 0x23 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x24 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x25 [Vendor Defined Widget] wcaps 0xf00000: Mono Node 0x26 [Vendor Defined Widget] wcaps 0xf00000: Mono _______________________________________________ Alsa-devel mailing list Alsa-devel< at >alsa-project.org http://mailman.alsa-project.org/mailman/listinfo/alsa-devel

[PATCH] ice1712/wtm: fix coding style

Alexander Beregalov — 2008-09-06T21:54:27

before: total: 2 errors, 0 warnings, 20 lines checked total: 49 errors, 2 warnings, 518 lines checked after: total: 0 errors, 0 warnings, 20 lines checked total: 0 errors, 0 warnings, 518 lines checked Compile tested, size and code are equal. Signed-off-by: Alexander Beregalov gmail.com> --- sound/pci/ice1712/wtm.c | 104 +++++++++++++++++++++++----------------------- sound/pci/ice1712/wtm.h | 4 +- 2 files changed, 54 insertions(+), 54 deletions(-) diff --git a/sound/pci/ice1712/wtm.c b/sound/pci/ice1712/wtm.c index a08d17c..5af9e84 100644 --- a/sound/pci/ice1712/wtm.c +++ b/sound/pci/ice1712/wtm.c < at >< at > -1,12 +1,12 < at >< at > /* *ALSA driver for ICEnsemble VT1724 (Envy24HT) - * + * *Lowlevel functions for Ego Sys Waveterminal 192M * *Copyright (c) 2006 Guedez Clement gmail.com> *Some functions are taken from the Prodigy192 driver *source - * + * *This program is free software; you can redistribute it and/or modify *it under the terms of the GNU General Public License as published by *the Free Software Foundation; either version 2 of the License, or < at >< at > -20,12 +20,12 < at >< at > *You should have received a copy of the GNU General Public License *along with this program; if not, write to the Free Software *Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ + * + */ -#include +#include #include #include #include < at >< at > -39,9 +39,9 < at >< at > /* - *2*ADC 6*DAC no1 ringbuffer r/w on i2c bus + *2*ADC 6*DAC no1 ringbuffer r/w on i2c bus */ -static inline void stac9460_put(struct snd_ice1712 *ice, int reg, +static inline void stac9460_put(struct snd_ice1712 *ice, int reg, unsigned char val) { snd_vt1724_write_i2c(ice, STAC9460_I2C_ADDR, reg, val); < at >< at > -73,7 +73,7 < at >< at > static inline unsigned char stac9460_2_get(struct snd_ice1712 *ice, int reg) #define stac9460_dac_mute_infosnd_ctl_boolean_mono_info static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char val; < at >< at > -88,14 +88,14 < at >< at > static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, } if (id < 6) val = stac9460_get(ice, idx); -else -val = stac9460_2_get(ice,idx - 6); +else +val = stac9460_2_get(ice, idx - 6); ucontrol->value.integer.value[0] = (~val >> 7) & 0x1; return 0; } static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char new, old; < at >< at > -105,8 +105,8 < at >< at > static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, if (kcontrol->private_value) { idx = STAC946X_MASTER_VOLUME; old = stac9460_get(ice, idx); -new = (~ucontrol->value.integer.value[0]<< 7 & 0x80) | - (old & ~0x80); +new = (~ucontrol->value.integer.value[0] << 7 & 0x80) | +(old & ~0x80); change = (new != old); if (change) { stac9460_put(ice, idx, new); < at >< at > -117,16 +117,16 < at >< at > static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, idx = id + STAC946X_LF_VOLUME; if (id < 6) old = stac9460_get(ice, idx); -else +else old = stac9460_2_get(ice, idx - 6); -new = (~ucontrol->value.integer.value[0]<< 7 & 0x80) | +new = (~ucontrol->value.integer.value[0] << 7 & 0x80) | (old & ~0x80); change = (new != old); if (change) { if (id < 6) - stac9460_put(ice, idx, new); +stac9460_put(ice, idx, new); else - stac9460_2_put(ice, idx - 6, new); +stac9460_2_put(ice, idx - 6, new); } } return change; < at >< at > -136,7 +136,7 < at >< at > static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, * DAC volume attenuation mixer control */ static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; < at >< at > -146,7 +146,7 < at >< at > static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol, } static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int idx, id; < at >< at > -161,14 +161,14 < at >< at > static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol, } if (id < 6) vol = stac9460_get(ice, idx) & 0x7f; -else +else vol = stac9460_2_get(ice, idx - 6) & 0x7f; ucontrol->value.integer.value[0] = 0x7f - vol; return 0; } static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int idx, id; < at >< at > -182,8 +182,8 < at >< at > static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, ovol = 0x7f - (tmp & 0x7f); change = (ovol != nvol); if (change) { - stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80)); - stac9460_2_put(ice, idx, (0x7f - nvol) | (tmp & 0x80)); +stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80)); +stac9460_2_put(ice, idx, (0x7f - nvol) | (tmp & 0x80)); } } else { id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); < at >< at > -191,17 +191,17 < at >< at > static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, nvol = ucontrol->value.integer.value[0] & 0x7f; if (id < 6) tmp = stac9460_get(ice, idx); -else +else tmp = stac9460_2_get(ice, idx - 6); ovol = 0x7f - (tmp & 0x7f); change = (ovol != nvol); if (change) { if (id < 6) stac9460_put(ice, idx, (0x7f - nvol) | - (tmp & 0x80)); -else +(tmp & 0x80)); +else stac9460_2_put(ice, idx-6, (0x7f - nvol) | - (tmp & 0x80)); +(tmp & 0x80)); } } return change; < at >< at > -213,12 +213,12 < at >< at > static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, #define stac9460_adc_mute_infosnd_ctl_boolean_stereo_info static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char val; int i, id; - + id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); if (id == 0) { for (i = 0; i < 2; ++i) { < at >< at > -235,20 +235,20 < at >< at > static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol, } static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char new, old; int i, reg, id; int change; - + id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); if (id == 0) { for (i = 0; i < 2; ++i) { reg = STAC946X_MIC_L_VOLUME + i; old = stac9460_get(ice, reg); new = (~ucontrol->value.integer.value[i]<<7&0x80) | - (old&~0x80); +(old&~0x80); change = (new != old); if (change) stac9460_put(ice, reg, new); < at >< at > -258,7 +258,7 < at >< at > static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, reg = STAC946X_MIC_L_VOLUME + i; old = stac9460_2_get(ice, reg); new = (~ucontrol->value.integer.value[i]<<7&0x80) | - (old&~0x80); +(old&~0x80); change = (new != old); if (change) stac9460_2_put(ice, reg, new); < at >< at > -271,7 +271,7 < at >< at > static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, *ADC gain mixer control */ static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; < at >< at > -281,12 +281,12 < at >< at > static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol, } static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int i, reg, id; unsigned char vol; - + id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); if (id == 0) { for (i = 0; i < 2; ++i) { < at >< at > -305,13 +305,13 < at >< at > static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol, } static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); int i, reg, id; unsigned char ovol, nvol; int change; - + id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); if (id == 0) { for (i = 0; i < 2; ++i) { < at >< at > -321,7 +321,7 < at >< at > static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, change = ((ovol & 0x0f) != nvol); if (change) stac9460_put(ice, reg, (0x0f - nvol) | - (ovol & ~0x0f)); +(ovol & ~0x0f)); } } else { for (i = 0; i < 2; ++i) { < at >< at > -331,7 +331,7 < at >< at > static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, change = ((ovol & 0x0f) != nvol); if (change) stac9460_2_put(ice, reg, (0x0f - nvol) | - (ovol & ~0x0f)); +(ovol & ~0x0f)); } } return change; < at >< at > -344,23 +344,23 < at >< at > static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, #define stac9460_mic_sw_infosnd_ctl_boolean_mono_info static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char val; int id; - + id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); if (id == 0) - val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE); +val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE); else - val = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE); +val = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE); ucontrol->value.integer.value[0] = ~val>>7 & 0x1; return 0; } static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +struct snd_ctl_elem_value *ucontrol) { struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); unsigned char new, old; < at >< at > -368,16 +368,16 < at >< at > static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol, id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); if (id == 0) - old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE); +old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE); else - old = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE); -new = (~ucontrol->value.integer.value[0]<< 7 & 0x80) | (old & ~0x80); +old = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE); +new = (~ucontrol->value.integer.value[0] << 7 & 0x80) | (old & ~0x80); change = (new != old); if (change) { if (id == 0) - stac9460_put(ice, STAC946X_GENERAL_PURPOSE, new); +stac9460_put(ice, STAC946X_GENERAL_PURPOSE, new); else - stac9460_2_put(ice, STAC946X_GENERAL_PURPOSE, new); +stac9460_2_put(ice, STAC946X_GENERAL_PURPOSE, new); } return change; } < at >< at > -443,7 +443,7 < at >< at > static struct snd_kcontrol_new stac9640_controls[] __devinitdata = { .get = stac9460_adc_vol_get, .put = stac9460_adc_vol_put, -} +} }; < at >< at > -470,7 +470,7 < at >< at > static int __devinit wtm_init(struct snd_ice1712 *ice) (unsigned short)-1 }; unsigned short *p; - + /*WTM 192M*/ ice->num_total_dacs = 8; ice->num_total_adcs = 4; diff --git a/sound/pci/ice1712/wtm.h b/sound/pci/ice1712/wtm.h index 03a394e..423c1a2 100644 --- a/sound/pci/ice1712/wtm.h +++ b/sound/pci/ice1712/wtm.h < at >< at > -10,8 +10,8 < at >< at > */ #defineAK4114_ADDR0x20/*S/PDIF receiver*/ -#define STAC9460_I2C_ADDR0x54/* ADC*2 | DAC*6 */ -#define STAC9460_2_I2C_ADDR0x56/* ADC|DAC *2 */ +#define STAC9460_I2C_ADDR0x54/* ADC*2 | DAC*6 */ +#define STAC9460_2_I2C_ADDR0x56/* ADC|DAC *2 */ extern struct snd_ice1712_card_info snd_vt1724_wtm_cards[];