input/misc/apanel.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Fujitsu Lifebook Application Panel button drive
0004  *
0005  *  Copyright (C) 2007 Stephen Hemminger <shemminger@linux-foundation.org>
0006  *  Copyright (C) 2001-2003 Jochen Eisinger <jochen@penguin-breeder.org>
0007  *
0008  * Many Fujitsu Lifebook laptops have a small panel of buttons that are
0009  * accessible via the i2c/smbus interface. This driver polls those
0010  * buttons and generates input events.
0011  *
0012  * For more details see:
0013  *  http://apanel.sourceforge.net/tech.php
0014  */
0015
0016 #include <linux/kernel.h>
0017 #include <linux/module.h>
0018 #include <linux/ioport.h>
0019 #include <linux/io.h>
0020 #include <linux/input.h>
0021 #include <linux/i2c.h>
0022 #include <linux/leds.h>
0023
0024 #define APANEL_NAME "Fujitsu Application Panel"
0025 #define APANEL      "apanel"
0026
0027 /* How often we poll keys - msecs */
0028 #define POLL_INTERVAL_DEFAULT   1000
0029
0030 /* Magic constants in BIOS that tell about buttons */
0031 enum apanel_devid {
0032     APANEL_DEV_NONE   = 0,
0033     APANEL_DEV_APPBTN = 1,
0034     APANEL_DEV_CDBTN  = 2,
0035     APANEL_DEV_LCD    = 3,
0036     APANEL_DEV_LED    = 4,
0037
0038     APANEL_DEV_MAX,
0039 };
0040
0041 enum apanel_chip {
0042     CHIP_NONE    = 0,
0043     CHIP_OZ992C  = 1,
0044     CHIP_OZ163T  = 2,
0045     CHIP_OZ711M3 = 4,
0046 };
0047
0048 /* Result of BIOS snooping/probing -- what features are supported */
0049 static enum apanel_chip device_chip[APANEL_DEV_MAX];
0050
0051 #define MAX_PANEL_KEYS  12
0052
0053 struct apanel {
0054     struct input_dev *idev;
0055     struct i2c_client *client;
0056     unsigned short keymap[MAX_PANEL_KEYS];
0057     u16 nkeys;
0058     struct led_classdev mail_led;
0059 };
0060
0061 static const unsigned short apanel_keymap[MAX_PANEL_KEYS] = {
0062     [0] = KEY_MAIL,
0063     [1] = KEY_WWW,
0064     [2] = KEY_PROG2,
0065     [3] = KEY_PROG1,
0066
0067     [8] = KEY_FORWARD,
0068     [9] = KEY_REWIND,
0069     [10] = KEY_STOPCD,
0070     [11] = KEY_PLAYPAUSE,
0071 };
0072
0073 static void report_key(struct input_dev *input, unsigned keycode)
0074 {
0075     dev_dbg(input->dev.parent, "report key %#x\n", keycode);
0076     input_report_key(input, keycode, 1);
0077     input_sync(input);
0078
0079     input_report_key(input, keycode, 0);
0080     input_sync(input);
0081 }
0082
0083 /* Poll for key changes
0084  *
0085  * Read Application keys via SMI
0086  *  A (0x4), B (0x8), Internet (0x2), Email (0x1).
0087  *
0088  * CD keys:
0089  * Forward (0x100), Rewind (0x200), Stop (0x400), Pause (0x800)
0090  */
0091 static void apanel_poll(struct input_dev *idev)
0092 {
0093     struct apanel *ap = input_get_drvdata(idev);
0094     u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
0095     s32 data;
0096     int i;
0097
0098     data = i2c_smbus_read_word_data(ap->client, cmd);
0099     if (data < 0)
0100         return; /* ignore errors (due to ACPI??) */
0101
0102     /* write back to clear latch */
0103     i2c_smbus_write_word_data(ap->client, cmd, 0);
0104
0105     if (!data)
0106         return;
0107
0108     dev_dbg(&idev->dev, APANEL ": data %#x\n", data);
0109     for (i = 0; i < idev->keycodemax; i++)
0110         if ((1u << i) & data)
0111             report_key(idev, ap->keymap[i]);
0112 }
0113
0114 static int mail_led_set(struct led_classdev *led,
0115              enum led_brightness value)
0116 {
0117     struct apanel *ap = container_of(led, struct apanel, mail_led);
0118     u16 led_bits = value != LED_OFF ? 0x8000 : 0x0000;
0119
0120     return i2c_smbus_write_word_data(ap->client, 0x10, led_bits);
0121 }
0122
0123 static int apanel_probe(struct i2c_client *client,
0124             const struct i2c_device_id *id)
0125 {
0126     struct apanel *ap;
0127     struct input_dev *idev;
0128     u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
0129     int i, err;
0130
0131     ap = devm_kzalloc(&client->dev, sizeof(*ap), GFP_KERNEL);
0132     if (!ap)
0133         return -ENOMEM;
0134
0135     idev = devm_input_allocate_device(&client->dev);
0136     if (!idev)
0137         return -ENOMEM;
0138
0139     ap->idev = idev;
0140     ap->client = client;
0141
0142     i2c_set_clientdata(client, ap);
0143
0144     err = i2c_smbus_write_word_data(client, cmd, 0);
0145     if (err) {
0146         dev_warn(&client->dev, "smbus write error %d\n", err);
0147         return err;
0148     }
0149
0150     input_set_drvdata(idev, ap);
0151
0152     idev->name = APANEL_NAME " buttons";
0153     idev->phys = "apanel/input0";
0154     idev->id.bustype = BUS_HOST;
0155
0156     memcpy(ap->keymap, apanel_keymap, sizeof(apanel_keymap));
0157     idev->keycode = ap->keymap;
0158     idev->keycodesize = sizeof(ap->keymap[0]);
0159     idev->keycodemax = (device_chip[APANEL_DEV_CDBTN] != CHIP_NONE) ? 12 : 4;
0160
0161     set_bit(EV_KEY, idev->evbit);
0162     for (i = 0; i < idev->keycodemax; i++)
0163         if (ap->keymap[i])
0164             set_bit(ap->keymap[i], idev->keybit);
0165
0166     err = input_setup_polling(idev, apanel_poll);
0167     if (err)
0168         return err;
0169
0170     input_set_poll_interval(idev, POLL_INTERVAL_DEFAULT);
0171
0172     err = input_register_device(idev);
0173     if (err)
0174         return err;
0175
0176     if (device_chip[APANEL_DEV_LED] != CHIP_NONE) {
0177         ap->mail_led.name = "mail:blue";
0178         ap->mail_led.brightness_set_blocking = mail_led_set;
0179         err = devm_led_classdev_register(&client->dev, &ap->mail_led);
0180         if (err)
0181             return err;
0182     }
0183
0184     return 0;
0185 }
0186
0187 static void apanel_shutdown(struct i2c_client *client)
0188 {
0189     struct apanel *ap = i2c_get_clientdata(client);
0190
0191     if (device_chip[APANEL_DEV_LED] != CHIP_NONE)
0192         led_set_brightness(&ap->mail_led, LED_OFF);
0193 }
0194
0195 static const struct i2c_device_id apanel_id[] = {
0196     { "fujitsu_apanel", 0 },
0197     { }
0198 };
0199 MODULE_DEVICE_TABLE(i2c, apanel_id);
0200
0201 static struct i2c_driver apanel_driver = {
0202     .driver = {
0203         .name = APANEL,
0204     },
0205     .probe      = apanel_probe,
0206     .shutdown   = apanel_shutdown,
0207     .id_table   = apanel_id,
0208 };
0209
0210 /* Scan the system ROM for the signature "FJKEYINF" */
0211 static __init const void __iomem *bios_signature(const void __iomem *bios)
0212 {
0213     ssize_t offset;
0214     const unsigned char signature[] = "FJKEYINF";
0215
0216     for (offset = 0; offset < 0x10000; offset += 0x10) {
0217         if (check_signature(bios + offset, signature,
0218                     sizeof(signature)-1))
0219             return bios + offset;
0220     }
0221     pr_notice(APANEL ": Fujitsu BIOS signature '%s' not found...\n",
0222           signature);
0223     return NULL;
0224 }
0225
0226 static int __init apanel_init(void)
0227 {
0228     void __iomem *bios;
0229     const void __iomem *p;
0230     u8 devno;
0231     unsigned char i2c_addr;
0232     int found = 0;
0233
0234     bios = ioremap(0xF0000, 0x10000); /* Can't fail */
0235
0236     p = bios_signature(bios);
0237     if (!p) {
0238         iounmap(bios);
0239         return -ENODEV;
0240     }
0241
0242     /* just use the first address */
0243     p += 8;
0244     i2c_addr = readb(p + 3) >> 1;
0245
0246     for ( ; (devno = readb(p)) & 0x7f; p += 4) {
0247         unsigned char method, slave, chip;
0248
0249         method = readb(p + 1);
0250         chip = readb(p + 2);
0251         slave = readb(p + 3) >> 1;
0252
0253         if (slave != i2c_addr) {
0254             pr_notice(APANEL ": only one SMBus slave "
0255                   "address supported, skipping device...\n");
0256             continue;
0257         }
0258
0259         /* translate alternative device numbers */
0260         switch (devno) {
0261         case 6:
0262             devno = APANEL_DEV_APPBTN;
0263             break;
0264         case 7:
0265             devno = APANEL_DEV_LED;
0266             break;
0267         }
0268
0269         if (devno >= APANEL_DEV_MAX)
0270             pr_notice(APANEL ": unknown device %u found\n", devno);
0271         else if (device_chip[devno] != CHIP_NONE)
0272             pr_warn(APANEL ": duplicate entry for devno %u\n",
0273                 devno);
0274
0275         else if (method != 1 && method != 2 && method != 4) {
0276             pr_notice(APANEL ": unknown method %u for devno %u\n",
0277                   method, devno);
0278         } else {
0279             device_chip[devno] = (enum apanel_chip) chip;
0280             ++found;
0281         }
0282     }
0283     iounmap(bios);
0284
0285     if (found == 0) {
0286         pr_info(APANEL ": no input devices reported by BIOS\n");
0287         return -EIO;
0288     }
0289
0290     return i2c_add_driver(&apanel_driver);
0291 }
0292 module_init(apanel_init);
0293
0294 static void __exit apanel_cleanup(void)
0295 {
0296     i2c_del_driver(&apanel_driver);
0297 }
0298 module_exit(apanel_cleanup);
0299
0300 MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
0301 MODULE_DESCRIPTION(APANEL_NAME " driver");
0302 MODULE_LICENSE("GPL");
0303
0304 MODULE_ALIAS("dmi:*:svnFUJITSU:pnLifeBook*:pvr*:rvnFUJITSU:*");
0305 MODULE_ALIAS("dmi:*:svnFUJITSU:pnLifebook*:pvr*:rvnFUJITSU:*");