Index: head/lib/libdevctl/devctl.3 =================================================================== --- head/lib/libdevctl/devctl.3 (revision 345965) +++ head/lib/libdevctl/devctl.3 (revision 345966) @@ -1,393 +1,437 @@ .\" .\" Copyright (c) 2014 John Baldwin .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .\" $FreeBSD$ .\" -.Dd August 22, 2018 +.Dd April 4, 2019 .Dt DEVCTL 3 .Os .Sh NAME .Nm devctl , .Nm devctl_attach , .Nm devctl_clear_driver , .Nm devctl_delete , .Nm devctl_detach , .Nm devctl_disable , .Nm devctl_enable , .Nm devctl_freeze , .Nm devctl_rescan , +.Nm devctl_reset , .Nm devctl_resume , .Nm devctl_set_driver , .Nm devctl_suspend , .Nm devctl_thaw .Nd device control library .Sh LIBRARY .Lb libdevctl .Sh SYNOPSIS .In devctl.h .Ft int .Fn devctl_attach "const char *device" .Ft int .Fn devctl_clear_driver "const char *device" "bool force" .Ft int .Fn devctl_delete "const char *device" "bool force" .Ft int .Fn devctl_detach "const char *device" "bool force" .Ft int .Fn devctl_disable "const char *device" "bool force_detach" .Ft int .Fn devctl_enable "const char *device" .Ft int .Fn devctl_freeze "void" .Ft int .Fn devctl_rescan "const char *device" .Ft int +.Fn devctl_reset "const char *device" "bool detach" +.Ft int .Fn devctl_resume "const char *device" .Ft int .Fn devctl_set_driver "const char *device" "const char *driver" "bool force" .Ft int .Fn devctl_suspend "const char *device" .Ft int .Fn devctl_thaw "void" .Sh DESCRIPTION The .Nm library adjusts the state of devices in the kernel's internal device hierarchy. Each control operation accepts a .Fa device argument that identifies the device to adjust. The .Fa device may be specified as either the name of an existing device or as a bus-specific address. The following bus-specific address formats are currently supported: .Bl -tag -offset indent .It Sy pci Ns Fa domain Ns : Ns Fa bus Ns : Ns Fa slot Ns : Ns Fa function A PCI device with the specified .Fa domain , .Fa bus , .Fa slot , and .Fa function . .It Sy pci Ns Fa bus Ns : Ns Fa slot Ns : Ns Fa function A PCI device in domain zero with the specified .Fa bus , .Fa slot , and .Fa function . .It Fa handle A device with an ACPI handle of .Fa handle . The handle must be specified as an absolute path and must begin with a .Dq \e . .El .Pp The .Fn devctl_attach function probes a device and attaches a suitable device driver if one is found. .Pp The .Fn devctl_detach function detaches a device from its current device driver. The device is left detached until either a new driver for its parent bus is loaded or the device is explicitly probed via .Fn devctl_attach . If .Fa force is true, the current device driver will be detached even if the device is busy. .Pp The .Fn devctl_delete function deletes a device from the device tree. No If .Fa force is true, the device is deleted even if the device is physically present. .Pp The .Fn devctl_disable function disables a device. If the device is currently attached to a device driver, the device driver will be detached from the device, but the device will retain its current name. If .Fa force_detach is true, the current device driver will be detached even if the device is busy. The device will remain disabled and detached until it is explicitly enabled via .Fn devctl_enable . .Pp The .Fn devctl_enable function re-enables a disabled device. The device will probe and attach if a suitable device driver is found. .Pp The .Fn devctl_suspend function suspends a device. This may include placing the device in a reduced power state, but any device driver currently attached to the device will remain attached. .Pp The .Fn devctl_resume function resumes a suspended device to a fully working state. .Pp The .Fn devctl_set_driver function attaches a device driver named .Fa driver to a device. If the device is already attached and .Fa force is false, the request will fail. If the device is already attached and .Fa force is true, the device will be detached from its current device driver before it is attached to the new device driver. .Pp The .Fn devctl_clear_driver function resets a device so that it can be attached to any valid device driver rather than only drivers with a previously specified name. This function is used to undo a previous call to .Fn devctl_set_driver . If the device is already attached and .Fa force is false, the request will fail. If the device is already attached and .Fa force is true, the device will be detached from its current device driver. After the device's name is reset, it is reprobed and attached to a suitable device driver if one is found. .Pp The .Fn devctl_rescan function rescans a bus device checking for devices that have been added or removed. .Pp The .Fn devctl_freeze function freezes probe and attach processing initiated in response to drivers being loaded. .Pp The .Fn devctl_thaw function resumes (thaws the freeze) probe and attach processing initiated in response to drivers being loaded. +.Pp +The +.Fn devctl_reset +function resets the specified device using bus-specific reset method. +The +.Fa detach +argument, if true, specifies that the device driver is detached before +the reset, and re-attached afterwards. +If false, the device is suspended before the reset, and resumed after. .Sh RETURN VALUES .Rv -std devctl_attach devctl_clear_driver devctl_delete devctl_detach \ devctl_disable devctl_enable devctl_suspend devctl_rescan devctl_resume \ devctl_set_driver .Sh ERRORS In addition to specific errors noted below, all of the .Nm functions may fail for any of the errors described in .Xr open 2 as well as: .Bl -tag -width Er .It Bq Er EINVAL The device name is too long. .It Bq Er ENOENT No existing device matches the specified name or location. .It Bq Er EPERM The current process is not permitted to adjust the state of .Fa device . .El .Pp The .Fn devctl_attach function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The device is already attached. .It Bq Er ENOMEM An internal memory allocation request failed. .It Bq Er ENXIO The device is disabled. .It Bq Er ENXIO No suitable driver for the device could be found, or the driver failed to attach. .El .Pp The .Fn devctl_detach function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The current device driver for .Fa device is busy and cannot detach at this time. Note that some drivers may return this even if .Fa force is true. .It Bq Er ENXIO The device is not attached to a driver. .It Bq Er ENXIO The current device driver for .Fa device does not support detaching. .El .Pp The .Fn devctl_enable function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The device is already enabled. .It Bq Er ENOMEM An internal memory allocation request failed. .It Bq Er ENXIO No suitable driver for the device could be found, or the driver failed to attach. .El .Pp The .Fn devctl_disable function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The current device driver for .Fa device is busy and cannot detach at this time. Note that some drivers may return this even if .Fa force_detach is true. .It Bq Er ENXIO The device is already disabled. .It Bq Er ENXIO The current device driver for .Fa device does not support detaching. .El .Pp The .Fn devctl_suspend function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The device is already suspended. .It Bq Er EINVAL The device to be suspended is the root bus device. .El .Pp The .Fn devctl_resume function may fail if: .Bl -tag -width Er .It Bq Er EINVAL The device is not suspended. .It Bq Er EINVAL The device to be resumed is the root bus device. .El .Pp The .Fn devctl_set_driver function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The device is currently attached to a device driver and .Fa force is false. .It Bq Er EBUSY The current device driver for .Fa device is busy and cannot detach at this time. .It Bq Er EFAULT The .Fa driver argument points outside the process' allocated address space. .It Bq Er ENOENT No device driver with the requested name exists. .It Bq Er ENOMEM An internal memory allocation request failed. .It Bq Er ENXIO The device is disabled. .It Bq Er ENXIO The new device driver failed to attach. .El .Pp The .Fn devctl_clear_driver function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The device is currently attached to a device driver and .Fa force is false. .It Bq Er EBUSY The current device driver for .Fa device is busy and cannot detach at this time. .It Bq Er EINVAL The device is not configured for a specific device driver name. .It Bq Er ENXIO The device driver chosen after reprobing failed to attach. .El .Pp The .Fn devctl_rescan function may fail if: .Bl -tag -width Er .It Bq Er ENXIO The device is not attached to a driver. .It Bq Er ENXIO The bus driver does not support rescanning. .El .Pp The .Fn devctl_delete function may fail if: .Bl -tag -width Er .It Bq Er EBUSY The device is physically present and .Fa force is false. .It Bq Er EINVAL .Fa dev is the root device of the device tree. .El +.Pp +The +.Fn devctl_reset +function may fail if: +.Bl -tag -width Er +.It Bq Er ENXIO +The bus does not implement the reset method. +.It Bq Er ETIMEDOUT +The device failed to respond after the reset in the time limits +specific to the bus. +.El +The +.Fn devctl_reset +function may also return errors caused by the attach, detach, suspend, +and resume methods of the device driver. .Sh SEE ALSO .Xr devinfo 3 , .Xr devstat 3 , .Xr devctl 8 .Sh HISTORY The .Nm library first appeared in .Fx 10.3 . .Sh BUGS If a device is suspended individually via .Fn devctl_suspend and the entire machine is subsequently suspended, the device will be resumed when the machine resumes. +.Pp +Similarly, if the device is suspended, and +.Fn devctl_reset +is called on the device with +.Fa detach +set to +.Va false , +the device is resumed by the +.Fn devctl_reset +call. +Or, if the driver for the device is detached manually, and +.Fn devctl_reset +is called on the device with +.Fa detach +set to +.Va true , +device reset re-attaches the driver. Index: head/lib/libdevctl/devctl.c =================================================================== --- head/lib/libdevctl/devctl.c (revision 345965) +++ head/lib/libdevctl/devctl.c (revision 345966) @@ -1,160 +1,168 @@ /*- * Copyright (c) 2014 John Baldwin * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include "devctl.h" static int devctl_request(u_long cmd, struct devreq *req) { static int devctl2_fd = -1; if (devctl2_fd == -1) { devctl2_fd = open("/dev/devctl2", O_RDONLY); if (devctl2_fd == -1) return (-1); } return (ioctl(devctl2_fd, cmd, req)); } static int devctl_simple_request(u_long cmd, const char *name, int flags) { struct devreq req; memset(&req, 0, sizeof(req)); if (strlcpy(req.dr_name, name, sizeof(req.dr_name)) >= sizeof(req.dr_name)) { errno = EINVAL; return (-1); } req.dr_flags = flags; return (devctl_request(cmd, &req)); } int devctl_attach(const char *device) { return (devctl_simple_request(DEV_ATTACH, device, 0)); } int devctl_detach(const char *device, bool force) { return (devctl_simple_request(DEV_DETACH, device, force ? DEVF_FORCE_DETACH : 0)); } int devctl_enable(const char *device) { return (devctl_simple_request(DEV_ENABLE, device, 0)); } int devctl_disable(const char *device, bool force_detach) { return (devctl_simple_request(DEV_DISABLE, device, force_detach ? DEVF_FORCE_DETACH : 0)); } int devctl_suspend(const char *device) { return (devctl_simple_request(DEV_SUSPEND, device, 0)); } int devctl_resume(const char *device) { return (devctl_simple_request(DEV_RESUME, device, 0)); } int devctl_set_driver(const char *device, const char *driver, bool force) { struct devreq req; memset(&req, 0, sizeof(req)); if (strlcpy(req.dr_name, device, sizeof(req.dr_name)) >= sizeof(req.dr_name)) { errno = EINVAL; return (-1); } req.dr_data = __DECONST(char *, driver); if (force) req.dr_flags |= DEVF_SET_DRIVER_DETACH; return (devctl_request(DEV_SET_DRIVER, &req)); } int devctl_clear_driver(const char *device, bool force) { return (devctl_simple_request(DEV_CLEAR_DRIVER, device, force ? DEVF_CLEAR_DRIVER_DETACH : 0)); } int devctl_rescan(const char *device) { return (devctl_simple_request(DEV_RESCAN, device, 0)); } int devctl_delete(const char *device, bool force) { return (devctl_simple_request(DEV_DELETE, device, force ? DEVF_FORCE_DELETE : 0)); } int devctl_freeze(void) { return (devctl_simple_request(DEV_FREEZE, "", 0)); } int devctl_thaw(void) { return (devctl_simple_request(DEV_THAW, "", 0)); } + +int +devctl_reset(const char *device, bool detach) +{ + + return (devctl_simple_request(DEV_RESET, device, detach ? + DEVF_RESET_DETACH : 0)); +} Index: head/lib/libdevctl/devctl.h =================================================================== --- head/lib/libdevctl/devctl.h (revision 345965) +++ head/lib/libdevctl/devctl.h (revision 345966) @@ -1,48 +1,49 @@ /*- * Copyright (c) 2014 John Baldwin * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef __DEVCTL_H__ #define __DEVCTL_H__ #include __BEGIN_DECLS int devctl_attach(const char *device); int devctl_detach(const char *device, bool force); int devctl_enable(const char *device); int devctl_disable(const char *device, bool force_detach); int devctl_suspend(const char *device); int devctl_resume(const char *device); int devctl_set_driver(const char *device, const char *driver, bool force); int devctl_clear_driver(const char *device, bool force); int devctl_rescan(const char *device); int devctl_delete(const char *device, bool force); int devctl_freeze(void); int devctl_thaw(void); +int devctl_reset(const char *device, bool detach); __END_DECLS #endif /* !__DEVCTL_H__ */ Index: head/usr.sbin/devctl/devctl.8 =================================================================== --- head/usr.sbin/devctl/devctl.8 (revision 345965) +++ head/usr.sbin/devctl/devctl.8 (revision 345966) @@ -1,177 +1,209 @@ .\" .\" Copyright (c) 2015 John Baldwin .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .\" $FreeBSD$ .\" -.Dd August 29, 2016 +.Dd April 4, 2019 .Dt DEVCTL 8 .Os .Sh NAME .Nm devctl .Nd device control utility .Sh SYNOPSIS .Nm .Cm attach .Ar device .Nm .Cm clear driver .Op Fl f .Ar device .Nm .Cm detach .Op Fl f .Ar device .Nm .Cm disable .Op Fl f .Ar device .Nm .Cm enable .Ar device .Nm .Cm suspend .Ar device .Nm .Cm resume .Ar device .Nm .Cm set driver .Op Fl f .Ar device driver .Nm .Cm rescan .Ar device .Nm .Cm delete .Op Fl f .Ar device +.Nm +.Cm reset +.Op Fl d +.Ar device .Sh DESCRIPTION The .Nm utility adjusts the state of individual devices in the kernel's internal device hierarchy. Each invocation of .Nm consists of a single command followed by command-specific arguments. Each command operates on a single device specified via the .Ar device argument. The .Ar device may be specified either as the name of an existing device or as a bus-specific address. More details on supported address formats can be found in .Xr devctl 3 . .Pp The following commands are supported: .Bl -tag -width indent .It Cm attach Ar device Force the kernel to re-probe the device. If a suitable driver is found, it is attached to the device. .It Xo Cm detach .Op Fl f .Ar device .Xc Detach the device from its current device driver. If the .Fl f flag is specified, the device driver will be detached even if the device is busy. .It Xo Cm disable .Op Fl f .Ar device .Xc Disable a device. If the device is currently attached to a device driver, the device driver will be detached from the device, but the device will retain its current name. If the .Fl f flag is specified, the device driver will be detached even if the device is busy. .It Cm enable Ar device Enable a device. The device will probe and attach if a suitable device driver is found. Note that this can re-enable a device disabled at boot time via a loader tunable. .It Cm suspend Ar device Suspend a device. This may include placing the device in a reduced power state. .It Cm resume Ar device Resume a suspended device to a fully working state. .It Xo Cm set driver .Op Fl f .Ar device driver .Xc Force the device to use a device driver named .Ar driver . If the device is already attached to a device driver and the .Fl f flag is specified, the device will be detached from its current device driver before it is attached to the new device driver. If the device is already attached to a device driver and the .Fl f flag is not specified, the device will not be changed. .It Xo Cm clear driver .Op Fl f .Ar device .Xc Clear a previously-forced driver name so that the device is able to use any valid device driver. After the previous name has been cleared, the device is reprobed so that other device drivers may attach to it. This can be used to undo an earlier .Cm set driver command. If the device is currently attached to a device driver and the .Fl f flag is not specified, the device will not be changed. .It Cm rescan Ar device Rescan a bus device checking for devices that have been added or removed. .It Xo Cm delete .Op Fl f .Ar device .Xc Delete the device from the device tree. If the .Fl f flag is specified, the device will be deleted even if it is physically present. This command should be used with care as a device that is deleted but present can no longer be used unless the parent bus device rediscovers the device via a rescan request. +.It Xo Cm reset +.Op Fl d +.Ar device +.Xc +Reset the device, using bus-specific reset method. +Drivers for the devices being reset are suspended around the reset. +If the +.Fl d +option is specified, drivers are detached instead. +.Pp +Currently, resets are implemented for PCIe buses and PCI devices. +For PCIe bus, the link is disabled and then re-trained, causing all +children of the bus to reset. +Use +.Fl p +option of +.Xr devinfo 8 +tool to report parent bus for the device. +For PCI device, if Function-Level Reset is implemented by it, FLR is +tried first; if failed or not implemented, power reset is tried. +.Pp +If you have detached or suspended a child device explicitly and then +do a reset, the child device will end up attached. .El +.Sh BUGS +Currently there is no administrative flag to prevent re-attach or resume +of the manually detached or suspended devices after reset. +Similarly, there is no flag to prevent un-suspending of the the manually +suspended devices after system resume. .Sh SEE ALSO .Xr devctl 3 , .Xr devinfo 8 .Sh HISTORY The .Nm utility first appeared in .Fx 10.3 . Index: head/usr.sbin/devctl/devctl.c =================================================================== --- head/usr.sbin/devctl/devctl.c (revision 345965) +++ head/usr.sbin/devctl/devctl.c (revision 345966) @@ -1,407 +1,443 @@ /*- * Copyright (c) 2014 John Baldwin * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include struct devctl_command { const char *name; int (*handler)(int ac, char **av); }; #define DEVCTL_DATASET(name) devctl_ ## name ## _table #define DEVCTL_COMMAND(set, name, function) \ static struct devctl_command function ## _devctl_command = \ { #name, function }; \ DATA_SET(DEVCTL_DATASET(set), function ## _devctl_command) #define DEVCTL_TABLE(set, name) \ SET_DECLARE(DEVCTL_DATASET(name), struct devctl_command); \ \ static int \ devctl_ ## name ## _table_handler(int ac, char **av) \ { \ return (devctl_table_handler(SET_BEGIN(DEVCTL_DATASET(name)), \ SET_LIMIT(DEVCTL_DATASET(name)), ac, av)); \ } \ DEVCTL_COMMAND(set, name, devctl_ ## name ## _table_handler) static int devctl_table_handler(struct devctl_command **start, struct devctl_command **end, int ac, char **av); SET_DECLARE(DEVCTL_DATASET(top), struct devctl_command); DEVCTL_TABLE(top, clear); DEVCTL_TABLE(top, set); static void usage(void) { fprintf(stderr, "usage: devctl attach device\n" " devctl detach [-f] device\n" " devctl disable [-f] device\n" " devctl enable device\n" " devctl suspend device\n" " devctl resume device\n" " devctl set driver [-f] device driver\n" " devctl clear driver [-f] device\n" " devctl rescan device\n" " devctl delete [-f] device\n" " devctl freeze\n" - " devctl thaw\n"); + " devctl thaw\n" + " devctl reset [-d] device\n" + ); exit(1); } static int devctl_table_handler(struct devctl_command **start, struct devctl_command **end, int ac, char **av) { struct devctl_command **cmd; if (ac < 2) { warnx("The %s command requires a sub-command.", av[0]); return (EINVAL); } for (cmd = start; cmd < end; cmd++) { if (strcmp((*cmd)->name, av[1]) == 0) return ((*cmd)->handler(ac - 1, av + 1)); } warnx("%s is not a valid sub-command of %s.", av[1], av[0]); return (ENOENT); } static int help(int ac __unused, char **av __unused) { usage(); return (0); } DEVCTL_COMMAND(top, help, help); static int attach(int ac, char **av) { if (ac != 2) usage(); if (devctl_attach(av[1]) < 0) err(1, "Failed to attach %s", av[1]); return (0); } DEVCTL_COMMAND(top, attach, attach); static void detach_usage(void) { fprintf(stderr, "usage: devctl detach [-f] device\n"); exit(1); } static int detach(int ac, char **av) { bool force; int ch; force = false; while ((ch = getopt(ac, av, "f")) != -1) switch (ch) { case 'f': force = true; break; default: detach_usage(); } ac -= optind; av += optind; if (ac != 1) detach_usage(); if (devctl_detach(av[0], force) < 0) err(1, "Failed to detach %s", av[0]); return (0); } DEVCTL_COMMAND(top, detach, detach); static void disable_usage(void) { fprintf(stderr, "usage: devctl disable [-f] device\n"); exit(1); } static int disable(int ac, char **av) { bool force; int ch; force = false; while ((ch = getopt(ac, av, "f")) != -1) switch (ch) { case 'f': force = true; break; default: disable_usage(); } ac -= optind; av += optind; if (ac != 1) disable_usage(); if (devctl_disable(av[0], force) < 0) err(1, "Failed to disable %s", av[0]); return (0); } DEVCTL_COMMAND(top, disable, disable); static int enable(int ac, char **av) { if (ac != 2) usage(); if (devctl_enable(av[1]) < 0) err(1, "Failed to enable %s", av[1]); return (0); } DEVCTL_COMMAND(top, enable, enable); static int suspend(int ac, char **av) { if (ac != 2) usage(); if (devctl_suspend(av[1]) < 0) err(1, "Failed to suspend %s", av[1]); return (0); } DEVCTL_COMMAND(top, suspend, suspend); static int resume(int ac, char **av) { if (ac != 2) usage(); if (devctl_resume(av[1]) < 0) err(1, "Failed to resume %s", av[1]); return (0); } DEVCTL_COMMAND(top, resume, resume); static void set_driver_usage(void) { fprintf(stderr, "usage: devctl set driver [-f] device driver\n"); exit(1); } static int set_driver(int ac, char **av) { bool force; int ch; force = false; while ((ch = getopt(ac, av, "f")) != -1) switch (ch) { case 'f': force = true; break; default: set_driver_usage(); } ac -= optind; av += optind; if (ac != 2) set_driver_usage(); if (devctl_set_driver(av[0], av[1], force) < 0) err(1, "Failed to set %s driver to %s", av[0], av[1]); return (0); } DEVCTL_COMMAND(set, driver, set_driver); static void clear_driver_usage(void) { fprintf(stderr, "usage: devctl clear driver [-f] device\n"); exit(1); } static int clear_driver(int ac, char **av) { bool force; int ch; force = false; while ((ch = getopt(ac, av, "f")) != -1) switch (ch) { case 'f': force = true; break; default: clear_driver_usage(); } ac -= optind; av += optind; if (ac != 1) clear_driver_usage(); if (devctl_clear_driver(av[0], force) < 0) err(1, "Failed to clear %s driver", av[0]); return (0); } DEVCTL_COMMAND(clear, driver, clear_driver); static int rescan(int ac, char **av) { if (ac != 2) usage(); if (devctl_rescan(av[1]) < 0) err(1, "Failed to rescan %s", av[1]); return (0); } DEVCTL_COMMAND(top, rescan, rescan); static void delete_usage(void) { fprintf(stderr, "usage: devctl delete [-f] device\n"); exit(1); } static int delete(int ac, char **av) { bool force; int ch; force = false; while ((ch = getopt(ac, av, "f")) != -1) switch (ch) { case 'f': force = true; break; default: delete_usage(); } ac -= optind; av += optind; if (ac != 1) delete_usage(); if (devctl_delete(av[0], force) < 0) err(1, "Failed to delete %s", av[0]); return (0); } DEVCTL_COMMAND(top, delete, delete); static void freeze_usage(void) { fprintf(stderr, "usage: devctl freeze\n"); exit(1); } static int freeze(int ac, char **av __unused) { if (ac != 1) freeze_usage(); if (devctl_freeze() < 0) err(1, "Failed to freeze probe/attach"); return (0); } DEVCTL_COMMAND(top, freeze, freeze); static void thaw_usage(void) { fprintf(stderr, "usage: devctl thaw\n"); exit(1); } static int thaw(int ac, char **av __unused) { if (ac != 1) thaw_usage(); if (devctl_thaw() < 0) err(1, "Failed to thaw probe/attach"); return (0); } DEVCTL_COMMAND(top, thaw, thaw); + +static void +reset_usage(void) +{ + + fprintf(stderr, "usage: devctl reset [-d] device\n"); + exit(1); +} + +static int +reset(int ac, char **av) +{ + bool detach; + int ch; + + detach = false; + while ((ch = getopt(ac, av, "d")) != -1) + switch (ch) { + case 'd': + detach = true; + break; + default: + reset_usage(); + } + ac -= optind; + av += optind; + + if (ac != 1) + reset_usage(); + if (devctl_reset(av[0], detach) < 0) + err(1, "Failed to reset %s", av[0]); + return (0); +} +DEVCTL_COMMAND(top, reset, reset); int main(int ac, char *av[]) { struct devctl_command **cmd; if (ac == 1) usage(); ac--; av++; SET_FOREACH(cmd, DEVCTL_DATASET(top)) { if (strcmp((*cmd)->name, av[0]) == 0) { if ((*cmd)->handler(ac, av) != 0) return (1); else return (0); } } warnx("Unknown command %s.", av[0]); return (1); }