drivers/remoteproc/remoteproc_sysfs.c

   1 /*
   2  * Remote Processor Framework
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * 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 #include <linux/remoteproc.h>
  15
  16 #include "remoteproc_internal.h"
  17
  18 #define to_rproc(d) container_of(d, struct rproc, dev)
  19
  20 /* Expose the loaded / running firmware name via sysfs */
  21 static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
  22                           char *buf)
  23 {
  24         struct rproc *rproc = to_rproc(dev);
  25
  26         return sprintf(buf, "%s\n", rproc->firmware);
  27 }
  28
  29 /* Change firmware name via sysfs */
  30 static ssize_t firmware_store(struct device *dev,
  31                               struct device_attribute *attr,
  32                               const char *buf, size_t count)
  33 {
  34         struct rproc *rproc = to_rproc(dev);
  35         char *p;
  36         int err, len = count;
  37
  38         err = mutex_lock_interruptible(&rproc->lock);
  39         if (err) {
  40                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, err);
  41                 return -EINVAL;
  42         }
  43
  44         if (rproc->state != RPROC_OFFLINE) {
  45                 dev_err(dev, "can't change firmware while running\n");
  46                 err = -EBUSY;
  47                 goto out;
  48         }
  49
  50         len = strcspn(buf, "\n");
  51
  52         p = kstrndup(buf, len, GFP_KERNEL);
  53         if (!p) {
  54                 err = -ENOMEM;
  55                 goto out;
  56         }
  57
  58         kfree(rproc->firmware);
  59         rproc->firmware = p;
  60 out:
  61         mutex_unlock(&rproc->lock);
  62
  63         return err ? err : count;
  64 }
  65 static DEVICE_ATTR_RW(firmware);
  66
  67 /*
  68  * A state-to-string lookup table, for exposing a human readable state
  69  * via sysfs. Always keep in sync with enum rproc_state
  70  */
  71 static const char * const rproc_state_string[] = {
  72         [RPROC_OFFLINE]         = "offline",
  73         [RPROC_SUSPENDED]       = "suspended",
  74         [RPROC_RUNNING]         = "running",
  75         [RPROC_CRASHED]         = "crashed",
  76         [RPROC_LAST]            = "invalid",
  77 };
  78
  79 /* Expose the state of the remote processor via sysfs */
  80 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
  81                           char *buf)
  82 {
  83         struct rproc *rproc = to_rproc(dev);
  84         unsigned int state;
  85
  86         state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
  87         return sprintf(buf, "%s\n", rproc_state_string[state]);
  88 }
  89
  90 /* Change remote processor state via sysfs */
  91 static ssize_t state_store(struct device *dev,
  92                               struct device_attribute *attr,
  93                               const char *buf, size_t count)
  94 {
  95         struct rproc *rproc = to_rproc(dev);
  96         int ret = 0;
  97
  98         if (sysfs_streq(buf, "start")) {
  99                 if (rproc->state == RPROC_RUNNING)
 100                         return -EBUSY;
 101
 102                 ret = rproc_boot(rproc);
 103                 if (ret)
 104                         dev_err(&rproc->dev, "Boot failed: %d\n", ret);
 105         } else if (sysfs_streq(buf, "stop")) {
 106                 if (rproc->state != RPROC_RUNNING)
 107                         return -EINVAL;
 108
 109                 rproc_shutdown(rproc);
 110         } else {
 111                 dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
 112                 ret = -EINVAL;
 113         }
 114         return ret ? ret : count;
 115 }
 116 static DEVICE_ATTR_RW(state);
 117
 118 static struct attribute *rproc_attrs[] = {
 119         &dev_attr_firmware.attr,
 120         &dev_attr_state.attr,
 121         NULL
 122 };
 123
 124 static const struct attribute_group rproc_devgroup = {
 125         .attrs = rproc_attrs
 126 };
 127
 128 static const struct attribute_group *rproc_devgroups[] = {
 129         &rproc_devgroup,
 130         NULL
 131 };
 132
 133 struct class rproc_class = {
 134         .name           = "remoteproc",
 135         .dev_groups     = rproc_devgroups,
 136 };
 137
 138 int __init rproc_init_sysfs(void)
 139 {
 140         /* create remoteproc device class for sysfs */
 141         int err = class_register(&rproc_class);
 142
 143         if (err)
 144                 pr_err("remoteproc: unable to register class\n");
 145         return err;
 146 }
 147
 148 void __exit rproc_exit_sysfs(void)
 149 {
 150         class_unregister(&rproc_class);
 151 }