← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rme/fireface_flash.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_flash.cpp
47
47
            status = readRegister(RME_FF400_FLASH_STAT_REG);
48
48
            if (status == 0)
49
49
                break;
50
 
        } else {
 
50
        } else 
 
51
        if (m_rme_model == RME_MODEL_FIREFACE800) {
51
52
            status = readRegister(RME_FF_STATUS_REG1);
52
53
            if (status & 0x40000000)
53
54
                break;
 
55
        } else {
 
56
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
57
            return -1;
54
58
        }
55
59
    }
56
60
 
138
142
                return -1;
139
143
        }
140
144
        data = 0;
141
 
    } else {
 
145
    } else 
 
146
    if (m_rme_model == RME_MODEL_FIREFACE400) {
142
147
        addr = RME_FF400_FLASH_CMD_REG;
143
148
        switch (flags) {
144
149
            case RME_FF_FLASH_ERASE_VOLUME:
151
156
                debugOutput(DEBUG_LEVEL_WARNING, "unknown flag %d\n", flags);
152
157
                return -1;
153
158
        }
 
159
    } else {
 
160
        debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
161
        return -1;
154
162
    }
155
163
 
156
164
    err |= writeRegister(addr, data);
213
221
    FF_device_flash_settings_t hw_settings;
214
222
    signed int i, err = 0;
215
223
    unsigned int rev;
 
224
    long long int addr;
216
225
 
217
226
    // FIXME: the debug output in this function is mostly for testing at
218
227
    // present.
225
234
    }
226
235
 
227
236
    // Read settings flash ram block
228
 
    err = read_flash(m_rme_model==RME_MODEL_FIREFACE800?
229
 
      RME_FF800_FLASH_SETTINGS_ADDR:RME_FF400_FLASH_SETTINGS_ADDR, 
230
 
        (quadlet_t *)&hw_settings, sizeof(hw_settings)/sizeof(uint32_t));
 
237
    if (m_rme_model == RME_MODEL_FIREFACE800)
 
238
        addr = RME_FF800_FLASH_SETTINGS_ADDR;
 
239
    else
 
240
    if (m_rme_model == RME_MODEL_FIREFACE400)
 
241
        addr = RME_FF400_FLASH_SETTINGS_ADDR;
 
242
    else {
 
243
        debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
244
        return -1;
 
245
    }
 
246
    err = read_flash(addr, 
 
247
            (quadlet_t *)&hw_settings, sizeof(hw_settings)/sizeof(uint32_t));
 
248
 
