]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
823d494a | 2 | * Copyright IBM Corp. 2002, 2009 |
1da177e4 | 3 | * |
823d494a | 4 | * Author(s): Arnd Bergmann <arndb@de.ibm.com> |
1da177e4 | 5 | * |
823d494a | 6 | * Interface for CCW device drivers |
1da177e4 LT |
7 | */ |
8 | #ifndef _S390_CCWDEV_H_ | |
9 | #define _S390_CCWDEV_H_ | |
10 | ||
11 | #include <linux/device.h> | |
12 | #include <linux/mod_devicetable.h> | |
83262d63 | 13 | #include <asm/fcx.h> |
1da177e4 LT |
14 | |
15 | /* structs from asm/cio.h */ | |
16 | struct irb; | |
17 | struct ccw1; | |
9a92fe48 | 18 | struct ccw_dev_id; |
1da177e4 LT |
19 | |
20 | /* simplified initializers for struct ccw_device: | |
21 | * CCW_DEVICE and CCW_DEVICE_DEVTYPE initialize one | |
22 | * entry in your MODULE_DEVICE_TABLE and set the match_flag correctly */ | |
23 | #define CCW_DEVICE(cu, cum) \ | |
24 | .cu_type=(cu), .cu_model=(cum), \ | |
25 | .match_flags=(CCW_DEVICE_ID_MATCH_CU_TYPE \ | |
26 | | (cum ? CCW_DEVICE_ID_MATCH_CU_MODEL : 0)) | |
27 | ||
28 | #define CCW_DEVICE_DEVTYPE(cu, cum, dev, devm) \ | |
29 | .cu_type=(cu), .cu_model=(cum), .dev_type=(dev), .dev_model=(devm),\ | |
30 | .match_flags=CCW_DEVICE_ID_MATCH_CU_TYPE \ | |
31 | | ((cum) ? CCW_DEVICE_ID_MATCH_CU_MODEL : 0) \ | |
32 | | CCW_DEVICE_ID_MATCH_DEVICE_TYPE \ | |
33 | | ((devm) ? CCW_DEVICE_ID_MATCH_DEVICE_MODEL : 0) | |
34 | ||
35 | /* scan through an array of device ids and return the first | |
36 | * entry that matches the device. | |
37 | * | |
38 | * the array must end with an entry containing zero match_flags | |
39 | */ | |
40 | static inline const struct ccw_device_id * | |
41 | ccw_device_id_match(const struct ccw_device_id *array, | |
42 | const struct ccw_device_id *match) | |
43 | { | |
44 | const struct ccw_device_id *id = array; | |
45 | ||
46 | for (id = array; id->match_flags; id++) { | |
47 | if ((id->match_flags & CCW_DEVICE_ID_MATCH_CU_TYPE) | |
48 | && (id->cu_type != match->cu_type)) | |
49 | continue; | |
50 | ||
51 | if ((id->match_flags & CCW_DEVICE_ID_MATCH_CU_MODEL) | |
52 | && (id->cu_model != match->cu_model)) | |
53 | continue; | |
54 | ||
55 | if ((id->match_flags & CCW_DEVICE_ID_MATCH_DEVICE_TYPE) | |
56 | && (id->dev_type != match->dev_type)) | |
57 | continue; | |
58 | ||
59 | if ((id->match_flags & CCW_DEVICE_ID_MATCH_DEVICE_MODEL) | |
60 | && (id->dev_model != match->dev_model)) | |
61 | continue; | |
62 | ||
63 | return id; | |
64 | } | |
65 | ||
d2c993d8 | 66 | return NULL; |
1da177e4 LT |
67 | } |
68 | ||
b2ffd8e9 CH |
69 | /** |
70 | * struct ccw_device - channel attached device | |
71 | * @ccwlock: pointer to device lock | |
72 | * @id: id of this device | |
73 | * @drv: ccw driver for this device | |
74 | * @dev: embedded device structure | |
75 | * @online: online status of device | |
76 | * @handler: interrupt handler | |
1da177e4 | 77 | * |
b2ffd8e9 CH |
78 | * @handler is a member of the device rather than the driver since a driver |
79 | * can have different interrupt handlers for different ccw devices | |
80 | * (multi-subchannel drivers). | |
81 | */ | |
1da177e4 LT |
82 | struct ccw_device { |
83 | spinlock_t *ccwlock; | |
b2ffd8e9 | 84 | /* private: */ |
1da177e4 | 85 | struct ccw_device_private *private; /* cio private information */ |
b2ffd8e9 CH |
86 | /* public: */ |
87 | struct ccw_device_id id; | |
88 | struct ccw_driver *drv; | |
89 | struct device dev; | |
1da177e4 | 90 | int online; |
1da177e4 LT |
91 | void (*handler) (struct ccw_device *, unsigned long, struct irb *); |
92 | }; | |
93 | ||
94 | ||
b2ffd8e9 CH |
95 | /** |
96 | * struct ccw driver - device driver for channel attached devices | |
97 | * @owner: owning module | |
98 | * @ids: ids supported by this driver | |
99 | * @probe: function called on probe | |
100 | * @remove: function called on remove | |
101 | * @set_online: called when setting device online | |
102 | * @set_offline: called when setting device offline | |
103 | * @notify: notify driver of device state changes | |
958974fb | 104 | * @shutdown: called at device shutdown |
823d494a SO |
105 | * @prepare: prepare for pm state transition |
106 | * @complete: undo work done in @prepare | |
107 | * @freeze: callback for freezing during hibernation snapshotting | |
108 | * @thaw: undo work done in @freeze | |
109 | * @restore: callback for restoring after hibernation | |
b2ffd8e9 CH |
110 | * @driver: embedded device driver structure |
111 | * @name: device driver name | |
112 | */ | |
1da177e4 | 113 | struct ccw_driver { |
b2ffd8e9 CH |
114 | struct module *owner; |
115 | struct ccw_device_id *ids; | |
116 | int (*probe) (struct ccw_device *); | |
1da177e4 | 117 | void (*remove) (struct ccw_device *); |
1da177e4 LT |
118 | int (*set_online) (struct ccw_device *); |
119 | int (*set_offline) (struct ccw_device *); | |
120 | int (*notify) (struct ccw_device *, int); | |
958974fb | 121 | void (*shutdown) (struct ccw_device *); |
823d494a SO |
122 | int (*prepare) (struct ccw_device *); |
123 | void (*complete) (struct ccw_device *); | |
124 | int (*freeze)(struct ccw_device *); | |
125 | int (*thaw) (struct ccw_device *); | |
126 | int (*restore)(struct ccw_device *); | |
b2ffd8e9 | 127 | struct device_driver driver; |
1da177e4 LT |
128 | char *name; |
129 | }; | |
130 | ||
131 | extern struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv, | |
132 | const char *bus_id); | |
133 | ||
134 | /* devices drivers call these during module load and unload. | |
135 | * When a driver is registered, its probe method is called | |
136 | * when new devices for its type pop up */ | |
137 | extern int ccw_driver_register (struct ccw_driver *driver); | |
138 | extern void ccw_driver_unregister (struct ccw_driver *driver); | |
139 | ||
140 | struct ccw1; | |
141 | ||
4dd3cc5c | 142 | extern int ccw_device_set_options_mask(struct ccw_device *, unsigned long); |
1da177e4 | 143 | extern int ccw_device_set_options(struct ccw_device *, unsigned long); |
4dd3cc5c | 144 | extern void ccw_device_clear_options(struct ccw_device *, unsigned long); |
1da177e4 LT |
145 | |
146 | /* Allow for i/o completion notification after primary interrupt status. */ | |
147 | #define CCWDEV_EARLY_NOTIFICATION 0x0001 | |
148 | /* Report all interrupt conditions. */ | |
149 | #define CCWDEV_REPORT_ALL 0x0002 | |
150 | /* Try to perform path grouping. */ | |
151 | #define CCWDEV_DO_PATHGROUP 0x0004 | |
152 | /* Allow forced onlining of boxed devices. */ | |
153 | #define CCWDEV_ALLOW_FORCE 0x0008 | |
154 | ||
1da177e4 LT |
155 | extern int ccw_device_start(struct ccw_device *, struct ccw1 *, |
156 | unsigned long, __u8, unsigned long); | |
1da177e4 LT |
157 | extern int ccw_device_start_timeout(struct ccw_device *, struct ccw1 *, |
158 | unsigned long, __u8, unsigned long, int); | |
1da177e4 LT |
159 | extern int ccw_device_start_key(struct ccw_device *, struct ccw1 *, |
160 | unsigned long, __u8, __u8, unsigned long); | |
161 | extern int ccw_device_start_timeout_key(struct ccw_device *, struct ccw1 *, | |
162 | unsigned long, __u8, __u8, | |
163 | unsigned long, int); | |
164 | ||
165 | ||
166 | extern int ccw_device_resume(struct ccw_device *); | |
167 | extern int ccw_device_halt(struct ccw_device *, unsigned long); | |
168 | extern int ccw_device_clear(struct ccw_device *, unsigned long); | |
83262d63 PO |
169 | int ccw_device_tm_start_key(struct ccw_device *cdev, struct tcw *tcw, |
170 | unsigned long intparm, u8 lpm, u8 key); | |
171 | int ccw_device_tm_start_key(struct ccw_device *, struct tcw *, | |
172 | unsigned long, u8, u8); | |
173 | int ccw_device_tm_start_timeout_key(struct ccw_device *, struct tcw *, | |
174 | unsigned long, u8, u8, int); | |
175 | int ccw_device_tm_start(struct ccw_device *, struct tcw *, | |
176 | unsigned long, u8); | |
177 | int ccw_device_tm_start_timeout(struct ccw_device *, struct tcw *, | |
178 | unsigned long, u8, int); | |
179 | int ccw_device_tm_intrg(struct ccw_device *cdev); | |
1da177e4 | 180 | |
1da177e4 LT |
181 | extern int ccw_device_set_online(struct ccw_device *cdev); |
182 | extern int ccw_device_set_offline(struct ccw_device *cdev); | |
183 | ||
184 | ||
185 | extern struct ciw *ccw_device_get_ciw(struct ccw_device *, __u32 cmd); | |
186 | extern __u8 ccw_device_get_path_mask(struct ccw_device *); | |
9a92fe48 | 187 | extern void ccw_device_get_id(struct ccw_device *, struct ccw_dev_id *); |
1da177e4 LT |
188 | |
189 | #define get_ccwdev_lock(x) (x)->ccwlock | |
190 | ||
191 | #define to_ccwdev(n) container_of(n, struct ccw_device, dev) | |
192 | #define to_ccwdrv(n) container_of(n, struct ccw_driver, driver) | |
193 | ||
194 | extern struct ccw_device *ccw_device_probe_console(void); | |
195 | ||
196 | // FIXME: these have to go | |
1da177e4 LT |
197 | extern int _ccw_device_get_subchannel_number(struct ccw_device *); |
198 | ||
1da177e4 LT |
199 | extern void *ccw_device_get_chp_desc(struct ccw_device *, int); |
200 | #endif /* _S390_CCWDEV_H_ */ |