drivers/platform/x86/dell-rbtn.c

   1 /*
   2     Dell Airplane Mode Switch driver
   3     Copyright (C) 2014-2015  Pali Rohár <[email protected]>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14 */
  15
  16 #include <linux/module.h>
  17 #include <linux/acpi.h>
  18 #include <linux/rfkill.h>
  19 #include <linux/input.h>
  20
  21 enum rbtn_type {
  22         RBTN_UNKNOWN,
  23         RBTN_TOGGLE,
  24         RBTN_SLIDER,
  25 };
  26
  27 struct rbtn_data {
  28         enum rbtn_type type;
  29         struct rfkill *rfkill;
  30         struct input_dev *input_dev;
  31 };
  32
  33
  34 /*
  35  * acpi functions
  36  */
  37
  38 static enum rbtn_type rbtn_check(struct acpi_device *device)
  39 {
  40         unsigned long long output;
  41         acpi_status status;
  42
  43         status = acpi_evaluate_integer(device->handle, "CRBT", NULL, &output);
  44         if (ACPI_FAILURE(status))
  45                 return RBTN_UNKNOWN;
  46
  47         switch (output) {
  48         case 0:
  49         case 1:
  50                 return RBTN_TOGGLE;
  51         case 2:
  52         case 3:
  53                 return RBTN_SLIDER;
  54         default:
  55                 return RBTN_UNKNOWN;
  56         }
  57 }
  58
  59 static int rbtn_get(struct acpi_device *device)
  60 {
  61         unsigned long long output;
  62         acpi_status status;
  63
  64         status = acpi_evaluate_integer(device->handle, "GRBT", NULL, &output);
  65         if (ACPI_FAILURE(status))
  66                 return -EINVAL;
  67
  68         return !output;
  69 }
  70
  71 static int rbtn_acquire(struct acpi_device *device, bool enable)
  72 {
  73         struct acpi_object_list input;
  74         union acpi_object param;
  75         acpi_status status;
  76
  77         param.type = ACPI_TYPE_INTEGER;
  78         param.integer.value = enable;
  79         input.count = 1;
  80         input.pointer = &param;
  81
  82         status = acpi_evaluate_object(device->handle, "ARBT", &input, NULL);
  83         if (ACPI_FAILURE(status))
  84                 return -EINVAL;
  85
  86         return 0;
  87 }
  88
  89
  90 /*
  91  * rfkill device
  92  */
  93
  94 static void rbtn_rfkill_query(struct rfkill *rfkill, void *data)
  95 {
  96         struct acpi_device *device = data;
  97         int state;
  98
  99         state = rbtn_get(device);
 100         if (state < 0)
 101                 return;
 102
 103         rfkill_set_states(rfkill, state, state);
 104 }
 105
 106 static int rbtn_rfkill_set_block(void *data, bool blocked)
 107 {
 108         /* NOTE: setting soft rfkill state is not supported */
 109         return -EINVAL;
 110 }
 111
 112 static struct rfkill_ops rbtn_ops = {
 113         .query = rbtn_rfkill_query,
 114         .set_block = rbtn_rfkill_set_block,
 115 };
 116
 117 static int rbtn_rfkill_init(struct acpi_device *device)
 118 {
 119         struct rbtn_data *rbtn_data = device->driver_data;
 120         int ret;
 121
 122         if (rbtn_data->rfkill)
 123                 return 0;
 124
 125         /*
 126          * NOTE: rbtn controls all radio devices, not only WLAN
 127          *       but rfkill interface does not support "ANY" type
 128          *       so "WLAN" type is used
 129          */
 130         rbtn_data->rfkill = rfkill_alloc("dell-rbtn", &device->dev,
 131                                          RFKILL_TYPE_WLAN, &rbtn_ops, device);
 132         if (!rbtn_data->rfkill)
 133                 return -ENOMEM;
 134
 135         ret = rfkill_register(rbtn_data->rfkill);
 136         if (ret) {
 137                 rfkill_destroy(rbtn_data->rfkill);
 138                 rbtn_data->rfkill = NULL;
 139                 return ret;
 140         }
 141
 142         return 0;
 143 }
 144
 145 static void rbtn_rfkill_exit(struct acpi_device *device)
 146 {
 147         struct rbtn_data *rbtn_data = device->driver_data;
 148
 149         if (!rbtn_data->rfkill)
 150                 return;
 151
 152         rfkill_unregister(rbtn_data->rfkill);
 153         rfkill_destroy(rbtn_data->rfkill);
 154         rbtn_data->rfkill = NULL;
 155 }
 156
 157 static void rbtn_rfkill_event(struct acpi_device *device)
 158 {
 159         struct rbtn_data *rbtn_data = device->driver_data;
 160
 161         if (rbtn_data->rfkill)
 162                 rbtn_rfkill_query(rbtn_data->rfkill, device);
 163 }
 164
 165
 166 /*
 167  * input device
 168  */
 169
 170 static int rbtn_input_init(struct rbtn_data *rbtn_data)
 171 {
 172         int ret;
 173
 174         rbtn_data->input_dev = input_allocate_device();
 175         if (!rbtn_data->input_dev)
 176                 return -ENOMEM;
 177
 178         rbtn_data->input_dev->name = "DELL Wireless hotkeys";
 179         rbtn_data->input_dev->phys = "dellabce/input0";
 180         rbtn_data->input_dev->id.bustype = BUS_HOST;
 181         rbtn_data->input_dev->evbit[0] = BIT(EV_KEY);
 182         set_bit(KEY_RFKILL, rbtn_data->input_dev->keybit);
 183
 184         ret = input_register_device(rbtn_data->input_dev);
 185         if (ret) {
 186                 input_free_device(rbtn_data->input_dev);
 187                 rbtn_data->input_dev = NULL;
 188                 return ret;
 189         }
 190
 191         return 0;
 192 }
 193
 194 static void rbtn_input_exit(struct rbtn_data *rbtn_data)
 195 {
 196         input_unregister_device(rbtn_data->input_dev);
 197         rbtn_data->input_dev = NULL;
 198 }
 199
 200 static void rbtn_input_event(struct rbtn_data *rbtn_data)
 201 {
 202         input_report_key(rbtn_data->input_dev, KEY_RFKILL, 1);
 203         input_sync(rbtn_data->input_dev);
 204         input_report_key(rbtn_data->input_dev, KEY_RFKILL, 0);
 205         input_sync(rbtn_data->input_dev);
 206 }
 207
 208
 209 /*
 210  * acpi driver
 211  */
 212
 213 static int rbtn_add(struct acpi_device *device);
 214 static int rbtn_remove(struct acpi_device *device);
 215 static void rbtn_notify(struct acpi_device *device, u32 event);
 216
 217 static const struct acpi_device_id rbtn_ids[] = {
 218         { "DELRBTN", 0 },
 219         { "DELLABCE", 0 },
 220
 221         /*
 222          * This driver can also handle the "DELLABC6" device that
 223          * appears on the XPS 13 9350, but that device is disabled
 224          * by the DSDT unless booted with acpi_osi="!Windows 2012"
 225          * acpi_osi="!Windows 2013".  Even if we boot that and bind
 226          * the driver, we seem to have inconsistent behavior in
 227          * which NetworkManager can get out of sync with the rfkill
 228          * state.
 229          *
 230          * On the XPS 13 9350 and similar laptops, we're not supposed to
 231          * use DELLABC6 at all.  Instead, we handle the rfkill button
 232          * via the intel-hid driver.
 233          */
 234
 235         { "", 0 },
 236 };
 237
 238 static struct acpi_driver rbtn_driver = {
 239         .name = "dell-rbtn",
 240         .ids = rbtn_ids,
 241         .ops = {
 242                 .add = rbtn_add,
 243                 .remove = rbtn_remove,
 244                 .notify = rbtn_notify,
 245         },
 246         .owner = THIS_MODULE,
 247 };
 248
 249
 250 /*
 251  * notifier export functions
 252  */
 253
 254 static bool auto_remove_rfkill = true;
 255
 256 static ATOMIC_NOTIFIER_HEAD(rbtn_chain_head);
 257
 258 static int rbtn_inc_count(struct device *dev, void *data)
 259 {
 260         struct acpi_device *device = to_acpi_device(dev);
 261         struct rbtn_data *rbtn_data = device->driver_data;
 262         int *count = data;
 263
 264         if (rbtn_data->type == RBTN_SLIDER)
 265                 (*count)++;
 266
 267         return 0;
 268 }
 269
 270 static int rbtn_switch_dev(struct device *dev, void *data)
 271 {
 272         struct acpi_device *device = to_acpi_device(dev);
 273         struct rbtn_data *rbtn_data = device->driver_data;
 274         bool enable = data;
 275
 276         if (rbtn_data->type != RBTN_SLIDER)
 277                 return 0;
 278
 279         if (enable)
 280                 rbtn_rfkill_init(device);
 281         else
 282                 rbtn_rfkill_exit(device);
 283
 284         return 0;
 285 }
 286
 287 int dell_rbtn_notifier_register(struct notifier_block *nb)
 288 {
 289         bool first;
 290         int count;
 291         int ret;
 292
 293         count = 0;
 294         ret = driver_for_each_device(&rbtn_driver.drv, NULL, &count,
 295                                      rbtn_inc_count);
 296         if (ret || count == 0)
 297                 return -ENODEV;
 298
 299         first = !rbtn_chain_head.head;
 300
 301         ret = atomic_notifier_chain_register(&rbtn_chain_head, nb);
 302         if (ret != 0)
 303                 return ret;
 304
 305         if (auto_remove_rfkill && first)
 306                 ret = driver_for_each_device(&rbtn_driver.drv, NULL,
 307                                              (void *)false, rbtn_switch_dev);
 308
 309         return ret;
 310 }
 311 EXPORT_SYMBOL_GPL(dell_rbtn_notifier_register);
 312
 313 int dell_rbtn_notifier_unregister(struct notifier_block *nb)
 314 {
 315         int ret;
 316
 317         ret = atomic_notifier_chain_unregister(&rbtn_chain_head, nb);
 318         if (ret != 0)
 319                 return ret;
 320
 321         if (auto_remove_rfkill && !rbtn_chain_head.head)
 322                 ret = driver_for_each_device(&rbtn_driver.drv, NULL,
 323                                              (void *)true, rbtn_switch_dev);
 324
 325         return ret;
 326 }
 327 EXPORT_SYMBOL_GPL(dell_rbtn_notifier_unregister);
 328
 329
 330 /*
 331  * acpi driver functions
 332  */
 333
 334 static int rbtn_add(struct acpi_device *device)
 335 {
 336         struct rbtn_data *rbtn_data;
 337         enum rbtn_type type;
 338         int ret = 0;
 339
 340         type = rbtn_check(device);
 341         if (type == RBTN_UNKNOWN) {
 342                 dev_info(&device->dev, "Unknown device type\n");
 343                 return -EINVAL;
 344         }
 345
 346         ret = rbtn_acquire(device, true);
 347         if (ret < 0) {
 348                 dev_err(&device->dev, "Cannot enable device\n");
 349                 return ret;
 350         }
 351
 352         rbtn_data = devm_kzalloc(&device->dev, sizeof(*rbtn_data), GFP_KERNEL);
 353         if (!rbtn_data)
 354                 return -ENOMEM;
 355
 356         rbtn_data->type = type;
 357         device->driver_data = rbtn_data;
 358
 359         switch (rbtn_data->type) {
 360         case RBTN_TOGGLE:
 361                 ret = rbtn_input_init(rbtn_data);
 362                 break;
 363         case RBTN_SLIDER:
 364                 if (auto_remove_rfkill && rbtn_chain_head.head)
 365                         ret = 0;
 366                 else
 367                         ret = rbtn_rfkill_init(device);
 368                 break;
 369         default:
 370                 ret = -EINVAL;
 371         }
 372
 373         return ret;
 374
 375 }
 376
 377 static int rbtn_remove(struct acpi_device *device)
 378 {
 379         struct rbtn_data *rbtn_data = device->driver_data;
 380
 381         switch (rbtn_data->type) {
 382         case RBTN_TOGGLE:
 383                 rbtn_input_exit(rbtn_data);
 384                 break;
 385         case RBTN_SLIDER:
 386                 rbtn_rfkill_exit(device);
 387                 break;
 388         default:
 389                 break;
 390         }
 391
 392         rbtn_acquire(device, false);
 393         device->driver_data = NULL;
 394
 395         return 0;
 396 }
 397
 398 static void rbtn_notify(struct acpi_device *device, u32 event)
 399 {
 400         struct rbtn_data *rbtn_data = device->driver_data;
 401
 402         if (event != 0x80) {
 403                 dev_info(&device->dev, "Received unknown event (0x%x)\n",
 404                          event);
 405                 return;
 406         }
 407
 408         switch (rbtn_data->type) {
 409         case RBTN_TOGGLE:
 410                 rbtn_input_event(rbtn_data);
 411                 break;
 412         case RBTN_SLIDER:
 413                 rbtn_rfkill_event(device);
 414                 atomic_notifier_call_chain(&rbtn_chain_head, event, device);
 415                 break;
 416         default:
 417                 break;
 418         }
 419 }
 420
 421
 422 /*
 423  * module functions
 424  */
 425
 426 module_acpi_driver(rbtn_driver);
 427
 428 module_param(auto_remove_rfkill, bool, 0444);
 429
 430 MODULE_PARM_DESC(auto_remove_rfkill, "Automatically remove rfkill devices when "
 431                                      "other modules start receiving events "
 432                                      "from this module and re-add them when "
 433                                      "the last module stops receiving events "
 434                                      "(default true)");
 435 MODULE_DEVICE_TABLE(acpi, rbtn_ids);
 436 MODULE_DESCRIPTION("Dell Airplane Mode Switch driver");
 437 MODULE_AUTHOR("Pali Rohár <[email protected]>");
 438 MODULE_LICENSE("GPL");