231
249
    if (err != 0) {
232
250
        debugOutput(DEBUG_LEVEL_WARNING, "Error reading device flash settings: %d\n", i);
233
251
    } else {
254
272
        // appropriate.
255
273
        for (i=0; i<2; i++)
256
274
            settings->mic_phantom[i] = hw_settings.mic_phantom[i];
 
275
 
257
276
        if (m_rme_model == RME_MODEL_FIREFACE800) {
258
277
            for (i=2; i<4; i++)
259
278
                settings->mic_phantom[i] = hw_settings.mic_phantom[i];
260
 
        } else {
 
279
        } else 
 
280
        if (m_rme_model == RME_MODEL_FIREFACE400) {
261
281
            // TODO: confirm this is true
262
282
            for (i=2; i<4; i++)
263
283
                settings->ff400_input_pad[i-2] = hw_settings.mic_phantom[i];
 
284
        } else {
 
285
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
286
            return -1;
264
287
        }
 
288
 
265
289
        settings->spdif_input_mode = hw_settings.spdif_input_mode;
266
290
        settings->spdif_output_emphasis = hw_settings.spdif_output_emphasis;
267
291
        settings->spdif_output_pro = hw_settings.spdif_output_pro;
277
301
        if (m_rme_model == RME_MODEL_FIREFACE800) {
278
302
            settings->filter = hw_settings.filter;
279
303
            settings->fuzz = hw_settings.fuzz;
280
 
        } else {
 
304
        } else 
 
305
        if (m_rme_model == RME_MODEL_FIREFACE400) {
281
306
            // TODO: confirm this is true
282
307
            settings->ff400_instr_input[0] = hw_settings.fuzz;
283
308
            settings->ff400_instr_input[1] = hw_settings.filter;
295
320
        // used in the flash by other operating systems.
296
321
        if (m_rme_model == RME_MODEL_FIREFACE400)
297
322
            settings->phones_level = hw_settings.mic_plug_select[0] + 1;
298
 
        else {
 
323
        else 
 
324
        if (m_rme_model == RME_MODEL_FIREFACE800) {
299
325
            settings->input_opt[0] = hw_settings.instrument_plug_select + 1;
300
326
            settings->input_opt[1] = hw_settings.mic_plug_select[0] + 1;
301
327
            settings->input_opt[2] = hw_settings.mic_plug_select[1] + 1;
314
340
{
315
341
// Read mixer volume flash ram block
316
342
quadlet_t buf[0x800];
 
343
quadlet_t addr = 0;
317
344
  memset(buf, 0xdb, sizeof(buf));
318
 
  i = read_flash(m_rme_model==RME_MODEL_FIREFACE800?
319
 
        RME_FF800_FLASH_MIXER_VOLUME_ADDR:RME_FF400_FLASH_MIXER_VOLUME_ADDR, buf, 32);
320
 
fprintf(stderr,"result=%d\n", i);
321
 
for (i=0; i<32; i++) {
322
 
  fprintf(stderr, "%d: 0x%08x\n", i, buf[i]);
323
 
}
 
345
  if (m_rme_model == RME_MODEL_FIREFACE400)
 
346
      addr = RME_FF400_FLASH_MIXER_VOLUME_ADDR;
 
347
  else
 
348
  if (m_rme_model == RME_MODEL_FIREFACE800)
 
349
      addr = RME_FF800_FLASH_MIXER_VOLUME_ADDR;
 
350
  if (addr != 0) {
 
351
    i = read_flash(addr, buf, 32);
 
352
    fprintf(stderr,"result=%d\n", i);
 
353
    for (i=0; i<32; i++) {
 
354
      fprintf(stderr, "%d: 0x%08x\n", i, buf[i]);
 
355
    }
 
356
  }
324
357
}
325
358
#endif
326
359
 
377
410
    // read_device_flash_settings().
378
411
    if (m_rme_model == RME_MODEL_FIREFACE400)
379
412
        hw_settings.mic_plug_select[0] = settings->phones_level - 1;
380
 
    else {
 
413
    else 
 
414
    if (m_rme_model == RME_MODEL_FIREFACE800) {
381
415
        hw_settings.instrument_plug_select = settings->input_opt[0] - 1;
382
416
        hw_settings.mic_plug_select[0] = settings->input_opt[1] - 1;
383
417
        hw_settings.mic_plug_select[1] = settings->input_opt[2] - 1;
388
422
    if (err != 0)
389
423
        debugOutput(DEBUG_LEVEL_WARNING, "Error erasing settings flash block: %d\n", i);
390
424
    else {
391
 
        err = write_flash(m_rme_model==RME_MODEL_FIREFACE800?
392
 
                  RME_FF800_FLASH_SETTINGS_ADDR:RME_FF400_FLASH_SETTINGS_ADDR,
 
425
        long long int addr;
 
426
        if (m_rme_model == RME_MODEL_FIREFACE800)
 
427
            addr = RME_FF800_FLASH_SETTINGS_ADDR;
 
428
        else
 
429
        if (m_rme_model == RME_MODEL_FIREFACE400)
 
430
            addr = RME_FF400_FLASH_SETTINGS_ADDR;
 
431
        else {
 
432
            debugOutput(DEBUG_LEVEL_ERROR, "unimplemented model %d\n", m_rme_model);
 
433
            return -1;
 
434
        }
 
435
        err = write_flash(addr, 
393
436
                  (quadlet_t *)&hw_settings, sizeof(hw_settings)/sizeof(uint32_t));
394
437
 
395
438
        if (err != 0)