Use dentry_path() to create full path to inode object
[pohmelfs.git] / drivers / s390 / scsi / zfcp_qdio.c
blobe14da5751d32674fa089fe6ffae6ed93da843262
1 /*
2 * zfcp device driver
4 * Setup and helper functions to access QDIO.
6 * Copyright IBM Corporation 2002, 2010
7 */
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/slab.h>
13 #include <linux/module.h>
14 #include "zfcp_ext.h"
15 #include "zfcp_qdio.h"
17 #define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer))
19 static bool enable_multibuffer;
20 module_param_named(datarouter, enable_multibuffer, bool, 0400);
21 MODULE_PARM_DESC(datarouter, "Enable hardware data router support");
23 static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal)
25 int pos;
27 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) {
28 sbal[pos] = (struct qdio_buffer *) get_zeroed_page(GFP_KERNEL);
29 if (!sbal[pos])
30 return -ENOMEM;
32 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++)
33 if (pos % QBUFF_PER_PAGE)
34 sbal[pos] = sbal[pos - 1] + 1;
35 return 0;
38 static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id,
39 unsigned int qdio_err)
41 struct zfcp_adapter *adapter = qdio->adapter;
43 dev_warn(&adapter->ccw_device->dev, "A QDIO problem occurred\n");
45 if (qdio_err & QDIO_ERROR_SLSB_STATE) {
46 zfcp_qdio_siosl(adapter);
47 zfcp_erp_adapter_shutdown(adapter, 0, id);
48 return;
50 zfcp_erp_adapter_reopen(adapter,
51 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
52 ZFCP_STATUS_COMMON_ERP_FAILED, id);
55 static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
57 int i, sbal_idx;
59 for (i = first; i < first + cnt; i++) {
60 sbal_idx = i % QDIO_MAX_BUFFERS_PER_Q;
61 memset(sbal[sbal_idx], 0, sizeof(struct qdio_buffer));
65 /* this needs to be called prior to updating the queue fill level */
66 static inline void zfcp_qdio_account(struct zfcp_qdio *qdio)
68 unsigned long long now, span;
69 int used;
71 now = get_clock_monotonic();
72 span = (now - qdio->req_q_time) >> 12;
73 used = QDIO_MAX_BUFFERS_PER_Q - atomic_read(&qdio->req_q_free);
74 qdio->req_q_util += used * span;
75 qdio->req_q_time = now;
78 static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
79 int queue_no, int idx, int count,
80 unsigned long parm)
82 struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
84 if (unlikely(qdio_err)) {
85 zfcp_qdio_handler_error(qdio, "qdireq1", qdio_err);
86 return;
89 /* cleanup all SBALs being program-owned now */
90 zfcp_qdio_zero_sbals(qdio->req_q, idx, count);
92 spin_lock_irq(&qdio->stat_lock);
93 zfcp_qdio_account(qdio);
94 spin_unlock_irq(&qdio->stat_lock);
95 atomic_add(count, &qdio->req_q_free);
96 wake_up(&qdio->req_q_wq);
99 static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
100 int queue_no, int idx, int count,
101 unsigned long parm)
103 struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
104 struct zfcp_adapter *adapter = qdio->adapter;
105 struct qdio_buffer_element *sbale;
106 int sbal_no, sbal_idx;
107 void *pl[ZFCP_QDIO_MAX_SBALS_PER_REQ + 1];
108 u64 req_id;
109 u8 scount;
111 if (unlikely(qdio_err)) {
112 memset(pl, 0, ZFCP_QDIO_MAX_SBALS_PER_REQ * sizeof(void *));
113 if (zfcp_adapter_multi_buffer_active(adapter)) {
114 sbale = qdio->res_q[idx]->element;
115 req_id = (u64) sbale->addr;
116 scount = sbale->scount + 1; /* incl. signaling SBAL */
118 for (sbal_no = 0; sbal_no < scount; sbal_no++) {
119 sbal_idx = (idx + sbal_no) %
120 QDIO_MAX_BUFFERS_PER_Q;
121 pl[sbal_no] = qdio->res_q[sbal_idx];
123 zfcp_dbf_hba_def_err(adapter, req_id, scount, pl);
125 zfcp_qdio_handler_error(qdio, "qdires1", qdio_err);
126 return;
130 * go through all SBALs from input queue currently
131 * returned by QDIO layer
133 for (sbal_no = 0; sbal_no < count; sbal_no++) {
134 sbal_idx = (idx + sbal_no) % QDIO_MAX_BUFFERS_PER_Q;
135 /* go through all SBALEs of SBAL */
136 zfcp_fsf_reqid_check(qdio, sbal_idx);
140 * put SBALs back to response queue
142 if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count))
143 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2");
146 static struct qdio_buffer_element *
147 zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
149 struct qdio_buffer_element *sbale;
151 /* set last entry flag in current SBALE of current SBAL */
152 sbale = zfcp_qdio_sbale_curr(qdio, q_req);
153 sbale->eflags |= SBAL_EFLAGS_LAST_ENTRY;
155 /* don't exceed last allowed SBAL */
156 if (q_req->sbal_last == q_req->sbal_limit)
157 return NULL;
159 /* set chaining flag in first SBALE of current SBAL */
160 sbale = zfcp_qdio_sbale_req(qdio, q_req);
161 sbale->sflags |= SBAL_SFLAGS0_MORE_SBALS;
163 /* calculate index of next SBAL */
164 q_req->sbal_last++;
165 q_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
167 /* keep this requests number of SBALs up-to-date */
168 q_req->sbal_number++;
169 BUG_ON(q_req->sbal_number > ZFCP_QDIO_MAX_SBALS_PER_REQ);
171 /* start at first SBALE of new SBAL */
172 q_req->sbale_curr = 0;
174 /* set storage-block type for new SBAL */
175 sbale = zfcp_qdio_sbale_curr(qdio, q_req);
176 sbale->sflags |= q_req->sbtype;
178 return sbale;
181 static struct qdio_buffer_element *
182 zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
184 if (q_req->sbale_curr == qdio->max_sbale_per_sbal - 1)
185 return zfcp_qdio_sbal_chain(qdio, q_req);
186 q_req->sbale_curr++;
187 return zfcp_qdio_sbale_curr(qdio, q_req);
191 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
192 * @qdio: pointer to struct zfcp_qdio
193 * @q_req: pointer to struct zfcp_qdio_req
194 * @sg: scatter-gather list
195 * @max_sbals: upper bound for number of SBALs to be used
196 * Returns: zero or -EINVAL on error
198 int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
199 struct scatterlist *sg)
201 struct qdio_buffer_element *sbale;
203 /* set storage-block type for this request */
204 sbale = zfcp_qdio_sbale_req(qdio, q_req);
205 sbale->sflags |= q_req->sbtype;
207 for (; sg; sg = sg_next(sg)) {
208 sbale = zfcp_qdio_sbale_next(qdio, q_req);
209 if (!sbale) {
210 atomic_inc(&qdio->req_q_full);
211 zfcp_qdio_zero_sbals(qdio->req_q, q_req->sbal_first,
212 q_req->sbal_number);
213 return -EINVAL;
215 sbale->addr = sg_virt(sg);
216 sbale->length = sg->length;
218 return 0;
221 static int zfcp_qdio_sbal_check(struct zfcp_qdio *qdio)
223 spin_lock_irq(&qdio->req_q_lock);
224 if (atomic_read(&qdio->req_q_free) ||
225 !(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
226 return 1;
227 spin_unlock_irq(&qdio->req_q_lock);
228 return 0;
232 * zfcp_qdio_sbal_get - get free sbal in request queue, wait if necessary
233 * @qdio: pointer to struct zfcp_qdio
235 * The req_q_lock must be held by the caller of this function, and
236 * this function may only be called from process context; it will
237 * sleep when waiting for a free sbal.
239 * Returns: 0 on success, -EIO if there is no free sbal after waiting.
241 int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
243 long ret;
245 spin_unlock_irq(&qdio->req_q_lock);
246 ret = wait_event_interruptible_timeout(qdio->req_q_wq,
247 zfcp_qdio_sbal_check(qdio), 5 * HZ);
249 if (!(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
250 return -EIO;
252 if (ret > 0)
253 return 0;
255 if (!ret) {
256 atomic_inc(&qdio->req_q_full);
257 /* assume hanging outbound queue, try queue recovery */
258 zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1");
261 spin_lock_irq(&qdio->req_q_lock);
262 return -EIO;
266 * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
267 * @qdio: pointer to struct zfcp_qdio
268 * @q_req: pointer to struct zfcp_qdio_req
269 * Returns: 0 on success, error otherwise
271 int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
273 int retval;
274 u8 sbal_number = q_req->sbal_number;
276 spin_lock(&qdio->stat_lock);
277 zfcp_qdio_account(qdio);
278 spin_unlock(&qdio->stat_lock);
280 retval = do_QDIO(qdio->adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0,
281 q_req->sbal_first, sbal_number);
283 if (unlikely(retval)) {
284 zfcp_qdio_zero_sbals(qdio->req_q, q_req->sbal_first,
285 sbal_number);
286 return retval;
289 /* account for transferred buffers */
290 atomic_sub(sbal_number, &qdio->req_q_free);
291 qdio->req_q_idx += sbal_number;
292 qdio->req_q_idx %= QDIO_MAX_BUFFERS_PER_Q;
294 return 0;
298 static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
299 struct zfcp_qdio *qdio)
301 memset(id, 0, sizeof(*id));
302 id->cdev = qdio->adapter->ccw_device;
303 id->q_format = QDIO_ZFCP_QFMT;
304 memcpy(id->adapter_name, dev_name(&id->cdev->dev), 8);
305 ASCEBC(id->adapter_name, 8);
306 id->qib_rflags = QIB_RFLAGS_ENABLE_DATA_DIV;
307 if (enable_multibuffer)
308 id->qdr_ac |= QDR_AC_MULTI_BUFFER_ENABLE;
309 id->no_input_qs = 1;
310 id->no_output_qs = 1;
311 id->input_handler = zfcp_qdio_int_resp;
312 id->output_handler = zfcp_qdio_int_req;
313 id->int_parm = (unsigned long) qdio;
314 id->input_sbal_addr_array = (void **) (qdio->res_q);
315 id->output_sbal_addr_array = (void **) (qdio->req_q);
316 id->scan_threshold =
317 QDIO_MAX_BUFFERS_PER_Q - ZFCP_QDIO_MAX_SBALS_PER_REQ * 2;
321 * zfcp_qdio_allocate - allocate queue memory and initialize QDIO data
322 * @adapter: pointer to struct zfcp_adapter
323 * Returns: -ENOMEM on memory allocation error or return value from
324 * qdio_allocate
326 static int zfcp_qdio_allocate(struct zfcp_qdio *qdio)
328 struct qdio_initialize init_data;
330 if (zfcp_qdio_buffers_enqueue(qdio->req_q) ||
331 zfcp_qdio_buffers_enqueue(qdio->res_q))
332 return -ENOMEM;
334 zfcp_qdio_setup_init_data(&init_data, qdio);
335 init_waitqueue_head(&qdio->req_q_wq);
337 return qdio_allocate(&init_data);
341 * zfcp_close_qdio - close qdio queues for an adapter
342 * @qdio: pointer to structure zfcp_qdio
344 void zfcp_qdio_close(struct zfcp_qdio *qdio)
346 struct zfcp_adapter *adapter = qdio->adapter;
347 int idx, count;
349 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
350 return;
352 /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
353 spin_lock_irq(&qdio->req_q_lock);
354 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
355 spin_unlock_irq(&qdio->req_q_lock);
357 wake_up(&qdio->req_q_wq);
359 qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
361 /* cleanup used outbound sbals */
362 count = atomic_read(&qdio->req_q_free);
363 if (count < QDIO_MAX_BUFFERS_PER_Q) {
364 idx = (qdio->req_q_idx + count) % QDIO_MAX_BUFFERS_PER_Q;
365 count = QDIO_MAX_BUFFERS_PER_Q - count;
366 zfcp_qdio_zero_sbals(qdio->req_q, idx, count);
368 qdio->req_q_idx = 0;
369 atomic_set(&qdio->req_q_free, 0);
373 * zfcp_qdio_open - prepare and initialize response queue
374 * @qdio: pointer to struct zfcp_qdio
375 * Returns: 0 on success, otherwise -EIO
377 int zfcp_qdio_open(struct zfcp_qdio *qdio)
379 struct qdio_buffer_element *sbale;
380 struct qdio_initialize init_data;
381 struct zfcp_adapter *adapter = qdio->adapter;
382 struct ccw_device *cdev = adapter->ccw_device;
383 struct qdio_ssqd_desc ssqd;
384 int cc;
386 if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)
387 return -EIO;
389 atomic_clear_mask(ZFCP_STATUS_ADAPTER_SIOSL_ISSUED,
390 &qdio->adapter->status);
392 zfcp_qdio_setup_init_data(&init_data, qdio);
394 if (qdio_establish(&init_data))
395 goto failed_establish;
397 if (qdio_get_ssqd_desc(init_data.cdev, &ssqd))
398 goto failed_qdio;
400 if (ssqd.qdioac2 & CHSC_AC2_DATA_DIV_ENABLED)
401 atomic_set_mask(ZFCP_STATUS_ADAPTER_DATA_DIV_ENABLED,
402 &qdio->adapter->status);
404 if (ssqd.qdioac2 & CHSC_AC2_MULTI_BUFFER_ENABLED) {
405 atomic_set_mask(ZFCP_STATUS_ADAPTER_MB_ACT, &adapter->status);
406 qdio->max_sbale_per_sbal = QDIO_MAX_ELEMENTS_PER_BUFFER;
407 } else {
408 atomic_clear_mask(ZFCP_STATUS_ADAPTER_MB_ACT, &adapter->status);
409 qdio->max_sbale_per_sbal = QDIO_MAX_ELEMENTS_PER_BUFFER - 1;
412 qdio->max_sbale_per_req =
413 ZFCP_QDIO_MAX_SBALS_PER_REQ * qdio->max_sbale_per_sbal
414 - 2;
415 if (qdio_activate(cdev))
416 goto failed_qdio;
418 for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) {
419 sbale = &(qdio->res_q[cc]->element[0]);
420 sbale->length = 0;
421 sbale->eflags = SBAL_EFLAGS_LAST_ENTRY;
422 sbale->sflags = 0;
423 sbale->addr = NULL;
426 if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q))
427 goto failed_qdio;
429 /* set index of first available SBALS / number of available SBALS */
430 qdio->req_q_idx = 0;
431 atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q);
432 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status);
434 if (adapter->scsi_host) {
435 adapter->scsi_host->sg_tablesize = qdio->max_sbale_per_req;
436 adapter->scsi_host->max_sectors = qdio->max_sbale_per_req * 8;
439 return 0;
441 failed_qdio:
442 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
443 failed_establish:
444 dev_err(&cdev->dev,
445 "Setting up the QDIO connection to the FCP adapter failed\n");
446 return -EIO;
449 void zfcp_qdio_destroy(struct zfcp_qdio *qdio)
451 int p;
453 if (!qdio)
454 return;
456 if (qdio->adapter->ccw_device)
457 qdio_free(qdio->adapter->ccw_device);
459 for (p = 0; p < QDIO_MAX_BUFFERS_PER_Q; p += QBUFF_PER_PAGE) {
460 free_page((unsigned long) qdio->req_q[p]);
461 free_page((unsigned long) qdio->res_q[p]);
464 kfree(qdio);
467 int zfcp_qdio_setup(struct zfcp_adapter *adapter)
469 struct zfcp_qdio *qdio;
471 qdio = kzalloc(sizeof(struct zfcp_qdio), GFP_KERNEL);
472 if (!qdio)
473 return -ENOMEM;
475 qdio->adapter = adapter;
477 if (zfcp_qdio_allocate(qdio)) {
478 zfcp_qdio_destroy(qdio);
479 return -ENOMEM;
482 spin_lock_init(&qdio->req_q_lock);
483 spin_lock_init(&qdio->stat_lock);
485 adapter->qdio = qdio;
486 return 0;
490 * zfcp_qdio_siosl - Trigger logging in FCP channel
491 * @adapter: The zfcp_adapter where to trigger logging
493 * Call the cio siosl function to trigger hardware logging. This
494 * wrapper function sets a flag to ensure hardware logging is only
495 * triggered once before going through qdio shutdown.
497 * The triggers are always run from qdio tasklet context, so no
498 * additional synchronization is necessary.
500 void zfcp_qdio_siosl(struct zfcp_adapter *adapter)
502 int rc;
504 if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_SIOSL_ISSUED)
505 return;
507 rc = ccw_device_siosl(adapter->ccw_device);
508 if (!rc)
509 atomic_set_mask(ZFCP_STATUS_ADAPTER_SIOSL_ISSUED,
510 &adapter->status);