Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * HT16K33 driver
0004  *
0005  * Author: Robin van der Gracht <robin@protonic.nl>
0006  *
0007  * Copyright: (C) 2016 Protonic Holland.
0008  * Copyright (C) 2021 Glider bv
0009  */
0010 
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/i2c.h>
0015 #include <linux/property.h>
0016 #include <linux/fb.h>
0017 #include <linux/backlight.h>
0018 #include <linux/input.h>
0019 #include <linux/input/matrix_keypad.h>
0020 #include <linux/leds.h>
0021 #include <linux/workqueue.h>
0022 #include <linux/mm.h>
0023 
0024 #include <linux/map_to_7segment.h>
0025 #include <linux/map_to_14segment.h>
0026 
0027 #include <asm/unaligned.h>
0028 
0029 #include "line-display.h"
0030 
0031 /* Registers */
0032 #define REG_SYSTEM_SETUP        0x20
0033 #define REG_SYSTEM_SETUP_OSC_ON     BIT(0)
0034 
0035 #define REG_DISPLAY_SETUP       0x80
0036 #define REG_DISPLAY_SETUP_ON        BIT(0)
0037 #define REG_DISPLAY_SETUP_BLINK_OFF (0 << 1)
0038 #define REG_DISPLAY_SETUP_BLINK_2HZ (1 << 1)
0039 #define REG_DISPLAY_SETUP_BLINK_1HZ (2 << 1)
0040 #define REG_DISPLAY_SETUP_BLINK_0HZ5    (3 << 1)
0041 
0042 #define REG_ROWINT_SET          0xA0
0043 #define REG_ROWINT_SET_INT_EN       BIT(0)
0044 #define REG_ROWINT_SET_INT_ACT_HIGH BIT(1)
0045 
0046 #define REG_BRIGHTNESS          0xE0
0047 
0048 /* Defines */
0049 #define DRIVER_NAME         "ht16k33"
0050 
0051 #define MIN_BRIGHTNESS          0x1
0052 #define MAX_BRIGHTNESS          0x10
0053 
0054 #define HT16K33_MATRIX_LED_MAX_COLS 8
0055 #define HT16K33_MATRIX_LED_MAX_ROWS 16
0056 #define HT16K33_MATRIX_KEYPAD_MAX_COLS  3
0057 #define HT16K33_MATRIX_KEYPAD_MAX_ROWS  12
0058 
0059 #define BYTES_PER_ROW       (HT16K33_MATRIX_LED_MAX_ROWS / 8)
0060 #define HT16K33_FB_SIZE     (HT16K33_MATRIX_LED_MAX_COLS * BYTES_PER_ROW)
0061 
0062 enum display_type {
0063     DISP_MATRIX = 0,
0064     DISP_QUAD_7SEG,
0065     DISP_QUAD_14SEG,
0066 };
0067 
0068 struct ht16k33_keypad {
0069     struct i2c_client *client;
0070     struct input_dev *dev;
0071     uint32_t cols;
0072     uint32_t rows;
0073     uint32_t row_shift;
0074     uint32_t debounce_ms;
0075     uint16_t last_key_state[HT16K33_MATRIX_KEYPAD_MAX_COLS];
0076 
0077     wait_queue_head_t wait;
0078     bool stopped;
0079 };
0080 
0081 struct ht16k33_fbdev {
0082     struct fb_info *info;
0083     uint32_t refresh_rate;
0084     uint8_t *buffer;
0085     uint8_t *cache;
0086 };
0087 
0088 struct ht16k33_seg {
0089     struct linedisp linedisp;
0090     union {
0091         struct seg7_conversion_map seg7;
0092         struct seg14_conversion_map seg14;
0093     } map;
0094     unsigned int map_size;
0095     char curr[4];
0096 };
0097 
0098 struct ht16k33_priv {
0099     struct i2c_client *client;
0100     struct delayed_work work;
0101     struct led_classdev led;
0102     struct ht16k33_keypad keypad;
0103     union {
0104         struct ht16k33_fbdev fbdev;
0105         struct ht16k33_seg seg;
0106     };
0107     enum display_type type;
0108     uint8_t blink;
0109 };
0110 
0111 static const struct fb_fix_screeninfo ht16k33_fb_fix = {
0112     .id     = DRIVER_NAME,
0113     .type       = FB_TYPE_PACKED_PIXELS,
0114     .visual     = FB_VISUAL_MONO10,
0115     .xpanstep   = 0,
0116     .ypanstep   = 0,
0117     .ywrapstep  = 0,
0118     .line_length    = HT16K33_MATRIX_LED_MAX_ROWS,
0119     .accel      = FB_ACCEL_NONE,
0120 };
0121 
0122 static const struct fb_var_screeninfo ht16k33_fb_var = {
0123     .xres = HT16K33_MATRIX_LED_MAX_ROWS,
0124     .yres = HT16K33_MATRIX_LED_MAX_COLS,
0125     .xres_virtual = HT16K33_MATRIX_LED_MAX_ROWS,
0126     .yres_virtual = HT16K33_MATRIX_LED_MAX_COLS,
0127     .bits_per_pixel = 1,
0128     .red = { 0, 1, 0 },
0129     .green = { 0, 1, 0 },
0130     .blue = { 0, 1, 0 },
0131     .left_margin = 0,
0132     .right_margin = 0,
0133     .upper_margin = 0,
0134     .lower_margin = 0,
0135     .vmode = FB_VMODE_NONINTERLACED,
0136 };
0137 
0138 static const SEG7_DEFAULT_MAP(initial_map_seg7);
0139 static const SEG14_DEFAULT_MAP(initial_map_seg14);
0140 
0141 static ssize_t map_seg_show(struct device *dev, struct device_attribute *attr,
0142                 char *buf)
0143 {
0144     struct ht16k33_priv *priv = dev_get_drvdata(dev);
0145 
0146     memcpy(buf, &priv->seg.map, priv->seg.map_size);
0147     return priv->seg.map_size;
0148 }
0149 
0150 static ssize_t map_seg_store(struct device *dev, struct device_attribute *attr,
0151                  const char *buf, size_t cnt)
0152 {
0153     struct ht16k33_priv *priv = dev_get_drvdata(dev);
0154 
0155     if (cnt != priv->seg.map_size)
0156         return -EINVAL;
0157 
0158     memcpy(&priv->seg.map, buf, cnt);
0159     return cnt;
0160 }
0161 
0162 static DEVICE_ATTR(map_seg7, 0644, map_seg_show, map_seg_store);
0163 static DEVICE_ATTR(map_seg14, 0644, map_seg_show, map_seg_store);
0164 
0165 static int ht16k33_display_on(struct ht16k33_priv *priv)
0166 {
0167     uint8_t data = REG_DISPLAY_SETUP | REG_DISPLAY_SETUP_ON | priv->blink;
0168 
0169     return i2c_smbus_write_byte(priv->client, data);
0170 }
0171 
0172 static int ht16k33_display_off(struct ht16k33_priv *priv)
0173 {
0174     return i2c_smbus_write_byte(priv->client, REG_DISPLAY_SETUP);
0175 }
0176 
0177 static int ht16k33_brightness_set(struct ht16k33_priv *priv,
0178                   unsigned int brightness)
0179 {
0180     int err;
0181 
0182     if (brightness == 0) {
0183         priv->blink = REG_DISPLAY_SETUP_BLINK_OFF;
0184         return ht16k33_display_off(priv);
0185     }
0186 
0187     err = ht16k33_display_on(priv);
0188     if (err)
0189         return err;
0190 
0191     return i2c_smbus_write_byte(priv->client,
0192                     REG_BRIGHTNESS | (brightness - 1));
0193 }
0194 
0195 static int ht16k33_brightness_set_blocking(struct led_classdev *led_cdev,
0196                        enum led_brightness brightness)
0197 {
0198     struct ht16k33_priv *priv = container_of(led_cdev, struct ht16k33_priv,
0199                          led);
0200 
0201     return ht16k33_brightness_set(priv, brightness);
0202 }
0203 
0204 static int ht16k33_blink_set(struct led_classdev *led_cdev,
0205                  unsigned long *delay_on, unsigned long *delay_off)
0206 {
0207     struct ht16k33_priv *priv = container_of(led_cdev, struct ht16k33_priv,
0208                          led);
0209     unsigned int delay;
0210     uint8_t blink;
0211     int err;
0212 
0213     if (!*delay_on && !*delay_off) {
0214         blink = REG_DISPLAY_SETUP_BLINK_1HZ;
0215         delay = 1000;
0216     } else if (*delay_on <= 750) {
0217         blink = REG_DISPLAY_SETUP_BLINK_2HZ;
0218         delay = 500;
0219     } else if (*delay_on <= 1500) {
0220         blink = REG_DISPLAY_SETUP_BLINK_1HZ;
0221         delay = 1000;
0222     } else {
0223         blink = REG_DISPLAY_SETUP_BLINK_0HZ5;
0224         delay = 2000;
0225     }
0226 
0227     err = i2c_smbus_write_byte(priv->client,
0228                    REG_DISPLAY_SETUP | REG_DISPLAY_SETUP_ON |
0229                    blink);
0230     if (err)
0231         return err;
0232 
0233     priv->blink = blink;
0234     *delay_on = *delay_off = delay;
0235     return 0;
0236 }
0237 
0238 static void ht16k33_fb_queue(struct ht16k33_priv *priv)
0239 {
0240     struct ht16k33_fbdev *fbdev = &priv->fbdev;
0241 
0242     schedule_delayed_work(&priv->work, HZ / fbdev->refresh_rate);
0243 }
0244 
0245 /*
0246  * This gets the fb data from cache and copies it to ht16k33 display RAM
0247  */
0248 static void ht16k33_fb_update(struct work_struct *work)
0249 {
0250     struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv,
0251                          work.work);
0252     struct ht16k33_fbdev *fbdev = &priv->fbdev;
0253 
0254     uint8_t *p1, *p2;
0255     int len, pos = 0, first = -1;
0256 
0257     p1 = fbdev->cache;
0258     p2 = fbdev->buffer;
0259 
0260     /* Search for the first byte with changes */
0261     while (pos < HT16K33_FB_SIZE && first < 0) {
0262         if (*(p1++) - *(p2++))
0263             first = pos;
0264         pos++;
0265     }
0266 
0267     /* No changes found */
0268     if (first < 0)
0269         goto requeue;
0270 
0271     len = HT16K33_FB_SIZE - first;
0272     p1 = fbdev->cache + HT16K33_FB_SIZE - 1;
0273     p2 = fbdev->buffer + HT16K33_FB_SIZE - 1;
0274 
0275     /* Determine i2c transfer length */
0276     while (len > 1) {
0277         if (*(p1--) - *(p2--))
0278             break;
0279         len--;
0280     }
0281 
0282     p1 = fbdev->cache + first;
0283     p2 = fbdev->buffer + first;
0284     if (!i2c_smbus_write_i2c_block_data(priv->client, first, len, p2))
0285         memcpy(p1, p2, len);
0286 requeue:
0287     ht16k33_fb_queue(priv);
0288 }
0289 
0290 static int ht16k33_initialize(struct ht16k33_priv *priv)
0291 {
0292     uint8_t data[HT16K33_FB_SIZE];
0293     uint8_t byte;
0294     int err;
0295 
0296     /* Clear RAM (8 * 16 bits) */
0297     memset(data, 0, sizeof(data));
0298     err = i2c_smbus_write_block_data(priv->client, 0, sizeof(data), data);
0299     if (err)
0300         return err;
0301 
0302     /* Turn on internal oscillator */
0303     byte = REG_SYSTEM_SETUP_OSC_ON | REG_SYSTEM_SETUP;
0304     err = i2c_smbus_write_byte(priv->client, byte);
0305     if (err)
0306         return err;
0307 
0308     /* Configure INT pin */
0309     byte = REG_ROWINT_SET | REG_ROWINT_SET_INT_ACT_HIGH;
0310     if (priv->client->irq > 0)
0311         byte |= REG_ROWINT_SET_INT_EN;
0312     return i2c_smbus_write_byte(priv->client, byte);
0313 }
0314 
0315 static int ht16k33_bl_update_status(struct backlight_device *bl)
0316 {
0317     int brightness = bl->props.brightness;
0318     struct ht16k33_priv *priv = bl_get_data(bl);
0319 
0320     if (bl->props.power != FB_BLANK_UNBLANK ||
0321         bl->props.fb_blank != FB_BLANK_UNBLANK ||
0322         bl->props.state & BL_CORE_FBBLANK)
0323         brightness = 0;
0324 
0325     return ht16k33_brightness_set(priv, brightness);
0326 }
0327 
0328 static int ht16k33_bl_check_fb(struct backlight_device *bl, struct fb_info *fi)
0329 {
0330     struct ht16k33_priv *priv = bl_get_data(bl);
0331 
0332     return (fi == NULL) || (fi->par == priv);
0333 }
0334 
0335 static const struct backlight_ops ht16k33_bl_ops = {
0336     .update_status  = ht16k33_bl_update_status,
0337     .check_fb   = ht16k33_bl_check_fb,
0338 };
0339 
0340 /*
0341  * Blank events will be passed to the actual device handling the backlight when
0342  * we return zero here.
0343  */
0344 static int ht16k33_blank(int blank, struct fb_info *info)
0345 {
0346     return 0;
0347 }
0348 
0349 static int ht16k33_mmap(struct fb_info *info, struct vm_area_struct *vma)
0350 {
0351     struct ht16k33_priv *priv = info->par;
0352     struct page *pages = virt_to_page(priv->fbdev.buffer);
0353 
0354     return vm_map_pages_zero(vma, &pages, 1);
0355 }
0356 
0357 static const struct fb_ops ht16k33_fb_ops = {
0358     .owner = THIS_MODULE,
0359     .fb_read = fb_sys_read,
0360     .fb_write = fb_sys_write,
0361     .fb_blank = ht16k33_blank,
0362     .fb_fillrect = sys_fillrect,
0363     .fb_copyarea = sys_copyarea,
0364     .fb_imageblit = sys_imageblit,
0365     .fb_mmap = ht16k33_mmap,
0366 };
0367 
0368 /*
0369  * This gets the keys from keypad and reports it to input subsystem.
0370  * Returns true if a key is pressed.
0371  */
0372 static bool ht16k33_keypad_scan(struct ht16k33_keypad *keypad)
0373 {
0374     const unsigned short *keycodes = keypad->dev->keycode;
0375     u16 new_state[HT16K33_MATRIX_KEYPAD_MAX_COLS];
0376     __le16 data[HT16K33_MATRIX_KEYPAD_MAX_COLS];
0377     unsigned long bits_changed;
0378     int row, col, code;
0379     int rc;
0380     bool pressed = false;
0381 
0382     rc = i2c_smbus_read_i2c_block_data(keypad->client, 0x40,
0383                        sizeof(data), (u8 *)data);
0384     if (rc != sizeof(data)) {
0385         dev_err(&keypad->client->dev,
0386             "Failed to read key data, rc=%d\n", rc);
0387         return false;
0388     }
0389 
0390     for (col = 0; col < keypad->cols; col++) {
0391         new_state[col] = le16_to_cpu(data[col]);
0392         if (new_state[col])
0393             pressed = true;
0394         bits_changed = keypad->last_key_state[col] ^ new_state[col];
0395 
0396         for_each_set_bit(row, &bits_changed, BITS_PER_LONG) {
0397             code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
0398             input_event(keypad->dev, EV_MSC, MSC_SCAN, code);
0399             input_report_key(keypad->dev, keycodes[code],
0400                      new_state[col] & BIT(row));
0401         }
0402     }
0403     input_sync(keypad->dev);
0404     memcpy(keypad->last_key_state, new_state, sizeof(u16) * keypad->cols);
0405 
0406     return pressed;
0407 }
0408 
0409 static irqreturn_t ht16k33_keypad_irq_thread(int irq, void *dev)
0410 {
0411     struct ht16k33_keypad *keypad = dev;
0412 
0413     do {
0414         wait_event_timeout(keypad->wait, keypad->stopped,
0415                     msecs_to_jiffies(keypad->debounce_ms));
0416         if (keypad->stopped)
0417             break;
0418     } while (ht16k33_keypad_scan(keypad));
0419 
0420     return IRQ_HANDLED;
0421 }
0422 
0423 static int ht16k33_keypad_start(struct input_dev *dev)
0424 {
0425     struct ht16k33_keypad *keypad = input_get_drvdata(dev);
0426 
0427     keypad->stopped = false;
0428     mb();
0429     enable_irq(keypad->client->irq);
0430 
0431     return 0;
0432 }
0433 
0434 static void ht16k33_keypad_stop(struct input_dev *dev)
0435 {
0436     struct ht16k33_keypad *keypad = input_get_drvdata(dev);
0437 
0438     keypad->stopped = true;
0439     mb();
0440     wake_up(&keypad->wait);
0441     disable_irq(keypad->client->irq);
0442 }
0443 
0444 static void ht16k33_linedisp_update(struct linedisp *linedisp)
0445 {
0446     struct ht16k33_priv *priv = container_of(linedisp, struct ht16k33_priv,
0447                          seg.linedisp);
0448 
0449     schedule_delayed_work(&priv->work, 0);
0450 }
0451 
0452 static void ht16k33_seg7_update(struct work_struct *work)
0453 {
0454     struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv,
0455                          work.work);
0456     struct ht16k33_seg *seg = &priv->seg;
0457     char *s = seg->curr;
0458     uint8_t buf[9];
0459 
0460     buf[0] = map_to_seg7(&seg->map.seg7, *s++);
0461     buf[1] = 0;
0462     buf[2] = map_to_seg7(&seg->map.seg7, *s++);
0463     buf[3] = 0;
0464     buf[4] = 0;
0465     buf[5] = 0;
0466     buf[6] = map_to_seg7(&seg->map.seg7, *s++);
0467     buf[7] = 0;
0468     buf[8] = map_to_seg7(&seg->map.seg7, *s++);
0469 
0470     i2c_smbus_write_i2c_block_data(priv->client, 0, ARRAY_SIZE(buf), buf);
0471 }
0472 
0473 static void ht16k33_seg14_update(struct work_struct *work)
0474 {
0475     struct ht16k33_priv *priv = container_of(work, struct ht16k33_priv,
0476                          work.work);
0477     struct ht16k33_seg *seg = &priv->seg;
0478     char *s = seg->curr;
0479     uint8_t buf[8];
0480 
0481     put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf);
0482     put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf + 2);
0483     put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf + 4);
0484     put_unaligned_le16(map_to_seg14(&seg->map.seg14, *s++), buf + 6);
0485 
0486     i2c_smbus_write_i2c_block_data(priv->client, 0, ARRAY_SIZE(buf), buf);
0487 }
0488 
0489 static int ht16k33_led_probe(struct device *dev, struct led_classdev *led,
0490                  unsigned int brightness)
0491 {
0492     struct led_init_data init_data = {};
0493     int err;
0494 
0495     /* The LED is optional */
0496     init_data.fwnode = device_get_named_child_node(dev, "led");
0497     if (!init_data.fwnode)
0498         return 0;
0499 
0500     init_data.devicename = "auxdisplay";
0501     init_data.devname_mandatory = true;
0502 
0503     led->brightness_set_blocking = ht16k33_brightness_set_blocking;
0504     led->blink_set = ht16k33_blink_set;
0505     led->flags = LED_CORE_SUSPENDRESUME;
0506     led->brightness = brightness;
0507     led->max_brightness = MAX_BRIGHTNESS;
0508 
0509     err = devm_led_classdev_register_ext(dev, led, &init_data);
0510     if (err)
0511         dev_err(dev, "Failed to register LED\n");
0512 
0513     return err;
0514 }
0515 
0516 static int ht16k33_keypad_probe(struct i2c_client *client,
0517                 struct ht16k33_keypad *keypad)
0518 {
0519     struct device *dev = &client->dev;
0520     u32 rows = HT16K33_MATRIX_KEYPAD_MAX_ROWS;
0521     u32 cols = HT16K33_MATRIX_KEYPAD_MAX_COLS;
0522     int err;
0523 
0524     keypad->client = client;
0525     init_waitqueue_head(&keypad->wait);
0526 
0527     keypad->dev = devm_input_allocate_device(dev);
0528     if (!keypad->dev)
0529         return -ENOMEM;
0530 
0531     input_set_drvdata(keypad->dev, keypad);
0532 
0533     keypad->dev->name = DRIVER_NAME"-keypad";
0534     keypad->dev->id.bustype = BUS_I2C;
0535     keypad->dev->open = ht16k33_keypad_start;
0536     keypad->dev->close = ht16k33_keypad_stop;
0537 
0538     if (!device_property_read_bool(dev, "linux,no-autorepeat"))
0539         __set_bit(EV_REP, keypad->dev->evbit);
0540 
0541     err = device_property_read_u32(dev, "debounce-delay-ms",
0542                        &keypad->debounce_ms);
0543     if (err) {
0544         dev_err(dev, "key debounce delay not specified\n");
0545         return err;
0546     }
0547 
0548     err = matrix_keypad_parse_properties(dev, &rows, &cols);
0549     if (err)
0550         return err;
0551     if (rows > HT16K33_MATRIX_KEYPAD_MAX_ROWS ||
0552         cols > HT16K33_MATRIX_KEYPAD_MAX_COLS) {
0553         dev_err(dev, "%u rows or %u cols out of range in DT\n", rows,
0554             cols);
0555         return -ERANGE;
0556     }
0557 
0558     keypad->rows = rows;
0559     keypad->cols = cols;
0560     keypad->row_shift = get_count_order(cols);
0561 
0562     err = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL,
0563                      keypad->dev);
0564     if (err) {
0565         dev_err(dev, "failed to build keymap\n");
0566         return err;
0567     }
0568 
0569     err = devm_request_threaded_irq(dev, client->irq, NULL,
0570                     ht16k33_keypad_irq_thread,
0571                     IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
0572                     DRIVER_NAME, keypad);
0573     if (err) {
0574         dev_err(dev, "irq request failed %d, error %d\n", client->irq,
0575             err);
0576         return err;
0577     }
0578 
0579     ht16k33_keypad_stop(keypad->dev);
0580 
0581     return input_register_device(keypad->dev);
0582 }
0583 
0584 static int ht16k33_fbdev_probe(struct device *dev, struct ht16k33_priv *priv,
0585                    uint32_t brightness)
0586 {
0587     struct ht16k33_fbdev *fbdev = &priv->fbdev;
0588     struct backlight_device *bl = NULL;
0589     int err;
0590 
0591     if (priv->led.dev) {
0592         err = ht16k33_brightness_set(priv, brightness);
0593         if (err)
0594             return err;
0595     } else {
0596         /* backwards compatibility with DT lacking an led subnode */
0597         struct backlight_properties bl_props;
0598 
0599         memset(&bl_props, 0, sizeof(struct backlight_properties));
0600         bl_props.type = BACKLIGHT_RAW;
0601         bl_props.max_brightness = MAX_BRIGHTNESS;
0602 
0603         bl = devm_backlight_device_register(dev, DRIVER_NAME"-bl", dev,
0604                             priv, &ht16k33_bl_ops,
0605                             &bl_props);
0606         if (IS_ERR(bl)) {
0607             dev_err(dev, "failed to register backlight\n");
0608             return PTR_ERR(bl);
0609         }
0610 
0611         bl->props.brightness = brightness;
0612         ht16k33_bl_update_status(bl);
0613     }
0614 
0615     /* Framebuffer (2 bytes per column) */
0616     BUILD_BUG_ON(PAGE_SIZE < HT16K33_FB_SIZE);
0617     fbdev->buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL);
0618     if (!fbdev->buffer)
0619         return -ENOMEM;
0620 
0621     fbdev->cache = devm_kmalloc(dev, HT16K33_FB_SIZE, GFP_KERNEL);
0622     if (!fbdev->cache) {
0623         err = -ENOMEM;
0624         goto err_fbdev_buffer;
0625     }
0626 
0627     fbdev->info = framebuffer_alloc(0, dev);
0628     if (!fbdev->info) {
0629         err = -ENOMEM;
0630         goto err_fbdev_buffer;
0631     }
0632 
0633     err = device_property_read_u32(dev, "refresh-rate-hz",
0634                        &fbdev->refresh_rate);
0635     if (err) {
0636         dev_err(dev, "refresh rate not specified\n");
0637         goto err_fbdev_info;
0638     }
0639     fb_bl_default_curve(fbdev->info, 0, MIN_BRIGHTNESS, MAX_BRIGHTNESS);
0640 
0641     INIT_DELAYED_WORK(&priv->work, ht16k33_fb_update);
0642     fbdev->info->fbops = &ht16k33_fb_ops;
0643     fbdev->info->screen_base = (char __iomem *) fbdev->buffer;
0644     fbdev->info->screen_size = HT16K33_FB_SIZE;
0645     fbdev->info->fix = ht16k33_fb_fix;
0646     fbdev->info->var = ht16k33_fb_var;
0647     fbdev->info->bl_dev = bl;
0648     fbdev->info->pseudo_palette = NULL;
0649     fbdev->info->flags = FBINFO_FLAG_DEFAULT;
0650     fbdev->info->par = priv;
0651 
0652     err = register_framebuffer(fbdev->info);
0653     if (err)
0654         goto err_fbdev_info;
0655 
0656     ht16k33_fb_queue(priv);
0657     return 0;
0658 
0659 err_fbdev_info:
0660     framebuffer_release(fbdev->info);
0661 err_fbdev_buffer:
0662     free_page((unsigned long) fbdev->buffer);
0663 
0664     return err;
0665 }
0666 
0667 static int ht16k33_seg_probe(struct device *dev, struct ht16k33_priv *priv,
0668                  uint32_t brightness)
0669 {
0670     struct ht16k33_seg *seg = &priv->seg;
0671     int err;
0672 
0673     err = ht16k33_brightness_set(priv, brightness);
0674     if (err)
0675         return err;
0676 
0677     switch (priv->type) {
0678     case DISP_MATRIX:
0679         /* not handled here */
0680         err = -EINVAL;
0681         break;
0682 
0683     case DISP_QUAD_7SEG:
0684         INIT_DELAYED_WORK(&priv->work, ht16k33_seg7_update);
0685         seg->map.seg7 = initial_map_seg7;
0686         seg->map_size = sizeof(seg->map.seg7);
0687         err = device_create_file(dev, &dev_attr_map_seg7);
0688         break;
0689 
0690     case DISP_QUAD_14SEG:
0691         INIT_DELAYED_WORK(&priv->work, ht16k33_seg14_update);
0692         seg->map.seg14 = initial_map_seg14;
0693         seg->map_size = sizeof(seg->map.seg14);
0694         err = device_create_file(dev, &dev_attr_map_seg14);
0695         break;
0696     }
0697     if (err)
0698         return err;
0699 
0700     err = linedisp_register(&seg->linedisp, dev, 4, seg->curr,
0701                 ht16k33_linedisp_update);
0702     if (err)
0703         goto err_remove_map_file;
0704 
0705     return 0;
0706 
0707 err_remove_map_file:
0708     device_remove_file(dev, &dev_attr_map_seg7);
0709     device_remove_file(dev, &dev_attr_map_seg14);
0710     return err;
0711 }
0712 
0713 static int ht16k33_probe(struct i2c_client *client)
0714 {
0715     struct device *dev = &client->dev;
0716     const struct of_device_id *id;
0717     struct ht16k33_priv *priv;
0718     uint32_t dft_brightness;
0719     int err;
0720 
0721     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
0722         dev_err(dev, "i2c_check_functionality error\n");
0723         return -EIO;
0724     }
0725 
0726     priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
0727     if (!priv)
0728         return -ENOMEM;
0729 
0730     priv->client = client;
0731     id = i2c_of_match_device(dev->driver->of_match_table, client);
0732     if (id)
0733         priv->type = (uintptr_t)id->data;
0734     i2c_set_clientdata(client, priv);
0735 
0736     err = ht16k33_initialize(priv);
0737     if (err)
0738         return err;
0739 
0740     err = device_property_read_u32(dev, "default-brightness-level",
0741                        &dft_brightness);
0742     if (err) {
0743         dft_brightness = MAX_BRIGHTNESS;
0744     } else if (dft_brightness > MAX_BRIGHTNESS) {
0745         dev_warn(dev,
0746              "invalid default brightness level: %u, using %u\n",
0747              dft_brightness, MAX_BRIGHTNESS);
0748         dft_brightness = MAX_BRIGHTNESS;
0749     }
0750 
0751     /* LED */
0752     err = ht16k33_led_probe(dev, &priv->led, dft_brightness);
0753     if (err)
0754         return err;
0755 
0756     /* Keypad */
0757     if (client->irq > 0) {
0758         err = ht16k33_keypad_probe(client, &priv->keypad);
0759         if (err)
0760             return err;
0761     }
0762 
0763     switch (priv->type) {
0764     case DISP_MATRIX:
0765         /* Frame Buffer Display */
0766         err = ht16k33_fbdev_probe(dev, priv, dft_brightness);
0767         break;
0768 
0769     case DISP_QUAD_7SEG:
0770     case DISP_QUAD_14SEG:
0771         /* Segment Display */
0772         err = ht16k33_seg_probe(dev, priv, dft_brightness);
0773         break;
0774     }
0775     return err;
0776 }
0777 
0778 static int ht16k33_remove(struct i2c_client *client)
0779 {
0780     struct ht16k33_priv *priv = i2c_get_clientdata(client);
0781     struct ht16k33_fbdev *fbdev = &priv->fbdev;
0782 
0783     cancel_delayed_work_sync(&priv->work);
0784 
0785     switch (priv->type) {
0786     case DISP_MATRIX:
0787         unregister_framebuffer(fbdev->info);
0788         framebuffer_release(fbdev->info);
0789         free_page((unsigned long)fbdev->buffer);
0790         break;
0791 
0792     case DISP_QUAD_7SEG:
0793     case DISP_QUAD_14SEG:
0794         linedisp_unregister(&priv->seg.linedisp);
0795         device_remove_file(&client->dev, &dev_attr_map_seg7);
0796         device_remove_file(&client->dev, &dev_attr_map_seg14);
0797         break;
0798     }
0799 
0800     return 0;
0801 }
0802 
0803 static const struct i2c_device_id ht16k33_i2c_match[] = {
0804     { "ht16k33", 0 },
0805     { }
0806 };
0807 MODULE_DEVICE_TABLE(i2c, ht16k33_i2c_match);
0808 
0809 static const struct of_device_id ht16k33_of_match[] = {
0810     {
0811         /* 0.56" 4-Digit 7-Segment FeatherWing Display (Red) */
0812         .compatible = "adafruit,3108", .data = (void *)DISP_QUAD_7SEG,
0813     }, {
0814         /* 0.54" Quad Alphanumeric FeatherWing Display (Red) */
0815         .compatible = "adafruit,3130", .data = (void *)DISP_QUAD_14SEG,
0816     }, {
0817         /* Generic, assumed Dot-Matrix Display */
0818         .compatible = "holtek,ht16k33", .data = (void *)DISP_MATRIX,
0819     },
0820     { }
0821 };
0822 MODULE_DEVICE_TABLE(of, ht16k33_of_match);
0823 
0824 static struct i2c_driver ht16k33_driver = {
0825     .probe_new  = ht16k33_probe,
0826     .remove     = ht16k33_remove,
0827     .driver     = {
0828         .name       = DRIVER_NAME,
0829         .of_match_table = ht16k33_of_match,
0830     },
0831     .id_table = ht16k33_i2c_match,
0832 };
0833 module_i2c_driver(ht16k33_driver);
0834 
0835 MODULE_DESCRIPTION("Holtek HT16K33 driver");
0836 MODULE_LICENSE("GPL");
0837 MODULE_AUTHOR("Robin van der Gracht <robin@protonic.nl>");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!