/* do we need this? --aij raw_insts_t * raw_insts_of_file(const char *filename) { //segs = NULL; raw_insts_t *ret = new raw_insts_t; asm_program_t *prog = new asm_program_t; bfd *abfd = initialize_bfd(filename); initialize_sections(abfd, prog); prog->functions = identify_functions(prog->sections, abfd); for(map<address_t, asm_function_t *>::const_iterator it = prog->functions.begin(); it != prog->functions.end(); it++){ asm_function_t *f = it->second; bfd_vma pc = f->start_addr; // Disassemble the function while(pc <= f->end_addr){ bfd_byte *ptr = get_ptr_to_instr(prog, pc); raw_inst_t *temp = new raw_inst_t; temp->length = instr->length; temp->bytes = ptr; temp->address = instr->address; ret->push_back(temp); pc += instr->length; } } return ret; } */ asm_program_t * disassemble_program(const char *filename) { asm_program_t *prog = new asm_program_t; //segs = NULL; bfd *abfd = initialize_bfd(filename); prog->abfd = abfd; initialize_sections(abfd, prog); prog->functions = identify_functions(prog->sections, abfd); unsigned long total_instrs =0; set<asm_function_t *> functions; for(map<address_t, asm_function_t *>::const_iterator it = prog->functions.begin(); it != prog->functions.end(); it++){ // Give each function a unique ID (for BGL) // and fill in control flow graph, etc for function asm_function_t *f = it->second; //f->cg_num = cg_num++; disassemble_function(f, prog); functions.insert(f); if(is_debug_on("stats")){ for(map<address_t, Instruction *>::const_iterator iit = f->instmap.begin(); iit != f->instmap.end(); iit++){ total_instrs++; } } } print_debug("stats", "Size of program %u (instrs)\n", total_instrs); //create_callgraph(prog); return prog; }
int debug_dump(debug_type_t type, int level, void *addr, int len) { char tohex[] = "0123456789ABCDEF"; int i = 0; unsigned char *pc = addr; char buf0[32]; // offset char buf1[64]; // hex char buf2[64]; // literal char *pc1; char *pc2; // if (debuglevel < level) { if(!is_debug_on(type, level)) { return 0; } while(--len >= 0) { if(i % 16 == 0) { sprintf(buf0, "%08x", i); buf1[0] = 0; buf2[0] = 0; pc1 = buf1; pc2 = buf2; } *pc1++ = tohex[*pc >> 4]; *pc1++ = tohex[*pc & 15]; *pc1++ = ' '; if(*pc >= 32 && *pc < 127) { *pc2++ = *pc; } else { *pc2++ = '.'; } i++; pc++; if(i % 16 == 0) { *pc1 = 0; *pc2 = 0; debug(type, level, "%s: %s %s", buf0, buf1, buf2); } } if(i % 16 != 0) { while(i % 16 != 0) { *pc1++ = ' '; *pc1++ = ' '; *pc1++ = ' '; *pc2++ = ' '; i++; } *pc1 = 0; *pc2 = 0; debug(type, level, "%s: %s %s", buf0, buf1, buf2); } return 1; }
int acer_soc_resume_post(struct snd_soc_card *card) { int state = (int) is_hp_plugged(); if (!is_debug_on()) snd_soc_jack_report(&tegra_wm8903_hp_jack, state, 1); return 0; }
void print_dbuf(debug_type_t logtype, int loglevel, dbuf_t * d) { if(is_debug_on(logtype, loglevel)) { debug(logtype, loglevel, "dbuf: %x", d); debug(logtype, loglevel, "size: %6d, dsize: %6d", d->size, d->dsize); debug(logtype, loglevel, "allocator backtrace size: %d", d->allocator.size); print_backtrace_t(logtype, loglevel, &d->allocator); debug(logtype, loglevel, "lock count: %d", d->lock); debug(logtype, loglevel, "releaser backtrace size: %d", d->releaser.size); print_backtrace_t(logtype, loglevel, &d->releaser); } }
/** * Routine to print the debug messages with timestamp. * * @param type the type of the debug * @param level and the level of the debug message (0=always shown) * @param fmt printf-style format string, followed by additional parameter * * @return the number of characters printed from the debug message * @see debug_dump */ int debug(debug_type_t type, int level, const char *fmt, ...) { va_list ap; int result = 0; //struct tm *tm; struct timeval tv; char date_buf[256]; if (type == 0) { type = DBG_ALL; } if(is_debug_on(type, level)) { if (show_timestamp_in_debugs) { gettimeofday(&tv, NULL); } else { memset(&tv, 0, sizeof(struct timeval)); } asctime_r(localtime(&tv.tv_sec), date_buf); date_buf[strlen(date_buf) - 6] = 0; if(debug_needs_erase) { fprintf(stderr, "\r"); debug_needs_erase = 0; } fprintf(stderr, "%s.%06d LOG-%4s-%04d: ", date_buf, (int) tv.tv_usec, type->id, level); va_start(ap, fmt); result = vfprintf(stderr, fmt, ap); /* CONSOLEXXX if(need_console_debugs()) { console_printf("\n%s.%06d LOG-%4s-%04d: ", date_buf, (int) tv.tv_usec, type->id, level); console_vprintf(fmt, ap); console_putstr("\n"); } */ va_end(ap); fprintf(stderr, "\n"); } return result; }
static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_codec *codec = rtd->codec; struct snd_soc_dapm_context *dapm = &codec->dapm; struct snd_soc_card *card = codec->card; struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card); struct tegra_wm8903_platform_data *pdata = machine->pdata; int ret; machine->bias_level = SND_SOC_BIAS_STANDBY; if (gpio_is_valid(pdata->gpio_spkr_en)) { ret = gpio_request(pdata->gpio_spkr_en, "spkr_en"); if (ret) { dev_err(card->dev, "cannot get spkr_en gpio\n"); return ret; } machine->gpio_requested |= GPIO_SPKR_EN; gpio_direction_output(pdata->gpio_spkr_en, 0); } if (gpio_is_valid(pdata->gpio_hp_mute)) { ret = gpio_request(pdata->gpio_hp_mute, "hp_mute"); if (ret) { dev_err(card->dev, "cannot get hp_mute gpio\n"); return ret; } machine->gpio_requested |= GPIO_HP_MUTE; gpio_direction_output(pdata->gpio_hp_mute, 0); } if (gpio_is_valid(pdata->gpio_int_mic_en)) { ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en"); if (ret) { dev_err(card->dev, "cannot get int_mic_en gpio\n"); return ret; } machine->gpio_requested |= GPIO_INT_MIC_EN; /* Disable int mic; enable signal is active-high */ gpio_direction_output(pdata->gpio_int_mic_en, 0); } if (gpio_is_valid(pdata->gpio_ext_mic_en)) { ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en"); if (ret) { dev_err(card->dev, "cannot get ext_mic_en gpio\n"); return ret; } machine->gpio_requested |= GPIO_EXT_MIC_EN; /* Enable ext mic; enable signal is active-low */ gpio_direction_output(pdata->gpio_ext_mic_en, 0); } #if defined(CONFIG_ARCH_ACER_T30) /* bypass switch enable gpio */ if (gpio_is_valid(pdata->gpio_bypass_switch_en)) { tegra_gpio_enable(pdata->gpio_bypass_switch_en); ret = gpio_request(pdata->gpio_bypass_switch_en, "bypass_switch_en"); if (ret) { dev_err(card->dev, "cannot get bypass_switch_en gpio\n"); return ret; } machine->gpio_requested |= GPIO_BYBASS_EN; /* Enable bypass switch; enable signal is active-high */ gpio_direction_output(pdata->gpio_bypass_switch_en, 0); } #endif #if defined(CONFIG_ARCH_ACER_T20) || defined(CONFIG_ARCH_ACER_T30) ret = snd_soc_add_controls(codec, cardhu_controls, ARRAY_SIZE(cardhu_controls)); if (ret < 0) return ret; snd_soc_dapm_new_controls(dapm, cardhu_dapm_widgets, ARRAY_SIZE(cardhu_dapm_widgets)); snd_soc_dapm_add_routes(dapm, cardhu_audio_map, ARRAY_SIZE(cardhu_audio_map)); #else if (machine_is_cardhu() || machine_is_ventana()) { ret = snd_soc_add_controls(codec, cardhu_controls, ARRAY_SIZE(cardhu_controls)); if (ret < 0) return ret; snd_soc_dapm_new_controls(dapm, cardhu_dapm_widgets, ARRAY_SIZE(cardhu_dapm_widgets)); } else { ret = snd_soc_add_controls(codec, tegra_wm8903_default_controls, ARRAY_SIZE(tegra_wm8903_default_controls)); if (ret < 0) return ret; snd_soc_dapm_new_controls(dapm, tegra_wm8903_default_dapm_widgets, ARRAY_SIZE(tegra_wm8903_default_dapm_widgets)); } if (machine_is_harmony()) { snd_soc_dapm_add_routes(dapm, harmony_audio_map, ARRAY_SIZE(harmony_audio_map)); } else if (machine_is_cardhu() || machine_is_ventana()) { snd_soc_dapm_add_routes(dapm, cardhu_audio_map, ARRAY_SIZE(cardhu_audio_map)); } else if (machine_is_seaboard()) { snd_soc_dapm_add_routes(dapm, seaboard_audio_map, ARRAY_SIZE(seaboard_audio_map)); } else if (machine_is_kaen()) { snd_soc_dapm_add_routes(dapm, kaen_audio_map, ARRAY_SIZE(kaen_audio_map)); } else { snd_soc_dapm_add_routes(dapm, aebl_audio_map, ARRAY_SIZE(aebl_audio_map)); } #endif #if defined(CONFIG_ARCH_ACER_T20) || defined(CONFIG_ARCH_ACER_T30) audio_data.gpio.debug_en = pdata->gpio_debug_switch_en; /* if debug on, will not enable headset */ if (gpio_is_valid(pdata->gpio_hp_det) && !is_debug_on()) { pr_info("[Audio]register headphone jack\n"); audio_data.gpio.hp_det = pdata->gpio_hp_det; #else if (gpio_is_valid(pdata->gpio_hp_det)) { #endif tegra_wm8903_hp_jack_gpio.gpio = pdata->gpio_hp_det; snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE, &tegra_wm8903_hp_jack); #ifndef CONFIG_SWITCH snd_soc_jack_add_pins(&tegra_wm8903_hp_jack, ARRAY_SIZE(tegra_wm8903_hp_jack_pins), tegra_wm8903_hp_jack_pins); #else snd_soc_jack_notifier_register(&tegra_wm8903_hp_jack, &tegra_wm8903_jack_detect_nb); #endif snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack, 1, &tegra_wm8903_hp_jack_gpio); machine->gpio_requested |= GPIO_HP_DET; } snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE, &tegra_wm8903_mic_jack); #if !defined(CONFIG_ARCH_ACER_T20) && !defined(CONFIG_ARCH_ACER_T30) #ifndef CONFIG_SWITCH snd_soc_jack_add_pins(&tegra_wm8903_mic_jack, ARRAY_SIZE(tegra_wm8903_mic_jack_pins), tegra_wm8903_mic_jack_pins); #else snd_soc_jack_notifier_register(&tegra_wm8903_mic_jack, &tegra_wm8903_jack_detect_nb); #endif #endif wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE, machine_is_cardhu() ? SND_JACK_MICROPHONE : 0); snd_soc_dapm_force_enable_pin(dapm, "Mic Bias"); /* Disable Spk,Headphone,Line Out when wm8903 init */ #if defined(CONFIG_ARCH_ACER_T20) || defined(CONFIG_ARCH_ACER_T30) snd_soc_dapm_disable_pin(dapm, "Int Spk"); snd_soc_dapm_disable_pin(dapm, "Headphone Jack"); snd_soc_dapm_disable_pin(dapm, "LineOut"); snd_soc_dapm_disable_pin(dapm, "Mic Jack"); snd_soc_dapm_disable_pin(dapm, "Int Mic"); #if !defined(CONFIG_ARCH_ACER_T30) snd_soc_dapm_disable_pin(dapm, "LineIn"); #endif audio_data.codec = codec; audio_data.gpio.spkr_en = pdata->gpio_spkr_en; audio_data.gpio.int_mic_en = pdata->gpio_int_mic_en; audio_data.gpio.bypass_en = pdata->gpio_bypass_switch_en; #else /* FIXME: Calculate automatically based on DAPM routes? */ if (!machine_is_harmony() && !machine_is_ventana() && !machine_is_cardhu()) snd_soc_dapm_nc_pin(dapm, "IN1L"); if (!machine_is_seaboard() && !machine_is_aebl() && !machine_is_cardhu()) snd_soc_dapm_nc_pin(dapm, "IN1R"); snd_soc_dapm_nc_pin(dapm, "IN2L"); if (!machine_is_kaen()) snd_soc_dapm_nc_pin(dapm, "IN2R"); snd_soc_dapm_nc_pin(dapm, "IN3L"); snd_soc_dapm_nc_pin(dapm, "IN3R"); if (machine_is_aebl()) { snd_soc_dapm_nc_pin(dapm, "LON"); snd_soc_dapm_nc_pin(dapm, "RON"); snd_soc_dapm_nc_pin(dapm, "ROP"); snd_soc_dapm_nc_pin(dapm, "LOP"); } else { snd_soc_dapm_nc_pin(dapm, "LINEOUTR"); snd_soc_dapm_nc_pin(dapm, "LINEOUTL"); } #endif snd_soc_dapm_sync(dapm); return 0; } static int tegra30_soc_set_bias_level(struct snd_soc_card *card, enum snd_soc_bias_level level) { struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card); if (machine->bias_level == SND_SOC_BIAS_OFF && level != SND_SOC_BIAS_OFF) tegra_asoc_utils_clk_enable(&machine->util_data); return 0; } static int tegra30_soc_set_bias_level_post(struct snd_soc_card *card, enum snd_soc_bias_level level) { struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card); if (machine->bias_level != SND_SOC_BIAS_OFF && level == SND_SOC_BIAS_OFF) tegra_asoc_utils_clk_disable(&machine->util_data); machine->bias_level = level; return 0 ; } static struct snd_soc_dai_link tegra_wm8903_dai[] = { { .name = "WM8903", .stream_name = "WM8903 PCM", .codec_name = "wm8903.0-001a", .platform_name = "tegra-pcm-audio", .cpu_dai_name = "tegra20-i2s.0", .codec_dai_name = "wm8903-hifi", .init = tegra_wm8903_init, .ops = &tegra_wm8903_ops, }, { .name = "SPDIF",