Commit | Line | Data |
---|---|---|
8992da44 RG |
1 | /* |
2 | * HT16K33 driver | |
3 | * | |
4 | * Author: Robin van der Gracht <robin@protonic.nl> | |
5 | * | |
6 | * Copyright: (C) 2016 Protonic Holland. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | */ | |
17 | ||
18 | #include <linux/kernel.h> | |
19 | #include <linux/module.h> | |
20 | #include <linux/interrupt.h> | |
21 | #include <linux/i2c.h> | |
22 | #include <linux/of.h> | |
23 | #include <linux/fb.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/backlight.h> | |
26 | #include <linux/input.h> | |
27 | #include <linux/input/matrix_keypad.h> | |
28 | #include <linux/workqueue.h> | |
29 | #include <linux/mm.h> | |
30 | ||
31 | /* Registers */ | |
32 | #define REG_SYSTEM_SETUP 0x20 | |
33 | #define REG_SYSTEM_SETUP_OSC_ON BIT(0) | |
34 | ||
35 | #define REG_DISPLAY_SETUP 0x80 | |
36 | #define REG_DISPLAY_SETUP_ON BIT(0) | |
37 | ||
38 | #define REG_ROWINT_SET 0xA0 | |
39 | #define REG_ROWINT_SET_INT_EN BIT(0) | |
40 | #define REG_ROWINT_SET_INT_ACT_HIGH BIT(1) | |
41 | ||
42 | #define REG_BRIGHTNESS 0xE0 | |
43 | ||
44 | /* Defines */ | |
45 | #define DRIVER_NAME "ht16k33" | |
46 | ||
47 | #define MIN_BRIGHTNESS 0x1 | |
48 | #define MAX_BRIGHTNESS 0x10 | |
49 | ||
50 | #define HT16K33_MATRIX_LED_MAX_COLS 8 | |
51 | #define HT16K33_MATRIX_LED_MAX_ROWS 16 | |
52 | #define HT16K33_MATRIX_KEYPAD_MAX_COLS 3 | |
53 | #define HT16K33_MATRIX_KEYPAD_MAX_ROWS 12 | |
54 | ||
55 | #define BYTES_PER_ROW (HT16K33_MATRIX_LED_MAX_ROWS / 8) | |
56 | #define HT16K33_FB_SIZE (HT16K33_MATRIX_LED_MAX_COLS * BYTES_PER_ROW) | |
57 | ||
58 | struct ht16k33_keypad { | |
59 | struct input_dev *dev; | |
60 | spinlock_t lock; | |
61 | struct delayed_work work; | |
62 | uint32_t cols; | |
63 | uint32_t rows; | |
64 | uint32_t row_shift; | |
65 | uint32_t debounce_ms; | |
66 | uint16_t last_key_state[HT16K33_MATRIX_KEYPAD_MAX_COLS]; | |
67 | }; | |
68 | ||
69 | struct ht16k33_fbdev { | |
70 | struct fb_info *info; | |
71 | uint32_t refresh_rate; | |
72 | uint8_t *buffer; | |
73 | uint8_t *cache; | |
74 | struct delayed_work work; | |
75 | }; | |
76 | ||
77 | struct ht16k33_priv { | |
78 | struct i2c_client *client; | |
79 | struct ht16k33_keypad keypad; | |
80 | struct ht16k33_fbdev fbdev; | |
81 | struct workqueue_struct *workqueue; | |
82 | }; | |
83 | ||
84 | static struct fb_fix_screeninfo ht16k33_fb_fix = { | |
85 | .id = DRIVER_NAME, | |
86 | .type = FB_TYPE_PACKED_PIXELS, | |
87 | .visual = FB_VISUAL_MONO10, | |
88 | .xpanstep = 0, | |
89 | .ypanstep = 0, | |
90 | .ywrapstep = 0, | |
91 | .line_length = HT16K33_MATRIX_LED_MAX_ROWS, | |
92 | .accel = FB_ACCEL_NONE, | |
93 | }; | |
94 | ||
95 | static struct fb_var_screeninfo ht16k33_fb_var = { | |
96 | .xres = HT16K33_MATRIX_LED_MAX_ROWS, | |
97 | .yres = HT16K33_MATRIX_LED_MAX_COLS, | |
98 | .xres_virtual = HT16K33_MATRIX_LED_MAX_ROWS, | |
99 | .yres_virtual = HT16K33_MATRIX_LED_MAX_COLS, | |
100 | .bits_per_pixel = 1, | |
101 | .red = { 0, 1, 0 }, | |
102 | .green = { 0, 1, 0 }, | |
103 | .blue = { 0, 1, 0 }, | |
104 | .left_margin = 0, | |
105 | .right_margin = 0, | |
106 | .upper_margin = 0, | |
107 | .lower_margin = 0, | |
108 | .vmode = FB_VMODE_NONINTERLACED, | |
109 | }; | |
110 | ||
111 | static int ht16k33_display_on(struct ht16k33_priv *priv) | |
112 | { | |
113 | uint8_t data = REG_DISPLAY_SETUP | REG_DISPLAY_SETUP_ON; | |
114 | ||
115 | return i2c_smbus_write_byte(priv->client, data); | |
116 | } | |
117 | ||
118 | static int ht16k33_display_off(struct ht16k33_priv *priv) | |
119 | { | |
120 | return i2c_smbus_write_byte(priv->client, REG_DISPLAY_SETUP); | |
121 | } | |
122 | ||
123 | static void ht16k33_fb_queue(struct ht16k33_priv *priv) | |
124 | { | |
125 | struct ht16k33_fbdev *fbdev = &priv->fbdev; | |
126 | ||
127 | queue_delayed_work(priv->workqueue, &fbdev->work, | |
128 | msecs_to_jiffies(HZ / fbdev->refresh_rate)); | |
129 | } | |
130 | ||
131 | static void ht16k33_keypad_queue(struct ht16k33_priv *priv) | |
132 | { | |
133 | struct ht16k33_keypad *keypad = &priv->keypad; | |
134 | ||
135 | queue_delayed_work(priv->workqueue, &keypad->work, | |
136 | msecs_to_jiffies(keypad->debounce_ms)); | |
137 | } | |
138 | ||
139 | /* | |
140 | * This gets the fb data from cache and copies it to ht16k33 display RAM | |
141 | */ | |
142 | static void ht16k33_fb_update(struct work_struct *work) | |
143 | { | |
144 | struct ht16k33_fbdev *fbdev = | |
145 | container_of(work, struct ht16k33_fbdev, work.work); | |
146 | struct ht16k33_priv *priv = | |
147 | container_of(fbdev, struct ht16k33_priv, fbdev); | |
148 | ||
149 | uint8_t *p1, *p2; | |
150 | int len, pos = 0, first = -1; | |
151 | ||
152 | p1 = fbdev->cache; | |
153 | p2 = fbdev->buffer; | |
154 | ||
155 | /* Search for the first byte with changes */ | |
156 | while (pos < HT16K33_FB_SIZE && first < 0) { | |
157 | if (*(p1++) - *(p2++)) | |
158 | first = pos; | |
159 | pos++; | |
160 | } | |
161 | ||
162 | /* No changes found */ | |
163 | if (first < 0) | |
164 | goto requeue; | |
165 | ||
166 | len = HT16K33_FB_SIZE - first; | |
167 | p1 = fbdev->cache + HT16K33_FB_SIZE - 1; | |
168 | p2 = fbdev->buffer + HT16K33_FB_SIZE - 1; | |
169 | ||
170 | /* Determine i2c transfer length */ | |
171 | while (len > 1) { | |
172 | if (*(p1--) - *(p2--)) | |
173 | break; | |
174 | len--; | |
175 | } | |
176 | ||
177 | p1 = fbdev->cache + first; | |
178 | p2 = fbdev->buffer + first; | |
179 | if (!i2c_smbus_write_i2c_block_data(priv->client, first, len, p2)) | |
180 | memcpy(p1, p2, len); | |
181 | requeue: | |
182 | ht16k33_fb_queue(priv); | |
183 | } | |
184 | ||
185 | static int ht16k33_keypad_start(struct input_dev *dev) | |
186 | { | |
187 | struct ht16k33_priv *priv = input_get_drvdata(dev); | |
188 | struct ht16k33_keypad *keypad = &priv->keypad; | |
189 | ||
190 | /* | |
191 | * Schedule an immediate key scan to capture current key state; | |
192 | * columns will be activated and IRQs be enabled after the scan. | |
193 | */ | |
194 | queue_delayed_work(priv->workqueue, &keypad->work, 0); | |
195 | return 0; | |
196 | } | |
197 | ||
198 | static void ht16k33_keypad_stop(struct input_dev *dev) | |
199 | { | |
200 | struct ht16k33_priv *priv = input_get_drvdata(dev); | |
201 | struct ht16k33_keypad *keypad = &priv->keypad; | |
202 | ||
203 | cancel_delayed_work(&keypad->work); | |
204 | /* | |
205 | * ht16k33_keypad_scan() will leave IRQs enabled; | |
206 | * we should disable them now. | |
207 | */ | |
208 | disable_irq_nosync(priv->client->irq); | |
209 | } | |
210 | ||
211 | static int ht16k33_initialize(struct ht16k33_priv *priv) | |
212 | { | |
213 | uint8_t byte; | |
214 | int err; | |
215 | uint8_t data[HT16K33_MATRIX_LED_MAX_COLS * 2]; | |
216 | ||
217 | /* Clear RAM (8 * 16 bits) */ | |
218 | memset(data, 0, sizeof(data)); | |
219 | err = i2c_smbus_write_block_data(priv->client, 0, sizeof(data), data); | |
220 | if (err) | |
221 | return err; | |
222 | ||
223 | /* Turn on internal oscillator */ | |
224 | byte = REG_SYSTEM_SETUP_OSC_ON | REG_SYSTEM_SETUP; | |
225 | err = i2c_smbus_write_byte(priv->client, byte); | |
226 | if (err) | |
227 | return err; | |
228 | ||
229 | /* Configure INT pin */ | |
230 | byte = REG_ROWINT_SET | REG_ROWINT_SET_INT_ACT_HIGH; | |
231 | if (priv->client->irq > 0) | |
232 | byte |= REG_ROWINT_SET_INT_EN; | |
233 | return i2c_smbus_write_byte(priv->client, byte); | |
234 | } | |
235 | ||
236 | /* | |
237 | * This gets the keys from keypad and reports it to input subsystem | |
238 | */ | |
239 | static void ht16k33_keypad_scan(struct work_struct *work) | |
240 | { | |
241 | struct ht16k33_keypad *keypad = | |
242 | container_of(work, struct ht16k33_keypad, work.work); | |
243 | struct ht16k33_priv *priv = | |
244 | container_of(keypad, struct ht16k33_priv, keypad); | |
245 | const unsigned short *keycodes = keypad->dev->keycode; | |
246 | uint16_t bits_changed, new_state[HT16K33_MATRIX_KEYPAD_MAX_COLS]; | |
247 | uint8_t data[HT16K33_MATRIX_KEYPAD_MAX_COLS * 2]; | |
248 | int row, col, code; | |
249 | bool reschedule = false; | |
250 | ||
251 | if (i2c_smbus_read_i2c_block_data(priv->client, 0x40, 6, data) != 6) { | |
252 | dev_err(&priv->client->dev, "Failed to read key data\n"); | |
253 | goto end; | |
254 | } | |
255 | ||
256 | for (col = 0; col < keypad->cols; col++) { | |
257 | new_state[col] = (data[col * 2 + 1] << 8) | data[col * 2]; | |
258 | if (new_state[col]) | |
259 | reschedule = true; | |
260 | bits_changed = keypad->last_key_state[col] ^ new_state[col]; | |
261 | ||
262 | while (bits_changed) { | |
263 | row = ffs(bits_changed) - 1; | |
264 | code = MATRIX_SCAN_CODE(row, col, keypad->row_shift); | |
265 | input_event(keypad->dev, EV_MSC, MSC_SCAN, code); | |
266 | input_report_key(keypad->dev, keycodes[code], | |
267 | new_state[col] & BIT(row)); | |
268 | bits_changed &= ~BIT(row); | |
269 | } | |
270 | } | |
271 | input_sync(keypad->dev); | |
272 | memcpy(keypad->last_key_state, new_state, sizeof(new_state)); | |
273 | ||
274 | end: | |
275 | if (reschedule) | |
276 | ht16k33_keypad_queue(priv); | |
277 | else | |
278 | enable_irq(priv->client->irq); | |
279 | } | |
280 | ||
281 | static irqreturn_t ht16k33_irq_thread(int irq, void *dev) | |
282 | { | |
283 | struct ht16k33_priv *priv = dev; | |
284 | ||
285 | disable_irq_nosync(priv->client->irq); | |
286 | ht16k33_keypad_queue(priv); | |
287 | ||
288 | return IRQ_HANDLED; | |
289 | } | |
290 | ||
291 | static int ht16k33_bl_update_status(struct backlight_device *bl) | |
292 | { | |
293 | int brightness = bl->props.brightness; | |
294 | struct ht16k33_priv *priv = bl_get_data(bl); | |
295 | ||
296 | if (bl->props.power != FB_BLANK_UNBLANK || | |
297 | bl->props.fb_blank != FB_BLANK_UNBLANK || | |
298 | bl->props.state & BL_CORE_FBBLANK || brightness == 0) { | |
299 | return ht16k33_display_off(priv); | |
300 | } | |
301 | ||
302 | ht16k33_display_on(priv); | |
303 | return i2c_smbus_write_byte(priv->client, | |
304 | REG_BRIGHTNESS | (brightness - 1)); | |
305 | } | |
306 | ||
307 | static int ht16k33_bl_check_fb(struct backlight_device *bl, struct fb_info *fi) | |
308 | { | |
309 | struct ht16k33_priv *priv = bl_get_data(bl); | |
310 | ||
311 | return (fi == NULL) || (fi->par == priv); | |
312 | } | |
313 | ||
314 | static const struct backlight_ops ht16k33_bl_ops = { | |
315 | .update_status = ht16k33_bl_update_status, | |
316 | .check_fb = ht16k33_bl_check_fb, | |
317 | }; | |
318 | ||
319 | static int ht16k33_mmap(struct fb_info *info, struct vm_area_struct *vma) | |
320 | { | |
321 | struct ht16k33_priv *priv = info->par; | |
322 | ||
323 | return vm_insert_page(vma, vma->vm_start, | |
324 | virt_to_page(priv->fbdev.buffer)); | |
325 | } | |
326 | ||
327 | static struct fb_ops ht16k33_fb_ops = { | |
328 | .owner = THIS_MODULE, | |
329 | .fb_read = fb_sys_read, | |
330 | .fb_write = fb_sys_write, | |
331 | .fb_fillrect = sys_fillrect, | |
332 | .fb_copyarea = sys_copyarea, | |
333 | .fb_imageblit = sys_imageblit, | |
334 | .fb_mmap = ht16k33_mmap, | |
335 | }; | |
336 | ||
337 | static int ht16k33_probe(struct i2c_client *client, | |
338 | const struct i2c_device_id *id) | |
339 | { | |
340 | int err; | |
341 | uint32_t rows, cols, dft_brightness; | |
342 | struct backlight_device *bl; | |
343 | struct backlight_properties bl_props; | |
344 | struct ht16k33_priv *priv; | |
345 | struct ht16k33_keypad *keypad; | |
346 | struct ht16k33_fbdev *fbdev; | |
347 | struct device_node *node = client->dev.of_node; | |
348 | ||
349 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
350 | dev_err(&client->dev, "i2c_check_functionality error\n"); | |
351 | return -EIO; | |
352 | } | |
353 | ||
354 | if (client->irq <= 0) { | |
355 | dev_err(&client->dev, "No IRQ specified\n"); | |
356 | return -EINVAL; | |
357 | } | |
358 | ||
359 | priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); | |
360 | if (!priv) | |
361 | return -ENOMEM; | |
362 | ||
363 | priv->client = client; | |
364 | i2c_set_clientdata(client, priv); | |
365 | fbdev = &priv->fbdev; | |
366 | keypad = &priv->keypad; | |
367 | ||
368 | priv->workqueue = create_singlethread_workqueue(DRIVER_NAME "-wq"); | |
369 | if (priv->workqueue == NULL) | |
370 | return -ENOMEM; | |
371 | ||
372 | err = ht16k33_initialize(priv); | |
373 | if (err) | |
374 | goto err_destroy_wq; | |
375 | ||
376 | /* Framebuffer (2 bytes per column) */ | |
377 | BUILD_BUG_ON(PAGE_SIZE < HT16K33_FB_SIZE); | |
378 | fbdev->buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL); | |
379 | if (!fbdev->buffer) { | |
380 | err = -ENOMEM; | |
381 | goto err_free_fbdev; | |
382 | } | |
383 | ||
384 | fbdev->cache = devm_kmalloc(&client->dev, HT16K33_FB_SIZE, GFP_KERNEL); | |
385 | if (!fbdev->cache) { | |
386 | err = -ENOMEM; | |
387 | goto err_fbdev_buffer; | |
388 | } | |
389 | ||
390 | fbdev->info = framebuffer_alloc(0, &client->dev); | |
391 | if (!fbdev->info) { | |
392 | err = -ENOMEM; | |
393 | goto err_fbdev_buffer; | |
394 | } | |
395 | ||
396 | err = of_property_read_u32(node, "refresh-rate-hz", | |
397 | &fbdev->refresh_rate); | |
398 | if (err) { | |
399 | dev_err(&client->dev, "refresh rate not specified\n"); | |
400 | goto err_fbdev_info; | |
401 | } | |
402 | fb_bl_default_curve(fbdev->info, 0, MIN_BRIGHTNESS, MAX_BRIGHTNESS); | |
403 | ||
404 | INIT_DELAYED_WORK(&fbdev->work, ht16k33_fb_update); | |
405 | fbdev->info->fbops = &ht16k33_fb_ops; | |
406 | fbdev->info->screen_base = (char __iomem *) fbdev->buffer; | |
407 | fbdev->info->screen_size = HT16K33_FB_SIZE; | |
408 | fbdev->info->fix = ht16k33_fb_fix; | |
409 | fbdev->info->var = ht16k33_fb_var; | |
410 | fbdev->info->pseudo_palette = NULL; | |
411 | fbdev->info->flags = FBINFO_FLAG_DEFAULT; | |
412 | fbdev->info->par = priv; | |
413 | ||
414 | err = register_framebuffer(fbdev->info); | |
415 | if (err) | |
416 | goto err_fbdev_info; | |
417 | ||
418 | /* Keypad */ | |
419 | keypad->dev = devm_input_allocate_device(&client->dev); | |
420 | if (!keypad->dev) { | |
421 | err = -ENOMEM; | |
422 | goto err_fbdev_unregister; | |
423 | } | |
424 | ||
425 | keypad->dev->name = DRIVER_NAME"-keypad"; | |
426 | keypad->dev->id.bustype = BUS_I2C; | |
427 | keypad->dev->open = ht16k33_keypad_start; | |
428 | keypad->dev->close = ht16k33_keypad_stop; | |
429 | ||
430 | if (!of_get_property(node, "linux,no-autorepeat", NULL)) | |
431 | __set_bit(EV_REP, keypad->dev->evbit); | |
432 | ||
433 | err = of_property_read_u32(node, "debounce-delay-ms", | |
434 | &keypad->debounce_ms); | |
435 | if (err) { | |
436 | dev_err(&client->dev, "key debounce delay not specified\n"); | |
437 | goto err_fbdev_unregister; | |
438 | } | |
439 | ||
440 | err = devm_request_threaded_irq(&client->dev, client->irq, NULL, | |
441 | ht16k33_irq_thread, | |
442 | IRQF_TRIGGER_RISING | IRQF_ONESHOT, | |
443 | DRIVER_NAME, priv); | |
444 | if (err) { | |
445 | dev_err(&client->dev, "irq request failed %d, error %d\n", | |
446 | client->irq, err); | |
447 | goto err_fbdev_unregister; | |
448 | } | |
449 | ||
450 | disable_irq_nosync(client->irq); | |
451 | rows = HT16K33_MATRIX_KEYPAD_MAX_ROWS; | |
452 | cols = HT16K33_MATRIX_KEYPAD_MAX_COLS; | |
453 | err = matrix_keypad_parse_of_params(&client->dev, &rows, &cols); | |
454 | if (err) | |
455 | goto err_fbdev_unregister; | |
456 | ||
457 | err = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL, | |
458 | keypad->dev); | |
459 | if (err) { | |
460 | dev_err(&client->dev, "failed to build keymap\n"); | |
461 | goto err_fbdev_unregister; | |
462 | } | |
463 | ||
464 | input_set_drvdata(keypad->dev, priv); | |
465 | keypad->rows = rows; | |
466 | keypad->cols = cols; | |
467 | keypad->row_shift = get_count_order(cols); | |
468 | INIT_DELAYED_WORK(&keypad->work, ht16k33_keypad_scan); | |
469 | ||
470 | err = input_register_device(keypad->dev); | |
471 | if (err) | |
472 | goto err_fbdev_unregister; | |
473 | ||
474 | /* Backlight */ | |
475 | memset(&bl_props, 0, sizeof(struct backlight_properties)); | |
476 | bl_props.type = BACKLIGHT_RAW; | |
477 | bl_props.max_brightness = MAX_BRIGHTNESS; | |
478 | ||
479 | bl = devm_backlight_device_register(&client->dev, DRIVER_NAME"-bl", | |
480 | &client->dev, priv, | |
481 | &ht16k33_bl_ops, &bl_props); | |
482 | if (IS_ERR(bl)) { | |
483 | dev_err(&client->dev, "failed to register backlight\n"); | |
484 | err = PTR_ERR(bl); | |
485 | goto err_keypad_unregister; | |
486 | } | |
487 | ||
488 | err = of_property_read_u32(node, "default-brightness-level", | |
489 | &dft_brightness); | |
490 | if (err) { | |
491 | dft_brightness = MAX_BRIGHTNESS; | |
492 | } else if (dft_brightness > MAX_BRIGHTNESS) { | |
493 | dev_warn(&client->dev, | |
494 | "invalid default brightness level: %u, using %u\n", | |
495 | dft_brightness, MAX_BRIGHTNESS); | |
496 | dft_brightness = MAX_BRIGHTNESS; | |
497 | } | |
498 | ||
499 | bl->props.brightness = dft_brightness; | |
500 | ht16k33_bl_update_status(bl); | |
501 | ||
502 | ht16k33_fb_queue(priv); | |
503 | return 0; | |
504 | ||
505 | err_keypad_unregister: | |
506 | input_unregister_device(keypad->dev); | |
507 | err_fbdev_unregister: | |
508 | unregister_framebuffer(fbdev->info); | |
509 | err_fbdev_info: | |
510 | framebuffer_release(fbdev->info); | |
511 | err_fbdev_buffer: | |
512 | free_page((unsigned long) fbdev->buffer); | |
513 | err_free_fbdev: | |
514 | kfree(fbdev); | |
515 | err_destroy_wq: | |
516 | destroy_workqueue(priv->workqueue); | |
517 | ||
518 | return err; | |
519 | } | |
520 | ||
521 | static int ht16k33_remove(struct i2c_client *client) | |
522 | { | |
523 | struct ht16k33_priv *priv = i2c_get_clientdata(client); | |
524 | struct ht16k33_keypad *keypad = &priv->keypad; | |
525 | struct ht16k33_fbdev *fbdev = &priv->fbdev; | |
526 | ||
527 | ht16k33_keypad_stop(keypad->dev); | |
528 | ||
529 | cancel_delayed_work(&fbdev->work); | |
530 | unregister_framebuffer(fbdev->info); | |
531 | framebuffer_release(fbdev->info); | |
532 | free_page((unsigned long) fbdev->buffer); | |
533 | ||
534 | destroy_workqueue(priv->workqueue); | |
535 | return 0; | |
536 | } | |
537 | ||
538 | static const struct i2c_device_id ht16k33_i2c_match[] = { | |
539 | { "ht16k33", 0 }, | |
540 | { } | |
541 | }; | |
542 | MODULE_DEVICE_TABLE(i2c, ht16k33_i2c_match); | |
543 | ||
544 | static const struct of_device_id ht16k33_of_match[] = { | |
545 | { .compatible = "holtek,ht16k33", }, | |
546 | { } | |
547 | }; | |
548 | MODULE_DEVICE_TABLE(of, ht16k33_of_match); | |
549 | ||
550 | static struct i2c_driver ht16k33_driver = { | |
551 | .probe = ht16k33_probe, | |
552 | .remove = ht16k33_remove, | |
553 | .driver = { | |
554 | .name = DRIVER_NAME, | |
555 | .of_match_table = of_match_ptr(ht16k33_of_match), | |
556 | }, | |
557 | .id_table = ht16k33_i2c_match, | |
558 | }; | |
559 | module_i2c_driver(ht16k33_driver); | |
560 | ||
561 | MODULE_DESCRIPTION("Holtek HT16K33 driver"); | |
562 | MODULE_LICENSE("GPL"); | |
563 | MODULE_AUTHOR("Robin van der Gracht <robin@protonic.nl>"); |