// SPDX-License-Identifier: GPL-2.0 /* * Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers * * This driver supports the newer, SCSI-based firmware interface only. * * Copyright 2017 Hannes Reinecke, SUSE Linux GmbH <hare@suse.com> * * Based on the original DAC960 driver, which has * Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com> * Portions Copyright 2002 by Mylex (An IBM Business Unit) #include <linux/module.h>#include <linux/types.h>#include <linux/delay.h>#include <linux/interrupt.h>#include <linux/pci.h>#include <linux/raid_class.h>#include <linux/unaligned.h>#include <scsi/scsi.h>#include <scsi/scsi_host.h>#include <scsi/scsi_device.h>#include <scsi/scsi_cmnd.h>#include <scsi/scsi_tcq.h>#include "myrs.h" static struct raid_template *myrs_raid_template;static struct myrs_devstate_name_entry {enum myrs_devstate state;char *name;"Unconfigured" },"Online" },"Rebuild" },"Missing" },"SuspectedCritical" },"Offline" },"Critical" },"SuspectedDead" },"CommandedOffline" },"Standby" },"Invalid" },static char *myrs_devstate_name(enum myrs_devstate state)struct myrs_devstate_name_entry *entry = myrs_devstate_name_list;int i;for (i = 0; i < ARRAY_SIZE(myrs_devstate_name_list); i++) {if (entry[i].state == state)return entry[i].name;return NULL;static struct myrs_raid_level_name_entry {enum myrs_raid_level level;char *name;"RAID0" },"RAID1" },"RAID3 right asymmetric parity" },"RAID5 right asymmetric parity" },"RAID6" },"JBOD" },"New Mylex SPAN" },"RAID3 fixed parity" },"RAID3 left symmetric parity" },"Mylex SPAN" },"RAID5 left symmetric parity" },"RAIDE (concatenation)" },"Physical device" },static char *myrs_raid_level_name(enum myrs_raid_level level)struct myrs_raid_level_name_entry *entry = myrs_raid_level_name_list;int i;for (i = 0; i < ARRAY_SIZE(myrs_raid_level_name_list); i++) {if (entry[i].level == level)return entry[i].name;return NULL;/* * myrs_reset_cmd - clears critical fields in struct myrs_cmdblk static inline void myrs_reset_cmd(struct myrs_cmdblk *cmd_blk)union myrs_cmd_mbox *mbox = &cmd_blk->mbox;sizeof (union myrs_cmd_mbox));/* * myrs_qcmd - queues Command for DAC960 V2 Series Controllers. static void myrs_qcmd(struct myrs_hba *cs, struct myrs_cmdblk *cmd_blk)void __iomem *base = cs->io_base;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;union myrs_cmd_mbox *next_mbox = cs->next_cmd_mbox;if (cs->prev_cmd_mbox1->words[0] == 0 ||if (++next_mbox > cs->last_cmd_mbox)/* * myrs_exec_cmd - executes V2 Command and waits for completion. static void myrs_exec_cmd(struct myrs_hba *cs,struct myrs_cmdblk *cmd_blk)unsigned long flags;/* * myrs_report_progress - prints progress message static void myrs_report_progress(struct myrs_hba *cs, unsigned short ldev_num,unsigned char *msg, unsigned long blocks,unsigned long size)"Logical Drive %d: %s in Progress: %d%% completed\n" ,int )(blocks >> 7)) / (int )(size >> 7));/* * myrs_get_ctlr_info - executes a Controller Information IOCTL Command static unsigned char myrs_get_ctlr_info(struct myrs_hba *cs)struct myrs_cmdblk *cmd_blk = &cs->dcmd_blk;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;union myrs_sgl *sgl;unsigned char status;unsigned short ldev_present, ldev_critical, ldev_offline;sizeof (struct myrs_ctlr_info),if (dma_mapping_error(&cs->pdev->dev, ctlr_info_addr))return MYRS_STATUS_FAILED;true ;true ;sizeof (struct myrs_ctlr_info);"Sending GetControllerInfo\n" );sizeof (struct myrs_ctlr_info), DMA_FROM_DEVICE);if (status == MYRS_STATUS_SUCCESS) {if (cs->ctlr_info->bg_init_active +true ;if (cs->ctlr_info->ldev_present != ldev_present ||"Logical drive count changes (%d/%d/%d)\n" ,return status;/* * myrs_get_ldev_info - executes a Logical Device Information IOCTL Command static unsigned char myrs_get_ldev_info(struct myrs_hba *cs,unsigned short ldev_num, struct myrs_ldev_info *ldev_info)struct myrs_cmdblk *cmd_blk = &cs->dcmd_blk;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;struct myrs_ldev_info ldev_info_orig;union myrs_sgl *sgl;unsigned char status;sizeof (struct myrs_ldev_info));sizeof (struct myrs_ldev_info),if (dma_mapping_error(&cs->pdev->dev, ldev_info_addr))return MYRS_STATUS_FAILED;true ;true ;sizeof (struct myrs_ldev_info);"Sending GetLogicalDeviceInfoValid for ldev %d\n" , ldev_num);sizeof (struct myrs_ldev_info), DMA_FROM_DEVICE);if (status == MYRS_STATUS_SUCCESS) {unsigned short ldev_num = ldev_info->ldev_num;struct myrs_ldev_info *new = ldev_info;struct myrs_ldev_info *old = &ldev_info_orig;unsigned long ldev_size = new->cfg_devsize;if (new->dev_state != old->dev_state) {const char *name;"Logical Drive %d is now %s\n" ,"Invalid" );if ((new->soft_errs != old->soft_errs) ||"Logical Drive %d Errors: Soft = %d, Failed = %d, Deferred Write = %d\n" ,if (new->bg_init_active)"Background Initialization" ,else if (new->fg_init_active)"Foreground Initialization" ,else if (new->migration_active)"Data Migration" ,else if (new->patrol_active)"Patrol Operation" ,if (old->bg_init_active && !new->bg_init_active)"Logical Drive %d: Background Initialization %s\n" ,"Completed" : "Failed" ));return status;/* * myrs_get_pdev_info - executes a "Read Physical Device Information" Command static unsigned char myrs_get_pdev_info(struct myrs_hba *cs,unsigned char channel, unsigned char target, unsigned char lun,struct myrs_pdev_info *pdev_info)struct myrs_cmdblk *cmd_blk = &cs->dcmd_blk;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;union myrs_sgl *sgl;unsigned char status;sizeof (struct myrs_pdev_info),if (dma_mapping_error(&cs->pdev->dev, pdev_info_addr))return MYRS_STATUS_FAILED;true ;true ;sizeof (struct myrs_pdev_info);"Sending GetPhysicalDeviceInfoValid for pdev %d:%d:%d\n" ,sizeof (struct myrs_pdev_info), DMA_FROM_DEVICE);return status;/* * myrs_dev_op - executes a "Device Operation" Command static unsigned char myrs_dev_op(struct myrs_hba *cs,enum myrs_ioctl_opcode opcode, enum myrs_opdev opdev)struct myrs_cmdblk *cmd_blk = &cs->dcmd_blk;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;unsigned char status;true ;true ;return status;/* * myrs_translate_pdev - translates a Physical Device Channel and * TargetID into a Logical Device. static unsigned char myrs_translate_pdev(struct myrs_hba *cs,unsigned char channel, unsigned char target, unsigned char lun,struct myrs_devmap *devmap)struct pci_dev *pdev = cs->pdev;struct myrs_cmdblk *cmd_blk;union myrs_cmd_mbox *mbox;union myrs_sgl *sgl;unsigned char status;sizeof (struct myrs_devmap));sizeof (struct myrs_devmap),if (dma_mapping_error(&pdev->dev, devmap_addr))return MYRS_STATUS_FAILED;true ;true ;sizeof (struct myrs_devmap);sizeof (struct myrs_devmap), DMA_FROM_DEVICE);return status;/* * myrs_get_event - executes a Get Event Command static unsigned char myrs_get_event(struct myrs_hba *cs,unsigned int event_num, struct myrs_event *event_buf)struct pci_dev *pdev = cs->pdev;struct myrs_cmdblk *cmd_blk = &cs->mcmd_blk;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;union myrs_sgl *sgl;unsigned char status;sizeof (struct myrs_event), DMA_FROM_DEVICE);if (dma_mapping_error(&pdev->dev, event_addr))return MYRS_STATUS_FAILED;sizeof (struct myrs_event);sizeof (struct myrs_event), DMA_FROM_DEVICE);return status;/* * myrs_get_fwstatus - executes a Get Health Status Command static unsigned char myrs_get_fwstatus(struct myrs_hba *cs)struct myrs_cmdblk *cmd_blk = &cs->mcmd_blk;union myrs_cmd_mbox *mbox = &cmd_blk->mbox;union myrs_sgl *sgl;unsigned char status = cmd_blk->status;true ;true ;sizeof (struct myrs_fwstat);"Sending GetHealthStatus\n" );return status;/* * myrs_enable_mmio_mbox - enables the Memory Mailbox Interface static bool myrs_enable_mmio_mbox(struct myrs_hba *cs,void __iomem *base = cs->io_base;struct pci_dev *pdev = cs->pdev;union myrs_cmd_mbox *cmd_mbox;struct myrs_stat_mbox *stat_mbox;union myrs_cmd_mbox *mbox;unsigned char status = MYRS_STATUS_FAILED;if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)))if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {"DMA mask out of range\n" );return false ;/* Temporary dma mapping, used only in the scope of this function */ sizeof (union myrs_cmd_mbox),if (!mbox)return false ;/* These are the base addresses for the command memory mailbox array */ sizeof (union myrs_cmd_mbox);if (!cmd_mbox) {"Failed to map command mailbox\n" );goto out_free;/* These are the base addresses for the status memory mailbox array */ sizeof (struct myrs_stat_mbox);if (!stat_mbox) {"Failed to map status mailbox\n" );goto out_free;sizeof (struct myrs_fwstat),if (!cs->fwstat_buf) {"Failed to map firmware health buffer\n" );goto out_free;sizeof (struct myrs_ctlr_info), GFP_KERNEL);if (!cs->ctlr_info)goto out_free;sizeof (struct myrs_event), GFP_KERNEL);if (!cs->event_buf)goto out_free;/* Enable the Memory Mailbox Interface. */ sizeof (union myrs_cmd_mbox));true ;sizeof (union myrs_cmd_mbox)) >> 10;sizeof (struct myrs_stat_mbox)) >> 10;sizeof (union myrs_cmd_mbox),if (status != MYRS_STATUS_SUCCESS)"Failed to enable mailbox, status %X\n" ,return (status == MYRS_STATUS_SUCCESS);/* * myrs_get_config - reads the Configuration Information static int myrs_get_config(struct myrs_hba *cs)struct myrs_ctlr_info *info = cs->ctlr_info;struct Scsi_Host *shost = cs->host;unsigned char status;unsigned char model[20];unsigned char fw_version[12];int i, model_len;/* Get data into dma-able area, then copy into permanent location */ if (status != MYRS_STATUS_SUCCESS) {"Failed to get controller information\n" );return -ENODEV;/* Initialize the Controller Model Name and Full Model Name fields. */ sizeof (info->ctlr_name);if (model_len > sizeof (model)-1)sizeof (model)-1;while (model[model_len] == ' ' || model[model_len] == '\0' )'\0' ;"DAC960 " );/* Initialize the Controller Firmware Version field. */ "%d.%02d-%02d" ,if (info->fw_major_version == 6 &&"FIRMWARE VERSION %s DOES NOT PROVIDE THE CONTROLLER\n" "STATUS MONITORING FUNCTIONALITY NEEDED BY THIS DRIVER.\n" "PLEASE UPGRADE TO VERSION 6.00-01 OR ABOVE.\n" ,return -ENODEV;/* Initialize the Controller Channels and Targets. */ for (i = 1; i < 16; i++) {if (!info->max_targets[i])continue ;if (shost->max_id < info->max_targets[i])/* * Initialize the Controller Queue Depth, Driver Queue Depth, * Logical Drive Count, Maximum Blocks per Command, Controller * Scatter/Gather Limit, and Driver Scatter/Gather Limit. * The Driver Queue Depth must be at most three less than * the Controller Queue Depth; tag '1' is reserved for * direct commands, and tag '2' for monitoring commands. if (shost->can_queue > MYRS_MAX_CMD_MBOX - 3)if (shost->sg_tablesize > MYRS_SG_LIMIT)"Configuring %s PCI RAID Controller\n" , model);" Firmware Version: %s, Channels: %d, Memory Size: %dMB\n" ," Controller Queue Depth: %d, Maximum Blocks per Command: %d\n" ," Driver Queue Depth: %d, Scatter/Gather Limit: %d of %d Segments\n" ,for (i = 0; i < info->physchan_max; i++) {if (!info->max_targets[i])continue ;" Device Channel %d: max %d devices\n" ," Physical: %d/%d channels, %d disks, %d devices\n" ," Logical: %d/%d channels, %d disks\n" ,return 0;/* * myrs_log_event - prints a Controller Event message static struct {int ev_code;unsigned char *ev_msg;/* Physical Device Events (0x0000 - 0x007F) */ "P Online" },"P Standby" },"P Automatic Rebuild Started" },"P Manual Rebuild Started" },"P Rebuild Completed" },"P Rebuild Cancelled" },"P Rebuild Failed for Unknown Reasons" },"P Rebuild Failed due to New Physical Device" },"P Rebuild Failed due to Logical Drive Failure" },"S Offline" },"P Found" },"P Removed" },"P Unconfigured" },"P Expand Capacity Started" },"P Expand Capacity Completed" },"P Expand Capacity Failed" },"P Command Timed Out" },"P Command Aborted" },"P Command Retried" },"P Parity Error" },"P Soft Error" },"P Miscellaneous Error" },"P Reset" },"P Active Spare Found" },"P Warm Spare Found" },"S Sense Data Received" },"P Initialization Started" },"P Initialization Completed" },"P Initialization Failed" },"P Initialization Cancelled" },"P Failed because Write Recovery Failed" },"P Failed because SCSI Bus Reset Failed" },"P Failed because of Double Check Condition" },"P Failed because Device Cannot Be Accessed" },"P Failed because of Gross Error on SCSI Processor" },"P Failed because of Bad Tag from Device" },"P Failed because of Command Timeout" },"P Failed because of System Reset" },"P Failed because of Busy Status or Parity Error" },"P Failed because Host Set Device to Failed State" },"P Failed because of Selection Timeout" },"P Failed because of SCSI Bus Phase Error" },"P Failed because Device Returned Unknown Status" },"P Failed because Device Not Ready" },"P Failed because Device Not Found at Startup" },"P Failed because COD Write Operation Failed" },"P Failed because BDT Write Operation Failed" },"P Missing at Startup" },"P Start Rebuild Failed due to Physical Drive Too Small" },"P Temporarily Offline Device Automatically Made Online" },"P Standby Rebuild Started" },/* Logical Device Events (0x0080 - 0x00FF) */ "M Consistency Check Started" },"M Consistency Check Completed" },"M Consistency Check Cancelled" },"M Consistency Check Completed With Errors" },"M Consistency Check Failed due to Logical Drive Failure" },"M Consistency Check Failed due to Physical Device Failure" },"L Offline" },"L Critical" },"L Online" },"M Automatic Rebuild Started" },"M Manual Rebuild Started" },"M Rebuild Completed" },"M Rebuild Cancelled" },"M Rebuild Failed for Unknown Reasons" },"M Rebuild Failed due to New Physical Device" },"M Rebuild Failed due to Logical Drive Failure" },"M Initialization Started" },"M Initialization Completed" },"M Initialization Cancelled" },"M Initialization Failed" },"L Found" },"L Deleted" },"M Expand Capacity Started" },"M Expand Capacity Completed" },"M Expand Capacity Failed" },"L Bad Block Found" },"L Size Changed" },"L Type Changed" },"L Bad Data Block Found" },"L Read of Data Block in BDT" },"L Write Back Data for Disk Block Lost" },"L Temporarily Offline RAID-5/3 Drive Made Online" },"L Temporarily Offline RAID-6/1/0/7 Drive Made Online" },"L Standby Rebuild Started" },/* Fault Management Events (0x0100 - 0x017F) */ "E Fan %d Failed" },"E Fan %d OK" },"E Fan %d Not Present" },"E Power Supply %d Failed" },"E Power Supply %d OK" },"E Power Supply %d Not Present" },"E Temperature Sensor %d Temperature Exceeds Safe Limit" },"E Temperature Sensor %d Temperature Exceeds Working Limit" },"E Temperature Sensor %d Temperature Normal" },"E Temperature Sensor %d Not Present" },"E Enclosure Management Unit %d Access Critical" },"E Enclosure Management Unit %d Access OK" },"E Enclosure Management Unit %d Access Offline" },/* Controller Events (0x0180 - 0x01FF) */ "C Cache Write Back Error" },"C Battery Backup Unit Found" },"C Battery Backup Unit Charge Level Low" },"C Battery Backup Unit Charge Level OK" },"C Installation Aborted" },"C Battery Backup Unit Physically Removed" },"C Memory Error During Warm Boot" },"C Memory Soft ECC Error Corrected" },"C Memory Hard ECC Error Corrected" },"C Battery Backup Unit Failed" },"C Mirror Race Recovery Failed" },"C Mirror Race on Critical Drive" },/* Controller Internal Processor Events */ "C Internal Controller Hung" },"C Internal Controller Firmware Breakpoint" },"C Internal Controller i960 Processor Specific Error" },"C Internal Controller StrongARM Processor Specific Error" },"" }static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)unsigned char msg_buf[MYRS_LINE_BUFFER_SIZE];int ev_idx = 0, ev_code;unsigned char ev_type, *ev_msg;struct Scsi_Host *shost = cs->host;struct scsi_device *sdev;struct scsi_sense_hdr sshdr = {0};unsigned char sense_info[4];unsigned char cmd_specific[4];if (ev->ev_code == 0x1C) {if (!scsi_normalize_sense(ev->sense_data, 40, &sshdr)) {sizeof (sshdr));sizeof (sense_info));sizeof (cmd_specific));else {if (sshdr.sense_key == VENDOR_SPECIFIC &&while (true ) {if (ev_code == ev->ev_code || ev_code == 0)break ;if (ev_code == 0) {"Unknown Controller Event Code %04X\n" ,return ;switch (ev_type) {case 'P' :"event %d: Physical Device %s\n" ,if (sdev && sdev->hostdata &&struct myrs_pdev_info *pdev_info = sdev->hostdata;switch (ev->ev_code) {case 0x0001:case 0x0007:break ;case 0x0002:break ;case 0x000C:break ;case 0x000E:break ;case 0x000F:break ;break ;case 'L' :"event %d: Logical Drive %d %s\n" ,true ;break ;case 'M' :"event %d: Logical Drive %d %s\n" ,true ;break ;case 'S' :if (sshdr.sense_key == NO_SENSE ||break ;"event %d: Physical Device %d:%d %s\n" ,"Physical Device %d:%d Sense Key = %X, ASC = %02X, ASCQ = %02X\n" ,"Physical Device %d:%d Sense Information = %02X%02X%02X%02X %02X%02X%02X%02X\n" ,break ;case 'E' :if (cs->disable_enc_msg)break ;"event %d: Enclosure %d %s\n" ,break ;case 'C' :"event %d: Controller %s\n" ,break ;default :"event %d: Unknown Event Code %04X\n" ,break ;/* * SCSI sysfs interface functions static ssize_t raid_state_show(struct device *dev,struct device_attribute *attr, char *buf)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);int ret;if (!sdev->hostdata)return snprintf(buf, 16, "Unknown\n" );if (sdev->channel >= cs->ctlr_info->physchan_present) {struct myrs_ldev_info *ldev_info = sdev->hostdata;const char *name;if (name)"%s\n" , name);else "Invalid (%02X)\n" ,else {struct myrs_pdev_info *pdev_info;const char *name;if (name)"%s\n" , name);else "Invalid (%02X)\n" ,return ret;static ssize_t raid_state_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_cmdblk *cmd_blk;union myrs_cmd_mbox *mbox;enum myrs_devstate new_state;unsigned short ldev_num;unsigned char status;if (!strncmp(buf, "offline" , 7) ||"kill" , 4))else if (!strncmp(buf, "online" , 6))else if (!strncmp(buf, "standby" , 7))else return -EINVAL;if (sdev->channel < cs->ctlr_info->physchan_present) {struct myrs_pdev_info *pdev_info = sdev->hostdata;struct myrs_devmap *pdev_devmap =struct myrs_devmap *)&pdev_info->rsvd13;if (pdev_info->dev_state == new_state) {"Device already in %s\n" ,return count;if (status != MYRS_STATUS_SUCCESS)return -ENXIO;else {struct myrs_ldev_info *ldev_info = sdev->hostdata;if (ldev_info->dev_state == new_state) {"Device already in %s\n" ,return count;true ;true ;if (status == MYRS_STATUS_SUCCESS) {if (sdev->channel < cs->ctlr_info->physchan_present) {struct myrs_pdev_info *pdev_info = sdev->hostdata;else {struct myrs_ldev_info *ldev_info = sdev->hostdata;"Set device state to %s\n" ,return count;"Failed to set device state to %s, status 0x%02x\n" ,return -EINVAL;static DEVICE_ATTR_RW(raid_state);static ssize_t raid_level_show(struct device *dev,struct device_attribute *attr, char *buf)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);const char *name = NULL;if (!sdev->hostdata)return snprintf(buf, 16, "Unknown\n" );if (sdev->channel >= cs->ctlr_info->physchan_present) {struct myrs_ldev_info *ldev_info;if (!name)return snprintf(buf, 64, "Invalid (%02X)\n" ,else return snprintf(buf, 64, "%s\n" , name);static DEVICE_ATTR_RO(raid_level);static ssize_t rebuild_show(struct device *dev,struct device_attribute *attr, char *buf)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info;unsigned short ldev_num;unsigned char status;if (sdev->channel < cs->ctlr_info->physchan_present)return snprintf(buf, 64, "physical device - not rebuilding\n" );if (status != MYRS_STATUS_SUCCESS) {"Failed to get device information, status 0x%02x\n" ,return -EIO;if (ldev_info->rbld_active) {return snprintf(buf, 64, "rebuilding block %zu of %zu\n" ,else return snprintf(buf, 64, "not rebuilding\n" );static ssize_t rebuild_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info;struct myrs_cmdblk *cmd_blk;union myrs_cmd_mbox *mbox;unsigned short ldev_num;unsigned char status;int rebuild, ret;if (sdev->channel < cs->ctlr_info->physchan_present)return -EINVAL;if (!ldev_info)return -ENXIO;if (ret)return ret;if (status != MYRS_STATUS_SUCCESS) {"Failed to get device information, status 0x%02x\n" ,return -EIO;if (rebuild && ldev_info->rbld_active) {"Rebuild Not Initiated; already in progress\n" );return -EALREADY;if (!rebuild && !ldev_info->rbld_active) {"Rebuild Not Cancelled; no rebuild in progress\n" );return count;true ;true ;if (rebuild) {else {if (status) {"Rebuild Not %s, status 0x%02x\n" ,"Initiated" : "Cancelled" , status);else {"Rebuild %s\n" ,"Initiated" : "Cancelled" );return ret;static DEVICE_ATTR_RW(rebuild);static ssize_t consistency_check_show(struct device *dev,struct device_attribute *attr, char *buf)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info;unsigned short ldev_num;if (sdev->channel < cs->ctlr_info->physchan_present)return snprintf(buf, 64, "physical device - not checking\n" );if (!ldev_info)return -ENXIO;if (ldev_info->cc_active)return snprintf(buf, 64, "checking block %zu of %zu\n" ,else return snprintf(buf, 64, "not checking\n" );static ssize_t consistency_check_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info;struct myrs_cmdblk *cmd_blk;union myrs_cmd_mbox *mbox;unsigned short ldev_num;unsigned char status;int check, ret;if (sdev->channel < cs->ctlr_info->physchan_present)return -EINVAL;if (!ldev_info)return -ENXIO;if (ret)return ret;if (status != MYRS_STATUS_SUCCESS) {"Failed to get device information, status 0x%02x\n" ,return -EIO;if (check && ldev_info->cc_active) {"Consistency Check Not Initiated; " "already in progress\n" );return -EALREADY;if (!check && !ldev_info->cc_active) {"Consistency Check Not Cancelled; " "check not in progress\n" );return count;true ;true ;if (check) {true ;false ;else {if (status != MYRS_STATUS_SUCCESS) {"Consistency Check Not %s, status 0x%02x\n" ,"Initiated" : "Cancelled" , status);else {"Consistency Check %s\n" ,"Initiated" : "Cancelled" );return ret;static DEVICE_ATTR_RW(consistency_check);static struct attribute *myrs_sdev_attrs[] = {static ssize_t serial_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);char serial[17];'\0' ;return snprintf(buf, 16, "%s\n" , serial);static DEVICE_ATTR_RO(serial);static ssize_t ctlr_num_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);return snprintf(buf, 20, "%d\n" , cs->host->host_no);static DEVICE_ATTR_RO(ctlr_num);static struct myrs_cpu_type_tbl {enum myrs_cpu_type type;char *name;"i960CA" },"i960RD" },"i960RN" },"i960RP" },"NorthBay" },"StrongARM" },"i960RM" },static ssize_t processor_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);struct myrs_cpu_type_tbl *tbl;const char *first_processor = NULL;const char *second_processor = NULL;struct myrs_ctlr_info *info = cs->ctlr_info;int i;if (info->cpu[0].cpu_count) {for (i = 0; i < ARRAY_SIZE(myrs_cpu_type_names); i++) {if (tbl[i].type == info->cpu[0].cpu_type) {break ;if (info->cpu[1].cpu_count) {for (i = 0; i < ARRAY_SIZE(myrs_cpu_type_names); i++) {if (tbl[i].type == info->cpu[1].cpu_type) {break ;if (first_processor && second_processor)"1: %s (%s, %d cpus)\n" "2: %s (%s, %d cpus)\n" ,else if (first_processor && !second_processor)"1: %s (%s, %d cpus)\n2: absent\n" ,else if (!first_processor && second_processor)"1: absent\n2: %s (%s, %d cpus)\n" ,else "1: absent\n2: absent\n" );return ret;static DEVICE_ATTR_RO(processor);static ssize_t model_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);return snprintf(buf, 28, "%s\n" , cs->model_name);static DEVICE_ATTR_RO(model);static ssize_t ctlr_type_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);return snprintf(buf, 4, "%d\n" , cs->ctlr_info->ctlr_type);static DEVICE_ATTR_RO(ctlr_type);static ssize_t cache_size_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);return snprintf(buf, 8, "%d MB\n" , cs->ctlr_info->cache_size_mb);static DEVICE_ATTR_RO(cache_size);static ssize_t firmware_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);return snprintf(buf, 16, "%d.%02d-%02d\n" ,static DEVICE_ATTR_RO(firmware);static ssize_t discovery_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);struct myrs_cmdblk *cmd_blk;union myrs_cmd_mbox *mbox;unsigned char status;true ;true ;if (status != MYRS_STATUS_SUCCESS) {"Discovery Not Initiated, status %02X\n" ,return -EINVAL;"Discovery Initiated\n" );true ;"Discovery Completed\n" );return count;static DEVICE_ATTR_WO(discovery);static ssize_t flush_cache_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);unsigned char status;if (status == MYRS_STATUS_SUCCESS) {"Cache Flush Completed\n" );return count;"Cache Flush failed, status 0x%02x\n" , status);return -EIO;static DEVICE_ATTR_WO(flush_cache);static ssize_t disable_enclosure_messages_show(struct device *dev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(dev);struct myrs_hba *cs = shost_priv(shost);return snprintf(buf, 3, "%d\n" , cs->disable_enc_msg);static ssize_t disable_enclosure_messages_store(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);int value, ret;if (ret)return ret;if (value > 2)return -EINVAL;return count;static DEVICE_ATTR_RW(disable_enclosure_messages);static struct attribute *myrs_shost_attrs[] = {/* * SCSI midlayer interface static int myrs_host_reset(struct scsi_cmnd *scmd)struct Scsi_Host *shost = scmd->device->host;struct myrs_hba *cs = shost_priv(shost);return SUCCESS;static void myrs_mode_sense(struct myrs_hba *cs, struct scsi_cmnd *scmd,struct myrs_ldev_info *ldev_info)unsigned char modes[32], *mode_pg;bool dbd;if (dbd) {else {sizeof (modes));/* Enable FUA */ if (ldev_info->ldev_control.wce == MYRS_LOGICALDEVICE_RO)if (!dbd) {unsigned char *block_desc = &modes[4];if (ldev_info->ldev_control.rce == MYRS_READCACHE_DISABLED)if (ldev_info->ldev_control.wce == MYRS_WRITECACHE_ENABLED ||if (ldev_info->cacheline_size) {static int myrs_queuecommand(struct Scsi_Host *shost,struct scsi_cmnd *scmd)struct request *rq = scsi_cmd_to_rq(scmd);struct myrs_hba *cs = shost_priv(shost);struct myrs_cmdblk *cmd_blk = scsi_cmd_priv(scmd);union myrs_cmd_mbox *mbox = &cmd_blk->mbox;struct scsi_device *sdev = scmd->device;union myrs_sgl *hw_sge;struct scatterlist *sgl;unsigned long flags, timeout;int nsge;if (!scmd->device->hostdata) {return 0;switch (scmd->cmnd[0]) {case REPORT_LUNS:return 0;case MODE_SENSE:if (scmd->device->channel >= cs->ctlr_info->physchan_present) {struct myrs_ldev_info *ldev_info = sdev->hostdata;if ((scmd->cmnd[2] & 0x3F) != 0x3F &&/* Illegal request, invalid field in CDB */ else {return 0;break ;if (!cmd_blk->sense)return SCSI_MLQUEUE_HOST_BUSY;if (scmd->cmd_len <= 10) {if (scmd->device->channel >= cs->ctlr_info->physchan_present) {struct myrs_ldev_info *ldev_info = sdev->hostdata;else {if (rq->cmd_flags & REQ_FUA)true ;if (timeout > 60) {else {else {if (!cmd_blk->dcdb) {return SCSI_MLQUEUE_HOST_BUSY;if (scmd->device->channel >= cs->ctlr_info->physchan_present) {struct myrs_ldev_info *ldev_info = sdev->hostdata;else {if (rq->cmd_flags & REQ_FUA)true ;if (timeout > 60) {else {if (scmd->sc_data_direction == DMA_NONE)goto submit;if (nsge == 1) {else {struct myrs_sge *hw_sgl;int i;if (nsge > 2) {if (WARN_ON(!hw_sgl)) {if (cmd_blk->dcdb) {return SCSI_MLQUEUE_HOST_BUSY;if (scmd->cmd_len <= 10)true ;else true ;else if (WARN_ON(!hw_sgl)) {return 0;return 0;static unsigned short myrs_translate_ldev(struct myrs_hba *cs,struct scsi_device *sdev)unsigned short ldev_num;unsigned int chan_offset =return ldev_num;static int myrs_sdev_init(struct scsi_device *sdev)struct myrs_hba *cs = shost_priv(sdev->host);unsigned char status;if (sdev->channel > sdev->host->max_channel)return 0;if (sdev->channel >= cs->ctlr_info->physchan_present) {struct myrs_ldev_info *ldev_info;unsigned short ldev_num;if (sdev->lun > 0)return -ENXIO;sizeof (*ldev_info), GFP_KERNEL);if (!ldev_info)return -ENOMEM;if (status != MYRS_STATUS_SUCCESS) {else {enum raid_level level;"Logical device mapping %d:%d:%d -> %d\n" ,switch (ldev_info->raid_level) {case MYRS_RAID_LEVEL0:break ;case MYRS_RAID_LEVEL1:break ;case MYRS_RAID_LEVEL3:case MYRS_RAID_LEVEL3F:case MYRS_RAID_LEVEL3L:break ;case MYRS_RAID_LEVEL5:case MYRS_RAID_LEVEL5L:break ;case MYRS_RAID_LEVEL6:break ;case MYRS_RAID_LEVELE:case MYRS_RAID_NEWSPAN:case MYRS_RAID_SPAN:break ;case MYRS_RAID_JBOD:break ;default :break ;if (ldev_info->dev_state != MYRS_DEVICE_ONLINE) {const char *name;"logical device in state %s\n" ,"Invalid" );else {struct myrs_pdev_info *pdev_info;sizeof (*pdev_info), GFP_KERNEL);if (!pdev_info)return -ENOMEM;if (status != MYRS_STATUS_SUCCESS) {return -ENXIO;return 0;static int myrs_sdev_configure(struct scsi_device *sdev,struct queue_limits *lim)struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info;if (sdev->channel > sdev->host->max_channel)return -ENXIO;if (sdev->channel < cs->ctlr_info->physchan_present) {/* Skip HBA device */ if (sdev->type == TYPE_RAID)return -ENXIO;return 0;if (sdev->lun != 0)return -ENXIO;if (!ldev_info)return -ENXIO;if (ldev_info->ldev_control.wce == MYRS_WRITECACHE_ENABLED ||return 0;static void myrs_sdev_destroy(struct scsi_device *sdev)static const struct scsi_host_template myrs_template = {"DAC960" ,"myrs" ,sizeof (struct myrs_cmdblk),static struct myrs_hba *myrs_alloc_host(struct pci_dev *pdev,const struct pci_device_id *entry)struct Scsi_Host *shost;struct myrs_hba *cs;sizeof (struct myrs_hba));if (!shost)return NULL;return cs;/* * RAID template functions /** * myrs_is_raid - return boolean indicating device is raid volume * @dev: the device struct object static int struct device *dev)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);return (sdev->channel >= cs->ctlr_info->physchan_present) ? 1 : 0;/** * myrs_get_resync - get raid volume resync percent complete * @dev: the device struct object static void struct device *dev)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info = sdev->hostdata;if (sdev->channel < cs->ctlr_info->physchan_present || !ldev_info)return ;if (ldev_info->rbld_active) {unsigned short ldev_num = ldev_info->ldev_num;/** * myrs_get_state - get raid volume status * @dev: the device struct object static void struct device *dev)struct scsi_device *sdev = to_scsi_device(dev);struct myrs_hba *cs = shost_priv(sdev->host);struct myrs_ldev_info *ldev_info = sdev->hostdata;enum raid_state state = RAID_STATE_UNKNOWN;if (sdev->channel < cs->ctlr_info->physchan_present || !ldev_info)else {switch (ldev_info->dev_state) {case MYRS_DEVICE_ONLINE:break ;case MYRS_DEVICE_SUSPECTED_CRITICAL:case MYRS_DEVICE_CRITICAL:break ;case MYRS_DEVICE_REBUILD:break ;case MYRS_DEVICE_UNCONFIGURED:case MYRS_DEVICE_INVALID_STATE:break ;default :static struct raid_function_template myrs_raid_functions = {/* * PCI interface functions static void myrs_flush_cache(struct myrs_hba *cs)static void myrs_handle_scsi(struct myrs_hba *cs, struct myrs_cmdblk *cmd_blk,struct scsi_cmnd *scmd)unsigned char status;if (!cmd_blk)return ;if (cmd_blk->sense) {if (status == MYRS_STATUS_FAILED && cmd_blk->sense_len) {unsigned int sense_len = SCSI_SENSE_BUFFERSIZE;if (sense_len > cmd_blk->sense_len)if (cmd_blk->dcdb) {if (cmd_blk->sgl) {if (cmd_blk->residual)if (status == MYRS_STATUS_DEVICE_NON_RESPONSIVE ||else static void myrs_handle_cmdblk(struct myrs_hba *cs, struct myrs_cmdblk *cmd_blk)if (!cmd_blk)return ;if (cmd_blk->complete) {static void myrs_monitor(struct work_struct *work)struct myrs_hba *cs = container_of(work, struct myrs_hba,struct Scsi_Host *shost = cs->host;struct myrs_ctlr_info *info = cs->ctlr_info;unsigned int epoch = cs->fwstat_buf->epoch;unsigned long interval = MYRS_PRIMARY_MONITOR_INTERVAL;unsigned char status;"monitor tick\n" );if (cs->needs_update) {false ;if (cs->fwstat_buf->next_evseq - cs->next_evseq > 0) {if (status == MYRS_STATUS_SUCCESS) {if (time_after(jiffies, cs->secondary_monitor_timeif (info->bg_init_active +struct scsi_device *sdev;struct myrs_ldev_info *ldev_info;int ldev_num;if (sdev->channel < info->physchan_present)continue ;if (!ldev_info)continue ;true ;if (epoch == cs->epoch &&false ||if (interval > 1)
Messung V0.5 C=99 H=98 G=98
¤ Dauer der Verarbeitung: 0.59 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
