drivers/bus/mhi/pci_generic.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * MHI PCI driver - MHI over PCI controller driver
   4  *
   5  * This module is a generic driver for registering MHI-over-PCI devices,
   6  * such as PCIe QCOM modems.
   7  *
   8  * Copyright (C) 2020 Linaro Ltd <loic.poulain@linaro.org>
   9  */
  10
  11 #include <linux/aer.h>
  12 #include <linux/delay.h>
  13 #include <linux/device.h>
  14 #include <linux/mhi.h>
  15 #include <linux/module.h>
  16 #include <linux/pci.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/timer.h>
  19 #include <linux/workqueue.h>
  20
  21 #define MHI_PCI_DEFAULT_BAR_NUM 0
  22
  23 #define MHI_POST_RESET_DELAY_MS 500
  24
  25 #define HEALTH_CHECK_PERIOD (HZ * 2)
  26
  27 /**
  28  * struct mhi_pci_dev_info - MHI PCI device specific information
  29  * @config: MHI controller configuration
  30  * @name: name of the PCI module
  31  * @fw: firmware path (if any)
  32  * @edl: emergency download mode firmware path (if any)
  33  * @bar_num: PCI base address register to use for MHI MMIO register space
  34  * @dma_data_width: DMA transfer word size (32 or 64 bits)
  35  * @sideband_wake: Devices using dedicated sideband GPIO for wakeup instead
  36  *                 of inband wake support (such as sdx24)
  37  */
  38 struct mhi_pci_dev_info {
  39         const struct mhi_controller_config *config;
  40         const char *name;
  41         const char *fw;
  42         const char *edl;
  43         unsigned int bar_num;
  44         unsigned int dma_data_width;
  45         bool sideband_wake;
  46 };
  47
  48 #define MHI_CHANNEL_CONFIG_UL(ch_num, ch_name, el_count, ev_ring) \
  49         {                                               \
  50                 .num = ch_num,                          \
  51                 .name = ch_name,                        \
  52                 .num_elements = el_count,               \
  53                 .event_ring = ev_ring,                  \
  54                 .dir = DMA_TO_DEVICE,                   \
  55                 .ee_mask = BIT(MHI_EE_AMSS),            \
  56                 .pollcfg = 0,                           \
  57                 .doorbell = MHI_DB_BRST_DISABLE,        \
  58                 .lpm_notify = false,                    \
  59                 .offload_channel = false,               \
  60                 .doorbell_mode_switch = false,          \
  61         }                                               \
  62
  63 #define MHI_CHANNEL_CONFIG_DL(ch_num, ch_name, el_count, ev_ring) \
  64         {                                               \
  65                 .num = ch_num,                          \
  66                 .name = ch_name,                        \
  67                 .num_elements = el_count,               \
  68                 .event_ring = ev_ring,                  \
  69                 .dir = DMA_FROM_DEVICE,                 \
  70                 .ee_mask = BIT(MHI_EE_AMSS),            \
  71                 .pollcfg = 0,                           \
  72                 .doorbell = MHI_DB_BRST_DISABLE,        \
  73                 .lpm_notify = false,                    \
  74                 .offload_channel = false,               \
  75                 .doorbell_mode_switch = false,          \
  76         }
  77
  78 #define MHI_CHANNEL_CONFIG_DL_AUTOQUEUE(ch_num, ch_name, el_count, ev_ring) \
  79         {                                               \
  80                 .num = ch_num,                          \
  81                 .name = ch_name,                        \
  82                 .num_elements = el_count,               \
  83                 .event_ring = ev_ring,                  \
  84                 .dir = DMA_FROM_DEVICE,                 \
  85                 .ee_mask = BIT(MHI_EE_AMSS),            \
  86                 .pollcfg = 0,                           \
  87                 .doorbell = MHI_DB_BRST_DISABLE,        \
  88                 .lpm_notify = false,                    \
  89                 .offload_channel = false,               \
  90                 .doorbell_mode_switch = false,          \
  91                 .auto_queue = true,                     \
  92         }
  93
  94 #define MHI_EVENT_CONFIG_CTRL(ev_ring, el_count) \
  95         {                                       \
  96                 .num_elements = el_count,       \
  97                 .irq_moderation_ms = 0,         \
  98                 .irq = (ev_ring) + 1,           \
  99                 .priority = 1,                  \
 100                 .mode = MHI_DB_BRST_DISABLE,    \
 101                 .data_type = MHI_ER_CTRL,       \
 102                 .hardware_event = false,        \
 103                 .client_managed = false,        \
 104                 .offload_channel = false,       \
 105         }
 106
 107 #define MHI_CHANNEL_CONFIG_HW_UL(ch_num, ch_name, el_count, ev_ring) \
 108         {                                               \
 109                 .num = ch_num,                          \
 110                 .name = ch_name,                        \
 111                 .num_elements = el_count,               \
 112                 .event_ring = ev_ring,                  \
 113                 .dir = DMA_TO_DEVICE,                   \
 114                 .ee_mask = BIT(MHI_EE_AMSS),            \
 115                 .pollcfg = 0,                           \
 116                 .doorbell = MHI_DB_BRST_ENABLE, \
 117                 .lpm_notify = false,                    \
 118                 .offload_channel = false,               \
 119                 .doorbell_mode_switch = true,           \
 120         }                                               \
 121
 122 #define MHI_CHANNEL_CONFIG_HW_DL(ch_num, ch_name, el_count, ev_ring) \
 123         {                                               \
 124                 .num = ch_num,                          \
 125                 .name = ch_name,                        \
 126                 .num_elements = el_count,               \
 127                 .event_ring = ev_ring,                  \
 128                 .dir = DMA_FROM_DEVICE,                 \
 129                 .ee_mask = BIT(MHI_EE_AMSS),            \
 130                 .pollcfg = 0,                           \
 131                 .doorbell = MHI_DB_BRST_ENABLE, \
 132                 .lpm_notify = false,                    \
 133                 .offload_channel = false,               \
 134                 .doorbell_mode_switch = true,           \
 135         }
 136
 137 #define MHI_CHANNEL_CONFIG_UL_SBL(ch_num, ch_name, el_count, ev_ring) \
 138         {                                               \
 139                 .num = ch_num,                          \
 140                 .name = ch_name,                        \
 141                 .num_elements = el_count,               \
 142                 .event_ring = ev_ring,                  \
 143                 .dir = DMA_TO_DEVICE,                   \
 144                 .ee_mask = BIT(MHI_EE_SBL),             \
 145                 .pollcfg = 0,                           \
 146                 .doorbell = MHI_DB_BRST_DISABLE,        \
 147                 .lpm_notify = false,                    \
 148                 .offload_channel = false,               \
 149                 .doorbell_mode_switch = false,          \
 150         }                                               \
 151
 152 #define MHI_CHANNEL_CONFIG_DL_SBL(ch_num, ch_name, el_count, ev_ring) \
 153         {                                               \
 154                 .num = ch_num,                          \
 155                 .name = ch_name,                        \
 156                 .num_elements = el_count,               \
 157                 .event_ring = ev_ring,                  \
 158                 .dir = DMA_FROM_DEVICE,                 \
 159                 .ee_mask = BIT(MHI_EE_SBL),             \
 160                 .pollcfg = 0,                           \
 161                 .doorbell = MHI_DB_BRST_DISABLE,        \
 162                 .lpm_notify = false,                    \
 163                 .offload_channel = false,               \
 164                 .doorbell_mode_switch = false,          \
 165         }
 166
 167 #define MHI_CHANNEL_CONFIG_UL_FP(ch_num, ch_name, el_count, ev_ring) \
 168         {                                               \
 169                 .num = ch_num,                          \
 170                 .name = ch_name,                        \
 171                 .num_elements = el_count,               \
 172                 .event_ring = ev_ring,                  \
 173                 .dir = DMA_TO_DEVICE,                   \
 174                 .ee_mask = BIT(MHI_EE_FP),              \
 175                 .pollcfg = 0,                           \
 176                 .doorbell = MHI_DB_BRST_DISABLE,        \
 177                 .lpm_notify = false,                    \
 178                 .offload_channel = false,               \
 179                 .doorbell_mode_switch = false,          \
 180         }                                               \
 181
 182 #define MHI_CHANNEL_CONFIG_DL_FP(ch_num, ch_name, el_count, ev_ring) \
 183         {                                               \
 184                 .num = ch_num,                          \
 185                 .name = ch_name,                        \
 186                 .num_elements = el_count,               \
 187                 .event_ring = ev_ring,                  \
 188                 .dir = DMA_FROM_DEVICE,                 \
 189                 .ee_mask = BIT(MHI_EE_FP),              \
 190                 .pollcfg = 0,                           \
 191                 .doorbell = MHI_DB_BRST_DISABLE,        \
 192                 .lpm_notify = false,                    \
 193                 .offload_channel = false,               \
 194                 .doorbell_mode_switch = false,          \
 195         }
 196
 197 #define MHI_EVENT_CONFIG_DATA(ev_ring, el_count) \
 198         {                                       \
 199                 .num_elements = el_count,       \
 200                 .irq_moderation_ms = 5,         \
 201                 .irq = (ev_ring) + 1,           \
 202                 .priority = 1,                  \
 203                 .mode = MHI_DB_BRST_DISABLE,    \
 204                 .data_type = MHI_ER_DATA,       \
 205                 .hardware_event = false,        \
 206                 .client_managed = false,        \
 207                 .offload_channel = false,       \
 208         }
 209
 210 #define MHI_EVENT_CONFIG_HW_DATA(ev_ring, el_count, ch_num) \
 211         {                                       \
 212                 .num_elements = el_count,       \
 213                 .irq_moderation_ms = 1,         \
 214                 .irq = (ev_ring) + 1,           \
 215                 .priority = 1,                  \
 216                 .mode = MHI_DB_BRST_DISABLE,    \
 217                 .data_type = MHI_ER_DATA,       \
 218                 .hardware_event = true,         \
 219                 .client_managed = false,        \
 220                 .offload_channel = false,       \
 221                 .channel = ch_num,              \
 222         }
 223
 224 static const struct mhi_channel_config modem_qcom_v1_mhi_channels[] = {
 225         MHI_CHANNEL_CONFIG_UL(4, "DIAG", 16, 1),
 226         MHI_CHANNEL_CONFIG_DL(5, "DIAG", 16, 1),
 227         MHI_CHANNEL_CONFIG_UL(12, "MBIM", 4, 0),
 228         MHI_CHANNEL_CONFIG_DL(13, "MBIM", 4, 0),
 229         MHI_CHANNEL_CONFIG_UL(14, "QMI", 4, 0),
 230         MHI_CHANNEL_CONFIG_DL(15, "QMI", 4, 0),
 231         MHI_CHANNEL_CONFIG_UL(20, "IPCR", 8, 0),
 232         MHI_CHANNEL_CONFIG_DL_AUTOQUEUE(21, "IPCR", 8, 0),
 233         MHI_CHANNEL_CONFIG_UL_FP(34, "FIREHOSE", 32, 0),
 234         MHI_CHANNEL_CONFIG_DL_FP(35, "FIREHOSE", 32, 0),
 235         MHI_CHANNEL_CONFIG_HW_UL(100, "IP_HW0", 128, 2),
 236         MHI_CHANNEL_CONFIG_HW_DL(101, "IP_HW0", 128, 3),
 237 };
 238
 239 static struct mhi_event_config modem_qcom_v1_mhi_events[] = {
 240         /* first ring is control+data ring */
 241         MHI_EVENT_CONFIG_CTRL(0, 64),
 242         /* DIAG dedicated event ring */
 243         MHI_EVENT_CONFIG_DATA(1, 128),
 244         /* Hardware channels request dedicated hardware event rings */
 245         MHI_EVENT_CONFIG_HW_DATA(2, 1024, 100),
 246         MHI_EVENT_CONFIG_HW_DATA(3, 2048, 101)
 247 };
 248
 249 static const struct mhi_controller_config modem_qcom_v1_mhiv_config = {
 250         .max_channels = 128,
 251         .timeout_ms = 8000,
 252         .num_channels = ARRAY_SIZE(modem_qcom_v1_mhi_channels),
 253         .ch_cfg = modem_qcom_v1_mhi_channels,
 254         .num_events = ARRAY_SIZE(modem_qcom_v1_mhi_events),
 255         .event_cfg = modem_qcom_v1_mhi_events,
 256 };
 257
 258 static const struct mhi_pci_dev_info mhi_qcom_sdx65_info = {
 259         .name = "qcom-sdx65m",
 260         .fw = "qcom/sdx65m/xbl.elf",
 261         .edl = "qcom/sdx65m/edl.mbn",
 262         .config = &modem_qcom_v1_mhiv_config,
 263         .bar_num = MHI_PCI_DEFAULT_BAR_NUM,
 264         .dma_data_width = 32,
 265         .sideband_wake = false,
 266 };
 267
 268 static const struct mhi_pci_dev_info mhi_qcom_sdx55_info = {
 269         .name = "qcom-sdx55m",
 270         .fw = "qcom/sdx55m/sbl1.mbn",
 271         .edl = "qcom/sdx55m/edl.mbn",
 272         .config = &modem_qcom_v1_mhiv_config,
 273         .bar_num = MHI_PCI_DEFAULT_BAR_NUM,
 274         .dma_data_width = 32,
 275         .sideband_wake = false,
 276 };
 277
 278 static const struct mhi_pci_dev_info mhi_qcom_sdx24_info = {
 279         .name = "qcom-sdx24",
 280         .edl = "qcom/prog_firehose_sdx24.mbn",
 281         .config = &modem_qcom_v1_mhiv_config,
 282         .bar_num = MHI_PCI_DEFAULT_BAR_NUM,
 283         .dma_data_width = 32,
 284         .sideband_wake = true,
 285 };
 286
 287 static const struct mhi_channel_config mhi_quectel_em1xx_channels[] = {
 288         MHI_CHANNEL_CONFIG_UL(0, "NMEA", 32, 0),
 289         MHI_CHANNEL_CONFIG_DL(1, "NMEA", 32, 0),
 290         MHI_CHANNEL_CONFIG_UL_SBL(2, "SAHARA", 32, 0),
 291         MHI_CHANNEL_CONFIG_DL_SBL(3, "SAHARA", 32, 0),
 292         MHI_CHANNEL_CONFIG_UL(4, "DIAG", 32, 1),
 293         MHI_CHANNEL_CONFIG_DL(5, "DIAG", 32, 1),
 294         MHI_CHANNEL_CONFIG_UL(12, "MBIM", 32, 0),
 295         MHI_CHANNEL_CONFIG_DL(13, "MBIM", 32, 0),
 296         MHI_CHANNEL_CONFIG_UL(32, "DUN", 32, 0),
 297         MHI_CHANNEL_CONFIG_DL(33, "DUN", 32, 0),
 298         /* The EDL firmware is a flash-programmer exposing firehose protocol */
 299         MHI_CHANNEL_CONFIG_UL_FP(34, "FIREHOSE", 32, 0),
 300         MHI_CHANNEL_CONFIG_DL_FP(35, "FIREHOSE", 32, 0),
 301         MHI_CHANNEL_CONFIG_HW_UL(100, "IP_HW0_MBIM", 128, 2),
 302         MHI_CHANNEL_CONFIG_HW_DL(101, "IP_HW0_MBIM", 128, 3),
 303 };
 304
 305 static struct mhi_event_config mhi_quectel_em1xx_events[] = {
 306         MHI_EVENT_CONFIG_CTRL(0, 128),
 307         MHI_EVENT_CONFIG_DATA(1, 128),
 308         MHI_EVENT_CONFIG_HW_DATA(2, 1024, 100),
 309         MHI_EVENT_CONFIG_HW_DATA(3, 1024, 101)
 310 };
 311
 312 static const struct mhi_controller_config modem_quectel_em1xx_config = {
 313         .max_channels = 128,
 314         .timeout_ms = 20000,
 315         .num_channels = ARRAY_SIZE(mhi_quectel_em1xx_channels),
 316         .ch_cfg = mhi_quectel_em1xx_channels,
 317         .num_events = ARRAY_SIZE(mhi_quectel_em1xx_events),
 318         .event_cfg = mhi_quectel_em1xx_events,
 319 };
 320
 321 static const struct mhi_pci_dev_info mhi_quectel_em1xx_info = {
 322         .name = "quectel-em1xx",
 323         .edl = "qcom/prog_firehose_sdx24.mbn",
 324         .config = &modem_quectel_em1xx_config,
 325         .bar_num = MHI_PCI_DEFAULT_BAR_NUM,
 326         .dma_data_width = 32,
 327         .sideband_wake = true,
 328 };
 329
 330 static const struct mhi_channel_config mhi_foxconn_sdx55_channels[] = {
 331         MHI_CHANNEL_CONFIG_UL(0, "LOOPBACK", 32, 0),
 332         MHI_CHANNEL_CONFIG_DL(1, "LOOPBACK", 32, 0),
 333         MHI_CHANNEL_CONFIG_UL(4, "DIAG", 32, 1),
 334         MHI_CHANNEL_CONFIG_DL(5, "DIAG", 32, 1),
 335         MHI_CHANNEL_CONFIG_UL(12, "MBIM", 32, 0),
 336         MHI_CHANNEL_CONFIG_DL(13, "MBIM", 32, 0),
 337         MHI_CHANNEL_CONFIG_UL(32, "DUN", 32, 0),
 338         MHI_CHANNEL_CONFIG_DL(33, "DUN", 32, 0),
 339         MHI_CHANNEL_CONFIG_HW_UL(100, "IP_HW0_MBIM", 128, 2),
 340         MHI_CHANNEL_CONFIG_HW_DL(101, "IP_HW0_MBIM", 128, 3),
 341 };
 342
 343 static struct mhi_event_config mhi_foxconn_sdx55_events[] = {
 344         MHI_EVENT_CONFIG_CTRL(0, 128),
 345         MHI_EVENT_CONFIG_DATA(1, 128),
 346         MHI_EVENT_CONFIG_HW_DATA(2, 1024, 100),
 347         MHI_EVENT_CONFIG_HW_DATA(3, 1024, 101)
 348 };
 349
 350 static const struct mhi_controller_config modem_foxconn_sdx55_config = {
 351         .max_channels = 128,
 352         .timeout_ms = 20000,
 353         .num_channels = ARRAY_SIZE(mhi_foxconn_sdx55_channels),
 354         .ch_cfg = mhi_foxconn_sdx55_channels,
 355         .num_events = ARRAY_SIZE(mhi_foxconn_sdx55_events),
 356         .event_cfg = mhi_foxconn_sdx55_events,
 357 };
 358
 359 static const struct mhi_pci_dev_info mhi_foxconn_sdx55_info = {
 360         .name = "foxconn-sdx55",
 361         .fw = "qcom/sdx55m/sbl1.mbn",
 362         .edl = "qcom/sdx55m/edl.mbn",
 363         .config = &modem_foxconn_sdx55_config,
 364         .bar_num = MHI_PCI_DEFAULT_BAR_NUM,
 365         .dma_data_width = 32,
 366         .sideband_wake = false,
 367 };
 368
 369 static const struct mhi_channel_config mhi_mv31_channels[] = {
 370         MHI_CHANNEL_CONFIG_UL(0, "LOOPBACK", 64, 0),
 371         MHI_CHANNEL_CONFIG_DL(1, "LOOPBACK", 64, 0),
 372         /* MBIM Control Channel */
 373         MHI_CHANNEL_CONFIG_UL(12, "MBIM", 64, 0),
 374         MHI_CHANNEL_CONFIG_DL(13, "MBIM", 64, 0),
 375         /* MBIM Data Channel */
 376         MHI_CHANNEL_CONFIG_HW_UL(100, "IP_HW0_MBIM", 512, 2),
 377         MHI_CHANNEL_CONFIG_HW_DL(101, "IP_HW0_MBIM", 512, 3),
 378 };
 379
 380 static struct mhi_event_config mhi_mv31_events[] = {
 381         MHI_EVENT_CONFIG_CTRL(0, 256),
 382         MHI_EVENT_CONFIG_DATA(1, 256),
 383         MHI_EVENT_CONFIG_HW_DATA(2, 1024, 100),
 384         MHI_EVENT_CONFIG_HW_DATA(3, 1024, 101),
 385 };
 386
 387 static const struct mhi_controller_config modem_mv31_config = {
 388         .max_channels = 128,
 389         .timeout_ms = 20000,
 390         .num_channels = ARRAY_SIZE(mhi_mv31_channels),
 391         .ch_cfg = mhi_mv31_channels,
 392         .num_events = ARRAY_SIZE(mhi_mv31_events),
 393         .event_cfg = mhi_mv31_events,
 394 };
 395
 396 static const struct mhi_pci_dev_info mhi_mv31_info = {
 397         .name = "cinterion-mv31",
 398         .config = &modem_mv31_config,
 399         .bar_num = MHI_PCI_DEFAULT_BAR_NUM,
 400         .dma_data_width = 32,
 401 };
 402
 403 static const struct pci_device_id mhi_pci_id_table[] = {
 404         { PCI_DEVICE(PCI_VENDOR_ID_QCOM, 0x0306),
 405                 .driver_data = (kernel_ulong_t) &mhi_qcom_sdx55_info },
 406         { PCI_DEVICE(PCI_VENDOR_ID_QCOM, 0x0304),
 407                 .driver_data = (kernel_ulong_t) &mhi_qcom_sdx24_info },
 408         { PCI_DEVICE(0x1eac, 0x1001), /* EM120R-GL (sdx24) */
 409                 .driver_data = (kernel_ulong_t) &mhi_quectel_em1xx_info },
 410         { PCI_DEVICE(0x1eac, 0x1002), /* EM160R-GL (sdx24) */
 411                 .driver_data = (kernel_ulong_t) &mhi_quectel_em1xx_info },
 412         { PCI_DEVICE(PCI_VENDOR_ID_QCOM, 0x0308),
 413                 .driver_data = (kernel_ulong_t) &mhi_qcom_sdx65_info },
 414         /* T99W175 (sdx55), Both for eSIM and Non-eSIM */
 415         { PCI_DEVICE(PCI_VENDOR_ID_FOXCONN, 0xe0ab),
 416                 .driver_data = (kernel_ulong_t) &mhi_foxconn_sdx55_info },
 417         /* DW5930e (sdx55), With eSIM, It's also T99W175 */
 418         { PCI_DEVICE(PCI_VENDOR_ID_FOXCONN, 0xe0b0),
 419                 .driver_data = (kernel_ulong_t) &mhi_foxconn_sdx55_info },
 420         /* DW5930e (sdx55), Non-eSIM, It's also T99W175 */
 421         { PCI_DEVICE(PCI_VENDOR_ID_FOXCONN, 0xe0b1),
 422                 .driver_data = (kernel_ulong_t) &mhi_foxconn_sdx55_info },
 423         /* MV31-W (Cinterion) */
 424         { PCI_DEVICE(0x1269, 0x00b3),
 425                 .driver_data = (kernel_ulong_t) &mhi_mv31_info },
 426         {  }
 427 };
 428 MODULE_DEVICE_TABLE(pci, mhi_pci_id_table);
 429
 430 enum mhi_pci_device_status {
 431         MHI_PCI_DEV_STARTED,
 432         MHI_PCI_DEV_SUSPENDED,
 433 };
 434
 435 struct mhi_pci_device {
 436         struct mhi_controller mhi_cntrl;
 437         struct pci_saved_state *pci_state;
 438         struct work_struct recovery_work;
 439         struct timer_list health_check_timer;
 440         unsigned long status;
 441 };
 442
 443 static int mhi_pci_read_reg(struct mhi_controller *mhi_cntrl,
 444                             void __iomem *addr, u32 *out)
 445 {
 446         *out = readl(addr);
 447         return 0;
 448 }
 449
 450 static void mhi_pci_write_reg(struct mhi_controller *mhi_cntrl,
 451                               void __iomem *addr, u32 val)
 452 {
 453         writel(val, addr);
 454 }
 455
 456 static void mhi_pci_status_cb(struct mhi_controller *mhi_cntrl,
 457                               enum mhi_callback cb)
 458 {
 459         struct pci_dev *pdev = to_pci_dev(mhi_cntrl->cntrl_dev);
 460
 461         /* Nothing to do for now */
 462         switch (cb) {
 463         case MHI_CB_FATAL_ERROR:
 464         case MHI_CB_SYS_ERROR:
 465                 dev_warn(&pdev->dev, "firmware crashed (%u)\n", cb);
 466                 pm_runtime_forbid(&pdev->dev);
 467                 break;
 468         case MHI_CB_EE_MISSION_MODE:
 469                 pm_runtime_allow(&pdev->dev);
 470                 break;
 471         default:
 472                 break;
 473         }
 474 }
 475
 476 static void mhi_pci_wake_get_nop(struct mhi_controller *mhi_cntrl, bool force)
 477 {
 478         /* no-op */
 479 }
 480
 481 static void mhi_pci_wake_put_nop(struct mhi_controller *mhi_cntrl, bool override)
 482 {
 483         /* no-op */
 484 }
 485
 486 static void mhi_pci_wake_toggle_nop(struct mhi_controller *mhi_cntrl)
 487 {
 488         /* no-op */
 489 }
 490
 491 static bool mhi_pci_is_alive(struct mhi_controller *mhi_cntrl)
 492 {
 493         struct pci_dev *pdev = to_pci_dev(mhi_cntrl->cntrl_dev);
 494         u16 vendor = 0;
 495
 496         if (pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor))
 497                 return false;
 498
 499         if (vendor == (u16) ~0 || vendor == 0)
 500                 return false;
 501
 502         return true;
 503 }
 504
 505 static int mhi_pci_claim(struct mhi_controller *mhi_cntrl,
 506                          unsigned int bar_num, u64 dma_mask)
 507 {
 508         struct pci_dev *pdev = to_pci_dev(mhi_cntrl->cntrl_dev);
 509         int err;
 510
 511         err = pci_assign_resource(pdev, bar_num);
 512         if (err)
 513                 return err;
 514
 515         err = pcim_enable_device(pdev);
 516         if (err) {
 517                 dev_err(&pdev->dev, "failed to enable pci device: %d\n", err);
 518                 return err;
 519         }
 520
 521         err = pcim_iomap_regions(pdev, 1 << bar_num, pci_name(pdev));
 522         if (err) {
 523                 dev_err(&pdev->dev, "failed to map pci region: %d\n", err);
 524                 return err;
 525         }
 526         mhi_cntrl->regs = pcim_iomap_table(pdev)[bar_num];
 527         mhi_cntrl->reg_len = pci_resource_len(pdev, bar_num);
 528
 529         err = pci_set_dma_mask(pdev, dma_mask);
 530         if (err) {
 531                 dev_err(&pdev->dev, "Cannot set proper DMA mask\n");
 532                 return err;
 533         }
 534
 535         err = pci_set_consistent_dma_mask(pdev, dma_mask);
 536         if (err) {
 537                 dev_err(&pdev->dev, "set consistent dma mask failed\n");
 538                 return err;
 539         }
 540
 541         pci_set_master(pdev);
 542
 543         return 0;
 544 }
 545
 546 static int mhi_pci_get_irqs(struct mhi_controller *mhi_cntrl,
 547                             const struct mhi_controller_config *mhi_cntrl_config)
 548 {
 549         struct pci_dev *pdev = to_pci_dev(mhi_cntrl->cntrl_dev);
 550         int nr_vectors, i;
 551         int *irq;
 552
 553         /*
 554          * Alloc one MSI vector for BHI + one vector per event ring, ideally...
 555          * No explicit pci_free_irq_vectors required, done by pcim_release.
 556          */
 557         mhi_cntrl->nr_irqs = 1 + mhi_cntrl_config->num_events;
 558
 559         nr_vectors = pci_alloc_irq_vectors(pdev, 1, mhi_cntrl->nr_irqs, PCI_IRQ_MSI);
 560         if (nr_vectors < 0) {
 561                 dev_err(&pdev->dev, "Error allocating MSI vectors %d\n",
 562                         nr_vectors);
 563                 return nr_vectors;
 564         }
 565
 566         if (nr_vectors < mhi_cntrl->nr_irqs) {
 567                 dev_warn(&pdev->dev, "using shared MSI\n");
 568
 569                 /* Patch msi vectors, use only one (shared) */
 570                 for (i = 0; i < mhi_cntrl_config->num_events; i++)
 571                         mhi_cntrl_config->event_cfg[i].irq = 0;
 572                 mhi_cntrl->nr_irqs = 1;
 573         }
 574
 575         irq = devm_kcalloc(&pdev->dev, mhi_cntrl->nr_irqs, sizeof(int), GFP_KERNEL);
 576         if (!irq)
 577                 return -ENOMEM;
 578
 579         for (i = 0; i < mhi_cntrl->nr_irqs; i++) {
 580                 int vector = i >= nr_vectors ? (nr_vectors - 1) : i;
 581
 582                 irq[i] = pci_irq_vector(pdev, vector);
 583         }
 584
 585         mhi_cntrl->irq = irq;
 586
 587         return 0;
 588 }
 589
 590 static int mhi_pci_runtime_get(struct mhi_controller *mhi_cntrl)
 591 {
 592         /* The runtime_get() MHI callback means:
 593          *    Do whatever is requested to leave M3.
 594          */
 595         return pm_runtime_get(mhi_cntrl->cntrl_dev);
 596 }
 597
 598 static void mhi_pci_runtime_put(struct mhi_controller *mhi_cntrl)
 599 {
 600         /* The runtime_put() MHI callback means:
 601          *    Device can be moved in M3 state.
 602          */
 603         pm_runtime_mark_last_busy(mhi_cntrl->cntrl_dev);
 604         pm_runtime_put(mhi_cntrl->cntrl_dev);
 605 }
 606
 607 static void mhi_pci_recovery_work(struct work_struct *work)
 608 {
 609         struct mhi_pci_device *mhi_pdev = container_of(work, struct mhi_pci_device,
 610                                                        recovery_work);
 611         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 612         struct pci_dev *pdev = to_pci_dev(mhi_cntrl->cntrl_dev);
 613         int err;
 614
 615         dev_warn(&pdev->dev, "device recovery started\n");
 616
 617         del_timer(&mhi_pdev->health_check_timer);
 618         pm_runtime_forbid(&pdev->dev);
 619
 620         /* Clean up MHI state */
 621         if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
 622                 mhi_power_down(mhi_cntrl, false);
 623                 mhi_unprepare_after_power_down(mhi_cntrl);
 624         }
 625
 626         pci_set_power_state(pdev, PCI_D0);
 627         pci_load_saved_state(pdev, mhi_pdev->pci_state);
 628         pci_restore_state(pdev);
 629
 630         if (!mhi_pci_is_alive(mhi_cntrl))
 631                 goto err_try_reset;
 632
 633         err = mhi_prepare_for_power_up(mhi_cntrl);
 634         if (err)
 635                 goto err_try_reset;
 636
 637         err = mhi_sync_power_up(mhi_cntrl);
 638         if (err)
 639                 goto err_unprepare;
 640
 641         dev_dbg(&pdev->dev, "Recovery completed\n");
 642
 643         set_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status);
 644         mod_timer(&mhi_pdev->health_check_timer, jiffies + HEALTH_CHECK_PERIOD);
 645         return;
 646
 647 err_unprepare:
 648         mhi_unprepare_after_power_down(mhi_cntrl);
 649 err_try_reset:
 650         if (pci_reset_function(pdev))
 651                 dev_err(&pdev->dev, "Recovery failed\n");
 652 }
 653
 654 static void health_check(struct timer_list *t)
 655 {
 656         struct mhi_pci_device *mhi_pdev = from_timer(mhi_pdev, t, health_check_timer);
 657         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 658
 659         if (!test_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status) ||
 660                         test_bit(MHI_PCI_DEV_SUSPENDED, &mhi_pdev->status))
 661                 return;
 662
 663         if (!mhi_pci_is_alive(mhi_cntrl)) {
 664                 dev_err(mhi_cntrl->cntrl_dev, "Device died\n");
 665                 queue_work(system_long_wq, &mhi_pdev->recovery_work);
 666                 return;
 667         }
 668
 669         /* reschedule in two seconds */
 670         mod_timer(&mhi_pdev->health_check_timer, jiffies + HEALTH_CHECK_PERIOD);
 671 }
 672
 673 static int mhi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 674 {
 675         const struct mhi_pci_dev_info *info = (struct mhi_pci_dev_info *) id->driver_data;
 676         const struct mhi_controller_config *mhi_cntrl_config;
 677         struct mhi_pci_device *mhi_pdev;
 678         struct mhi_controller *mhi_cntrl;
 679         int err;
 680
 681         dev_dbg(&pdev->dev, "MHI PCI device found: %s\n", info->name);
 682
 683         /* mhi_pdev.mhi_cntrl must be zero-initialized */
 684         mhi_pdev = devm_kzalloc(&pdev->dev, sizeof(*mhi_pdev), GFP_KERNEL);
 685         if (!mhi_pdev)
 686                 return -ENOMEM;
 687
 688         INIT_WORK(&mhi_pdev->recovery_work, mhi_pci_recovery_work);
 689         timer_setup(&mhi_pdev->health_check_timer, health_check, 0);
 690
 691         mhi_cntrl_config = info->config;
 692         mhi_cntrl = &mhi_pdev->mhi_cntrl;
 693
 694         mhi_cntrl->cntrl_dev = &pdev->dev;
 695         mhi_cntrl->iova_start = 0;
 696         mhi_cntrl->iova_stop = (dma_addr_t)DMA_BIT_MASK(info->dma_data_width);
 697         mhi_cntrl->fw_image = info->fw;
 698         mhi_cntrl->edl_image = info->edl;
 699
 700         mhi_cntrl->read_reg = mhi_pci_read_reg;
 701         mhi_cntrl->write_reg = mhi_pci_write_reg;
 702         mhi_cntrl->status_cb = mhi_pci_status_cb;
 703         mhi_cntrl->runtime_get = mhi_pci_runtime_get;
 704         mhi_cntrl->runtime_put = mhi_pci_runtime_put;
 705
 706         if (info->sideband_wake) {
 707                 mhi_cntrl->wake_get = mhi_pci_wake_get_nop;
 708                 mhi_cntrl->wake_put = mhi_pci_wake_put_nop;
 709                 mhi_cntrl->wake_toggle = mhi_pci_wake_toggle_nop;
 710         }
 711
 712         err = mhi_pci_claim(mhi_cntrl, info->bar_num, DMA_BIT_MASK(info->dma_data_width));
 713         if (err)
 714                 return err;
 715
 716         err = mhi_pci_get_irqs(mhi_cntrl, mhi_cntrl_config);
 717         if (err)
 718                 return err;
 719
 720         pci_set_drvdata(pdev, mhi_pdev);
 721
 722         /* Have stored pci confspace at hand for restore in sudden PCI error.
 723          * cache the state locally and discard the PCI core one.
 724          */
 725         pci_save_state(pdev);
 726         mhi_pdev->pci_state = pci_store_saved_state(pdev);
 727         pci_load_saved_state(pdev, NULL);
 728
 729         pci_enable_pcie_error_reporting(pdev);
 730
 731         err = mhi_register_controller(mhi_cntrl, mhi_cntrl_config);
 732         if (err)
 733                 goto err_disable_reporting;
 734
 735         /* MHI bus does not power up the controller by default */
 736         err = mhi_prepare_for_power_up(mhi_cntrl);
 737         if (err) {
 738                 dev_err(&pdev->dev, "failed to prepare MHI controller\n");
 739                 goto err_unregister;
 740         }
 741
 742         err = mhi_sync_power_up(mhi_cntrl);
 743         if (err) {
 744                 dev_err(&pdev->dev, "failed to power up MHI controller\n");
 745                 goto err_unprepare;
 746         }
 747
 748         set_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status);
 749
 750         /* start health check */
 751         mod_timer(&mhi_pdev->health_check_timer, jiffies + HEALTH_CHECK_PERIOD);
 752
 753         /* Only allow runtime-suspend if PME capable (for wakeup) */
 754         if (pci_pme_capable(pdev, PCI_D3hot)) {
 755                 pm_runtime_set_autosuspend_delay(&pdev->dev, 2000);
 756                 pm_runtime_use_autosuspend(&pdev->dev);
 757                 pm_runtime_mark_last_busy(&pdev->dev);
 758                 pm_runtime_put_noidle(&pdev->dev);
 759         }
 760
 761         return 0;
 762
 763 err_unprepare:
 764         mhi_unprepare_after_power_down(mhi_cntrl);
 765 err_unregister:
 766         mhi_unregister_controller(mhi_cntrl);
 767 err_disable_reporting:
 768         pci_disable_pcie_error_reporting(pdev);
 769
 770         return err;
 771 }
 772
 773 static void mhi_pci_remove(struct pci_dev *pdev)
 774 {
 775         struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);
 776         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 777
 778         del_timer_sync(&mhi_pdev->health_check_timer);
 779         cancel_work_sync(&mhi_pdev->recovery_work);
 780
 781         if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
 782                 mhi_power_down(mhi_cntrl, true);
 783                 mhi_unprepare_after_power_down(mhi_cntrl);
 784         }
 785
 786         /* balancing probe put_noidle */
 787         if (pci_pme_capable(pdev, PCI_D3hot))
 788                 pm_runtime_get_noresume(&pdev->dev);
 789
 790         mhi_unregister_controller(mhi_cntrl);
 791         pci_disable_pcie_error_reporting(pdev);
 792 }
 793
 794 static void mhi_pci_shutdown(struct pci_dev *pdev)
 795 {
 796         mhi_pci_remove(pdev);
 797         pci_set_power_state(pdev, PCI_D3hot);
 798 }
 799
 800 static void mhi_pci_reset_prepare(struct pci_dev *pdev)
 801 {
 802         struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);
 803         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 804
 805         dev_info(&pdev->dev, "reset\n");
 806
 807         del_timer(&mhi_pdev->health_check_timer);
 808
 809         /* Clean up MHI state */
 810         if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
 811                 mhi_power_down(mhi_cntrl, false);
 812                 mhi_unprepare_after_power_down(mhi_cntrl);
 813         }
 814
 815         /* cause internal device reset */
 816         mhi_soc_reset(mhi_cntrl);
 817
 818         /* Be sure device reset has been executed */
 819         msleep(MHI_POST_RESET_DELAY_MS);
 820 }
 821
 822 static void mhi_pci_reset_done(struct pci_dev *pdev)
 823 {
 824         struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);
 825         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 826         int err;
 827
 828         /* Restore initial known working PCI state */
 829         pci_load_saved_state(pdev, mhi_pdev->pci_state);
 830         pci_restore_state(pdev);
 831
 832         /* Is device status available ? */
 833         if (!mhi_pci_is_alive(mhi_cntrl)) {
 834                 dev_err(&pdev->dev, "reset failed\n");
 835                 return;
 836         }
 837
 838         err = mhi_prepare_for_power_up(mhi_cntrl);
 839         if (err) {
 840                 dev_err(&pdev->dev, "failed to prepare MHI controller\n");
 841                 return;
 842         }
 843
 844         err = mhi_sync_power_up(mhi_cntrl);
 845         if (err) {
 846                 dev_err(&pdev->dev, "failed to power up MHI controller\n");
 847                 mhi_unprepare_after_power_down(mhi_cntrl);
 848                 return;
 849         }
 850
 851         set_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status);
 852         mod_timer(&mhi_pdev->health_check_timer, jiffies + HEALTH_CHECK_PERIOD);
 853 }
 854
 855 static pci_ers_result_t mhi_pci_error_detected(struct pci_dev *pdev,
 856                                                pci_channel_state_t state)
 857 {
 858         struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);
 859         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 860
 861         dev_err(&pdev->dev, "PCI error detected, state = %u\n", state);
 862
 863         if (state == pci_channel_io_perm_failure)
 864                 return PCI_ERS_RESULT_DISCONNECT;
 865
 866         /* Clean up MHI state */
 867         if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
 868                 mhi_power_down(mhi_cntrl, false);
 869                 mhi_unprepare_after_power_down(mhi_cntrl);
 870         } else {
 871                 /* Nothing to do */
 872                 return PCI_ERS_RESULT_RECOVERED;
 873         }
 874
 875         pci_disable_device(pdev);
 876
 877         return PCI_ERS_RESULT_NEED_RESET;
 878 }
 879
 880 static pci_ers_result_t mhi_pci_slot_reset(struct pci_dev *pdev)
 881 {
 882         if (pci_enable_device(pdev)) {
 883                 dev_err(&pdev->dev, "Cannot re-enable PCI device after reset.\n");
 884                 return PCI_ERS_RESULT_DISCONNECT;
 885         }
 886
 887         return PCI_ERS_RESULT_RECOVERED;
 888 }
 889
 890 static void mhi_pci_io_resume(struct pci_dev *pdev)
 891 {
 892         struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);
 893
 894         dev_err(&pdev->dev, "PCI slot reset done\n");
 895
 896         queue_work(system_long_wq, &mhi_pdev->recovery_work);
 897 }
 898
 899 static const struct pci_error_handlers mhi_pci_err_handler = {
 900         .error_detected = mhi_pci_error_detected,
 901         .slot_reset = mhi_pci_slot_reset,
 902         .resume = mhi_pci_io_resume,
 903         .reset_prepare = mhi_pci_reset_prepare,
 904         .reset_done = mhi_pci_reset_done,
 905 };
 906
 907 static int  __maybe_unused mhi_pci_runtime_suspend(struct device *dev)
 908 {
 909         struct pci_dev *pdev = to_pci_dev(dev);
 910         struct mhi_pci_device *mhi_pdev = dev_get_drvdata(dev);
 911         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 912         int err;
 913
 914         if (test_and_set_bit(MHI_PCI_DEV_SUSPENDED, &mhi_pdev->status))
 915                 return 0;
 916
 917         del_timer(&mhi_pdev->health_check_timer);
 918         cancel_work_sync(&mhi_pdev->recovery_work);
 919
 920         if (!test_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status) ||
 921                         mhi_cntrl->ee != MHI_EE_AMSS)
 922                 goto pci_suspend; /* Nothing to do at MHI level */
 923
 924         /* Transition to M3 state */
 925         err = mhi_pm_suspend(mhi_cntrl);
 926         if (err) {
 927                 dev_err(&pdev->dev, "failed to suspend device: %d\n", err);
 928                 clear_bit(MHI_PCI_DEV_SUSPENDED, &mhi_pdev->status);
 929                 return -EBUSY;
 930         }
 931
 932 pci_suspend:
 933         pci_disable_device(pdev);
 934         pci_wake_from_d3(pdev, true);
 935
 936         return 0;
 937 }
 938
 939 static int __maybe_unused mhi_pci_runtime_resume(struct device *dev)
 940 {
 941         struct pci_dev *pdev = to_pci_dev(dev);
 942         struct mhi_pci_device *mhi_pdev = dev_get_drvdata(dev);
 943         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
 944         int err;
 945
 946         if (!test_and_clear_bit(MHI_PCI_DEV_SUSPENDED, &mhi_pdev->status))
 947                 return 0;
 948
 949         err = pci_enable_device(pdev);
 950         if (err)
 951                 goto err_recovery;
 952
 953         pci_set_master(pdev);
 954         pci_wake_from_d3(pdev, false);
 955
 956         if (!test_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status) ||
 957                         mhi_cntrl->ee != MHI_EE_AMSS)
 958                 return 0; /* Nothing to do at MHI level */
 959
 960         /* Exit M3, transition to M0 state */
 961         err = mhi_pm_resume(mhi_cntrl);
 962         if (err) {
 963                 dev_err(&pdev->dev, "failed to resume device: %d\n", err);
 964                 goto err_recovery;
 965         }
 966
 967         /* Resume health check */
 968         mod_timer(&mhi_pdev->health_check_timer, jiffies + HEALTH_CHECK_PERIOD);
 969
 970         /* It can be a remote wakeup (no mhi runtime_get), update access time */
 971         pm_runtime_mark_last_busy(dev);
 972
 973         return 0;
 974
 975 err_recovery:
 976         /* Do not fail to not mess up our PCI device state, the device likely
 977          * lost power (d3cold) and we simply need to reset it from the recovery
 978          * procedure, trigger the recovery asynchronously to prevent system
 979          * suspend exit delaying.
 980          */
 981         queue_work(system_long_wq, &mhi_pdev->recovery_work);
 982         pm_runtime_mark_last_busy(dev);
 983
 984         return 0;
 985 }
 986
 987 static int  __maybe_unused mhi_pci_suspend(struct device *dev)
 988 {
 989         pm_runtime_disable(dev);
 990         return mhi_pci_runtime_suspend(dev);
 991 }
 992
 993 static int __maybe_unused mhi_pci_resume(struct device *dev)
 994 {
 995         int ret;
 996
 997         /* Depending the platform, device may have lost power (d3cold), we need
 998          * to resume it now to check its state and recover when necessary.
 999          */
1000         ret = mhi_pci_runtime_resume(dev);
1001         pm_runtime_enable(dev);
1002
1003         return ret;
1004 }
1005
1006 static int __maybe_unused mhi_pci_freeze(struct device *dev)
1007 {
1008         struct mhi_pci_device *mhi_pdev = dev_get_drvdata(dev);
1009         struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
1010
1011         /* We want to stop all operations, hibernation does not guarantee that
1012          * device will be in the same state as before freezing, especially if
1013          * the intermediate restore kernel reinitializes MHI device with new
1014          * context.
1015          */
1016         if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
1017                 mhi_power_down(mhi_cntrl, false);
1018                 mhi_unprepare_after_power_down(mhi_cntrl);
1019         }
1020
1021         return 0;
1022 }
1023
1024 static int __maybe_unused mhi_pci_restore(struct device *dev)
1025 {
1026         struct mhi_pci_device *mhi_pdev = dev_get_drvdata(dev);
1027
1028         /* Reinitialize the device */
1029         queue_work(system_long_wq, &mhi_pdev->recovery_work);
1030
1031         return 0;
1032 }
1033
1034 static const struct dev_pm_ops mhi_pci_pm_ops = {
1035         SET_RUNTIME_PM_OPS(mhi_pci_runtime_suspend, mhi_pci_runtime_resume, NULL)
1036 #ifdef CONFIG_PM_SLEEP
1037         .suspend = mhi_pci_suspend,
1038         .resume = mhi_pci_resume,
1039         .freeze = mhi_pci_freeze,
1040         .thaw = mhi_pci_restore,
1041         .restore = mhi_pci_restore,
1042 #endif
1043 };
1044
1045 static struct pci_driver mhi_pci_driver = {
1046         .name           = "mhi-pci-generic",
1047         .id_table       = mhi_pci_id_table,
1048         .probe          = mhi_pci_probe,
1049         .remove         = mhi_pci_remove,
1050         .shutdown       = mhi_pci_shutdown,
1051         .err_handler    = &mhi_pci_err_handler,
1052         .driver.pm      = &mhi_pci_pm_ops
1053 };
1054 module_pci_driver(mhi_pci_driver);
1055
1056 MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>");
1057 MODULE_DESCRIPTION("Modem Host Interface (MHI) PCI controller driver");
1058 MODULE_LICENSE("GPL");