Changeset 050d4fa in mainline

Timestamp:

2011-09-26T10:44:34Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

bde691c

Parents:

c7325dd6

Message:

sb16: Use new sb_mixer_t structure.

Location:

uspace/drv/audio/sb16

Files:

• mixer.c (modified) (3 diffs)
• mixer.h (modified) (1 diff)
• sb16.c (modified) (2 diffs)
• sb16.h (modified) (1 diff)

uspace/drv/audio/sb16/mixer.c

@@ -89 +89 @@
 };
 
-const char * mixer_type_to_str(mixer_type_t type)
+static void mixer_max_master_levels(sb_mixer_t *mixer)
+{
+        assert(mixer);
+        /* Set Master to maximum */
+        if (!mixer_get_control_item_count(mixer))
+                return;
+        unsigned levels = 0, channels = 0, current_level;
+        const char *name = NULL;
+        mixer_get_control_item_info(mixer, 0, &name, &channels, &levels);
+        unsigned channel = 0;
+        for (;channel < channels; ++channel) {
+                current_level =
+                    mixer_get_volume_level(mixer, 0, channel);
+                ddf_log_note("Setting %s channel %d to %d (%d).\n",
+                    name, channel, levels - 1, current_level);
+
+                mixer_set_volume_level(mixer, 0, channel, levels - 1);
+
+                current_level =
+                    mixer_get_volume_level(mixer, 0, channel);
+                ddf_log_note("%s channel %d set to %d.\n",
+                    name, channel, current_level);
+        }
+
+}
+/*----------------------------------------------------------------------------*/
+const char * mixer_type_str(mixer_type_t type)
 {
         static const char * names[] = {
@@ -100 +126 @@
 }
 /*----------------------------------------------------------------------------*/
-int mixer_init(sb16_regs_t *regs, mixer_type_t type)
-{
+int mixer_init(sb_mixer_t *mixer, sb16_regs_t *regs, mixer_type_t type)
+{
+        assert(mixer);
+        mixer->regs = regs;
+        mixer->type = type;
         if (type == SB_MIXER_UNKNOWN)
                 return ENOTSUP;
@@ -108 +137 @@
                 pio_write_8(&regs->mixer_address, CT_MIXER_RESET_ADDRESS);
                 pio_write_8(&regs->mixer_data, 1);
+                mixer_max_master_levels(mixer);
         }
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
-void mixer_load_volume_levels(sb16_regs_t *regs, mixer_type_t type)
-{
-        /* Set Master to maximum */
-        if (!mixer_get_control_item_count(type))
-                return;
-        unsigned levels = 0, channels = 0, current_level;
-        const char *name = NULL;
-        mixer_get_control_item_info(type, 0, &name, &channels, &levels);
-        unsigned channel = 0;
-        for (;channel < channels; ++channel) {
-                current_level =
-                    mixer_get_volume_level(regs, type, 0, channel);
-                ddf_log_note("Setting %s channel %d to %d (%d).\n",
-                    name, channel, levels - 1, current_level);
-
-                mixer_set_volume_level(regs, type, 0, channel, levels - 1);
-
-                current_level =
-                    mixer_get_volume_level(regs, type, 0, channel);
-                ddf_log_note("%s channel %d set to %d.\n",
-                    name, channel, current_level);
-        }
-
-}
-/*----------------------------------------------------------------------------*/
-void mixer_store_volume_levels(sb16_regs_t *regs, mixer_type_t type)
-{
-        /* No place to store the values. */
-}
-/*----------------------------------------------------------------------------*/
-int mixer_get_control_item_count(mixer_type_t type)
-{
-        return volume_table[type].count;
-}
-/*----------------------------------------------------------------------------*/
-int mixer_get_control_item_info(mixer_type_t type, unsigned index,
+int mixer_get_control_item_count(const sb_mixer_t *mixer)
+{
+        assert(mixer);
+        return volume_table[mixer->type].count;
+}
+/*----------------------------------------------------------------------------*/
+int mixer_get_control_item_info(const sb_mixer_t *mixer, unsigned index,
     const char** name, unsigned *channels, unsigned *levels)
 {
-        if (index > volume_table[type].count)
+        assert(mixer);
+        if (index > volume_table[mixer->type].count)
                 return ENOENT;
 
         if (name)
-                *name = volume_table[type].table[index].description;
+                *name = volume_table[mixer->type].table[index].description;
         if (channels)
-                *channels = volume_table[type].table[index].channels;
+                *channels = volume_table[mixer->type].table[index].channels;
         if (levels)
-                *levels = volume_table[type].table[index].volume_levels;
+                *levels = volume_table[mixer->type].table[index].volume_levels;
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
-int mixer_set_volume_level(sb16_regs_t *regs, mixer_type_t type,
+int mixer_set_volume_level(const sb_mixer_t *mixer,
     unsigned index, unsigned channel, unsigned level)
 {
-        if (type == SB_MIXER_UNKNOWN || type == SB_MIXER_NONE)
+        if (mixer->type == SB_MIXER_UNKNOWN || mixer->type == SB_MIXER_NONE)
                 return ENOTSUP;
-        if (index >= volume_table[type].count)
+        if (index >= volume_table[mixer->type].count)
                 return ENOENT;
-        if (level >= volume_table[type].table[index].volume_levels)
+        if (level >= volume_table[mixer->type].table[index].volume_levels)
                 return ENOTSUP;
-        if (channel >= volume_table[type].table[index].channels)
+        if (channel >= volume_table[mixer->type].table[index].channels)
                 return ENOENT;
 
-        const volume_item_t item = volume_table[type].table[index];
+        const volume_item_t item = volume_table[mixer->type].table[index];
         const uint8_t address = item.address + (item.same_reg ? 0 : channel);
-        pio_write_8(&regs->mixer_address, address);
+        pio_write_8(&mixer->regs->mixer_address, address);
         if (!item.same_reg) {
                 const uint8_t value = level << item.shift;
-                pio_write_8(&regs->mixer_data, value);
+                pio_write_8(&mixer->regs->mixer_data, value);
         } else {
                 /* Nasty stuff */
-                uint8_t value = pio_read_8(&regs->mixer_data);
+                uint8_t value = pio_read_8(&mixer->regs->mixer_data);
                 /* Remove value that is to be replaced register format is L:R*/
                 value &= (channel ? 0xf0 : 0x0f);
                 /* Add the new value */
                 value |= (level << item.shift) << (channel ? 0 : 4);
-                pio_write_8(&regs->mixer_data, value);
+                pio_write_8(&mixer->regs->mixer_data, value);
         }
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
-unsigned mixer_get_volume_level(sb16_regs_t *regs, mixer_type_t type,
-    unsigned index, unsigned channel)
-{
-        if (type == SB_MIXER_UNKNOWN
-            || type == SB_MIXER_NONE
-            || (index >= volume_table[type].count)
-            || (channel >= volume_table[type].table[index].channels))
+unsigned mixer_get_volume_level(const sb_mixer_t *mixer, unsigned index,
+    unsigned channel)
+{
+        assert(mixer);
+        if (mixer->type == SB_MIXER_UNKNOWN
+            || mixer->type == SB_MIXER_NONE
+            || (index >= volume_table[mixer->type].count)
+            || (channel >= volume_table[mixer->type].table[index].channels))
                 return 0;
 
-        const volume_item_t item = volume_table[type].table[index];
+        const volume_item_t item = volume_table[mixer->type].table[index];
         const uint8_t address = item.address + (item.same_reg ? 0 : channel);
-        pio_write_8(&regs->mixer_address, address);
+        pio_write_8(&mixer->regs->mixer_address, address);
         if (!item.same_reg) {
-                return pio_read_8(&regs->mixer_data) >> item.shift;
+                return pio_read_8(&mixer->regs->mixer_data) >> item.shift;
         } else {
                 const uint8_t value =
-                    pio_read_8(&regs->mixer_data) >> (channel ? 0 : 4);
+                    pio_read_8(&mixer->regs->mixer_data) >> (channel ? 0 : 4);
                 return value >> item.shift;
         }

uspace/drv/audio/sb16/mixer.h

@@ -45 +45 @@
 } mixer_type_t;
 
-const char * mixer_type_to_str(mixer_type_t type);
-int mixer_init(sb16_regs_t *regs, mixer_type_t type);
-void mixer_load_volume_levels(sb16_regs_t *regs, mixer_type_t type);
-void mixer_store_volume_levels(sb16_regs_t *regs, mixer_type_t type);
-int mixer_get_control_item_count(mixer_type_t type);
-int mixer_get_control_item_info(mixer_type_t type, unsigned index,
+typedef struct sb_mixer {
+        sb16_regs_t *regs;
+        mixer_type_t type;
+} sb_mixer_t;
+
+const char * mixer_type_str(mixer_type_t type);
+int mixer_init(sb_mixer_t *mixer, sb16_regs_t *regs, mixer_type_t type);
+int mixer_get_control_item_count(const sb_mixer_t *mixer);
+int mixer_get_control_item_info(const sb_mixer_t *mixer, unsigned index,
     const char** name, unsigned *channels, unsigned *levels);
-int mixer_set_volume_level(sb16_regs_t *regs, mixer_type_t type,
+int mixer_set_volume_level(const sb_mixer_t *mixer,
     unsigned item, unsigned channel, unsigned level);
-unsigned mixer_get_volume_level(sb16_regs_t *regs, mixer_type_t type,
+unsigned mixer_get_volume_level(const sb_mixer_t *mixer,
     unsigned item, unsigned channel);
 #endif

uspace/drv/audio/sb16/sb16.c

@@ -91 +91 @@
 
         /* Initialize mixer */
-        drv->mixer = mixer_type_by_dsp_version(
+        const mixer_type_t mixer_type = mixer_type_by_dsp_version(
             drv->dsp_version.major, drv->dsp_version.minor);
 
-        ret = mixer_init(drv->regs, drv->mixer);
+        ret = mixer_init(&drv->mixer, drv->regs, mixer_type);
         if (ret != EOK) {
                 ddf_log_error("Failed to initialize SB mixer: %s.\n",
@@ -100 +100 @@
                 return ret;
         }
-        mixer_load_volume_levels(drv->regs, drv->mixer);
-        ddf_log_note("Initialized mixer: %s.\n", mixer_type_to_str(drv->mixer));
+        ddf_log_note("Initialized mixer: %s.\n",
+            mixer_type_str(drv->mixer.type));
 
         return EOK;

uspace/drv/audio/sb16/sb16.h

@@ -49 +49 @@
                 uint8_t minor;
         } dsp_version;
-        mixer_type_t mixer;
+        sb_mixer_t mixer;
 } sb16_drv_t;