LXR linux/sound/firewire/bebob/bebob

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * bebob_focusrite.c - a part of driver for BeBoB based devices
   4 *
   5 * Copyright (c) 2013-2014 Takashi Sakamoto
   6 */
   7
   8#include "./bebob.h"
   9
  10#define ANA_IN  "Analog In"
  11#define DIG_IN  "Digital In"
  12#define ANA_OUT "Analog Out"
  13#define DIG_OUT "Digital Out"
  14#define STM_IN  "Stream In"
  15
  16#define SAFFIRE_ADDRESS_BASE                    0x000100000000ULL
  17
  18#define SAFFIRE_OFFSET_CLOCK_SOURCE             0x00f8
  19#define SAFFIREPRO_OFFSET_CLOCK_SOURCE          0x0174
  20
  21/* whether sync to external device or not */
  22#define SAFFIRE_OFFSET_CLOCK_SYNC_EXT           0x013c
  23#define SAFFIRE_LE_OFFSET_CLOCK_SYNC_EXT        0x0432
  24#define SAFFIREPRO_OFFSET_CLOCK_SYNC_EXT        0x0164
  25
  26#define SAFFIRE_CLOCK_SOURCE_INTERNAL           0
  27#define SAFFIRE_CLOCK_SOURCE_SPDIF              1
  28
  29/* clock sources as returned from register of Saffire Pro 10 and 26 */
  30#define SAFFIREPRO_CLOCK_SOURCE_SELECT_MASK     0x000000ff
  31#define SAFFIREPRO_CLOCK_SOURCE_DETECT_MASK     0x0000ff00
  32#define SAFFIREPRO_CLOCK_SOURCE_INTERNAL        0
  33#define SAFFIREPRO_CLOCK_SOURCE_SKIP            1 /* never used on hardware */
  34#define SAFFIREPRO_CLOCK_SOURCE_SPDIF           2
  35#define SAFFIREPRO_CLOCK_SOURCE_ADAT1           3 /* not used on s.pro. 10 */
  36#define SAFFIREPRO_CLOCK_SOURCE_ADAT2           4 /* not used on s.pro. 10 */
  37#define SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK       5
  38#define SAFFIREPRO_CLOCK_SOURCE_COUNT           6
  39
  40/* S/PDIF, ADAT1, ADAT2 is enabled or not. three quadlets */
  41#define SAFFIREPRO_ENABLE_DIG_IFACES            0x01a4
  42
  43/* saffirepro has its own parameter for sampling frequency */
  44#define SAFFIREPRO_RATE_NOREBOOT                0x01cc
  45/* index is the value for this register */
  46static const unsigned int rates[] = {
  47        [0] = 0,
  48        [1] = 44100,
  49        [2] = 48000,
  50        [3] = 88200,
  51        [4] = 96000,
  52        [5] = 176400,
  53        [6] = 192000
  54};
  55
  56/* saffire(no label)/saffire LE has metering */
  57#define SAFFIRE_OFFSET_METER                    0x0100
  58#define SAFFIRE_LE_OFFSET_METER                 0x0168
  59
  60static inline int
  61saffire_read_block(struct snd_bebob *bebob, u64 offset,
  62                   u32 *buf, unsigned int size)
  63{
  64        unsigned int i;
  65        int err;
  66        __be32 *tmp = (__be32 *)buf;
  67
  68        err =  snd_fw_transaction(bebob->unit, TCODE_READ_BLOCK_REQUEST,
  69                                  SAFFIRE_ADDRESS_BASE + offset,
  70                                  tmp, size, 0);
  71        if (err < 0)
  72                goto end;
  73
  74        for (i = 0; i < size / sizeof(u32); i++)
  75                buf[i] = be32_to_cpu(tmp[i]);
  76end:
  77        return err;
  78}
  79
  80static inline int
  81saffire_read_quad(struct snd_bebob *bebob, u64 offset, u32 *value)
  82{
  83        int err;
  84        __be32 tmp;
  85
  86        err = snd_fw_transaction(bebob->unit, TCODE_READ_QUADLET_REQUEST,
  87                                 SAFFIRE_ADDRESS_BASE + offset,
  88                                 &tmp, sizeof(__be32), 0);
  89        if (err < 0)
  90                goto end;
  91
  92        *value = be32_to_cpu(tmp);
  93end:
  94        return err;
  95}
  96
  97static inline int
  98saffire_write_quad(struct snd_bebob *bebob, u64 offset, u32 value)
  99{
 100        __be32 data = cpu_to_be32(value);
 101
 102        return snd_fw_transaction(bebob->unit, TCODE_WRITE_QUADLET_REQUEST,
 103                                  SAFFIRE_ADDRESS_BASE + offset,
 104                                  &data, sizeof(__be32), 0);
 105}
 106
 107static const enum snd_bebob_clock_type saffirepro_10_clk_src_types[] = {
 108        SND_BEBOB_CLOCK_TYPE_INTERNAL,
 109        SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* S/PDIF */
 110        SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* Word Clock */
 111};
 112static const enum snd_bebob_clock_type saffirepro_26_clk_src_types[] = {
 113        SND_BEBOB_CLOCK_TYPE_INTERNAL,
 114        SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* S/PDIF */
 115        SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* ADAT1 */
 116        SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* ADAT2 */
 117        SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* Word Clock */
 118};
 119/* Value maps between registers and labels for SaffirePro 10/26. */
 120static const signed char saffirepro_clk_maps[][SAFFIREPRO_CLOCK_SOURCE_COUNT] = {
 121        /* SaffirePro 10 */
 122        [0] = {
 123                [SAFFIREPRO_CLOCK_SOURCE_INTERNAL]  =  0,
 124                [SAFFIREPRO_CLOCK_SOURCE_SKIP]      = -1, /* not supported */
 125                [SAFFIREPRO_CLOCK_SOURCE_SPDIF]     =  1,
 126                [SAFFIREPRO_CLOCK_SOURCE_ADAT1]     = -1, /* not supported */
 127                [SAFFIREPRO_CLOCK_SOURCE_ADAT2]     = -1, /* not supported */
 128                [SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK] =  2,
 129        },
 130        /* SaffirePro 26 */
 131        [1] = {
 132                [SAFFIREPRO_CLOCK_SOURCE_INTERNAL]  =  0,
 133                [SAFFIREPRO_CLOCK_SOURCE_SKIP]      = -1, /* not supported */
 134                [SAFFIREPRO_CLOCK_SOURCE_SPDIF]     =  1,
 135                [SAFFIREPRO_CLOCK_SOURCE_ADAT1]     =  2,
 136                [SAFFIREPRO_CLOCK_SOURCE_ADAT2]     =  3,
 137                [SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK] =  4,
 138        }
 139};
 140
 141static int
 142saffirepro_both_clk_freq_get(struct snd_bebob *bebob, unsigned int *rate)
 143{
 144        u32 id;
 145        int err;
 146
 147        err = saffire_read_quad(bebob, SAFFIREPRO_RATE_NOREBOOT, &id);
 148        if (err < 0)
 149                goto end;
 150        if (id >= ARRAY_SIZE(rates))
 151                err = -EIO;
 152        else
 153                *rate = rates[id];
 154end:
 155        return err;
 156}
 157static int
 158saffirepro_both_clk_freq_set(struct snd_bebob *bebob, unsigned int rate)
 159{
 160        u32 id;
 161
 162        for (id = 0; id < ARRAY_SIZE(rates); id++) {
 163                if (rates[id] == rate)
 164                        break;
 165        }
 166        if (id == ARRAY_SIZE(rates))
 167                return -EINVAL;
 168
 169        return saffire_write_quad(bebob, SAFFIREPRO_RATE_NOREBOOT, id);
 170}
 171
 172/*
 173 * query hardware for current clock source, return our internally
 174 * used clock index in *id, depending on hardware.
 175 */
 176static int
 177saffirepro_both_clk_src_get(struct snd_bebob *bebob, unsigned int *id)
 178{
 179        int err;
 180        u32 value;       /* clock source read from hw register */
 181        const signed char *map;
 182
 183        err = saffire_read_quad(bebob, SAFFIREPRO_OFFSET_CLOCK_SOURCE, &value);
 184        if (err < 0)
 185                goto end;
 186
 187        /* depending on hardware, use a different mapping */
 188        if (bebob->spec->clock->types == saffirepro_10_clk_src_types)
 189                map = saffirepro_clk_maps[0];
 190        else
 191                map = saffirepro_clk_maps[1];
 192
 193        /* In a case that this driver cannot handle the value of register. */
 194        value &= SAFFIREPRO_CLOCK_SOURCE_SELECT_MASK;
 195        if (value >= SAFFIREPRO_CLOCK_SOURCE_COUNT || map[value] < 0) {
 196                err = -EIO;
 197                goto end;
 198        }
 199
 200        *id = (unsigned int)map[value];
 201end:
 202        return err;
 203}
 204
 205const struct snd_bebob_spec saffire_le_spec;
 206static const enum snd_bebob_clock_type saffire_both_clk_src_types[] = {
 207        SND_BEBOB_CLOCK_TYPE_INTERNAL,
 208        SND_BEBOB_CLOCK_TYPE_EXTERNAL,
 209};
 210static int
 211saffire_both_clk_src_get(struct snd_bebob *bebob, unsigned int *id)
 212{
 213        int err;
 214        u32 value;
 215
 216        err = saffire_read_quad(bebob, SAFFIRE_OFFSET_CLOCK_SOURCE, &value);
 217        if (err >= 0)
 218                *id = 0xff & value;
 219
 220        return err;
 221};
 222static const char *const saffire_le_meter_labels[] = {
 223        ANA_IN, ANA_IN, DIG_IN,
 224        ANA_OUT, ANA_OUT, ANA_OUT, ANA_OUT,
 225        STM_IN, STM_IN
 226};
 227static const char *const saffire_meter_labels[] = {
 228        ANA_IN, ANA_IN,
 229        STM_IN, STM_IN, STM_IN, STM_IN, STM_IN,
 230};
 231static int
 232saffire_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size)
 233{
 234        const struct snd_bebob_meter_spec *spec = bebob->spec->meter;
 235        unsigned int channels;
 236        u64 offset;
 237        int err;
 238
 239        if (spec->labels == saffire_le_meter_labels)
 240                offset = SAFFIRE_LE_OFFSET_METER;
 241        else
 242                offset = SAFFIRE_OFFSET_METER;
 243
 244        channels = spec->num * 2;
 245        if (size < channels * sizeof(u32))
 246                return -EIO;
 247
 248        err = saffire_read_block(bebob, offset, buf, size);
 249        if (err >= 0 && spec->labels == saffire_le_meter_labels) {
 250                swap(buf[1], buf[3]);
 251                swap(buf[2], buf[3]);
 252                swap(buf[3], buf[4]);
 253
 254                swap(buf[7], buf[10]);
 255                swap(buf[8], buf[10]);
 256                swap(buf[9], buf[11]);
 257                swap(buf[11], buf[12]);
 258
 259                swap(buf[15], buf[16]);
 260        }
 261
 262        return err;
 263}
 264
 265static const struct snd_bebob_rate_spec saffirepro_both_rate_spec = {
 266        .get    = &saffirepro_both_clk_freq_get,
 267        .set    = &saffirepro_both_clk_freq_set,
 268};
 269/* Saffire Pro 26 I/O  */
 270static const struct snd_bebob_clock_spec saffirepro_26_clk_spec = {
 271        .num    = ARRAY_SIZE(saffirepro_26_clk_src_types),
 272        .types  = saffirepro_26_clk_src_types,
 273        .get    = &saffirepro_both_clk_src_get,
 274};
 275const struct snd_bebob_spec saffirepro_26_spec = {
 276        .clock  = &saffirepro_26_clk_spec,
 277        .rate   = &saffirepro_both_rate_spec,
 278        .meter  = NULL
 279};
 280/* Saffire Pro 10 I/O */
 281static const struct snd_bebob_clock_spec saffirepro_10_clk_spec = {
 282        .num    = ARRAY_SIZE(saffirepro_10_clk_src_types),
 283        .types  = saffirepro_10_clk_src_types,
 284        .get    = &saffirepro_both_clk_src_get,
 285};
 286const struct snd_bebob_spec saffirepro_10_spec = {
 287        .clock  = &saffirepro_10_clk_spec,
 288        .rate   = &saffirepro_both_rate_spec,
 289        .meter  = NULL
 290};
 291
 292static const struct snd_bebob_rate_spec saffire_both_rate_spec = {
 293        .get    = &snd_bebob_stream_get_rate,
 294        .set    = &snd_bebob_stream_set_rate,
 295};
 296static const struct snd_bebob_clock_spec saffire_both_clk_spec = {
 297        .num    = ARRAY_SIZE(saffire_both_clk_src_types),
 298        .types  = saffire_both_clk_src_types,
 299        .get    = &saffire_both_clk_src_get,
 300};
 301/* Saffire LE */
 302static const struct snd_bebob_meter_spec saffire_le_meter_spec = {
 303        .num    = ARRAY_SIZE(saffire_le_meter_labels),
 304        .labels = saffire_le_meter_labels,
 305        .get    = &saffire_meter_get,
 306};
 307const struct snd_bebob_spec saffire_le_spec = {
 308        .clock  = &saffire_both_clk_spec,
 309        .rate   = &saffire_both_rate_spec,
 310        .meter  = &saffire_le_meter_spec
 311};
 312/* Saffire */
 313static const struct snd_bebob_meter_spec saffire_meter_spec = {
 314        .num    = ARRAY_SIZE(saffire_meter_labels),
 315        .labels = saffire_meter_labels,
 316        .get    = &saffire_meter_get,
 317};
 318const struct snd_bebob_spec saffire_spec = {
 319        .clock  = &saffire_both_clk_spec,
 320        .rate   = &saffire_both_rate_spec,
 321        .meter  = &saffire_meter_spec
 322};
 323