linux/alsa/hammerfall.c

   1 /*
   2     Copyright (C) 2001 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id: hammerfall.c,v 1.3 2005/09/29 14:51:59 letz Exp $
  19 */
  20
  21 #include "hardware.h"
  22 #include "alsa_driver.h"
  23 #include "hammerfall.h"
  24 #include "JackError.h"
  25
  26 #define FALSE 0
  27 #define TRUE 1
  28
  29 /* Set this to 1 if you want this compile error:
  30  *   warning: `hammerfall_monitor_controls' defined but not used */
  31 #define HAMMERFALL_MONITOR_CONTROLS 0
  32
  33 static void
  34 set_control_id (snd_ctl_elem_id_t *ctl, const char *name)
  35 {
  36         snd_ctl_elem_id_set_name (ctl, name);
  37         snd_ctl_elem_id_set_numid (ctl, 0);
  38         snd_ctl_elem_id_set_interface (ctl, SND_CTL_ELEM_IFACE_MIXER);
  39         snd_ctl_elem_id_set_device (ctl, 0);
  40         snd_ctl_elem_id_set_subdevice (ctl, 0);
  41         snd_ctl_elem_id_set_index (ctl, 0);
  42 }
  43
  44 #if HAMMERFALL_MONITOR_CONTROLS
  45 static void
  46 hammerfall_broadcast_channel_status_change (hammerfall_t *h, int lock, int sync, channel_t lowchn, channel_t highchn)
  47
  48 {
  49         channel_t chn;
  50         ClockSyncStatus status = 0;
  51
  52         if (lock) {
  53                 status |= Lock;
  54         } else {
  55                 status |= NoLock;
  56         }
  57
  58         if (sync) {
  59                 status |= Sync;
  60         } else {
  61                 status |= NoSync;
  62         }
  63
  64         for (chn = lowchn; chn < highchn; chn++) {
  65                 alsa_driver_set_clock_sync_status (h->driver, chn, status);
  66         }
  67 }
  68
  69 static void
  70 hammerfall_check_sync_state (hammerfall_t *h, int val, int adat_id)
  71
  72 {
  73         int lock;
  74         int sync;
  75
  76         /* S/PDIF channel is always locked and synced, but we only
  77            need tell people once that this is TRUE.
  78
  79            XXX - maybe need to make sure that the rate matches our
  80            idea of the current rate ?
  81         */
  82
  83         if (!h->said_that_spdif_is_fine) {
  84                 ClockSyncStatus status;
  85
  86                 status = Lock|Sync;
  87
  88                 /* XXX broken! fix for hammerfall light ! */
  89
  90                 alsa_driver_set_clock_sync_status (h->driver, 24, status);
  91                 alsa_driver_set_clock_sync_status (h->driver, 25, status);
  92
  93                 h->said_that_spdif_is_fine = TRUE;
  94         }
  95
  96         lock = (val & 0x1) ? TRUE : FALSE;
  97         sync = (val & 0x2) ? TRUE : FALSE;
  98
  99         if (h->lock_status[adat_id] != lock ||
 100             h->sync_status[adat_id] != sync) {
 101                 hammerfall_broadcast_channel_status_change (h, lock, sync, adat_id*8, (adat_id*8)+8);
 102         }
 103
 104         h->lock_status[adat_id] = lock;
 105         h->sync_status[adat_id] = sync;
 106 }
 107
 108 static void
 109 hammerfall_check_sync (hammerfall_t *h, snd_ctl_elem_value_t *ctl)
 110
 111 {
 112         const char *name;
 113         int val;
 114         snd_ctl_elem_id_t *ctl_id;
 115
 116         jack_info ("check sync");
 117
 118         snd_ctl_elem_id_alloca (&ctl_id);
 119         snd_ctl_elem_value_get_id (ctl, ctl_id);
 120
 121         name = snd_ctl_elem_id_get_name (ctl_id);
 122
 123         if (strcmp (name, "ADAT1 Sync Check") == 0) {
 124                 val = snd_ctl_elem_value_get_enumerated (ctl, 0);
 125                 hammerfall_check_sync_state (h, val, 0);
 126         } else if (strcmp (name, "ADAT2 Sync Check") == 0) {
 127                 val = snd_ctl_elem_value_get_enumerated (ctl, 0);
 128                 hammerfall_check_sync_state (h, val, 1);
 129         } else if (strcmp (name, "ADAT3 Sync Check") == 0) {
 130                 val = snd_ctl_elem_value_get_enumerated (ctl, 0);
 131                 hammerfall_check_sync_state (h, val, 2);
 132         } else {
 133                 jack_error ("Hammerfall: unknown control \"%s\"", name);
 134         }
 135 }
 136 #endif /* HAMMERFALL_MONITOR_CONTROLS */
 137
 138 static int
 139 hammerfall_set_input_monitor_mask (jack_hardware_t *hw, unsigned long mask)
 140 {
 141         hammerfall_t *h = (hammerfall_t *) hw->private_hw;
 142         snd_ctl_elem_value_t *ctl;
 143         snd_ctl_elem_id_t *ctl_id;
 144         int err;
 145         int i;
 146
 147         snd_ctl_elem_value_alloca (&ctl);
 148         snd_ctl_elem_id_alloca (&ctl_id);
 149         set_control_id (ctl_id, "Channels Thru");
 150         snd_ctl_elem_value_set_id (ctl, ctl_id);
 151
 152         for (i = 0; i < 26; i++) {
 153                 snd_ctl_elem_value_set_integer (ctl, i, (mask & (1<<i)) ? 1 : 0);
 154         }
 155
 156         if ((err = snd_ctl_elem_write (h->driver->ctl_handle, ctl)) != 0) {
 157                 jack_error ("ALSA/Hammerfall: cannot set input monitoring (%s)", snd_strerror (err));
 158                 return -1;
 159         }
 160
 161         hw->input_monitor_mask = mask;
 162
 163         return 0;
 164 }
 165
 166 static int
 167 hammerfall_change_sample_clock (jack_hardware_t *hw, SampleClockMode mode)
 168 {
 169         hammerfall_t *h = (hammerfall_t *) hw->private_hw;
 170         snd_ctl_elem_value_t *ctl;
 171         snd_ctl_elem_id_t *ctl_id;
 172         int err;
 173
 174         snd_ctl_elem_value_alloca (&ctl);
 175         snd_ctl_elem_id_alloca (&ctl_id);
 176         set_control_id (ctl_id, "Sync Mode");
 177         snd_ctl_elem_value_set_id (ctl, ctl_id);
 178
 179         switch (mode) {
 180         case AutoSync:
 181                 snd_ctl_elem_value_set_enumerated (ctl, 0, 0);
 182                 break;
 183         case ClockMaster:
 184                 snd_ctl_elem_value_set_enumerated (ctl, 0, 1);
 185                 break;
 186         case WordClock:
 187                 snd_ctl_elem_value_set_enumerated (ctl, 0, 2);
 188                 break;
 189         }
 190
 191         if ((err = snd_ctl_elem_write (h->driver->ctl_handle, ctl)) < 0) {
 192                 jack_error ("ALSA-Hammerfall: cannot set clock mode");
 193         }
 194
 195         return 0;
 196 }
 197
 198 static void
 199 hammerfall_release (jack_hardware_t *hw)
 200
 201 {
 202         hammerfall_t *h = (hammerfall_t *) hw->private_hw;
 203         void *status;
 204
 205         if (h == 0) {
 206                 return;
 207         }
 208
 209     if (h->monitor_thread) {
 210         pthread_cancel (h->monitor_thread);
 211         pthread_join (h->monitor_thread, &status);
 212     }
 213
 214         free (h);
 215 }
 216
 217 #if HAMMERFALL_MONITOR_CONTROLS
 218 static void *
 219 hammerfall_monitor_controls (void *arg)
 220 {
 221         jack_hardware_t *hw = (jack_hardware_t *) arg;
 222         hammerfall_t *h = (hammerfall_t *) hw->private_hw;
 223         snd_ctl_elem_id_t *switch_id[3];
 224         snd_ctl_elem_value_t *sw[3];
 225
 226         pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 227
 228         snd_ctl_elem_id_malloc (&switch_id[0]);
 229         snd_ctl_elem_id_malloc (&switch_id[1]);
 230         snd_ctl_elem_id_malloc (&switch_id[2]);
 231
 232         snd_ctl_elem_value_malloc (&sw[0]);
 233         snd_ctl_elem_value_malloc (&sw[1]);
 234         snd_ctl_elem_value_malloc (&sw[2]);
 235
 236         set_control_id (switch_id[0], "ADAT1 Sync Check");
 237         set_control_id (switch_id[1], "ADAT2 Sync Check");
 238         set_control_id (switch_id[2], "ADAT3 Sync Check");
 239
 240         snd_ctl_elem_value_set_id (sw[0], switch_id[0]);
 241         snd_ctl_elem_value_set_id (sw[1], switch_id[1]);
 242         snd_ctl_elem_value_set_id (sw[2], switch_id[2]);
 243
 244         while (1) {
 245                 if (snd_ctl_elem_read (h->driver->ctl_handle, sw[0])) {
 246                         jack_error ("cannot read control switch 0 ...");
 247                 }
 248                 hammerfall_check_sync (h, sw[0]);
 249
 250                 if (snd_ctl_elem_read (h->driver->ctl_handle, sw[1])) {
 251                         jack_error ("cannot read control switch 0 ...");
 252                 }
 253                 hammerfall_check_sync (h, sw[1]);
 254
 255                 if (snd_ctl_elem_read (h->driver->ctl_handle, sw[2])) {
 256                         jack_error ("cannot read control switch 0 ...");
 257                 }
 258                 hammerfall_check_sync (h, sw[2]);
 259
 260                 if (nanosleep (&h->monitor_interval, 0)) {
 261                         break;
 262                 }
 263         }
 264
 265         pthread_exit (0);
 266 }
 267 #endif /* HAMMERFALL_MONITOR_CONTROLS */
 268
 269 jack_hardware_t *
 270 jack_alsa_hammerfall_hw_new (alsa_driver_t *driver)
 271 {
 272         jack_hardware_t *hw;
 273         hammerfall_t *h;
 274
 275         hw = (jack_hardware_t *) malloc (sizeof (jack_hardware_t));
 276
 277         hw->capabilities = Cap_HardwareMonitoring|Cap_AutoSync|Cap_WordClock|Cap_ClockMaster|Cap_ClockLockReporting;
 278         hw->input_monitor_mask = 0;
 279         hw->private_hw = 0;
 280
 281         hw->set_input_monitor_mask = hammerfall_set_input_monitor_mask;
 282         hw->change_sample_clock = hammerfall_change_sample_clock;
 283         hw->release = hammerfall_release;
 284
 285         h = (hammerfall_t *) malloc (sizeof (hammerfall_t));
 286
 287         h->lock_status[0] = FALSE;
 288         h->sync_status[0] = FALSE;
 289         h->lock_status[1] = FALSE;
 290         h->sync_status[1] = FALSE;
 291         h->lock_status[2] = FALSE;
 292         h->sync_status[2] = FALSE;
 293         h->said_that_spdif_is_fine = FALSE;
 294         h->driver = driver;
 295
 296         h->monitor_interval.tv_sec = 1;
 297         h->monitor_interval.tv_nsec = 0;
 298
 299         hw->private_hw = h;
 300
 301 #if 0
 302         if (pthread_create (&h->monitor_thread, 0, hammerfall_monitor_controls, hw)) {
 303                 jack_error ("ALSA/Hammerfall: cannot create sync monitor thread");
 304         }
 305 #endif
 306
 307         return hw;
 308 }