Lines Matching refs:emif
27 #include "emif.h"
79 static void do_emif_regdump_show(struct seq_file *s, struct emif_data *emif,
82 u32 type = emif->plat_data->device_info->type;
83 u32 ip_rev = emif->plat_data->ip_rev;
117 struct emif_data *emif = s->private;
121 if (emif->duplicate)
124 regs_cache = emif->regs_cache;
127 do_emif_regdump_show(s, emif, regs_cache[i]);
138 struct emif_data *emif = s->private;
140 seq_printf(s, "MR4=%d\n", emif->temperature_level);
146 static int __init_or_module emif_debugfs_init(struct emif_data *emif)
148 emif->debugfs_root = debugfs_create_dir(dev_name(emif->dev), NULL);
149 debugfs_create_file("regcache_dump", S_IRUGO, emif->debugfs_root, emif,
151 debugfs_create_file("mr4", S_IRUGO, emif->debugfs_root, emif,
156 static void __exit emif_debugfs_exit(struct emif_data *emif)
158 debugfs_remove_recursive(emif->debugfs_root);
159 emif->debugfs_root = NULL;
162 static inline int __init_or_module emif_debugfs_init(struct emif_data *emif)
167 static inline void __exit emif_debugfs_exit(struct emif_data *emif)
187 static u32 get_emif_bus_width(struct emif_data *emif)
190 void __iomem *base = emif->base;
202 static u32 get_cl(struct emif_data *emif)
205 void __iomem *base = emif->base;
212 static void set_lpmode(struct emif_data *emif, u8 lpmode)
215 void __iomem *base = emif->base;
243 if ((emif->plat_data->ip_rev == EMIF_4D) &&
259 struct emif_data *emif;
284 list_for_each_entry(emif, &device_list, node) {
285 if (emif->lpmode == EMIF_LP_MODE_SELF_REFRESH)
286 set_lpmode(emif, EMIF_LP_MODE_DISABLE);
295 list_for_each_entry(emif, &device_list, node) {
296 if (emif->lpmode == EMIF_LP_MODE_SELF_REFRESH)
297 set_lpmode(emif, EMIF_LP_MODE_SELF_REFRESH);
335 static const struct lpddr2_timings *get_timings_table(struct emif_data *emif,
340 const struct lpddr2_timings *timings_arr = emif->plat_data->timings;
341 struct device *dev = emif->dev;
351 for (i = 0; i < emif->plat_data->timings_arr_size; i++) {
703 static u32 get_pwr_mgmt_ctrl(u32 freq, struct emif_data *emif, u32 ip_rev)
713 struct emif_custom_configs *cust_cfgs = emif->plat_data->custom_configs;
794 static void get_temperature_level(struct emif_data *emif)
799 base = emif->base;
807 if (emif->plat_data->device_info->cs1_used) {
821 emif->temperature_level = temperature_level;
828 static void setup_registers(struct emif_data *emif, struct emif_regs *regs)
830 void __iomem *base = emif->base;
838 if (emif->plat_data->ip_rev != EMIF_4D5)
849 static void setup_volt_sensitive_regs(struct emif_data *emif,
853 void __iomem *base = emif->base;
877 static void setup_temperature_sensitive_regs(struct emif_data *emif,
881 void __iomem *base = emif->base;
884 type = emif->plat_data->device_info->type;
894 temperature = emif->temperature_level;
909 static irqreturn_t handle_temp_alert(void __iomem *base, struct emif_data *emif)
916 old_temp_level = emif->temperature_level;
917 get_temperature_level(emif);
919 if (unlikely(emif->temperature_level == old_temp_level)) {
921 } else if (!emif->curr_regs) {
922 dev_err(emif->dev, "temperature alert before registers are calculated, not de-rating timings\n");
926 custom_configs = emif->plat_data->custom_configs;
934 if (emif->temperature_level >= SDRAM_TEMP_HIGH_DERATE_REFRESH) {
935 dev_err(emif->dev,
937 __func__, emif->temperature_level);
942 emif->temperature_level = SDRAM_TEMP_VERY_HIGH_SHUTDOWN;
948 if (emif->temperature_level < old_temp_level ||
949 emif->temperature_level == SDRAM_TEMP_VERY_HIGH_SHUTDOWN) {
958 setup_temperature_sensitive_regs(emif, emif->curr_regs);
970 struct emif_data *emif = dev_id;
971 void __iomem *base = emif->base;
972 struct device *dev = emif->dev;
985 ret = handle_temp_alert(base, emif);
990 if (emif->plat_data->hw_caps & EMIF_HW_CAPS_LL_INTERFACE) {
1005 struct emif_data *emif = dev_id;
1007 if (emif->temperature_level == SDRAM_TEMP_VERY_HIGH_SHUTDOWN) {
1008 dev_emerg(emif->dev, "SDRAM temperature exceeds operating limit.. Needs shut down!!!\n");
1022 if (emif->curr_regs) {
1023 setup_temperature_sensitive_regs(emif, emif->curr_regs);
1026 dev_err(emif->dev, "temperature alert before registers are calculated, not de-rating timings\n");
1034 static void clear_all_interrupts(struct emif_data *emif)
1036 void __iomem *base = emif->base;
1040 if (emif->plat_data->hw_caps & EMIF_HW_CAPS_LL_INTERFACE)
1045 static void disable_and_clear_all_interrupts(struct emif_data *emif)
1047 void __iomem *base = emif->base;
1052 if (emif->plat_data->hw_caps & EMIF_HW_CAPS_LL_INTERFACE)
1057 clear_all_interrupts(emif);
1060 static int __init_or_module setup_interrupts(struct emif_data *emif, u32 irq)
1063 void __iomem *base = emif->base;
1065 type = emif->plat_data->device_info->type;
1067 clear_all_interrupts(emif);
1076 if (emif->plat_data->hw_caps & EMIF_HW_CAPS_LL_INTERFACE) {
1083 return devm_request_threaded_irq(emif->dev, irq,
1086 0, dev_name(emif->dev),
1087 emif);
1091 static void __init_or_module emif_onetime_settings(struct emif_data *emif)
1094 void __iomem *base = emif->base;
1098 device_info = emif->plat_data->device_info;
1106 pwr_mgmt_ctrl = get_pwr_mgmt_ctrl(1000000000, emif,
1107 emif->plat_data->ip_rev);
1108 emif->lpmode = (pwr_mgmt_ctrl & LP_MODE_MASK) >> LP_MODE_SHIFT;
1117 get_temperature_level(emif);
1118 if (emif->temperature_level == SDRAM_TEMP_VERY_HIGH_SHUTDOWN)
1119 dev_emerg(emif->dev, "SDRAM temperature exceeds operating limit.. Needs shut down!!!\n");
1123 emif->plat_data->custom_configs, device_info->cs1_used,
1124 device_info->io_width, get_emif_bus_width(emif));
1131 if (emif->plat_data->phy_type != EMIF_PHY_TYPE_INTELLIPHY)
1156 static void get_default_timings(struct emif_data *emif)
1158 struct emif_platform_data *pd = emif->plat_data;
1163 dev_warn(emif->dev, "%s: using default timings\n", __func__);
1217 struct emif_data *emif)
1227 cust_cfgs = devm_kzalloc(emif->dev, sizeof(*cust_cfgs),
1257 if (!is_custom_config_valid(cust_cfgs, emif->dev)) {
1258 devm_kfree(emif->dev, cust_cfgs);
1262 emif->plat_data->custom_configs = cust_cfgs;
1302 struct emif_data *emif = NULL;
1311 emif = devm_kzalloc(dev, sizeof(struct emif_data), GFP_KERNEL);
1315 if (!emif || !pd || !dev_info) {
1321 emif->plat_data = pd;
1323 emif->dev = dev;
1324 emif->np_ddr = np_ddr;
1325 emif->temperature_level = SDRAM_TEMP_NOMINAL;
1327 if (of_device_is_compatible(np_emif, "ti,emif-4d"))
1328 emif->plat_data->ip_rev = EMIF_4D;
1329 else if (of_device_is_compatible(np_emif, "ti,emif-4d5"))
1330 emif->plat_data->ip_rev = EMIF_4D5;
1340 emif->dev)) {
1351 emif->duplicate = true;
1354 dev_warn(emif->dev, "%s: Non-symmetric DDR geometry\n",
1358 of_get_custom_configs(np_emif, emif);
1359 emif->plat_data->timings = of_get_ddr_timings(np_ddr, emif->dev,
1360 emif->plat_data->device_info->type,
1361 &emif->plat_data->timings_arr_size);
1363 emif->plat_data->min_tck = of_get_min_tck(np_ddr, emif->dev);
1369 return emif;
1385 struct emif_data *emif = NULL;
1402 emif = devm_kzalloc(dev, sizeof(*emif), GFP_KERNEL);
1406 if (!emif || !temp || !dev_info) {
1416 emif->plat_data = pd;
1417 emif->dev = dev;
1418 emif->temperature_level = SDRAM_TEMP_NOMINAL;
1426 emif->duplicate = emif1 && (memcmp(dev_info,
1430 if (emif->duplicate) {
1435 dev_warn(emif->dev, "%s: Non-symmetric DDR geometry\n",
1467 get_default_timings(emif);
1470 get_default_timings(emif);
1488 return emif;
1496 struct emif_data *emif;
1501 emif = of_get_memory_device_details(pdev->dev.of_node, &pdev->dev);
1503 emif = get_device_details(pdev);
1505 if (!emif) {
1510 list_add(&emif->node, &device_list);
1511 emif->addressing = get_addressing_table(emif->plat_data->device_info);
1513 /* Save pointers to each other in emif and device structures */
1514 emif->dev = &pdev->dev;
1515 platform_set_drvdata(pdev, emif);
1518 emif->base = devm_ioremap_resource(emif->dev, res);
1519 if (IS_ERR(emif->base))
1526 emif_onetime_settings(emif);
1527 emif_debugfs_init(emif);
1528 disable_and_clear_all_interrupts(emif);
1529 ret = setup_interrupts(emif, irq);
1535 emif1 = emif;
1546 __func__, emif->base, irq);
1555 struct emif_data *emif = platform_get_drvdata(pdev);
1557 emif_debugfs_exit(emif);
1564 struct emif_data *emif = platform_get_drvdata(pdev);
1566 disable_and_clear_all_interrupts(emif);
1569 static int get_emif_reg_values(struct emif_data *emif, u32 freq,
1581 dev = emif->dev;
1586 emif_for_calc = emif->duplicate ? emif1 : emif;
1612 cl = get_cl(emif);
1677 static struct emif_regs *get_regs(struct emif_data *emif, u32 freq)
1684 dev = emif->dev;
1685 if (emif->curr_regs && emif->curr_regs->freq == freq) {
1687 return emif->curr_regs;
1690 if (emif->duplicate)
1693 regs_cache = emif->regs_cache;
1710 regs = devm_kzalloc(emif->dev, sizeof(*regs), GFP_ATOMIC);
1714 if (get_emif_reg_values(emif, freq, regs)) {
1715 devm_kfree(emif->dev, regs);
1731 devm_kfree(emif->dev, regs_cache[i]);
1739 static void do_volt_notify_handling(struct emif_data *emif, u32 volt_state)
1741 dev_dbg(emif->dev, "%s: voltage notification : %d", __func__,
1744 if (!emif->curr_regs) {
1745 dev_err(emif->dev,
1751 setup_volt_sensitive_regs(emif, emif->curr_regs, volt_state);
1762 struct emif_data *emif;
1766 list_for_each_entry(emif, &device_list, node)
1767 do_volt_notify_handling(emif, volt_state);
1773 static void do_freq_pre_notify_handling(struct emif_data *emif, u32 new_freq)
1777 regs = get_regs(emif, new_freq);
1781 emif->curr_regs = regs;
1789 dev_dbg(emif->dev, "%s: setting up shadow registers for %uHz",
1791 setup_registers(emif, regs);
1792 setup_temperature_sensitive_regs(emif, regs);
1793 setup_volt_sensitive_regs(emif, regs, DDR_VOLTAGE_STABLE);
1799 if (emif->lpmode == EMIF_LP_MODE_SELF_REFRESH)
1800 set_lpmode(emif, EMIF_LP_MODE_DISABLE);
1811 struct emif_data *emif;
1834 list_for_each_entry(emif, &device_list, node)
1835 do_freq_pre_notify_handling(emif, new_freq);
1838 static void do_freq_post_notify_handling(struct emif_data *emif)
1844 if (emif->lpmode == EMIF_LP_MODE_SELF_REFRESH)
1845 set_lpmode(emif, EMIF_LP_MODE_SELF_REFRESH);
1856 struct emif_data *emif;
1858 list_for_each_entry(emif, &device_list, node)
1859 do_freq_post_notify_handling(emif);
1870 { .compatible = "ti,emif-4d" },
1871 { .compatible = "ti,emif-4d5" },
1881 .name = "emif",
1890 MODULE_ALIAS("platform:emif");