xref: /linux/drivers/s390/scsi/zfcp_ccw.c (revision cdd38c5f1ce4398ec58fec95904b75824daab7b5)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * zfcp device driver
4  *
5  * Registration and callback for the s390 common I/O layer.
6  *
7  * Copyright IBM Corp. 2002, 2010
8  */
9 
10 #define KMSG_COMPONENT "zfcp"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 
13 #include <linux/module.h>
14 #include "zfcp_ext.h"
15 #include "zfcp_reqlist.h"
16 
17 #define ZFCP_MODEL_PRIV 0x4
18 
19 static DEFINE_SPINLOCK(zfcp_ccw_adapter_ref_lock);
20 
zfcp_ccw_adapter_by_cdev(struct ccw_device * cdev)21 struct zfcp_adapter *zfcp_ccw_adapter_by_cdev(struct ccw_device *cdev)
22 {
23 	struct zfcp_adapter *adapter;
24 	unsigned long flags;
25 
26 	spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
27 	adapter = dev_get_drvdata(&cdev->dev);
28 	if (adapter)
29 		kref_get(&adapter->ref);
30 	spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
31 	return adapter;
32 }
33 
zfcp_ccw_adapter_put(struct zfcp_adapter * adapter)34 void zfcp_ccw_adapter_put(struct zfcp_adapter *adapter)
35 {
36 	unsigned long flags;
37 
38 	spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
39 	kref_put(&adapter->ref, zfcp_adapter_release);
40 	spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
41 }
42 
43 /**
44  * zfcp_ccw_activate - activate adapter and wait for it to finish
45  * @cdev: pointer to belonging ccw device
46  * @clear: Status flags to clear.
47  * @tag: s390dbf trace record tag
48  */
zfcp_ccw_activate(struct ccw_device * cdev,int clear,char * tag)49 static int zfcp_ccw_activate(struct ccw_device *cdev, int clear, char *tag)
50 {
51 	struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
52 
53 	if (!adapter)
54 		return 0;
55 
56 	zfcp_erp_clear_adapter_status(adapter, clear);
57 	zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
58 	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
59 				tag);
60 
61 	/*
62 	 * We want to scan ports here, with some random backoff and without
63 	 * rate limit. Recovery has already scheduled a port scan for us,
64 	 * but with both random delay and rate limit. Nevertheless we get
65 	 * what we want here by flushing the scheduled work after sleeping
66 	 * an equivalent random time.
67 	 * Let the port scan random delay elapse first. If recovery finishes
68 	 * up to that point in time, that would be perfect for both recovery
69 	 * and port scan. If not, i.e. recovery takes ages, there was no
70 	 * point in waiting a random delay on top of the time consumed by
71 	 * recovery.
72 	 */
73 	msleep(zfcp_fc_port_scan_backoff());
74 	zfcp_erp_wait(adapter);
75 	flush_delayed_work(&adapter->scan_work);
76 
77 	zfcp_ccw_adapter_put(adapter);
78 
79 	return 0;
80 }
81 
82 static struct ccw_device_id zfcp_ccw_device_id[] = {
83 	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
84 	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) },
85 	{},
86 };
87 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
88 
89 /**
90  * zfcp_ccw_probe - probe function of zfcp driver
91  * @cdev: pointer to belonging ccw device
92  *
93  * This function gets called by the common i/o layer for each FCP
94  * device found on the current system. This is only a stub to make cio
95  * work: To only allocate adapter resources for devices actually used,
96  * the allocation is deferred to the first call to ccw_set_online.
97  */
zfcp_ccw_probe(struct ccw_device * cdev)98 static int zfcp_ccw_probe(struct ccw_device *cdev)
99 {
100 	return 0;
101 }
102 
103 /**
104  * zfcp_ccw_remove - remove function of zfcp driver
105  * @cdev: pointer to belonging ccw device
106  *
107  * This function gets called by the common i/o layer and removes an adapter
108  * from the system. Task of this function is to get rid of all units and
109  * ports that belong to this adapter. And in addition all resources of this
110  * adapter will be freed too.
111  */
zfcp_ccw_remove(struct ccw_device * cdev)112 static void zfcp_ccw_remove(struct ccw_device *cdev)
113 {
114 	struct zfcp_adapter *adapter;
115 	struct zfcp_port *port, *p;
116 	struct zfcp_unit *unit, *u;
117 	LIST_HEAD(unit_remove_lh);
118 	LIST_HEAD(port_remove_lh);
119 
120 	ccw_device_set_offline(cdev);
121 
122 	adapter = zfcp_ccw_adapter_by_cdev(cdev);
123 	if (!adapter)
124 		return;
125 
126 	write_lock_irq(&adapter->port_list_lock);
127 	list_for_each_entry(port, &adapter->port_list, list) {
128 		write_lock(&port->unit_list_lock);
129 		list_splice_init(&port->unit_list, &unit_remove_lh);
130 		write_unlock(&port->unit_list_lock);
131 	}
132 	list_splice_init(&adapter->port_list, &port_remove_lh);
133 	write_unlock_irq(&adapter->port_list_lock);
134 	zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */
135 
136 	list_for_each_entry_safe(unit, u, &unit_remove_lh, list)
137 		device_unregister(&unit->dev);
138 
139 	list_for_each_entry_safe(port, p, &port_remove_lh, list)
140 		device_unregister(&port->dev);
141 
142 	zfcp_adapter_unregister(adapter);
143 }
144 
145 /**
146  * zfcp_ccw_set_online - set_online function of zfcp driver
147  * @cdev: pointer to belonging ccw device
148  *
149  * This function gets called by the common i/o layer and sets an
150  * adapter into state online.  The first call will allocate all
151  * adapter resources that will be retained until the device is removed
152  * via zfcp_ccw_remove.
153  *
154  * Setting an fcp device online means that it will be registered with
155  * the SCSI stack, that the QDIO queues will be set up and that the
156  * adapter will be opened.
157  */
zfcp_ccw_set_online(struct ccw_device * cdev)158 static int zfcp_ccw_set_online(struct ccw_device *cdev)
159 {
160 	struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
161 
162 	if (!adapter) {
163 		adapter = zfcp_adapter_enqueue(cdev);
164 
165 		if (IS_ERR(adapter)) {
166 			dev_err(&cdev->dev,
167 				"Setting up data structures for the "
168 				"FCP adapter failed\n");
169 			return PTR_ERR(adapter);
170 		}
171 		kref_get(&adapter->ref);
172 	}
173 
174 	/* initialize request counter */
175 	BUG_ON(!zfcp_reqlist_isempty(adapter->req_list));
176 	adapter->req_no = 0;
177 
178 	zfcp_ccw_activate(cdev, 0, "ccsonl1");
179 
180 	/*
181 	 * We want to scan ports here, always, with some random delay and
182 	 * without rate limit - basically what zfcp_ccw_activate() has
183 	 * achieved for us. Not quite! That port scan depended on
184 	 * !no_auto_port_rescan. So let's cover the no_auto_port_rescan
185 	 * case here to make sure a port scan is done unconditionally.
186 	 * Since zfcp_ccw_activate() has waited the desired random time,
187 	 * we can immediately schedule and flush a port scan for the
188 	 * remaining cases.
189 	 */
190 	zfcp_fc_inverse_conditional_port_scan(adapter);
191 	flush_delayed_work(&adapter->scan_work);
192 	zfcp_ccw_adapter_put(adapter);
193 	return 0;
194 }
195 
196 /**
197  * zfcp_ccw_set_offline - set_offline function of zfcp driver
198  * @cdev: pointer to belonging ccw device
199  *
200  * This function gets called by the common i/o layer and sets an adapter
201  * into state offline.
202  */
zfcp_ccw_set_offline(struct ccw_device * cdev)203 static int zfcp_ccw_set_offline(struct ccw_device *cdev)
204 {
205 	struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
206 
207 	if (!adapter)
208 		return 0;
209 
210 	zfcp_erp_set_adapter_status(adapter, 0);
211 	zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1");
212 	zfcp_erp_wait(adapter);
213 
214 	zfcp_ccw_adapter_put(adapter);
215 	return 0;
216 }
217 
218 /**
219  * zfcp_ccw_notify - ccw notify function
220  * @cdev: pointer to belonging ccw device
221  * @event: indicates if adapter was detached or attached
222  *
223  * This function gets called by the common i/o layer if an adapter has gone
224  * or reappeared.
225  */
zfcp_ccw_notify(struct ccw_device * cdev,int event)226 static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
227 {
228 	struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
229 
230 	if (!adapter)
231 		return 1;
232 
233 	switch (event) {
234 	case CIO_GONE:
235 		dev_warn(&cdev->dev, "The FCP device has been detached\n");
236 		zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1");
237 		break;
238 	case CIO_NO_PATH:
239 		dev_warn(&cdev->dev,
240 			 "The CHPID for the FCP device is offline\n");
241 		zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2");
242 		break;
243 	case CIO_OPER:
244 		dev_info(&cdev->dev, "The FCP device is operational again\n");
245 		zfcp_erp_set_adapter_status(adapter,
246 					    ZFCP_STATUS_COMMON_RUNNING);
247 		zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
248 					"ccnoti4");
249 		break;
250 	case CIO_BOXED:
251 		dev_warn(&cdev->dev, "The FCP device did not respond within "
252 				     "the specified time\n");
253 		zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5");
254 		break;
255 	}
256 
257 	zfcp_ccw_adapter_put(adapter);
258 	return 1;
259 }
260 
261 /**
262  * zfcp_ccw_shutdown - handle shutdown from cio
263  * @cdev: device for adapter to shutdown.
264  */
zfcp_ccw_shutdown(struct ccw_device * cdev)265 static void zfcp_ccw_shutdown(struct ccw_device *cdev)
266 {
267 	struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
268 
269 	if (!adapter)
270 		return;
271 
272 	zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1");
273 	zfcp_erp_wait(adapter);
274 	zfcp_erp_thread_kill(adapter);
275 
276 	zfcp_ccw_adapter_put(adapter);
277 }
278 
279 struct ccw_driver zfcp_ccw_driver = {
280 	.driver = {
281 		.owner	= THIS_MODULE,
282 		.name	= "zfcp",
283 	},
284 	.ids         = zfcp_ccw_device_id,
285 	.probe       = zfcp_ccw_probe,
286 	.remove      = zfcp_ccw_remove,
287 	.set_online  = zfcp_ccw_set_online,
288 	.set_offline = zfcp_ccw_set_offline,
289 	.notify      = zfcp_ccw_notify,
290 	.shutdown    = zfcp_ccw_shutdown,
291 };
292