Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | Low Level Linux Driver for the IBM Microchannel SCSI Subsystem for |
| 3 | Linux Kernel >= 2.4.0. |
| 4 | Copyright (c) 1995 Strom Systems, Inc. under the terms of the GNU |
| 5 | General Public License. Written by Martin Kolinek, December 1995. |
| 6 | Further development by: Chris Beauregard, Klaus Kudielka, Michael Lang |
| 7 | See the file Documentation/scsi/ibmmca.txt for a detailed description |
| 8 | of this driver, the commandline arguments and the history of its |
| 9 | development. |
| 10 | See the WWW-page: http://www.uni-mainz.de/~langm000/linux.html for latest |
| 11 | updates, info and ADF-files for adapters supported by this driver. |
| 12 | |
| 13 | Alan Cox <alan@redhat.com> |
| 14 | Updated for Linux 2.5.45 to use the new error handler, cleaned up the |
| 15 | lock macros and did a few unavoidable locking tweaks, plus one locking |
| 16 | fix in the irq and completion path. |
| 17 | |
| 18 | */ |
| 19 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/module.h> |
| 21 | #include <linux/kernel.h> |
| 22 | #include <linux/types.h> |
| 23 | #include <linux/ctype.h> |
| 24 | #include <linux/string.h> |
| 25 | #include <linux/interrupt.h> |
| 26 | #include <linux/ioport.h> |
| 27 | #include <linux/delay.h> |
| 28 | #include <linux/blkdev.h> |
| 29 | #include <linux/proc_fs.h> |
| 30 | #include <linux/stat.h> |
| 31 | #include <linux/mca.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | #include <linux/spinlock.h> |
| 33 | #include <linux/init.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
| 35 | #include <asm/system.h> |
| 36 | #include <asm/io.h> |
| 37 | |
| 38 | #include "scsi.h" |
| 39 | #include <scsi/scsi_host.h> |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 40 | |
| 41 | /* Common forward declarations for all Linux-versions: */ |
| 42 | static int ibmmca_queuecommand (Scsi_Cmnd *, void (*done) (Scsi_Cmnd *)); |
| 43 | static int ibmmca_abort (Scsi_Cmnd *); |
| 44 | static int ibmmca_host_reset (Scsi_Cmnd *); |
| 45 | static int ibmmca_biosparam (struct scsi_device *, struct block_device *, sector_t, int *); |
| 46 | static int ibmmca_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout); |
| 47 | |
| 48 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | |
| 50 | /* current version of this driver-source: */ |
| 51 | #define IBMMCA_SCSI_DRIVER_VERSION "4.0b-ac" |
| 52 | |
| 53 | /* driver configuration */ |
| 54 | #define IM_MAX_HOSTS 8 /* maximum number of host adapters */ |
| 55 | #define IM_RESET_DELAY 60 /* seconds allowed for a reset */ |
| 56 | |
| 57 | /* driver debugging - #undef all for normal operation */ |
| 58 | /* if defined: count interrupts and ignore this special one: */ |
| 59 | #undef IM_DEBUG_TIMEOUT //50 |
| 60 | #define TIMEOUT_PUN 0 |
| 61 | #define TIMEOUT_LUN 0 |
| 62 | /* verbose interrupt: */ |
| 63 | #undef IM_DEBUG_INT |
| 64 | /* verbose queuecommand: */ |
| 65 | #undef IM_DEBUG_CMD |
| 66 | /* verbose queucommand for specific SCSI-device type: */ |
| 67 | #undef IM_DEBUG_CMD_SPEC_DEV |
| 68 | /* verbose device probing */ |
| 69 | #undef IM_DEBUG_PROBE |
| 70 | |
| 71 | /* device type that shall be displayed on syslog (only during debugging): */ |
| 72 | #define IM_DEBUG_CMD_DEVICE TYPE_TAPE |
| 73 | |
| 74 | /* relative addresses of hardware registers on a subsystem */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 75 | #define IM_CMD_REG(h) ((h)->io_port) /*Command Interface, (4 bytes long) */ |
| 76 | #define IM_ATTN_REG(h) ((h)->io_port+4) /*Attention (1 byte) */ |
| 77 | #define IM_CTR_REG(h) ((h)->io_port+5) /*Basic Control (1 byte) */ |
| 78 | #define IM_INTR_REG(h) ((h)->io_port+6) /*Interrupt Status (1 byte, r/o) */ |
| 79 | #define IM_STAT_REG(h) ((h)->io_port+7) /*Basic Status (1 byte, read only) */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | |
| 81 | /* basic I/O-port of first adapter */ |
| 82 | #define IM_IO_PORT 0x3540 |
| 83 | /* maximum number of hosts that can be found */ |
| 84 | #define IM_N_IO_PORT 8 |
| 85 | |
| 86 | /*requests going into the upper nibble of the Attention register */ |
| 87 | /*note: the lower nibble specifies the device(0-14), or subsystem(15) */ |
| 88 | #define IM_IMM_CMD 0x10 /*immediate command */ |
| 89 | #define IM_SCB 0x30 /*Subsystem Control Block command */ |
| 90 | #define IM_LONG_SCB 0x40 /*long Subsystem Control Block command */ |
| 91 | #define IM_EOI 0xe0 /*end-of-interrupt request */ |
| 92 | |
| 93 | /*values for bits 7,1,0 of Basic Control reg. (bits 6-2 reserved) */ |
| 94 | #define IM_HW_RESET 0x80 /*hardware reset */ |
| 95 | #define IM_ENABLE_DMA 0x02 /*enable subsystem's busmaster DMA */ |
| 96 | #define IM_ENABLE_INTR 0x01 /*enable interrupts to the system */ |
| 97 | |
| 98 | /*to interpret the upper nibble of Interrupt Status register */ |
| 99 | /*note: the lower nibble specifies the device(0-14), or subsystem(15) */ |
| 100 | #define IM_SCB_CMD_COMPLETED 0x10 |
| 101 | #define IM_SCB_CMD_COMPLETED_WITH_RETRIES 0x50 |
| 102 | #define IM_LOOP_SCATTER_BUFFER_FULL 0x60 |
| 103 | #define IM_ADAPTER_HW_FAILURE 0x70 |
| 104 | #define IM_IMMEDIATE_CMD_COMPLETED 0xa0 |
| 105 | #define IM_CMD_COMPLETED_WITH_FAILURE 0xc0 |
| 106 | #define IM_CMD_ERROR 0xe0 |
| 107 | #define IM_SOFTWARE_SEQUENCING_ERROR 0xf0 |
| 108 | |
| 109 | /*to interpret bits 3-0 of Basic Status register (bits 7-4 reserved) */ |
| 110 | #define IM_CMD_REG_FULL 0x08 |
| 111 | #define IM_CMD_REG_EMPTY 0x04 |
| 112 | #define IM_INTR_REQUEST 0x02 |
| 113 | #define IM_BUSY 0x01 |
| 114 | |
| 115 | /*immediate commands (word written into low 2 bytes of command reg) */ |
| 116 | #define IM_RESET_IMM_CMD 0x0400 |
| 117 | #define IM_FEATURE_CTR_IMM_CMD 0x040c |
| 118 | #define IM_DMA_PACING_IMM_CMD 0x040d |
| 119 | #define IM_ASSIGN_IMM_CMD 0x040e |
| 120 | #define IM_ABORT_IMM_CMD 0x040f |
| 121 | #define IM_FORMAT_PREP_IMM_CMD 0x0417 |
| 122 | |
| 123 | /*SCB (Subsystem Control Block) structure */ |
| 124 | struct im_scb { |
| 125 | unsigned short command; /*command word (read, etc.) */ |
| 126 | unsigned short enable; /*enable word, modifies cmd */ |
| 127 | union { |
| 128 | unsigned long log_blk_adr; /*block address on SCSI device */ |
| 129 | unsigned char scsi_cmd_length; /*6,10,12, for other scsi cmd */ |
| 130 | } u1; |
| 131 | unsigned long sys_buf_adr; /*physical system memory adr */ |
| 132 | unsigned long sys_buf_length; /*size of sys mem buffer */ |
| 133 | unsigned long tsb_adr; /*Termination Status Block adr */ |
| 134 | unsigned long scb_chain_adr; /*optional SCB chain address */ |
| 135 | union { |
| 136 | struct { |
| 137 | unsigned short count; /*block count, on SCSI device */ |
| 138 | unsigned short length; /*block length, on SCSI device */ |
| 139 | } blk; |
| 140 | unsigned char scsi_command[12]; /*other scsi command */ |
| 141 | } u2; |
| 142 | }; |
| 143 | |
| 144 | /*structure scatter-gather element (for list of system memory areas) */ |
| 145 | struct im_sge { |
| 146 | void *address; |
| 147 | unsigned long byte_length; |
| 148 | }; |
| 149 | |
| 150 | /*structure returned by a get_pos_info command: */ |
| 151 | struct im_pos_info { |
| 152 | unsigned short pos_id; /* adapter id */ |
| 153 | unsigned char pos_3a; /* pos 3 (if pos 6 = 0) */ |
| 154 | unsigned char pos_2; /* pos 2 */ |
| 155 | unsigned char int_level; /* interrupt level IRQ 11 or 14 */ |
| 156 | unsigned char pos_4a; /* pos 4 (if pos 6 = 0) */ |
| 157 | unsigned short connector_size; /* MCA connector size: 16 or 32 Bit */ |
| 158 | unsigned char num_luns; /* number of supported luns per device */ |
| 159 | unsigned char num_puns; /* number of supported puns */ |
| 160 | unsigned char pacing_factor; /* pacing factor */ |
| 161 | unsigned char num_ldns; /* number of ldns available */ |
| 162 | unsigned char eoi_off; /* time EOI and interrupt inactive */ |
| 163 | unsigned char max_busy; /* time between reset and busy on */ |
| 164 | unsigned short cache_stat; /* ldn cachestat. Bit=1 = not cached */ |
| 165 | unsigned short retry_stat; /* retry status of ldns. Bit=1=disabled */ |
| 166 | unsigned char pos_4b; /* pos 4 (if pos 6 = 1) */ |
| 167 | unsigned char pos_3b; /* pos 3 (if pos 6 = 1) */ |
| 168 | unsigned char pos_6; /* pos 6 */ |
| 169 | unsigned char pos_5; /* pos 5 */ |
| 170 | unsigned short max_overlap; /* maximum overlapping requests */ |
| 171 | unsigned short num_bus; /* number of SCSI-busses */ |
| 172 | }; |
| 173 | |
| 174 | /*values for SCB command word */ |
| 175 | #define IM_NO_SYNCHRONOUS 0x0040 /*flag for any command */ |
| 176 | #define IM_NO_DISCONNECT 0x0080 /*flag for any command */ |
| 177 | #define IM_READ_DATA_CMD 0x1c01 |
| 178 | #define IM_WRITE_DATA_CMD 0x1c02 |
| 179 | #define IM_READ_VERIFY_CMD 0x1c03 |
| 180 | #define IM_WRITE_VERIFY_CMD 0x1c04 |
| 181 | #define IM_REQUEST_SENSE_CMD 0x1c08 |
| 182 | #define IM_READ_CAPACITY_CMD 0x1c09 |
| 183 | #define IM_DEVICE_INQUIRY_CMD 0x1c0b |
| 184 | #define IM_READ_LOGICAL_CMD 0x1c2a |
| 185 | #define IM_OTHER_SCSI_CMD_CMD 0x241f |
| 186 | |
| 187 | /* unused, but supported, SCB commands */ |
| 188 | #define IM_GET_COMMAND_COMPLETE_STATUS_CMD 0x1c07 /* command status */ |
| 189 | #define IM_GET_POS_INFO_CMD 0x1c0a /* returns neat stuff */ |
| 190 | #define IM_READ_PREFETCH_CMD 0x1c31 /* caching controller only */ |
| 191 | #define IM_FOMAT_UNIT_CMD 0x1c16 /* format unit */ |
| 192 | #define IM_REASSIGN_BLOCK_CMD 0x1c18 /* in case of error */ |
| 193 | |
| 194 | /*values to set bits in the enable word of SCB */ |
| 195 | #define IM_READ_CONTROL 0x8000 |
| 196 | #define IM_REPORT_TSB_ONLY_ON_ERROR 0x4000 |
| 197 | #define IM_RETRY_ENABLE 0x2000 |
| 198 | #define IM_POINTER_TO_LIST 0x1000 |
| 199 | #define IM_SUPRESS_EXCEPTION_SHORT 0x0400 |
| 200 | #define IM_BYPASS_BUFFER 0x0200 |
| 201 | #define IM_CHAIN_ON_NO_ERROR 0x0001 |
| 202 | |
| 203 | /*TSB (Termination Status Block) structure */ |
| 204 | struct im_tsb { |
| 205 | unsigned short end_status; |
| 206 | unsigned short reserved1; |
| 207 | unsigned long residual_byte_count; |
| 208 | unsigned long sg_list_element_adr; |
| 209 | unsigned short status_length; |
| 210 | unsigned char dev_status; |
| 211 | unsigned char cmd_status; |
| 212 | unsigned char dev_error; |
| 213 | unsigned char cmd_error; |
| 214 | unsigned short reserved2; |
| 215 | unsigned short reserved3; |
| 216 | unsigned short low_of_last_scb_adr; |
| 217 | unsigned short high_of_last_scb_adr; |
| 218 | }; |
| 219 | |
| 220 | /*subsystem uses interrupt request level 14 */ |
| 221 | #define IM_IRQ 14 |
| 222 | /*SCSI-2 F/W may evade to interrupt 11 */ |
| 223 | #define IM_IRQ_FW 11 |
| 224 | |
| 225 | /* Model 95 has an additional alphanumeric display, which can be used |
| 226 | to display SCSI-activities. 8595 models do not have any disk led, which |
| 227 | makes this feature quite useful. |
| 228 | The regular PS/2 disk led is turned on/off by bits 6,7 of system |
| 229 | control port. */ |
| 230 | |
| 231 | /* LED display-port (actually, last LED on display) */ |
| 232 | #define MOD95_LED_PORT 0x108 |
| 233 | /* system-control-register of PS/2s with diskindicator */ |
| 234 | #define PS2_SYS_CTR 0x92 |
| 235 | /* activity displaying methods */ |
| 236 | #define LED_DISP 1 |
| 237 | #define LED_ADISP 2 |
| 238 | #define LED_ACTIVITY 4 |
| 239 | /* failed intr */ |
| 240 | #define CMD_FAIL 255 |
| 241 | |
| 242 | /* The SCSI-ID(!) of the accessed SCSI-device is shown on PS/2-95 machines' LED |
| 243 | displays. ldn is no longer displayed here, because the ldn mapping is now |
| 244 | done dynamically and the ldn <-> pun,lun maps can be looked-up at boottime |
| 245 | or during uptime in /proc/scsi/ibmmca/<host_no> in case of trouble, |
| 246 | interest, debugging or just for having fun. The left number gives the |
| 247 | host-adapter number and the right shows the accessed SCSI-ID. */ |
| 248 | |
| 249 | /* display_mode is set by the ibmmcascsi= command line arg */ |
| 250 | static int display_mode = 0; |
| 251 | /* set default adapter timeout */ |
| 252 | static unsigned int adapter_timeout = 45; |
| 253 | /* for probing on feature-command: */ |
| 254 | static unsigned int global_command_error_excuse = 0; |
| 255 | /* global setting by command line for adapter_speed */ |
| 256 | static int global_adapter_speed = 0; /* full speed by default */ |
| 257 | |
| 258 | /* Panel / LED on, do it right for F/W addressin, too. adisplay will |
| 259 | * just ignore ids>7, as the panel has only 7 digits available */ |
| 260 | #define PS2_DISK_LED_ON(ad,id) { if (display_mode & LED_DISP) { if (id>9) \ |
| 261 | outw((ad+48)|((id+55)<<8), MOD95_LED_PORT ); else \ |
| 262 | outw((ad+48)|((id+48)<<8), MOD95_LED_PORT ); } else \ |
| 263 | if (display_mode & LED_ADISP) { if (id<7) outb((char)(id+48),MOD95_LED_PORT+1+id); \ |
| 264 | outb((char)(ad+48), MOD95_LED_PORT); } \ |
| 265 | if ((display_mode & LED_ACTIVITY)||(!display_mode)) \ |
| 266 | outb(inb(PS2_SYS_CTR) | 0xc0, PS2_SYS_CTR); } |
| 267 | |
| 268 | /* Panel / LED off */ |
| 269 | /* bug fixed, Dec 15, 1997, where | was replaced by & here */ |
| 270 | #define PS2_DISK_LED_OFF() { if (display_mode & LED_DISP) \ |
| 271 | outw(0x2020, MOD95_LED_PORT ); else if (display_mode & LED_ADISP) { \ |
| 272 | outl(0x20202020,MOD95_LED_PORT); outl(0x20202020,MOD95_LED_PORT+4); } \ |
| 273 | if ((display_mode & LED_ACTIVITY)||(!display_mode)) \ |
| 274 | outb(inb(PS2_SYS_CTR) & 0x3f, PS2_SYS_CTR); } |
| 275 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | /* types of different supported hardware that goes to hostdata special */ |
| 277 | #define IBM_SCSI2_FW 0 |
| 278 | #define IBM_7568_WCACHE 1 |
| 279 | #define IBM_EXP_UNIT 2 |
| 280 | #define IBM_SCSI_WCACHE 3 |
| 281 | #define IBM_SCSI 4 |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 282 | #define IBM_INTEGSCSI 5 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | |
| 284 | /* other special flags for hostdata structure */ |
| 285 | #define FORCED_DETECTION 100 |
| 286 | #define INTEGRATED_SCSI 101 |
| 287 | |
| 288 | /* List of possible IBM-SCSI-adapters */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 289 | static short ibmmca_id_table[] = { |
| 290 | 0x8efc, |
| 291 | 0x8efd, |
| 292 | 0x8ef8, |
| 293 | 0x8eff, |
| 294 | 0x8efe, |
| 295 | /* No entry for integrated SCSI, that's part of the register */ |
| 296 | 0 |
| 297 | }; |
| 298 | |
| 299 | static const char *ibmmca_description[] = { |
| 300 | "IBM SCSI-2 F/W Adapter", /* special = 0 */ |
| 301 | "IBM 7568 Industrial Computer SCSI Adapter w/Cache", /* special = 1 */ |
| 302 | "IBM Expansion Unit SCSI Controller", /* special = 2 */ |
| 303 | "IBM SCSI Adapter w/Cache", /* special = 3 */ |
| 304 | "IBM SCSI Adapter", /* special = 4 */ |
| 305 | "IBM Integrated SCSI Controller", /* special = 5 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | }; |
| 307 | |
| 308 | /* Max number of logical devices (can be up from 0 to 14). 15 is the address |
| 309 | of the adapter itself. */ |
| 310 | #define MAX_LOG_DEV 15 |
| 311 | |
| 312 | /*local data for a logical device */ |
| 313 | struct logical_device { |
| 314 | struct im_scb scb; /* SCSI-subsystem-control-block structure */ |
| 315 | struct im_tsb tsb; /* SCSI command complete status block structure */ |
| 316 | struct im_sge sge[16]; /* scatter gather list structure */ |
| 317 | unsigned char buf[256]; /* SCSI command return data buffer */ |
| 318 | Scsi_Cmnd *cmd; /* SCSI-command that is currently in progress */ |
| 319 | int device_type; /* type of the SCSI-device. See include/scsi/scsi.h |
| 320 | for interpretation of the possible values */ |
| 321 | int block_length; /* blocksize of a particular logical SCSI-device */ |
| 322 | int cache_flag; /* 1 if this is uncached, 0 if cache is present for ldn */ |
| 323 | int retry_flag; /* 1 if adapter retry is disabled, 0 if enabled */ |
| 324 | }; |
| 325 | |
| 326 | /* statistics of the driver during operations (for proc_info) */ |
| 327 | struct Driver_Statistics { |
| 328 | /* SCSI statistics on the adapter */ |
| 329 | int ldn_access[MAX_LOG_DEV + 1]; /* total accesses on a ldn */ |
| 330 | int ldn_read_access[MAX_LOG_DEV + 1]; /* total read-access on a ldn */ |
| 331 | int ldn_write_access[MAX_LOG_DEV + 1]; /* total write-access on a ldn */ |
| 332 | int ldn_inquiry_access[MAX_LOG_DEV + 1]; /* total inquiries on a ldn */ |
| 333 | int ldn_modeselect_access[MAX_LOG_DEV + 1]; /* total mode selects on ldn */ |
| 334 | int scbs; /* short SCBs queued */ |
| 335 | int long_scbs; /* long SCBs queued */ |
| 336 | int total_accesses; /* total accesses on all ldns */ |
| 337 | int total_interrupts; /* total interrupts (should be |
| 338 | same as total_accesses) */ |
| 339 | int total_errors; /* command completed with error */ |
| 340 | /* dynamical assignment statistics */ |
| 341 | int total_scsi_devices; /* number of physical pun,lun */ |
| 342 | int dyn_flag; /* flag showing dynamical mode */ |
| 343 | int dynamical_assignments; /* number of remappings of ldns */ |
| 344 | int ldn_assignments[MAX_LOG_DEV + 1]; /* number of remappings of each |
| 345 | ldn */ |
| 346 | }; |
| 347 | |
| 348 | /* data structure for each host adapter */ |
| 349 | struct ibmmca_hostdata { |
| 350 | /* array of logical devices: */ |
| 351 | struct logical_device _ld[MAX_LOG_DEV + 1]; |
| 352 | /* array to convert (pun, lun) into logical device number: */ |
| 353 | unsigned char _get_ldn[16][8]; |
| 354 | /*array that contains the information about the physical SCSI-devices |
| 355 | attached to this host adapter: */ |
| 356 | unsigned char _get_scsi[16][8]; |
| 357 | /* used only when checking logical devices: */ |
| 358 | int _local_checking_phase_flag; |
| 359 | /* report received interrupt: */ |
| 360 | int _got_interrupt; |
| 361 | /* report termination-status of SCSI-command: */ |
| 362 | int _stat_result; |
| 363 | /* reset status (used only when doing reset): */ |
| 364 | int _reset_status; |
| 365 | /* code of the last SCSI command (needed for panic info): */ |
| 366 | int _last_scsi_command[MAX_LOG_DEV + 1]; |
| 367 | /* identifier of the last SCSI-command type */ |
| 368 | int _last_scsi_type[MAX_LOG_DEV + 1]; |
| 369 | /* last blockcount */ |
| 370 | int _last_scsi_blockcount[MAX_LOG_DEV + 1]; |
| 371 | /* last locgical block address */ |
| 372 | unsigned long _last_scsi_logical_block[MAX_LOG_DEV + 1]; |
| 373 | /* Counter that points on the next reassignable ldn for dynamical |
| 374 | remapping. The default value is 7, that is the first reassignable |
| 375 | number in the list at boottime: */ |
| 376 | int _next_ldn; |
| 377 | /* Statistics-structure for this IBM-SCSI-host: */ |
| 378 | struct Driver_Statistics _IBM_DS; |
| 379 | /* This hostadapters pos-registers pos2 until pos6 */ |
| 380 | unsigned int _pos[8]; |
| 381 | /* assign a special variable, that contains dedicated info about the |
| 382 | adaptertype */ |
| 383 | int _special; |
| 384 | /* connector size on the MCA bus */ |
| 385 | int _connector_size; |
| 386 | /* synchronous SCSI transfer rate bitpattern */ |
| 387 | int _adapter_speed; |
| 388 | }; |
| 389 | |
| 390 | /* macros to access host data structure */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 391 | #define subsystem_pun(h) ((h)->this_id) |
| 392 | #define subsystem_maxid(h) ((h)->max_id) |
| 393 | #define ld(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_ld) |
| 394 | #define get_ldn(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_get_ldn) |
| 395 | #define get_scsi(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_get_scsi) |
| 396 | #define local_checking_phase_flag(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_local_checking_phase_flag) |
| 397 | #define got_interrupt(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_got_interrupt) |
| 398 | #define stat_result(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_stat_result) |
| 399 | #define reset_status(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_reset_status) |
| 400 | #define last_scsi_command(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_command) |
| 401 | #define last_scsi_type(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_type) |
| 402 | #define last_scsi_blockcount(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_blockcount) |
| 403 | #define last_scsi_logical_block(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_logical_block) |
| 404 | #define last_scsi_type(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_last_scsi_type) |
| 405 | #define next_ldn(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_next_ldn) |
| 406 | #define IBM_DS(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_IBM_DS) |
| 407 | #define special(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_special) |
| 408 | #define subsystem_connector_size(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_connector_size) |
| 409 | #define adapter_speed(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_adapter_speed) |
| 410 | #define pos2(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[2]) |
| 411 | #define pos3(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[3]) |
| 412 | #define pos4(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[4]) |
| 413 | #define pos5(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[5]) |
| 414 | #define pos6(h) (((struct ibmmca_hostdata *) (h)->hostdata)->_pos[6]) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | |
| 416 | /* Define a arbitrary number as subsystem-marker-type. This number is, as |
| 417 | described in the ANSI-SCSI-standard, not occupied by other device-types. */ |
| 418 | #define TYPE_IBM_SCSI_ADAPTER 0x2F |
| 419 | |
| 420 | /* Define 0xFF for no device type, because this type is not defined within |
| 421 | the ANSI-SCSI-standard, therefore, it can be used and should not cause any |
| 422 | harm. */ |
| 423 | #define TYPE_NO_DEVICE 0xFF |
| 424 | |
| 425 | /* define medium-changer. If this is not defined previously, e.g. Linux |
| 426 | 2.0.x, define this type here. */ |
| 427 | #ifndef TYPE_MEDIUM_CHANGER |
| 428 | #define TYPE_MEDIUM_CHANGER 0x08 |
| 429 | #endif |
| 430 | |
| 431 | /* define possible operations for the immediate_assign command */ |
| 432 | #define SET_LDN 0 |
| 433 | #define REMOVE_LDN 1 |
| 434 | |
| 435 | /* ldn which is used to probe the SCSI devices */ |
| 436 | #define PROBE_LDN 0 |
| 437 | |
| 438 | /* reset status flag contents */ |
| 439 | #define IM_RESET_NOT_IN_PROGRESS 0 |
| 440 | #define IM_RESET_IN_PROGRESS 1 |
| 441 | #define IM_RESET_FINISHED_OK 2 |
| 442 | #define IM_RESET_FINISHED_FAIL 3 |
| 443 | #define IM_RESET_NOT_IN_PROGRESS_NO_INT 4 |
| 444 | #define IM_RESET_FINISHED_OK_NO_INT 5 |
| 445 | |
| 446 | /* define undefined SCSI-command */ |
| 447 | #define NO_SCSI 0xffff |
| 448 | |
| 449 | /*-----------------------------------------------------------------------*/ |
| 450 | |
| 451 | /* if this is nonzero, ibmmcascsi option has been passed to the kernel */ |
| 452 | static int io_port[IM_MAX_HOSTS] = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| 453 | static int scsi_id[IM_MAX_HOSTS] = { 7, 7, 7, 7, 7, 7, 7, 7 }; |
| 454 | |
| 455 | /* fill module-parameters only, when this define is present. |
| 456 | (that is kernel version 2.1.x) */ |
| 457 | #if defined(MODULE) |
| 458 | static char *boot_options = NULL; |
| 459 | module_param(boot_options, charp, 0); |
| 460 | module_param_array(io_port, int, NULL, 0); |
| 461 | module_param_array(scsi_id, int, NULL, 0); |
| 462 | |
Randy.Dunlap | d39a942 | 2005-09-13 21:43:56 -0700 | [diff] [blame] | 463 | MODULE_LICENSE("GPL"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | #endif |
| 465 | /*counter of concurrent disk read/writes, to turn on/off disk led */ |
| 466 | static int disk_rw_in_progress = 0; |
| 467 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | static unsigned int pos[8]; /* whole pos register-line for diagnosis */ |
| 469 | /* Taking into account the additions, made by ZP Gu. |
| 470 | * This selects now the preset value from the configfile and |
| 471 | * offers the 'normal' commandline option to be accepted */ |
| 472 | #ifdef CONFIG_IBMMCA_SCSI_ORDER_STANDARD |
| 473 | static char ibm_ansi_order = 1; |
| 474 | #else |
| 475 | static char ibm_ansi_order = 0; |
| 476 | #endif |
| 477 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 478 | static void issue_cmd(struct Scsi_Host *, unsigned long, unsigned char); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | static void internal_done(Scsi_Cmnd * cmd); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 480 | static void check_devices(struct Scsi_Host *, int); |
| 481 | static int immediate_assign(struct Scsi_Host *, unsigned int, unsigned int, unsigned int, unsigned int); |
| 482 | static int immediate_feature(struct Scsi_Host *, unsigned int, unsigned int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | #ifdef CONFIG_IBMMCA_SCSI_DEV_RESET |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 484 | static int immediate_reset(struct Scsi_Host *, unsigned int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | #endif |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 486 | static int device_inquiry(struct Scsi_Host *, int); |
| 487 | static int read_capacity(struct Scsi_Host *, int); |
| 488 | static int get_pos_info(struct Scsi_Host *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | static char *ti_p(int); |
| 490 | static char *ti_l(int); |
| 491 | static char *ibmrate(unsigned int, int); |
| 492 | static int probe_display(int); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 493 | static int probe_bus_mode(struct Scsi_Host *); |
| 494 | static int device_exists(struct Scsi_Host *, int, int *, int *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | static int option_setup(char *); |
| 496 | /* local functions needed for proc_info */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 497 | static int ldn_access_load(struct Scsi_Host *, int); |
| 498 | static int ldn_access_total_read_write(struct Scsi_Host *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 500 | static irqreturn_t interrupt_handler(int irq, void *dev_id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 502 | unsigned int intr_reg; |
| 503 | unsigned int cmd_result; |
| 504 | unsigned int ldn; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 505 | unsigned long flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | Scsi_Cmnd *cmd; |
| 507 | int lastSCSI; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 508 | struct device *dev = dev_id; |
| 509 | struct Scsi_Host *shpnt = dev_get_drvdata(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 510 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 511 | spin_lock_irqsave(shpnt->host_lock, flags); |
| 512 | |
| 513 | if(!(inb(IM_STAT_REG(shpnt)) & IM_INTR_REQUEST)) { |
| 514 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 515 | return IRQ_NONE; |
| 516 | } |
| 517 | |
| 518 | /* the reset-function already did all the job, even ints got |
| 519 | renabled on the subsystem, so just return */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 520 | if ((reset_status(shpnt) == IM_RESET_NOT_IN_PROGRESS_NO_INT) || (reset_status(shpnt) == IM_RESET_FINISHED_OK_NO_INT)) { |
| 521 | reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS; |
| 522 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | return IRQ_HANDLED; |
| 524 | } |
| 525 | |
| 526 | /*must wait for attention reg not busy, then send EOI to subsystem */ |
| 527 | while (1) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 528 | if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 529 | break; |
| 530 | cpu_relax(); |
| 531 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 532 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 533 | /*get command result and logical device */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 534 | intr_reg = (unsigned char) (inb(IM_INTR_REG(shpnt))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | cmd_result = intr_reg & 0xf0; |
| 536 | ldn = intr_reg & 0x0f; |
| 537 | /* get the last_scsi_command here */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 538 | lastSCSI = last_scsi_command(shpnt)[ldn]; |
| 539 | outb(IM_EOI | ldn, IM_ATTN_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 540 | |
| 541 | /*these should never happen (hw fails, or a local programming bug) */ |
| 542 | if (!global_command_error_excuse) { |
| 543 | switch (cmd_result) { |
| 544 | /* Prevent from Ooopsing on error to show the real reason */ |
| 545 | case IM_ADAPTER_HW_FAILURE: |
| 546 | case IM_SOFTWARE_SEQUENCING_ERROR: |
| 547 | case IM_CMD_ERROR: |
| 548 | printk(KERN_ERR "IBM MCA SCSI: Fatal Subsystem ERROR!\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 549 | printk(KERN_ERR " Last cmd=0x%x, ena=%x, len=", lastSCSI, ld(shpnt)[ldn].scb.enable); |
| 550 | if (ld(shpnt)[ldn].cmd) |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 551 | printk("%ld/%ld,", (long) (scsi_bufflen(ld(shpnt)[ldn].cmd)), (long) (ld(shpnt)[ldn].scb.sys_buf_length)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 552 | else |
| 553 | printk("none,"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 554 | if (ld(shpnt)[ldn].cmd) |
| 555 | printk("Blocksize=%d", ld(shpnt)[ldn].scb.u2.blk.length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | else |
| 557 | printk("Blocksize=none"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 558 | printk(", host=%p, ldn=0x%x\n", shpnt, ldn); |
| 559 | if (ld(shpnt)[ldn].cmd) { |
| 560 | printk(KERN_ERR "Blockcount=%d/%d\n", last_scsi_blockcount(shpnt)[ldn], ld(shpnt)[ldn].scb.u2.blk.count); |
| 561 | printk(KERN_ERR "Logical block=%lx/%lx\n", last_scsi_logical_block(shpnt)[ldn], ld(shpnt)[ldn].scb.u1.log_blk_adr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 562 | } |
| 563 | printk(KERN_ERR "Reason given: %s\n", (cmd_result == IM_ADAPTER_HW_FAILURE) ? "HARDWARE FAILURE" : (cmd_result == IM_SOFTWARE_SEQUENCING_ERROR) ? "SOFTWARE SEQUENCING ERROR" : (cmd_result == IM_CMD_ERROR) ? "COMMAND ERROR" : "UNKNOWN"); |
| 564 | /* if errors appear, enter this section to give detailed info */ |
| 565 | printk(KERN_ERR "IBM MCA SCSI: Subsystem Error-Status follows:\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 566 | printk(KERN_ERR " Command Type................: %x\n", last_scsi_type(shpnt)[ldn]); |
| 567 | printk(KERN_ERR " Attention Register..........: %x\n", inb(IM_ATTN_REG(shpnt))); |
| 568 | printk(KERN_ERR " Basic Control Register......: %x\n", inb(IM_CTR_REG(shpnt))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 569 | printk(KERN_ERR " Interrupt Status Register...: %x\n", intr_reg); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 570 | printk(KERN_ERR " Basic Status Register.......: %x\n", inb(IM_STAT_REG(shpnt))); |
| 571 | if ((last_scsi_type(shpnt)[ldn] == IM_SCB) || (last_scsi_type(shpnt)[ldn] == IM_LONG_SCB)) { |
| 572 | printk(KERN_ERR " SCB-Command.................: %x\n", ld(shpnt)[ldn].scb.command); |
| 573 | printk(KERN_ERR " SCB-Enable..................: %x\n", ld(shpnt)[ldn].scb.enable); |
| 574 | printk(KERN_ERR " SCB-logical block address...: %lx\n", ld(shpnt)[ldn].scb.u1.log_blk_adr); |
| 575 | printk(KERN_ERR " SCB-system buffer address...: %lx\n", ld(shpnt)[ldn].scb.sys_buf_adr); |
| 576 | printk(KERN_ERR " SCB-system buffer length....: %lx\n", ld(shpnt)[ldn].scb.sys_buf_length); |
| 577 | printk(KERN_ERR " SCB-tsb address.............: %lx\n", ld(shpnt)[ldn].scb.tsb_adr); |
| 578 | printk(KERN_ERR " SCB-Chain address...........: %lx\n", ld(shpnt)[ldn].scb.scb_chain_adr); |
| 579 | printk(KERN_ERR " SCB-block count.............: %x\n", ld(shpnt)[ldn].scb.u2.blk.count); |
| 580 | printk(KERN_ERR " SCB-block length............: %x\n", ld(shpnt)[ldn].scb.u2.blk.length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 581 | } |
| 582 | printk(KERN_ERR " Send this report to the maintainer.\n"); |
| 583 | panic("IBM MCA SCSI: Fatal error message from the subsystem (0x%X,0x%X)!\n", lastSCSI, cmd_result); |
| 584 | break; |
| 585 | } |
| 586 | } else { |
| 587 | /* The command error handling is made silent, but we tell the |
| 588 | * calling function, that there is a reported error from the |
| 589 | * adapter. */ |
| 590 | switch (cmd_result) { |
| 591 | case IM_ADAPTER_HW_FAILURE: |
| 592 | case IM_SOFTWARE_SEQUENCING_ERROR: |
| 593 | case IM_CMD_ERROR: |
| 594 | global_command_error_excuse = CMD_FAIL; |
| 595 | break; |
| 596 | default: |
| 597 | global_command_error_excuse = 0; |
| 598 | break; |
| 599 | } |
| 600 | } |
| 601 | /* if no panic appeared, increase the interrupt-counter */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 602 | IBM_DS(shpnt).total_interrupts++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 603 | /*only for local checking phase */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 604 | if (local_checking_phase_flag(shpnt)) { |
| 605 | stat_result(shpnt) = cmd_result; |
| 606 | got_interrupt(shpnt) = 1; |
| 607 | reset_status(shpnt) = IM_RESET_FINISHED_OK; |
| 608 | last_scsi_command(shpnt)[ldn] = NO_SCSI; |
| 609 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | return IRQ_HANDLED; |
| 611 | } |
| 612 | /* handling of commands coming from upper level of scsi driver */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 613 | if (last_scsi_type(shpnt)[ldn] == IM_IMM_CMD) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 614 | /* verify ldn, and may handle rare reset immediate command */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 615 | if ((reset_status(shpnt) == IM_RESET_IN_PROGRESS) && (last_scsi_command(shpnt)[ldn] == IM_RESET_IMM_CMD)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 616 | if (cmd_result == IM_CMD_COMPLETED_WITH_FAILURE) { |
| 617 | disk_rw_in_progress = 0; |
| 618 | PS2_DISK_LED_OFF(); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 619 | reset_status(shpnt) = IM_RESET_FINISHED_FAIL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 620 | } else { |
| 621 | /*reset disk led counter, turn off disk led */ |
| 622 | disk_rw_in_progress = 0; |
| 623 | PS2_DISK_LED_OFF(); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 624 | reset_status(shpnt) = IM_RESET_FINISHED_OK; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 625 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 626 | stat_result(shpnt) = cmd_result; |
| 627 | last_scsi_command(shpnt)[ldn] = NO_SCSI; |
| 628 | last_scsi_type(shpnt)[ldn] = 0; |
| 629 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 630 | return IRQ_HANDLED; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 631 | } else if (last_scsi_command(shpnt)[ldn] == IM_ABORT_IMM_CMD) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 632 | /* react on SCSI abort command */ |
| 633 | #ifdef IM_DEBUG_PROBE |
| 634 | printk("IBM MCA SCSI: Interrupt from SCSI-abort.\n"); |
| 635 | #endif |
| 636 | disk_rw_in_progress = 0; |
| 637 | PS2_DISK_LED_OFF(); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 638 | cmd = ld(shpnt)[ldn].cmd; |
| 639 | ld(shpnt)[ldn].cmd = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 640 | if (cmd_result == IM_CMD_COMPLETED_WITH_FAILURE) |
| 641 | cmd->result = DID_NO_CONNECT << 16; |
| 642 | else |
| 643 | cmd->result = DID_ABORT << 16; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 644 | stat_result(shpnt) = cmd_result; |
| 645 | last_scsi_command(shpnt)[ldn] = NO_SCSI; |
| 646 | last_scsi_type(shpnt)[ldn] = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 647 | if (cmd->scsi_done) |
| 648 | (cmd->scsi_done) (cmd); /* should be the internal_done */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 649 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 650 | return IRQ_HANDLED; |
| 651 | } else { |
| 652 | disk_rw_in_progress = 0; |
| 653 | PS2_DISK_LED_OFF(); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 654 | reset_status(shpnt) = IM_RESET_FINISHED_OK; |
| 655 | stat_result(shpnt) = cmd_result; |
| 656 | last_scsi_command(shpnt)[ldn] = NO_SCSI; |
| 657 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 658 | return IRQ_HANDLED; |
| 659 | } |
| 660 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 661 | last_scsi_command(shpnt)[ldn] = NO_SCSI; |
| 662 | last_scsi_type(shpnt)[ldn] = 0; |
| 663 | cmd = ld(shpnt)[ldn].cmd; |
| 664 | ld(shpnt)[ldn].cmd = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 665 | #ifdef IM_DEBUG_TIMEOUT |
| 666 | if (cmd) { |
| 667 | if ((cmd->target == TIMEOUT_PUN) && (cmd->device->lun == TIMEOUT_LUN)) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 668 | spin_unlock_irqsave(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 669 | printk("IBM MCA SCSI: Ignoring interrupt from pun=%x, lun=%x.\n", cmd->target, cmd->device->lun); |
| 670 | return IRQ_HANDLED; |
| 671 | } |
| 672 | } |
| 673 | #endif |
| 674 | /*if no command structure, just return, else clear cmd */ |
| 675 | if (!cmd) |
| 676 | { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 677 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 678 | return IRQ_HANDLED; |
| 679 | } |
| 680 | |
| 681 | #ifdef IM_DEBUG_INT |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 682 | printk("cmd=%02x ireg=%02x ds=%02x cs=%02x de=%02x ce=%02x\n", cmd->cmnd[0], intr_reg, ld(shpnt)[ldn].tsb.dev_status, ld(shpnt)[ldn].tsb.cmd_status, ld(shpnt)[ldn].tsb.dev_error, ld(shpnt)[ldn].tsb.cmd_error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 683 | #endif |
| 684 | /*if this is end of media read/write, may turn off PS/2 disk led */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 685 | if ((ld(shpnt)[ldn].device_type != TYPE_NO_LUN) && (ld(shpnt)[ldn].device_type != TYPE_NO_DEVICE)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 686 | /* only access this, if there was a valid device addressed */ |
| 687 | if (--disk_rw_in_progress == 0) |
| 688 | PS2_DISK_LED_OFF(); |
| 689 | } |
| 690 | |
| 691 | /* IBM describes the status-mask to be 0x1e, but this is not conform |
| 692 | * with SCSI-definition, I suppose, the reason for it is that IBM |
| 693 | * adapters do not support CMD_TERMINATED, TASK_SET_FULL and |
| 694 | * ACA_ACTIVE as returning statusbyte information. (ML) */ |
| 695 | if (cmd_result == IM_CMD_COMPLETED_WITH_FAILURE) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 696 | cmd->result = (unsigned char) (ld(shpnt)[ldn].tsb.dev_status & 0x1e); |
| 697 | IBM_DS(shpnt).total_errors++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 698 | } else |
| 699 | cmd->result = 0; |
| 700 | /* write device status into cmd->result, and call done function */ |
| 701 | if (lastSCSI == NO_SCSI) { /* unexpected interrupt :-( */ |
| 702 | cmd->result |= DID_BAD_INTR << 16; |
| 703 | printk("IBM MCA SCSI: WARNING - Interrupt from non-pending SCSI-command!\n"); |
| 704 | } else /* things went right :-) */ |
| 705 | cmd->result |= DID_OK << 16; |
| 706 | if (cmd->scsi_done) |
| 707 | (cmd->scsi_done) (cmd); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 708 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 709 | return IRQ_HANDLED; |
| 710 | } |
| 711 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 712 | static void issue_cmd(struct Scsi_Host *shpnt, unsigned long cmd_reg, |
| 713 | unsigned char attn_reg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 714 | { |
| 715 | unsigned long flags; |
| 716 | /* must wait for attention reg not busy */ |
| 717 | while (1) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 718 | spin_lock_irqsave(shpnt->host_lock, flags); |
| 719 | if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 720 | break; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 721 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 722 | } |
| 723 | /* write registers and enable system interrupts */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 724 | outl(cmd_reg, IM_CMD_REG(shpnt)); |
| 725 | outb(attn_reg, IM_ATTN_REG(shpnt)); |
| 726 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 727 | } |
| 728 | |
| 729 | static void internal_done(Scsi_Cmnd * cmd) |
| 730 | { |
| 731 | cmd->SCp.Status++; |
| 732 | return; |
| 733 | } |
| 734 | |
| 735 | /* SCSI-SCB-command for device_inquiry */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 736 | static int device_inquiry(struct Scsi_Host *shpnt, int ldn) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 737 | { |
| 738 | int retr; |
| 739 | struct im_scb *scb; |
| 740 | struct im_tsb *tsb; |
| 741 | unsigned char *buf; |
| 742 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 743 | scb = &(ld(shpnt)[ldn].scb); |
| 744 | tsb = &(ld(shpnt)[ldn].tsb); |
| 745 | buf = (unsigned char *) (&(ld(shpnt)[ldn].buf)); |
| 746 | ld(shpnt)[ldn].tsb.dev_status = 0; /* prepare statusblock */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 747 | for (retr = 0; retr < 3; retr++) { |
| 748 | /* fill scb with inquiry command */ |
| 749 | scb->command = IM_DEVICE_INQUIRY_CMD | IM_NO_DISCONNECT; |
| 750 | scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_RETRY_ENABLE | IM_BYPASS_BUFFER; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 751 | last_scsi_command(shpnt)[ldn] = IM_DEVICE_INQUIRY_CMD; |
| 752 | last_scsi_type(shpnt)[ldn] = IM_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 753 | scb->sys_buf_adr = isa_virt_to_bus(buf); |
| 754 | scb->sys_buf_length = 255; /* maximum bufferlength gives max info */ |
| 755 | scb->tsb_adr = isa_virt_to_bus(tsb); |
| 756 | /* issue scb to passed ldn, and busy wait for interrupt */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 757 | got_interrupt(shpnt) = 0; |
| 758 | issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn); |
| 759 | while (!got_interrupt(shpnt)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 760 | barrier(); |
| 761 | |
Andreas Mohr | d6e05ed | 2006-06-26 18:35:02 +0200 | [diff] [blame] | 762 | /*if command successful, break */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 763 | if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 764 | return 1; |
| 765 | } |
| 766 | /*if all three retries failed, return "no device at this ldn" */ |
| 767 | if (retr >= 3) |
| 768 | return 0; |
| 769 | else |
| 770 | return 1; |
| 771 | } |
| 772 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 773 | static int read_capacity(struct Scsi_Host *shpnt, int ldn) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 774 | { |
| 775 | int retr; |
| 776 | struct im_scb *scb; |
| 777 | struct im_tsb *tsb; |
| 778 | unsigned char *buf; |
| 779 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 780 | scb = &(ld(shpnt)[ldn].scb); |
| 781 | tsb = &(ld(shpnt)[ldn].tsb); |
| 782 | buf = (unsigned char *) (&(ld(shpnt)[ldn].buf)); |
| 783 | ld(shpnt)[ldn].tsb.dev_status = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 784 | for (retr = 0; retr < 3; retr++) { |
| 785 | /*fill scb with read capacity command */ |
| 786 | scb->command = IM_READ_CAPACITY_CMD; |
| 787 | scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_READ_CONTROL | IM_RETRY_ENABLE | IM_BYPASS_BUFFER; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 788 | last_scsi_command(shpnt)[ldn] = IM_READ_CAPACITY_CMD; |
| 789 | last_scsi_type(shpnt)[ldn] = IM_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 790 | scb->sys_buf_adr = isa_virt_to_bus(buf); |
| 791 | scb->sys_buf_length = 8; |
| 792 | scb->tsb_adr = isa_virt_to_bus(tsb); |
| 793 | /*issue scb to passed ldn, and busy wait for interrupt */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 794 | got_interrupt(shpnt) = 0; |
| 795 | issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn); |
| 796 | while (!got_interrupt(shpnt)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 797 | barrier(); |
| 798 | |
| 799 | /*if got capacity, get block length and return one device found */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 800 | if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 801 | return 1; |
| 802 | } |
| 803 | /*if all three retries failed, return "no device at this ldn" */ |
| 804 | if (retr >= 3) |
| 805 | return 0; |
| 806 | else |
| 807 | return 1; |
| 808 | } |
| 809 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 810 | static int get_pos_info(struct Scsi_Host *shpnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 811 | { |
| 812 | int retr; |
| 813 | struct im_scb *scb; |
| 814 | struct im_tsb *tsb; |
| 815 | unsigned char *buf; |
| 816 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 817 | scb = &(ld(shpnt)[MAX_LOG_DEV].scb); |
| 818 | tsb = &(ld(shpnt)[MAX_LOG_DEV].tsb); |
| 819 | buf = (unsigned char *) (&(ld(shpnt)[MAX_LOG_DEV].buf)); |
| 820 | ld(shpnt)[MAX_LOG_DEV].tsb.dev_status = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 821 | for (retr = 0; retr < 3; retr++) { |
| 822 | /*fill scb with get_pos_info command */ |
| 823 | scb->command = IM_GET_POS_INFO_CMD; |
| 824 | scb->enable = IM_READ_CONTROL | IM_REPORT_TSB_ONLY_ON_ERROR | IM_RETRY_ENABLE | IM_BYPASS_BUFFER; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 825 | last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_GET_POS_INFO_CMD; |
| 826 | last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 827 | scb->sys_buf_adr = isa_virt_to_bus(buf); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 828 | if (special(shpnt) == IBM_SCSI2_FW) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 829 | scb->sys_buf_length = 256; /* get all info from F/W adapter */ |
| 830 | else |
| 831 | scb->sys_buf_length = 18; /* get exactly 18 bytes for other SCSI */ |
| 832 | scb->tsb_adr = isa_virt_to_bus(tsb); |
| 833 | /*issue scb to ldn=15, and busy wait for interrupt */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 834 | got_interrupt(shpnt) = 0; |
| 835 | issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | MAX_LOG_DEV); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 836 | |
| 837 | /* FIXME: timeout */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 838 | while (!got_interrupt(shpnt)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 839 | barrier(); |
| 840 | |
| 841 | /*if got POS-stuff, get block length and return one device found */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 842 | if ((stat_result(shpnt) == IM_SCB_CMD_COMPLETED) || (stat_result(shpnt) == IM_SCB_CMD_COMPLETED_WITH_RETRIES)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 843 | return 1; |
| 844 | } |
| 845 | /* if all three retries failed, return "no device at this ldn" */ |
| 846 | if (retr >= 3) |
| 847 | return 0; |
| 848 | else |
| 849 | return 1; |
| 850 | } |
| 851 | |
| 852 | /* SCSI-immediate-command for assign. This functions maps/unmaps specific |
| 853 | ldn-numbers on SCSI (PUN,LUN). It is needed for presetting of the |
| 854 | subsystem and for dynamical remapping od ldns. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 855 | static int immediate_assign(struct Scsi_Host *shpnt, unsigned int pun, |
| 856 | unsigned int lun, unsigned int ldn, |
| 857 | unsigned int operation) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 858 | { |
| 859 | int retr; |
| 860 | unsigned long imm_cmd; |
| 861 | |
| 862 | for (retr = 0; retr < 3; retr++) { |
| 863 | /* select mutation level of the SCSI-adapter */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 864 | switch (special(shpnt)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 865 | case IBM_SCSI2_FW: |
| 866 | imm_cmd = (unsigned long) (IM_ASSIGN_IMM_CMD); |
| 867 | imm_cmd |= (unsigned long) ((lun & 7) << 24); |
| 868 | imm_cmd |= (unsigned long) ((operation & 1) << 23); |
| 869 | imm_cmd |= (unsigned long) ((pun & 7) << 20) | ((pun & 8) << 24); |
| 870 | imm_cmd |= (unsigned long) ((ldn & 15) << 16); |
| 871 | break; |
| 872 | default: |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 873 | imm_cmd = inl(IM_CMD_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 874 | imm_cmd &= (unsigned long) (0xF8000000); /* keep reserved bits */ |
| 875 | imm_cmd |= (unsigned long) (IM_ASSIGN_IMM_CMD); |
| 876 | imm_cmd |= (unsigned long) ((lun & 7) << 24); |
| 877 | imm_cmd |= (unsigned long) ((operation & 1) << 23); |
| 878 | imm_cmd |= (unsigned long) ((pun & 7) << 20); |
| 879 | imm_cmd |= (unsigned long) ((ldn & 15) << 16); |
| 880 | break; |
| 881 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 882 | last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_ASSIGN_IMM_CMD; |
| 883 | last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_IMM_CMD; |
| 884 | got_interrupt(shpnt) = 0; |
| 885 | issue_cmd(shpnt, (unsigned long) (imm_cmd), IM_IMM_CMD | MAX_LOG_DEV); |
| 886 | while (!got_interrupt(shpnt)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 887 | barrier(); |
| 888 | |
Andreas Mohr | d6e05ed | 2006-06-26 18:35:02 +0200 | [diff] [blame] | 889 | /*if command successful, break */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 890 | if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 891 | return 1; |
| 892 | } |
| 893 | if (retr >= 3) |
| 894 | return 0; |
| 895 | else |
| 896 | return 1; |
| 897 | } |
| 898 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 899 | static int immediate_feature(struct Scsi_Host *shpnt, unsigned int speed, unsigned int timeout) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 900 | { |
| 901 | int retr; |
| 902 | unsigned long imm_cmd; |
| 903 | |
| 904 | for (retr = 0; retr < 3; retr++) { |
| 905 | /* select mutation level of the SCSI-adapter */ |
| 906 | imm_cmd = IM_FEATURE_CTR_IMM_CMD; |
| 907 | imm_cmd |= (unsigned long) ((speed & 0x7) << 29); |
| 908 | imm_cmd |= (unsigned long) ((timeout & 0x1fff) << 16); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 909 | last_scsi_command(shpnt)[MAX_LOG_DEV] = IM_FEATURE_CTR_IMM_CMD; |
| 910 | last_scsi_type(shpnt)[MAX_LOG_DEV] = IM_IMM_CMD; |
| 911 | got_interrupt(shpnt) = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 912 | /* we need to run into command errors in order to probe for the |
| 913 | * right speed! */ |
| 914 | global_command_error_excuse = 1; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 915 | issue_cmd(shpnt, (unsigned long) (imm_cmd), IM_IMM_CMD | MAX_LOG_DEV); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 916 | |
| 917 | /* FIXME: timeout */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 918 | while (!got_interrupt(shpnt)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 919 | barrier(); |
| 920 | if (global_command_error_excuse == CMD_FAIL) { |
| 921 | global_command_error_excuse = 0; |
| 922 | return 2; |
| 923 | } else |
| 924 | global_command_error_excuse = 0; |
Andreas Mohr | d6e05ed | 2006-06-26 18:35:02 +0200 | [diff] [blame] | 925 | /*if command successful, break */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 926 | if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 927 | return 1; |
| 928 | } |
| 929 | if (retr >= 3) |
| 930 | return 0; |
| 931 | else |
| 932 | return 1; |
| 933 | } |
| 934 | |
| 935 | #ifdef CONFIG_IBMMCA_SCSI_DEV_RESET |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 936 | static int immediate_reset(struct Scsi_Host *shpnt, unsigned int ldn) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 937 | { |
| 938 | int retries; |
| 939 | int ticks; |
| 940 | unsigned long imm_command; |
| 941 | |
| 942 | for (retries = 0; retries < 3; retries++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 943 | imm_command = inl(IM_CMD_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 944 | imm_command &= (unsigned long) (0xFFFF0000); /* keep reserved bits */ |
| 945 | imm_command |= (unsigned long) (IM_RESET_IMM_CMD); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 946 | last_scsi_command(shpnt)[ldn] = IM_RESET_IMM_CMD; |
| 947 | last_scsi_type(shpnt)[ldn] = IM_IMM_CMD; |
| 948 | got_interrupt(shpnt) = 0; |
| 949 | reset_status(shpnt) = IM_RESET_IN_PROGRESS; |
| 950 | issue_cmd(shpnt, (unsigned long) (imm_command), IM_IMM_CMD | ldn); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 951 | ticks = IM_RESET_DELAY * HZ; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 952 | while (reset_status(shpnt) == IM_RESET_IN_PROGRESS && --ticks) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 953 | udelay((1 + 999 / HZ) * 1000); |
| 954 | barrier(); |
| 955 | } |
| 956 | /* if reset did not complete, just complain */ |
| 957 | if (!ticks) { |
| 958 | printk(KERN_ERR "IBM MCA SCSI: reset did not complete within %d seconds.\n", IM_RESET_DELAY); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 959 | reset_status(shpnt) = IM_RESET_FINISHED_OK; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 960 | /* did not work, finish */ |
| 961 | return 1; |
| 962 | } |
Andreas Mohr | d6e05ed | 2006-06-26 18:35:02 +0200 | [diff] [blame] | 963 | /*if command successful, break */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 964 | if (stat_result(shpnt) == IM_IMMEDIATE_CMD_COMPLETED) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 965 | return 1; |
| 966 | } |
| 967 | if (retries >= 3) |
| 968 | return 0; |
| 969 | else |
| 970 | return 1; |
| 971 | } |
| 972 | #endif |
| 973 | |
| 974 | /* type-interpreter for physical device numbers */ |
| 975 | static char *ti_p(int dev) |
| 976 | { |
| 977 | switch (dev) { |
| 978 | case TYPE_IBM_SCSI_ADAPTER: |
| 979 | return ("A"); |
| 980 | case TYPE_DISK: |
| 981 | return ("D"); |
| 982 | case TYPE_TAPE: |
| 983 | return ("T"); |
| 984 | case TYPE_PROCESSOR: |
| 985 | return ("P"); |
| 986 | case TYPE_WORM: |
| 987 | return ("W"); |
| 988 | case TYPE_ROM: |
| 989 | return ("R"); |
| 990 | case TYPE_SCANNER: |
| 991 | return ("S"); |
| 992 | case TYPE_MOD: |
| 993 | return ("M"); |
| 994 | case TYPE_MEDIUM_CHANGER: |
| 995 | return ("C"); |
| 996 | case TYPE_NO_LUN: |
| 997 | return ("+"); /* show NO_LUN */ |
| 998 | } |
| 999 | return ("-"); /* TYPE_NO_DEVICE and others */ |
| 1000 | } |
| 1001 | |
| 1002 | /* interpreter for logical device numbers (ldn) */ |
| 1003 | static char *ti_l(int val) |
| 1004 | { |
| 1005 | const char hex[16] = "0123456789abcdef"; |
| 1006 | static char answer[2]; |
| 1007 | |
| 1008 | answer[1] = (char) (0x0); |
| 1009 | if (val <= MAX_LOG_DEV) |
| 1010 | answer[0] = hex[val]; |
| 1011 | else |
| 1012 | answer[0] = '-'; |
| 1013 | return (char *) &answer; |
| 1014 | } |
| 1015 | |
| 1016 | /* transfers bitpattern of the feature command to values in MHz */ |
| 1017 | static char *ibmrate(unsigned int speed, int i) |
| 1018 | { |
| 1019 | switch (speed) { |
| 1020 | case 0: |
| 1021 | return i ? "5.00" : "10.00"; |
| 1022 | case 1: |
| 1023 | return i ? "4.00" : "8.00"; |
| 1024 | case 2: |
| 1025 | return i ? "3.33" : "6.66"; |
| 1026 | case 3: |
| 1027 | return i ? "2.86" : "5.00"; |
| 1028 | case 4: |
| 1029 | return i ? "2.50" : "4.00"; |
| 1030 | case 5: |
| 1031 | return i ? "2.22" : "3.10"; |
| 1032 | case 6: |
| 1033 | return i ? "2.00" : "2.50"; |
| 1034 | case 7: |
| 1035 | return i ? "1.82" : "2.00"; |
| 1036 | } |
| 1037 | return "---"; |
| 1038 | } |
| 1039 | |
| 1040 | static int probe_display(int what) |
| 1041 | { |
| 1042 | static int rotator = 0; |
| 1043 | const char rotor[] = "|/-\\"; |
| 1044 | |
| 1045 | if (!(display_mode & LED_DISP)) |
| 1046 | return 0; |
| 1047 | if (!what) { |
| 1048 | outl(0x20202020, MOD95_LED_PORT); |
| 1049 | outl(0x20202020, MOD95_LED_PORT + 4); |
| 1050 | } else { |
| 1051 | outb('S', MOD95_LED_PORT + 7); |
| 1052 | outb('C', MOD95_LED_PORT + 6); |
| 1053 | outb('S', MOD95_LED_PORT + 5); |
| 1054 | outb('I', MOD95_LED_PORT + 4); |
| 1055 | outb('i', MOD95_LED_PORT + 3); |
| 1056 | outb('n', MOD95_LED_PORT + 2); |
| 1057 | outb('i', MOD95_LED_PORT + 1); |
| 1058 | outb((char) (rotor[rotator]), MOD95_LED_PORT); |
| 1059 | rotator++; |
| 1060 | if (rotator > 3) |
| 1061 | rotator = 0; |
| 1062 | } |
| 1063 | return 0; |
| 1064 | } |
| 1065 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1066 | static int probe_bus_mode(struct Scsi_Host *shpnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1067 | { |
| 1068 | struct im_pos_info *info; |
| 1069 | int num_bus = 0; |
| 1070 | int ldn; |
| 1071 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1072 | info = (struct im_pos_info *) (&(ld(shpnt)[MAX_LOG_DEV].buf)); |
| 1073 | if (get_pos_info(shpnt)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1074 | if (info->connector_size & 0xf000) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1075 | subsystem_connector_size(shpnt) = 16; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1076 | else |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1077 | subsystem_connector_size(shpnt) = 32; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1078 | num_bus |= (info->pos_4b & 8) >> 3; |
| 1079 | for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1080 | if ((special(shpnt) == IBM_SCSI_WCACHE) || (special(shpnt) == IBM_7568_WCACHE)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1081 | if (!((info->cache_stat >> ldn) & 1)) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1082 | ld(shpnt)[ldn].cache_flag = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1083 | } |
| 1084 | if (!((info->retry_stat >> ldn) & 1)) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1085 | ld(shpnt)[ldn].retry_flag = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1086 | } |
| 1087 | #ifdef IM_DEBUG_PROBE |
| 1088 | printk("IBM MCA SCSI: SCSI-Cache bits: "); |
| 1089 | for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1090 | printk("%d", ld(shpnt)[ldn].cache_flag); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1091 | } |
| 1092 | printk("\nIBM MCA SCSI: SCSI-Retry bits: "); |
| 1093 | for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1094 | printk("%d", ld(shpnt)[ldn].retry_flag); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1095 | } |
| 1096 | printk("\n"); |
| 1097 | #endif |
| 1098 | } |
| 1099 | return num_bus; |
| 1100 | } |
| 1101 | |
| 1102 | /* probing scsi devices */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1103 | static void check_devices(struct Scsi_Host *shpnt, int adaptertype) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1104 | { |
| 1105 | int id, lun, ldn, ticks; |
| 1106 | int count_devices; /* local counter for connected device */ |
| 1107 | int max_pun; |
| 1108 | int num_bus; |
| 1109 | int speedrun; /* local adapter_speed check variable */ |
| 1110 | |
| 1111 | /* assign default values to certain variables */ |
| 1112 | ticks = 0; |
| 1113 | count_devices = 0; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1114 | IBM_DS(shpnt).dyn_flag = 0; /* normally no need for dynamical ldn management */ |
| 1115 | IBM_DS(shpnt).total_errors = 0; /* set errorcounter to 0 */ |
| 1116 | next_ldn(shpnt) = 7; /* next ldn to be assigned is 7, because 0-6 is 'hardwired' */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1117 | |
| 1118 | /* initialize the very important driver-informational arrays/structs */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1119 | memset(ld(shpnt), 0, sizeof(ld(shpnt))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1120 | for (ldn = 0; ldn <= MAX_LOG_DEV; ldn++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1121 | last_scsi_command(shpnt)[ldn] = NO_SCSI; /* emptify last SCSI-command storage */ |
| 1122 | last_scsi_type(shpnt)[ldn] = 0; |
| 1123 | ld(shpnt)[ldn].cache_flag = 1; |
| 1124 | ld(shpnt)[ldn].retry_flag = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1125 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1126 | memset(get_ldn(shpnt), TYPE_NO_DEVICE, sizeof(get_ldn(shpnt))); /* this is essential ! */ |
| 1127 | memset(get_scsi(shpnt), TYPE_NO_DEVICE, sizeof(get_scsi(shpnt))); /* this is essential ! */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1128 | for (lun = 0; lun < 8; lun++) { |
| 1129 | /* mark the adapter at its pun on all luns */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1130 | get_scsi(shpnt)[subsystem_pun(shpnt)][lun] = TYPE_IBM_SCSI_ADAPTER; |
| 1131 | get_ldn(shpnt)[subsystem_pun(shpnt)][lun] = MAX_LOG_DEV; /* make sure, the subsystem |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1132 | ldn is active for all |
| 1133 | luns. */ |
| 1134 | } |
| 1135 | probe_display(0); /* Supercool display usage during SCSI-probing. */ |
| 1136 | /* This makes sense, when booting without any */ |
| 1137 | /* monitor connected on model XX95. */ |
| 1138 | |
| 1139 | /* STEP 1: */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1140 | adapter_speed(shpnt) = global_adapter_speed; |
| 1141 | speedrun = adapter_speed(shpnt); |
| 1142 | while (immediate_feature(shpnt, speedrun, adapter_timeout) == 2) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1143 | probe_display(1); |
| 1144 | if (speedrun == 7) |
| 1145 | panic("IBM MCA SCSI: Cannot set Synchronous-Transfer-Rate!\n"); |
| 1146 | speedrun++; |
| 1147 | if (speedrun > 7) |
| 1148 | speedrun = 7; |
| 1149 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1150 | adapter_speed(shpnt) = speedrun; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1151 | /* Get detailed information about the current adapter, necessary for |
| 1152 | * device operations: */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1153 | num_bus = probe_bus_mode(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1154 | |
| 1155 | /* num_bus contains only valid data for the F/W adapter! */ |
| 1156 | if (adaptertype == IBM_SCSI2_FW) { /* F/W SCSI adapter: */ |
| 1157 | /* F/W adapter PUN-space extension evaluation: */ |
| 1158 | if (num_bus) { |
| 1159 | printk(KERN_INFO "IBM MCA SCSI: Separate bus mode (wide-addressing enabled)\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1160 | subsystem_maxid(shpnt) = 16; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1161 | } else { |
| 1162 | printk(KERN_INFO "IBM MCA SCSI: Combined bus mode (wide-addressing disabled)\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1163 | subsystem_maxid(shpnt) = 8; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1164 | } |
| 1165 | printk(KERN_INFO "IBM MCA SCSI: Sync.-Rate (F/W: 20, Int.: 10, Ext.: %s) MBytes/s\n", ibmrate(speedrun, adaptertype)); |
| 1166 | } else /* all other IBM SCSI adapters: */ |
| 1167 | printk(KERN_INFO "IBM MCA SCSI: Synchronous-SCSI-Transfer-Rate: %s MBytes/s\n", ibmrate(speedrun, adaptertype)); |
| 1168 | |
| 1169 | /* assign correct PUN device space */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1170 | max_pun = subsystem_maxid(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1171 | |
| 1172 | #ifdef IM_DEBUG_PROBE |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1173 | printk("IBM MCA SCSI: Current SCSI-host index: %d\n", shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1174 | printk("IBM MCA SCSI: Removing default logical SCSI-device mapping."); |
| 1175 | #else |
| 1176 | printk(KERN_INFO "IBM MCA SCSI: Dev. Order: %s, Mapping (takes <2min): ", (ibm_ansi_order) ? "ANSI" : "New"); |
| 1177 | #endif |
| 1178 | for (ldn = 0; ldn < MAX_LOG_DEV; ldn++) { |
| 1179 | probe_display(1); |
| 1180 | #ifdef IM_DEBUG_PROBE |
| 1181 | printk("."); |
| 1182 | #endif |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1183 | immediate_assign(shpnt, 0, 0, ldn, REMOVE_LDN); /* remove ldn (wherever) */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1184 | } |
| 1185 | lun = 0; /* default lun is 0 */ |
| 1186 | #ifndef IM_DEBUG_PROBE |
| 1187 | printk("cleared,"); |
| 1188 | #endif |
| 1189 | /* STEP 2: */ |
| 1190 | #ifdef IM_DEBUG_PROBE |
| 1191 | printk("\nIBM MCA SCSI: Scanning SCSI-devices."); |
| 1192 | #endif |
| 1193 | for (id = 0; id < max_pun; id++) |
| 1194 | #ifdef CONFIG_SCSI_MULTI_LUN |
| 1195 | for (lun = 0; lun < 8; lun++) |
| 1196 | #endif |
| 1197 | { |
| 1198 | probe_display(1); |
| 1199 | #ifdef IM_DEBUG_PROBE |
| 1200 | printk("."); |
| 1201 | #endif |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1202 | if (id != subsystem_pun(shpnt)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1203 | /* if pun is not the adapter: */ |
| 1204 | /* set ldn=0 to pun,lun */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1205 | immediate_assign(shpnt, id, lun, PROBE_LDN, SET_LDN); |
| 1206 | if (device_inquiry(shpnt, PROBE_LDN)) { /* probe device */ |
| 1207 | get_scsi(shpnt)[id][lun] = (unsigned char) (ld(shpnt)[PROBE_LDN].buf[0]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1208 | /* entry, even for NO_LUN */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1209 | if (ld(shpnt)[PROBE_LDN].buf[0] != TYPE_NO_LUN) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1210 | count_devices++; /* a existing device is found */ |
| 1211 | } |
| 1212 | /* remove ldn */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1213 | immediate_assign(shpnt, id, lun, PROBE_LDN, REMOVE_LDN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1214 | } |
| 1215 | } |
| 1216 | #ifndef IM_DEBUG_PROBE |
| 1217 | printk("scanned,"); |
| 1218 | #endif |
| 1219 | /* STEP 3: */ |
| 1220 | #ifdef IM_DEBUG_PROBE |
| 1221 | printk("\nIBM MCA SCSI: Mapping SCSI-devices."); |
| 1222 | #endif |
| 1223 | ldn = 0; |
| 1224 | lun = 0; |
| 1225 | #ifdef CONFIG_SCSI_MULTI_LUN |
| 1226 | for (lun = 0; lun < 8 && ldn < MAX_LOG_DEV; lun++) |
| 1227 | #endif |
| 1228 | for (id = 0; id < max_pun && ldn < MAX_LOG_DEV; id++) { |
| 1229 | probe_display(1); |
| 1230 | #ifdef IM_DEBUG_PROBE |
| 1231 | printk("."); |
| 1232 | #endif |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1233 | if (id != subsystem_pun(shpnt)) { |
| 1234 | if (get_scsi(shpnt)[id][lun] != TYPE_NO_LUN && get_scsi(shpnt)[id][lun] != TYPE_NO_DEVICE) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1235 | /* Only map if accepted type. Always enter for |
| 1236 | lun == 0 to get no gaps into ldn-mapping for ldn<7. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1237 | immediate_assign(shpnt, id, lun, ldn, SET_LDN); |
| 1238 | get_ldn(shpnt)[id][lun] = ldn; /* map ldn */ |
| 1239 | if (device_exists(shpnt, ldn, &ld(shpnt)[ldn].block_length, &ld(shpnt)[ldn].device_type)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1240 | #ifdef CONFIG_IBMMCA_SCSI_DEV_RESET |
| 1241 | printk("resetting device at ldn=%x ... ", ldn); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1242 | immediate_reset(shpnt, ldn); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1243 | #endif |
| 1244 | ldn++; |
| 1245 | } else { |
| 1246 | /* device vanished, probably because we don't know how to |
| 1247 | * handle it or because it has problems */ |
| 1248 | if (lun > 0) { |
| 1249 | /* remove mapping */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1250 | get_ldn(shpnt)[id][lun] = TYPE_NO_DEVICE; |
| 1251 | immediate_assign(shpnt, 0, 0, ldn, REMOVE_LDN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1252 | } else |
| 1253 | ldn++; |
| 1254 | } |
| 1255 | } else if (lun == 0) { |
| 1256 | /* map lun == 0, even if no device exists */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1257 | immediate_assign(shpnt, id, lun, ldn, SET_LDN); |
| 1258 | get_ldn(shpnt)[id][lun] = ldn; /* map ldn */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1259 | ldn++; |
| 1260 | } |
| 1261 | } |
| 1262 | } |
| 1263 | /* STEP 4: */ |
| 1264 | |
| 1265 | /* map remaining ldns to non-existing devices */ |
| 1266 | for (lun = 1; lun < 8 && ldn < MAX_LOG_DEV; lun++) |
| 1267 | for (id = 0; id < max_pun && ldn < MAX_LOG_DEV; id++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1268 | if (get_scsi(shpnt)[id][lun] == TYPE_NO_LUN || get_scsi(shpnt)[id][lun] == TYPE_NO_DEVICE) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1269 | probe_display(1); |
| 1270 | /* Map remaining ldns only to NON-existing pun,lun |
| 1271 | combinations to make sure an inquiry will fail. |
| 1272 | For MULTI_LUN, it is needed to avoid adapter autonome |
| 1273 | SCSI-remapping. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1274 | immediate_assign(shpnt, id, lun, ldn, SET_LDN); |
| 1275 | get_ldn(shpnt)[id][lun] = ldn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1276 | ldn++; |
| 1277 | } |
| 1278 | } |
| 1279 | #ifndef IM_DEBUG_PROBE |
| 1280 | printk("mapped."); |
| 1281 | #endif |
| 1282 | printk("\n"); |
| 1283 | #ifdef IM_DEBUG_PROBE |
| 1284 | if (ibm_ansi_order) |
| 1285 | printk("IBM MCA SCSI: Device order: IBM/ANSI (pun=7 is first).\n"); |
| 1286 | else |
| 1287 | printk("IBM MCA SCSI: Device order: New Industry Standard (pun=0 is first).\n"); |
| 1288 | #endif |
| 1289 | |
| 1290 | #ifdef IM_DEBUG_PROBE |
| 1291 | /* Show the physical and logical mapping during boot. */ |
| 1292 | printk("IBM MCA SCSI: Determined SCSI-device-mapping:\n"); |
| 1293 | printk(" Physical SCSI-Device Map Logical SCSI-Device Map\n"); |
| 1294 | printk("ID\\LUN 0 1 2 3 4 5 6 7 ID\\LUN 0 1 2 3 4 5 6 7\n"); |
| 1295 | for (id = 0; id < max_pun; id++) { |
| 1296 | printk("%2d ", id); |
| 1297 | for (lun = 0; lun < 8; lun++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1298 | printk("%2s ", ti_p(get_scsi(shpnt)[id][lun])); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1299 | printk(" %2d ", id); |
| 1300 | for (lun = 0; lun < 8; lun++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1301 | printk("%2s ", ti_l(get_ldn(shpnt)[id][lun])); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1302 | printk("\n"); |
| 1303 | } |
| 1304 | #endif |
| 1305 | |
| 1306 | /* assign total number of found SCSI-devices to the statistics struct */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1307 | IBM_DS(shpnt).total_scsi_devices = count_devices; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1308 | |
| 1309 | /* decide for output in /proc-filesystem, if the configuration of |
| 1310 | SCSI-devices makes dynamical reassignment of devices necessary */ |
| 1311 | if (count_devices >= MAX_LOG_DEV) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1312 | IBM_DS(shpnt).dyn_flag = 1; /* dynamical assignment is necessary */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1313 | else |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1314 | IBM_DS(shpnt).dyn_flag = 0; /* dynamical assignment is not necessary */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1315 | |
| 1316 | /* If no SCSI-devices are assigned, return 1 in order to cause message. */ |
| 1317 | if (ldn == 0) |
| 1318 | printk("IBM MCA SCSI: Warning: No SCSI-devices found/assigned!\n"); |
| 1319 | |
| 1320 | /* reset the counters for statistics on the current adapter */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1321 | IBM_DS(shpnt).scbs = 0; |
| 1322 | IBM_DS(shpnt).long_scbs = 0; |
| 1323 | IBM_DS(shpnt).total_accesses = 0; |
| 1324 | IBM_DS(shpnt).total_interrupts = 0; |
| 1325 | IBM_DS(shpnt).dynamical_assignments = 0; |
| 1326 | memset(IBM_DS(shpnt).ldn_access, 0x0, sizeof(IBM_DS(shpnt).ldn_access)); |
| 1327 | memset(IBM_DS(shpnt).ldn_read_access, 0x0, sizeof(IBM_DS(shpnt).ldn_read_access)); |
| 1328 | memset(IBM_DS(shpnt).ldn_write_access, 0x0, sizeof(IBM_DS(shpnt).ldn_write_access)); |
| 1329 | memset(IBM_DS(shpnt).ldn_inquiry_access, 0x0, sizeof(IBM_DS(shpnt).ldn_inquiry_access)); |
| 1330 | memset(IBM_DS(shpnt).ldn_modeselect_access, 0x0, sizeof(IBM_DS(shpnt).ldn_modeselect_access)); |
| 1331 | memset(IBM_DS(shpnt).ldn_assignments, 0x0, sizeof(IBM_DS(shpnt).ldn_assignments)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1332 | probe_display(0); |
| 1333 | return; |
| 1334 | } |
| 1335 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1336 | static int device_exists(struct Scsi_Host *shpnt, int ldn, int *block_length, int *device_type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1337 | { |
| 1338 | unsigned char *buf; |
| 1339 | /* if no valid device found, return immediately with 0 */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1340 | if (!(device_inquiry(shpnt, ldn))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1341 | return 0; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1342 | buf = (unsigned char *) (&(ld(shpnt)[ldn].buf)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1343 | if (*buf == TYPE_ROM) { |
| 1344 | *device_type = TYPE_ROM; |
| 1345 | *block_length = 2048; /* (standard blocksize for yellow-/red-book) */ |
| 1346 | return 1; |
| 1347 | } |
| 1348 | if (*buf == TYPE_WORM) { |
| 1349 | *device_type = TYPE_WORM; |
| 1350 | *block_length = 2048; |
| 1351 | return 1; |
| 1352 | } |
| 1353 | if (*buf == TYPE_DISK) { |
| 1354 | *device_type = TYPE_DISK; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1355 | if (read_capacity(shpnt, ldn)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1356 | *block_length = *(buf + 7) + (*(buf + 6) << 8) + (*(buf + 5) << 16) + (*(buf + 4) << 24); |
| 1357 | return 1; |
| 1358 | } else |
| 1359 | return 0; |
| 1360 | } |
| 1361 | if (*buf == TYPE_MOD) { |
| 1362 | *device_type = TYPE_MOD; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1363 | if (read_capacity(shpnt, ldn)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1364 | *block_length = *(buf + 7) + (*(buf + 6) << 8) + (*(buf + 5) << 16) + (*(buf + 4) << 24); |
| 1365 | return 1; |
| 1366 | } else |
| 1367 | return 0; |
| 1368 | } |
| 1369 | if (*buf == TYPE_TAPE) { |
| 1370 | *device_type = TYPE_TAPE; |
| 1371 | *block_length = 0; /* not in use (setting by mt and mtst in op.) */ |
| 1372 | return 1; |
| 1373 | } |
| 1374 | if (*buf == TYPE_PROCESSOR) { |
| 1375 | *device_type = TYPE_PROCESSOR; |
| 1376 | *block_length = 0; /* they set their stuff on drivers */ |
| 1377 | return 1; |
| 1378 | } |
| 1379 | if (*buf == TYPE_SCANNER) { |
| 1380 | *device_type = TYPE_SCANNER; |
| 1381 | *block_length = 0; /* they set their stuff on drivers */ |
| 1382 | return 1; |
| 1383 | } |
| 1384 | if (*buf == TYPE_MEDIUM_CHANGER) { |
| 1385 | *device_type = TYPE_MEDIUM_CHANGER; |
| 1386 | *block_length = 0; /* One never knows, what to expect on a medium |
| 1387 | changer device. */ |
| 1388 | return 1; |
| 1389 | } |
| 1390 | return 0; |
| 1391 | } |
| 1392 | |
| 1393 | static void internal_ibmmca_scsi_setup(char *str, int *ints) |
| 1394 | { |
| 1395 | int i, j, io_base, id_base; |
| 1396 | char *token; |
| 1397 | |
| 1398 | io_base = 0; |
| 1399 | id_base = 0; |
| 1400 | if (str) { |
| 1401 | j = 0; |
| 1402 | while ((token = strsep(&str, ",")) != NULL) { |
| 1403 | if (!strcmp(token, "activity")) |
| 1404 | display_mode |= LED_ACTIVITY; |
| 1405 | if (!strcmp(token, "display")) |
| 1406 | display_mode |= LED_DISP; |
| 1407 | if (!strcmp(token, "adisplay")) |
| 1408 | display_mode |= LED_ADISP; |
| 1409 | if (!strcmp(token, "normal")) |
| 1410 | ibm_ansi_order = 0; |
| 1411 | if (!strcmp(token, "ansi")) |
| 1412 | ibm_ansi_order = 1; |
| 1413 | if (!strcmp(token, "fast")) |
| 1414 | global_adapter_speed = 0; |
| 1415 | if (!strcmp(token, "medium")) |
| 1416 | global_adapter_speed = 4; |
| 1417 | if (!strcmp(token, "slow")) |
| 1418 | global_adapter_speed = 7; |
| 1419 | if ((*token == '-') || (isdigit(*token))) { |
| 1420 | if (!(j % 2) && (io_base < IM_MAX_HOSTS)) |
| 1421 | io_port[io_base++] = simple_strtoul(token, NULL, 0); |
| 1422 | if ((j % 2) && (id_base < IM_MAX_HOSTS)) |
| 1423 | scsi_id[id_base++] = simple_strtoul(token, NULL, 0); |
| 1424 | j++; |
| 1425 | } |
| 1426 | } |
| 1427 | } else if (ints) { |
| 1428 | for (i = 0; i < IM_MAX_HOSTS && 2 * i + 2 < ints[0]; i++) { |
| 1429 | io_port[i] = ints[2 * i + 2]; |
| 1430 | scsi_id[i] = ints[2 * i + 2]; |
| 1431 | } |
| 1432 | } |
| 1433 | return; |
| 1434 | } |
| 1435 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1436 | #if 0 |
| 1437 | FIXME NEED TO MOVE TO SYSFS |
| 1438 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1439 | static int ibmmca_getinfo(char *buf, int slot, void *dev_id) |
| 1440 | { |
| 1441 | struct Scsi_Host *shpnt; |
| 1442 | int len, speciale, connectore, k; |
| 1443 | unsigned int pos[8]; |
| 1444 | unsigned long flags; |
| 1445 | struct Scsi_Host *dev = dev_id; |
| 1446 | |
| 1447 | spin_lock_irqsave(dev->host_lock, flags); |
Tobias Klauser | 6391a11 | 2006-06-08 22:23:48 -0700 | [diff] [blame] | 1448 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1449 | shpnt = dev; /* assign host-structure to local pointer */ |
| 1450 | len = 0; /* set filled text-buffer index to 0 */ |
| 1451 | /* get the _special contents of the hostdata structure */ |
| 1452 | speciale = ((struct ibmmca_hostdata *) shpnt->hostdata)->_special; |
| 1453 | connectore = ((struct ibmmca_hostdata *) shpnt->hostdata)->_connector_size; |
| 1454 | for (k = 2; k < 4; k++) |
| 1455 | pos[k] = ((struct ibmmca_hostdata *) shpnt->hostdata)->_pos[k]; |
| 1456 | if (speciale == FORCED_DETECTION) { /* forced detection */ |
| 1457 | len += sprintf(buf + len, |
| 1458 | "Adapter category: forced detected\n" "***************************************\n" "*** Forced detected SCSI Adapter ***\n" "*** No chip-information available ***\n" "***************************************\n"); |
| 1459 | } else if (speciale == INTEGRATED_SCSI) { |
| 1460 | /* if the integrated subsystem has been found automatically: */ |
| 1461 | len += sprintf(buf + len, |
| 1462 | "Adapter category: integrated\n" "Chip revision level: %d\n" "Chip status: %s\n" "8 kByte NVRAM status: %s\n", ((pos[2] & 0xf0) >> 4), (pos[2] & 1) ? "enabled" : "disabled", (pos[2] & 2) ? "locked" : "accessible"); |
Tobias Klauser | 6391a11 | 2006-06-08 22:23:48 -0700 | [diff] [blame] | 1463 | } else if ((speciale >= 0) && (speciale < ARRAY_SIZE(subsys_list))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1464 | /* if the subsystem is a slot adapter */ |
| 1465 | len += sprintf(buf + len, "Adapter category: slot-card\n" "ROM Segment Address: "); |
| 1466 | if ((pos[2] & 0xf0) == 0xf0) |
| 1467 | len += sprintf(buf + len, "off\n"); |
| 1468 | else |
| 1469 | len += sprintf(buf + len, "0x%x\n", ((pos[2] & 0xf0) << 13) + 0xc0000); |
| 1470 | len += sprintf(buf + len, "Chip status: %s\n", (pos[2] & 1) ? "enabled" : "disabled"); |
| 1471 | len += sprintf(buf + len, "Adapter I/O Offset: 0x%x\n", ((pos[2] & 0x0e) << 2)); |
| 1472 | } else { |
| 1473 | len += sprintf(buf + len, "Adapter category: unknown\n"); |
| 1474 | } |
| 1475 | /* common subsystem information to write to the slotn file */ |
| 1476 | len += sprintf(buf + len, "Subsystem PUN: %d\n", shpnt->this_id); |
| 1477 | len += sprintf(buf + len, "I/O base address range: 0x%x-0x%x\n", (unsigned int) (shpnt->io_port), (unsigned int) (shpnt->io_port + 7)); |
| 1478 | len += sprintf(buf + len, "MCA-slot size: %d bits", connectore); |
| 1479 | /* Now make sure, the bufferlength is devidable by 4 to avoid |
| 1480 | * paging problems of the buffer. */ |
| 1481 | while (len % sizeof(int) != (sizeof(int) - 1)) |
| 1482 | len += sprintf(buf + len, " "); |
| 1483 | len += sprintf(buf + len, "\n"); |
Tobias Klauser | 6391a11 | 2006-06-08 22:23:48 -0700 | [diff] [blame] | 1484 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1485 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
Tobias Klauser | 6391a11 | 2006-06-08 22:23:48 -0700 | [diff] [blame] | 1486 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1487 | return len; |
| 1488 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1489 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1490 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1491 | static struct scsi_host_template ibmmca_driver_template = { |
| 1492 | .proc_name = "ibmmca", |
| 1493 | .proc_info = ibmmca_proc_info, |
| 1494 | .name = "IBM SCSI-Subsystem", |
| 1495 | .queuecommand = ibmmca_queuecommand, |
| 1496 | .eh_abort_handler = ibmmca_abort, |
| 1497 | .eh_host_reset_handler = ibmmca_host_reset, |
| 1498 | .bios_param = ibmmca_biosparam, |
| 1499 | .can_queue = 16, |
| 1500 | .this_id = 7, |
| 1501 | .sg_tablesize = 16, |
| 1502 | .cmd_per_lun = 1, |
| 1503 | .use_clustering = ENABLE_CLUSTERING, |
FUJITA Tomonori | 9cb83c7 | 2007-10-16 11:24:32 +0200 | [diff] [blame] | 1504 | .use_sg_chaining = ENABLE_SG_CHAINING, |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1505 | }; |
| 1506 | |
| 1507 | static int ibmmca_probe(struct device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1508 | { |
| 1509 | struct Scsi_Host *shpnt; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1510 | int port, id, i, j, k, irq, enabled, ret = -EINVAL; |
| 1511 | struct mca_device *mca_dev = to_mca_device(dev); |
| 1512 | const char *description = ibmmca_description[mca_dev->index]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1513 | |
| 1514 | /* First of all, print the version number of the driver. This is |
| 1515 | * important to allow better user bugreports in case of already |
| 1516 | * having problems with the MCA_bus probing. */ |
| 1517 | printk(KERN_INFO "IBM MCA SCSI: Version %s\n", IBMMCA_SCSI_DRIVER_VERSION); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1518 | /* The POS2-register of all PS/2 model SCSI-subsystems has the following |
| 1519 | * interpretation of bits: |
| 1520 | * Bit 7 - 4 : Chip Revision ID (Release) |
| 1521 | * Bit 3 - 2 : Reserved |
| 1522 | * Bit 1 : 8k NVRAM Disabled |
| 1523 | * Bit 0 : Chip Enable (EN-Signal) |
| 1524 | * The POS3-register is interpreted as follows: |
| 1525 | * Bit 7 - 5 : SCSI ID |
| 1526 | * Bit 4 : Reserved = 0 |
| 1527 | * Bit 3 - 0 : Reserved = 0 |
| 1528 | * (taken from "IBM, PS/2 Hardware Interface Technical Reference, Common |
| 1529 | * Interfaces (1991)"). |
| 1530 | * In short words, this means, that IBM PS/2 machines only support |
| 1531 | * 1 single subsystem by default. The slot-adapters must have another |
| 1532 | * configuration on pos2. Here, one has to assume the following |
| 1533 | * things for POS2-register: |
| 1534 | * Bit 7 - 4 : Chip Revision ID (Release) |
| 1535 | * Bit 3 - 1 : port offset factor |
| 1536 | * Bit 0 : Chip Enable (EN-Signal) |
| 1537 | * As I found a patch here, setting the IO-registers to 0x3540 forced, |
| 1538 | * as there was a 0x05 in POS2 on a model 56, I assume, that the |
| 1539 | * port 0x3540 must be fix for integrated SCSI-controllers. |
| 1540 | * Ok, this discovery leads to the following implementation: (M.Lang) */ |
| 1541 | |
| 1542 | /* first look for the IBM SCSI integrated subsystem on the motherboard */ |
| 1543 | for (j = 0; j < 8; j++) /* read the pos-information */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1544 | pos[j] = mca_device_read_pos(mca_dev, j); |
| 1545 | id = (pos[3] & 0xe0) >> 5; /* this is correct and represents the PUN */ |
| 1546 | enabled = (pos[2] &0x01); |
| 1547 | if (!enabled) { |
| 1548 | printk(KERN_WARNING "IBM MCA SCSI: WARNING - Your SCSI-subsystem is disabled!\n"); |
| 1549 | printk(KERN_WARNING " SCSI-operations may not work.\n"); |
| 1550 | } |
| 1551 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1552 | /* pos2 = pos3 = 0xff if there is no integrated SCSI-subsystem present, but |
| 1553 | * if we ignore the settings of all surrounding pos registers, it is not |
| 1554 | * completely sufficient to only check pos2 and pos3. */ |
| 1555 | /* Therefore, now the following if statement is used to |
| 1556 | * make sure, we see a real integrated onboard SCSI-interface and no |
| 1557 | * internal system information, which gets mapped to some pos registers |
| 1558 | * on models 95xx. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1559 | if (mca_dev->slot == MCA_INTEGSCSI && |
| 1560 | ((!pos[0] && !pos[1] && pos[2] > 0 && |
| 1561 | pos[3] > 0 && !pos[4] && !pos[5] && |
| 1562 | !pos[6] && !pos[7]) || |
| 1563 | (pos[0] == 0xff && pos[1] == 0xff && |
| 1564 | pos[2] < 0xff && pos[3] < 0xff && |
| 1565 | pos[4] == 0xff && pos[5] == 0xff && |
| 1566 | pos[6] == 0xff && pos[7] == 0xff))) { |
| 1567 | irq = IM_IRQ; |
| 1568 | port = IM_IO_PORT; |
| 1569 | } else { |
| 1570 | irq = IM_IRQ; |
| 1571 | port = IM_IO_PORT + ((pos[2] &0x0e) << 2); |
| 1572 | if ((mca_dev->index == IBM_SCSI2_FW) && (pos[6] != 0)) { |
| 1573 | printk(KERN_ERR "IBM MCA SCSI: ERROR - Wrong POS(6)-register setting!\n"); |
| 1574 | printk(KERN_ERR " Impossible to determine adapter PUN!\n"); |
| 1575 | printk(KERN_ERR " Guessing adapter PUN = 7.\n"); |
| 1576 | id = 7; |
| 1577 | } else { |
| 1578 | id = (pos[3] & 0xe0) >> 5; /* get subsystem PUN */ |
| 1579 | if (mca_dev->index == IBM_SCSI2_FW) { |
| 1580 | id |= (pos[3] & 0x10) >> 1; /* get subsystem PUN high-bit |
| 1581 | * for F/W adapters */ |
| 1582 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1583 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1584 | if ((mca_dev->index == IBM_SCSI2_FW) && |
| 1585 | (pos[4] & 0x01) && (pos[6] == 0)) { |
| 1586 | /* IRQ11 is used by SCSI-2 F/W Adapter/A */ |
| 1587 | printk(KERN_DEBUG "IBM MCA SCSI: SCSI-2 F/W adapter needs IRQ 11.\n"); |
| 1588 | irq = IM_IRQ_FW; |
| 1589 | } |
| 1590 | } |
| 1591 | |
| 1592 | |
| 1593 | |
| 1594 | /* give detailed information on the subsystem. This helps me |
| 1595 | * additionally during debugging and analyzing bug-reports. */ |
| 1596 | printk(KERN_INFO "IBM MCA SCSI: %s found, io=0x%x, scsi id=%d,\n", |
| 1597 | description, port, id); |
| 1598 | if (mca_dev->slot == MCA_INTEGSCSI) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1599 | printk(KERN_INFO " chip rev.=%d, 8K NVRAM=%s, subsystem=%s\n", ((pos[2] & 0xf0) >> 4), (pos[2] & 2) ? "locked" : "accessible", (pos[2] & 1) ? "enabled." : "disabled."); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1600 | else { |
| 1601 | if ((pos[2] & 0xf0) == 0xf0) |
| 1602 | printk(KERN_DEBUG " ROM Addr.=off,"); |
| 1603 | else |
| 1604 | printk(KERN_DEBUG " ROM Addr.=0x%x,", ((pos[2] & 0xf0) << 13) + 0xc0000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1605 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1606 | printk(KERN_DEBUG " port-offset=0x%x, subsystem=%s\n", ((pos[2] & 0x0e) << 2), (pos[2] & 1) ? "enabled." : "disabled."); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1607 | } |
| 1608 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1609 | /* check I/O region */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1610 | if (!request_region(port, IM_N_IO_PORT, description)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1611 | printk(KERN_ERR "IBM MCA SCSI: Unable to get I/O region 0x%x-0x%x (%d ports).\n", port, port + IM_N_IO_PORT - 1, IM_N_IO_PORT); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1612 | goto out_fail; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1613 | } |
| 1614 | |
| 1615 | /* register host */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1616 | shpnt = scsi_host_alloc(&ibmmca_driver_template, |
| 1617 | sizeof(struct ibmmca_hostdata)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1618 | if (!shpnt) { |
| 1619 | printk(KERN_ERR "IBM MCA SCSI: Unable to register host.\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1620 | goto out_release; |
| 1621 | } |
| 1622 | |
| 1623 | dev_set_drvdata(dev, shpnt); |
| 1624 | if(request_irq(irq, interrupt_handler, IRQF_SHARED, description, dev)) { |
| 1625 | printk(KERN_ERR "IBM MCA SCSI: failed to request interrupt %d\n", irq); |
| 1626 | goto out_free_host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1627 | } |
| 1628 | |
| 1629 | /* request I/O region */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1630 | special(shpnt) = mca_dev->index; /* important assignment or else crash! */ |
| 1631 | subsystem_connector_size(shpnt) = 0; /* preset slot-size */ |
| 1632 | shpnt->irq = irq; /* assign necessary stuff for the adapter */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1633 | shpnt->io_port = port; |
| 1634 | shpnt->n_io_port = IM_N_IO_PORT; |
| 1635 | shpnt->this_id = id; |
| 1636 | shpnt->max_id = 8; /* 8 PUNs are default */ |
| 1637 | /* now, the SCSI-subsystem is connected to Linux */ |
| 1638 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1639 | #ifdef IM_DEBUG_PROBE |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1640 | ctrl = (unsigned int) (inb(IM_CTR_REG(found))); /* get control-register status */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1641 | printk("IBM MCA SCSI: Control Register contents: %x, status: %x\n", ctrl, inb(IM_STAT_REG(found))); |
| 1642 | printk("IBM MCA SCSI: This adapters' POS-registers: "); |
| 1643 | for (i = 0; i < 8; i++) |
| 1644 | printk("%x ", pos[i]); |
| 1645 | printk("\n"); |
| 1646 | #endif |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1647 | reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1648 | |
| 1649 | for (i = 0; i < 16; i++) /* reset the tables */ |
| 1650 | for (j = 0; j < 8; j++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1651 | get_ldn(shpnt)[i][j] = MAX_LOG_DEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1652 | |
| 1653 | /* check which logical devices exist */ |
| 1654 | /* after this line, local interrupting is possible: */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1655 | local_checking_phase_flag(shpnt) = 1; |
| 1656 | check_devices(shpnt, mca_dev->index); /* call by value, using the global variable hosts */ |
| 1657 | local_checking_phase_flag(shpnt) = 0; |
| 1658 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1659 | /* an ibm mca subsystem has been detected */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1660 | |
| 1661 | for (k = 2; k < 7; k++) |
| 1662 | ((struct ibmmca_hostdata *) shpnt->hostdata)->_pos[k] = pos[k]; |
| 1663 | ((struct ibmmca_hostdata *) shpnt->hostdata)->_special = INTEGRATED_SCSI; |
| 1664 | mca_device_set_name(mca_dev, description); |
| 1665 | /* FIXME: NEED TO REPLUMB TO SYSFS |
| 1666 | mca_set_adapter_procfn(MCA_INTEGSCSI, (MCA_ProcFn) ibmmca_getinfo, shpnt); |
| 1667 | */ |
| 1668 | mca_device_set_claim(mca_dev, 1); |
| 1669 | if (scsi_add_host(shpnt, dev)) { |
| 1670 | dev_printk(KERN_ERR, dev, "IBM MCA SCSI: scsi_add_host failed\n"); |
| 1671 | goto out_free_host; |
| 1672 | } |
| 1673 | scsi_scan_host(shpnt); |
| 1674 | |
| 1675 | return 0; |
| 1676 | out_free_host: |
| 1677 | scsi_host_put(shpnt); |
| 1678 | out_release: |
| 1679 | release_region(port, IM_N_IO_PORT); |
| 1680 | out_fail: |
| 1681 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1682 | } |
| 1683 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1684 | static int __devexit ibmmca_remove(struct device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1685 | { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1686 | struct Scsi_Host *shpnt = dev_get_drvdata(dev); |
| 1687 | scsi_remove_host(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1688 | release_region(shpnt->io_port, shpnt->n_io_port); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1689 | free_irq(shpnt->irq, dev); |
Matthew Wilcox | 34f8f0d | 2007-08-15 12:56:58 -0600 | [diff] [blame] | 1690 | scsi_host_put(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1691 | return 0; |
| 1692 | } |
| 1693 | |
| 1694 | /* The following routine is the SCSI command queue for the midlevel driver */ |
| 1695 | static int ibmmca_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) |
| 1696 | { |
| 1697 | unsigned int ldn; |
| 1698 | unsigned int scsi_cmd; |
| 1699 | struct im_scb *scb; |
| 1700 | struct Scsi_Host *shpnt; |
| 1701 | int current_ldn; |
| 1702 | int id, lun; |
| 1703 | int target; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1704 | int max_pun; |
| 1705 | int i; |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1706 | struct scatterlist *sg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1707 | |
| 1708 | shpnt = cmd->device->host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1709 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1710 | max_pun = subsystem_maxid(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1711 | if (ibm_ansi_order) { |
| 1712 | target = max_pun - 1 - cmd->device->id; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1713 | if ((target <= subsystem_pun(shpnt)) && (cmd->device->id <= subsystem_pun(shpnt))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1714 | target--; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1715 | else if ((target >= subsystem_pun(shpnt)) && (cmd->device->id >= subsystem_pun(shpnt))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1716 | target++; |
| 1717 | } else |
| 1718 | target = cmd->device->id; |
| 1719 | |
| 1720 | /* if (target,lun) is NO LUN or not existing at all, return error */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1721 | if ((get_scsi(shpnt)[target][cmd->device->lun] == TYPE_NO_LUN) || (get_scsi(shpnt)[target][cmd->device->lun] == TYPE_NO_DEVICE)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1722 | cmd->result = DID_NO_CONNECT << 16; |
| 1723 | if (done) |
| 1724 | done(cmd); |
| 1725 | return 0; |
| 1726 | } |
| 1727 | |
| 1728 | /*if (target,lun) unassigned, do further checks... */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1729 | ldn = get_ldn(shpnt)[target][cmd->device->lun]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1730 | if (ldn >= MAX_LOG_DEV) { /* on invalid ldn do special stuff */ |
| 1731 | if (ldn > MAX_LOG_DEV) { /* dynamical remapping if ldn unassigned */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1732 | current_ldn = next_ldn(shpnt); /* stop-value for one circle */ |
| 1733 | while (ld(shpnt)[next_ldn(shpnt)].cmd) { /* search for a occupied, but not in */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1734 | /* command-processing ldn. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1735 | next_ldn(shpnt)++; |
| 1736 | if (next_ldn(shpnt) >= MAX_LOG_DEV) |
| 1737 | next_ldn(shpnt) = 7; |
| 1738 | if (current_ldn == next_ldn(shpnt)) { /* One circle done ? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1739 | /* no non-processing ldn found */ |
Jeff Garzik | 017560f | 2005-10-24 18:04:36 -0400 | [diff] [blame] | 1740 | scmd_printk(KERN_WARNING, cmd, |
| 1741 | "IBM MCA SCSI: Cannot assign SCSI-device dynamically!\n" |
| 1742 | " On ldn 7-14 SCSI-commands everywhere in progress.\n" |
| 1743 | " Reporting DID_NO_CONNECT for device.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1744 | cmd->result = DID_NO_CONNECT << 16; /* return no connect */ |
| 1745 | if (done) |
| 1746 | done(cmd); |
| 1747 | return 0; |
| 1748 | } |
| 1749 | } |
| 1750 | |
| 1751 | /* unmap non-processing ldn */ |
| 1752 | for (id = 0; id < max_pun; id++) |
| 1753 | for (lun = 0; lun < 8; lun++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1754 | if (get_ldn(shpnt)[id][lun] == next_ldn(shpnt)) { |
| 1755 | get_ldn(shpnt)[id][lun] = TYPE_NO_DEVICE; |
| 1756 | get_scsi(shpnt)[id][lun] = TYPE_NO_DEVICE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1757 | /* unmap entry */ |
| 1758 | } |
| 1759 | } |
| 1760 | /* set reduced interrupt_handler-mode for checking */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1761 | local_checking_phase_flag(shpnt) = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1762 | /* map found ldn to pun,lun */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1763 | get_ldn(shpnt)[target][cmd->device->lun] = next_ldn(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1764 | /* change ldn to the right value, that is now next_ldn */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1765 | ldn = next_ldn(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1766 | /* unassign all ldns (pun,lun,ldn does not matter for remove) */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1767 | immediate_assign(shpnt, 0, 0, 0, REMOVE_LDN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1768 | /* set only LDN for remapped device */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1769 | immediate_assign(shpnt, target, cmd->device->lun, ldn, SET_LDN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1770 | /* get device information for ld[ldn] */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1771 | if (device_exists(shpnt, ldn, &ld(shpnt)[ldn].block_length, &ld(shpnt)[ldn].device_type)) { |
| 1772 | ld(shpnt)[ldn].cmd = NULL; /* To prevent panic set 0, because |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1773 | devices that were not assigned, |
| 1774 | should have nothing in progress. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1775 | get_scsi(shpnt)[target][cmd->device->lun] = ld(shpnt)[ldn].device_type; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1776 | /* increase assignment counters for statistics in /proc */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1777 | IBM_DS(shpnt).dynamical_assignments++; |
| 1778 | IBM_DS(shpnt).ldn_assignments[ldn]++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1779 | } else |
| 1780 | /* panic here, because a device, found at boottime has |
| 1781 | vanished */ |
| 1782 | panic("IBM MCA SCSI: ldn=0x%x, SCSI-device on (%d,%d) vanished!\n", ldn, target, cmd->device->lun); |
| 1783 | /* unassign again all ldns (pun,lun,ldn does not matter for remove) */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1784 | immediate_assign(shpnt, 0, 0, 0, REMOVE_LDN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1785 | /* remap all ldns, as written in the pun/lun table */ |
| 1786 | lun = 0; |
| 1787 | #ifdef CONFIG_SCSI_MULTI_LUN |
| 1788 | for (lun = 0; lun < 8; lun++) |
| 1789 | #endif |
| 1790 | for (id = 0; id < max_pun; id++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1791 | if (get_ldn(shpnt)[id][lun] <= MAX_LOG_DEV) |
| 1792 | immediate_assign(shpnt, id, lun, get_ldn(shpnt)[id][lun], SET_LDN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1793 | } |
| 1794 | /* set back to normal interrupt_handling */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1795 | local_checking_phase_flag(shpnt) = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1796 | #ifdef IM_DEBUG_PROBE |
| 1797 | /* Information on syslog terminal */ |
| 1798 | printk("IBM MCA SCSI: ldn=0x%x dynamically reassigned to (%d,%d).\n", ldn, target, cmd->device->lun); |
| 1799 | #endif |
| 1800 | /* increase next_ldn for next dynamical assignment */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1801 | next_ldn(shpnt)++; |
| 1802 | if (next_ldn(shpnt) >= MAX_LOG_DEV) |
| 1803 | next_ldn(shpnt) = 7; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1804 | } else { /* wall against Linux accesses to the subsystem adapter */ |
| 1805 | cmd->result = DID_BAD_TARGET << 16; |
| 1806 | if (done) |
| 1807 | done(cmd); |
| 1808 | return 0; |
| 1809 | } |
| 1810 | } |
| 1811 | |
| 1812 | /*verify there is no command already in progress for this log dev */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1813 | if (ld(shpnt)[ldn].cmd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1814 | panic("IBM MCA SCSI: cmd already in progress for this ldn.\n"); |
| 1815 | |
| 1816 | /*save done in cmd, and save cmd for the interrupt handler */ |
| 1817 | cmd->scsi_done = done; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1818 | ld(shpnt)[ldn].cmd = cmd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1819 | |
| 1820 | /*fill scb information independent of the scsi command */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1821 | scb = &(ld(shpnt)[ldn].scb); |
| 1822 | ld(shpnt)[ldn].tsb.dev_status = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1823 | scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_RETRY_ENABLE; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1824 | scb->tsb_adr = isa_virt_to_bus(&(ld(shpnt)[ldn].tsb)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1825 | scsi_cmd = cmd->cmnd[0]; |
| 1826 | |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1827 | if (scsi_sg_count(cmd)) { |
| 1828 | BUG_ON(scsi_sg_count(cmd) > 16); |
| 1829 | |
| 1830 | scsi_for_each_sg(cmd, sg, scsi_sg_count(cmd), i) { |
Jens Axboe | 45711f1 | 2007-10-22 21:19:53 +0200 | [diff] [blame^] | 1831 | ld(shpnt)[ldn].sge[i].address = (void *) (isa_page_to_bus(sg_page(sg)) + sg->offset); |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1832 | ld(shpnt)[ldn].sge[i].byte_length = sg->length; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1833 | } |
| 1834 | scb->enable |= IM_POINTER_TO_LIST; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1835 | scb->sys_buf_adr = isa_virt_to_bus(&(ld(shpnt)[ldn].sge[0])); |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1836 | scb->sys_buf_length = scsi_sg_count(cmd) * sizeof(struct im_sge); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1837 | } else { |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1838 | scb->sys_buf_adr = isa_virt_to_bus(scsi_sglist(cmd)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1839 | /* recent Linux midlevel SCSI places 1024 byte for inquiry |
| 1840 | * command. Far too much for old PS/2 hardware. */ |
| 1841 | switch (scsi_cmd) { |
| 1842 | /* avoid command errors by setting bufferlengths to |
| 1843 | * ANSI-standard. Beware of forcing it to 255, |
| 1844 | * this could SEGV the kernel!!! */ |
| 1845 | case INQUIRY: |
| 1846 | case REQUEST_SENSE: |
| 1847 | case MODE_SENSE: |
| 1848 | case MODE_SELECT: |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1849 | if (scsi_bufflen(cmd) > 255) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1850 | scb->sys_buf_length = 255; |
| 1851 | else |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1852 | scb->sys_buf_length = scsi_bufflen(cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1853 | break; |
| 1854 | case TEST_UNIT_READY: |
| 1855 | scb->sys_buf_length = 0; |
| 1856 | break; |
| 1857 | default: |
FUJITA Tomonori | 5f60ef6 | 2007-05-21 15:10:00 +0900 | [diff] [blame] | 1858 | scb->sys_buf_length = scsi_bufflen(cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1859 | break; |
| 1860 | } |
| 1861 | } |
| 1862 | /*fill scb information dependent on scsi command */ |
| 1863 | |
| 1864 | #ifdef IM_DEBUG_CMD |
| 1865 | printk("issue scsi cmd=%02x to ldn=%d\n", scsi_cmd, ldn); |
| 1866 | #endif |
| 1867 | |
| 1868 | /* for specific device-type debugging: */ |
| 1869 | #ifdef IM_DEBUG_CMD_SPEC_DEV |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1870 | if (ld(shpnt)[ldn].device_type == IM_DEBUG_CMD_DEVICE) |
| 1871 | printk("(SCSI-device-type=0x%x) issue scsi cmd=%02x to ldn=%d\n", ld(shpnt)[ldn].device_type, scsi_cmd, ldn); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1872 | #endif |
| 1873 | |
| 1874 | /* for possible panics store current command */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1875 | last_scsi_command(shpnt)[ldn] = scsi_cmd; |
| 1876 | last_scsi_type(shpnt)[ldn] = IM_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1877 | /* update statistical info */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1878 | IBM_DS(shpnt).total_accesses++; |
| 1879 | IBM_DS(shpnt).ldn_access[ldn]++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1880 | |
| 1881 | switch (scsi_cmd) { |
| 1882 | case READ_6: |
| 1883 | case WRITE_6: |
| 1884 | case READ_10: |
| 1885 | case WRITE_10: |
| 1886 | case READ_12: |
| 1887 | case WRITE_12: |
| 1888 | /* Distinguish between disk and other devices. Only disks (that are the |
| 1889 | most frequently accessed devices) should be supported by the |
| 1890 | IBM-SCSI-Subsystem commands. */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1891 | switch (ld(shpnt)[ldn].device_type) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1892 | case TYPE_DISK: /* for harddisks enter here ... */ |
| 1893 | case TYPE_MOD: /* ... try it also for MO-drives (send flames as */ |
| 1894 | /* you like, if this won't work.) */ |
| 1895 | if (scsi_cmd == READ_6 || scsi_cmd == READ_10 || scsi_cmd == READ_12) { |
| 1896 | /* read command preparations */ |
| 1897 | scb->enable |= IM_READ_CONTROL; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1898 | IBM_DS(shpnt).ldn_read_access[ldn]++; /* increase READ-access on ldn stat. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1899 | scb->command = IM_READ_DATA_CMD | IM_NO_DISCONNECT; |
| 1900 | } else { /* write command preparations */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1901 | IBM_DS(shpnt).ldn_write_access[ldn]++; /* increase write-count on ldn stat. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1902 | scb->command = IM_WRITE_DATA_CMD | IM_NO_DISCONNECT; |
| 1903 | } |
| 1904 | if (scsi_cmd == READ_6 || scsi_cmd == WRITE_6) { |
| 1905 | scb->u1.log_blk_adr = (((unsigned) cmd->cmnd[3]) << 0) | (((unsigned) cmd->cmnd[2]) << 8) | ((((unsigned) cmd->cmnd[1]) & 0x1f) << 16); |
| 1906 | scb->u2.blk.count = (unsigned) cmd->cmnd[4]; |
| 1907 | } else { |
| 1908 | scb->u1.log_blk_adr = (((unsigned) cmd->cmnd[5]) << 0) | (((unsigned) cmd->cmnd[4]) << 8) | (((unsigned) cmd->cmnd[3]) << 16) | (((unsigned) cmd->cmnd[2]) << 24); |
| 1909 | scb->u2.blk.count = (((unsigned) cmd->cmnd[8]) << 0) | (((unsigned) cmd->cmnd[7]) << 8); |
| 1910 | } |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1911 | last_scsi_logical_block(shpnt)[ldn] = scb->u1.log_blk_adr; |
| 1912 | last_scsi_blockcount(shpnt)[ldn] = scb->u2.blk.count; |
| 1913 | scb->u2.blk.length = ld(shpnt)[ldn].block_length; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1914 | break; |
| 1915 | /* for other devices, enter here. Other types are not known by |
| 1916 | Linux! TYPE_NO_LUN is forbidden as valid device. */ |
| 1917 | case TYPE_ROM: |
| 1918 | case TYPE_TAPE: |
| 1919 | case TYPE_PROCESSOR: |
| 1920 | case TYPE_WORM: |
| 1921 | case TYPE_SCANNER: |
| 1922 | case TYPE_MEDIUM_CHANGER: |
| 1923 | /* If there is a sequential-device, IBM recommends to use |
| 1924 | IM_OTHER_SCSI_CMD_CMD instead of subsystem READ/WRITE. |
| 1925 | This includes CD-ROM devices, too, due to the partial sequential |
| 1926 | read capabilities. */ |
| 1927 | scb->command = IM_OTHER_SCSI_CMD_CMD; |
| 1928 | if (scsi_cmd == READ_6 || scsi_cmd == READ_10 || scsi_cmd == READ_12) |
| 1929 | /* enable READ */ |
| 1930 | scb->enable |= IM_READ_CONTROL; |
| 1931 | scb->enable |= IM_BYPASS_BUFFER; |
| 1932 | scb->u1.scsi_cmd_length = cmd->cmd_len; |
| 1933 | memcpy(scb->u2.scsi_command, cmd->cmnd, cmd->cmd_len); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1934 | last_scsi_type(shpnt)[ldn] = IM_LONG_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1935 | /* Read/write on this non-disk devices is also displayworthy, |
| 1936 | so flash-up the LED/display. */ |
| 1937 | break; |
| 1938 | } |
| 1939 | break; |
| 1940 | case INQUIRY: |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1941 | IBM_DS(shpnt).ldn_inquiry_access[ldn]++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1942 | scb->command = IM_DEVICE_INQUIRY_CMD; |
| 1943 | scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER; |
| 1944 | scb->u1.log_blk_adr = 0; |
| 1945 | break; |
| 1946 | case TEST_UNIT_READY: |
| 1947 | scb->command = IM_OTHER_SCSI_CMD_CMD; |
| 1948 | scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER; |
| 1949 | scb->u1.log_blk_adr = 0; |
| 1950 | scb->u1.scsi_cmd_length = 6; |
| 1951 | memcpy(scb->u2.scsi_command, cmd->cmnd, 6); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1952 | last_scsi_type(shpnt)[ldn] = IM_LONG_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1953 | break; |
| 1954 | case READ_CAPACITY: |
| 1955 | /* the length of system memory buffer must be exactly 8 bytes */ |
| 1956 | scb->command = IM_READ_CAPACITY_CMD; |
| 1957 | scb->enable |= IM_READ_CONTROL | IM_BYPASS_BUFFER; |
| 1958 | if (scb->sys_buf_length > 8) |
| 1959 | scb->sys_buf_length = 8; |
| 1960 | break; |
| 1961 | /* Commands that need read-only-mode (system <- device): */ |
| 1962 | case REQUEST_SENSE: |
| 1963 | scb->command = IM_REQUEST_SENSE_CMD; |
| 1964 | scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER; |
| 1965 | break; |
| 1966 | /* Commands that need write-only-mode (system -> device): */ |
| 1967 | case MODE_SELECT: |
| 1968 | case MODE_SELECT_10: |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1969 | IBM_DS(shpnt).ldn_modeselect_access[ldn]++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1970 | scb->command = IM_OTHER_SCSI_CMD_CMD; |
| 1971 | scb->enable |= IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER; /*Select needs WRITE-enabled */ |
| 1972 | scb->u1.scsi_cmd_length = cmd->cmd_len; |
| 1973 | memcpy(scb->u2.scsi_command, cmd->cmnd, cmd->cmd_len); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1974 | last_scsi_type(shpnt)[ldn] = IM_LONG_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1975 | break; |
| 1976 | /* For other commands, read-only is useful. Most other commands are |
| 1977 | running without an input-data-block. */ |
| 1978 | default: |
| 1979 | scb->command = IM_OTHER_SCSI_CMD_CMD; |
| 1980 | scb->enable |= IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_BYPASS_BUFFER; |
| 1981 | scb->u1.scsi_cmd_length = cmd->cmd_len; |
| 1982 | memcpy(scb->u2.scsi_command, cmd->cmnd, cmd->cmd_len); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1983 | last_scsi_type(shpnt)[ldn] = IM_LONG_SCB; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1984 | break; |
| 1985 | } |
| 1986 | /*issue scb command, and return */ |
| 1987 | if (++disk_rw_in_progress == 1) |
| 1988 | PS2_DISK_LED_ON(shpnt->host_no, target); |
| 1989 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1990 | if (last_scsi_type(shpnt)[ldn] == IM_LONG_SCB) { |
| 1991 | issue_cmd(shpnt, isa_virt_to_bus(scb), IM_LONG_SCB | ldn); |
| 1992 | IBM_DS(shpnt).long_scbs++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1993 | } else { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 1994 | issue_cmd(shpnt, isa_virt_to_bus(scb), IM_SCB | ldn); |
| 1995 | IBM_DS(shpnt).scbs++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1996 | } |
| 1997 | return 0; |
| 1998 | } |
| 1999 | |
Jeff Garzik | 8fa728a | 2005-05-28 07:54:40 -0400 | [diff] [blame] | 2000 | static int __ibmmca_abort(Scsi_Cmnd * cmd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2001 | { |
| 2002 | /* Abort does not work, as the adapter never generates an interrupt on |
| 2003 | * whatever situation is simulated, even when really pending commands |
| 2004 | * are running on the adapters' hardware ! */ |
| 2005 | |
| 2006 | struct Scsi_Host *shpnt; |
| 2007 | unsigned int ldn; |
| 2008 | void (*saved_done) (Scsi_Cmnd *); |
| 2009 | int target; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2010 | int max_pun; |
| 2011 | unsigned long imm_command; |
| 2012 | |
| 2013 | #ifdef IM_DEBUG_PROBE |
| 2014 | printk("IBM MCA SCSI: Abort subroutine called...\n"); |
| 2015 | #endif |
| 2016 | |
| 2017 | shpnt = cmd->device->host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2018 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2019 | max_pun = subsystem_maxid(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2020 | if (ibm_ansi_order) { |
| 2021 | target = max_pun - 1 - cmd->device->id; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2022 | if ((target <= subsystem_pun(shpnt)) && (cmd->device->id <= subsystem_pun(shpnt))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2023 | target--; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2024 | else if ((target >= subsystem_pun(shpnt)) && (cmd->device->id >= subsystem_pun(shpnt))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2025 | target++; |
| 2026 | } else |
| 2027 | target = cmd->device->id; |
| 2028 | |
| 2029 | /* get logical device number, and disable system interrupts */ |
| 2030 | printk(KERN_WARNING "IBM MCA SCSI: Sending abort to device pun=%d, lun=%d.\n", target, cmd->device->lun); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2031 | ldn = get_ldn(shpnt)[target][cmd->device->lun]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2032 | |
| 2033 | /*if cmd for this ldn has already finished, no need to abort */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2034 | if (!ld(shpnt)[ldn].cmd) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2035 | return SUCCESS; |
| 2036 | } |
| 2037 | |
| 2038 | /* Clear ld.cmd, save done function, install internal done, |
| 2039 | * send abort immediate command (this enables sys. interrupts), |
| 2040 | * and wait until the interrupt arrives. |
| 2041 | */ |
| 2042 | saved_done = cmd->scsi_done; |
| 2043 | cmd->scsi_done = internal_done; |
| 2044 | cmd->SCp.Status = 0; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2045 | last_scsi_command(shpnt)[ldn] = IM_ABORT_IMM_CMD; |
| 2046 | last_scsi_type(shpnt)[ldn] = IM_IMM_CMD; |
| 2047 | imm_command = inl(IM_CMD_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2048 | imm_command &= (unsigned long) (0xffff0000); /* mask reserved stuff */ |
| 2049 | imm_command |= (unsigned long) (IM_ABORT_IMM_CMD); |
| 2050 | /* must wait for attention reg not busy */ |
| 2051 | /* FIXME - timeout, politeness */ |
| 2052 | while (1) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2053 | if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2054 | break; |
| 2055 | } |
| 2056 | /* write registers and enable system interrupts */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2057 | outl(imm_command, IM_CMD_REG(shpnt)); |
| 2058 | outb(IM_IMM_CMD | ldn, IM_ATTN_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2059 | #ifdef IM_DEBUG_PROBE |
| 2060 | printk("IBM MCA SCSI: Abort queued to adapter...\n"); |
| 2061 | #endif |
| 2062 | spin_unlock_irq(shpnt->host_lock); |
| 2063 | while (!cmd->SCp.Status) |
| 2064 | yield(); |
| 2065 | spin_lock_irq(shpnt->host_lock); |
| 2066 | cmd->scsi_done = saved_done; |
| 2067 | #ifdef IM_DEBUG_PROBE |
| 2068 | printk("IBM MCA SCSI: Abort returned with adapter response...\n"); |
| 2069 | #endif |
| 2070 | |
| 2071 | /*if abort went well, call saved done, then return success or error */ |
| 2072 | if (cmd->result == (DID_ABORT << 16)) |
| 2073 | { |
| 2074 | cmd->result |= DID_ABORT << 16; |
| 2075 | if (cmd->scsi_done) |
| 2076 | (cmd->scsi_done) (cmd); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2077 | ld(shpnt)[ldn].cmd = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2078 | #ifdef IM_DEBUG_PROBE |
| 2079 | printk("IBM MCA SCSI: Abort finished with success.\n"); |
| 2080 | #endif |
| 2081 | return SUCCESS; |
| 2082 | } else { |
| 2083 | cmd->result |= DID_NO_CONNECT << 16; |
| 2084 | if (cmd->scsi_done) |
| 2085 | (cmd->scsi_done) (cmd); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2086 | ld(shpnt)[ldn].cmd = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2087 | #ifdef IM_DEBUG_PROBE |
| 2088 | printk("IBM MCA SCSI: Abort failed.\n"); |
| 2089 | #endif |
| 2090 | return FAILED; |
| 2091 | } |
| 2092 | } |
| 2093 | |
Jeff Garzik | 8fa728a | 2005-05-28 07:54:40 -0400 | [diff] [blame] | 2094 | static int ibmmca_abort(Scsi_Cmnd * cmd) |
| 2095 | { |
| 2096 | struct Scsi_Host *shpnt = cmd->device->host; |
| 2097 | int rc; |
| 2098 | |
| 2099 | spin_lock_irq(shpnt->host_lock); |
| 2100 | rc = __ibmmca_abort(cmd); |
| 2101 | spin_unlock_irq(shpnt->host_lock); |
| 2102 | |
| 2103 | return rc; |
| 2104 | } |
| 2105 | |
Jeff Garzik | df0ae24 | 2005-05-28 07:57:14 -0400 | [diff] [blame] | 2106 | static int __ibmmca_host_reset(Scsi_Cmnd * cmd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2107 | { |
| 2108 | struct Scsi_Host *shpnt; |
| 2109 | Scsi_Cmnd *cmd_aid; |
| 2110 | int ticks, i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2111 | unsigned long imm_command; |
| 2112 | |
Eric Sesterhenn | 125e187 | 2006-06-23 02:06:06 -0700 | [diff] [blame] | 2113 | BUG_ON(cmd == NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2114 | |
| 2115 | ticks = IM_RESET_DELAY * HZ; |
| 2116 | shpnt = cmd->device->host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2117 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2118 | if (local_checking_phase_flag(shpnt)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2119 | printk(KERN_WARNING "IBM MCA SCSI: unable to reset while checking devices.\n"); |
| 2120 | return FAILED; |
| 2121 | } |
| 2122 | |
| 2123 | /* issue reset immediate command to subsystem, and wait for interrupt */ |
| 2124 | printk("IBM MCA SCSI: resetting all devices.\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2125 | reset_status(shpnt) = IM_RESET_IN_PROGRESS; |
| 2126 | last_scsi_command(shpnt)[0xf] = IM_RESET_IMM_CMD; |
| 2127 | last_scsi_type(shpnt)[0xf] = IM_IMM_CMD; |
| 2128 | imm_command = inl(IM_CMD_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2129 | imm_command &= (unsigned long) (0xffff0000); /* mask reserved stuff */ |
| 2130 | imm_command |= (unsigned long) (IM_RESET_IMM_CMD); |
| 2131 | /* must wait for attention reg not busy */ |
| 2132 | while (1) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2133 | if (!(inb(IM_STAT_REG(shpnt)) & IM_BUSY)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2134 | break; |
| 2135 | spin_unlock_irq(shpnt->host_lock); |
| 2136 | yield(); |
| 2137 | spin_lock_irq(shpnt->host_lock); |
| 2138 | } |
| 2139 | /*write registers and enable system interrupts */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2140 | outl(imm_command, IM_CMD_REG(shpnt)); |
| 2141 | outb(IM_IMM_CMD | 0xf, IM_ATTN_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2142 | /* wait for interrupt finished or intr_stat register to be set, as the |
| 2143 | * interrupt will not be executed, while we are in here! */ |
| 2144 | |
| 2145 | /* FIXME: This is really really icky we so want a sleeping version of this ! */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2146 | while (reset_status(shpnt) == IM_RESET_IN_PROGRESS && --ticks && ((inb(IM_INTR_REG(shpnt)) & 0x8f) != 0x8f)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2147 | udelay((1 + 999 / HZ) * 1000); |
| 2148 | barrier(); |
| 2149 | } |
| 2150 | /* if reset did not complete, just return an error */ |
| 2151 | if (!ticks) { |
| 2152 | printk(KERN_ERR "IBM MCA SCSI: reset did not complete within %d seconds.\n", IM_RESET_DELAY); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2153 | reset_status(shpnt) = IM_RESET_FINISHED_FAIL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2154 | return FAILED; |
| 2155 | } |
| 2156 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2157 | if ((inb(IM_INTR_REG(shpnt)) & 0x8f) == 0x8f) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2158 | /* analysis done by this routine and not by the intr-routine */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2159 | if (inb(IM_INTR_REG(shpnt)) == 0xaf) |
| 2160 | reset_status(shpnt) = IM_RESET_FINISHED_OK_NO_INT; |
| 2161 | else if (inb(IM_INTR_REG(shpnt)) == 0xcf) |
| 2162 | reset_status(shpnt) = IM_RESET_FINISHED_FAIL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2163 | else /* failed, 4get it */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2164 | reset_status(shpnt) = IM_RESET_NOT_IN_PROGRESS_NO_INT; |
| 2165 | outb(IM_EOI | 0xf, IM_ATTN_REG(shpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2166 | } |
| 2167 | |
| 2168 | /* if reset failed, just return an error */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2169 | if (reset_status(shpnt) == IM_RESET_FINISHED_FAIL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2170 | printk(KERN_ERR "IBM MCA SCSI: reset failed.\n"); |
| 2171 | return FAILED; |
| 2172 | } |
| 2173 | |
| 2174 | /* so reset finished ok - call outstanding done's, and return success */ |
| 2175 | printk(KERN_INFO "IBM MCA SCSI: Reset successfully completed.\n"); |
| 2176 | for (i = 0; i < MAX_LOG_DEV; i++) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2177 | cmd_aid = ld(shpnt)[i].cmd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2178 | if (cmd_aid && cmd_aid->scsi_done) { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2179 | ld(shpnt)[i].cmd = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2180 | cmd_aid->result = DID_RESET << 16; |
| 2181 | } |
| 2182 | } |
| 2183 | return SUCCESS; |
| 2184 | } |
| 2185 | |
Jeff Garzik | df0ae24 | 2005-05-28 07:57:14 -0400 | [diff] [blame] | 2186 | static int ibmmca_host_reset(Scsi_Cmnd * cmd) |
| 2187 | { |
| 2188 | struct Scsi_Host *shpnt = cmd->device->host; |
| 2189 | int rc; |
| 2190 | |
| 2191 | spin_lock_irq(shpnt->host_lock); |
| 2192 | rc = __ibmmca_host_reset(cmd); |
| 2193 | spin_unlock_irq(shpnt->host_lock); |
| 2194 | |
| 2195 | return rc; |
| 2196 | } |
| 2197 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2198 | static int ibmmca_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *info) |
| 2199 | { |
| 2200 | int size = capacity; |
| 2201 | info[0] = 64; |
| 2202 | info[1] = 32; |
| 2203 | info[2] = size / (info[0] * info[1]); |
| 2204 | if (info[2] >= 1024) { |
| 2205 | info[0] = 128; |
| 2206 | info[1] = 63; |
| 2207 | info[2] = size / (info[0] * info[1]); |
| 2208 | if (info[2] >= 1024) { |
| 2209 | info[0] = 255; |
| 2210 | info[1] = 63; |
| 2211 | info[2] = size / (info[0] * info[1]); |
| 2212 | if (info[2] >= 1024) |
| 2213 | info[2] = 1023; |
| 2214 | } |
| 2215 | } |
| 2216 | return 0; |
| 2217 | } |
| 2218 | |
| 2219 | /* calculate percentage of total accesses on a ldn */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2220 | static int ldn_access_load(struct Scsi_Host *shpnt, int ldn) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2221 | { |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2222 | if (IBM_DS(shpnt).total_accesses == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2223 | return (0); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2224 | if (IBM_DS(shpnt).ldn_access[ldn] == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2225 | return (0); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2226 | return (IBM_DS(shpnt).ldn_access[ldn] * 100) / IBM_DS(shpnt).total_accesses; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2227 | } |
| 2228 | |
| 2229 | /* calculate total amount of r/w-accesses */ |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2230 | static int ldn_access_total_read_write(struct Scsi_Host *shpnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2231 | { |
| 2232 | int a; |
| 2233 | int i; |
| 2234 | |
| 2235 | a = 0; |
| 2236 | for (i = 0; i <= MAX_LOG_DEV; i++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2237 | a += IBM_DS(shpnt).ldn_read_access[i] + IBM_DS(shpnt).ldn_write_access[i]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2238 | return (a); |
| 2239 | } |
| 2240 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2241 | static int ldn_access_total_inquiry(struct Scsi_Host *shpnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2242 | { |
| 2243 | int a; |
| 2244 | int i; |
| 2245 | |
| 2246 | a = 0; |
| 2247 | for (i = 0; i <= MAX_LOG_DEV; i++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2248 | a += IBM_DS(shpnt).ldn_inquiry_access[i]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2249 | return (a); |
| 2250 | } |
| 2251 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2252 | static int ldn_access_total_modeselect(struct Scsi_Host *shpnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2253 | { |
| 2254 | int a; |
| 2255 | int i; |
| 2256 | |
| 2257 | a = 0; |
| 2258 | for (i = 0; i <= MAX_LOG_DEV; i++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2259 | a += IBM_DS(shpnt).ldn_modeselect_access[i]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2260 | return (a); |
| 2261 | } |
| 2262 | |
| 2263 | /* routine to display info in the proc-fs-structure (a deluxe feature) */ |
| 2264 | static int ibmmca_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout) |
| 2265 | { |
| 2266 | int len = 0; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2267 | int i, id, lun; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2268 | unsigned long flags; |
| 2269 | int max_pun; |
| 2270 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2271 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2272 | spin_lock_irqsave(shpnt->host_lock, flags); /* Check it */ |
| 2273 | |
| 2274 | max_pun = subsystem_maxid(shpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2275 | |
| 2276 | len += sprintf(buffer + len, "\n IBM-SCSI-Subsystem-Linux-Driver, Version %s\n\n\n", IBMMCA_SCSI_DRIVER_VERSION); |
| 2277 | len += sprintf(buffer + len, " SCSI Access-Statistics:\n"); |
| 2278 | len += sprintf(buffer + len, " Device Scanning Order....: %s\n", (ibm_ansi_order) ? "IBM/ANSI" : "New Industry Standard"); |
| 2279 | #ifdef CONFIG_SCSI_MULTI_LUN |
| 2280 | len += sprintf(buffer + len, " Multiple LUN probing.....: Yes\n"); |
| 2281 | #else |
| 2282 | len += sprintf(buffer + len, " Multiple LUN probing.....: No\n"); |
| 2283 | #endif |
| 2284 | len += sprintf(buffer + len, " This Hostnumber..........: %d\n", shpnt->host_no); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2285 | len += sprintf(buffer + len, " Base I/O-Port............: 0x%x\n", (unsigned int) (IM_CMD_REG(shpnt))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2286 | len += sprintf(buffer + len, " (Shared) IRQ.............: %d\n", IM_IRQ); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2287 | len += sprintf(buffer + len, " Total Interrupts.........: %d\n", IBM_DS(shpnt).total_interrupts); |
| 2288 | len += sprintf(buffer + len, " Total SCSI Accesses......: %d\n", IBM_DS(shpnt).total_accesses); |
| 2289 | len += sprintf(buffer + len, " Total short SCBs.........: %d\n", IBM_DS(shpnt).scbs); |
| 2290 | len += sprintf(buffer + len, " Total long SCBs..........: %d\n", IBM_DS(shpnt).long_scbs); |
| 2291 | len += sprintf(buffer + len, " Total SCSI READ/WRITE..: %d\n", ldn_access_total_read_write(shpnt)); |
| 2292 | len += sprintf(buffer + len, " Total SCSI Inquiries...: %d\n", ldn_access_total_inquiry(shpnt)); |
| 2293 | len += sprintf(buffer + len, " Total SCSI Modeselects.: %d\n", ldn_access_total_modeselect(shpnt)); |
| 2294 | len += sprintf(buffer + len, " Total SCSI other cmds..: %d\n", IBM_DS(shpnt).total_accesses - ldn_access_total_read_write(shpnt) |
| 2295 | - ldn_access_total_modeselect(shpnt) |
| 2296 | - ldn_access_total_inquiry(shpnt)); |
| 2297 | len += sprintf(buffer + len, " Total SCSI command fails.: %d\n\n", IBM_DS(shpnt).total_errors); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2298 | len += sprintf(buffer + len, " Logical-Device-Number (LDN) Access-Statistics:\n"); |
| 2299 | len += sprintf(buffer + len, " LDN | Accesses [%%] | READ | WRITE | ASSIGNMENTS\n"); |
| 2300 | len += sprintf(buffer + len, " -----|--------------|-----------|-----------|--------------\n"); |
| 2301 | for (i = 0; i <= MAX_LOG_DEV; i++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2302 | len += sprintf(buffer + len, " %2X | %3d | %8d | %8d | %8d\n", i, ldn_access_load(shpnt, i), IBM_DS(shpnt).ldn_read_access[i], IBM_DS(shpnt).ldn_write_access[i], IBM_DS(shpnt).ldn_assignments[i]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2303 | len += sprintf(buffer + len, " -----------------------------------------------------------\n\n"); |
| 2304 | len += sprintf(buffer + len, " Dynamical-LDN-Assignment-Statistics:\n"); |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2305 | len += sprintf(buffer + len, " Number of physical SCSI-devices..: %d (+ Adapter)\n", IBM_DS(shpnt).total_scsi_devices); |
| 2306 | len += sprintf(buffer + len, " Dynamical Assignment necessary...: %s\n", IBM_DS(shpnt).dyn_flag ? "Yes" : "No "); |
| 2307 | len += sprintf(buffer + len, " Next LDN to be assigned..........: 0x%x\n", next_ldn(shpnt)); |
| 2308 | len += sprintf(buffer + len, " Dynamical assignments done yet...: %d\n", IBM_DS(shpnt).dynamical_assignments); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2309 | len += sprintf(buffer + len, "\n Current SCSI-Device-Mapping:\n"); |
| 2310 | len += sprintf(buffer + len, " Physical SCSI-Device Map Logical SCSI-Device Map\n"); |
| 2311 | len += sprintf(buffer + len, " ID\\LUN 0 1 2 3 4 5 6 7 ID\\LUN 0 1 2 3 4 5 6 7\n"); |
| 2312 | for (id = 0; id < max_pun; id++) { |
| 2313 | len += sprintf(buffer + len, " %2d ", id); |
| 2314 | for (lun = 0; lun < 8; lun++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2315 | len += sprintf(buffer + len, "%2s ", ti_p(get_scsi(shpnt)[id][lun])); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2316 | len += sprintf(buffer + len, " %2d ", id); |
| 2317 | for (lun = 0; lun < 8; lun++) |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2318 | len += sprintf(buffer + len, "%2s ", ti_l(get_ldn(shpnt)[id][lun])); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2319 | len += sprintf(buffer + len, "\n"); |
| 2320 | } |
| 2321 | |
| 2322 | len += sprintf(buffer + len, "(A = IBM-Subsystem, D = Harddisk, T = Tapedrive, P = Processor, W = WORM,\n"); |
| 2323 | len += sprintf(buffer + len, " R = CD-ROM, S = Scanner, M = MO-Drive, C = Medium-Changer, + = unprovided LUN,\n"); |
| 2324 | len += sprintf(buffer + len, " - = nothing found, nothing assigned or unprobed LUN)\n\n"); |
| 2325 | |
| 2326 | *start = buffer + offset; |
| 2327 | len -= offset; |
| 2328 | if (len > length) |
| 2329 | len = length; |
| 2330 | spin_unlock_irqrestore(shpnt->host_lock, flags); |
| 2331 | return len; |
| 2332 | } |
| 2333 | |
| 2334 | static int option_setup(char *str) |
| 2335 | { |
| 2336 | int ints[IM_MAX_HOSTS]; |
| 2337 | char *cur = str; |
| 2338 | int i = 1; |
| 2339 | |
| 2340 | while (cur && isdigit(*cur) && i <= IM_MAX_HOSTS) { |
| 2341 | ints[i++] = simple_strtoul(cur, NULL, 0); |
| 2342 | if ((cur = strchr(cur, ',')) != NULL) |
| 2343 | cur++; |
| 2344 | } |
| 2345 | ints[0] = i - 1; |
| 2346 | internal_ibmmca_scsi_setup(cur, ints); |
OGAWA Hirofumi | 9b41046 | 2006-03-31 02:30:33 -0800 | [diff] [blame] | 2347 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2348 | } |
| 2349 | |
| 2350 | __setup("ibmmcascsi=", option_setup); |
| 2351 | |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2352 | static struct mca_driver ibmmca_driver = { |
| 2353 | .id_table = ibmmca_id_table, |
| 2354 | .driver = { |
| 2355 | .name = "ibmmca", |
| 2356 | .bus = &mca_bus_type, |
| 2357 | .probe = ibmmca_probe, |
| 2358 | .remove = __devexit_p(ibmmca_remove), |
| 2359 | }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2360 | }; |
James Bottomley | 67b2009 | 2007-05-03 11:13:08 -0500 | [diff] [blame] | 2361 | |
| 2362 | static int __init ibmmca_init(void) |
| 2363 | { |
| 2364 | #ifdef MODULE |
| 2365 | /* If the driver is run as module, read from conf.modules or cmd-line */ |
| 2366 | if (boot_options) |
| 2367 | option_setup(boot_options); |
| 2368 | #endif |
| 2369 | |
| 2370 | return mca_register_driver_integrated(&ibmmca_driver, MCA_INTEGSCSI); |
| 2371 | } |
| 2372 | |
| 2373 | static void __exit ibmmca_exit(void) |
| 2374 | { |
| 2375 | mca_unregister_driver(&ibmmca_driver); |
| 2376 | } |
| 2377 | |
| 2378 | module_init(ibmmca_init); |
| 2379 | module_exit(ibmmca_exit); |