[S390] cio: Add docbook comments. (b2ffd8e9) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/s390/cio/ccwgroup.c

+50 −17

Original line number	Diff line number	Diff line
		@@ -152,16 +152,24 @@ __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
		return 0;
		}

		/*
		* try to add a new ccwgroup device for one driver
		* argc and argv[] are a list of bus_id's of devices
		* belonging to the driver.
		/**
		* ccwgroup_create() - create and register a ccw group device
		* @root: parent device for the new device
		* @creator_id: identifier of creating driver
		* @cdrv: ccw driver of slave devices
		* @argc: number of slave devices
		* @argv: bus ids of slave devices
		*
		* Create and register a new ccw group device as a child of @root. Slave
		* devices are obtained from the list of bus ids given in @argv[] and must all
		* belong to @cdrv.
		* Returns:
		* %0 on success and an error code on failure.
		* Context:
		* non-atomic
		*/
		int
		ccwgroup_create(struct device *root,
		unsigned int creator_id,
		struct ccw_driver *cdrv,
		int argc, char *argv[])
		int ccwgroup_create(struct device *root, unsigned int creator_id,
		struct ccw_driver cdrv, int argc, char argv[])
		{
		struct ccwgroup_device *gdev;
		int i;
		@@ -390,8 +398,13 @@ static struct bus_type ccwgroup_bus_type = {
		.remove = ccwgroup_remove,
		};

		int
		ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
		/**
		* ccwgroup_driver_register() - register a ccw group driver
		* @cdriver: driver to be registered
		*
		* This function is mainly a wrapper around driver_register().
		*/
		int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
		{
		/* register our new driver with the core */
		cdriver->driver.bus = &ccwgroup_bus_type;
		@@ -406,8 +419,13 @@ __ccwgroup_match_all(struct device dev, void data)
		return 1;
		}

		void
		ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
		/**
		* ccwgroup_driver_unregister() - deregister a ccw group driver
		* @cdriver: driver to be deregistered
		*
		* This function is mainly a wrapper around driver_unregister().
		*/
		void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
		{
		struct device *dev;

		@@ -427,8 +445,16 @@ ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
		driver_unregister(&cdriver->driver);
		}

		int
		ccwgroup_probe_ccwdev(struct ccw_device *cdev)
		/**
		* ccwgroup_probe_ccwdev() - probe function for slave devices
		* @cdev: ccw device to be probed
		*
		* This is a dummy probe function for ccw devices that are slave devices in
		* a ccw group device.
		* Returns:
		* always %0
		*/
		int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
		{
		return 0;
		}
		@@ -452,8 +478,15 @@ __ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
		return NULL;
		}

		void
		ccwgroup_remove_ccwdev(struct ccw_device *cdev)
		/**
		* ccwgroup_remove_ccwdev() - remove function for slave devices
		* @cdev: ccw device to be removed
		*
		* This is a remove function for ccw devices that are slave devices in a ccw
		* group device. It sets the ccw device offline and also deregisters the
		* embedding ccw group device.
		*/
		void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
		{
		struct ccwgroup_device *gdev;

drivers/s390/cio/device.c

+54 −10

Original line number	Diff line number	Diff line
		@@ -357,8 +357,18 @@ ccw_device_remove_disconnected(struct ccw_device *cdev)
		cdev->private->dev_id.devno);
		}

		int
		ccw_device_set_offline(struct ccw_device *cdev)
		/**
		* ccw_device_set_offline() - disable a ccw device for I/O
		* @cdev: target ccw device
		*
		* This function calls the driver's set_offline() function for @cdev, if
		* given, and then disables @cdev.
		* Returns:
		* %0 on success and a negative error value on failure.
		* Context:
		* enabled, ccw device lock not held
		*/
		int ccw_device_set_offline(struct ccw_device *cdev)
		{
		int ret;

		@@ -396,8 +406,19 @@ ccw_device_set_offline(struct ccw_device *cdev)
		return ret;
		}

		int
		ccw_device_set_online(struct ccw_device *cdev)
		/**
		* ccw_device_set_online() - enable a ccw device for I/O
		* @cdev: target ccw device
		*
		* This function first enables @cdev and then calls the driver's set_online()
		* function for @cdev, if given. If set_online() returns an error, @cdev is
		* disabled again.
		* Returns:
		* %0 on success and a negative error value on failure.
		* Context:
		* enabled, ccw device lock not held
		*/
		int ccw_device_set_online(struct ccw_device *cdev)
		{
		int ret;

		@@ -1326,8 +1347,19 @@ __ccwdev_check_busid(struct device dev, void id)
		}


		struct ccw_device *
		get_ccwdev_by_busid(struct ccw_driver cdrv, const char bus_id)
		/**
		* get_ccwdev_by_busid() - obtain device from a bus id
		* @cdrv: driver the device is owned by
		* @bus_id: bus id of the device to be searched
		*
		* This function searches all devices owned by @cdrv for a device with a bus
		* id matching @bus_id.
		* Returns:
		* If a match is found, its reference count of the found device is increased
		* and it is returned; else %NULL is returned.
		*/
		struct ccw_device get_ccwdev_by_busid(struct ccw_driver cdrv,
		const char *bus_id)
		{
		struct device *dev;
		struct device_driver *drv;
		@@ -1409,8 +1441,15 @@ struct bus_type ccw_bus_type = {
		.remove = ccw_device_remove,
		};

		int
		ccw_driver_register (struct ccw_driver *cdriver)
		/**
		* ccw_driver_register() - register a ccw driver
		* @cdriver: driver to be registered
		*
		* This function is mainly a wrapper around driver_register().
		* Returns:
		* %0 on success and a negative error value on failure.
		*/
		int ccw_driver_register(struct ccw_driver *cdriver)
		{
		struct device_driver *drv = &cdriver->driver;

		@@ -1420,8 +1459,13 @@ ccw_driver_register (struct ccw_driver *cdriver)
		return driver_register(drv);
		}

		void
		ccw_driver_unregister (struct ccw_driver *cdriver)
		/**
		* ccw_driver_unregister() - deregister a ccw driver
		* @cdriver: driver to be deregistered
		*
		* This function is mainly a wrapper around driver_unregister().
		*/
		void ccw_driver_unregister(struct ccw_driver *cdriver)
		{
		driver_unregister(&cdriver->driver);
		}

drivers/s390/cio/device_ops.c

+211 −30

Original line number	Diff line number	Diff line
		@@ -25,6 +25,16 @@
		#include "device.h"
		#include "chp.h"

		/**
		* ccw_device_set_options_mask() - set some options and unset the rest
		* @cdev: device for which the options are to be set
		* @flags: options to be set
		*
		* All flags specified in @flags are set, all flags not specified in @flags
		* are cleared.
		* Returns:
		* %0 on success, -%EINVAL on an invalid flag combination.
		*/
		int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
		{
		/*
		@@ -40,6 +50,15 @@ int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
		return 0;
		}

		/**
		* ccw_device_set_options() - set some options
		* @cdev: device for which the options are to be set
		* @flags: options to be set
		*
		* All flags specified in @flags are set, the remainder is left untouched.
		* Returns:
		* %0 on success, -%EINVAL if an invalid flag combination would ensue.
		*/
		int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
		{
		/*
		@@ -59,6 +78,13 @@ int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
		return 0;
		}

		/**
		* ccw_device_clear_options() - clear some options
		* @cdev: device for which the options are to be cleared
		* @flags: options to be cleared
		*
		* All flags specified in @flags are cleared, the remainder is left untouched.
		*/
		void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
		{
		cdev->private->options.fast &= (flags & CCWDEV_EARLY_NOTIFICATION) == 0;
		@@ -67,8 +93,22 @@ void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
		cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
		}

		int
		ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
		/**
		* ccw_device_clear() - terminate I/O request processing
		* @cdev: target ccw device
		* @intparm: interruption parameter; value is only used if no I/O is
		* outstanding, otherwise the intparm associated with the I/O request
		* is returned
		*
		* ccw_device_clear() calls csch on @cdev's subchannel.
		* Returns:
		* %0 on success,
		* -%ENODEV on device not operational,
		* -%EINVAL on invalid device state.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
		{
		struct subchannel *sch;
		int ret;
		@@ -89,8 +129,31 @@ ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
		return ret;
		}

		int
		ccw_device_start_key(struct ccw_device cdev, struct ccw1 cpa,
		/**
		* ccw_device_start_key() - start a s390 channel program with key
		* @cdev: target ccw device
		* @cpa: logical start address of channel program
		* @intparm: user specific interruption parameter; will be presented back to
		* @cdev's interrupt handler. Allows a device driver to associate
		* the interrupt with a particular I/O request.
		* @lpm: defines the channel path to be used for a specific I/O request. A
		* value of 0 will make cio use the opm.
		* @key: storage key to be used for the I/O
		* @flags: additional flags; defines the action to be performed for I/O
		* processing.
		*
		* Start a S/390 channel program. When the interrupt arrives, the
		* IRQ handler is called, either immediately, delayed (dev-end missing,
		* or sense required) or never (no IRQ handler registered).
		* Returns:
		* %0, if the operation was successful;
		* -%EBUSY, if the device is busy, or status pending;
		* -%EACCES, if no path specified in @lpm is operational;
		* -%ENODEV, if the device is not operational.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_start_key(struct ccw_device cdev, struct ccw1 cpa,
		unsigned long intparm, __u8 lpm, __u8 key,
		unsigned long flags)
		{
		@@ -135,9 +198,36 @@ ccw_device_start_key(struct ccw_device cdev, struct ccw1 cpa,
		return ret;
		}


		int
		ccw_device_start_timeout_key(struct ccw_device cdev, struct ccw1 cpa,
		/**
		* ccw_device_start_timeout_key() - start a s390 channel program with timeout and key
		* @cdev: target ccw device
		* @cpa: logical start address of channel program
		* @intparm: user specific interruption parameter; will be presented back to
		* @cdev's interrupt handler. Allows a device driver to associate
		* the interrupt with a particular I/O request.
		* @lpm: defines the channel path to be used for a specific I/O request. A
		* value of 0 will make cio use the opm.
		* @key: storage key to be used for the I/O
		* @flags: additional flags; defines the action to be performed for I/O
		* processing.
		* @expires: timeout value in jiffies
		*
		* Start a S/390 channel program. When the interrupt arrives, the
		* IRQ handler is called, either immediately, delayed (dev-end missing,
		* or sense required) or never (no IRQ handler registered).
		* This function notifies the device driver if the channel program has not
		* completed during the time specified by @expires. If a timeout occurs, the
		* channel program is terminated via xsch, hsch or csch, and the device's
		* interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
		* Returns:
		* %0, if the operation was successful;
		* -%EBUSY, if the device is busy, or status pending;
		* -%EACCES, if no path specified in @lpm is operational;
		* -%ENODEV, if the device is not operational.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_start_timeout_key(struct ccw_device cdev, struct ccw1 cpa,
		unsigned long intparm, __u8 lpm, __u8 key,
		unsigned long flags, int expires)
		{
		@@ -152,18 +242,67 @@ ccw_device_start_timeout_key(struct ccw_device cdev, struct ccw1 cpa,
		return ret;
		}

		int
		ccw_device_start(struct ccw_device cdev, struct ccw1 cpa,
		/**
		* ccw_device_start() - start a s390 channel program
		* @cdev: target ccw device
		* @cpa: logical start address of channel program
		* @intparm: user specific interruption parameter; will be presented back to
		* @cdev's interrupt handler. Allows a device driver to associate
		* the interrupt with a particular I/O request.
		* @lpm: defines the channel path to be used for a specific I/O request. A
		* value of 0 will make cio use the opm.
		* @flags: additional flags; defines the action to be performed for I/O
		* processing.
		*
		* Start a S/390 channel program. When the interrupt arrives, the
		* IRQ handler is called, either immediately, delayed (dev-end missing,
		* or sense required) or never (no IRQ handler registered).
		* Returns:
		* %0, if the operation was successful;
		* -%EBUSY, if the device is busy, or status pending;
		* -%EACCES, if no path specified in @lpm is operational;
		* -%ENODEV, if the device is not operational.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_start(struct ccw_device cdev, struct ccw1 cpa,
		unsigned long intparm, __u8 lpm, unsigned long flags)
		{
		return ccw_device_start_key(cdev, cpa, intparm, lpm,
		PAGE_DEFAULT_KEY, flags);
		}

		int
		ccw_device_start_timeout(struct ccw_device cdev, struct ccw1 cpa,
		unsigned long intparm, __u8 lpm, unsigned long flags,
		int expires)
		/**
		* ccw_device_start_timeout() - start a s390 channel program with timeout
		* @cdev: target ccw device
		* @cpa: logical start address of channel program
		* @intparm: user specific interruption parameter; will be presented back to
		* @cdev's interrupt handler. Allows a device driver to associate
		* the interrupt with a particular I/O request.
		* @lpm: defines the channel path to be used for a specific I/O request. A
		* value of 0 will make cio use the opm.
		* @flags: additional flags; defines the action to be performed for I/O
		* processing.
		* @expires: timeout value in jiffies
		*
		* Start a S/390 channel program. When the interrupt arrives, the
		* IRQ handler is called, either immediately, delayed (dev-end missing,
		* or sense required) or never (no IRQ handler registered).
		* This function notifies the device driver if the channel program has not
		* completed during the time specified by @expires. If a timeout occurs, the
		* channel program is terminated via xsch, hsch or csch, and the device's
		* interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
		* Returns:
		* %0, if the operation was successful;
		* -%EBUSY, if the device is busy, or status pending;
		* -%EACCES, if no path specified in @lpm is operational;
		* -%ENODEV, if the device is not operational.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_start_timeout(struct ccw_device cdev, struct ccw1 cpa,
		unsigned long intparm, __u8 lpm,
		unsigned long flags, int expires)
		{
		return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
		PAGE_DEFAULT_KEY, flags,
		@@ -171,8 +310,23 @@ ccw_device_start_timeout(struct ccw_device cdev, struct ccw1 cpa,
		}


		int
		ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
		/**
		* ccw_device_halt() - halt I/O request processing
		* @cdev: target ccw device
		* @intparm: interruption parameter; value is only used if no I/O is
		* outstanding, otherwise the intparm associated with the I/O request
		* is returned
		*
		* ccw_device_halt() calls hsch on @cdev's subchannel.
		* Returns:
		* %0 on success,
		* -%ENODEV on device not operational,
		* -%EINVAL on invalid device state,
		* -%EBUSY on device busy or interrupt pending.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
		{
		struct subchannel *sch;
		int ret;
		@@ -193,8 +347,20 @@ ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
		return ret;
		}

		int
		ccw_device_resume(struct ccw_device *cdev)
		/**
		* ccw_device_resume() - resume channel program execution
		* @cdev: target ccw device
		*
		* ccw_device_resume() calls rsch on @cdev's subchannel.
		* Returns:
		* %0 on success,
		* -%ENODEV on device not operational,
		* -%EINVAL on invalid device state,
		* -%EBUSY on device busy or interrupt pending.
		* Context:
		* Interrupts disabled, ccw device lock held
		*/
		int ccw_device_resume(struct ccw_device *cdev)
		{
		struct subchannel *sch;

		@@ -260,11 +426,21 @@ ccw_device_call_handler(struct ccw_device *cdev)
		return 1;
		}

		/*
		* Search for CIW command in extended sense data.
		/**
		* ccw_device_get_ciw() - Search for CIW command in extended sense data.
		* @cdev: ccw device to inspect
		* @ct: command type to look for
		*
		* During SenseID, command information words (CIWs) describing special
		* commands available to the device may have been stored in the extended
		* sense data. This function searches for CIWs of a specified command
		* type in the extended sense data.
		* Returns:
		* %NULL if no extended sense data has been stored or if no CIW of the
		* specified command type could be found,
		* else a pointer to the CIW of the specified command type.
		*/
		struct ciw *
		ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
		struct ciw ccw_device_get_ciw(struct ccw_device cdev, __u32 ct)
		{
		int ciw_cnt;

		@@ -276,8 +452,14 @@ ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
		return NULL;
		}

		__u8
		ccw_device_get_path_mask(struct ccw_device *cdev)
		/**
		* ccw_device_get_path_mask() - get currently available paths
		* @cdev: ccw device to be queried
		* Returns:
		* %0 if no subchannel for the device is available,
		* else the mask of currently available paths for the ccw device's subchannel.
		*/
		__u8 ccw_device_get_path_mask(struct ccw_device *cdev)
		{
		struct subchannel *sch;

		@@ -357,8 +539,7 @@ ccw_device_stlck(struct ccw_device *cdev)
		return ret;
		}

		void *
		ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
		void ccw_device_get_chp_desc(struct ccw_device cdev, int chp_no)
		{
		struct subchannel *sch;
		struct chp_id chpid;

include/asm-s390/ccwdev.h

+33 −42

Original line number	Diff line number	Diff line
		@@ -67,36 +67,53 @@ ccw_device_id_match(const struct ccw_device_id *array,
		return NULL;
		}

		/* The struct ccw device is our replacement for the globally accessible
		* ioinfo array. ioinfo will mutate into a subchannel device later.
		/**
		* struct ccw_device - channel attached device
		* @ccwlock: pointer to device lock
		* @id: id of this device
		* @drv: ccw driver for this device
		* @dev: embedded device structure
		* @online: online status of device
		* @handler: interrupt handler
		*
		* Reference: Documentation/s390/driver-model.txt */
		* @handler is a member of the device rather than the driver since a driver
		* can have different interrupt handlers for different ccw devices
		* (multi-subchannel drivers).
		*/
		struct ccw_device {
		spinlock_t *ccwlock;
		/* private: */
		struct ccw_device_private private; / cio private information */
		struct ccw_device_id id; /* id of this device, driver_info is
		set by ccw_find_driver */
		struct ccw_driver drv; / */
		struct device dev; /* */
		/* public: */
		struct ccw_device_id id;
		struct ccw_driver *drv;
		struct device dev;
		int online;
		/* This is sick, but a driver can have different interrupt handlers
		for different ccw_devices (multi-subchannel drivers)... */
		void (handler) (struct ccw_device , unsigned long, struct irb *);
		};


		/* Each ccw driver registers with the ccw root bus */
		/**
		* struct ccw driver - device driver for channel attached devices
		* @owner: owning module
		* @ids: ids supported by this driver
		* @probe: function called on probe
		* @remove: function called on remove
		* @set_online: called when setting device online
		* @set_offline: called when setting device offline
		* @notify: notify driver of device state changes
		* @driver: embedded device driver structure
		* @name: device driver name
		*/
		struct ccw_driver {
		struct module owner; / for automatic MOD_INC_USE_COUNT */
		struct ccw_device_id ids; / probe driver with these devs */
		int (probe) (struct ccw_device ); /* ask driver to probe dev */
		struct module *owner;
		struct ccw_device_id *ids;
		int (probe) (struct ccw_device );
		void (remove) (struct ccw_device );
		/* device is no longer available */
		int (set_online) (struct ccw_device );
		int (set_offline) (struct ccw_device );
		int (notify) (struct ccw_device , int);
		struct device_driver driver; /* higher level structure, don't init
		this from your driver */
		struct device_driver driver;
		char *name;
		};

		@@ -124,36 +141,10 @@ extern void ccw_device_clear_options(struct ccw_device *, unsigned long);
		/* Allow forced onlining of boxed devices. */
		#define CCWDEV_ALLOW_FORCE 0x0008

		/*
		* ccw_device_start()
		*
		* Start a S/390 channel program. When the interrupt arrives, the
		* IRQ handler is called, either immediately, delayed (dev-end missing,
		* or sense required) or never (no IRQ handler registered).
		* Depending on the action taken, ccw_device_start() returns:
		* 0 - Success
		* -EBUSY - Device busy, or status pending
		* -ENODEV - Device not operational
		* -EINVAL - Device invalid for operation
		*/
		extern int ccw_device_start(struct ccw_device , struct ccw1 ,
		unsigned long, __u8, unsigned long);
		/*
		* ccw_device_start_timeout()
		*
		* This function notifies the device driver if the channel program has not
		* completed during the specified time. If a timeout occurs, the channel
		* program is terminated via xsch(), hsch() or csch().
		*/
		extern int ccw_device_start_timeout(struct ccw_device , struct ccw1 ,
		unsigned long, __u8, unsigned long, int);
		/*
		* ccw_device_start_key()
		* ccw_device_start_key_timeout()
		*
		* Same as ccw_device_start() and ccw_device_start_timeout(), except a
		* storage key != default key can be provided for the I/O.
		*/
		extern int ccw_device_start_key(struct ccw_device , struct ccw1 ,
		unsigned long, __u8, __u8, unsigned long);
		extern int ccw_device_start_timeout_key(struct ccw_device , struct ccw1 ,

include/asm-s390/ccwgroup.h

+27 −5

Original line number	Diff line number	Diff line
		@@ -4,19 +4,41 @@
		struct ccw_device;
		struct ccw_driver;

		/**
		* struct ccwgroup_device - ccw group device
		* @creator_id: unique number of the driver
		* @state: online/offline state
		* @count: number of attached slave devices
		* @dev: embedded device structure
		* @cdev: variable number of slave devices, allocated as needed
		*/
		struct ccwgroup_device {
		unsigned long creator_id; /* unique number of the driver */
		unsigned long creator_id;
		enum {
		CCWGROUP_OFFLINE,
		CCWGROUP_ONLINE,
		} state;
		/* private: */
		atomic_t onoff;
		struct mutex reg_mutex;
		unsigned int count; /* number of attached slave devices */
		struct device dev; /* master device */
		struct ccw_device cdev[0]; / variable number, allocate as needed */
		/* public: */
		unsigned int count;
		struct device dev;
		struct ccw_device *cdev[0];
		};

		/**
		* struct ccwgroup_driver - driver for ccw group devices
		* @owner: driver owner
		* @name: driver name
		* @max_slaves: maximum number of slave devices
		* @driver_id: unique id
		* @probe: function called on probe
		* @remove: function called on remove
		* @set_online: function called when device is set online
		* @set_offline: function called when device is set offline
		* @driver: embedded driver structure
		*/
		struct ccwgroup_driver {
		struct module *owner;
		char *name;
		@@ -28,7 +50,7 @@ struct ccwgroup_driver {
		int (set_online) (struct ccwgroup_device );
		int (set_offline) (struct ccwgroup_device );

		struct device_driver driver; /* this driver */
		struct device_driver driver;
		};

		extern int ccwgroup_driver_register (struct ccwgroup_driver *cdriver);