Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 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

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         scsi_adjust_queue_depth(sdev, 0, shost->cmd_per_lun);
1933         return 0;
1934 }
1935 
1936 /**
1937  * ibmvscsi_change_queue_depth - Change the device's queue depth
1938  * @sdev:       scsi device struct
1939  * @qdepth:     depth to set
1940  * @reason:     calling context
1941  *
1942  * Return value:
1943  *      actual depth set
1944  **/
1945 static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth,
1946                                        int reason)
1947 {
1948         if (reason != SCSI_QDEPTH_DEFAULT)
1949                 return -EOPNOTSUPP;
1950 
1951         if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN)
1952                 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN;
1953 
1954         scsi_adjust_queue_depth(sdev, 0, qdepth);
1955         return sdev->queue_depth;
1956 }
1957 
1958 /* ------------------------------------------------------------
1959  * sysfs attributes
1960  */
1961 static ssize_t show_host_vhost_loc(struct device *dev,
1962                                    struct device_attribute *attr, char *buf)
1963 {
1964         struct Scsi_Host *shost = class_to_shost(dev);
1965         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1966         int len;
1967 
1968         len = snprintf(buf, sizeof(hostdata->caps.loc), "%s\n",
1969                        hostdata->caps.loc);
1970         return len;
1971 }
1972 
1973 static struct device_attribute ibmvscsi_host_vhost_loc = {
1974         .attr = {
1975                  .name = "vhost_loc",
1976                  .mode = S_IRUGO,
1977                  },
1978         .show = show_host_vhost_loc,
1979 };
1980 
1981 static ssize_t show_host_vhost_name(struct device *dev,
1982                                     struct device_attribute *attr, char *buf)
1983 {
1984         struct Scsi_Host *shost = class_to_shost(dev);
1985         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1986         int len;
1987 
1988         len = snprintf(buf, sizeof(hostdata->caps.name), "%s\n",
1989                        hostdata->caps.name);
1990         return len;
1991 }
1992 
1993 static struct device_attribute ibmvscsi_host_vhost_name = {
1994         .attr = {
1995                  .name = "vhost_name",
1996                  .mode = S_IRUGO,
1997                  },
1998         .show = show_host_vhost_name,
1999 };
2000 
2001 static ssize_t show_host_srp_version(struct device *dev,
2002                                      struct device_attribute *attr, char *buf)
2003 {
2004         struct Scsi_Host *shost = class_to_shost(dev);
2005         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2006         int len;
2007 
2008         len = snprintf(buf, PAGE_SIZE, "%s\n",
2009                        hostdata->madapter_info.srp_version);
2010         return len;
2011 }
2012 
2013 static struct device_attribute ibmvscsi_host_srp_version = {
2014         .attr = {
2015                  .name = "srp_version",
2016                  .mode = S_IRUGO,
2017                  },
2018         .show = show_host_srp_version,
2019 };
2020 
2021 static ssize_t show_host_partition_name(struct device *dev,
2022                                         struct device_attribute *attr,
2023                                         char *buf)
2024 {
2025         struct Scsi_Host *shost = class_to_shost(dev);
2026         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2027         int len;
2028 
2029         len = snprintf(buf, PAGE_SIZE, "%s\n",
2030                        hostdata->madapter_info.partition_name);
2031         return len;
2032 }
2033 
2034 static struct device_attribute ibmvscsi_host_partition_name = {
2035         .attr = {
2036                  .name = "partition_name",
2037                  .mode = S_IRUGO,
2038                  },
2039         .show = show_host_partition_name,
2040 };
2041 
2042 static ssize_t show_host_partition_number(struct device *dev,
2043                                           struct device_attribute *attr,
2044                                           char *buf)
2045 {
2046         struct Scsi_Host *shost = class_to_shost(dev);
2047         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2048         int len;
2049 
2050         len = snprintf(buf, PAGE_SIZE, "%d\n",
2051                        hostdata->madapter_info.partition_number);
2052         return len;
2053 }
2054 
2055 static struct device_attribute ibmvscsi_host_partition_number = {
2056         .attr = {
2057                  .name = "partition_number",
2058                  .mode = S_IRUGO,
2059                  },
2060         .show = show_host_partition_number,
2061 };
2062 
2063 static ssize_t show_host_mad_version(struct device *dev,
2064                                      struct device_attribute *attr, char *buf)
2065 {
2066         struct Scsi_Host *shost = class_to_shost(dev);
2067         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2068         int len;
2069 
2070         len = snprintf(buf, PAGE_SIZE, "%d\n",
2071                        hostdata->madapter_info.mad_version);
2072         return len;
2073 }
2074 
2075 static struct device_attribute ibmvscsi_host_mad_version = {
2076         .attr = {
2077                  .name = "mad_version",
2078                  .mode = S_IRUGO,
2079                  },
2080         .show = show_host_mad_version,
2081 };
2082 
2083 static ssize_t show_host_os_type(struct device *dev,
2084                                  struct device_attribute *attr, char *buf)
2085 {
2086         struct Scsi_Host *shost = class_to_shost(dev);
2087         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2088         int len;
2089 
2090         len = snprintf(buf, PAGE_SIZE, "%d\n", hostdata->madapter_info.os_type);
2091         return len;
2092 }
2093 
2094 static struct device_attribute ibmvscsi_host_os_type = {
2095         .attr = {
2096                  .name = "os_type",
2097                  .mode = S_IRUGO,
2098                  },
2099         .show = show_host_os_type,
2100 };
2101 
2102 static ssize_t show_host_config(struct device *dev,
2103                                 struct device_attribute *attr, char *buf)
2104 {
2105         struct Scsi_Host *shost = class_to_shost(dev);
2106         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2107 
2108         /* returns null-terminated host config data */
2109         if (ibmvscsi_do_host_config(hostdata, buf, PAGE_SIZE) == 0)
2110                 return strlen(buf);
2111         else
2112                 return 0;
2113 }
2114 
2115 static struct device_attribute ibmvscsi_host_config = {
2116         .attr = {
2117                  .name = "config",
2118                  .mode = S_IRUGO,
2119                  },
2120         .show = show_host_config,
2121 };
2122 
2123 static struct device_attribute *ibmvscsi_attrs[] = {
2124         &ibmvscsi_host_vhost_loc,
2125         &ibmvscsi_host_vhost_name,
2126         &ibmvscsi_host_srp_version,
2127         &ibmvscsi_host_partition_name,
2128         &ibmvscsi_host_partition_number,
2129         &ibmvscsi_host_mad_version,
2130         &ibmvscsi_host_os_type,
2131         &ibmvscsi_host_config,
2132         NULL
2133 };
2134 
2135 /* ------------------------------------------------------------
2136  * SCSI driver registration
2137  */
2138 static struct scsi_host_template driver_template = {
2139         .module = THIS_MODULE,
2140         .name = "IBM POWER Virtual SCSI Adapter " IBMVSCSI_VERSION,
2141         .proc_name = "ibmvscsi",
2142         .queuecommand = ibmvscsi_queuecommand,
2143         .eh_abort_handler = ibmvscsi_eh_abort_handler,
2144         .eh_device_reset_handler = ibmvscsi_eh_device_reset_handler,
2145         .eh_host_reset_handler = ibmvscsi_eh_host_reset_handler,
2146         .slave_configure = ibmvscsi_slave_configure,
2147         .change_queue_depth = ibmvscsi_change_queue_depth,
2148         .cmd_per_lun = IBMVSCSI_CMDS_PER_LUN_DEFAULT,
2149         .can_queue = IBMVSCSI_MAX_REQUESTS_DEFAULT,
2150         .this_id = -1,
2151         .sg_tablesize = SG_ALL,
2152         .use_clustering = ENABLE_CLUSTERING,
2153         .shost_attrs = ibmvscsi_attrs,
2154 };
2155 
2156 /**
2157  * ibmvscsi_get_desired_dma - Calculate IO memory desired by the driver
2158  *
2159  * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
2160  *
2161  * Return value:
2162  *      Number of bytes of IO data the driver will need to perform well.
2163  */
2164 static unsigned long ibmvscsi_get_desired_dma(struct vio_dev *vdev)
2165 {
2166         /* iu_storage data allocated in initialize_event_pool */
2167         unsigned long desired_io = max_events * sizeof(union viosrp_iu);
2168 
2169         /* add io space for sg data */
2170         desired_io += (IBMVSCSI_MAX_SECTORS_DEFAULT * 512 *
2171                              IBMVSCSI_CMDS_PER_LUN_DEFAULT);
2172 
2173         return desired_io;
2174 }
2175 
2176 static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
2177 {
2178         int rc;
2179         char *action = "reset";
2180 
2181         if (hostdata->reset_crq) {
2182                 smp_rmb();
2183                 hostdata->reset_crq = 0;
2184 
2185                 rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
2186                 if (!rc)
2187                         rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2188                 vio_enable_interrupts(to_vio_dev(hostdata->dev));
2189         } else if (hostdata->reenable_crq) {
2190                 smp_rmb();
2191                 action = "enable";
2192                 rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata);
2193                 hostdata->reenable_crq = 0;
2194                 if (!rc)
2195                         rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2196         } else
2197                 return;
2198 
2199         if (rc) {
2200                 atomic_set(&hostdata->request_limit, -1);
2201                 dev_err(hostdata->dev, "error after %s\n", action);
2202         }
2203 
2204         scsi_unblock_requests(hostdata->host);
2205 }
2206 
2207 static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
2208 {
2209         if (kthread_should_stop())
2210                 return 1;
2211         else if (hostdata->reset_crq) {
2212                 smp_rmb();
2213                 return 1;
2214         } else if (hostdata->reenable_crq) {
2215                 smp_rmb();
2216                 return 1;
2217         }
2218 
2219         return 0;
2220 }
2221 
2222 static int ibmvscsi_work(void *data)
2223 {
2224         struct ibmvscsi_host_data *hostdata = data;
2225         int rc;
2226 
2227         set_user_nice(current, MIN_NICE);
2228 
2229         while (1) {
2230                 rc = wait_event_interruptible(hostdata->work_wait_q,
2231                                               ibmvscsi_work_to_do(hostdata));
2232 
2233                 BUG_ON(rc);
2234 
2235                 if (kthread_should_stop())
2236                         break;
2237 
2238                 ibmvscsi_do_work(hostdata);
2239         }
2240 
2241         return 0;
2242 }
2243 
2244 /**
2245  * Called by bus code for each adapter
2246  */
2247 static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id)
2248 {
2249         struct ibmvscsi_host_data *hostdata;
2250         struct Scsi_Host *host;
2251         struct device *dev = &vdev->dev;
2252         struct srp_rport_identifiers ids;
2253         struct srp_rport *rport;
2254         unsigned long wait_switch = 0;
2255         int rc;
2256 
2257         dev_set_drvdata(&vdev->dev, NULL);
2258 
2259         host = scsi_host_alloc(&driver_template, sizeof(*hostdata));
2260         if (!host) {
2261                 dev_err(&vdev->dev, "couldn't allocate host data\n");
2262                 goto scsi_host_alloc_failed;
2263         }
2264 
2265         host->transportt = ibmvscsi_transport_template;
2266         hostdata = shost_priv(host);
2267         memset(hostdata, 0x00, sizeof(*hostdata));
2268         INIT_LIST_HEAD(&hostdata->sent);
2269         init_waitqueue_head(&hostdata->work_wait_q);
2270         hostdata->host = host;
2271         hostdata->dev = dev;
2272         atomic_set(&hostdata->request_limit, -1);
2273         hostdata->host->max_sectors = IBMVSCSI_MAX_SECTORS_DEFAULT;
2274 
2275         if (map_persist_bufs(hostdata)) {
2276                 dev_err(&vdev->dev, "couldn't map persistent buffers\n");
2277                 goto persist_bufs_failed;
2278         }
2279 
2280         hostdata->work_thread = kthread_run(ibmvscsi_work, hostdata, "%s_%d",
2281                                             "ibmvscsi", host->host_no);
2282 
2283         if (IS_ERR(hostdata->work_thread)) {
2284                 dev_err(&vdev->dev, "couldn't initialize kthread. rc=%ld\n",
2285                         PTR_ERR(hostdata->work_thread));
2286                 goto init_crq_failed;
2287         }
2288 
2289         rc = ibmvscsi_init_crq_queue(&hostdata->queue, hostdata, max_events);
2290         if (rc != 0 && rc != H_RESOURCE) {
2291                 dev_err(&vdev->dev, "couldn't initialize crq. rc=%d\n", rc);
2292                 goto kill_kthread;
2293         }
2294         if (initialize_event_pool(&hostdata->pool, max_events, hostdata) != 0) {
2295                 dev_err(&vdev->dev, "couldn't initialize event pool\n");
2296                 goto init_pool_failed;
2297         }
2298 
2299         host->max_lun = 8;
2300         host->max_id = max_id;
2301         host->max_channel = max_channel;
2302         host->max_cmd_len = 16;
2303 
2304         if (scsi_add_host(hostdata->host, hostdata->dev))
2305                 goto add_host_failed;
2306 
2307         /* we don't have a proper target_port_id so let's use the fake one */
2308         memcpy(ids.port_id, hostdata->madapter_info.partition_name,
2309                sizeof(ids.port_id));
2310         ids.roles = SRP_RPORT_ROLE_TARGET;
2311         rport = srp_rport_add(host, &ids);
2312         if (IS_ERR(rport))
2313                 goto add_srp_port_failed;
2314 
2315         /* Try to send an initialization message.  Note that this is allowed
2316          * to fail if the other end is not acive.  In that case we don't
2317          * want to scan
2318          */
2319         if (ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0) == 0
2320             || rc == H_RESOURCE) {
2321                 /*
2322                  * Wait around max init_timeout secs for the adapter to finish
2323                  * initializing. When we are done initializing, we will have a
2324                  * valid request_limit.  We don't want Linux scanning before
2325                  * we are ready.
2326                  */
2327                 for (wait_switch = jiffies + (init_timeout * HZ);
2328                      time_before(jiffies, wait_switch) &&
2329                      atomic_read(&hostdata->request_limit) < 2;) {
2330 
2331                         msleep(10);
2332                 }
2333 
2334                 /* if we now have a valid request_limit, initiate a scan */
2335                 if (atomic_read(&hostdata->request_limit) > 0)
2336                         scsi_scan_host(host);
2337         }
2338 
2339         dev_set_drvdata(&vdev->dev, hostdata);
2340         return 0;
2341 
2342       add_srp_port_failed:
2343         scsi_remove_host(hostdata->host);
2344       add_host_failed:
2345         release_event_pool(&hostdata->pool, hostdata);
2346       init_pool_failed:
2347         ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, max_events);
2348       kill_kthread:
2349       kthread_stop(hostdata->work_thread);
2350       init_crq_failed:
2351         unmap_persist_bufs(hostdata);
2352       persist_bufs_failed:
2353         scsi_host_put(host);
2354       scsi_host_alloc_failed:
2355         return -1;
2356 }
2357 
2358 static int ibmvscsi_remove(struct vio_dev *vdev)
2359 {
2360         struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev);
2361         unmap_persist_bufs(hostdata);
2362         release_event_pool(&hostdata->pool, hostdata);
2363         ibmvscsi_release_crq_queue(&hostdata->queue, hostdata,
2364                                         max_events);
2365 
2366         kthread_stop(hostdata->work_thread);
2367         srp_remove_host(hostdata->host);
2368         scsi_remove_host(hostdata->host);
2369         scsi_host_put(hostdata->host);
2370 
2371         return 0;
2372 }
2373 
2374 /**
2375  * ibmvscsi_resume: Resume from suspend
2376  * @dev:        device struct
2377  *
2378  * We may have lost an interrupt across suspend/resume, so kick the
2379  * interrupt handler
2380  */
2381 static int ibmvscsi_resume(struct device *dev)
2382 {
2383         struct ibmvscsi_host_data *hostdata = dev_get_drvdata(dev);
2384         vio_disable_interrupts(to_vio_dev(hostdata->dev));
2385         tasklet_schedule(&hostdata->srp_task);
2386 
2387         return 0;
2388 }
2389 
2390 /**
2391  * ibmvscsi_device_table: Used by vio.c to match devices in the device tree we 
2392  * support.
2393  */
2394 static struct vio_device_id ibmvscsi_device_table[] = {
2395         {"vscsi", "IBM,v-scsi"},
2396         { "", "" }
2397 };
2398 MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table);
2399 
2400 static struct dev_pm_ops ibmvscsi_pm_ops = {
2401         .resume = ibmvscsi_resume
2402 };
2403 
2404 static struct vio_driver ibmvscsi_driver = {
2405         .id_table = ibmvscsi_device_table,
2406         .probe = ibmvscsi_probe,
2407         .remove = ibmvscsi_remove,
2408         .get_desired_dma = ibmvscsi_get_desired_dma,
2409         .name = "ibmvscsi",
2410         .pm = &ibmvscsi_pm_ops,
2411 };
2412 
2413 static struct srp_function_template ibmvscsi_transport_functions = {
2414 };
2415 
2416 int __init ibmvscsi_module_init(void)
2417 {
2418         int ret;
2419 
2420         /* Ensure we have two requests to do error recovery */
2421         driver_template.can_queue = max_requests;
2422         max_events = max_requests + 2;
2423 
2424         if (!firmware_has_feature(FW_FEATURE_VIO))
2425                 return -ENODEV;
2426 
2427         ibmvscsi_transport_template =
2428                 srp_attach_transport(&ibmvscsi_transport_functions);
2429         if (!ibmvscsi_transport_template)
2430                 return -ENOMEM;
2431 
2432         ret = vio_register_driver(&ibmvscsi_driver);
2433         if (ret)
2434                 srp_release_transport(ibmvscsi_transport_template);
2435         return ret;
2436 }
2437 
2438 void __exit ibmvscsi_module_exit(void)
2439 {
2440         vio_unregister_driver(&ibmvscsi_driver);
2441         srp_release_transport(ibmvscsi_transport_template);
2442 }
2443 
2444 module_init(ibmvscsi_module_init);
2445 module_exit(ibmvscsi_module_exit);
2446 

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