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