blob: f48ae0190d95f04d8fae77157668740f103b643d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* ------------------------------------------------------------
2 * rpa_vscsi.c
3 * (C) Copyright IBM Corporation 1994, 2003
4 * Authors: Colin DeVilbiss (devilbis@us.ibm.com)
5 * Santiago Leon (santil@us.ibm.com)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 * USA
21 *
22 * ------------------------------------------------------------
23 * RPA-specific functions of the SCSI host adapter for Virtual I/O devices
24 *
25 * This driver allows the Linux SCSI peripheral drivers to directly
26 * access devices in the hosting partition, either on an iSeries
27 * hypervisor system or a converged hypervisor system.
28 */
29
30#include <asm/vio.h>
Stephen Rothwell71d276d2005-08-17 16:41:44 +100031#include <asm/prom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <asm/iommu.h>
33#include <asm/hvcall.h>
Brian King0f33ece2010-06-17 13:56:00 -050034#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/dma-mapping.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090036#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/interrupt.h>
38#include "ibmvscsi.h"
Linda Xieb4687ca2005-06-27 17:01:48 -050039
40static char partition_name[97] = "UNKNOWN";
41static unsigned int partition_number = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43/* ------------------------------------------------------------
44 * Routines for managing the command/response queue
45 */
46/**
David Woodhoused3849d52007-09-22 08:29:36 +100047 * rpavscsi_handle_event: - Interrupt handler for crq events
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 * @irq: number of irq to handle, not used
49 * @dev_instance: ibmvscsi_host_data of host that received interrupt
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 *
51 * Disables interrupts and schedules srp_task
52 * Always returns IRQ_HANDLED
53 */
David Woodhoused3849d52007-09-22 08:29:36 +100054static irqreturn_t rpavscsi_handle_event(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -070055{
56 struct ibmvscsi_host_data *hostdata =
57 (struct ibmvscsi_host_data *)dev_instance;
58 vio_disable_interrupts(to_vio_dev(hostdata->dev));
59 tasklet_schedule(&hostdata->srp_task);
60 return IRQ_HANDLED;
61}
62
63/**
64 * release_crq_queue: - Deallocates data and unregisters CRQ
65 * @queue: crq_queue to initialize and register
66 * @host_data: ibmvscsi_host_data of host
67 *
68 * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
69 * the crq with the hypervisor.
70 */
David Woodhoused3849d52007-09-22 08:29:36 +100071static void rpavscsi_release_crq_queue(struct crq_queue *queue,
72 struct ibmvscsi_host_data *hostdata,
73 int max_requests)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
Brian King0f33ece2010-06-17 13:56:00 -050075 long rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
77 free_irq(vdev->irq, (void *)hostdata);
78 tasklet_kill(&hostdata->srp_task);
79 do {
Brian King0f33ece2010-06-17 13:56:00 -050080 if (rc)
81 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
Segher Boessenkool706c8c92006-03-30 14:49:40 +020083 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 dma_unmap_single(hostdata->dev,
85 queue->msg_token,
86 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
87 free_page((unsigned long)queue->msgs);
88}
89
90/**
91 * crq_queue_next_crq: - Returns the next entry in message queue
92 * @queue: crq_queue to use
93 *
94 * Returns pointer to next entry in queue, or NULL if there are no new
95 * entried in the CRQ.
96 */
97static struct viosrp_crq *crq_queue_next_crq(struct crq_queue *queue)
98{
99 struct viosrp_crq *crq;
100 unsigned long flags;
101
102 spin_lock_irqsave(&queue->lock, flags);
103 crq = &queue->msgs[queue->cur];
104 if (crq->valid & 0x80) {
105 if (++queue->cur == queue->size)
106 queue->cur = 0;
107 } else
108 crq = NULL;
109 spin_unlock_irqrestore(&queue->lock, flags);
110
111 return crq;
112}
113
114/**
David Woodhoused3849d52007-09-22 08:29:36 +1000115 * rpavscsi_send_crq: - Send a CRQ
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 * @hostdata: the adapter
117 * @word1: the first 64 bits of the data
118 * @word2: the second 64 bits of the data
119 */
David Woodhoused3849d52007-09-22 08:29:36 +1000120static int rpavscsi_send_crq(struct ibmvscsi_host_data *hostdata,
121 u64 word1, u64 word2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
123 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
124
125 return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
126}
127
128/**
David Woodhoused3849d52007-09-22 08:29:36 +1000129 * rpavscsi_task: - Process srps asynchronously
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 * @data: ibmvscsi_host_data of host
131 */
David Woodhoused3849d52007-09-22 08:29:36 +1000132static void rpavscsi_task(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
134 struct ibmvscsi_host_data *hostdata = (struct ibmvscsi_host_data *)data;
135 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
136 struct viosrp_crq *crq;
137 int done = 0;
138
139 while (!done) {
140 /* Pull all the valid messages off the CRQ */
141 while ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) {
142 ibmvscsi_handle_crq(crq, hostdata);
143 crq->valid = 0x00;
144 }
145
146 vio_enable_interrupts(vdev);
147 if ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) {
148 vio_disable_interrupts(vdev);
149 ibmvscsi_handle_crq(crq, hostdata);
150 crq->valid = 0x00;
151 } else {
152 done = 1;
153 }
154 }
155}
156
Linda Xieb4687ca2005-06-27 17:01:48 -0500157static void gather_partition_info(void)
158{
159 struct device_node *rootdn;
160
Jeremy Kerr294ef162006-07-12 15:40:51 +1000161 const char *ppartition_name;
162 const unsigned int *p_number_ptr;
Linda Xieb4687ca2005-06-27 17:01:48 -0500163
164 /* Retrieve information about this partition */
Stephen Rothwell8c8dc322007-04-24 13:50:55 +1000165 rootdn = of_find_node_by_path("/");
Linda Xieb4687ca2005-06-27 17:01:48 -0500166 if (!rootdn) {
167 return;
168 }
169
Stephen Rothwell40cd3a42007-05-01 13:54:02 +1000170 ppartition_name = of_get_property(rootdn, "ibm,partition-name", NULL);
Linda Xieb4687ca2005-06-27 17:01:48 -0500171 if (ppartition_name)
172 strncpy(partition_name, ppartition_name,
173 sizeof(partition_name));
Stephen Rothwell40cd3a42007-05-01 13:54:02 +1000174 p_number_ptr = of_get_property(rootdn, "ibm,partition-no", NULL);
Linda Xieb4687ca2005-06-27 17:01:48 -0500175 if (p_number_ptr)
176 partition_number = *p_number_ptr;
Stephen Rothwell8c8dc322007-04-24 13:50:55 +1000177 of_node_put(rootdn);
Linda Xieb4687ca2005-06-27 17:01:48 -0500178}
179
180static void set_adapter_info(struct ibmvscsi_host_data *hostdata)
181{
182 memset(&hostdata->madapter_info, 0x00,
183 sizeof(hostdata->madapter_info));
184
Brian King6c0a60e2007-06-13 17:12:19 -0500185 dev_info(hostdata->dev, "SRP_VERSION: %s\n", SRP_VERSION);
Linda Xieb4687ca2005-06-27 17:01:48 -0500186 strcpy(hostdata->madapter_info.srp_version, SRP_VERSION);
187
188 strncpy(hostdata->madapter_info.partition_name, partition_name,
189 sizeof(hostdata->madapter_info.partition_name));
190
191 hostdata->madapter_info.partition_number = partition_number;
192
193 hostdata->madapter_info.mad_version = 1;
194 hostdata->madapter_info.os_type = 2;
195}
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 * reset_crq_queue: - resets a crq after a failure
199 * @queue: crq_queue to initialize and register
200 * @hostdata: ibmvscsi_host_data of host
201 *
202 */
David Woodhoused3849d52007-09-22 08:29:36 +1000203static int rpavscsi_reset_crq_queue(struct crq_queue *queue,
204 struct ibmvscsi_host_data *hostdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Brian King0f33ece2010-06-17 13:56:00 -0500206 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
208
209 /* Close the CRQ */
210 do {
Brian King0f33ece2010-06-17 13:56:00 -0500211 if (rc)
212 msleep(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
Segher Boessenkool706c8c92006-03-30 14:49:40 +0200214 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216 /* Clean out the queue */
217 memset(queue->msgs, 0x00, PAGE_SIZE);
218 queue->cur = 0;
219
Linda Xieb4687ca2005-06-27 17:01:48 -0500220 set_adapter_info(hostdata);
221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 /* And re-open it again */
223 rc = plpar_hcall_norets(H_REG_CRQ,
224 vdev->unit_address,
225 queue->msg_token, PAGE_SIZE);
226 if (rc == 2) {
227 /* Adapter is good, but other end is not ready */
Brian King6c0a60e2007-06-13 17:12:19 -0500228 dev_warn(hostdata->dev, "Partner adapter not ready\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 } else if (rc != 0) {
Brian King6c0a60e2007-06-13 17:12:19 -0500230 dev_warn(hostdata->dev, "couldn't register crq--rc 0x%x\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
Dave C Boutcherbb585962005-11-15 09:53:00 -0600232 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
David Woodhoused3849d52007-09-22 08:29:36 +1000234
235/**
236 * initialize_crq_queue: - Initializes and registers CRQ with hypervisor
237 * @queue: crq_queue to initialize and register
238 * @hostdata: ibmvscsi_host_data of host
239 *
240 * Allocates a page for messages, maps it for dma, and registers
241 * the crq with the hypervisor.
242 * Returns zero on success.
243 */
244static int rpavscsi_init_crq_queue(struct crq_queue *queue,
245 struct ibmvscsi_host_data *hostdata,
246 int max_requests)
247{
248 int rc;
249 int retrc;
250 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
251
252 queue->msgs = (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL);
253
254 if (!queue->msgs)
255 goto malloc_failed;
256 queue->size = PAGE_SIZE / sizeof(*queue->msgs);
257
258 queue->msg_token = dma_map_single(hostdata->dev, queue->msgs,
259 queue->size * sizeof(*queue->msgs),
260 DMA_BIDIRECTIONAL);
261
FUJITA Tomonori8d8bb392008-07-25 19:44:49 -0700262 if (dma_mapping_error(hostdata->dev, queue->msg_token))
David Woodhoused3849d52007-09-22 08:29:36 +1000263 goto map_failed;
264
265 gather_partition_info();
266 set_adapter_info(hostdata);
267
268 retrc = rc = plpar_hcall_norets(H_REG_CRQ,
269 vdev->unit_address,
270 queue->msg_token, PAGE_SIZE);
271 if (rc == H_RESOURCE)
272 /* maybe kexecing and resource is busy. try a reset */
273 rc = rpavscsi_reset_crq_queue(queue,
274 hostdata);
275
276 if (rc == 2) {
277 /* Adapter is good, but other end is not ready */
278 dev_warn(hostdata->dev, "Partner adapter not ready\n");
279 retrc = 0;
280 } else if (rc != 0) {
281 dev_warn(hostdata->dev, "Error %d opening adapter\n", rc);
282 goto reg_crq_failed;
283 }
284
Anton Blanchard8f83d762010-07-13 14:59:29 +1000285 queue->cur = 0;
286 spin_lock_init(&queue->lock);
287
288 tasklet_init(&hostdata->srp_task, (void *)rpavscsi_task,
289 (unsigned long)hostdata);
290
David Woodhoused3849d52007-09-22 08:29:36 +1000291 if (request_irq(vdev->irq,
292 rpavscsi_handle_event,
293 0, "ibmvscsi", (void *)hostdata) != 0) {
294 dev_err(hostdata->dev, "couldn't register irq 0x%x\n",
295 vdev->irq);
296 goto req_irq_failed;
297 }
298
299 rc = vio_enable_interrupts(vdev);
300 if (rc != 0) {
301 dev_err(hostdata->dev, "Error %d enabling interrupts!!!\n", rc);
302 goto req_irq_failed;
303 }
304
David Woodhoused3849d52007-09-22 08:29:36 +1000305 return retrc;
306
307 req_irq_failed:
Anton Blanchard8f83d762010-07-13 14:59:29 +1000308 tasklet_kill(&hostdata->srp_task);
Brian King0f33ece2010-06-17 13:56:00 -0500309 rc = 0;
David Woodhoused3849d52007-09-22 08:29:36 +1000310 do {
Brian King0f33ece2010-06-17 13:56:00 -0500311 if (rc)
312 msleep(100);
David Woodhoused3849d52007-09-22 08:29:36 +1000313 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
314 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
315 reg_crq_failed:
316 dma_unmap_single(hostdata->dev,
317 queue->msg_token,
318 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
319 map_failed:
320 free_page((unsigned long)queue->msgs);
321 malloc_failed:
322 return -1;
323}
324
325/**
326 * reenable_crq_queue: - reenables a crq after
327 * @queue: crq_queue to initialize and register
328 * @hostdata: ibmvscsi_host_data of host
329 *
330 */
331static int rpavscsi_reenable_crq_queue(struct crq_queue *queue,
332 struct ibmvscsi_host_data *hostdata)
333{
Brian King0f33ece2010-06-17 13:56:00 -0500334 int rc = 0;
David Woodhoused3849d52007-09-22 08:29:36 +1000335 struct vio_dev *vdev = to_vio_dev(hostdata->dev);
336
337 /* Re-enable the CRQ */
338 do {
Brian King0f33ece2010-06-17 13:56:00 -0500339 if (rc)
340 msleep(100);
David Woodhoused3849d52007-09-22 08:29:36 +1000341 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
342 } while ((rc == H_IN_PROGRESS) || (rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
343
344 if (rc)
345 dev_err(hostdata->dev, "Error %d enabling adapter\n", rc);
346 return rc;
347}
348
Brian King64355b92010-02-21 10:37:57 -0600349/**
350 * rpavscsi_resume: - resume after suspend
351 * @hostdata: ibmvscsi_host_data of host
352 *
353 */
354static int rpavscsi_resume(struct ibmvscsi_host_data *hostdata)
355{
356 vio_disable_interrupts(to_vio_dev(hostdata->dev));
357 tasklet_schedule(&hostdata->srp_task);
358 return 0;
359}
360
David Woodhoused3849d52007-09-22 08:29:36 +1000361struct ibmvscsi_ops rpavscsi_ops = {
362 .init_crq_queue = rpavscsi_init_crq_queue,
363 .release_crq_queue = rpavscsi_release_crq_queue,
364 .reset_crq_queue = rpavscsi_reset_crq_queue,
365 .reenable_crq_queue = rpavscsi_reenable_crq_queue,
366 .send_crq = rpavscsi_send_crq,
Brian King64355b92010-02-21 10:37:57 -0600367 .resume = rpavscsi_resume,
David Woodhoused3849d52007-09-22 08:29:36 +1000368};