static int __init iommu_init(void) { int ret; if (!msm_soc_version_supports_iommu_v1()) { pr_err("IOMMU v1 is not supported on this SoC version.\n"); return -ENODEV; } ret = platform_device_register(&msm_root_iommu_dev); if (ret != 0) { pr_err("Failed to register root IOMMU device!\n"); goto failure; } platform_add_devices(msm_iommu_common_devs, ARRAY_SIZE(msm_iommu_common_devs)); if (cpu_is_msm8x60() || cpu_is_msm8960()) { platform_add_devices(msm_iommu_jpegd_devs, ARRAY_SIZE(msm_iommu_jpegd_devs)); platform_add_devices(msm_iommu_gfx2d_devs, ARRAY_SIZE(msm_iommu_gfx2d_devs)); } if (cpu_is_apq8064() || cpu_is_apq8064ab()) { platform_add_devices(msm_iommu_jpegd_devs, ARRAY_SIZE(msm_iommu_jpegd_devs)); platform_add_devices(msm_iommu_8064_devs, ARRAY_SIZE(msm_iommu_8064_devs)); } ret = platform_add_devices(msm_iommu_common_ctx_devs, ARRAY_SIZE(msm_iommu_common_ctx_devs)); if (cpu_is_msm8x60() || cpu_is_msm8960()) { platform_add_devices(msm_iommu_jpegd_ctx_devs, ARRAY_SIZE(msm_iommu_jpegd_ctx_devs)); platform_add_devices(msm_iommu_gfx2d_ctx_devs, ARRAY_SIZE(msm_iommu_gfx2d_ctx_devs)); } if (cpu_is_apq8064() || cpu_is_apq8064ab()) { platform_add_devices(msm_iommu_jpegd_ctx_devs, ARRAY_SIZE(msm_iommu_jpegd_ctx_devs)); platform_add_devices(msm_iommu_8064_ctx_devs, ARRAY_SIZE(msm_iommu_8064_ctx_devs)); } return 0; failure: return ret; }
static int __init iommu_init(void) { int ret; if (!msm_soc_version_supports_iommu_v1()) { pr_err("IOMMU v1 is not supported on this SoC version.\n"); return -ENODEV; } /* Initialize common devs */ platform_add_devices(msm_iommu_common_devs, ARRAY_SIZE(msm_iommu_common_devs)); /* Initialize soc-specific devs */ if (cpu_is_msm8x60() || cpu_is_msm8960()) { platform_add_devices(msm_iommu_jpegd_devs, ARRAY_SIZE(msm_iommu_jpegd_devs)); platform_add_devices(msm_iommu_gfx2d_devs, ARRAY_SIZE(msm_iommu_gfx2d_devs)); } if (soc_class_is_apq8064() || cpu_is_msm8960ab()) { platform_add_devices(msm_iommu_jpegd_devs, ARRAY_SIZE(msm_iommu_jpegd_devs)); platform_add_devices(msm_iommu_adreno3xx_gfx_devs, ARRAY_SIZE(msm_iommu_adreno3xx_gfx_devs)); } if (soc_class_is_apq8064()) platform_add_devices(msm_iommu_vcap_devs, ARRAY_SIZE(msm_iommu_vcap_devs)); /* Initialize common ctx_devs */ ret = platform_add_devices(msm_iommu_common_ctx_devs, ARRAY_SIZE(msm_iommu_common_ctx_devs)); /* Initialize soc-specific ctx_devs */ if (cpu_is_msm8x60() || cpu_is_msm8960()) { platform_add_devices(msm_iommu_jpegd_ctx_devs, ARRAY_SIZE(msm_iommu_jpegd_ctx_devs)); platform_add_devices(msm_iommu_gfx2d_ctx_devs, ARRAY_SIZE(msm_iommu_gfx2d_ctx_devs)); } if (soc_class_is_apq8064() || cpu_is_msm8960ab()) { platform_add_devices(msm_iommu_jpegd_ctx_devs, ARRAY_SIZE(msm_iommu_jpegd_ctx_devs)); platform_add_devices(msm_iommu_adreno3xx_ctx_devs, ARRAY_SIZE(msm_iommu_adreno3xx_ctx_devs)); } if (soc_class_is_apq8064()) platform_add_devices(msm_iommu_vcap_ctx_devs, ARRAY_SIZE(msm_iommu_vcap_ctx_devs)); return 0; }
void diag_send_data(struct diag_master_table entry, unsigned char *buf, int len, int type) { driver->pkt_length = len; if (entry.process_id != NON_APPS_PROC && type != MODEM_DATA) { diag_update_pkt_buffer(buf); diag_update_sleeping_process(entry.process_id); } else { if (len > 0) { if (entry.client_id == MODEM_PROC && driver->ch) { if (cpu_is_msm8960() && (int)(*(char *)buf) == MODE_CMD) if ((int)(*(char *)(buf+1)) == RESET_ID) return; smd_write(driver->ch, buf, len); } else if (entry.client_id == QDSP_PROC && driver->chqdsp) { smd_write(driver->chqdsp, buf, len); } else if (entry.client_id == WCNSS_PROC && driver->ch_wcnss) { smd_write(driver->ch_wcnss, buf, len); } else { pr_alert("diag: incorrect channel"); } } } }
int msm_spm_turn_on_cpu_rail(unsigned int cpu) { uint32_t val = 0; uint32_t timeout = 0; void *reg = NULL; void *saw_bases[] = { 0, MSM_SAW1_BASE, MSM_SAW2_BASE, MSM_SAW3_BASE }; if (cpu == 0 || cpu >= num_possible_cpus()) return -EINVAL; reg = saw_bases[cpu]; if (cpu_is_msm8960() || cpu_is_msm8930() || cpu_is_msm8930aa() || cpu_is_apq8064() || cpu_is_msm8627() || cpu_is_msm8960ab() || cpu_is_apq8064ab()) { val = 0xA4; reg += 0x14; timeout = 512; } else { return -ENOSYS; } writel_relaxed(val, reg); mb(); udelay(timeout); return 0; }
static int tz_init(struct kgsl_device *device, struct kgsl_pwrscale *pwrscale) { struct tz_priv *priv; int ret; if (!(cpu_is_msm8x60() || cpu_is_msm8960() || cpu_is_apq8064() || cpu_is_msm8930() || cpu_is_msm8930aa() || cpu_is_msm8627())) return -EINVAL; priv = pwrscale->priv = kzalloc(sizeof(struct tz_priv), GFP_KERNEL); if (pwrscale->priv == NULL) return -ENOMEM; priv->governor = TZ_GOVERNOR_ONDEMAND; spin_lock_init(&tz_lock); kgsl_pwrscale_policy_add_files(device, pwrscale, &tz_attr_group); ret = __secure_tz_entry(TZ_CMD_ID, 0, PARAM_INDEX_WRITE_ALGORITHM); if(ret == 1) pr_info("Using HTC GPU DCVS algorithm\n"); else pr_info("Using QCT GPU DCVS algorithm\n"); return 0; }
static int __init msm8960_audio_init(void) { int ret; if (!cpu_is_msm8960() && !cpu_is_msm8930()) { pr_err("%s: Not the right machine type\n", __func__); return -ENODEV ; } mbhc_cfg.calibration = def_tabla_mbhc_cal(); if (!mbhc_cfg.calibration) { pr_err("Calibration data allocation failed\n"); return -ENOMEM; } msm8960_snd_device = platform_device_alloc("soc-audio", 0); if (!msm8960_snd_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } memcpy(msm8960_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla2x, sizeof(msm8960_dai_delta_tabla2x)); platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm8960_snd_device); if (ret) { platform_device_put(msm8960_snd_device); kfree(mbhc_cfg.calibration); return ret; } msm8960_snd_tabla1x_device = platform_device_alloc("soc-audio", 1); if (!msm8960_snd_tabla1x_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } memcpy(msm8960_tabla1x_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_tabla1x_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla1x, sizeof(msm8960_dai_delta_tabla1x)); platform_set_drvdata(msm8960_snd_tabla1x_device, &snd_soc_tabla1x_card_msm8960); ret = platform_device_add(msm8960_snd_tabla1x_device); if (ret) { platform_device_put(msm8960_snd_tabla1x_device); kfree(mbhc_cfg.calibration); return -ENOMEM; return ret; } mutex_init(&cdc_mclk_mutex); return ret; }
static void __exit iommu_exit(void) { int i; /* Common ctx_devs */ for (i = 0; i < ARRAY_SIZE(msm_iommu_common_ctx_devs); i++) platform_device_unregister(msm_iommu_common_ctx_devs[i]); /* Common devs. */ for (i = 0; i < ARRAY_SIZE(msm_iommu_common_devs); ++i) platform_device_unregister(msm_iommu_common_devs[i]); if (cpu_is_msm8x60() || cpu_is_msm8960()) { for (i = 0; i < ARRAY_SIZE(msm_iommu_gfx2d_ctx_devs); i++) platform_device_unregister(msm_iommu_gfx2d_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_ctx_devs); i++) platform_device_unregister(msm_iommu_jpegd_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_gfx2d_devs); i++) platform_device_unregister(msm_iommu_gfx2d_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_devs); i++) platform_device_unregister(msm_iommu_jpegd_devs[i]); } if (cpu_is_apq8064() || cpu_is_apq8064ab()) { for (i = 0; i < ARRAY_SIZE(msm_iommu_vcap_ctx_devs); i++) platform_device_unregister(msm_iommu_vcap_ctx_devs[i]); } if (cpu_is_apq8064() || cpu_is_msm8960ab() || cpu_is_apq8064ab()) { for (i = 0; i < ARRAY_SIZE(msm_iommu_adreno3xx_ctx_devs); i++) platform_device_unregister( msm_iommu_adreno3xx_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_ctx_devs); i++) platform_device_unregister( msm_iommu_jpegd_ctx_devs[i]); if (cpu_is_apq8064() || cpu_is_apq8064ab()) { for (i = 0; i < ARRAY_SIZE(msm_iommu_vcap_devs); i++) platform_device_unregister( msm_iommu_vcap_devs[i]); } for (i = 0; i < ARRAY_SIZE(msm_iommu_adreno3xx_gfx_devs); i++) platform_device_unregister( msm_iommu_adreno3xx_gfx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_devs); i++) platform_device_unregister(msm_iommu_jpegd_devs[i]); } platform_device_unregister(&msm_root_iommu_dev); }
/* * kgsl_iommu_setup_defaultpagetable - Setup the initial defualtpagetable * for iommu. This function is only called once during first start, successive * start do not call this funciton. * @mmu - Pointer to mmu structure * * Create the initial defaultpagetable and setup the iommu mappings to it * Return - 0 on success else error code */ static int kgsl_iommu_setup_defaultpagetable(struct kgsl_mmu *mmu) { int status = 0; int i = 0; struct kgsl_iommu *iommu = mmu->priv; struct kgsl_pagetable *pagetable = NULL; /* If chip is not 8960 then we use the 2nd context bank for pagetable * switching on the 3D side for which a separate table is allocated */ if (!cpu_is_msm8960() && msm_soc_version_supports_iommu_v1()) { mmu->priv_bank_table = kgsl_mmu_getpagetable(KGSL_MMU_PRIV_BANK_TABLE_NAME); if (mmu->priv_bank_table == NULL) { status = -ENOMEM; goto err; } } mmu->defaultpagetable = kgsl_mmu_getpagetable(KGSL_MMU_GLOBAL_PT); /* Return error if the default pagetable doesn't exist */ if (mmu->defaultpagetable == NULL) { status = -ENOMEM; goto err; } pagetable = mmu->priv_bank_table ? mmu->priv_bank_table : mmu->defaultpagetable; /* Map the IOMMU regsiters to only defaultpagetable */ if (msm_soc_version_supports_iommu_v1()) { for (i = 0; i < iommu->unit_count; i++) { iommu->iommu_units[i].reg_map.priv |= KGSL_MEMFLAGS_GLOBAL; status = kgsl_mmu_map(pagetable, &(iommu->iommu_units[i].reg_map), GSL_PT_PAGE_RV | GSL_PT_PAGE_WV); if (status) { iommu->iommu_units[i].reg_map.priv &= ~KGSL_MEMFLAGS_GLOBAL; goto err; } } } return status; err: for (i--; i >= 0; i--) { kgsl_mmu_unmap(pagetable, &(iommu->iommu_units[i].reg_map)); iommu->iommu_units[i].reg_map.priv &= ~KGSL_MEMFLAGS_GLOBAL; } if (mmu->priv_bank_table) { kgsl_mmu_putpagetable(mmu->priv_bank_table); mmu->priv_bank_table = NULL; } if (mmu->defaultpagetable) { kgsl_mmu_putpagetable(mmu->defaultpagetable); mmu->defaultpagetable = NULL; } return status; }
int __init meminfo_init(unsigned int type, unsigned int min_bank_size) { unsigned int i; unsigned long bank_size; unsigned long bank_start; struct smem_ram_ptable *ram_ptable; /* physical memory banks */ unsigned int nr_mem_banks = 0; /* logical memory regions for dmm */ nr_mem_regions = 0; ram_ptable = smem_alloc(SMEM_USABLE_RAM_PARTITION_TABLE, sizeof(struct smem_ram_ptable)); if (!ram_ptable) { pr_err("Could not read ram partition table\n"); return -EINVAL; } /* Determine power control mode based on the hw version */ /* This check will be removed when PASR is fully supported */ if (cpu_is_msm8960() && SOCINFO_VERSION_MAJOR(socinfo_get_version()) < 2) dmm_mode = MEM_DEEP_POWER_DOWN; else dmm_mode = MEM_SELF_REFRESH; pr_info("meminfo_init: smem ram ptable found: ver: %d len: %d\n", ram_ptable->version, ram_ptable->len); for (i = 0; i < ram_ptable->len; i++) { if (ram_ptable->parts[i].type == type && ram_ptable->parts[i].size >= min_bank_size) { bank_start = ram_ptable->parts[i].start; bank_size = ram_ptable->parts[i].size; /* Divide into logical memory regions of same size */ while (bank_size) { mem_regions[nr_mem_regions].start = bank_start; mem_regions[nr_mem_regions].size = MIN_MEMORY_BLOCK_SIZE; mutex_init(&mem_regions[nr_mem_regions] .state_mutex); mem_regions[nr_mem_regions].state = STATE_DEFAULT; mem_regions[nr_mem_regions].mask = default_mask; bank_start += MIN_MEMORY_BLOCK_SIZE; bank_size -= MIN_MEMORY_BLOCK_SIZE; nr_mem_regions++; } nr_mem_banks++; } } pr_info("Found %d memory banks grouped into %d memory regions\n", nr_mem_banks, nr_mem_regions); return 0; }
static void __exit msm8960_audio_exit(void) { if (!cpu_is_msm8960() && !cpu_is_msm8930()) { pr_err("%s: Not the right machine type\n", __func__); return ; } msm8960_free_headset_mic_gpios(); platform_device_unregister(msm8960_snd_device); kfree(tabla_mbhc_cal); }
static int __init jet_audio_init(void) { int ret; if (!cpu_is_msm8960()) { pr_err("%s: Not the right machine type\n", __func__); return -ENODEV; } pr_debug("%s", __func__); msm_snd_device = platform_device_alloc("soc-audio", 0); if (!msm_snd_device) { pr_err("Platform device allocation failed\n"); return -ENOMEM; } memcpy(msm_dai, msm_dai_common, sizeof(msm_dai_common)); memcpy(msm_dai + ARRAY_SIZE(msm_dai_common), msm_dai_delta_tabla2x, sizeof(msm_dai_delta_tabla2x)); platform_set_drvdata(msm_snd_device, &snd_soc_card_msm); ret = platform_device_add(msm_snd_device); if (ret) { platform_device_put(msm_snd_device); return ret; } msm_snd_tabla1x_device = platform_device_alloc("soc-audio", 1); if (!msm_snd_tabla1x_device) { pr_err("Platform device allocation failed\n"); return -ENOMEM; } memcpy(msm_tabla1x_dai, msm_dai_common, sizeof(msm_dai_common)); memcpy(msm_tabla1x_dai + ARRAY_SIZE(msm_dai_common), msm_dai_delta_tabla1x, sizeof(msm_dai_delta_tabla1x)); platform_set_drvdata(msm_snd_tabla1x_device, &snd_soc_tabla1x_card_msm); ret = platform_device_add(msm_snd_tabla1x_device); if (ret) { platform_device_put(msm_snd_tabla1x_device); return ret; } mutex_init(&audio_notifier_lock); pr_debug("%s: register cable detect func for dock", __func__); ret = cable_detect_register_notifier(&audio_dock_notifier); mutex_init(&cdc_mclk_mutex); return ret; }
static void __exit msm8960_audio_exit(void) { if (!cpu_is_msm8960() && !cpu_is_msm8930()) { pr_err("%s: Not the right machine type\n", __func__); return ; } platform_device_unregister(msm8960_snd_device); platform_device_unregister(msm8960_snd_tabla1x_device); kfree(mbhc_cfg.calibration); mutex_destroy(&cdc_mclk_mutex); }
static int kgsl_iommu_setup_defaultpagetable(struct kgsl_mmu *mmu) { int status = 0; int i = 0; struct kgsl_iommu *iommu = mmu->priv; struct kgsl_iommu_pt *iommu_pt; struct kgsl_pagetable *pagetable = NULL; if (!cpu_is_msm8960()) { mmu->priv_bank_table = kgsl_mmu_getpagetable(KGSL_MMU_PRIV_BANK_TABLE_NAME); if (mmu->priv_bank_table == NULL) { status = -ENOMEM; goto err; } iommu_pt = mmu->priv_bank_table->priv; } mmu->defaultpagetable = kgsl_mmu_getpagetable(KGSL_MMU_GLOBAL_PT); if (mmu->defaultpagetable == NULL) { status = -ENOMEM; goto err; } pagetable = mmu->priv_bank_table ? mmu->priv_bank_table : mmu->defaultpagetable; for (i = 0; i < iommu->unit_count; i++) { iommu->iommu_units[i].reg_map.priv |= KGSL_MEMFLAGS_GLOBAL; status = kgsl_mmu_map(pagetable, &(iommu->iommu_units[i].reg_map), GSL_PT_PAGE_RV | GSL_PT_PAGE_WV); if (status) { iommu->iommu_units[i].reg_map.priv &= ~KGSL_MEMFLAGS_GLOBAL; goto err; } } return status; err: for (i--; i >= 0; i--) { kgsl_mmu_unmap(pagetable, &(iommu->iommu_units[i].reg_map)); iommu->iommu_units[i].reg_map.priv &= ~KGSL_MEMFLAGS_GLOBAL; } if (mmu->priv_bank_table) { kgsl_mmu_putpagetable(mmu->priv_bank_table); mmu->priv_bank_table = NULL; } if (mmu->defaultpagetable) { kgsl_mmu_putpagetable(mmu->defaultpagetable); mmu->defaultpagetable = NULL; } return status; }
static int __init ville_audio_init(void) { int ret; if (!cpu_is_msm8960()) { pr_info("%s: Not the right machine type\n", __func__); return -ENODEV ; } pr_info("%s", __func__); msm8960_snd_device = platform_device_alloc("soc-audio", 0); if (!msm8960_snd_device) { pr_err("Platform device allocation failed\n"); return -ENOMEM; } memcpy(msm8960_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla2x, sizeof(msm8960_dai_delta_tabla2x)); platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm8960_snd_device); if (ret) { platform_device_put(msm8960_snd_device); return ret; } msm8960_snd_tabla1x_device = platform_device_alloc("soc-audio", 1); if (!msm8960_snd_tabla1x_device) { pr_err("Platform device allocation failed\n"); return -ENOMEM; } memcpy(msm8960_tabla1x_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_tabla1x_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla1x, sizeof(msm8960_dai_delta_tabla1x)); platform_set_drvdata(msm8960_snd_tabla1x_device, &snd_soc_tabla1x_card_msm8960); ret = platform_device_add(msm8960_snd_tabla1x_device); if (ret) { platform_device_put(msm8960_snd_tabla1x_device); return ret; } mutex_init(&cdc_mclk_mutex); htc_register_q6asm_ops(&qops); htc_register_pcm_routing_ops(&rops); acoustic_register_ops(&acoustic); return ret; }
static void __exit ville_audio_exit(void) { if (!cpu_is_msm8960()) { pr_info("%s: Not the right machine type\n", __func__); return ; } pr_info("%s", __func__); platform_device_unregister(msm8960_snd_device); platform_device_unregister(msm8960_snd_tabla1x_device); mutex_destroy(&cdc_mclk_mutex); }
static void __exit jet_audio_exit(void) { if (!cpu_is_msm8960()) { pr_err("%s: Not the right machine type\n", __func__); return; } pr_debug("%s", __func__); platform_device_unregister(msm_snd_device); platform_device_unregister(msm_snd_tabla1x_device); mutex_destroy(&audio_notifier_lock); mutex_destroy(&cdc_mclk_mutex); }
static int __init modem_8960_init(void) { int ret; if (!cpu_is_msm8960()) return -ENODEV; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); if (ret < 0) pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); ret = request_irq(Q6FW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_fw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6fw watchdog IRQ. (%d)\n", __func__, ret); goto out; } ret = request_irq(Q6SW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n", __func__, ret); disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ); goto out; } ret = modem_subsystem_restart_init(); if (ret < 0) { pr_err("%s: Unable to reg with subsystem restart. (%d)\n", __func__, ret); goto out; } ret = modem_debugfs_init(); pr_info("%s: 8960 modem fatal driver init'ed.\n", __func__); out: return ret; }
static int __cpuinit release_secondary(unsigned int cpu) { BUG_ON(cpu >= get_core_count()); if (cpu_is_msm8x60()) return scorpion_release_secondary(); if (machine_is_msm8960_sim() || machine_is_msm8960_rumi3() || machine_is_apq8064_sim()) return krait_release_secondary_sim(cpu); if (cpu_is_msm8960() || cpu_is_msm8930() || cpu_is_apq8064()) return krait_release_secondary(cpu); WARN(1, "unknown CPU case in release_secondary\n"); return -EINVAL; }
static int tz_init(struct kgsl_device *device, struct kgsl_pwrscale *pwrscale) { struct tz_priv *priv; /* Trustzone is only valid for some SOCs */ if (!(cpu_is_msm8x60() || cpu_is_msm8960())) return -EINVAL; priv = pwrscale->priv = kzalloc(sizeof(struct tz_priv), GFP_KERNEL); if (pwrscale->priv == NULL) return -ENOMEM; priv->governor = TZ_GOVERNOR_ONDEMAND; spin_lock_init(&tz_lock); kgsl_pwrscale_policy_add_files(device, pwrscale, &tz_attr_group); return 0; }
static void __exit iommu_exit(void) { int i; for (i = 0; i < ARRAY_SIZE(msm_iommu_common_ctx_devs); i++) platform_device_unregister(msm_iommu_common_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_common_devs); ++i) platform_device_unregister(msm_iommu_common_devs[i]); if (cpu_is_msm8x60() || cpu_is_msm8960()) { for (i = 0; i < ARRAY_SIZE(msm_iommu_gfx2d_ctx_devs); i++) platform_device_unregister(msm_iommu_gfx2d_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_ctx_devs); i++) platform_device_unregister(msm_iommu_jpegd_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_gfx2d_devs); i++) platform_device_unregister(msm_iommu_gfx2d_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_devs); i++) platform_device_unregister(msm_iommu_jpegd_devs[i]); } if (cpu_is_apq8064() || cpu_is_apq8064ab()) { for (i = 0; i < ARRAY_SIZE(msm_iommu_8064_ctx_devs); i++) platform_device_unregister(msm_iommu_8064_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_ctx_devs); i++) platform_device_unregister(msm_iommu_jpegd_ctx_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_8064_devs); i++) platform_device_unregister(msm_iommu_8064_devs[i]); for (i = 0; i < ARRAY_SIZE(msm_iommu_jpegd_devs); i++) platform_device_unregister(msm_iommu_jpegd_devs[i]); } platform_device_unregister(&msm_root_iommu_dev); }
static int release_secondary(unsigned int cpu) { BUG_ON(cpu >= get_core_count()); if (cpu_is_msm8x60()) return scorpion_release_secondary(); if (machine_is_msm8974_sim()) return krait_release_secondary_sim(0xf9088000, cpu); if (cpu_is_msm8960() || cpu_is_msm8930() || cpu_is_msm8930aa() || cpu_is_apq8064() || cpu_is_msm8627() || cpu_is_msm8960ab()) return krait_release_secondary(0x02088000, cpu); if (cpu_is_msm8974()) return krait_release_secondary_p3(0xf9088000, cpu); WARN(1, "unknown CPU case in release_secondary\n"); return -EINVAL; }
/* * kgsl_iommu_setup_defaultpagetable - Setup the initial defualtpagetable * for iommu. This function is only called once during first start, successive * start do not call this funciton. * @mmu - Pointer to mmu structure * * Create the initial defaultpagetable and setup the iommu mappings to it * Return - 0 on success else error code */ static int kgsl_iommu_setup_defaultpagetable(struct kgsl_mmu *mmu) { int status = 0; int i = 0; struct kgsl_iommu *iommu = mmu->priv; struct kgsl_iommu_pt *iommu_pt; struct kgsl_pagetable *pagetable = NULL; /* If chip is not 8960 then we use the 2nd context bank for pagetable * switching on the 3D side for which a separate table is allocated */ if (!cpu_is_msm8960()) { mmu->priv_bank_table = kgsl_mmu_getpagetable(KGSL_MMU_PRIV_BANK_TABLE_NAME); if (mmu->priv_bank_table == NULL) { status = -ENOMEM; goto err; } iommu_pt = mmu->priv_bank_table->priv; iommu_pt->asid = 1; } mmu->defaultpagetable = kgsl_mmu_getpagetable(KGSL_MMU_GLOBAL_PT); /* Return error if the default pagetable doesn't exist */ if (mmu->defaultpagetable == NULL) { status = -ENOMEM; goto err; } pagetable = mmu->priv_bank_table ? mmu->priv_bank_table : mmu->defaultpagetable; /* Map the IOMMU regsiters to only defaultpagetable */ for (i = 0; i < iommu->unit_count; i++) { iommu->iommu_units[i].reg_map.priv |= KGSL_MEMFLAGS_GLOBAL; status = kgsl_mmu_map(pagetable, &(iommu->iommu_units[i].reg_map), GSL_PT_PAGE_RV | GSL_PT_PAGE_WV); if (status) { iommu->iommu_units[i].reg_map.priv &= ~KGSL_MEMFLAGS_GLOBAL; goto err; } } /* * The dafault pagetable always has asid 0 assigned by the iommu driver * and asid 1 is assigned to the private context. */ iommu_pt = mmu->defaultpagetable->priv; iommu_pt->asid = 0; set_bit(0, iommu->asids); set_bit(1, iommu->asids); return status; err: for (i--; i >= 0; i--) { kgsl_mmu_unmap(pagetable, &(iommu->iommu_units[i].reg_map)); iommu->iommu_units[i].reg_map.priv &= ~KGSL_MEMFLAGS_GLOBAL; } if (mmu->priv_bank_table) { kgsl_mmu_putpagetable(mmu->priv_bank_table); mmu->priv_bank_table = NULL; } if (mmu->defaultpagetable) { kgsl_mmu_putpagetable(mmu->defaultpagetable); mmu->defaultpagetable = NULL; } return status; }
static int diag_process_apps_pkt(unsigned char *buf, int len) { uint16_t subsys_cmd_code; int subsys_id, ssid_first, ssid_last, ssid_range; int packet_type = 1, i, cmd_code; unsigned char *temp = buf; int data_type; #if defined(CONFIG_DIAG_OVER_USB) int payload_length; unsigned char *ptr; #endif /* Check for registered clients and forward packet to apropriate proc */ cmd_code = (int)(*(char *)buf); temp++; subsys_id = (int)(*(char *)temp); temp++; subsys_cmd_code = *(uint16_t *)temp; temp += 2; data_type = APPS_DATA; /* Dont send any command other than mode reset */ if (cpu_is_msm8960() && cmd_code == MODE_CMD) { if (subsys_id != RESET_ID) data_type = MODEM_DATA; } pr_debug("diag: %d %d %d", cmd_code, subsys_id, subsys_cmd_code); for (i = 0; i < diag_max_registration; i++) { entry = driver->table[i]; if (entry.process_id != NO_PROCESS) { if (entry.cmd_code == cmd_code && entry.subsys_id == subsys_id && entry.cmd_code_lo <= subsys_cmd_code && entry.cmd_code_hi >= subsys_cmd_code) { diag_send_data(entry, buf, len, data_type); packet_type = 0; } else if (entry.cmd_code == 255 && cmd_code == 75) { if (entry.subsys_id == subsys_id && entry.cmd_code_lo <= subsys_cmd_code && entry.cmd_code_hi >= subsys_cmd_code) { diag_send_data(entry, buf, len, data_type); packet_type = 0; } } else if (entry.cmd_code == 255 && entry.subsys_id == 255) { if (entry.cmd_code_lo <= cmd_code && entry. cmd_code_hi >= cmd_code) { diag_send_data(entry, buf, len, data_type); packet_type = 0; } } } } /* set event mask */ if (*buf == 0x82) { buf += 4; diag_update_event_mask(buf, 1, *(uint16_t *)buf); diag_update_userspace_clients(EVENT_MASKS_TYPE); } /* event mask change */ else if ((*buf == 0x60) && (*(buf+1) == 0x0)) { diag_update_event_mask(buf+1, 0, 0); diag_update_userspace_clients(EVENT_MASKS_TYPE); #if defined(CONFIG_DIAG_OVER_USB) /* Check for Apps Only 8960 */ if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID)) { /* echo response back for apps only DIAG */ driver->apps_rsp_buf[0] = 0x60; driver->apps_rsp_buf[1] = 0x0; driver->apps_rsp_buf[2] = 0x0; ENCODE_RSP_AND_SEND(2); return 0; } #endif } /* Set log masks */ else if (*buf == 0x73 && *(int *)(buf+4) == 3) { buf += 8; /* Read Equip ID and pass as first param below*/ diag_update_log_mask(*(int *)buf, buf+8, *(int *)(buf+4)); diag_update_userspace_clients(LOG_MASKS_TYPE); #if defined(CONFIG_DIAG_OVER_USB) /* Check for Apps Only 8960 */ if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID)) { /* echo response back for Apps only DIAG */ driver->apps_rsp_buf[0] = 0x73; *(int *)(driver->apps_rsp_buf + 4) = 0x3; /* op. ID */ *(int *)(driver->apps_rsp_buf + 8) = 0x0; /* success */ payload_length = 8 + ((*(int *)(buf + 4)) + 7)/8; for (i = 0; i < payload_length; i++) *(int *)(driver->apps_rsp_buf+12+i) = *(buf+8+i); ENCODE_RSP_AND_SEND(12 + payload_length - 1); return 0; } #endif } /* Check for set message mask */ else if ((*buf == 0x7d) && (*(buf+1) == 0x4)) { ssid_first = *(uint16_t *)(buf + 2); ssid_last = *(uint16_t *)(buf + 4); ssid_range = 4 * (ssid_last - ssid_first + 1); diag_update_msg_mask(ssid_first, ssid_last , buf + 8); diag_update_userspace_clients(MSG_MASKS_TYPE); #if defined(CONFIG_DIAG_OVER_USB) if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID)) { /* echo response back for apps only DIAG */ for (i = 0; i < 8 + ssid_range; i++) *(driver->apps_rsp_buf + i) = *(buf+i); ENCODE_RSP_AND_SEND(8 + ssid_range - 1); return 0; } #endif } #if defined(CONFIG_DIAG_OVER_USB) /* Check for Apps Only 8960 & get event mask request */ else if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID) && *buf == 0x81) { driver->apps_rsp_buf[0] = 0x81; driver->apps_rsp_buf[1] = 0x0; *(uint16_t *)(driver->apps_rsp_buf + 2) = 0x0; *(uint16_t *)(driver->apps_rsp_buf + 4) = EVENT_LAST_ID + 1; for (i = 0; i < EVENT_LAST_ID/8 + 1; i++) *(unsigned char *)(driver->apps_rsp_buf + 6 + i) = 0x0; ENCODE_RSP_AND_SEND(6 + EVENT_LAST_ID/8); return 0; } /* Get log ID range & Check for Apps Only 8960 */ else if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID) && (*buf == 0x73) && *(int *)(buf+4) == 1) { driver->apps_rsp_buf[0] = 0x73; *(int *)(driver->apps_rsp_buf + 4) = 0x1; /* operation ID */ *(int *)(driver->apps_rsp_buf + 8) = 0x0; /* success code */ *(int *)(driver->apps_rsp_buf + 12) = LOG_GET_ITEM_NUM(LOG_0); *(int *)(driver->apps_rsp_buf + 16) = LOG_GET_ITEM_NUM(LOG_1); *(int *)(driver->apps_rsp_buf + 20) = LOG_GET_ITEM_NUM(LOG_2); *(int *)(driver->apps_rsp_buf + 24) = LOG_GET_ITEM_NUM(LOG_3); *(int *)(driver->apps_rsp_buf + 28) = LOG_GET_ITEM_NUM(LOG_4); *(int *)(driver->apps_rsp_buf + 32) = LOG_GET_ITEM_NUM(LOG_5); *(int *)(driver->apps_rsp_buf + 36) = LOG_GET_ITEM_NUM(LOG_6); *(int *)(driver->apps_rsp_buf + 40) = LOG_GET_ITEM_NUM(LOG_7); *(int *)(driver->apps_rsp_buf + 44) = LOG_GET_ITEM_NUM(LOG_8); *(int *)(driver->apps_rsp_buf + 48) = LOG_GET_ITEM_NUM(LOG_9); *(int *)(driver->apps_rsp_buf + 52) = LOG_GET_ITEM_NUM(LOG_10); *(int *)(driver->apps_rsp_buf + 56) = LOG_GET_ITEM_NUM(LOG_11); *(int *)(driver->apps_rsp_buf + 60) = LOG_GET_ITEM_NUM(LOG_12); *(int *)(driver->apps_rsp_buf + 64) = LOG_GET_ITEM_NUM(LOG_13); *(int *)(driver->apps_rsp_buf + 68) = LOG_GET_ITEM_NUM(LOG_14); *(int *)(driver->apps_rsp_buf + 72) = LOG_GET_ITEM_NUM(LOG_15); ENCODE_RSP_AND_SEND(75); return 0; } /* Respond to Get SSID Range request message */ else if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID) && (*buf == 0x7d) && (*(buf+1) == 0x1)) { driver->apps_rsp_buf[0] = 0x7d; driver->apps_rsp_buf[1] = 0x1; driver->apps_rsp_buf[2] = 0x1; driver->apps_rsp_buf[3] = 0x0; *(int *)(driver->apps_rsp_buf + 4) = MSG_MASK_TBL_CNT; *(uint16_t *)(driver->apps_rsp_buf + 8) = MSG_SSID_0; *(uint16_t *)(driver->apps_rsp_buf + 10) = MSG_SSID_0_LAST; *(uint16_t *)(driver->apps_rsp_buf + 12) = MSG_SSID_1; *(uint16_t *)(driver->apps_rsp_buf + 14) = MSG_SSID_1_LAST; *(uint16_t *)(driver->apps_rsp_buf + 16) = MSG_SSID_2; *(uint16_t *)(driver->apps_rsp_buf + 18) = MSG_SSID_2_LAST; *(uint16_t *)(driver->apps_rsp_buf + 20) = MSG_SSID_3; *(uint16_t *)(driver->apps_rsp_buf + 22) = MSG_SSID_3_LAST; *(uint16_t *)(driver->apps_rsp_buf + 24) = MSG_SSID_4; *(uint16_t *)(driver->apps_rsp_buf + 26) = MSG_SSID_4_LAST; *(uint16_t *)(driver->apps_rsp_buf + 28) = MSG_SSID_5; *(uint16_t *)(driver->apps_rsp_buf + 30) = MSG_SSID_5_LAST; *(uint16_t *)(driver->apps_rsp_buf + 32) = MSG_SSID_6; *(uint16_t *)(driver->apps_rsp_buf + 34) = MSG_SSID_6_LAST; *(uint16_t *)(driver->apps_rsp_buf + 36) = MSG_SSID_7; *(uint16_t *)(driver->apps_rsp_buf + 38) = MSG_SSID_7_LAST; *(uint16_t *)(driver->apps_rsp_buf + 40) = MSG_SSID_8; *(uint16_t *)(driver->apps_rsp_buf + 42) = MSG_SSID_8_LAST; *(uint16_t *)(driver->apps_rsp_buf + 44) = MSG_SSID_9; *(uint16_t *)(driver->apps_rsp_buf + 46) = MSG_SSID_9_LAST; *(uint16_t *)(driver->apps_rsp_buf + 48) = MSG_SSID_10; *(uint16_t *)(driver->apps_rsp_buf + 50) = MSG_SSID_10_LAST; *(uint16_t *)(driver->apps_rsp_buf + 52) = MSG_SSID_11; *(uint16_t *)(driver->apps_rsp_buf + 54) = MSG_SSID_11_LAST; *(uint16_t *)(driver->apps_rsp_buf + 56) = MSG_SSID_12; *(uint16_t *)(driver->apps_rsp_buf + 58) = MSG_SSID_12_LAST; *(uint16_t *)(driver->apps_rsp_buf + 60) = MSG_SSID_13; *(uint16_t *)(driver->apps_rsp_buf + 62) = MSG_SSID_13_LAST; *(uint16_t *)(driver->apps_rsp_buf + 64) = MSG_SSID_14; *(uint16_t *)(driver->apps_rsp_buf + 66) = MSG_SSID_14_LAST; *(uint16_t *)(driver->apps_rsp_buf + 68) = MSG_SSID_15; *(uint16_t *)(driver->apps_rsp_buf + 70) = MSG_SSID_15_LAST; *(uint16_t *)(driver->apps_rsp_buf + 72) = MSG_SSID_16; *(uint16_t *)(driver->apps_rsp_buf + 74) = MSG_SSID_16_LAST; *(uint16_t *)(driver->apps_rsp_buf + 76) = MSG_SSID_17; *(uint16_t *)(driver->apps_rsp_buf + 78) = MSG_SSID_17_LAST; *(uint16_t *)(driver->apps_rsp_buf + 80) = MSG_SSID_18; *(uint16_t *)(driver->apps_rsp_buf + 82) = MSG_SSID_18_LAST; ENCODE_RSP_AND_SEND(83); return 0; } /* Check for AO8960 Respond to Get Subsys Build mask */ else if (!(driver->ch) && (chk_config_get_id() == AO8960_TOOLS_ID) && (*buf == 0x7d) && (*(buf+1) == 0x2)) { ssid_first = *(uint16_t *)(buf + 2); ssid_last = *(uint16_t *)(buf + 4); ssid_range = 4 * (ssid_last - ssid_first + 1); /* frame response */ driver->apps_rsp_buf[0] = 0x7d; driver->apps_rsp_buf[1] = 0x2; *(uint16_t *)(driver->apps_rsp_buf + 2) = ssid_first; *(uint16_t *)(driver->apps_rsp_buf + 4) = ssid_last; driver->apps_rsp_buf[6] = 0x1; driver->apps_rsp_buf[7] = 0x0; ptr = driver->apps_rsp_buf + 8; /* bld time masks */ switch (ssid_first) { case MSG_SSID_0: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_0[i/4]; break; case MSG_SSID_1: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_1[i/4]; break; case MSG_SSID_2: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_2[i/4]; break; case MSG_SSID_3: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_3[i/4]; break; case MSG_SSID_4: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_4[i/4]; break; case MSG_SSID_5: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_5[i/4]; break; case MSG_SSID_6: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_6[i/4]; break; case MSG_SSID_7: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_7[i/4]; break; case MSG_SSID_8: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_8[i/4]; break; case MSG_SSID_9: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_9[i/4]; break; case MSG_SSID_10: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_10[i/4]; break; case MSG_SSID_11: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_11[i/4]; break; case MSG_SSID_12: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_12[i/4]; break; case MSG_SSID_13: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_13[i/4]; break; case MSG_SSID_14: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_14[i/4]; break; case MSG_SSID_15: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_15[i/4]; break; case MSG_SSID_16: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_16[i/4]; break; case MSG_SSID_17: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_17[i/4]; break; case MSG_SSID_18: for (i = 0; i < ssid_range; i += 4) *(int *)(ptr + i) = msg_bld_masks_18[i/4]; break; } ENCODE_RSP_AND_SEND(8 + ssid_range - 1); return 0; } /* Check for download command */ else if ((cpu_is_msm8x60() || cpu_is_msm8960()) && (*buf == 0x3A)) { /* send response back */ driver->apps_rsp_buf[0] = *buf; ENCODE_RSP_AND_SEND(0); msleep(5000); /* call download API */ msm_set_restart_mode(RESTART_DLOAD); printk(KERN_CRIT "diag: download mode set, Rebooting SoC..\n"); kernel_restart(NULL); /* Not required, represents that command isnt sent to modem */ return 0; } /* Check for ID for NO MODEM present */ else if (!(driver->ch)) { /* Respond to polling for Apps only DIAG */ if ((*buf == 0x4b) && (*(buf+1) == 0x32) && (*(buf+2) == 0x03)) { for (i = 0; i < 3; i++) driver->apps_rsp_buf[i] = *(buf+i); for (i = 0; i < 13; i++) driver->apps_rsp_buf[i+3] = 0; ENCODE_RSP_AND_SEND(15); return 0; } /* respond to 0x0 command */ else if (*buf == 0x00) { for (i = 0; i < 55; i++) driver->apps_rsp_buf[i] = 0; ENCODE_RSP_AND_SEND(54); return 0; } /* respond to 0x7c command */ else if (*buf == 0x7c) { driver->apps_rsp_buf[0] = 0x7c; for (i = 1; i < 8; i++) driver->apps_rsp_buf[i] = 0; /* Tools ID for APQ 8060 */ *(int *)(driver->apps_rsp_buf + 8) = chk_config_get_id(); *(unsigned char *)(driver->apps_rsp_buf + 12) = '\0'; *(unsigned char *)(driver->apps_rsp_buf + 13) = '\0'; ENCODE_RSP_AND_SEND(13); return 0; } } #endif return packet_type; }
static int msm_configure_headset_mic_gpios(void) { int ret; struct pm_gpio param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_MED, .function = PM_GPIO_FUNC_NORMAL, }; ret = gpio_request(PM8921_GPIO_PM_TO_SYS(23), "AV_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(23), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(23), 0); ret = gpio_request(us_euro_sel_gpio, "US_EURO_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, us_euro_sel_gpio); gpio_free(PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(us_euro_sel_gpio, ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, us_euro_sel_gpio); else gpio_direction_output(us_euro_sel_gpio, 0); return 0; } static void msm_free_headset_mic_gpios(void) { if (msm_headset_gpios_configured) { gpio_free(PM8921_GPIO_PM_TO_SYS(23)); gpio_free(us_euro_sel_gpio); } } static int __init msm_fighter_audio_init(void) { int ret; if (!soc_class_is_msm8960()) { pr_debug("%s: Not the right machine type\n", __func__); return -ENODEV ; } mbhc_cfg.calibration = def_tabla_mbhc_cal(); if (!mbhc_cfg.calibration) { pr_err("Calibration data allocation failed\n"); return -ENOMEM; } msm_snd_device = platform_device_alloc("soc-audio", 0); if (!msm_snd_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } platform_set_drvdata(msm_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm_snd_device); if (ret) { platform_device_put(msm_snd_device); kfree(mbhc_cfg.calibration); return ret; } if (cpu_is_msm8960()) { if (msm_configure_headset_mic_gpios()) { pr_err("%s Fail to configure headset mic gpios\n", __func__); msm_headset_gpios_configured = 0; } else msm_headset_gpios_configured = 1; } else { msm_headset_gpios_configured = 0; pr_debug("%s headset GPIO 23 and 35 not configured msm960ab", __func__); } mutex_init(&cdc_mclk_mutex); atomic_set(&auxpcm_rsc_ref, 0); return ret; }
static int __init smd_tty_init(void) { int ret; int n; int idx; smd_tty_driver = alloc_tty_driver(MAX_SMD_TTYS); if (smd_tty_driver == 0) return -ENOMEM; smd_tty_driver->owner = THIS_MODULE; smd_tty_driver->driver_name = "smd_tty_driver"; smd_tty_driver->name = "smd"; smd_tty_driver->major = 0; smd_tty_driver->minor_start = 0; smd_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; smd_tty_driver->subtype = SERIAL_TYPE_NORMAL; smd_tty_driver->init_termios = tty_std_termios; smd_tty_driver->init_termios.c_iflag = 0; smd_tty_driver->init_termios.c_oflag = 0; smd_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; smd_tty_driver->init_termios.c_lflag = 0; smd_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(smd_tty_driver, &smd_tty_ops); ret = tty_register_driver(smd_tty_driver); if (ret) { put_tty_driver(smd_tty_driver); pr_err("%s: driver registration failed %d\n", __func__, ret); return ret; } for (n = 0; n < ARRAY_SIZE(smd_configs); ++n) { idx = smd_configs[n].tty_dev_index; if (smd_configs[n].dev_name == NULL) smd_configs[n].dev_name = smd_configs[n].port_name; if (idx == DS_IDX) { int legacy_ds = 0; legacy_ds |= cpu_is_msm7x01() || cpu_is_msm7x25(); legacy_ds |= cpu_is_msm7x27() || cpu_is_msm7x30(); legacy_ds |= cpu_is_qsd8x50() || cpu_is_msm8x55(); legacy_ds |= (cpu_is_msm8960() || cpu_is_msm8930() || cpu_is_msm8930aa()) && (board_mfg_mode() == 8); legacy_ds |= cpu_is_msm8x60() && (socinfo_get_platform_subtype() == 0x0); #ifdef CONFIG_MACH_DUMMY legacy_ds = 1; #endif if (!legacy_ds) continue; } tty_register_device(smd_tty_driver, idx, 0); init_completion(&smd_tty[idx].ch_allocated); smd_tty[idx].driver.probe = smd_tty_dummy_probe; smd_tty[idx].driver.driver.name = smd_configs[n].dev_name; smd_tty[idx].driver.driver.owner = THIS_MODULE; spin_lock_init(&smd_tty[idx].reset_lock); smd_tty[idx].is_open = 0; setup_timer(&smd_tty[idx].buf_req_timer, buf_req_retry, (unsigned long)&smd_tty[idx]); init_waitqueue_head(&smd_tty[idx].ch_opened_wait_queue); ret = platform_driver_register(&smd_tty[idx].driver); if (ret) { pr_err("%s: init failed %d (%d)\n", __func__, idx, ret); smd_tty[idx].driver.probe = NULL; goto out; } smd_tty[idx].smd = &smd_configs[n]; } INIT_DELAYED_WORK(&loopback_work, loopback_probe_worker); return 0; out: for (n = 0; n < ARRAY_SIZE(smd_configs); ++n) { idx = smd_configs[n].tty_dev_index; if (smd_tty[idx].driver.probe) { platform_driver_unregister(&smd_tty[idx].driver); tty_unregister_device(smd_tty_driver, idx); } } tty_unregister_driver(smd_tty_driver); put_tty_driver(smd_tty_driver); return ret; }
static int kgsl_iommu_start(struct kgsl_mmu *mmu) { struct kgsl_device *device = mmu->device; int status; struct kgsl_iommu *iommu = mmu->priv; int i, j; if (mmu->flags & KGSL_FLAGS_STARTED) return 0; if (mmu->defaultpagetable == NULL) { status = kgsl_iommu_setup_defaultpagetable(mmu); if (status) return -ENOMEM; /* Initialize the sync lock between GPU and CPU */ if (msm_soc_version_supports_iommu_v1() && (device->id == KGSL_DEVICE_3D0)) kgsl_iommu_init_sync_lock(mmu); } /* We use the GPU MMU to control access to IOMMU registers on 8960 with * a225, hence we still keep the MMU active on 8960 */ if (cpu_is_msm8960()) { struct kgsl_mh *mh = &(mmu->device->mh); kgsl_regwrite(mmu->device, MH_MMU_CONFIG, 0x00000001); kgsl_regwrite(mmu->device, MH_MMU_MPU_END, mh->mpu_base + iommu->iommu_units[0].reg_map.gpuaddr); } else { kgsl_regwrite(mmu->device, MH_MMU_CONFIG, 0x00000000); } mmu->hwpagetable = mmu->defaultpagetable; status = kgsl_attach_pagetable_iommu_domain(mmu); if (status) { mmu->hwpagetable = NULL; goto done; } status = kgsl_iommu_enable_clk(mmu, KGSL_IOMMU_CONTEXT_USER); if (status) { KGSL_CORE_ERR("clk enable failed\n"); goto done; } status = kgsl_iommu_enable_clk(mmu, KGSL_IOMMU_CONTEXT_PRIV); if (status) { KGSL_CORE_ERR("clk enable failed\n"); goto done; } /* Get the lsb value of pagetables set in the IOMMU ttbr0 register as * that value should not change when we change pagetables, so while * changing pagetables we can use this lsb value of the pagetable w/o * having to read it again */ for (i = 0; i < iommu->unit_count; i++) { struct kgsl_iommu_unit *iommu_unit = &iommu->iommu_units[i]; for (j = 0; j < iommu_unit->dev_count; j++) iommu_unit->dev[j].pt_lsb = KGSL_IOMMMU_PT_LSB(iommu, KGSL_IOMMU_GET_CTX_REG(iommu, iommu_unit, iommu_unit->dev[j].ctx_id, TTBR0)); } kgsl_iommu_disable_clk_on_ts(mmu, 0, false); mmu->flags |= KGSL_FLAGS_STARTED; done: if (status) { kgsl_iommu_disable_clk_on_ts(mmu, 0, false); kgsl_detach_pagetable_iommu_domain(mmu); } return status; }
static void __init msm_timer_init(void) { int i; int res; int global_offset = 0; if (cpu_is_msm7x01()) { msm_clocks[MSM_CLOCK_GPT].regbase = MSM_CSR_BASE; msm_clocks[MSM_CLOCK_DGT].regbase = MSM_CSR_BASE + 0x10; } else if (cpu_is_msm7x30()) { msm_clocks[MSM_CLOCK_GPT].regbase = MSM_CSR_BASE + 0x04; msm_clocks[MSM_CLOCK_DGT].regbase = MSM_CSR_BASE + 0x24; } else if (cpu_is_qsd8x50()) { msm_clocks[MSM_CLOCK_GPT].regbase = MSM_CSR_BASE; msm_clocks[MSM_CLOCK_DGT].regbase = MSM_CSR_BASE + 0x10; } else if (cpu_is_msm8x60() || cpu_is_msm8960()) { msm_clocks[MSM_CLOCK_GPT].regbase = MSM_TMR_BASE + 0x04; msm_clocks[MSM_CLOCK_DGT].regbase = MSM_TMR_BASE + 0x24; /* Use CPU0's timer as the global timer. */ global_offset = MSM_TMR0_BASE - MSM_TMR_BASE; } else BUG(); #ifdef CONFIG_ARCH_MSM_SCORPIONMP writel(DGT_CLK_CTL_DIV_4, MSM_TMR_BASE + DGT_CLK_CTL); #endif for (i = 0; i < ARRAY_SIZE(msm_clocks); i++) { struct msm_clock *clock = &msm_clocks[i]; struct clock_event_device *ce = &clock->clockevent; struct clocksource *cs = &clock->clocksource; clock->local_counter = clock->regbase + TIMER_COUNT_VAL; clock->global_counter = clock->local_counter + global_offset; writel(0, clock->regbase + TIMER_ENABLE); writel(0, clock->regbase + TIMER_CLEAR); writel(~0, clock->regbase + TIMER_MATCH_VAL); ce->mult = div_sc(clock->freq, NSEC_PER_SEC, ce->shift); /* allow at least 10 seconds to notice that the timer wrapped */ ce->max_delta_ns = clockevent_delta2ns(0xf0000000 >> clock->shift, ce); /* 4 gets rounded down to 3 */ ce->min_delta_ns = clockevent_delta2ns(4, ce); ce->cpumask = cpumask_of(0); res = clocksource_register_hz(cs, clock->freq); if (res) printk(KERN_ERR "msm_timer_init: clocksource_register " "failed for %s\n", cs->name); res = setup_irq(clock->irq.irq, &clock->irq); if (res) printk(KERN_ERR "msm_timer_init: setup_irq " "failed for %s\n", cs->name); clockevents_register_device(ce); } }
static int __init modem_8960_init(void) { int ret; if (!cpu_is_msm8960() && !cpu_is_msm8930() && !cpu_is_msm9615()) return -ENODEV; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); xo1 = msm_xo_get(MSM_XO_TCXO_A0, "modem-8960"); if (IS_ERR(xo1)) { ret = PTR_ERR(xo1); goto out; } xo2 = msm_xo_get(MSM_XO_TCXO_A1, "modem-8960"); if (IS_ERR(xo2)) { ret = PTR_ERR(xo2); goto out; } if (ret < 0) pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); ret = request_irq(Q6FW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_fw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6fw watchdog IRQ. (%d)\n", __func__, ret); goto out; } ret = request_irq(Q6SW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n", __func__, ret); disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ); goto out; } ret = modem_subsystem_restart_init(); if (ret < 0) { pr_err("%s: Unable to reg with subsystem restart. (%d)\n", __func__, ret); goto out; } modemfw_ramdump_dev = create_ramdump_device("modem_fw"); if (!modemfw_ramdump_dev) { pr_err("%s: Unable to create modem fw ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } modemsw_ramdump_dev = create_ramdump_device("modem_sw"); if (!modemsw_ramdump_dev) { pr_err("%s: Unable to create modem sw ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } smem_ramdump_dev = create_ramdump_device("smem"); if (!smem_ramdump_dev) { pr_err("%s: Unable to create smem ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } modem_coredump_dev = create_modem_coredump_device("modem"); if (!modem_coredump_dev) { pr_err("%s: Unable to create modem coredump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } ret = modem_debugfs_init(); pr_info("%s: modem fatal driver init'ed.\n", __func__); out: return ret; }
static int msm8960_configure_headset_mic_gpios(void) { int ret; struct pm_gpio param = { .direction = PM_GPIO_DIR_OUT, .output_buffer = PM_GPIO_OUT_BUF_CMOS, .output_value = 1, .pull = PM_GPIO_PULL_NO, .vin_sel = PM_GPIO_VIN_S4, .out_strength = PM_GPIO_STRENGTH_MED, .function = PM_GPIO_FUNC_NORMAL, }; ret = gpio_request(PM8921_GPIO_PM_TO_SYS(23), "AV_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(23), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(23)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(23), 0); ret = gpio_request(PM8921_GPIO_PM_TO_SYS(35), "US_EURO_SWITCH"); if (ret) { pr_err("%s: Failed to request gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(35)); gpio_free(PM8921_GPIO_PM_TO_SYS(23)); return ret; } ret = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(35), ¶m); if (ret) pr_err("%s: Failed to configure gpio %d\n", __func__, PM8921_GPIO_PM_TO_SYS(35)); else gpio_direction_output(PM8921_GPIO_PM_TO_SYS(35), 0); return 0; } static void msm8960_free_headset_mic_gpios(void) { if (msm8960_headset_gpios_configured) { gpio_free(PM8921_GPIO_PM_TO_SYS(23)); gpio_free(PM8921_GPIO_PM_TO_SYS(35)); } } static int __init msm8960_audio_init(void) { int ret; if (!cpu_is_msm8960() && !cpu_is_msm8930()) { pr_err("%s: Not the right machine type\n", __func__); return -ENODEV ; } mbhc_cfg.calibration = def_tabla_mbhc_cal(); if (!mbhc_cfg.calibration) { pr_err("Calibration data allocation failed\n"); return -ENOMEM; } msm8960_snd_device = platform_device_alloc("soc-audio", 0); if (!msm8960_snd_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } memcpy(msm8960_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla2x, sizeof(msm8960_dai_delta_tabla2x)); platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm8960_snd_device); if (ret) { platform_device_put(msm8960_snd_device); kfree(mbhc_cfg.calibration); return ret; } msm8960_snd_tabla1x_device = platform_device_alloc("soc-audio", 1); if (!msm8960_snd_tabla1x_device) { pr_err("Platform device allocation failed\n"); kfree(mbhc_cfg.calibration); return -ENOMEM; } memcpy(msm8960_tabla1x_dai, msm8960_dai_common, sizeof(msm8960_dai_common)); memcpy(msm8960_tabla1x_dai + ARRAY_SIZE(msm8960_dai_common), msm8960_dai_delta_tabla1x, sizeof(msm8960_dai_delta_tabla1x)); platform_set_drvdata(msm8960_snd_tabla1x_device, &snd_soc_tabla1x_card_msm8960); ret = platform_device_add(msm8960_snd_tabla1x_device); if (ret) { platform_device_put(msm8960_snd_tabla1x_device); kfree(mbhc_cfg.calibration); return -ENOMEM; return ret; } if (msm8960_configure_headset_mic_gpios()) { pr_err("%s Fail to configure headset mic gpios\n", __func__); msm8960_headset_gpios_configured = 0; } else msm8960_headset_gpios_configured = 1; mutex_init(&cdc_mclk_mutex); return ret; }
static int kgsl_iommu_start(struct kgsl_mmu *mmu) { int status; struct kgsl_iommu *iommu = mmu->priv; int i, j; if (mmu->flags & KGSL_FLAGS_STARTED) return 0; if (mmu->defaultpagetable == NULL) { status = kgsl_iommu_setup_defaultpagetable(mmu); if (status) return -ENOMEM; } /* We use the GPU MMU to control access to IOMMU registers on 8960 with * a225, hence we still keep the MMU active on 8960 */ if (cpu_is_msm8960()) { struct kgsl_mh *mh = &(mmu->device->mh); kgsl_regwrite(mmu->device, MH_MMU_CONFIG, 0x00000001); kgsl_regwrite(mmu->device, MH_MMU_MPU_END, mh->mpu_base + iommu->iommu_units [iommu->unit_count - 1].reg_map.gpuaddr - PAGE_SIZE); } else { kgsl_regwrite(mmu->device, MH_MMU_CONFIG, 0x00000000); } mmu->hwpagetable = mmu->defaultpagetable; status = kgsl_attach_pagetable_iommu_domain(mmu); if (status) { mmu->hwpagetable = NULL; goto done; } status = kgsl_iommu_enable_clk(mmu, KGSL_IOMMU_CONTEXT_USER); if (status) { KGSL_CORE_ERR("clk enable failed\n"); goto done; } status = kgsl_iommu_enable_clk(mmu, KGSL_IOMMU_CONTEXT_PRIV); if (status) { KGSL_CORE_ERR("clk enable failed\n"); goto done; } /* Get the lsb value of pagetables set in the IOMMU ttbr0 register as * that value should not change when we change pagetables, so while * changing pagetables we can use this lsb value of the pagetable w/o * having to read it again */ for (i = 0; i < iommu->unit_count; i++) { struct kgsl_iommu_unit *iommu_unit = &iommu->iommu_units[i]; /* Make sure that the ASID of the priv bank is set to 1. * When we a different pagetable for the priv bank then the * iommu driver sets the ASID to 0 instead of 1 */ KGSL_IOMMU_SET_IOMMU_REG(iommu->iommu_units[i].reg_map.hostptr, KGSL_IOMMU_CONTEXT_PRIV, CONTEXTIDR, 1); for (j = 0; j < iommu_unit->dev_count; j++) iommu_unit->dev[j].pt_lsb = KGSL_IOMMMU_PT_LSB( KGSL_IOMMU_GET_IOMMU_REG( iommu_unit->reg_map.hostptr, iommu_unit->dev[j].ctx_id, TTBR0)); } iommu->asid = KGSL_IOMMU_GET_IOMMU_REG( iommu->iommu_units[0].reg_map.hostptr, KGSL_IOMMU_CONTEXT_USER, CONTEXTIDR); kgsl_iommu_disable_clk_on_ts(mmu, 0, false); mmu->flags |= KGSL_FLAGS_STARTED; done: if (status) { kgsl_iommu_disable_clk_on_ts(mmu, 0, false); kgsl_detach_pagetable_iommu_domain(mmu); } return status; }