?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / scsi / 3w-sas.c
blob4d314d740de443f34e28c100f88932c580f42c24
1 /*
2 3w-sas.c -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux.
3
4 Written By: Adam Radford <linuxraid@lsi.com>
5
6 Copyright (C) 2009 LSI Corporation.
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; version 2 of the License.
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 NO WARRANTY
18 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
19 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
20 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
21 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
22 solely responsible for determining the appropriateness of using and
23 distributing the Program and assumes all risks associated with its
24 exercise of rights under this Agreement, including but not limited to
25 the risks and costs of program errors, damage to or loss of data,
26 programs or equipment, and unavailability or interruption of operations.
27
28 DISCLAIMER OF LIABILITY
29 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
30 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
32 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
33 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
34 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
35 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
36
37 You should have received a copy of the GNU General Public License
38 along with this program; if not, write to the Free Software
39 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
40
41 Controllers supported by this driver:
42
43 LSI 3ware 9750 6Gb/s SAS/SATA-RAID
44
45 Bugs/Comments/Suggestions should be mailed to:
46 linuxraid@lsi.com
47
48 For more information, goto:
49 http://www.lsi.com
50
51 History
52 -------
53 3.26.02.000 - Initial driver release.
54 */
55
56 #include <linux/module.h>
57 #include <linux/reboot.h>
58 #include <linux/spinlock.h>
59 #include <linux/interrupt.h>
60 #include <linux/moduleparam.h>
61 #include <linux/errno.h>
62 #include <linux/types.h>
63 #include <linux/delay.h>
64 #include <linux/pci.h>
65 #include <linux/time.h>
66 #include <linux/mutex.h>
67 #include <linux/smp_lock.h>
68 #include <asm/io.h>
69 #include <asm/irq.h>
70 #include <asm/uaccess.h>
71 #include <scsi/scsi.h>
72 #include <scsi/scsi_host.h>
73 #include <scsi/scsi_tcq.h>
74 #include <scsi/scsi_cmnd.h>
75 #include "3w-sas.h"
76
77 /* Globals */
78 #define TW_DRIVER_VERSION "3.26.02.000"
79 static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT];
80 static unsigned int twl_device_extension_count;
81 static int twl_major = -1;
82 extern struct timezone sys_tz;
83
84 /* Module parameters */
85 MODULE_AUTHOR ("LSI");
86 MODULE_DESCRIPTION ("LSI 3ware SAS/SATA-RAID Linux Driver");
87 MODULE_LICENSE("GPL");
88 MODULE_VERSION(TW_DRIVER_VERSION);
89
90 static int use_msi;
91 module_param(use_msi, int, S_IRUGO);
92 MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0");
93
94 /* Function prototypes */
95 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
96
97 /* Functions */
98
99 /* This function returns AENs through sysfs */
100 static ssize_t twl_sysfs_aen_read(struct kobject *kobj,
101 struct bin_attribute *bin_attr,
102 char *outbuf, loff_t offset, size_t count)
103 {
104 struct device *dev = container_of(kobj, struct device, kobj);
105 struct Scsi_Host *shost = class_to_shost(dev);
106 TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
107 unsigned long flags = 0;
108 ssize_t ret;
109
110 if (!capable(CAP_SYS_ADMIN))
111 return -EACCES;
112
113 spin_lock_irqsave(tw_dev->host->host_lock, flags);
114 ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH);
115 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
116
117 return ret;
118 } /* End twl_sysfs_aen_read() */
119
120 /* aen_read sysfs attribute initializer */
121 static struct bin_attribute twl_sysfs_aen_read_attr = {
122 .attr = {
123 .name = "3ware_aen_read",
124 .mode = S_IRUSR,
125 },
126 .size = 0,
127 .read = twl_sysfs_aen_read
128 };
129
130 /* This function returns driver compatibility info through sysfs */
131 static ssize_t twl_sysfs_compat_info(struct kobject *kobj,
132 struct bin_attribute *bin_attr,
133 char *outbuf, loff_t offset, size_t count)
134 {
135 struct device *dev = container_of(kobj, struct device, kobj);
136 struct Scsi_Host *shost = class_to_shost(dev);
137 TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
138 unsigned long flags = 0;
139 ssize_t ret;
140
141 if (!capable(CAP_SYS_ADMIN))
142 return -EACCES;
143
144 spin_lock_irqsave(tw_dev->host->host_lock, flags);
145 ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
146 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
147
148 return ret;
149 } /* End twl_sysfs_compat_info() */
150
151 /* compat_info sysfs attribute initializer */
152 static struct bin_attribute twl_sysfs_compat_info_attr = {
153 .attr = {
154 .name = "3ware_compat_info",
155 .mode = S_IRUSR,
156 },
157 .size = 0,
158 .read = twl_sysfs_compat_info
159 };
160
161 /* Show some statistics about the card */
162 static ssize_t twl_show_stats(struct device *dev,
163 struct device_attribute *attr, char *buf)
164 {
165 struct Scsi_Host *host = class_to_shost(dev);
166 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
167 unsigned long flags = 0;
168 ssize_t len;
169
170 spin_lock_irqsave(tw_dev->host->host_lock, flags);
171 len = snprintf(buf, PAGE_SIZE, "3w-sas Driver version: %s\n"
172 "Current commands posted: %4d\n"
173 "Max commands posted: %4d\n"
174 "Last sgl length: %4d\n"
175 "Max sgl length: %4d\n"
176 "Last sector count: %4d\n"
177 "Max sector count: %4d\n"
178 "SCSI Host Resets: %4d\n"
179 "AEN's: %4d\n",
180 TW_DRIVER_VERSION,
181 tw_dev->posted_request_count,
182 tw_dev->max_posted_request_count,
183 tw_dev->sgl_entries,
184 tw_dev->max_sgl_entries,
185 tw_dev->sector_count,
186 tw_dev->max_sector_count,
187 tw_dev->num_resets,
188 tw_dev->aen_count);
189 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
190 return len;
191 } /* End twl_show_stats() */
192
193 /* This function will set a devices queue depth */
194 static int twl_change_queue_depth(struct scsi_device *sdev, int queue_depth,
195 int reason)
196 {
197 if (reason != SCSI_QDEPTH_DEFAULT)
198 return -EOPNOTSUPP;
199
200 if (queue_depth > TW_Q_LENGTH-2)
201 queue_depth = TW_Q_LENGTH-2;
202 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
203 return queue_depth;
204 } /* End twl_change_queue_depth() */
205
206 /* stats sysfs attribute initializer */
207 static struct device_attribute twl_host_stats_attr = {
208 .attr = {
209 .name = "3ware_stats",
210 .mode = S_IRUGO,
211 },
212 .show = twl_show_stats
213 };
214
215 /* Host attributes initializer */
216 static struct device_attribute *twl_host_attrs[] = {
217 &twl_host_stats_attr,
218 NULL,
219 };
220
221 /* This function will look up an AEN severity string */
222 static char *twl_aen_severity_lookup(unsigned char severity_code)
223 {
224 char *retval = NULL;
225
226 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
227 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
228 goto out;
229
230 retval = twl_aen_severity_table[severity_code];
231 out:
232 return retval;
233 } /* End twl_aen_severity_lookup() */
234
235 /* This function will queue an event */
236 static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
237 {
238 u32 local_time;
239 struct timeval time;
240 TW_Event *event;
241 unsigned short aen;
242 char host[16];
243 char *error_str;
244
245 tw_dev->aen_count++;
246
247 /* Fill out event info */
248 event = tw_dev->event_queue[tw_dev->error_index];
249
250 host[0] = '\0';
251 if (tw_dev->host)
252 sprintf(host, " scsi%d:", tw_dev->host->host_no);
253
254 aen = le16_to_cpu(header->status_block.error);
255 memset(event, 0, sizeof(TW_Event));
256
257 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
258 do_gettimeofday(&time);
259 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
260 event->time_stamp_sec = local_time;
261 event->aen_code = aen;
262 event->retrieved = TW_AEN_NOT_RETRIEVED;
263 event->sequence_id = tw_dev->error_sequence_id;
264 tw_dev->error_sequence_id++;
265
266 /* Check for embedded error string */
267 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
268
269 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
270 event->parameter_len = strlen(header->err_specific_desc);
271 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str));
272 if (event->severity != TW_AEN_SEVERITY_DEBUG)
273 printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
274 host,
275 twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
276 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str,
277 header->err_specific_desc);
278 else
279 tw_dev->aen_count--;
280
281 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
282 } /* End twl_aen_queue_event() */
283
284 /* This function will attempt to post a command packet to the board */
285 static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
286 {
287 dma_addr_t command_que_value;
288
289 command_que_value = tw_dev->command_packet_phys[request_id];
290 command_que_value += TW_COMMAND_OFFSET;
291
292 /* First write upper 4 bytes */
293 writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev));
294 /* Then the lower 4 bytes */
295 writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev));
296
297 tw_dev->state[request_id] = TW_S_POSTED;
298 tw_dev->posted_request_count++;
299 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count)
300 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
301
302 return 0;
303 } /* End twl_post_command_packet() */
304
305 /* This function will perform a pci-dma mapping for a scatter gather list */
306 static int twl_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
307 {
308 int use_sg;
309 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
310
311 use_sg = scsi_dma_map(cmd);
312 if (!use_sg)
313 return 0;
314 else if (use_sg < 0) {
315 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Failed to map scatter gather list");
316 return 0;
317 }
318
319 cmd->SCp.phase = TW_PHASE_SGLIST;
320 cmd->SCp.have_data_in = use_sg;
321
322 return use_sg;
323 } /* End twl_map_scsi_sg_data() */
324
325 /* This function hands scsi cdb's to the firmware */
326 static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry_ISO *sglistarg)
327 {
328 TW_Command_Full *full_command_packet;
329 TW_Command_Apache *command_packet;
330 int i, sg_count;
331 struct scsi_cmnd *srb = NULL;
332 struct scatterlist *sglist = NULL, *sg;
333 int retval = 1;
334
335 if (tw_dev->srb[request_id]) {
336 srb = tw_dev->srb[request_id];
337 if (scsi_sglist(srb))
338 sglist = scsi_sglist(srb);
339 }
340
341 /* Initialize command packet */
342 full_command_packet = tw_dev->command_packet_virt[request_id];
343 full_command_packet->header.header_desc.size_header = 128;
344 full_command_packet->header.status_block.error = 0;
345 full_command_packet->header.status_block.severity__reserved = 0;
346
347 command_packet = &full_command_packet->command.newcommand;
348 command_packet->status = 0;
349 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
350
351 /* We forced 16 byte cdb use earlier */
352 if (!cdb)
353 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
354 else
355 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
356
357 if (srb) {
358 command_packet->unit = srb->device->id;
359 command_packet->request_id__lunl =
360 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
361 } else {
362 command_packet->request_id__lunl =
363 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
364 command_packet->unit = 0;
365 }
366
367 command_packet->sgl_offset = 16;
368
369 if (!sglistarg) {
370 /* Map sglist from scsi layer to cmd packet */
371 if (scsi_sg_count(srb)) {
372 sg_count = twl_map_scsi_sg_data(tw_dev, request_id);
373 if (sg_count == 0)
374 goto out;
375
376 scsi_for_each_sg(srb, sg, sg_count, i) {
377 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
378 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));
379 }
380 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
381 }
382 } else {
383 /* Internal cdb post */
384 for (i = 0; i < use_sg; i++) {
385 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
386 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length);
387 }
388 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
389 }
390
391 /* Update some stats */
392 if (srb) {
393 tw_dev->sector_count = scsi_bufflen(srb) / 512;
394 if (tw_dev->sector_count > tw_dev->max_sector_count)
395 tw_dev->max_sector_count = tw_dev->sector_count;
396 tw_dev->sgl_entries = scsi_sg_count(srb);
397 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
398 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
399 }
400
401 /* Now post the command to the board */
402 retval = twl_post_command_packet(tw_dev, request_id);
403
404 out:
405 return retval;
406 } /* End twl_scsiop_execute_scsi() */
407
408 /* This function will read the aen queue from the isr */
409 static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
410 {
411 char cdb[TW_MAX_CDB_LEN];
412 TW_SG_Entry_ISO sglist[1];
413 TW_Command_Full *full_command_packet;
414 int retval = 1;
415
416 full_command_packet = tw_dev->command_packet_virt[request_id];
417 memset(full_command_packet, 0, sizeof(TW_Command_Full));
418
419 /* Initialize cdb */
420 memset(&cdb, 0, TW_MAX_CDB_LEN);
421 cdb[0] = REQUEST_SENSE; /* opcode */
422 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
423
424 /* Initialize sglist */
425 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
426 sglist[0].length = TW_SECTOR_SIZE;
427 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
428
429 /* Mark internal command */
430 tw_dev->srb[request_id] = NULL;
431
432 /* Now post the command packet */
433 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
434 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue");
435 goto out;
436 }
437 retval = 0;
438 out:
439 return retval;
440 } /* End twl_aen_read_queue() */
441
442 /* This function will sync firmware time with the host time */
443 static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
444 {
445 u32 schedulertime;
446 struct timeval utc;
447 TW_Command_Full *full_command_packet;
448 TW_Command *command_packet;
449 TW_Param_Apache *param;
450 u32 local_time;
451
452 /* Fill out the command packet */
453 full_command_packet = tw_dev->command_packet_virt[request_id];
454 memset(full_command_packet, 0, sizeof(TW_Command_Full));
455 command_packet = &full_command_packet->command.oldcommand;
456 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
457 command_packet->request_id = request_id;
458 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
459 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
460 command_packet->size = TW_COMMAND_SIZE;
461 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
462
463 /* Setup the param */
464 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
465 memset(param, 0, TW_SECTOR_SIZE);
466 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
467 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
468 param->parameter_size_bytes = cpu_to_le16(4);
469
470 /* Convert system time in UTC to local time seconds since last
471 Sunday 12:00AM */
472 do_gettimeofday(&utc);
473 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
474 schedulertime = local_time - (3 * 86400);
475 schedulertime = cpu_to_le32(schedulertime % 604800);
476
477 memcpy(param->data, &schedulertime, sizeof(u32));
478
479 /* Mark internal command */
480 tw_dev->srb[request_id] = NULL;
481
482 /* Now post the command */
483 twl_post_command_packet(tw_dev, request_id);
484 } /* End twl_aen_sync_time() */
485
486 /* This function will assign an available request id */
487 static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
488 {
489 *request_id = tw_dev->free_queue[tw_dev->free_head];
490 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
491 tw_dev->state[*request_id] = TW_S_STARTED;
492 } /* End twl_get_request_id() */
493
494 /* This function will free a request id */
495 static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id)
496 {
497 tw_dev->free_queue[tw_dev->free_tail] = request_id;
498 tw_dev->state[request_id] = TW_S_FINISHED;
499 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
500 } /* End twl_free_request_id() */
501
502 /* This function will complete an aen request from the isr */
503 static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id)
504 {
505 TW_Command_Full *full_command_packet;
506 TW_Command *command_packet;
507 TW_Command_Apache_Header *header;
508 unsigned short aen;
509 int retval = 1;
510
511 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
512 tw_dev->posted_request_count--;
513 aen = le16_to_cpu(header->status_block.error);
514 full_command_packet = tw_dev->command_packet_virt[request_id];
515 command_packet = &full_command_packet->command.oldcommand;
516
517 /* First check for internal completion of set param for time sync */
518 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
519 /* Keep reading the queue in case there are more aen's */
520 if (twl_aen_read_queue(tw_dev, request_id))
521 goto out2;
522 else {
523 retval = 0;
524 goto out;
525 }
526 }
527
528 switch (aen) {
529 case TW_AEN_QUEUE_EMPTY:
530 /* Quit reading the queue if this is the last one */
531 break;
532 case TW_AEN_SYNC_TIME_WITH_HOST:
533 twl_aen_sync_time(tw_dev, request_id);
534 retval = 0;
535 goto out;
536 default:
537 twl_aen_queue_event(tw_dev, header);
538
539 /* If there are more aen's, keep reading the queue */
540 if (twl_aen_read_queue(tw_dev, request_id))
541 goto out2;
542 else {
543 retval = 0;
544 goto out;
545 }
546 }
547 retval = 0;
548 out2:
549 tw_dev->state[request_id] = TW_S_COMPLETED;
550 twl_free_request_id(tw_dev, request_id);
551 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
552 out:
553 return retval;
554 } /* End twl_aen_complete() */
555
556 /* This function will poll for a response */
557 static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
558 {
559 unsigned long before;
560 dma_addr_t mfa;
561 u32 regh, regl;
562 u32 response;
563 int retval = 1;
564 int found = 0;
565
566 before = jiffies;
567
568 while (!found) {
569 if (sizeof(dma_addr_t) > 4) {
570 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
571 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
572 mfa = ((u64)regh << 32) | regl;
573 } else
574 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
575
576 response = (u32)mfa;
577
578 if (TW_RESID_OUT(response) == request_id)
579 found = 1;
580
581 if (time_after(jiffies, before + HZ * seconds))
582 goto out;
583
584 msleep(50);
585 }
586 retval = 0;
587 out:
588 return retval;
589 } /* End twl_poll_response() */
590
591 /* This function will drain the aen queue */
592 static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
593 {
594 int request_id = 0;
595 char cdb[TW_MAX_CDB_LEN];
596 TW_SG_Entry_ISO sglist[1];
597 int finished = 0, count = 0;
598 TW_Command_Full *full_command_packet;
599 TW_Command_Apache_Header *header;
600 unsigned short aen;
601 int first_reset = 0, queue = 0, retval = 1;
602
603 if (no_check_reset)
604 first_reset = 0;
605 else
606 first_reset = 1;
607
608 full_command_packet = tw_dev->command_packet_virt[request_id];
609 memset(full_command_packet, 0, sizeof(TW_Command_Full));
610
611 /* Initialize cdb */
612 memset(&cdb, 0, TW_MAX_CDB_LEN);
613 cdb[0] = REQUEST_SENSE; /* opcode */
614 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
615
616 /* Initialize sglist */
617 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
618 sglist[0].length = TW_SECTOR_SIZE;
619 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
620
621 /* Mark internal command */
622 tw_dev->srb[request_id] = NULL;
623
624 do {
625 /* Send command to the board */
626 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
627 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense");
628 goto out;
629 }
630
631 /* Now poll for completion */
632 if (twl_poll_response(tw_dev, request_id, 30)) {
633 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue");
634 tw_dev->posted_request_count--;
635 goto out;
636 }
637
638 tw_dev->posted_request_count--;
639 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
640 aen = le16_to_cpu(header->status_block.error);
641 queue = 0;
642 count++;
643
644 switch (aen) {
645 case TW_AEN_QUEUE_EMPTY:
646 if (first_reset != 1)
647 goto out;
648 else
649 finished = 1;
650 break;
651 case TW_AEN_SOFT_RESET:
652 if (first_reset == 0)
653 first_reset = 1;
654 else
655 queue = 1;
656 break;
657 case TW_AEN_SYNC_TIME_WITH_HOST:
658 break;
659 default:
660 queue = 1;
661 }
662
663 /* Now queue an event info */
664 if (queue)
665 twl_aen_queue_event(tw_dev, header);
666 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
667
668 if (count == TW_MAX_AEN_DRAIN)
669 goto out;
670
671 retval = 0;
672 out:
673 tw_dev->state[request_id] = TW_S_INITIAL;
674 return retval;
675 } /* End twl_aen_drain_queue() */
676
677 /* This function will allocate memory and check if it is correctly aligned */
678 static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
679 {
680 int i;
681 dma_addr_t dma_handle;
682 unsigned long *cpu_addr;
683 int retval = 1;
684
685 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
686 if (!cpu_addr) {
687 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
688 goto out;
689 }
690
691 memset(cpu_addr, 0, size*TW_Q_LENGTH);
692
693 for (i = 0; i < TW_Q_LENGTH; i++) {
694 switch(which) {
695 case 0:
696 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
697 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
698 break;
699 case 1:
700 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
701 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
702 break;
703 case 2:
704 tw_dev->sense_buffer_phys[i] = dma_handle+(i*size);
705 tw_dev->sense_buffer_virt[i] = (TW_Command_Apache_Header *)((unsigned char *)cpu_addr + (i*size));
706 break;
707 }
708 }
709 retval = 0;
710 out:
711 return retval;
712 } /* End twl_allocate_memory() */
713
714 /* This function will load the request id and various sgls for ioctls */
715 static void twl_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
716 {
717 TW_Command *oldcommand;
718 TW_Command_Apache *newcommand;
719 TW_SG_Entry_ISO *sgl;
720 unsigned int pae = 0;
721
722 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
723 pae = 1;
724
725 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
726 newcommand = &full_command_packet->command.newcommand;
727 newcommand->request_id__lunl =
728 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
729 if (length) {
730 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
731 newcommand->sg_list[0].length = TW_CPU_TO_SGL(length);
732 }
733 newcommand->sgl_entries__lunh =
734 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
735 } else {
736 oldcommand = &full_command_packet->command.oldcommand;
737 oldcommand->request_id = request_id;
738
739 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
740 /* Load the sg list */
741 sgl = (TW_SG_Entry_ISO *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry_ISO)/4) + pae + (sizeof(dma_addr_t) > 4 ? 1 : 0));
742 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
743 sgl->length = TW_CPU_TO_SGL(length);
744 oldcommand->size += pae;
745 oldcommand->size += sizeof(dma_addr_t) > 4 ? 1 : 0;
746 }
747 }
748 } /* End twl_load_sgl() */
749
750 /* This function handles ioctl for the character device
751 This interface is used by smartmontools open source software */
752 static int twl_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
753 {
754 long timeout;
755 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
756 dma_addr_t dma_handle;
757 int request_id = 0;
758 TW_Ioctl_Driver_Command driver_command;
759 TW_Ioctl_Buf_Apache *tw_ioctl;
760 TW_Command_Full *full_command_packet;
761 TW_Device_Extension *tw_dev = twl_device_extension_list[iminor(inode)];
762 int retval = -EFAULT;
763 void __user *argp = (void __user *)arg;
764
765 /* Only let one of these through at a time */
766 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
767 retval = -EINTR;
768 goto out;
769 }
770
771 /* First copy down the driver command */
772 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
773 goto out2;
774
775 /* Check data buffer size */
776 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
777 retval = -EINVAL;
778 goto out2;
779 }
780
781 /* Hardware can only do multiple of 512 byte transfers */
782 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
783
784 /* Now allocate ioctl buf memory */
785 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, &dma_handle, GFP_KERNEL);
786 if (!cpu_addr) {
787 retval = -ENOMEM;
788 goto out2;
789 }
790
791 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
792
793 /* Now copy down the entire ioctl */
794 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
795 goto out3;
796
797 /* See which ioctl we are doing */
798 switch (cmd) {
799 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
800 spin_lock_irqsave(tw_dev->host->host_lock, flags);
801 twl_get_request_id(tw_dev, &request_id);
802
803 /* Flag internal command */
804 tw_dev->srb[request_id] = NULL;
805
806 /* Flag chrdev ioctl */
807 tw_dev->chrdev_request_id = request_id;
808
809 full_command_packet = (TW_Command_Full *)&tw_ioctl->firmware_command;
810
811 /* Load request id and sglist for both command types */
812 twl_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
813
814 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
815
816 /* Now post the command packet to the controller */
817 twl_post_command_packet(tw_dev, request_id);
818 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
819
820 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
821
822 /* Now wait for command to complete */
823 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
824
825 /* We timed out, and didn't get an interrupt */
826 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
827 /* Now we need to reset the board */
828 printk(KERN_WARNING "3w-sas: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
829 tw_dev->host->host_no, TW_DRIVER, 0x6,
830 cmd);
831 retval = -EIO;
832 twl_reset_device_extension(tw_dev, 1);
833 goto out3;
834 }
835
836 /* Now copy in the command packet response */
837 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
838
839 /* Now complete the io */
840 spin_lock_irqsave(tw_dev->host->host_lock, flags);
841 tw_dev->posted_request_count--;
842 tw_dev->state[request_id] = TW_S_COMPLETED;
843 twl_free_request_id(tw_dev, request_id);
844 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
845 break;
846 default:
847 retval = -ENOTTY;
848 goto out3;
849 }
850
851 /* Now copy the entire response to userspace */
852 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
853 retval = 0;
854 out3:
855 /* Now free ioctl buf memory */
856 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
857 out2:
858 mutex_unlock(&tw_dev->ioctl_lock);
859 out:
860 return retval;
861 } /* End twl_chrdev_ioctl() */
862
863 /* This function handles open for the character device */
864 static int twl_chrdev_open(struct inode *inode, struct file *file)
865 {
866 unsigned int minor_number;
867 int retval = -ENODEV;
868
869 if (!capable(CAP_SYS_ADMIN)) {
870 retval = -EACCES;
871 goto out;
872 }
873
874 cycle_kernel_lock();
875 minor_number = iminor(inode);
876 if (minor_number >= twl_device_extension_count)
877 goto out;
878 retval = 0;
879 out:
880 return retval;
881 } /* End twl_chrdev_open() */
882
883 /* File operations struct for character device */
884 static const struct file_operations twl_fops = {
885 .owner = THIS_MODULE,
886 .ioctl = twl_chrdev_ioctl,
887 .open = twl_chrdev_open,
888 .release = NULL
889 };
890
891 /* This function passes sense data from firmware to scsi layer */
892 static int twl_fill_sense(TW_Device_Extension *tw_dev, int i, int request_id, int copy_sense, int print_host)
893 {
894 TW_Command_Apache_Header *header;
895 TW_Command_Full *full_command_packet;
896 unsigned short error;
897 char *error_str;
898 int retval = 1;
899
900 header = tw_dev->sense_buffer_virt[i];
901 full_command_packet = tw_dev->command_packet_virt[request_id];
902
903 /* Get embedded firmware error string */
904 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]);
905
906 /* Don't print error for Logical unit not supported during rollcall */
907 error = le16_to_cpu(header->status_block.error);
908 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) {
909 if (print_host)
910 printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
911 tw_dev->host->host_no,
912 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
913 header->status_block.error,
914 error_str,
915 header->err_specific_desc);
916 else
917 printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n",
918 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
919 header->status_block.error,
920 error_str,
921 header->err_specific_desc);
922 }
923
924 if (copy_sense) {
925 memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH);
926 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
927 goto out;
928 }
929 out:
930 return retval;
931 } /* End twl_fill_sense() */
932
933 /* This function will free up device extension resources */
934 static void twl_free_device_extension(TW_Device_Extension *tw_dev)
935 {
936 if (tw_dev->command_packet_virt[0])
937 pci_free_consistent(tw_dev->tw_pci_dev,
938 sizeof(TW_Command_Full)*TW_Q_LENGTH,
939 tw_dev->command_packet_virt[0],
940 tw_dev->command_packet_phys[0]);
941
942 if (tw_dev->generic_buffer_virt[0])
943 pci_free_consistent(tw_dev->tw_pci_dev,
944 TW_SECTOR_SIZE*TW_Q_LENGTH,
945 tw_dev->generic_buffer_virt[0],
946 tw_dev->generic_buffer_phys[0]);
947
948 if (tw_dev->sense_buffer_virt[0])
949 pci_free_consistent(tw_dev->tw_pci_dev,
950 sizeof(TW_Command_Apache_Header)*
951 TW_Q_LENGTH,
952 tw_dev->sense_buffer_virt[0],
953 tw_dev->sense_buffer_phys[0]);
954
955 kfree(tw_dev->event_queue[0]);
956 } /* End twl_free_device_extension() */
957
958 /* This function will get parameter table entries from the firmware */
959 static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
960 {
961 TW_Command_Full *full_command_packet;
962 TW_Command *command_packet;
963 TW_Param_Apache *param;
964 void *retval = NULL;
965
966 /* Setup the command packet */
967 full_command_packet = tw_dev->command_packet_virt[request_id];
968 memset(full_command_packet, 0, sizeof(TW_Command_Full));
969 command_packet = &full_command_packet->command.oldcommand;
970
971 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
972 command_packet->size = TW_COMMAND_SIZE;
973 command_packet->request_id = request_id;
974 command_packet->byte6_offset.block_count = cpu_to_le16(1);
975
976 /* Now setup the param */
977 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
978 memset(param, 0, TW_SECTOR_SIZE);
979 param->table_id = cpu_to_le16(table_id | 0x8000);
980 param->parameter_id = cpu_to_le16(parameter_id);
981 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
982
983 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
984 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
985
986 /* Post the command packet to the board */
987 twl_post_command_packet(tw_dev, request_id);
988
989 /* Poll for completion */
990 if (twl_poll_response(tw_dev, request_id, 30))
991 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param")
992 else
993 retval = (void *)&(param->data[0]);
994
995 tw_dev->posted_request_count--;
996 tw_dev->state[request_id] = TW_S_INITIAL;
997
998 return retval;
999 } /* End twl_get_param() */
1000
1001 /* This function will send an initconnection command to controller */
1002 static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1003 u32 set_features, unsigned short current_fw_srl,
1004 unsigned short current_fw_arch_id,
1005 unsigned short current_fw_branch,
1006 unsigned short current_fw_build,
1007 unsigned short *fw_on_ctlr_srl,
1008 unsigned short *fw_on_ctlr_arch_id,
1009 unsigned short *fw_on_ctlr_branch,
1010 unsigned short *fw_on_ctlr_build,
1011 u32 *init_connect_result)
1012 {
1013 TW_Command_Full *full_command_packet;
1014 TW_Initconnect *tw_initconnect;
1015 int request_id = 0, retval = 1;
1016
1017 /* Initialize InitConnection command packet */
1018 full_command_packet = tw_dev->command_packet_virt[request_id];
1019 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1020 full_command_packet->header.header_desc.size_header = 128;
1021
1022 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1023 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1024 tw_initconnect->request_id = request_id;
1025 tw_initconnect->message_credits = cpu_to_le16(message_credits);
1026 tw_initconnect->features = set_features;
1027
1028 /* Turn on 64-bit sgl support if we need to */
1029 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1030
1031 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1032
1033 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1034 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1035 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1036 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1037 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1038 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1039 } else
1040 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1041
1042 /* Send command packet to the board */
1043 twl_post_command_packet(tw_dev, request_id);
1044
1045 /* Poll for completion */
1046 if (twl_poll_response(tw_dev, request_id, 30)) {
1047 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection");
1048 } else {
1049 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1050 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1051 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1052 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1053 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1054 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1055 }
1056 retval = 0;
1057 }
1058
1059 tw_dev->posted_request_count--;
1060 tw_dev->state[request_id] = TW_S_INITIAL;
1061
1062 return retval;
1063 } /* End twl_initconnection() */
1064
1065 /* This function will initialize the fields of a device extension */
1066 static int twl_initialize_device_extension(TW_Device_Extension *tw_dev)
1067 {
1068 int i, retval = 1;
1069
1070 /* Initialize command packet buffers */
1071 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1072 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed");
1073 goto out;
1074 }
1075
1076 /* Initialize generic buffer */
1077 if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1078 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed");
1079 goto out;
1080 }
1081
1082 /* Allocate sense buffers */
1083 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) {
1084 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed");
1085 goto out;
1086 }
1087
1088 /* Allocate event info space */
1089 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1090 if (!tw_dev->event_queue[0]) {
1091 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed");
1092 goto out;
1093 }
1094
1095 for (i = 0; i < TW_Q_LENGTH; i++) {
1096 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1097 tw_dev->free_queue[i] = i;
1098 tw_dev->state[i] = TW_S_INITIAL;
1099 }
1100
1101 tw_dev->free_head = TW_Q_START;
1102 tw_dev->free_tail = TW_Q_START;
1103 tw_dev->error_sequence_id = 1;
1104 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1105
1106 mutex_init(&tw_dev->ioctl_lock);
1107 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1108
1109 retval = 0;
1110 out:
1111 return retval;
1112 } /* End twl_initialize_device_extension() */
1113
1114 /* This function will perform a pci-dma unmap */
1115 static void twl_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1116 {
1117 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1118
1119 if (cmd->SCp.phase == TW_PHASE_SGLIST)
1120 scsi_dma_unmap(cmd);
1121 } /* End twl_unmap_scsi_data() */
1122
1123 /* This function will handle attention interrupts */
1124 static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev)
1125 {
1126 int retval = 1;
1127 u32 request_id, doorbell;
1128
1129 /* Read doorbell status */
1130 doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev));
1131
1132 /* Check for controller errors */
1133 if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) {
1134 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing");
1135 goto out;
1136 }
1137
1138 /* Check if we need to perform an AEN drain */
1139 if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) {
1140 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1141 twl_get_request_id(tw_dev, &request_id);
1142 if (twl_aen_read_queue(tw_dev, request_id)) {
1143 tw_dev->state[request_id] = TW_S_COMPLETED;
1144 twl_free_request_id(tw_dev, request_id);
1145 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1146 }
1147 }
1148 }
1149
1150 retval = 0;
1151 out:
1152 /* Clear doorbell interrupt */
1153 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1154
1155 /* Make sure the clear was flushed by reading it back */
1156 readl(TWL_HOBDBC_REG_ADDR(tw_dev));
1157
1158 return retval;
1159 } /* End twl_handle_attention_interrupt() */
1160
1161 /* Interrupt service routine */
1162 static irqreturn_t twl_interrupt(int irq, void *dev_instance)
1163 {
1164 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1165 int i, handled = 0, error = 0;
1166 dma_addr_t mfa = 0;
1167 u32 reg, regl, regh, response, request_id = 0;
1168 struct scsi_cmnd *cmd;
1169 TW_Command_Full *full_command_packet;
1170
1171 spin_lock(tw_dev->host->host_lock);
1172
1173 /* Read host interrupt status */
1174 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1175
1176 /* Check if this is our interrupt, otherwise bail */
1177 if (!(reg & TWL_HISTATUS_VALID_INTERRUPT))
1178 goto twl_interrupt_bail;
1179
1180 handled = 1;
1181
1182 /* If we are resetting, bail */
1183 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1184 goto twl_interrupt_bail;
1185
1186 /* Attention interrupt */
1187 if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) {
1188 if (twl_handle_attention_interrupt(tw_dev)) {
1189 TWL_MASK_INTERRUPTS(tw_dev);
1190 goto twl_interrupt_bail;
1191 }
1192 }
1193
1194 /* Response interrupt */
1195 while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) {
1196 if (sizeof(dma_addr_t) > 4) {
1197 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
1198 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1199 mfa = ((u64)regh << 32) | regl;
1200 } else
1201 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1202
1203 error = 0;
1204 response = (u32)mfa;
1205
1206 /* Check for command packet error */
1207 if (!TW_NOTMFA_OUT(response)) {
1208 for (i=0;i<TW_Q_LENGTH;i++) {
1209 if (tw_dev->sense_buffer_phys[i] == mfa) {
1210 request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id);
1211 if (tw_dev->srb[request_id] != NULL)
1212 error = twl_fill_sense(tw_dev, i, request_id, 1, 1);
1213 else {
1214 /* Skip ioctl error prints */
1215 if (request_id != tw_dev->chrdev_request_id)
1216 error = twl_fill_sense(tw_dev, i, request_id, 0, 1);
1217 else
1218 memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header));
1219 }
1220
1221 /* Now re-post the sense buffer */
1222 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1223 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1224 break;
1225 }
1226 }
1227 } else
1228 request_id = TW_RESID_OUT(response);
1229
1230 full_command_packet = tw_dev->command_packet_virt[request_id];
1231
1232 /* Check for correct state */
1233 if (tw_dev->state[request_id] != TW_S_POSTED) {
1234 if (tw_dev->srb[request_id] != NULL) {
1235 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted");
1236 TWL_MASK_INTERRUPTS(tw_dev);
1237 goto twl_interrupt_bail;
1238 }
1239 }
1240
1241 /* Check for internal command completion */
1242 if (tw_dev->srb[request_id] == NULL) {
1243 if (request_id != tw_dev->chrdev_request_id) {
1244 if (twl_aen_complete(tw_dev, request_id))
1245 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt");
1246 } else {
1247 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1248 wake_up(&tw_dev->ioctl_wqueue);
1249 }
1250 } else {
1251 cmd = tw_dev->srb[request_id];
1252
1253 if (!error)
1254 cmd->result = (DID_OK << 16);
1255
1256 /* Report residual bytes for single sgl */
1257 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1258 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1259 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1260 }
1261
1262 /* Now complete the io */
1263 tw_dev->state[request_id] = TW_S_COMPLETED;
1264 twl_free_request_id(tw_dev, request_id);
1265 tw_dev->posted_request_count--;
1266 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1267 twl_unmap_scsi_data(tw_dev, request_id);
1268 }
1269
1270 /* Check for another response interrupt */
1271 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1272 }
1273
1274 twl_interrupt_bail:
1275 spin_unlock(tw_dev->host->host_lock);
1276 return IRQ_RETVAL(handled);
1277 } /* End twl_interrupt() */
1278
1279 /* This function will poll for a register change */
1280 static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds)
1281 {
1282 unsigned long before;
1283 int retval = 1;
1284 u32 reg_value;
1285
1286 reg_value = readl(reg);
1287 before = jiffies;
1288
1289 while ((reg_value & value) != result) {
1290 reg_value = readl(reg);
1291 if (time_after(jiffies, before + HZ * seconds))
1292 goto out;
1293 msleep(50);
1294 }
1295 retval = 0;
1296 out:
1297 return retval;
1298 } /* End twl_poll_register() */
1299
1300 /* This function will reset a controller */
1301 static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1302 {
1303 int retval = 1;
1304 int i = 0;
1305 u32 status = 0;
1306 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
1307 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
1308 u32 init_connect_result = 0;
1309 int tries = 0;
1310 int do_soft_reset = soft_reset;
1311
1312 while (tries < TW_MAX_RESET_TRIES) {
1313 /* Do a soft reset if one is needed */
1314 if (do_soft_reset) {
1315 TWL_SOFT_RESET(tw_dev);
1316
1317 /* Make sure controller is in a good state */
1318 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) {
1319 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence");
1320 tries++;
1321 continue;
1322 }
1323 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) {
1324 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence");
1325 tries++;
1326 continue;
1327 }
1328 }
1329
1330 /* Initconnect */
1331 if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
1332 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
1333 TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
1334 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
1335 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
1336 &fw_on_ctlr_build, &init_connect_result)) {
1337 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL");
1338 do_soft_reset = 1;
1339 tries++;
1340 continue;
1341 }
1342
1343 /* Load sense buffers */
1344 while (i < TW_Q_LENGTH) {
1345 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1346 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1347
1348 /* Check status for over-run after each write */
1349 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1350 if (!(status & TWL_STATUS_OVERRUN_SUBMIT))
1351 i++;
1352 }
1353
1354 /* Now check status */
1355 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1356 if (status) {
1357 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers");
1358 do_soft_reset = 1;
1359 tries++;
1360 continue;
1361 }
1362
1363 /* Drain the AEN queue */
1364 if (twl_aen_drain_queue(tw_dev, soft_reset)) {
1365 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence");
1366 do_soft_reset = 1;
1367 tries++;
1368 continue;
1369 }
1370
1371 /* Load rest of compatibility struct */
1372 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
1373 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
1374 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
1375 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
1376 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
1377 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
1378 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
1379 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
1380 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
1381 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
1382
1383 /* If we got here, controller is in a good state */
1384 retval = 0;
1385 goto out;
1386 }
1387 out:
1388 return retval;
1389 } /* End twl_reset_sequence() */
1390
1391 /* This function will reset a device extension */
1392 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1393 {
1394 int i = 0, retval = 1;
1395 unsigned long flags = 0;
1396
1397 /* Block SCSI requests while we are resetting */
1398 if (ioctl_reset)
1399 scsi_block_requests(tw_dev->host);
1400
1401 set_bit(TW_IN_RESET, &tw_dev->flags);
1402 TWL_MASK_INTERRUPTS(tw_dev);
1403 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1404
1405 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1406
1407 /* Abort all requests that are in progress */
1408 for (i = 0; i < TW_Q_LENGTH; i++) {
1409 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1410 (tw_dev->state[i] != TW_S_INITIAL) &&
1411 (tw_dev->state[i] != TW_S_COMPLETED)) {
1412 if (tw_dev->srb[i]) {
1413 tw_dev->srb[i]->result = (DID_RESET << 16);
1414 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1415 twl_unmap_scsi_data(tw_dev, i);
1416 }
1417 }
1418 }
1419
1420 /* Reset queues and counts */
1421 for (i = 0; i < TW_Q_LENGTH; i++) {
1422 tw_dev->free_queue[i] = i;
1423 tw_dev->state[i] = TW_S_INITIAL;
1424 }
1425 tw_dev->free_head = TW_Q_START;
1426 tw_dev->free_tail = TW_Q_START;
1427 tw_dev->posted_request_count = 0;
1428
1429 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1430
1431 if (twl_reset_sequence(tw_dev, 1))
1432 goto out;
1433
1434 TWL_UNMASK_INTERRUPTS(tw_dev);
1435
1436 clear_bit(TW_IN_RESET, &tw_dev->flags);
1437 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1438
1439 retval = 0;
1440 out:
1441 if (ioctl_reset)
1442 scsi_unblock_requests(tw_dev->host);
1443 return retval;
1444 } /* End twl_reset_device_extension() */
1445
1446 /* This funciton returns unit geometry in cylinders/heads/sectors */
1447 static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1448 {
1449 int heads, sectors;
1450 TW_Device_Extension *tw_dev;
1451
1452 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1453
1454 if (capacity >= 0x200000) {
1455 heads = 255;
1456 sectors = 63;
1457 } else {
1458 heads = 64;
1459 sectors = 32;
1460 }
1461
1462 geom[0] = heads;
1463 geom[1] = sectors;
1464 geom[2] = sector_div(capacity, heads * sectors); /* cylinders */
1465
1466 return 0;
1467 } /* End twl_scsi_biosparam() */
1468
1469 /* This is the new scsi eh reset function */
1470 static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1471 {
1472 TW_Device_Extension *tw_dev = NULL;
1473 int retval = FAILED;
1474
1475 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1476
1477 tw_dev->num_resets++;
1478
1479 sdev_printk(KERN_WARNING, SCpnt->device,
1480 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1481 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1482
1483 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1484 mutex_lock(&tw_dev->ioctl_lock);
1485
1486 /* Now reset the card and some of the device extension data */
1487 if (twl_reset_device_extension(tw_dev, 0)) {
1488 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset");
1489 goto out;
1490 }
1491
1492 retval = SUCCESS;
1493 out:
1494 mutex_unlock(&tw_dev->ioctl_lock);
1495 return retval;
1496 } /* End twl_scsi_eh_reset() */
1497
1498 /* This is the main scsi queue function to handle scsi opcodes */
1499 static int twl_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1500 {
1501 int request_id, retval;
1502 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1503
1504 /* If we are resetting due to timed out ioctl, report as busy */
1505 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1506 retval = SCSI_MLQUEUE_HOST_BUSY;
1507 goto out;
1508 }
1509
1510 /* Save done function into scsi_cmnd struct */
1511 SCpnt->scsi_done = done;
1512
1513 /* Get a free request id */
1514 twl_get_request_id(tw_dev, &request_id);
1515
1516 /* Save the scsi command for use by the ISR */
1517 tw_dev->srb[request_id] = SCpnt;
1518
1519 /* Initialize phase to zero */
1520 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1521
1522 retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1523 if (retval) {
1524 tw_dev->state[request_id] = TW_S_COMPLETED;
1525 twl_free_request_id(tw_dev, request_id);
1526 SCpnt->result = (DID_ERROR << 16);
1527 done(SCpnt);
1528 retval = 0;
1529 }
1530 out:
1531 return retval;
1532 } /* End twl_scsi_queue() */
1533
1534 /* This function tells the controller to shut down */
1535 static void __twl_shutdown(TW_Device_Extension *tw_dev)
1536 {
1537 /* Disable interrupts */
1538 TWL_MASK_INTERRUPTS(tw_dev);
1539
1540 /* Free up the IRQ */
1541 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1542
1543 printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no);
1544
1545 /* Tell the card we are shutting down */
1546 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1547 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed");
1548 } else {
1549 printk(KERN_WARNING "3w-sas: Shutdown complete.\n");
1550 }
1551
1552 /* Clear doorbell interrupt just before exit */
1553 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1554 } /* End __twl_shutdown() */
1555
1556 /* Wrapper for __twl_shutdown */
1557 static void twl_shutdown(struct pci_dev *pdev)
1558 {
1559 struct Scsi_Host *host = pci_get_drvdata(pdev);
1560 TW_Device_Extension *tw_dev;
1561
1562 if (!host)
1563 return;
1564
1565 tw_dev = (TW_Device_Extension *)host->hostdata;
1566
1567 if (tw_dev->online)
1568 __twl_shutdown(tw_dev);
1569 } /* End twl_shutdown() */
1570
1571 /* This function configures unit settings when a unit is coming on-line */
1572 static int twl_slave_configure(struct scsi_device *sdev)
1573 {
1574 /* Force 60 second timeout */
1575 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1576
1577 return 0;
1578 } /* End twl_slave_configure() */
1579
1580 /* scsi_host_template initializer */
1581 static struct scsi_host_template driver_template = {
1582 .module = THIS_MODULE,
1583 .name = "3w-sas",
1584 .queuecommand = twl_scsi_queue,
1585 .eh_host_reset_handler = twl_scsi_eh_reset,
1586 .bios_param = twl_scsi_biosparam,
1587 .change_queue_depth = twl_change_queue_depth,
1588 .can_queue = TW_Q_LENGTH-2,
1589 .slave_configure = twl_slave_configure,
1590 .this_id = -1,
1591 .sg_tablesize = TW_LIBERATOR_MAX_SGL_LENGTH,
1592 .max_sectors = TW_MAX_SECTORS,
1593 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
1594 .use_clustering = ENABLE_CLUSTERING,
1595 .shost_attrs = twl_host_attrs,
1596 .emulated = 1
1597 };
1598
1599 /* This function will probe and initialize a card */
1600 static int __devinit twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1601 {
1602 struct Scsi_Host *host = NULL;
1603 TW_Device_Extension *tw_dev;
1604 int retval = -ENODEV;
1605 int *ptr_phycount, phycount=0;
1606
1607 retval = pci_enable_device(pdev);
1608 if (retval) {
1609 TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
1610 goto out_disable_device;
1611 }
1612
1613 pci_set_master(pdev);
1614 pci_try_set_mwi(pdev);
1615
1616 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
1617 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1618 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
1619 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1620 TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
1621 retval = -ENODEV;
1622 goto out_disable_device;
1623 }
1624
1625 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
1626 if (!host) {
1627 TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
1628 retval = -ENOMEM;
1629 goto out_disable_device;
1630 }
1631 tw_dev = shost_priv(host);
1632
1633 /* Save values to device extension */
1634 tw_dev->host = host;
1635 tw_dev->tw_pci_dev = pdev;
1636
1637 if (twl_initialize_device_extension(tw_dev)) {
1638 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
1639 goto out_free_device_extension;
1640 }
1641
1642 /* Request IO regions */
1643 retval = pci_request_regions(pdev, "3w-sas");
1644 if (retval) {
1645 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
1646 goto out_free_device_extension;
1647 }
1648
1649 /* Save base address, use region 1 */
1650 tw_dev->base_addr = pci_iomap(pdev, 1, 0);
1651 if (!tw_dev->base_addr) {
1652 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
1653 goto out_release_mem_region;
1654 }
1655
1656 /* Disable interrupts on the card */
1657 TWL_MASK_INTERRUPTS(tw_dev);
1658
1659 /* Initialize the card */
1660 if (twl_reset_sequence(tw_dev, 0)) {
1661 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
1662 goto out_iounmap;
1663 }
1664
1665 /* Set host specific parameters */
1666 host->max_id = TW_MAX_UNITS;
1667 host->max_cmd_len = TW_MAX_CDB_LEN;
1668 host->max_lun = TW_MAX_LUNS;
1669 host->max_channel = 0;
1670
1671 /* Register the card with the kernel SCSI layer */
1672 retval = scsi_add_host(host, &pdev->dev);
1673 if (retval) {
1674 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
1675 goto out_iounmap;
1676 }
1677
1678 pci_set_drvdata(pdev, host);
1679
1680 printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
1681 host->host_no,
1682 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1683 TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
1684 (u64)pci_resource_start(pdev, 1), pdev->irq);
1685
1686 ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
1687 TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
1688 if (ptr_phycount)
1689 phycount = le32_to_cpu(*(int *)ptr_phycount);
1690
1691 printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
1692 host->host_no,
1693 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1694 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
1695 (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
1696 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
1697 phycount);
1698
1699 /* Try to enable MSI */
1700 if (use_msi && !pci_enable_msi(pdev))
1701 set_bit(TW_USING_MSI, &tw_dev->flags);
1702
1703 /* Now setup the interrupt handler */
1704 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1705 if (retval) {
1706 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
1707 goto out_remove_host;
1708 }
1709
1710 twl_device_extension_list[twl_device_extension_count] = tw_dev;
1711 twl_device_extension_count++;
1712
1713 /* Re-enable interrupts on the card */
1714 TWL_UNMASK_INTERRUPTS(tw_dev);
1715
1716 /* Finally, scan the host */
1717 scsi_scan_host(host);
1718
1719 /* Add sysfs binary files */
1720 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
1721 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
1722 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
1723 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
1724
1725 if (twl_major == -1) {
1726 if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
1727 TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
1728 }
1729 tw_dev->online = 1;
1730 return 0;
1731
1732 out_remove_host:
1733 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1734 pci_disable_msi(pdev);
1735 scsi_remove_host(host);
1736 out_iounmap:
1737 iounmap(tw_dev->base_addr);
1738 out_release_mem_region:
1739 pci_release_regions(pdev);
1740 out_free_device_extension:
1741 twl_free_device_extension(tw_dev);
1742 scsi_host_put(host);
1743 out_disable_device:
1744 pci_disable_device(pdev);
1745
1746 return retval;
1747 } /* End twl_probe() */
1748
1749 /* This function is called to remove a device */
1750 static void twl_remove(struct pci_dev *pdev)
1751 {
1752 struct Scsi_Host *host = pci_get_drvdata(pdev);
1753 TW_Device_Extension *tw_dev;
1754
1755 if (!host)
1756 return;
1757
1758 tw_dev = (TW_Device_Extension *)host->hostdata;
1759
1760 if (!tw_dev->online)
1761 return;
1762
1763 /* Remove sysfs binary files */
1764 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
1765 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
1766
1767 scsi_remove_host(tw_dev->host);
1768
1769 /* Unregister character device */
1770 if (twl_major >= 0) {
1771 unregister_chrdev(twl_major, "twl");
1772 twl_major = -1;
1773 }
1774
1775 /* Shutdown the card */
1776 __twl_shutdown(tw_dev);
1777
1778 /* Disable MSI if enabled */
1779 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1780 pci_disable_msi(pdev);
1781
1782 /* Free IO remapping */
1783 iounmap(tw_dev->base_addr);
1784
1785 /* Free up the mem region */
1786 pci_release_regions(pdev);
1787
1788 /* Free up device extension resources */
1789 twl_free_device_extension(tw_dev);
1790
1791 scsi_host_put(tw_dev->host);
1792 pci_disable_device(pdev);
1793 twl_device_extension_count--;
1794 } /* End twl_remove() */
1795
1796 #ifdef CONFIG_PM
1797 /* This function is called on PCI suspend */
1798 static int twl_suspend(struct pci_dev *pdev, pm_message_t state)
1799 {
1800 struct Scsi_Host *host = pci_get_drvdata(pdev);
1801 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1802
1803 printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
1804 /* Disable interrupts */
1805 TWL_MASK_INTERRUPTS(tw_dev);
1806
1807 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1808
1809 /* Tell the card we are shutting down */
1810 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1811 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
1812 } else {
1813 printk(KERN_WARNING "3w-sas: Suspend complete.\n");
1814 }
1815
1816 /* Clear doorbell interrupt */
1817 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1818
1819 pci_save_state(pdev);
1820 pci_disable_device(pdev);
1821 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1822
1823 return 0;
1824 } /* End twl_suspend() */
1825
1826 /* This function is called on PCI resume */
1827 static int twl_resume(struct pci_dev *pdev)
1828 {
1829 int retval = 0;
1830 struct Scsi_Host *host = pci_get_drvdata(pdev);
1831 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1832
1833 printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
1834 pci_set_power_state(pdev, PCI_D0);
1835 pci_enable_wake(pdev, PCI_D0, 0);
1836 pci_restore_state(pdev);
1837
1838 retval = pci_enable_device(pdev);
1839 if (retval) {
1840 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x24, "Enable device failed during resume");
1841 return retval;
1842 }
1843
1844 pci_set_master(pdev);
1845 pci_try_set_mwi(pdev);
1846
1847 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
1848 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1849 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
1850 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1851 TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
1852 retval = -ENODEV;
1853 goto out_disable_device;
1854 }
1855
1856 /* Initialize the card */
1857 if (twl_reset_sequence(tw_dev, 0)) {
1858 retval = -ENODEV;
1859 goto out_disable_device;
1860 }
1861
1862 /* Now setup the interrupt handler */
1863 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1864 if (retval) {
1865 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
1866 retval = -ENODEV;
1867 goto out_disable_device;
1868 }
1869
1870 /* Now enable MSI if enabled */
1871 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1872 pci_enable_msi(pdev);
1873
1874 /* Re-enable interrupts on the card */
1875 TWL_UNMASK_INTERRUPTS(tw_dev);
1876
1877 printk(KERN_WARNING "3w-sas: Resume complete.\n");
1878 return 0;
1879
1880 out_disable_device:
1881 scsi_remove_host(host);
1882 pci_disable_device(pdev);
1883
1884 return retval;
1885 } /* End twl_resume() */
1886 #endif
1887
1888 /* PCI Devices supported by this driver */
1889 static struct pci_device_id twl_pci_tbl[] __devinitdata = {
1890 { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
1891 { }
1892 };
1893 MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
1894
1895 /* pci_driver initializer */
1896 static struct pci_driver twl_driver = {
1897 .name = "3w-sas",
1898 .id_table = twl_pci_tbl,
1899 .probe = twl_probe,
1900 .remove = twl_remove,
1901 #ifdef CONFIG_PM
1902 .suspend = twl_suspend,
1903 .resume = twl_resume,
1904 #endif
1905 .shutdown = twl_shutdown
1906 };
1907
1908 /* This function is called on driver initialization */
1909 static int __init twl_init(void)
1910 {
1911 printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
1912
1913 return pci_register_driver(&twl_driver);
1914 } /* End twl_init() */
1915
1916 /* This function is called on driver exit */
1917 static void __exit twl_exit(void)
1918 {
1919 pci_unregister_driver(&twl_driver);
1920 } /* End twl_exit() */
1921
1922 module_init(twl_init);
1923 module_exit(twl_exit);
1924