blob: d6dbd653fde9a46496de95b971d4338f9ec48035 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Swen Schillig00bab912008-06-10 18:20:57 +02002 * zfcp device driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Swen Schillig00bab912008-06-10 18:20:57 +02004 * Setup and helper functions to access QDIO.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
Swen Schillig00bab912008-06-10 18:20:57 +02006 * Copyright IBM Corporation 2002, 2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include "zfcp_ext.h"
10
Swen Schillig00bab912008-06-10 18:20:57 +020011/* FIXME(tune): free space should be one max. SBAL chain plus what? */
12#define ZFCP_QDIO_PCI_INTERVAL (QDIO_MAX_BUFFERS_PER_Q \
Swen Schilligc41f8cb2008-07-02 10:56:39 +020013 - (FSF_MAX_SBALS_PER_REQ + 4))
Christof Schmitt5d4e2262008-07-02 10:56:34 +020014#define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer))
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Swen Schillig00bab912008-06-10 18:20:57 +020016static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal)
Swen Schilligb4e44592007-07-18 10:55:13 +020017{
18 int pos;
19
20 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) {
Swen Schillig00bab912008-06-10 18:20:57 +020021 sbal[pos] = (struct qdio_buffer *) get_zeroed_page(GFP_KERNEL);
22 if (!sbal[pos])
Swen Schilligb4e44592007-07-18 10:55:13 +020023 return -ENOMEM;
Swen Schilligb4e44592007-07-18 10:55:13 +020024 }
25 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++)
26 if (pos % QBUFF_PER_PAGE)
Swen Schillig00bab912008-06-10 18:20:57 +020027 sbal[pos] = sbal[pos - 1] + 1;
Swen Schilligb4e44592007-07-18 10:55:13 +020028 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029}
30
Swen Schillig00bab912008-06-10 18:20:57 +020031static volatile struct qdio_buffer_element *
32zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033{
Swen Schillig00bab912008-06-10 18:20:57 +020034 return &q->sbal[sbal_idx]->element[sbale_idx];
Linus Torvalds1da177e2005-04-16 15:20:36 -070035}
36
Volker Sameskefea9d6c2006-08-02 11:05:16 +020037/**
Swen Schillig00bab912008-06-10 18:20:57 +020038 * zfcp_qdio_free - free memory used by request- and resposne queue
39 * @adapter: pointer to the zfcp_adapter structure
Volker Sameskefea9d6c2006-08-02 11:05:16 +020040 */
Swen Schillig00bab912008-06-10 18:20:57 +020041void zfcp_qdio_free(struct zfcp_adapter *adapter)
42{
43 struct qdio_buffer **sbal_req, **sbal_resp;
44 int p;
45
46 if (adapter->ccw_device)
47 qdio_free(adapter->ccw_device);
48
49 sbal_req = adapter->req_q.sbal;
50 sbal_resp = adapter->resp_q.sbal;
51
52 for (p = 0; p < QDIO_MAX_BUFFERS_PER_Q; p += QBUFF_PER_PAGE) {
53 free_page((unsigned long) sbal_req[p]);
54 free_page((unsigned long) sbal_resp[p]);
55 }
56}
57
58static void zfcp_qdio_handler_error(struct zfcp_adapter *adapter, u8 id)
59{
60 dev_warn(&adapter->ccw_device->dev, "QDIO problem occurred.\n");
61
62 zfcp_erp_adapter_reopen(adapter,
63 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
64 ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL);
65}
66
Christof Schmitt5d4e2262008-07-02 10:56:34 +020067static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
68{
69 int i, sbal_idx;
70
71 for (i = first; i < first + cnt; i++) {
72 sbal_idx = i % QDIO_MAX_BUFFERS_PER_Q;
73 memset(sbal[sbal_idx], 0, sizeof(struct qdio_buffer));
74 }
75}
76
Jan Glauber779e6e12008-07-17 17:16:48 +020077static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
78 int queue_no, int first, int count,
Swen Schillig00bab912008-06-10 18:20:57 +020079 unsigned long parm)
80{
81 struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm;
82 struct zfcp_qdio_queue *queue = &adapter->req_q;
83
Jan Glauber779e6e12008-07-17 17:16:48 +020084 if (unlikely(qdio_err)) {
85 zfcp_hba_dbf_event_qdio(adapter, qdio_err, first, count);
Swen Schillig00bab912008-06-10 18:20:57 +020086 zfcp_qdio_handler_error(adapter, 140);
87 return;
88 }
89
90 /* cleanup all SBALs being program-owned now */
91 zfcp_qdio_zero_sbals(queue->sbal, first, count);
92
93 atomic_add(count, &queue->count);
94 wake_up(&adapter->request_wq);
95}
96
Christof Schmittb03670e2007-05-07 16:35:04 +020097static void zfcp_qdio_reqid_check(struct zfcp_adapter *adapter,
Swen Schillig00bab912008-06-10 18:20:57 +020098 unsigned long req_id, int sbal_idx)
Volker Sameskefea9d6c2006-08-02 11:05:16 +020099{
100 struct zfcp_fsf_req *fsf_req;
101 unsigned long flags;
102
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200103 spin_lock_irqsave(&adapter->req_list_lock, flags);
Heiko Carstensca2d02c2007-05-08 11:17:54 +0200104 fsf_req = zfcp_reqlist_find(adapter, req_id);
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200105
Heiko Carstensca2d02c2007-05-08 11:17:54 +0200106 if (!fsf_req)
107 /*
108 * Unknown request means that we have potentially memory
109 * corruption and must stop the machine immediatly.
110 */
Swen Schillig00bab912008-06-10 18:20:57 +0200111 panic("error: unknown request id (%lx) on adapter %s.\n",
Heiko Carstensca2d02c2007-05-08 11:17:54 +0200112 req_id, zfcp_get_busid_by_adapter(adapter));
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200113
Heiko Carstensca2d02c2007-05-08 11:17:54 +0200114 zfcp_reqlist_remove(adapter, fsf_req);
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200115 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
116
Swen Schillig00bab912008-06-10 18:20:57 +0200117 fsf_req->sbal_response = sbal_idx;
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200118 zfcp_fsf_req_complete(fsf_req);
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200119}
120
Swen Schillig00bab912008-06-10 18:20:57 +0200121static void zfcp_qdio_resp_put_back(struct zfcp_adapter *adapter, int processed)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
Swen Schillig00bab912008-06-10 18:20:57 +0200123 struct zfcp_qdio_queue *queue = &adapter->resp_q;
124 struct ccw_device *cdev = adapter->ccw_device;
125 u8 count, start = queue->first;
126 unsigned int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Swen Schillig00bab912008-06-10 18:20:57 +0200128 count = atomic_read(&queue->count) + processed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Jan Glauber779e6e12008-07-17 17:16:48 +0200130 retval = do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, start, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Swen Schillig00bab912008-06-10 18:20:57 +0200132 if (unlikely(retval)) {
133 atomic_set(&queue->count, count);
134 /* FIXME: Recover this with an adapter reopen? */
135 } else {
136 queue->first += count;
137 queue->first %= QDIO_MAX_BUFFERS_PER_Q;
138 atomic_set(&queue->count, 0);
139 }
140}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Jan Glauber779e6e12008-07-17 17:16:48 +0200142static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
143 int queue_no, int first, int count,
Swen Schillig00bab912008-06-10 18:20:57 +0200144 unsigned long parm)
145{
146 struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm;
147 struct zfcp_qdio_queue *queue = &adapter->resp_q;
148 volatile struct qdio_buffer_element *sbale;
149 int sbal_idx, sbale_idx, sbal_no;
150
Jan Glauber779e6e12008-07-17 17:16:48 +0200151 if (unlikely(qdio_err)) {
152 zfcp_hba_dbf_event_qdio(adapter, qdio_err, first, count);
Swen Schillig00bab912008-06-10 18:20:57 +0200153 zfcp_qdio_handler_error(adapter, 147);
154 return;
155 }
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 /*
158 * go through all SBALs from input queue currently
159 * returned by QDIO layer
160 */
Swen Schillig00bab912008-06-10 18:20:57 +0200161 for (sbal_no = 0; sbal_no < count; sbal_no++) {
162 sbal_idx = (first + sbal_no) % QDIO_MAX_BUFFERS_PER_Q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164 /* go through all SBALEs of SBAL */
Swen Schillig00bab912008-06-10 18:20:57 +0200165 for (sbale_idx = 0; sbale_idx < QDIO_MAX_ELEMENTS_PER_BUFFER;
166 sbale_idx++) {
167 sbale = zfcp_qdio_sbale(queue, sbal_idx, sbale_idx);
Christof Schmittb03670e2007-05-07 16:35:04 +0200168 zfcp_qdio_reqid_check(adapter,
Swen Schillig00bab912008-06-10 18:20:57 +0200169 (unsigned long) sbale->addr,
170 sbal_idx);
171 if (likely(sbale->flags & SBAL_FLAGS_LAST_ENTRY))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 break;
173 };
174
Swen Schillig00bab912008-06-10 18:20:57 +0200175 if (unlikely(!(sbale->flags & SBAL_FLAGS_LAST_ENTRY)))
176 dev_warn(&adapter->ccw_device->dev,
177 "Protocol violation by adapter. "
178 "Continuing operations.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
180
181 /*
182 * put range of SBALs back to response queue
183 * (including SBALs which have already been free before)
184 */
Swen Schillig00bab912008-06-10 18:20:57 +0200185 zfcp_qdio_resp_put_back(adapter, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186}
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/**
Swen Schillig00bab912008-06-10 18:20:57 +0200189 * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req
190 * @fsf_req: pointer to struct fsf_req
191 * Returns: pointer to qdio_buffer_element (SBALE) structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 */
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100193volatile struct qdio_buffer_element *
Swen Schillig00bab912008-06-10 18:20:57 +0200194zfcp_qdio_sbale_req(struct zfcp_fsf_req *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
Swen Schillig00bab912008-06-10 18:20:57 +0200196 return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
199/**
Swen Schillig00bab912008-06-10 18:20:57 +0200200 * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req
201 * @fsf_req: pointer to struct fsf_req
202 * Returns: pointer to qdio_buffer_element (SBALE) structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 */
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100204volatile struct qdio_buffer_element *
Swen Schillig00bab912008-06-10 18:20:57 +0200205zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
Swen Schillig00bab912008-06-10 18:20:57 +0200207 return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last,
208 req->sbale_curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
Swen Schillig00bab912008-06-10 18:20:57 +0200211static void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Swen Schillig00bab912008-06-10 18:20:57 +0200213 int count = atomic_read(&fsf_req->adapter->req_q.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 count = min(count, max_sbals);
Swen Schillig00bab912008-06-10 18:20:57 +0200215 fsf_req->sbal_limit = (fsf_req->sbal_first + count - 1)
216 % QDIO_MAX_BUFFERS_PER_Q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100219static volatile struct qdio_buffer_element *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
221{
222 volatile struct qdio_buffer_element *sbale;
223
224 /* set last entry flag in current SBALE of current SBAL */
225 sbale = zfcp_qdio_sbale_curr(fsf_req);
226 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
227
228 /* don't exceed last allowed SBAL */
Martin Peschkee891bff2008-05-19 12:17:43 +0200229 if (fsf_req->sbal_last == fsf_req->sbal_limit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return NULL;
231
232 /* set chaining flag in first SBALE of current SBAL */
Swen Schillig00bab912008-06-10 18:20:57 +0200233 sbale = zfcp_qdio_sbale_req(fsf_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
235
236 /* calculate index of next SBAL */
Martin Peschkee891bff2008-05-19 12:17:43 +0200237 fsf_req->sbal_last++;
238 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
240 /* keep this requests number of SBALs up-to-date */
241 fsf_req->sbal_number++;
242
243 /* start at first SBALE of new SBAL */
244 fsf_req->sbale_curr = 0;
245
246 /* set storage-block type for new SBAL */
247 sbale = zfcp_qdio_sbale_curr(fsf_req);
248 sbale->flags |= sbtype;
249
250 return sbale;
251}
252
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100253static volatile struct qdio_buffer_element *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
255{
256 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
257 return zfcp_qdio_sbal_chain(fsf_req, sbtype);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 fsf_req->sbale_curr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 return zfcp_qdio_sbale_curr(fsf_req);
260}
261
Swen Schillig00bab912008-06-10 18:20:57 +0200262static void zfcp_qdio_undo_sbals(struct zfcp_fsf_req *fsf_req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
Swen Schillig00bab912008-06-10 18:20:57 +0200264 struct qdio_buffer **sbal = fsf_req->adapter->req_q.sbal;
265 int first = fsf_req->sbal_first;
266 int last = fsf_req->sbal_last;
267 int count = (last - first + QDIO_MAX_BUFFERS_PER_Q) %
268 QDIO_MAX_BUFFERS_PER_Q + 1;
269 zfcp_qdio_zero_sbals(sbal, first, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
Swen Schillig00bab912008-06-10 18:20:57 +0200272static int zfcp_qdio_fill_sbals(struct zfcp_fsf_req *fsf_req,
273 unsigned int sbtype, void *start_addr,
274 unsigned int total_length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
276 volatile struct qdio_buffer_element *sbale;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 unsigned long remaining, length;
278 void *addr;
279
Swen Schillig00bab912008-06-10 18:20:57 +0200280 /* split segment up */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 for (addr = start_addr, remaining = total_length; remaining > 0;
282 addr += length, remaining -= length) {
Swen Schillig00bab912008-06-10 18:20:57 +0200283 sbale = zfcp_qdio_sbale_next(fsf_req, sbtype);
284 if (!sbale) {
285 zfcp_qdio_undo_sbals(fsf_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return -EINVAL;
287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Swen Schillig00bab912008-06-10 18:20:57 +0200289 /* new piece must not exceed next page boundary */
290 length = min(remaining,
291 (PAGE_SIZE - ((unsigned long)addr &
292 (PAGE_SIZE - 1))));
293 sbale->addr = addr;
294 sbale->length = length;
295 }
296 return 0;
297}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299/**
300 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
301 * @fsf_req: request to be processed
302 * @sbtype: SBALE flags
303 * @sg: scatter-gather list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 * @max_sbals: upper bound for number of SBALs to be used
Swen Schillig00bab912008-06-10 18:20:57 +0200305 * Returns: number of bytes, or error (negativ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 */
Swen Schillig00bab912008-06-10 18:20:57 +0200307int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
308 struct scatterlist *sg, int max_sbals)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 volatile struct qdio_buffer_element *sbale;
Swen Schillig00bab912008-06-10 18:20:57 +0200311 int retval, bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
313 /* figure out last allowed SBAL */
314 zfcp_qdio_sbal_limit(fsf_req, max_sbals);
315
Swen Schillig00bab912008-06-10 18:20:57 +0200316 /* set storage-block type for this request */
317 sbale = zfcp_qdio_sbale_req(fsf_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 sbale->flags |= sbtype;
319
Swen Schillig00bab912008-06-10 18:20:57 +0200320 for (; sg; sg = sg_next(sg)) {
321 retval = zfcp_qdio_fill_sbals(fsf_req, sbtype, sg_virt(sg),
322 sg->length);
323 if (retval < 0)
324 return retval;
325 bytes += sg->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 }
Swen Schillig00bab912008-06-10 18:20:57 +0200327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 /* assume that no other SBALEs are to follow in the same SBAL */
329 sbale = zfcp_qdio_sbale_curr(fsf_req);
330 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
Swen Schillig00bab912008-06-10 18:20:57 +0200331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 return bytes;
333}
334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335/**
Swen Schillig00bab912008-06-10 18:20:57 +0200336 * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
337 * @fsf_req: pointer to struct zfcp_fsf_req
338 * Returns: 0 on success, error otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 */
Swen Schillig00bab912008-06-10 18:20:57 +0200340int zfcp_qdio_send(struct zfcp_fsf_req *fsf_req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
Swen Schillig00bab912008-06-10 18:20:57 +0200342 struct zfcp_adapter *adapter = fsf_req->adapter;
343 struct zfcp_qdio_queue *req_q = &adapter->req_q;
344 int first = fsf_req->sbal_first;
345 int count = fsf_req->sbal_number;
346 int retval, pci, pci_batch;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 volatile struct qdio_buffer_element *sbale;
348
Swen Schillig00bab912008-06-10 18:20:57 +0200349 /* acknowledgements for transferred buffers */
350 pci_batch = req_q->pci_batch + count;
351 if (unlikely(pci_batch >= ZFCP_QDIO_PCI_INTERVAL)) {
352 pci_batch %= ZFCP_QDIO_PCI_INTERVAL;
353 pci = first + count - (pci_batch + 1);
354 pci %= QDIO_MAX_BUFFERS_PER_Q;
355 sbale = zfcp_qdio_sbale(req_q, pci, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 sbale->flags |= SBAL_FLAGS0_PCI;
357 }
Swen Schillig00bab912008-06-10 18:20:57 +0200358
359 retval = do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0, first,
Jan Glauber779e6e12008-07-17 17:16:48 +0200360 count);
Swen Schillig00bab912008-06-10 18:20:57 +0200361 if (unlikely(retval)) {
362 zfcp_qdio_zero_sbals(req_q->sbal, first, count);
363 return retval;
364 }
365
366 /* account for transferred buffers */
367 atomic_sub(count, &req_q->count);
368 req_q->first += count;
369 req_q->first %= QDIO_MAX_BUFFERS_PER_Q;
370 req_q->pci_batch = pci_batch;
371 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372}
373
Swen Schillig00bab912008-06-10 18:20:57 +0200374/**
Swen Schillig00bab912008-06-10 18:20:57 +0200375 * zfcp_qdio_allocate - allocate queue memory and initialize QDIO data
376 * @adapter: pointer to struct zfcp_adapter
377 * Returns: -ENOMEM on memory allocation error or return value from
378 * qdio_allocate
379 */
380int zfcp_qdio_allocate(struct zfcp_adapter *adapter)
381{
382 struct qdio_initialize *init_data;
383
384 if (zfcp_qdio_buffers_enqueue(adapter->req_q.sbal) ||
385 zfcp_qdio_buffers_enqueue(adapter->resp_q.sbal))
386 return -ENOMEM;
387
388 init_data = &adapter->qdio_init_data;
389
390 init_data->cdev = adapter->ccw_device;
391 init_data->q_format = QDIO_ZFCP_QFMT;
392 memcpy(init_data->adapter_name, zfcp_get_busid_by_adapter(adapter), 8);
393 ASCEBC(init_data->adapter_name, 8);
394 init_data->qib_param_field_format = 0;
395 init_data->qib_param_field = NULL;
396 init_data->input_slib_elements = NULL;
397 init_data->output_slib_elements = NULL;
Swen Schillig00bab912008-06-10 18:20:57 +0200398 init_data->no_input_qs = 1;
399 init_data->no_output_qs = 1;
400 init_data->input_handler = zfcp_qdio_int_resp;
401 init_data->output_handler = zfcp_qdio_int_req;
402 init_data->int_parm = (unsigned long) adapter;
403 init_data->flags = QDIO_INBOUND_0COPY_SBALS |
404 QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
405 init_data->input_sbal_addr_array =
406 (void **) (adapter->resp_q.sbal);
407 init_data->output_sbal_addr_array =
408 (void **) (adapter->req_q.sbal);
409
410 return qdio_allocate(init_data);
411}
412
413/**
414 * zfcp_close_qdio - close qdio queues for an adapter
415 */
416void zfcp_qdio_close(struct zfcp_adapter *adapter)
417{
418 struct zfcp_qdio_queue *req_q;
419 int first, count;
420
421 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
422 return;
423
424 /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
425 req_q = &adapter->req_q;
Swen Schilligc41f8cb2008-07-02 10:56:39 +0200426 spin_lock(&req_q->lock);
Swen Schillig00bab912008-06-10 18:20:57 +0200427 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
Swen Schilligc41f8cb2008-07-02 10:56:39 +0200428 spin_unlock(&req_q->lock);
Swen Schillig00bab912008-06-10 18:20:57 +0200429
Jan Glauber779e6e12008-07-17 17:16:48 +0200430 qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
Swen Schillig00bab912008-06-10 18:20:57 +0200431
432 /* cleanup used outbound sbals */
433 count = atomic_read(&req_q->count);
434 if (count < QDIO_MAX_BUFFERS_PER_Q) {
435 first = (req_q->first + count) % QDIO_MAX_BUFFERS_PER_Q;
436 count = QDIO_MAX_BUFFERS_PER_Q - count;
437 zfcp_qdio_zero_sbals(req_q->sbal, first, count);
438 }
439 req_q->first = 0;
440 atomic_set(&req_q->count, 0);
441 req_q->pci_batch = 0;
442 adapter->resp_q.first = 0;
443 atomic_set(&adapter->resp_q.count, 0);
444}
445
446/**
447 * zfcp_qdio_open - prepare and initialize response queue
448 * @adapter: pointer to struct zfcp_adapter
449 * Returns: 0 on success, otherwise -EIO
450 */
451int zfcp_qdio_open(struct zfcp_adapter *adapter)
452{
453 volatile struct qdio_buffer_element *sbale;
454 int cc;
455
456 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
457 return -EIO;
458
459 if (qdio_establish(&adapter->qdio_init_data)) {
460 dev_err(&adapter->ccw_device->dev,
461 "Establish of QDIO queues failed.\n");
462 return -EIO;
463 }
464
Jan Glauber779e6e12008-07-17 17:16:48 +0200465 if (qdio_activate(adapter->ccw_device)) {
Swen Schillig00bab912008-06-10 18:20:57 +0200466 dev_err(&adapter->ccw_device->dev,
467 "Activate of QDIO queues failed.\n");
468 goto failed_qdio;
469 }
470
471 for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) {
472 sbale = &(adapter->resp_q.sbal[cc]->element[0]);
473 sbale->length = 0;
474 sbale->flags = SBAL_FLAGS_LAST_ENTRY;
475 sbale->addr = NULL;
476 }
477
478 if (do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_INPUT, 0, 0,
Jan Glauber779e6e12008-07-17 17:16:48 +0200479 QDIO_MAX_BUFFERS_PER_Q)) {
Swen Schillig00bab912008-06-10 18:20:57 +0200480 dev_err(&adapter->ccw_device->dev,
481 "Init of QDIO response queue failed.\n");
482 goto failed_qdio;
483 }
484
485 /* set index of first avalable SBALS / number of available SBALS */
486 adapter->req_q.first = 0;
487 atomic_set(&adapter->req_q.count, QDIO_MAX_BUFFERS_PER_Q);
488 adapter->req_q.pci_batch = 0;
489
490 return 0;
491
492failed_qdio:
Jan Glauber779e6e12008-07-17 17:16:48 +0200493 qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
Swen Schillig00bab912008-06-10 18:20:57 +0200494 return -EIO;
495}