Input: lkkbd - change formatting style to match the rest of the kernel

 - no spaces between function name and opening parenthesis
 - switch statements were indented too much

This makes checkpatch (and me) happy.

Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

1 files changed, 238 insertions, 258 deletions

diff --git a/drivers/input/keyboard/lkkbd.c b/drivers/input/keyboard/lkkbd.c
index f9847e0fb553..fa9bb6d235e2 100644
--- a/drivers/input/keyboard/lkkbd.c
+++ b/drivers/input/keyboard/lkkbd.c
@@ -72,9 +72,9 @@
 
 #define DRIVER_DESC     "LK keyboard driver"
 
-MODULE_AUTHOR ("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
-MODULE_DESCRIPTION (DRIVER_DESC);
-MODULE_LICENSE ("GPL");
+MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
 
 /*
  * Known parameters:
@@ -85,27 +85,27 @@ MODULE_LICENSE ("GPL");
  * Please notice that there's not yet an API to set these at runtime.
  */
 static int bell_volume = 100; /* % */
-module_param (bell_volume, int, 0);
-MODULE_PARM_DESC (bell_volume, "Bell volume (in %). default is 100%");
+module_param(bell_volume, int, 0);
+MODULE_PARM_DESC(bell_volume, "Bell volume (in %). default is 100%");
 
 static int keyclick_volume = 100; /* % */
-module_param (keyclick_volume, int, 0);
-MODULE_PARM_DESC (keyclick_volume, "Keyclick volume (in %), default is 100%");
+module_param(keyclick_volume, int, 0);
+MODULE_PARM_DESC(keyclick_volume, "Keyclick volume (in %), default is 100%");
 
 static int ctrlclick_volume = 100; /* % */
-module_param (ctrlclick_volume, int, 0);
-MODULE_PARM_DESC (ctrlclick_volume, "Ctrlclick volume (in %), default is 100%");
+module_param(ctrlclick_volume, int, 0);
+MODULE_PARM_DESC(ctrlclick_volume, "Ctrlclick volume (in %), default is 100%");
 
 static int lk201_compose_is_alt;
-module_param (lk201_compose_is_alt, int, 0);
-MODULE_PARM_DESC (lk201_compose_is_alt, "If set non-zero, LK201' Compose key "
-                "will act as an Alt key");
+module_param(lk201_compose_is_alt, int, 0);
+MODULE_PARM_DESC(lk201_compose_is_alt,
+                 "If set non-zero, LK201' Compose key will act as an Alt key");
 
 
 
 #undef LKKBD_DEBUG
 #ifdef LKKBD_DEBUG
-#define DBG(x...) printk (x)
+#define DBG(x...) printk(x)
 #else
 #define DBG(x...) do {} while (0)
 #endif
@@ -122,7 +122,7 @@ MODULE_PARM_DESC (lk201_compose_is_alt, "If set non-zero, LK201' Compose key "
 #define LK_MODE_DOWN            0x80
 #define LK_MODE_AUTODOWN        0x82
 #define LK_MODE_UPDOWN          0x86
-#define LK_CMD_SET_MODE(mode,div)       ((mode) | ((div) << 3))
+#define LK_CMD_SET_MODE(mode, div)      ((mode) | ((div) << 3))
 
 /* Misc commands */
 #define LK_CMD_ENABLE_KEYCLICK  0x1b
@@ -152,11 +152,8 @@ MODULE_PARM_DESC (lk201_compose_is_alt, "If set non-zero, LK201' Compose key "
 
 #define LK_NUM_KEYCODES         256
 #define LK_NUM_IGNORE_BYTES     6
-typedef u_int16_t lk_keycode_t;
 
-
-
-static lk_keycode_t lkkbd_keycode[LK_NUM_KEYCODES] = {
+static unsigned short lkkbd_keycode[LK_NUM_KEYCODES] = {
         [0x56] = KEY_F1,
         [0x57] = KEY_F2,
         [0x58] = KEY_F3,
@@ -268,7 +265,7 @@ static lk_keycode_t lkkbd_keycode[LK_NUM_KEYCODES] = {
 };
 
 #define CHECK_LED(LK, VAR_ON, VAR_OFF, LED, BITS) do {          \
-        if (test_bit (LED, (LK)->dev->led))                     \
+        if (test_bit(LED, (LK)->dev->led))                      \
                 VAR_ON |= BITS;                                 \
         else                                                    \
                 VAR_OFF |= BITS;                                \
@@ -278,7 +275,7 @@ static lk_keycode_t lkkbd_keycode[LK_NUM_KEYCODES] = {
  * Per-keyboard data
  */
 struct lkkbd {
-        lk_keycode_t keycode[LK_NUM_KEYCODES];
+        unsigned short keycode[LK_NUM_KEYCODES];
         int ignore_bytes;
         unsigned char id[LK_NUM_IGNORE_BYTES];
         struct input_dev *dev;
@@ -301,26 +298,25 @@ static struct {
         unsigned char *name;
 } lk_response[] = {
 #define RESPONSE(x) { .value = (x), .name = #x, }
-        RESPONSE (LK_STUCK_KEY),
-        RESPONSE (LK_SELFTEST_FAILED),
-        RESPONSE (LK_ALL_KEYS_UP),
-        RESPONSE (LK_METRONOME),
-        RESPONSE (LK_OUTPUT_ERROR),
-        RESPONSE (LK_INPUT_ERROR),
-        RESPONSE (LK_KBD_LOCKED),
-        RESPONSE (LK_KBD_TEST_MODE_ACK),
-        RESPONSE (LK_PREFIX_KEY_DOWN),
-        RESPONSE (LK_MODE_CHANGE_ACK),
-        RESPONSE (LK_RESPONSE_RESERVED),
+        RESPONSE(LK_STUCK_KEY),
+        RESPONSE(LK_SELFTEST_FAILED),
+        RESPONSE(LK_ALL_KEYS_UP),
+        RESPONSE(LK_METRONOME),
+        RESPONSE(LK_OUTPUT_ERROR),
+        RESPONSE(LK_INPUT_ERROR),
+        RESPONSE(LK_KBD_LOCKED),
+        RESPONSE(LK_KBD_TEST_MODE_ACK),
+        RESPONSE(LK_PREFIX_KEY_DOWN),
+        RESPONSE(LK_MODE_CHANGE_ACK),
+        RESPONSE(LK_RESPONSE_RESERVED),
 #undef RESPONSE
 };
 
-static unsigned char *
-response_name (unsigned char value)
+static unsigned char *response_name(unsigned char value)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE (lk_response); i++)
+        for (i = 0; i < ARRAY_SIZE(lk_response); i++)
                 if (lk_response[i].value == value)
                         return lk_response[i].name;
 
@@ -331,8 +327,7 @@ response_name (unsigned char value)
 /*
  * Calculate volume parameter byte for a given volume.
  */
-static unsigned char
-volume_to_hw (int volume_percent)
+static unsigned char volume_to_hw(int volume_percent)
 {
         unsigned char ret = 0;
 
@@ -363,8 +358,7 @@ volume_to_hw (int volume_percent)
         return ret;
 }
 
-static void
-lkkbd_detection_done (struct lkkbd *lk)
+static void lkkbd_detection_done(struct lkkbd *lk)
 {
         int i;
 
@@ -377,190 +371,202 @@ lkkbd_detection_done (struct lkkbd *lk)
          * Print keyboard name and modify Compose=Alt on user's request.
          */
         switch (lk->id[4]) {
-                case 1:
-                        strlcpy (lk->name, "DEC LK201 keyboard",
-                                 sizeof (lk->name));
-
-                        if (lk201_compose_is_alt)
-                                lk->keycode[0xb1] = KEY_LEFTALT;
-                        break;
-
-                case 2:
-                        strlcpy (lk->name, "DEC LK401 keyboard",
-                                 sizeof (lk->name));
-                        break;
-
-                default:
-                        strlcpy (lk->name, "Unknown DEC keyboard",
-                                 sizeof (lk->name));
-                        printk (KERN_ERR "lkkbd: keyboard on %s is unknown, "
-                                        "please report to Jan-Benedict Glaw "
-                                        "<jbglaw@lug-owl.de>\n", lk->phys);
-                        printk (KERN_ERR "lkkbd: keyboard ID'ed as:");
-                        for (i = 0; i < LK_NUM_IGNORE_BYTES; i++)
-                                printk (" 0x%02x", lk->id[i]);
-                        printk ("\n");
-                        break;
+        case 1:
+                strlcpy(lk->name, "DEC LK201 keyboard", sizeof(lk->name));
+
+                if (lk201_compose_is_alt)
+                        lk->keycode[0xb1] = KEY_LEFTALT;
+                break;
+
+        case 2:
+                strlcpy(lk->name, "DEC LK401 keyboard", sizeof(lk->name));
+                break;
+
+        default:
+                strlcpy(lk->name, "Unknown DEC keyboard", sizeof(lk->name));
+                printk(KERN_ERR
+                        "lkkbd: keyboard on %s is unknown, please report to "
+                        "Jan-Benedict Glaw <jbglaw@lug-owl.de>\n", lk->phys);
+                printk(KERN_ERR "lkkbd: keyboard ID'ed as:");
+                for (i = 0; i < LK_NUM_IGNORE_BYTES; i++)
+                        printk(" 0x%02x", lk->id[i]);
+                printk("\n");
+                break;
         }
-        printk (KERN_INFO "lkkbd: keyboard on %s identified as: %s\n",
-                        lk->phys, lk->name);
+
+        printk(KERN_INFO "lkkbd: keyboard on %s identified as: %s\n",
+                lk->phys, lk->name);
 
         /*
          * Report errors during keyboard boot-up.
          */
         switch (lk->id[2]) {
-                case 0x00:
-                        /* All okay */
-                        break;
-
-                case LK_STUCK_KEY:
-                        printk (KERN_ERR "lkkbd: Stuck key on keyboard at "
-                                        "%s\n", lk->phys);
-                        break;
-
-                case LK_SELFTEST_FAILED:
-                        printk (KERN_ERR "lkkbd: Selftest failed on keyboard "
-                                        "at %s, keyboard may not work "
-                                        "properly\n", lk->phys);
-                        break;
-
-                default:
-                        printk (KERN_ERR "lkkbd: Unknown error %02x on "
-                                        "keyboard at %s\n", lk->id[2],
-                                        lk->phys);
-                        break;
+        case 0x00:
+                /* All okay */
+                break;
+
+        case LK_STUCK_KEY:
+                printk(KERN_ERR "lkkbd: Stuck key on keyboard at %s\n",
+                        lk->phys);
+                break;
+
+        case LK_SELFTEST_FAILED:
+                printk(KERN_ERR
+                        "lkkbd: Selftest failed on keyboard at %s, "
+                        "keyboard may not work properly\n", lk->phys);
+                break;
+
+        default:
+                printk(KERN_ERR
+                        "lkkbd: Unknown error %02x on keyboard at %s\n",
+                        lk->id[2], lk->phys);
+                break;
         }
 
         /*
          * Try to hint user if there's a stuck key.
          */
         if (lk->id[2] == LK_STUCK_KEY && lk->id[3] != 0)
-                printk (KERN_ERR "Scancode of stuck key is 0x%02x, keycode "
-                                "is 0x%04x\n", lk->id[3],
-                                lk->keycode[lk->id[3]]);
-
-        return;
+                printk(KERN_ERR
+                        "Scancode of stuck key is 0x%02x, keycode is 0x%04x\n",
+                        lk->id[3], lk->keycode[lk->id[3]]);
 }
 
 /*
  * lkkbd_interrupt() is called by the low level driver when a character
  * is received.
  */
-static irqreturn_t
-lkkbd_interrupt (struct serio *serio, unsigned char data, unsigned int flags)
+static irqreturn_t lkkbd_interrupt(struct serio *serio,
+                                   unsigned char data, unsigned int flags)
 {
-        struct lkkbd *lk = serio_get_drvdata (serio);
+        struct lkkbd *lk = serio_get_drvdata(serio);
+        struct input_dev *input_dev = lk->dev;
+        unsigned int keycode;
         int i;
 
-        DBG (KERN_INFO "Got byte 0x%02x\n", data);
+        DBG(KERN_INFO "Got byte 0x%02x\n", data);
 
         if (lk->ignore_bytes > 0) {
-                DBG (KERN_INFO "Ignoring a byte on %s\n", lk->name);
+                DBG(KERN_INFO "Ignoring a byte on %s\n", lk->name);
                 lk->id[LK_NUM_IGNORE_BYTES - lk->ignore_bytes--] = data;
 
                 if (lk->ignore_bytes == 0)
-                        lkkbd_detection_done (lk);
+                        lkkbd_detection_done(lk);
 
                 return IRQ_HANDLED;
         }
 
         switch (data) {
-                case LK_ALL_KEYS_UP:
-                        for (i = 0; i < ARRAY_SIZE (lkkbd_keycode); i++)
-                                if (lk->keycode[i] != KEY_RESERVED)
-                                        input_report_key (lk->dev, lk->keycode[i], 0);
-                        input_sync (lk->dev);
-                        break;
-
-                case 0x01:
-                        DBG (KERN_INFO "Got 0x01, scheduling re-initialization\n");
-                        lk->ignore_bytes = LK_NUM_IGNORE_BYTES;
-                        lk->id[LK_NUM_IGNORE_BYTES - lk->ignore_bytes--] = data;
-                        schedule_work (&lk->tq);
-                        break;
-
-                case LK_METRONOME:
-                case LK_OUTPUT_ERROR:
-                case LK_INPUT_ERROR:
-                case LK_KBD_LOCKED:
-                case LK_KBD_TEST_MODE_ACK:
-                case LK_PREFIX_KEY_DOWN:
-                case LK_MODE_CHANGE_ACK:
-                case LK_RESPONSE_RESERVED:
-                        DBG (KERN_INFO "Got %s and don't know how to handle...\n",
-                                        response_name (data));
-                        break;
-
-                default:
-                        if (lk->keycode[data] != KEY_RESERVED) {
-                                if (!test_bit (lk->keycode[data], lk->dev->key))
-                                        input_report_key (lk->dev, lk->keycode[data], 1);
-                                else
-                                        input_report_key (lk->dev, lk->keycode[data], 0);
-                                input_sync (lk->dev);
-                        } else
-                                printk (KERN_WARNING "%s: Unknown key with "
-                                                "scancode 0x%02x on %s.\n",
-                                                __FILE__, data, lk->name);
+        case LK_ALL_KEYS_UP:
+                for (i = 0; i < ARRAY_SIZE(lkkbd_keycode); i++)
+                        input_report_key(input_dev, lk->keycode[i], 0);
+                input_sync(input_dev);
+                break;
+
+        case 0x01:
+                DBG(KERN_INFO "Got 0x01, scheduling re-initialization\n");
+                lk->ignore_bytes = LK_NUM_IGNORE_BYTES;
+                lk->id[LK_NUM_IGNORE_BYTES - lk->ignore_bytes--] = data;
+                schedule_work(&lk->tq);
+                break;
+
+        case LK_METRONOME:
+        case LK_OUTPUT_ERROR:
+        case LK_INPUT_ERROR:
+        case LK_KBD_LOCKED:
+        case LK_KBD_TEST_MODE_ACK:
+        case LK_PREFIX_KEY_DOWN:
+        case LK_MODE_CHANGE_ACK:
+        case LK_RESPONSE_RESERVED:
+                DBG(KERN_INFO "Got %s and don't know how to handle...\n",
+                        response_name(data));
+                break;
+
+        default:
+                keycode = lk->keycode[data];
+                if (keycode != KEY_RESERVED) {
+                        input_report_key(input_dev, keycode,
+                                         !test_bit(keycode, input_dev->key));
+                        input_sync(input_dev);
+                } else {
+                        printk(KERN_WARNING
+                                "%s: Unknown key with scancode 0x%02x on %s.\n",
+                                __FILE__, data, lk->name);
+                }
         }
 
         return IRQ_HANDLED;
 }
 
+static void lkkbd_toggle_leds(struct lkkbd *lk)
+{
+        struct serio *serio = lk->serio;
+        unsigned char leds_on = 0;
+        unsigned char leds_off = 0;
+
+        CHECK_LED(lk, leds_on, leds_off, LED_CAPSL, LK_LED_SHIFTLOCK);
+        CHECK_LED(lk, leds_on, leds_off, LED_COMPOSE, LK_LED_COMPOSE);
+        CHECK_LED(lk, leds_on, leds_off, LED_SCROLLL, LK_LED_SCROLLLOCK);
+        CHECK_LED(lk, leds_on, leds_off, LED_SLEEP, LK_LED_WAIT);
+        if (leds_on != 0) {
+                serio_write(serio, LK_CMD_LED_ON);
+                serio_write(serio, leds_on);
+        }
+        if (leds_off != 0) {
+                serio_write(serio, LK_CMD_LED_OFF);
+                serio_write(serio, leds_off);
+        }
+}
+
+static void lkkbd_toggle_keyclick(struct lkkbd *lk, bool on)
+{
+        struct serio *serio = lk->serio;
+
+        if (on) {
+                DBG("%s: Activating key clicks\n", __func__);
+                serio_write(serio, LK_CMD_ENABLE_KEYCLICK);
+                serio_write(serio, volume_to_hw(lk->keyclick_volume));
+                serio_write(serio, LK_CMD_ENABLE_CTRCLICK);
+                serio_write(serio, volume_to_hw(lk->ctrlclick_volume));
+        } else {
+                DBG("%s: Deactivating key clicks\n", __func__);
+                serio_write(serio, LK_CMD_DISABLE_KEYCLICK);
+                serio_write(serio, LK_CMD_DISABLE_CTRCLICK);
+        }
+
+}
+
 /*
  * lkkbd_event() handles events from the input module.
  */
-static int
-lkkbd_event (struct input_dev *dev, unsigned int type, unsigned int code,
-                int value)
+static int lkkbd_event(struct input_dev *dev,
+                        unsigned int type, unsigned int code, int value)
 {
-        struct lkkbd *lk = input_get_drvdata (dev);
-        unsigned char leds_on = 0;
-        unsigned char leds_off = 0;
+        struct lkkbd *lk = input_get_drvdata(dev);
 
         switch (type) {
-                case EV_LED:
-                        CHECK_LED (lk, leds_on, leds_off, LED_CAPSL, LK_LED_SHIFTLOCK);
-                        CHECK_LED (lk, leds_on, leds_off, LED_COMPOSE, LK_LED_COMPOSE);
-                        CHECK_LED (lk, leds_on, leds_off, LED_SCROLLL, LK_LED_SCROLLLOCK);
-                        CHECK_LED (lk, leds_on, leds_off, LED_SLEEP, LK_LED_WAIT);
-                        if (leds_on != 0) {
-                                serio_write (lk->serio, LK_CMD_LED_ON);
-                                serio_write (lk->serio, leds_on);
-                        }
-                        if (leds_off != 0) {
-                                serio_write (lk->serio, LK_CMD_LED_OFF);
-                                serio_write (lk->serio, leds_off);
-                        }
+        case EV_LED:
+                lkkbd_toggle_leds(lk);
+                return 0;
+
+        case EV_SND:
+                switch (code) {
+                case SND_CLICK:
+                        lkkbd_toggle_keyclick(lk, value);
                         return 0;
 
-                case EV_SND:
-                        switch (code) {
-                                case SND_CLICK:
-                                        if (value == 0) {
-                                                DBG ("%s: Deactivating key clicks\n", __func__);
-                                                serio_write (lk->serio, LK_CMD_DISABLE_KEYCLICK);
-                                                serio_write (lk->serio, LK_CMD_DISABLE_CTRCLICK);
-                                        } else {
-                                                DBG ("%s: Activating key clicks\n", __func__);
-                                                serio_write (lk->serio, LK_CMD_ENABLE_KEYCLICK);
-                                                serio_write (lk->serio, volume_to_hw (lk->keyclick_volume));
-                                                serio_write (lk->serio, LK_CMD_ENABLE_CTRCLICK);
-                                                serio_write (lk->serio, volume_to_hw (lk->ctrlclick_volume));
-                                        }
-                                        return 0;
-
-                                case SND_BELL:
-                                        if (value != 0)
-                                                serio_write (lk->serio, LK_CMD_SOUND_BELL);
-
-                                        return 0;
-                        }
-                        break;
-
-                default:
-                        printk (KERN_ERR "%s (): Got unknown type %d, code %d, value %d\n",
-                                        __func__, type, code, value);
+                case SND_BELL:
+                        if (value != 0)
+                                serio_write(lk->serio, LK_CMD_SOUND_BELL);
+
+                        return 0;
+                }
+
+                break;
+
+        default:
+                printk(KERN_ERR "%s(): Got unknown type %d, code %d, value %d\n",
+                        __func__, type, code, value);
         }
 
         return -1;
@@ -570,79 +576,56 @@ lkkbd_event (struct input_dev *dev, unsigned int type, unsigned int code,
  * lkkbd_reinit() sets leds and beeps to a state the computer remembers they
  * were in.
  */
-static void
-lkkbd_reinit (struct work_struct *work)
+static void lkkbd_reinit(struct work_struct *work)
 {
         struct lkkbd *lk = container_of(work, struct lkkbd, tq);
         int division;
-        unsigned char leds_on = 0;
-        unsigned char leds_off = 0;
 
         /* Ask for ID */
-        serio_write (lk->serio, LK_CMD_REQUEST_ID);
+        serio_write(lk->serio, LK_CMD_REQUEST_ID);
 
         /* Reset parameters */
-        serio_write (lk->serio, LK_CMD_SET_DEFAULTS);
+        serio_write(lk->serio, LK_CMD_SET_DEFAULTS);
 
         /* Set LEDs */
-        CHECK_LED (lk, leds_on, leds_off, LED_CAPSL, LK_LED_SHIFTLOCK);
-        CHECK_LED (lk, leds_on, leds_off, LED_COMPOSE, LK_LED_COMPOSE);
-        CHECK_LED (lk, leds_on, leds_off, LED_SCROLLL, LK_LED_SCROLLLOCK);
-        CHECK_LED (lk, leds_on, leds_off, LED_SLEEP, LK_LED_WAIT);
-        if (leds_on != 0) {
-                serio_write (lk->serio, LK_CMD_LED_ON);
-                serio_write (lk->serio, leds_on);
-        }
-        if (leds_off != 0) {
-                serio_write (lk->serio, LK_CMD_LED_OFF);
-                serio_write (lk->serio, leds_off);
-        }
+        lkkbd_toggle_leds(lk);
 
         /*
          * Try to activate extended LK401 mode. This command will
          * only work with a LK401 keyboard and grants access to
          * LAlt, RAlt, RCompose and RShift.
          */
-        serio_write (lk->serio, LK_CMD_ENABLE_LK401);
+        serio_write(lk->serio, LK_CMD_ENABLE_LK401);
 
         /* Set all keys to UPDOWN mode */
         for (division = 1; division <= 14; division++)
-                serio_write (lk->serio, LK_CMD_SET_MODE (LK_MODE_UPDOWN,
-                                        division));
+                serio_write(lk->serio,
+                            LK_CMD_SET_MODE(LK_MODE_UPDOWN, division));
 
         /* Enable bell and set volume */
-        serio_write (lk->serio, LK_CMD_ENABLE_BELL);
-        serio_write (lk->serio, volume_to_hw (lk->bell_volume));
+        serio_write(lk->serio, LK_CMD_ENABLE_BELL);
+        serio_write(lk->serio, volume_to_hw(lk->bell_volume));
 
         /* Enable/disable keyclick (and possibly set volume) */
-        if (test_bit (SND_CLICK, lk->dev->snd)) {
-                serio_write (lk->serio, LK_CMD_ENABLE_KEYCLICK);
-                serio_write (lk->serio, volume_to_hw (lk->keyclick_volume));
-                serio_write (lk->serio, LK_CMD_ENABLE_CTRCLICK);
-                serio_write (lk->serio, volume_to_hw (lk->ctrlclick_volume));
-        } else {
-                serio_write (lk->serio, LK_CMD_DISABLE_KEYCLICK);
-                serio_write (lk->serio, LK_CMD_DISABLE_CTRCLICK);
-        }
+        lkkbd_toggle_keyclick(lk, test_bit(SND_CLICK, lk->dev->snd));
 
         /* Sound the bell if needed */
-        if (test_bit (SND_BELL, lk->dev->snd))
-                serio_write (lk->serio, LK_CMD_SOUND_BELL);
+        if (test_bit(SND_BELL, lk->dev->snd))
+                serio_write(lk->serio, LK_CMD_SOUND_BELL);
 }
 
 /*
  * lkkbd_connect() probes for a LK keyboard and fills the necessary structures.
  */
-static int
-lkkbd_connect (struct serio *serio, struct serio_driver *drv)
+static int lkkbd_connect(struct serio *serio, struct serio_driver *drv)
 {
         struct lkkbd *lk;
         struct input_dev *input_dev;
         int i;
         int err;
 
-        lk = kzalloc (sizeof (struct lkkbd), GFP_KERNEL);
-        input_dev = input_allocate_device ();
+        lk = kzalloc(sizeof(struct lkkbd), GFP_KERNEL);
+        input_dev = input_allocate_device();
         if (!lk || !input_dev) {
                 err = -ENOMEM;
                 goto fail1;
@@ -650,14 +633,14 @@ lkkbd_connect (struct serio *serio, struct serio_driver *drv)
 
         lk->serio = serio;
         lk->dev = input_dev;
-        INIT_WORK (&lk->tq, lkkbd_reinit);
+        INIT_WORK(&lk->tq, lkkbd_reinit);
         lk->bell_volume = bell_volume;
         lk->keyclick_volume = keyclick_volume;
         lk->ctrlclick_volume = ctrlclick_volume;
-        memcpy (lk->keycode, lkkbd_keycode, sizeof (lk_keycode_t) * LK_NUM_KEYCODES);
+        memcpy(lk->keycode, lkkbd_keycode, sizeof(lk->keycode));
 
-        strlcpy (lk->name, "DEC LK keyboard", sizeof(lk->name));
-        snprintf (lk->phys, sizeof(lk->phys), "%s/input0", serio->phys);
+        strlcpy(lk->name, "DEC LK keyboard", sizeof(lk->name));
+        snprintf(lk->phys, sizeof(lk->phys), "%s/input0", serio->phys);
 
         input_dev->name = lk->name;
         input_dev->phys = lk->phys;
@@ -668,62 +651,61 @@ lkkbd_connect (struct serio *serio, struct serio_driver *drv)
         input_dev->dev.parent = &serio->dev;
         input_dev->event = lkkbd_event;
 
-        input_set_drvdata (input_dev, lk);
+        input_set_drvdata(input_dev, lk);
 
-        set_bit (EV_KEY, input_dev->evbit);
-        set_bit (EV_LED, input_dev->evbit);
-        set_bit (EV_SND, input_dev->evbit);
-        set_bit (EV_REP, input_dev->evbit);
-        set_bit (LED_CAPSL, input_dev->ledbit);
-        set_bit (LED_SLEEP, input_dev->ledbit);
-        set_bit (LED_COMPOSE, input_dev->ledbit);
-        set_bit (LED_SCROLLL, input_dev->ledbit);
-        set_bit (SND_BELL, input_dev->sndbit);
-        set_bit (SND_CLICK, input_dev->sndbit);
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(EV_LED, input_dev->evbit);
+        __set_bit(EV_SND, input_dev->evbit);
+        __set_bit(EV_REP, input_dev->evbit);
+        __set_bit(LED_CAPSL, input_dev->ledbit);
+        __set_bit(LED_SLEEP, input_dev->ledbit);
+        __set_bit(LED_COMPOSE, input_dev->ledbit);
+        __set_bit(LED_SCROLLL, input_dev->ledbit);
+        __set_bit(SND_BELL, input_dev->sndbit);
+        __set_bit(SND_CLICK, input_dev->sndbit);
 
         input_dev->keycode = lk->keycode;
-        input_dev->keycodesize = sizeof (lk_keycode_t);
-        input_dev->keycodemax = LK_NUM_KEYCODES;
+        input_dev->keycodesize = sizeof(lk->keycode[0]);
+        input_dev->keycodemax = ARRAY_SIZE(lk->keycode);
 
         for (i = 0; i < LK_NUM_KEYCODES; i++)
-                __set_bit (lk->keycode[i], input_dev->keybit);
+                __set_bit(lk->keycode[i], input_dev->keybit);
         __clear_bit(KEY_RESERVED, input_dev->keybit);
 
-        serio_set_drvdata (serio, lk);
+        serio_set_drvdata(serio, lk);
 
-        err = serio_open (serio, drv);
+        err = serio_open(serio, drv);
         if (err)
                 goto fail2;
 
-        err = input_register_device (lk->dev);
+        err = input_register_device(lk->dev);
         if (err)
                 goto fail3;
 
-        serio_write (lk->serio, LK_CMD_POWERCYCLE_RESET);
+        serio_write(lk->serio, LK_CMD_POWERCYCLE_RESET);
 
         return 0;
 
- fail3: serio_close (serio);
- fail2: serio_set_drvdata (serio, NULL);
- fail1: input_free_device (input_dev);
-        kfree (lk);
+ fail3: serio_close(serio);
+ fail2: serio_set_drvdata(serio, NULL);
+ fail1: input_free_device(input_dev);
+        kfree(lk);
         return err;
 }
 
 /*
  * lkkbd_disconnect() unregisters and closes behind us.
  */
-static void
-lkkbd_disconnect (struct serio *serio)
+static void lkkbd_disconnect(struct serio *serio)
 {
-        struct lkkbd *lk = serio_get_drvdata (serio);
-
-        input_get_device (lk->dev);
-        input_unregister_device (lk->dev);
-        serio_close (serio);
-        serio_set_drvdata (serio, NULL);
-        input_put_device (lk->dev);
-        kfree (lk);
+        struct lkkbd *lk = serio_get_drvdata(serio);
+
+        input_get_device(lk->dev);
+        input_unregister_device(lk->dev);
+        serio_close(serio);
+        serio_set_drvdata(serio, NULL);
+        input_put_device(lk->dev);
+        kfree(lk);
 }
 
 static struct serio_device_id lkkbd_serio_ids[] = {
@@ -752,18 +734,16 @@ static struct serio_driver lkkbd_drv = {
 /*
  * The functions for insering/removing us as a module.
  */
-static int __init
-lkkbd_init (void)
+static int __init lkkbd_init(void)
 {
         return serio_register_driver(&lkkbd_drv);
 }
 
-static void __exit
-lkkbd_exit (void)
+static void __exit lkkbd_exit(void)
 {
         serio_unregister_driver(&lkkbd_drv);
 }
 
-module_init (lkkbd_init);
-module_exit (lkkbd_exit);
+module_init(lkkbd_init);
+module_exit(lkkbd_exit);