Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 1 | /* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved. |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [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/slab.h> |
| 14 | #include <linux/init.h> |
| 15 | #include <linux/uaccess.h> |
| 16 | #include <linux/diagchar.h> |
| 17 | #include <linux/sched.h> |
| 18 | #include <linux/err.h> |
| 19 | #include <linux/delay.h> |
| 20 | #include <linux/workqueue.h> |
| 21 | #include <linux/pm_runtime.h> |
| 22 | #include <linux/platform_device.h> |
| 23 | #include <linux/spinlock.h> |
| 24 | #include <linux/ratelimit.h> |
| 25 | #include "diagchar.h" |
| 26 | #include "diagfwd.h" |
| 27 | #include "diag_mux.h" |
| 28 | #include "diag_usb.h" |
| 29 | #include "diag_memorydevice.h" |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 30 | #include "diag_pcie.h" |
Manoj Prabhu B | 571cf42 | 2017-08-08 19:01:41 +0530 | [diff] [blame] | 31 | #include "diagfwd_peripheral.h" |
| 32 | #include "diag_ipc_logging.h" |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 33 | |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 34 | #ifdef CONFIG_DIAG_OVER_PCIE |
| 35 | #define diag_mux_register_ops diag_pcie_register_ops |
| 36 | #else |
| 37 | #define diag_mux_register_ops diag_usb_register_ops |
| 38 | #endif |
| 39 | |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 40 | struct diag_mux_state_t *diag_mux; |
| 41 | static struct diag_logger_t usb_logger; |
| 42 | static struct diag_logger_t md_logger; |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 43 | static struct diag_logger_t pcie_logger; |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 44 | |
| 45 | static struct diag_logger_ops usb_log_ops = { |
| 46 | .open = diag_usb_connect_all, |
| 47 | .close = diag_usb_disconnect_all, |
| 48 | .queue_read = diag_usb_queue_read, |
| 49 | .write = diag_usb_write, |
| 50 | .close_peripheral = NULL |
| 51 | }; |
| 52 | |
| 53 | static struct diag_logger_ops md_log_ops = { |
| 54 | .open = diag_md_open_all, |
| 55 | .close = diag_md_close_all, |
| 56 | .queue_read = NULL, |
| 57 | .write = diag_md_write, |
| 58 | .close_peripheral = diag_md_close_peripheral, |
| 59 | }; |
| 60 | |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 61 | #ifdef CONFIG_DIAG_OVER_PCIE |
| 62 | static struct diag_logger_ops pcie_log_ops = { |
| 63 | .open = diag_pcie_connect_all, |
| 64 | .close = diag_pcie_disconnect_all, |
| 65 | .queue_read = NULL, |
| 66 | .write = diag_pcie_write, |
| 67 | .close_peripheral = NULL |
| 68 | }; |
| 69 | #endif |
| 70 | |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 71 | int diag_mux_init(void) |
| 72 | { |
| 73 | diag_mux = kzalloc(sizeof(struct diag_mux_state_t), |
| 74 | GFP_KERNEL); |
| 75 | if (!diag_mux) |
| 76 | return -ENOMEM; |
| 77 | kmemleak_not_leak(diag_mux); |
| 78 | |
| 79 | usb_logger.mode = DIAG_USB_MODE; |
| 80 | usb_logger.log_ops = &usb_log_ops; |
| 81 | |
| 82 | md_logger.mode = DIAG_MEMORY_DEVICE_MODE; |
| 83 | md_logger.log_ops = &md_log_ops; |
| 84 | diag_md_init(); |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 85 | #ifdef CONFIG_DIAG_OVER_PCIE |
| 86 | pcie_logger.mode = DIAG_PCIE_MODE; |
| 87 | pcie_logger.log_ops = &pcie_log_ops; |
| 88 | diag_mux->pcie_ptr = &pcie_logger; |
| 89 | #endif |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 90 | /* |
| 91 | * Set USB logging as the default logger. This is the mode |
| 92 | * Diag should be in when it initializes. |
| 93 | */ |
| 94 | diag_mux->usb_ptr = &usb_logger; |
| 95 | diag_mux->md_ptr = &md_logger; |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 96 | switch (driver->transport_set) { |
| 97 | case DIAG_ROUTE_TO_PCIE: |
| 98 | diag_mux->logger = &pcie_logger; |
| 99 | diag_mux->mode = DIAG_PCIE_MODE; |
| 100 | break; |
| 101 | case DIAG_ROUTE_TO_USB: |
| 102 | default: |
| 103 | diag_mux->logger = &usb_logger; |
| 104 | diag_mux->mode = DIAG_USB_MODE; |
| 105 | break; |
| 106 | } |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 107 | diag_mux->mux_mask = 0; |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 108 | return 0; |
| 109 | } |
| 110 | |
| 111 | void diag_mux_exit(void) |
| 112 | { |
| 113 | kfree(diag_mux); |
| 114 | } |
| 115 | |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 116 | #ifdef CONFIG_DIAG_OVER_PCIE |
| 117 | int diag_pcie_register_ops(int proc, int ctx, struct diag_mux_ops *ops) |
| 118 | { |
| 119 | int err = 0; |
| 120 | |
| 121 | if (!ops) |
| 122 | return -EINVAL; |
| 123 | |
| 124 | if (proc < 0 || proc >= NUM_MUX_PROC) |
| 125 | return 0; |
| 126 | |
| 127 | pcie_logger.ops[proc] = ops; |
| 128 | err = diag_pcie_register(proc, ctx, ops); |
| 129 | if (err) { |
Mohit Aggarwal | b5f9b8f | 2018-12-02 17:39:24 -0800 | [diff] [blame] | 130 | driver->transport_set = DIAG_ROUTE_TO_USB; |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 131 | diag_mux->logger = &usb_logger; |
| 132 | diag_mux->mode = DIAG_USB_MODE; |
| 133 | usb_logger.ops[proc] = ops; |
| 134 | err = diag_usb_register(proc, ctx, ops); |
| 135 | if (err) { |
| 136 | pr_err("diag: MUX: unable to register usb operations for proc: %d, err: %d\n", |
| 137 | proc, err); |
| 138 | return err; |
| 139 | } |
| 140 | pr_err("diag: MUX: unable to register pcie operations for proc: %d, err: %d\n", |
| 141 | proc, err); |
| 142 | } |
| 143 | return 0; |
| 144 | } |
| 145 | #else |
| 146 | int diag_usb_register_ops(int proc, int ctx, struct diag_mux_ops *ops) |
| 147 | { |
| 148 | int err = 0; |
| 149 | |
| 150 | if (!ops) |
| 151 | return -EINVAL; |
| 152 | |
| 153 | if (proc < 0 || proc >= NUM_MUX_PROC) |
| 154 | return 0; |
| 155 | usb_logger.ops[proc] = ops; |
| 156 | err = diag_usb_register(proc, ctx, ops); |
| 157 | if (err) { |
| 158 | pr_err("diag: MUX: unable to register usb operations for proc: %d, err: %d\n", |
| 159 | proc, err); |
| 160 | return err; |
| 161 | } |
| 162 | return 0; |
| 163 | } |
| 164 | #endif |
| 165 | |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 166 | int diag_mux_register(int proc, int ctx, struct diag_mux_ops *ops) |
| 167 | { |
| 168 | int err = 0; |
| 169 | |
| 170 | if (!ops) |
| 171 | return -EINVAL; |
| 172 | |
| 173 | if (proc < 0 || proc >= NUM_MUX_PROC) |
| 174 | return 0; |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 175 | err = diag_mux_register_ops(proc, ctx, ops); |
| 176 | if (err) |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 177 | return err; |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 178 | md_logger.ops[proc] = ops; |
| 179 | err = diag_md_register(proc, ctx, ops); |
| 180 | if (err) { |
| 181 | pr_err("diag: MUX: unable to register md operations for proc: %d, err: %d\n", |
| 182 | proc, err); |
| 183 | return err; |
| 184 | } |
| 185 | |
| 186 | return 0; |
| 187 | } |
| 188 | |
| 189 | int diag_mux_queue_read(int proc) |
| 190 | { |
| 191 | struct diag_logger_t *logger = NULL; |
| 192 | |
| 193 | if (proc < 0 || proc >= NUM_MUX_PROC) |
| 194 | return -EINVAL; |
| 195 | if (!diag_mux) |
| 196 | return -EIO; |
| 197 | |
| 198 | if (diag_mux->mode == DIAG_MULTI_MODE) |
| 199 | logger = diag_mux->usb_ptr; |
| 200 | else |
| 201 | logger = diag_mux->logger; |
| 202 | |
| 203 | if (logger && logger->log_ops && logger->log_ops->queue_read) |
| 204 | return logger->log_ops->queue_read(proc); |
| 205 | |
| 206 | return 0; |
| 207 | } |
| 208 | |
| 209 | int diag_mux_write(int proc, unsigned char *buf, int len, int ctx) |
| 210 | { |
| 211 | struct diag_logger_t *logger = NULL; |
| 212 | int peripheral; |
| 213 | |
| 214 | if (proc < 0 || proc >= NUM_MUX_PROC) |
| 215 | return -EINVAL; |
| 216 | if (!diag_mux) |
| 217 | return -EIO; |
| 218 | |
Manoj Prabhu B | 571cf42 | 2017-08-08 19:01:41 +0530 | [diff] [blame] | 219 | peripheral = diag_md_get_peripheral(ctx); |
| 220 | if (peripheral < 0) { |
| 221 | DIAG_LOG(DIAG_DEBUG_PERIPHERALS, |
| 222 | "diag:%s:%d invalid peripheral = %d\n", |
| 223 | __func__, __LINE__, peripheral); |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 224 | return -EINVAL; |
Manoj Prabhu B | 571cf42 | 2017-08-08 19:01:41 +0530 | [diff] [blame] | 225 | } |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 226 | |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 227 | if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask) { |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 228 | logger = diag_mux->md_ptr; |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 229 | } else { |
| 230 | switch (driver->transport_set) { |
| 231 | case DIAG_ROUTE_TO_PCIE: |
| 232 | logger = diag_mux->pcie_ptr; |
| 233 | break; |
| 234 | case DIAG_ROUTE_TO_USB: |
| 235 | default: |
| 236 | logger = diag_mux->usb_ptr; |
| 237 | break; |
| 238 | } |
| 239 | } |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 240 | |
| 241 | if (logger && logger->log_ops && logger->log_ops->write) |
| 242 | return logger->log_ops->write(proc, buf, len, ctx); |
| 243 | return 0; |
| 244 | } |
| 245 | |
| 246 | int diag_mux_close_peripheral(int proc, uint8_t peripheral) |
| 247 | { |
| 248 | struct diag_logger_t *logger = NULL; |
| 249 | |
| 250 | if (proc < 0 || proc >= NUM_MUX_PROC) |
| 251 | return -EINVAL; |
| 252 | /* Peripheral should account for Apps data as well */ |
Manoj Prabhu B | 571cf42 | 2017-08-08 19:01:41 +0530 | [diff] [blame] | 253 | if (peripheral > NUM_PERIPHERALS) { |
| 254 | if (!driver->num_pd_session) |
| 255 | return -EINVAL; |
| 256 | if (peripheral > NUM_MD_SESSIONS) |
| 257 | return -EINVAL; |
| 258 | } |
| 259 | |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 260 | if (!diag_mux) |
| 261 | return -EIO; |
| 262 | |
| 263 | if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask) |
| 264 | logger = diag_mux->md_ptr; |
| 265 | else |
| 266 | logger = diag_mux->logger; |
| 267 | |
| 268 | if (logger && logger->log_ops && logger->log_ops->close_peripheral) |
| 269 | return logger->log_ops->close_peripheral(proc, peripheral); |
| 270 | return 0; |
| 271 | } |
| 272 | |
| 273 | int diag_mux_switch_logging(int *req_mode, int *peripheral_mask) |
| 274 | { |
| 275 | unsigned int new_mask = 0; |
| 276 | |
| 277 | if (!req_mode) |
| 278 | return -EINVAL; |
| 279 | |
Manoj Prabhu B | 571cf42 | 2017-08-08 19:01:41 +0530 | [diff] [blame] | 280 | if (*peripheral_mask <= 0 || |
| 281 | (*peripheral_mask > (DIAG_CON_ALL | DIAG_CON_UPD_ALL))) { |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 282 | pr_err("diag: mask %d in %s\n", *peripheral_mask, __func__); |
| 283 | return -EINVAL; |
| 284 | } |
| 285 | |
| 286 | switch (*req_mode) { |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 287 | case DIAG_PCIE_MODE: |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 288 | case DIAG_USB_MODE: |
| 289 | new_mask = ~(*peripheral_mask) & diag_mux->mux_mask; |
| 290 | if (new_mask != DIAG_CON_NONE) |
| 291 | *req_mode = DIAG_MULTI_MODE; |
Manoj Prabhu B | 85088ba | 2017-12-06 11:52:02 +0530 | [diff] [blame] | 292 | if (new_mask == DIAG_CON_ALL) |
| 293 | *req_mode = DIAG_MEMORY_DEVICE_MODE; |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 294 | break; |
| 295 | case DIAG_MEMORY_DEVICE_MODE: |
| 296 | new_mask = (*peripheral_mask) | diag_mux->mux_mask; |
| 297 | if (new_mask != DIAG_CON_ALL) |
| 298 | *req_mode = DIAG_MULTI_MODE; |
| 299 | break; |
| 300 | default: |
| 301 | pr_err("diag: Invalid mode %d in %s\n", *req_mode, __func__); |
| 302 | return -EINVAL; |
| 303 | } |
| 304 | |
| 305 | switch (diag_mux->mode) { |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 306 | case DIAG_PCIE_MODE: |
| 307 | if (*req_mode == DIAG_MEMORY_DEVICE_MODE) { |
| 308 | diag_mux->pcie_ptr->log_ops->close(); |
| 309 | diag_mux->logger = diag_mux->md_ptr; |
| 310 | diag_mux->md_ptr->log_ops->open(); |
| 311 | } else if (*req_mode == DIAG_MULTI_MODE) { |
| 312 | diag_mux->md_ptr->log_ops->open(); |
| 313 | diag_mux->logger = NULL; |
| 314 | } |
| 315 | break; |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 316 | case DIAG_USB_MODE: |
| 317 | if (*req_mode == DIAG_MEMORY_DEVICE_MODE) { |
| 318 | diag_mux->usb_ptr->log_ops->close(); |
| 319 | diag_mux->logger = diag_mux->md_ptr; |
| 320 | diag_mux->md_ptr->log_ops->open(); |
| 321 | } else if (*req_mode == DIAG_MULTI_MODE) { |
| 322 | diag_mux->md_ptr->log_ops->open(); |
| 323 | diag_mux->logger = NULL; |
| 324 | } |
| 325 | break; |
| 326 | case DIAG_MEMORY_DEVICE_MODE: |
| 327 | if (*req_mode == DIAG_USB_MODE) { |
| 328 | diag_mux->md_ptr->log_ops->close(); |
| 329 | diag_mux->logger = diag_mux->usb_ptr; |
| 330 | diag_mux->usb_ptr->log_ops->open(); |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 331 | } else if (*req_mode == DIAG_PCIE_MODE) { |
| 332 | diag_mux->md_ptr->log_ops->close(); |
| 333 | diag_mux->logger = diag_mux->pcie_ptr; |
| 334 | diag_mux->pcie_ptr->log_ops->open(); |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 335 | } else if (*req_mode == DIAG_MULTI_MODE) { |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 336 | if (driver->transport_set == DIAG_ROUTE_TO_PCIE) |
| 337 | diag_mux->pcie_ptr->log_ops->open(); |
| 338 | else |
| 339 | diag_mux->usb_ptr->log_ops->open(); |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 340 | diag_mux->logger = NULL; |
| 341 | } |
| 342 | break; |
| 343 | case DIAG_MULTI_MODE: |
| 344 | if (*req_mode == DIAG_USB_MODE) { |
| 345 | diag_mux->md_ptr->log_ops->close(); |
| 346 | diag_mux->logger = diag_mux->usb_ptr; |
Sreelakshmi Gownipalli | 75c91e1 | 2018-10-16 16:54:43 -0700 | [diff] [blame] | 347 | } else if (*req_mode == DIAG_PCIE_MODE) { |
| 348 | diag_mux->md_ptr->log_ops->close(); |
| 349 | diag_mux->logger = diag_mux->pcie_ptr; |
Sreelakshmi Gownipalli | cb8893d | 2016-10-19 16:02:34 -0700 | [diff] [blame] | 350 | } else if (*req_mode == DIAG_MEMORY_DEVICE_MODE) { |
| 351 | diag_mux->usb_ptr->log_ops->close(); |
| 352 | diag_mux->logger = diag_mux->md_ptr; |
| 353 | } |
| 354 | break; |
| 355 | } |
| 356 | diag_mux->mode = *req_mode; |
| 357 | diag_mux->mux_mask = new_mask; |
| 358 | *peripheral_mask = new_mask; |
| 359 | return 0; |
| 360 | } |