linux/drivers/platform/chrome/cros_ec_lightbar.c

// SPDX-License-Identifier: GPL-2.0+
// Expose the Chromebook Pixel lightbar to userspace
//
// Copyright (C) 2014 Google, Inc.

#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/kobject.h>
#include <linux/kstrtox.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/slab.h>

#define DRV_NAME …

/* Rate-limit the lightbar interface to prevent DoS. */
static unsigned long lb_interval_jiffies = …;

/*
 * Whether or not we have given userspace control of the lightbar.
 * If this is true, we won't do anything during suspend/resume.
 */
static bool userspace_control;

static ssize_t interval_msec_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{ … }

static ssize_t interval_msec_store(struct device *dev,
				   struct device_attribute *attr,
				   const char *buf, size_t count)
{ … }

static DEFINE_MUTEX(lb_mutex);
/* Return 0 if able to throttle correctly, error otherwise */
static int lb_throttle(void)
{ … }

static struct cros_ec_command *alloc_lightbar_cmd_msg(struct cros_ec_dev *ec)
{ … }

static int get_lightbar_version(struct cros_ec_dev *ec,
				uint32_t *ver_ptr, uint32_t *flg_ptr)
{ … }

static ssize_t version_show(struct device *dev,
			    struct device_attribute *attr, char *buf)
{ … }

static ssize_t brightness_store(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{ … }


/*
 * We expect numbers, and we'll keep reading until we find them, skipping over
 * any whitespace (sysfs guarantees that the input is null-terminated). Every
 * four numbers are sent to the lightbar as <LED,R,G,B>. We fail at the first
 * parsing error, if we don't parse any numbers, or if we have numbers left
 * over.
 */
static ssize_t led_rgb_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{ … }

static char const *seqname[] = …;

static ssize_t sequence_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{ … }

static int lb_send_empty_cmd(struct cros_ec_dev *ec, uint8_t cmd)
{ … }

static int lb_manual_suspend_ctrl(struct cros_ec_dev *ec, uint8_t enable)
{ … }

static ssize_t sequence_store(struct device *dev, struct device_attribute *attr,
			      const char *buf, size_t count)
{ … }

static ssize_t program_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{ … }

static ssize_t userspace_control_show(struct device *dev,
				      struct device_attribute *attr,
				      char *buf)
{ … }

static ssize_t userspace_control_store(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf,
				       size_t count)
{ … }

/* Module initialization */

static DEVICE_ATTR_RW(interval_msec);
static DEVICE_ATTR_RO(version);
static DEVICE_ATTR_WO(brightness);
static DEVICE_ATTR_WO(led_rgb);
static DEVICE_ATTR_RW(sequence);
static DEVICE_ATTR_WO(program);
static DEVICE_ATTR_RW(userspace_control);

static struct attribute *__lb_cmds_attrs[] = …;

static const struct attribute_group cros_ec_lightbar_attr_group = …;

static int cros_ec_lightbar_probe(struct platform_device *pd)
{ … }

static void cros_ec_lightbar_remove(struct platform_device *pd)
{ … }

static int __maybe_unused cros_ec_lightbar_resume(struct device *dev)
{ … }

static int __maybe_unused cros_ec_lightbar_suspend(struct device *dev)
{ … }

static SIMPLE_DEV_PM_OPS(cros_ec_lightbar_pm_ops,
			 cros_ec_lightbar_suspend, cros_ec_lightbar_resume);

static const struct platform_device_id cros_ec_lightbar_id[] = …;
MODULE_DEVICE_TABLE(platform, cros_ec_lightbar_id);

static struct platform_driver cros_ec_lightbar_driver = …;

module_platform_driver(…) …;

MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;