projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'rproc-v5.17' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc...
[linux-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,
1789671d 123 },
f619106b 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,
1789671d 154 },
f619106b 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"
1789671d 177 "AEN's: %4d\n",
f619106b 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 = {
1789671d 194 .name = "3ware_stats",
f619106b 195 .mode = S_IRUGO,
196 },
197 .show = twl_show_stats
198};
199
200/* Host attributes initializer */
8de1cc90
BVA		 201static struct attribute *twl_host_attrs[] = {
202 &twl_host_stats_attr.attr,
f619106b 203 NULL,
204};
205
8de1cc90
BVA		 206ATTRIBUTE_GROUPS(twl_host);
207
f619106b 208/* This function will look up an AEN severity string */
209static char *twl_aen_severity_lookup(unsigned char severity_code)
210{
211 char *retval = NULL;
212
213 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
214 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
215 goto out;
216
217 retval = twl_aen_severity_table[severity_code];
218out:
219 return retval;
220} /* End twl_aen_severity_lookup() */
221
222/* This function will queue an event */
223static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
224{
225 u32 local_time;
f619106b 226 TW_Event *event;
227 unsigned short aen;
228 char host[16];
229 char *error_str;
230
231 tw_dev->aen_count++;
232
233 /* Fill out event info */
234 event = tw_dev->event_queue[tw_dev->error_index];
235
236 host[0] = '\0';
237 if (tw_dev->host)
238 sprintf(host, " scsi%d:", tw_dev->host->host_no);
239
240 aen = le16_to_cpu(header->status_block.error);
241 memset(event, 0, sizeof(TW_Event));
242
243 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
9c88673f
AB		 244 /* event->time_stamp_sec overflows in y2106 */
245 local_time = (u32)(ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
f619106b 246 event->time_stamp_sec = local_time;
247 event->aen_code = aen;
248 event->retrieved = TW_AEN_NOT_RETRIEVED;
249 event->sequence_id = tw_dev->error_sequence_id;
250 tw_dev->error_sequence_id++;
251
252 /* Check for embedded error string */
253 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
254
255 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
256 event->parameter_len = strlen(header->err_specific_desc);
257 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str));
258 if (event->severity != TW_AEN_SEVERITY_DEBUG)
259 printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
260 host,
261 twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
262 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str,
263 header->err_specific_desc);
264 else
265 tw_dev->aen_count--;
266
267 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
268} /* End twl_aen_queue_event() */
269
270/* This function will attempt to post a command packet to the board */
271static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
272{
273 dma_addr_t command_que_value;
274
275 command_que_value = tw_dev->command_packet_phys[request_id];
276 command_que_value += TW_COMMAND_OFFSET;
277
278 /* First write upper 4 bytes */
279 writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev));
280 /* Then the lower 4 bytes */
281 writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev));
282
283 tw_dev->state[request_id] = TW_S_POSTED;
284 tw_dev->posted_request_count++;
285 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count)
286 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
287
288 return 0;
289} /* End twl_post_command_packet() */
290
f619106b 291/* This function hands scsi cdb's to the firmware */
09968e50
NC		 292static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id,
293 unsigned char *cdb, int use_sg,
294 TW_SG_Entry_ISO *sglistarg)
f619106b 295{
296 TW_Command_Full *full_command_packet;
297 TW_Command_Apache *command_packet;
298 int i, sg_count;
299 struct scsi_cmnd *srb = NULL;
475bff65 300 struct scatterlist *sg;
f619106b 301 int retval = 1;
302
475bff65 303 if (tw_dev->srb[request_id])
f619106b 304 srb = tw_dev->srb[request_id];
f619106b 305
306 /* Initialize command packet */
307 full_command_packet = tw_dev->command_packet_virt[request_id];
308 full_command_packet->header.header_desc.size_header = 128;
309 full_command_packet->header.status_block.error = 0;
310 full_command_packet->header.status_block.severity__reserved = 0;
311
312 command_packet = &full_command_packet->command.newcommand;
313 command_packet->status = 0;
314 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
315
316 /* We forced 16 byte cdb use earlier */
317 if (!cdb)
318 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
319 else
320 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
321
322 if (srb) {
323 command_packet->unit = srb->device->id;
324 command_packet->request_id__lunl =
325 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
326 } else {
327 command_packet->request_id__lunl =
328 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
329 command_packet->unit = 0;
330 }
331
332 command_packet->sgl_offset = 16;
333
334 if (!sglistarg) {
335 /* Map sglist from scsi layer to cmd packet */
336 if (scsi_sg_count(srb)) {
579d69bc
CH		 337 sg_count = scsi_dma_map(srb);
338 if (sg_count <= 0)
f619106b 339 goto out;
340
341 scsi_for_each_sg(srb, sg, sg_count, i) {
342 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
343 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));
344 }
345 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
346 }
347 } else {
348 /* Internal cdb post */
349 for (i = 0; i < use_sg; i++) {
350 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
351 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length);
352 }
353 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
354 }
355
356 /* Update some stats */
357 if (srb) {
358 tw_dev->sector_count = scsi_bufflen(srb) / 512;
359 if (tw_dev->sector_count > tw_dev->max_sector_count)
360 tw_dev->max_sector_count = tw_dev->sector_count;
361 tw_dev->sgl_entries = scsi_sg_count(srb);
362 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
363 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
364 }
365
366 /* Now post the command to the board */
367 retval = twl_post_command_packet(tw_dev, request_id);
368
369out:
370 return retval;
371} /* End twl_scsiop_execute_scsi() */
372
373/* This function will read the aen queue from the isr */
374static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
375{
09968e50 376 unsigned char cdb[TW_MAX_CDB_LEN];
f619106b 377 TW_SG_Entry_ISO sglist[1];
378 TW_Command_Full *full_command_packet;
379 int retval = 1;
380
381 full_command_packet = tw_dev->command_packet_virt[request_id];
382 memset(full_command_packet, 0, sizeof(TW_Command_Full));
383
384 /* Initialize cdb */
385 memset(&cdb, 0, TW_MAX_CDB_LEN);
386 cdb[0] = REQUEST_SENSE; /* opcode */
387 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
388
389 /* Initialize sglist */
390 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
391 sglist[0].length = TW_SECTOR_SIZE;
392 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
393
394 /* Mark internal command */
395 tw_dev->srb[request_id] = NULL;
396
397 /* Now post the command packet */
398 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
399 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue");
400 goto out;
401 }
402 retval = 0;
403out:
404 return retval;
405} /* End twl_aen_read_queue() */
406
407/* This function will sync firmware time with the host time */
408static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
409{
410 u32 schedulertime;
f619106b 411 TW_Command_Full *full_command_packet;
412 TW_Command *command_packet;
413 TW_Param_Apache *param;
bc8f9166 414 time64_t local_time;
f619106b 415
416 /* Fill out the command packet */
417 full_command_packet = tw_dev->command_packet_virt[request_id];
418 memset(full_command_packet, 0, sizeof(TW_Command_Full));
419 command_packet = &full_command_packet->command.oldcommand;
420 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
421 command_packet->request_id = request_id;
422 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
423 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
424 command_packet->size = TW_COMMAND_SIZE;
425 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
426
427 /* Setup the param */
428 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
429 memset(param, 0, TW_SECTOR_SIZE);
430 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
431 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
432 param->parameter_size_bytes = cpu_to_le16(4);
433
1789671d 434 /* Convert system time in UTC to local time seconds since last
f619106b 435 Sunday 12:00AM */
bc8f9166
AB		 436 local_time = (ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
437 div_u64_rem(local_time - (3 * 86400), 604800, &schedulertime);
438 schedulertime = cpu_to_le32(schedulertime);
f619106b 439
440 memcpy(param->data, &schedulertime, sizeof(u32));
441
442 /* Mark internal command */
443 tw_dev->srb[request_id] = NULL;
444
445 /* Now post the command */
446 twl_post_command_packet(tw_dev, request_id);
447} /* End twl_aen_sync_time() */
448
449/* This function will assign an available request id */
450static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
451{
452 *request_id = tw_dev->free_queue[tw_dev->free_head];
453 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
454 tw_dev->state[*request_id] = TW_S_STARTED;
455} /* End twl_get_request_id() */
456
457/* This function will free a request id */
458static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id)
459{
460 tw_dev->free_queue[tw_dev->free_tail] = request_id;
461 tw_dev->state[request_id] = TW_S_FINISHED;
462 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
463} /* End twl_free_request_id() */
464
465/* This function will complete an aen request from the isr */
466static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id)
467{
468 TW_Command_Full *full_command_packet;
469 TW_Command *command_packet;
470 TW_Command_Apache_Header *header;
471 unsigned short aen;
472 int retval = 1;
473
474 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
475 tw_dev->posted_request_count--;
476 aen = le16_to_cpu(header->status_block.error);
477 full_command_packet = tw_dev->command_packet_virt[request_id];
478 command_packet = &full_command_packet->command.oldcommand;
479
480 /* First check for internal completion of set param for time sync */
481 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
482 /* Keep reading the queue in case there are more aen's */
483 if (twl_aen_read_queue(tw_dev, request_id))
484 goto out2;
1789671d 485 else {
f619106b 486 retval = 0;
487 goto out;
488 }
489 }
490
491 switch (aen) {
492 case TW_AEN_QUEUE_EMPTY:
493 /* Quit reading the queue if this is the last one */
494 break;
495 case TW_AEN_SYNC_TIME_WITH_HOST:
496 twl_aen_sync_time(tw_dev, request_id);
497 retval = 0;
498 goto out;
499 default:
500 twl_aen_queue_event(tw_dev, header);
501
502 /* If there are more aen's, keep reading the queue */
503 if (twl_aen_read_queue(tw_dev, request_id))
504 goto out2;
505 else {
506 retval = 0;
507 goto out;
508 }
509 }
510 retval = 0;
511out2:
512 tw_dev->state[request_id] = TW_S_COMPLETED;
513 twl_free_request_id(tw_dev, request_id);
514 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
515out:
516 return retval;
517} /* End twl_aen_complete() */
518
519/* This function will poll for a response */
520static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
521{
522 unsigned long before;
523 dma_addr_t mfa;
524 u32 regh, regl;
525 u32 response;
526 int retval = 1;
527 int found = 0;
528
529 before = jiffies;
530
531 while (!found) {
532 if (sizeof(dma_addr_t) > 4) {
533 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
534 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
535 mfa = ((u64)regh << 32) | regl;
536 } else
537 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
538
539 response = (u32)mfa;
540
541 if (TW_RESID_OUT(response) == request_id)
542 found = 1;
543
544 if (time_after(jiffies, before + HZ * seconds))
545 goto out;
546
547 msleep(50);
548 }
549 retval = 0;
1789671d 550out:
f619106b 551 return retval;
552} /* End twl_poll_response() */
553
554/* This function will drain the aen queue */
555static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
556{
557 int request_id = 0;
09968e50 558 unsigned char cdb[TW_MAX_CDB_LEN];
f619106b 559 TW_SG_Entry_ISO sglist[1];
560 int finished = 0, count = 0;
561 TW_Command_Full *full_command_packet;
562 TW_Command_Apache_Header *header;
563 unsigned short aen;
564 int first_reset = 0, queue = 0, retval = 1;
565
566 if (no_check_reset)
567 first_reset = 0;
568 else
569 first_reset = 1;
570
571 full_command_packet = tw_dev->command_packet_virt[request_id];
572 memset(full_command_packet, 0, sizeof(TW_Command_Full));
573
574 /* Initialize cdb */
575 memset(&cdb, 0, TW_MAX_CDB_LEN);
576 cdb[0] = REQUEST_SENSE; /* opcode */
577 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
578
579 /* Initialize sglist */
580 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
581 sglist[0].length = TW_SECTOR_SIZE;
582 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
583
584 /* Mark internal command */
585 tw_dev->srb[request_id] = NULL;
586
587 do {
588 /* Send command to the board */
589 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
590 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense");
591 goto out;
592 }
593
594 /* Now poll for completion */
595 if (twl_poll_response(tw_dev, request_id, 30)) {
596 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue");
597 tw_dev->posted_request_count--;
598 goto out;
599 }
600
601 tw_dev->posted_request_count--;
602 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
603 aen = le16_to_cpu(header->status_block.error);
604 queue = 0;
605 count++;
606
607 switch (aen) {
608 case TW_AEN_QUEUE_EMPTY:
609 if (first_reset != 1)
610 goto out;
611 else
612 finished = 1;
613 break;
614 case TW_AEN_SOFT_RESET:
615 if (first_reset == 0)
616 first_reset = 1;
617 else
618 queue = 1;
619 break;
620 case TW_AEN_SYNC_TIME_WITH_HOST:
621 break;
622 default:
623 queue = 1;
624 }
625
626 /* Now queue an event info */
627 if (queue)
628 twl_aen_queue_event(tw_dev, header);
629 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
630
631 if (count == TW_MAX_AEN_DRAIN)
632 goto out;
633
634 retval = 0;
635out:
636 tw_dev->state[request_id] = TW_S_INITIAL;
637 return retval;
638} /* End twl_aen_drain_queue() */
639
640/* This function will allocate memory and check if it is correctly aligned */
641static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
642{
643 int i;
644 dma_addr_t dma_handle;
645 unsigned long *cpu_addr;
646 int retval = 1;
647
750afb08
LC		 648 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
649 size * TW_Q_LENGTH, &dma_handle,
650 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));
1789671d 804
f619106b 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;
f619106b 865
866 header = tw_dev->sense_buffer_virt[i];
867 full_command_packet = tw_dev->command_packet_virt[request_id];
868
869 /* Get embedded firmware error string */
870 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]);
871
872 /* Don't print error for Logical unit not supported during rollcall */
873 error = le16_to_cpu(header->status_block.error);
874 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) {
875 if (print_host)
876 printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
877 tw_dev->host->host_no,
878 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
879 header->status_block.error,
1789671d 880 error_str,
f619106b 881 header->err_specific_desc);
882 else
883 printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n",
884 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
885 header->status_block.error,
886 error_str,
887 header->err_specific_desc);
888 }
889
890 if (copy_sense) {
891 memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH);
892 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
893 goto out;
894 }
895out:
2af0bf34 896 return 1;
f619106b 897} /* End twl_fill_sense() */
898
899/* This function will free up device extension resources */
900static void twl_free_device_extension(TW_Device_Extension *tw_dev)
901{
902 if (tw_dev->command_packet_virt[0])
b1fa1229 903 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
f619106b 904 sizeof(TW_Command_Full)*TW_Q_LENGTH,
905 tw_dev->command_packet_virt[0],
906 tw_dev->command_packet_phys[0]);
907
908 if (tw_dev->generic_buffer_virt[0])
b1fa1229 909 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
f619106b 910 TW_SECTOR_SIZE*TW_Q_LENGTH,
911 tw_dev->generic_buffer_virt[0],
912 tw_dev->generic_buffer_phys[0]);
913
914 if (tw_dev->sense_buffer_virt[0])
b1fa1229 915 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
f619106b 916 sizeof(TW_Command_Apache_Header)*
917 TW_Q_LENGTH,
918 tw_dev->sense_buffer_virt[0],
919 tw_dev->sense_buffer_phys[0]);
920
921 kfree(tw_dev->event_queue[0]);
922} /* End twl_free_device_extension() */
923
924/* This function will get parameter table entries from the firmware */
925static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
926{
927 TW_Command_Full *full_command_packet;
928 TW_Command *command_packet;
929 TW_Param_Apache *param;
930 void *retval = NULL;
931
932 /* Setup the command packet */
933 full_command_packet = tw_dev->command_packet_virt[request_id];
934 memset(full_command_packet, 0, sizeof(TW_Command_Full));
935 command_packet = &full_command_packet->command.oldcommand;
936
937 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1789671d
HR		 938 command_packet->size = TW_COMMAND_SIZE;
939 command_packet->request_id = request_id;
f619106b 940 command_packet->byte6_offset.block_count = cpu_to_le16(1);
941
942 /* Now setup the param */
943 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
944 memset(param, 0, TW_SECTOR_SIZE);
945 param->table_id = cpu_to_le16(table_id | 0x8000);
946 param->parameter_id = cpu_to_le16(parameter_id);
947 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
948
949 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
950 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
951
952 /* Post the command packet to the board */
953 twl_post_command_packet(tw_dev, request_id);
954
955 /* Poll for completion */
956 if (twl_poll_response(tw_dev, request_id, 30))
957 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param")
958 else
959 retval = (void *)&(param->data[0]);
960
961 tw_dev->posted_request_count--;
962 tw_dev->state[request_id] = TW_S_INITIAL;
963
964 return retval;
965} /* End twl_get_param() */
966
967/* This function will send an initconnection command to controller */
968static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1789671d
HR		 969 u32 set_features, unsigned short current_fw_srl,
970 unsigned short current_fw_arch_id,
971 unsigned short current_fw_branch,
972 unsigned short current_fw_build,
973 unsigned short *fw_on_ctlr_srl,
974 unsigned short *fw_on_ctlr_arch_id,
975 unsigned short *fw_on_ctlr_branch,
976 unsigned short *fw_on_ctlr_build,
f619106b 977 u32 *init_connect_result)
978{
979 TW_Command_Full *full_command_packet;
980 TW_Initconnect *tw_initconnect;
981 int request_id = 0, retval = 1;
982
983 /* Initialize InitConnection command packet */
984 full_command_packet = tw_dev->command_packet_virt[request_id];
985 memset(full_command_packet, 0, sizeof(TW_Command_Full));
986 full_command_packet->header.header_desc.size_header = 128;
1789671d 987
f619106b 988 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
989 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
990 tw_initconnect->request_id = request_id;
991 tw_initconnect->message_credits = cpu_to_le16(message_credits);
992 tw_initconnect->features = set_features;
993
994 /* Turn on 64-bit sgl support if we need to */
995 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
996
997 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
998
999 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1000 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1001 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1002 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1003 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1004 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1789671d 1005 } else
f619106b 1006 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1007
1008 /* Send command packet to the board */
1009 twl_post_command_packet(tw_dev, request_id);
1010
1011 /* Poll for completion */
1012 if (twl_poll_response(tw_dev, request_id, 30)) {
1013 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection");
1014 } else {
1015 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1016 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1017 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1018 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1019 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1020 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1021 }
1022 retval = 0;
1023 }
1024
1025 tw_dev->posted_request_count--;
1026 tw_dev->state[request_id] = TW_S_INITIAL;
1027
1028 return retval;
1029} /* End twl_initconnection() */
1030
1031/* This function will initialize the fields of a device extension */
1032static int twl_initialize_device_extension(TW_Device_Extension *tw_dev)
1033{
1034 int i, retval = 1;
1035
1036 /* Initialize command packet buffers */
1037 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1038 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed");
1039 goto out;
1040 }
1041
1042 /* Initialize generic buffer */
1043 if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1044 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed");
1045 goto out;
1046 }
1047
1048 /* Allocate sense buffers */
1049 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) {
1050 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed");
1051 goto out;
1052 }
1053
1054 /* Allocate event info space */
1055 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1056 if (!tw_dev->event_queue[0]) {
1057 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed");
1058 goto out;
1059 }
1060
1061 for (i = 0; i < TW_Q_LENGTH; i++) {
1062 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1063 tw_dev->free_queue[i] = i;
1064 tw_dev->state[i] = TW_S_INITIAL;
1065 }
1066
1067 tw_dev->free_head = TW_Q_START;
1068 tw_dev->free_tail = TW_Q_START;
1069 tw_dev->error_sequence_id = 1;
1070 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1071
1072 mutex_init(&tw_dev->ioctl_lock);
1073 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1074
1075 retval = 0;
1076out:
1077 return retval;
1078} /* End twl_initialize_device_extension() */
1079
f619106b 1080/* This function will handle attention interrupts */
1081static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev)
1082{
1083 int retval = 1;
1084 u32 request_id, doorbell;
1085
1086 /* Read doorbell status */
1087 doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev));
1088
1089 /* Check for controller errors */
1090 if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) {
1091 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing");
1092 goto out;
1093 }
1094
1095 /* Check if we need to perform an AEN drain */
1096 if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) {
1097 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1098 twl_get_request_id(tw_dev, &request_id);
1099 if (twl_aen_read_queue(tw_dev, request_id)) {
1100 tw_dev->state[request_id] = TW_S_COMPLETED;
1101 twl_free_request_id(tw_dev, request_id);
1102 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1103 }
1104 }
1105 }
1106
1107 retval = 0;
1108out:
1109 /* Clear doorbell interrupt */
1110 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1111
1112 /* Make sure the clear was flushed by reading it back */
1113 readl(TWL_HOBDBC_REG_ADDR(tw_dev));
1114
1115 return retval;
1116} /* End twl_handle_attention_interrupt() */
1117
1118/* Interrupt service routine */
1119static irqreturn_t twl_interrupt(int irq, void *dev_instance)
1120{
1121 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1122 int i, handled = 0, error = 0;
1123 dma_addr_t mfa = 0;
1124 u32 reg, regl, regh, response, request_id = 0;
1125 struct scsi_cmnd *cmd;
1126 TW_Command_Full *full_command_packet;
1127
1128 spin_lock(tw_dev->host->host_lock);
1129
1130 /* Read host interrupt status */
1131 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1132
1133 /* Check if this is our interrupt, otherwise bail */
1134 if (!(reg & TWL_HISTATUS_VALID_INTERRUPT))
1135 goto twl_interrupt_bail;
1136
1137 handled = 1;
1138
1139 /* If we are resetting, bail */
1140 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1141 goto twl_interrupt_bail;
1142
1143 /* Attention interrupt */
1144 if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) {
1145 if (twl_handle_attention_interrupt(tw_dev)) {
1146 TWL_MASK_INTERRUPTS(tw_dev);
1147 goto twl_interrupt_bail;
1148 }
1149 }
1150
1151 /* Response interrupt */
1152 while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) {
1153 if (sizeof(dma_addr_t) > 4) {
1154 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
1155 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1156 mfa = ((u64)regh << 32) | regl;
1157 } else
1158 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1159
1160 error = 0;
1161 response = (u32)mfa;
1162
1163 /* Check for command packet error */
1164 if (!TW_NOTMFA_OUT(response)) {
1165 for (i=0;i<TW_Q_LENGTH;i++) {
1166 if (tw_dev->sense_buffer_phys[i] == mfa) {
1167 request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id);
1168 if (tw_dev->srb[request_id] != NULL)
1169 error = twl_fill_sense(tw_dev, i, request_id, 1, 1);
1170 else {
1171 /* Skip ioctl error prints */
1172 if (request_id != tw_dev->chrdev_request_id)
1173 error = twl_fill_sense(tw_dev, i, request_id, 0, 1);
1174 else
1175 memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header));
1176 }
1177
1178 /* Now re-post the sense buffer */
1179 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1180 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1181 break;
1182 }
1183 }
1184 } else
1185 request_id = TW_RESID_OUT(response);
1186
1187 full_command_packet = tw_dev->command_packet_virt[request_id];
1188
1189 /* Check for correct state */
1190 if (tw_dev->state[request_id] != TW_S_POSTED) {
1191 if (tw_dev->srb[request_id] != NULL) {
1192 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted");
1193 TWL_MASK_INTERRUPTS(tw_dev);
1194 goto twl_interrupt_bail;
1195 }
1196 }
1197
1198 /* Check for internal command completion */
1199 if (tw_dev->srb[request_id] == NULL) {
1200 if (request_id != tw_dev->chrdev_request_id) {
1201 if (twl_aen_complete(tw_dev, request_id))
1202 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt");
1203 } else {
1204 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1205 wake_up(&tw_dev->ioctl_wqueue);
1206 }
1207 } else {
1208 cmd = tw_dev->srb[request_id];
1209
1210 if (!error)
1211 cmd->result = (DID_OK << 16);
1789671d 1212
f619106b 1213 /* Report residual bytes for single sgl */
1214 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1215 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1216 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1217 }
1218
1219 /* Now complete the io */
579d69bc 1220 scsi_dma_unmap(cmd);
2adf975e 1221 scsi_done(cmd);
f619106b 1222 tw_dev->state[request_id] = TW_S_COMPLETED;
1223 twl_free_request_id(tw_dev, request_id);
1224 tw_dev->posted_request_count--;
f619106b 1225 }
1226
1227 /* Check for another response interrupt */
1228 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1229 }
1230
1231twl_interrupt_bail:
1232 spin_unlock(tw_dev->host->host_lock);
1233 return IRQ_RETVAL(handled);
1234} /* End twl_interrupt() */
1235
1236/* This function will poll for a register change */
1237static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds)
1238{
1239 unsigned long before;
1240 int retval = 1;
1241 u32 reg_value;
1242
1243 reg_value = readl(reg);
1244 before = jiffies;
1245
1789671d 1246 while ((reg_value & value) != result) {
f619106b 1247 reg_value = readl(reg);
1248 if (time_after(jiffies, before + HZ * seconds))
1249 goto out;
1250 msleep(50);
1251 }
1252 retval = 0;
1253out:
1254 return retval;
1255} /* End twl_poll_register() */
1256
1257/* This function will reset a controller */
1258static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1259{
1260 int retval = 1;
1261 int i = 0;
1262 u32 status = 0;
1263 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
1264 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
1265 u32 init_connect_result = 0;
1266 int tries = 0;
1267 int do_soft_reset = soft_reset;
1268
1269 while (tries < TW_MAX_RESET_TRIES) {
1270 /* Do a soft reset if one is needed */
1271 if (do_soft_reset) {
1272 TWL_SOFT_RESET(tw_dev);
1273
1274 /* Make sure controller is in a good state */
1275 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) {
1276 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence");
1277 tries++;
1278 continue;
1279 }
1280 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) {
1281 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence");
1282 tries++;
1283 continue;
1284 }
1285 }
1286
1287 /* Initconnect */
1288 if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
1289 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
1290 TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
1291 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
1292 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
1293 &fw_on_ctlr_build, &init_connect_result)) {
1294 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL");
1295 do_soft_reset = 1;
1296 tries++;
1297 continue;
1298 }
1299
1300 /* Load sense buffers */
1301 while (i < TW_Q_LENGTH) {
1302 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1303 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1304
1305 /* Check status for over-run after each write */
1306 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1307 if (!(status & TWL_STATUS_OVERRUN_SUBMIT))
1308 i++;
1309 }
1310
1311 /* Now check status */
1312 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1313 if (status) {
1314 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers");
1315 do_soft_reset = 1;
1316 tries++;
1317 continue;
1318 }
1319
1320 /* Drain the AEN queue */
1321 if (twl_aen_drain_queue(tw_dev, soft_reset)) {
1322 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence");
1323 do_soft_reset = 1;
1324 tries++;
1325 continue;
1326 }
1327
1328 /* Load rest of compatibility struct */
1329 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
1330 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
1331 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
1332 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
1333 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
1334 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
1335 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
1336 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
1337 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
1338 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
1339
1340 /* If we got here, controller is in a good state */
1341 retval = 0;
1342 goto out;
1343 }
1344out:
1345 return retval;
1346} /* End twl_reset_sequence() */
1347
1348/* This function will reset a device extension */
1349static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1350{
1351 int i = 0, retval = 1;
1352 unsigned long flags = 0;
1353
1354 /* Block SCSI requests while we are resetting */
1355 if (ioctl_reset)
1356 scsi_block_requests(tw_dev->host);
1357
1358 set_bit(TW_IN_RESET, &tw_dev->flags);
1359 TWL_MASK_INTERRUPTS(tw_dev);
1360 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1361
1362 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1363
1364 /* Abort all requests that are in progress */
1365 for (i = 0; i < TW_Q_LENGTH; i++) {
1366 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1367 (tw_dev->state[i] != TW_S_INITIAL) &&
1368 (tw_dev->state[i] != TW_S_COMPLETED)) {
579d69bc
CH		 1369 struct scsi_cmnd *cmd = tw_dev->srb[i];
1370
1371 if (cmd) {
1372 cmd->result = (DID_RESET << 16);
1373 scsi_dma_unmap(cmd);
2adf975e 1374 scsi_done(cmd);
f619106b 1375 }
1376 }
1377 }
1378
1379 /* Reset queues and counts */
1380 for (i = 0; i < TW_Q_LENGTH; i++) {
1381 tw_dev->free_queue[i] = i;
1382 tw_dev->state[i] = TW_S_INITIAL;
1383 }
1384 tw_dev->free_head = TW_Q_START;
1385 tw_dev->free_tail = TW_Q_START;
1386 tw_dev->posted_request_count = 0;
1387
1388 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1389
1390 if (twl_reset_sequence(tw_dev, 1))
1391 goto out;
1392
1393 TWL_UNMASK_INTERRUPTS(tw_dev);
1394
1395 clear_bit(TW_IN_RESET, &tw_dev->flags);
1396 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1397
1398 retval = 0;
1399out:
1400 if (ioctl_reset)
1401 scsi_unblock_requests(tw_dev->host);
1402 return retval;
1403} /* End twl_reset_device_extension() */
1404
1405/* This funciton returns unit geometry in cylinders/heads/sectors */
1406static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1407{
1408 int heads, sectors;
f619106b 1409
1410 if (capacity >= 0x200000) {
1411 heads = 255;
1412 sectors = 63;
1413 } else {
1414 heads = 64;
1415 sectors = 32;
1416 }
1417
1418 geom[0] = heads;
1419 geom[1] = sectors;
1420 geom[2] = sector_div(capacity, heads * sectors); /* cylinders */
1421
1422 return 0;
1423} /* End twl_scsi_biosparam() */
1424
1425/* This is the new scsi eh reset function */
1426static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1427{
1428 TW_Device_Extension *tw_dev = NULL;
1429 int retval = FAILED;
1430
1431 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1432
1433 tw_dev->num_resets++;
1434
1435 sdev_printk(KERN_WARNING, SCpnt->device,
1436 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1437 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1438
1439 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1440 mutex_lock(&tw_dev->ioctl_lock);
1441
1442 /* Now reset the card and some of the device extension data */
1443 if (twl_reset_device_extension(tw_dev, 0)) {
1444 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset");
1445 goto out;
1446 }
1447
1448 retval = SUCCESS;
1449out:
1450 mutex_unlock(&tw_dev->ioctl_lock);
1451 return retval;
1452} /* End twl_scsi_eh_reset() */
1453
1454/* This is the main scsi queue function to handle scsi opcodes */
af049dfd 1455static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt)
f619106b 1456{
af049dfd 1457 void (*done)(struct scsi_cmnd *) = scsi_done;
f619106b 1458 int request_id, retval;
1459 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1460
1461 /* If we are resetting due to timed out ioctl, report as busy */
1462 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1463 retval = SCSI_MLQUEUE_HOST_BUSY;
1464 goto out;
1465 }
1466
f619106b 1467 /* Get a free request id */
1468 twl_get_request_id(tw_dev, &request_id);
1469
1470 /* Save the scsi command for use by the ISR */
1471 tw_dev->srb[request_id] = SCpnt;
1472
f619106b 1473 retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1474 if (retval) {
1475 tw_dev->state[request_id] = TW_S_COMPLETED;
1476 twl_free_request_id(tw_dev, request_id);
1477 SCpnt->result = (DID_ERROR << 16);
1478 done(SCpnt);
1479 retval = 0;
1480 }
1481out:
1482 return retval;
1483} /* End twl_scsi_queue() */
1484
f281233d
JG		 1485static DEF_SCSI_QCMD(twl_scsi_queue)
1486
f619106b 1487/* This function tells the controller to shut down */
1488static void __twl_shutdown(TW_Device_Extension *tw_dev)
1489{
1490 /* Disable interrupts */
1491 TWL_MASK_INTERRUPTS(tw_dev);
1492
1493 /* Free up the IRQ */
1494 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1495
1496 printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no);
1497
1498 /* Tell the card we are shutting down */
1499 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1500 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed");
1501 } else {
1502 printk(KERN_WARNING "3w-sas: Shutdown complete.\n");
1503 }
1504
1505 /* Clear doorbell interrupt just before exit */
1506 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1507} /* End __twl_shutdown() */
1508
1509/* Wrapper for __twl_shutdown */
1510static void twl_shutdown(struct pci_dev *pdev)
1511{
1512 struct Scsi_Host *host = pci_get_drvdata(pdev);
1513 TW_Device_Extension *tw_dev;
1514
1515 if (!host)
1516 return;
1517
1518 tw_dev = (TW_Device_Extension *)host->hostdata;
1519
1789671d 1520 if (tw_dev->online)
f619106b 1521 __twl_shutdown(tw_dev);
1522} /* End twl_shutdown() */
1523
1524/* This function configures unit settings when a unit is coming on-line */
1525static int twl_slave_configure(struct scsi_device *sdev)
1526{
1527 /* Force 60 second timeout */
1528 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1529
1530 return 0;
1531} /* End twl_slave_configure() */
1532
1533/* scsi_host_template initializer */
1534static struct scsi_host_template driver_template = {
1535 .module = THIS_MODULE,
1536 .name = "3w-sas",
1537 .queuecommand = twl_scsi_queue,
1538 .eh_host_reset_handler = twl_scsi_eh_reset,
1539 .bios_param = twl_scsi_biosparam,
db5ed4df 1540 .change_queue_depth = scsi_change_queue_depth,
f619106b 1541 .can_queue = TW_Q_LENGTH-2,
1542 .slave_configure = twl_slave_configure,
1543 .this_id = -1,
1544 .sg_tablesize = TW_LIBERATOR_MAX_SGL_LENGTH,
1545 .max_sectors = TW_MAX_SECTORS,
1546 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
8de1cc90 1547 .shost_groups = twl_host_groups,
54b2b50c
MP		 1548 .emulated = 1,
1549 .no_write_same = 1,
f619106b 1550};
1551
1552/* This function will probe and initialize a card */
6f039790 1553static int twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
f619106b 1554{
1555 struct Scsi_Host *host = NULL;
1556 TW_Device_Extension *tw_dev;
1557 int retval = -ENODEV;
1558 int *ptr_phycount, phycount=0;
1559
1560 retval = pci_enable_device(pdev);
1561 if (retval) {
1562 TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
1563 goto out_disable_device;
1564 }
1565
1566 pci_set_master(pdev);
1567 pci_try_set_mwi(pdev);
1568
1feb3b02
HR		 1569 retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
1570 if (retval)
1571 retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1572 if (retval) {
b1fa1229
CH		 1573 TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
1574 retval = -ENODEV;
1575 goto out_disable_device;
1576 }
f619106b 1577
1578 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
1579 if (!host) {
1580 TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
1581 retval = -ENOMEM;
1582 goto out_disable_device;
1583 }
1584 tw_dev = shost_priv(host);
1585
1586 /* Save values to device extension */
1587 tw_dev->host = host;
1588 tw_dev->tw_pci_dev = pdev;
1589
1590 if (twl_initialize_device_extension(tw_dev)) {
1591 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
4dc98c19 1592 retval = -ENOMEM;
f619106b 1593 goto out_free_device_extension;
1594 }
1595
1596 /* Request IO regions */
1597 retval = pci_request_regions(pdev, "3w-sas");
1598 if (retval) {
1599 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
1600 goto out_free_device_extension;
1601 }
1602
1603 /* Save base address, use region 1 */
1604 tw_dev->base_addr = pci_iomap(pdev, 1, 0);
1605 if (!tw_dev->base_addr) {
1606 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
4dc98c19 1607 retval = -ENOMEM;
f619106b 1608 goto out_release_mem_region;
1609 }
1610
1611 /* Disable interrupts on the card */
1612 TWL_MASK_INTERRUPTS(tw_dev);
1613
1614 /* Initialize the card */
1615 if (twl_reset_sequence(tw_dev, 0)) {
1616 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
4dc98c19 1617 retval = -ENOMEM;
f619106b 1618 goto out_iounmap;
1619 }
1620
1621 /* Set host specific parameters */
1622 host->max_id = TW_MAX_UNITS;
1623 host->max_cmd_len = TW_MAX_CDB_LEN;
1624 host->max_lun = TW_MAX_LUNS;
1625 host->max_channel = 0;
1626
1627 /* Register the card with the kernel SCSI layer */
1628 retval = scsi_add_host(host, &pdev->dev);
1629 if (retval) {
1630 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
1631 goto out_iounmap;
1632 }
1633
1634 pci_set_drvdata(pdev, host);
1635
1636 printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
1637 host->host_no,
1638 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1639 TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
1640 (u64)pci_resource_start(pdev, 1), pdev->irq);
1641
1642 ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
1643 TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
1644 if (ptr_phycount)
1645 phycount = le32_to_cpu(*(int *)ptr_phycount);
1646
1647 printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
1648 host->host_no,
1649 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1650 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
1651 (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
1652 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
1653 phycount);
1654
1655 /* Try to enable MSI */
1656 if (use_msi && !pci_enable_msi(pdev))
1657 set_bit(TW_USING_MSI, &tw_dev->flags);
1658
1659 /* Now setup the interrupt handler */
1660 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1661 if (retval) {
1662 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
1663 goto out_remove_host;
1664 }
1665
1666 twl_device_extension_list[twl_device_extension_count] = tw_dev;
1667 twl_device_extension_count++;
1668
1669 /* Re-enable interrupts on the card */
1670 TWL_UNMASK_INTERRUPTS(tw_dev);
1789671d 1671
f619106b 1672 /* Finally, scan the host */
1673 scsi_scan_host(host);
1674
1675 /* Add sysfs binary files */
1676 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
1677 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
1678 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
1679 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
1680
1681 if (twl_major == -1) {
1682 if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
1683 TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
1684 }
1685 tw_dev->online = 1;
1686 return 0;
1687
1688out_remove_host:
1689 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1690 pci_disable_msi(pdev);
1691 scsi_remove_host(host);
1692out_iounmap:
1693 iounmap(tw_dev->base_addr);
1694out_release_mem_region:
1695 pci_release_regions(pdev);
1696out_free_device_extension:
1697 twl_free_device_extension(tw_dev);
1698 scsi_host_put(host);
1699out_disable_device:
1700 pci_disable_device(pdev);
1701
1702 return retval;
1703} /* End twl_probe() */
1704
1705/* This function is called to remove a device */
1706static void twl_remove(struct pci_dev *pdev)
1707{
1708 struct Scsi_Host *host = pci_get_drvdata(pdev);
1709 TW_Device_Extension *tw_dev;
1710
1711 if (!host)
1712 return;
1713
1714 tw_dev = (TW_Device_Extension *)host->hostdata;
1715
1716 if (!tw_dev->online)
1717 return;
1718
1719 /* Remove sysfs binary files */
1720 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
1721 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
1722
1723 scsi_remove_host(tw_dev->host);
1724
1725 /* Unregister character device */
1726 if (twl_major >= 0) {
1727 unregister_chrdev(twl_major, "twl");
1728 twl_major = -1;
1729 }
1730
1731 /* Shutdown the card */
1732 __twl_shutdown(tw_dev);
1733
1734 /* Disable MSI if enabled */
1735 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1736 pci_disable_msi(pdev);
1737
1738 /* Free IO remapping */
1739 iounmap(tw_dev->base_addr);
1740
1741 /* Free up the mem region */
1742 pci_release_regions(pdev);
1743
1744 /* Free up device extension resources */
1745 twl_free_device_extension(tw_dev);
1746
1747 scsi_host_put(tw_dev->host);
1748 pci_disable_device(pdev);
1749 twl_device_extension_count--;
1750} /* End twl_remove() */
1751
f619106b 1752/* This function is called on PCI suspend */
99769d8d 1753static int __maybe_unused twl_suspend(struct device *dev)
f619106b 1754{
99769d8d 1755 struct Scsi_Host *host = dev_get_drvdata(dev);
f619106b 1756 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1757
1758 printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
1759 /* Disable interrupts */
1760 TWL_MASK_INTERRUPTS(tw_dev);
1761
1762 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1763
1764 /* Tell the card we are shutting down */
1765 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1766 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
1767 } else {
1768 printk(KERN_WARNING "3w-sas: Suspend complete.\n");
1769 }
1770
1771 /* Clear doorbell interrupt */
1772 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1773
f619106b 1774 return 0;
1775} /* End twl_suspend() */
1776
1777/* This function is called on PCI resume */
99769d8d 1778static int __maybe_unused twl_resume(struct device *dev)
f619106b 1779{
1780 int retval = 0;
99769d8d 1781 struct pci_dev *pdev = to_pci_dev(dev);
f619106b 1782 struct Scsi_Host *host = pci_get_drvdata(pdev);
1783 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1784
1785 printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
f619106b 1786 pci_try_set_mwi(pdev);
1787
1feb3b02
HR		 1788 retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
1789 if (retval)
1790 retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1791 if (retval) {
b1fa1229
CH		 1792 TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
1793 retval = -ENODEV;
1794 goto out_disable_device;
1795 }
f619106b 1796
1797 /* Initialize the card */
1798 if (twl_reset_sequence(tw_dev, 0)) {
1799 retval = -ENODEV;
1800 goto out_disable_device;
1801 }
1802
1803 /* Now setup the interrupt handler */
1804 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1805 if (retval) {
1806 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
1807 retval = -ENODEV;
1808 goto out_disable_device;
1809 }
1810
1811 /* Now enable MSI if enabled */
1812 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1813 pci_enable_msi(pdev);
1814
1815 /* Re-enable interrupts on the card */
1816 TWL_UNMASK_INTERRUPTS(tw_dev);
1817
1818 printk(KERN_WARNING "3w-sas: Resume complete.\n");
1819 return 0;
1820
1821out_disable_device:
1822 scsi_remove_host(host);
f619106b 1823
1824 return retval;
1825} /* End twl_resume() */
f619106b 1826
1827/* PCI Devices supported by this driver */
6f039790 1828static struct pci_device_id twl_pci_tbl[] = {
f619106b 1829 { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
1830 { }
1831};
1832MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
1833
99769d8d
VG		 1834static SIMPLE_DEV_PM_OPS(twl_pm_ops, twl_suspend, twl_resume);
1835
f619106b 1836/* pci_driver initializer */
1837static struct pci_driver twl_driver = {
1838 .name = "3w-sas",
1839 .id_table = twl_pci_tbl,
1840 .probe = twl_probe,
1841 .remove = twl_remove,
99769d8d 1842 .driver.pm = &twl_pm_ops,
f619106b 1843 .shutdown = twl_shutdown
1844};
1845
1846/* This function is called on driver initialization */
1847static int __init twl_init(void)
1848{
1849 printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
1850
1851 return pci_register_driver(&twl_driver);
1852} /* End twl_init() */
1853
1854/* This function is called on driver exit */
1855static void __exit twl_exit(void)
1856{
1857 pci_unregister_driver(&twl_driver);
1858} /* End twl_exit() */
1859
1860module_init(twl_init);
1861module_exit(twl_exit);
1862
Linux 6.x block layer and io_uring tree(s)