1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /************************************************************************** |
3 | * Initio 9100 device driver for Linux. |
4 | * |
5 | * Copyright (c) 1994-1998 Initio Corporation |
6 | * Copyright (c) 1998 Bas Vermeulen <bvermeul@blackstar.xs4all.nl> |
7 | * Copyright (c) 2004 Christoph Hellwig <hch@lst.de> |
8 | * Copyright (c) 2007 Red Hat |
9 | * |
10 | ************************************************************************* |
11 | * |
12 | * DESCRIPTION: |
13 | * |
14 | * This is the Linux low-level SCSI driver for Initio INI-9X00U/UW SCSI host |
15 | * adapters |
16 | * |
17 | * 08/06/97 hc - v1.01h |
18 | * - Support inic-940 and inic-935 |
19 | * 09/26/97 hc - v1.01i |
20 | * - Make correction from J.W. Schultz suggestion |
21 | * 10/13/97 hc - Support reset function |
22 | * 10/21/97 hc - v1.01j |
23 | * - Support 32 LUN (SCSI 3) |
24 | * 01/14/98 hc - v1.01k |
25 | * - Fix memory allocation problem |
26 | * 03/04/98 hc - v1.01l |
27 | * - Fix tape rewind which will hang the system problem |
28 | * - Set can_queue to initio_num_scb |
29 | * 06/25/98 hc - v1.01m |
30 | * - Get it work for kernel version >= 2.1.75 |
31 | * - Dynamic assign SCSI bus reset holding time in initio_init() |
32 | * 07/02/98 hc - v1.01n |
33 | * - Support 0002134A |
34 | * 08/07/98 hc - v1.01o |
35 | * - Change the initio_abort_srb routine to use scsi_done. <01> |
36 | * 09/07/98 hl - v1.02 |
37 | * - Change the INI9100U define and proc_dir_entry to |
38 | * reflect the newer Kernel 2.1.118, but the v1.o1o |
39 | * should work with Kernel 2.1.118. |
40 | * 09/20/98 wh - v1.02a |
41 | * - Support Abort command. |
42 | * - Handle reset routine. |
43 | * 09/21/98 hl - v1.03 |
44 | * - remove comments. |
45 | * 12/09/98 bv - v1.03a |
46 | * - Removed unused code |
47 | * 12/13/98 bv - v1.03b |
48 | * - Remove cli() locking for kernels >= 2.1.95. This uses |
49 | * spinlocks to serialize access to the pSRB_head and |
50 | * pSRB_tail members of the HCS structure. |
51 | * 09/01/99 bv - v1.03d |
52 | * - Fixed a deadlock problem in SMP. |
53 | * 21/01/99 bv - v1.03e |
54 | * - Add support for the Domex 3192U PCI SCSI |
55 | * This is a slightly modified patch by |
56 | * Brian Macy <bmacy@sunshinecomputing.com> |
57 | * 22/02/99 bv - v1.03f |
58 | * - Didn't detect the INIC-950 in 2.0.x correctly. |
59 | * Now fixed. |
60 | * 05/07/99 bv - v1.03g |
61 | * - Changed the assumption that HZ = 100 |
62 | * 10/17/03 mc - v1.04 |
63 | * - added new DMA API support |
64 | * 06/01/04 jmd - v1.04a |
65 | * - Re-add reset_bus support |
66 | **************************************************************************/ |
67 | |
68 | #include <linux/module.h> |
69 | #include <linux/errno.h> |
70 | #include <linux/delay.h> |
71 | #include <linux/pci.h> |
72 | #include <linux/init.h> |
73 | #include <linux/blkdev.h> |
74 | #include <linux/spinlock.h> |
75 | #include <linux/stat.h> |
76 | #include <linux/kernel.h> |
77 | #include <linux/proc_fs.h> |
78 | #include <linux/string.h> |
79 | #include <linux/interrupt.h> |
80 | #include <linux/ioport.h> |
81 | #include <linux/slab.h> |
82 | #include <linux/jiffies.h> |
83 | #include <linux/dma-mapping.h> |
84 | #include <asm/io.h> |
85 | |
86 | #include <scsi/scsi.h> |
87 | #include <scsi/scsi_cmnd.h> |
88 | #include <scsi/scsi_device.h> |
89 | #include <scsi/scsi_host.h> |
90 | #include <scsi/scsi_tcq.h> |
91 | |
92 | #include "initio.h" |
93 | |
94 | #define SENSE_SIZE 14 |
95 | |
96 | #define i91u_MAXQUEUE 2 |
97 | #define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.04a" |
98 | |
99 | #ifdef DEBUG_i91u |
100 | static unsigned int i91u_debug = DEBUG_DEFAULT; |
101 | #endif |
102 | |
103 | static int initio_tag_enable = 1; |
104 | |
105 | #ifdef DEBUG_i91u |
106 | static int setup_debug = 0; |
107 | #endif |
108 | |
109 | static void i91uSCBPost(u8 * pHcb, u8 * pScb); |
110 | |
111 | #define DEBUG_INTERRUPT 0 |
112 | #define DEBUG_QUEUE 0 |
113 | #define DEBUG_STATE 0 |
114 | #define INT_DISC 0 |
115 | |
116 | /*--- forward references ---*/ |
117 | static struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun); |
118 | static struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host); |
119 | |
120 | static int tulip_main(struct initio_host * host); |
121 | |
122 | static int initio_next_state(struct initio_host * host); |
123 | static int initio_state_1(struct initio_host * host); |
124 | static int initio_state_2(struct initio_host * host); |
125 | static int initio_state_3(struct initio_host * host); |
126 | static int initio_state_4(struct initio_host * host); |
127 | static int initio_state_5(struct initio_host * host); |
128 | static int initio_state_6(struct initio_host * host); |
129 | static int initio_state_7(struct initio_host * host); |
130 | static int initio_xfer_data_in(struct initio_host * host); |
131 | static int initio_xfer_data_out(struct initio_host * host); |
132 | static int initio_xpad_in(struct initio_host * host); |
133 | static int initio_xpad_out(struct initio_host * host); |
134 | static int initio_status_msg(struct initio_host * host); |
135 | |
136 | static int initio_msgin(struct initio_host * host); |
137 | static int initio_msgin_sync(struct initio_host * host); |
138 | static int initio_msgin_accept(struct initio_host * host); |
139 | static int initio_msgout_reject(struct initio_host * host); |
140 | static int initio_msgin_extend(struct initio_host * host); |
141 | |
142 | static int initio_msgout_ide(struct initio_host * host); |
143 | static int initio_msgout_abort_targ(struct initio_host * host); |
144 | static int initio_msgout_abort_tag(struct initio_host * host); |
145 | |
146 | static int initio_bus_device_reset(struct initio_host * host); |
147 | static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb); |
148 | static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb); |
149 | static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb); |
150 | static int int_initio_busfree(struct initio_host * host); |
151 | static int int_initio_scsi_rst(struct initio_host * host); |
152 | static int int_initio_bad_seq(struct initio_host * host); |
153 | static int int_initio_resel(struct initio_host * host); |
154 | static int initio_sync_done(struct initio_host * host); |
155 | static int wdtr_done(struct initio_host * host); |
156 | static int wait_tulip(struct initio_host * host); |
157 | static int initio_wait_done_disc(struct initio_host * host); |
158 | static int initio_wait_disc(struct initio_host * host); |
159 | static void tulip_scsi(struct initio_host * host); |
160 | static int initio_post_scsi_rst(struct initio_host * host); |
161 | |
162 | static void initio_se2_ew_en(unsigned long base); |
163 | static void initio_se2_ew_ds(unsigned long base); |
164 | static int initio_se2_rd_all(unsigned long base); |
165 | static void initio_se2_update_all(unsigned long base); /* setup default pattern */ |
166 | static void initio_read_eeprom(unsigned long base); |
167 | |
168 | /* ---- INTERNAL VARIABLES ---- */ |
169 | |
170 | static NVRAM i91unvram; |
171 | static NVRAM *i91unvramp; |
172 | |
173 | static u8 i91udftNvRam[64] = |
174 | { |
175 | /*----------- header -----------*/ |
176 | 0x25, 0xc9, /* Signature */ |
177 | 0x40, /* Size */ |
178 | 0x01, /* Revision */ |
179 | /* -- Host Adapter Structure -- */ |
180 | 0x95, /* ModelByte0 */ |
181 | 0x00, /* ModelByte1 */ |
182 | 0x00, /* ModelInfo */ |
183 | 0x01, /* NumOfCh */ |
184 | NBC1_DEFAULT, /* BIOSConfig1 */ |
185 | 0, /* BIOSConfig2 */ |
186 | 0, /* HAConfig1 */ |
187 | 0, /* HAConfig2 */ |
188 | /* SCSI channel 0 and target Structure */ |
189 | 7, /* SCSIid */ |
190 | NCC1_DEFAULT, /* SCSIconfig1 */ |
191 | 0, /* SCSIconfig2 */ |
192 | 0x10, /* NumSCSItarget */ |
193 | |
194 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
195 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
196 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
197 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
198 | |
199 | /* SCSI channel 1 and target Structure */ |
200 | 7, /* SCSIid */ |
201 | NCC1_DEFAULT, /* SCSIconfig1 */ |
202 | 0, /* SCSIconfig2 */ |
203 | 0x10, /* NumSCSItarget */ |
204 | |
205 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
206 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
207 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
208 | NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, |
209 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
210 | 0, 0}; /* - CheckSum - */ |
211 | |
212 | |
213 | static u8 initio_rate_tbl[8] = /* fast 20 */ |
214 | { |
215 | /* nanosecond divide by 4 */ |
216 | 12, /* 50ns, 20M */ |
217 | 18, /* 75ns, 13.3M */ |
218 | 25, /* 100ns, 10M */ |
219 | 31, /* 125ns, 8M */ |
220 | 37, /* 150ns, 6.6M */ |
221 | 43, /* 175ns, 5.7M */ |
222 | 50, /* 200ns, 5M */ |
223 | 62 /* 250ns, 4M */ |
224 | }; |
225 | |
226 | static void initio_do_pause(unsigned amount) |
227 | { |
228 | /* Pause for amount jiffies */ |
229 | unsigned long the_time = jiffies + amount; |
230 | |
231 | while (time_before_eq(jiffies, the_time)) |
232 | cpu_relax(); |
233 | } |
234 | |
235 | /*-- forward reference --*/ |
236 | |
237 | /****************************************************************** |
238 | Input: instruction for Serial E2PROM |
239 | |
240 | EX: se2_rd(0 call se2_instr() to send address and read command |
241 | |
242 | StartBit OP_Code Address Data |
243 | --------- -------- ------------------ ------- |
244 | 1 1 , 0 A5,A4,A3,A2,A1,A0 D15-D0 |
245 | |
246 | +----------------------------------------------------- |
247 | | |
248 | CS -----+ |
249 | +--+ +--+ +--+ +--+ +--+ |
250 | ^ | ^ | ^ | ^ | ^ | |
251 | | | | | | | | | | | |
252 | CLK -------+ +--+ +--+ +--+ +--+ +-- |
253 | (leading edge trigger) |
254 | |
255 | +--1-----1--+ |
256 | | SB OP | OP A5 A4 |
257 | DI ----+ +--0------------------ |
258 | (address and cmd sent to nvram) |
259 | |
260 | -------------------------------------------+ |
261 | | |
262 | DO +--- |
263 | (data sent from nvram) |
264 | |
265 | |
266 | ******************************************************************/ |
267 | |
268 | /** |
269 | * initio_se2_instr - bitbang an instruction |
270 | * @base: Base of InitIO controller |
271 | * @instr: Instruction for serial E2PROM |
272 | * |
273 | * Bitbang an instruction out to the serial E2Prom |
274 | */ |
275 | |
276 | static void initio_se2_instr(unsigned long base, u8 instr) |
277 | { |
278 | int i; |
279 | u8 b; |
280 | |
281 | outb(SE2CS | SE2DO, port: base + TUL_NVRAM); /* cs+start bit */ |
282 | udelay(30); |
283 | outb(SE2CS | SE2CLK | SE2DO, port: base + TUL_NVRAM); /* +CLK */ |
284 | udelay(30); |
285 | |
286 | for (i = 0; i < 8; i++) { |
287 | if (instr & 0x80) |
288 | b = SE2CS | SE2DO; /* -CLK+dataBit */ |
289 | else |
290 | b = SE2CS; /* -CLK */ |
291 | outb(value: b, port: base + TUL_NVRAM); |
292 | udelay(30); |
293 | outb(value: b | SE2CLK, port: base + TUL_NVRAM); /* +CLK */ |
294 | udelay(30); |
295 | instr <<= 1; |
296 | } |
297 | outb(SE2CS, port: base + TUL_NVRAM); /* -CLK */ |
298 | udelay(30); |
299 | } |
300 | |
301 | |
302 | /** |
303 | * initio_se2_ew_en - Enable erase/write |
304 | * @base: Base address of InitIO controller |
305 | * |
306 | * Enable erase/write state of serial EEPROM |
307 | */ |
308 | void initio_se2_ew_en(unsigned long base) |
309 | { |
310 | initio_se2_instr(base, instr: 0x30); /* EWEN */ |
311 | outb(value: 0, port: base + TUL_NVRAM); /* -CS */ |
312 | udelay(30); |
313 | } |
314 | |
315 | |
316 | /** |
317 | * initio_se2_ew_ds - Disable erase/write |
318 | * @base: Base address of InitIO controller |
319 | * |
320 | * Disable erase/write state of serial EEPROM |
321 | */ |
322 | void initio_se2_ew_ds(unsigned long base) |
323 | { |
324 | initio_se2_instr(base, instr: 0); /* EWDS */ |
325 | outb(value: 0, port: base + TUL_NVRAM); /* -CS */ |
326 | udelay(30); |
327 | } |
328 | |
329 | |
330 | /** |
331 | * initio_se2_rd - read E2PROM word |
332 | * @base: Base of InitIO controller |
333 | * @addr: Address of word in E2PROM |
334 | * |
335 | * Read a word from the NV E2PROM device |
336 | */ |
337 | static u16 initio_se2_rd(unsigned long base, u8 addr) |
338 | { |
339 | u8 instr, rb; |
340 | u16 val = 0; |
341 | int i; |
342 | |
343 | instr = (u8) (addr | 0x80); |
344 | initio_se2_instr(base, instr); /* READ INSTR */ |
345 | |
346 | for (i = 15; i >= 0; i--) { |
347 | outb(SE2CS | SE2CLK, port: base + TUL_NVRAM); /* +CLK */ |
348 | udelay(30); |
349 | outb(SE2CS, port: base + TUL_NVRAM); /* -CLK */ |
350 | |
351 | /* sample data after the following edge of clock */ |
352 | rb = inb(port: base + TUL_NVRAM); |
353 | rb &= SE2DI; |
354 | val += (rb << i); |
355 | udelay(30); /* 6/20/95 */ |
356 | } |
357 | |
358 | outb(value: 0, port: base + TUL_NVRAM); /* no chip select */ |
359 | udelay(30); |
360 | return val; |
361 | } |
362 | |
363 | /** |
364 | * initio_se2_wr - read E2PROM word |
365 | * @base: Base of InitIO controller |
366 | * @addr: Address of word in E2PROM |
367 | * @val: Value to write |
368 | * |
369 | * Write a word to the NV E2PROM device. Used when recovering from |
370 | * a problem with the NV. |
371 | */ |
372 | static void initio_se2_wr(unsigned long base, u8 addr, u16 val) |
373 | { |
374 | u8 rb; |
375 | u8 instr; |
376 | int i; |
377 | |
378 | instr = (u8) (addr | 0x40); |
379 | initio_se2_instr(base, instr); /* WRITE INSTR */ |
380 | for (i = 15; i >= 0; i--) { |
381 | if (val & 0x8000) |
382 | outb(SE2CS | SE2DO, port: base + TUL_NVRAM); /* -CLK+dataBit 1 */ |
383 | else |
384 | outb(SE2CS, port: base + TUL_NVRAM); /* -CLK+dataBit 0 */ |
385 | udelay(30); |
386 | outb(SE2CS | SE2CLK, port: base + TUL_NVRAM); /* +CLK */ |
387 | udelay(30); |
388 | val <<= 1; |
389 | } |
390 | outb(SE2CS, port: base + TUL_NVRAM); /* -CLK */ |
391 | udelay(30); |
392 | outb(value: 0, port: base + TUL_NVRAM); /* -CS */ |
393 | udelay(30); |
394 | |
395 | outb(SE2CS, port: base + TUL_NVRAM); /* +CS */ |
396 | udelay(30); |
397 | |
398 | for (;;) { |
399 | outb(SE2CS | SE2CLK, port: base + TUL_NVRAM); /* +CLK */ |
400 | udelay(30); |
401 | outb(SE2CS, port: base + TUL_NVRAM); /* -CLK */ |
402 | udelay(30); |
403 | if ((rb = inb(port: base + TUL_NVRAM)) & SE2DI) |
404 | break; /* write complete */ |
405 | } |
406 | outb(value: 0, port: base + TUL_NVRAM); /* -CS */ |
407 | } |
408 | |
409 | /** |
410 | * initio_se2_rd_all - read hostadapter NV configuration |
411 | * @base: Base address of InitIO controller |
412 | * |
413 | * Reads the E2PROM data into main memory. Ensures that the checksum |
414 | * and header marker are valid. Returns 1 on success -1 on error. |
415 | */ |
416 | |
417 | static int initio_se2_rd_all(unsigned long base) |
418 | { |
419 | int i; |
420 | u16 chksum = 0; |
421 | u16 *np; |
422 | |
423 | i91unvramp = &i91unvram; |
424 | np = (u16 *) i91unvramp; |
425 | for (i = 0; i < 32; i++) |
426 | *np++ = initio_se2_rd(base, addr: i); |
427 | |
428 | /* Is signature "ini" ok ? */ |
429 | if (i91unvramp->NVM_Signature != INI_SIGNATURE) |
430 | return -1; |
431 | /* Is ckecksum ok ? */ |
432 | np = (u16 *) i91unvramp; |
433 | for (i = 0; i < 31; i++) |
434 | chksum += *np++; |
435 | if (i91unvramp->NVM_CheckSum != chksum) |
436 | return -1; |
437 | return 1; |
438 | } |
439 | |
440 | /** |
441 | * initio_se2_update_all - Update E2PROM |
442 | * @base: Base of InitIO controller |
443 | * |
444 | * Update the E2PROM by wrting any changes into the E2PROM |
445 | * chip, rewriting the checksum. |
446 | */ |
447 | static void initio_se2_update_all(unsigned long base) |
448 | { /* setup default pattern */ |
449 | int i; |
450 | u16 chksum = 0; |
451 | u16 *np, *np1; |
452 | |
453 | i91unvramp = &i91unvram; |
454 | /* Calculate checksum first */ |
455 | np = (u16 *) i91udftNvRam; |
456 | for (i = 0; i < 31; i++) |
457 | chksum += *np++; |
458 | *np = chksum; |
459 | initio_se2_ew_en(base); /* Enable write */ |
460 | |
461 | np = (u16 *) i91udftNvRam; |
462 | np1 = (u16 *) i91unvramp; |
463 | for (i = 0; i < 32; i++, np++, np1++) { |
464 | if (*np != *np1) |
465 | initio_se2_wr(base, addr: i, val: *np); |
466 | } |
467 | initio_se2_ew_ds(base); /* Disable write */ |
468 | } |
469 | |
470 | /** |
471 | * initio_read_eeprom - Retrieve configuration |
472 | * @base: Base of InitIO Host Adapter |
473 | * |
474 | * Retrieve the host adapter configuration data from E2Prom. If the |
475 | * data is invalid then the defaults are used and are also restored |
476 | * into the E2PROM. This forms the access point for the SCSI driver |
477 | * into the E2PROM layer, the other functions for the E2PROM are all |
478 | * internal use. |
479 | * |
480 | * Must be called single threaded, uses a shared global area. |
481 | */ |
482 | |
483 | static void initio_read_eeprom(unsigned long base) |
484 | { |
485 | u8 gctrl; |
486 | |
487 | i91unvramp = &i91unvram; |
488 | /* Enable EEProm programming */ |
489 | gctrl = inb(port: base + TUL_GCTRL); |
490 | outb(value: gctrl | TUL_GCTRL_EEPROM_BIT, port: base + TUL_GCTRL); |
491 | if (initio_se2_rd_all(base) != 1) { |
492 | initio_se2_update_all(base); /* setup default pattern */ |
493 | initio_se2_rd_all(base); /* load again */ |
494 | } |
495 | /* Disable EEProm programming */ |
496 | gctrl = inb(port: base + TUL_GCTRL); |
497 | outb(value: gctrl & ~TUL_GCTRL_EEPROM_BIT, port: base + TUL_GCTRL); |
498 | } |
499 | |
500 | /** |
501 | * initio_stop_bm - stop bus master |
502 | * @host: InitIO we are stopping |
503 | * |
504 | * Stop any pending DMA operation, aborting the DMA if necessary |
505 | */ |
506 | |
507 | static void initio_stop_bm(struct initio_host * host) |
508 | { |
509 | |
510 | if (inb(port: host->addr + TUL_XStatus) & XPEND) { /* if DMA xfer is pending, abort DMA xfer */ |
511 | outb(TAX_X_ABT | TAX_X_CLR_FIFO, port: host->addr + TUL_XCmd); |
512 | /* wait Abort DMA xfer done */ |
513 | while ((inb(port: host->addr + TUL_Int) & XABT) == 0) |
514 | cpu_relax(); |
515 | } |
516 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
517 | } |
518 | |
519 | /** |
520 | * initio_reset_scsi - Reset SCSI host controller |
521 | * @host: InitIO host to reset |
522 | * @seconds: Recovery time |
523 | * |
524 | * Perform a full reset of the SCSI subsystem. |
525 | */ |
526 | |
527 | static int initio_reset_scsi(struct initio_host * host, int seconds) |
528 | { |
529 | outb(TSC_RST_BUS, port: host->addr + TUL_SCtrl0); |
530 | |
531 | while (!((host->jsint = inb(port: host->addr + TUL_SInt)) & TSS_SCSIRST_INT)) |
532 | cpu_relax(); |
533 | |
534 | /* reset tulip chip */ |
535 | outb(value: 0, port: host->addr + TUL_SSignal); |
536 | |
537 | /* Stall for a while, wait for target's firmware ready,make it 2 sec ! */ |
538 | /* SONY 5200 tape drive won't work if only stall for 1 sec */ |
539 | /* FIXME: this is a very long busy wait right now */ |
540 | initio_do_pause(amount: seconds * HZ); |
541 | |
542 | inb(port: host->addr + TUL_SInt); |
543 | return SCSI_RESET_SUCCESS; |
544 | } |
545 | |
546 | /** |
547 | * initio_init - set up an InitIO host adapter |
548 | * @host: InitIO host adapter |
549 | * @bios_addr: BIOS address |
550 | * |
551 | * Set up the host adapter and devices according to the configuration |
552 | * retrieved from the E2PROM. |
553 | * |
554 | * Locking: Calls E2PROM layer code which is not re-enterable so must |
555 | * run single threaded for now. |
556 | */ |
557 | |
558 | static void initio_init(struct initio_host * host, u8 *bios_addr) |
559 | { |
560 | int i; |
561 | u8 *flags; |
562 | u8 *heads; |
563 | |
564 | /* Get E2Prom configuration */ |
565 | initio_read_eeprom(base: host->addr); |
566 | if (i91unvramp->NVM_SCSIInfo[0].NVM_NumOfTarg == 8) |
567 | host->max_tar = 8; |
568 | else |
569 | host->max_tar = 16; |
570 | |
571 | host->config = i91unvramp->NVM_SCSIInfo[0].NVM_ChConfig1; |
572 | |
573 | host->scsi_id = i91unvramp->NVM_SCSIInfo[0].NVM_ChSCSIID; |
574 | host->idmask = ~(1 << host->scsi_id); |
575 | |
576 | #ifdef CHK_PARITY |
577 | /* Enable parity error response */ |
578 | outb(inb(host->addr + TUL_PCMD) | 0x40, host->addr + TUL_PCMD); |
579 | #endif |
580 | |
581 | /* Mask all the interrupt */ |
582 | outb(value: 0x1F, port: host->addr + TUL_Mask); |
583 | |
584 | initio_stop_bm(host); |
585 | /* --- Initialize the tulip --- */ |
586 | outb(TSC_RST_CHIP, port: host->addr + TUL_SCtrl0); |
587 | |
588 | /* program HBA's SCSI ID */ |
589 | outb(value: host->scsi_id << 4, port: host->addr + TUL_SScsiId); |
590 | |
591 | /* Enable Initiator Mode ,phase latch,alternate sync period mode, |
592 | disable SCSI reset */ |
593 | if (host->config & HCC_EN_PAR) |
594 | host->sconf1 = (TSC_INITDEFAULT | TSC_EN_SCSI_PAR); |
595 | else |
596 | host->sconf1 = (TSC_INITDEFAULT); |
597 | outb(value: host->sconf1, port: host->addr + TUL_SConfig); |
598 | |
599 | /* Enable HW reselect */ |
600 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); |
601 | |
602 | outb(value: 0, port: host->addr + TUL_SPeriod); |
603 | |
604 | /* selection time out = 250 ms */ |
605 | outb(value: 153, port: host->addr + TUL_STimeOut); |
606 | |
607 | /* Enable SCSI terminator */ |
608 | outb(value: (host->config & (HCC_ACT_TERM1 | HCC_ACT_TERM2)), |
609 | port: host->addr + TUL_XCtrl); |
610 | outb(value: ((host->config & HCC_AUTO_TERM) >> 4) | |
611 | (inb(port: host->addr + TUL_GCTRL1) & 0xFE), |
612 | port: host->addr + TUL_GCTRL1); |
613 | |
614 | for (i = 0, |
615 | flags = & (i91unvramp->NVM_SCSIInfo[0].NVM_Targ0Config), |
616 | heads = bios_addr + 0x180; |
617 | i < host->max_tar; |
618 | i++, flags++) { |
619 | host->targets[i].flags = *flags & ~(TCF_SYNC_DONE | TCF_WDTR_DONE); |
620 | if (host->targets[i].flags & TCF_EN_255) |
621 | host->targets[i].drv_flags = TCF_DRV_255_63; |
622 | else |
623 | host->targets[i].drv_flags = 0; |
624 | host->targets[i].js_period = 0; |
625 | host->targets[i].sconfig0 = host->sconf1; |
626 | host->targets[i].heads = *heads++; |
627 | if (host->targets[i].heads == 255) |
628 | host->targets[i].drv_flags = TCF_DRV_255_63; |
629 | else |
630 | host->targets[i].drv_flags = 0; |
631 | host->targets[i].sectors = *heads++; |
632 | host->targets[i].flags &= ~TCF_BUSY; |
633 | host->act_tags[i] = 0; |
634 | host->max_tags[i] = 0xFF; |
635 | } /* for */ |
636 | printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n" , |
637 | host->addr, host->pci_dev->irq, |
638 | host->bios_addr, host->scsi_id); |
639 | /* Reset SCSI Bus */ |
640 | if (host->config & HCC_SCSI_RESET) { |
641 | printk(KERN_INFO "i91u: Reset SCSI Bus ... \n" ); |
642 | initio_reset_scsi(host, seconds: 10); |
643 | } |
644 | outb(value: 0x17, port: host->addr + TUL_SCFG1); |
645 | outb(value: 0xE9, port: host->addr + TUL_SIntEnable); |
646 | } |
647 | |
648 | /** |
649 | * initio_alloc_scb - Allocate an SCB |
650 | * @host: InitIO host we are allocating for |
651 | * |
652 | * Walk the SCB list for the controller and allocate a free SCB if |
653 | * one exists. |
654 | */ |
655 | static struct scsi_ctrl_blk *initio_alloc_scb(struct initio_host *host) |
656 | { |
657 | struct scsi_ctrl_blk *scb; |
658 | unsigned long flags; |
659 | |
660 | spin_lock_irqsave(&host->avail_lock, flags); |
661 | if ((scb = host->first_avail) != NULL) { |
662 | #if DEBUG_QUEUE |
663 | printk("find scb at %p\n" , scb); |
664 | #endif |
665 | if ((host->first_avail = scb->next) == NULL) |
666 | host->last_avail = NULL; |
667 | scb->next = NULL; |
668 | scb->status = SCB_RENT; |
669 | } |
670 | spin_unlock_irqrestore(lock: &host->avail_lock, flags); |
671 | return scb; |
672 | } |
673 | |
674 | /** |
675 | * initio_release_scb - Release an SCB |
676 | * @host: InitIO host that owns the SCB |
677 | * @cmnd: SCB command block being returned |
678 | * |
679 | * Return an allocated SCB to the host free list |
680 | */ |
681 | |
682 | static void initio_release_scb(struct initio_host * host, struct scsi_ctrl_blk * cmnd) |
683 | { |
684 | unsigned long flags; |
685 | |
686 | #if DEBUG_QUEUE |
687 | printk("Release SCB %p; " , cmnd); |
688 | #endif |
689 | spin_lock_irqsave(&(host->avail_lock), flags); |
690 | cmnd->srb = NULL; |
691 | cmnd->status = 0; |
692 | cmnd->next = NULL; |
693 | if (host->last_avail != NULL) { |
694 | host->last_avail->next = cmnd; |
695 | host->last_avail = cmnd; |
696 | } else { |
697 | host->first_avail = cmnd; |
698 | host->last_avail = cmnd; |
699 | } |
700 | spin_unlock_irqrestore(lock: &(host->avail_lock), flags); |
701 | } |
702 | |
703 | /***************************************************************************/ |
704 | static void initio_append_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) |
705 | { |
706 | |
707 | #if DEBUG_QUEUE |
708 | printk("Append pend SCB %p; " , scbp); |
709 | #endif |
710 | scbp->status = SCB_PEND; |
711 | scbp->next = NULL; |
712 | if (host->last_pending != NULL) { |
713 | host->last_pending->next = scbp; |
714 | host->last_pending = scbp; |
715 | } else { |
716 | host->first_pending = scbp; |
717 | host->last_pending = scbp; |
718 | } |
719 | } |
720 | |
721 | /***************************************************************************/ |
722 | static void initio_push_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) |
723 | { |
724 | |
725 | #if DEBUG_QUEUE |
726 | printk("Push pend SCB %p; " , scbp); |
727 | #endif |
728 | scbp->status = SCB_PEND; |
729 | if ((scbp->next = host->first_pending) != NULL) { |
730 | host->first_pending = scbp; |
731 | } else { |
732 | host->first_pending = scbp; |
733 | host->last_pending = scbp; |
734 | } |
735 | } |
736 | |
737 | static struct scsi_ctrl_blk *initio_find_first_pend_scb(struct initio_host * host) |
738 | { |
739 | struct scsi_ctrl_blk *first; |
740 | |
741 | |
742 | first = host->first_pending; |
743 | while (first != NULL) { |
744 | if (first->opcode != ExecSCSI) |
745 | return first; |
746 | if (first->tagmsg == 0) { |
747 | if ((host->act_tags[first->target] == 0) && |
748 | !(host->targets[first->target].flags & TCF_BUSY)) |
749 | return first; |
750 | } else { |
751 | if ((host->act_tags[first->target] >= |
752 | host->max_tags[first->target]) | |
753 | (host->targets[first->target].flags & TCF_BUSY)) { |
754 | first = first->next; |
755 | continue; |
756 | } |
757 | return first; |
758 | } |
759 | first = first->next; |
760 | } |
761 | return first; |
762 | } |
763 | |
764 | static void initio_unlink_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scb) |
765 | { |
766 | struct scsi_ctrl_blk *tmp, *prev; |
767 | |
768 | #if DEBUG_QUEUE |
769 | printk("unlink pend SCB %p; " , scb); |
770 | #endif |
771 | |
772 | prev = tmp = host->first_pending; |
773 | while (tmp != NULL) { |
774 | if (scb == tmp) { /* Unlink this SCB */ |
775 | if (tmp == host->first_pending) { |
776 | if ((host->first_pending = tmp->next) == NULL) |
777 | host->last_pending = NULL; |
778 | } else { |
779 | prev->next = tmp->next; |
780 | if (tmp == host->last_pending) |
781 | host->last_pending = prev; |
782 | } |
783 | tmp->next = NULL; |
784 | break; |
785 | } |
786 | prev = tmp; |
787 | tmp = tmp->next; |
788 | } |
789 | } |
790 | |
791 | static void initio_append_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) |
792 | { |
793 | |
794 | #if DEBUG_QUEUE |
795 | printk("append busy SCB %p; " , scbp); |
796 | #endif |
797 | if (scbp->tagmsg) |
798 | host->act_tags[scbp->target]++; |
799 | else |
800 | host->targets[scbp->target].flags |= TCF_BUSY; |
801 | scbp->status = SCB_BUSY; |
802 | scbp->next = NULL; |
803 | if (host->last_busy != NULL) { |
804 | host->last_busy->next = scbp; |
805 | host->last_busy = scbp; |
806 | } else { |
807 | host->first_busy = scbp; |
808 | host->last_busy = scbp; |
809 | } |
810 | } |
811 | |
812 | /***************************************************************************/ |
813 | static struct scsi_ctrl_blk *initio_pop_busy_scb(struct initio_host * host) |
814 | { |
815 | struct scsi_ctrl_blk *tmp; |
816 | |
817 | |
818 | if ((tmp = host->first_busy) != NULL) { |
819 | if ((host->first_busy = tmp->next) == NULL) |
820 | host->last_busy = NULL; |
821 | tmp->next = NULL; |
822 | if (tmp->tagmsg) |
823 | host->act_tags[tmp->target]--; |
824 | else |
825 | host->targets[tmp->target].flags &= ~TCF_BUSY; |
826 | } |
827 | #if DEBUG_QUEUE |
828 | printk("Pop busy SCB %p; " , tmp); |
829 | #endif |
830 | return tmp; |
831 | } |
832 | |
833 | /***************************************************************************/ |
834 | static void initio_unlink_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scb) |
835 | { |
836 | struct scsi_ctrl_blk *tmp, *prev; |
837 | |
838 | #if DEBUG_QUEUE |
839 | printk("unlink busy SCB %p; " , scb); |
840 | #endif |
841 | |
842 | prev = tmp = host->first_busy; |
843 | while (tmp != NULL) { |
844 | if (scb == tmp) { /* Unlink this SCB */ |
845 | if (tmp == host->first_busy) { |
846 | if ((host->first_busy = tmp->next) == NULL) |
847 | host->last_busy = NULL; |
848 | } else { |
849 | prev->next = tmp->next; |
850 | if (tmp == host->last_busy) |
851 | host->last_busy = prev; |
852 | } |
853 | tmp->next = NULL; |
854 | if (tmp->tagmsg) |
855 | host->act_tags[tmp->target]--; |
856 | else |
857 | host->targets[tmp->target].flags &= ~TCF_BUSY; |
858 | break; |
859 | } |
860 | prev = tmp; |
861 | tmp = tmp->next; |
862 | } |
863 | return; |
864 | } |
865 | |
866 | struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun) |
867 | { |
868 | struct scsi_ctrl_blk *tmp; |
869 | u16 scbp_tarlun; |
870 | |
871 | |
872 | tmp = host->first_busy; |
873 | while (tmp != NULL) { |
874 | scbp_tarlun = (tmp->lun << 8) | (tmp->target); |
875 | if (scbp_tarlun == tarlun) { /* Unlink this SCB */ |
876 | break; |
877 | } |
878 | tmp = tmp->next; |
879 | } |
880 | #if DEBUG_QUEUE |
881 | printk("find busy SCB %p; " , tmp); |
882 | #endif |
883 | return tmp; |
884 | } |
885 | |
886 | static void initio_append_done_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) |
887 | { |
888 | #if DEBUG_QUEUE |
889 | printk("append done SCB %p; " , scbp); |
890 | #endif |
891 | |
892 | scbp->status = SCB_DONE; |
893 | scbp->next = NULL; |
894 | if (host->last_done != NULL) { |
895 | host->last_done->next = scbp; |
896 | host->last_done = scbp; |
897 | } else { |
898 | host->first_done = scbp; |
899 | host->last_done = scbp; |
900 | } |
901 | } |
902 | |
903 | struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host) |
904 | { |
905 | struct scsi_ctrl_blk *tmp; |
906 | |
907 | if ((tmp = host->first_done) != NULL) { |
908 | if ((host->first_done = tmp->next) == NULL) |
909 | host->last_done = NULL; |
910 | tmp->next = NULL; |
911 | } |
912 | #if DEBUG_QUEUE |
913 | printk("find done SCB %p; " ,tmp); |
914 | #endif |
915 | return tmp; |
916 | } |
917 | |
918 | static int initio_abort_srb(struct initio_host * host, struct scsi_cmnd *srbp) |
919 | { |
920 | unsigned long flags; |
921 | struct scsi_ctrl_blk *tmp, *prev; |
922 | |
923 | spin_lock_irqsave(&host->semaph_lock, flags); |
924 | |
925 | if ((host->semaph == 0) && (host->active == NULL)) { |
926 | /* disable Jasmin SCSI Int */ |
927 | outb(value: 0x1F, port: host->addr + TUL_Mask); |
928 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
929 | /* FIXME: synchronize_irq needed ? */ |
930 | tulip_main(host); |
931 | spin_lock_irqsave(&host->semaph_lock, flags); |
932 | host->semaph = 1; |
933 | outb(value: 0x0F, port: host->addr + TUL_Mask); |
934 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
935 | return SCSI_ABORT_SNOOZE; |
936 | } |
937 | prev = tmp = host->first_pending; /* Check Pend queue */ |
938 | while (tmp != NULL) { |
939 | /* 07/27/98 */ |
940 | if (tmp->srb == srbp) { |
941 | if (tmp == host->active) { |
942 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
943 | return SCSI_ABORT_BUSY; |
944 | } else if (tmp == host->first_pending) { |
945 | if ((host->first_pending = tmp->next) == NULL) |
946 | host->last_pending = NULL; |
947 | } else { |
948 | prev->next = tmp->next; |
949 | if (tmp == host->last_pending) |
950 | host->last_pending = prev; |
951 | } |
952 | tmp->hastat = HOST_ABORTED; |
953 | tmp->flags |= SCF_DONE; |
954 | if (tmp->flags & SCF_POST) |
955 | (*tmp->post) ((u8 *) host, (u8 *) tmp); |
956 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
957 | return SCSI_ABORT_SUCCESS; |
958 | } |
959 | prev = tmp; |
960 | tmp = tmp->next; |
961 | } |
962 | |
963 | prev = tmp = host->first_busy; /* Check Busy queue */ |
964 | while (tmp != NULL) { |
965 | if (tmp->srb == srbp) { |
966 | if (tmp == host->active) { |
967 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
968 | return SCSI_ABORT_BUSY; |
969 | } else if (tmp->tagmsg == 0) { |
970 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
971 | return SCSI_ABORT_BUSY; |
972 | } else { |
973 | host->act_tags[tmp->target]--; |
974 | if (tmp == host->first_busy) { |
975 | if ((host->first_busy = tmp->next) == NULL) |
976 | host->last_busy = NULL; |
977 | } else { |
978 | prev->next = tmp->next; |
979 | if (tmp == host->last_busy) |
980 | host->last_busy = prev; |
981 | } |
982 | tmp->next = NULL; |
983 | |
984 | |
985 | tmp->hastat = HOST_ABORTED; |
986 | tmp->flags |= SCF_DONE; |
987 | if (tmp->flags & SCF_POST) |
988 | (*tmp->post) ((u8 *) host, (u8 *) tmp); |
989 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
990 | return SCSI_ABORT_SUCCESS; |
991 | } |
992 | } |
993 | prev = tmp; |
994 | tmp = tmp->next; |
995 | } |
996 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
997 | return SCSI_ABORT_NOT_RUNNING; |
998 | } |
999 | |
1000 | /***************************************************************************/ |
1001 | static int initio_bad_seq(struct initio_host * host) |
1002 | { |
1003 | struct scsi_ctrl_blk *scb; |
1004 | |
1005 | printk("initio_bad_seg c=%d\n" , host->index); |
1006 | |
1007 | if ((scb = host->active) != NULL) { |
1008 | initio_unlink_busy_scb(host, scb); |
1009 | scb->hastat = HOST_BAD_PHAS; |
1010 | scb->tastat = 0; |
1011 | initio_append_done_scb(host, scbp: scb); |
1012 | } |
1013 | initio_stop_bm(host); |
1014 | initio_reset_scsi(host, seconds: 8); /* 7/29/98 */ |
1015 | return initio_post_scsi_rst(host); |
1016 | } |
1017 | |
1018 | |
1019 | /************************************************************************/ |
1020 | static void initio_exec_scb(struct initio_host * host, struct scsi_ctrl_blk * scb) |
1021 | { |
1022 | unsigned long flags; |
1023 | |
1024 | scb->mode = 0; |
1025 | |
1026 | scb->sgidx = 0; |
1027 | scb->sgmax = scb->sglen; |
1028 | |
1029 | spin_lock_irqsave(&host->semaph_lock, flags); |
1030 | |
1031 | initio_append_pend_scb(host, scbp: scb); /* Append this SCB to Pending queue */ |
1032 | |
1033 | /* VVVVV 07/21/98 */ |
1034 | if (host->semaph == 1) { |
1035 | /* Disable Jasmin SCSI Int */ |
1036 | outb(value: 0x1F, port: host->addr + TUL_Mask); |
1037 | host->semaph = 0; |
1038 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
1039 | |
1040 | tulip_main(host); |
1041 | |
1042 | spin_lock_irqsave(&host->semaph_lock, flags); |
1043 | host->semaph = 1; |
1044 | outb(value: 0x0F, port: host->addr + TUL_Mask); |
1045 | } |
1046 | spin_unlock_irqrestore(lock: &host->semaph_lock, flags); |
1047 | return; |
1048 | } |
1049 | |
1050 | /***************************************************************************/ |
1051 | static int initio_isr(struct initio_host * host) |
1052 | { |
1053 | if (inb(port: host->addr + TUL_Int) & TSS_INT_PENDING) { |
1054 | if (host->semaph == 1) { |
1055 | outb(value: 0x1F, port: host->addr + TUL_Mask); |
1056 | /* Disable Tulip SCSI Int */ |
1057 | host->semaph = 0; |
1058 | |
1059 | tulip_main(host); |
1060 | |
1061 | host->semaph = 1; |
1062 | outb(value: 0x0F, port: host->addr + TUL_Mask); |
1063 | return 1; |
1064 | } |
1065 | } |
1066 | return 0; |
1067 | } |
1068 | |
1069 | static int tulip_main(struct initio_host * host) |
1070 | { |
1071 | struct scsi_ctrl_blk *scb; |
1072 | |
1073 | for (;;) { |
1074 | tulip_scsi(host); /* Call tulip_scsi */ |
1075 | |
1076 | /* Walk the list of completed SCBs */ |
1077 | while ((scb = initio_find_done_scb(host)) != NULL) { /* find done entry */ |
1078 | if (scb->tastat == INI_QUEUE_FULL) { |
1079 | host->max_tags[scb->target] = |
1080 | host->act_tags[scb->target] - 1; |
1081 | scb->tastat = 0; |
1082 | initio_append_pend_scb(host, scbp: scb); |
1083 | continue; |
1084 | } |
1085 | if (!(scb->mode & SCM_RSENS)) { /* not in auto req. sense mode */ |
1086 | if (scb->tastat == 2) { |
1087 | |
1088 | /* clr sync. nego flag */ |
1089 | |
1090 | if (scb->flags & SCF_SENSE) { |
1091 | u8 len; |
1092 | len = scb->senselen; |
1093 | if (len == 0) |
1094 | len = 1; |
1095 | scb->buflen = scb->senselen; |
1096 | scb->bufptr = scb->senseptr; |
1097 | scb->flags &= ~(SCF_SG | SCF_DIR); /* for xfer_data_in */ |
1098 | /* so, we won't report wrong direction in xfer_data_in, |
1099 | and won't report HOST_DO_DU in state_6 */ |
1100 | scb->mode = SCM_RSENS; |
1101 | scb->ident &= 0xBF; /* Disable Disconnect */ |
1102 | scb->tagmsg = 0; |
1103 | scb->tastat = 0; |
1104 | scb->cdblen = 6; |
1105 | scb->cdb[0] = SCSICMD_RequestSense; |
1106 | scb->cdb[1] = 0; |
1107 | scb->cdb[2] = 0; |
1108 | scb->cdb[3] = 0; |
1109 | scb->cdb[4] = len; |
1110 | scb->cdb[5] = 0; |
1111 | initio_push_pend_scb(host, scbp: scb); |
1112 | break; |
1113 | } |
1114 | } |
1115 | } else { /* in request sense mode */ |
1116 | |
1117 | if (scb->tastat == 2) { /* check contition status again after sending |
1118 | requset sense cmd 0x3 */ |
1119 | scb->hastat = HOST_BAD_PHAS; |
1120 | } |
1121 | scb->tastat = 2; |
1122 | } |
1123 | scb->flags |= SCF_DONE; |
1124 | if (scb->flags & SCF_POST) { |
1125 | /* FIXME: only one post method and lose casts */ |
1126 | (*scb->post) ((u8 *) host, (u8 *) scb); |
1127 | } |
1128 | } /* while */ |
1129 | /* find_active: */ |
1130 | if (inb(port: host->addr + TUL_SStatus0) & TSS_INT_PENDING) |
1131 | continue; |
1132 | if (host->active) /* return to OS and wait for xfer_done_ISR/Selected_ISR */ |
1133 | return 1; /* return to OS, enable interrupt */ |
1134 | /* Check pending SCB */ |
1135 | if (initio_find_first_pend_scb(host) == NULL) |
1136 | return 1; /* return to OS, enable interrupt */ |
1137 | } /* End of for loop */ |
1138 | /* statement won't reach here */ |
1139 | } |
1140 | |
1141 | static void tulip_scsi(struct initio_host * host) |
1142 | { |
1143 | struct scsi_ctrl_blk *scb; |
1144 | struct target_control *active_tc; |
1145 | |
1146 | /* make sure to service interrupt asap */ |
1147 | if ((host->jsstatus0 = inb(port: host->addr + TUL_SStatus0)) & TSS_INT_PENDING) { |
1148 | host->phase = host->jsstatus0 & TSS_PH_MASK; |
1149 | host->jsstatus1 = inb(port: host->addr + TUL_SStatus1); |
1150 | host->jsint = inb(port: host->addr + TUL_SInt); |
1151 | if (host->jsint & TSS_SCSIRST_INT) { /* SCSI bus reset detected */ |
1152 | int_initio_scsi_rst(host); |
1153 | return; |
1154 | } |
1155 | if (host->jsint & TSS_RESEL_INT) { /* if selected/reselected interrupt */ |
1156 | if (int_initio_resel(host) == 0) |
1157 | initio_next_state(host); |
1158 | return; |
1159 | } |
1160 | if (host->jsint & TSS_SEL_TIMEOUT) { |
1161 | int_initio_busfree(host); |
1162 | return; |
1163 | } |
1164 | if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ |
1165 | int_initio_busfree(host); /* unexpected bus free or sel timeout */ |
1166 | return; |
1167 | } |
1168 | if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) { /* func complete or Bus service */ |
1169 | if (host->active) |
1170 | initio_next_state(host); |
1171 | return; |
1172 | } |
1173 | } |
1174 | if (host->active != NULL) |
1175 | return; |
1176 | |
1177 | if ((scb = initio_find_first_pend_scb(host)) == NULL) |
1178 | return; |
1179 | |
1180 | /* program HBA's SCSI ID & target SCSI ID */ |
1181 | outb(value: (host->scsi_id << 4) | (scb->target & 0x0F), |
1182 | port: host->addr + TUL_SScsiId); |
1183 | if (scb->opcode == ExecSCSI) { |
1184 | active_tc = &host->targets[scb->target]; |
1185 | |
1186 | if (scb->tagmsg) |
1187 | active_tc->drv_flags |= TCF_DRV_EN_TAG; |
1188 | else |
1189 | active_tc->drv_flags &= ~TCF_DRV_EN_TAG; |
1190 | |
1191 | outb(value: active_tc->js_period, port: host->addr + TUL_SPeriod); |
1192 | if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) { /* do wdtr negotiation */ |
1193 | initio_select_atn_stop(host, scb); |
1194 | } else { |
1195 | if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) { /* do sync negotiation */ |
1196 | initio_select_atn_stop(host, scb); |
1197 | } else { |
1198 | if (scb->tagmsg) |
1199 | initio_select_atn3(host, scb); |
1200 | else |
1201 | initio_select_atn(host, scb); |
1202 | } |
1203 | } |
1204 | if (scb->flags & SCF_POLL) { |
1205 | while (wait_tulip(host) != -1) { |
1206 | if (initio_next_state(host) == -1) |
1207 | break; |
1208 | } |
1209 | } |
1210 | } else if (scb->opcode == BusDevRst) { |
1211 | initio_select_atn_stop(host, scb); |
1212 | scb->next_state = 8; |
1213 | if (scb->flags & SCF_POLL) { |
1214 | while (wait_tulip(host) != -1) { |
1215 | if (initio_next_state(host) == -1) |
1216 | break; |
1217 | } |
1218 | } |
1219 | } else if (scb->opcode == AbortCmd) { |
1220 | if (initio_abort_srb(host, srbp: scb->srb) != 0) { |
1221 | initio_unlink_pend_scb(host, scb); |
1222 | initio_release_scb(host, cmnd: scb); |
1223 | } else { |
1224 | scb->opcode = BusDevRst; |
1225 | initio_select_atn_stop(host, scb); |
1226 | scb->next_state = 8; |
1227 | } |
1228 | } else { |
1229 | initio_unlink_pend_scb(host, scb); |
1230 | scb->hastat = 0x16; /* bad command */ |
1231 | initio_append_done_scb(host, scbp: scb); |
1232 | } |
1233 | return; |
1234 | } |
1235 | |
1236 | /** |
1237 | * initio_next_state - Next SCSI state |
1238 | * @host: InitIO host we are processing |
1239 | * |
1240 | * Progress the active command block along the state machine |
1241 | * until we hit a state which we must wait for activity to occur. |
1242 | * |
1243 | * Returns zero or a negative code. |
1244 | */ |
1245 | |
1246 | static int initio_next_state(struct initio_host * host) |
1247 | { |
1248 | int next; |
1249 | |
1250 | next = host->active->next_state; |
1251 | for (;;) { |
1252 | switch (next) { |
1253 | case 1: |
1254 | next = initio_state_1(host); |
1255 | break; |
1256 | case 2: |
1257 | next = initio_state_2(host); |
1258 | break; |
1259 | case 3: |
1260 | next = initio_state_3(host); |
1261 | break; |
1262 | case 4: |
1263 | next = initio_state_4(host); |
1264 | break; |
1265 | case 5: |
1266 | next = initio_state_5(host); |
1267 | break; |
1268 | case 6: |
1269 | next = initio_state_6(host); |
1270 | break; |
1271 | case 7: |
1272 | next = initio_state_7(host); |
1273 | break; |
1274 | case 8: |
1275 | return initio_bus_device_reset(host); |
1276 | default: |
1277 | return initio_bad_seq(host); |
1278 | } |
1279 | if (next <= 0) |
1280 | return next; |
1281 | } |
1282 | } |
1283 | |
1284 | |
1285 | /** |
1286 | * initio_state_1 - SCSI state machine |
1287 | * @host: InitIO host we are controlling |
1288 | * |
1289 | * Perform SCSI state processing for Select/Attention/Stop |
1290 | */ |
1291 | |
1292 | static int initio_state_1(struct initio_host * host) |
1293 | { |
1294 | struct scsi_ctrl_blk *scb = host->active; |
1295 | struct target_control *active_tc = host->active_tc; |
1296 | #if DEBUG_STATE |
1297 | printk("-s1-" ); |
1298 | #endif |
1299 | |
1300 | /* Move the SCB from pending to busy */ |
1301 | initio_unlink_pend_scb(host, scb); |
1302 | initio_append_busy_scb(host, scbp: scb); |
1303 | |
1304 | outb(value: active_tc->sconfig0, port: host->addr + TUL_SConfig ); |
1305 | /* ATN on */ |
1306 | if (host->phase == MSG_OUT) { |
1307 | outb(TSC_EN_BUS_IN | TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); |
1308 | outb(value: scb->ident, port: host->addr + TUL_SFifo); |
1309 | |
1310 | if (scb->tagmsg) { |
1311 | outb(value: scb->tagmsg, port: host->addr + TUL_SFifo); |
1312 | outb(value: scb->tagid, port: host->addr + TUL_SFifo); |
1313 | } |
1314 | if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) { |
1315 | active_tc->flags |= TCF_WDTR_DONE; |
1316 | outb(value: EXTENDED_MESSAGE, port: host->addr + TUL_SFifo); |
1317 | outb(value: 2, port: host->addr + TUL_SFifo); /* Extended msg length */ |
1318 | outb(EXTENDED_SDTR, port: host->addr + TUL_SFifo); /* Sync request */ |
1319 | outb(value: 1, port: host->addr + TUL_SFifo); /* Start from 16 bits */ |
1320 | } else if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) { |
1321 | active_tc->flags |= TCF_SYNC_DONE; |
1322 | outb(value: EXTENDED_MESSAGE, port: host->addr + TUL_SFifo); |
1323 | outb(value: 3, port: host->addr + TUL_SFifo); /* extended msg length */ |
1324 | outb(EXTENDED_SDTR, port: host->addr + TUL_SFifo); /* sync request */ |
1325 | outb(value: initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], port: host->addr + TUL_SFifo); |
1326 | outb(MAX_OFFSET, port: host->addr + TUL_SFifo); /* REQ/ACK offset */ |
1327 | } |
1328 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1329 | if (wait_tulip(host) == -1) |
1330 | return -1; |
1331 | } |
1332 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1333 | outb(value: (inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), port: host->addr + TUL_SSignal); |
1334 | /* Into before CDB xfer */ |
1335 | return 3; |
1336 | } |
1337 | |
1338 | |
1339 | /** |
1340 | * initio_state_2 - SCSI state machine |
1341 | * @host: InitIO host we are controlling |
1342 | * |
1343 | * state after selection with attention |
1344 | * state after selection with attention3 |
1345 | */ |
1346 | |
1347 | static int initio_state_2(struct initio_host * host) |
1348 | { |
1349 | struct scsi_ctrl_blk *scb = host->active; |
1350 | struct target_control *active_tc = host->active_tc; |
1351 | #if DEBUG_STATE |
1352 | printk("-s2-" ); |
1353 | #endif |
1354 | |
1355 | initio_unlink_pend_scb(host, scb); |
1356 | initio_append_busy_scb(host, scbp: scb); |
1357 | |
1358 | outb(value: active_tc->sconfig0, port: host->addr + TUL_SConfig); |
1359 | |
1360 | if (host->jsstatus1 & TSS_CMD_PH_CMP) |
1361 | return 4; |
1362 | |
1363 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1364 | outb(value: (inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), port: host->addr + TUL_SSignal); |
1365 | /* Into before CDB xfer */ |
1366 | return 3; |
1367 | } |
1368 | |
1369 | /** |
1370 | * initio_state_3 - SCSI state machine |
1371 | * @host: InitIO host we are controlling |
1372 | * |
1373 | * state before CDB xfer is done |
1374 | */ |
1375 | |
1376 | static int initio_state_3(struct initio_host * host) |
1377 | { |
1378 | struct scsi_ctrl_blk *scb = host->active; |
1379 | struct target_control *active_tc = host->active_tc; |
1380 | int i; |
1381 | |
1382 | #if DEBUG_STATE |
1383 | printk("-s3-" ); |
1384 | #endif |
1385 | for (;;) { |
1386 | switch (host->phase) { |
1387 | case CMD_OUT: /* Command out phase */ |
1388 | for (i = 0; i < (int) scb->cdblen; i++) |
1389 | outb(value: scb->cdb[i], port: host->addr + TUL_SFifo); |
1390 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1391 | if (wait_tulip(host) == -1) |
1392 | return -1; |
1393 | if (host->phase == CMD_OUT) |
1394 | return initio_bad_seq(host); |
1395 | return 4; |
1396 | |
1397 | case MSG_IN: /* Message in phase */ |
1398 | scb->next_state = 3; |
1399 | if (initio_msgin(host) == -1) |
1400 | return -1; |
1401 | break; |
1402 | |
1403 | case STATUS_IN: /* Status phase */ |
1404 | if (initio_status_msg(host) == -1) |
1405 | return -1; |
1406 | break; |
1407 | |
1408 | case MSG_OUT: /* Message out phase */ |
1409 | if (active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) { |
1410 | outb(value: NOP, port: host->addr + TUL_SFifo); /* msg nop */ |
1411 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1412 | if (wait_tulip(host) == -1) |
1413 | return -1; |
1414 | } else { |
1415 | active_tc->flags |= TCF_SYNC_DONE; |
1416 | |
1417 | outb(value: EXTENDED_MESSAGE, port: host->addr + TUL_SFifo); |
1418 | outb(value: 3, port: host->addr + TUL_SFifo); /* ext. msg len */ |
1419 | outb(EXTENDED_SDTR, port: host->addr + TUL_SFifo); /* sync request */ |
1420 | outb(value: initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], port: host->addr + TUL_SFifo); |
1421 | outb(MAX_OFFSET, port: host->addr + TUL_SFifo); /* REQ/ACK offset */ |
1422 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1423 | if (wait_tulip(host) == -1) |
1424 | return -1; |
1425 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1426 | outb(inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7), port: host->addr + TUL_SSignal); |
1427 | |
1428 | } |
1429 | break; |
1430 | default: |
1431 | return initio_bad_seq(host); |
1432 | } |
1433 | } |
1434 | } |
1435 | |
1436 | /** |
1437 | * initio_state_4 - SCSI state machine |
1438 | * @host: InitIO host we are controlling |
1439 | * |
1440 | * SCSI state machine. State 4 |
1441 | */ |
1442 | |
1443 | static int initio_state_4(struct initio_host * host) |
1444 | { |
1445 | struct scsi_ctrl_blk *scb = host->active; |
1446 | |
1447 | #if DEBUG_STATE |
1448 | printk("-s4-" ); |
1449 | #endif |
1450 | if ((scb->flags & SCF_DIR) == SCF_NO_XF) { |
1451 | return 6; /* Go to state 6 (After data) */ |
1452 | } |
1453 | for (;;) { |
1454 | if (scb->buflen == 0) |
1455 | return 6; |
1456 | |
1457 | switch (host->phase) { |
1458 | |
1459 | case STATUS_IN: /* Status phase */ |
1460 | if ((scb->flags & SCF_DIR) != 0) /* if direction bit set then report data underrun */ |
1461 | scb->hastat = HOST_DO_DU; |
1462 | if ((initio_status_msg(host)) == -1) |
1463 | return -1; |
1464 | break; |
1465 | |
1466 | case MSG_IN: /* Message in phase */ |
1467 | scb->next_state = 0x4; |
1468 | if (initio_msgin(host) == -1) |
1469 | return -1; |
1470 | break; |
1471 | |
1472 | case MSG_OUT: /* Message out phase */ |
1473 | if (host->jsstatus0 & TSS_PAR_ERROR) { |
1474 | scb->buflen = 0; |
1475 | scb->hastat = HOST_DO_DU; |
1476 | if (initio_msgout_ide(host) == -1) |
1477 | return -1; |
1478 | return 6; |
1479 | } else { |
1480 | outb(value: NOP, port: host->addr + TUL_SFifo); /* msg nop */ |
1481 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1482 | if (wait_tulip(host) == -1) |
1483 | return -1; |
1484 | } |
1485 | break; |
1486 | |
1487 | case DATA_IN: /* Data in phase */ |
1488 | return initio_xfer_data_in(host); |
1489 | |
1490 | case DATA_OUT: /* Data out phase */ |
1491 | return initio_xfer_data_out(host); |
1492 | |
1493 | default: |
1494 | return initio_bad_seq(host); |
1495 | } |
1496 | } |
1497 | } |
1498 | |
1499 | |
1500 | /** |
1501 | * initio_state_5 - SCSI state machine |
1502 | * @host: InitIO host we are controlling |
1503 | * |
1504 | * State after dma xfer done or phase change before xfer done |
1505 | */ |
1506 | |
1507 | static int initio_state_5(struct initio_host * host) |
1508 | { |
1509 | struct scsi_ctrl_blk *scb = host->active; |
1510 | long cnt, xcnt; /* cannot use unsigned !! code: if (xcnt < 0) */ |
1511 | |
1512 | #if DEBUG_STATE |
1513 | printk("-s5-" ); |
1514 | #endif |
1515 | /*------ get remaining count -------*/ |
1516 | cnt = inl(port: host->addr + TUL_SCnt0) & 0x0FFFFFF; |
1517 | |
1518 | if (inb(port: host->addr + TUL_XCmd) & 0x20) { |
1519 | /* ----------------------- DATA_IN ----------------------------- */ |
1520 | /* check scsi parity error */ |
1521 | if (host->jsstatus0 & TSS_PAR_ERROR) |
1522 | scb->hastat = HOST_DO_DU; |
1523 | if (inb(port: host->addr + TUL_XStatus) & XPEND) { /* DMA xfer pending, Send STOP */ |
1524 | /* tell Hardware scsi xfer has been terminated */ |
1525 | outb(inb(port: host->addr + TUL_XCtrl) | 0x80, port: host->addr + TUL_XCtrl); |
1526 | /* wait until DMA xfer not pending */ |
1527 | while (inb(port: host->addr + TUL_XStatus) & XPEND) |
1528 | cpu_relax(); |
1529 | } |
1530 | } else { |
1531 | /*-------- DATA OUT -----------*/ |
1532 | if ((inb(port: host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) { |
1533 | if (host->active_tc->js_period & TSC_WIDE_SCSI) |
1534 | cnt += (inb(port: host->addr + TUL_SFifoCnt) & 0x1F) << 1; |
1535 | else |
1536 | cnt += (inb(port: host->addr + TUL_SFifoCnt) & 0x1F); |
1537 | } |
1538 | if (inb(port: host->addr + TUL_XStatus) & XPEND) { /* if DMA xfer is pending, abort DMA xfer */ |
1539 | outb(TAX_X_ABT, port: host->addr + TUL_XCmd); |
1540 | /* wait Abort DMA xfer done */ |
1541 | while ((inb(port: host->addr + TUL_Int) & XABT) == 0) |
1542 | cpu_relax(); |
1543 | } |
1544 | if ((cnt == 1) && (host->phase == DATA_OUT)) { |
1545 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1546 | if (wait_tulip(host) == -1) |
1547 | return -1; |
1548 | cnt = 0; |
1549 | } else { |
1550 | if ((inb(port: host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) |
1551 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1552 | } |
1553 | } |
1554 | if (cnt == 0) { |
1555 | scb->buflen = 0; |
1556 | return 6; /* After Data */ |
1557 | } |
1558 | /* Update active data pointer */ |
1559 | xcnt = (long) scb->buflen - cnt; /* xcnt== bytes already xferred */ |
1560 | scb->buflen = (u32) cnt; /* cnt == bytes left to be xferred */ |
1561 | if (scb->flags & SCF_SG) { |
1562 | struct sg_entry *sgp; |
1563 | unsigned long i; |
1564 | |
1565 | sgp = &scb->sglist[scb->sgidx]; |
1566 | for (i = scb->sgidx; i < scb->sgmax; sgp++, i++) { |
1567 | xcnt -= (long) sgp->len; |
1568 | if (xcnt < 0) { /* this sgp xfer half done */ |
1569 | xcnt += (long) sgp->len; /* xcnt == bytes xferred in this sgp */ |
1570 | sgp->data += (u32) xcnt; /* new ptr to be xfer */ |
1571 | sgp->len -= (u32) xcnt; /* new len to be xfer */ |
1572 | scb->bufptr += ((u32) (i - scb->sgidx) << 3); |
1573 | /* new SG table ptr */ |
1574 | scb->sglen = (u8) (scb->sgmax - i); |
1575 | /* new SG table len */ |
1576 | scb->sgidx = (u16) i; |
1577 | /* for next disc and come in this loop */ |
1578 | return 4; /* Go to state 4 */ |
1579 | } |
1580 | /* else (xcnt >= 0 , i.e. this sgp already xferred */ |
1581 | } /* for */ |
1582 | return 6; /* Go to state 6 */ |
1583 | } else { |
1584 | scb->bufptr += (u32) xcnt; |
1585 | } |
1586 | return 4; /* Go to state 4 */ |
1587 | } |
1588 | |
1589 | /** |
1590 | * initio_state_6 - SCSI state machine |
1591 | * @host: InitIO host we are controlling |
1592 | * |
1593 | * State after Data phase |
1594 | */ |
1595 | |
1596 | static int initio_state_6(struct initio_host * host) |
1597 | { |
1598 | struct scsi_ctrl_blk *scb = host->active; |
1599 | |
1600 | #if DEBUG_STATE |
1601 | printk("-s6-" ); |
1602 | #endif |
1603 | for (;;) { |
1604 | switch (host->phase) { |
1605 | case STATUS_IN: /* Status phase */ |
1606 | if ((initio_status_msg(host)) == -1) |
1607 | return -1; |
1608 | break; |
1609 | |
1610 | case MSG_IN: /* Message in phase */ |
1611 | scb->next_state = 6; |
1612 | if ((initio_msgin(host)) == -1) |
1613 | return -1; |
1614 | break; |
1615 | |
1616 | case MSG_OUT: /* Message out phase */ |
1617 | outb(value: NOP, port: host->addr + TUL_SFifo); /* msg nop */ |
1618 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1619 | if (wait_tulip(host) == -1) |
1620 | return -1; |
1621 | break; |
1622 | |
1623 | case DATA_IN: /* Data in phase */ |
1624 | return initio_xpad_in(host); |
1625 | |
1626 | case DATA_OUT: /* Data out phase */ |
1627 | return initio_xpad_out(host); |
1628 | |
1629 | default: |
1630 | return initio_bad_seq(host); |
1631 | } |
1632 | } |
1633 | } |
1634 | |
1635 | /** |
1636 | * initio_state_7 - SCSI state machine |
1637 | * @host: InitIO host we are controlling |
1638 | * |
1639 | */ |
1640 | |
1641 | static int initio_state_7(struct initio_host * host) |
1642 | { |
1643 | int cnt, i; |
1644 | |
1645 | #if DEBUG_STATE |
1646 | printk("-s7-" ); |
1647 | #endif |
1648 | /* flush SCSI FIFO */ |
1649 | cnt = inb(port: host->addr + TUL_SFifoCnt) & 0x1F; |
1650 | if (cnt) { |
1651 | for (i = 0; i < cnt; i++) |
1652 | inb(port: host->addr + TUL_SFifo); |
1653 | } |
1654 | switch (host->phase) { |
1655 | case DATA_IN: /* Data in phase */ |
1656 | case DATA_OUT: /* Data out phase */ |
1657 | return initio_bad_seq(host); |
1658 | default: |
1659 | return 6; /* Go to state 6 */ |
1660 | } |
1661 | } |
1662 | |
1663 | /** |
1664 | * initio_xfer_data_in - Commence data input |
1665 | * @host: InitIO host in use |
1666 | * |
1667 | * Commence a block of data transfer. The transfer itself will |
1668 | * be managed by the controller and we will get a completion (or |
1669 | * failure) interrupt. |
1670 | */ |
1671 | static int initio_xfer_data_in(struct initio_host * host) |
1672 | { |
1673 | struct scsi_ctrl_blk *scb = host->active; |
1674 | |
1675 | if ((scb->flags & SCF_DIR) == SCF_DOUT) |
1676 | return 6; /* wrong direction */ |
1677 | |
1678 | outl(value: scb->buflen, port: host->addr + TUL_SCnt0); |
1679 | outb(TSC_XF_DMA_IN, port: host->addr + TUL_SCmd); /* 7/25/95 */ |
1680 | |
1681 | if (scb->flags & SCF_SG) { /* S/G xfer */ |
1682 | outl(value: ((u32) scb->sglen) << 3, port: host->addr + TUL_XCntH); |
1683 | outl(value: scb->bufptr, port: host->addr + TUL_XAddH); |
1684 | outb(TAX_SG_IN, port: host->addr + TUL_XCmd); |
1685 | } else { |
1686 | outl(value: scb->buflen, port: host->addr + TUL_XCntH); |
1687 | outl(value: scb->bufptr, port: host->addr + TUL_XAddH); |
1688 | outb(TAX_X_IN, port: host->addr + TUL_XCmd); |
1689 | } |
1690 | scb->next_state = 0x5; |
1691 | return 0; /* return to OS, wait xfer done , let jas_isr come in */ |
1692 | } |
1693 | |
1694 | /** |
1695 | * initio_xfer_data_out - Commence data output |
1696 | * @host: InitIO host in use |
1697 | * |
1698 | * Commence a block of data transfer. The transfer itself will |
1699 | * be managed by the controller and we will get a completion (or |
1700 | * failure) interrupt. |
1701 | */ |
1702 | |
1703 | static int initio_xfer_data_out(struct initio_host * host) |
1704 | { |
1705 | struct scsi_ctrl_blk *scb = host->active; |
1706 | |
1707 | if ((scb->flags & SCF_DIR) == SCF_DIN) |
1708 | return 6; /* wrong direction */ |
1709 | |
1710 | outl(value: scb->buflen, port: host->addr + TUL_SCnt0); |
1711 | outb(TSC_XF_DMA_OUT, port: host->addr + TUL_SCmd); |
1712 | |
1713 | if (scb->flags & SCF_SG) { /* S/G xfer */ |
1714 | outl(value: ((u32) scb->sglen) << 3, port: host->addr + TUL_XCntH); |
1715 | outl(value: scb->bufptr, port: host->addr + TUL_XAddH); |
1716 | outb(TAX_SG_OUT, port: host->addr + TUL_XCmd); |
1717 | } else { |
1718 | outl(value: scb->buflen, port: host->addr + TUL_XCntH); |
1719 | outl(value: scb->bufptr, port: host->addr + TUL_XAddH); |
1720 | outb(TAX_X_OUT, port: host->addr + TUL_XCmd); |
1721 | } |
1722 | |
1723 | scb->next_state = 0x5; |
1724 | return 0; /* return to OS, wait xfer done , let jas_isr come in */ |
1725 | } |
1726 | |
1727 | int initio_xpad_in(struct initio_host * host) |
1728 | { |
1729 | struct scsi_ctrl_blk *scb = host->active; |
1730 | struct target_control *active_tc = host->active_tc; |
1731 | |
1732 | if ((scb->flags & SCF_DIR) != SCF_NO_DCHK) |
1733 | scb->hastat = HOST_DO_DU; /* over run */ |
1734 | for (;;) { |
1735 | if (active_tc->js_period & TSC_WIDE_SCSI) |
1736 | outl(value: 2, port: host->addr + TUL_SCnt0); |
1737 | else |
1738 | outl(value: 1, port: host->addr + TUL_SCnt0); |
1739 | |
1740 | outb(TSC_XF_FIFO_IN, port: host->addr + TUL_SCmd); |
1741 | if (wait_tulip(host) == -1) |
1742 | return -1; |
1743 | if (host->phase != DATA_IN) { |
1744 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1745 | return 6; |
1746 | } |
1747 | inb(port: host->addr + TUL_SFifo); |
1748 | } |
1749 | } |
1750 | |
1751 | int initio_xpad_out(struct initio_host * host) |
1752 | { |
1753 | struct scsi_ctrl_blk *scb = host->active; |
1754 | struct target_control *active_tc = host->active_tc; |
1755 | |
1756 | if ((scb->flags & SCF_DIR) != SCF_NO_DCHK) |
1757 | scb->hastat = HOST_DO_DU; /* over run */ |
1758 | for (;;) { |
1759 | if (active_tc->js_period & TSC_WIDE_SCSI) |
1760 | outl(value: 2, port: host->addr + TUL_SCnt0); |
1761 | else |
1762 | outl(value: 1, port: host->addr + TUL_SCnt0); |
1763 | |
1764 | outb(value: 0, port: host->addr + TUL_SFifo); |
1765 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1766 | if ((wait_tulip(host)) == -1) |
1767 | return -1; |
1768 | if (host->phase != DATA_OUT) { /* Disable wide CPU to allow read 16 bits */ |
1769 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); |
1770 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1771 | return 6; |
1772 | } |
1773 | } |
1774 | } |
1775 | |
1776 | int initio_status_msg(struct initio_host * host) |
1777 | { /* status & MSG_IN */ |
1778 | struct scsi_ctrl_blk *scb = host->active; |
1779 | u8 msg; |
1780 | |
1781 | outb(TSC_CMD_COMP, port: host->addr + TUL_SCmd); |
1782 | if (wait_tulip(host) == -1) |
1783 | return -1; |
1784 | |
1785 | /* get status */ |
1786 | scb->tastat = inb(port: host->addr + TUL_SFifo); |
1787 | |
1788 | if (host->phase == MSG_OUT) { |
1789 | if (host->jsstatus0 & TSS_PAR_ERROR) |
1790 | outb(value: MSG_PARITY_ERROR, port: host->addr + TUL_SFifo); |
1791 | else |
1792 | outb(value: NOP, port: host->addr + TUL_SFifo); |
1793 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1794 | return wait_tulip(host); |
1795 | } |
1796 | if (host->phase == MSG_IN) { |
1797 | msg = inb(port: host->addr + TUL_SFifo); |
1798 | if (host->jsstatus0 & TSS_PAR_ERROR) { /* Parity error */ |
1799 | if ((initio_msgin_accept(host)) == -1) |
1800 | return -1; |
1801 | if (host->phase != MSG_OUT) |
1802 | return initio_bad_seq(host); |
1803 | outb(value: MSG_PARITY_ERROR, port: host->addr + TUL_SFifo); |
1804 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
1805 | return wait_tulip(host); |
1806 | } |
1807 | if (msg == 0) { /* Command complete */ |
1808 | |
1809 | if ((scb->tastat & 0x18) == 0x10) /* No link support */ |
1810 | return initio_bad_seq(host); |
1811 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1812 | outb(TSC_MSG_ACCEPT, port: host->addr + TUL_SCmd); |
1813 | return initio_wait_done_disc(host); |
1814 | |
1815 | } |
1816 | if (msg == LINKED_CMD_COMPLETE || |
1817 | msg == LINKED_FLG_CMD_COMPLETE) { |
1818 | if ((scb->tastat & 0x18) == 0x10) |
1819 | return initio_msgin_accept(host); |
1820 | } |
1821 | } |
1822 | return initio_bad_seq(host); |
1823 | } |
1824 | |
1825 | |
1826 | /* scsi bus free */ |
1827 | int int_initio_busfree(struct initio_host * host) |
1828 | { |
1829 | struct scsi_ctrl_blk *scb = host->active; |
1830 | |
1831 | if (scb != NULL) { |
1832 | if (scb->status & SCB_SELECT) { /* selection timeout */ |
1833 | initio_unlink_pend_scb(host, scb); |
1834 | scb->hastat = HOST_SEL_TOUT; |
1835 | initio_append_done_scb(host, scbp: scb); |
1836 | } else { /* Unexpected bus free */ |
1837 | initio_unlink_busy_scb(host, scb); |
1838 | scb->hastat = HOST_BUS_FREE; |
1839 | initio_append_done_scb(host, scbp: scb); |
1840 | } |
1841 | host->active = NULL; |
1842 | host->active_tc = NULL; |
1843 | } |
1844 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ |
1845 | outb(TSC_INITDEFAULT, port: host->addr + TUL_SConfig); |
1846 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); /* Enable HW reselect */ |
1847 | return -1; |
1848 | } |
1849 | |
1850 | |
1851 | /** |
1852 | * int_initio_scsi_rst - SCSI reset occurred |
1853 | * @host: Host seeing the reset |
1854 | * |
1855 | * A SCSI bus reset has occurred. Clean up any pending transfer |
1856 | * the hardware is doing by DMA and then abort all active and |
1857 | * disconnected commands. The mid layer should sort the rest out |
1858 | * for us |
1859 | */ |
1860 | |
1861 | static int int_initio_scsi_rst(struct initio_host * host) |
1862 | { |
1863 | struct scsi_ctrl_blk *scb; |
1864 | int i; |
1865 | |
1866 | /* if DMA xfer is pending, abort DMA xfer */ |
1867 | if (inb(port: host->addr + TUL_XStatus) & 0x01) { |
1868 | outb(TAX_X_ABT | TAX_X_CLR_FIFO, port: host->addr + TUL_XCmd); |
1869 | /* wait Abort DMA xfer done */ |
1870 | while ((inb(port: host->addr + TUL_Int) & 0x04) == 0) |
1871 | cpu_relax(); |
1872 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
1873 | } |
1874 | /* Abort all active & disconnected scb */ |
1875 | while ((scb = initio_pop_busy_scb(host)) != NULL) { |
1876 | scb->hastat = HOST_BAD_PHAS; |
1877 | initio_append_done_scb(host, scbp: scb); |
1878 | } |
1879 | host->active = NULL; |
1880 | host->active_tc = NULL; |
1881 | |
1882 | /* clr sync nego. done flag */ |
1883 | for (i = 0; i < host->max_tar; i++) |
1884 | host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE); |
1885 | return -1; |
1886 | } |
1887 | |
1888 | /** |
1889 | * int_initio_resel - Reselection occurred |
1890 | * @host: InitIO host adapter |
1891 | * |
1892 | * A SCSI reselection event has been signalled and the interrupt |
1893 | * is now being processed. Work out which command block needs attention |
1894 | * and continue processing that command. |
1895 | */ |
1896 | |
1897 | int int_initio_resel(struct initio_host * host) |
1898 | { |
1899 | struct scsi_ctrl_blk *scb; |
1900 | struct target_control *active_tc; |
1901 | u8 tag, msg = 0; |
1902 | u8 tar, lun; |
1903 | |
1904 | if ((scb = host->active) != NULL) { |
1905 | /* FIXME: Why check and not just clear ? */ |
1906 | if (scb->status & SCB_SELECT) /* if waiting for selection complete */ |
1907 | scb->status &= ~SCB_SELECT; |
1908 | host->active = NULL; |
1909 | } |
1910 | /* --------- get target id---------------------- */ |
1911 | tar = inb(port: host->addr + TUL_SBusId); |
1912 | /* ------ get LUN from Identify message----------- */ |
1913 | lun = inb(port: host->addr + TUL_SIdent) & 0x0F; |
1914 | /* 07/22/98 from 0x1F -> 0x0F */ |
1915 | active_tc = &host->targets[tar]; |
1916 | host->active_tc = active_tc; |
1917 | outb(value: active_tc->sconfig0, port: host->addr + TUL_SConfig); |
1918 | outb(value: active_tc->js_period, port: host->addr + TUL_SPeriod); |
1919 | |
1920 | /* ------------- tag queueing ? ------------------- */ |
1921 | if (active_tc->drv_flags & TCF_DRV_EN_TAG) { |
1922 | if ((initio_msgin_accept(host)) == -1) |
1923 | return -1; |
1924 | if (host->phase != MSG_IN) |
1925 | goto no_tag; |
1926 | outl(value: 1, port: host->addr + TUL_SCnt0); |
1927 | outb(TSC_XF_FIFO_IN, port: host->addr + TUL_SCmd); |
1928 | if (wait_tulip(host) == -1) |
1929 | return -1; |
1930 | msg = inb(port: host->addr + TUL_SFifo); /* Read Tag Message */ |
1931 | |
1932 | if (msg < SIMPLE_QUEUE_TAG || msg > ORDERED_QUEUE_TAG) |
1933 | /* Is simple Tag */ |
1934 | goto no_tag; |
1935 | |
1936 | if (initio_msgin_accept(host) == -1) |
1937 | return -1; |
1938 | |
1939 | if (host->phase != MSG_IN) |
1940 | goto no_tag; |
1941 | |
1942 | outl(value: 1, port: host->addr + TUL_SCnt0); |
1943 | outb(TSC_XF_FIFO_IN, port: host->addr + TUL_SCmd); |
1944 | if (wait_tulip(host) == -1) |
1945 | return -1; |
1946 | tag = inb(port: host->addr + TUL_SFifo); /* Read Tag ID */ |
1947 | scb = host->scb + tag; |
1948 | if (scb->target != tar || scb->lun != lun) { |
1949 | return initio_msgout_abort_tag(host); |
1950 | } |
1951 | if (scb->status != SCB_BUSY) { /* 03/24/95 */ |
1952 | return initio_msgout_abort_tag(host); |
1953 | } |
1954 | host->active = scb; |
1955 | if ((initio_msgin_accept(host)) == -1) |
1956 | return -1; |
1957 | } else { /* No tag */ |
1958 | no_tag: |
1959 | if ((scb = initio_find_busy_scb(host, tarlun: tar | (lun << 8))) == NULL) { |
1960 | return initio_msgout_abort_targ(host); |
1961 | } |
1962 | host->active = scb; |
1963 | if (!(active_tc->drv_flags & TCF_DRV_EN_TAG)) { |
1964 | if ((initio_msgin_accept(host)) == -1) |
1965 | return -1; |
1966 | } |
1967 | } |
1968 | return 0; |
1969 | } |
1970 | |
1971 | /** |
1972 | * int_initio_bad_seq - out of phase |
1973 | * @host: InitIO host flagging event |
1974 | * |
1975 | * We have ended up out of phase somehow. Reset the host controller |
1976 | * and throw all our toys out of the pram. Let the midlayer clean up |
1977 | */ |
1978 | |
1979 | static int int_initio_bad_seq(struct initio_host * host) |
1980 | { /* target wrong phase */ |
1981 | struct scsi_ctrl_blk *scb; |
1982 | int i; |
1983 | |
1984 | initio_reset_scsi(host, seconds: 10); |
1985 | |
1986 | while ((scb = initio_pop_busy_scb(host)) != NULL) { |
1987 | scb->hastat = HOST_BAD_PHAS; |
1988 | initio_append_done_scb(host, scbp: scb); |
1989 | } |
1990 | for (i = 0; i < host->max_tar; i++) |
1991 | host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE); |
1992 | return -1; |
1993 | } |
1994 | |
1995 | |
1996 | /** |
1997 | * initio_msgout_abort_targ - abort a tag |
1998 | * @host: InitIO host |
1999 | * |
2000 | * Abort when the target/lun does not match or when our SCB is not |
2001 | * busy. Used by untagged commands. |
2002 | */ |
2003 | |
2004 | static int initio_msgout_abort_targ(struct initio_host * host) |
2005 | { |
2006 | |
2007 | outb(value: ((inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), port: host->addr + TUL_SSignal); |
2008 | if (initio_msgin_accept(host) == -1) |
2009 | return -1; |
2010 | if (host->phase != MSG_OUT) |
2011 | return initio_bad_seq(host); |
2012 | |
2013 | outb(value: ABORT_TASK_SET, port: host->addr + TUL_SFifo); |
2014 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2015 | |
2016 | return initio_wait_disc(host); |
2017 | } |
2018 | |
2019 | /** |
2020 | * initio_msgout_abort_tag - abort a tag |
2021 | * @host: InitIO host |
2022 | * |
2023 | * Abort when the target/lun does not match or when our SCB is not |
2024 | * busy. Used for tagged commands. |
2025 | */ |
2026 | |
2027 | static int initio_msgout_abort_tag(struct initio_host * host) |
2028 | { |
2029 | |
2030 | outb(value: ((inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), port: host->addr + TUL_SSignal); |
2031 | if (initio_msgin_accept(host) == -1) |
2032 | return -1; |
2033 | if (host->phase != MSG_OUT) |
2034 | return initio_bad_seq(host); |
2035 | |
2036 | outb(value: ABORT_TASK, port: host->addr + TUL_SFifo); |
2037 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2038 | |
2039 | return initio_wait_disc(host); |
2040 | |
2041 | } |
2042 | |
2043 | /** |
2044 | * initio_msgin - Message in |
2045 | * @host: InitIO Host |
2046 | * |
2047 | * Process incoming message |
2048 | */ |
2049 | static int initio_msgin(struct initio_host * host) |
2050 | { |
2051 | struct target_control *active_tc; |
2052 | |
2053 | for (;;) { |
2054 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
2055 | |
2056 | outl(value: 1, port: host->addr + TUL_SCnt0); |
2057 | outb(TSC_XF_FIFO_IN, port: host->addr + TUL_SCmd); |
2058 | if (wait_tulip(host) == -1) |
2059 | return -1; |
2060 | |
2061 | switch (inb(port: host->addr + TUL_SFifo)) { |
2062 | case DISCONNECT: /* Disconnect msg */ |
2063 | outb(TSC_MSG_ACCEPT, port: host->addr + TUL_SCmd); |
2064 | return initio_wait_disc(host); |
2065 | case SAVE_POINTERS: |
2066 | case RESTORE_POINTERS: |
2067 | case NOP: |
2068 | initio_msgin_accept(host); |
2069 | break; |
2070 | case MESSAGE_REJECT: /* Clear ATN first */ |
2071 | outb(value: (inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), |
2072 | port: host->addr + TUL_SSignal); |
2073 | active_tc = host->active_tc; |
2074 | if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) /* do sync nego */ |
2075 | outb(value: ((inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), |
2076 | port: host->addr + TUL_SSignal); |
2077 | initio_msgin_accept(host); |
2078 | break; |
2079 | case EXTENDED_MESSAGE: /* extended msg */ |
2080 | initio_msgin_extend(host); |
2081 | break; |
2082 | case IGNORE_WIDE_RESIDUE: |
2083 | initio_msgin_accept(host); |
2084 | break; |
2085 | case COMMAND_COMPLETE: |
2086 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
2087 | outb(TSC_MSG_ACCEPT, port: host->addr + TUL_SCmd); |
2088 | return initio_wait_done_disc(host); |
2089 | default: |
2090 | initio_msgout_reject(host); |
2091 | break; |
2092 | } |
2093 | if (host->phase != MSG_IN) |
2094 | return host->phase; |
2095 | } |
2096 | /* statement won't reach here */ |
2097 | } |
2098 | |
2099 | static int initio_msgout_reject(struct initio_host * host) |
2100 | { |
2101 | outb(value: ((inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), port: host->addr + TUL_SSignal); |
2102 | |
2103 | if (initio_msgin_accept(host) == -1) |
2104 | return -1; |
2105 | |
2106 | if (host->phase == MSG_OUT) { |
2107 | outb(value: MESSAGE_REJECT, port: host->addr + TUL_SFifo); /* Msg reject */ |
2108 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2109 | return wait_tulip(host); |
2110 | } |
2111 | return host->phase; |
2112 | } |
2113 | |
2114 | static int initio_msgout_ide(struct initio_host * host) |
2115 | { |
2116 | outb(value: INITIATOR_ERROR, port: host->addr + TUL_SFifo); /* Initiator Detected Error */ |
2117 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2118 | return wait_tulip(host); |
2119 | } |
2120 | |
2121 | static int initio_msgin_extend(struct initio_host * host) |
2122 | { |
2123 | u8 len, idx; |
2124 | |
2125 | if (initio_msgin_accept(host) != MSG_IN) |
2126 | return host->phase; |
2127 | |
2128 | /* Get extended msg length */ |
2129 | outl(value: 1, port: host->addr + TUL_SCnt0); |
2130 | outb(TSC_XF_FIFO_IN, port: host->addr + TUL_SCmd); |
2131 | if (wait_tulip(host) == -1) |
2132 | return -1; |
2133 | |
2134 | len = inb(port: host->addr + TUL_SFifo); |
2135 | host->msg[0] = len; |
2136 | for (idx = 1; len != 0; len--) { |
2137 | |
2138 | if ((initio_msgin_accept(host)) != MSG_IN) |
2139 | return host->phase; |
2140 | outl(value: 1, port: host->addr + TUL_SCnt0); |
2141 | outb(TSC_XF_FIFO_IN, port: host->addr + TUL_SCmd); |
2142 | if (wait_tulip(host) == -1) |
2143 | return -1; |
2144 | host->msg[idx++] = inb(port: host->addr + TUL_SFifo); |
2145 | } |
2146 | if (host->msg[1] == 1) { /* if it's synchronous data transfer request */ |
2147 | u8 r; |
2148 | if (host->msg[0] != 3) /* if length is not right */ |
2149 | return initio_msgout_reject(host); |
2150 | if (host->active_tc->flags & TCF_NO_SYNC_NEGO) { /* Set OFFSET=0 to do async, nego back */ |
2151 | host->msg[3] = 0; |
2152 | } else { |
2153 | if (initio_msgin_sync(host) == 0 && |
2154 | (host->active_tc->flags & TCF_SYNC_DONE)) { |
2155 | initio_sync_done(host); |
2156 | return initio_msgin_accept(host); |
2157 | } |
2158 | } |
2159 | |
2160 | r = inb(port: host->addr + TUL_SSignal); |
2161 | outb(value: (r & (TSC_SET_ACK | 7)) | TSC_SET_ATN, |
2162 | port: host->addr + TUL_SSignal); |
2163 | if (initio_msgin_accept(host) != MSG_OUT) |
2164 | return host->phase; |
2165 | /* sync msg out */ |
2166 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); |
2167 | |
2168 | initio_sync_done(host); |
2169 | |
2170 | outb(value: EXTENDED_MESSAGE, port: host->addr + TUL_SFifo); |
2171 | outb(value: 3, port: host->addr + TUL_SFifo); |
2172 | outb(EXTENDED_SDTR, port: host->addr + TUL_SFifo); |
2173 | outb(value: host->msg[2], port: host->addr + TUL_SFifo); |
2174 | outb(value: host->msg[3], port: host->addr + TUL_SFifo); |
2175 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2176 | return wait_tulip(host); |
2177 | } |
2178 | if (host->msg[0] != 2 || host->msg[1] != 3) |
2179 | return initio_msgout_reject(host); |
2180 | /* if it's WIDE DATA XFER REQ */ |
2181 | if (host->active_tc->flags & TCF_NO_WDTR) { |
2182 | host->msg[2] = 0; |
2183 | } else { |
2184 | if (host->msg[2] > 2) /* > 32 bits */ |
2185 | return initio_msgout_reject(host); |
2186 | if (host->msg[2] == 2) { /* == 32 */ |
2187 | host->msg[2] = 1; |
2188 | } else { |
2189 | if ((host->active_tc->flags & TCF_NO_WDTR) == 0) { |
2190 | wdtr_done(host); |
2191 | if ((host->active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) |
2192 | outb(value: ((inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), port: host->addr + TUL_SSignal); |
2193 | return initio_msgin_accept(host); |
2194 | } |
2195 | } |
2196 | } |
2197 | outb(value: ((inb(port: host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), port: host->addr + TUL_SSignal); |
2198 | |
2199 | if (initio_msgin_accept(host) != MSG_OUT) |
2200 | return host->phase; |
2201 | /* WDTR msg out */ |
2202 | outb(value: EXTENDED_MESSAGE, port: host->addr + TUL_SFifo); |
2203 | outb(value: 2, port: host->addr + TUL_SFifo); |
2204 | outb(EXTENDED_WDTR, port: host->addr + TUL_SFifo); |
2205 | outb(value: host->msg[2], port: host->addr + TUL_SFifo); |
2206 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2207 | return wait_tulip(host); |
2208 | } |
2209 | |
2210 | static int initio_msgin_sync(struct initio_host * host) |
2211 | { |
2212 | char default_period; |
2213 | |
2214 | default_period = initio_rate_tbl[host->active_tc->flags & TCF_SCSI_RATE]; |
2215 | if (host->msg[3] > MAX_OFFSET) { |
2216 | host->msg[3] = MAX_OFFSET; |
2217 | if (host->msg[2] < default_period) { |
2218 | host->msg[2] = default_period; |
2219 | return 1; |
2220 | } |
2221 | if (host->msg[2] >= 59) /* Change to async */ |
2222 | host->msg[3] = 0; |
2223 | return 1; |
2224 | } |
2225 | /* offset requests asynchronous transfers ? */ |
2226 | if (host->msg[3] == 0) { |
2227 | return 0; |
2228 | } |
2229 | if (host->msg[2] < default_period) { |
2230 | host->msg[2] = default_period; |
2231 | return 1; |
2232 | } |
2233 | if (host->msg[2] >= 59) { |
2234 | host->msg[3] = 0; |
2235 | return 1; |
2236 | } |
2237 | return 0; |
2238 | } |
2239 | |
2240 | static int wdtr_done(struct initio_host * host) |
2241 | { |
2242 | host->active_tc->flags &= ~TCF_SYNC_DONE; |
2243 | host->active_tc->flags |= TCF_WDTR_DONE; |
2244 | |
2245 | host->active_tc->js_period = 0; |
2246 | if (host->msg[2]) /* if 16 bit */ |
2247 | host->active_tc->js_period |= TSC_WIDE_SCSI; |
2248 | host->active_tc->sconfig0 &= ~TSC_ALT_PERIOD; |
2249 | outb(value: host->active_tc->sconfig0, port: host->addr + TUL_SConfig); |
2250 | outb(value: host->active_tc->js_period, port: host->addr + TUL_SPeriod); |
2251 | |
2252 | return 1; |
2253 | } |
2254 | |
2255 | static int initio_sync_done(struct initio_host * host) |
2256 | { |
2257 | int i; |
2258 | |
2259 | host->active_tc->flags |= TCF_SYNC_DONE; |
2260 | |
2261 | if (host->msg[3]) { |
2262 | host->active_tc->js_period |= host->msg[3]; |
2263 | for (i = 0; i < 8; i++) { |
2264 | if (initio_rate_tbl[i] >= host->msg[2]) /* pick the big one */ |
2265 | break; |
2266 | } |
2267 | host->active_tc->js_period |= (i << 4); |
2268 | host->active_tc->sconfig0 |= TSC_ALT_PERIOD; |
2269 | } |
2270 | outb(value: host->active_tc->sconfig0, port: host->addr + TUL_SConfig); |
2271 | outb(value: host->active_tc->js_period, port: host->addr + TUL_SPeriod); |
2272 | |
2273 | return -1; |
2274 | } |
2275 | |
2276 | |
2277 | static int initio_post_scsi_rst(struct initio_host * host) |
2278 | { |
2279 | struct scsi_ctrl_blk *scb; |
2280 | struct target_control *active_tc; |
2281 | int i; |
2282 | |
2283 | host->active = NULL; |
2284 | host->active_tc = NULL; |
2285 | host->flags = 0; |
2286 | |
2287 | while ((scb = initio_pop_busy_scb(host)) != NULL) { |
2288 | scb->hastat = HOST_BAD_PHAS; |
2289 | initio_append_done_scb(host, scbp: scb); |
2290 | } |
2291 | /* clear sync done flag */ |
2292 | active_tc = &host->targets[0]; |
2293 | for (i = 0; i < host->max_tar; active_tc++, i++) { |
2294 | active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE); |
2295 | /* Initialize the sync. xfer register values to an asyn xfer */ |
2296 | active_tc->js_period = 0; |
2297 | active_tc->sconfig0 = host->sconf1; |
2298 | host->act_tags[0] = 0; /* 07/22/98 */ |
2299 | host->targets[i].flags &= ~TCF_BUSY; /* 07/22/98 */ |
2300 | } /* for */ |
2301 | |
2302 | return -1; |
2303 | } |
2304 | |
2305 | static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb) |
2306 | { |
2307 | scb->status |= SCB_SELECT; |
2308 | scb->next_state = 0x1; |
2309 | host->active = scb; |
2310 | host->active_tc = &host->targets[scb->target]; |
2311 | outb(TSC_SELATNSTOP, port: host->addr + TUL_SCmd); |
2312 | } |
2313 | |
2314 | |
2315 | static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb) |
2316 | { |
2317 | int i; |
2318 | |
2319 | scb->status |= SCB_SELECT; |
2320 | scb->next_state = 0x2; |
2321 | |
2322 | outb(value: scb->ident, port: host->addr + TUL_SFifo); |
2323 | for (i = 0; i < (int) scb->cdblen; i++) |
2324 | outb(value: scb->cdb[i], port: host->addr + TUL_SFifo); |
2325 | host->active_tc = &host->targets[scb->target]; |
2326 | host->active = scb; |
2327 | outb(TSC_SEL_ATN, port: host->addr + TUL_SCmd); |
2328 | } |
2329 | |
2330 | static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb) |
2331 | { |
2332 | int i; |
2333 | |
2334 | scb->status |= SCB_SELECT; |
2335 | scb->next_state = 0x2; |
2336 | |
2337 | outb(value: scb->ident, port: host->addr + TUL_SFifo); |
2338 | outb(value: scb->tagmsg, port: host->addr + TUL_SFifo); |
2339 | outb(value: scb->tagid, port: host->addr + TUL_SFifo); |
2340 | for (i = 0; i < scb->cdblen; i++) |
2341 | outb(value: scb->cdb[i], port: host->addr + TUL_SFifo); |
2342 | host->active_tc = &host->targets[scb->target]; |
2343 | host->active = scb; |
2344 | outb(TSC_SEL_ATN3, port: host->addr + TUL_SCmd); |
2345 | } |
2346 | |
2347 | /** |
2348 | * initio_bus_device_reset - SCSI Bus Device Reset |
2349 | * @host: InitIO host to reset |
2350 | * |
2351 | * Perform a device reset and abort all pending SCBs for the |
2352 | * victim device |
2353 | */ |
2354 | int initio_bus_device_reset(struct initio_host * host) |
2355 | { |
2356 | struct scsi_ctrl_blk *scb = host->active; |
2357 | struct target_control *active_tc = host->active_tc; |
2358 | struct scsi_ctrl_blk *tmp, *prev; |
2359 | u8 tar; |
2360 | |
2361 | if (host->phase != MSG_OUT) |
2362 | return int_initio_bad_seq(host); /* Unexpected phase */ |
2363 | |
2364 | initio_unlink_pend_scb(host, scb); |
2365 | initio_release_scb(host, cmnd: scb); |
2366 | |
2367 | |
2368 | tar = scb->target; /* target */ |
2369 | active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE | TCF_BUSY); |
2370 | /* clr sync. nego & WDTR flags 07/22/98 */ |
2371 | |
2372 | /* abort all SCB with same target */ |
2373 | prev = tmp = host->first_busy; /* Check Busy queue */ |
2374 | while (tmp != NULL) { |
2375 | if (tmp->target == tar) { |
2376 | /* unlink it */ |
2377 | if (tmp == host->first_busy) { |
2378 | if ((host->first_busy = tmp->next) == NULL) |
2379 | host->last_busy = NULL; |
2380 | } else { |
2381 | prev->next = tmp->next; |
2382 | if (tmp == host->last_busy) |
2383 | host->last_busy = prev; |
2384 | } |
2385 | tmp->hastat = HOST_ABORTED; |
2386 | initio_append_done_scb(host, scbp: tmp); |
2387 | } |
2388 | /* Previous haven't change */ |
2389 | else { |
2390 | prev = tmp; |
2391 | } |
2392 | tmp = tmp->next; |
2393 | } |
2394 | outb(value: TARGET_RESET, port: host->addr + TUL_SFifo); |
2395 | outb(TSC_XF_FIFO_OUT, port: host->addr + TUL_SCmd); |
2396 | return initio_wait_disc(host); |
2397 | |
2398 | } |
2399 | |
2400 | static int initio_msgin_accept(struct initio_host * host) |
2401 | { |
2402 | outb(TSC_MSG_ACCEPT, port: host->addr + TUL_SCmd); |
2403 | return wait_tulip(host); |
2404 | } |
2405 | |
2406 | static int wait_tulip(struct initio_host * host) |
2407 | { |
2408 | |
2409 | while (!((host->jsstatus0 = inb(port: host->addr + TUL_SStatus0)) |
2410 | & TSS_INT_PENDING)) |
2411 | cpu_relax(); |
2412 | |
2413 | host->jsint = inb(port: host->addr + TUL_SInt); |
2414 | host->phase = host->jsstatus0 & TSS_PH_MASK; |
2415 | host->jsstatus1 = inb(port: host->addr + TUL_SStatus1); |
2416 | |
2417 | if (host->jsint & TSS_RESEL_INT) /* if SCSI bus reset detected */ |
2418 | return int_initio_resel(host); |
2419 | if (host->jsint & TSS_SEL_TIMEOUT) /* if selected/reselected timeout interrupt */ |
2420 | return int_initio_busfree(host); |
2421 | if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */ |
2422 | return int_initio_scsi_rst(host); |
2423 | |
2424 | if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ |
2425 | if (host->flags & HCF_EXPECT_DONE_DISC) { |
2426 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ |
2427 | initio_unlink_busy_scb(host, scb: host->active); |
2428 | host->active->hastat = 0; |
2429 | initio_append_done_scb(host, scbp: host->active); |
2430 | host->active = NULL; |
2431 | host->active_tc = NULL; |
2432 | host->flags &= ~HCF_EXPECT_DONE_DISC; |
2433 | outb(TSC_INITDEFAULT, port: host->addr + TUL_SConfig); |
2434 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); /* Enable HW reselect */ |
2435 | return -1; |
2436 | } |
2437 | if (host->flags & HCF_EXPECT_DISC) { |
2438 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ |
2439 | host->active = NULL; |
2440 | host->active_tc = NULL; |
2441 | host->flags &= ~HCF_EXPECT_DISC; |
2442 | outb(TSC_INITDEFAULT, port: host->addr + TUL_SConfig); |
2443 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); /* Enable HW reselect */ |
2444 | return -1; |
2445 | } |
2446 | return int_initio_busfree(host); |
2447 | } |
2448 | /* The old code really does the below. Can probably be removed */ |
2449 | if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) |
2450 | return host->phase; |
2451 | return host->phase; |
2452 | } |
2453 | |
2454 | static int initio_wait_disc(struct initio_host * host) |
2455 | { |
2456 | while (!((host->jsstatus0 = inb(port: host->addr + TUL_SStatus0)) & TSS_INT_PENDING)) |
2457 | cpu_relax(); |
2458 | |
2459 | host->jsint = inb(port: host->addr + TUL_SInt); |
2460 | |
2461 | if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */ |
2462 | return int_initio_scsi_rst(host); |
2463 | if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ |
2464 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ |
2465 | outb(TSC_INITDEFAULT, port: host->addr + TUL_SConfig); |
2466 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); /* Enable HW reselect */ |
2467 | host->active = NULL; |
2468 | return -1; |
2469 | } |
2470 | return initio_bad_seq(host); |
2471 | } |
2472 | |
2473 | static int initio_wait_done_disc(struct initio_host * host) |
2474 | { |
2475 | while (!((host->jsstatus0 = inb(port: host->addr + TUL_SStatus0)) |
2476 | & TSS_INT_PENDING)) |
2477 | cpu_relax(); |
2478 | |
2479 | host->jsint = inb(port: host->addr + TUL_SInt); |
2480 | |
2481 | if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */ |
2482 | return int_initio_scsi_rst(host); |
2483 | if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ |
2484 | outb(TSC_FLUSH_FIFO, port: host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ |
2485 | outb(TSC_INITDEFAULT, port: host->addr + TUL_SConfig); |
2486 | outb(TSC_HW_RESELECT, port: host->addr + TUL_SCtrl1); /* Enable HW reselect */ |
2487 | initio_unlink_busy_scb(host, scb: host->active); |
2488 | |
2489 | initio_append_done_scb(host, scbp: host->active); |
2490 | host->active = NULL; |
2491 | return -1; |
2492 | } |
2493 | return initio_bad_seq(host); |
2494 | } |
2495 | |
2496 | /** |
2497 | * i91u_intr - IRQ handler |
2498 | * @irqno: IRQ number |
2499 | * @dev_id: IRQ identifier |
2500 | * |
2501 | * Take the relevant locks and then invoke the actual isr processing |
2502 | * code under the lock. |
2503 | */ |
2504 | |
2505 | static irqreturn_t i91u_intr(int irqno, void *dev_id) |
2506 | { |
2507 | struct Scsi_Host *dev = dev_id; |
2508 | unsigned long flags; |
2509 | int r; |
2510 | |
2511 | spin_lock_irqsave(dev->host_lock, flags); |
2512 | r = initio_isr(host: (struct initio_host *)dev->hostdata); |
2513 | spin_unlock_irqrestore(lock: dev->host_lock, flags); |
2514 | if (r) |
2515 | return IRQ_HANDLED; |
2516 | else |
2517 | return IRQ_NONE; |
2518 | } |
2519 | |
2520 | |
2521 | /** |
2522 | * initio_build_scb - Build the mappings and SCB |
2523 | * @host: InitIO host taking the command |
2524 | * @cblk: Firmware command block |
2525 | * @cmnd: SCSI midlayer command block |
2526 | * |
2527 | * Translate the abstract SCSI command into a firmware command block |
2528 | * suitable for feeding to the InitIO host controller. This also requires |
2529 | * we build the scatter gather lists and ensure they are mapped properly. |
2530 | */ |
2531 | |
2532 | static void initio_build_scb(struct initio_host * host, struct scsi_ctrl_blk * cblk, struct scsi_cmnd * cmnd) |
2533 | { /* Create corresponding SCB */ |
2534 | struct scatterlist *sglist; |
2535 | struct sg_entry *sg; /* Pointer to SG list */ |
2536 | int i, nseg; |
2537 | long total_len; |
2538 | dma_addr_t dma_addr; |
2539 | |
2540 | /* Fill in the command headers */ |
2541 | cblk->post = i91uSCBPost; /* i91u's callback routine */ |
2542 | cblk->srb = cmnd; |
2543 | cblk->opcode = ExecSCSI; |
2544 | cblk->flags = SCF_POST; /* After SCSI done, call post routine */ |
2545 | cblk->target = cmnd->device->id; |
2546 | cblk->lun = cmnd->device->lun; |
2547 | cblk->ident = cmnd->device->lun | DISC_ALLOW; |
2548 | |
2549 | cblk->flags |= SCF_SENSE; /* Turn on auto request sense */ |
2550 | |
2551 | /* Map the sense buffer into bus memory */ |
2552 | dma_addr = dma_map_single(&host->pci_dev->dev, cmnd->sense_buffer, |
2553 | SENSE_SIZE, DMA_FROM_DEVICE); |
2554 | cblk->senseptr = (u32)dma_addr; |
2555 | cblk->senselen = SENSE_SIZE; |
2556 | initio_priv(cmd: cmnd)->sense_dma_addr = dma_addr; |
2557 | cblk->cdblen = cmnd->cmd_len; |
2558 | |
2559 | /* Clear the returned status */ |
2560 | cblk->hastat = 0; |
2561 | cblk->tastat = 0; |
2562 | /* Command the command */ |
2563 | memcpy(cblk->cdb, cmnd->cmnd, cmnd->cmd_len); |
2564 | |
2565 | /* Set up tags */ |
2566 | if (cmnd->device->tagged_supported) { /* Tag Support */ |
2567 | cblk->tagmsg = SIMPLE_QUEUE_TAG; /* Do simple tag only */ |
2568 | } else { |
2569 | cblk->tagmsg = 0; /* No tag support */ |
2570 | } |
2571 | |
2572 | /* todo handle map_sg error */ |
2573 | nseg = scsi_dma_map(cmd: cmnd); |
2574 | BUG_ON(nseg < 0); |
2575 | if (nseg) { |
2576 | dma_addr = dma_map_single(&host->pci_dev->dev, &cblk->sglist[0], |
2577 | sizeof(struct sg_entry) * TOTAL_SG_ENTRY, |
2578 | DMA_BIDIRECTIONAL); |
2579 | cblk->bufptr = (u32)dma_addr; |
2580 | initio_priv(cmd: cmnd)->sglist_dma_addr = dma_addr; |
2581 | |
2582 | cblk->sglen = nseg; |
2583 | |
2584 | cblk->flags |= SCF_SG; /* Turn on SG list flag */ |
2585 | total_len = 0; |
2586 | sg = &cblk->sglist[0]; |
2587 | scsi_for_each_sg(cmnd, sglist, cblk->sglen, i) { |
2588 | sg->data = cpu_to_le32((u32)sg_dma_address(sglist)); |
2589 | sg->len = cpu_to_le32((u32)sg_dma_len(sglist)); |
2590 | total_len += sg_dma_len(sglist); |
2591 | ++sg; |
2592 | } |
2593 | |
2594 | cblk->buflen = (scsi_bufflen(cmd: cmnd) > total_len) ? |
2595 | total_len : scsi_bufflen(cmd: cmnd); |
2596 | } else { /* No data transfer required */ |
2597 | cblk->buflen = 0; |
2598 | cblk->sglen = 0; |
2599 | } |
2600 | } |
2601 | |
2602 | /** |
2603 | * i91u_queuecommand_lck - Queue a new command if possible |
2604 | * @cmd: SCSI command block from the mid layer |
2605 | * |
2606 | * Attempts to queue a new command with the host adapter. Will return |
2607 | * zero if successful or indicate a host busy condition if not (which |
2608 | * will cause the mid layer to call us again later with the command) |
2609 | */ |
2610 | static int i91u_queuecommand_lck(struct scsi_cmnd *cmd) |
2611 | { |
2612 | struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata; |
2613 | struct scsi_ctrl_blk *cmnd; |
2614 | |
2615 | cmnd = initio_alloc_scb(host); |
2616 | if (!cmnd) |
2617 | return SCSI_MLQUEUE_HOST_BUSY; |
2618 | |
2619 | initio_build_scb(host, cblk: cmnd, cmnd: cmd); |
2620 | initio_exec_scb(host, scb: cmnd); |
2621 | return 0; |
2622 | } |
2623 | |
2624 | static DEF_SCSI_QCMD(i91u_queuecommand) |
2625 | |
2626 | /** |
2627 | * i91u_bus_reset - reset the SCSI bus |
2628 | * @cmnd: Command block we want to trigger the reset for |
2629 | * |
2630 | * Initiate a SCSI bus reset sequence |
2631 | */ |
2632 | |
2633 | static int i91u_bus_reset(struct scsi_cmnd * cmnd) |
2634 | { |
2635 | struct initio_host *host; |
2636 | |
2637 | host = (struct initio_host *) cmnd->device->host->hostdata; |
2638 | |
2639 | spin_lock_irq(lock: cmnd->device->host->host_lock); |
2640 | initio_reset_scsi(host, seconds: 0); |
2641 | spin_unlock_irq(lock: cmnd->device->host->host_lock); |
2642 | |
2643 | return SUCCESS; |
2644 | } |
2645 | |
2646 | /** |
2647 | * i91u_biosparam - return the "logical geometry |
2648 | * @sdev: SCSI device |
2649 | * @dev: Matching block device |
2650 | * @capacity: Sector size of drive |
2651 | * @info_array: Return space for BIOS geometry |
2652 | * |
2653 | * Map the device geometry in a manner compatible with the host |
2654 | * controller BIOS behaviour. |
2655 | * |
2656 | * FIXME: limited to 2^32 sector devices. |
2657 | */ |
2658 | |
2659 | static int i91u_biosparam(struct scsi_device *sdev, struct block_device *dev, |
2660 | sector_t capacity, int *info_array) |
2661 | { |
2662 | struct initio_host *host; /* Point to Host adapter control block */ |
2663 | struct target_control *tc; |
2664 | |
2665 | host = (struct initio_host *) sdev->host->hostdata; |
2666 | tc = &host->targets[sdev->id]; |
2667 | |
2668 | if (tc->heads) { |
2669 | info_array[0] = tc->heads; |
2670 | info_array[1] = tc->sectors; |
2671 | info_array[2] = (unsigned long)capacity / tc->heads / tc->sectors; |
2672 | } else { |
2673 | if (tc->drv_flags & TCF_DRV_255_63) { |
2674 | info_array[0] = 255; |
2675 | info_array[1] = 63; |
2676 | info_array[2] = (unsigned long)capacity / 255 / 63; |
2677 | } else { |
2678 | info_array[0] = 64; |
2679 | info_array[1] = 32; |
2680 | info_array[2] = (unsigned long)capacity >> 11; |
2681 | } |
2682 | } |
2683 | |
2684 | #if defined(DEBUG_BIOSPARAM) |
2685 | if (i91u_debug & debug_biosparam) { |
2686 | printk("bios geometry: head=%d, sec=%d, cyl=%d\n" , |
2687 | info_array[0], info_array[1], info_array[2]); |
2688 | printk("WARNING: check, if the bios geometry is correct.\n" ); |
2689 | } |
2690 | #endif |
2691 | |
2692 | return 0; |
2693 | } |
2694 | |
2695 | /** |
2696 | * i91u_unmap_scb - Unmap a command |
2697 | * @pci_dev: PCI device the command is for |
2698 | * @cmnd: The command itself |
2699 | * |
2700 | * Unmap any PCI mapping/IOMMU resources allocated when the command |
2701 | * was mapped originally as part of initio_build_scb |
2702 | */ |
2703 | |
2704 | static void i91u_unmap_scb(struct pci_dev *pci_dev, struct scsi_cmnd *cmnd) |
2705 | { |
2706 | /* auto sense buffer */ |
2707 | if (initio_priv(cmd: cmnd)->sense_dma_addr) { |
2708 | dma_unmap_single(&pci_dev->dev, |
2709 | initio_priv(cmnd)->sense_dma_addr, |
2710 | SENSE_SIZE, DMA_FROM_DEVICE); |
2711 | initio_priv(cmd: cmnd)->sense_dma_addr = 0; |
2712 | } |
2713 | |
2714 | /* request buffer */ |
2715 | if (scsi_sg_count(cmd: cmnd)) { |
2716 | dma_unmap_single(&pci_dev->dev, |
2717 | initio_priv(cmnd)->sglist_dma_addr, |
2718 | sizeof(struct sg_entry) * TOTAL_SG_ENTRY, |
2719 | DMA_BIDIRECTIONAL); |
2720 | |
2721 | scsi_dma_unmap(cmd: cmnd); |
2722 | } |
2723 | } |
2724 | |
2725 | /* |
2726 | * i91uSCBPost - SCSI callback |
2727 | * |
2728 | * This is callback routine be called when tulip finish one |
2729 | * SCSI command. |
2730 | */ |
2731 | |
2732 | static void i91uSCBPost(u8 * host_mem, u8 * cblk_mem) |
2733 | { |
2734 | struct scsi_cmnd *cmnd; /* Pointer to SCSI request block */ |
2735 | struct initio_host *host; |
2736 | struct scsi_ctrl_blk *cblk; |
2737 | |
2738 | host = (struct initio_host *) host_mem; |
2739 | cblk = (struct scsi_ctrl_blk *) cblk_mem; |
2740 | if ((cmnd = cblk->srb) == NULL) { |
2741 | printk(KERN_ERR "i91uSCBPost: SRB pointer is empty\n" ); |
2742 | WARN_ON(1); |
2743 | initio_release_scb(host, cmnd: cblk); /* Release SCB for current channel */ |
2744 | return; |
2745 | } |
2746 | |
2747 | /* |
2748 | * Remap the firmware error status into a mid layer one |
2749 | */ |
2750 | switch (cblk->hastat) { |
2751 | case 0x0: |
2752 | case 0xa: /* Linked command complete without error and linked normally */ |
2753 | case 0xb: /* Linked command complete without error interrupt generated */ |
2754 | cblk->hastat = 0; |
2755 | break; |
2756 | |
2757 | case 0x11: /* Selection time out-The initiator selection or target |
2758 | reselection was not complete within the SCSI Time out period */ |
2759 | cblk->hastat = DID_TIME_OUT; |
2760 | break; |
2761 | |
2762 | case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus |
2763 | phase sequence was requested by the target. The host adapter |
2764 | will generate a SCSI Reset Condition, notifying the host with |
2765 | a SCRD interrupt */ |
2766 | cblk->hastat = DID_RESET; |
2767 | break; |
2768 | |
2769 | case 0x1a: /* SCB Aborted. 07/21/98 */ |
2770 | cblk->hastat = DID_ABORT; |
2771 | break; |
2772 | |
2773 | case 0x12: /* Data overrun/underrun-The target attempted to transfer more data |
2774 | than was allocated by the Data Length field or the sum of the |
2775 | Scatter / Gather Data Length fields. */ |
2776 | case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */ |
2777 | case 0x16: /* Invalid SCB Operation Code. */ |
2778 | |
2779 | default: |
2780 | printk("ini9100u: %x %x\n" , cblk->hastat, cblk->tastat); |
2781 | cblk->hastat = DID_ERROR; /* Couldn't find any better */ |
2782 | break; |
2783 | } |
2784 | |
2785 | cmnd->result = cblk->tastat | (cblk->hastat << 16); |
2786 | i91u_unmap_scb(pci_dev: host->pci_dev, cmnd); |
2787 | scsi_done(cmd: cmnd); /* Notify system DONE */ |
2788 | initio_release_scb(host, cmnd: cblk); /* Release SCB for current channel */ |
2789 | } |
2790 | |
2791 | static const struct scsi_host_template initio_template = { |
2792 | .proc_name = "INI9100U" , |
2793 | .name = "Initio INI-9X00U/UW SCSI device driver" , |
2794 | .queuecommand = i91u_queuecommand, |
2795 | .eh_bus_reset_handler = i91u_bus_reset, |
2796 | .bios_param = i91u_biosparam, |
2797 | .can_queue = MAX_TARGETS * i91u_MAXQUEUE, |
2798 | .this_id = 1, |
2799 | .sg_tablesize = SG_ALL, |
2800 | .cmd_size = sizeof(struct initio_cmd_priv), |
2801 | }; |
2802 | |
2803 | static int initio_probe_one(struct pci_dev *pdev, |
2804 | const struct pci_device_id *id) |
2805 | { |
2806 | struct Scsi_Host *shost; |
2807 | struct initio_host *host; |
2808 | u32 reg; |
2809 | u16 bios_seg; |
2810 | struct scsi_ctrl_blk *scb, *tmp, *prev = NULL /* silence gcc */; |
2811 | int num_scb, i, error; |
2812 | |
2813 | error = pci_enable_device(dev: pdev); |
2814 | if (error) |
2815 | return error; |
2816 | |
2817 | pci_read_config_dword(dev: pdev, where: 0x44, val: (u32 *) & reg); |
2818 | bios_seg = (u16) (reg & 0xFF); |
2819 | if (((reg & 0xFF00) >> 8) == 0xFF) |
2820 | reg = 0; |
2821 | bios_seg = (bios_seg << 8) + ((u16) ((reg & 0xFF00) >> 8)); |
2822 | |
2823 | if (dma_set_mask(dev: &pdev->dev, DMA_BIT_MASK(32))) { |
2824 | printk(KERN_WARNING "i91u: Could not set 32 bit DMA mask\n" ); |
2825 | error = -ENODEV; |
2826 | goto out_disable_device; |
2827 | } |
2828 | shost = scsi_host_alloc(&initio_template, sizeof(struct initio_host)); |
2829 | if (!shost) { |
2830 | printk(KERN_WARNING "initio: Could not allocate host structure.\n" ); |
2831 | error = -ENOMEM; |
2832 | goto out_disable_device; |
2833 | } |
2834 | host = (struct initio_host *)shost->hostdata; |
2835 | memset(host, 0, sizeof(struct initio_host)); |
2836 | host->addr = pci_resource_start(pdev, 0); |
2837 | host->bios_addr = bios_seg; |
2838 | |
2839 | if (!request_region(host->addr, 256, "i91u" )) { |
2840 | printk(KERN_WARNING "initio: I/O port range 0x%x is busy.\n" , host->addr); |
2841 | error = -ENODEV; |
2842 | goto out_host_put; |
2843 | } |
2844 | |
2845 | if (initio_tag_enable) /* 1.01i */ |
2846 | num_scb = MAX_TARGETS * i91u_MAXQUEUE; |
2847 | else |
2848 | num_scb = MAX_TARGETS + 3; /* 1-tape, 1-CD_ROM, 1- extra */ |
2849 | |
2850 | for (; num_scb >= MAX_TARGETS + 3; num_scb--) { |
2851 | i = num_scb * sizeof(struct scsi_ctrl_blk); |
2852 | scb = kzalloc(size: i, GFP_KERNEL); |
2853 | if (scb) |
2854 | break; |
2855 | } |
2856 | |
2857 | if (!scb) { |
2858 | printk(KERN_WARNING "initio: Cannot allocate SCB array.\n" ); |
2859 | error = -ENOMEM; |
2860 | goto out_release_region; |
2861 | } |
2862 | |
2863 | host->pci_dev = pdev; |
2864 | |
2865 | host->semaph = 1; |
2866 | spin_lock_init(&host->semaph_lock); |
2867 | host->num_scbs = num_scb; |
2868 | host->scb = scb; |
2869 | host->next_pending = scb; |
2870 | host->next_avail = scb; |
2871 | for (i = 0, tmp = scb; i < num_scb; i++, tmp++) { |
2872 | tmp->tagid = i; |
2873 | if (i != 0) |
2874 | prev->next = tmp; |
2875 | prev = tmp; |
2876 | } |
2877 | prev->next = NULL; |
2878 | host->scb_end = tmp; |
2879 | host->first_avail = scb; |
2880 | host->last_avail = prev; |
2881 | spin_lock_init(&host->avail_lock); |
2882 | |
2883 | initio_init(host, phys_to_virt(address: ((u32)bios_seg << 4))); |
2884 | |
2885 | host->jsstatus0 = 0; |
2886 | |
2887 | shost->io_port = host->addr; |
2888 | shost->n_io_port = 0xff; |
2889 | shost->can_queue = num_scb; /* 03/05/98 */ |
2890 | shost->unique_id = host->addr; |
2891 | shost->max_id = host->max_tar; |
2892 | shost->max_lun = 32; /* 10/21/97 */ |
2893 | shost->irq = pdev->irq; |
2894 | shost->this_id = host->scsi_id; /* Assign HCS index */ |
2895 | shost->base = host->addr; |
2896 | shost->sg_tablesize = TOTAL_SG_ENTRY; |
2897 | |
2898 | error = request_irq(irq: pdev->irq, handler: i91u_intr, IRQF_SHARED, name: "i91u" , dev: shost); |
2899 | if (error < 0) { |
2900 | printk(KERN_WARNING "initio: Unable to request IRQ %d\n" , pdev->irq); |
2901 | goto out_free_scbs; |
2902 | } |
2903 | |
2904 | pci_set_drvdata(pdev, data: shost); |
2905 | |
2906 | error = scsi_add_host(host: shost, dev: &pdev->dev); |
2907 | if (error) |
2908 | goto out_free_irq; |
2909 | scsi_scan_host(shost); |
2910 | return 0; |
2911 | out_free_irq: |
2912 | free_irq(pdev->irq, shost); |
2913 | out_free_scbs: |
2914 | kfree(objp: host->scb); |
2915 | out_release_region: |
2916 | release_region(host->addr, 256); |
2917 | out_host_put: |
2918 | scsi_host_put(t: shost); |
2919 | out_disable_device: |
2920 | pci_disable_device(dev: pdev); |
2921 | return error; |
2922 | } |
2923 | |
2924 | /** |
2925 | * initio_remove_one - control shutdown |
2926 | * @pdev: PCI device being released |
2927 | * |
2928 | * Release the resources assigned to this adapter after it has |
2929 | * finished being used. |
2930 | */ |
2931 | |
2932 | static void initio_remove_one(struct pci_dev *pdev) |
2933 | { |
2934 | struct Scsi_Host *host = pci_get_drvdata(pdev); |
2935 | struct initio_host *s = (struct initio_host *)host->hostdata; |
2936 | scsi_remove_host(host); |
2937 | free_irq(pdev->irq, host); |
2938 | release_region(s->addr, 256); |
2939 | scsi_host_put(t: host); |
2940 | pci_disable_device(dev: pdev); |
2941 | } |
2942 | |
2943 | MODULE_LICENSE("GPL" ); |
2944 | |
2945 | static struct pci_device_id initio_pci_tbl[] = { |
2946 | {PCI_VENDOR_ID_INIT, 0x9500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
2947 | {PCI_VENDOR_ID_INIT, 0x9400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
2948 | {PCI_VENDOR_ID_INIT, 0x9401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
2949 | {PCI_VENDOR_ID_INIT, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
2950 | {PCI_VENDOR_ID_DOMEX, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
2951 | {0,} |
2952 | }; |
2953 | MODULE_DEVICE_TABLE(pci, initio_pci_tbl); |
2954 | |
2955 | static struct pci_driver initio_pci_driver = { |
2956 | .name = "initio" , |
2957 | .id_table = initio_pci_tbl, |
2958 | .probe = initio_probe_one, |
2959 | .remove = initio_remove_one, |
2960 | }; |
2961 | module_pci_driver(initio_pci_driver); |
2962 | |
2963 | MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver" ); |
2964 | MODULE_AUTHOR("Initio Corporation" ); |
2965 | MODULE_LICENSE("GPL" ); |
2966 | |