Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/acpi/dock.c

  1 /*
  2  *  dock.c - ACPI dock station driver
  3  *
  4  *  Copyright (C) 2006, 2014, Intel Corp.
  5  *  Author: Kristen Carlson Accardi <kristen.c.accardi@intel.com>
  6  *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
  7  *
  8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  9  *
 10  *  This program is free software; you can redistribute it and/or modify
 11  *  it under the terms of the GNU General Public License as published by
 12  *  the Free Software Foundation; either version 2 of the License, or (at
 13  *  your option) any later version.
 14  *
 15  *  This program is distributed in the hope that it will be useful, but
 16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
 17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 18  *  General Public License for more details.
 19  *
 20  *  You should have received a copy of the GNU General Public License along
 21  *  with this program; if not, write to the Free Software Foundation, Inc.,
 22  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 23  *
 24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 25  */
 26 
 27 #include <linux/kernel.h>
 28 #include <linux/module.h>
 29 #include <linux/slab.h>
 30 #include <linux/init.h>
 31 #include <linux/types.h>
 32 #include <linux/notifier.h>
 33 #include <linux/platform_device.h>
 34 #include <linux/jiffies.h>
 35 #include <linux/stddef.h>
 36 #include <linux/acpi.h>
 37 
 38 #include "internal.h"
 39 
 40 #define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver"
 41 
 42 ACPI_MODULE_NAME("dock");
 43 MODULE_AUTHOR("Kristen Carlson Accardi");
 44 MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION);
 45 MODULE_LICENSE("GPL");
 46 
 47 static bool immediate_undock = 1;
 48 module_param(immediate_undock, bool, 0644);
 49 MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to "
 50         "undock immediately when the undock button is pressed, 0 will cause"
 51         " the driver to wait for userspace to write the undock sysfs file "
 52         " before undocking");
 53 
 54 struct dock_station {
 55         acpi_handle handle;
 56         unsigned long last_dock_time;
 57         u32 flags;
 58         struct list_head dependent_devices;
 59 
 60         struct list_head sibling;
 61         struct platform_device *dock_device;
 62 };
 63 static LIST_HEAD(dock_stations);
 64 static int dock_station_count;
 65 
 66 struct dock_dependent_device {
 67         struct list_head list;
 68         struct acpi_device *adev;
 69 };
 70 
 71 #define DOCK_DOCKING    0x00000001
 72 #define DOCK_UNDOCKING  0x00000002
 73 #define DOCK_IS_DOCK    0x00000010
 74 #define DOCK_IS_ATA     0x00000020
 75 #define DOCK_IS_BAT     0x00000040
 76 #define DOCK_EVENT      3
 77 #define UNDOCK_EVENT    2
 78 
 79 enum dock_callback_type {
 80         DOCK_CALL_HANDLER,
 81         DOCK_CALL_FIXUP,
 82         DOCK_CALL_UEVENT,
 83 };
 84 
 85 /*****************************************************************************
 86  *                         Dock Dependent device functions                   *
 87  *****************************************************************************/
 88 /**
 89  * add_dock_dependent_device - associate a device with the dock station
 90  * @ds: Dock station.
 91  * @adev: Dependent ACPI device object.
 92  *
 93  * Add the dependent device to the dock's dependent device list.
 94  */
 95 static int add_dock_dependent_device(struct dock_station *ds,
 96                                      struct acpi_device *adev)
 97 {
 98         struct dock_dependent_device *dd;
 99 
100         dd = kzalloc(sizeof(*dd), GFP_KERNEL);
101         if (!dd)
102                 return -ENOMEM;
103 
104         dd->adev = adev;
105         INIT_LIST_HEAD(&dd->list);
106         list_add_tail(&dd->list, &ds->dependent_devices);
107 
108         return 0;
109 }
110 
111 static void dock_hotplug_event(struct dock_dependent_device *dd, u32 event,
112                                enum dock_callback_type cb_type)
113 {
114         struct acpi_device *adev = dd->adev;
115 
116         acpi_lock_hp_context();
117 
118         if (!adev->hp)
119                 goto out;
120 
121         if (cb_type == DOCK_CALL_FIXUP) {
122                 void (*fixup)(struct acpi_device *);
123 
124                 fixup = adev->hp->fixup;
125                 if (fixup) {
126                         acpi_unlock_hp_context();
127                         fixup(adev);
128                         return;
129                 }
130         } else if (cb_type == DOCK_CALL_UEVENT) {
131                 void (*uevent)(struct acpi_device *, u32);
132 
133                 uevent = adev->hp->uevent;
134                 if (uevent) {
135                         acpi_unlock_hp_context();
136                         uevent(adev, event);
137                         return;
138                 }
139         } else {
140                 int (*notify)(struct acpi_device *, u32);
141 
142                 notify = adev->hp->notify;
143                 if (notify) {
144                         acpi_unlock_hp_context();
145                         notify(adev, event);
146                         return;
147                 }
148         }
149 
150  out:
151         acpi_unlock_hp_context();
152 }
153 
154 static struct dock_station *find_dock_station(acpi_handle handle)
155 {
156         struct dock_station *ds;
157 
158         list_for_each_entry(ds, &dock_stations, sibling)
159                 if (ds->handle == handle)
160                         return ds;
161 
162         return NULL;
163 }
164 
165 /**
166  * find_dock_dependent_device - get a device dependent on this dock
167  * @ds: the dock station
168  * @adev: ACPI device object to find.
169  *
170  * iterate over the dependent device list for this dock.  If the
171  * dependent device matches the handle, return.
172  */
173 static struct dock_dependent_device *
174 find_dock_dependent_device(struct dock_station *ds, struct acpi_device *adev)
175 {
176         struct dock_dependent_device *dd;
177 
178         list_for_each_entry(dd, &ds->dependent_devices, list)
179                 if (adev == dd->adev)
180                         return dd;
181 
182         return NULL;
183 }
184 
185 void register_dock_dependent_device(struct acpi_device *adev,
186                                     acpi_handle dshandle)
187 {
188         struct dock_station *ds = find_dock_station(dshandle);
189 
190         if (ds && !find_dock_dependent_device(ds, adev))
191                 add_dock_dependent_device(ds, adev);
192 }
193 
194 /*****************************************************************************
195  *                         Dock functions                                    *
196  *****************************************************************************/
197 
198 /**
199  * is_dock_device - see if a device is on a dock station
200  * @adev: ACPI device object to check.
201  *
202  * If this device is either the dock station itself,
203  * or is a device dependent on the dock station, then it
204  * is a dock device
205  */
206 int is_dock_device(struct acpi_device *adev)
207 {
208         struct dock_station *dock_station;
209 
210         if (!dock_station_count)
211                 return 0;
212 
213         if (acpi_dock_match(adev->handle))
214                 return 1;
215 
216         list_for_each_entry(dock_station, &dock_stations, sibling)
217                 if (find_dock_dependent_device(dock_station, adev))
218                         return 1;
219 
220         return 0;
221 }
222 EXPORT_SYMBOL_GPL(is_dock_device);
223 
224 /**
225  * dock_present - see if the dock station is present.
226  * @ds: the dock station
227  *
228  * execute the _STA method.  note that present does not
229  * imply that we are docked.
230  */
231 static int dock_present(struct dock_station *ds)
232 {
233         unsigned long long sta;
234         acpi_status status;
235 
236         if (ds) {
237                 status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
238                 if (ACPI_SUCCESS(status) && sta)
239                         return 1;
240         }
241         return 0;
242 }
243 
244 /**
245  * hot_remove_dock_devices - Remove dock station devices.
246  * @ds: Dock station.
247  */
248 static void hot_remove_dock_devices(struct dock_station *ds)
249 {
250         struct dock_dependent_device *dd;
251 
252         /*
253          * Walk the list in reverse order so that devices that have been added
254          * last are removed first (in case there are some indirect dependencies
255          * between them).
256          */
257         list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
258                 dock_hotplug_event(dd, ACPI_NOTIFY_EJECT_REQUEST, false);
259 
260         list_for_each_entry_reverse(dd, &ds->dependent_devices, list)
261                 acpi_bus_trim(dd->adev);
262 }
263 
264 /**
265  * hotplug_dock_devices - Insert devices on a dock station.
266  * @ds: the dock station
267  * @event: either bus check or device check request
268  *
269  * Some devices on the dock station need to have drivers called
270  * to perform hotplug operations after a dock event has occurred.
271  * Traverse the list of dock devices that have registered a
272  * hotplug handler, and call the handler.
273  */
274 static void hotplug_dock_devices(struct dock_station *ds, u32 event)
275 {
276         struct dock_dependent_device *dd;
277 
278         /* Call driver specific post-dock fixups. */
279         list_for_each_entry(dd, &ds->dependent_devices, list)
280                 dock_hotplug_event(dd, event, DOCK_CALL_FIXUP);
281 
282         /* Call driver specific hotplug functions. */
283         list_for_each_entry(dd, &ds->dependent_devices, list)
284                 dock_hotplug_event(dd, event, DOCK_CALL_HANDLER);
285 
286         /*
287          * Check if all devices have been enumerated already.  If not, run
288          * acpi_bus_scan() for them and that will cause scan handlers to be
289          * attached to device objects or acpi_drivers to be stopped/started if
290          * they are present.
291          */
292         list_for_each_entry(dd, &ds->dependent_devices, list) {
293                 struct acpi_device *adev = dd->adev;
294 
295                 if (!acpi_device_enumerated(adev)) {
296                         int ret = acpi_bus_scan(adev->handle);
297                         if (ret)
298                                 dev_dbg(&adev->dev, "scan error %d\n", -ret);
299                 }
300         }
301 }
302 
303 static void dock_event(struct dock_station *ds, u32 event, int num)
304 {
305         struct device *dev = &ds->dock_device->dev;
306         char event_string[13];
307         char *envp[] = { event_string, NULL };
308         struct dock_dependent_device *dd;
309 
310         if (num == UNDOCK_EVENT)
311                 sprintf(event_string, "EVENT=undock");
312         else
313                 sprintf(event_string, "EVENT=dock");
314 
315         /*
316          * Indicate that the status of the dock station has
317          * changed.
318          */
319         if (num == DOCK_EVENT)
320                 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
321 
322         list_for_each_entry(dd, &ds->dependent_devices, list)
323                 dock_hotplug_event(dd, event, DOCK_CALL_UEVENT);
324 
325         if (num != DOCK_EVENT)
326                 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
327 }
328 
329 /**
330  * handle_dock - handle a dock event
331  * @ds: the dock station
332  * @dock: to dock, or undock - that is the question
333  *
334  * Execute the _DCK method in response to an acpi event
335  */
336 static void handle_dock(struct dock_station *ds, int dock)
337 {
338         acpi_status status;
339         struct acpi_object_list arg_list;
340         union acpi_object arg;
341         unsigned long long value;
342 
343         acpi_handle_info(ds->handle, "%s\n", dock ? "docking" : "undocking");
344 
345         /* _DCK method has one argument */
346         arg_list.count = 1;
347         arg_list.pointer = &arg;
348         arg.type = ACPI_TYPE_INTEGER;
349         arg.integer.value = dock;
350         status = acpi_evaluate_integer(ds->handle, "_DCK", &arg_list, &value);
351         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
352                 acpi_handle_err(ds->handle, "Failed to execute _DCK (0x%x)\n",
353                                 status);
354 }
355 
356 static inline void dock(struct dock_station *ds)
357 {
358         handle_dock(ds, 1);
359 }
360 
361 static inline void undock(struct dock_station *ds)
362 {
363         handle_dock(ds, 0);
364 }
365 
366 static inline void begin_dock(struct dock_station *ds)
367 {
368         ds->flags |= DOCK_DOCKING;
369 }
370 
371 static inline void complete_dock(struct dock_station *ds)
372 {
373         ds->flags &= ~(DOCK_DOCKING);
374         ds->last_dock_time = jiffies;
375 }
376 
377 static inline void begin_undock(struct dock_station *ds)
378 {
379         ds->flags |= DOCK_UNDOCKING;
380 }
381 
382 static inline void complete_undock(struct dock_station *ds)
383 {
384         ds->flags &= ~(DOCK_UNDOCKING);
385 }
386 
387 /**
388  * dock_in_progress - see if we are in the middle of handling a dock event
389  * @ds: the dock station
390  *
391  * Sometimes while docking, false dock events can be sent to the driver
392  * because good connections aren't made or some other reason.  Ignore these
393  * if we are in the middle of doing something.
394  */
395 static int dock_in_progress(struct dock_station *ds)
396 {
397         if ((ds->flags & DOCK_DOCKING) ||
398             time_before(jiffies, (ds->last_dock_time + HZ)))
399                 return 1;
400         return 0;
401 }
402 
403 /**
404  * handle_eject_request - handle an undock request checking for error conditions
405  *
406  * Check to make sure the dock device is still present, then undock and
407  * hotremove all the devices that may need removing.
408  */
409 static int handle_eject_request(struct dock_station *ds, u32 event)
410 {
411         if (dock_in_progress(ds))
412                 return -EBUSY;
413 
414         /*
415          * here we need to generate the undock
416          * event prior to actually doing the undock
417          * so that the device struct still exists.
418          * Also, even send the dock event if the
419          * device is not present anymore
420          */
421         dock_event(ds, event, UNDOCK_EVENT);
422 
423         hot_remove_dock_devices(ds);
424         undock(ds);
425         acpi_evaluate_lck(ds->handle, 0);
426         acpi_evaluate_ej0(ds->handle);
427         if (dock_present(ds)) {
428                 acpi_handle_err(ds->handle, "Unable to undock!\n");
429                 return -EBUSY;
430         }
431         complete_undock(ds);
432         return 0;
433 }
434 
435 /**
436  * dock_notify - Handle ACPI dock notification.
437  * @adev: Dock station's ACPI device object.
438  * @event: Event code.
439  *
440  * If we are notified to dock, then check to see if the dock is
441  * present and then dock.  Notify all drivers of the dock event,
442  * and then hotplug and devices that may need hotplugging.
443  */
444 int dock_notify(struct acpi_device *adev, u32 event)
445 {
446         acpi_handle handle = adev->handle;
447         struct dock_station *ds = find_dock_station(handle);
448         int surprise_removal = 0;
449 
450         if (!ds)
451                 return -ENODEV;
452 
453         /*
454          * According to acpi spec 3.0a, if a DEVICE_CHECK notification
455          * is sent and _DCK is present, it is assumed to mean an undock
456          * request.
457          */
458         if ((ds->flags & DOCK_IS_DOCK) && event == ACPI_NOTIFY_DEVICE_CHECK)
459                 event = ACPI_NOTIFY_EJECT_REQUEST;
460 
461         /*
462          * dock station: BUS_CHECK - docked or surprise removal
463          *               DEVICE_CHECK - undocked
464          * other device: BUS_CHECK/DEVICE_CHECK - added or surprise removal
465          *
466          * To simplify event handling, dock dependent device handler always
467          * get ACPI_NOTIFY_BUS_CHECK/ACPI_NOTIFY_DEVICE_CHECK for add and
468          * ACPI_NOTIFY_EJECT_REQUEST for removal
469          */
470         switch (event) {
471         case ACPI_NOTIFY_BUS_CHECK:
472         case ACPI_NOTIFY_DEVICE_CHECK:
473                 if (!dock_in_progress(ds) && !acpi_device_enumerated(adev)) {
474                         begin_dock(ds);
475                         dock(ds);
476                         if (!dock_present(ds)) {
477                                 acpi_handle_err(handle, "Unable to dock!\n");
478                                 complete_dock(ds);
479                                 break;
480                         }
481                         hotplug_dock_devices(ds, event);
482                         complete_dock(ds);
483                         dock_event(ds, event, DOCK_EVENT);
484                         acpi_evaluate_lck(ds->handle, 1);
485                         acpi_update_all_gpes();
486                         break;
487                 }
488                 if (dock_present(ds) || dock_in_progress(ds))
489                         break;
490                 /* This is a surprise removal */
491                 surprise_removal = 1;
492                 event = ACPI_NOTIFY_EJECT_REQUEST;
493                 /* Fall back */
494         case ACPI_NOTIFY_EJECT_REQUEST:
495                 begin_undock(ds);
496                 if ((immediate_undock && !(ds->flags & DOCK_IS_ATA))
497                    || surprise_removal)
498                         handle_eject_request(ds, event);
499                 else
500                         dock_event(ds, event, UNDOCK_EVENT);
501                 break;
502         }
503         return 0;
504 }
505 
506 /*
507  * show_docked - read method for "docked" file in sysfs
508  */
509 static ssize_t show_docked(struct device *dev,
510                            struct device_attribute *attr, char *buf)
511 {
512         struct dock_station *dock_station = dev->platform_data;
513         struct acpi_device *adev = NULL;
514 
515         acpi_bus_get_device(dock_station->handle, &adev);
516         return snprintf(buf, PAGE_SIZE, "%u\n", acpi_device_enumerated(adev));
517 }
518 static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
519 
520 /*
521  * show_flags - read method for flags file in sysfs
522  */
523 static ssize_t show_flags(struct device *dev,
524                           struct device_attribute *attr, char *buf)
525 {
526         struct dock_station *dock_station = dev->platform_data;
527         return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags);
528 
529 }
530 static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
531 
532 /*
533  * write_undock - write method for "undock" file in sysfs
534  */
535 static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
536                            const char *buf, size_t count)
537 {
538         int ret;
539         struct dock_station *dock_station = dev->platform_data;
540 
541         if (!count)
542                 return -EINVAL;
543 
544         acpi_scan_lock_acquire();
545         begin_undock(dock_station);
546         ret = handle_eject_request(dock_station, ACPI_NOTIFY_EJECT_REQUEST);
547         acpi_scan_lock_release();
548         return ret ? ret: count;
549 }
550 static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);
551 
552 /*
553  * show_dock_uid - read method for "uid" file in sysfs
554  */
555 static ssize_t show_dock_uid(struct device *dev,
556                              struct device_attribute *attr, char *buf)
557 {
558         unsigned long long lbuf;
559         struct dock_station *dock_station = dev->platform_data;
560         acpi_status status = acpi_evaluate_integer(dock_station->handle,
561                                         "_UID", NULL, &lbuf);
562         if (ACPI_FAILURE(status))
563             return 0;
564 
565         return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf);
566 }
567 static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);
568 
569 static ssize_t show_dock_type(struct device *dev,
570                 struct device_attribute *attr, char *buf)
571 {
572         struct dock_station *dock_station = dev->platform_data;
573         char *type;
574 
575         if (dock_station->flags & DOCK_IS_DOCK)
576                 type = "dock_station";
577         else if (dock_station->flags & DOCK_IS_ATA)
578                 type = "ata_bay";
579         else if (dock_station->flags & DOCK_IS_BAT)
580                 type = "battery_bay";
581         else
582                 type = "unknown";
583 
584         return snprintf(buf, PAGE_SIZE, "%s\n", type);
585 }
586 static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL);
587 
588 static struct attribute *dock_attributes[] = {
589         &dev_attr_docked.attr,
590         &dev_attr_flags.attr,
591         &dev_attr_undock.attr,
592         &dev_attr_uid.attr,
593         &dev_attr_type.attr,
594         NULL
595 };
596 
597 static struct attribute_group dock_attribute_group = {
598         .attrs = dock_attributes
599 };
600 
601 /**
602  * acpi_dock_add - Add a new dock station
603  * @adev: Dock station ACPI device object.
604  *
605  * allocated and initialize a new dock station device.
606  */
607 void acpi_dock_add(struct acpi_device *adev)
608 {
609         struct dock_station *dock_station, ds = { NULL, };
610         struct platform_device_info pdevinfo;
611         acpi_handle handle = adev->handle;
612         struct platform_device *dd;
613         int ret;
614 
615         memset(&pdevinfo, 0, sizeof(pdevinfo));
616         pdevinfo.name = "dock";
617         pdevinfo.id = dock_station_count;
618         pdevinfo.acpi_node.companion = adev;
619         pdevinfo.data = &ds;
620         pdevinfo.size_data = sizeof(ds);
621         dd = platform_device_register_full(&pdevinfo);
622         if (IS_ERR(dd))
623                 return;
624 
625         dock_station = dd->dev.platform_data;
626 
627         dock_station->handle = handle;
628         dock_station->dock_device = dd;
629         dock_station->last_dock_time = jiffies - HZ;
630 
631         INIT_LIST_HEAD(&dock_station->sibling);
632         INIT_LIST_HEAD(&dock_station->dependent_devices);
633 
634         /* we want the dock device to send uevents */
635         dev_set_uevent_suppress(&dd->dev, 0);
636 
637         if (acpi_dock_match(handle))
638                 dock_station->flags |= DOCK_IS_DOCK;
639         if (acpi_ata_match(handle))
640                 dock_station->flags |= DOCK_IS_ATA;
641         if (acpi_device_is_battery(adev))
642                 dock_station->flags |= DOCK_IS_BAT;
643 
644         ret = sysfs_create_group(&dd->dev.kobj, &dock_attribute_group);
645         if (ret)
646                 goto err_unregister;
647 
648         /* add the dock station as a device dependent on itself */
649         ret = add_dock_dependent_device(dock_station, adev);
650         if (ret)
651                 goto err_rmgroup;
652 
653         dock_station_count++;
654         list_add(&dock_station->sibling, &dock_stations);
655         adev->flags.is_dock_station = true;
656         dev_info(&adev->dev, "ACPI dock station (docks/bays count: %d)\n",
657                  dock_station_count);
658         return;
659 
660 err_rmgroup:
661         sysfs_remove_group(&dd->dev.kobj, &dock_attribute_group);
662 
663 err_unregister:
664         platform_device_unregister(dd);
665         acpi_handle_err(handle, "%s encountered error %d\n", __func__, ret);
666 }
667 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us