Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 1 | /* Copyright (c) 2014-2015, 2017, The Linux Foundation. All rights reserved. |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 2 | * |
| 3 | * This program is free software; you can redistribute it and/or modify |
| 4 | * it under the terms of the GNU General Public License version 2 and |
| 5 | * only version 2 as published by the Free Software Foundation. |
| 6 | * |
| 7 | * This program is distributed in the hope that it will be useful, |
| 8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 10 | * GNU General Public License for more details. |
| 11 | */ |
| 12 | |
| 13 | #include <linux/coresight.h> |
| 14 | #include <linux/coresight-cti.h> |
| 15 | #include <linux/workqueue.h> |
| 16 | #include <soc/qcom/sysmon.h> |
| 17 | #include "esoc-mdm.h" |
| 18 | |
| 19 | enum gpio_update_config { |
| 20 | GPIO_UPDATE_BOOTING_CONFIG = 1, |
| 21 | GPIO_UPDATE_RUNNING_CONFIG, |
| 22 | }; |
| 23 | |
| 24 | enum irq_mask { |
| 25 | IRQ_ERRFATAL = 0x1, |
| 26 | IRQ_STATUS = 0x2, |
| 27 | IRQ_PBLRDY = 0x4, |
| 28 | }; |
| 29 | |
| 30 | |
| 31 | static struct gpio_map { |
| 32 | const char *name; |
| 33 | int index; |
| 34 | } gpio_map[] = { |
| 35 | {"qcom,mdm2ap-errfatal-gpio", MDM2AP_ERRFATAL}, |
| 36 | {"qcom,ap2mdm-errfatal-gpio", AP2MDM_ERRFATAL}, |
| 37 | {"qcom,mdm2ap-status-gpio", MDM2AP_STATUS}, |
| 38 | {"qcom,ap2mdm-status-gpio", AP2MDM_STATUS}, |
| 39 | {"qcom,mdm2ap-pblrdy-gpio", MDM2AP_PBLRDY}, |
| 40 | {"qcom,ap2mdm-wakeup-gpio", AP2MDM_WAKEUP}, |
| 41 | {"qcom,ap2mdm-chnlrdy-gpio", AP2MDM_CHNLRDY}, |
| 42 | {"qcom,mdm2ap-wakeup-gpio", MDM2AP_WAKEUP}, |
| 43 | {"qcom,ap2mdm-vddmin-gpio", AP2MDM_VDDMIN}, |
| 44 | {"qcom,mdm2ap-vddmin-gpio", MDM2AP_VDDMIN}, |
| 45 | {"qcom,ap2mdm-pmic-pwr-en-gpio", AP2MDM_PMIC_PWR_EN}, |
| 46 | {"qcom,mdm-link-detect-gpio", MDM_LINK_DETECT}, |
| 47 | }; |
| 48 | |
| 49 | /* Required gpios */ |
| 50 | static const int required_gpios[] = { |
| 51 | MDM2AP_ERRFATAL, |
| 52 | AP2MDM_ERRFATAL, |
| 53 | MDM2AP_STATUS, |
| 54 | AP2MDM_STATUS, |
| 55 | }; |
| 56 | |
| 57 | static void mdm_debug_gpio_show(struct mdm_ctrl *mdm) |
| 58 | { |
| 59 | struct device *dev = mdm->dev; |
| 60 | |
| 61 | dev_dbg(dev, "%s: MDM2AP_ERRFATAL gpio = %d\n", |
| 62 | __func__, MDM_GPIO(mdm, MDM2AP_ERRFATAL)); |
| 63 | dev_dbg(dev, "%s: AP2MDM_ERRFATAL gpio = %d\n", |
| 64 | __func__, MDM_GPIO(mdm, AP2MDM_ERRFATAL)); |
| 65 | dev_dbg(dev, "%s: MDM2AP_STATUS gpio = %d\n", |
| 66 | __func__, MDM_GPIO(mdm, MDM2AP_STATUS)); |
| 67 | dev_dbg(dev, "%s: AP2MDM_STATUS gpio = %d\n", |
| 68 | __func__, MDM_GPIO(mdm, AP2MDM_STATUS)); |
| 69 | dev_dbg(dev, "%s: AP2MDM_SOFT_RESET gpio = %d\n", |
| 70 | __func__, MDM_GPIO(mdm, AP2MDM_SOFT_RESET)); |
| 71 | dev_dbg(dev, "%s: MDM2AP_WAKEUP gpio = %d\n", |
| 72 | __func__, MDM_GPIO(mdm, MDM2AP_WAKEUP)); |
| 73 | dev_dbg(dev, "%s: AP2MDM_WAKEUP gpio = %d\n", |
| 74 | __func__, MDM_GPIO(mdm, AP2MDM_WAKEUP)); |
| 75 | dev_dbg(dev, "%s: AP2MDM_PMIC_PWR_EN gpio = %d\n", |
| 76 | __func__, MDM_GPIO(mdm, AP2MDM_PMIC_PWR_EN)); |
| 77 | dev_dbg(dev, "%s: MDM2AP_PBLRDY gpio = %d\n", |
| 78 | __func__, MDM_GPIO(mdm, MDM2AP_PBLRDY)); |
| 79 | dev_dbg(dev, "%s: AP2MDM_VDDMIN gpio = %d\n", |
| 80 | __func__, MDM_GPIO(mdm, AP2MDM_VDDMIN)); |
| 81 | dev_dbg(dev, "%s: MDM2AP_VDDMIN gpio = %d\n", |
| 82 | __func__, MDM_GPIO(mdm, MDM2AP_VDDMIN)); |
| 83 | } |
| 84 | |
| 85 | static void mdm_enable_irqs(struct mdm_ctrl *mdm) |
| 86 | { |
| 87 | if (!mdm) |
| 88 | return; |
| 89 | if (mdm->irq_mask & IRQ_ERRFATAL) { |
| 90 | enable_irq(mdm->errfatal_irq); |
| 91 | irq_set_irq_wake(mdm->errfatal_irq, 1); |
| 92 | mdm->irq_mask &= ~IRQ_ERRFATAL; |
| 93 | } |
| 94 | if (mdm->irq_mask & IRQ_STATUS) { |
| 95 | enable_irq(mdm->status_irq); |
| 96 | irq_set_irq_wake(mdm->status_irq, 1); |
| 97 | mdm->irq_mask &= ~IRQ_STATUS; |
| 98 | } |
| 99 | if (mdm->irq_mask & IRQ_PBLRDY) { |
| 100 | enable_irq(mdm->pblrdy_irq); |
| 101 | mdm->irq_mask &= ~IRQ_PBLRDY; |
| 102 | } |
| 103 | } |
| 104 | |
| 105 | static void mdm_disable_irqs(struct mdm_ctrl *mdm) |
| 106 | { |
| 107 | if (!mdm) |
| 108 | return; |
| 109 | if (!(mdm->irq_mask & IRQ_ERRFATAL)) { |
| 110 | irq_set_irq_wake(mdm->errfatal_irq, 0); |
| 111 | disable_irq_nosync(mdm->errfatal_irq); |
| 112 | mdm->irq_mask |= IRQ_ERRFATAL; |
| 113 | } |
| 114 | if (!(mdm->irq_mask & IRQ_STATUS)) { |
| 115 | irq_set_irq_wake(mdm->status_irq, 0); |
| 116 | disable_irq_nosync(mdm->status_irq); |
| 117 | mdm->irq_mask |= IRQ_STATUS; |
| 118 | } |
| 119 | if (!(mdm->irq_mask & IRQ_PBLRDY)) { |
| 120 | disable_irq_nosync(mdm->pblrdy_irq); |
| 121 | mdm->irq_mask |= IRQ_PBLRDY; |
| 122 | } |
| 123 | } |
| 124 | |
| 125 | static void mdm_deconfigure_ipc(struct mdm_ctrl *mdm) |
| 126 | { |
| 127 | int i; |
| 128 | |
| 129 | for (i = 0; i < NUM_GPIOS; ++i) { |
| 130 | if (gpio_is_valid(MDM_GPIO(mdm, i))) |
| 131 | gpio_free(MDM_GPIO(mdm, i)); |
| 132 | } |
| 133 | if (mdm->mdm_queue) { |
| 134 | destroy_workqueue(mdm->mdm_queue); |
| 135 | mdm->mdm_queue = NULL; |
| 136 | } |
| 137 | } |
| 138 | |
| 139 | static void mdm_update_gpio_configs(struct mdm_ctrl *mdm, |
| 140 | enum gpio_update_config gpio_config) |
| 141 | { |
| 142 | struct pinctrl_state *pins_state = NULL; |
| 143 | /* Some gpio configuration may need updating after modem bootup.*/ |
| 144 | switch (gpio_config) { |
| 145 | case GPIO_UPDATE_RUNNING_CONFIG: |
| 146 | pins_state = mdm->gpio_state_running; |
| 147 | break; |
| 148 | case GPIO_UPDATE_BOOTING_CONFIG: |
| 149 | pins_state = mdm->gpio_state_booting; |
| 150 | break; |
| 151 | default: |
| 152 | pins_state = NULL; |
| 153 | dev_err(mdm->dev, "%s: called with no config\n", __func__); |
| 154 | break; |
| 155 | } |
| 156 | if (pins_state != NULL) { |
| 157 | if (pinctrl_select_state(mdm->pinctrl, pins_state)) |
| 158 | dev_err(mdm->dev, "switching gpio config failed\n"); |
| 159 | } |
| 160 | } |
| 161 | |
| 162 | static void mdm_trigger_dbg(struct mdm_ctrl *mdm) |
| 163 | { |
| 164 | int ret; |
| 165 | |
| 166 | if (mdm->dbg_mode && !mdm->trig_cnt) { |
| 167 | ret = coresight_cti_pulse_trig(mdm->cti, MDM_CTI_CH); |
| 168 | mdm->trig_cnt++; |
| 169 | if (ret) |
| 170 | dev_err(mdm->dev, "unable to trigger cti pulse on\n"); |
| 171 | } |
| 172 | } |
| 173 | |
| 174 | static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) |
| 175 | { |
| 176 | unsigned long end_time; |
| 177 | bool status_down = false; |
| 178 | struct mdm_ctrl *mdm = get_esoc_clink_data(esoc); |
| 179 | struct device *dev = mdm->dev; |
| 180 | int ret; |
| 181 | bool graceful_shutdown = false; |
| 182 | |
| 183 | switch (cmd) { |
| 184 | case ESOC_PWR_ON: |
| 185 | gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 0); |
| 186 | mdm_enable_irqs(mdm); |
| 187 | mdm->init = 1; |
| 188 | mdm_do_first_power_on(mdm); |
| 189 | break; |
| 190 | case ESOC_PWR_OFF: |
| 191 | mdm_disable_irqs(mdm); |
| 192 | mdm->debug = 0; |
| 193 | mdm->ready = false; |
| 194 | mdm->trig_cnt = 0; |
| 195 | graceful_shutdown = true; |
| 196 | ret = sysmon_send_shutdown(&esoc->subsys); |
| 197 | if (ret) { |
| 198 | dev_err(mdm->dev, "sysmon shutdown fail, ret = %d\n", |
| 199 | ret); |
| 200 | graceful_shutdown = false; |
| 201 | goto force_poff; |
| 202 | } |
| 203 | dev_dbg(mdm->dev, "Waiting for status gpio go low\n"); |
| 204 | status_down = false; |
| 205 | end_time = jiffies + msecs_to_jiffies(10000); |
| 206 | while (time_before(jiffies, end_time)) { |
| 207 | if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) |
| 208 | == 0) { |
| 209 | dev_dbg(dev, "Status went low\n"); |
| 210 | status_down = true; |
| 211 | break; |
| 212 | } |
| 213 | msleep(100); |
| 214 | } |
| 215 | if (status_down) |
| 216 | dev_dbg(dev, "shutdown successful\n"); |
| 217 | else |
| 218 | dev_err(mdm->dev, "graceful poff ipc fail\n"); |
| 219 | break; |
| 220 | force_poff: |
| 221 | case ESOC_FORCE_PWR_OFF: |
| 222 | if (!graceful_shutdown) { |
| 223 | mdm_disable_irqs(mdm); |
| 224 | mdm->debug = 0; |
| 225 | mdm->ready = false; |
| 226 | mdm->trig_cnt = 0; |
| 227 | |
| 228 | dev_err(mdm->dev, "Graceful shutdown fail, ret = %d\n", |
| 229 | esoc->subsys.sysmon_shutdown_ret); |
| 230 | } |
| 231 | |
| 232 | /* |
| 233 | * Force a shutdown of the mdm. This is required in order |
| 234 | * to prevent the mdm from immediately powering back on |
| 235 | * after the shutdown |
| 236 | */ |
| 237 | gpio_set_value(MDM_GPIO(mdm, AP2MDM_STATUS), 0); |
| 238 | esoc_clink_queue_request(ESOC_REQ_SHUTDOWN, esoc); |
| 239 | mdm_power_down(mdm); |
| 240 | mdm_update_gpio_configs(mdm, GPIO_UPDATE_BOOTING_CONFIG); |
| 241 | break; |
| 242 | case ESOC_RESET: |
| 243 | mdm_toggle_soft_reset(mdm, false); |
| 244 | break; |
| 245 | case ESOC_PREPARE_DEBUG: |
| 246 | /* |
| 247 | * disable all irqs except request irq (pblrdy) |
| 248 | * force a reset of the mdm by signaling |
| 249 | * an APQ crash, wait till mdm is ready for ramdumps. |
| 250 | */ |
| 251 | mdm->ready = false; |
| 252 | cancel_delayed_work(&mdm->mdm2ap_status_check_work); |
| 253 | gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 1); |
| 254 | dev_dbg(mdm->dev, "set ap2mdm errfatal to force reset\n"); |
| 255 | msleep(mdm->ramdump_delay_ms); |
| 256 | break; |
| 257 | case ESOC_EXE_DEBUG: |
| 258 | mdm->debug = 1; |
| 259 | mdm->trig_cnt = 0; |
| 260 | mdm_toggle_soft_reset(mdm, false); |
| 261 | /* |
| 262 | * wait for ramdumps to be collected |
| 263 | * then power down the mdm and switch gpios to booting |
| 264 | * config |
| 265 | */ |
| 266 | wait_for_completion(&mdm->debug_done); |
| 267 | if (mdm->debug_fail) { |
| 268 | dev_err(mdm->dev, "unable to collect ramdumps\n"); |
| 269 | mdm->debug = 0; |
| 270 | return -EIO; |
| 271 | } |
| 272 | dev_dbg(mdm->dev, "ramdump collection done\n"); |
| 273 | mdm->debug = 0; |
| 274 | init_completion(&mdm->debug_done); |
| 275 | break; |
| 276 | case ESOC_EXIT_DEBUG: |
| 277 | /* |
| 278 | * Deassert APQ to mdm err fatal |
| 279 | * Power on the mdm |
| 280 | */ |
| 281 | gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 0); |
| 282 | dev_dbg(mdm->dev, "exiting debug state after power on\n"); |
| 283 | mdm->get_restart_reason = true; |
| 284 | break; |
| 285 | default: |
| 286 | return -EINVAL; |
| 287 | }; |
| 288 | return 0; |
| 289 | } |
| 290 | |
| 291 | static void mdm2ap_status_check(struct work_struct *work) |
| 292 | { |
| 293 | struct mdm_ctrl *mdm = |
| 294 | container_of(work, struct mdm_ctrl, |
| 295 | mdm2ap_status_check_work.work); |
| 296 | struct device *dev = mdm->dev; |
| 297 | struct esoc_clink *esoc = mdm->esoc; |
| 298 | |
| 299 | if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) == 0) { |
| 300 | dev_dbg(dev, "MDM2AP_STATUS did not go high\n"); |
| 301 | esoc_clink_evt_notify(ESOC_UNEXPECTED_RESET, esoc); |
| 302 | } |
| 303 | } |
| 304 | |
| 305 | static void mdm_status_fn(struct work_struct *work) |
| 306 | { |
| 307 | struct mdm_ctrl *mdm = |
| 308 | container_of(work, struct mdm_ctrl, mdm_status_work); |
| 309 | struct device *dev = mdm->dev; |
| 310 | int value = gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)); |
| 311 | |
| 312 | dev_dbg(dev, "%s: status:%d\n", __func__, value); |
| 313 | /* Update gpio configuration to "running" config. */ |
| 314 | mdm_update_gpio_configs(mdm, GPIO_UPDATE_RUNNING_CONFIG); |
| 315 | } |
| 316 | |
| 317 | static void mdm_get_restart_reason(struct work_struct *work) |
| 318 | { |
| 319 | int ret, ntries = 0; |
| 320 | char sfr_buf[RD_BUF_SIZE]; |
| 321 | struct mdm_ctrl *mdm = |
| 322 | container_of(work, struct mdm_ctrl, restart_reason_work); |
| 323 | struct device *dev = mdm->dev; |
| 324 | |
| 325 | do { |
| 326 | ret = sysmon_get_reason(&mdm->esoc->subsys, sfr_buf, |
| 327 | sizeof(sfr_buf)); |
| 328 | if (!ret) { |
| 329 | dev_err(dev, "mdm restart reason is %s\n", sfr_buf); |
| 330 | break; |
| 331 | } |
| 332 | msleep(SFR_RETRY_INTERVAL); |
| 333 | } while (++ntries < SFR_MAX_RETRIES); |
| 334 | if (ntries == SFR_MAX_RETRIES) |
| 335 | dev_dbg(dev, "%s: Error retrieving restart reason: %d\n", |
| 336 | __func__, ret); |
| 337 | mdm->get_restart_reason = false; |
| 338 | } |
| 339 | |
| 340 | static void mdm_notify(enum esoc_notify notify, struct esoc_clink *esoc) |
| 341 | { |
| 342 | bool status_down; |
| 343 | uint64_t timeout; |
| 344 | uint64_t now; |
| 345 | struct mdm_ctrl *mdm = get_esoc_clink_data(esoc); |
| 346 | struct device *dev = mdm->dev; |
| 347 | |
| 348 | switch (notify) { |
| 349 | case ESOC_IMG_XFER_DONE: |
| 350 | if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) == 0) |
| 351 | schedule_delayed_work(&mdm->mdm2ap_status_check_work, |
| 352 | msecs_to_jiffies(MDM2AP_STATUS_TIMEOUT_MS)); |
| 353 | break; |
| 354 | case ESOC_BOOT_DONE: |
| 355 | esoc_clink_evt_notify(ESOC_RUN_STATE, esoc); |
| 356 | break; |
| 357 | case ESOC_IMG_XFER_RETRY: |
| 358 | mdm->init = 1; |
| 359 | mdm_toggle_soft_reset(mdm, false); |
| 360 | break; |
| 361 | case ESOC_IMG_XFER_FAIL: |
| 362 | esoc_clink_evt_notify(ESOC_INVALID_STATE, esoc); |
| 363 | break; |
| 364 | case ESOC_BOOT_FAIL: |
| 365 | esoc_clink_evt_notify(ESOC_INVALID_STATE, esoc); |
| 366 | break; |
| 367 | case ESOC_UPGRADE_AVAILABLE: |
| 368 | break; |
| 369 | case ESOC_DEBUG_DONE: |
| 370 | mdm->debug_fail = false; |
| 371 | mdm_update_gpio_configs(mdm, GPIO_UPDATE_BOOTING_CONFIG); |
| 372 | complete(&mdm->debug_done); |
| 373 | break; |
| 374 | case ESOC_DEBUG_FAIL: |
| 375 | mdm->debug_fail = true; |
| 376 | complete(&mdm->debug_done); |
| 377 | break; |
| 378 | case ESOC_PRIMARY_CRASH: |
| 379 | mdm_disable_irqs(mdm); |
| 380 | status_down = false; |
| 381 | dev_dbg(dev, "signal apq err fatal for graceful restart\n"); |
| 382 | gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 1); |
| 383 | timeout = local_clock(); |
| 384 | do_div(timeout, NSEC_PER_MSEC); |
| 385 | timeout += MDM_MODEM_TIMEOUT; |
| 386 | do { |
| 387 | if (gpio_get_value(MDM_GPIO(mdm, |
| 388 | MDM2AP_STATUS)) == 0) { |
| 389 | status_down = true; |
| 390 | break; |
| 391 | } |
| 392 | now = local_clock(); |
| 393 | do_div(now, NSEC_PER_MSEC); |
| 394 | } while (!time_after64(now, timeout)); |
| 395 | |
| 396 | if (!status_down) { |
| 397 | dev_err(mdm->dev, "%s MDM2AP status did not go low\n", |
| 398 | __func__); |
| 399 | mdm_toggle_soft_reset(mdm, true); |
| 400 | } |
| 401 | break; |
| 402 | case ESOC_PRIMARY_REBOOT: |
| 403 | mdm_disable_irqs(mdm); |
| 404 | mdm->debug = 0; |
| 405 | mdm->ready = false; |
| 406 | mdm_cold_reset(mdm); |
| 407 | break; |
| 408 | }; |
| 409 | } |
| 410 | |
| 411 | static irqreturn_t mdm_errfatal(int irq, void *dev_id) |
| 412 | { |
| 413 | struct mdm_ctrl *mdm = (struct mdm_ctrl *)dev_id; |
| 414 | struct esoc_clink *esoc; |
| 415 | struct device *dev; |
| 416 | |
| 417 | if (!mdm) |
| 418 | goto no_mdm_irq; |
| 419 | dev = mdm->dev; |
| 420 | if (!mdm->ready) |
| 421 | goto mdm_pwroff_irq; |
| 422 | esoc = mdm->esoc; |
| 423 | dev_err(dev, "%s: mdm sent errfatal interrupt\n", |
| 424 | __func__); |
| 425 | /* disable irq ?*/ |
| 426 | esoc_clink_evt_notify(ESOC_ERR_FATAL, esoc); |
| 427 | return IRQ_HANDLED; |
| 428 | mdm_pwroff_irq: |
| 429 | dev_info(dev, "errfatal irq when in pwroff\n"); |
| 430 | no_mdm_irq: |
| 431 | return IRQ_HANDLED; |
| 432 | } |
| 433 | |
| 434 | static irqreturn_t mdm_status_change(int irq, void *dev_id) |
| 435 | { |
| 436 | int value; |
| 437 | struct esoc_clink *esoc; |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 438 | struct device *dev; |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 439 | struct mdm_ctrl *mdm = (struct mdm_ctrl *)dev_id; |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 440 | |
| 441 | if (!mdm) |
| 442 | return IRQ_HANDLED; |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 443 | dev = mdm->dev; |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 444 | esoc = mdm->esoc; |
| 445 | value = gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)); |
| 446 | if (value == 0 && mdm->ready) { |
| 447 | dev_err(dev, "unexpected reset external modem\n"); |
| 448 | esoc_clink_evt_notify(ESOC_UNEXPECTED_RESET, esoc); |
| 449 | } else if (value == 1) { |
| 450 | cancel_delayed_work(&mdm->mdm2ap_status_check_work); |
| 451 | dev_dbg(dev, "status = 1: mdm is now ready\n"); |
| 452 | mdm->ready = true; |
| 453 | mdm_trigger_dbg(mdm); |
| 454 | queue_work(mdm->mdm_queue, &mdm->mdm_status_work); |
| 455 | if (mdm->get_restart_reason) |
| 456 | queue_work(mdm->mdm_queue, &mdm->restart_reason_work); |
| 457 | } |
| 458 | return IRQ_HANDLED; |
| 459 | } |
| 460 | |
| 461 | static irqreturn_t mdm_pblrdy_change(int irq, void *dev_id) |
| 462 | { |
| 463 | struct mdm_ctrl *mdm; |
| 464 | struct device *dev; |
| 465 | struct esoc_clink *esoc; |
| 466 | |
| 467 | mdm = (struct mdm_ctrl *)dev_id; |
| 468 | if (!mdm) |
| 469 | return IRQ_HANDLED; |
| 470 | esoc = mdm->esoc; |
| 471 | dev = mdm->dev; |
| 472 | dev_dbg(dev, "pbl ready %d:\n", |
| 473 | gpio_get_value(MDM_GPIO(mdm, MDM2AP_PBLRDY))); |
| 474 | if (mdm->init) { |
| 475 | mdm->init = 0; |
| 476 | mdm_trigger_dbg(mdm); |
| 477 | esoc_clink_queue_request(ESOC_REQ_IMG, esoc); |
| 478 | return IRQ_HANDLED; |
| 479 | } |
| 480 | if (mdm->debug) |
| 481 | esoc_clink_queue_request(ESOC_REQ_DEBUG, esoc); |
| 482 | return IRQ_HANDLED; |
| 483 | } |
| 484 | |
| 485 | static int mdm_get_status(u32 *status, struct esoc_clink *esoc) |
| 486 | { |
| 487 | struct mdm_ctrl *mdm = get_esoc_clink_data(esoc); |
| 488 | |
| 489 | if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) == 0) |
| 490 | *status = 0; |
| 491 | else |
| 492 | *status = 1; |
| 493 | return 0; |
| 494 | } |
| 495 | |
| 496 | static void mdm_configure_debug(struct mdm_ctrl *mdm) |
| 497 | { |
| 498 | void __iomem *addr; |
| 499 | unsigned int val; |
| 500 | int ret; |
| 501 | struct device_node *node = mdm->dev->of_node; |
| 502 | |
| 503 | addr = of_iomap(node, 0); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 504 | if (IS_ERR_OR_NULL(addr)) { |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 505 | dev_err(mdm->dev, "failed to get debug base address\n"); |
| 506 | return; |
| 507 | } |
| 508 | mdm->dbg_addr = addr + MDM_DBG_OFFSET; |
| 509 | val = readl_relaxed(mdm->dbg_addr); |
| 510 | if (val == MDM_DBG_MODE) { |
| 511 | mdm->dbg_mode = true; |
| 512 | mdm->cti = coresight_cti_get(MDM_CTI_NAME); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 513 | if (IS_ERR_OR_NULL(mdm->cti)) { |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 514 | dev_err(mdm->dev, "unable to get cti handle\n"); |
| 515 | goto cti_get_err; |
| 516 | } |
| 517 | ret = coresight_cti_map_trigout(mdm->cti, MDM_CTI_TRIG, |
| 518 | MDM_CTI_CH); |
| 519 | if (ret) { |
| 520 | dev_err(mdm->dev, "unable to map trig to channel\n"); |
| 521 | goto cti_map_err; |
| 522 | } |
| 523 | mdm->trig_cnt = 0; |
| 524 | } else { |
| 525 | dev_dbg(mdm->dev, "Not in debug mode. debug mode = %u\n", val); |
| 526 | mdm->dbg_mode = false; |
| 527 | } |
| 528 | return; |
| 529 | cti_map_err: |
| 530 | coresight_cti_put(mdm->cti); |
| 531 | cti_get_err: |
| 532 | mdm->dbg_mode = false; |
| 533 | } |
| 534 | |
| 535 | /* Fail if any of the required gpios is absent. */ |
| 536 | static int mdm_dt_parse_gpios(struct mdm_ctrl *mdm) |
| 537 | { |
| 538 | int i, val, rc = 0; |
| 539 | struct device_node *node = mdm->dev->of_node; |
| 540 | |
| 541 | for (i = 0; i < NUM_GPIOS; i++) |
| 542 | mdm->gpios[i] = INVALID_GPIO; |
| 543 | |
| 544 | for (i = 0; i < ARRAY_SIZE(gpio_map); i++) { |
| 545 | val = of_get_named_gpio(node, gpio_map[i].name, 0); |
| 546 | if (val >= 0) |
| 547 | MDM_GPIO(mdm, gpio_map[i].index) = val; |
| 548 | } |
| 549 | /* These two are special because they can be inverted. */ |
| 550 | /* Verify that the required gpios have valid values */ |
| 551 | for (i = 0; i < ARRAY_SIZE(required_gpios); i++) { |
| 552 | if (MDM_GPIO(mdm, required_gpios[i]) == INVALID_GPIO) { |
| 553 | rc = -ENXIO; |
| 554 | break; |
| 555 | } |
| 556 | } |
| 557 | mdm_debug_gpio_show(mdm); |
| 558 | return rc; |
| 559 | } |
| 560 | |
| 561 | static int mdm_configure_ipc(struct mdm_ctrl *mdm, struct platform_device *pdev) |
| 562 | { |
| 563 | int ret = -1; |
| 564 | int irq; |
| 565 | struct device *dev = mdm->dev; |
| 566 | struct device_node *node = pdev->dev.of_node; |
| 567 | |
| 568 | ret = of_property_read_u32(node, "qcom,ramdump-timeout-ms", |
| 569 | &mdm->dump_timeout_ms); |
| 570 | if (ret) |
| 571 | mdm->dump_timeout_ms = DEF_RAMDUMP_TIMEOUT; |
| 572 | ret = of_property_read_u32(node, "qcom,ramdump-delay-ms", |
| 573 | &mdm->ramdump_delay_ms); |
| 574 | if (ret) |
| 575 | mdm->ramdump_delay_ms = DEF_RAMDUMP_DELAY; |
| 576 | /* Multilple gpio_request calls are allowed */ |
| 577 | if (gpio_request(MDM_GPIO(mdm, AP2MDM_STATUS), "AP2MDM_STATUS")) |
| 578 | dev_err(dev, "Failed to configure AP2MDM_STATUS gpio\n"); |
| 579 | /* Multilple gpio_request calls are allowed */ |
| 580 | if (gpio_request(MDM_GPIO(mdm, AP2MDM_ERRFATAL), "AP2MDM_ERRFATAL")) |
| 581 | dev_err(dev, "%s Failed to configure AP2MDM_ERRFATAL gpio\n", |
| 582 | __func__); |
| 583 | if (gpio_request(MDM_GPIO(mdm, MDM2AP_STATUS), "MDM2AP_STATUS")) { |
| 584 | dev_err(dev, "%s Failed to configure MDM2AP_STATUS gpio\n", |
| 585 | __func__); |
| 586 | goto fatal_err; |
| 587 | } |
| 588 | if (gpio_request(MDM_GPIO(mdm, MDM2AP_ERRFATAL), "MDM2AP_ERRFATAL")) { |
| 589 | dev_err(dev, "%s Failed to configure MDM2AP_ERRFATAL gpio\n", |
| 590 | __func__); |
| 591 | goto fatal_err; |
| 592 | } |
| 593 | if (gpio_is_valid(MDM_GPIO(mdm, MDM2AP_PBLRDY))) { |
| 594 | if (gpio_request(MDM_GPIO(mdm, MDM2AP_PBLRDY), |
| 595 | "MDM2AP_PBLRDY")) { |
| 596 | dev_err(dev, "Cannot configure MDM2AP_PBLRDY gpio\n"); |
| 597 | goto fatal_err; |
| 598 | } |
| 599 | } |
| 600 | if (gpio_is_valid(MDM_GPIO(mdm, AP2MDM_WAKEUP))) { |
| 601 | if (gpio_request(MDM_GPIO(mdm, AP2MDM_WAKEUP), |
| 602 | "AP2MDM_WAKEUP")) { |
| 603 | dev_err(dev, "Cannot configure AP2MDM_WAKEUP gpio\n"); |
| 604 | goto fatal_err; |
| 605 | } |
| 606 | } |
| 607 | if (gpio_is_valid(MDM_GPIO(mdm, AP2MDM_CHNLRDY))) { |
| 608 | if (gpio_request(MDM_GPIO(mdm, AP2MDM_CHNLRDY), |
| 609 | "AP2MDM_CHNLRDY")) { |
| 610 | dev_err(dev, "Cannot configure AP2MDM_CHNLRDY gpio\n"); |
| 611 | goto fatal_err; |
| 612 | } |
| 613 | } |
| 614 | |
| 615 | gpio_direction_output(MDM_GPIO(mdm, AP2MDM_STATUS), 0); |
| 616 | gpio_direction_output(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 0); |
| 617 | |
| 618 | if (gpio_is_valid(MDM_GPIO(mdm, AP2MDM_CHNLRDY))) |
| 619 | gpio_direction_output(MDM_GPIO(mdm, AP2MDM_CHNLRDY), 0); |
| 620 | |
| 621 | gpio_direction_input(MDM_GPIO(mdm, MDM2AP_STATUS)); |
| 622 | gpio_direction_input(MDM_GPIO(mdm, MDM2AP_ERRFATAL)); |
| 623 | |
| 624 | /* ERR_FATAL irq. */ |
| 625 | irq = gpio_to_irq(MDM_GPIO(mdm, MDM2AP_ERRFATAL)); |
| 626 | if (irq < 0) { |
| 627 | dev_err(dev, "bad MDM2AP_ERRFATAL IRQ resource\n"); |
| 628 | goto errfatal_err; |
| 629 | |
| 630 | } |
| 631 | ret = request_irq(irq, mdm_errfatal, |
| 632 | IRQF_TRIGGER_RISING, "mdm errfatal", mdm); |
| 633 | |
| 634 | if (ret < 0) { |
| 635 | dev_err(dev, "%s: MDM2AP_ERRFATAL IRQ#%d request failed,\n", |
| 636 | __func__, irq); |
| 637 | goto errfatal_err; |
| 638 | } |
| 639 | mdm->errfatal_irq = irq; |
| 640 | |
| 641 | errfatal_err: |
| 642 | /* status irq */ |
| 643 | irq = gpio_to_irq(MDM_GPIO(mdm, MDM2AP_STATUS)); |
| 644 | if (irq < 0) { |
| 645 | dev_err(dev, "%s: bad MDM2AP_STATUS IRQ resource, err = %d\n", |
| 646 | __func__, irq); |
| 647 | goto status_err; |
| 648 | } |
| 649 | ret = request_threaded_irq(irq, NULL, mdm_status_change, |
| 650 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
| 651 | "mdm status", mdm); |
| 652 | if (ret < 0) { |
| 653 | dev_err(dev, "%s: MDM2AP_STATUS IRQ#%d request failed, err=%d", |
| 654 | __func__, irq, ret); |
| 655 | goto status_err; |
| 656 | } |
| 657 | mdm->status_irq = irq; |
| 658 | status_err: |
| 659 | if (gpio_is_valid(MDM_GPIO(mdm, MDM2AP_PBLRDY))) { |
| 660 | irq = platform_get_irq_byname(pdev, "plbrdy_irq"); |
| 661 | if (irq < 0) { |
| 662 | dev_err(dev, "%s: MDM2AP_PBLRDY IRQ request failed\n", |
| 663 | __func__); |
| 664 | goto pblrdy_err; |
| 665 | } |
| 666 | |
| 667 | ret = request_threaded_irq(irq, NULL, mdm_pblrdy_change, |
| 668 | IRQF_TRIGGER_RISING | IRQF_ONESHOT, |
| 669 | "mdm pbl ready", mdm); |
| 670 | if (ret < 0) { |
| 671 | dev_err(dev, "MDM2AP_PBL IRQ#%d request failed %d\n", |
| 672 | irq, ret); |
| 673 | goto pblrdy_err; |
| 674 | } |
| 675 | mdm->pblrdy_irq = irq; |
| 676 | } |
| 677 | mdm_disable_irqs(mdm); |
| 678 | pblrdy_err: |
| 679 | return 0; |
| 680 | fatal_err: |
| 681 | mdm_deconfigure_ipc(mdm); |
| 682 | return ret; |
| 683 | |
| 684 | } |
| 685 | |
| 686 | static int mdm_pinctrl_init(struct mdm_ctrl *mdm) |
| 687 | { |
| 688 | int retval = 0; |
| 689 | |
| 690 | mdm->pinctrl = devm_pinctrl_get(mdm->dev); |
| 691 | if (IS_ERR_OR_NULL(mdm->pinctrl)) { |
| 692 | retval = PTR_ERR(mdm->pinctrl); |
| 693 | goto err_state_suspend; |
| 694 | } |
| 695 | mdm->gpio_state_booting = |
| 696 | pinctrl_lookup_state(mdm->pinctrl, |
| 697 | "mdm_booting"); |
| 698 | if (IS_ERR_OR_NULL(mdm->gpio_state_booting)) { |
| 699 | mdm->gpio_state_running = NULL; |
| 700 | mdm->gpio_state_booting = NULL; |
| 701 | } else { |
| 702 | mdm->gpio_state_running = |
| 703 | pinctrl_lookup_state(mdm->pinctrl, |
| 704 | "mdm_running"); |
| 705 | if (IS_ERR_OR_NULL(mdm->gpio_state_running)) { |
| 706 | mdm->gpio_state_booting = NULL; |
| 707 | mdm->gpio_state_running = NULL; |
| 708 | } |
| 709 | } |
| 710 | mdm->gpio_state_active = |
| 711 | pinctrl_lookup_state(mdm->pinctrl, |
| 712 | "mdm_active"); |
| 713 | if (IS_ERR_OR_NULL(mdm->gpio_state_active)) { |
| 714 | retval = PTR_ERR(mdm->gpio_state_active); |
| 715 | goto err_state_active; |
| 716 | } |
| 717 | mdm->gpio_state_suspend = |
| 718 | pinctrl_lookup_state(mdm->pinctrl, |
| 719 | "mdm_suspend"); |
| 720 | if (IS_ERR_OR_NULL(mdm->gpio_state_suspend)) { |
| 721 | retval = PTR_ERR(mdm->gpio_state_suspend); |
| 722 | goto err_state_suspend; |
| 723 | } |
| 724 | retval = pinctrl_select_state(mdm->pinctrl, mdm->gpio_state_active); |
| 725 | return retval; |
| 726 | |
| 727 | err_state_suspend: |
| 728 | mdm->gpio_state_active = NULL; |
| 729 | err_state_active: |
| 730 | mdm->gpio_state_suspend = NULL; |
| 731 | mdm->gpio_state_booting = NULL; |
| 732 | mdm->gpio_state_running = NULL; |
| 733 | return retval; |
| 734 | } |
| 735 | static int mdm9x25_setup_hw(struct mdm_ctrl *mdm, |
| 736 | const struct mdm_ops *ops, |
| 737 | struct platform_device *pdev) |
| 738 | { |
| 739 | int ret; |
| 740 | struct esoc_clink *esoc; |
| 741 | const struct esoc_clink_ops *clink_ops = ops->clink_ops; |
| 742 | const struct mdm_pon_ops *pon_ops = ops->pon_ops; |
| 743 | |
| 744 | mdm->dev = &pdev->dev; |
| 745 | mdm->pon_ops = pon_ops; |
| 746 | esoc = devm_kzalloc(mdm->dev, sizeof(*esoc), GFP_KERNEL); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 747 | if (IS_ERR_OR_NULL(esoc)) { |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 748 | dev_err(mdm->dev, "cannot allocate esoc device\n"); |
| 749 | return PTR_ERR(esoc); |
| 750 | } |
| 751 | mdm->mdm_queue = alloc_workqueue("mdm_queue", 0, 0); |
| 752 | if (!mdm->mdm_queue) { |
| 753 | dev_err(mdm->dev, "could not create mdm_queue\n"); |
| 754 | return -ENOMEM; |
| 755 | } |
| 756 | mdm->irq_mask = 0; |
| 757 | mdm->ready = false; |
| 758 | ret = mdm_dt_parse_gpios(mdm); |
| 759 | if (ret) |
| 760 | return ret; |
| 761 | dev_err(mdm->dev, "parsing gpio done\n"); |
| 762 | ret = mdm_pon_dt_init(mdm); |
| 763 | if (ret) |
| 764 | return ret; |
| 765 | dev_dbg(mdm->dev, "pon dt init done\n"); |
| 766 | ret = mdm_pinctrl_init(mdm); |
| 767 | if (ret) |
| 768 | return ret; |
| 769 | dev_err(mdm->dev, "pinctrl init done\n"); |
| 770 | ret = mdm_pon_setup(mdm); |
| 771 | if (ret) |
| 772 | return ret; |
| 773 | dev_dbg(mdm->dev, "pon setup done\n"); |
| 774 | ret = mdm_configure_ipc(mdm, pdev); |
| 775 | if (ret) |
| 776 | return ret; |
| 777 | mdm_configure_debug(mdm); |
| 778 | dev_err(mdm->dev, "ipc configure done\n"); |
| 779 | esoc->name = MDM9x25_LABEL; |
| 780 | esoc->link_name = MDM9x25_HSIC; |
| 781 | esoc->clink_ops = clink_ops; |
| 782 | esoc->parent = mdm->dev; |
| 783 | esoc->owner = THIS_MODULE; |
| 784 | esoc->np = pdev->dev.of_node; |
| 785 | set_esoc_clink_data(esoc, mdm); |
| 786 | ret = esoc_clink_register(esoc); |
| 787 | if (ret) { |
| 788 | dev_err(mdm->dev, "esoc registration failed\n"); |
| 789 | return ret; |
| 790 | } |
| 791 | dev_dbg(mdm->dev, "esoc registration done\n"); |
| 792 | init_completion(&mdm->debug_done); |
| 793 | INIT_WORK(&mdm->mdm_status_work, mdm_status_fn); |
| 794 | INIT_WORK(&mdm->restart_reason_work, mdm_get_restart_reason); |
| 795 | INIT_DELAYED_WORK(&mdm->mdm2ap_status_check_work, mdm2ap_status_check); |
| 796 | mdm->get_restart_reason = false; |
| 797 | mdm->debug_fail = false; |
| 798 | mdm->esoc = esoc; |
| 799 | mdm->init = 0; |
| 800 | return 0; |
| 801 | } |
| 802 | |
| 803 | static int mdm9x35_setup_hw(struct mdm_ctrl *mdm, |
| 804 | const struct mdm_ops *ops, |
| 805 | struct platform_device *pdev) |
| 806 | { |
| 807 | int ret; |
| 808 | struct device_node *node; |
| 809 | struct esoc_clink *esoc; |
| 810 | const struct esoc_clink_ops *clink_ops = ops->clink_ops; |
| 811 | const struct mdm_pon_ops *pon_ops = ops->pon_ops; |
| 812 | |
| 813 | mdm->dev = &pdev->dev; |
| 814 | mdm->pon_ops = pon_ops; |
| 815 | node = pdev->dev.of_node; |
| 816 | esoc = devm_kzalloc(mdm->dev, sizeof(*esoc), GFP_KERNEL); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 817 | if (IS_ERR_OR_NULL(esoc)) { |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 818 | dev_err(mdm->dev, "cannot allocate esoc device\n"); |
| 819 | return PTR_ERR(esoc); |
| 820 | } |
| 821 | mdm->mdm_queue = alloc_workqueue("mdm_queue", 0, 0); |
| 822 | if (!mdm->mdm_queue) { |
| 823 | dev_err(mdm->dev, "could not create mdm_queue\n"); |
| 824 | return -ENOMEM; |
| 825 | } |
| 826 | mdm->irq_mask = 0; |
| 827 | mdm->ready = false; |
| 828 | ret = mdm_dt_parse_gpios(mdm); |
| 829 | if (ret) |
| 830 | return ret; |
| 831 | dev_dbg(mdm->dev, "parsing gpio done\n"); |
| 832 | ret = mdm_pon_dt_init(mdm); |
| 833 | if (ret) |
| 834 | return ret; |
| 835 | dev_dbg(mdm->dev, "pon dt init done\n"); |
| 836 | ret = mdm_pinctrl_init(mdm); |
| 837 | if (ret) |
| 838 | return ret; |
| 839 | dev_dbg(mdm->dev, "pinctrl init done\n"); |
| 840 | ret = mdm_pon_setup(mdm); |
| 841 | if (ret) |
| 842 | return ret; |
| 843 | dev_dbg(mdm->dev, "pon setup done\n"); |
| 844 | ret = mdm_configure_ipc(mdm, pdev); |
| 845 | if (ret) |
| 846 | return ret; |
| 847 | mdm_configure_debug(mdm); |
| 848 | dev_dbg(mdm->dev, "ipc configure done\n"); |
| 849 | esoc->name = MDM9x35_LABEL; |
| 850 | mdm->dual_interface = of_property_read_bool(node, |
| 851 | "qcom,mdm-dual-link"); |
| 852 | /* Check if link gpio is available */ |
| 853 | if (gpio_is_valid(MDM_GPIO(mdm, MDM_LINK_DETECT))) { |
| 854 | if (mdm->dual_interface) { |
| 855 | if (gpio_get_value(MDM_GPIO(mdm, MDM_LINK_DETECT))) |
| 856 | esoc->link_name = MDM9x35_DUAL_LINK; |
| 857 | else |
| 858 | esoc->link_name = MDM9x35_PCIE; |
| 859 | } else { |
| 860 | if (gpio_get_value(MDM_GPIO(mdm, MDM_LINK_DETECT))) |
| 861 | esoc->link_name = MDM9x35_HSIC; |
| 862 | else |
| 863 | esoc->link_name = MDM9x35_PCIE; |
| 864 | } |
| 865 | } else if (mdm->dual_interface) |
| 866 | esoc->link_name = MDM9x35_DUAL_LINK; |
| 867 | else |
| 868 | esoc->link_name = MDM9x35_HSIC; |
| 869 | esoc->clink_ops = clink_ops; |
| 870 | esoc->parent = mdm->dev; |
| 871 | esoc->owner = THIS_MODULE; |
| 872 | esoc->np = pdev->dev.of_node; |
| 873 | set_esoc_clink_data(esoc, mdm); |
| 874 | ret = esoc_clink_register(esoc); |
| 875 | if (ret) { |
| 876 | dev_err(mdm->dev, "esoc registration failed\n"); |
| 877 | return ret; |
| 878 | } |
| 879 | dev_dbg(mdm->dev, "esoc registration done\n"); |
| 880 | init_completion(&mdm->debug_done); |
| 881 | INIT_WORK(&mdm->mdm_status_work, mdm_status_fn); |
| 882 | INIT_WORK(&mdm->restart_reason_work, mdm_get_restart_reason); |
| 883 | INIT_DELAYED_WORK(&mdm->mdm2ap_status_check_work, mdm2ap_status_check); |
| 884 | mdm->get_restart_reason = false; |
| 885 | mdm->debug_fail = false; |
| 886 | mdm->esoc = esoc; |
| 887 | mdm->init = 0; |
| 888 | return 0; |
| 889 | } |
| 890 | |
| 891 | static int mdm9x55_setup_hw(struct mdm_ctrl *mdm, |
| 892 | const struct mdm_ops *ops, |
| 893 | struct platform_device *pdev) |
| 894 | { |
| 895 | int ret; |
| 896 | struct device_node *node; |
| 897 | struct esoc_clink *esoc; |
| 898 | const struct esoc_clink_ops *clink_ops = ops->clink_ops; |
| 899 | const struct mdm_pon_ops *pon_ops = ops->pon_ops; |
| 900 | |
| 901 | mdm->dev = &pdev->dev; |
| 902 | mdm->pon_ops = pon_ops; |
| 903 | node = pdev->dev.of_node; |
| 904 | esoc = devm_kzalloc(mdm->dev, sizeof(*esoc), GFP_KERNEL); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 905 | if (IS_ERR_OR_NULL(esoc)) { |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 906 | dev_err(mdm->dev, "cannot allocate esoc device\n"); |
| 907 | return PTR_ERR(esoc); |
| 908 | } |
| 909 | mdm->mdm_queue = alloc_workqueue("mdm_queue", 0, 0); |
| 910 | if (!mdm->mdm_queue) { |
| 911 | dev_err(mdm->dev, "could not create mdm_queue\n"); |
| 912 | return -ENOMEM; |
| 913 | } |
| 914 | mdm->irq_mask = 0; |
| 915 | mdm->ready = false; |
| 916 | ret = mdm_dt_parse_gpios(mdm); |
| 917 | if (ret) |
| 918 | return ret; |
| 919 | dev_dbg(mdm->dev, "parsing gpio done\n"); |
| 920 | ret = mdm_pon_dt_init(mdm); |
| 921 | if (ret) |
| 922 | return ret; |
| 923 | dev_dbg(mdm->dev, "pon dt init done\n"); |
| 924 | ret = mdm_pinctrl_init(mdm); |
| 925 | if (ret) |
| 926 | return ret; |
| 927 | dev_dbg(mdm->dev, "pinctrl init done\n"); |
| 928 | ret = mdm_pon_setup(mdm); |
| 929 | if (ret) |
| 930 | return ret; |
| 931 | dev_dbg(mdm->dev, "pon setup done\n"); |
| 932 | ret = mdm_configure_ipc(mdm, pdev); |
| 933 | if (ret) |
| 934 | return ret; |
| 935 | dev_dbg(mdm->dev, "ipc configure done\n"); |
| 936 | esoc->name = MDM9x55_LABEL; |
| 937 | mdm->dual_interface = of_property_read_bool(node, |
| 938 | "qcom,mdm-dual-link"); |
| 939 | esoc->link_name = MDM9x55_PCIE; |
Satya Durga Srinivasu Prabhala | b8a2a4e | 2017-03-14 16:51:50 -0700 | [diff] [blame] | 940 | ret = of_property_read_string(node, "qcom,mdm-link-info", |
| 941 | &esoc->link_info); |
| 942 | if (ret) |
| 943 | dev_info(mdm->dev, "esoc link info missing\n"); |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 944 | esoc->clink_ops = clink_ops; |
| 945 | esoc->parent = mdm->dev; |
| 946 | esoc->owner = THIS_MODULE; |
| 947 | esoc->np = pdev->dev.of_node; |
| 948 | set_esoc_clink_data(esoc, mdm); |
| 949 | ret = esoc_clink_register(esoc); |
| 950 | if (ret) { |
| 951 | dev_err(mdm->dev, "esoc registration failed\n"); |
| 952 | return ret; |
| 953 | } |
| 954 | dev_dbg(mdm->dev, "esoc registration done\n"); |
| 955 | init_completion(&mdm->debug_done); |
| 956 | INIT_WORK(&mdm->mdm_status_work, mdm_status_fn); |
| 957 | INIT_WORK(&mdm->restart_reason_work, mdm_get_restart_reason); |
| 958 | INIT_DELAYED_WORK(&mdm->mdm2ap_status_check_work, mdm2ap_status_check); |
| 959 | mdm->get_restart_reason = false; |
| 960 | mdm->debug_fail = false; |
| 961 | mdm->esoc = esoc; |
| 962 | mdm->init = 0; |
| 963 | return 0; |
| 964 | } |
| 965 | |
| 966 | static struct esoc_clink_ops mdm_cops = { |
| 967 | .cmd_exe = mdm_cmd_exe, |
| 968 | .get_status = mdm_get_status, |
| 969 | .notify = mdm_notify, |
| 970 | }; |
| 971 | |
| 972 | static struct mdm_ops mdm9x25_ops = { |
| 973 | .clink_ops = &mdm_cops, |
| 974 | .config_hw = mdm9x25_setup_hw, |
| 975 | .pon_ops = &mdm9x25_pon_ops, |
| 976 | }; |
| 977 | |
| 978 | static struct mdm_ops mdm9x35_ops = { |
| 979 | .clink_ops = &mdm_cops, |
| 980 | .config_hw = mdm9x35_setup_hw, |
| 981 | .pon_ops = &mdm9x35_pon_ops, |
| 982 | }; |
| 983 | |
| 984 | static struct mdm_ops mdm9x55_ops = { |
| 985 | .clink_ops = &mdm_cops, |
| 986 | .config_hw = mdm9x55_setup_hw, |
| 987 | .pon_ops = &mdm9x55_pon_ops, |
| 988 | }; |
| 989 | |
| 990 | static const struct of_device_id mdm_dt_match[] = { |
| 991 | { .compatible = "qcom,ext-mdm9x25", |
| 992 | .data = &mdm9x25_ops, }, |
| 993 | { .compatible = "qcom,ext-mdm9x35", |
| 994 | .data = &mdm9x35_ops, }, |
| 995 | { .compatible = "qcom,ext-mdm9x55", |
| 996 | .data = &mdm9x55_ops, }, |
| 997 | {}, |
| 998 | }; |
| 999 | MODULE_DEVICE_TABLE(of, mdm_dt_match); |
| 1000 | |
| 1001 | static int mdm_probe(struct platform_device *pdev) |
| 1002 | { |
| 1003 | const struct of_device_id *match; |
| 1004 | const struct mdm_ops *mdm_ops; |
| 1005 | struct device_node *node = pdev->dev.of_node; |
| 1006 | struct mdm_ctrl *mdm; |
| 1007 | |
| 1008 | match = of_match_node(mdm_dt_match, node); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 1009 | if (IS_ERR_OR_NULL(match)) |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 1010 | return PTR_ERR(match); |
| 1011 | mdm_ops = match->data; |
| 1012 | mdm = devm_kzalloc(&pdev->dev, sizeof(*mdm), GFP_KERNEL); |
Satya Durga Srinivasu Prabhala | 377d32f | 2017-03-15 11:09:28 -0700 | [diff] [blame] | 1013 | if (IS_ERR_OR_NULL(mdm)) |
Abhimanyu Kapur | c75b2e1 | 2016-02-22 18:15:13 -0800 | [diff] [blame] | 1014 | return PTR_ERR(mdm); |
| 1015 | return mdm_ops->config_hw(mdm, mdm_ops, pdev); |
| 1016 | } |
| 1017 | |
| 1018 | static struct platform_driver mdm_driver = { |
| 1019 | .probe = mdm_probe, |
| 1020 | .driver = { |
| 1021 | .name = "ext-mdm", |
| 1022 | .owner = THIS_MODULE, |
| 1023 | .of_match_table = of_match_ptr(mdm_dt_match), |
| 1024 | }, |
| 1025 | }; |
| 1026 | |
| 1027 | static int __init mdm_register(void) |
| 1028 | { |
| 1029 | return platform_driver_register(&mdm_driver); |
| 1030 | } |
| 1031 | module_init(mdm_register); |
| 1032 | |
| 1033 | static void __exit mdm_unregister(void) |
| 1034 | { |
| 1035 | platform_driver_unregister(&mdm_driver); |
| 1036 | } |
| 1037 | module_exit(mdm_unregister); |
| 1038 | MODULE_LICENSE("GPL v2"); |