Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/scsi/ibmvscsi/ibmvscsi.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us