1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2019 Christian Mauderer <oss@c-mauderer.de>
/*
* The driver supports controllers with a very simple SPI protocol:
* - one LED is controlled by a single byte on MOSI
* - the value of the byte gives the brightness between two values (lowest to
* highest)
* - no return value is necessary (no MISO signal)
*
* The value for minimum and maximum brightness depends on the device
* (compatible string).
*
* Supported devices:
* - "ubnt,acb-spi-led": Microcontroller (SONiX 8F26E611LA) based device used
* for example in Ubiquiti airCube ISP. Reverse engineered protocol for this
* controller:
* * Higher two bits set a mode. Lower six bits are a parameter.
* * Mode: 00 -> set brightness between 0x00 (min) and 0x3F (max)
* * Mode: 01 -> pulsing pattern (min -> max -> min) with an interval. From
* some tests, the period is about (50ms + 102ms * parameter). There is a
* slightly different pattern starting from 0x10 (longer gap between the
* pulses) but the time still follows that calculation.
* * Mode: 10 -> same as 01 but with only a ramp from min to max. Again a
* slight jump in the pattern at 0x10.
* * Mode: 11 -> blinking (off -> 25% -> off -> 25% -> ...) with a period of
* (105ms * parameter)
* NOTE: This driver currently only supports mode 00.
*/
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/spi/spi.h>
#include <linux/mutex.h>
#include <uapi/linux/uleds.h>
struct spi_byte_chipdef {
/* SPI byte that will be send to switch the LED off */
u8 off_value;
/* SPI byte that will be send to switch the LED to maximum brightness */
u8 max_value;
};
struct spi_byte_led {
struct led_classdev ldev;
struct spi_device *spi;
char name[LED_MAX_NAME_SIZE];
struct mutex mutex;
const struct spi_byte_chipdef *cdef;
};
static const struct spi_byte_chipdef ubnt_acb_spi_led_cdef = {
.off_value = 0x0,
.max_value = 0x3F,
};
static const struct of_device_id spi_byte_dt_ids[] = {
{ .compatible = "ubnt,acb-spi-led", .data = &ubnt_acb_spi_led_cdef },
{},
};
MODULE_DEVICE_TABLE(of, spi_byte_dt_ids);
static int spi_byte_brightness_set_blocking(struct led_classdev *dev,
enum led_brightness brightness)
{
struct spi_byte_led *led = container_of(dev, struct spi_byte_led, ldev);
u8 value;
int ret;
value = (u8) brightness + led->cdef->off_value;
mutex_lock(&led->mutex);
ret = spi_write(led->spi, &value, sizeof(value));
mutex_unlock(&led->mutex);
return ret;
}
static int spi_byte_probe(struct spi_device *spi)
{
struct device_node *child;
struct device *dev = &spi->dev;
struct spi_byte_led *led;
const char *name = "leds-spi-byte::";
const char *state;
int ret;
if (of_get_available_child_count(dev_of_node(dev)) != 1) {
dev_err(dev, "Device must have exactly one LED sub-node.");
return -EINVAL;
}
child = of_get_next_available_child(dev_of_node(dev), NULL);
led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
if (!led)
return -ENOMEM;
of_property_read_string(child, "label", &name);
strscpy(led->name, name, sizeof(led->name));
led->spi = spi;
mutex_init(&led->mutex);
led->cdef = device_get_match_data(dev);
led->ldev.name = led->name;
led->ldev.brightness = LED_OFF;
led->ldev.max_brightness = led->cdef->max_value - led->cdef->off_value;
led->ldev.brightness_set_blocking = spi_byte_brightness_set_blocking;
state = of_get_property(child, "default-state", NULL);
if (state) {
if (!strcmp(state, "on")) {
led->ldev.brightness = led->ldev.max_brightness;
} else if (strcmp(state, "off")) {
/* all other cases except "off" */
dev_err(dev, "default-state can only be 'on' or 'off'");
return -EINVAL;
}
}
spi_byte_brightness_set_blocking(&led->ldev,
led->ldev.brightness);
ret = devm_led_classdev_register(&spi->dev, &led->ldev);
if (ret) {
mutex_destroy(&led->mutex);
return ret;
}
spi_set_drvdata(spi, led);
return 0;
}
static void spi_byte_remove(struct spi_device *spi)
{
struct spi_byte_led *led = spi_get_drvdata(spi);
mutex_destroy(&led->mutex);
}
static struct spi_driver spi_byte_driver = {
.probe = spi_byte_probe,
.remove = spi_byte_remove,
.driver = {
.name = KBUILD_MODNAME,
.of_match_table = spi_byte_dt_ids,
},
};
module_spi_driver(spi_byte_driver);
MODULE_AUTHOR("Christian Mauderer <oss@c-mauderer.de>");
MODULE_DESCRIPTION("single byte SPI LED driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("spi:leds-spi-byte");
|
