?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: possible cleanups
[linux-2.6/verdex.git] / drivers / scsi / hptiop.c
blobf77808329e7cb8937913bb725ef4d0b402e8d9c0
1 /*
2 * HighPoint RR3xxx controller driver for Linux
3 * Copyright (C) 2006 HighPoint Technologies, Inc. All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * Please report bugs/comments/suggestions to linux@highpoint-tech.com
15 *
16 * For more information, visit http://www.highpoint-tech.com
17 */
18 #include <linux/config.h>
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/string.h>
22 #include <linux/kernel.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
25 #include <linux/errno.h>
26 #include <linux/delay.h>
27 #include <linux/timer.h>
28 #include <linux/spinlock.h>
29 #include <linux/hdreg.h>
30 #include <asm/uaccess.h>
31 #include <asm/io.h>
32 #include <asm/div64.h>
33 #include <scsi/scsi_cmnd.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi.h>
36 #include <scsi/scsi_tcq.h>
37 #include <scsi/scsi_host.h>
38
39 #include "hptiop.h"
40
41 MODULE_AUTHOR("HighPoint Technologies, Inc.");
42 MODULE_DESCRIPTION("HighPoint RocketRAID 3xxx SATA Controller Driver");
43
44 static char driver_name[] = "hptiop";
45 static const char driver_name_long[] = "RocketRAID 3xxx SATA Controller driver";
46 static const char driver_ver[] = "v1.0 (060426)";
47
48 static DEFINE_SPINLOCK(hptiop_hba_list_lock);
49 static LIST_HEAD(hptiop_hba_list);
50 static int hptiop_cdev_major = -1;
51
52 static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 tag);
53 static void hptiop_iop_request_callback(struct hptiop_hba *hba, u32 tag);
54 static void hptiop_message_callback(struct hptiop_hba *hba, u32 msg);
55
56 static inline void hptiop_pci_posting_flush(struct hpt_iopmu __iomem *iop)
57 {
58 readl(&iop->outbound_intstatus);
59 }
60
61 static int iop_wait_ready(struct hpt_iopmu __iomem *iop, u32 millisec)
62 {
63 u32 req = 0;
64 int i;
65
66 for (i = 0; i < millisec; i++) {
67 req = readl(&iop->inbound_queue);
68 if (req != IOPMU_QUEUE_EMPTY)
69 break;
70 msleep(1);
71 }
72
73 if (req != IOPMU_QUEUE_EMPTY) {
74 writel(req, &iop->outbound_queue);
75 hptiop_pci_posting_flush(iop);
76 return 0;
77 }
78
79 return -1;
80 }
81
82 static void hptiop_request_callback(struct hptiop_hba *hba, u32 tag)
83 {
84 if ((tag & IOPMU_QUEUE_MASK_HOST_BITS) == IOPMU_QUEUE_ADDR_HOST_BIT)
85 return hptiop_host_request_callback(hba,
86 tag & ~IOPMU_QUEUE_ADDR_HOST_BIT);
87 else
88 return hptiop_iop_request_callback(hba, tag);
89 }
90
91 static inline void hptiop_drain_outbound_queue(struct hptiop_hba *hba)
92 {
93 u32 req;
94
95 while ((req = readl(&hba->iop->outbound_queue)) != IOPMU_QUEUE_EMPTY) {
96
97 if (req & IOPMU_QUEUE_MASK_HOST_BITS)
98 hptiop_request_callback(hba, req);
99 else {
100 struct hpt_iop_request_header __iomem * p;
101
102 p = (struct hpt_iop_request_header __iomem *)
103 ((char __iomem *)hba->iop + req);
104
105 if (readl(&p->flags) & IOP_REQUEST_FLAG_SYNC_REQUEST) {
106 if (readl(&p->context))
107 hptiop_request_callback(hba, req);
108 else
109 writel(1, &p->context);
110 }
111 else
112 hptiop_request_callback(hba, req);
113 }
114 }
115 }
116
117 static int __iop_intr(struct hptiop_hba *hba)
118 {
119 struct hpt_iopmu __iomem *iop = hba->iop;
120 u32 status;
121 int ret = 0;
122
123 status = readl(&iop->outbound_intstatus);
124
125 if (status & IOPMU_OUTBOUND_INT_MSG0) {
126 u32 msg = readl(&iop->outbound_msgaddr0);
127 dprintk("received outbound msg %x\n", msg);
128 writel(IOPMU_OUTBOUND_INT_MSG0, &iop->outbound_intstatus);
129 hptiop_message_callback(hba, msg);
130 ret = 1;
131 }
132
133 if (status & IOPMU_OUTBOUND_INT_POSTQUEUE) {
134 hptiop_drain_outbound_queue(hba);
135 ret = 1;
136 }
137
138 return ret;
139 }
140
141 static int iop_send_sync_request(struct hptiop_hba *hba,
142 void __iomem *_req, u32 millisec)
143 {
144 struct hpt_iop_request_header __iomem *req = _req;
145 u32 i;
146
147 writel(readl(&req->flags) | IOP_REQUEST_FLAG_SYNC_REQUEST,
148 &req->flags);
149
150 writel(0, &req->context);
151
152 writel((unsigned long)req - (unsigned long)hba->iop,
153 &hba->iop->inbound_queue);
154
155 hptiop_pci_posting_flush(hba->iop);
156
157 for (i = 0; i < millisec; i++) {
158 __iop_intr(hba);
159 if (readl(&req->context))
160 return 0;
161 msleep(1);
162 }
163
164 return -1;
165 }
166
167 static int iop_send_sync_msg(struct hptiop_hba *hba, u32 msg, u32 millisec)
168 {
169 u32 i;
170
171 hba->msg_done = 0;
172
173 writel(msg, &hba->iop->inbound_msgaddr0);
174
175 hptiop_pci_posting_flush(hba->iop);
176
177 for (i = 0; i < millisec; i++) {
178 spin_lock_irq(hba->host->host_lock);
179 __iop_intr(hba);
180 spin_unlock_irq(hba->host->host_lock);
181 if (hba->msg_done)
182 break;
183 msleep(1);
184 }
185
186 return hba->msg_done? 0 : -1;
187 }
188
189 static int iop_get_config(struct hptiop_hba *hba,
190 struct hpt_iop_request_get_config *config)
191 {
192 u32 req32;
193 struct hpt_iop_request_get_config __iomem *req;
194
195 req32 = readl(&hba->iop->inbound_queue);
196 if (req32 == IOPMU_QUEUE_EMPTY)
197 return -1;
198
199 req = (struct hpt_iop_request_get_config __iomem *)
200 ((unsigned long)hba->iop + req32);
201
202 writel(0, &req->header.flags);
203 writel(IOP_REQUEST_TYPE_GET_CONFIG, &req->header.type);
204 writel(sizeof(struct hpt_iop_request_get_config), &req->header.size);
205 writel(IOP_RESULT_PENDING, &req->header.result);
206
207 if (iop_send_sync_request(hba, req, 20000)) {
208 dprintk("Get config send cmd failed\n");
209 return -1;
210 }
211
212 memcpy_fromio(config, req, sizeof(*config));
213 writel(req32, &hba->iop->outbound_queue);
214 return 0;
215 }
216
217 static int iop_set_config(struct hptiop_hba *hba,
218 struct hpt_iop_request_set_config *config)
219 {
220 u32 req32;
221 struct hpt_iop_request_set_config __iomem *req;
222
223 req32 = readl(&hba->iop->inbound_queue);
224 if (req32 == IOPMU_QUEUE_EMPTY)
225 return -1;
226
227 req = (struct hpt_iop_request_set_config __iomem *)
228 ((unsigned long)hba->iop + req32);
229
230 memcpy_toio((u8 __iomem *)req + sizeof(struct hpt_iop_request_header),
231 (u8 *)config + sizeof(struct hpt_iop_request_header),
232 sizeof(struct hpt_iop_request_set_config) -
233 sizeof(struct hpt_iop_request_header));
234
235 writel(0, &req->header.flags);
236 writel(IOP_REQUEST_TYPE_SET_CONFIG, &req->header.type);
237 writel(sizeof(struct hpt_iop_request_set_config), &req->header.size);
238 writel(IOP_RESULT_PENDING, &req->header.result);
239
240 if (iop_send_sync_request(hba, req, 20000)) {
241 dprintk("Set config send cmd failed\n");
242 return -1;
243 }
244
245 writel(req32, &hba->iop->outbound_queue);
246 return 0;
247 }
248
249 static int hptiop_initialize_iop(struct hptiop_hba *hba)
250 {
251 struct hpt_iopmu __iomem *iop = hba->iop;
252
253 /* enable interrupts */
254 writel(~(IOPMU_OUTBOUND_INT_POSTQUEUE | IOPMU_OUTBOUND_INT_MSG0),
255 &iop->outbound_intmask);
256
257 hba->initialized = 1;
258
259 /* start background tasks */
260 if (iop_send_sync_msg(hba,
261 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) {
262 printk(KERN_ERR "scsi%d: fail to start background task\n",
263 hba->host->host_no);
264 return -1;
265 }
266 return 0;
267 }
268
269 static int hptiop_map_pci_bar(struct hptiop_hba *hba)
270 {
271 u32 mem_base_phy, length;
272 void __iomem *mem_base_virt;
273 struct pci_dev *pcidev = hba->pcidev;
274
275 if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
276 printk(KERN_ERR "scsi%d: pci resource invalid\n",
277 hba->host->host_no);
278 return -1;
279 }
280
281 mem_base_phy = pci_resource_start(pcidev, 0);
282 length = pci_resource_len(pcidev, 0);
283 mem_base_virt = ioremap(mem_base_phy, length);
284
285 if (!mem_base_virt) {
286 printk(KERN_ERR "scsi%d: Fail to ioremap memory space\n",
287 hba->host->host_no);
288 return -1;
289 }
290
291 hba->iop = mem_base_virt;
292 dprintk("hptiop_map_pci_bar: iop=%p\n", hba->iop);
293 return 0;
294 }
295
296 static void hptiop_message_callback(struct hptiop_hba *hba, u32 msg)
297 {
298 dprintk("iop message 0x%x\n", msg);
299
300 if (!hba->initialized)
301 return;
302
303 if (msg == IOPMU_INBOUND_MSG0_RESET) {
304 atomic_set(&hba->resetting, 0);
305 wake_up(&hba->reset_wq);
306 }
307 else if (msg <= IOPMU_INBOUND_MSG0_MAX)
308 hba->msg_done = 1;
309 }
310
311 static inline struct hptiop_request *get_req(struct hptiop_hba *hba)
312 {
313 struct hptiop_request *ret;
314
315 dprintk("get_req : req=%p\n", hba->req_list);
316
317 ret = hba->req_list;
318 if (ret)
319 hba->req_list = ret->next;
320
321 return ret;
322 }
323
324 static inline void free_req(struct hptiop_hba *hba, struct hptiop_request *req)
325 {
326 dprintk("free_req(%d, %p)\n", req->index, req);
327 req->next = hba->req_list;
328 hba->req_list = req;
329 }
330
331 static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 tag)
332 {
333 struct hpt_iop_request_scsi_command *req;
334 struct scsi_cmnd *scp;
335
336 req = (struct hpt_iop_request_scsi_command *)hba->reqs[tag].req_virt;
337 dprintk("hptiop_host_request_callback: req=%p, type=%d, "
338 "result=%d, context=0x%x tag=%d\n",
339 req, req->header.type, req->header.result,
340 req->header.context, tag);
341
342 BUG_ON(!req->header.result);
343 BUG_ON(req->header.type != cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND));
344
345 scp = hba->reqs[tag].scp;
346
347 if (HPT_SCP(scp)->mapped) {
348 if (scp->use_sg)
349 pci_unmap_sg(hba->pcidev,
350 (struct scatterlist *)scp->request_buffer,
351 scp->use_sg,
352 scp->sc_data_direction
353 );
354 else
355 pci_unmap_single(hba->pcidev,
356 HPT_SCP(scp)->dma_handle,
357 scp->request_bufflen,
358 scp->sc_data_direction
359 );
360 }
361
362 switch (le32_to_cpu(req->header.result)) {
363 case IOP_RESULT_SUCCESS:
364 scp->result = (DID_OK<<16);
365 break;
366 case IOP_RESULT_BAD_TARGET:
367 scp->result = (DID_BAD_TARGET<<16);
368 break;
369 case IOP_RESULT_BUSY:
370 scp->result = (DID_BUS_BUSY<<16);
371 break;
372 case IOP_RESULT_RESET:
373 scp->result = (DID_RESET<<16);
374 break;
375 case IOP_RESULT_FAIL:
376 scp->result = (DID_ERROR<<16);
377 break;
378 case IOP_RESULT_INVALID_REQUEST:
379 scp->result = (DID_ABORT<<16);
380 break;
381 case IOP_RESULT_MODE_SENSE_CHECK_CONDITION:
382 scp->result = SAM_STAT_CHECK_CONDITION;
383 memset(&scp->sense_buffer,
384 0, sizeof(scp->sense_buffer));
385 memcpy(&scp->sense_buffer,
386 &req->sg_list, le32_to_cpu(req->dataxfer_length));
387 break;
388
389 default:
390 scp->result = ((DRIVER_INVALID|SUGGEST_ABORT)<<24) |
391 (DID_ABORT<<16);
392 break;
393 }
394
395 dprintk("scsi_done(%p)\n", scp);
396 scp->scsi_done(scp);
397 free_req(hba, &hba->reqs[tag]);
398 }
399
400 void hptiop_iop_request_callback(struct hptiop_hba *hba, u32 tag)
401 {
402 struct hpt_iop_request_header __iomem *req;
403 struct hpt_iop_request_ioctl_command __iomem *p;
404 struct hpt_ioctl_k *arg;
405
406 req = (struct hpt_iop_request_header __iomem *)
407 ((unsigned long)hba->iop + tag);
408 dprintk("hptiop_iop_request_callback: req=%p, type=%d, "
409 "result=%d, context=0x%x tag=%d\n",
410 req, readl(&req->type), readl(&req->result),
411 readl(&req->context), tag);
412
413 BUG_ON(!readl(&req->result));
414 BUG_ON(readl(&req->type) != IOP_REQUEST_TYPE_IOCTL_COMMAND);
415
416 p = (struct hpt_iop_request_ioctl_command __iomem *)req;
417 arg = (struct hpt_ioctl_k *)(unsigned long)
418 (readl(&req->context) |
419 ((u64)readl(&req->context_hi32)<<32));
420
421 if (readl(&req->result) == IOP_RESULT_SUCCESS) {
422 arg->result = HPT_IOCTL_RESULT_OK;
423
424 if (arg->outbuf_size)
425 memcpy_fromio(arg->outbuf,
426 &p->buf[(readl(&p->inbuf_size) + 3)& ~3],
427 arg->outbuf_size);
428
429 if (arg->bytes_returned)
430 *arg->bytes_returned = arg->outbuf_size;
431 }
432 else
433 arg->result = HPT_IOCTL_RESULT_FAILED;
434
435 arg->done(arg);
436 writel(tag, &hba->iop->outbound_queue);
437 }
438
439 static irqreturn_t hptiop_intr(int irq, void *dev_id, struct pt_regs *regs)
440 {
441 struct hptiop_hba *hba = dev_id;
442 int handled;
443 unsigned long flags;
444
445 spin_lock_irqsave(hba->host->host_lock, flags);
446 handled = __iop_intr(hba);
447 spin_unlock_irqrestore(hba->host->host_lock, flags);
448
449 return handled;
450 }
451
452 static int hptiop_buildsgl(struct scsi_cmnd *scp, struct hpt_iopsg *psg)
453 {
454 struct Scsi_Host *host = scp->device->host;
455 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
456 struct scatterlist *sglist = (struct scatterlist *)scp->request_buffer;
457
458 /*
459 * though we'll not get non-use_sg fields anymore,
460 * keep use_sg checking anyway
461 */
462 if (scp->use_sg) {
463 int idx;
464
465 HPT_SCP(scp)->sgcnt = pci_map_sg(hba->pcidev,
466 sglist, scp->use_sg,
467 scp->sc_data_direction);
468 HPT_SCP(scp)->mapped = 1;
469 BUG_ON(HPT_SCP(scp)->sgcnt > hba->max_sg_descriptors);
470
471 for (idx = 0; idx < HPT_SCP(scp)->sgcnt; idx++) {
472 psg[idx].pci_address =
473 cpu_to_le64(sg_dma_address(&sglist[idx]));
474 psg[idx].size = cpu_to_le32(sg_dma_len(&sglist[idx]));
475 psg[idx].eot = (idx == HPT_SCP(scp)->sgcnt - 1) ?
476 cpu_to_le32(1) : 0;
477 }
478
479 return HPT_SCP(scp)->sgcnt;
480 } else {
481 HPT_SCP(scp)->dma_handle = pci_map_single(
482 hba->pcidev,
483 scp->request_buffer,
484 scp->request_bufflen,
485 scp->sc_data_direction
486 );
487 HPT_SCP(scp)->mapped = 1;
488 psg->pci_address = cpu_to_le64(HPT_SCP(scp)->dma_handle);
489 psg->size = cpu_to_le32(scp->request_bufflen);
490 psg->eot = cpu_to_le32(1);
491 return 1;
492 }
493 }
494
495 static int hptiop_queuecommand(struct scsi_cmnd *scp,
496 void (*done)(struct scsi_cmnd *))
497 {
498 struct Scsi_Host *host = scp->device->host;
499 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
500 struct hpt_iop_request_scsi_command *req;
501 int sg_count = 0;
502 struct hptiop_request *_req;
503
504 BUG_ON(!done);
505 scp->scsi_done = done;
506
507 _req = get_req(hba);
508 if (_req == NULL) {
509 dprintk("hptiop_queuecmd : no free req\n");
510 return SCSI_MLQUEUE_HOST_BUSY;
511 }
512
513 _req->scp = scp;
514
515 dprintk("hptiop_queuecmd(scp=%p) %d/%d/%d/%d cdb=(%x-%x-%x) "
516 "req_index=%d, req=%p\n",
517 scp,
518 host->host_no, scp->device->channel,
519 scp->device->id, scp->device->lun,
520 *((u32 *)&scp->cmnd),
521 *((u32 *)&scp->cmnd + 1),
522 *((u32 *)&scp->cmnd + 2),
523 _req->index, _req->req_virt);
524
525 scp->result = 0;
526
527 if (scp->device->channel || scp->device->lun ||
528 scp->device->id > hba->max_devices) {
529 scp->result = DID_BAD_TARGET << 16;
530 free_req(hba, _req);
531 goto cmd_done;
532 }
533
534 req = (struct hpt_iop_request_scsi_command *)_req->req_virt;
535
536 /* build S/G table */
537 if (scp->request_bufflen)
538 sg_count = hptiop_buildsgl(scp, req->sg_list);
539 else
540 HPT_SCP(scp)->mapped = 0;
541
542 req->header.flags = cpu_to_le32(IOP_REQUEST_FLAG_OUTPUT_CONTEXT);
543 req->header.type = cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND);
544 req->header.result = cpu_to_le32(IOP_RESULT_PENDING);
545 req->header.context = cpu_to_le32(IOPMU_QUEUE_ADDR_HOST_BIT |
546 (u32)_req->index);
547 req->header.context_hi32 = 0;
548 req->dataxfer_length = cpu_to_le32(scp->request_bufflen);
549 req->channel = scp->device->channel;
550 req->target = scp->device->id;
551 req->lun = scp->device->lun;
552 req->header.size = cpu_to_le32(
553 sizeof(struct hpt_iop_request_scsi_command)
554 - sizeof(struct hpt_iopsg)
555 + sg_count * sizeof(struct hpt_iopsg));
556
557 memcpy(req->cdb, scp->cmnd, sizeof(req->cdb));
558
559 writel(IOPMU_QUEUE_ADDR_HOST_BIT | _req->req_shifted_phy,
560 &hba->iop->inbound_queue);
561
562 return 0;
563
564 cmd_done:
565 dprintk("scsi_done(scp=%p)\n", scp);
566 scp->scsi_done(scp);
567 return 0;
568 }
569
570 static const char *hptiop_info(struct Scsi_Host *host)
571 {
572 return driver_name_long;
573 }
574
575 static int hptiop_reset_hba(struct hptiop_hba *hba)
576 {
577 if (atomic_xchg(&hba->resetting, 1) == 0) {
578 atomic_inc(&hba->reset_count);
579 writel(IOPMU_INBOUND_MSG0_RESET,
580 &hba->iop->outbound_msgaddr0);
581 hptiop_pci_posting_flush(hba->iop);
582 }
583
584 wait_event_timeout(hba->reset_wq,
585 atomic_read(&hba->resetting) == 0, 60 * HZ);
586
587 if (atomic_read(&hba->resetting)) {
588 /* IOP is in unkown state, abort reset */
589 printk(KERN_ERR "scsi%d: reset failed\n", hba->host->host_no);
590 return -1;
591 }
592
593 if (iop_send_sync_msg(hba,
594 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) {
595 dprintk("scsi%d: fail to start background task\n",
596 hba->host->host_no);
597 }
598
599 return 0;
600 }
601
602 static int hptiop_reset(struct scsi_cmnd *scp)
603 {
604 struct Scsi_Host * host = scp->device->host;
605 struct hptiop_hba * hba = (struct hptiop_hba *)host->hostdata;
606
607 printk(KERN_WARNING "hptiop_reset(%d/%d/%d) scp=%p\n",
608 scp->device->host->host_no, scp->device->channel,
609 scp->device->id, scp);
610
611 return hptiop_reset_hba(hba)? FAILED : SUCCESS;
612 }
613
614 static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev,
615 int queue_depth)
616 {
617 if(queue_depth > 256)
618 queue_depth = 256;
619 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
620 return queue_depth;
621 }
622
623 struct hptiop_getinfo {
624 char __user *buffer;
625 loff_t buflength;
626 loff_t bufoffset;
627 loff_t buffillen;
628 loff_t filpos;
629 };
630
631 static void hptiop_copy_mem_info(struct hptiop_getinfo *pinfo,
632 char *data, int datalen)
633 {
634 if (pinfo->filpos < pinfo->bufoffset) {
635 if (pinfo->filpos + datalen <= pinfo->bufoffset) {
636 pinfo->filpos += datalen;
637 return;
638 } else {
639 data += (pinfo->bufoffset - pinfo->filpos);
640 datalen -= (pinfo->bufoffset - pinfo->filpos);
641 pinfo->filpos = pinfo->bufoffset;
642 }
643 }
644
645 pinfo->filpos += datalen;
646 if (pinfo->buffillen == pinfo->buflength)
647 return;
648
649 if (pinfo->buflength - pinfo->buffillen < datalen)
650 datalen = pinfo->buflength - pinfo->buffillen;
651
652 if (copy_to_user(pinfo->buffer + pinfo->buffillen, data, datalen))
653 return;
654
655 pinfo->buffillen += datalen;
656 }
657
658 static int hptiop_copy_info(struct hptiop_getinfo *pinfo, char *fmt, ...)
659 {
660 va_list args;
661 char buf[128];
662 int len;
663
664 va_start(args, fmt);
665 len = vsnprintf(buf, sizeof(buf), fmt, args);
666 va_end(args);
667 hptiop_copy_mem_info(pinfo, buf, len);
668 return len;
669 }
670
671 static void hptiop_ioctl_done(struct hpt_ioctl_k *arg)
672 {
673 arg->done = NULL;
674 wake_up(&arg->hba->ioctl_wq);
675 }
676
677 static void hptiop_do_ioctl(struct hpt_ioctl_k *arg)
678 {
679 struct hptiop_hba *hba = arg->hba;
680 u32 val;
681 struct hpt_iop_request_ioctl_command __iomem *req;
682 int ioctl_retry = 0;
683
684 dprintk("scsi%d: hptiop_do_ioctl\n", hba->host->host_no);
685
686 /*
687 * check (in + out) buff size from application.
688 * outbuf must be dword aligned.
689 */
690 if (((arg->inbuf_size + 3) & ~3) + arg->outbuf_size >
691 hba->max_request_size
692 - sizeof(struct hpt_iop_request_header)
693 - 4 * sizeof(u32)) {
694 dprintk("scsi%d: ioctl buf size (%d/%d) is too large\n",
695 hba->host->host_no,
696 arg->inbuf_size, arg->outbuf_size);
697 arg->result = HPT_IOCTL_RESULT_FAILED;
698 return;
699 }
700
701 retry:
702 spin_lock_irq(hba->host->host_lock);
703
704 val = readl(&hba->iop->inbound_queue);
705 if (val == IOPMU_QUEUE_EMPTY) {
706 spin_unlock_irq(hba->host->host_lock);
707 dprintk("scsi%d: no free req for ioctl\n", hba->host->host_no);
708 arg->result = -1;
709 return;
710 }
711
712 req = (struct hpt_iop_request_ioctl_command __iomem *)
713 ((unsigned long)hba->iop + val);
714
715 writel(HPT_CTL_CODE_LINUX_TO_IOP(arg->ioctl_code),
716 &req->ioctl_code);
717 writel(arg->inbuf_size, &req->inbuf_size);
718 writel(arg->outbuf_size, &req->outbuf_size);
719
720 /*
721 * use the buffer on the IOP local memory first, then copy it
722 * back to host.
723 * the caller's request buffer shoudl be little-endian.
724 */
725 if (arg->inbuf_size)
726 memcpy_toio(req->buf, arg->inbuf, arg->inbuf_size);
727
728 /* correct the controller ID for IOP */
729 if ((arg->ioctl_code == HPT_IOCTL_GET_CHANNEL_INFO ||
730 arg->ioctl_code == HPT_IOCTL_GET_CONTROLLER_INFO_V2 ||
731 arg->ioctl_code == HPT_IOCTL_GET_CONTROLLER_INFO)
732 && arg->inbuf_size >= sizeof(u32))
733 writel(0, req->buf);
734
735 writel(IOP_REQUEST_TYPE_IOCTL_COMMAND, &req->header.type);
736 writel(0, &req->header.flags);
737 writel(offsetof(struct hpt_iop_request_ioctl_command, buf)
738 + arg->inbuf_size, &req->header.size);
739 writel((u32)(unsigned long)arg, &req->header.context);
740 writel(BITS_PER_LONG > 32 ? (u32)((unsigned long)arg>>32) : 0,
741 &req->header.context_hi32);
742 writel(IOP_RESULT_PENDING, &req->header.result);
743
744 arg->result = HPT_IOCTL_RESULT_FAILED;
745 arg->done = hptiop_ioctl_done;
746
747 writel(val, &hba->iop->inbound_queue);
748 hptiop_pci_posting_flush(hba->iop);
749
750 spin_unlock_irq(hba->host->host_lock);
751
752 wait_event_timeout(hba->ioctl_wq, arg->done == NULL, 60 * HZ);
753
754 if (arg->done != NULL) {
755 hptiop_reset_hba(hba);
756 if (ioctl_retry++ < 3)
757 goto retry;
758 }
759
760 dprintk("hpt_iop_ioctl %x result %d\n",
761 arg->ioctl_code, arg->result);
762 }
763
764 static int __hpt_do_ioctl(struct hptiop_hba *hba, u32 code, void *inbuf,
765 u32 insize, void *outbuf, u32 outsize)
766 {
767 struct hpt_ioctl_k arg;
768 arg.hba = hba;
769 arg.ioctl_code = code;
770 arg.inbuf = inbuf;
771 arg.outbuf = outbuf;
772 arg.inbuf_size = insize;
773 arg.outbuf_size = outsize;
774 arg.bytes_returned = NULL;
775 hptiop_do_ioctl(&arg);
776 return arg.result;
777 }
778
779 static inline int hpt_id_valid(__le32 id)
780 {
781 return id != 0 && id != cpu_to_le32(0xffffffff);
782 }
783
784 static int hptiop_get_controller_info(struct hptiop_hba *hba,
785 struct hpt_controller_info *pinfo)
786 {
787 int id = 0;
788
789 return __hpt_do_ioctl(hba, HPT_IOCTL_GET_CONTROLLER_INFO,
790 &id, sizeof(int), pinfo, sizeof(*pinfo));
791 }
792
793
794 static int hptiop_get_channel_info(struct hptiop_hba *hba, int bus,
795 struct hpt_channel_info *pinfo)
796 {
797 u32 ids[2];
798
799 ids[0] = 0;
800 ids[1] = bus;
801 return __hpt_do_ioctl(hba, HPT_IOCTL_GET_CHANNEL_INFO,
802 ids, sizeof(ids), pinfo, sizeof(*pinfo));
803
804 }
805
806 static int hptiop_get_logical_devices(struct hptiop_hba *hba,
807 __le32 *pids, int maxcount)
808 {
809 int i;
810 u32 count = maxcount - 1;
811
812 if (__hpt_do_ioctl(hba, HPT_IOCTL_GET_LOGICAL_DEVICES,
813 &count, sizeof(u32),
814 pids, sizeof(u32) * maxcount))
815 return -1;
816
817 maxcount = le32_to_cpu(pids[0]);
818 for (i = 0; i < maxcount; i++)
819 pids[i] = pids[i+1];
820
821 return maxcount;
822 }
823
824 static int hptiop_get_device_info_v3(struct hptiop_hba *hba, __le32 id,
825 struct hpt_logical_device_info_v3 *pinfo)
826 {
827 return __hpt_do_ioctl(hba, HPT_IOCTL_GET_DEVICE_INFO_V3,
828 &id, sizeof(u32),
829 pinfo, sizeof(*pinfo));
830 }
831
832 static const char *get_array_status(struct hpt_logical_device_info_v3 *devinfo)
833 {
834 static char s[64];
835 u32 flags = le32_to_cpu(devinfo->u.array.flags);
836 u32 trans_prog = le32_to_cpu(devinfo->u.array.transforming_progress);
837 u32 reb_prog = le32_to_cpu(devinfo->u.array.rebuilding_progress);
838
839 if (flags & ARRAY_FLAG_DISABLED)
840 return "Disabled";
841 else if (flags & ARRAY_FLAG_TRANSFORMING)
842 sprintf(s, "Expanding/Migrating %d.%d%%%s%s",
843 trans_prog / 100,
844 trans_prog % 100,
845 (flags & (ARRAY_FLAG_NEEDBUILDING|ARRAY_FLAG_BROKEN))?
846 ", Critical" : "",
847 ((flags & ARRAY_FLAG_NEEDINITIALIZING) &&
848 !(flags & ARRAY_FLAG_REBUILDING) &&
849 !(flags & ARRAY_FLAG_INITIALIZING))?
850 ", Unintialized" : "");
851 else if ((flags & ARRAY_FLAG_BROKEN) &&
852 devinfo->u.array.array_type != AT_RAID6)
853 return "Critical";
854 else if (flags & ARRAY_FLAG_REBUILDING)
855 sprintf(s,
856 (flags & ARRAY_FLAG_NEEDINITIALIZING)?
857 "%sBackground initializing %d.%d%%" :
858 "%sRebuilding %d.%d%%",
859 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "",
860 reb_prog / 100,
861 reb_prog % 100);
862 else if (flags & ARRAY_FLAG_VERIFYING)
863 sprintf(s, "%sVerifying %d.%d%%",
864 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "",
865 reb_prog / 100,
866 reb_prog % 100);
867 else if (flags & ARRAY_FLAG_INITIALIZING)
868 sprintf(s, "%sForground initializing %d.%d%%",
869 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "",
870 reb_prog / 100,
871 reb_prog % 100);
872 else if (flags & ARRAY_FLAG_NEEDTRANSFORM)
873 sprintf(s,"%s%s%s", "Need Expanding/Migrating",
874 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "",
875 ((flags & ARRAY_FLAG_NEEDINITIALIZING) &&
876 !(flags & ARRAY_FLAG_REBUILDING) &&
877 !(flags & ARRAY_FLAG_INITIALIZING))?
878 ", Unintialized" : "");
879 else if (flags & ARRAY_FLAG_NEEDINITIALIZING &&
880 !(flags & ARRAY_FLAG_REBUILDING) &&
881 !(flags & ARRAY_FLAG_INITIALIZING))
882 sprintf(s,"%sUninitialized",
883 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "");
884 else if ((flags & ARRAY_FLAG_NEEDBUILDING) ||
885 (flags & ARRAY_FLAG_BROKEN))
886 return "Critical";
887 else
888 return "Normal";
889 return s;
890 }
891
892 static void hptiop_dump_devinfo(struct hptiop_hba *hba,
893 struct hptiop_getinfo *pinfo, __le32 id, int indent)
894 {
895 struct hpt_logical_device_info_v3 devinfo;
896 int i;
897 u64 capacity;
898
899 for (i = 0; i < indent; i++)
900 hptiop_copy_info(pinfo, "\t");
901
902 if (hptiop_get_device_info_v3(hba, id, &devinfo)) {
903 hptiop_copy_info(pinfo, "unknown\n");
904 return;
905 }
906
907 switch (devinfo.type) {
908
909 case LDT_DEVICE: {
910 struct hd_driveid *driveid;
911 u32 flags = le32_to_cpu(devinfo.u.device.flags);
912
913 driveid = (struct hd_driveid *)devinfo.u.device.ident;
914 /* model[] is 40 chars long, but we just want 20 chars here */
915 driveid->model[20] = 0;
916
917 if (indent)
918 if (flags & DEVICE_FLAG_DISABLED)
919 hptiop_copy_info(pinfo,"Missing\n");
920 else
921 hptiop_copy_info(pinfo, "CH%d %s\n",
922 devinfo.u.device.path_id + 1,
923 driveid->model);
924 else {
925 capacity = le64_to_cpu(devinfo.capacity) * 512;
926 do_div(capacity, 1000000);
927 hptiop_copy_info(pinfo,
928 "CH%d %s, %lluMB, %s %s%s%s%s\n",
929 devinfo.u.device.path_id + 1,
930 driveid->model,
931 capacity,
932 (flags & DEVICE_FLAG_DISABLED)?
933 "Disabled" : "Normal",
934 devinfo.u.device.read_ahead_enabled?
935 "[RA]" : "",
936 devinfo.u.device.write_cache_enabled?
937 "[WC]" : "",
938 devinfo.u.device.TCQ_enabled?
939 "[TCQ]" : "",
940 devinfo.u.device.NCQ_enabled?
941 "[NCQ]" : ""
942 );
943 }
944 break;
945 }
946
947 case LDT_ARRAY:
948 if (devinfo.target_id != INVALID_TARGET_ID)
949 hptiop_copy_info(pinfo, "[DISK %d_%d] ",
950 devinfo.vbus_id, devinfo.target_id);
951
952 capacity = le64_to_cpu(devinfo.capacity) * 512;
953 do_div(capacity, 1000000);
954 hptiop_copy_info(pinfo, "%s (%s), %lluMB, %s\n",
955 devinfo.u.array.name,
956 devinfo.u.array.array_type==AT_RAID0? "RAID0" :
957 devinfo.u.array.array_type==AT_RAID1? "RAID1" :
958 devinfo.u.array.array_type==AT_RAID5? "RAID5" :
959 devinfo.u.array.array_type==AT_RAID6? "RAID6" :
960 devinfo.u.array.array_type==AT_JBOD? "JBOD" :
961 "unknown",
962 capacity,
963 get_array_status(&devinfo));
964 for (i = 0; i < devinfo.u.array.ndisk; i++) {
965 if (hpt_id_valid(devinfo.u.array.members[i])) {
966 if (cpu_to_le16(1<<i) &
967 devinfo.u.array.critical_members)
968 hptiop_copy_info(pinfo, "\t*");
969 hptiop_dump_devinfo(hba, pinfo,
970 devinfo.u.array.members[i], indent+1);
971 }
972 else
973 hptiop_copy_info(pinfo, "\tMissing\n");
974 }
975 if (id == devinfo.u.array.transform_source) {
976 hptiop_copy_info(pinfo, "\tExpanding/Migrating to:\n");
977 hptiop_dump_devinfo(hba, pinfo,
978 devinfo.u.array.transform_target, indent+1);
979 }
980 break;
981 }
982 }
983
984 static ssize_t hptiop_show_version(struct class_device *class_dev, char *buf)
985 {
986 return snprintf(buf, PAGE_SIZE, "%s\n", driver_ver);
987 }
988
989 static ssize_t hptiop_cdev_read(struct file *filp, char __user *buf,
990 size_t count, loff_t *ppos)
991 {
992 struct hptiop_hba *hba = filp->private_data;
993 struct hptiop_getinfo info;
994 int i, j, ndev;
995 struct hpt_controller_info con_info;
996 struct hpt_channel_info chan_info;
997 __le32 ids[32];
998
999 info.buffer = buf;
1000 info.buflength = count;
1001 info.bufoffset = ppos ? *ppos : 0;
1002 info.filpos = 0;
1003 info.buffillen = 0;
1004
1005 if (hptiop_get_controller_info(hba, &con_info))
1006 return -EIO;
1007
1008 for (i = 0; i < con_info.num_buses; i++) {
1009 if (hptiop_get_channel_info(hba, i, &chan_info) == 0) {
1010 if (hpt_id_valid(chan_info.devices[0]))
1011 hptiop_dump_devinfo(hba, &info,
1012 chan_info.devices[0], 0);
1013 if (hpt_id_valid(chan_info.devices[1]))
1014 hptiop_dump_devinfo(hba, &info,
1015 chan_info.devices[1], 0);
1016 }
1017 }
1018
1019 ndev = hptiop_get_logical_devices(hba, ids,
1020 sizeof(ids) / sizeof(ids[0]));
1021
1022 /*
1023 * if hptiop_get_logical_devices fails, ndev==-1 and it just
1024 * output nothing here
1025 */
1026 for (j = 0; j < ndev; j++)
1027 hptiop_dump_devinfo(hba, &info, ids[j], 0);
1028
1029 if (ppos)
1030 *ppos += info.buffillen;
1031
1032 return info.buffillen;
1033 }
1034
1035 static int hptiop_cdev_ioctl(struct inode *inode, struct file *file,
1036 unsigned int cmd, unsigned long arg)
1037 {
1038 struct hptiop_hba *hba = file->private_data;
1039 struct hpt_ioctl_u ioctl_u;
1040 struct hpt_ioctl_k ioctl_k;
1041 u32 bytes_returned;
1042 int err = -EINVAL;
1043
1044 if (copy_from_user(&ioctl_u,
1045 (void __user *)arg, sizeof(struct hpt_ioctl_u)))
1046 return -EINVAL;
1047
1048 if (ioctl_u.magic != HPT_IOCTL_MAGIC)
1049 return -EINVAL;
1050
1051 ioctl_k.ioctl_code = ioctl_u.ioctl_code;
1052 ioctl_k.inbuf = NULL;
1053 ioctl_k.inbuf_size = ioctl_u.inbuf_size;
1054 ioctl_k.outbuf = NULL;
1055 ioctl_k.outbuf_size = ioctl_u.outbuf_size;
1056 ioctl_k.hba = hba;
1057 ioctl_k.bytes_returned = &bytes_returned;
1058
1059 /* verify user buffer */
1060 if ((ioctl_k.inbuf_size && !access_ok(VERIFY_READ,
1061 ioctl_u.inbuf, ioctl_k.inbuf_size)) ||
1062 (ioctl_k.outbuf_size && !access_ok(VERIFY_WRITE,
1063 ioctl_u.outbuf, ioctl_k.outbuf_size)) ||
1064 (ioctl_u.bytes_returned && !access_ok(VERIFY_WRITE,
1065 ioctl_u.bytes_returned, sizeof(u32))) ||
1066 ioctl_k.inbuf_size + ioctl_k.outbuf_size > 0x10000) {
1067
1068 dprintk("scsi%d: got bad user address\n", hba->host->host_no);
1069 return -EINVAL;
1070 }
1071
1072 /* map buffer to kernel. */
1073 if (ioctl_k.inbuf_size) {
1074 ioctl_k.inbuf = kmalloc(ioctl_k.inbuf_size, GFP_KERNEL);
1075 if (!ioctl_k.inbuf) {
1076 dprintk("scsi%d: fail to alloc inbuf\n",
1077 hba->host->host_no);
1078 err = -ENOMEM;
1079 goto err_exit;
1080 }
1081
1082 if (copy_from_user(ioctl_k.inbuf,
1083 ioctl_u.inbuf, ioctl_k.inbuf_size)) {
1084 goto err_exit;
1085 }
1086 }
1087
1088 if (ioctl_k.outbuf_size) {
1089 ioctl_k.outbuf = kmalloc(ioctl_k.outbuf_size, GFP_KERNEL);
1090 if (!ioctl_k.outbuf) {
1091 dprintk("scsi%d: fail to alloc outbuf\n",
1092 hba->host->host_no);
1093 err = -ENOMEM;
1094 goto err_exit;
1095 }
1096 }
1097
1098 hptiop_do_ioctl(&ioctl_k);
1099
1100 if (ioctl_k.result == HPT_IOCTL_RESULT_OK) {
1101 if (ioctl_k.outbuf_size &&
1102 copy_to_user(ioctl_u.outbuf,
1103 ioctl_k.outbuf, ioctl_k.outbuf_size))
1104 goto err_exit;
1105
1106 if (ioctl_u.bytes_returned &&
1107 copy_to_user(ioctl_u.bytes_returned,
1108 &bytes_returned, sizeof(u32)))
1109 goto err_exit;
1110
1111 err = 0;
1112 }
1113
1114 err_exit:
1115 kfree(ioctl_k.inbuf);
1116 kfree(ioctl_k.outbuf);
1117
1118 return err;
1119 }
1120
1121 static int hptiop_cdev_open(struct inode *inode, struct file *file)
1122 {
1123 struct hptiop_hba *hba;
1124 unsigned i = 0, minor = iminor(inode);
1125 int ret = -ENODEV;
1126
1127 spin_lock(&hptiop_hba_list_lock);
1128 list_for_each_entry(hba, &hptiop_hba_list, link) {
1129 if (i == minor) {
1130 file->private_data = hba;
1131 ret = 0;
1132 goto out;
1133 }
1134 i++;
1135 }
1136
1137 out:
1138 spin_unlock(&hptiop_hba_list_lock);
1139 return ret;
1140 }
1141
1142 static struct file_operations hptiop_cdev_fops = {
1143 .owner = THIS_MODULE,
1144 .read = hptiop_cdev_read,
1145 .ioctl = hptiop_cdev_ioctl,
1146 .open = hptiop_cdev_open,
1147 };
1148
1149 static ssize_t hptiop_show_fw_version(struct class_device *class_dev, char *buf)
1150 {
1151 struct Scsi_Host *host = class_to_shost(class_dev);
1152 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
1153
1154 return snprintf(buf, PAGE_SIZE, "%d.%d.%d.%d\n",
1155 hba->firmware_version >> 24,
1156 (hba->firmware_version >> 16) & 0xff,
1157 (hba->firmware_version >> 8) & 0xff,
1158 hba->firmware_version & 0xff);
1159 }
1160
1161 static struct class_device_attribute hptiop_attr_version = {
1162 .attr = {
1163 .name = "driver-version",
1164 .mode = S_IRUGO,
1165 },
1166 .show = hptiop_show_version,
1167 };
1168
1169 static struct class_device_attribute hptiop_attr_fw_version = {
1170 .attr = {
1171 .name = "firmware-version",
1172 .mode = S_IRUGO,
1173 },
1174 .show = hptiop_show_fw_version,
1175 };
1176
1177 static struct class_device_attribute *hptiop_attrs[] = {
1178 &hptiop_attr_version,
1179 &hptiop_attr_fw_version,
1180 NULL
1181 };
1182
1183 static struct scsi_host_template driver_template = {
1184 .module = THIS_MODULE,
1185 .name = driver_name,
1186 .queuecommand = hptiop_queuecommand,
1187 .eh_device_reset_handler = hptiop_reset,
1188 .eh_bus_reset_handler = hptiop_reset,
1189 .info = hptiop_info,
1190 .unchecked_isa_dma = 0,
1191 .emulated = 0,
1192 .use_clustering = ENABLE_CLUSTERING,
1193 .proc_name = driver_name,
1194 .shost_attrs = hptiop_attrs,
1195 .this_id = -1,
1196 .change_queue_depth = hptiop_adjust_disk_queue_depth,
1197 };
1198
1199 static int __devinit hptiop_probe(struct pci_dev *pcidev,
1200 const struct pci_device_id *id)
1201 {
1202 struct Scsi_Host *host = NULL;
1203 struct hptiop_hba *hba;
1204 struct hpt_iop_request_get_config iop_config;
1205 struct hpt_iop_request_set_config set_config;
1206 dma_addr_t start_phy;
1207 void *start_virt;
1208 u32 offset, i, req_size;
1209
1210 dprintk("hptiop_probe(%p)\n", pcidev);
1211
1212 if (pci_enable_device(pcidev)) {
1213 printk(KERN_ERR "hptiop: fail to enable pci device\n");
1214 return -ENODEV;
1215 }
1216
1217 printk(KERN_INFO "adapter at PCI %d:%d:%d, IRQ %d\n",
1218 pcidev->bus->number, pcidev->devfn >> 3, pcidev->devfn & 7,
1219 pcidev->irq);
1220
1221 pci_set_master(pcidev);
1222
1223 /* Enable 64bit DMA if possible */
1224 if (pci_set_dma_mask(pcidev, DMA_64BIT_MASK)) {
1225 if (pci_set_dma_mask(pcidev, DMA_32BIT_MASK)) {
1226 printk(KERN_ERR "hptiop: fail to set dma_mask\n");
1227 goto disable_pci_device;
1228 }
1229 }
1230
1231 if (pci_request_regions(pcidev, driver_name)) {
1232 printk(KERN_ERR "hptiop: pci_request_regions failed\n");
1233 goto disable_pci_device;
1234 }
1235
1236 host = scsi_host_alloc(&driver_template, sizeof(struct hptiop_hba));
1237 if (!host) {
1238 printk(KERN_ERR "hptiop: fail to alloc scsi host\n");
1239 goto free_pci_regions;
1240 }
1241
1242 hba = (struct hptiop_hba *)host->hostdata;
1243
1244 hba->pcidev = pcidev;
1245 hba->host = host;
1246 hba->initialized = 0;
1247
1248 atomic_set(&hba->resetting, 0);
1249 atomic_set(&hba->reset_count, 0);
1250
1251 init_waitqueue_head(&hba->reset_wq);
1252 init_waitqueue_head(&hba->ioctl_wq);
1253
1254 host->max_lun = 1;
1255 host->max_channel = 0;
1256 host->io_port = 0;
1257 host->n_io_port = 0;
1258 host->irq = pcidev->irq;
1259
1260 if (hptiop_map_pci_bar(hba))
1261 goto free_scsi_host;
1262
1263 if (iop_wait_ready(hba->iop, 20000)) {
1264 printk(KERN_ERR "scsi%d: firmware not ready\n",
1265 hba->host->host_no);
1266 goto unmap_pci_bar;
1267 }
1268
1269 if (iop_get_config(hba, &iop_config)) {
1270 printk(KERN_ERR "scsi%d: get config failed\n",
1271 hba->host->host_no);
1272 goto unmap_pci_bar;
1273 }
1274
1275 hba->max_requests = min(le32_to_cpu(iop_config.max_requests),
1276 HPTIOP_MAX_REQUESTS);
1277 hba->max_devices = le32_to_cpu(iop_config.max_devices);
1278 hba->max_request_size = le32_to_cpu(iop_config.request_size);
1279 hba->max_sg_descriptors = le32_to_cpu(iop_config.max_sg_count);
1280 hba->firmware_version = le32_to_cpu(iop_config.firmware_version);
1281 hba->sdram_size = le32_to_cpu(iop_config.sdram_size);
1282
1283 host->max_sectors = le32_to_cpu(iop_config.data_transfer_length) >> 9;
1284 host->max_id = le32_to_cpu(iop_config.max_devices);
1285 host->sg_tablesize = le32_to_cpu(iop_config.max_sg_count);
1286 host->can_queue = le32_to_cpu(iop_config.max_requests);
1287 host->cmd_per_lun = le32_to_cpu(iop_config.max_requests);
1288 host->max_cmd_len = 16;
1289
1290 set_config.vbus_id = cpu_to_le32(host->host_no);
1291 set_config.iop_id = cpu_to_le32(host->host_no);
1292
1293 if (iop_set_config(hba, &set_config)) {
1294 printk(KERN_ERR "scsi%d: set config failed\n",
1295 hba->host->host_no);
1296 goto unmap_pci_bar;
1297 }
1298
1299 if (scsi_add_host(host, &pcidev->dev)) {
1300 printk(KERN_ERR "scsi%d: scsi_add_host failed\n",
1301 hba->host->host_no);
1302 goto unmap_pci_bar;
1303 }
1304
1305 pci_set_drvdata(pcidev, host);
1306
1307 if (request_irq(pcidev->irq, hptiop_intr, SA_SHIRQ,
1308 driver_name, hba)) {
1309 printk(KERN_ERR "scsi%d: request irq %d failed\n",
1310 hba->host->host_no, pcidev->irq);
1311 goto remove_scsi_host;
1312 }
1313
1314 /* Allocate request mem */
1315 req_size = sizeof(struct hpt_iop_request_scsi_command)
1316 + sizeof(struct hpt_iopsg) * (hba->max_sg_descriptors - 1);
1317 if ((req_size& 0x1f) != 0)
1318 req_size = (req_size + 0x1f) & ~0x1f;
1319
1320 dprintk("req_size=%d, max_requests=%d\n", req_size, hba->max_requests);
1321
1322 hba->req_size = req_size;
1323 start_virt = dma_alloc_coherent(&pcidev->dev,
1324 hba->req_size*hba->max_requests + 0x20,
1325 &start_phy, GFP_KERNEL);
1326
1327 if (!start_virt) {
1328 printk(KERN_ERR "scsi%d: fail to alloc request mem\n",
1329 hba->host->host_no);
1330 goto free_request_irq;
1331 }
1332
1333 hba->dma_coherent = start_virt;
1334 hba->dma_coherent_handle = start_phy;
1335
1336 if ((start_phy & 0x1f) != 0)
1337 {
1338 offset = ((start_phy + 0x1f) & ~0x1f) - start_phy;
1339 start_phy += offset;
1340 start_virt += offset;
1341 }
1342
1343 hba->req_list = start_virt;
1344 for (i = 0; i < hba->max_requests; i++) {
1345 hba->reqs[i].next = NULL;
1346 hba->reqs[i].req_virt = start_virt;
1347 hba->reqs[i].req_shifted_phy = start_phy >> 5;
1348 hba->reqs[i].index = i;
1349 free_req(hba, &hba->reqs[i]);
1350 start_virt = (char *)start_virt + hba->req_size;
1351 start_phy = start_phy + hba->req_size;
1352 }
1353
1354 /* Enable Interrupt and start background task */
1355 if (hptiop_initialize_iop(hba))
1356 goto free_request_mem;
1357
1358 spin_lock(&hptiop_hba_list_lock);
1359 list_add_tail(&hba->link, &hptiop_hba_list);
1360 spin_unlock(&hptiop_hba_list_lock);
1361
1362 scsi_scan_host(host);
1363
1364 dprintk("scsi%d: hptiop_probe successfully\n", hba->host->host_no);
1365 return 0;
1366
1367 free_request_mem:
1368 dma_free_coherent(&hba->pcidev->dev,
1369 hba->req_size*hba->max_requests + 0x20,
1370 hba->dma_coherent, hba->dma_coherent_handle);
1371
1372 free_request_irq:
1373 free_irq(hba->pcidev->irq, hba);
1374
1375 remove_scsi_host:
1376 scsi_remove_host(host);
1377
1378 unmap_pci_bar:
1379 iounmap(hba->iop);
1380
1381 free_pci_regions:
1382 pci_release_regions(pcidev) ;
1383
1384 free_scsi_host:
1385 scsi_host_put(host);
1386
1387 disable_pci_device:
1388 pci_disable_device(pcidev);
1389
1390 dprintk("scsi%d: hptiop_probe fail\n", host->host_no);
1391 return -ENODEV;
1392 }
1393
1394 static void hptiop_shutdown(struct pci_dev *pcidev)
1395 {
1396 struct Scsi_Host *host = pci_get_drvdata(pcidev);
1397 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
1398 struct hpt_iopmu __iomem *iop = hba->iop;
1399 u32 int_mask;
1400
1401 dprintk("hptiop_shutdown(%p)\n", hba);
1402
1403 /* stop the iop */
1404 if (iop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_SHUTDOWN, 60000))
1405 printk(KERN_ERR "scsi%d: shutdown the iop timeout\n",
1406 hba->host->host_no);
1407
1408 /* disable all outbound interrupts */
1409 int_mask = readl(&iop->outbound_intmask);
1410 writel(int_mask |
1411 IOPMU_OUTBOUND_INT_MSG0 | IOPMU_OUTBOUND_INT_POSTQUEUE,
1412 &iop->outbound_intmask);
1413 hptiop_pci_posting_flush(iop);
1414 }
1415
1416 static void hptiop_remove(struct pci_dev *pcidev)
1417 {
1418 struct Scsi_Host *host = pci_get_drvdata(pcidev);
1419 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
1420
1421 dprintk("scsi%d: hptiop_remove\n", hba->host->host_no);
1422
1423 scsi_remove_host(host);
1424
1425 spin_lock(&hptiop_hba_list_lock);
1426 list_del_init(&hba->link);
1427 spin_unlock(&hptiop_hba_list_lock);
1428
1429 hptiop_shutdown(pcidev);
1430
1431 free_irq(hba->pcidev->irq, hba);
1432
1433 dma_free_coherent(&hba->pcidev->dev,
1434 hba->req_size * hba->max_requests + 0x20,
1435 hba->dma_coherent,
1436 hba->dma_coherent_handle);
1437
1438 iounmap(hba->iop);
1439
1440 pci_release_regions(hba->pcidev);
1441 pci_set_drvdata(hba->pcidev, NULL);
1442 pci_disable_device(hba->pcidev);
1443
1444 scsi_host_put(host);
1445 }
1446
1447 static struct pci_device_id hptiop_id_table[] = {
1448 { PCI_DEVICE(0x1103, 0x3220) },
1449 { PCI_DEVICE(0x1103, 0x3320) },
1450 {},
1451 };
1452
1453 MODULE_DEVICE_TABLE(pci, hptiop_id_table);
1454
1455 static struct pci_driver hptiop_pci_driver = {
1456 .name = driver_name,
1457 .id_table = hptiop_id_table,
1458 .probe = hptiop_probe,
1459 .remove = hptiop_remove,
1460 .shutdown = hptiop_shutdown,
1461 };
1462
1463 static int __init hptiop_module_init(void)
1464 {
1465 int error;
1466
1467 printk(KERN_INFO "%s %s\n", driver_name_long, driver_ver);
1468
1469 error = pci_register_driver(&hptiop_pci_driver);
1470 if (error < 0)
1471 return error;
1472
1473 hptiop_cdev_major = register_chrdev(0, "hptiop", &hptiop_cdev_fops);
1474 if (hptiop_cdev_major < 0) {
1475 printk(KERN_WARNING "unable to register hptiop device.\n");
1476 return hptiop_cdev_major;
1477 }
1478
1479 return 0;
1480 }
1481
1482 static void __exit hptiop_module_exit(void)
1483 {
1484 dprintk("hptiop_module_exit\n");
1485 unregister_chrdev(hptiop_cdev_major, "hptiop");
1486 pci_unregister_driver(&hptiop_pci_driver);
1487 }
1488
1489
1490 module_init(hptiop_module_init);
1491 module_exit(hptiop_module_exit);
1492
1493 MODULE_LICENSE("GPL");
Verdex Pro support