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_DELETED]         = "deleted",
  77         [RPROC_LAST]            = "invalid",
  78 };
  79
  80 /* Expose the state of the remote processor via sysfs */
  81 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
  82                           char *buf)
  83 {
  84         struct rproc *rproc = to_rproc(dev);
  85         unsigned int state;
  86
  87         state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
  88         return sprintf(buf, "%s\n", rproc_state_string[state]);
  89 }
  90
  91 /* Change remote processor state via sysfs */
  92 static ssize_t state_store(struct device *dev,
  93                               struct device_attribute *attr,
  94                               const char *buf, size_t count)
  95 {
  96         struct rproc *rproc = to_rproc(dev);
  97         int ret = 0;
  98
  99         if (sysfs_streq(buf, "start")) {
 100                 if (rproc->state == RPROC_RUNNING)
 101                         return -EBUSY;
 102
 103                 ret = rproc_boot(rproc);
 104                 if (ret)
 105                         dev_err(&rproc->dev, "Boot failed: %d\n", ret);
 106         } else if (sysfs_streq(buf, "stop")) {
 107                 if (rproc->state != RPROC_RUNNING)
 108                         return -EINVAL;
 109
 110                 rproc_shutdown(rproc);
 111         } else {
 112                 dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
 113                 ret = -EINVAL;
 114         }
 115         return ret ? ret : count;
 116 }
 117 static DEVICE_ATTR_RW(state);
 118
 119 static struct attribute *rproc_attrs[] = {
 120         &dev_attr_firmware.attr,
 121         &dev_attr_state.attr,
 122         NULL
 123 };
 124
 125 static const struct attribute_group rproc_devgroup = {
 126         .attrs = rproc_attrs
 127 };
 128
 129 static const struct attribute_group *rproc_devgroups[] = {
 130         &rproc_devgroup,
 131         NULL
 132 };
 133
 134 struct class rproc_class = {
 135         .name           = "remoteproc",
 136         .dev_groups     = rproc_devgroups,
 137 };
 138
 139 int __init rproc_init_sysfs(void)
 140 {
 141         /* create remoteproc device class for sysfs */
 142         int err = class_register(&rproc_class);
 143
 144         if (err)
 145                 pr_err("remoteproc: unable to register class\n");
 146         return err;
 147 }
 148
 149 void __exit rproc_exit_sysfs(void)
 150 {
 151         class_unregister(&rproc_class);
 152 }