1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Handling of internal CCW device requests.
4 *
5 * Copyright IBM Corp. 2009, 2011
6 * Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
7 */
8
9 #define KMSG_COMPONENT "cio"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
12 #include <linux/types.h>
13 #include <linux/err.h>
14 #include <asm/ccwdev.h>
15 #include <asm/cio.h>
16
17 #include "io_sch.h"
18 #include "cio.h"
19 #include "device.h"
20 #include "cio_debug.h"
21
22 /**
23 * lpm_adjust - adjust path mask
24 * @lpm: path mask to adjust
25 * @mask: mask of available paths
26 *
27 * Shift @lpm right until @lpm and @mask have at least one bit in common or
28 * until @lpm is zero. Return the resulting lpm.
29 */
lpm_adjust(int lpm,int mask)30 int lpm_adjust(int lpm, int mask)
31 {
32 while (lpm && ((lpm & mask) == 0))
33 lpm >>= 1;
34 return lpm;
35 }
36
37 /*
38 * Adjust path mask to use next path and reset retry count. Return resulting
39 * path mask.
40 */
ccwreq_next_path(struct ccw_device * cdev)41 static u16 ccwreq_next_path(struct ccw_device *cdev)
42 {
43 struct ccw_request *req = &cdev->private->req;
44
45 if (!req->singlepath) {
46 req->mask = 0;
47 goto out;
48 }
49 req->retries = req->maxretries;
50 req->mask = lpm_adjust(req->mask >> 1, req->lpm);
51 out:
52 return req->mask;
53 }
54
55 /*
56 * Clean up device state and report to callback.
57 */
ccwreq_stop(struct ccw_device * cdev,int rc)58 static void ccwreq_stop(struct ccw_device *cdev, int rc)
59 {
60 struct ccw_request *req = &cdev->private->req;
61
62 if (req->done)
63 return;
64 req->done = 1;
65 ccw_device_set_timeout(cdev, 0);
66 memset(&cdev->private->irb, 0, sizeof(struct irb));
67 if (rc && rc != -ENODEV && req->drc)
68 rc = req->drc;
69 req->callback(cdev, req->data, rc);
70 }
71
72 /*
73 * (Re-)Start the operation until retries and paths are exhausted.
74 */
ccwreq_do(struct ccw_device * cdev)75 static void ccwreq_do(struct ccw_device *cdev)
76 {
77 struct ccw_request *req = &cdev->private->req;
78 struct subchannel *sch = to_subchannel(cdev->dev.parent);
79 struct ccw1 *cp = req->cp;
80 int rc = -EACCES;
81
82 while (req->mask) {
83 if (req->retries-- == 0) {
84 /* Retries exhausted, try next path. */
85 ccwreq_next_path(cdev);
86 continue;
87 }
88 /* Perform start function. */
89 memset(&cdev->private->irb, 0, sizeof(struct irb));
90 rc = cio_start(sch, cp, (u8) req->mask);
91 if (rc == 0) {
92 /* I/O started successfully. */
93 ccw_device_set_timeout(cdev, req->timeout);
94 return;
95 }
96 if (rc == -ENODEV) {
97 /* Permanent device error. */
98 break;
99 }
100 if (rc == -EACCES) {
101 /* Permant path error. */
102 ccwreq_next_path(cdev);
103 continue;
104 }
105 /* Temporary improper status. */
106 rc = cio_clear(sch);
107 if (rc)
108 break;
109 return;
110 }
111 ccwreq_stop(cdev, rc);
112 }
113
114 /**
115 * ccw_request_start - perform I/O request
116 * @cdev: ccw device
117 *
118 * Perform the I/O request specified by cdev->req.
119 */
ccw_request_start(struct ccw_device * cdev)120 void ccw_request_start(struct ccw_device *cdev)
121 {
122 struct ccw_request *req = &cdev->private->req;
123
124 if (req->singlepath) {
125 /* Try all paths twice to counter link flapping. */
126 req->mask = 0x8080;
127 } else
128 req->mask = req->lpm;
129
130 req->retries = req->maxretries;
131 req->mask = lpm_adjust(req->mask, req->lpm);
132 req->drc = 0;
133 req->done = 0;
134 req->cancel = 0;
135 if (!req->mask)
136 goto out_nopath;
137 ccwreq_do(cdev);
138 return;
139
140 out_nopath:
141 ccwreq_stop(cdev, -EACCES);
142 }
143
144 /**
145 * ccw_request_cancel - cancel running I/O request
146 * @cdev: ccw device
147 *
148 * Cancel the I/O request specified by cdev->req. Return non-zero if request
149 * has already finished, zero otherwise.
150 */
ccw_request_cancel(struct ccw_device * cdev)151 int ccw_request_cancel(struct ccw_device *cdev)
152 {
153 struct subchannel *sch = to_subchannel(cdev->dev.parent);
154 struct ccw_request *req = &cdev->private->req;
155 int rc;
156
157 if (req->done)
158 return 1;
159 req->cancel = 1;
160 rc = cio_clear(sch);
161 if (rc)
162 ccwreq_stop(cdev, rc);
163 return 0;
164 }
165
166 /*
167 * Return the status of the internal I/O started on the specified ccw device.
168 * Perform BASIC SENSE if required.
169 */
ccwreq_status(struct ccw_device * cdev,struct irb * lcirb)170 static enum io_status ccwreq_status(struct ccw_device *cdev, struct irb *lcirb)
171 {
172 struct irb *irb = &cdev->private->irb;
173 struct cmd_scsw *scsw = &irb->scsw.cmd;
174 enum uc_todo todo;
175
176 /* Perform BASIC SENSE if needed. */
177 if (ccw_device_accumulate_and_sense(cdev, lcirb))
178 return IO_RUNNING;
179 /* Check for halt/clear interrupt. */
180 if (scsw->fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC))
181 return IO_KILLED;
182 /* Check for path error. */
183 if (scsw->cc == 3 || scsw->pno)
184 return IO_PATH_ERROR;
185 /* Handle BASIC SENSE data. */
186 if (irb->esw.esw0.erw.cons) {
187 CIO_TRACE_EVENT(2, "sensedata");
188 CIO_HEX_EVENT(2, &cdev->private->dev_id,
189 sizeof(struct ccw_dev_id));
190 CIO_HEX_EVENT(2, &cdev->private->irb.ecw, SENSE_MAX_COUNT);
191 /* Check for command reject. */
192 if (irb->ecw[0] & SNS0_CMD_REJECT)
193 return IO_REJECTED;
194 /* Ask the driver what to do */
195 if (cdev->drv && cdev->drv->uc_handler) {
196 todo = cdev->drv->uc_handler(cdev, lcirb);
197 CIO_TRACE_EVENT(2, "uc_response");
198 CIO_HEX_EVENT(2, &todo, sizeof(todo));
199 switch (todo) {
200 case UC_TODO_RETRY:
201 return IO_STATUS_ERROR;
202 case UC_TODO_RETRY_ON_NEW_PATH:
203 return IO_PATH_ERROR;
204 case UC_TODO_STOP:
205 return IO_REJECTED;
206 default:
207 return IO_STATUS_ERROR;
208 }
209 }
210 /* Assume that unexpected SENSE data implies an error. */
211 return IO_STATUS_ERROR;
212 }
213 /* Check for channel errors. */
214 if (scsw->cstat != 0)
215 return IO_STATUS_ERROR;
216 /* Check for device errors. */
217 if (scsw->dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
218 return IO_STATUS_ERROR;
219 /* Check for final state. */
220 if (!(scsw->dstat & DEV_STAT_DEV_END))
221 return IO_RUNNING;
222 /* Check for other improper status. */
223 if (scsw->cc == 1 && (scsw->stctl & SCSW_STCTL_ALERT_STATUS))
224 return IO_STATUS_ERROR;
225 return IO_DONE;
226 }
227
228 /*
229 * Log ccw request status.
230 */
ccwreq_log_status(struct ccw_device * cdev,enum io_status status)231 static void ccwreq_log_status(struct ccw_device *cdev, enum io_status status)
232 {
233 struct ccw_request *req = &cdev->private->req;
234 struct {
235 struct ccw_dev_id dev_id;
236 u16 retries;
237 u8 lpm;
238 u8 status;
239 } __attribute__ ((packed)) data;
240 data.dev_id = cdev->private->dev_id;
241 data.retries = req->retries;
242 data.lpm = (u8) req->mask;
243 data.status = (u8) status;
244 CIO_TRACE_EVENT(2, "reqstat");
245 CIO_HEX_EVENT(2, &data, sizeof(data));
246 }
247
248 /**
249 * ccw_request_handler - interrupt handler for I/O request procedure.
250 * @cdev: ccw device
251 *
252 * Handle interrupt during I/O request procedure.
253 */
ccw_request_handler(struct ccw_device * cdev)254 void ccw_request_handler(struct ccw_device *cdev)
255 {
256 struct irb *irb = this_cpu_ptr(&cio_irb);
257 struct ccw_request *req = &cdev->private->req;
258 enum io_status status;
259 int rc = -EOPNOTSUPP;
260
261 /* Check status of I/O request. */
262 status = ccwreq_status(cdev, irb);
263 if (req->filter)
264 status = req->filter(cdev, req->data, irb, status);
265 if (status != IO_RUNNING)
266 ccw_device_set_timeout(cdev, 0);
267 if (status != IO_DONE && status != IO_RUNNING)
268 ccwreq_log_status(cdev, status);
269 switch (status) {
270 case IO_DONE:
271 break;
272 case IO_RUNNING:
273 return;
274 case IO_REJECTED:
275 goto err;
276 case IO_PATH_ERROR:
277 goto out_next_path;
278 case IO_STATUS_ERROR:
279 goto out_restart;
280 case IO_KILLED:
281 /* Check if request was cancelled on purpose. */
282 if (req->cancel) {
283 rc = -EIO;
284 goto err;
285 }
286 goto out_restart;
287 }
288 /* Check back with request initiator. */
289 if (!req->check)
290 goto out;
291 switch (req->check(cdev, req->data)) {
292 case 0:
293 break;
294 case -EAGAIN:
295 goto out_restart;
296 case -EACCES:
297 goto out_next_path;
298 default:
299 goto err;
300 }
301 out:
302 ccwreq_stop(cdev, 0);
303 return;
304
305 out_next_path:
306 /* Try next path and restart I/O. */
307 if (!ccwreq_next_path(cdev)) {
308 rc = -EACCES;
309 goto err;
310 }
311 out_restart:
312 /* Restart. */
313 ccwreq_do(cdev);
314 return;
315 err:
316 ccwreq_stop(cdev, rc);
317 }
318
319
320 /**
321 * ccw_request_timeout - timeout handler for I/O request procedure
322 * @cdev: ccw device
323 *
324 * Handle timeout during I/O request procedure.
325 */
ccw_request_timeout(struct ccw_device * cdev)326 void ccw_request_timeout(struct ccw_device *cdev)
327 {
328 struct subchannel *sch = to_subchannel(cdev->dev.parent);
329 struct ccw_request *req = &cdev->private->req;
330 int rc = -ENODEV, chp;
331
332 if (cio_update_schib(sch))
333 goto err;
334
335 for (chp = 0; chp < 8; chp++) {
336 if ((0x80 >> chp) & sch->schib.pmcw.lpum)
337 pr_warn("%s: No interrupt was received within %lus (CS=%02x, DS=%02x, CHPID=%x.%02x)\n",
338 dev_name(&cdev->dev), req->timeout / HZ,
339 scsw_cstat(&sch->schib.scsw),
340 scsw_dstat(&sch->schib.scsw),
341 sch->schid.cssid,
342 sch->schib.pmcw.chpid[chp]);
343 }
344
345 if (!ccwreq_next_path(cdev)) {
346 /* set the final return code for this request */
347 req->drc = -ETIME;
348 }
349 rc = cio_clear(sch);
350 if (rc)
351 goto err;
352 return;
353
354 err:
355 ccwreq_stop(cdev, rc);
356 }
357
358 /**
359 * ccw_request_notoper - notoper handler for I/O request procedure
360 * @cdev: ccw device
361 *
362 * Handle notoper during I/O request procedure.
363 */
ccw_request_notoper(struct ccw_device * cdev)364 void ccw_request_notoper(struct ccw_device *cdev)
365 {
366 ccwreq_stop(cdev, -ENODEV);
367 }
368