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