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