Loading...
1/*
2 * leds-max8997.c - LED class driver for MAX8997 LEDs.
3 *
4 * Copyright (C) 2011 Samsung Electronics
5 * Donggeun Kim <dg77.kim@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 */
12
13#include <linux/module.h>
14#include <linux/err.h>
15#include <linux/slab.h>
16#include <linux/workqueue.h>
17#include <linux/leds.h>
18#include <linux/mfd/max8997.h>
19#include <linux/mfd/max8997-private.h>
20#include <linux/platform_device.h>
21
22#define MAX8997_LED_FLASH_SHIFT 3
23#define MAX8997_LED_FLASH_CUR_MASK 0xf8
24#define MAX8997_LED_MOVIE_SHIFT 4
25#define MAX8997_LED_MOVIE_CUR_MASK 0xf0
26
27#define MAX8997_LED_FLASH_MAX_BRIGHTNESS 0x1f
28#define MAX8997_LED_MOVIE_MAX_BRIGHTNESS 0xf
29#define MAX8997_LED_NONE_MAX_BRIGHTNESS 0
30
31#define MAX8997_LED0_FLASH_MASK 0x1
32#define MAX8997_LED0_FLASH_PIN_MASK 0x5
33#define MAX8997_LED0_MOVIE_MASK 0x8
34#define MAX8997_LED0_MOVIE_PIN_MASK 0x28
35
36#define MAX8997_LED1_FLASH_MASK 0x2
37#define MAX8997_LED1_FLASH_PIN_MASK 0x6
38#define MAX8997_LED1_MOVIE_MASK 0x10
39#define MAX8997_LED1_MOVIE_PIN_MASK 0x30
40
41#define MAX8997_LED_BOOST_ENABLE_MASK (1 << 6)
42
43struct max8997_led {
44 struct max8997_dev *iodev;
45 struct led_classdev cdev;
46 bool enabled;
47 int id;
48 enum max8997_led_mode led_mode;
49 struct mutex mutex;
50};
51
52static void max8997_led_clear_mode(struct max8997_led *led,
53 enum max8997_led_mode mode)
54{
55 struct i2c_client *client = led->iodev->i2c;
56 u8 val = 0, mask = 0;
57 int ret;
58
59 switch (mode) {
60 case MAX8997_FLASH_MODE:
61 mask = led->id ?
62 MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
63 break;
64 case MAX8997_MOVIE_MODE:
65 mask = led->id ?
66 MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
67 break;
68 case MAX8997_FLASH_PIN_CONTROL_MODE:
69 mask = led->id ?
70 MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
71 break;
72 case MAX8997_MOVIE_PIN_CONTROL_MODE:
73 mask = led->id ?
74 MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
75 break;
76 default:
77 break;
78 }
79
80 if (mask) {
81 ret = max8997_update_reg(client,
82 MAX8997_REG_LEN_CNTL, val, mask);
83 if (ret)
84 dev_err(led->iodev->dev,
85 "failed to update register(%d)\n", ret);
86 }
87}
88
89static void max8997_led_set_mode(struct max8997_led *led,
90 enum max8997_led_mode mode)
91{
92 int ret;
93 struct i2c_client *client = led->iodev->i2c;
94 u8 mask = 0;
95
96 /* First, clear the previous mode */
97 max8997_led_clear_mode(led, led->led_mode);
98
99 switch (mode) {
100 case MAX8997_FLASH_MODE:
101 mask = led->id ?
102 MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
103 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
104 break;
105 case MAX8997_MOVIE_MODE:
106 mask = led->id ?
107 MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
108 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
109 break;
110 case MAX8997_FLASH_PIN_CONTROL_MODE:
111 mask = led->id ?
112 MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
113 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
114 break;
115 case MAX8997_MOVIE_PIN_CONTROL_MODE:
116 mask = led->id ?
117 MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
118 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
119 break;
120 default:
121 led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
122 break;
123 }
124
125 if (mask) {
126 ret = max8997_update_reg(client,
127 MAX8997_REG_LEN_CNTL, mask, mask);
128 if (ret)
129 dev_err(led->iodev->dev,
130 "failed to update register(%d)\n", ret);
131 }
132
133 led->led_mode = mode;
134}
135
136static void max8997_led_enable(struct max8997_led *led, bool enable)
137{
138 int ret;
139 struct i2c_client *client = led->iodev->i2c;
140 u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
141
142 if (led->enabled == enable)
143 return;
144
145 val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
146
147 ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
148 if (ret)
149 dev_err(led->iodev->dev,
150 "failed to update register(%d)\n", ret);
151
152 led->enabled = enable;
153}
154
155static void max8997_led_set_current(struct max8997_led *led,
156 enum led_brightness value)
157{
158 int ret;
159 struct i2c_client *client = led->iodev->i2c;
160 u8 val = 0, mask = 0, reg = 0;
161
162 switch (led->led_mode) {
163 case MAX8997_FLASH_MODE:
164 case MAX8997_FLASH_PIN_CONTROL_MODE:
165 val = value << MAX8997_LED_FLASH_SHIFT;
166 mask = MAX8997_LED_FLASH_CUR_MASK;
167 reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
168 break;
169 case MAX8997_MOVIE_MODE:
170 case MAX8997_MOVIE_PIN_CONTROL_MODE:
171 val = value << MAX8997_LED_MOVIE_SHIFT;
172 mask = MAX8997_LED_MOVIE_CUR_MASK;
173 reg = MAX8997_REG_MOVIE_CUR;
174 break;
175 default:
176 break;
177 }
178
179 if (mask) {
180 ret = max8997_update_reg(client, reg, val, mask);
181 if (ret)
182 dev_err(led->iodev->dev,
183 "failed to update register(%d)\n", ret);
184 }
185}
186
187static void max8997_led_brightness_set(struct led_classdev *led_cdev,
188 enum led_brightness value)
189{
190 struct max8997_led *led =
191 container_of(led_cdev, struct max8997_led, cdev);
192
193 if (value) {
194 max8997_led_set_current(led, value);
195 max8997_led_enable(led, true);
196 } else {
197 max8997_led_set_current(led, value);
198 max8997_led_enable(led, false);
199 }
200}
201
202static ssize_t max8997_led_show_mode(struct device *dev,
203 struct device_attribute *attr, char *buf)
204{
205 struct led_classdev *led_cdev = dev_get_drvdata(dev);
206 struct max8997_led *led =
207 container_of(led_cdev, struct max8997_led, cdev);
208 ssize_t ret = 0;
209
210 mutex_lock(&led->mutex);
211
212 switch (led->led_mode) {
213 case MAX8997_FLASH_MODE:
214 ret += sprintf(buf, "FLASH\n");
215 break;
216 case MAX8997_MOVIE_MODE:
217 ret += sprintf(buf, "MOVIE\n");
218 break;
219 case MAX8997_FLASH_PIN_CONTROL_MODE:
220 ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
221 break;
222 case MAX8997_MOVIE_PIN_CONTROL_MODE:
223 ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
224 break;
225 default:
226 ret += sprintf(buf, "NONE\n");
227 break;
228 }
229
230 mutex_unlock(&led->mutex);
231
232 return ret;
233}
234
235static ssize_t max8997_led_store_mode(struct device *dev,
236 struct device_attribute *attr,
237 const char *buf, size_t size)
238{
239 struct led_classdev *led_cdev = dev_get_drvdata(dev);
240 struct max8997_led *led =
241 container_of(led_cdev, struct max8997_led, cdev);
242 enum max8997_led_mode mode;
243
244 mutex_lock(&led->mutex);
245
246 if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
247 mode = MAX8997_FLASH_PIN_CONTROL_MODE;
248 else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
249 mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
250 else if (!strncmp(buf, "FLASH", 5))
251 mode = MAX8997_FLASH_MODE;
252 else if (!strncmp(buf, "MOVIE", 5))
253 mode = MAX8997_MOVIE_MODE;
254 else
255 mode = MAX8997_NONE;
256
257 max8997_led_set_mode(led, mode);
258
259 mutex_unlock(&led->mutex);
260
261 return size;
262}
263
264static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
265
266static int __devinit max8997_led_probe(struct platform_device *pdev)
267{
268 struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
269 struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
270 struct max8997_led *led;
271 char name[20];
272 int ret = 0;
273
274 if (pdata == NULL) {
275 dev_err(&pdev->dev, "no platform data\n");
276 return -ENODEV;
277 }
278
279 led = kzalloc(sizeof(*led), GFP_KERNEL);
280 if (led == NULL) {
281 ret = -ENOMEM;
282 goto err_mem;
283 }
284
285 led->id = pdev->id;
286 snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
287
288 led->cdev.name = name;
289 led->cdev.brightness_set = max8997_led_brightness_set;
290 led->cdev.flags |= LED_CORE_SUSPENDRESUME;
291 led->cdev.brightness = 0;
292 led->iodev = iodev;
293
294 /* initialize mode and brightness according to platform_data */
295 if (pdata->led_pdata) {
296 u8 mode = 0, brightness = 0;
297
298 mode = pdata->led_pdata->mode[led->id];
299 brightness = pdata->led_pdata->brightness[led->id];
300
301 max8997_led_set_mode(led, pdata->led_pdata->mode[led->id]);
302
303 if (brightness > led->cdev.max_brightness)
304 brightness = led->cdev.max_brightness;
305 max8997_led_set_current(led, brightness);
306 led->cdev.brightness = brightness;
307 } else {
308 max8997_led_set_mode(led, MAX8997_NONE);
309 max8997_led_set_current(led, 0);
310 }
311
312 mutex_init(&led->mutex);
313
314 platform_set_drvdata(pdev, led);
315
316 ret = led_classdev_register(&pdev->dev, &led->cdev);
317 if (ret < 0)
318 goto err_led;
319
320 ret = device_create_file(led->cdev.dev, &dev_attr_mode);
321 if (ret != 0) {
322 dev_err(&pdev->dev,
323 "failed to create file: %d\n", ret);
324 goto err_file;
325 }
326
327 return 0;
328
329err_file:
330 led_classdev_unregister(&led->cdev);
331err_led:
332 kfree(led);
333err_mem:
334 return ret;
335}
336
337static int __devexit max8997_led_remove(struct platform_device *pdev)
338{
339 struct max8997_led *led = platform_get_drvdata(pdev);
340
341 device_remove_file(led->cdev.dev, &dev_attr_mode);
342 led_classdev_unregister(&led->cdev);
343 kfree(led);
344
345 return 0;
346}
347
348static struct platform_driver max8997_led_driver = {
349 .driver = {
350 .name = "max8997-led",
351 .owner = THIS_MODULE,
352 },
353 .probe = max8997_led_probe,
354 .remove = __devexit_p(max8997_led_remove),
355};
356
357static int __init max8997_led_init(void)
358{
359 return platform_driver_register(&max8997_led_driver);
360}
361module_init(max8997_led_init);
362
363static void __exit max8997_led_exit(void)
364{
365 platform_driver_unregister(&max8997_led_driver);
366}
367module_exit(max8997_led_exit);
368
369MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
370MODULE_DESCRIPTION("MAX8997 LED driver");
371MODULE_LICENSE("GPL");
372MODULE_ALIAS("platform:max8997-led");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * leds-max8997.c - LED class driver for MAX8997 LEDs.
4 *
5 * Copyright (C) 2011 Samsung Electronics
6 * Donggeun Kim <dg77.kim@samsung.com>
7 */
8
9#include <linux/module.h>
10#include <linux/err.h>
11#include <linux/slab.h>
12#include <linux/leds.h>
13#include <linux/mfd/max8997.h>
14#include <linux/mfd/max8997-private.h>
15#include <linux/platform_device.h>
16
17#define MAX8997_LED_FLASH_SHIFT 3
18#define MAX8997_LED_FLASH_CUR_MASK 0xf8
19#define MAX8997_LED_MOVIE_SHIFT 4
20#define MAX8997_LED_MOVIE_CUR_MASK 0xf0
21
22#define MAX8997_LED_FLASH_MAX_BRIGHTNESS 0x1f
23#define MAX8997_LED_MOVIE_MAX_BRIGHTNESS 0xf
24#define MAX8997_LED_NONE_MAX_BRIGHTNESS 0
25
26#define MAX8997_LED0_FLASH_MASK 0x1
27#define MAX8997_LED0_FLASH_PIN_MASK 0x5
28#define MAX8997_LED0_MOVIE_MASK 0x8
29#define MAX8997_LED0_MOVIE_PIN_MASK 0x28
30
31#define MAX8997_LED1_FLASH_MASK 0x2
32#define MAX8997_LED1_FLASH_PIN_MASK 0x6
33#define MAX8997_LED1_MOVIE_MASK 0x10
34#define MAX8997_LED1_MOVIE_PIN_MASK 0x30
35
36#define MAX8997_LED_BOOST_ENABLE_MASK (1 << 6)
37
38struct max8997_led {
39 struct max8997_dev *iodev;
40 struct led_classdev cdev;
41 bool enabled;
42 int id;
43 enum max8997_led_mode led_mode;
44 struct mutex mutex;
45};
46
47static void max8997_led_set_mode(struct max8997_led *led,
48 enum max8997_led_mode mode)
49{
50 int ret;
51 struct i2c_client *client = led->iodev->i2c;
52 u8 mask = 0, val;
53
54 switch (mode) {
55 case MAX8997_FLASH_MODE:
56 mask = MAX8997_LED1_FLASH_MASK | MAX8997_LED0_FLASH_MASK;
57 val = led->id ?
58 MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
59 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
60 break;
61 case MAX8997_MOVIE_MODE:
62 mask = MAX8997_LED1_MOVIE_MASK | MAX8997_LED0_MOVIE_MASK;
63 val = led->id ?
64 MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
65 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
66 break;
67 case MAX8997_FLASH_PIN_CONTROL_MODE:
68 mask = MAX8997_LED1_FLASH_PIN_MASK |
69 MAX8997_LED0_FLASH_PIN_MASK;
70 val = led->id ?
71 MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
72 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
73 break;
74 case MAX8997_MOVIE_PIN_CONTROL_MODE:
75 mask = MAX8997_LED1_MOVIE_PIN_MASK |
76 MAX8997_LED0_MOVIE_PIN_MASK;
77 val = led->id ?
78 MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
79 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
80 break;
81 default:
82 led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
83 break;
84 }
85
86 if (mask) {
87 ret = max8997_update_reg(client, MAX8997_REG_LEN_CNTL, val,
88 mask);
89 if (ret)
90 dev_err(led->iodev->dev,
91 "failed to update register(%d)\n", ret);
92 }
93
94 led->led_mode = mode;
95}
96
97static void max8997_led_enable(struct max8997_led *led, bool enable)
98{
99 int ret;
100 struct i2c_client *client = led->iodev->i2c;
101 u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
102
103 if (led->enabled == enable)
104 return;
105
106 val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
107
108 ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
109 if (ret)
110 dev_err(led->iodev->dev,
111 "failed to update register(%d)\n", ret);
112
113 led->enabled = enable;
114}
115
116static void max8997_led_set_current(struct max8997_led *led,
117 enum led_brightness value)
118{
119 int ret;
120 struct i2c_client *client = led->iodev->i2c;
121 u8 val = 0, mask = 0, reg = 0;
122
123 switch (led->led_mode) {
124 case MAX8997_FLASH_MODE:
125 case MAX8997_FLASH_PIN_CONTROL_MODE:
126 val = value << MAX8997_LED_FLASH_SHIFT;
127 mask = MAX8997_LED_FLASH_CUR_MASK;
128 reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
129 break;
130 case MAX8997_MOVIE_MODE:
131 case MAX8997_MOVIE_PIN_CONTROL_MODE:
132 val = value << MAX8997_LED_MOVIE_SHIFT;
133 mask = MAX8997_LED_MOVIE_CUR_MASK;
134 reg = MAX8997_REG_MOVIE_CUR;
135 break;
136 default:
137 break;
138 }
139
140 if (mask) {
141 ret = max8997_update_reg(client, reg, val, mask);
142 if (ret)
143 dev_err(led->iodev->dev,
144 "failed to update register(%d)\n", ret);
145 }
146}
147
148static void max8997_led_brightness_set(struct led_classdev *led_cdev,
149 enum led_brightness value)
150{
151 struct max8997_led *led =
152 container_of(led_cdev, struct max8997_led, cdev);
153
154 if (value) {
155 max8997_led_set_current(led, value);
156 max8997_led_enable(led, true);
157 } else {
158 max8997_led_set_current(led, value);
159 max8997_led_enable(led, false);
160 }
161}
162
163static ssize_t max8997_led_show_mode(struct device *dev,
164 struct device_attribute *attr, char *buf)
165{
166 struct led_classdev *led_cdev = dev_get_drvdata(dev);
167 struct max8997_led *led =
168 container_of(led_cdev, struct max8997_led, cdev);
169 ssize_t ret = 0;
170
171 mutex_lock(&led->mutex);
172
173 switch (led->led_mode) {
174 case MAX8997_FLASH_MODE:
175 ret += sprintf(buf, "FLASH\n");
176 break;
177 case MAX8997_MOVIE_MODE:
178 ret += sprintf(buf, "MOVIE\n");
179 break;
180 case MAX8997_FLASH_PIN_CONTROL_MODE:
181 ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
182 break;
183 case MAX8997_MOVIE_PIN_CONTROL_MODE:
184 ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
185 break;
186 default:
187 ret += sprintf(buf, "NONE\n");
188 break;
189 }
190
191 mutex_unlock(&led->mutex);
192
193 return ret;
194}
195
196static ssize_t max8997_led_store_mode(struct device *dev,
197 struct device_attribute *attr,
198 const char *buf, size_t size)
199{
200 struct led_classdev *led_cdev = dev_get_drvdata(dev);
201 struct max8997_led *led =
202 container_of(led_cdev, struct max8997_led, cdev);
203 enum max8997_led_mode mode;
204
205 mutex_lock(&led->mutex);
206
207 if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
208 mode = MAX8997_FLASH_PIN_CONTROL_MODE;
209 else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
210 mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
211 else if (!strncmp(buf, "FLASH", 5))
212 mode = MAX8997_FLASH_MODE;
213 else if (!strncmp(buf, "MOVIE", 5))
214 mode = MAX8997_MOVIE_MODE;
215 else
216 mode = MAX8997_NONE;
217
218 max8997_led_set_mode(led, mode);
219
220 mutex_unlock(&led->mutex);
221
222 return size;
223}
224
225static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
226
227static struct attribute *max8997_attrs[] = {
228 &dev_attr_mode.attr,
229 NULL
230};
231ATTRIBUTE_GROUPS(max8997);
232
233static int max8997_led_probe(struct platform_device *pdev)
234{
235 struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
236 struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
237 struct max8997_led *led;
238 char name[20];
239 int ret = 0;
240
241 if (pdata == NULL) {
242 dev_err(&pdev->dev, "no platform data\n");
243 return -ENODEV;
244 }
245
246 led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
247 if (led == NULL)
248 return -ENOMEM;
249
250 led->id = pdev->id;
251 snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
252
253 led->cdev.name = name;
254 led->cdev.brightness_set = max8997_led_brightness_set;
255 led->cdev.flags |= LED_CORE_SUSPENDRESUME;
256 led->cdev.brightness = 0;
257 led->cdev.groups = max8997_groups;
258 led->iodev = iodev;
259
260 /* initialize mode and brightness according to platform_data */
261 if (pdata->led_pdata) {
262 u8 mode = 0, brightness = 0;
263
264 mode = pdata->led_pdata->mode[led->id];
265 brightness = pdata->led_pdata->brightness[led->id];
266
267 max8997_led_set_mode(led, mode);
268
269 if (brightness > led->cdev.max_brightness)
270 brightness = led->cdev.max_brightness;
271 max8997_led_set_current(led, brightness);
272 led->cdev.brightness = brightness;
273 } else {
274 max8997_led_set_mode(led, MAX8997_NONE);
275 max8997_led_set_current(led, 0);
276 }
277
278 mutex_init(&led->mutex);
279
280 ret = devm_led_classdev_register(&pdev->dev, &led->cdev);
281 if (ret < 0)
282 return ret;
283
284 return 0;
285}
286
287static struct platform_driver max8997_led_driver = {
288 .driver = {
289 .name = "max8997-led",
290 },
291 .probe = max8997_led_probe,
292};
293
294module_platform_driver(max8997_led_driver);
295
296MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
297MODULE_DESCRIPTION("MAX8997 LED driver");
298MODULE_LICENSE("GPL");
299MODULE_ALIAS("platform:max8997-led");