1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63#include <linux/module.h>
64#include <linux/moduleparam.h>
65#include <linux/dma-mapping.h>
66#include <linux/delay.h>
67#include <linux/slab.h>
68#include <linux/of.h>
69#include <linux/pm.h>
70#include <linux/kthread.h>
71#include <asm/firmware.h>
72#include <asm/vio.h>
73#include <scsi/scsi.h>
74#include <scsi/scsi_cmnd.h>
75#include <scsi/scsi_host.h>
76#include <scsi/scsi_device.h>
77#include <scsi/scsi_transport_srp.h>
78#include "ibmvscsi.h"
79
80
81
82
83
84
85static int max_id = 64;
86static int max_channel = 3;
87static int init_timeout = 300;
88static int login_timeout = 60;
89static int info_timeout = 30;
90static int abort_timeout = 60;
91static int reset_timeout = 60;
92static int max_requests = IBMVSCSI_MAX_REQUESTS_DEFAULT;
93static int max_events = IBMVSCSI_MAX_REQUESTS_DEFAULT + 2;
94static int fast_fail = 1;
95static int client_reserve = 1;
96static char partition_name[97] = "UNKNOWN";
97static unsigned int partition_number = -1;
98
99static struct scsi_transport_template *ibmvscsi_transport_template;
100
101#define IBMVSCSI_VERSION "1.5.9"
102
103MODULE_DESCRIPTION("IBM Virtual SCSI");
104MODULE_AUTHOR("Dave Boutcher");
105MODULE_LICENSE("GPL");
106MODULE_VERSION(IBMVSCSI_VERSION);
107
108module_param_named(max_id, max_id, int, S_IRUGO | S_IWUSR);
109MODULE_PARM_DESC(max_id, "Largest ID value for each channel [Default=64]");
110module_param_named(max_channel, max_channel, int, S_IRUGO | S_IWUSR);
111MODULE_PARM_DESC(max_channel, "Largest channel value [Default=3]");
112module_param_named(init_timeout, init_timeout, int, S_IRUGO | S_IWUSR);
113MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds");
114module_param_named(max_requests, max_requests, int, S_IRUGO);
115MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter");
116module_param_named(fast_fail, fast_fail, int, S_IRUGO | S_IWUSR);
117MODULE_PARM_DESC(fast_fail, "Enable fast fail. [Default=1]");
118module_param_named(client_reserve, client_reserve, int, S_IRUGO );
119MODULE_PARM_DESC(client_reserve, "Attempt client managed reserve/release");
120
121static void ibmvscsi_handle_crq(struct viosrp_crq *crq,
122 struct ibmvscsi_host_data *hostdata);
123
124
125
126
127
128
129
130
131
132
133
134
135static irqreturn_t ibmvscsi_handle_event(int irq, void *dev_instance)
136{
137 struct ibmvscsi_host_data *hostdata =
138 (struct ibmvscsi_host_data *)dev_instance;
139 vio_disable_interrupts(to_vio_dev(hostdata->dev));
140 tasklet_schedule(&hostdata->srp_task);
141 return IRQ_HANDLED;
142}
143
144
145
146
147
148
149
150
151
152static void ibmvscsi_release_crq_queue(struct crq_queue *queue,
153 struct ibmvscsi_host_data *hostdata,
154 int max_requests)
155{
156 long rc = 0;
157 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
158 free_irq(vdev->irq, (void *)hostdata);
159 tasklet_kill(&hostdata->srp_task);
160 do {
161 if (rc)
162 msleep(100);
163 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
164 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
165 dma_unmap_single(hostdata->dev,
166 queue->msg_token,
167 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
168 free_page((unsigned long)queue->msgs);
169}
170
171
172
173
174
175
176
177
178static struct viosrp_crq *crq_queue_next_crq(struct crq_queue *queue)
179{
180 struct viosrp_crq *crq;
181 unsigned long flags;
182
183 spin_lock_irqsave(&queue->lock, flags);
184 crq = &queue->msgs[queue->cur];
185 if (crq->valid != VIOSRP_CRQ_FREE) {
186 if (++queue->cur == queue->size)
187 queue->cur = 0;
188
189
190
191
192 rmb();
193 } else
194 crq = NULL;
195 spin_unlock_irqrestore(&queue->lock, flags);
196
197 return crq;
198}
199
200
201
202
203
204
205
206static int ibmvscsi_send_crq(struct ibmvscsi_host_data *hostdata,
207 u64 word1, u64 word2)
208{
209 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
210
211
212
213
214
215 mb();
216 return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
217}
218
219
220
221
222
223static void ibmvscsi_task(void *data)
224{
225 struct ibmvscsi_host_data *hostdata = (struct ibmvscsi_host_data *)data;
226 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
227 struct viosrp_crq *crq;
228 int done = 0;
229
230 while (!done) {
231
232 while ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) {
233 ibmvscsi_handle_crq(crq, hostdata);
234 crq->valid = VIOSRP_CRQ_FREE;
235 }
236
237 vio_enable_interrupts(vdev);
238 crq = crq_queue_next_crq(&hostdata->queue);
239 if (crq != NULL) {
240 vio_disable_interrupts(vdev);
241 ibmvscsi_handle_crq(crq, hostdata);
242 crq->valid = VIOSRP_CRQ_FREE;
243 } else {
244 done = 1;
245 }
246 }
247}
248
249static void gather_partition_info(void)
250{
251 const char *ppartition_name;
252 const __be32 *p_number_ptr;
253
254
255 if (!of_root)
256 return;
257
258 of_node_get(of_root);
259
260 ppartition_name = of_get_property(of_root, "ibm,partition-name", NULL);
261 if (ppartition_name)
262 strncpy(partition_name, ppartition_name,
263 sizeof(partition_name));
264 p_number_ptr = of_get_property(of_root, "ibm,partition-no", NULL);
265 if (p_number_ptr)
266 partition_number = of_read_number(p_number_ptr, 1);
267 of_node_put(of_root);
268}
269
270static void set_adapter_info(struct ibmvscsi_host_data *hostdata)
271{
272 memset(&hostdata->madapter_info, 0x00,
273 sizeof(hostdata->madapter_info));
274
275 dev_info(hostdata->dev, "SRP_VERSION: %s\n", SRP_VERSION);
276 strcpy(hostdata->madapter_info.srp_version, SRP_VERSION);
277
278 strncpy(hostdata->madapter_info.partition_name, partition_name,
279 sizeof(hostdata->madapter_info.partition_name));
280
281 hostdata->madapter_info.partition_number =
282 cpu_to_be32(partition_number);
283
284 hostdata->madapter_info.mad_version = cpu_to_be32(SRP_MAD_VERSION_1);
285 hostdata->madapter_info.os_type = cpu_to_be32(SRP_MAD_OS_LINUX);
286}
287
288
289
290
291
292
293
294static int ibmvscsi_reset_crq_queue(struct crq_queue *queue,
295 struct ibmvscsi_host_data *hostdata)
296{
297 int rc = 0;
298 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
299
300
301 do {
302 if (rc)
303 msleep(100);
304 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
305 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
306
307
308 memset(queue->msgs, 0x00, PAGE_SIZE);
309 queue->cur = 0;
310
311 set_adapter_info(hostdata);
312
313
314 rc = plpar_hcall_norets(H_REG_CRQ,
315 vdev->unit_address,
316 queue->msg_token, PAGE_SIZE);
317 if (rc == H_CLOSED) {
318
319 dev_warn(hostdata->dev, "Partner adapter not ready\n");
320 } else if (rc != 0) {
321 dev_warn(hostdata->dev, "couldn't register crq--rc 0x%x\n", rc);
322 }
323 return rc;
324}
325
326
327
328
329
330
331
332
333
334
335static int ibmvscsi_init_crq_queue(struct crq_queue *queue,
336 struct ibmvscsi_host_data *hostdata,
337 int max_requests)
338{
339 int rc;
340 int retrc;
341 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
342
343 queue->msgs = (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL);
344
345 if (!queue->msgs)
346 goto malloc_failed;
347 queue->size = PAGE_SIZE / sizeof(*queue->msgs);
348
349 queue->msg_token = dma_map_single(hostdata->dev, queue->msgs,
350 queue->size * sizeof(*queue->msgs),
351 DMA_BIDIRECTIONAL);
352
353 if (dma_mapping_error(hostdata->dev, queue->msg_token))
354 goto map_failed;
355
356 gather_partition_info();
357 set_adapter_info(hostdata);
358
359 retrc = rc = plpar_hcall_norets(H_REG_CRQ,
360 vdev->unit_address,
361 queue->msg_token, PAGE_SIZE);
362 if (rc == H_RESOURCE)
363
364 rc = ibmvscsi_reset_crq_queue(queue,
365 hostdata);
366
367 if (rc == H_CLOSED) {
368
369 dev_warn(hostdata->dev, "Partner adapter not ready\n");
370 retrc = 0;
371 } else if (rc != 0) {
372 dev_warn(hostdata->dev, "Error %d opening adapter\n", rc);
373 goto reg_crq_failed;
374 }
375
376 queue->cur = 0;
377 spin_lock_init(&queue->lock);
378
379 tasklet_init(&hostdata->srp_task, (void *)ibmvscsi_task,
380 (unsigned long)hostdata);
381
382 if (request_irq(vdev->irq,
383 ibmvscsi_handle_event,
384 0, "ibmvscsi", (void *)hostdata) != 0) {
385 dev_err(hostdata->dev, "couldn't register irq 0x%x\n",
386 vdev->irq);
387 goto req_irq_failed;
388 }
389
390 rc = vio_enable_interrupts(vdev);
391 if (rc != 0) {
392 dev_err(hostdata->dev, "Error %d enabling interrupts!!!\n", rc);
393 goto req_irq_failed;
394 }
395
396 return retrc;
397
398 req_irq_failed:
399 tasklet_kill(&hostdata->srp_task);
400 rc = 0;
401 do {
402 if (rc)
403 msleep(100);
404 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
405 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
406 reg_crq_failed:
407 dma_unmap_single(hostdata->dev,
408 queue->msg_token,
409 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
410 map_failed:
411 free_page((unsigned long)queue->msgs);
412 malloc_failed:
413 return -1;
414}
415
416
417
418
419
420
421
422static int ibmvscsi_reenable_crq_queue(struct crq_queue *queue,
423 struct ibmvscsi_host_data *hostdata)
424{
425 int rc = 0;
426 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
427
428
429 do {
430 if (rc)
431 msleep(100);
432 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
433 } while ((rc == H_IN_PROGRESS) || (rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
434
435 if (rc)
436 dev_err(hostdata->dev, "Error %d enabling adapter\n", rc);
437 return rc;
438}
439
440
441
442
443
444
445
446
447
448
449
450
451static int initialize_event_pool(struct event_pool *pool,
452 int size, struct ibmvscsi_host_data *hostdata)
453{
454 int i;
455
456 pool->size = size;
457 pool->next = 0;
458 pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL);
459 if (!pool->events)
460 return -ENOMEM;
461
462 pool->iu_storage =
463 dma_alloc_coherent(hostdata->dev,
464 pool->size * sizeof(*pool->iu_storage),
465 &pool->iu_token, 0);
466 if (!pool->iu_storage) {
467 kfree(pool->events);
468 return -ENOMEM;
469 }
470
471 for (i = 0; i < pool->size; ++i) {
472 struct srp_event_struct *evt = &pool->events[i];
473 memset(&evt->crq, 0x00, sizeof(evt->crq));
474 atomic_set(&evt->free, 1);
475 evt->crq.valid = VIOSRP_CRQ_CMD_RSP;
476 evt->crq.IU_length = cpu_to_be16(sizeof(*evt->xfer_iu));
477 evt->crq.IU_data_ptr = cpu_to_be64(pool->iu_token +
478 sizeof(*evt->xfer_iu) * i);
479 evt->xfer_iu = pool->iu_storage + i;
480 evt->hostdata = hostdata;
481 evt->ext_list = NULL;
482 evt->ext_list_token = 0;
483 }
484
485 return 0;
486}
487
488
489
490
491
492
493
494
495static void release_event_pool(struct event_pool *pool,
496 struct ibmvscsi_host_data *hostdata)
497{
498 int i, in_use = 0;
499 for (i = 0; i < pool->size; ++i) {
500 if (atomic_read(&pool->events[i].free) != 1)
501 ++in_use;
502 if (pool->events[i].ext_list) {
503 dma_free_coherent(hostdata->dev,
504 SG_ALL * sizeof(struct srp_direct_buf),
505 pool->events[i].ext_list,
506 pool->events[i].ext_list_token);
507 }
508 }
509 if (in_use)
510 dev_warn(hostdata->dev, "releasing event pool with %d "
511 "events still in use?\n", in_use);
512 kfree(pool->events);
513 dma_free_coherent(hostdata->dev,
514 pool->size * sizeof(*pool->iu_storage),
515 pool->iu_storage, pool->iu_token);
516}
517
518
519
520
521
522
523
524
525static int valid_event_struct(struct event_pool *pool,
526 struct srp_event_struct *evt)
527{
528 int index = evt - pool->events;
529 if (index < 0 || index >= pool->size)
530 return 0;
531 if (evt != pool->events + index)
532 return 0;
533 return 1;
534}
535
536
537
538
539
540
541
542static void free_event_struct(struct event_pool *pool,
543 struct srp_event_struct *evt)
544{
545 if (!valid_event_struct(pool, evt)) {
546 dev_err(evt->hostdata->dev, "Freeing invalid event_struct %p "
547 "(not in pool %p)\n", evt, pool->events);
548 return;
549 }
550 if (atomic_inc_return(&evt->free) != 1) {
551 dev_err(evt->hostdata->dev, "Freeing event_struct %p "
552 "which is not in use!\n", evt);
553 return;
554 }
555}
556
557
558
559
560
561
562
563
564
565static struct srp_event_struct *get_event_struct(struct event_pool *pool)
566{
567 int i;
568 int poolsize = pool->size;
569 int offset = pool->next;
570
571 for (i = 0; i < poolsize; i++) {
572 offset = (offset + 1) % poolsize;
573 if (!atomic_dec_if_positive(&pool->events[offset].free)) {
574 pool->next = offset;
575 return &pool->events[offset];
576 }
577 }
578
579 printk(KERN_ERR "ibmvscsi: found no event struct in pool!\n");
580 return NULL;
581}
582
583
584
585
586
587
588
589
590
591static void init_event_struct(struct srp_event_struct *evt_struct,
592 void (*done) (struct srp_event_struct *),
593 u8 format,
594 int timeout)
595{
596 evt_struct->cmnd = NULL;
597 evt_struct->cmnd_done = NULL;
598 evt_struct->sync_srp = NULL;
599 evt_struct->crq.format = format;
600 evt_struct->crq.timeout = cpu_to_be16(timeout);
601 evt_struct->done = done;
602}
603
604
605
606
607
608
609
610
611
612
613static void set_srp_direction(struct scsi_cmnd *cmd,
614 struct srp_cmd *srp_cmd,
615 int numbuf)
616{
617 u8 fmt;
618
619 if (numbuf == 0)
620 return;
621
622 if (numbuf == 1)
623 fmt = SRP_DATA_DESC_DIRECT;
624 else {
625 fmt = SRP_DATA_DESC_INDIRECT;
626 numbuf = min(numbuf, MAX_INDIRECT_BUFS);
627
628 if (cmd->sc_data_direction == DMA_TO_DEVICE)
629 srp_cmd->data_out_desc_cnt = numbuf;
630 else
631 srp_cmd->data_in_desc_cnt = numbuf;
632 }
633
634 if (cmd->sc_data_direction == DMA_TO_DEVICE)
635 srp_cmd->buf_fmt = fmt << 4;
636 else
637 srp_cmd->buf_fmt = fmt;
638}
639
640
641
642
643
644
645
646static void unmap_cmd_data(struct srp_cmd *cmd,
647 struct srp_event_struct *evt_struct,
648 struct device *dev)
649{
650 u8 out_fmt, in_fmt;
651
652 out_fmt = cmd->buf_fmt >> 4;
653 in_fmt = cmd->buf_fmt & ((1U << 4) - 1);
654
655 if (out_fmt == SRP_NO_DATA_DESC && in_fmt == SRP_NO_DATA_DESC)
656 return;
657
658 if (evt_struct->cmnd)
659 scsi_dma_unmap(evt_struct->cmnd);
660}
661
662static int map_sg_list(struct scsi_cmnd *cmd, int nseg,
663 struct srp_direct_buf *md)
664{
665 int i;
666 struct scatterlist *sg;
667 u64 total_length = 0;
668
669 scsi_for_each_sg(cmd, sg, nseg, i) {
670 struct srp_direct_buf *descr = md + i;
671 descr->va = cpu_to_be64(sg_dma_address(sg));
672 descr->len = cpu_to_be32(sg_dma_len(sg));
673 descr->key = 0;
674 total_length += sg_dma_len(sg);
675 }
676 return total_length;
677}
678
679
680
681
682
683
684
685
686
687
688static int map_sg_data(struct scsi_cmnd *cmd,
689 struct srp_event_struct *evt_struct,
690 struct srp_cmd *srp_cmd, struct device *dev)
691{
692
693 int sg_mapped;
694 u64 total_length = 0;
695 struct srp_direct_buf *data =
696 (struct srp_direct_buf *) srp_cmd->add_data;
697 struct srp_indirect_buf *indirect =
698 (struct srp_indirect_buf *) data;
699
700 sg_mapped = scsi_dma_map(cmd);
701 if (!sg_mapped)
702 return 1;
703 else if (sg_mapped < 0)
704 return 0;
705
706 set_srp_direction(cmd, srp_cmd, sg_mapped);
707
708
709 if (sg_mapped == 1) {
710 map_sg_list(cmd, sg_mapped, data);
711 return 1;
712 }
713
714 indirect->table_desc.va = 0;
715 indirect->table_desc.len = cpu_to_be32(sg_mapped *
716 sizeof(struct srp_direct_buf));
717 indirect->table_desc.key = 0;
718
719 if (sg_mapped <= MAX_INDIRECT_BUFS) {
720 total_length = map_sg_list(cmd, sg_mapped,
721 &indirect->desc_list[0]);
722 indirect->len = cpu_to_be32(total_length);
723 return 1;
724 }
725
726
727 if (!evt_struct->ext_list) {
728 evt_struct->ext_list = (struct srp_direct_buf *)
729 dma_alloc_coherent(dev,
730 SG_ALL * sizeof(struct srp_direct_buf),
731 &evt_struct->ext_list_token, 0);
732 if (!evt_struct->ext_list) {
733 if (!firmware_has_feature(FW_FEATURE_CMO))
734 sdev_printk(KERN_ERR, cmd->device,
735 "Can't allocate memory "
736 "for indirect table\n");
737 scsi_dma_unmap(cmd);
738 return 0;
739 }
740 }
741
742 total_length = map_sg_list(cmd, sg_mapped, evt_struct->ext_list);
743
744 indirect->len = cpu_to_be32(total_length);
745 indirect->table_desc.va = cpu_to_be64(evt_struct->ext_list_token);
746 indirect->table_desc.len = cpu_to_be32(sg_mapped *
747 sizeof(indirect->desc_list[0]));
748 memcpy(indirect->desc_list, evt_struct->ext_list,
749 MAX_INDIRECT_BUFS * sizeof(struct srp_direct_buf));
750 return 1;
751}
752
753
754
755
756
757
758
759
760
761
762static int map_data_for_srp_cmd(struct scsi_cmnd *cmd,
763 struct srp_event_struct *evt_struct,
764 struct srp_cmd *srp_cmd, struct device *dev)
765{
766 switch (cmd->sc_data_direction) {
767 case DMA_FROM_DEVICE:
768 case DMA_TO_DEVICE:
769 break;
770 case DMA_NONE:
771 return 1;
772 case DMA_BIDIRECTIONAL:
773 sdev_printk(KERN_ERR, cmd->device,
774 "Can't map DMA_BIDIRECTIONAL to read/write\n");
775 return 0;
776 default:
777 sdev_printk(KERN_ERR, cmd->device,
778 "Unknown data direction 0x%02x; can't map!\n",
779 cmd->sc_data_direction);
780 return 0;
781 }
782
783 return map_sg_data(cmd, evt_struct, srp_cmd, dev);
784}
785
786
787
788
789
790static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code)
791{
792 struct srp_event_struct *evt;
793 unsigned long flags;
794
795 spin_lock_irqsave(hostdata->host->host_lock, flags);
796 while (!list_empty(&hostdata->sent)) {
797 evt = list_first_entry(&hostdata->sent, struct srp_event_struct, list);
798 list_del(&evt->list);
799 del_timer(&evt->timer);
800
801 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
802 if (evt->cmnd) {
803 evt->cmnd->result = (error_code << 16);
804 unmap_cmd_data(&evt->iu.srp.cmd, evt,
805 evt->hostdata->dev);
806 if (evt->cmnd_done)
807 evt->cmnd_done(evt->cmnd);
808 } else if (evt->done && evt->crq.format != VIOSRP_MAD_FORMAT &&
809 evt->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
810 evt->done(evt);
811 free_event_struct(&evt->hostdata->pool, evt);
812 spin_lock_irqsave(hostdata->host->host_lock, flags);
813 }
814 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
815}
816
817
818
819
820
821static void ibmvscsi_reset_host(struct ibmvscsi_host_data *hostdata)
822{
823 scsi_block_requests(hostdata->host);
824 atomic_set(&hostdata->request_limit, 0);
825
826 purge_requests(hostdata, DID_ERROR);
827 hostdata->reset_crq = 1;
828 wake_up(&hostdata->work_wait_q);
829}
830
831
832
833
834
835
836
837static void ibmvscsi_timeout(struct srp_event_struct *evt_struct)
838{
839 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
840
841 dev_err(hostdata->dev, "Command timed out (%x). Resetting connection\n",
842 evt_struct->iu.srp.cmd.opcode);
843
844 ibmvscsi_reset_host(hostdata);
845}
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
861 struct ibmvscsi_host_data *hostdata,
862 unsigned long timeout)
863{
864 __be64 *crq_as_u64 = (__be64 *)&evt_struct->crq;
865 int request_status = 0;
866 int rc;
867 int srp_req = 0;
868
869
870
871
872
873
874
875 if (evt_struct->crq.format == VIOSRP_SRP_FORMAT) {
876 srp_req = 1;
877 request_status =
878 atomic_dec_if_positive(&hostdata->request_limit);
879
880
881
882 if (request_status < -1)
883 goto send_error;
884
885
886
887
888
889 else if (request_status == -1 &&
890 evt_struct->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
891 goto send_busy;
892
893
894
895
896 else if (request_status < 2 &&
897 evt_struct->iu.srp.cmd.opcode != SRP_TSK_MGMT) {
898
899
900
901
902
903
904
905 int server_limit = request_status;
906 struct srp_event_struct *tmp_evt;
907
908 list_for_each_entry(tmp_evt, &hostdata->sent, list) {
909 server_limit++;
910 }
911
912 if (server_limit > 2)
913 goto send_busy;
914 }
915 }
916
917
918 *evt_struct->xfer_iu = evt_struct->iu;
919 evt_struct->xfer_iu->srp.rsp.tag = (u64)evt_struct;
920
921
922
923
924
925 list_add_tail(&evt_struct->list, &hostdata->sent);
926
927 init_timer(&evt_struct->timer);
928 if (timeout) {
929 evt_struct->timer.data = (unsigned long) evt_struct;
930 evt_struct->timer.expires = jiffies + (timeout * HZ);
931 evt_struct->timer.function = (void (*)(unsigned long))ibmvscsi_timeout;
932 add_timer(&evt_struct->timer);
933 }
934
935 rc = ibmvscsi_send_crq(hostdata, be64_to_cpu(crq_as_u64[0]),
936 be64_to_cpu(crq_as_u64[1]));
937 if (rc != 0) {
938 list_del(&evt_struct->list);
939 del_timer(&evt_struct->timer);
940
941
942
943
944
945
946 if (rc == H_CLOSED) {
947 dev_warn(hostdata->dev, "send warning. "
948 "Receive queue closed, will retry.\n");
949 goto send_busy;
950 }
951 dev_err(hostdata->dev, "send error %d\n", rc);
952 if (srp_req)
953 atomic_inc(&hostdata->request_limit);
954 goto send_error;
955 }
956
957 return 0;
958
959 send_busy:
960 unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
961
962 free_event_struct(&hostdata->pool, evt_struct);
963 if (srp_req && request_status != -1)
964 atomic_inc(&hostdata->request_limit);
965 return SCSI_MLQUEUE_HOST_BUSY;
966
967 send_error:
968 unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
969
970 if (evt_struct->cmnd != NULL) {
971 evt_struct->cmnd->result = DID_ERROR << 16;
972 evt_struct->cmnd_done(evt_struct->cmnd);
973 } else if (evt_struct->done)
974 evt_struct->done(evt_struct);
975
976 free_event_struct(&hostdata->pool, evt_struct);
977 return 0;
978}
979
980
981
982
983
984
985
986
987static void handle_cmd_rsp(struct srp_event_struct *evt_struct)
988{
989 struct srp_rsp *rsp = &evt_struct->xfer_iu->srp.rsp;
990 struct scsi_cmnd *cmnd = evt_struct->cmnd;
991
992 if (unlikely(rsp->opcode != SRP_RSP)) {
993 if (printk_ratelimit())
994 dev_warn(evt_struct->hostdata->dev,
995 "bad SRP RSP type %d\n", rsp->opcode);
996 }
997
998 if (cmnd) {
999 cmnd->result |= rsp->status;
1000 if (((cmnd->result >> 1) & 0x1f) == CHECK_CONDITION)
1001 memcpy(cmnd->sense_buffer,
1002 rsp->data,
1003 be32_to_cpu(rsp->sense_data_len));
1004 unmap_cmd_data(&evt_struct->iu.srp.cmd,
1005 evt_struct,
1006 evt_struct->hostdata->dev);
1007
1008 if (rsp->flags & SRP_RSP_FLAG_DOOVER)
1009 scsi_set_resid(cmnd,
1010 be32_to_cpu(rsp->data_out_res_cnt));
1011 else if (rsp->flags & SRP_RSP_FLAG_DIOVER)
1012 scsi_set_resid(cmnd, be32_to_cpu(rsp->data_in_res_cnt));
1013 }
1014
1015 if (evt_struct->cmnd_done)
1016 evt_struct->cmnd_done(cmnd);
1017}
1018
1019
1020
1021
1022
1023
1024static inline u16 lun_from_dev(struct scsi_device *dev)
1025{
1026 return (0x2 << 14) | (dev->id << 8) | (dev->channel << 5) | dev->lun;
1027}
1028
1029
1030
1031
1032
1033
1034static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd,
1035 void (*done) (struct scsi_cmnd *))
1036{
1037 struct srp_cmd *srp_cmd;
1038 struct srp_event_struct *evt_struct;
1039 struct srp_indirect_buf *indirect;
1040 struct ibmvscsi_host_data *hostdata = shost_priv(cmnd->device->host);
1041 u16 lun = lun_from_dev(cmnd->device);
1042 u8 out_fmt, in_fmt;
1043
1044 cmnd->result = (DID_OK << 16);
1045 evt_struct = get_event_struct(&hostdata->pool);
1046 if (!evt_struct)
1047 return SCSI_MLQUEUE_HOST_BUSY;
1048
1049
1050 srp_cmd = &evt_struct->iu.srp.cmd;
1051 memset(srp_cmd, 0x00, SRP_MAX_IU_LEN);
1052 srp_cmd->opcode = SRP_CMD;
1053 memcpy(srp_cmd->cdb, cmnd->cmnd, sizeof(srp_cmd->cdb));
1054 int_to_scsilun(lun, &srp_cmd->lun);
1055
1056 if (!map_data_for_srp_cmd(cmnd, evt_struct, srp_cmd, hostdata->dev)) {
1057 if (!firmware_has_feature(FW_FEATURE_CMO))
1058 sdev_printk(KERN_ERR, cmnd->device,
1059 "couldn't convert cmd to srp_cmd\n");
1060 free_event_struct(&hostdata->pool, evt_struct);
1061 return SCSI_MLQUEUE_HOST_BUSY;
1062 }
1063
1064 init_event_struct(evt_struct,
1065 handle_cmd_rsp,
1066 VIOSRP_SRP_FORMAT,
1067 cmnd->request->timeout/HZ);
1068
1069 evt_struct->cmnd = cmnd;
1070 evt_struct->cmnd_done = done;
1071
1072
1073 indirect = (struct srp_indirect_buf *) srp_cmd->add_data;
1074 out_fmt = srp_cmd->buf_fmt >> 4;
1075 in_fmt = srp_cmd->buf_fmt & ((1U << 4) - 1);
1076 if ((in_fmt == SRP_DATA_DESC_INDIRECT ||
1077 out_fmt == SRP_DATA_DESC_INDIRECT) &&
1078 indirect->table_desc.va == 0) {
1079 indirect->table_desc.va =
1080 cpu_to_be64(be64_to_cpu(evt_struct->crq.IU_data_ptr) +
1081 offsetof(struct srp_cmd, add_data) +
1082 offsetof(struct srp_indirect_buf, desc_list));
1083 }
1084
1085 return ibmvscsi_send_srp_event(evt_struct, hostdata, 0);
1086}
1087
1088static DEF_SCSI_QCMD(ibmvscsi_queuecommand)
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101static int map_persist_bufs(struct ibmvscsi_host_data *hostdata)
1102{
1103
1104 hostdata->caps_addr = dma_map_single(hostdata->dev, &hostdata->caps,
1105 sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1106
1107 if (dma_mapping_error(hostdata->dev, hostdata->caps_addr)) {
1108 dev_err(hostdata->dev, "Unable to map capabilities buffer!\n");
1109 return 1;
1110 }
1111
1112 hostdata->adapter_info_addr = dma_map_single(hostdata->dev,
1113 &hostdata->madapter_info,
1114 sizeof(hostdata->madapter_info),
1115 DMA_BIDIRECTIONAL);
1116 if (dma_mapping_error(hostdata->dev, hostdata->adapter_info_addr)) {
1117 dev_err(hostdata->dev, "Unable to map adapter info buffer!\n");
1118 dma_unmap_single(hostdata->dev, hostdata->caps_addr,
1119 sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1120 return 1;
1121 }
1122
1123 return 0;
1124}
1125
1126
1127
1128
1129
1130
1131
1132static void unmap_persist_bufs(struct ibmvscsi_host_data *hostdata)
1133{
1134 dma_unmap_single(hostdata->dev, hostdata->caps_addr,
1135 sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1136
1137 dma_unmap_single(hostdata->dev, hostdata->adapter_info_addr,
1138 sizeof(hostdata->madapter_info), DMA_BIDIRECTIONAL);
1139}
1140
1141
1142
1143
1144
1145
1146
1147
1148static void login_rsp(struct srp_event_struct *evt_struct)
1149{
1150 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1151 switch (evt_struct->xfer_iu->srp.login_rsp.opcode) {
1152 case SRP_LOGIN_RSP:
1153 break;
1154 case SRP_LOGIN_REJ:
1155 dev_info(hostdata->dev, "SRP_LOGIN_REJ reason %u\n",
1156 evt_struct->xfer_iu->srp.login_rej.reason);
1157
1158 atomic_set(&hostdata->request_limit, -1);
1159 return;
1160 default:
1161 dev_err(hostdata->dev, "Invalid login response typecode 0x%02x!\n",
1162 evt_struct->xfer_iu->srp.login_rsp.opcode);
1163
1164 atomic_set(&hostdata->request_limit, -1);
1165 return;
1166 }
1167
1168 dev_info(hostdata->dev, "SRP_LOGIN succeeded\n");
1169 hostdata->client_migrated = 0;
1170
1171
1172
1173
1174
1175 atomic_set(&hostdata->request_limit,
1176 be32_to_cpu(evt_struct->xfer_iu->srp.login_rsp.req_lim_delta));
1177
1178
1179 scsi_unblock_requests(hostdata->host);
1180}
1181
1182
1183
1184
1185
1186
1187
1188static int send_srp_login(struct ibmvscsi_host_data *hostdata)
1189{
1190 int rc;
1191 unsigned long flags;
1192 struct srp_login_req *login;
1193 struct srp_event_struct *evt_struct = get_event_struct(&hostdata->pool);
1194
1195 BUG_ON(!evt_struct);
1196 init_event_struct(evt_struct, login_rsp,
1197 VIOSRP_SRP_FORMAT, login_timeout);
1198
1199 login = &evt_struct->iu.srp.login_req;
1200 memset(login, 0, sizeof(*login));
1201 login->opcode = SRP_LOGIN_REQ;
1202 login->req_it_iu_len = cpu_to_be32(sizeof(union srp_iu));
1203 login->req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
1204 SRP_BUF_FORMAT_INDIRECT);
1205
1206 spin_lock_irqsave(hostdata->host->host_lock, flags);
1207
1208
1209
1210
1211 atomic_set(&hostdata->request_limit, 0);
1212
1213 rc = ibmvscsi_send_srp_event(evt_struct, hostdata, login_timeout * 2);
1214 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1215 dev_info(hostdata->dev, "sent SRP login\n");
1216 return rc;
1217};
1218
1219
1220
1221
1222
1223
1224
1225static void capabilities_rsp(struct srp_event_struct *evt_struct)
1226{
1227 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1228
1229 if (evt_struct->xfer_iu->mad.capabilities.common.status) {
1230 dev_err(hostdata->dev, "error 0x%X getting capabilities info\n",
1231 evt_struct->xfer_iu->mad.capabilities.common.status);
1232 } else {
1233 if (hostdata->caps.migration.common.server_support !=
1234 cpu_to_be16(SERVER_SUPPORTS_CAP))
1235 dev_info(hostdata->dev, "Partition migration not supported\n");
1236
1237 if (client_reserve) {
1238 if (hostdata->caps.reserve.common.server_support ==
1239 cpu_to_be16(SERVER_SUPPORTS_CAP))
1240 dev_info(hostdata->dev, "Client reserve enabled\n");
1241 else
1242 dev_info(hostdata->dev, "Client reserve not supported\n");
1243 }
1244 }
1245
1246 send_srp_login(hostdata);
1247}
1248
1249
1250
1251
1252
1253
1254static void send_mad_capabilities(struct ibmvscsi_host_data *hostdata)
1255{
1256 struct viosrp_capabilities *req;
1257 struct srp_event_struct *evt_struct;
1258 unsigned long flags;
1259 struct device_node *of_node = hostdata->dev->of_node;
1260 const char *location;
1261
1262 evt_struct = get_event_struct(&hostdata->pool);
1263 BUG_ON(!evt_struct);
1264
1265 init_event_struct(evt_struct, capabilities_rsp,
1266 VIOSRP_MAD_FORMAT, info_timeout);
1267
1268 req = &evt_struct->iu.mad.capabilities;
1269 memset(req, 0, sizeof(*req));
1270
1271 hostdata->caps.flags = cpu_to_be32(CAP_LIST_SUPPORTED);
1272 if (hostdata->client_migrated)
1273 hostdata->caps.flags |= cpu_to_be32(CLIENT_MIGRATED);
1274
1275 strncpy(hostdata->caps.name, dev_name(&hostdata->host->shost_gendev),
1276 sizeof(hostdata->caps.name));
1277 hostdata->caps.name[sizeof(hostdata->caps.name) - 1] = '\0';
1278
1279 location = of_get_property(of_node, "ibm,loc-code", NULL);
1280 location = location ? location : dev_name(hostdata->dev);
1281 strncpy(hostdata->caps.loc, location, sizeof(hostdata->caps.loc));
1282 hostdata->caps.loc[sizeof(hostdata->caps.loc) - 1] = '\0';
1283
1284 req->common.type = cpu_to_be32(VIOSRP_CAPABILITIES_TYPE);
1285 req->buffer = cpu_to_be64(hostdata->caps_addr);
1286
1287 hostdata->caps.migration.common.cap_type =
1288 cpu_to_be32(MIGRATION_CAPABILITIES);
1289 hostdata->caps.migration.common.length =
1290 cpu_to_be16(sizeof(hostdata->caps.migration));
1291 hostdata->caps.migration.common.server_support =
1292 cpu_to_be16(SERVER_SUPPORTS_CAP);
1293 hostdata->caps.migration.ecl = cpu_to_be32(1);
1294
1295 if (client_reserve) {
1296 hostdata->caps.reserve.common.cap_type =
1297 cpu_to_be32(RESERVATION_CAPABILITIES);
1298 hostdata->caps.reserve.common.length =
1299 cpu_to_be16(sizeof(hostdata->caps.reserve));
1300 hostdata->caps.reserve.common.server_support =
1301 cpu_to_be16(SERVER_SUPPORTS_CAP);
1302 hostdata->caps.reserve.type =
1303 cpu_to_be32(CLIENT_RESERVE_SCSI_2);
1304 req->common.length =
1305 cpu_to_be16(sizeof(hostdata->caps));
1306 } else
1307 req->common.length = cpu_to_be16(sizeof(hostdata->caps) -
1308 sizeof(hostdata->caps.reserve));
1309
1310 spin_lock_irqsave(hostdata->host->host_lock, flags);
1311 if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
1312 dev_err(hostdata->dev, "couldn't send CAPABILITIES_REQ!\n");
1313 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1314};
1315
1316
1317
1318
1319
1320
1321
1322
1323static void fast_fail_rsp(struct srp_event_struct *evt_struct)
1324{
1325 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1326 u16 status = be16_to_cpu(evt_struct->xfer_iu->mad.fast_fail.common.status);
1327
1328 if (status == VIOSRP_MAD_NOT_SUPPORTED)
1329 dev_err(hostdata->dev, "fast_fail not supported in server\n");
1330 else if (status == VIOSRP_MAD_FAILED)
1331 dev_err(hostdata->dev, "fast_fail request failed\n");
1332 else if (status != VIOSRP_MAD_SUCCESS)
1333 dev_err(hostdata->dev, "error 0x%X enabling fast_fail\n", status);
1334
1335 send_mad_capabilities(hostdata);
1336}
1337
1338
1339
1340
1341
1342
1343
1344static int enable_fast_fail(struct ibmvscsi_host_data *hostdata)
1345{
1346 int rc;
1347 unsigned long flags;
1348 struct viosrp_fast_fail *fast_fail_mad;
1349 struct srp_event_struct *evt_struct;
1350
1351 if (!fast_fail) {
1352 send_mad_capabilities(hostdata);
1353 return 0;
1354 }
1355
1356 evt_struct = get_event_struct(&hostdata->pool);
1357 BUG_ON(!evt_struct);
1358
1359 init_event_struct(evt_struct, fast_fail_rsp, VIOSRP_MAD_FORMAT, info_timeout);
1360
1361 fast_fail_mad = &evt_struct->iu.mad.fast_fail;
1362 memset(fast_fail_mad, 0, sizeof(*fast_fail_mad));
1363 fast_fail_mad->common.type = cpu_to_be32(VIOSRP_ENABLE_FAST_FAIL);
1364 fast_fail_mad->common.length = cpu_to_be16(sizeof(*fast_fail_mad));
1365
1366 spin_lock_irqsave(hostdata->host->host_lock, flags);
1367 rc = ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2);
1368 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1369 return rc;
1370}
1371
1372
1373
1374
1375
1376
1377
1378
1379static void adapter_info_rsp(struct srp_event_struct *evt_struct)
1380{
1381 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1382
1383 if (evt_struct->xfer_iu->mad.adapter_info.common.status) {
1384 dev_err(hostdata->dev, "error %d getting adapter info\n",
1385 evt_struct->xfer_iu->mad.adapter_info.common.status);
1386 } else {
1387 dev_info(hostdata->dev, "host srp version: %s, "
1388 "host partition %s (%d), OS %d, max io %u\n",
1389 hostdata->madapter_info.srp_version,
1390 hostdata->madapter_info.partition_name,
1391 be32_to_cpu(hostdata->madapter_info.partition_number),
1392 be32_to_cpu(hostdata->madapter_info.os_type),
1393 be32_to_cpu(hostdata->madapter_info.port_max_txu[0]));
1394
1395 if (hostdata->madapter_info.port_max_txu[0])
1396 hostdata->host->max_sectors =
1397 be32_to_cpu(hostdata->madapter_info.port_max_txu[0]) >> 9;
1398
1399 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX &&
1400 strcmp(hostdata->madapter_info.srp_version, "1.6a") <= 0) {
1401 dev_err(hostdata->dev, "host (Ver. %s) doesn't support large transfers\n",
1402 hostdata->madapter_info.srp_version);
1403 dev_err(hostdata->dev, "limiting scatterlists to %d\n",
1404 MAX_INDIRECT_BUFS);
1405 hostdata->host->sg_tablesize = MAX_INDIRECT_BUFS;
1406 }
1407
1408 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX) {
1409 enable_fast_fail(hostdata);
1410 return;
1411 }
1412 }
1413
1414 send_srp_login(hostdata);
1415}
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426static void send_mad_adapter_info(struct ibmvscsi_host_data *hostdata)
1427{
1428 struct viosrp_adapter_info *req;
1429 struct srp_event_struct *evt_struct;
1430 unsigned long flags;
1431
1432 evt_struct = get_event_struct(&hostdata->pool);
1433 BUG_ON(!evt_struct);
1434
1435 init_event_struct(evt_struct,
1436 adapter_info_rsp,
1437 VIOSRP_MAD_FORMAT,
1438 info_timeout);
1439
1440 req = &evt_struct->iu.mad.adapter_info;
1441 memset(req, 0x00, sizeof(*req));
1442
1443 req->common.type = cpu_to_be32(VIOSRP_ADAPTER_INFO_TYPE);
1444 req->common.length = cpu_to_be16(sizeof(hostdata->madapter_info));
1445 req->buffer = cpu_to_be64(hostdata->adapter_info_addr);
1446
1447 spin_lock_irqsave(hostdata->host->host_lock, flags);
1448 if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
1449 dev_err(hostdata->dev, "couldn't send ADAPTER_INFO_REQ!\n");
1450 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1451};
1452
1453
1454
1455
1456
1457static void init_adapter(struct ibmvscsi_host_data *hostdata)
1458{
1459 send_mad_adapter_info(hostdata);
1460}
1461
1462
1463
1464
1465
1466
1467
1468static void sync_completion(struct srp_event_struct *evt_struct)
1469{
1470
1471 if (evt_struct->sync_srp)
1472 *evt_struct->sync_srp = *evt_struct->xfer_iu;
1473
1474 complete(&evt_struct->comp);
1475}
1476
1477
1478
1479
1480
1481static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
1482{
1483 struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1484 struct srp_tsk_mgmt *tsk_mgmt;
1485 struct srp_event_struct *evt;
1486 struct srp_event_struct *tmp_evt, *found_evt;
1487 union viosrp_iu srp_rsp;
1488 int rsp_rc;
1489 unsigned long flags;
1490 u16 lun = lun_from_dev(cmd->device);
1491 unsigned long wait_switch = 0;
1492
1493
1494
1495
1496 spin_lock_irqsave(hostdata->host->host_lock, flags);
1497 wait_switch = jiffies + (init_timeout * HZ);
1498 do {
1499 found_evt = NULL;
1500 list_for_each_entry(tmp_evt, &hostdata->sent, list) {
1501 if (tmp_evt->cmnd == cmd) {
1502 found_evt = tmp_evt;
1503 break;
1504 }
1505 }
1506
1507 if (!found_evt) {
1508 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1509 return SUCCESS;
1510 }
1511
1512 evt = get_event_struct(&hostdata->pool);
1513 if (evt == NULL) {
1514 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1515 sdev_printk(KERN_ERR, cmd->device,
1516 "failed to allocate abort event\n");
1517 return FAILED;
1518 }
1519
1520 init_event_struct(evt,
1521 sync_completion,
1522 VIOSRP_SRP_FORMAT,
1523 abort_timeout);
1524
1525 tsk_mgmt = &evt->iu.srp.tsk_mgmt;
1526
1527
1528 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt));
1529 tsk_mgmt->opcode = SRP_TSK_MGMT;
1530 int_to_scsilun(lun, &tsk_mgmt->lun);
1531 tsk_mgmt->tsk_mgmt_func = SRP_TSK_ABORT_TASK;
1532 tsk_mgmt->task_tag = (u64) found_evt;
1533
1534 evt->sync_srp = &srp_rsp;
1535
1536 init_completion(&evt->comp);
1537 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, abort_timeout * 2);
1538
1539 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
1540 break;
1541
1542 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1543 msleep(10);
1544 spin_lock_irqsave(hostdata->host->host_lock, flags);
1545 } while (time_before(jiffies, wait_switch));
1546
1547 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1548
1549 if (rsp_rc != 0) {
1550 sdev_printk(KERN_ERR, cmd->device,
1551 "failed to send abort() event. rc=%d\n", rsp_rc);
1552 return FAILED;
1553 }
1554
1555 sdev_printk(KERN_INFO, cmd->device,
1556 "aborting command. lun 0x%llx, tag 0x%llx\n",
1557 (((u64) lun) << 48), (u64) found_evt);
1558
1559 wait_for_completion(&evt->comp);
1560
1561
1562 if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) {
1563 if (printk_ratelimit())
1564 sdev_printk(KERN_WARNING, cmd->device, "abort bad SRP RSP type %d\n",
1565 srp_rsp.srp.rsp.opcode);
1566 return FAILED;
1567 }
1568
1569 if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID)
1570 rsp_rc = *((int *)srp_rsp.srp.rsp.data);
1571 else
1572 rsp_rc = srp_rsp.srp.rsp.status;
1573
1574 if (rsp_rc) {
1575 if (printk_ratelimit())
1576 sdev_printk(KERN_WARNING, cmd->device,
1577 "abort code %d for task tag 0x%llx\n",
1578 rsp_rc, tsk_mgmt->task_tag);
1579 return FAILED;
1580 }
1581
1582
1583
1584
1585
1586 spin_lock_irqsave(hostdata->host->host_lock, flags);
1587 found_evt = NULL;
1588 list_for_each_entry(tmp_evt, &hostdata->sent, list) {
1589 if (tmp_evt->cmnd == cmd) {
1590 found_evt = tmp_evt;
1591 break;
1592 }
1593 }
1594
1595 if (found_evt == NULL) {
1596 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1597 sdev_printk(KERN_INFO, cmd->device, "aborted task tag 0x%llx completed\n",
1598 tsk_mgmt->task_tag);
1599 return SUCCESS;
1600 }
1601
1602 sdev_printk(KERN_INFO, cmd->device, "successfully aborted task tag 0x%llx\n",
1603 tsk_mgmt->task_tag);
1604
1605 cmd->result = (DID_ABORT << 16);
1606 list_del(&found_evt->list);
1607 unmap_cmd_data(&found_evt->iu.srp.cmd, found_evt,
1608 found_evt->hostdata->dev);
1609 free_event_struct(&found_evt->hostdata->pool, found_evt);
1610 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1611 atomic_inc(&hostdata->request_limit);
1612 return SUCCESS;
1613}
1614
1615
1616
1617
1618
1619
1620static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
1621{
1622 struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1623 struct srp_tsk_mgmt *tsk_mgmt;
1624 struct srp_event_struct *evt;
1625 struct srp_event_struct *tmp_evt, *pos;
1626 union viosrp_iu srp_rsp;
1627 int rsp_rc;
1628 unsigned long flags;
1629 u16 lun = lun_from_dev(cmd->device);
1630 unsigned long wait_switch = 0;
1631
1632 spin_lock_irqsave(hostdata->host->host_lock, flags);
1633 wait_switch = jiffies + (init_timeout * HZ);
1634 do {
1635 evt = get_event_struct(&hostdata->pool);
1636 if (evt == NULL) {
1637 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1638 sdev_printk(KERN_ERR, cmd->device,
1639 "failed to allocate reset event\n");
1640 return FAILED;
1641 }
1642
1643 init_event_struct(evt,
1644 sync_completion,
1645 VIOSRP_SRP_FORMAT,
1646 reset_timeout);
1647
1648 tsk_mgmt = &evt->iu.srp.tsk_mgmt;
1649
1650
1651 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt));
1652 tsk_mgmt->opcode = SRP_TSK_MGMT;
1653 int_to_scsilun(lun, &tsk_mgmt->lun);
1654 tsk_mgmt->tsk_mgmt_func = SRP_TSK_LUN_RESET;
1655
1656 evt->sync_srp = &srp_rsp;
1657
1658 init_completion(&evt->comp);
1659 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, reset_timeout * 2);
1660
1661 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
1662 break;
1663
1664 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1665 msleep(10);
1666 spin_lock_irqsave(hostdata->host->host_lock, flags);
1667 } while (time_before(jiffies, wait_switch));
1668
1669 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1670
1671 if (rsp_rc != 0) {
1672 sdev_printk(KERN_ERR, cmd->device,
1673 "failed to send reset event. rc=%d\n", rsp_rc);
1674 return FAILED;
1675 }
1676
1677 sdev_printk(KERN_INFO, cmd->device, "resetting device. lun 0x%llx\n",
1678 (((u64) lun) << 48));
1679
1680 wait_for_completion(&evt->comp);
1681
1682
1683 if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) {
1684 if (printk_ratelimit())
1685 sdev_printk(KERN_WARNING, cmd->device, "reset bad SRP RSP type %d\n",
1686 srp_rsp.srp.rsp.opcode);
1687 return FAILED;
1688 }
1689
1690 if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID)
1691 rsp_rc = *((int *)srp_rsp.srp.rsp.data);
1692 else
1693 rsp_rc = srp_rsp.srp.rsp.status;
1694
1695 if (rsp_rc) {
1696 if (printk_ratelimit())
1697 sdev_printk(KERN_WARNING, cmd->device,
1698 "reset code %d for task tag 0x%llx\n",
1699 rsp_rc, tsk_mgmt->task_tag);
1700 return FAILED;
1701 }
1702
1703
1704
1705
1706 spin_lock_irqsave(hostdata->host->host_lock, flags);
1707 list_for_each_entry_safe(tmp_evt, pos, &hostdata->sent, list) {
1708 if ((tmp_evt->cmnd) && (tmp_evt->cmnd->device == cmd->device)) {
1709 if (tmp_evt->cmnd)
1710 tmp_evt->cmnd->result = (DID_RESET << 16);
1711 list_del(&tmp_evt->list);
1712 unmap_cmd_data(&tmp_evt->iu.srp.cmd, tmp_evt,
1713 tmp_evt->hostdata->dev);
1714 free_event_struct(&tmp_evt->hostdata->pool,
1715 tmp_evt);
1716 atomic_inc(&hostdata->request_limit);
1717 if (tmp_evt->cmnd_done)
1718 tmp_evt->cmnd_done(tmp_evt->cmnd);
1719 else if (tmp_evt->done)
1720 tmp_evt->done(tmp_evt);
1721 }
1722 }
1723 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1724 return SUCCESS;
1725}
1726
1727
1728
1729
1730
1731static int ibmvscsi_eh_host_reset_handler(struct scsi_cmnd *cmd)
1732{
1733 unsigned long wait_switch = 0;
1734 struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1735
1736 dev_err(hostdata->dev, "Resetting connection due to error recovery\n");
1737
1738 ibmvscsi_reset_host(hostdata);
1739
1740 for (wait_switch = jiffies + (init_timeout * HZ);
1741 time_before(jiffies, wait_switch) &&
1742 atomic_read(&hostdata->request_limit) < 2;) {
1743
1744 msleep(10);
1745 }
1746
1747 if (atomic_read(&hostdata->request_limit) <= 0)
1748 return FAILED;
1749
1750 return SUCCESS;
1751}
1752
1753
1754
1755
1756
1757
1758
1759static void ibmvscsi_handle_crq(struct viosrp_crq *crq,
1760 struct ibmvscsi_host_data *hostdata)
1761{
1762 long rc;
1763 unsigned long flags;
1764
1765 struct srp_event_struct *evt_struct =
1766 (__force struct srp_event_struct *)crq->IU_data_ptr;
1767 switch (crq->valid) {
1768 case VIOSRP_CRQ_INIT_RSP:
1769 switch (crq->format) {
1770 case VIOSRP_CRQ_INIT:
1771 dev_info(hostdata->dev, "partner initialized\n");
1772
1773 rc = ibmvscsi_send_crq(hostdata, 0xC002000000000000LL, 0);
1774 if (rc == 0) {
1775
1776 init_adapter(hostdata);
1777 } else {
1778 dev_err(hostdata->dev, "Unable to send init rsp. rc=%ld\n", rc);
1779 }
1780
1781 break;
1782 case VIOSRP_CRQ_INIT_COMPLETE:
1783 dev_info(hostdata->dev, "partner initialization complete\n");
1784
1785
1786 init_adapter(hostdata);
1787 break;
1788 default:
1789 dev_err(hostdata->dev, "unknown crq message type: %d\n", crq->format);
1790 }
1791 return;
1792 case VIOSRP_CRQ_XPORT_EVENT:
1793 scsi_block_requests(hostdata->host);
1794 atomic_set(&hostdata->request_limit, 0);
1795 if (crq->format == 0x06) {
1796
1797 dev_info(hostdata->dev, "Re-enabling adapter!\n");
1798 hostdata->client_migrated = 1;
1799 hostdata->reenable_crq = 1;
1800 purge_requests(hostdata, DID_REQUEUE);
1801 wake_up(&hostdata->work_wait_q);
1802 } else {
1803 dev_err(hostdata->dev, "Virtual adapter failed rc %d!\n",
1804 crq->format);
1805 ibmvscsi_reset_host(hostdata);
1806 }
1807 return;
1808 case VIOSRP_CRQ_CMD_RSP:
1809 break;
1810 default:
1811 dev_err(hostdata->dev, "got an invalid message type 0x%02x\n",
1812 crq->valid);
1813 return;
1814 }
1815
1816
1817
1818
1819
1820 if (!valid_event_struct(&hostdata->pool, evt_struct)) {
1821 dev_err(hostdata->dev, "returned correlation_token 0x%p is invalid!\n",
1822 evt_struct);
1823 return;
1824 }
1825
1826 if (atomic_read(&evt_struct->free)) {
1827 dev_err(hostdata->dev, "received duplicate correlation_token 0x%p!\n",
1828 evt_struct);
1829 return;
1830 }
1831
1832 if (crq->format == VIOSRP_SRP_FORMAT)
1833 atomic_add(be32_to_cpu(evt_struct->xfer_iu->srp.rsp.req_lim_delta),
1834 &hostdata->request_limit);
1835
1836 del_timer(&evt_struct->timer);
1837
1838 if ((crq->status != VIOSRP_OK && crq->status != VIOSRP_OK2) && evt_struct->cmnd)
1839 evt_struct->cmnd->result = DID_ERROR << 16;
1840 if (evt_struct->done)
1841 evt_struct->done(evt_struct);
1842 else
1843 dev_err(hostdata->dev, "returned done() is NULL; not running it!\n");
1844
1845
1846
1847
1848
1849 spin_lock_irqsave(evt_struct->hostdata->host->host_lock, flags);
1850 list_del(&evt_struct->list);
1851 free_event_struct(&evt_struct->hostdata->pool, evt_struct);
1852 spin_unlock_irqrestore(evt_struct->hostdata->host->host_lock, flags);
1853}
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863static int ibmvscsi_slave_configure(struct scsi_device *sdev)
1864{
1865 struct Scsi_Host *shost = sdev->host;
1866 unsigned long lock_flags = 0;
1867
1868 spin_lock_irqsave(shost->host_lock, lock_flags);
1869 if (sdev->type == TYPE_DISK) {
1870 sdev->allow_restart = 1;
1871 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
1872 }
1873 spin_unlock_irqrestore(shost->host_lock, lock_flags);
1874 return 0;
1875}
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
1887{
1888 if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN)
1889 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN;
1890 return scsi_change_queue_depth(sdev, qdepth);
1891}
1892
1893
1894
1895
1896static ssize_t show_host_vhost_loc(struct device *dev,
1897 struct device_attribute *attr, char *buf)
1898{
1899 struct Scsi_Host *shost = class_to_shost(dev);
1900 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1901 int len;
1902
1903 len = snprintf(buf, sizeof(hostdata->caps.loc), "%s\n",
1904 hostdata->caps.loc);
1905 return len;
1906}
1907
1908static struct device_attribute ibmvscsi_host_vhost_loc = {
1909 .attr = {
1910 .name = "vhost_loc",
1911 .mode = S_IRUGO,
1912 },
1913 .show = show_host_vhost_loc,
1914};
1915
1916static ssize_t show_host_vhost_name(struct device *dev,
1917 struct device_attribute *attr, char *buf)
1918{
1919 struct Scsi_Host *shost = class_to_shost(dev);
1920 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1921 int len;
1922
1923 len = snprintf(buf, sizeof(hostdata->caps.name), "%s\n",
1924 hostdata->caps.name);
1925 return len;
1926}
1927
1928static struct device_attribute ibmvscsi_host_vhost_name = {
1929 .attr = {
1930 .name = "vhost_name",
1931 .mode = S_IRUGO,
1932 },
1933 .show = show_host_vhost_name,
1934};
1935
1936static ssize_t show_host_srp_version(struct device *dev,
1937 struct device_attribute *attr, char *buf)
1938{
1939 struct Scsi_Host *shost = class_to_shost(dev);
1940 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1941 int len;
1942
1943 len = snprintf(buf, PAGE_SIZE, "%s\n",
1944 hostdata->madapter_info.srp_version);
1945 return len;
1946}
1947
1948static struct device_attribute ibmvscsi_host_srp_version = {
1949 .attr = {
1950 .name = "srp_version",
1951 .mode = S_IRUGO,
1952 },
1953 .show = show_host_srp_version,
1954};
1955
1956static ssize_t show_host_partition_name(struct device *dev,
1957 struct device_attribute *attr,
1958 char *buf)
1959{
1960 struct Scsi_Host *shost = class_to_shost(dev);
1961 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1962 int len;
1963
1964 len = snprintf(buf, PAGE_SIZE, "%s\n",
1965 hostdata->madapter_info.partition_name);
1966 return len;
1967}
1968
1969static struct device_attribute ibmvscsi_host_partition_name = {
1970 .attr = {
1971 .name = "partition_name",
1972 .mode = S_IRUGO,
1973 },
1974 .show = show_host_partition_name,
1975};
1976
1977static ssize_t show_host_partition_number(struct device *dev,
1978 struct device_attribute *attr,
1979 char *buf)
1980{
1981 struct Scsi_Host *shost = class_to_shost(dev);
1982 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1983 int len;
1984
1985 len = snprintf(buf, PAGE_SIZE, "%d\n",
1986 be32_to_cpu(hostdata->madapter_info.partition_number));
1987 return len;
1988}
1989
1990static struct device_attribute ibmvscsi_host_partition_number = {
1991 .attr = {
1992 .name = "partition_number",
1993 .mode = S_IRUGO,
1994 },
1995 .show = show_host_partition_number,
1996};
1997
1998static ssize_t show_host_mad_version(struct device *dev,
1999 struct device_attribute *attr, char *buf)
2000{
2001 struct Scsi_Host *shost = class_to_shost(dev);
2002 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2003 int len;
2004
2005 len = snprintf(buf, PAGE_SIZE, "%d\n",
2006 be32_to_cpu(hostdata->madapter_info.mad_version));
2007 return len;
2008}
2009
2010static struct device_attribute ibmvscsi_host_mad_version = {
2011 .attr = {
2012 .name = "mad_version",
2013 .mode = S_IRUGO,
2014 },
2015 .show = show_host_mad_version,
2016};
2017
2018static ssize_t show_host_os_type(struct device *dev,
2019 struct device_attribute *attr, char *buf)
2020{
2021 struct Scsi_Host *shost = class_to_shost(dev);
2022 struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2023 int len;
2024
2025 len = snprintf(buf, PAGE_SIZE, "%d\n",
2026 be32_to_cpu(hostdata->madapter_info.os_type));
2027 return len;
2028}
2029
2030static struct device_attribute ibmvscsi_host_os_type = {
2031 .attr = {
2032 .name = "os_type",
2033 .mode = S_IRUGO,
2034 },
2035 .show = show_host_os_type,
2036};
2037
2038static ssize_t show_host_config(struct device *dev,
2039 struct device_attribute *attr, char *buf)
2040{
2041 return 0;
2042}
2043
2044static struct device_attribute ibmvscsi_host_config = {
2045 .attr = {
2046 .name = "config",
2047 .mode = S_IRUGO,
2048 },
2049 .show = show_host_config,
2050};
2051
2052static struct device_attribute *ibmvscsi_attrs[] = {
2053 &ibmvscsi_host_vhost_loc,
2054 &ibmvscsi_host_vhost_name,
2055 &ibmvscsi_host_srp_version,
2056 &ibmvscsi_host_partition_name,
2057 &ibmvscsi_host_partition_number,
2058 &ibmvscsi_host_mad_version,
2059 &ibmvscsi_host_os_type,
2060 &ibmvscsi_host_config,
2061 NULL
2062};
2063
2064
2065
2066
2067static struct scsi_host_template driver_template = {
2068 .module = THIS_MODULE,
2069 .name = "IBM POWER Virtual SCSI Adapter " IBMVSCSI_VERSION,
2070 .proc_name = "ibmvscsi",
2071 .queuecommand = ibmvscsi_queuecommand,
2072 .eh_abort_handler = ibmvscsi_eh_abort_handler,
2073 .eh_device_reset_handler = ibmvscsi_eh_device_reset_handler,
2074 .eh_host_reset_handler = ibmvscsi_eh_host_reset_handler,
2075 .slave_configure = ibmvscsi_slave_configure,
2076 .change_queue_depth = ibmvscsi_change_queue_depth,
2077 .cmd_per_lun = IBMVSCSI_CMDS_PER_LUN_DEFAULT,
2078 .can_queue = IBMVSCSI_MAX_REQUESTS_DEFAULT,
2079 .this_id = -1,
2080 .sg_tablesize = SG_ALL,
2081 .use_clustering = ENABLE_CLUSTERING,
2082 .shost_attrs = ibmvscsi_attrs,
2083};
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093static unsigned long ibmvscsi_get_desired_dma(struct vio_dev *vdev)
2094{
2095
2096 unsigned long desired_io = max_events * sizeof(union viosrp_iu);
2097
2098
2099 desired_io += (IBMVSCSI_MAX_SECTORS_DEFAULT * 512 *
2100 IBMVSCSI_CMDS_PER_LUN_DEFAULT);
2101
2102 return desired_io;
2103}
2104
2105static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
2106{
2107 int rc;
2108 char *action = "reset";
2109
2110 if (hostdata->reset_crq) {
2111 smp_rmb();
2112 hostdata->reset_crq = 0;
2113
2114 rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
2115 if (!rc)
2116 rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2117 vio_enable_interrupts(to_vio_dev(hostdata->dev));
2118 } else if (hostdata->reenable_crq) {
2119 smp_rmb();
2120 action = "enable";
2121 rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata);
2122 hostdata->reenable_crq = 0;
2123 if (!rc)
2124 rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2125 } else
2126 return;
2127
2128 if (rc) {
2129 atomic_set(&hostdata->request_limit, -1);
2130 dev_err(hostdata->dev, "error after %s\n", action);
2131 }
2132
2133 scsi_unblock_requests(hostdata->host);
2134}
2135
2136static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
2137{
2138 if (kthread_should_stop())
2139 return 1;
2140 else if (hostdata->reset_crq) {
2141 smp_rmb();
2142 return 1;
2143 } else if (hostdata->reenable_crq) {
2144 smp_rmb();
2145 return 1;
2146 }
2147
2148 return 0;
2149}
2150
2151static int ibmvscsi_work(void *data)
2152{
2153 struct ibmvscsi_host_data *hostdata = data;
2154 int rc;
2155
2156 set_user_nice(current, MIN_NICE);
2157
2158 while (1) {
2159 rc = wait_event_interruptible(hostdata->work_wait_q,
2160 ibmvscsi_work_to_do(hostdata));
2161
2162 BUG_ON(rc);
2163
2164 if (kthread_should_stop())
2165 break;
2166
2167 ibmvscsi_do_work(hostdata);
2168 }
2169
2170 return 0;
2171}
2172
2173
2174
2175
2176static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id)
2177{
2178 struct ibmvscsi_host_data *hostdata;
2179 struct Scsi_Host *host;
2180 struct device *dev = &vdev->dev;
2181 struct srp_rport_identifiers ids;
2182 struct srp_rport *rport;
2183 unsigned long wait_switch = 0;
2184 int rc;
2185
2186 dev_set_drvdata(&vdev->dev, NULL);
2187
2188 host = scsi_host_alloc(&driver_template, sizeof(*hostdata));
2189 if (!host) {
2190 dev_err(&vdev->dev, "couldn't allocate host data\n");
2191 goto scsi_host_alloc_failed;
2192 }
2193
2194 host->transportt = ibmvscsi_transport_template;
2195 hostdata = shost_priv(host);
2196 memset(hostdata, 0x00, sizeof(*hostdata));
2197 INIT_LIST_HEAD(&hostdata->sent);
2198 init_waitqueue_head(&hostdata->work_wait_q);
2199 hostdata->host = host;
2200 hostdata->dev = dev;
2201 atomic_set(&hostdata->request_limit, -1);
2202 hostdata->host->max_sectors = IBMVSCSI_MAX_SECTORS_DEFAULT;
2203
2204 if (map_persist_bufs(hostdata)) {
2205 dev_err(&vdev->dev, "couldn't map persistent buffers\n");
2206 goto persist_bufs_failed;
2207 }
2208
2209 hostdata->work_thread = kthread_run(ibmvscsi_work, hostdata, "%s_%d",
2210 "ibmvscsi", host->host_no);
2211
2212 if (IS_ERR(hostdata->work_thread)) {
2213 dev_err(&vdev->dev, "couldn't initialize kthread. rc=%ld\n",
2214 PTR_ERR(hostdata->work_thread));
2215 goto init_crq_failed;
2216 }
2217
2218 rc = ibmvscsi_init_crq_queue(&hostdata->queue, hostdata, max_events);
2219 if (rc != 0 && rc != H_RESOURCE) {
2220 dev_err(&vdev->dev, "couldn't initialize crq. rc=%d\n", rc);
2221 goto kill_kthread;
2222 }
2223 if (initialize_event_pool(&hostdata->pool, max_events, hostdata) != 0) {
2224 dev_err(&vdev->dev, "couldn't initialize event pool\n");
2225 goto init_pool_failed;
2226 }
2227
2228 host->max_lun = IBMVSCSI_MAX_LUN;
2229 host->max_id = max_id;
2230 host->max_channel = max_channel;
2231 host->max_cmd_len = 16;
2232
2233 dev_info(dev,
2234 "Maximum ID: %d Maximum LUN: %llu Maximum Channel: %d\n",
2235 host->max_id, host->max_lun, host->max_channel);
2236
2237 if (scsi_add_host(hostdata->host, hostdata->dev))
2238 goto add_host_failed;
2239
2240
2241 memcpy(ids.port_id, hostdata->madapter_info.partition_name,
2242 sizeof(ids.port_id));
2243 ids.roles = SRP_RPORT_ROLE_TARGET;
2244 rport = srp_rport_add(host, &ids);
2245 if (IS_ERR(rport))
2246 goto add_srp_port_failed;
2247
2248
2249
2250
2251
2252 if (ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0) == 0
2253 || rc == H_RESOURCE) {
2254
2255
2256
2257
2258
2259
2260 for (wait_switch = jiffies + (init_timeout * HZ);
2261 time_before(jiffies, wait_switch) &&
2262 atomic_read(&hostdata->request_limit) < 2;) {
2263
2264 msleep(10);
2265 }
2266
2267
2268 if (atomic_read(&hostdata->request_limit) > 0)
2269 scsi_scan_host(host);
2270 }
2271
2272 dev_set_drvdata(&vdev->dev, hostdata);
2273 return 0;
2274
2275 add_srp_port_failed:
2276 scsi_remove_host(hostdata->host);
2277 add_host_failed:
2278 release_event_pool(&hostdata->pool, hostdata);
2279 init_pool_failed:
2280 ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, max_events);
2281 kill_kthread:
2282 kthread_stop(hostdata->work_thread);
2283 init_crq_failed:
2284 unmap_persist_bufs(hostdata);
2285 persist_bufs_failed:
2286 scsi_host_put(host);
2287 scsi_host_alloc_failed:
2288 return -1;
2289}
2290
2291static int ibmvscsi_remove(struct vio_dev *vdev)
2292{
2293 struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev);
2294 unmap_persist_bufs(hostdata);
2295 release_event_pool(&hostdata->pool, hostdata);
2296 ibmvscsi_release_crq_queue(&hostdata->queue, hostdata,
2297 max_events);
2298
2299 kthread_stop(hostdata->work_thread);
2300 srp_remove_host(hostdata->host);
2301 scsi_remove_host(hostdata->host);
2302 scsi_host_put(hostdata->host);
2303
2304 return 0;
2305}
2306
2307
2308
2309
2310
2311
2312
2313
2314static int ibmvscsi_resume(struct device *dev)
2315{
2316 struct ibmvscsi_host_data *hostdata = dev_get_drvdata(dev);
2317 vio_disable_interrupts(to_vio_dev(hostdata->dev));
2318 tasklet_schedule(&hostdata->srp_task);
2319
2320 return 0;
2321}
2322
2323
2324
2325
2326
2327static struct vio_device_id ibmvscsi_device_table[] = {
2328 {"vscsi", "IBM,v-scsi"},
2329 { "", "" }
2330};
2331MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table);
2332
2333static struct dev_pm_ops ibmvscsi_pm_ops = {
2334 .resume = ibmvscsi_resume
2335};
2336
2337static struct vio_driver ibmvscsi_driver = {
2338 .id_table = ibmvscsi_device_table,
2339 .probe = ibmvscsi_probe,
2340 .remove = ibmvscsi_remove,
2341 .get_desired_dma = ibmvscsi_get_desired_dma,
2342 .name = "ibmvscsi",
2343 .pm = &ibmvscsi_pm_ops,
2344};
2345
2346static struct srp_function_template ibmvscsi_transport_functions = {
2347};
2348
2349int __init ibmvscsi_module_init(void)
2350{
2351 int ret;
2352
2353
2354 driver_template.can_queue = max_requests;
2355 max_events = max_requests + 2;
2356
2357 if (!firmware_has_feature(FW_FEATURE_VIO))
2358 return -ENODEV;
2359
2360 ibmvscsi_transport_template =
2361 srp_attach_transport(&ibmvscsi_transport_functions);
2362 if (!ibmvscsi_transport_template)
2363 return -ENOMEM;
2364
2365 ret = vio_register_driver(&ibmvscsi_driver);
2366 if (ret)
2367 srp_release_transport(ibmvscsi_transport_template);
2368 return ret;
2369}
2370
2371void __exit ibmvscsi_module_exit(void)
2372{
2373 vio_unregister_driver(&ibmvscsi_driver);
2374 srp_release_transport(ibmvscsi_transport_template);
2375}
2376
2377module_init(ibmvscsi_module_init);
2378module_exit(ibmvscsi_module_exit);
2379