/* * Adaptec AIC79xx device driver for Linux. * * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.c#171 $ * * -------------------------------------------------------------------------- * Copyright (c) 1994-2000 Justin T. Gibbs. * Copyright (c) 1997-1999 Doug Ledford * Copyright (c) 2000-2003 Adaptec Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions, and the following disclaimer, * without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer * substantially similar to the "NO WARRANTY" disclaimer below * ("Disclaimer") and any redistribution must be conditioned upon * including a substantially similar Disclaimer requirement for further * binary redistribution. * 3. Neither the names of the above-listed copyright holders nor the names * of any contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. */ #include "aic79xx_osm.h" #include "aic79xx_inline.h" #include <scsi/scsicam.h> static struct scsi_transport_template *ahd_linux_transport_template = …; #include <linux/init.h> /* __setup */ #include <linux/mm.h> /* For fetching system memory size */ #include <linux/blkdev.h> /* For block_size() */ #include <linux/delay.h> /* For ssleep/msleep */ #include <linux/device.h> #include <linux/slab.h> /* * Bucket size for counting good commands in between bad ones. */ #define AHD_LINUX_ERR_THRESH … /* * Set this to the delay in seconds after SCSI bus reset. * Note, we honor this only for the initial bus reset. * The scsi error recovery code performs its own bus settle * delay handling for error recovery actions. */ #ifdef CONFIG_AIC79XX_RESET_DELAY_MS #define AIC79XX_RESET_DELAY … #else #define AIC79XX_RESET_DELAY … #endif /* * To change the default number of tagged transactions allowed per-device, * add a line to the lilo.conf file like: * append="aic79xx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}" * which will result in the first four devices on the first two * controllers being set to a tagged queue depth of 32. * * The tag_commands is an array of 16 to allow for wide and twin adapters. * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15 * for channel 1. */ adapter_tag_info_t; /* * Modify this as you see fit for your system. * * 0 tagged queuing disabled * 1 <= n <= 253 n == max tags ever dispatched. * * The driver will throttle the number of commands dispatched to a * device if it returns queue full. For devices with a fixed maximum * queue depth, the driver will eventually determine this depth and * lock it in (a console message is printed to indicate that a lock * has occurred). On some devices, queue full is returned for a temporary * resource shortage. These devices will return queue full at varying * depths. The driver will throttle back when the queue fulls occur and * attempt to slowly increase the depth over time as the device recovers * from the resource shortage. * * In this example, the first line will disable tagged queueing for all * the devices on the first probed aic79xx adapter. * * The second line enables tagged queueing with 4 commands/LUN for IDs * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the * driver to attempt to use up to 64 tags for ID 1. * * The third line is the same as the first line. * * The fourth line disables tagged queueing for devices 0 and 3. It * enables tagged queueing for the other IDs, with 16 commands/LUN * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for * IDs 2, 5-7, and 9-15. */ /* * NOTE: The below structure is for reference only, the actual structure * to modify in order to change things is just below this comment block. adapter_tag_info_t aic79xx_tag_info[] = { {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}}, {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}} }; */ #ifdef CONFIG_AIC79XX_CMDS_PER_DEVICE #define AIC79XX_CMDS_PER_DEVICE … #else #define AIC79XX_CMDS_PER_DEVICE … #endif #define AIC79XX_CONFIGED_TAG_COMMANDS … /* * By default, use the number of commands specified by * the users kernel configuration. */ static adapter_tag_info_t aic79xx_tag_info[] = …; /* * The I/O cell on the chip is very configurable in respect to its analog * characteristics. Set the defaults here; they can be overriden with * the proper insmod parameters. */ struct ahd_linux_iocell_opts { … }; #define AIC79XX_DEFAULT_PRECOMP … #define AIC79XX_DEFAULT_SLEWRATE … #define AIC79XX_DEFAULT_AMPLITUDE … #define AIC79XX_DEFAULT_IOOPTS … #define AIC79XX_PRECOMP_INDEX … #define AIC79XX_SLEWRATE_INDEX … #define AIC79XX_AMPLITUDE_INDEX … static struct ahd_linux_iocell_opts aic79xx_iocell_info[] __ro_after_init = …; /* * There should be a specific return value for this in scsi.h, but * it seems that most drivers ignore it. */ #define DID_UNDERFLOW … void ahd_print_path(struct ahd_softc *ahd, struct scb *scb) { … } /* * XXX - these options apply unilaterally to _all_ adapters * cards in the system. This should be fixed. Exceptions to this * rule are noted in the comments. */ /* * Skip the scsi bus reset. Non 0 make us skip the reset at startup. This * has no effect on any later resets that might occur due to things like * SCSI bus timeouts. */ static uint32_t aic79xx_no_reset; /* * Should we force EXTENDED translation on a controller. * 0 == Use whatever is in the SEEPROM or default to off * 1 == Use whatever is in the SEEPROM or default to on */ static uint32_t aic79xx_extended; /* * PCI bus parity checking of the Adaptec controllers. This is somewhat * dubious at best. To my knowledge, this option has never actually * solved a PCI parity problem, but on certain machines with broken PCI * chipset configurations, it can generate tons of false error messages. * It's included in the driver for completeness. * 0 = Shut off PCI parity check * non-0 = Enable PCI parity check * * NOTE: you can't actually pass -1 on the lilo prompt. So, to set this * variable to -1 you would actually want to simply pass the variable * name without a number. That will invert the 0 which will result in * -1. */ static uint32_t aic79xx_pci_parity = …; /* * There are lots of broken chipsets in the world. Some of them will * violate the PCI spec when we issue byte sized memory writes to our * controller. I/O mapped register access, if allowed by the given * platform, will work in almost all cases. */ uint32_t aic79xx_allow_memio = …; /* * So that we can set how long each device is given as a selection timeout. * The table of values goes like this: * 0 - 256ms * 1 - 128ms * 2 - 64ms * 3 - 32ms * We default to 256ms because some older devices need a longer time * to respond to initial selection. */ static uint32_t aic79xx_seltime; /* * Certain devices do not perform any aging on commands. Should the * device be saturated by commands in one portion of the disk, it is * possible for transactions on far away sectors to never be serviced. * To handle these devices, we can periodically send an ordered tag to * force all outstanding transactions to be serviced prior to a new * transaction. */ static uint32_t aic79xx_periodic_otag; /* Some storage boxes are using an LSI chip which has a bug making it * impossible to use aic79xx Rev B chip in 320 speeds. The following * storage boxes have been reported to be buggy: * EonStor 3U 16-Bay: U16U-G3A3 * EonStor 2U 12-Bay: U12U-G3A3 * SentinelRAID: 2500F R5 / R6 * SentinelRAID: 2500F R1 * SentinelRAID: 2500F/1500F * SentinelRAID: 150F * * To get around this LSI bug, you can set your board to 160 mode * or you can enable the SLOWCRC bit. */ uint32_t aic79xx_slowcrc; /* * Module information and settable options. */ static char *aic79xx = …; MODULE_AUTHOR(…) …; MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …; MODULE_VERSION(…); module_param(aic79xx, charp, 0444); MODULE_PARM_DESC(…) …; static void ahd_linux_handle_scsi_status(struct ahd_softc *, struct scsi_device *, struct scb *); static void ahd_linux_queue_cmd_complete(struct ahd_softc *ahd, struct scsi_cmnd *cmd); static int ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd); static void ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd); static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd, struct ahd_devinfo *devinfo); static void ahd_linux_device_queue_depth(struct scsi_device *); static int ahd_linux_run_command(struct ahd_softc*, struct ahd_linux_device *, struct scsi_cmnd *); static void ahd_linux_setup_tag_info_global(char *p); static int aic79xx_setup(char *c); static void ahd_freeze_simq(struct ahd_softc *ahd); static void ahd_release_simq(struct ahd_softc *ahd); static int ahd_linux_unit; /************************** OS Utility Wrappers *******************************/ void ahd_delay(long); void ahd_delay(long usec) { … } /***************************** Low Level I/O **********************************/ uint8_t ahd_inb(struct ahd_softc * ahd, long port); void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val); void ahd_outw_atomic(struct ahd_softc * ahd, long port, uint16_t val); void ahd_outsb(struct ahd_softc * ahd, long port, uint8_t *, int count); void ahd_insb(struct ahd_softc * ahd, long port, uint8_t *, int count); uint8_t ahd_inb(struct ahd_softc * ahd, long port) { … } #if 0 /* unused */ static uint16_t ahd_inw_atomic(struct ahd_softc * ahd, long port) { uint8_t x; if (ahd->tags[0] == BUS_SPACE_MEMIO) { x = readw(ahd->bshs[0].maddr + port); } else { x = inw(ahd->bshs[(port) >> 8].ioport + ((port) & 0xFF)); } mb(); return (x); } #endif void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val) { … } void ahd_outw_atomic(struct ahd_softc * ahd, long port, uint16_t val) { … } void ahd_outsb(struct ahd_softc * ahd, long port, uint8_t *array, int count) { … } void ahd_insb(struct ahd_softc * ahd, long port, uint8_t *array, int count) { … } /******************************* PCI Routines *********************************/ uint32_t ahd_pci_read_config(ahd_dev_softc_t pci, int reg, int width) { … } void ahd_pci_write_config(ahd_dev_softc_t pci, int reg, uint32_t value, int width) { … } /****************************** Inlines ***************************************/ static void ahd_linux_unmap_scb(struct ahd_softc*, struct scb*); static void ahd_linux_unmap_scb(struct ahd_softc *ahd, struct scb *scb) { … } /******************************** Macros **************************************/ static inline unsigned int ahd_build_scsiid(struct ahd_softc *ahd, struct scsi_device *sdev) { … } /* * Return a string describing the driver. */ static const char * ahd_linux_info(struct Scsi_Host *host) { … } /* * Queue an SCB to the controller. */ static int ahd_linux_queue_lck(struct scsi_cmnd *cmd) { … } static DEF_SCSI_QCMD(ahd_linux_queue) static struct scsi_target ** ahd_linux_target_in_softc(struct scsi_target *starget) { … } static int ahd_linux_target_alloc(struct scsi_target *starget) { … } static void ahd_linux_target_destroy(struct scsi_target *starget) { … } static int ahd_linux_slave_alloc(struct scsi_device *sdev) { … } static int ahd_linux_slave_configure(struct scsi_device *sdev) { … } #if defined(__i386__) /* * Return the disk geometry for the given SCSI device. */ static int ahd_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]) { int heads; int sectors; int cylinders; int extended; struct ahd_softc *ahd; ahd = *((struct ahd_softc **)sdev->host->hostdata); if (scsi_partsize(bdev, capacity, geom)) return 0; heads = 64; sectors = 32; cylinders = aic_sector_div(capacity, heads, sectors); if (aic79xx_extended != 0) extended = 1; else extended = (ahd->flags & AHD_EXTENDED_TRANS_A) != 0; if (extended && cylinders >= 1024) { heads = 255; sectors = 63; cylinders = aic_sector_div(capacity, heads, sectors); } geom[0] = heads; geom[1] = sectors; geom[2] = cylinders; return (0); } #endif /* * Abort the current SCSI command(s). */ static int ahd_linux_abort(struct scsi_cmnd *cmd) { … } /* * Attempt to send a target reset message to the device that timed out. */ static int ahd_linux_dev_reset(struct scsi_cmnd *cmd) { … } /* * Reset the SCSI bus. */ static int ahd_linux_bus_reset(struct scsi_cmnd *cmd) { … } struct scsi_host_template aic79xx_driver_template = …; /******************************** Bus DMA *************************************/ int ahd_dma_tag_create(struct ahd_softc *ahd, bus_dma_tag_t parent, bus_size_t alignment, bus_size_t boundary, dma_addr_t lowaddr, dma_addr_t highaddr, bus_dma_filter_t *filter, void *filterarg, bus_size_t maxsize, int nsegments, bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag) { … } void ahd_dma_tag_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat) { … } int ahd_dmamem_alloc(struct ahd_softc *ahd, bus_dma_tag_t dmat, void** vaddr, int flags, bus_dmamap_t *mapp) { … } void ahd_dmamem_free(struct ahd_softc *ahd, bus_dma_tag_t dmat, void* vaddr, bus_dmamap_t map) { … } int ahd_dmamap_load(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map, void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb, void *cb_arg, int flags) { … } void ahd_dmamap_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map) { … } int ahd_dmamap_unload(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map) { … } /********************* Platform Dependent Functions ***************************/ static void ahd_linux_setup_iocell_info(u_long index, int instance, int targ, int32_t value) { … } static void ahd_linux_setup_tag_info_global(char *p) { … } static void ahd_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value) { … } static char * ahd_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth, void (*callback)(u_long, int, int, int32_t), u_long callback_arg) { … } /* * Handle Linux boot parameters. This routine allows for assigning a value * to a parameter with a ':' between the parameter and the value. * ie. aic79xx=stpwlev:1,extended */ static int aic79xx_setup(char *s) { … } __setup(…); uint32_t aic79xx_verbose; int ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *template) { … } /* * Place the SCSI bus into a known state by either resetting it, * or forcing transfer negotiations on the next command to any * target. */ static void ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd) { … } int ahd_platform_alloc(struct ahd_softc *ahd, void *platform_arg) { … } void ahd_platform_free(struct ahd_softc *ahd) { … } void ahd_platform_init(struct ahd_softc *ahd) { … } void ahd_platform_freeze_devq(struct ahd_softc *ahd, struct scb *scb) { … } void ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev, struct ahd_devinfo *devinfo, ahd_queue_alg alg) { … } int ahd_platform_abort_scbs(struct ahd_softc *ahd, int target, char channel, int lun, u_int tag, role_t role, uint32_t status) { … } static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd, struct ahd_devinfo *devinfo) { … } /* * Determines the queue depth for a given device. */ static void ahd_linux_device_queue_depth(struct scsi_device *sdev) { … } static int ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev, struct scsi_cmnd *cmd) { … } /* * SCSI controller interrupt handler. */ irqreturn_t ahd_linux_isr(int irq, void *dev_id) { … } void ahd_send_async(struct ahd_softc *ahd, char channel, u_int target, u_int lun, ac_code code) { … } /* * Calls the higher level scsi done function and frees the scb. */ void ahd_done(struct ahd_softc *ahd, struct scb *scb) { … } static void ahd_linux_handle_scsi_status(struct ahd_softc *ahd, struct scsi_device *sdev, struct scb *scb) { … } static void ahd_linux_queue_cmd_complete(struct ahd_softc *ahd, struct scsi_cmnd *cmd) { … } static void ahd_freeze_simq(struct ahd_softc *ahd) { … } static void ahd_release_simq(struct ahd_softc *ahd) { … } static int ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) { … } static void ahd_linux_set_width(struct scsi_target *starget, int width) { … } static void ahd_linux_set_period(struct scsi_target *starget, int period) { … } static void ahd_linux_set_offset(struct scsi_target *starget, int offset) { … } static void ahd_linux_set_dt(struct scsi_target *starget, int dt) { … } static void ahd_linux_set_qas(struct scsi_target *starget, int qas) { … } static void ahd_linux_set_iu(struct scsi_target *starget, int iu) { … } static void ahd_linux_set_rd_strm(struct scsi_target *starget, int rdstrm) { … } static void ahd_linux_set_wr_flow(struct scsi_target *starget, int wrflow) { … } static void ahd_linux_set_rti(struct scsi_target *starget, int rti) { … } static void ahd_linux_set_pcomp_en(struct scsi_target *starget, int pcomp) { … } static void ahd_linux_set_hold_mcs(struct scsi_target *starget, int hold) { … } static void ahd_linux_get_signalling(struct Scsi_Host *shost) { … } static struct spi_function_template ahd_linux_transport_functions = …; static int __init ahd_linux_init(void) { … } static void __exit ahd_linux_exit(void) { … } module_init(…) …; module_exit(ahd_linux_exit);
Codebase Browser
linux