Mayank Rana | 511f3b2 | 2016-08-02 12:00:11 -0700 | [diff] [blame] | 1 | /* |
Mayank Rana | d796cab | 2017-07-11 15:34:12 -0700 | [diff] [blame] | 2 | * Copyright (c) 2012-2015, 2017 The Linux Foundation. All rights reserved. |
Mayank Rana | 511f3b2 | 2016-08-02 12:00:11 -0700 | [diff] [blame] | 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 and |
| 6 | * only version 2 as published by the Free Software Foundation. |
| 7 | * |
| 8 | * This program is distributed in the hope that it will be useful, |
| 9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 11 | * GNU General Public License for more details. |
| 12 | * |
| 13 | */ |
| 14 | |
| 15 | #include <linux/platform_device.h> |
| 16 | #include <linux/of.h> |
| 17 | #include <linux/module.h> |
| 18 | #include <linux/delay.h> |
| 19 | #include <linux/io.h> |
| 20 | |
| 21 | #include "dbm.h" |
| 22 | |
| 23 | /** |
| 24 | * USB DBM Hardware registers. |
| 25 | * |
| 26 | */ |
| 27 | enum dbm_reg { |
| 28 | DBM_EP_CFG, |
| 29 | DBM_DATA_FIFO, |
| 30 | DBM_DATA_FIFO_SIZE, |
| 31 | DBM_DATA_FIFO_EN, |
| 32 | DBM_GEVNTADR, |
| 33 | DBM_GEVNTSIZ, |
| 34 | DBM_DBG_CNFG, |
| 35 | DBM_HW_TRB0_EP, |
| 36 | DBM_HW_TRB1_EP, |
| 37 | DBM_HW_TRB2_EP, |
| 38 | DBM_HW_TRB3_EP, |
| 39 | DBM_PIPE_CFG, |
| 40 | DBM_SOFT_RESET, |
| 41 | DBM_GEN_CFG, |
| 42 | DBM_GEVNTADR_LSB, |
| 43 | DBM_GEVNTADR_MSB, |
| 44 | DBM_DATA_FIFO_LSB, |
| 45 | DBM_DATA_FIFO_MSB, |
| 46 | DBM_DATA_FIFO_ADDR_EN, |
| 47 | DBM_DATA_FIFO_SIZE_EN, |
| 48 | }; |
| 49 | |
| 50 | struct dbm_reg_data { |
| 51 | u32 offset; |
| 52 | unsigned int ep_mult; |
| 53 | }; |
| 54 | |
| 55 | #define DBM_1_4_NUM_EP 4 |
| 56 | #define DBM_1_5_NUM_EP 8 |
| 57 | |
| 58 | struct dbm { |
| 59 | void __iomem *base; |
| 60 | const struct dbm_reg_data *reg_table; |
| 61 | |
| 62 | struct device *dev; |
| 63 | struct list_head head; |
| 64 | |
| 65 | int dbm_num_eps; |
| 66 | u8 ep_num_mapping[DBM_1_5_NUM_EP]; |
| 67 | bool dbm_reset_ep_after_lpm; |
| 68 | |
| 69 | bool is_1p4; |
| 70 | }; |
| 71 | |
| 72 | static const struct dbm_reg_data dbm_1_4_regtable[] = { |
| 73 | [DBM_EP_CFG] = { 0x0000, 0x4 }, |
| 74 | [DBM_DATA_FIFO] = { 0x0010, 0x4 }, |
| 75 | [DBM_DATA_FIFO_SIZE] = { 0x0020, 0x4 }, |
| 76 | [DBM_DATA_FIFO_EN] = { 0x0030, 0x0 }, |
| 77 | [DBM_GEVNTADR] = { 0x0034, 0x0 }, |
| 78 | [DBM_GEVNTSIZ] = { 0x0038, 0x0 }, |
| 79 | [DBM_DBG_CNFG] = { 0x003C, 0x0 }, |
| 80 | [DBM_HW_TRB0_EP] = { 0x0040, 0x4 }, |
| 81 | [DBM_HW_TRB1_EP] = { 0x0050, 0x4 }, |
| 82 | [DBM_HW_TRB2_EP] = { 0x0060, 0x4 }, |
| 83 | [DBM_HW_TRB3_EP] = { 0x0070, 0x4 }, |
| 84 | [DBM_PIPE_CFG] = { 0x0080, 0x0 }, |
| 85 | [DBM_SOFT_RESET] = { 0x0084, 0x0 }, |
| 86 | [DBM_GEN_CFG] = { 0x0088, 0x0 }, |
| 87 | [DBM_GEVNTADR_LSB] = { 0x0098, 0x0 }, |
| 88 | [DBM_GEVNTADR_MSB] = { 0x009C, 0x0 }, |
| 89 | [DBM_DATA_FIFO_LSB] = { 0x00A0, 0x8 }, |
| 90 | [DBM_DATA_FIFO_MSB] = { 0x00A4, 0x8 }, |
| 91 | }; |
| 92 | |
| 93 | static const struct dbm_reg_data dbm_1_5_regtable[] = { |
| 94 | [DBM_EP_CFG] = { 0x0000, 0x4 }, |
| 95 | [DBM_DATA_FIFO] = { 0x0280, 0x4 }, |
| 96 | [DBM_DATA_FIFO_SIZE] = { 0x0080, 0x4 }, |
| 97 | [DBM_DATA_FIFO_EN] = { 0x026C, 0x0 }, |
| 98 | [DBM_GEVNTADR] = { 0x0270, 0x0 }, |
| 99 | [DBM_GEVNTSIZ] = { 0x0268, 0x0 }, |
| 100 | [DBM_DBG_CNFG] = { 0x0208, 0x0 }, |
| 101 | [DBM_HW_TRB0_EP] = { 0x0220, 0x4 }, |
| 102 | [DBM_HW_TRB1_EP] = { 0x0230, 0x4 }, |
| 103 | [DBM_HW_TRB2_EP] = { 0x0240, 0x4 }, |
| 104 | [DBM_HW_TRB3_EP] = { 0x0250, 0x4 }, |
| 105 | [DBM_PIPE_CFG] = { 0x0274, 0x0 }, |
| 106 | [DBM_SOFT_RESET] = { 0x020C, 0x0 }, |
| 107 | [DBM_GEN_CFG] = { 0x0210, 0x0 }, |
| 108 | [DBM_GEVNTADR_LSB] = { 0x0260, 0x0 }, |
| 109 | [DBM_GEVNTADR_MSB] = { 0x0264, 0x0 }, |
| 110 | [DBM_DATA_FIFO_LSB] = { 0x0100, 0x8 }, |
| 111 | [DBM_DATA_FIFO_MSB] = { 0x0104, 0x8 }, |
| 112 | [DBM_DATA_FIFO_ADDR_EN] = { 0x0200, 0x0 }, |
| 113 | [DBM_DATA_FIFO_SIZE_EN] = { 0x0204, 0x0 }, |
| 114 | }; |
| 115 | |
| 116 | static LIST_HEAD(dbm_list); |
| 117 | |
| 118 | /** |
| 119 | * Write register masked field with debug info. |
| 120 | * |
| 121 | * @dbm - DBM specific data |
| 122 | * @reg - DBM register, used to look up the offset value |
| 123 | * @ep - endpoint number |
| 124 | * @mask - register bitmask. |
| 125 | * @val - value to write. |
| 126 | * |
| 127 | */ |
| 128 | static inline void msm_dbm_write_ep_reg_field(struct dbm *dbm, |
| 129 | enum dbm_reg reg, int ep, |
| 130 | const u32 mask, u32 val) |
| 131 | { |
Mayank Rana | d796cab | 2017-07-11 15:34:12 -0700 | [diff] [blame] | 132 | u32 shift = __ffs(mask); |
Mayank Rana | 511f3b2 | 2016-08-02 12:00:11 -0700 | [diff] [blame] | 133 | u32 offset = dbm->reg_table[reg].offset + |
| 134 | (dbm->reg_table[reg].ep_mult * ep); |
| 135 | u32 tmp = ioread32(dbm->base + offset); |
| 136 | |
| 137 | tmp &= ~mask; /* clear written bits */ |
| 138 | val = tmp | (val << shift); |
| 139 | iowrite32(val, dbm->base + offset); |
| 140 | } |
| 141 | |
| 142 | #define msm_dbm_write_reg_field(d, r, m, v) \ |
| 143 | msm_dbm_write_ep_reg_field(d, r, 0, m, v) |
| 144 | |
| 145 | /** |
| 146 | * |
| 147 | * Read register with debug info. |
| 148 | * |
| 149 | * @dbm - DBM specific data |
| 150 | * @reg - DBM register, used to look up the offset value |
| 151 | * @ep - endpoint number |
| 152 | * |
| 153 | * @return u32 |
| 154 | */ |
| 155 | static inline u32 msm_dbm_read_ep_reg(struct dbm *dbm, enum dbm_reg reg, int ep) |
| 156 | { |
| 157 | u32 offset = dbm->reg_table[reg].offset + |
| 158 | (dbm->reg_table[reg].ep_mult * ep); |
| 159 | return ioread32(dbm->base + offset); |
| 160 | } |
| 161 | |
| 162 | #define msm_dbm_read_reg(d, r) msm_dbm_read_ep_reg(d, r, 0) |
| 163 | |
| 164 | /** |
| 165 | * |
| 166 | * Write register with debug info. |
| 167 | * |
| 168 | * @dbm - DBM specific data |
| 169 | * @reg - DBM register, used to look up the offset value |
| 170 | * @ep - endpoint number |
| 171 | * |
| 172 | */ |
| 173 | static inline void msm_dbm_write_ep_reg(struct dbm *dbm, enum dbm_reg reg, |
| 174 | int ep, u32 val) |
| 175 | { |
| 176 | u32 offset = dbm->reg_table[reg].offset + |
| 177 | (dbm->reg_table[reg].ep_mult * ep); |
| 178 | iowrite32(val, dbm->base + offset); |
| 179 | } |
| 180 | |
| 181 | #define msm_dbm_write_reg(d, r, v) msm_dbm_write_ep_reg(d, r, 0, v) |
| 182 | |
| 183 | /** |
| 184 | * Return DBM EP number according to usb endpoint number. |
| 185 | * |
| 186 | */ |
| 187 | static int find_matching_dbm_ep(struct dbm *dbm, u8 usb_ep) |
| 188 | { |
| 189 | int i; |
| 190 | |
| 191 | for (i = 0; i < dbm->dbm_num_eps; i++) |
| 192 | if (dbm->ep_num_mapping[i] == usb_ep) |
| 193 | return i; |
| 194 | |
| 195 | pr_err("%s: No DBM EP matches USB EP %d", __func__, usb_ep); |
| 196 | return -ENODEV; /* Not found */ |
| 197 | } |
| 198 | |
| 199 | |
| 200 | /** |
| 201 | * Reset the DBM registers upon initialization. |
| 202 | * |
| 203 | */ |
| 204 | int dbm_soft_reset(struct dbm *dbm, bool reset) |
| 205 | { |
| 206 | if (!dbm) { |
| 207 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 208 | return -EPERM; |
| 209 | } |
| 210 | |
| 211 | pr_debug("%s DBM reset\n", (reset ? "Enter" : "Exit")); |
| 212 | |
| 213 | msm_dbm_write_reg_field(dbm, DBM_SOFT_RESET, DBM_SFT_RST_MASK, reset); |
| 214 | |
| 215 | return 0; |
| 216 | } |
| 217 | |
| 218 | /** |
| 219 | * Soft reset specific DBM ep. |
| 220 | * This function is called by the function driver upon events |
| 221 | * such as transfer aborting, USB re-enumeration and USB |
| 222 | * disconnection. |
| 223 | * |
| 224 | * @dbm_ep - DBM ep number. |
| 225 | * @enter_reset - should we enter a reset state or get out of it. |
| 226 | * |
| 227 | */ |
| 228 | static int ep_soft_reset(struct dbm *dbm, u8 dbm_ep, bool enter_reset) |
| 229 | { |
| 230 | pr_debug("Setting DBM ep %d reset to %d\n", dbm_ep, enter_reset); |
| 231 | |
| 232 | if (dbm_ep >= dbm->dbm_num_eps) { |
| 233 | pr_err("Invalid DBM ep index %d\n", dbm_ep); |
| 234 | return -ENODEV; |
| 235 | } |
| 236 | |
| 237 | if (enter_reset) { |
| 238 | msm_dbm_write_reg_field(dbm, DBM_SOFT_RESET, |
| 239 | DBM_SFT_RST_EPS_MASK & 1 << dbm_ep, 1); |
| 240 | } else { |
| 241 | msm_dbm_write_reg_field(dbm, DBM_SOFT_RESET, |
| 242 | DBM_SFT_RST_EPS_MASK & 1 << dbm_ep, 0); |
| 243 | } |
| 244 | |
| 245 | return 0; |
| 246 | } |
| 247 | |
| 248 | |
| 249 | /** |
| 250 | * Soft reset specific DBM ep (by USB EP number). |
| 251 | * This function is called by the function driver upon events |
| 252 | * such as transfer aborting, USB re-enumeration and USB |
| 253 | * disconnection. |
| 254 | * |
| 255 | * The function relies on ep_soft_reset() for checking |
| 256 | * the legality of the resulting DBM ep number. |
| 257 | * |
| 258 | * @usb_ep - USB ep number. |
| 259 | * @enter_reset - should we enter a reset state or get out of it. |
| 260 | * |
| 261 | */ |
| 262 | int dbm_ep_soft_reset(struct dbm *dbm, u8 usb_ep, bool enter_reset) |
| 263 | { |
| 264 | int dbm_ep; |
| 265 | |
| 266 | if (!dbm) { |
| 267 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 268 | return -EPERM; |
| 269 | } |
| 270 | |
| 271 | dbm_ep = find_matching_dbm_ep(dbm, usb_ep); |
| 272 | |
| 273 | pr_debug("Setting USB ep %d reset to %d\n", usb_ep, enter_reset); |
| 274 | return ep_soft_reset(dbm, dbm_ep, enter_reset); |
| 275 | } |
| 276 | |
| 277 | /** |
| 278 | * Configure a USB DBM ep to work in BAM mode. |
| 279 | * |
| 280 | * |
| 281 | * @usb_ep - USB physical EP number. |
| 282 | * @producer - producer/consumer. |
| 283 | * @disable_wb - disable write back to system memory. |
| 284 | * @internal_mem - use internal USB memory for data fifo. |
| 285 | * @ioc - enable interrupt on completion. |
| 286 | * |
| 287 | * @return int - DBM ep number. |
| 288 | */ |
| 289 | int dbm_ep_config(struct dbm *dbm, u8 usb_ep, u8 bam_pipe, bool producer, |
| 290 | bool disable_wb, bool internal_mem, bool ioc) |
| 291 | { |
| 292 | int dbm_ep; |
| 293 | u32 ep_cfg; |
| 294 | |
| 295 | if (!dbm) { |
| 296 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 297 | return -EPERM; |
| 298 | } |
| 299 | |
| 300 | pr_debug("Configuring DBM ep\n"); |
| 301 | |
| 302 | dbm_ep = find_matching_dbm_ep(dbm, usb_ep); |
| 303 | |
| 304 | if (dbm_ep < 0) { |
| 305 | pr_err("usb ep index %d has no corresponding dbm ep\n", usb_ep); |
| 306 | return -ENODEV; |
| 307 | } |
| 308 | |
| 309 | /* Due to HW issue, EP 7 can be set as IN EP only */ |
| 310 | if (!dbm->is_1p4 && dbm_ep == 7 && producer) { |
| 311 | pr_err("last DBM EP can't be OUT EP\n"); |
| 312 | return -ENODEV; |
| 313 | } |
| 314 | |
| 315 | /* First, reset the dbm endpoint */ |
| 316 | ep_soft_reset(dbm, dbm_ep, 0); |
| 317 | |
| 318 | /* Set ioc bit for dbm_ep if needed */ |
| 319 | msm_dbm_write_reg_field(dbm, DBM_DBG_CNFG, |
| 320 | DBM_ENABLE_IOC_MASK & 1 << dbm_ep, ioc ? 1 : 0); |
| 321 | |
| 322 | ep_cfg = (producer ? DBM_PRODUCER : 0) | |
| 323 | (disable_wb ? DBM_DISABLE_WB : 0) | |
| 324 | (internal_mem ? DBM_INT_RAM_ACC : 0); |
| 325 | |
| 326 | msm_dbm_write_ep_reg_field(dbm, DBM_EP_CFG, dbm_ep, |
| 327 | DBM_PRODUCER | DBM_DISABLE_WB | DBM_INT_RAM_ACC, ep_cfg >> 8); |
| 328 | |
| 329 | msm_dbm_write_ep_reg_field(dbm, DBM_EP_CFG, dbm_ep, USB3_EPNUM, |
| 330 | usb_ep); |
| 331 | |
| 332 | if (dbm->is_1p4) { |
| 333 | msm_dbm_write_ep_reg_field(dbm, DBM_EP_CFG, dbm_ep, |
| 334 | DBM_BAM_PIPE_NUM, bam_pipe); |
| 335 | msm_dbm_write_reg_field(dbm, DBM_PIPE_CFG, 0x000000ff, 0xe4); |
| 336 | } |
| 337 | |
| 338 | msm_dbm_write_ep_reg_field(dbm, DBM_EP_CFG, dbm_ep, DBM_EN_EP, 1); |
| 339 | |
| 340 | return dbm_ep; |
| 341 | } |
| 342 | |
| 343 | /** |
| 344 | * Return number of configured DBM endpoints. |
| 345 | */ |
| 346 | int dbm_get_num_of_eps_configured(struct dbm *dbm) |
| 347 | { |
| 348 | int i; |
| 349 | int count = 0; |
| 350 | |
| 351 | if (!dbm) { |
| 352 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 353 | return -EPERM; |
| 354 | } |
| 355 | |
| 356 | for (i = 0; i < dbm->dbm_num_eps; i++) |
| 357 | if (dbm->ep_num_mapping[i]) |
| 358 | count++; |
| 359 | |
| 360 | return count; |
| 361 | } |
| 362 | |
| 363 | /** |
| 364 | * Configure a USB DBM ep to work in normal mode. |
| 365 | * |
| 366 | * @usb_ep - USB ep number. |
| 367 | * |
| 368 | */ |
| 369 | int dbm_ep_unconfig(struct dbm *dbm, u8 usb_ep) |
| 370 | { |
| 371 | int dbm_ep; |
| 372 | u32 data; |
| 373 | |
| 374 | if (!dbm) { |
| 375 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 376 | return -EPERM; |
| 377 | } |
| 378 | |
| 379 | pr_debug("Unconfiguring DB ep\n"); |
| 380 | |
| 381 | dbm_ep = find_matching_dbm_ep(dbm, usb_ep); |
| 382 | |
| 383 | if (dbm_ep < 0) { |
| 384 | pr_err("usb ep index %d has no corresponding dbm ep\n", usb_ep); |
| 385 | return -ENODEV; |
| 386 | } |
| 387 | |
| 388 | dbm->ep_num_mapping[dbm_ep] = 0; |
| 389 | |
| 390 | data = msm_dbm_read_ep_reg(dbm, DBM_EP_CFG, dbm_ep); |
| 391 | data &= (~0x1); |
| 392 | msm_dbm_write_ep_reg(dbm, DBM_EP_CFG, dbm_ep, data); |
| 393 | |
| 394 | /* Reset the dbm endpoint */ |
| 395 | ep_soft_reset(dbm, dbm_ep, true); |
| 396 | /* |
| 397 | * The necessary delay between asserting and deasserting the dbm ep |
| 398 | * reset is based on the number of active endpoints. If there is more |
| 399 | * than one endpoint, a 1 msec delay is required. Otherwise, a shorter |
| 400 | * delay will suffice. |
| 401 | * |
| 402 | * As this function can be called in atomic context, sleeping variants |
| 403 | * for delay are not possible - albeit a 1ms delay. |
| 404 | */ |
| 405 | if (dbm_get_num_of_eps_configured(dbm) > 1) |
| 406 | udelay(1000); |
| 407 | else |
| 408 | udelay(10); |
| 409 | ep_soft_reset(dbm, dbm_ep, false); |
| 410 | |
| 411 | return 0; |
| 412 | } |
| 413 | |
| 414 | /** |
| 415 | * Configure the DBM with the USB3 core event buffer. |
| 416 | * This function is called by the SNPS UDC upon initialization. |
| 417 | * |
| 418 | * @addr - address of the event buffer. |
| 419 | * @size - size of the event buffer. |
| 420 | * |
| 421 | */ |
| 422 | int dbm_event_buffer_config(struct dbm *dbm, u32 addr_lo, u32 addr_hi, int size) |
| 423 | { |
| 424 | if (!dbm) { |
| 425 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 426 | return -EPERM; |
| 427 | } |
| 428 | |
| 429 | pr_debug("Configuring event buffer\n"); |
| 430 | |
| 431 | if (size < 0) { |
| 432 | pr_err("Invalid size. size = %d", size); |
| 433 | return -EINVAL; |
| 434 | } |
| 435 | |
| 436 | /* In case event buffer is already configured, Do nothing. */ |
| 437 | if (msm_dbm_read_reg(dbm, DBM_GEVNTSIZ)) |
| 438 | return 0; |
| 439 | |
| 440 | if (!dbm->is_1p4 || sizeof(phys_addr_t) > sizeof(u32)) { |
| 441 | msm_dbm_write_reg(dbm, DBM_GEVNTADR_LSB, addr_lo); |
| 442 | msm_dbm_write_reg(dbm, DBM_GEVNTADR_MSB, addr_hi); |
| 443 | } else { |
| 444 | msm_dbm_write_reg(dbm, DBM_GEVNTADR, addr_lo); |
| 445 | } |
| 446 | |
| 447 | msm_dbm_write_reg_field(dbm, DBM_GEVNTSIZ, DBM_GEVNTSIZ_MASK, size); |
| 448 | |
| 449 | return 0; |
| 450 | } |
| 451 | |
| 452 | |
| 453 | int dbm_data_fifo_config(struct dbm *dbm, u8 dep_num, phys_addr_t addr, |
| 454 | u32 size, u8 dst_pipe_idx) |
| 455 | { |
| 456 | u8 dbm_ep = dst_pipe_idx; |
| 457 | u32 lo = lower_32_bits(addr); |
| 458 | u32 hi = upper_32_bits(addr); |
| 459 | |
| 460 | if (!dbm) { |
| 461 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 462 | return -EPERM; |
| 463 | } |
| 464 | |
| 465 | dbm->ep_num_mapping[dbm_ep] = dep_num; |
| 466 | |
| 467 | if (!dbm->is_1p4 || sizeof(addr) > sizeof(u32)) { |
| 468 | msm_dbm_write_ep_reg(dbm, DBM_DATA_FIFO_LSB, dbm_ep, lo); |
| 469 | msm_dbm_write_ep_reg(dbm, DBM_DATA_FIFO_MSB, dbm_ep, hi); |
| 470 | } else { |
| 471 | msm_dbm_write_ep_reg(dbm, DBM_DATA_FIFO, dbm_ep, addr); |
| 472 | } |
| 473 | |
| 474 | msm_dbm_write_ep_reg_field(dbm, DBM_DATA_FIFO_SIZE, dbm_ep, |
| 475 | DBM_DATA_FIFO_SIZE_MASK, size); |
| 476 | |
| 477 | return 0; |
| 478 | } |
| 479 | |
| 480 | void dbm_set_speed(struct dbm *dbm, bool speed) |
| 481 | { |
| 482 | if (!dbm) { |
| 483 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 484 | return; |
| 485 | } |
| 486 | |
| 487 | msm_dbm_write_reg(dbm, DBM_GEN_CFG, speed); |
| 488 | } |
| 489 | |
| 490 | void dbm_enable(struct dbm *dbm) |
| 491 | { |
| 492 | if (!dbm) { |
| 493 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 494 | return; |
| 495 | } |
| 496 | |
| 497 | if (dbm->is_1p4) /* no-op */ |
| 498 | return; |
| 499 | |
| 500 | msm_dbm_write_reg(dbm, DBM_DATA_FIFO_ADDR_EN, 0x000000FF); |
| 501 | msm_dbm_write_reg(dbm, DBM_DATA_FIFO_SIZE_EN, 0x000000FF); |
| 502 | } |
| 503 | |
| 504 | bool dbm_reset_ep_after_lpm(struct dbm *dbm) |
| 505 | { |
| 506 | if (!dbm) { |
| 507 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 508 | return false; |
| 509 | } |
| 510 | |
| 511 | return dbm->dbm_reset_ep_after_lpm; |
| 512 | } |
| 513 | |
| 514 | bool dbm_l1_lpm_interrupt(struct dbm *dbm) |
| 515 | { |
| 516 | if (!dbm) { |
| 517 | pr_err("%s: dbm pointer is NULL!\n", __func__); |
| 518 | return false; |
| 519 | } |
| 520 | |
| 521 | return !dbm->is_1p4; |
| 522 | } |
| 523 | |
| 524 | static const struct of_device_id msm_dbm_id_table[] = { |
| 525 | { .compatible = "qcom,usb-dbm-1p4", .data = &dbm_1_4_regtable }, |
| 526 | { .compatible = "qcom,usb-dbm-1p5", .data = &dbm_1_5_regtable }, |
| 527 | { }, |
| 528 | }; |
| 529 | MODULE_DEVICE_TABLE(of, msm_dbm_id_table); |
| 530 | |
| 531 | static int msm_dbm_probe(struct platform_device *pdev) |
| 532 | { |
| 533 | struct device_node *node = pdev->dev.of_node; |
| 534 | const struct of_device_id *match; |
| 535 | struct dbm *dbm; |
| 536 | struct resource *res; |
| 537 | |
| 538 | dbm = devm_kzalloc(&pdev->dev, sizeof(*dbm), GFP_KERNEL); |
| 539 | if (!dbm) |
| 540 | return -ENOMEM; |
| 541 | |
| 542 | match = of_match_node(msm_dbm_id_table, node); |
| 543 | if (!match) { |
| 544 | dev_err(&pdev->dev, "Unsupported DBM module\n"); |
| 545 | return -ENODEV; |
| 546 | } |
| 547 | dbm->reg_table = match->data; |
| 548 | |
| 549 | if (!strcmp(match->compatible, "qcom,usb-dbm-1p4")) { |
| 550 | dbm->dbm_num_eps = DBM_1_4_NUM_EP; |
| 551 | dbm->is_1p4 = true; |
| 552 | } else { |
| 553 | dbm->dbm_num_eps = DBM_1_5_NUM_EP; |
| 554 | } |
| 555 | |
| 556 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 557 | if (!res) { |
| 558 | dev_err(&pdev->dev, "missing memory base resource\n"); |
| 559 | return -ENODEV; |
| 560 | } |
| 561 | |
| 562 | dbm->base = devm_ioremap_nocache(&pdev->dev, res->start, |
| 563 | resource_size(res)); |
| 564 | if (!dbm->base) { |
| 565 | dev_err(&pdev->dev, "ioremap failed\n"); |
| 566 | return -ENOMEM; |
| 567 | } |
| 568 | |
| 569 | dbm->dbm_reset_ep_after_lpm = of_property_read_bool(node, |
| 570 | "qcom,reset-ep-after-lpm-resume"); |
| 571 | |
| 572 | dbm->dev = &pdev->dev; |
| 573 | |
| 574 | platform_set_drvdata(pdev, dbm); |
| 575 | |
| 576 | list_add_tail(&dbm->head, &dbm_list); |
| 577 | |
| 578 | return 0; |
| 579 | } |
| 580 | |
| 581 | static struct platform_driver msm_dbm_driver = { |
| 582 | .probe = msm_dbm_probe, |
| 583 | .driver = { |
| 584 | .name = "msm-usb-dbm", |
| 585 | .of_match_table = of_match_ptr(msm_dbm_id_table), |
| 586 | }, |
| 587 | }; |
| 588 | |
| 589 | module_platform_driver(msm_dbm_driver); |
| 590 | |
| 591 | static struct dbm *of_usb_find_dbm(struct device_node *node) |
| 592 | { |
| 593 | struct dbm *dbm; |
| 594 | |
| 595 | list_for_each_entry(dbm, &dbm_list, head) { |
| 596 | if (node != dbm->dev->of_node) |
| 597 | continue; |
| 598 | return dbm; |
| 599 | } |
| 600 | return ERR_PTR(-ENODEV); |
| 601 | } |
| 602 | |
| 603 | struct dbm *usb_get_dbm_by_phandle(struct device *dev, const char *phandle) |
| 604 | { |
| 605 | struct device_node *node; |
| 606 | |
| 607 | if (!dev->of_node) { |
| 608 | dev_dbg(dev, "device does not have a device node entry\n"); |
| 609 | return ERR_PTR(-EINVAL); |
| 610 | } |
| 611 | |
| 612 | node = of_parse_phandle(dev->of_node, phandle, 0); |
| 613 | if (!node) { |
| 614 | dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle, |
| 615 | dev->of_node->full_name); |
| 616 | return ERR_PTR(-ENODEV); |
| 617 | } |
| 618 | |
| 619 | return of_usb_find_dbm(node); |
| 620 | } |
| 621 | |
| 622 | MODULE_DESCRIPTION("MSM USB DBM driver"); |
| 623 | MODULE_LICENSE("GPL v2"); |