← Back to branch summary

~ubuntu-branches/ubuntu/wily/libffado/wily

« back to all changes in this revision

Viewing changes to src/rme/fireface_hw.cpp

  • Committer: Package Import Robot
  • Author(s): Artem Popov
  • Date: 2013-01-26 14:55:38 UTC
  • mfrom: (8.1.11 experimental)
  • Revision ID: package-import@ubuntu.com-20130126145538-4we9vsu1ra1d7mgh
Tags: 2.1.0+svn2240-1ubuntu1
https://launchpad.net/bugs/1105818
* Merge with Debian (LP: #1105818); remaining changes:
  - Build using dh_python2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rme/fireface_hw.cpp
60
60
{
61
61
    signed int ret = 0;
62
62
    signed int src, dest;
63
 
    signed int n_channels = (m_rme_model==RME_MODEL_FIREFACE400)?
64
 
                   RME_FF400_MAX_CHANNELS:RME_FF800_MAX_CHANNELS;
 
63
    signed int n_channels;
 
64
 
 
65
    switch (m_rme_model) {
 
66
        case RME_MODEL_FIREFACE400: n_channels = RME_FF400_MAX_CHANNELS; break;
 
67
        case RME_MODEL_FIREFACE800: n_channels = RME_FF800_MAX_CHANNELS; break;
 
68
        default:
 
69
          debugOutput(DEBUG_LEVEL_ERROR, "unknown model %d\n", m_rme_model);
 
70
          return -1;
 
71
    }
65
72
 
66
73
    // Initialises the device's settings structure to a known state and then
67
74
    // sets the hardware to reflect this state.
328
335
      data[0] |= CR0_PHANTOM_MIC0;
329
336
    if (sw_settings->mic_phantom[1])
330
337
      data[0] |= CR0_PHANTOM_MIC1;
331
 
    if (m_rme_model == RME_MODEL_FIREFACE800) {
332
 
        if (sw_settings->mic_phantom[2])
333
 
            data[0] |= CR0_FF800_PHANTOM_MIC9;
334
 
        if (sw_settings->mic_phantom[3])
335
 
            data[0] |= CR0_FF800_PHANTOM_MIC10;
336
 
    } else {
337
 
        if (sw_settings->ff400_input_pad[0])
338
 
            data[0] |= CR0_FF400_CH3_PAD;
339
 
        if (sw_settings->ff400_input_pad[1])
340
 
            data[0] |= CR0_FF400_CH4_PAD;
 
338
    switch (m_rme_model) {
 
339
        case RME_MODEL_FIREFACE800:
 
340
            if (sw_settings->mic_phantom[2])
 
341
                data[0] |= CR0_FF800_PHANTOM_MIC9;
 
342
            if (sw_settings->mic_phantom[3])
 
343
                data[0] |= CR0_FF800_PHANTOM_MIC10;
 
344
            break;
 
345
        case RME_MODEL_FIREFACE400:
 
346
            if (sw_settings->ff400_input_pad[0])
 
347
                data[0] |= CR0_FF400_CH3_PAD;
 
348
            if (sw_settings->ff400_input_pad[1])
 
349
                data[0] |= CR0_FF400_CH4_PAD;
 
350
            break;
 
351
        default:
 
352
            break;
341
353
    }
342
354
 
343
355
    /* Phones level */
399
411
    // the same bit controls the channel 4 "instrument" option.
400
412
    if (m_rme_model == RME_MODEL_FIREFACE800) {
401
413
        data[0] |= (sw_settings->filter) ? CR0_FF800_FILTER_FPGA : 0;
402
 
    } else {
 
414
    } else
 
415
    if (m_rme_model == RME_MODEL_FIREFACE400) {
403
416
        data[0] |= (sw_settings->ff400_instr_input[1]) ? CR0_FF400_CH4_INSTR : 0;
404
417
    }
405
418
 
431
444
            data[0] |= CR0_FF800_DRIVE_FPGA; // FPGA LED control
432
445
        else
433
446
            data[1] |= CR1_INSTR_DRIVE;      // CPLD
434
 
    } else {
 
447
    } else 
 
448
    if (m_rme_model == RME_MODEL_FIREFACE400) {
435
449
        data[0] |= (sw_settings->ff400_instr_input[0]) ? CR0_FF400_CH3_INSTR : 0;
436
450
    }
437
451
 
477
491
    debugOutput(DEBUG_LEVEL_VERBOSE, "set hardware registers: 0x%08x 0x%08x 0x%08x\n",
478
492
      data[0], data[1], data[2]);
479
493
 
480
 
    conf_reg = (m_rme_model==RME_MODEL_FIREFACE800)?RME_FF800_CONF_REG:RME_FF400_CONF_REG;
 
494
    switch (m_rme_model) {
 
495
        case RME_MODEL_FIREFACE800: conf_reg = RME_FF800_CONF_REG; break;
 
496
        case RME_MODEL_FIREFACE400: conf_reg = RME_FF400_CONF_REG; break;
 
497
        default:
 
498
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
499
            return -1;
 
500
    }
481
501
    if (writeBlock(conf_reg, data, 3) != 0)
482
502
        return -1;
483
503
 
496
516
    quadlet_t buf[4];
497
517
    signed int i;
498
518
 
499
 
    // The Fireface 400 can't have the TCO fitted
500
 
    if (m_rme_model==RME_MODEL_FIREFACE400)
 
519
    // Only the Fireface 800 can have the TCO fitted
 
520
    if (m_rme_model != RME_MODEL_FIREFACE800)
501
521
        return -1;
502
522
 
503
523
    if (readBlock(RME_FF_TCO_READ_REG, buf, 4) != 0)
531
551
    if (size < 4)
532
552
        return -1;
533
553
 
534
 
    // Don't bother trying to write if the device is a FF400 since the TCO
535
 
    // can't be fitted to this device.
536
 
    if (m_rme_model==RME_MODEL_FIREFACE400)
 
554
    // Don't bother trying to write if the device is not a FF800 since the
 
555
    // TCO can only be fitted to a FF800.
 
556
    if (m_rme_model != RME_MODEL_FIREFACE800)
537
557
        return -1;
538
558
 
539
559
    if (writeBlock(RME_FF_TCO_WRITE_REG, tco_data, 4) != 0)
698
718
    if (freq < MIN_SPEED || freq > MAX_SPEED)
699
719
        return -1;
700
720
 
701
 
    if (m_rme_model == RME_MODEL_FIREFACE400)
702
 
        ret = writeRegister(RME_FF400_STREAM_SRATE, freq);
703
 
    else
704
 
        ret = writeRegister(RME_FF800_STREAM_SRATE, freq);
705
 
 
 
721
    switch (m_rme_model) {
 
722
        case RME_MODEL_FIREFACE400:
 
723
            ret = writeRegister(RME_FF400_STREAM_SRATE, freq); break;
 
724
        case RME_MODEL_FIREFACE800:
 
725
            ret = writeRegister(RME_FF800_STREAM_SRATE, freq); break;
 
726
        default:
 
727
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
728
            ret = -1;
 
729
    }
706
730
    if (ret == 0)
707
731
        dev_config->hardware_freq = freq;
708
732
 
733
757
    if (m_rme_model == RME_MODEL_FIREFACE400) {
734
758
        addr = RME_FF400_STREAM_INIT_REG;
735
759
        size = RME_FF400_STREAM_INIT_SIZE;
736
 
    } else {
 
760
    } else 
 
761
    if (m_rme_model == RME_MODEL_FIREFACE800) {
737
762
        addr = RME_FF800_STREAM_INIT_REG;
738
763
        size = RME_FF800_STREAM_INIT_SIZE;
 
764
    } else {
 
765
        debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
766
        return -1;
739
767
    }
740
768
 
741
769
    return writeBlock(addr, buf, size);
756
784
        if (m_rme_model == RME_MODEL_FIREFACE400) {
757
785
            addr = RME_FF400_STREAM_START_REG;
758
786
            data |= (listen_channel << 5);
759
 
        } else {
 
787
        } else 
 
788
        if (m_rme_model == RME_MODEL_FIREFACE800) {
760
789
            addr = RME_FF800_STREAM_START_REG;
761
790
            if (speed800)
762
791
                data |= RME_FF800_STREAMING_SPEED_800; // Flag 800 Mbps speed
 
792
        } else {
 
793
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
794
            return -1;
763
795
        }
764
796
 
765
797
debugOutput(DEBUG_LEVEL_VERBOSE, "start 0x%016llx data: %08x\n", addr, data);
790
822
        if (m_rme_model == RME_MODEL_FIREFACE400) {
791
823
            addr = RME_FF400_STREAM_END_REG;
792
824
            size = RME_FF400_STREAM_END_SIZE;
793
 
        } else {
 
825
        } else 
 
826
        if (m_rme_model == RME_MODEL_FIREFACE800) {
794
827
            addr = RME_FF800_STREAM_END_REG;
795
828
            size = RME_FF800_STREAM_END_SIZE;
 
829
        } else {
 
830
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
831
            return -1;
796
832
        }
797
833
 
798
834
        ret = writeBlock(addr, buf, size);
864
900
    signed int ram_output_block_size;
865
901
    unsigned int ram_addr;
866
902
 
867
 
    n_channels = (m_rme_model==RME_MODEL_FIREFACE400)?
868
 
        RME_FF400_MAX_CHANNELS:RME_FF800_MAX_CHANNELS;
 
903
    if (m_rme_model == RME_MODEL_FIREFACE400) {
 
904
        n_channels = RME_FF400_MAX_CHANNELS;
 
905
        ram_output_block_size = 0x48;
 
906
    } else
 
907
    if (m_rme_model == RME_MODEL_FIREFACE800) {
 
908
        n_channels = RME_FF800_MAX_CHANNELS;
 
909
        ram_output_block_size = 0x80;
 
910
    } else {
 
911
        debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
912
        return -1;
 
913
    }
 
914
 
869
915
    if (src_channel>n_channels || dest_channel>n_channels)
870
916
        return -1;
871
917
    if (abs(val)>0x10000)
872
918
        return -1;
873
919
 
874
 
    if (m_rme_model == RME_MODEL_FIREFACE400) {
875
 
        ram_output_block_size = 0x48;
876
 
    } else {
877
 
        ram_output_block_size = 0x80;
878
 
    }
879
 
 
880
920
    ram_addr = RME_FF_MIXER_RAM;
881
921
    switch (ctype) {
882
922
        case RME_FF_MM_INPUT:
886
926
                 ram_addr += ram_output_block_size;
887
927
            break;
888
928
        case RME_FF_MM_OUTPUT:
889
 
            ram_addr += 0x0f80 + 4*src_channel;
 
929
            if (m_rme_model == RME_MODEL_FIREFACE400)
 
930
                ram_addr += 0x0f80;
 
931
            else
 
932
                ram_addr += 0x1f80;
 
933
            ram_addr += 4*src_channel;
890
934
            break;
891
935
    }
892
936
 
918
962
// this could be extended to allow individual channel control.
919
963
    quadlet_t buf[28];
920
964
    signed int i;
921
 
    signed int n_channels = (m_rme_model==RME_MODEL_FIREFACE400)?
922
 
        RME_FF400_MAX_CHANNELS:RME_FF800_MAX_CHANNELS;
 
965
    signed int n_channels;
 
966
    
 
967
    if (m_rme_model == RME_MODEL_FIREFACE400)
 
968
        n_channels = RME_FF400_MAX_CHANNELS;
 
969
    else
 
970
    if (m_rme_model == RME_MODEL_FIREFACE800)
 
971
        n_channels = RME_FF800_MAX_CHANNELS;
 
972
    else {
 
973
        debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
974
        return -1;
 
975
    }
923
976
 
924
977
    i = 0;
925
978
    if (chan < 0) {