Ashutosh Dixit | f8487a2 | 2015-09-29 18:12:27 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Intel MIC Platform Software Stack (MPSS) |
| 3 | * |
| 4 | * Copyright(c) 2015 Intel Corporation. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License, version 2, as |
| 8 | * published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, but |
| 11 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 13 | * General Public License for more details. |
| 14 | * |
| 15 | * The full GNU General Public License is included in this distribution in |
| 16 | * the file called "COPYING". |
| 17 | * |
| 18 | * Intel MIC Coprocessor State Management (COSM) Driver |
| 19 | * |
| 20 | */ |
| 21 | |
| 22 | #include <linux/module.h> |
| 23 | #include <linux/delay.h> |
| 24 | #include <linux/idr.h> |
| 25 | #include <linux/slab.h> |
| 26 | #include <linux/cred.h> |
| 27 | #include "cosm_main.h" |
| 28 | |
| 29 | static const char cosm_driver_name[] = "mic"; |
| 30 | |
| 31 | /* COSM ID allocator */ |
| 32 | static struct ida g_cosm_ida; |
| 33 | /* Class of MIC devices for sysfs accessibility. */ |
| 34 | static struct class *g_cosm_class; |
| 35 | /* Number of MIC devices */ |
| 36 | static atomic_t g_num_dev; |
| 37 | |
| 38 | /** |
| 39 | * cosm_hw_reset - Issue a HW reset for the MIC device |
| 40 | * @cdev: pointer to cosm_device instance |
| 41 | */ |
| 42 | static void cosm_hw_reset(struct cosm_device *cdev, bool force) |
| 43 | { |
| 44 | int i; |
| 45 | |
| 46 | #define MIC_RESET_TO (45) |
| 47 | if (force && cdev->hw_ops->force_reset) |
| 48 | cdev->hw_ops->force_reset(cdev); |
| 49 | else |
| 50 | cdev->hw_ops->reset(cdev); |
| 51 | |
| 52 | for (i = 0; i < MIC_RESET_TO; i++) { |
| 53 | if (cdev->hw_ops->ready(cdev)) { |
| 54 | cosm_set_state(cdev, MIC_READY); |
| 55 | return; |
| 56 | } |
| 57 | /* |
| 58 | * Resets typically take 10s of seconds to complete. |
| 59 | * Since an MMIO read is required to check if the |
| 60 | * firmware is ready or not, a 1 second delay works nicely. |
| 61 | */ |
| 62 | msleep(1000); |
| 63 | } |
| 64 | cosm_set_state(cdev, MIC_RESET_FAILED); |
| 65 | } |
| 66 | |
| 67 | /** |
| 68 | * cosm_start - Start the MIC |
| 69 | * @cdev: pointer to cosm_device instance |
| 70 | * |
| 71 | * This function prepares an MIC for boot and initiates boot. |
| 72 | * RETURNS: An appropriate -ERRNO error value on error, or 0 for success. |
| 73 | */ |
| 74 | int cosm_start(struct cosm_device *cdev) |
| 75 | { |
| 76 | const struct cred *orig_cred; |
| 77 | struct cred *override_cred; |
| 78 | int rc; |
| 79 | |
| 80 | mutex_lock(&cdev->cosm_mutex); |
| 81 | if (!cdev->bootmode) { |
| 82 | dev_err(&cdev->dev, "%s %d bootmode not set\n", |
| 83 | __func__, __LINE__); |
| 84 | rc = -EINVAL; |
| 85 | goto unlock_ret; |
| 86 | } |
| 87 | retry: |
| 88 | if (cdev->state != MIC_READY) { |
| 89 | dev_err(&cdev->dev, "%s %d MIC state not READY\n", |
| 90 | __func__, __LINE__); |
| 91 | rc = -EINVAL; |
| 92 | goto unlock_ret; |
| 93 | } |
| 94 | if (!cdev->hw_ops->ready(cdev)) { |
| 95 | cosm_hw_reset(cdev, false); |
| 96 | /* |
| 97 | * The state will either be MIC_READY if the reset succeeded |
| 98 | * or MIC_RESET_FAILED if the firmware reset failed. |
| 99 | */ |
| 100 | goto retry; |
| 101 | } |
| 102 | |
| 103 | /* |
| 104 | * Set credentials to root to allow non-root user to download initramsfs |
| 105 | * with 600 permissions |
| 106 | */ |
| 107 | override_cred = prepare_creds(); |
| 108 | if (!override_cred) { |
| 109 | dev_err(&cdev->dev, "%s %d prepare_creds failed\n", |
| 110 | __func__, __LINE__); |
| 111 | rc = -ENOMEM; |
| 112 | goto unlock_ret; |
| 113 | } |
| 114 | override_cred->fsuid = GLOBAL_ROOT_UID; |
| 115 | orig_cred = override_creds(override_cred); |
| 116 | |
| 117 | rc = cdev->hw_ops->start(cdev, cdev->index); |
| 118 | |
| 119 | revert_creds(orig_cred); |
| 120 | put_cred(override_cred); |
| 121 | if (rc) |
| 122 | goto unlock_ret; |
| 123 | |
| 124 | /* |
| 125 | * If linux is being booted, card is treated 'online' only |
| 126 | * when the scif interface in the card is up. If anything else |
| 127 | * is booted, we set card to 'online' immediately. |
| 128 | */ |
| 129 | if (!strcmp(cdev->bootmode, "linux")) |
| 130 | cosm_set_state(cdev, MIC_BOOTING); |
| 131 | else |
| 132 | cosm_set_state(cdev, MIC_ONLINE); |
| 133 | unlock_ret: |
| 134 | mutex_unlock(&cdev->cosm_mutex); |
| 135 | if (rc) |
| 136 | dev_err(&cdev->dev, "cosm_start failed rc %d\n", rc); |
| 137 | return rc; |
| 138 | } |
| 139 | |
| 140 | /** |
| 141 | * cosm_stop - Prepare the MIC for reset and trigger reset |
| 142 | * @cdev: pointer to cosm_device instance |
| 143 | * @force: force a MIC to reset even if it is already reset and ready. |
| 144 | * |
| 145 | * RETURNS: None |
| 146 | */ |
| 147 | void cosm_stop(struct cosm_device *cdev, bool force) |
| 148 | { |
| 149 | mutex_lock(&cdev->cosm_mutex); |
| 150 | if (cdev->state != MIC_READY || force) { |
| 151 | /* |
| 152 | * Don't call hw_ops if they have been called previously. |
| 153 | * stop(..) calls device_unregister and will crash the system if |
| 154 | * called multiple times. |
| 155 | */ |
Ashutosh Dixit | f38e87e | 2015-11-17 15:55:37 -0800 | [diff] [blame] | 156 | u8 state = cdev->state == MIC_RESETTING ? |
| 157 | cdev->prev_state : cdev->state; |
| 158 | bool call_hw_ops = state != MIC_RESET_FAILED && |
| 159 | state != MIC_READY; |
Ashutosh Dixit | f8487a2 | 2015-09-29 18:12:27 -0700 | [diff] [blame] | 160 | |
| 161 | if (cdev->state != MIC_RESETTING) |
| 162 | cosm_set_state(cdev, MIC_RESETTING); |
| 163 | cdev->heartbeat_watchdog_enable = false; |
| 164 | if (call_hw_ops) |
| 165 | cdev->hw_ops->stop(cdev, force); |
| 166 | cosm_hw_reset(cdev, force); |
| 167 | cosm_set_shutdown_status(cdev, MIC_NOP); |
| 168 | if (call_hw_ops && cdev->hw_ops->post_reset) |
| 169 | cdev->hw_ops->post_reset(cdev, cdev->state); |
| 170 | } |
| 171 | mutex_unlock(&cdev->cosm_mutex); |
| 172 | flush_work(&cdev->scif_work); |
| 173 | } |
| 174 | |
| 175 | /** |
| 176 | * cosm_reset_trigger_work - Trigger MIC reset |
| 177 | * @work: The work structure |
| 178 | * |
| 179 | * This work is scheduled whenever the host wants to reset the MIC. |
| 180 | */ |
| 181 | static void cosm_reset_trigger_work(struct work_struct *work) |
| 182 | { |
| 183 | struct cosm_device *cdev = container_of(work, struct cosm_device, |
| 184 | reset_trigger_work); |
| 185 | cosm_stop(cdev, false); |
| 186 | } |
| 187 | |
| 188 | /** |
| 189 | * cosm_reset - Schedule MIC reset |
| 190 | * @cdev: pointer to cosm_device instance |
| 191 | * |
| 192 | * RETURNS: An -EINVAL if the card is already READY or 0 for success. |
| 193 | */ |
| 194 | int cosm_reset(struct cosm_device *cdev) |
| 195 | { |
| 196 | int rc = 0; |
| 197 | |
| 198 | mutex_lock(&cdev->cosm_mutex); |
| 199 | if (cdev->state != MIC_READY) { |
Ashutosh Dixit | f38e87e | 2015-11-17 15:55:37 -0800 | [diff] [blame] | 200 | if (cdev->state != MIC_RESETTING) { |
| 201 | cdev->prev_state = cdev->state; |
| 202 | cosm_set_state(cdev, MIC_RESETTING); |
| 203 | schedule_work(&cdev->reset_trigger_work); |
| 204 | } |
Ashutosh Dixit | f8487a2 | 2015-09-29 18:12:27 -0700 | [diff] [blame] | 205 | } else { |
| 206 | dev_err(&cdev->dev, "%s %d MIC is READY\n", __func__, __LINE__); |
| 207 | rc = -EINVAL; |
| 208 | } |
| 209 | mutex_unlock(&cdev->cosm_mutex); |
| 210 | return rc; |
| 211 | } |
| 212 | |
| 213 | /** |
| 214 | * cosm_shutdown - Initiate MIC shutdown. |
| 215 | * @cdev: pointer to cosm_device instance |
| 216 | * |
| 217 | * RETURNS: None |
| 218 | */ |
| 219 | int cosm_shutdown(struct cosm_device *cdev) |
| 220 | { |
| 221 | struct cosm_msg msg = { .id = COSM_MSG_SHUTDOWN }; |
| 222 | int rc = 0; |
| 223 | |
| 224 | mutex_lock(&cdev->cosm_mutex); |
| 225 | if (cdev->state != MIC_ONLINE) { |
| 226 | rc = -EINVAL; |
| 227 | dev_err(&cdev->dev, "%s %d skipping shutdown in state: %s\n", |
| 228 | __func__, __LINE__, cosm_state_string[cdev->state]); |
| 229 | goto err; |
| 230 | } |
| 231 | |
| 232 | if (!cdev->epd) { |
| 233 | rc = -ENOTCONN; |
| 234 | dev_err(&cdev->dev, "%s %d scif endpoint not connected rc %d\n", |
| 235 | __func__, __LINE__, rc); |
| 236 | goto err; |
| 237 | } |
| 238 | |
| 239 | rc = scif_send(cdev->epd, &msg, sizeof(msg), SCIF_SEND_BLOCK); |
| 240 | if (rc < 0) { |
| 241 | dev_err(&cdev->dev, "%s %d scif_send failed rc %d\n", |
| 242 | __func__, __LINE__, rc); |
| 243 | goto err; |
| 244 | } |
| 245 | cdev->heartbeat_watchdog_enable = false; |
| 246 | cosm_set_state(cdev, MIC_SHUTTING_DOWN); |
| 247 | rc = 0; |
| 248 | err: |
| 249 | mutex_unlock(&cdev->cosm_mutex); |
| 250 | return rc; |
| 251 | } |
| 252 | |
| 253 | static int cosm_driver_probe(struct cosm_device *cdev) |
| 254 | { |
| 255 | int rc; |
| 256 | |
| 257 | /* Initialize SCIF server at first probe */ |
| 258 | if (atomic_add_return(1, &g_num_dev) == 1) { |
| 259 | rc = cosm_scif_init(); |
| 260 | if (rc) |
| 261 | goto scif_exit; |
| 262 | } |
| 263 | mutex_init(&cdev->cosm_mutex); |
| 264 | INIT_WORK(&cdev->reset_trigger_work, cosm_reset_trigger_work); |
| 265 | INIT_WORK(&cdev->scif_work, cosm_scif_work); |
| 266 | cdev->sysfs_heartbeat_enable = true; |
| 267 | cosm_sysfs_init(cdev); |
| 268 | cdev->sdev = device_create_with_groups(g_cosm_class, cdev->dev.parent, |
| 269 | MKDEV(0, cdev->index), cdev, cdev->attr_group, |
| 270 | "mic%d", cdev->index); |
| 271 | if (IS_ERR(cdev->sdev)) { |
| 272 | rc = PTR_ERR(cdev->sdev); |
| 273 | dev_err(&cdev->dev, "device_create_with_groups failed rc %d\n", |
| 274 | rc); |
| 275 | goto scif_exit; |
| 276 | } |
| 277 | |
| 278 | cdev->state_sysfs = sysfs_get_dirent(cdev->sdev->kobj.sd, |
| 279 | "state"); |
| 280 | if (!cdev->state_sysfs) { |
| 281 | rc = -ENODEV; |
| 282 | dev_err(&cdev->dev, "sysfs_get_dirent failed rc %d\n", rc); |
| 283 | goto destroy_device; |
| 284 | } |
| 285 | cosm_create_debug_dir(cdev); |
| 286 | return 0; |
| 287 | destroy_device: |
| 288 | device_destroy(g_cosm_class, MKDEV(0, cdev->index)); |
| 289 | scif_exit: |
| 290 | if (atomic_dec_and_test(&g_num_dev)) |
| 291 | cosm_scif_exit(); |
| 292 | return rc; |
| 293 | } |
| 294 | |
| 295 | static void cosm_driver_remove(struct cosm_device *cdev) |
| 296 | { |
| 297 | cosm_delete_debug_dir(cdev); |
| 298 | sysfs_put(cdev->state_sysfs); |
| 299 | device_destroy(g_cosm_class, MKDEV(0, cdev->index)); |
| 300 | flush_work(&cdev->reset_trigger_work); |
| 301 | cosm_stop(cdev, false); |
| 302 | if (atomic_dec_and_test(&g_num_dev)) |
| 303 | cosm_scif_exit(); |
| 304 | |
| 305 | /* These sysfs entries might have allocated */ |
| 306 | kfree(cdev->cmdline); |
| 307 | kfree(cdev->firmware); |
| 308 | kfree(cdev->ramdisk); |
| 309 | kfree(cdev->bootmode); |
| 310 | } |
| 311 | |
| 312 | static int cosm_suspend(struct device *dev) |
| 313 | { |
| 314 | struct cosm_device *cdev = dev_to_cosm(dev); |
| 315 | |
| 316 | mutex_lock(&cdev->cosm_mutex); |
| 317 | switch (cdev->state) { |
| 318 | /** |
| 319 | * Suspend/freeze hooks in userspace have already shutdown the card. |
| 320 | * Card should be 'ready' in most cases. It is however possible that |
| 321 | * some userspace application initiated a boot. In those cases, we |
| 322 | * simply reset the card. |
| 323 | */ |
| 324 | case MIC_ONLINE: |
| 325 | case MIC_BOOTING: |
| 326 | case MIC_SHUTTING_DOWN: |
| 327 | mutex_unlock(&cdev->cosm_mutex); |
| 328 | cosm_stop(cdev, false); |
| 329 | break; |
| 330 | default: |
| 331 | mutex_unlock(&cdev->cosm_mutex); |
| 332 | break; |
| 333 | } |
| 334 | return 0; |
| 335 | } |
| 336 | |
| 337 | static const struct dev_pm_ops cosm_pm_ops = { |
| 338 | .suspend = cosm_suspend, |
| 339 | .freeze = cosm_suspend |
| 340 | }; |
| 341 | |
| 342 | static struct cosm_driver cosm_driver = { |
| 343 | .driver = { |
| 344 | .name = KBUILD_MODNAME, |
| 345 | .owner = THIS_MODULE, |
| 346 | .pm = &cosm_pm_ops, |
| 347 | }, |
| 348 | .probe = cosm_driver_probe, |
| 349 | .remove = cosm_driver_remove |
| 350 | }; |
| 351 | |
| 352 | static int __init cosm_init(void) |
| 353 | { |
| 354 | int ret; |
| 355 | |
| 356 | cosm_init_debugfs(); |
| 357 | |
| 358 | g_cosm_class = class_create(THIS_MODULE, cosm_driver_name); |
| 359 | if (IS_ERR(g_cosm_class)) { |
| 360 | ret = PTR_ERR(g_cosm_class); |
| 361 | pr_err("class_create failed ret %d\n", ret); |
| 362 | goto cleanup_debugfs; |
| 363 | } |
| 364 | |
| 365 | ida_init(&g_cosm_ida); |
| 366 | ret = cosm_register_driver(&cosm_driver); |
| 367 | if (ret) { |
| 368 | pr_err("cosm_register_driver failed ret %d\n", ret); |
| 369 | goto ida_destroy; |
| 370 | } |
| 371 | return 0; |
| 372 | ida_destroy: |
| 373 | ida_destroy(&g_cosm_ida); |
| 374 | class_destroy(g_cosm_class); |
| 375 | cleanup_debugfs: |
| 376 | cosm_exit_debugfs(); |
| 377 | return ret; |
| 378 | } |
| 379 | |
| 380 | static void __exit cosm_exit(void) |
| 381 | { |
| 382 | cosm_unregister_driver(&cosm_driver); |
| 383 | ida_destroy(&g_cosm_ida); |
| 384 | class_destroy(g_cosm_class); |
| 385 | cosm_exit_debugfs(); |
| 386 | } |
| 387 | |
| 388 | module_init(cosm_init); |
| 389 | module_exit(cosm_exit); |
| 390 | |
| 391 | MODULE_AUTHOR("Intel Corporation"); |
| 392 | MODULE_DESCRIPTION("Intel(R) MIC Coprocessor State Management (COSM) Driver"); |
| 393 | MODULE_LICENSE("GPL v2"); |