Commit | Line | Data |
---|---|---|
0e5d030b FT |
1 | /* |
2 | * IBM eServer i/pSeries Virtual SCSI Target Driver | |
3 | * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp. | |
4 | * Santiago Leon (santil@us.ibm.com) IBM Corp. | |
5 | * Linda Xie (lxie@us.ibm.com) IBM Corp. | |
6 | * | |
7 | * Copyright (C) 2005-2006 FUJITA Tomonori <tomof@acm.org> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | |
22 | * USA | |
23 | */ | |
24 | #include <linux/interrupt.h> | |
25 | #include <linux/module.h> | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
0e5d030b FT |
27 | #include <scsi/scsi.h> |
28 | #include <scsi/scsi_host.h> | |
17b0bcfa | 29 | #include <scsi/scsi_transport_srp.h> |
0e5d030b FT |
30 | #include <scsi/scsi_tgt.h> |
31 | #include <scsi/libsrp.h> | |
32 | #include <asm/hvcall.h> | |
33 | #include <asm/iommu.h> | |
34 | #include <asm/prom.h> | |
35 | #include <asm/vio.h> | |
36 | ||
37 | #include "ibmvscsi.h" | |
38 | ||
39 | #define INITIAL_SRP_LIMIT 16 | |
ad1331a7 | 40 | #define DEFAULT_MAX_SECTORS 256 |
0e5d030b FT |
41 | |
42 | #define TGT_NAME "ibmvstgt" | |
43 | ||
44 | /* | |
45 | * Hypervisor calls. | |
46 | */ | |
47 | #define h_copy_rdma(l, sa, sb, da, db) \ | |
48 | plpar_hcall_norets(H_COPY_RDMA, l, sa, sb, da, db) | |
49 | #define h_send_crq(ua, l, h) \ | |
50 | plpar_hcall_norets(H_SEND_CRQ, ua, l, h) | |
51 | #define h_reg_crq(ua, tok, sz)\ | |
52 | plpar_hcall_norets(H_REG_CRQ, ua, tok, sz); | |
53 | #define h_free_crq(ua) \ | |
54 | plpar_hcall_norets(H_FREE_CRQ, ua); | |
55 | ||
56 | /* tmp - will replace with SCSI logging stuff */ | |
57 | #define eprintk(fmt, args...) \ | |
58 | do { \ | |
cadbd4a5 | 59 | printk("%s(%d) " fmt, __func__, __LINE__, ##args); \ |
0e5d030b FT |
60 | } while (0) |
61 | /* #define dprintk eprintk */ | |
62 | #define dprintk(fmt, args...) | |
63 | ||
64 | struct vio_port { | |
65 | struct vio_dev *dma_dev; | |
66 | ||
67 | struct crq_queue crq_queue; | |
68 | struct work_struct crq_work; | |
69 | ||
70 | unsigned long liobn; | |
71 | unsigned long riobn; | |
2fdb611d | 72 | struct srp_target *target; |
17b0bcfa FT |
73 | |
74 | struct srp_rport *rport; | |
0e5d030b FT |
75 | }; |
76 | ||
77 | static struct workqueue_struct *vtgtd; | |
17b0bcfa | 78 | static struct scsi_transport_template *ibmvstgt_transport_template; |
0e5d030b FT |
79 | |
80 | /* | |
81 | * These are fixed for the system and come from the Open Firmware device tree. | |
82 | * We just store them here to save getting them every time. | |
83 | */ | |
84 | static char system_id[64] = ""; | |
85 | static char partition_name[97] = "UNKNOWN"; | |
86 | static unsigned int partition_number = -1; | |
87 | ||
88 | static struct vio_port *target_to_port(struct srp_target *target) | |
89 | { | |
90 | return (struct vio_port *) target->ldata; | |
91 | } | |
92 | ||
93 | static inline union viosrp_iu *vio_iu(struct iu_entry *iue) | |
94 | { | |
95 | return (union viosrp_iu *) (iue->sbuf->buf); | |
96 | } | |
97 | ||
98 | static int send_iu(struct iu_entry *iue, uint64_t length, uint8_t format) | |
99 | { | |
100 | struct srp_target *target = iue->target; | |
101 | struct vio_port *vport = target_to_port(target); | |
102 | long rc, rc1; | |
103 | union { | |
104 | struct viosrp_crq cooked; | |
105 | uint64_t raw[2]; | |
106 | } crq; | |
107 | ||
108 | /* First copy the SRP */ | |
109 | rc = h_copy_rdma(length, vport->liobn, iue->sbuf->dma, | |
110 | vport->riobn, iue->remote_token); | |
111 | ||
112 | if (rc) | |
113 | eprintk("Error %ld transferring data\n", rc); | |
114 | ||
115 | crq.cooked.valid = 0x80; | |
116 | crq.cooked.format = format; | |
117 | crq.cooked.reserved = 0x00; | |
118 | crq.cooked.timeout = 0x00; | |
119 | crq.cooked.IU_length = length; | |
120 | crq.cooked.IU_data_ptr = vio_iu(iue)->srp.rsp.tag; | |
121 | ||
122 | if (rc == 0) | |
123 | crq.cooked.status = 0x99; /* Just needs to be non-zero */ | |
124 | else | |
125 | crq.cooked.status = 0x00; | |
126 | ||
127 | rc1 = h_send_crq(vport->dma_dev->unit_address, crq.raw[0], crq.raw[1]); | |
128 | ||
129 | if (rc1) { | |
130 | eprintk("%ld sending response\n", rc1); | |
131 | return rc1; | |
132 | } | |
133 | ||
134 | return rc; | |
135 | } | |
136 | ||
137 | #define SRP_RSP_SENSE_DATA_LEN 18 | |
138 | ||
139 | static int send_rsp(struct iu_entry *iue, struct scsi_cmnd *sc, | |
140 | unsigned char status, unsigned char asc) | |
141 | { | |
142 | union viosrp_iu *iu = vio_iu(iue); | |
143 | uint64_t tag = iu->srp.rsp.tag; | |
144 | ||
145 | /* If the linked bit is on and status is good */ | |
146 | if (test_bit(V_LINKED, &iue->flags) && (status == NO_SENSE)) | |
147 | status = 0x10; | |
148 | ||
149 | memset(iu, 0, sizeof(struct srp_rsp)); | |
150 | iu->srp.rsp.opcode = SRP_RSP; | |
151 | iu->srp.rsp.req_lim_delta = 1; | |
152 | iu->srp.rsp.tag = tag; | |
153 | ||
154 | if (test_bit(V_DIOVER, &iue->flags)) | |
155 | iu->srp.rsp.flags |= SRP_RSP_FLAG_DIOVER; | |
156 | ||
157 | iu->srp.rsp.data_in_res_cnt = 0; | |
158 | iu->srp.rsp.data_out_res_cnt = 0; | |
159 | ||
160 | iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID; | |
161 | ||
162 | iu->srp.rsp.resp_data_len = 0; | |
163 | iu->srp.rsp.status = status; | |
164 | if (status) { | |
165 | uint8_t *sense = iu->srp.rsp.data; | |
166 | ||
167 | if (sc) { | |
168 | iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID; | |
169 | iu->srp.rsp.sense_data_len = SCSI_SENSE_BUFFERSIZE; | |
170 | memcpy(sense, sc->sense_buffer, SCSI_SENSE_BUFFERSIZE); | |
171 | } else { | |
172 | iu->srp.rsp.status = SAM_STAT_CHECK_CONDITION; | |
173 | iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID; | |
174 | iu->srp.rsp.sense_data_len = SRP_RSP_SENSE_DATA_LEN; | |
175 | ||
176 | /* Valid bit and 'current errors' */ | |
177 | sense[0] = (0x1 << 7 | 0x70); | |
178 | /* Sense key */ | |
179 | sense[2] = status; | |
180 | /* Additional sense length */ | |
181 | sense[7] = 0xa; /* 10 bytes */ | |
182 | /* Additional sense code */ | |
183 | sense[12] = asc; | |
184 | } | |
185 | } | |
186 | ||
187 | send_iu(iue, sizeof(iu->srp.rsp) + SRP_RSP_SENSE_DATA_LEN, | |
188 | VIOSRP_SRP_FORMAT); | |
189 | ||
190 | return 0; | |
191 | } | |
192 | ||
193 | static void handle_cmd_queue(struct srp_target *target) | |
194 | { | |
195 | struct Scsi_Host *shost = target->shost; | |
17b0bcfa | 196 | struct srp_rport *rport = target_to_port(target)->rport; |
0e5d030b FT |
197 | struct iu_entry *iue; |
198 | struct srp_cmd *cmd; | |
199 | unsigned long flags; | |
200 | int err; | |
201 | ||
202 | retry: | |
203 | spin_lock_irqsave(&target->lock, flags); | |
204 | ||
205 | list_for_each_entry(iue, &target->cmd_queue, ilist) { | |
206 | if (!test_and_set_bit(V_FLYING, &iue->flags)) { | |
207 | spin_unlock_irqrestore(&target->lock, flags); | |
208 | cmd = iue->sbuf->buf; | |
17b0bcfa FT |
209 | err = srp_cmd_queue(shost, cmd, iue, |
210 | (unsigned long)rport, 0); | |
0e5d030b FT |
211 | if (err) { |
212 | eprintk("cannot queue cmd %p %d\n", cmd, err); | |
213 | srp_iu_put(iue); | |
214 | } | |
215 | goto retry; | |
216 | } | |
217 | } | |
218 | ||
219 | spin_unlock_irqrestore(&target->lock, flags); | |
220 | } | |
221 | ||
222 | static int ibmvstgt_rdma(struct scsi_cmnd *sc, struct scatterlist *sg, int nsg, | |
223 | struct srp_direct_buf *md, int nmd, | |
224 | enum dma_data_direction dir, unsigned int rest) | |
225 | { | |
226 | struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr; | |
227 | struct srp_target *target = iue->target; | |
228 | struct vio_port *vport = target_to_port(target); | |
229 | dma_addr_t token; | |
230 | long err; | |
231 | unsigned int done = 0; | |
232 | int i, sidx, soff; | |
233 | ||
234 | sidx = soff = 0; | |
235 | token = sg_dma_address(sg + sidx); | |
236 | ||
237 | for (i = 0; i < nmd && rest; i++) { | |
238 | unsigned int mdone, mlen; | |
239 | ||
240 | mlen = min(rest, md[i].len); | |
241 | for (mdone = 0; mlen;) { | |
242 | int slen = min(sg_dma_len(sg + sidx) - soff, mlen); | |
243 | ||
244 | if (dir == DMA_TO_DEVICE) | |
245 | err = h_copy_rdma(slen, | |
246 | vport->riobn, | |
247 | md[i].va + mdone, | |
248 | vport->liobn, | |
249 | token + soff); | |
250 | else | |
251 | err = h_copy_rdma(slen, | |
252 | vport->liobn, | |
253 | token + soff, | |
254 | vport->riobn, | |
255 | md[i].va + mdone); | |
256 | ||
257 | if (err != H_SUCCESS) { | |
ad1331a7 BB |
258 | eprintk("rdma error %d %d %ld\n", dir, slen, err); |
259 | return -EIO; | |
0e5d030b FT |
260 | } |
261 | ||
262 | mlen -= slen; | |
263 | mdone += slen; | |
264 | soff += slen; | |
265 | done += slen; | |
266 | ||
267 | if (soff == sg_dma_len(sg + sidx)) { | |
268 | sidx++; | |
269 | soff = 0; | |
270 | token = sg_dma_address(sg + sidx); | |
271 | ||
272 | if (sidx > nsg) { | |
273 | eprintk("out of sg %p %d %d\n", | |
274 | iue, sidx, nsg); | |
ad1331a7 | 275 | return -EIO; |
0e5d030b FT |
276 | } |
277 | } | |
278 | }; | |
279 | ||
280 | rest -= mlen; | |
281 | } | |
0e5d030b FT |
282 | return 0; |
283 | } | |
284 | ||
0e5d030b FT |
285 | static int ibmvstgt_cmd_done(struct scsi_cmnd *sc, |
286 | void (*done)(struct scsi_cmnd *)) | |
287 | { | |
288 | unsigned long flags; | |
289 | struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr; | |
290 | struct srp_target *target = iue->target; | |
ad1331a7 | 291 | int err = 0; |
0e5d030b | 292 | |
bc7e380a | 293 | dprintk("%p %p %x %u\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0], |
21f1e91d | 294 | scsi_sg_count(sc)); |
bc7e380a | 295 | |
f10ab66f | 296 | if (scsi_sg_count(sc)) |
ad1331a7 | 297 | err = srp_transfer_data(sc, &vio_iu(iue)->srp.cmd, ibmvstgt_rdma, 1, 1); |
0e5d030b FT |
298 | |
299 | spin_lock_irqsave(&target->lock, flags); | |
300 | list_del(&iue->ilist); | |
301 | spin_unlock_irqrestore(&target->lock, flags); | |
302 | ||
ad1331a7 | 303 | if (err|| sc->result != SAM_STAT_GOOD) { |
0e5d030b FT |
304 | eprintk("operation failed %p %d %x\n", |
305 | iue, sc->result, vio_iu(iue)->srp.cmd.cdb[0]); | |
306 | send_rsp(iue, sc, HARDWARE_ERROR, 0x00); | |
307 | } else | |
308 | send_rsp(iue, sc, NO_SENSE, 0x00); | |
309 | ||
310 | done(sc); | |
311 | srp_iu_put(iue); | |
312 | return 0; | |
313 | } | |
314 | ||
315 | int send_adapter_info(struct iu_entry *iue, | |
316 | dma_addr_t remote_buffer, uint16_t length) | |
317 | { | |
318 | struct srp_target *target = iue->target; | |
319 | struct vio_port *vport = target_to_port(target); | |
320 | struct Scsi_Host *shost = target->shost; | |
321 | dma_addr_t data_token; | |
322 | struct mad_adapter_info_data *info; | |
323 | int err; | |
324 | ||
325 | info = dma_alloc_coherent(target->dev, sizeof(*info), &data_token, | |
326 | GFP_KERNEL); | |
327 | if (!info) { | |
328 | eprintk("bad dma_alloc_coherent %p\n", target); | |
329 | return 1; | |
330 | } | |
331 | ||
332 | /* Get remote info */ | |
333 | err = h_copy_rdma(sizeof(*info), vport->riobn, remote_buffer, | |
334 | vport->liobn, data_token); | |
335 | if (err == H_SUCCESS) { | |
336 | dprintk("Client connect: %s (%d)\n", | |
337 | info->partition_name, info->partition_number); | |
338 | } | |
339 | ||
340 | memset(info, 0, sizeof(*info)); | |
341 | ||
342 | strcpy(info->srp_version, "16.a"); | |
343 | strncpy(info->partition_name, partition_name, | |
344 | sizeof(info->partition_name)); | |
345 | info->partition_number = partition_number; | |
346 | info->mad_version = 1; | |
347 | info->os_type = 2; | |
348 | info->port_max_txu[0] = shost->hostt->max_sectors << 9; | |
349 | ||
350 | /* Send our info to remote */ | |
351 | err = h_copy_rdma(sizeof(*info), vport->liobn, data_token, | |
352 | vport->riobn, remote_buffer); | |
353 | ||
354 | dma_free_coherent(target->dev, sizeof(*info), info, data_token); | |
355 | ||
356 | if (err != H_SUCCESS) { | |
357 | eprintk("Error sending adapter info %d\n", err); | |
358 | return 1; | |
359 | } | |
360 | ||
361 | return 0; | |
362 | } | |
363 | ||
364 | static void process_login(struct iu_entry *iue) | |
365 | { | |
366 | union viosrp_iu *iu = vio_iu(iue); | |
367 | struct srp_login_rsp *rsp = &iu->srp.login_rsp; | |
368 | uint64_t tag = iu->srp.rsp.tag; | |
17b0bcfa FT |
369 | struct Scsi_Host *shost = iue->target->shost; |
370 | struct srp_target *target = host_to_srp_target(shost); | |
371 | struct vio_port *vport = target_to_port(target); | |
372 | struct srp_rport_identifiers ids; | |
373 | ||
374 | memset(&ids, 0, sizeof(ids)); | |
375 | sprintf(ids.port_id, "%x", vport->dma_dev->unit_address); | |
376 | ids.roles = SRP_RPORT_ROLE_INITIATOR; | |
377 | if (!vport->rport) | |
378 | vport->rport = srp_rport_add(shost, &ids); | |
0e5d030b FT |
379 | |
380 | /* TODO handle case that requested size is wrong and | |
381 | * buffer format is wrong | |
382 | */ | |
383 | memset(iu, 0, sizeof(struct srp_login_rsp)); | |
384 | rsp->opcode = SRP_LOGIN_RSP; | |
385 | rsp->req_lim_delta = INITIAL_SRP_LIMIT; | |
386 | rsp->tag = tag; | |
387 | rsp->max_it_iu_len = sizeof(union srp_iu); | |
388 | rsp->max_ti_iu_len = sizeof(union srp_iu); | |
389 | /* direct and indirect */ | |
390 | rsp->buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT; | |
391 | ||
392 | send_iu(iue, sizeof(*rsp), VIOSRP_SRP_FORMAT); | |
393 | } | |
394 | ||
395 | static inline void queue_cmd(struct iu_entry *iue) | |
396 | { | |
397 | struct srp_target *target = iue->target; | |
398 | unsigned long flags; | |
399 | ||
400 | spin_lock_irqsave(&target->lock, flags); | |
401 | list_add_tail(&iue->ilist, &target->cmd_queue); | |
402 | spin_unlock_irqrestore(&target->lock, flags); | |
403 | } | |
404 | ||
405 | static int process_tsk_mgmt(struct iu_entry *iue) | |
406 | { | |
407 | union viosrp_iu *iu = vio_iu(iue); | |
408 | int fn; | |
409 | ||
410 | dprintk("%p %u\n", iue, iu->srp.tsk_mgmt.tsk_mgmt_func); | |
411 | ||
412 | switch (iu->srp.tsk_mgmt.tsk_mgmt_func) { | |
413 | case SRP_TSK_ABORT_TASK: | |
414 | fn = ABORT_TASK; | |
415 | break; | |
416 | case SRP_TSK_ABORT_TASK_SET: | |
417 | fn = ABORT_TASK_SET; | |
418 | break; | |
419 | case SRP_TSK_CLEAR_TASK_SET: | |
420 | fn = CLEAR_TASK_SET; | |
421 | break; | |
422 | case SRP_TSK_LUN_RESET: | |
423 | fn = LOGICAL_UNIT_RESET; | |
424 | break; | |
425 | case SRP_TSK_CLEAR_ACA: | |
426 | fn = CLEAR_ACA; | |
427 | break; | |
428 | default: | |
429 | fn = 0; | |
430 | } | |
431 | if (fn) | |
17b0bcfa FT |
432 | scsi_tgt_tsk_mgmt_request(iue->target->shost, |
433 | (unsigned long)iue->target->shost, | |
434 | fn, | |
0e5d030b FT |
435 | iu->srp.tsk_mgmt.task_tag, |
436 | (struct scsi_lun *) &iu->srp.tsk_mgmt.lun, | |
437 | iue); | |
438 | else | |
439 | send_rsp(iue, NULL, ILLEGAL_REQUEST, 0x20); | |
440 | ||
441 | return !fn; | |
442 | } | |
443 | ||
444 | static int process_mad_iu(struct iu_entry *iue) | |
445 | { | |
446 | union viosrp_iu *iu = vio_iu(iue); | |
447 | struct viosrp_adapter_info *info; | |
448 | struct viosrp_host_config *conf; | |
449 | ||
450 | switch (iu->mad.empty_iu.common.type) { | |
451 | case VIOSRP_EMPTY_IU_TYPE: | |
452 | eprintk("%s\n", "Unsupported EMPTY MAD IU"); | |
453 | break; | |
454 | case VIOSRP_ERROR_LOG_TYPE: | |
455 | eprintk("%s\n", "Unsupported ERROR LOG MAD IU"); | |
456 | iu->mad.error_log.common.status = 1; | |
457 | send_iu(iue, sizeof(iu->mad.error_log), VIOSRP_MAD_FORMAT); | |
458 | break; | |
459 | case VIOSRP_ADAPTER_INFO_TYPE: | |
460 | info = &iu->mad.adapter_info; | |
461 | info->common.status = send_adapter_info(iue, info->buffer, | |
462 | info->common.length); | |
463 | send_iu(iue, sizeof(*info), VIOSRP_MAD_FORMAT); | |
464 | break; | |
465 | case VIOSRP_HOST_CONFIG_TYPE: | |
466 | conf = &iu->mad.host_config; | |
467 | conf->common.status = 1; | |
468 | send_iu(iue, sizeof(*conf), VIOSRP_MAD_FORMAT); | |
469 | break; | |
470 | default: | |
471 | eprintk("Unknown type %u\n", iu->srp.rsp.opcode); | |
472 | } | |
473 | ||
474 | return 1; | |
475 | } | |
476 | ||
477 | static int process_srp_iu(struct iu_entry *iue) | |
478 | { | |
479 | union viosrp_iu *iu = vio_iu(iue); | |
480 | int done = 1; | |
481 | u8 opcode = iu->srp.rsp.opcode; | |
482 | ||
483 | switch (opcode) { | |
484 | case SRP_LOGIN_REQ: | |
485 | process_login(iue); | |
486 | break; | |
487 | case SRP_TSK_MGMT: | |
488 | done = process_tsk_mgmt(iue); | |
489 | break; | |
490 | case SRP_CMD: | |
491 | queue_cmd(iue); | |
492 | done = 0; | |
493 | break; | |
494 | case SRP_LOGIN_RSP: | |
495 | case SRP_I_LOGOUT: | |
496 | case SRP_T_LOGOUT: | |
497 | case SRP_RSP: | |
498 | case SRP_CRED_REQ: | |
499 | case SRP_CRED_RSP: | |
500 | case SRP_AER_REQ: | |
501 | case SRP_AER_RSP: | |
502 | eprintk("Unsupported type %u\n", opcode); | |
503 | break; | |
504 | default: | |
505 | eprintk("Unknown type %u\n", opcode); | |
506 | } | |
507 | ||
508 | return done; | |
509 | } | |
510 | ||
511 | static void process_iu(struct viosrp_crq *crq, struct srp_target *target) | |
512 | { | |
513 | struct vio_port *vport = target_to_port(target); | |
514 | struct iu_entry *iue; | |
ad1331a7 BB |
515 | long err; |
516 | int done = 1; | |
0e5d030b FT |
517 | |
518 | iue = srp_iu_get(target); | |
519 | if (!iue) { | |
520 | eprintk("Error getting IU from pool, %p\n", target); | |
521 | return; | |
522 | } | |
523 | ||
524 | iue->remote_token = crq->IU_data_ptr; | |
525 | ||
526 | err = h_copy_rdma(crq->IU_length, vport->riobn, | |
527 | iue->remote_token, vport->liobn, iue->sbuf->dma); | |
528 | ||
529 | if (err != H_SUCCESS) { | |
530 | eprintk("%ld transferring data error %p\n", err, iue); | |
0e5d030b FT |
531 | goto out; |
532 | } | |
533 | ||
534 | if (crq->format == VIOSRP_MAD_FORMAT) | |
535 | done = process_mad_iu(iue); | |
536 | else | |
537 | done = process_srp_iu(iue); | |
538 | out: | |
539 | if (done) | |
540 | srp_iu_put(iue); | |
541 | } | |
542 | ||
15aafa2f | 543 | static irqreturn_t ibmvstgt_interrupt(int dummy, void *data) |
0e5d030b | 544 | { |
15aafa2f | 545 | struct srp_target *target = data; |
0e5d030b FT |
546 | struct vio_port *vport = target_to_port(target); |
547 | ||
548 | vio_disable_interrupts(vport->dma_dev); | |
549 | queue_work(vtgtd, &vport->crq_work); | |
550 | ||
551 | return IRQ_HANDLED; | |
552 | } | |
553 | ||
554 | static int crq_queue_create(struct crq_queue *queue, struct srp_target *target) | |
555 | { | |
556 | int err; | |
557 | struct vio_port *vport = target_to_port(target); | |
558 | ||
559 | queue->msgs = (struct viosrp_crq *) get_zeroed_page(GFP_KERNEL); | |
560 | if (!queue->msgs) | |
561 | goto malloc_failed; | |
562 | queue->size = PAGE_SIZE / sizeof(*queue->msgs); | |
563 | ||
564 | queue->msg_token = dma_map_single(target->dev, queue->msgs, | |
565 | queue->size * sizeof(*queue->msgs), | |
566 | DMA_BIDIRECTIONAL); | |
567 | ||
8d8bb39b | 568 | if (dma_mapping_error(target->dev, queue->msg_token)) |
0e5d030b FT |
569 | goto map_failed; |
570 | ||
571 | err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token, | |
572 | PAGE_SIZE); | |
573 | ||
574 | /* If the adapter was left active for some reason (like kexec) | |
575 | * try freeing and re-registering | |
576 | */ | |
577 | if (err == H_RESOURCE) { | |
578 | do { | |
579 | err = h_free_crq(vport->dma_dev->unit_address); | |
580 | } while (err == H_BUSY || H_IS_LONG_BUSY(err)); | |
581 | ||
582 | err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token, | |
583 | PAGE_SIZE); | |
584 | } | |
585 | ||
586 | if (err != H_SUCCESS && err != 2) { | |
587 | eprintk("Error 0x%x opening virtual adapter\n", err); | |
588 | goto reg_crq_failed; | |
589 | } | |
590 | ||
591 | err = request_irq(vport->dma_dev->irq, &ibmvstgt_interrupt, | |
38515e90 | 592 | IRQF_DISABLED, "ibmvstgt", target); |
0e5d030b FT |
593 | if (err) |
594 | goto req_irq_failed; | |
595 | ||
596 | vio_enable_interrupts(vport->dma_dev); | |
597 | ||
598 | h_send_crq(vport->dma_dev->unit_address, 0xC001000000000000, 0); | |
599 | ||
600 | queue->cur = 0; | |
601 | spin_lock_init(&queue->lock); | |
602 | ||
603 | return 0; | |
604 | ||
605 | req_irq_failed: | |
606 | do { | |
607 | err = h_free_crq(vport->dma_dev->unit_address); | |
608 | } while (err == H_BUSY || H_IS_LONG_BUSY(err)); | |
609 | ||
610 | reg_crq_failed: | |
611 | dma_unmap_single(target->dev, queue->msg_token, | |
612 | queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); | |
613 | map_failed: | |
614 | free_page((unsigned long) queue->msgs); | |
615 | ||
616 | malloc_failed: | |
617 | return -ENOMEM; | |
618 | } | |
619 | ||
620 | static void crq_queue_destroy(struct srp_target *target) | |
621 | { | |
622 | struct vio_port *vport = target_to_port(target); | |
623 | struct crq_queue *queue = &vport->crq_queue; | |
624 | int err; | |
625 | ||
626 | free_irq(vport->dma_dev->irq, target); | |
627 | do { | |
628 | err = h_free_crq(vport->dma_dev->unit_address); | |
629 | } while (err == H_BUSY || H_IS_LONG_BUSY(err)); | |
630 | ||
631 | dma_unmap_single(target->dev, queue->msg_token, | |
632 | queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); | |
633 | ||
634 | free_page((unsigned long) queue->msgs); | |
635 | } | |
636 | ||
637 | static void process_crq(struct viosrp_crq *crq, struct srp_target *target) | |
638 | { | |
639 | struct vio_port *vport = target_to_port(target); | |
640 | dprintk("%x %x\n", crq->valid, crq->format); | |
641 | ||
642 | switch (crq->valid) { | |
643 | case 0xC0: | |
644 | /* initialization */ | |
645 | switch (crq->format) { | |
646 | case 0x01: | |
647 | h_send_crq(vport->dma_dev->unit_address, | |
648 | 0xC002000000000000, 0); | |
649 | break; | |
650 | case 0x02: | |
651 | break; | |
652 | default: | |
653 | eprintk("Unknown format %u\n", crq->format); | |
654 | } | |
655 | break; | |
656 | case 0xFF: | |
657 | /* transport event */ | |
658 | break; | |
659 | case 0x80: | |
660 | /* real payload */ | |
661 | switch (crq->format) { | |
662 | case VIOSRP_SRP_FORMAT: | |
663 | case VIOSRP_MAD_FORMAT: | |
664 | process_iu(crq, target); | |
665 | break; | |
666 | case VIOSRP_OS400_FORMAT: | |
667 | case VIOSRP_AIX_FORMAT: | |
668 | case VIOSRP_LINUX_FORMAT: | |
669 | case VIOSRP_INLINE_FORMAT: | |
670 | eprintk("Unsupported format %u\n", crq->format); | |
671 | break; | |
672 | default: | |
673 | eprintk("Unknown format %u\n", crq->format); | |
674 | } | |
675 | break; | |
676 | default: | |
677 | eprintk("unknown message type 0x%02x!?\n", crq->valid); | |
678 | } | |
679 | } | |
680 | ||
681 | static inline struct viosrp_crq *next_crq(struct crq_queue *queue) | |
682 | { | |
683 | struct viosrp_crq *crq; | |
684 | unsigned long flags; | |
685 | ||
686 | spin_lock_irqsave(&queue->lock, flags); | |
687 | crq = &queue->msgs[queue->cur]; | |
688 | if (crq->valid & 0x80) { | |
689 | if (++queue->cur == queue->size) | |
690 | queue->cur = 0; | |
691 | } else | |
692 | crq = NULL; | |
693 | spin_unlock_irqrestore(&queue->lock, flags); | |
694 | ||
695 | return crq; | |
696 | } | |
697 | ||
2fdb611d | 698 | static void handle_crq(struct work_struct *work) |
0e5d030b | 699 | { |
2fdb611d AV |
700 | struct vio_port *vport = container_of(work, struct vio_port, crq_work); |
701 | struct srp_target *target = vport->target; | |
0e5d030b FT |
702 | struct viosrp_crq *crq; |
703 | int done = 0; | |
704 | ||
705 | while (!done) { | |
706 | while ((crq = next_crq(&vport->crq_queue)) != NULL) { | |
707 | process_crq(crq, target); | |
708 | crq->valid = 0x00; | |
709 | } | |
710 | ||
711 | vio_enable_interrupts(vport->dma_dev); | |
712 | ||
713 | crq = next_crq(&vport->crq_queue); | |
714 | if (crq) { | |
715 | vio_disable_interrupts(vport->dma_dev); | |
716 | process_crq(crq, target); | |
717 | crq->valid = 0x00; | |
718 | } else | |
719 | done = 1; | |
720 | } | |
721 | ||
722 | handle_cmd_queue(target); | |
723 | } | |
724 | ||
725 | ||
726 | static int ibmvstgt_eh_abort_handler(struct scsi_cmnd *sc) | |
727 | { | |
728 | unsigned long flags; | |
729 | struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr; | |
730 | struct srp_target *target = iue->target; | |
731 | ||
732 | dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]); | |
733 | ||
734 | spin_lock_irqsave(&target->lock, flags); | |
735 | list_del(&iue->ilist); | |
736 | spin_unlock_irqrestore(&target->lock, flags); | |
737 | ||
738 | srp_iu_put(iue); | |
739 | ||
740 | return 0; | |
741 | } | |
742 | ||
17b0bcfa FT |
743 | static int ibmvstgt_tsk_mgmt_response(struct Scsi_Host *shost, |
744 | u64 itn_id, u64 mid, int result) | |
0e5d030b FT |
745 | { |
746 | struct iu_entry *iue = (struct iu_entry *) ((void *) mid); | |
747 | union viosrp_iu *iu = vio_iu(iue); | |
748 | unsigned char status, asc; | |
749 | ||
750 | eprintk("%p %d\n", iue, result); | |
751 | status = NO_SENSE; | |
752 | asc = 0; | |
753 | ||
754 | switch (iu->srp.tsk_mgmt.tsk_mgmt_func) { | |
755 | case SRP_TSK_ABORT_TASK: | |
756 | asc = 0x14; | |
757 | if (result) | |
758 | status = ABORTED_COMMAND; | |
759 | break; | |
760 | default: | |
761 | break; | |
762 | } | |
763 | ||
764 | send_rsp(iue, NULL, status, asc); | |
765 | srp_iu_put(iue); | |
766 | ||
767 | return 0; | |
768 | } | |
769 | ||
17b0bcfa FT |
770 | static int ibmvstgt_it_nexus_response(struct Scsi_Host *shost, u64 itn_id, |
771 | int result) | |
772 | { | |
773 | struct srp_target *target = host_to_srp_target(shost); | |
774 | struct vio_port *vport = target_to_port(target); | |
775 | ||
776 | if (result) { | |
777 | eprintk("%p %d\n", shost, result); | |
778 | srp_rport_del(vport->rport); | |
779 | vport->rport = NULL; | |
780 | } | |
781 | return 0; | |
782 | } | |
783 | ||
ee959b00 TJ |
784 | static ssize_t system_id_show(struct device *dev, |
785 | struct device_attribute *attr, char *buf) | |
0e5d030b FT |
786 | { |
787 | return snprintf(buf, PAGE_SIZE, "%s\n", system_id); | |
788 | } | |
789 | ||
ee959b00 TJ |
790 | static ssize_t partition_number_show(struct device *dev, |
791 | struct device_attribute *attr, char *buf) | |
0e5d030b FT |
792 | { |
793 | return snprintf(buf, PAGE_SIZE, "%x\n", partition_number); | |
794 | } | |
795 | ||
ee959b00 TJ |
796 | static ssize_t unit_address_show(struct device *dev, |
797 | struct device_attribute *attr, char *buf) | |
0e5d030b | 798 | { |
ee959b00 | 799 | struct Scsi_Host *shost = class_to_shost(dev); |
0e5d030b FT |
800 | struct srp_target *target = host_to_srp_target(shost); |
801 | struct vio_port *vport = target_to_port(target); | |
802 | return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address); | |
803 | } | |
804 | ||
ee959b00 TJ |
805 | static DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL); |
806 | static DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL); | |
807 | static DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL); | |
0e5d030b | 808 | |
ee959b00 TJ |
809 | static struct device_attribute *ibmvstgt_attrs[] = { |
810 | &dev_attr_system_id, | |
811 | &dev_attr_partition_number, | |
812 | &dev_attr_unit_address, | |
0e5d030b FT |
813 | NULL, |
814 | }; | |
815 | ||
816 | static struct scsi_host_template ibmvstgt_sht = { | |
817 | .name = TGT_NAME, | |
818 | .module = THIS_MODULE, | |
819 | .can_queue = INITIAL_SRP_LIMIT, | |
820 | .sg_tablesize = SG_ALL, | |
821 | .use_clustering = DISABLE_CLUSTERING, | |
822 | .max_sectors = DEFAULT_MAX_SECTORS, | |
823 | .transfer_response = ibmvstgt_cmd_done, | |
0e5d030b | 824 | .eh_abort_handler = ibmvstgt_eh_abort_handler, |
0e5d030b FT |
825 | .shost_attrs = ibmvstgt_attrs, |
826 | .proc_name = TGT_NAME, | |
72e39ea7 | 827 | .supported_mode = MODE_TARGET, |
0e5d030b FT |
828 | }; |
829 | ||
830 | static int ibmvstgt_probe(struct vio_dev *dev, const struct vio_device_id *id) | |
831 | { | |
832 | struct Scsi_Host *shost; | |
833 | struct srp_target *target; | |
834 | struct vio_port *vport; | |
835 | unsigned int *dma, dma_size; | |
836 | int err = -ENOMEM; | |
837 | ||
838 | vport = kzalloc(sizeof(struct vio_port), GFP_KERNEL); | |
839 | if (!vport) | |
840 | return err; | |
841 | shost = scsi_host_alloc(&ibmvstgt_sht, sizeof(struct srp_target)); | |
842 | if (!shost) | |
843 | goto free_vport; | |
17b0bcfa | 844 | shost->transportt = ibmvstgt_transport_template; |
0e5d030b FT |
845 | |
846 | target = host_to_srp_target(shost); | |
847 | target->shost = shost; | |
848 | vport->dma_dev = dev; | |
849 | target->ldata = vport; | |
2fdb611d | 850 | vport->target = target; |
0e5d030b FT |
851 | err = srp_target_alloc(target, &dev->dev, INITIAL_SRP_LIMIT, |
852 | SRP_MAX_IU_LEN); | |
853 | if (err) | |
854 | goto put_host; | |
855 | ||
856 | dma = (unsigned int *) vio_get_attribute(dev, "ibm,my-dma-window", | |
857 | &dma_size); | |
858 | if (!dma || dma_size != 40) { | |
859 | eprintk("Couldn't get window property %d\n", dma_size); | |
860 | err = -EIO; | |
861 | goto free_srp_target; | |
862 | } | |
863 | vport->liobn = dma[0]; | |
864 | vport->riobn = dma[5]; | |
865 | ||
2fdb611d | 866 | INIT_WORK(&vport->crq_work, handle_crq); |
0e5d030b | 867 | |
57458036 | 868 | err = scsi_add_host(shost, target->dev); |
0e5d030b FT |
869 | if (err) |
870 | goto free_srp_target; | |
871 | ||
57458036 | 872 | err = scsi_tgt_alloc_queue(shost); |
0e5d030b | 873 | if (err) |
57458036 | 874 | goto remove_host; |
0e5d030b | 875 | |
57458036 | 876 | err = crq_queue_create(&vport->crq_queue, target); |
b560665c | 877 | if (err) |
57458036 | 878 | goto free_queue; |
b560665c | 879 | |
17b0bcfa | 880 | return 0; |
57458036 BK |
881 | free_queue: |
882 | scsi_tgt_free_queue(shost); | |
883 | remove_host: | |
884 | scsi_remove_host(shost); | |
0e5d030b FT |
885 | free_srp_target: |
886 | srp_target_free(target); | |
887 | put_host: | |
888 | scsi_host_put(shost); | |
889 | free_vport: | |
890 | kfree(vport); | |
891 | return err; | |
892 | } | |
893 | ||
894 | static int ibmvstgt_remove(struct vio_dev *dev) | |
895 | { | |
559fde70 | 896 | struct srp_target *target = dev_get_drvdata(&dev->dev); |
0e5d030b FT |
897 | struct Scsi_Host *shost = target->shost; |
898 | struct vio_port *vport = target->ldata; | |
899 | ||
900 | crq_queue_destroy(target); | |
17b0bcfa | 901 | srp_remove_host(shost); |
0e5d030b FT |
902 | scsi_remove_host(shost); |
903 | scsi_tgt_free_queue(shost); | |
904 | srp_target_free(target); | |
905 | kfree(vport); | |
906 | scsi_host_put(shost); | |
907 | return 0; | |
908 | } | |
909 | ||
910 | static struct vio_device_id ibmvstgt_device_table[] __devinitdata = { | |
911 | {"v-scsi-host", "IBM,v-scsi-host"}, | |
912 | {"",""} | |
913 | }; | |
914 | ||
915 | MODULE_DEVICE_TABLE(vio, ibmvstgt_device_table); | |
916 | ||
917 | static struct vio_driver ibmvstgt_driver = { | |
918 | .id_table = ibmvstgt_device_table, | |
919 | .probe = ibmvstgt_probe, | |
920 | .remove = ibmvstgt_remove, | |
cb52d897 | 921 | .name = "ibmvscsis", |
0e5d030b FT |
922 | }; |
923 | ||
924 | static int get_system_info(void) | |
925 | { | |
926 | struct device_node *rootdn; | |
927 | const char *id, *model, *name; | |
a7edd0e6 | 928 | const unsigned int *num; |
0e5d030b | 929 | |
8c8dc322 | 930 | rootdn = of_find_node_by_path("/"); |
0e5d030b FT |
931 | if (!rootdn) |
932 | return -ENOENT; | |
933 | ||
40cd3a45 SR |
934 | model = of_get_property(rootdn, "model", NULL); |
935 | id = of_get_property(rootdn, "system-id", NULL); | |
0e5d030b FT |
936 | if (model && id) |
937 | snprintf(system_id, sizeof(system_id), "%s-%s", model, id); | |
938 | ||
40cd3a45 | 939 | name = of_get_property(rootdn, "ibm,partition-name", NULL); |
0e5d030b FT |
940 | if (name) |
941 | strncpy(partition_name, name, sizeof(partition_name)); | |
942 | ||
40cd3a45 | 943 | num = of_get_property(rootdn, "ibm,partition-no", NULL); |
0e5d030b FT |
944 | if (num) |
945 | partition_number = *num; | |
946 | ||
8c8dc322 | 947 | of_node_put(rootdn); |
0e5d030b FT |
948 | return 0; |
949 | } | |
950 | ||
17b0bcfa | 951 | static struct srp_function_template ibmvstgt_transport_functions = { |
e9906fe8 | 952 | .tsk_mgmt_response = ibmvstgt_tsk_mgmt_response, |
17b0bcfa FT |
953 | .it_nexus_response = ibmvstgt_it_nexus_response, |
954 | }; | |
955 | ||
b5833cbb | 956 | static int __init ibmvstgt_init(void) |
0e5d030b FT |
957 | { |
958 | int err = -ENOMEM; | |
959 | ||
960 | printk("IBM eServer i/pSeries Virtual SCSI Target Driver\n"); | |
961 | ||
17b0bcfa FT |
962 | ibmvstgt_transport_template = |
963 | srp_attach_transport(&ibmvstgt_transport_functions); | |
964 | if (!ibmvstgt_transport_template) | |
965 | return err; | |
966 | ||
0e5d030b FT |
967 | vtgtd = create_workqueue("ibmvtgtd"); |
968 | if (!vtgtd) | |
17b0bcfa | 969 | goto release_transport; |
0e5d030b FT |
970 | |
971 | err = get_system_info(); | |
972 | if (err) | |
973 | goto destroy_wq; | |
974 | ||
975 | err = vio_register_driver(&ibmvstgt_driver); | |
976 | if (err) | |
977 | goto destroy_wq; | |
978 | ||
979 | return 0; | |
0e5d030b FT |
980 | destroy_wq: |
981 | destroy_workqueue(vtgtd); | |
17b0bcfa FT |
982 | release_transport: |
983 | srp_release_transport(ibmvstgt_transport_template); | |
0e5d030b FT |
984 | return err; |
985 | } | |
986 | ||
b5833cbb | 987 | static void __exit ibmvstgt_exit(void) |
0e5d030b FT |
988 | { |
989 | printk("Unregister IBM virtual SCSI driver\n"); | |
990 | ||
991 | destroy_workqueue(vtgtd); | |
992 | vio_unregister_driver(&ibmvstgt_driver); | |
17b0bcfa | 993 | srp_release_transport(ibmvstgt_transport_template); |
0e5d030b FT |
994 | } |
995 | ||
996 | MODULE_DESCRIPTION("IBM Virtual SCSI Target"); | |
997 | MODULE_AUTHOR("Santiago Leon"); | |
998 | MODULE_LICENSE("GPL"); | |
999 | ||
1000 | module_init(ibmvstgt_init); | |
1001 | module_exit(ibmvstgt_exit); |