xref: /openbmc/linux/drivers/scsi/FlashPoint.c (revision 554b117e)
1 /*
2 
3   FlashPoint.c -- FlashPoint SCCB Manager for Linux
4 
5   This file contains the FlashPoint SCCB Manager from BusLogic's FlashPoint
6   Driver Developer's Kit, with minor modifications by Leonard N. Zubkoff for
7   Linux compatibility.  It was provided by BusLogic in the form of 16 separate
8   source files, which would have unnecessarily cluttered the scsi directory, so
9   the individual files have been combined into this single file.
10 
11   Copyright 1995-1996 by Mylex Corporation.  All Rights Reserved
12 
13   This file is available under both the GNU General Public License
14   and a BSD-style copyright; see LICENSE.FlashPoint for details.
15 
16 */
17 
18 
19 #ifdef CONFIG_SCSI_FLASHPOINT
20 
21 #define MAX_CARDS	8
22 #undef BUSTYPE_PCI
23 
24 #define CRCMASK	0xA001
25 
26 #define FAILURE         0xFFFFFFFFL
27 
28 struct sccb;
29 typedef void (*CALL_BK_FN) (struct sccb *);
30 
31 struct sccb_mgr_info {
32 	u32 si_baseaddr;
33 	unsigned char si_present;
34 	unsigned char si_intvect;
35 	unsigned char si_id;
36 	unsigned char si_lun;
37 	u16 si_fw_revision;
38 	u16 si_per_targ_init_sync;
39 	u16 si_per_targ_fast_nego;
40 	u16 si_per_targ_ultra_nego;
41 	u16 si_per_targ_no_disc;
42 	u16 si_per_targ_wide_nego;
43 	u16 si_mflags;
44 	unsigned char si_card_family;
45 	unsigned char si_bustype;
46 	unsigned char si_card_model[3];
47 	unsigned char si_relative_cardnum;
48 	unsigned char si_reserved[4];
49 	u32 si_OS_reserved;
50 	unsigned char si_XlatInfo[4];
51 	u32 si_reserved2[5];
52 	u32 si_secondary_range;
53 };
54 
55 #define SCSI_PARITY_ENA		  0x0001
56 #define LOW_BYTE_TERM		  0x0010
57 #define HIGH_BYTE_TERM		  0x0020
58 #define BUSTYPE_PCI	  0x3
59 
60 #define SUPPORT_16TAR_32LUN	  0x0002
61 #define SOFT_RESET		  0x0004
62 #define EXTENDED_TRANSLATION	  0x0008
63 #define POST_ALL_UNDERRRUNS	  0x0040
64 #define FLAG_SCAM_ENABLED	  0x0080
65 #define FLAG_SCAM_LEVEL2	  0x0100
66 
67 #define HARPOON_FAMILY        0x02
68 
69 /* SCCB struct used for both SCCB and UCB manager compiles!
70  * The UCB Manager treats the SCCB as it's 'native hardware structure'
71  */
72 
73 /*#pragma pack(1)*/
74 struct sccb {
75 	unsigned char OperationCode;
76 	unsigned char ControlByte;
77 	unsigned char CdbLength;
78 	unsigned char RequestSenseLength;
79 	u32 DataLength;
80 	void *DataPointer;
81 	unsigned char CcbRes[2];
82 	unsigned char HostStatus;
83 	unsigned char TargetStatus;
84 	unsigned char TargID;
85 	unsigned char Lun;
86 	unsigned char Cdb[12];
87 	unsigned char CcbRes1;
88 	unsigned char Reserved1;
89 	u32 Reserved2;
90 	u32 SensePointer;
91 
92 	CALL_BK_FN SccbCallback;	/* VOID (*SccbCallback)(); */
93 	u32 SccbIOPort;			/* Identifies board base port */
94 	unsigned char SccbStatus;
95 	unsigned char SCCBRes2;
96 	u16 SccbOSFlags;
97 
98 	u32 Sccb_XferCnt;	/* actual transfer count */
99 	u32 Sccb_ATC;
100 	u32 SccbVirtDataPtr;	/* virtual addr for OS/2 */
101 	u32 Sccb_res1;
102 	u16 Sccb_MGRFlags;
103 	u16 Sccb_sgseg;
104 	unsigned char Sccb_scsimsg;	/* identify msg for selection */
105 	unsigned char Sccb_tag;
106 	unsigned char Sccb_scsistat;
107 	unsigned char Sccb_idmsg;	/* image of last msg in */
108 	struct sccb *Sccb_forwardlink;
109 	struct sccb *Sccb_backlink;
110 	u32 Sccb_savedATC;
111 	unsigned char Save_Cdb[6];
112 	unsigned char Save_CdbLen;
113 	unsigned char Sccb_XferState;
114 	u32 Sccb_SGoffset;
115 };
116 
117 #pragma pack()
118 
119 #define SCATTER_GATHER_COMMAND    0x02
120 #define RESIDUAL_COMMAND          0x03
121 #define RESIDUAL_SG_COMMAND       0x04
122 #define RESET_COMMAND             0x81
123 
124 #define F_USE_CMD_Q              0x20	/*Inidcates TAGGED command. */
125 #define TAG_TYPE_MASK            0xC0	/*Type of tag msg to send. */
126 #define SCCB_DATA_XFER_OUT       0x10	/* Write */
127 #define SCCB_DATA_XFER_IN        0x08	/* Read */
128 
129 #define NO_AUTO_REQUEST_SENSE    0x01	/* No Request Sense Buffer */
130 
131 #define BUS_FREE_ST     0
132 #define SELECT_ST       1
133 #define SELECT_BDR_ST   2	/* Select w\ Bus Device Reset */
134 #define SELECT_SN_ST    3	/* Select w\ Sync Nego */
135 #define SELECT_WN_ST    4	/* Select w\ Wide Data Nego */
136 #define SELECT_Q_ST     5	/* Select w\ Tagged Q'ing */
137 #define COMMAND_ST      6
138 #define DATA_OUT_ST     7
139 #define DATA_IN_ST      8
140 #define DISCONNECT_ST   9
141 #define ABORT_ST        11
142 
143 #define F_HOST_XFER_DIR                0x01
144 #define F_ALL_XFERRED                  0x02
145 #define F_SG_XFER                      0x04
146 #define F_AUTO_SENSE                   0x08
147 #define F_ODD_BALL_CNT                 0x10
148 #define F_NO_DATA_YET                  0x80
149 
150 #define F_STATUSLOADED                 0x01
151 #define F_DEV_SELECTED                 0x04
152 
153 #define SCCB_COMPLETE               0x00	/* SCCB completed without error */
154 #define SCCB_DATA_UNDER_RUN         0x0C
155 #define SCCB_SELECTION_TIMEOUT      0x11	/* Set SCSI selection timed out */
156 #define SCCB_DATA_OVER_RUN          0x12
157 #define SCCB_PHASE_SEQUENCE_FAIL    0x14	/* Target bus phase sequence failure */
158 
159 #define SCCB_GROSS_FW_ERR           0x27	/* Major problem! */
160 #define SCCB_BM_ERR                 0x30	/* BusMaster error. */
161 #define SCCB_PARITY_ERR             0x34	/* SCSI parity error */
162 
163 #define SCCB_IN_PROCESS            0x00
164 #define SCCB_SUCCESS               0x01
165 #define SCCB_ABORT                 0x02
166 #define SCCB_ERROR                 0x04
167 
168 #define  ORION_FW_REV      3110
169 
170 #define QUEUE_DEPTH     254+1	/*1 for Normal disconnect 32 for Q'ing. */
171 
172 #define	MAX_MB_CARDS	4	/* Max. no of cards suppoerted on Mother Board */
173 
174 #define MAX_SCSI_TAR    16
175 #define MAX_LUN         32
176 #define LUN_MASK			0x1f
177 
178 #define SG_BUF_CNT      16	/*Number of prefetched elements. */
179 
180 #define SG_ELEMENT_SIZE 8	/*Eight byte per element. */
181 
182 #define RD_HARPOON(ioport)          inb((u32)ioport)
183 #define RDW_HARPOON(ioport)         inw((u32)ioport)
184 #define RD_HARP32(ioport,offset,data) (data = inl((u32)(ioport + offset)))
185 #define WR_HARPOON(ioport,val)      outb((u8) val, (u32)ioport)
186 #define WRW_HARPOON(ioport,val)       outw((u16)val, (u32)ioport)
187 #define WR_HARP32(ioport,offset,data)  outl(data, (u32)(ioport + offset))
188 
189 #define  TAR_SYNC_MASK     (BIT(7)+BIT(6))
190 #define  SYNC_TRYING               BIT(6)
191 #define  SYNC_SUPPORTED    (BIT(7)+BIT(6))
192 
193 #define  TAR_WIDE_MASK     (BIT(5)+BIT(4))
194 #define  WIDE_ENABLED              BIT(4)
195 #define  WIDE_NEGOCIATED   BIT(5)
196 
197 #define  TAR_TAG_Q_MASK    (BIT(3)+BIT(2))
198 #define  TAG_Q_TRYING              BIT(2)
199 #define  TAG_Q_REJECT      BIT(3)
200 
201 #define  TAR_ALLOW_DISC    BIT(0)
202 
203 #define  EE_SYNC_MASK      (BIT(0)+BIT(1))
204 #define  EE_SYNC_5MB       BIT(0)
205 #define  EE_SYNC_10MB      BIT(1)
206 #define  EE_SYNC_20MB      (BIT(0)+BIT(1))
207 
208 #define  EE_WIDE_SCSI      BIT(7)
209 
210 struct sccb_mgr_tar_info {
211 
212 	struct sccb *TarSelQ_Head;
213 	struct sccb *TarSelQ_Tail;
214 	unsigned char TarLUN_CA;	/*Contingent Allgiance */
215 	unsigned char TarTagQ_Cnt;
216 	unsigned char TarSelQ_Cnt;
217 	unsigned char TarStatus;
218 	unsigned char TarEEValue;
219 	unsigned char TarSyncCtrl;
220 	unsigned char TarReserved[2];	/* for alignment */
221 	unsigned char LunDiscQ_Idx[MAX_LUN];
222 	unsigned char TarLUNBusy[MAX_LUN];
223 };
224 
225 struct nvram_info {
226 	unsigned char niModel;		/* Model No. of card */
227 	unsigned char niCardNo;		/* Card no. */
228 	u32 niBaseAddr;			/* Port Address of card */
229 	unsigned char niSysConf;	/* Adapter Configuration byte -
230 					   Byte 16 of eeprom map */
231 	unsigned char niScsiConf;	/* SCSI Configuration byte -
232 					   Byte 17 of eeprom map */
233 	unsigned char niScamConf;	/* SCAM Configuration byte -
234 					   Byte 20 of eeprom map */
235 	unsigned char niAdapId;		/* Host Adapter ID -
236 					   Byte 24 of eerpom map */
237 	unsigned char niSyncTbl[MAX_SCSI_TAR / 2];	/* Sync/Wide byte
238 							   of targets */
239 	unsigned char niScamTbl[MAX_SCSI_TAR][4];	/* Compressed Scam name
240 							   string of Targets */
241 };
242 
243 #define	MODEL_LT		1
244 #define	MODEL_DL		2
245 #define	MODEL_LW		3
246 #define	MODEL_DW		4
247 
248 struct sccb_card {
249 	struct sccb *currentSCCB;
250 	struct sccb_mgr_info *cardInfo;
251 
252 	u32 ioPort;
253 
254 	unsigned short cmdCounter;
255 	unsigned char discQCount;
256 	unsigned char tagQ_Lst;
257 	unsigned char cardIndex;
258 	unsigned char scanIndex;
259 	unsigned char globalFlags;
260 	unsigned char ourId;
261 	struct nvram_info *pNvRamInfo;
262 	struct sccb *discQ_Tbl[QUEUE_DEPTH];
263 
264 };
265 
266 #define F_TAG_STARTED		0x01
267 #define F_CONLUN_IO			0x02
268 #define F_DO_RENEGO			0x04
269 #define F_NO_FILTER			0x08
270 #define F_GREEN_PC			0x10
271 #define F_HOST_XFER_ACT		0x20
272 #define F_NEW_SCCB_CMD		0x40
273 #define F_UPDATE_EEPROM		0x80
274 
275 #define  ID_STRING_LENGTH  32
276 #define  TYPE_CODE0        0x63	/*Level2 Mstr (bits 7-6),  */
277 
278 #define  SLV_TYPE_CODE0    0xA3	/*Priority Bit set (bits 7-6),  */
279 
280 #define  ASSIGN_ID   0x00
281 #define  SET_P_FLAG  0x01
282 #define  CFG_CMPLT   0x03
283 #define  DOM_MSTR    0x0F
284 #define  SYNC_PTRN   0x1F
285 
286 #define  ID_0_7      0x18
287 #define  ID_8_F      0x11
288 #define  MISC_CODE   0x14
289 #define  CLR_P_FLAG  0x18
290 
291 #define  INIT_SELTD  0x01
292 #define  LEVEL2_TAR  0x02
293 
294 enum scam_id_st { ID0, ID1, ID2, ID3, ID4, ID5, ID6, ID7, ID8, ID9, ID10, ID11,
295 	    ID12,
296 	ID13, ID14, ID15, ID_UNUSED, ID_UNASSIGNED, ID_ASSIGNED, LEGACY,
297 	CLR_PRIORITY, NO_ID_AVAIL
298 };
299 
300 typedef struct SCCBscam_info {
301 
302 	unsigned char id_string[ID_STRING_LENGTH];
303 	enum scam_id_st state;
304 
305 } SCCBSCAM_INFO;
306 
307 
308 #define  SMIDENT                 0x80
309 #define  DISC_PRIV               0x40
310 
311 #define  SM8BIT                  0x00
312 #define  SM16BIT                 0x01
313 
314 #define  SIX_BYTE_CMD            0x06
315 #define  TWELVE_BYTE_CMD         0x0C
316 
317 #define  ASYNC                   0x00
318 #define  MAX_OFFSET              0x0F	/* Maxbyteoffset for Sync Xfers */
319 
320 #define  EEPROM_WD_CNT     256
321 
322 #define  EEPROM_CHECK_SUM  0
323 #define  FW_SIGNATURE      2
324 #define  MODEL_NUMB_0      4
325 #define  MODEL_NUMB_2      6
326 #define  MODEL_NUMB_4      8
327 #define  SYSTEM_CONFIG     16
328 #define  SCSI_CONFIG       17
329 #define  BIOS_CONFIG       18
330 #define  SCAM_CONFIG       20
331 #define  ADAPTER_SCSI_ID   24
332 
333 #define  IGNORE_B_SCAN     32
334 #define  SEND_START_ENA    34
335 #define  DEVICE_ENABLE     36
336 
337 #define  SYNC_RATE_TBL     38
338 #define  SYNC_RATE_TBL01   38
339 #define  SYNC_RATE_TBL23   40
340 #define  SYNC_RATE_TBL45   42
341 #define  SYNC_RATE_TBL67   44
342 #define  SYNC_RATE_TBL89   46
343 #define  SYNC_RATE_TBLab   48
344 #define  SYNC_RATE_TBLcd   50
345 #define  SYNC_RATE_TBLef   52
346 
347 #define  EE_SCAMBASE      256
348 
349 #define  SCAM_ENABLED   BIT(2)
350 #define  SCAM_LEVEL2    BIT(3)
351 
352 #define	RENEGO_ENA		BIT(10)
353 #define	CONNIO_ENA		BIT(11)
354 #define  GREEN_PC_ENA   BIT(12)
355 
356 #define  AUTO_RATE_00   00
357 #define  AUTO_RATE_05   01
358 #define  AUTO_RATE_10   02
359 #define  AUTO_RATE_20   03
360 
361 #define  WIDE_NEGO_BIT     BIT(7)
362 #define  DISC_ENABLE_BIT   BIT(6)
363 
364 #define  hp_vendor_id_0       0x00	/* LSB */
365 #define  ORION_VEND_0   0x4B
366 
367 #define  hp_vendor_id_1       0x01	/* MSB */
368 #define  ORION_VEND_1   0x10
369 
370 #define  hp_device_id_0       0x02	/* LSB */
371 #define  ORION_DEV_0    0x30
372 
373 #define  hp_device_id_1       0x03	/* MSB */
374 #define  ORION_DEV_1    0x81
375 
376 	/* Sub Vendor ID and Sub Device ID only available in
377 	   Harpoon Version 2 and higher */
378 
379 #define  hp_sub_device_id_0   0x06	/* LSB */
380 
381 #define  hp_semaphore         0x0C
382 #define SCCB_MGR_ACTIVE    BIT(0)
383 #define TICKLE_ME          BIT(1)
384 #define SCCB_MGR_PRESENT   BIT(3)
385 #define BIOS_IN_USE        BIT(4)
386 
387 #define  hp_sys_ctrl          0x0F
388 
389 #define  STOP_CLK          BIT(0)	/*Turn off BusMaster Clock */
390 #define  DRVR_RST          BIT(1)	/*Firmware Reset to 80C15 chip */
391 #define  HALT_MACH         BIT(3)	/*Halt State Machine      */
392 #define  HARD_ABORT        BIT(4)	/*Hard Abort              */
393 
394 #define  hp_host_blk_cnt      0x13
395 
396 #define  XFER_BLK64        0x06	/*     1 1 0 64 byte per block */
397 
398 #define  BM_THRESHOLD      0x40	/* PCI mode can only xfer 16 bytes */
399 
400 #define  hp_int_mask          0x17
401 
402 #define  INT_CMD_COMPL     BIT(0)	/* DMA command complete   */
403 #define  INT_EXT_STATUS    BIT(1)	/* Extended Status Set    */
404 
405 #define  hp_xfer_cnt_lo       0x18
406 #define  hp_xfer_cnt_hi       0x1A
407 #define  hp_xfer_cmd          0x1B
408 
409 #define  XFER_HOST_DMA     0x00	/*     0 0 0 Transfer Host -> DMA */
410 #define  XFER_DMA_HOST     0x01	/*     0 0 1 Transfer DMA  -> Host */
411 
412 #define  XFER_HOST_AUTO    0x00	/*     0 0 Auto Transfer Size   */
413 
414 #define  XFER_DMA_8BIT     0x20	/*     0 1 8 BIT  Transfer Size */
415 
416 #define  DISABLE_INT       BIT(7)	/*Do not interrupt at end of cmd. */
417 
418 #define  HOST_WRT_CMD      ((DISABLE_INT + XFER_HOST_DMA + XFER_HOST_AUTO + XFER_DMA_8BIT))
419 #define  HOST_RD_CMD       ((DISABLE_INT + XFER_DMA_HOST + XFER_HOST_AUTO + XFER_DMA_8BIT))
420 
421 #define  hp_host_addr_lo      0x1C
422 #define  hp_host_addr_hmi     0x1E
423 
424 #define  hp_ee_ctrl           0x22
425 
426 #define  EXT_ARB_ACK       BIT(7)
427 #define  SCSI_TERM_ENA_H   BIT(6)	/* SCSI high byte terminator */
428 #define  SEE_MS            BIT(5)
429 #define  SEE_CS            BIT(3)
430 #define  SEE_CLK           BIT(2)
431 #define  SEE_DO            BIT(1)
432 #define  SEE_DI            BIT(0)
433 
434 #define  EE_READ           0x06
435 #define  EE_WRITE          0x05
436 #define  EWEN              0x04
437 #define  EWEN_ADDR         0x03C0
438 #define  EWDS              0x04
439 #define  EWDS_ADDR         0x0000
440 
441 #define  hp_bm_ctrl           0x26
442 
443 #define  SCSI_TERM_ENA_L   BIT(0)	/*Enable/Disable external terminators */
444 #define  FLUSH_XFER_CNTR   BIT(1)	/*Flush transfer counter */
445 #define  FORCE1_XFER       BIT(5)	/*Always xfer one byte in byte mode */
446 #define  FAST_SINGLE       BIT(6)	/*?? */
447 
448 #define  BMCTRL_DEFAULT    (FORCE1_XFER|FAST_SINGLE|SCSI_TERM_ENA_L)
449 
450 #define  hp_sg_addr           0x28
451 #define  hp_page_ctrl         0x29
452 
453 #define  SCATTER_EN        BIT(0)
454 #define  SGRAM_ARAM        BIT(1)
455 #define  G_INT_DISABLE     BIT(3)	/* Enable/Disable all Interrupts */
456 #define  NARROW_SCSI_CARD  BIT(4)	/* NARROW/WIDE SCSI config pin */
457 
458 #define  hp_pci_stat_cfg      0x2D
459 
460 #define  REC_MASTER_ABORT  BIT(5)	/*received Master abort */
461 
462 #define  hp_rev_num           0x33
463 
464 #define  hp_stack_data        0x34
465 #define  hp_stack_addr        0x35
466 
467 #define  hp_ext_status        0x36
468 
469 #define  BM_FORCE_OFF      BIT(0)	/*Bus Master is forced to get off */
470 #define  PCI_TGT_ABORT     BIT(0)	/*PCI bus master transaction aborted */
471 #define  PCI_DEV_TMOUT     BIT(1)	/*PCI Device Time out */
472 #define  CMD_ABORTED       BIT(4)	/*Command aborted */
473 #define  BM_PARITY_ERR     BIT(5)	/*parity error on data received   */
474 #define  PIO_OVERRUN       BIT(6)	/*Slave data overrun */
475 #define  BM_CMD_BUSY       BIT(7)	/*Bus master transfer command busy */
476 #define  BAD_EXT_STATUS    (BM_FORCE_OFF | PCI_DEV_TMOUT | CMD_ABORTED | \
477                                   BM_PARITY_ERR | PIO_OVERRUN)
478 
479 #define  hp_int_status        0x37
480 
481 #define  EXT_STATUS_ON     BIT(1)	/*Extended status is valid */
482 #define  SCSI_INTERRUPT    BIT(2)	/*Global indication of a SCSI int. */
483 #define  INT_ASSERTED      BIT(5)	/* */
484 
485 #define  hp_fifo_cnt          0x38
486 
487 #define  hp_intena		 0x40
488 
489 #define  RESET		 BIT(7)
490 #define  PROG_HLT		 BIT(6)
491 #define  PARITY		 BIT(5)
492 #define  FIFO		 BIT(4)
493 #define  SEL		 BIT(3)
494 #define  SCAM_SEL		 BIT(2)
495 #define  RSEL		 BIT(1)
496 #define  TIMEOUT		 BIT(0)
497 #define  BUS_FREE		 BIT(15)
498 #define  XFER_CNT_0	 BIT(14)
499 #define  PHASE		 BIT(13)
500 #define  IUNKWN		 BIT(12)
501 #define  ICMD_COMP	 BIT(11)
502 #define  ITICKLE		 BIT(10)
503 #define  IDO_STRT		 BIT(9)
504 #define  ITAR_DISC	 BIT(8)
505 #define  AUTO_INT		 (BIT(12)+BIT(11)+BIT(10)+BIT(9)+BIT(8))
506 #define  CLR_ALL_INT	 0xFFFF
507 #define  CLR_ALL_INT_1	 0xFF00
508 
509 #define  hp_intstat		 0x42
510 
511 #define  hp_scsisig           0x44
512 
513 #define  SCSI_SEL          BIT(7)
514 #define  SCSI_BSY          BIT(6)
515 #define  SCSI_REQ          BIT(5)
516 #define  SCSI_ACK          BIT(4)
517 #define  SCSI_ATN          BIT(3)
518 #define  SCSI_CD           BIT(2)
519 #define  SCSI_MSG          BIT(1)
520 #define  SCSI_IOBIT        BIT(0)
521 
522 #define  S_SCSI_PHZ        (BIT(2)+BIT(1)+BIT(0))
523 #define  S_MSGO_PH         (BIT(2)+BIT(1)       )
524 #define  S_MSGI_PH         (BIT(2)+BIT(1)+BIT(0))
525 #define  S_DATAI_PH        (              BIT(0))
526 #define  S_DATAO_PH        0x00
527 #define  S_ILL_PH          (       BIT(1)       )
528 
529 #define  hp_scsictrl_0        0x45
530 
531 #define  SEL_TAR           BIT(6)
532 #define  ENA_ATN           BIT(4)
533 #define  ENA_RESEL         BIT(2)
534 #define  SCSI_RST          BIT(1)
535 #define  ENA_SCAM_SEL      BIT(0)
536 
537 #define  hp_portctrl_0        0x46
538 
539 #define  SCSI_PORT         BIT(7)
540 #define  SCSI_INBIT        BIT(6)
541 #define  DMA_PORT          BIT(5)
542 #define  DMA_RD            BIT(4)
543 #define  HOST_PORT         BIT(3)
544 #define  HOST_WRT          BIT(2)
545 #define  SCSI_BUS_EN       BIT(1)
546 #define  START_TO          BIT(0)
547 
548 #define  hp_scsireset         0x47
549 
550 #define  SCSI_INI          BIT(6)
551 #define  SCAM_EN           BIT(5)
552 #define  DMA_RESET         BIT(3)
553 #define  HPSCSI_RESET      BIT(2)
554 #define  PROG_RESET        BIT(1)
555 #define  FIFO_CLR          BIT(0)
556 
557 #define  hp_xfercnt_0         0x48
558 #define  hp_xfercnt_2         0x4A
559 
560 #define  hp_fifodata_0        0x4C
561 #define  hp_addstat           0x4E
562 
563 #define  SCAM_TIMER        BIT(7)
564 #define  SCSI_MODE8        BIT(3)
565 #define  SCSI_PAR_ERR      BIT(0)
566 
567 #define  hp_prgmcnt_0         0x4F
568 
569 #define  hp_selfid_0          0x50
570 #define  hp_selfid_1          0x51
571 #define  hp_arb_id            0x52
572 
573 #define  hp_select_id         0x53
574 
575 #define  hp_synctarg_base     0x54
576 #define  hp_synctarg_12       0x54
577 #define  hp_synctarg_13       0x55
578 #define  hp_synctarg_14       0x56
579 #define  hp_synctarg_15       0x57
580 
581 #define  hp_synctarg_8        0x58
582 #define  hp_synctarg_9        0x59
583 #define  hp_synctarg_10       0x5A
584 #define  hp_synctarg_11       0x5B
585 
586 #define  hp_synctarg_4        0x5C
587 #define  hp_synctarg_5        0x5D
588 #define  hp_synctarg_6        0x5E
589 #define  hp_synctarg_7        0x5F
590 
591 #define  hp_synctarg_0        0x60
592 #define  hp_synctarg_1        0x61
593 #define  hp_synctarg_2        0x62
594 #define  hp_synctarg_3        0x63
595 
596 #define  NARROW_SCSI       BIT(4)
597 #define  DEFAULT_OFFSET    0x0F
598 
599 #define  hp_autostart_0       0x64
600 #define  hp_autostart_1       0x65
601 #define  hp_autostart_3       0x67
602 
603 #define  AUTO_IMMED    BIT(5)
604 #define  SELECT   BIT(6)
605 #define  END_DATA (BIT(7)+BIT(6))
606 
607 #define  hp_gp_reg_0          0x68
608 #define  hp_gp_reg_1          0x69
609 #define  hp_gp_reg_3          0x6B
610 
611 #define  hp_seltimeout        0x6C
612 
613 #define  TO_4ms            0x67	/* 3.9959ms */
614 
615 #define  TO_5ms            0x03	/* 4.9152ms */
616 #define  TO_10ms           0x07	/* 11.xxxms */
617 #define  TO_250ms          0x99	/* 250.68ms */
618 #define  TO_290ms          0xB1	/* 289.99ms */
619 
620 #define  hp_clkctrl_0         0x6D
621 
622 #define  PWR_DWN           BIT(6)
623 #define  ACTdeassert       BIT(4)
624 #define  CLK_40MHZ         (BIT(1) + BIT(0))
625 
626 #define  CLKCTRL_DEFAULT   (ACTdeassert | CLK_40MHZ)
627 
628 #define  hp_fiforead          0x6E
629 #define  hp_fifowrite         0x6F
630 
631 #define  hp_offsetctr         0x70
632 #define  hp_xferstat          0x71
633 
634 #define  FIFO_EMPTY        BIT(6)
635 
636 #define  hp_portctrl_1        0x72
637 
638 #define  CHK_SCSI_P        BIT(3)
639 #define  HOST_MODE8        BIT(0)
640 
641 #define  hp_xfer_pad          0x73
642 
643 #define  ID_UNLOCK         BIT(3)
644 
645 #define  hp_scsidata_0        0x74
646 #define  hp_scsidata_1        0x75
647 
648 #define  hp_aramBase          0x80
649 #define  BIOS_DATA_OFFSET     0x60
650 #define  BIOS_RELATIVE_CARD   0x64
651 
652 #define  AR3      (BIT(9) + BIT(8))
653 #define  SDATA    BIT(10)
654 
655 #define  CRD_OP   BIT(11)	/* Cmp Reg. w/ Data */
656 
657 #define  CRR_OP   BIT(12)	/* Cmp Reg. w. Reg. */
658 
659 #define  CPE_OP   (BIT(14)+BIT(11))	/* Cmp SCSI phs & Branch EQ */
660 
661 #define  CPN_OP   (BIT(14)+BIT(12))	/* Cmp SCSI phs & Branch NOT EQ */
662 
663 #define  ADATA_OUT   0x00
664 #define  ADATA_IN    BIT(8)
665 #define  ACOMMAND    BIT(10)
666 #define  ASTATUS     (BIT(10)+BIT(8))
667 #define  AMSG_OUT    (BIT(10)+BIT(9))
668 #define  AMSG_IN     (BIT(10)+BIT(9)+BIT(8))
669 
670 #define  BRH_OP   BIT(13)	/* Branch */
671 
672 #define  ALWAYS   0x00
673 #define  EQUAL    BIT(8)
674 #define  NOT_EQ   BIT(9)
675 
676 #define  TCB_OP   (BIT(13)+BIT(11))	/* Test condition & branch */
677 
678 #define  FIFO_0      BIT(10)
679 
680 #define  MPM_OP   BIT(15)	/* Match phase and move data */
681 
682 #define  MRR_OP   BIT(14)	/* Move DReg. to Reg. */
683 
684 #define  S_IDREG  (BIT(2)+BIT(1)+BIT(0))
685 
686 #define  D_AR0    0x00
687 #define  D_AR1    BIT(0)
688 #define  D_BUCKET (BIT(2) + BIT(1) + BIT(0))
689 
690 #define  RAT_OP      (BIT(14)+BIT(13)+BIT(11))
691 
692 #define  SSI_OP      (BIT(15)+BIT(11))
693 
694 #define  SSI_ITAR_DISC	(ITAR_DISC >> 8)
695 #define  SSI_IDO_STRT	(IDO_STRT >> 8)
696 
697 #define  SSI_ICMD_COMP	(ICMD_COMP >> 8)
698 #define  SSI_ITICKLE	(ITICKLE >> 8)
699 
700 #define  SSI_IUNKWN	(IUNKWN >> 8)
701 #define  SSI_INO_CC	(IUNKWN >> 8)
702 #define  SSI_IRFAIL	(IUNKWN >> 8)
703 
704 #define  NP    0x10		/*Next Phase */
705 #define  NTCMD 0x02		/*Non- Tagged Command start */
706 #define  CMDPZ 0x04		/*Command phase */
707 #define  DINT  0x12		/*Data Out/In interrupt */
708 #define  DI    0x13		/*Data Out */
709 #define  DC    0x19		/*Disconnect Message */
710 #define  ST    0x1D		/*Status Phase */
711 #define  UNKNWN 0x24		/*Unknown bus action */
712 #define  CC    0x25		/*Command Completion failure */
713 #define  TICK  0x26		/*New target reselected us. */
714 #define  SELCHK 0x28		/*Select & Check SCSI ID latch reg */
715 
716 #define  ID_MSG_STRT    hp_aramBase + 0x00
717 #define  NON_TAG_ID_MSG hp_aramBase + 0x06
718 #define  CMD_STRT       hp_aramBase + 0x08
719 #define  SYNC_MSGS      hp_aramBase + 0x08
720 
721 #define  TAG_STRT          0x00
722 #define  DISCONNECT_START  0x10/2
723 #define  END_DATA_START    0x14/2
724 #define  CMD_ONLY_STRT     CMDPZ/2
725 #define  SELCHK_STRT     SELCHK/2
726 
727 #define GET_XFER_CNT(port, xfercnt) {RD_HARP32(port,hp_xfercnt_0,xfercnt); xfercnt &= 0xFFFFFF;}
728 /* #define GET_XFER_CNT(port, xfercnt) (xfercnt = RD_HARPOON(port+hp_xfercnt_2), \
729                                  xfercnt <<= 16,\
730                                  xfercnt |= RDW_HARPOON((unsigned short)(port+hp_xfercnt_0)))
731  */
732 #define HP_SETUP_ADDR_CNT(port,addr,count) (WRW_HARPOON((port+hp_host_addr_lo), (unsigned short)(addr & 0x0000FFFFL)),\
733          addr >>= 16,\
734          WRW_HARPOON((port+hp_host_addr_hmi), (unsigned short)(addr & 0x0000FFFFL)),\
735          WR_HARP32(port,hp_xfercnt_0,count),\
736          WRW_HARPOON((port+hp_xfer_cnt_lo), (unsigned short)(count & 0x0000FFFFL)),\
737          count >>= 16,\
738          WR_HARPOON(port+hp_xfer_cnt_hi, (count & 0xFF)))
739 
740 #define ACCEPT_MSG(port) {while(RD_HARPOON(port+hp_scsisig) & SCSI_REQ){}\
741                           WR_HARPOON(port+hp_scsisig, S_ILL_PH);}
742 
743 #define ACCEPT_MSG_ATN(port) {while(RD_HARPOON(port+hp_scsisig) & SCSI_REQ){}\
744                           WR_HARPOON(port+hp_scsisig, (S_ILL_PH|SCSI_ATN));}
745 
746 #define DISABLE_AUTO(port) (WR_HARPOON(port+hp_scsireset, PROG_RESET),\
747                         WR_HARPOON(port+hp_scsireset, 0x00))
748 
749 #define ARAM_ACCESS(p_port) (WR_HARPOON(p_port+hp_page_ctrl, \
750                              (RD_HARPOON(p_port+hp_page_ctrl) | SGRAM_ARAM)))
751 
752 #define SGRAM_ACCESS(p_port) (WR_HARPOON(p_port+hp_page_ctrl, \
753                              (RD_HARPOON(p_port+hp_page_ctrl) & ~SGRAM_ARAM)))
754 
755 #define MDISABLE_INT(p_port) (WR_HARPOON(p_port+hp_page_ctrl, \
756                              (RD_HARPOON(p_port+hp_page_ctrl) | G_INT_DISABLE)))
757 
758 #define MENABLE_INT(p_port) (WR_HARPOON(p_port+hp_page_ctrl, \
759                              (RD_HARPOON(p_port+hp_page_ctrl) & ~G_INT_DISABLE)))
760 
761 static unsigned char FPT_sisyncn(u32 port, unsigned char p_card,
762 				 unsigned char syncFlag);
763 static void FPT_ssel(u32 port, unsigned char p_card);
764 static void FPT_sres(u32 port, unsigned char p_card,
765 		     struct sccb_card *pCurrCard);
766 static void FPT_shandem(u32 port, unsigned char p_card,
767 			struct sccb *pCurrSCCB);
768 static void FPT_stsyncn(u32 port, unsigned char p_card);
769 static void FPT_sisyncr(u32 port, unsigned char sync_pulse,
770 			unsigned char offset);
771 static void FPT_sssyncv(u32 p_port, unsigned char p_id,
772 			unsigned char p_sync_value,
773 			struct sccb_mgr_tar_info *currTar_Info);
774 static void FPT_sresb(u32 port, unsigned char p_card);
775 static void FPT_sxfrp(u32 p_port, unsigned char p_card);
776 static void FPT_schkdd(u32 port, unsigned char p_card);
777 static unsigned char FPT_RdStack(u32 port, unsigned char index);
778 static void FPT_WrStack(u32 portBase, unsigned char index,
779 			unsigned char data);
780 static unsigned char FPT_ChkIfChipInitialized(u32 ioPort);
781 
782 static void FPT_SendMsg(u32 port, unsigned char message);
783 static void FPT_queueFlushTargSccb(unsigned char p_card, unsigned char thisTarg,
784 				   unsigned char error_code);
785 
786 static void FPT_sinits(struct sccb *p_sccb, unsigned char p_card);
787 static void FPT_RNVRamData(struct nvram_info *pNvRamInfo);
788 
789 static unsigned char FPT_siwidn(u32 port, unsigned char p_card);
790 static void FPT_stwidn(u32 port, unsigned char p_card);
791 static void FPT_siwidr(u32 port, unsigned char width);
792 
793 static void FPT_queueSelectFail(struct sccb_card *pCurrCard,
794 				unsigned char p_card);
795 static void FPT_queueDisconnect(struct sccb *p_SCCB, unsigned char p_card);
796 static void FPT_queueCmdComplete(struct sccb_card *pCurrCard,
797 				 struct sccb *p_SCCB, unsigned char p_card);
798 static void FPT_queueSearchSelect(struct sccb_card *pCurrCard,
799 				  unsigned char p_card);
800 static void FPT_queueFlushSccb(unsigned char p_card, unsigned char error_code);
801 static void FPT_queueAddSccb(struct sccb *p_SCCB, unsigned char card);
802 static unsigned char FPT_queueFindSccb(struct sccb *p_SCCB,
803 				       unsigned char p_card);
804 static void FPT_utilUpdateResidual(struct sccb *p_SCCB);
805 static unsigned short FPT_CalcCrc16(unsigned char buffer[]);
806 static unsigned char FPT_CalcLrc(unsigned char buffer[]);
807 
808 static void FPT_Wait1Second(u32 p_port);
809 static void FPT_Wait(u32 p_port, unsigned char p_delay);
810 static void FPT_utilEEWriteOnOff(u32 p_port, unsigned char p_mode);
811 static void FPT_utilEEWrite(u32 p_port, unsigned short ee_data,
812 			    unsigned short ee_addr);
813 static unsigned short FPT_utilEERead(u32 p_port,
814 				     unsigned short ee_addr);
815 static unsigned short FPT_utilEEReadOrg(u32 p_port,
816 					unsigned short ee_addr);
817 static void FPT_utilEESendCmdAddr(u32 p_port, unsigned char ee_cmd,
818 				  unsigned short ee_addr);
819 
820 static void FPT_phaseDataOut(u32 port, unsigned char p_card);
821 static void FPT_phaseDataIn(u32 port, unsigned char p_card);
822 static void FPT_phaseCommand(u32 port, unsigned char p_card);
823 static void FPT_phaseStatus(u32 port, unsigned char p_card);
824 static void FPT_phaseMsgOut(u32 port, unsigned char p_card);
825 static void FPT_phaseMsgIn(u32 port, unsigned char p_card);
826 static void FPT_phaseIllegal(u32 port, unsigned char p_card);
827 
828 static void FPT_phaseDecode(u32 port, unsigned char p_card);
829 static void FPT_phaseChkFifo(u32 port, unsigned char p_card);
830 static void FPT_phaseBusFree(u32 p_port, unsigned char p_card);
831 
832 static void FPT_XbowInit(u32 port, unsigned char scamFlg);
833 static void FPT_BusMasterInit(u32 p_port);
834 static void FPT_DiagEEPROM(u32 p_port);
835 
836 static void FPT_dataXferProcessor(u32 port,
837 				  struct sccb_card *pCurrCard);
838 static void FPT_busMstrSGDataXferStart(u32 port,
839 				       struct sccb *pCurrSCCB);
840 static void FPT_busMstrDataXferStart(u32 port,
841 				     struct sccb *pCurrSCCB);
842 static void FPT_hostDataXferAbort(u32 port, unsigned char p_card,
843 				  struct sccb *pCurrSCCB);
844 static void FPT_hostDataXferRestart(struct sccb *currSCCB);
845 
846 static unsigned char FPT_SccbMgr_bad_isr(u32 p_port,
847 					 unsigned char p_card,
848 					 struct sccb_card *pCurrCard,
849 					 unsigned short p_int);
850 
851 static void FPT_SccbMgrTableInitAll(void);
852 static void FPT_SccbMgrTableInitCard(struct sccb_card *pCurrCard,
853 				     unsigned char p_card);
854 static void FPT_SccbMgrTableInitTarget(unsigned char p_card,
855 				       unsigned char target);
856 
857 static void FPT_scini(unsigned char p_card, unsigned char p_our_id,
858 		      unsigned char p_power_up);
859 
860 static int FPT_scarb(u32 p_port, unsigned char p_sel_type);
861 static void FPT_scbusf(u32 p_port);
862 static void FPT_scsel(u32 p_port);
863 static void FPT_scasid(unsigned char p_card, u32 p_port);
864 static unsigned char FPT_scxferc(u32 p_port, unsigned char p_data);
865 static unsigned char FPT_scsendi(u32 p_port,
866 				 unsigned char p_id_string[]);
867 static unsigned char FPT_sciso(u32 p_port,
868 			       unsigned char p_id_string[]);
869 static void FPT_scwirod(u32 p_port, unsigned char p_data_bit);
870 static void FPT_scwiros(u32 p_port, unsigned char p_data_bit);
871 static unsigned char FPT_scvalq(unsigned char p_quintet);
872 static unsigned char FPT_scsell(u32 p_port, unsigned char targ_id);
873 static void FPT_scwtsel(u32 p_port);
874 static void FPT_inisci(unsigned char p_card, u32 p_port,
875 		       unsigned char p_our_id);
876 static void FPT_scsavdi(unsigned char p_card, u32 p_port);
877 static unsigned char FPT_scmachid(unsigned char p_card,
878 				  unsigned char p_id_string[]);
879 
880 static void FPT_autoCmdCmplt(u32 p_port, unsigned char p_card);
881 static void FPT_autoLoadDefaultMap(u32 p_port);
882 
883 static struct sccb_mgr_tar_info FPT_sccbMgrTbl[MAX_CARDS][MAX_SCSI_TAR] =
884     { {{0}} };
885 static struct sccb_card FPT_BL_Card[MAX_CARDS] = { {0} };
886 static SCCBSCAM_INFO FPT_scamInfo[MAX_SCSI_TAR] = { {{0}} };
887 static struct nvram_info FPT_nvRamInfo[MAX_MB_CARDS] = { {0} };
888 
889 static unsigned char FPT_mbCards = 0;
890 static unsigned char FPT_scamHAString[] =
891     { 0x63, 0x07, 'B', 'U', 'S', 'L', 'O', 'G', 'I', 'C',
892 	' ', 'B', 'T', '-', '9', '3', '0',
893 	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
894 	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
895 };
896 
897 static unsigned short FPT_default_intena = 0;
898 
899 static void (*FPT_s_PhaseTbl[8]) (u32, unsigned char) = {
900 0};
901 
902 /*---------------------------------------------------------------------
903  *
904  * Function: FlashPoint_ProbeHostAdapter
905  *
906  * Description: Setup and/or Search for cards and return info to caller.
907  *
908  *---------------------------------------------------------------------*/
909 
FlashPoint_ProbeHostAdapter(struct sccb_mgr_info * pCardInfo)910 static int FlashPoint_ProbeHostAdapter(struct sccb_mgr_info *pCardInfo)
911 {
912 	static unsigned char first_time = 1;
913 
914 	unsigned char i, j, id, ScamFlg;
915 	unsigned short temp, temp2, temp3, temp4, temp5, temp6;
916 	u32 ioport;
917 	struct nvram_info *pCurrNvRam;
918 
919 	ioport = pCardInfo->si_baseaddr;
920 
921 	if (RD_HARPOON(ioport + hp_vendor_id_0) != ORION_VEND_0)
922 		return (int)FAILURE;
923 
924 	if ((RD_HARPOON(ioport + hp_vendor_id_1) != ORION_VEND_1))
925 		return (int)FAILURE;
926 
927 	if ((RD_HARPOON(ioport + hp_device_id_0) != ORION_DEV_0))
928 		return (int)FAILURE;
929 
930 	if ((RD_HARPOON(ioport + hp_device_id_1) != ORION_DEV_1))
931 		return (int)FAILURE;
932 
933 	if (RD_HARPOON(ioport + hp_rev_num) != 0x0f) {
934 
935 /* For new Harpoon then check for sub_device ID LSB
936    the bits(0-3) must be all ZERO for compatible with
937    current version of SCCBMgr, else skip this Harpoon
938 	device. */
939 
940 		if (RD_HARPOON(ioport + hp_sub_device_id_0) & 0x0f)
941 			return (int)FAILURE;
942 	}
943 
944 	if (first_time) {
945 		FPT_SccbMgrTableInitAll();
946 		first_time = 0;
947 		FPT_mbCards = 0;
948 	}
949 
950 	if (FPT_RdStack(ioport, 0) != 0x00) {
951 		if (FPT_ChkIfChipInitialized(ioport) == 0) {
952 			pCurrNvRam = NULL;
953 			WR_HARPOON(ioport + hp_semaphore, 0x00);
954 			FPT_XbowInit(ioport, 0);	/*Must Init the SCSI before attempting */
955 			FPT_DiagEEPROM(ioport);
956 		} else {
957 			if (FPT_mbCards < MAX_MB_CARDS) {
958 				pCurrNvRam = &FPT_nvRamInfo[FPT_mbCards];
959 				FPT_mbCards++;
960 				pCurrNvRam->niBaseAddr = ioport;
961 				FPT_RNVRamData(pCurrNvRam);
962 			} else
963 				return (int)FAILURE;
964 		}
965 	} else
966 		pCurrNvRam = NULL;
967 
968 	WR_HARPOON(ioport + hp_clkctrl_0, CLKCTRL_DEFAULT);
969 	WR_HARPOON(ioport + hp_sys_ctrl, 0x00);
970 
971 	if (pCurrNvRam)
972 		pCardInfo->si_id = pCurrNvRam->niAdapId;
973 	else
974 		pCardInfo->si_id =
975 		    (unsigned
976 		     char)(FPT_utilEERead(ioport,
977 					  (ADAPTER_SCSI_ID /
978 					   2)) & (unsigned char)0x0FF);
979 
980 	pCardInfo->si_lun = 0x00;
981 	pCardInfo->si_fw_revision = ORION_FW_REV;
982 	temp2 = 0x0000;
983 	temp3 = 0x0000;
984 	temp4 = 0x0000;
985 	temp5 = 0x0000;
986 	temp6 = 0x0000;
987 
988 	for (id = 0; id < (16 / 2); id++) {
989 
990 		if (pCurrNvRam) {
991 			temp = (unsigned short)pCurrNvRam->niSyncTbl[id];
992 			temp = ((temp & 0x03) + ((temp << 4) & 0xc0)) +
993 			    (((temp << 4) & 0x0300) + ((temp << 8) & 0xc000));
994 		} else
995 			temp =
996 			    FPT_utilEERead(ioport,
997 					   (unsigned short)((SYNC_RATE_TBL / 2)
998 							    + id));
999 
1000 		for (i = 0; i < 2; temp >>= 8, i++) {
1001 
1002 			temp2 >>= 1;
1003 			temp3 >>= 1;
1004 			temp4 >>= 1;
1005 			temp5 >>= 1;
1006 			temp6 >>= 1;
1007 			switch (temp & 0x3) {
1008 			case AUTO_RATE_20:	/* Synchronous, 20 mega-transfers/second */
1009 				temp6 |= 0x8000;
1010 				fallthrough;
1011 			case AUTO_RATE_10:	/* Synchronous, 10 mega-transfers/second */
1012 				temp5 |= 0x8000;
1013 				fallthrough;
1014 			case AUTO_RATE_05:	/* Synchronous, 5 mega-transfers/second */
1015 				temp2 |= 0x8000;
1016 				fallthrough;
1017 			case AUTO_RATE_00:	/* Asynchronous */
1018 				break;
1019 			}
1020 
1021 			if (temp & DISC_ENABLE_BIT)
1022 				temp3 |= 0x8000;
1023 
1024 			if (temp & WIDE_NEGO_BIT)
1025 				temp4 |= 0x8000;
1026 
1027 		}
1028 	}
1029 
1030 	pCardInfo->si_per_targ_init_sync = temp2;
1031 	pCardInfo->si_per_targ_no_disc = temp3;
1032 	pCardInfo->si_per_targ_wide_nego = temp4;
1033 	pCardInfo->si_per_targ_fast_nego = temp5;
1034 	pCardInfo->si_per_targ_ultra_nego = temp6;
1035 
1036 	if (pCurrNvRam)
1037 		i = pCurrNvRam->niSysConf;
1038 	else
1039 		i = (unsigned
1040 		     char)(FPT_utilEERead(ioport, (SYSTEM_CONFIG / 2)));
1041 
1042 	if (pCurrNvRam)
1043 		ScamFlg = pCurrNvRam->niScamConf;
1044 	else
1045 		ScamFlg =
1046 		    (unsigned char)FPT_utilEERead(ioport, SCAM_CONFIG / 2);
1047 
1048 	pCardInfo->si_mflags = 0x0000;
1049 
1050 	if (i & 0x01)
1051 		pCardInfo->si_mflags |= SCSI_PARITY_ENA;
1052 
1053 	if (!(i & 0x02))
1054 		pCardInfo->si_mflags |= SOFT_RESET;
1055 
1056 	if (i & 0x10)
1057 		pCardInfo->si_mflags |= EXTENDED_TRANSLATION;
1058 
1059 	if (ScamFlg & SCAM_ENABLED)
1060 		pCardInfo->si_mflags |= FLAG_SCAM_ENABLED;
1061 
1062 	if (ScamFlg & SCAM_LEVEL2)
1063 		pCardInfo->si_mflags |= FLAG_SCAM_LEVEL2;
1064 
1065 	j = (RD_HARPOON(ioport + hp_bm_ctrl) & ~SCSI_TERM_ENA_L);
1066 	if (i & 0x04) {
1067 		j |= SCSI_TERM_ENA_L;
1068 	}
1069 	WR_HARPOON(ioport + hp_bm_ctrl, j);
1070 
1071 	j = (RD_HARPOON(ioport + hp_ee_ctrl) & ~SCSI_TERM_ENA_H);
1072 	if (i & 0x08) {
1073 		j |= SCSI_TERM_ENA_H;
1074 	}
1075 	WR_HARPOON(ioport + hp_ee_ctrl, j);
1076 
1077 	if (!(RD_HARPOON(ioport + hp_page_ctrl) & NARROW_SCSI_CARD))
1078 
1079 		pCardInfo->si_mflags |= SUPPORT_16TAR_32LUN;
1080 
1081 	pCardInfo->si_card_family = HARPOON_FAMILY;
1082 	pCardInfo->si_bustype = BUSTYPE_PCI;
1083 
1084 	if (pCurrNvRam) {
1085 		pCardInfo->si_card_model[0] = '9';
1086 		switch (pCurrNvRam->niModel & 0x0f) {
1087 		case MODEL_LT:
1088 			pCardInfo->si_card_model[1] = '3';
1089 			pCardInfo->si_card_model[2] = '0';
1090 			break;
1091 		case MODEL_LW:
1092 			pCardInfo->si_card_model[1] = '5';
1093 			pCardInfo->si_card_model[2] = '0';
1094 			break;
1095 		case MODEL_DL:
1096 			pCardInfo->si_card_model[1] = '3';
1097 			pCardInfo->si_card_model[2] = '2';
1098 			break;
1099 		case MODEL_DW:
1100 			pCardInfo->si_card_model[1] = '5';
1101 			pCardInfo->si_card_model[2] = '2';
1102 			break;
1103 		}
1104 	} else {
1105 		temp = FPT_utilEERead(ioport, (MODEL_NUMB_0 / 2));
1106 		pCardInfo->si_card_model[0] = (unsigned char)(temp >> 8);
1107 		temp = FPT_utilEERead(ioport, (MODEL_NUMB_2 / 2));
1108 
1109 		pCardInfo->si_card_model[1] = (unsigned char)(temp & 0x00FF);
1110 		pCardInfo->si_card_model[2] = (unsigned char)(temp >> 8);
1111 	}
1112 
1113 	if (pCardInfo->si_card_model[1] == '3') {
1114 		if (RD_HARPOON(ioport + hp_ee_ctrl) & BIT(7))
1115 			pCardInfo->si_mflags |= LOW_BYTE_TERM;
1116 	} else if (pCardInfo->si_card_model[2] == '0') {
1117 		temp = RD_HARPOON(ioport + hp_xfer_pad);
1118 		WR_HARPOON(ioport + hp_xfer_pad, (temp & ~BIT(4)));
1119 		if (RD_HARPOON(ioport + hp_ee_ctrl) & BIT(7))
1120 			pCardInfo->si_mflags |= LOW_BYTE_TERM;
1121 		WR_HARPOON(ioport + hp_xfer_pad, (temp | BIT(4)));
1122 		if (RD_HARPOON(ioport + hp_ee_ctrl) & BIT(7))
1123 			pCardInfo->si_mflags |= HIGH_BYTE_TERM;
1124 		WR_HARPOON(ioport + hp_xfer_pad, temp);
1125 	} else {
1126 		temp = RD_HARPOON(ioport + hp_ee_ctrl);
1127 		temp2 = RD_HARPOON(ioport + hp_xfer_pad);
1128 		WR_HARPOON(ioport + hp_ee_ctrl, (temp | SEE_CS));
1129 		WR_HARPOON(ioport + hp_xfer_pad, (temp2 | BIT(4)));
1130 		temp3 = 0;
1131 		for (i = 0; i < 8; i++) {
1132 			temp3 <<= 1;
1133 			if (!(RD_HARPOON(ioport + hp_ee_ctrl) & BIT(7)))
1134 				temp3 |= 1;
1135 			WR_HARPOON(ioport + hp_xfer_pad, (temp2 & ~BIT(4)));
1136 			WR_HARPOON(ioport + hp_xfer_pad, (temp2 | BIT(4)));
1137 		}
1138 		WR_HARPOON(ioport + hp_ee_ctrl, temp);
1139 		WR_HARPOON(ioport + hp_xfer_pad, temp2);
1140 		if (!(temp3 & BIT(7)))
1141 			pCardInfo->si_mflags |= LOW_BYTE_TERM;
1142 		if (!(temp3 & BIT(6)))
1143 			pCardInfo->si_mflags |= HIGH_BYTE_TERM;
1144 	}
1145 
1146 	ARAM_ACCESS(ioport);
1147 
1148 	for (i = 0; i < 4; i++) {
1149 
1150 		pCardInfo->si_XlatInfo[i] =
1151 		    RD_HARPOON(ioport + hp_aramBase + BIOS_DATA_OFFSET + i);
1152 	}
1153 
1154 	/* return with -1 if no sort, else return with
1155 	   logical card number sorted by BIOS (zero-based) */
1156 
1157 	pCardInfo->si_relative_cardnum =
1158 	    (unsigned
1159 	     char)(RD_HARPOON(ioport + hp_aramBase + BIOS_RELATIVE_CARD) - 1);
1160 
1161 	SGRAM_ACCESS(ioport);
1162 
1163 	FPT_s_PhaseTbl[0] = FPT_phaseDataOut;
1164 	FPT_s_PhaseTbl[1] = FPT_phaseDataIn;
1165 	FPT_s_PhaseTbl[2] = FPT_phaseIllegal;
1166 	FPT_s_PhaseTbl[3] = FPT_phaseIllegal;
1167 	FPT_s_PhaseTbl[4] = FPT_phaseCommand;
1168 	FPT_s_PhaseTbl[5] = FPT_phaseStatus;
1169 	FPT_s_PhaseTbl[6] = FPT_phaseMsgOut;
1170 	FPT_s_PhaseTbl[7] = FPT_phaseMsgIn;
1171 
1172 	pCardInfo->si_present = 0x01;
1173 
1174 	return 0;
1175 }
1176 
1177 /*---------------------------------------------------------------------
1178  *
1179  * Function: FlashPoint_HardwareResetHostAdapter
1180  *
1181  * Description: Setup adapter for normal operation (hard reset).
1182  *
1183  *---------------------------------------------------------------------*/
1184 
FlashPoint_HardwareResetHostAdapter(struct sccb_mgr_info * pCardInfo)1185 static void *FlashPoint_HardwareResetHostAdapter(struct sccb_mgr_info
1186 							 *pCardInfo)
1187 {
1188 	struct sccb_card *CurrCard = NULL;
1189 	struct nvram_info *pCurrNvRam;
1190 	unsigned char i, j, thisCard, ScamFlg;
1191 	unsigned short temp, sync_bit_map, id;
1192 	u32 ioport;
1193 
1194 	ioport = pCardInfo->si_baseaddr;
1195 
1196 	for (thisCard = 0; thisCard <= MAX_CARDS; thisCard++) {
1197 
1198 		if (thisCard == MAX_CARDS)
1199 			return (void *)FAILURE;
1200 
1201 		if (FPT_BL_Card[thisCard].ioPort == ioport) {
1202 
1203 			CurrCard = &FPT_BL_Card[thisCard];
1204 			FPT_SccbMgrTableInitCard(CurrCard, thisCard);
1205 			break;
1206 		}
1207 
1208 		else if (FPT_BL_Card[thisCard].ioPort == 0x00) {
1209 
1210 			FPT_BL_Card[thisCard].ioPort = ioport;
1211 			CurrCard = &FPT_BL_Card[thisCard];
1212 
1213 			if (FPT_mbCards)
1214 				for (i = 0; i < FPT_mbCards; i++) {
1215 					if (CurrCard->ioPort ==
1216 					    FPT_nvRamInfo[i].niBaseAddr)
1217 						CurrCard->pNvRamInfo =
1218 						    &FPT_nvRamInfo[i];
1219 				}
1220 			FPT_SccbMgrTableInitCard(CurrCard, thisCard);
1221 			CurrCard->cardIndex = thisCard;
1222 			CurrCard->cardInfo = pCardInfo;
1223 
1224 			break;
1225 		}
1226 	}
1227 
1228 	pCurrNvRam = CurrCard->pNvRamInfo;
1229 
1230 	if (pCurrNvRam) {
1231 		ScamFlg = pCurrNvRam->niScamConf;
1232 	} else {
1233 		ScamFlg =
1234 		    (unsigned char)FPT_utilEERead(ioport, SCAM_CONFIG / 2);
1235 	}
1236 
1237 	FPT_BusMasterInit(ioport);
1238 	FPT_XbowInit(ioport, ScamFlg);
1239 
1240 	FPT_autoLoadDefaultMap(ioport);
1241 
1242 	for (i = 0, id = 0x01; i != pCardInfo->si_id; i++, id <<= 1) {
1243 	}
1244 
1245 	WR_HARPOON(ioport + hp_selfid_0, id);
1246 	WR_HARPOON(ioport + hp_selfid_1, 0x00);
1247 	WR_HARPOON(ioport + hp_arb_id, pCardInfo->si_id);
1248 	CurrCard->ourId = pCardInfo->si_id;
1249 
1250 	i = (unsigned char)pCardInfo->si_mflags;
1251 	if (i & SCSI_PARITY_ENA)
1252 		WR_HARPOON(ioport + hp_portctrl_1, (HOST_MODE8 | CHK_SCSI_P));
1253 
1254 	j = (RD_HARPOON(ioport + hp_bm_ctrl) & ~SCSI_TERM_ENA_L);
1255 	if (i & LOW_BYTE_TERM)
1256 		j |= SCSI_TERM_ENA_L;
1257 	WR_HARPOON(ioport + hp_bm_ctrl, j);
1258 
1259 	j = (RD_HARPOON(ioport + hp_ee_ctrl) & ~SCSI_TERM_ENA_H);
1260 	if (i & HIGH_BYTE_TERM)
1261 		j |= SCSI_TERM_ENA_H;
1262 	WR_HARPOON(ioport + hp_ee_ctrl, j);
1263 
1264 	if (!(pCardInfo->si_mflags & SOFT_RESET)) {
1265 
1266 		FPT_sresb(ioport, thisCard);
1267 
1268 		FPT_scini(thisCard, pCardInfo->si_id, 0);
1269 	}
1270 
1271 	if (pCardInfo->si_mflags & POST_ALL_UNDERRRUNS)
1272 		CurrCard->globalFlags |= F_NO_FILTER;
1273 
1274 	if (pCurrNvRam) {
1275 		if (pCurrNvRam->niSysConf & 0x10)
1276 			CurrCard->globalFlags |= F_GREEN_PC;
1277 	} else {
1278 		if (FPT_utilEERead(ioport, (SYSTEM_CONFIG / 2)) & GREEN_PC_ENA)
1279 			CurrCard->globalFlags |= F_GREEN_PC;
1280 	}
1281 
1282 	/* Set global flag to indicate Re-Negotiation to be done on all
1283 	   ckeck condition */
1284 	if (pCurrNvRam) {
1285 		if (pCurrNvRam->niScsiConf & 0x04)
1286 			CurrCard->globalFlags |= F_DO_RENEGO;
1287 	} else {
1288 		if (FPT_utilEERead(ioport, (SCSI_CONFIG / 2)) & RENEGO_ENA)
1289 			CurrCard->globalFlags |= F_DO_RENEGO;
1290 	}
1291 
1292 	if (pCurrNvRam) {
1293 		if (pCurrNvRam->niScsiConf & 0x08)
1294 			CurrCard->globalFlags |= F_CONLUN_IO;
1295 	} else {
1296 		if (FPT_utilEERead(ioport, (SCSI_CONFIG / 2)) & CONNIO_ENA)
1297 			CurrCard->globalFlags |= F_CONLUN_IO;
1298 	}
1299 
1300 	temp = pCardInfo->si_per_targ_no_disc;
1301 
1302 	for (i = 0, id = 1; i < MAX_SCSI_TAR; i++, id <<= 1) {
1303 
1304 		if (temp & id)
1305 			FPT_sccbMgrTbl[thisCard][i].TarStatus |= TAR_ALLOW_DISC;
1306 	}
1307 
1308 	sync_bit_map = 0x0001;
1309 
1310 	for (id = 0; id < (MAX_SCSI_TAR / 2); id++) {
1311 
1312 		if (pCurrNvRam) {
1313 			temp = (unsigned short)pCurrNvRam->niSyncTbl[id];
1314 			temp = ((temp & 0x03) + ((temp << 4) & 0xc0)) +
1315 			    (((temp << 4) & 0x0300) + ((temp << 8) & 0xc000));
1316 		} else
1317 			temp =
1318 			    FPT_utilEERead(ioport,
1319 					   (unsigned short)((SYNC_RATE_TBL / 2)
1320 							    + id));
1321 
1322 		for (i = 0; i < 2; temp >>= 8, i++) {
1323 
1324 			if (pCardInfo->si_per_targ_init_sync & sync_bit_map) {
1325 
1326 				FPT_sccbMgrTbl[thisCard][id * 2 +
1327 							 i].TarEEValue =
1328 				    (unsigned char)temp;
1329 			}
1330 
1331 			else {
1332 				FPT_sccbMgrTbl[thisCard][id * 2 +
1333 							 i].TarStatus |=
1334 				    SYNC_SUPPORTED;
1335 				FPT_sccbMgrTbl[thisCard][id * 2 +
1336 							 i].TarEEValue =
1337 				    (unsigned char)(temp & ~EE_SYNC_MASK);
1338 			}
1339 
1340 /*         if ((pCardInfo->si_per_targ_wide_nego & sync_bit_map) ||
1341             (id*2+i >= 8)){
1342 */
1343 			if (pCardInfo->si_per_targ_wide_nego & sync_bit_map) {
1344 
1345 				FPT_sccbMgrTbl[thisCard][id * 2 +
1346 							 i].TarEEValue |=
1347 				    EE_WIDE_SCSI;
1348 
1349 			}
1350 
1351 			else {	/* NARROW SCSI */
1352 				FPT_sccbMgrTbl[thisCard][id * 2 +
1353 							 i].TarStatus |=
1354 				    WIDE_NEGOCIATED;
1355 			}
1356 
1357 			sync_bit_map <<= 1;
1358 
1359 		}
1360 	}
1361 
1362 	WR_HARPOON((ioport + hp_semaphore),
1363 		   (unsigned char)(RD_HARPOON((ioport + hp_semaphore)) |
1364 				   SCCB_MGR_PRESENT));
1365 
1366 	return (void *)CurrCard;
1367 }
1368 
FlashPoint_ReleaseHostAdapter(void * pCurrCard)1369 static void FlashPoint_ReleaseHostAdapter(void *pCurrCard)
1370 {
1371 	unsigned char i;
1372 	u32 portBase;
1373 	u32 regOffset;
1374 	u32 scamData;
1375 	u32 *pScamTbl;
1376 	struct nvram_info *pCurrNvRam;
1377 
1378 	pCurrNvRam = ((struct sccb_card *)pCurrCard)->pNvRamInfo;
1379 
1380 	if (pCurrNvRam) {
1381 		FPT_WrStack(pCurrNvRam->niBaseAddr, 0, pCurrNvRam->niModel);
1382 		FPT_WrStack(pCurrNvRam->niBaseAddr, 1, pCurrNvRam->niSysConf);
1383 		FPT_WrStack(pCurrNvRam->niBaseAddr, 2, pCurrNvRam->niScsiConf);
1384 		FPT_WrStack(pCurrNvRam->niBaseAddr, 3, pCurrNvRam->niScamConf);
1385 		FPT_WrStack(pCurrNvRam->niBaseAddr, 4, pCurrNvRam->niAdapId);
1386 
1387 		for (i = 0; i < MAX_SCSI_TAR / 2; i++)
1388 			FPT_WrStack(pCurrNvRam->niBaseAddr,
1389 				    (unsigned char)(i + 5),
1390 				    pCurrNvRam->niSyncTbl[i]);
1391 
1392 		portBase = pCurrNvRam->niBaseAddr;
1393 
1394 		for (i = 0; i < MAX_SCSI_TAR; i++) {
1395 			regOffset = hp_aramBase + 64 + i * 4;
1396 			pScamTbl = (u32 *)&pCurrNvRam->niScamTbl[i];
1397 			scamData = *pScamTbl;
1398 			WR_HARP32(portBase, regOffset, scamData);
1399 		}
1400 
1401 	} else {
1402 		FPT_WrStack(((struct sccb_card *)pCurrCard)->ioPort, 0, 0);
1403 	}
1404 }
1405 
FPT_RNVRamData(struct nvram_info * pNvRamInfo)1406 static void FPT_RNVRamData(struct nvram_info *pNvRamInfo)
1407 {
1408 	unsigned char i;
1409 	u32 portBase;
1410 	u32 regOffset;
1411 	u32 scamData;
1412 	u32 *pScamTbl;
1413 
1414 	pNvRamInfo->niModel = FPT_RdStack(pNvRamInfo->niBaseAddr, 0);
1415 	pNvRamInfo->niSysConf = FPT_RdStack(pNvRamInfo->niBaseAddr, 1);
1416 	pNvRamInfo->niScsiConf = FPT_RdStack(pNvRamInfo->niBaseAddr, 2);
1417 	pNvRamInfo->niScamConf = FPT_RdStack(pNvRamInfo->niBaseAddr, 3);
1418 	pNvRamInfo->niAdapId = FPT_RdStack(pNvRamInfo->niBaseAddr, 4);
1419 
1420 	for (i = 0; i < MAX_SCSI_TAR / 2; i++)
1421 		pNvRamInfo->niSyncTbl[i] =
1422 		    FPT_RdStack(pNvRamInfo->niBaseAddr, (unsigned char)(i + 5));
1423 
1424 	portBase = pNvRamInfo->niBaseAddr;
1425 
1426 	for (i = 0; i < MAX_SCSI_TAR; i++) {
1427 		regOffset = hp_aramBase + 64 + i * 4;
1428 		RD_HARP32(portBase, regOffset, scamData);
1429 		pScamTbl = (u32 *)&pNvRamInfo->niScamTbl[i];
1430 		*pScamTbl = scamData;
1431 	}
1432 
1433 }
1434 
FPT_RdStack(u32 portBase,unsigned char index)1435 static unsigned char FPT_RdStack(u32 portBase, unsigned char index)
1436 {
1437 	WR_HARPOON(portBase + hp_stack_addr, index);
1438 	return RD_HARPOON(portBase + hp_stack_data);
1439 }
1440 
FPT_WrStack(u32 portBase,unsigned char index,unsigned char data)1441 static void FPT_WrStack(u32 portBase, unsigned char index, unsigned char data)
1442 {
1443 	WR_HARPOON(portBase + hp_stack_addr, index);
1444 	WR_HARPOON(portBase + hp_stack_data, data);
1445 }
1446 
FPT_ChkIfChipInitialized(u32 ioPort)1447 static unsigned char FPT_ChkIfChipInitialized(u32 ioPort)
1448 {
1449 	if ((RD_HARPOON(ioPort + hp_arb_id) & 0x0f) != FPT_RdStack(ioPort, 4))
1450 		return 0;
1451 	if ((RD_HARPOON(ioPort + hp_clkctrl_0) & CLKCTRL_DEFAULT)
1452 	    != CLKCTRL_DEFAULT)
1453 		return 0;
1454 	if ((RD_HARPOON(ioPort + hp_seltimeout) == TO_250ms) ||
1455 	    (RD_HARPOON(ioPort + hp_seltimeout) == TO_290ms))
1456 		return 1;
1457 	return 0;
1458 
1459 }
1460 
1461 /*---------------------------------------------------------------------
1462  *
1463  * Function: FlashPoint_StartCCB
1464  *
1465  * Description: Start a command pointed to by p_Sccb. When the
1466  *              command is completed it will be returned via the
1467  *              callback function.
1468  *
1469  *---------------------------------------------------------------------*/
FlashPoint_StartCCB(void * curr_card,struct sccb * p_Sccb)1470 static void FlashPoint_StartCCB(void *curr_card, struct sccb *p_Sccb)
1471 {
1472 	u32 ioport;
1473 	unsigned char thisCard, lun;
1474 	struct sccb *pSaveSccb;
1475 	CALL_BK_FN callback;
1476 	struct sccb_card *pCurrCard = curr_card;
1477 
1478 	thisCard = pCurrCard->cardIndex;
1479 	ioport = pCurrCard->ioPort;
1480 
1481 	if ((p_Sccb->TargID >= MAX_SCSI_TAR) || (p_Sccb->Lun >= MAX_LUN)) {
1482 
1483 		p_Sccb->HostStatus = SCCB_COMPLETE;
1484 		p_Sccb->SccbStatus = SCCB_ERROR;
1485 		callback = (CALL_BK_FN) p_Sccb->SccbCallback;
1486 		if (callback)
1487 			callback(p_Sccb);
1488 
1489 		return;
1490 	}
1491 
1492 	FPT_sinits(p_Sccb, thisCard);
1493 
1494 	if (!pCurrCard->cmdCounter) {
1495 		WR_HARPOON(ioport + hp_semaphore,
1496 			   (RD_HARPOON(ioport + hp_semaphore)
1497 			    | SCCB_MGR_ACTIVE));
1498 
1499 		if (pCurrCard->globalFlags & F_GREEN_PC) {
1500 			WR_HARPOON(ioport + hp_clkctrl_0, CLKCTRL_DEFAULT);
1501 			WR_HARPOON(ioport + hp_sys_ctrl, 0x00);
1502 		}
1503 	}
1504 
1505 	pCurrCard->cmdCounter++;
1506 
1507 	if (RD_HARPOON(ioport + hp_semaphore) & BIOS_IN_USE) {
1508 
1509 		WR_HARPOON(ioport + hp_semaphore,
1510 			   (RD_HARPOON(ioport + hp_semaphore)
1511 			    | TICKLE_ME));
1512 		if (p_Sccb->OperationCode == RESET_COMMAND) {
1513 			pSaveSccb =
1514 			    pCurrCard->currentSCCB;
1515 			pCurrCard->currentSCCB = p_Sccb;
1516 			FPT_queueSelectFail(&FPT_BL_Card[thisCard], thisCard);
1517 			pCurrCard->currentSCCB =
1518 			    pSaveSccb;
1519 		} else {
1520 			FPT_queueAddSccb(p_Sccb, thisCard);
1521 		}
1522 	}
1523 
1524 	else if ((RD_HARPOON(ioport + hp_page_ctrl) & G_INT_DISABLE)) {
1525 
1526 		if (p_Sccb->OperationCode == RESET_COMMAND) {
1527 			pSaveSccb =
1528 			    pCurrCard->currentSCCB;
1529 			pCurrCard->currentSCCB = p_Sccb;
1530 			FPT_queueSelectFail(&FPT_BL_Card[thisCard], thisCard);
1531 			pCurrCard->currentSCCB =
1532 			    pSaveSccb;
1533 		} else {
1534 			FPT_queueAddSccb(p_Sccb, thisCard);
1535 		}
1536 	}
1537 
1538 	else {
1539 
1540 		MDISABLE_INT(ioport);
1541 
1542 		if ((pCurrCard->globalFlags & F_CONLUN_IO) &&
1543 		    ((FPT_sccbMgrTbl[thisCard][p_Sccb->TargID].
1544 		      TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
1545 			lun = p_Sccb->Lun;
1546 		else
1547 			lun = 0;
1548 		if ((pCurrCard->currentSCCB == NULL) &&
1549 		    (FPT_sccbMgrTbl[thisCard][p_Sccb->TargID].TarSelQ_Cnt == 0)
1550 		    && (FPT_sccbMgrTbl[thisCard][p_Sccb->TargID].TarLUNBusy[lun]
1551 			== 0)) {
1552 
1553 			pCurrCard->currentSCCB = p_Sccb;
1554 			FPT_ssel(p_Sccb->SccbIOPort, thisCard);
1555 		}
1556 
1557 		else {
1558 
1559 			if (p_Sccb->OperationCode == RESET_COMMAND) {
1560 				pSaveSccb = pCurrCard->currentSCCB;
1561 				pCurrCard->currentSCCB = p_Sccb;
1562 				FPT_queueSelectFail(&FPT_BL_Card[thisCard],
1563 						    thisCard);
1564 				pCurrCard->currentSCCB = pSaveSccb;
1565 			} else {
1566 				FPT_queueAddSccb(p_Sccb, thisCard);
1567 			}
1568 		}
1569 
1570 		MENABLE_INT(ioport);
1571 	}
1572 
1573 }
1574 
1575 /*---------------------------------------------------------------------
1576  *
1577  * Function: FlashPoint_AbortCCB
1578  *
1579  * Description: Abort the command pointed to by p_Sccb.  When the
1580  *              command is completed it will be returned via the
1581  *              callback function.
1582  *
1583  *---------------------------------------------------------------------*/
FlashPoint_AbortCCB(void * pCurrCard,struct sccb * p_Sccb)1584 static int FlashPoint_AbortCCB(void *pCurrCard, struct sccb *p_Sccb)
1585 {
1586 	u32 ioport;
1587 
1588 	unsigned char thisCard;
1589 	CALL_BK_FN callback;
1590 	struct sccb *pSaveSCCB;
1591 	struct sccb_mgr_tar_info *currTar_Info;
1592 
1593 	ioport = ((struct sccb_card *)pCurrCard)->ioPort;
1594 
1595 	thisCard = ((struct sccb_card *)pCurrCard)->cardIndex;
1596 
1597 	if (!(RD_HARPOON(ioport + hp_page_ctrl) & G_INT_DISABLE)) {
1598 
1599 		if (FPT_queueFindSccb(p_Sccb, thisCard)) {
1600 
1601 			((struct sccb_card *)pCurrCard)->cmdCounter--;
1602 
1603 			if (!((struct sccb_card *)pCurrCard)->cmdCounter)
1604 				WR_HARPOON(ioport + hp_semaphore,
1605 					   (RD_HARPOON(ioport + hp_semaphore)
1606 					    & (unsigned
1607 					       char)(~(SCCB_MGR_ACTIVE |
1608 						       TICKLE_ME))));
1609 
1610 			p_Sccb->SccbStatus = SCCB_ABORT;
1611 			callback = p_Sccb->SccbCallback;
1612 			callback(p_Sccb);
1613 
1614 			return 0;
1615 		}
1616 
1617 		else {
1618 			if (((struct sccb_card *)pCurrCard)->currentSCCB ==
1619 			    p_Sccb) {
1620 				p_Sccb->SccbStatus = SCCB_ABORT;
1621 				return 0;
1622 
1623 			}
1624 
1625 			else {
1626 				if (p_Sccb->Sccb_tag) {
1627 					MDISABLE_INT(ioport);
1628 					if (((struct sccb_card *)pCurrCard)->
1629 					    discQ_Tbl[p_Sccb->Sccb_tag] ==
1630 					    p_Sccb) {
1631 						p_Sccb->SccbStatus = SCCB_ABORT;
1632 						p_Sccb->Sccb_scsistat =
1633 						    ABORT_ST;
1634 						p_Sccb->Sccb_scsimsg =
1635 						    ABORT_TASK;
1636 
1637 						if (((struct sccb_card *)
1638 						     pCurrCard)->currentSCCB ==
1639 						    NULL) {
1640 							((struct sccb_card *)
1641 							 pCurrCard)->
1642 					currentSCCB = p_Sccb;
1643 							FPT_ssel(ioport,
1644 								 thisCard);
1645 						} else {
1646 							pSaveSCCB =
1647 							    ((struct sccb_card
1648 							      *)pCurrCard)->
1649 							    currentSCCB;
1650 							((struct sccb_card *)
1651 							 pCurrCard)->
1652 					currentSCCB = p_Sccb;
1653 							FPT_queueSelectFail((struct sccb_card *)pCurrCard, thisCard);
1654 							((struct sccb_card *)
1655 							 pCurrCard)->
1656 					currentSCCB = pSaveSCCB;
1657 						}
1658 					}
1659 					MENABLE_INT(ioport);
1660 					return 0;
1661 				} else {
1662 					currTar_Info =
1663 					    &FPT_sccbMgrTbl[thisCard][p_Sccb->
1664 								      TargID];
1665 
1666 					if (FPT_BL_Card[thisCard].
1667 					    discQ_Tbl[currTar_Info->
1668 						      LunDiscQ_Idx[p_Sccb->Lun]]
1669 					    == p_Sccb) {
1670 						p_Sccb->SccbStatus = SCCB_ABORT;
1671 						return 0;
1672 					}
1673 				}
1674 			}
1675 		}
1676 	}
1677 	return -1;
1678 }
1679 
1680 /*---------------------------------------------------------------------
1681  *
1682  * Function: FlashPoint_InterruptPending
1683  *
1684  * Description: Do a quick check to determine if there is a pending
1685  *              interrupt for this card and disable the IRQ Pin if so.
1686  *
1687  *---------------------------------------------------------------------*/
FlashPoint_InterruptPending(void * pCurrCard)1688 static unsigned char FlashPoint_InterruptPending(void *pCurrCard)
1689 {
1690 	u32 ioport;
1691 
1692 	ioport = ((struct sccb_card *)pCurrCard)->ioPort;
1693 
1694 	if (RD_HARPOON(ioport + hp_int_status) & INT_ASSERTED) {
1695 		return 1;
1696 	}
1697 
1698 	else
1699 
1700 		return 0;
1701 }
1702 
1703 /*---------------------------------------------------------------------
1704  *
1705  * Function: FlashPoint_HandleInterrupt
1706  *
1707  * Description: This is our entry point when an interrupt is generated
1708  *              by the card and the upper level driver passes it on to
1709  *              us.
1710  *
1711  *---------------------------------------------------------------------*/
FlashPoint_HandleInterrupt(void * pcard)1712 static int FlashPoint_HandleInterrupt(void *pcard)
1713 {
1714 	struct sccb *currSCCB;
1715 	unsigned char thisCard, result, bm_status;
1716 	unsigned short hp_int;
1717 	unsigned char i, target;
1718 	struct sccb_card *pCurrCard = pcard;
1719 	u32 ioport;
1720 
1721 	thisCard = pCurrCard->cardIndex;
1722 	ioport = pCurrCard->ioPort;
1723 
1724 	MDISABLE_INT(ioport);
1725 
1726 	if (RD_HARPOON(ioport + hp_int_status) & EXT_STATUS_ON)
1727 		bm_status = RD_HARPOON(ioport + hp_ext_status) &
1728 					(unsigned char)BAD_EXT_STATUS;
1729 	else
1730 		bm_status = 0;
1731 
1732 	WR_HARPOON(ioport + hp_int_mask, (INT_CMD_COMPL | SCSI_INTERRUPT));
1733 
1734 	while ((hp_int = RDW_HARPOON((ioport + hp_intstat)) &
1735 				FPT_default_intena) | bm_status) {
1736 
1737 		currSCCB = pCurrCard->currentSCCB;
1738 
1739 		if (hp_int & (FIFO | TIMEOUT | RESET | SCAM_SEL) || bm_status) {
1740 			result =
1741 			    FPT_SccbMgr_bad_isr(ioport, thisCard, pCurrCard,
1742 						hp_int);
1743 			WRW_HARPOON((ioport + hp_intstat),
1744 				    (FIFO | TIMEOUT | RESET | SCAM_SEL));
1745 			bm_status = 0;
1746 
1747 			if (result) {
1748 
1749 				MENABLE_INT(ioport);
1750 				return result;
1751 			}
1752 		}
1753 
1754 		else if (hp_int & ICMD_COMP) {
1755 
1756 			if (!(hp_int & BUS_FREE)) {
1757 				/* Wait for the BusFree before starting a new command.  We
1758 				   must also check for being reselected since the BusFree
1759 				   may not show up if another device reselects us in 1.5us or
1760 				   less.  SRR Wednesday, 3/8/1995.
1761 				 */
1762 				while (!
1763 				       (RDW_HARPOON((ioport + hp_intstat)) &
1764 					(BUS_FREE | RSEL))) ;
1765 			}
1766 
1767 			if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
1768 
1769 				FPT_phaseChkFifo(ioport, thisCard);
1770 
1771 /*         WRW_HARPOON((ioport+hp_intstat),
1772             (BUS_FREE | ICMD_COMP | ITAR_DISC | XFER_CNT_0));
1773          */
1774 
1775 			WRW_HARPOON((ioport + hp_intstat), CLR_ALL_INT_1);
1776 
1777 			FPT_autoCmdCmplt(ioport, thisCard);
1778 
1779 		}
1780 
1781 		else if (hp_int & ITAR_DISC) {
1782 
1783 			if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
1784 				FPT_phaseChkFifo(ioport, thisCard);
1785 
1786 			if (RD_HARPOON(ioport + hp_gp_reg_1) ==
1787 					SAVE_POINTERS) {
1788 
1789 				WR_HARPOON(ioport + hp_gp_reg_1, 0x00);
1790 				currSCCB->Sccb_XferState |= F_NO_DATA_YET;
1791 
1792 				currSCCB->Sccb_savedATC = currSCCB->Sccb_ATC;
1793 			}
1794 
1795 			currSCCB->Sccb_scsistat = DISCONNECT_ST;
1796 			FPT_queueDisconnect(currSCCB, thisCard);
1797 
1798 			/* Wait for the BusFree before starting a new command.  We
1799 			   must also check for being reselected since the BusFree
1800 			   may not show up if another device reselects us in 1.5us or
1801 			   less.  SRR Wednesday, 3/8/1995.
1802 			 */
1803 			while (!
1804 			       (RDW_HARPOON((ioport + hp_intstat)) &
1805 				(BUS_FREE | RSEL))
1806 			       && !((RDW_HARPOON((ioport + hp_intstat)) & PHASE)
1807 				    && RD_HARPOON((ioport + hp_scsisig)) ==
1808 				    (SCSI_BSY | SCSI_REQ | SCSI_CD | SCSI_MSG |
1809 				     SCSI_IOBIT))) ;
1810 
1811 			/*
1812 			   The additional loop exit condition above detects a timing problem
1813 			   with the revision D/E harpoon chips.  The caller should reset the
1814 			   host adapter to recover when 0xFE is returned.
1815 			 */
1816 			if (!
1817 			    (RDW_HARPOON((ioport + hp_intstat)) &
1818 			     (BUS_FREE | RSEL))) {
1819 				MENABLE_INT(ioport);
1820 				return 0xFE;
1821 			}
1822 
1823 			WRW_HARPOON((ioport + hp_intstat),
1824 				    (BUS_FREE | ITAR_DISC));
1825 
1826 			pCurrCard->globalFlags |= F_NEW_SCCB_CMD;
1827 
1828 		}
1829 
1830 		else if (hp_int & RSEL) {
1831 
1832 			WRW_HARPOON((ioport + hp_intstat),
1833 				    (PROG_HLT | RSEL | PHASE | BUS_FREE));
1834 
1835 			if (RDW_HARPOON((ioport + hp_intstat)) & ITAR_DISC) {
1836 				if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
1837 					FPT_phaseChkFifo(ioport, thisCard);
1838 
1839 				if (RD_HARPOON(ioport + hp_gp_reg_1) ==
1840 				    SAVE_POINTERS) {
1841 					WR_HARPOON(ioport + hp_gp_reg_1, 0x00);
1842 					currSCCB->Sccb_XferState |=
1843 					    F_NO_DATA_YET;
1844 					currSCCB->Sccb_savedATC =
1845 					    currSCCB->Sccb_ATC;
1846 				}
1847 
1848 				WRW_HARPOON((ioport + hp_intstat),
1849 					    (BUS_FREE | ITAR_DISC));
1850 				currSCCB->Sccb_scsistat = DISCONNECT_ST;
1851 				FPT_queueDisconnect(currSCCB, thisCard);
1852 			}
1853 
1854 			FPT_sres(ioport, thisCard, pCurrCard);
1855 			FPT_phaseDecode(ioport, thisCard);
1856 
1857 		}
1858 
1859 		else if ((hp_int & IDO_STRT) && (!(hp_int & BUS_FREE))) {
1860 
1861 			WRW_HARPOON((ioport + hp_intstat),
1862 				    (IDO_STRT | XFER_CNT_0));
1863 			FPT_phaseDecode(ioport, thisCard);
1864 
1865 		}
1866 
1867 		else if ((hp_int & IUNKWN) || (hp_int & PROG_HLT)) {
1868 			WRW_HARPOON((ioport + hp_intstat),
1869 				    (PHASE | IUNKWN | PROG_HLT));
1870 			if ((RD_HARPOON(ioport + hp_prgmcnt_0) & (unsigned char)
1871 			     0x3f) < (unsigned char)SELCHK) {
1872 				FPT_phaseDecode(ioport, thisCard);
1873 			} else {
1874 				/* Harpoon problem some SCSI target device respond to selection
1875 				   with short BUSY pulse (<400ns) this will make the Harpoon is not able
1876 				   to latch the correct Target ID into reg. x53.
1877 				   The work around require to correct this reg. But when write to this
1878 				   reg. (0x53) also increment the FIFO write addr reg (0x6f), thus we
1879 				   need to read this reg first then restore it later. After update to 0x53 */
1880 
1881 				i = (unsigned
1882 				     char)(RD_HARPOON(ioport + hp_fifowrite));
1883 				target =
1884 				    (unsigned
1885 				     char)(RD_HARPOON(ioport + hp_gp_reg_3));
1886 				WR_HARPOON(ioport + hp_xfer_pad,
1887 					   (unsigned char)ID_UNLOCK);
1888 				WR_HARPOON(ioport + hp_select_id,
1889 					   (unsigned char)(target | target <<
1890 							   4));
1891 				WR_HARPOON(ioport + hp_xfer_pad,
1892 					   (unsigned char)0x00);
1893 				WR_HARPOON(ioport + hp_fifowrite, i);
1894 				WR_HARPOON(ioport + hp_autostart_3,
1895 					   (AUTO_IMMED + TAG_STRT));
1896 			}
1897 		}
1898 
1899 		else if (hp_int & XFER_CNT_0) {
1900 
1901 			WRW_HARPOON((ioport + hp_intstat), XFER_CNT_0);
1902 
1903 			FPT_schkdd(ioport, thisCard);
1904 
1905 		}
1906 
1907 		else if (hp_int & BUS_FREE) {
1908 
1909 			WRW_HARPOON((ioport + hp_intstat), BUS_FREE);
1910 
1911 			if (pCurrCard->globalFlags & F_HOST_XFER_ACT) {
1912 
1913 				FPT_hostDataXferAbort(ioport, thisCard,
1914 						      currSCCB);
1915 			}
1916 
1917 			FPT_phaseBusFree(ioport, thisCard);
1918 		}
1919 
1920 		else if (hp_int & ITICKLE) {
1921 
1922 			WRW_HARPOON((ioport + hp_intstat), ITICKLE);
1923 			pCurrCard->globalFlags |= F_NEW_SCCB_CMD;
1924 		}
1925 
1926 		if (((struct sccb_card *)pCurrCard)->
1927 		    globalFlags & F_NEW_SCCB_CMD) {
1928 
1929 			pCurrCard->globalFlags &= ~F_NEW_SCCB_CMD;
1930 
1931 			if (pCurrCard->currentSCCB == NULL)
1932 				FPT_queueSearchSelect(pCurrCard, thisCard);
1933 
1934 			if (pCurrCard->currentSCCB != NULL) {
1935 				pCurrCard->globalFlags &= ~F_NEW_SCCB_CMD;
1936 				FPT_ssel(ioport, thisCard);
1937 			}
1938 
1939 			break;
1940 
1941 		}
1942 
1943 	}			/*end while */
1944 
1945 	MENABLE_INT(ioport);
1946 
1947 	return 0;
1948 }
1949 
1950 /*---------------------------------------------------------------------
1951  *
1952  * Function: Sccb_bad_isr
1953  *
1954  * Description: Some type of interrupt has occurred which is slightly
1955  *              out of the ordinary.  We will now decode it fully, in
1956  *              this routine.  This is broken up in an attempt to save
1957  *              processing time.
1958  *
1959  *---------------------------------------------------------------------*/
FPT_SccbMgr_bad_isr(u32 p_port,unsigned char p_card,struct sccb_card * pCurrCard,unsigned short p_int)1960 static unsigned char FPT_SccbMgr_bad_isr(u32 p_port, unsigned char p_card,
1961 					 struct sccb_card *pCurrCard,
1962 					 unsigned short p_int)
1963 {
1964 	unsigned char temp, ScamFlg;
1965 	struct sccb_mgr_tar_info *currTar_Info;
1966 	struct nvram_info *pCurrNvRam;
1967 
1968 	if (RD_HARPOON(p_port + hp_ext_status) &
1969 	    (BM_FORCE_OFF | PCI_DEV_TMOUT | BM_PARITY_ERR | PIO_OVERRUN)) {
1970 
1971 		if (pCurrCard->globalFlags & F_HOST_XFER_ACT) {
1972 
1973 			FPT_hostDataXferAbort(p_port, p_card,
1974 					      pCurrCard->currentSCCB);
1975 		}
1976 
1977 		if (RD_HARPOON(p_port + hp_pci_stat_cfg) & REC_MASTER_ABORT)
1978 		{
1979 			WR_HARPOON(p_port + hp_pci_stat_cfg,
1980 				   (RD_HARPOON(p_port + hp_pci_stat_cfg) &
1981 				    ~REC_MASTER_ABORT));
1982 
1983 			WR_HARPOON(p_port + hp_host_blk_cnt, 0x00);
1984 
1985 		}
1986 
1987 		if (pCurrCard->currentSCCB != NULL) {
1988 
1989 			if (!pCurrCard->currentSCCB->HostStatus)
1990 				pCurrCard->currentSCCB->HostStatus =
1991 				    SCCB_BM_ERR;
1992 
1993 			FPT_sxfrp(p_port, p_card);
1994 
1995 			temp = (unsigned char)(RD_HARPOON(p_port + hp_ee_ctrl) &
1996 					       (EXT_ARB_ACK | SCSI_TERM_ENA_H));
1997 			WR_HARPOON(p_port + hp_ee_ctrl,
1998 				   ((unsigned char)temp | SEE_MS | SEE_CS));
1999 			WR_HARPOON(p_port + hp_ee_ctrl, temp);
2000 
2001 			if (!
2002 			    (RDW_HARPOON((p_port + hp_intstat)) &
2003 			     (BUS_FREE | RESET))) {
2004 				FPT_phaseDecode(p_port, p_card);
2005 			}
2006 		}
2007 	}
2008 
2009 	else if (p_int & RESET) {
2010 
2011 		WR_HARPOON(p_port + hp_clkctrl_0, CLKCTRL_DEFAULT);
2012 		WR_HARPOON(p_port + hp_sys_ctrl, 0x00);
2013 		if (pCurrCard->currentSCCB != NULL) {
2014 
2015 			if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
2016 
2017 				FPT_hostDataXferAbort(p_port, p_card,
2018 						      pCurrCard->currentSCCB);
2019 		}
2020 
2021 		DISABLE_AUTO(p_port);
2022 
2023 		FPT_sresb(p_port, p_card);
2024 
2025 		while (RD_HARPOON(p_port + hp_scsictrl_0) & SCSI_RST) {
2026 		}
2027 
2028 		pCurrNvRam = pCurrCard->pNvRamInfo;
2029 		if (pCurrNvRam) {
2030 			ScamFlg = pCurrNvRam->niScamConf;
2031 		} else {
2032 			ScamFlg =
2033 			    (unsigned char)FPT_utilEERead(p_port,
2034 							  SCAM_CONFIG / 2);
2035 		}
2036 
2037 		FPT_XbowInit(p_port, ScamFlg);
2038 
2039 		FPT_scini(p_card, pCurrCard->ourId, 0);
2040 
2041 		return 0xFF;
2042 	}
2043 
2044 	else if (p_int & FIFO) {
2045 
2046 		WRW_HARPOON((p_port + hp_intstat), FIFO);
2047 
2048 		if (pCurrCard->currentSCCB != NULL)
2049 			FPT_sxfrp(p_port, p_card);
2050 	}
2051 
2052 	else if (p_int & TIMEOUT) {
2053 
2054 		DISABLE_AUTO(p_port);
2055 
2056 		WRW_HARPOON((p_port + hp_intstat),
2057 			    (PROG_HLT | TIMEOUT | SEL | BUS_FREE | PHASE |
2058 			     IUNKWN));
2059 
2060 		pCurrCard->currentSCCB->HostStatus = SCCB_SELECTION_TIMEOUT;
2061 
2062 		currTar_Info =
2063 		    &FPT_sccbMgrTbl[p_card][pCurrCard->currentSCCB->TargID];
2064 		if ((pCurrCard->globalFlags & F_CONLUN_IO)
2065 		    && ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) !=
2066 			TAG_Q_TRYING))
2067 			currTar_Info->TarLUNBusy[pCurrCard->currentSCCB->Lun] =
2068 			    0;
2069 		else
2070 			currTar_Info->TarLUNBusy[0] = 0;
2071 
2072 		if (currTar_Info->TarEEValue & EE_SYNC_MASK) {
2073 			currTar_Info->TarSyncCtrl = 0;
2074 			currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
2075 		}
2076 
2077 		if (currTar_Info->TarEEValue & EE_WIDE_SCSI) {
2078 			currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
2079 		}
2080 
2081 		FPT_sssyncv(p_port, pCurrCard->currentSCCB->TargID, NARROW_SCSI,
2082 			    currTar_Info);
2083 
2084 		FPT_queueCmdComplete(pCurrCard, pCurrCard->currentSCCB, p_card);
2085 
2086 	}
2087 
2088 	else if (p_int & SCAM_SEL) {
2089 
2090 		FPT_scarb(p_port, LEVEL2_TAR);
2091 		FPT_scsel(p_port);
2092 		FPT_scasid(p_card, p_port);
2093 
2094 		FPT_scbusf(p_port);
2095 
2096 		WRW_HARPOON((p_port + hp_intstat), SCAM_SEL);
2097 	}
2098 
2099 	return 0x00;
2100 }
2101 
2102 /*---------------------------------------------------------------------
2103  *
2104  * Function: SccbMgrTableInit
2105  *
2106  * Description: Initialize all Sccb manager data structures.
2107  *
2108  *---------------------------------------------------------------------*/
2109 
FPT_SccbMgrTableInitAll(void)2110 static void FPT_SccbMgrTableInitAll(void)
2111 {
2112 	unsigned char thisCard;
2113 
2114 	for (thisCard = 0; thisCard < MAX_CARDS; thisCard++) {
2115 		FPT_SccbMgrTableInitCard(&FPT_BL_Card[thisCard], thisCard);
2116 
2117 		FPT_BL_Card[thisCard].ioPort = 0x00;
2118 		FPT_BL_Card[thisCard].cardInfo = NULL;
2119 		FPT_BL_Card[thisCard].cardIndex = 0xFF;
2120 		FPT_BL_Card[thisCard].ourId = 0x00;
2121 		FPT_BL_Card[thisCard].pNvRamInfo = NULL;
2122 	}
2123 }
2124 
2125 /*---------------------------------------------------------------------
2126  *
2127  * Function: SccbMgrTableInit
2128  *
2129  * Description: Initialize all Sccb manager data structures.
2130  *
2131  *---------------------------------------------------------------------*/
2132 
FPT_SccbMgrTableInitCard(struct sccb_card * pCurrCard,unsigned char p_card)2133 static void FPT_SccbMgrTableInitCard(struct sccb_card *pCurrCard,
2134 				     unsigned char p_card)
2135 {
2136 	unsigned char scsiID, qtag;
2137 
2138 	for (qtag = 0; qtag < QUEUE_DEPTH; qtag++) {
2139 		FPT_BL_Card[p_card].discQ_Tbl[qtag] = NULL;
2140 	}
2141 
2142 	for (scsiID = 0; scsiID < MAX_SCSI_TAR; scsiID++) {
2143 		FPT_sccbMgrTbl[p_card][scsiID].TarStatus = 0;
2144 		FPT_sccbMgrTbl[p_card][scsiID].TarEEValue = 0;
2145 		FPT_SccbMgrTableInitTarget(p_card, scsiID);
2146 	}
2147 
2148 	pCurrCard->scanIndex = 0x00;
2149 	pCurrCard->currentSCCB = NULL;
2150 	pCurrCard->globalFlags = 0x00;
2151 	pCurrCard->cmdCounter = 0x00;
2152 	pCurrCard->tagQ_Lst = 0x01;
2153 	pCurrCard->discQCount = 0;
2154 
2155 }
2156 
2157 /*---------------------------------------------------------------------
2158  *
2159  * Function: SccbMgrTableInit
2160  *
2161  * Description: Initialize all Sccb manager data structures.
2162  *
2163  *---------------------------------------------------------------------*/
2164 
FPT_SccbMgrTableInitTarget(unsigned char p_card,unsigned char target)2165 static void FPT_SccbMgrTableInitTarget(unsigned char p_card,
2166 				       unsigned char target)
2167 {
2168 
2169 	unsigned char lun, qtag;
2170 	struct sccb_mgr_tar_info *currTar_Info;
2171 
2172 	currTar_Info = &FPT_sccbMgrTbl[p_card][target];
2173 
2174 	currTar_Info->TarSelQ_Cnt = 0;
2175 	currTar_Info->TarSyncCtrl = 0;
2176 
2177 	currTar_Info->TarSelQ_Head = NULL;
2178 	currTar_Info->TarSelQ_Tail = NULL;
2179 	currTar_Info->TarTagQ_Cnt = 0;
2180 	currTar_Info->TarLUN_CA = 0;
2181 
2182 	for (lun = 0; lun < MAX_LUN; lun++) {
2183 		currTar_Info->TarLUNBusy[lun] = 0;
2184 		currTar_Info->LunDiscQ_Idx[lun] = 0;
2185 	}
2186 
2187 	for (qtag = 0; qtag < QUEUE_DEPTH; qtag++) {
2188 		if (FPT_BL_Card[p_card].discQ_Tbl[qtag] != NULL) {
2189 			if (FPT_BL_Card[p_card].discQ_Tbl[qtag]->TargID ==
2190 			    target) {
2191 				FPT_BL_Card[p_card].discQ_Tbl[qtag] = NULL;
2192 				FPT_BL_Card[p_card].discQCount--;
2193 			}
2194 		}
2195 	}
2196 }
2197 
2198 /*---------------------------------------------------------------------
2199  *
2200  * Function: sfetm
2201  *
2202  * Description: Read in a message byte from the SCSI bus, and check
2203  *              for a parity error.
2204  *
2205  *---------------------------------------------------------------------*/
2206 
FPT_sfm(u32 port,struct sccb * pCurrSCCB)2207 static unsigned char FPT_sfm(u32 port, struct sccb *pCurrSCCB)
2208 {
2209 	unsigned char message;
2210 	unsigned short TimeOutLoop;
2211 
2212 	TimeOutLoop = 0;
2213 	while ((!(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)) &&
2214 	       (TimeOutLoop++ < 20000)) {
2215 	}
2216 
2217 	WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
2218 
2219 	message = RD_HARPOON(port + hp_scsidata_0);
2220 
2221 	WR_HARPOON(port + hp_scsisig, SCSI_ACK + S_MSGI_PH);
2222 
2223 	if (TimeOutLoop > 20000)
2224 		message = 0x00;	/* force message byte = 0 if Time Out on Req */
2225 
2226 	if ((RDW_HARPOON((port + hp_intstat)) & PARITY) &&
2227 	    (RD_HARPOON(port + hp_addstat) & SCSI_PAR_ERR)) {
2228 		WR_HARPOON(port + hp_scsisig, (SCSI_ACK + S_ILL_PH));
2229 		WR_HARPOON(port + hp_xferstat, 0);
2230 		WR_HARPOON(port + hp_fiforead, 0);
2231 		WR_HARPOON(port + hp_fifowrite, 0);
2232 		if (pCurrSCCB != NULL) {
2233 			pCurrSCCB->Sccb_scsimsg = MSG_PARITY_ERROR;
2234 		}
2235 		message = 0x00;
2236 		do {
2237 			ACCEPT_MSG_ATN(port);
2238 			TimeOutLoop = 0;
2239 			while ((!(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)) &&
2240 			       (TimeOutLoop++ < 20000)) {
2241 			}
2242 			if (TimeOutLoop > 20000) {
2243 				WRW_HARPOON((port + hp_intstat), PARITY);
2244 				return message;
2245 			}
2246 			if ((RD_HARPOON(port + hp_scsisig) & S_SCSI_PHZ) !=
2247 			    S_MSGI_PH) {
2248 				WRW_HARPOON((port + hp_intstat), PARITY);
2249 				return message;
2250 			}
2251 			WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
2252 
2253 			RD_HARPOON(port + hp_scsidata_0);
2254 
2255 			WR_HARPOON(port + hp_scsisig, (SCSI_ACK + S_ILL_PH));
2256 
2257 		} while (1);
2258 
2259 	}
2260 	WR_HARPOON(port + hp_scsisig, (SCSI_ACK + S_ILL_PH));
2261 	WR_HARPOON(port + hp_xferstat, 0);
2262 	WR_HARPOON(port + hp_fiforead, 0);
2263 	WR_HARPOON(port + hp_fifowrite, 0);
2264 	return message;
2265 }
2266 
2267 /*---------------------------------------------------------------------
2268  *
2269  * Function: FPT_ssel
2270  *
2271  * Description: Load up automation and select target device.
2272  *
2273  *---------------------------------------------------------------------*/
2274 
FPT_ssel(u32 port,unsigned char p_card)2275 static void FPT_ssel(u32 port, unsigned char p_card)
2276 {
2277 
2278 	unsigned char auto_loaded, i, target, *theCCB;
2279 
2280 	u32 cdb_reg;
2281 	struct sccb_card *CurrCard;
2282 	struct sccb *currSCCB;
2283 	struct sccb_mgr_tar_info *currTar_Info;
2284 	unsigned char lastTag, lun;
2285 
2286 	CurrCard = &FPT_BL_Card[p_card];
2287 	currSCCB = CurrCard->currentSCCB;
2288 	target = currSCCB->TargID;
2289 	currTar_Info = &FPT_sccbMgrTbl[p_card][target];
2290 	lastTag = CurrCard->tagQ_Lst;
2291 
2292 	ARAM_ACCESS(port);
2293 
2294 	if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_REJECT)
2295 		currSCCB->ControlByte &= ~F_USE_CMD_Q;
2296 
2297 	if (((CurrCard->globalFlags & F_CONLUN_IO) &&
2298 	     ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING)))
2299 
2300 		lun = currSCCB->Lun;
2301 	else
2302 		lun = 0;
2303 
2304 	if (CurrCard->globalFlags & F_TAG_STARTED) {
2305 		if (!(currSCCB->ControlByte & F_USE_CMD_Q)) {
2306 			if ((currTar_Info->TarLUN_CA == 0)
2307 			    && ((currTar_Info->TarStatus & TAR_TAG_Q_MASK)
2308 				== TAG_Q_TRYING)) {
2309 
2310 				if (currTar_Info->TarTagQ_Cnt != 0) {
2311 					currTar_Info->TarLUNBusy[lun] = 1;
2312 					FPT_queueSelectFail(CurrCard, p_card);
2313 					SGRAM_ACCESS(port);
2314 					return;
2315 				}
2316 
2317 				else {
2318 					currTar_Info->TarLUNBusy[lun] = 1;
2319 				}
2320 
2321 			}
2322 			/*End non-tagged */
2323 			else {
2324 				currTar_Info->TarLUNBusy[lun] = 1;
2325 			}
2326 
2327 		}
2328 		/*!Use cmd Q Tagged */
2329 		else {
2330 			if (currTar_Info->TarLUN_CA == 1) {
2331 				FPT_queueSelectFail(CurrCard, p_card);
2332 				SGRAM_ACCESS(port);
2333 				return;
2334 			}
2335 
2336 			currTar_Info->TarLUNBusy[lun] = 1;
2337 
2338 		}		/*else use cmd Q tagged */
2339 
2340 	}
2341 	/*if glob tagged started */
2342 	else {
2343 		currTar_Info->TarLUNBusy[lun] = 1;
2344 	}
2345 
2346 	if ((((CurrCard->globalFlags & F_CONLUN_IO) &&
2347 	      ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
2348 	     || (!(currSCCB->ControlByte & F_USE_CMD_Q)))) {
2349 		if (CurrCard->discQCount >= QUEUE_DEPTH) {
2350 			currTar_Info->TarLUNBusy[lun] = 1;
2351 			FPT_queueSelectFail(CurrCard, p_card);
2352 			SGRAM_ACCESS(port);
2353 			return;
2354 		}
2355 		for (i = 1; i < QUEUE_DEPTH; i++) {
2356 			if (++lastTag >= QUEUE_DEPTH)
2357 				lastTag = 1;
2358 			if (CurrCard->discQ_Tbl[lastTag] == NULL) {
2359 				CurrCard->tagQ_Lst = lastTag;
2360 				currTar_Info->LunDiscQ_Idx[lun] = lastTag;
2361 				CurrCard->discQ_Tbl[lastTag] = currSCCB;
2362 				CurrCard->discQCount++;
2363 				break;
2364 			}
2365 		}
2366 		if (i == QUEUE_DEPTH) {
2367 			currTar_Info->TarLUNBusy[lun] = 1;
2368 			FPT_queueSelectFail(CurrCard, p_card);
2369 			SGRAM_ACCESS(port);
2370 			return;
2371 		}
2372 	}
2373 
2374 	auto_loaded = 0;
2375 
2376 	WR_HARPOON(port + hp_select_id, target);
2377 	WR_HARPOON(port + hp_gp_reg_3, target);	/* Use by new automation logic */
2378 
2379 	if (currSCCB->OperationCode == RESET_COMMAND) {
2380 		WRW_HARPOON((port + ID_MSG_STRT), (MPM_OP + AMSG_OUT +
2381 						   (currSCCB->
2382 						    Sccb_idmsg & ~DISC_PRIV)));
2383 
2384 		WRW_HARPOON((port + ID_MSG_STRT + 2), BRH_OP + ALWAYS + NP);
2385 
2386 		currSCCB->Sccb_scsimsg = TARGET_RESET;
2387 
2388 		WR_HARPOON(port + hp_autostart_3, (SELECT + SELCHK_STRT));
2389 		auto_loaded = 1;
2390 		currSCCB->Sccb_scsistat = SELECT_BDR_ST;
2391 
2392 		if (currTar_Info->TarEEValue & EE_SYNC_MASK) {
2393 			currTar_Info->TarSyncCtrl = 0;
2394 			currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
2395 		}
2396 
2397 		if (currTar_Info->TarEEValue & EE_WIDE_SCSI) {
2398 			currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
2399 		}
2400 
2401 		FPT_sssyncv(port, target, NARROW_SCSI, currTar_Info);
2402 		FPT_SccbMgrTableInitTarget(p_card, target);
2403 
2404 	}
2405 
2406 	else if (currSCCB->Sccb_scsistat == ABORT_ST) {
2407 		WRW_HARPOON((port + ID_MSG_STRT), (MPM_OP + AMSG_OUT +
2408 						   (currSCCB->
2409 						    Sccb_idmsg & ~DISC_PRIV)));
2410 
2411 		WRW_HARPOON((port + ID_MSG_STRT + 2), BRH_OP + ALWAYS + CMDPZ);
2412 
2413 		WRW_HARPOON((port + SYNC_MSGS + 0), (MPM_OP + AMSG_OUT +
2414 						     (((unsigned
2415 							char)(currSCCB->
2416 							      ControlByte &
2417 							      TAG_TYPE_MASK)
2418 						       >> 6) | (unsigned char)
2419 						      0x20)));
2420 		WRW_HARPOON((port + SYNC_MSGS + 2),
2421 			    (MPM_OP + AMSG_OUT + currSCCB->Sccb_tag));
2422 		WRW_HARPOON((port + SYNC_MSGS + 4), (BRH_OP + ALWAYS + NP));
2423 
2424 		WR_HARPOON(port + hp_autostart_3, (SELECT + SELCHK_STRT));
2425 		auto_loaded = 1;
2426 
2427 	}
2428 
2429 	else if (!(currTar_Info->TarStatus & WIDE_NEGOCIATED)) {
2430 		auto_loaded = FPT_siwidn(port, p_card);
2431 		currSCCB->Sccb_scsistat = SELECT_WN_ST;
2432 	}
2433 
2434 	else if (!((currTar_Info->TarStatus & TAR_SYNC_MASK)
2435 		   == SYNC_SUPPORTED)) {
2436 		auto_loaded = FPT_sisyncn(port, p_card, 0);
2437 		currSCCB->Sccb_scsistat = SELECT_SN_ST;
2438 	}
2439 
2440 	if (!auto_loaded) {
2441 
2442 		if (currSCCB->ControlByte & F_USE_CMD_Q) {
2443 
2444 			CurrCard->globalFlags |= F_TAG_STARTED;
2445 
2446 			if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK)
2447 			    == TAG_Q_REJECT) {
2448 				currSCCB->ControlByte &= ~F_USE_CMD_Q;
2449 
2450 				/* Fix up the start instruction with a jump to
2451 				   Non-Tag-CMD handling */
2452 				WRW_HARPOON((port + ID_MSG_STRT),
2453 					    BRH_OP + ALWAYS + NTCMD);
2454 
2455 				WRW_HARPOON((port + NON_TAG_ID_MSG),
2456 					    (MPM_OP + AMSG_OUT +
2457 					     currSCCB->Sccb_idmsg));
2458 
2459 				WR_HARPOON(port + hp_autostart_3,
2460 					   (SELECT + SELCHK_STRT));
2461 
2462 				/* Setup our STATE so we know what happened when
2463 				   the wheels fall off. */
2464 				currSCCB->Sccb_scsistat = SELECT_ST;
2465 
2466 				currTar_Info->TarLUNBusy[lun] = 1;
2467 			}
2468 
2469 			else {
2470 				WRW_HARPOON((port + ID_MSG_STRT),
2471 					    (MPM_OP + AMSG_OUT +
2472 					     currSCCB->Sccb_idmsg));
2473 
2474 				WRW_HARPOON((port + ID_MSG_STRT + 2),
2475 					    (MPM_OP + AMSG_OUT +
2476 					     (((unsigned char)(currSCCB->
2477 							       ControlByte &
2478 							       TAG_TYPE_MASK)
2479 					       >> 6) | (unsigned char)0x20)));
2480 
2481 				for (i = 1; i < QUEUE_DEPTH; i++) {
2482 					if (++lastTag >= QUEUE_DEPTH)
2483 						lastTag = 1;
2484 					if (CurrCard->discQ_Tbl[lastTag] ==
2485 					    NULL) {
2486 						WRW_HARPOON((port +
2487 							     ID_MSG_STRT + 6),
2488 							    (MPM_OP + AMSG_OUT +
2489 							     lastTag));
2490 						CurrCard->tagQ_Lst = lastTag;
2491 						currSCCB->Sccb_tag = lastTag;
2492 						CurrCard->discQ_Tbl[lastTag] =
2493 						    currSCCB;
2494 						CurrCard->discQCount++;
2495 						break;
2496 					}
2497 				}
2498 
2499 				if (i == QUEUE_DEPTH) {
2500 					currTar_Info->TarLUNBusy[lun] = 1;
2501 					FPT_queueSelectFail(CurrCard, p_card);
2502 					SGRAM_ACCESS(port);
2503 					return;
2504 				}
2505 
2506 				currSCCB->Sccb_scsistat = SELECT_Q_ST;
2507 
2508 				WR_HARPOON(port + hp_autostart_3,
2509 					   (SELECT + SELCHK_STRT));
2510 			}
2511 		}
2512 
2513 		else {
2514 
2515 			WRW_HARPOON((port + ID_MSG_STRT),
2516 				    BRH_OP + ALWAYS + NTCMD);
2517 
2518 			WRW_HARPOON((port + NON_TAG_ID_MSG),
2519 				    (MPM_OP + AMSG_OUT + currSCCB->Sccb_idmsg));
2520 
2521 			currSCCB->Sccb_scsistat = SELECT_ST;
2522 
2523 			WR_HARPOON(port + hp_autostart_3,
2524 				   (SELECT + SELCHK_STRT));
2525 		}
2526 
2527 		theCCB = (unsigned char *)&currSCCB->Cdb[0];
2528 
2529 		cdb_reg = port + CMD_STRT;
2530 
2531 		for (i = 0; i < currSCCB->CdbLength; i++) {
2532 			WRW_HARPOON(cdb_reg, (MPM_OP + ACOMMAND + *theCCB));
2533 			cdb_reg += 2;
2534 			theCCB++;
2535 		}
2536 
2537 		if (currSCCB->CdbLength != TWELVE_BYTE_CMD)
2538 			WRW_HARPOON(cdb_reg, (BRH_OP + ALWAYS + NP));
2539 
2540 	}
2541 	/* auto_loaded */
2542 	WRW_HARPOON((port + hp_fiforead), (unsigned short)0x00);
2543 	WR_HARPOON(port + hp_xferstat, 0x00);
2544 
2545 	WRW_HARPOON((port + hp_intstat), (PROG_HLT | TIMEOUT | SEL | BUS_FREE));
2546 
2547 	WR_HARPOON(port + hp_portctrl_0, (SCSI_PORT));
2548 
2549 	if (!(currSCCB->Sccb_MGRFlags & F_DEV_SELECTED)) {
2550 		WR_HARPOON(port + hp_scsictrl_0,
2551 			   (SEL_TAR | ENA_ATN | ENA_RESEL | ENA_SCAM_SEL));
2552 	} else {
2553 
2554 /*      auto_loaded =  (RD_HARPOON(port+hp_autostart_3) & (unsigned char)0x1F);
2555       auto_loaded |= AUTO_IMMED; */
2556 		auto_loaded = AUTO_IMMED;
2557 
2558 		DISABLE_AUTO(port);
2559 
2560 		WR_HARPOON(port + hp_autostart_3, auto_loaded);
2561 	}
2562 
2563 	SGRAM_ACCESS(port);
2564 }
2565 
2566 /*---------------------------------------------------------------------
2567  *
2568  * Function: FPT_sres
2569  *
2570  * Description: Hookup the correct CCB and handle the incoming messages.
2571  *
2572  *---------------------------------------------------------------------*/
2573 
FPT_sres(u32 port,unsigned char p_card,struct sccb_card * pCurrCard)2574 static void FPT_sres(u32 port, unsigned char p_card,
2575 		     struct sccb_card *pCurrCard)
2576 {
2577 
2578 	unsigned char our_target, message, lun = 0, tag, msgRetryCount;
2579 
2580 	struct sccb_mgr_tar_info *currTar_Info;
2581 	struct sccb *currSCCB;
2582 
2583 	if (pCurrCard->currentSCCB != NULL) {
2584 		currTar_Info =
2585 		    &FPT_sccbMgrTbl[p_card][pCurrCard->currentSCCB->TargID];
2586 		DISABLE_AUTO(port);
2587 
2588 		WR_HARPOON((port + hp_scsictrl_0), (ENA_RESEL | ENA_SCAM_SEL));
2589 
2590 		currSCCB = pCurrCard->currentSCCB;
2591 		if (currSCCB->Sccb_scsistat == SELECT_WN_ST) {
2592 			currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
2593 			currSCCB->Sccb_scsistat = BUS_FREE_ST;
2594 		}
2595 		if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
2596 			currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
2597 			currSCCB->Sccb_scsistat = BUS_FREE_ST;
2598 		}
2599 		if (((pCurrCard->globalFlags & F_CONLUN_IO) &&
2600 		     ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) !=
2601 		      TAG_Q_TRYING))) {
2602 			currTar_Info->TarLUNBusy[currSCCB->Lun] = 0;
2603 			if (currSCCB->Sccb_scsistat != ABORT_ST) {
2604 				pCurrCard->discQCount--;
2605 				pCurrCard->discQ_Tbl[currTar_Info->
2606 						     LunDiscQ_Idx[currSCCB->
2607 								  Lun]]
2608 				    = NULL;
2609 			}
2610 		} else {
2611 			currTar_Info->TarLUNBusy[0] = 0;
2612 			if (currSCCB->Sccb_tag) {
2613 				if (currSCCB->Sccb_scsistat != ABORT_ST) {
2614 					pCurrCard->discQCount--;
2615 					pCurrCard->discQ_Tbl[currSCCB->
2616 							     Sccb_tag] = NULL;
2617 				}
2618 			} else {
2619 				if (currSCCB->Sccb_scsistat != ABORT_ST) {
2620 					pCurrCard->discQCount--;
2621 					pCurrCard->discQ_Tbl[currTar_Info->
2622 							     LunDiscQ_Idx[0]] =
2623 					    NULL;
2624 				}
2625 			}
2626 		}
2627 
2628 		FPT_queueSelectFail(&FPT_BL_Card[p_card], p_card);
2629 	}
2630 
2631 	WRW_HARPOON((port + hp_fiforead), (unsigned short)0x00);
2632 
2633 	our_target = (unsigned char)(RD_HARPOON(port + hp_select_id) >> 4);
2634 	currTar_Info = &FPT_sccbMgrTbl[p_card][our_target];
2635 
2636 	msgRetryCount = 0;
2637 	do {
2638 
2639 		currTar_Info = &FPT_sccbMgrTbl[p_card][our_target];
2640 		tag = 0;
2641 
2642 		while (!(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)) {
2643 			if (!(RD_HARPOON(port + hp_scsisig) & SCSI_BSY)) {
2644 
2645 				WRW_HARPOON((port + hp_intstat), PHASE);
2646 				return;
2647 			}
2648 		}
2649 
2650 		WRW_HARPOON((port + hp_intstat), PHASE);
2651 		if ((RD_HARPOON(port + hp_scsisig) & S_SCSI_PHZ) == S_MSGI_PH) {
2652 
2653 			message = FPT_sfm(port, pCurrCard->currentSCCB);
2654 			if (message) {
2655 
2656 				if (message <= (0x80 | LUN_MASK)) {
2657 					lun = message & (unsigned char)LUN_MASK;
2658 
2659 					if ((currTar_Info->
2660 					     TarStatus & TAR_TAG_Q_MASK) ==
2661 					    TAG_Q_TRYING) {
2662 						if (currTar_Info->TarTagQ_Cnt !=
2663 						    0) {
2664 
2665 							if (!
2666 							    (currTar_Info->
2667 							     TarLUN_CA)) {
2668 								ACCEPT_MSG(port);	/*Release the ACK for ID msg. */
2669 
2670 								message =
2671 								    FPT_sfm
2672 								    (port,
2673 								     pCurrCard->
2674 								     currentSCCB);
2675 								if (message) {
2676 									ACCEPT_MSG
2677 									    (port);
2678 								}
2679 
2680 								else
2681 									message
2682 									    = 0;
2683 
2684 								if (message !=
2685 								    0) {
2686 									tag =
2687 									    FPT_sfm
2688 									    (port,
2689 									     pCurrCard->
2690 									     currentSCCB);
2691 
2692 									if (!
2693 									    (tag))
2694 										message
2695 										    =
2696 										    0;
2697 								}
2698 
2699 							}
2700 							/*C.A. exists! */
2701 						}
2702 						/*End Q cnt != 0 */
2703 					}
2704 					/*End Tag cmds supported! */
2705 				}
2706 				/*End valid ID message.  */
2707 				else {
2708 
2709 					ACCEPT_MSG_ATN(port);
2710 				}
2711 
2712 			}
2713 			/* End good id message. */
2714 			else {
2715 
2716 				message = 0;
2717 			}
2718 		} else {
2719 			ACCEPT_MSG_ATN(port);
2720 
2721 			while (!
2722 			       (RDW_HARPOON((port + hp_intstat)) &
2723 				(PHASE | RESET))
2724 			       && !(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)
2725 			       && (RD_HARPOON(port + hp_scsisig) & SCSI_BSY)) ;
2726 
2727 			return;
2728 		}
2729 
2730 		if (message == 0) {
2731 			msgRetryCount++;
2732 			if (msgRetryCount == 1) {
2733 				FPT_SendMsg(port, MSG_PARITY_ERROR);
2734 			} else {
2735 				FPT_SendMsg(port, TARGET_RESET);
2736 
2737 				FPT_sssyncv(port, our_target, NARROW_SCSI,
2738 					    currTar_Info);
2739 
2740 				if (FPT_sccbMgrTbl[p_card][our_target].
2741 				    TarEEValue & EE_SYNC_MASK) {
2742 
2743 					FPT_sccbMgrTbl[p_card][our_target].
2744 					    TarStatus &= ~TAR_SYNC_MASK;
2745 
2746 				}
2747 
2748 				if (FPT_sccbMgrTbl[p_card][our_target].
2749 				    TarEEValue & EE_WIDE_SCSI) {
2750 
2751 					FPT_sccbMgrTbl[p_card][our_target].
2752 					    TarStatus &= ~TAR_WIDE_MASK;
2753 				}
2754 
2755 				FPT_queueFlushTargSccb(p_card, our_target,
2756 						       SCCB_COMPLETE);
2757 				FPT_SccbMgrTableInitTarget(p_card, our_target);
2758 				return;
2759 			}
2760 		}
2761 	} while (message == 0);
2762 
2763 	if (((pCurrCard->globalFlags & F_CONLUN_IO) &&
2764 	     ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))) {
2765 		currTar_Info->TarLUNBusy[lun] = 1;
2766 		pCurrCard->currentSCCB =
2767 		    pCurrCard->discQ_Tbl[currTar_Info->LunDiscQ_Idx[lun]];
2768 		if (pCurrCard->currentSCCB != NULL) {
2769 			ACCEPT_MSG(port);
2770 		} else {
2771 			ACCEPT_MSG_ATN(port);
2772 		}
2773 	} else {
2774 		currTar_Info->TarLUNBusy[0] = 1;
2775 
2776 		if (tag) {
2777 			if (pCurrCard->discQ_Tbl[tag] != NULL) {
2778 				pCurrCard->currentSCCB =
2779 				    pCurrCard->discQ_Tbl[tag];
2780 				currTar_Info->TarTagQ_Cnt--;
2781 				ACCEPT_MSG(port);
2782 			} else {
2783 				ACCEPT_MSG_ATN(port);
2784 			}
2785 		} else {
2786 			pCurrCard->currentSCCB =
2787 			    pCurrCard->discQ_Tbl[currTar_Info->LunDiscQ_Idx[0]];
2788 			if (pCurrCard->currentSCCB != NULL) {
2789 				ACCEPT_MSG(port);
2790 			} else {
2791 				ACCEPT_MSG_ATN(port);
2792 			}
2793 		}
2794 	}
2795 
2796 	if (pCurrCard->currentSCCB != NULL) {
2797 		if (pCurrCard->currentSCCB->Sccb_scsistat == ABORT_ST) {
2798 			/* During Abort Tag command, the target could have got re-selected
2799 			   and completed the command. Check the select Q and remove the CCB
2800 			   if it is in the Select Q */
2801 			FPT_queueFindSccb(pCurrCard->currentSCCB, p_card);
2802 		}
2803 	}
2804 
2805 	while (!(RDW_HARPOON((port + hp_intstat)) & (PHASE | RESET)) &&
2806 	       !(RD_HARPOON(port + hp_scsisig) & SCSI_REQ) &&
2807 	       (RD_HARPOON(port + hp_scsisig) & SCSI_BSY)) ;
2808 }
2809 
FPT_SendMsg(u32 port,unsigned char message)2810 static void FPT_SendMsg(u32 port, unsigned char message)
2811 {
2812 	while (!(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)) {
2813 		if (!(RD_HARPOON(port + hp_scsisig) & SCSI_BSY)) {
2814 
2815 			WRW_HARPOON((port + hp_intstat), PHASE);
2816 			return;
2817 		}
2818 	}
2819 
2820 	WRW_HARPOON((port + hp_intstat), PHASE);
2821 	if ((RD_HARPOON(port + hp_scsisig) & S_SCSI_PHZ) == S_MSGO_PH) {
2822 		WRW_HARPOON((port + hp_intstat),
2823 			    (BUS_FREE | PHASE | XFER_CNT_0));
2824 
2825 		WR_HARPOON(port + hp_portctrl_0, SCSI_BUS_EN);
2826 
2827 		WR_HARPOON(port + hp_scsidata_0, message);
2828 
2829 		WR_HARPOON(port + hp_scsisig, (SCSI_ACK + S_ILL_PH));
2830 
2831 		ACCEPT_MSG(port);
2832 
2833 		WR_HARPOON(port + hp_portctrl_0, 0x00);
2834 
2835 		if ((message == ABORT_TASK_SET) || (message == TARGET_RESET) ||
2836 		    (message == ABORT_TASK)) {
2837 			while (!
2838 			       (RDW_HARPOON((port + hp_intstat)) &
2839 				(BUS_FREE | PHASE))) {
2840 			}
2841 
2842 			if (RDW_HARPOON((port + hp_intstat)) & BUS_FREE) {
2843 				WRW_HARPOON((port + hp_intstat), BUS_FREE);
2844 			}
2845 		}
2846 	}
2847 }
2848 
2849 /*---------------------------------------------------------------------
2850  *
2851  * Function: FPT_sdecm
2852  *
2853  * Description: Determine the proper response to the message from the
2854  *              target device.
2855  *
2856  *---------------------------------------------------------------------*/
FPT_sdecm(unsigned char message,u32 port,unsigned char p_card)2857 static void FPT_sdecm(unsigned char message, u32 port, unsigned char p_card)
2858 {
2859 	struct sccb *currSCCB;
2860 	struct sccb_card *CurrCard;
2861 	struct sccb_mgr_tar_info *currTar_Info;
2862 
2863 	CurrCard = &FPT_BL_Card[p_card];
2864 	currSCCB = CurrCard->currentSCCB;
2865 
2866 	currTar_Info = &FPT_sccbMgrTbl[p_card][currSCCB->TargID];
2867 
2868 	if (message == RESTORE_POINTERS) {
2869 		if (!(currSCCB->Sccb_XferState & F_NO_DATA_YET)) {
2870 			currSCCB->Sccb_ATC = currSCCB->Sccb_savedATC;
2871 
2872 			FPT_hostDataXferRestart(currSCCB);
2873 		}
2874 
2875 		ACCEPT_MSG(port);
2876 		WR_HARPOON(port + hp_autostart_1,
2877 			   (AUTO_IMMED + DISCONNECT_START));
2878 	}
2879 
2880 	else if (message == COMMAND_COMPLETE) {
2881 
2882 		if (currSCCB->Sccb_scsistat == SELECT_Q_ST) {
2883 			currTar_Info->TarStatus &=
2884 			    ~(unsigned char)TAR_TAG_Q_MASK;
2885 			currTar_Info->TarStatus |= (unsigned char)TAG_Q_REJECT;
2886 		}
2887 
2888 		ACCEPT_MSG(port);
2889 
2890 	}
2891 
2892 	else if ((message == NOP) || (message >= IDENTIFY_BASE) ||
2893 		 (message == INITIATE_RECOVERY) ||
2894 		 (message == RELEASE_RECOVERY)) {
2895 
2896 		ACCEPT_MSG(port);
2897 		WR_HARPOON(port + hp_autostart_1,
2898 			   (AUTO_IMMED + DISCONNECT_START));
2899 	}
2900 
2901 	else if (message == MESSAGE_REJECT) {
2902 
2903 		if ((currSCCB->Sccb_scsistat == SELECT_SN_ST) ||
2904 		    (currSCCB->Sccb_scsistat == SELECT_WN_ST) ||
2905 		    ((currTar_Info->TarStatus & TAR_SYNC_MASK) == SYNC_TRYING)
2906 		    || ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) ==
2907 			TAG_Q_TRYING))
2908 		{
2909 			WRW_HARPOON((port + hp_intstat), BUS_FREE);
2910 
2911 			ACCEPT_MSG(port);
2912 
2913 			while ((!(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)) &&
2914 			       (!(RDW_HARPOON((port + hp_intstat)) & BUS_FREE)))
2915 			{
2916 			}
2917 
2918 			if (currSCCB->Lun == 0x00) {
2919 				if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
2920 
2921 					currTar_Info->TarStatus |=
2922 					    (unsigned char)SYNC_SUPPORTED;
2923 
2924 					currTar_Info->TarEEValue &=
2925 					    ~EE_SYNC_MASK;
2926 				}
2927 
2928 				else if (currSCCB->Sccb_scsistat ==
2929 					  SELECT_WN_ST) {
2930 
2931 					currTar_Info->TarStatus =
2932 					    (currTar_Info->
2933 					     TarStatus & ~WIDE_ENABLED) |
2934 					    WIDE_NEGOCIATED;
2935 
2936 					currTar_Info->TarEEValue &=
2937 					    ~EE_WIDE_SCSI;
2938 
2939 				}
2940 
2941 				else if ((currTar_Info->
2942 					  TarStatus & TAR_TAG_Q_MASK) ==
2943 					 TAG_Q_TRYING) {
2944 					currTar_Info->TarStatus =
2945 					    (currTar_Info->
2946 					     TarStatus & ~(unsigned char)
2947 					     TAR_TAG_Q_MASK) | TAG_Q_REJECT;
2948 
2949 					currSCCB->ControlByte &= ~F_USE_CMD_Q;
2950 					CurrCard->discQCount--;
2951 					CurrCard->discQ_Tbl[currSCCB->
2952 							    Sccb_tag] = NULL;
2953 					currSCCB->Sccb_tag = 0x00;
2954 
2955 				}
2956 			}
2957 
2958 			if (RDW_HARPOON((port + hp_intstat)) & BUS_FREE) {
2959 
2960 				if (currSCCB->Lun == 0x00) {
2961 					WRW_HARPOON((port + hp_intstat),
2962 						    BUS_FREE);
2963 					CurrCard->globalFlags |= F_NEW_SCCB_CMD;
2964 				}
2965 			}
2966 
2967 			else {
2968 
2969 				if ((CurrCard->globalFlags & F_CONLUN_IO) &&
2970 				    ((currTar_Info->
2971 				      TarStatus & TAR_TAG_Q_MASK) !=
2972 				     TAG_Q_TRYING))
2973 					currTar_Info->TarLUNBusy[currSCCB->
2974 								 Lun] = 1;
2975 				else
2976 					currTar_Info->TarLUNBusy[0] = 1;
2977 
2978 				currSCCB->ControlByte &=
2979 				    ~(unsigned char)F_USE_CMD_Q;
2980 
2981 				WR_HARPOON(port + hp_autostart_1,
2982 					   (AUTO_IMMED + DISCONNECT_START));
2983 
2984 			}
2985 		}
2986 
2987 		else {
2988 			ACCEPT_MSG(port);
2989 
2990 			while ((!(RD_HARPOON(port + hp_scsisig) & SCSI_REQ)) &&
2991 			       (!(RDW_HARPOON((port + hp_intstat)) & BUS_FREE)))
2992 			{
2993 			}
2994 
2995 			if (!(RDW_HARPOON((port + hp_intstat)) & BUS_FREE)) {
2996 				WR_HARPOON(port + hp_autostart_1,
2997 					   (AUTO_IMMED + DISCONNECT_START));
2998 			}
2999 		}
3000 	}
3001 
3002 	else if (message == EXTENDED_MESSAGE) {
3003 
3004 		ACCEPT_MSG(port);
3005 		FPT_shandem(port, p_card, currSCCB);
3006 	}
3007 
3008 	else if (message == IGNORE_WIDE_RESIDUE) {
3009 
3010 		ACCEPT_MSG(port);	/* ACK the RESIDUE MSG */
3011 
3012 		message = FPT_sfm(port, currSCCB);
3013 
3014 		if (currSCCB->Sccb_scsimsg != MSG_PARITY_ERROR)
3015 			ACCEPT_MSG(port);
3016 		WR_HARPOON(port + hp_autostart_1,
3017 			   (AUTO_IMMED + DISCONNECT_START));
3018 	}
3019 
3020 	else {
3021 
3022 		currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
3023 		currSCCB->Sccb_scsimsg = MESSAGE_REJECT;
3024 
3025 		ACCEPT_MSG_ATN(port);
3026 		WR_HARPOON(port + hp_autostart_1,
3027 			   (AUTO_IMMED + DISCONNECT_START));
3028 	}
3029 }
3030 
3031 /*---------------------------------------------------------------------
3032  *
3033  * Function: FPT_shandem
3034  *
3035  * Description: Decide what to do with the extended message.
3036  *
3037  *---------------------------------------------------------------------*/
FPT_shandem(u32 port,unsigned char p_card,struct sccb * pCurrSCCB)3038 static void FPT_shandem(u32 port, unsigned char p_card, struct sccb *pCurrSCCB)
3039 {
3040 	unsigned char length, message;
3041 
3042 	length = FPT_sfm(port, pCurrSCCB);
3043 	if (length) {
3044 
3045 		ACCEPT_MSG(port);
3046 		message = FPT_sfm(port, pCurrSCCB);
3047 		if (message) {
3048 
3049 			if (message == EXTENDED_SDTR) {
3050 
3051 				if (length == 0x03) {
3052 
3053 					ACCEPT_MSG(port);
3054 					FPT_stsyncn(port, p_card);
3055 				} else {
3056 
3057 					pCurrSCCB->Sccb_scsimsg = MESSAGE_REJECT;
3058 					ACCEPT_MSG_ATN(port);
3059 				}
3060 			} else if (message == EXTENDED_WDTR) {
3061 
3062 				if (length == 0x02) {
3063 
3064 					ACCEPT_MSG(port);
3065 					FPT_stwidn(port, p_card);
3066 				} else {
3067 
3068 					pCurrSCCB->Sccb_scsimsg = MESSAGE_REJECT;
3069 					ACCEPT_MSG_ATN(port);
3070 
3071 					WR_HARPOON(port + hp_autostart_1,
3072 						   (AUTO_IMMED +
3073 						    DISCONNECT_START));
3074 				}
3075 			} else {
3076 
3077 				pCurrSCCB->Sccb_scsimsg = MESSAGE_REJECT;
3078 				ACCEPT_MSG_ATN(port);
3079 
3080 				WR_HARPOON(port + hp_autostart_1,
3081 					   (AUTO_IMMED + DISCONNECT_START));
3082 			}
3083 		} else {
3084 			if (pCurrSCCB->Sccb_scsimsg != MSG_PARITY_ERROR)
3085 				ACCEPT_MSG(port);
3086 			WR_HARPOON(port + hp_autostart_1,
3087 				   (AUTO_IMMED + DISCONNECT_START));
3088 		}
3089 	} else {
3090 		if (pCurrSCCB->Sccb_scsimsg == MSG_PARITY_ERROR)
3091 			WR_HARPOON(port + hp_autostart_1,
3092 				   (AUTO_IMMED + DISCONNECT_START));
3093 	}
3094 }
3095 
3096 /*---------------------------------------------------------------------
3097  *
3098  * Function: FPT_sisyncn
3099  *
3100  * Description: Read in a message byte from the SCSI bus, and check
3101  *              for a parity error.
3102  *
3103  *---------------------------------------------------------------------*/
3104 
FPT_sisyncn(u32 port,unsigned char p_card,unsigned char syncFlag)3105 static unsigned char FPT_sisyncn(u32 port, unsigned char p_card,
3106 				 unsigned char syncFlag)
3107 {
3108 	struct sccb *currSCCB;
3109 	struct sccb_mgr_tar_info *currTar_Info;
3110 
3111 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
3112 	currTar_Info = &FPT_sccbMgrTbl[p_card][currSCCB->TargID];
3113 
3114 	if (!((currTar_Info->TarStatus & TAR_SYNC_MASK) == SYNC_TRYING)) {
3115 
3116 		WRW_HARPOON((port + ID_MSG_STRT),
3117 			    (MPM_OP + AMSG_OUT +
3118 			     (currSCCB->
3119 			      Sccb_idmsg & ~(unsigned char)DISC_PRIV)));
3120 
3121 		WRW_HARPOON((port + ID_MSG_STRT + 2), BRH_OP + ALWAYS + CMDPZ);
3122 
3123 		WRW_HARPOON((port + SYNC_MSGS + 0),
3124 			    (MPM_OP + AMSG_OUT + EXTENDED_MESSAGE));
3125 		WRW_HARPOON((port + SYNC_MSGS + 2), (MPM_OP + AMSG_OUT + 0x03));
3126 		WRW_HARPOON((port + SYNC_MSGS + 4),
3127 			    (MPM_OP + AMSG_OUT + EXTENDED_SDTR));
3128 
3129 		if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_20MB)
3130 
3131 			WRW_HARPOON((port + SYNC_MSGS + 6),
3132 				    (MPM_OP + AMSG_OUT + 12));
3133 
3134 		else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) ==
3135 			 EE_SYNC_10MB)
3136 
3137 			WRW_HARPOON((port + SYNC_MSGS + 6),
3138 				    (MPM_OP + AMSG_OUT + 25));
3139 
3140 		else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) ==
3141 			 EE_SYNC_5MB)
3142 
3143 			WRW_HARPOON((port + SYNC_MSGS + 6),
3144 				    (MPM_OP + AMSG_OUT + 50));
3145 
3146 		else
3147 			WRW_HARPOON((port + SYNC_MSGS + 6),
3148 				    (MPM_OP + AMSG_OUT + 00));
3149 
3150 		WRW_HARPOON((port + SYNC_MSGS + 8), (RAT_OP));
3151 		WRW_HARPOON((port + SYNC_MSGS + 10),
3152 			    (MPM_OP + AMSG_OUT + DEFAULT_OFFSET));
3153 		WRW_HARPOON((port + SYNC_MSGS + 12), (BRH_OP + ALWAYS + NP));
3154 
3155 		if (syncFlag == 0) {
3156 			WR_HARPOON(port + hp_autostart_3,
3157 				   (SELECT + SELCHK_STRT));
3158 			currTar_Info->TarStatus =
3159 			    ((currTar_Info->
3160 			      TarStatus & ~(unsigned char)TAR_SYNC_MASK) |
3161 			     (unsigned char)SYNC_TRYING);
3162 		} else {
3163 			WR_HARPOON(port + hp_autostart_3,
3164 				   (AUTO_IMMED + CMD_ONLY_STRT));
3165 		}
3166 
3167 		return 1;
3168 	}
3169 
3170 	else {
3171 
3172 		currTar_Info->TarStatus |= (unsigned char)SYNC_SUPPORTED;
3173 		currTar_Info->TarEEValue &= ~EE_SYNC_MASK;
3174 		return 0;
3175 	}
3176 }
3177 
3178 /*---------------------------------------------------------------------
3179  *
3180  * Function: FPT_stsyncn
3181  *
3182  * Description: The has sent us a Sync Nego message so handle it as
3183  *              necessary.
3184  *
3185  *---------------------------------------------------------------------*/
FPT_stsyncn(u32 port,unsigned char p_card)3186 static void FPT_stsyncn(u32 port, unsigned char p_card)
3187 {
3188 	unsigned char sync_msg, offset, sync_reg, our_sync_msg;
3189 	struct sccb *currSCCB;
3190 	struct sccb_mgr_tar_info *currTar_Info;
3191 
3192 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
3193 	currTar_Info = &FPT_sccbMgrTbl[p_card][currSCCB->TargID];
3194 
3195 	sync_msg = FPT_sfm(port, currSCCB);
3196 
3197 	if ((sync_msg == 0x00) && (currSCCB->Sccb_scsimsg == MSG_PARITY_ERROR)) {
3198 		WR_HARPOON(port + hp_autostart_1,
3199 			   (AUTO_IMMED + DISCONNECT_START));
3200 		return;
3201 	}
3202 
3203 	ACCEPT_MSG(port);
3204 
3205 	offset = FPT_sfm(port, currSCCB);
3206 
3207 	if ((offset == 0x00) && (currSCCB->Sccb_scsimsg == MSG_PARITY_ERROR)) {
3208 		WR_HARPOON(port + hp_autostart_1,
3209 			   (AUTO_IMMED + DISCONNECT_START));
3210 		return;
3211 	}
3212 
3213 	if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_20MB)
3214 
3215 		our_sync_msg = 12;	/* Setup our Message to 20mb/s */
3216 
3217 	else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_10MB)
3218 
3219 		our_sync_msg = 25;	/* Setup our Message to 10mb/s */
3220 
3221 	else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_5MB)
3222 
3223 		our_sync_msg = 50;	/* Setup our Message to 5mb/s */
3224 	else
3225 
3226 		our_sync_msg = 0;	/* Message = Async */
3227 
3228 	if (sync_msg < our_sync_msg) {
3229 		sync_msg = our_sync_msg;	/*if faster, then set to max. */
3230 	}
3231 
3232 	if (offset == ASYNC)
3233 		sync_msg = ASYNC;
3234 
3235 	if (offset > MAX_OFFSET)
3236 		offset = MAX_OFFSET;
3237 
3238 	sync_reg = 0x00;
3239 
3240 	if (sync_msg > 12)
3241 
3242 		sync_reg = 0x20;	/* Use 10MB/s */
3243 
3244 	if (sync_msg > 25)
3245 
3246 		sync_reg = 0x40;	/* Use 6.6MB/s */
3247 
3248 	if (sync_msg > 38)
3249 
3250 		sync_reg = 0x60;	/* Use 5MB/s */
3251 
3252 	if (sync_msg > 50)
3253 
3254 		sync_reg = 0x80;	/* Use 4MB/s */
3255 
3256 	if (sync_msg > 62)
3257 
3258 		sync_reg = 0xA0;	/* Use 3.33MB/s */
3259 
3260 	if (sync_msg > 75)
3261 
3262 		sync_reg = 0xC0;	/* Use 2.85MB/s */
3263 
3264 	if (sync_msg > 87)
3265 
3266 		sync_reg = 0xE0;	/* Use 2.5MB/s */
3267 
3268 	if (sync_msg > 100) {
3269 
3270 		sync_reg = 0x00;	/* Use ASYNC */
3271 		offset = 0x00;
3272 	}
3273 
3274 	if (currTar_Info->TarStatus & WIDE_ENABLED)
3275 
3276 		sync_reg |= offset;
3277 
3278 	else
3279 
3280 		sync_reg |= (offset | NARROW_SCSI);
3281 
3282 	FPT_sssyncv(port, currSCCB->TargID, sync_reg, currTar_Info);
3283 
3284 	if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
3285 
3286 		ACCEPT_MSG(port);
3287 
3288 		currTar_Info->TarStatus = ((currTar_Info->TarStatus &
3289 					    ~(unsigned char)TAR_SYNC_MASK) |
3290 					   (unsigned char)SYNC_SUPPORTED);
3291 
3292 		WR_HARPOON(port + hp_autostart_1,
3293 			   (AUTO_IMMED + DISCONNECT_START));
3294 	}
3295 
3296 	else {
3297 
3298 		ACCEPT_MSG_ATN(port);
3299 
3300 		FPT_sisyncr(port, sync_msg, offset);
3301 
3302 		currTar_Info->TarStatus = ((currTar_Info->TarStatus &
3303 					    ~(unsigned char)TAR_SYNC_MASK) |
3304 					   (unsigned char)SYNC_SUPPORTED);
3305 	}
3306 }
3307 
3308 /*---------------------------------------------------------------------
3309  *
3310  * Function: FPT_sisyncr
3311  *
3312  * Description: Answer the targets sync message.
3313  *
3314  *---------------------------------------------------------------------*/
FPT_sisyncr(u32 port,unsigned char sync_pulse,unsigned char offset)3315 static void FPT_sisyncr(u32 port, unsigned char sync_pulse,
3316 			unsigned char offset)
3317 {
3318 	ARAM_ACCESS(port);
3319 	WRW_HARPOON((port + SYNC_MSGS + 0),
3320 		    (MPM_OP + AMSG_OUT + EXTENDED_MESSAGE));
3321 	WRW_HARPOON((port + SYNC_MSGS + 2), (MPM_OP + AMSG_OUT + 0x03));
3322 	WRW_HARPOON((port + SYNC_MSGS + 4),
3323 		    (MPM_OP + AMSG_OUT + EXTENDED_SDTR));
3324 	WRW_HARPOON((port + SYNC_MSGS + 6), (MPM_OP + AMSG_OUT + sync_pulse));
3325 	WRW_HARPOON((port + SYNC_MSGS + 8), (RAT_OP));
3326 	WRW_HARPOON((port + SYNC_MSGS + 10), (MPM_OP + AMSG_OUT + offset));
3327 	WRW_HARPOON((port + SYNC_MSGS + 12), (BRH_OP + ALWAYS + NP));
3328 	SGRAM_ACCESS(port);
3329 
3330 	WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
3331 	WRW_HARPOON((port + hp_intstat), CLR_ALL_INT_1);
3332 
3333 	WR_HARPOON(port + hp_autostart_3, (AUTO_IMMED + CMD_ONLY_STRT));
3334 
3335 	while (!(RDW_HARPOON((port + hp_intstat)) & (BUS_FREE | AUTO_INT))) {
3336 	}
3337 }
3338 
3339 /*---------------------------------------------------------------------
3340  *
3341  * Function: FPT_siwidn
3342  *
3343  * Description: Read in a message byte from the SCSI bus, and check
3344  *              for a parity error.
3345  *
3346  *---------------------------------------------------------------------*/
3347 
FPT_siwidn(u32 port,unsigned char p_card)3348 static unsigned char FPT_siwidn(u32 port, unsigned char p_card)
3349 {
3350 	struct sccb *currSCCB;
3351 	struct sccb_mgr_tar_info *currTar_Info;
3352 
3353 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
3354 	currTar_Info = &FPT_sccbMgrTbl[p_card][currSCCB->TargID];
3355 
3356 	if (!((currTar_Info->TarStatus & TAR_WIDE_MASK) == WIDE_NEGOCIATED)) {
3357 
3358 		WRW_HARPOON((port + ID_MSG_STRT),
3359 			    (MPM_OP + AMSG_OUT +
3360 			     (currSCCB->
3361 			      Sccb_idmsg & ~(unsigned char)DISC_PRIV)));
3362 
3363 		WRW_HARPOON((port + ID_MSG_STRT + 2), BRH_OP + ALWAYS + CMDPZ);
3364 
3365 		WRW_HARPOON((port + SYNC_MSGS + 0),
3366 			    (MPM_OP + AMSG_OUT + EXTENDED_MESSAGE));
3367 		WRW_HARPOON((port + SYNC_MSGS + 2), (MPM_OP + AMSG_OUT + 0x02));
3368 		WRW_HARPOON((port + SYNC_MSGS + 4),
3369 			    (MPM_OP + AMSG_OUT + EXTENDED_WDTR));
3370 		WRW_HARPOON((port + SYNC_MSGS + 6), (RAT_OP));
3371 		WRW_HARPOON((port + SYNC_MSGS + 8),
3372 			    (MPM_OP + AMSG_OUT + SM16BIT));
3373 		WRW_HARPOON((port + SYNC_MSGS + 10), (BRH_OP + ALWAYS + NP));
3374 
3375 		WR_HARPOON(port + hp_autostart_3, (SELECT + SELCHK_STRT));
3376 
3377 		currTar_Info->TarStatus = ((currTar_Info->TarStatus &
3378 					    ~(unsigned char)TAR_WIDE_MASK) |
3379 					   (unsigned char)WIDE_ENABLED);
3380 
3381 		return 1;
3382 	}
3383 
3384 	else {
3385 
3386 		currTar_Info->TarStatus = ((currTar_Info->TarStatus &
3387 					    ~(unsigned char)TAR_WIDE_MASK) |
3388 					   WIDE_NEGOCIATED);
3389 
3390 		currTar_Info->TarEEValue &= ~EE_WIDE_SCSI;
3391 		return 0;
3392 	}
3393 }
3394 
3395 /*---------------------------------------------------------------------
3396  *
3397  * Function: FPT_stwidn
3398  *
3399  * Description: The has sent us a Wide Nego message so handle it as
3400  *              necessary.
3401  *
3402  *---------------------------------------------------------------------*/
FPT_stwidn(u32 port,unsigned char p_card)3403 static void FPT_stwidn(u32 port, unsigned char p_card)
3404 {
3405 	unsigned char width;
3406 	struct sccb *currSCCB;
3407 	struct sccb_mgr_tar_info *currTar_Info;
3408 
3409 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
3410 	currTar_Info = &FPT_sccbMgrTbl[p_card][currSCCB->TargID];
3411 
3412 	width = FPT_sfm(port, currSCCB);
3413 
3414 	if ((width == 0x00) && (currSCCB->Sccb_scsimsg == MSG_PARITY_ERROR)) {
3415 		WR_HARPOON(port + hp_autostart_1,
3416 			   (AUTO_IMMED + DISCONNECT_START));
3417 		return;
3418 	}
3419 
3420 	if (!(currTar_Info->TarEEValue & EE_WIDE_SCSI))
3421 		width = 0;
3422 
3423 	if (width) {
3424 		currTar_Info->TarStatus |= WIDE_ENABLED;
3425 		width = 0;
3426 	} else {
3427 		width = NARROW_SCSI;
3428 		currTar_Info->TarStatus &= ~WIDE_ENABLED;
3429 	}
3430 
3431 	FPT_sssyncv(port, currSCCB->TargID, width, currTar_Info);
3432 
3433 	if (currSCCB->Sccb_scsistat == SELECT_WN_ST) {
3434 
3435 		currTar_Info->TarStatus |= WIDE_NEGOCIATED;
3436 
3437 		if (!
3438 		    ((currTar_Info->TarStatus & TAR_SYNC_MASK) ==
3439 		     SYNC_SUPPORTED)) {
3440 			ACCEPT_MSG_ATN(port);
3441 			ARAM_ACCESS(port);
3442 			FPT_sisyncn(port, p_card, 1);
3443 			currSCCB->Sccb_scsistat = SELECT_SN_ST;
3444 			SGRAM_ACCESS(port);
3445 		} else {
3446 			ACCEPT_MSG(port);
3447 			WR_HARPOON(port + hp_autostart_1,
3448 				   (AUTO_IMMED + DISCONNECT_START));
3449 		}
3450 	}
3451 
3452 	else {
3453 
3454 		ACCEPT_MSG_ATN(port);
3455 
3456 		if (currTar_Info->TarEEValue & EE_WIDE_SCSI)
3457 			width = SM16BIT;
3458 		else
3459 			width = SM8BIT;
3460 
3461 		FPT_siwidr(port, width);
3462 
3463 		currTar_Info->TarStatus |= (WIDE_NEGOCIATED | WIDE_ENABLED);
3464 	}
3465 }
3466 
3467 /*---------------------------------------------------------------------
3468  *
3469  * Function: FPT_siwidr
3470  *
3471  * Description: Answer the targets Wide nego message.
3472  *
3473  *---------------------------------------------------------------------*/
FPT_siwidr(u32 port,unsigned char width)3474 static void FPT_siwidr(u32 port, unsigned char width)
3475 {
3476 	ARAM_ACCESS(port);
3477 	WRW_HARPOON((port + SYNC_MSGS + 0),
3478 		    (MPM_OP + AMSG_OUT + EXTENDED_MESSAGE));
3479 	WRW_HARPOON((port + SYNC_MSGS + 2), (MPM_OP + AMSG_OUT + 0x02));
3480 	WRW_HARPOON((port + SYNC_MSGS + 4),
3481 		    (MPM_OP + AMSG_OUT + EXTENDED_WDTR));
3482 	WRW_HARPOON((port + SYNC_MSGS + 6), (RAT_OP));
3483 	WRW_HARPOON((port + SYNC_MSGS + 8), (MPM_OP + AMSG_OUT + width));
3484 	WRW_HARPOON((port + SYNC_MSGS + 10), (BRH_OP + ALWAYS + NP));
3485 	SGRAM_ACCESS(port);
3486 
3487 	WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
3488 	WRW_HARPOON((port + hp_intstat), CLR_ALL_INT_1);
3489 
3490 	WR_HARPOON(port + hp_autostart_3, (AUTO_IMMED + CMD_ONLY_STRT));
3491 
3492 	while (!(RDW_HARPOON((port + hp_intstat)) & (BUS_FREE | AUTO_INT))) {
3493 	}
3494 }
3495 
3496 /*---------------------------------------------------------------------
3497  *
3498  * Function: FPT_sssyncv
3499  *
3500  * Description: Write the desired value to the Sync Register for the
3501  *              ID specified.
3502  *
3503  *---------------------------------------------------------------------*/
FPT_sssyncv(u32 p_port,unsigned char p_id,unsigned char p_sync_value,struct sccb_mgr_tar_info * currTar_Info)3504 static void FPT_sssyncv(u32 p_port, unsigned char p_id,
3505 			unsigned char p_sync_value,
3506 			struct sccb_mgr_tar_info *currTar_Info)
3507 {
3508 	unsigned char index;
3509 
3510 	index = p_id;
3511 
3512 	switch (index) {
3513 
3514 	case 0:
3515 		index = 12;	/* hp_synctarg_0 */
3516 		break;
3517 	case 1:
3518 		index = 13;	/* hp_synctarg_1 */
3519 		break;
3520 	case 2:
3521 		index = 14;	/* hp_synctarg_2 */
3522 		break;
3523 	case 3:
3524 		index = 15;	/* hp_synctarg_3 */
3525 		break;
3526 	case 4:
3527 		index = 8;	/* hp_synctarg_4 */
3528 		break;
3529 	case 5:
3530 		index = 9;	/* hp_synctarg_5 */
3531 		break;
3532 	case 6:
3533 		index = 10;	/* hp_synctarg_6 */
3534 		break;
3535 	case 7:
3536 		index = 11;	/* hp_synctarg_7 */
3537 		break;
3538 	case 8:
3539 		index = 4;	/* hp_synctarg_8 */
3540 		break;
3541 	case 9:
3542 		index = 5;	/* hp_synctarg_9 */
3543 		break;
3544 	case 10:
3545 		index = 6;	/* hp_synctarg_10 */
3546 		break;
3547 	case 11:
3548 		index = 7;	/* hp_synctarg_11 */
3549 		break;
3550 	case 12:
3551 		index = 0;	/* hp_synctarg_12 */
3552 		break;
3553 	case 13:
3554 		index = 1;	/* hp_synctarg_13 */
3555 		break;
3556 	case 14:
3557 		index = 2;	/* hp_synctarg_14 */
3558 		break;
3559 	case 15:
3560 		index = 3;	/* hp_synctarg_15 */
3561 
3562 	}
3563 
3564 	WR_HARPOON(p_port + hp_synctarg_base + index, p_sync_value);
3565 
3566 	currTar_Info->TarSyncCtrl = p_sync_value;
3567 }
3568 
3569 /*---------------------------------------------------------------------
3570  *
3571  * Function: FPT_sresb
3572  *
3573  * Description: Reset the desired card's SCSI bus.
3574  *
3575  *---------------------------------------------------------------------*/
FPT_sresb(u32 port,unsigned char p_card)3576 static void FPT_sresb(u32 port, unsigned char p_card)
3577 {
3578 	unsigned char scsiID, i;
3579 
3580 	struct sccb_mgr_tar_info *currTar_Info;
3581 
3582 	WR_HARPOON(port + hp_page_ctrl,
3583 		   (RD_HARPOON(port + hp_page_ctrl) | G_INT_DISABLE));
3584 	WRW_HARPOON((port + hp_intstat), CLR_ALL_INT);
3585 
3586 	WR_HARPOON(port + hp_scsictrl_0, SCSI_RST);
3587 
3588 	scsiID = RD_HARPOON(port + hp_seltimeout);
3589 	WR_HARPOON(port + hp_seltimeout, TO_5ms);
3590 	WRW_HARPOON((port + hp_intstat), TIMEOUT);
3591 
3592 	WR_HARPOON(port + hp_portctrl_0, (SCSI_PORT | START_TO));
3593 
3594 	while (!(RDW_HARPOON((port + hp_intstat)) & TIMEOUT)) {
3595 	}
3596 
3597 	WR_HARPOON(port + hp_seltimeout, scsiID);
3598 
3599 	WR_HARPOON(port + hp_scsictrl_0, ENA_SCAM_SEL);
3600 
3601 	FPT_Wait(port, TO_5ms);
3602 
3603 	WRW_HARPOON((port + hp_intstat), CLR_ALL_INT);
3604 
3605 	WR_HARPOON(port + hp_int_mask, (RD_HARPOON(port + hp_int_mask) | 0x00));
3606 
3607 	for (scsiID = 0; scsiID < MAX_SCSI_TAR; scsiID++) {
3608 		currTar_Info = &FPT_sccbMgrTbl[p_card][scsiID];
3609 
3610 		if (currTar_Info->TarEEValue & EE_SYNC_MASK) {
3611 			currTar_Info->TarSyncCtrl = 0;
3612 			currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
3613 		}
3614 
3615 		if (currTar_Info->TarEEValue & EE_WIDE_SCSI) {
3616 			currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
3617 		}
3618 
3619 		FPT_sssyncv(port, scsiID, NARROW_SCSI, currTar_Info);
3620 
3621 		FPT_SccbMgrTableInitTarget(p_card, scsiID);
3622 	}
3623 
3624 	FPT_BL_Card[p_card].scanIndex = 0x00;
3625 	FPT_BL_Card[p_card].currentSCCB = NULL;
3626 	FPT_BL_Card[p_card].globalFlags &= ~(F_TAG_STARTED | F_HOST_XFER_ACT
3627 					     | F_NEW_SCCB_CMD);
3628 	FPT_BL_Card[p_card].cmdCounter = 0x00;
3629 	FPT_BL_Card[p_card].discQCount = 0x00;
3630 	FPT_BL_Card[p_card].tagQ_Lst = 0x01;
3631 
3632 	for (i = 0; i < QUEUE_DEPTH; i++)
3633 		FPT_BL_Card[p_card].discQ_Tbl[i] = NULL;
3634 
3635 	WR_HARPOON(port + hp_page_ctrl,
3636 		   (RD_HARPOON(port + hp_page_ctrl) & ~G_INT_DISABLE));
3637 
3638 }
3639 
3640 /*---------------------------------------------------------------------
3641  *
3642  * Function: FPT_ssenss
3643  *
3644  * Description: Setup for the Auto Sense command.
3645  *
3646  *---------------------------------------------------------------------*/
FPT_ssenss(struct sccb_card * pCurrCard)3647 static void FPT_ssenss(struct sccb_card *pCurrCard)
3648 {
3649 	unsigned char i;
3650 	struct sccb *currSCCB;
3651 
3652 	currSCCB = pCurrCard->currentSCCB;
3653 
3654 	currSCCB->Save_CdbLen = currSCCB->CdbLength;
3655 
3656 	for (i = 0; i < 6; i++) {
3657 
3658 		currSCCB->Save_Cdb[i] = currSCCB->Cdb[i];
3659 	}
3660 
3661 	currSCCB->CdbLength = SIX_BYTE_CMD;
3662 	currSCCB->Cdb[0] = REQUEST_SENSE;
3663 	currSCCB->Cdb[1] = currSCCB->Cdb[1] & (unsigned char)0xE0;	/*Keep LUN. */
3664 	currSCCB->Cdb[2] = 0x00;
3665 	currSCCB->Cdb[3] = 0x00;
3666 	currSCCB->Cdb[4] = currSCCB->RequestSenseLength;
3667 	currSCCB->Cdb[5] = 0x00;
3668 
3669 	currSCCB->Sccb_XferCnt = (u32)currSCCB->RequestSenseLength;
3670 
3671 	currSCCB->Sccb_ATC = 0x00;
3672 
3673 	currSCCB->Sccb_XferState |= F_AUTO_SENSE;
3674 
3675 	currSCCB->Sccb_XferState &= ~F_SG_XFER;
3676 
3677 	currSCCB->Sccb_idmsg = currSCCB->Sccb_idmsg & ~(unsigned char)DISC_PRIV;
3678 
3679 	currSCCB->ControlByte = 0x00;
3680 
3681 	currSCCB->Sccb_MGRFlags &= F_STATUSLOADED;
3682 }
3683 
3684 /*---------------------------------------------------------------------
3685  *
3686  * Function: FPT_sxfrp
3687  *
3688  * Description: Transfer data into the bit bucket until the device
3689  *              decides to switch phase.
3690  *
3691  *---------------------------------------------------------------------*/
3692 
FPT_sxfrp(u32 p_port,unsigned char p_card)3693 static void FPT_sxfrp(u32 p_port, unsigned char p_card)
3694 {
3695 	unsigned char curr_phz;
3696 
3697 	DISABLE_AUTO(p_port);
3698 
3699 	if (FPT_BL_Card[p_card].globalFlags & F_HOST_XFER_ACT) {
3700 
3701 		FPT_hostDataXferAbort(p_port, p_card,
3702 				      FPT_BL_Card[p_card].currentSCCB);
3703 
3704 	}
3705 
3706 	/* If the Automation handled the end of the transfer then do not
3707 	   match the phase or we will get out of sync with the ISR.       */
3708 
3709 	if (RDW_HARPOON((p_port + hp_intstat)) &
3710 	    (BUS_FREE | XFER_CNT_0 | AUTO_INT))
3711 		return;
3712 
3713 	WR_HARPOON(p_port + hp_xfercnt_0, 0x00);
3714 
3715 	curr_phz = RD_HARPOON(p_port + hp_scsisig) & (unsigned char)S_SCSI_PHZ;
3716 
3717 	WRW_HARPOON((p_port + hp_intstat), XFER_CNT_0);
3718 
3719 	WR_HARPOON(p_port + hp_scsisig, curr_phz);
3720 
3721 	while (!(RDW_HARPOON((p_port + hp_intstat)) & (BUS_FREE | RESET)) &&
3722 	       (curr_phz ==
3723 		(RD_HARPOON(p_port + hp_scsisig) & (unsigned char)S_SCSI_PHZ)))
3724 	{
3725 		if (curr_phz & (unsigned char)SCSI_IOBIT) {
3726 			WR_HARPOON(p_port + hp_portctrl_0,
3727 				   (SCSI_PORT | HOST_PORT | SCSI_INBIT));
3728 
3729 			if (!(RD_HARPOON(p_port + hp_xferstat) & FIFO_EMPTY)) {
3730 				RD_HARPOON(p_port + hp_fifodata_0);
3731 			}
3732 		} else {
3733 			WR_HARPOON(p_port + hp_portctrl_0,
3734 				   (SCSI_PORT | HOST_PORT | HOST_WRT));
3735 			if (RD_HARPOON(p_port + hp_xferstat) & FIFO_EMPTY) {
3736 				WR_HARPOON(p_port + hp_fifodata_0, 0xFA);
3737 			}
3738 		}
3739 	}			/* End of While loop for padding data I/O phase */
3740 
3741 	while (!(RDW_HARPOON((p_port + hp_intstat)) & (BUS_FREE | RESET))) {
3742 		if (RD_HARPOON(p_port + hp_scsisig) & SCSI_REQ)
3743 			break;
3744 	}
3745 
3746 	WR_HARPOON(p_port + hp_portctrl_0,
3747 		   (SCSI_PORT | HOST_PORT | SCSI_INBIT));
3748 	while (!(RD_HARPOON(p_port + hp_xferstat) & FIFO_EMPTY)) {
3749 		RD_HARPOON(p_port + hp_fifodata_0);
3750 	}
3751 
3752 	if (!(RDW_HARPOON((p_port + hp_intstat)) & (BUS_FREE | RESET))) {
3753 		WR_HARPOON(p_port + hp_autostart_0,
3754 			   (AUTO_IMMED + DISCONNECT_START));
3755 		while (!(RDW_HARPOON((p_port + hp_intstat)) & AUTO_INT)) {
3756 		}
3757 
3758 		if (RDW_HARPOON((p_port + hp_intstat)) &
3759 		    (ICMD_COMP | ITAR_DISC))
3760 			while (!
3761 			       (RDW_HARPOON((p_port + hp_intstat)) &
3762 				(BUS_FREE | RSEL))) ;
3763 	}
3764 }
3765 
3766 /*---------------------------------------------------------------------
3767  *
3768  * Function: FPT_schkdd
3769  *
3770  * Description: Make sure data has been flushed from both FIFOs and abort
3771  *              the operations if necessary.
3772  *
3773  *---------------------------------------------------------------------*/
3774 
FPT_schkdd(u32 port,unsigned char p_card)3775 static void FPT_schkdd(u32 port, unsigned char p_card)
3776 {
3777 	unsigned short TimeOutLoop;
3778 	unsigned char sPhase;
3779 
3780 	struct sccb *currSCCB;
3781 
3782 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
3783 
3784 	if ((currSCCB->Sccb_scsistat != DATA_OUT_ST) &&
3785 	    (currSCCB->Sccb_scsistat != DATA_IN_ST)) {
3786 		return;
3787 	}
3788 
3789 	if (currSCCB->Sccb_XferState & F_ODD_BALL_CNT) {
3790 
3791 		currSCCB->Sccb_ATC += (currSCCB->Sccb_XferCnt - 1);
3792 
3793 		currSCCB->Sccb_XferCnt = 1;
3794 
3795 		currSCCB->Sccb_XferState &= ~F_ODD_BALL_CNT;
3796 		WRW_HARPOON((port + hp_fiforead), (unsigned short)0x00);
3797 		WR_HARPOON(port + hp_xferstat, 0x00);
3798 	}
3799 
3800 	else {
3801 
3802 		currSCCB->Sccb_ATC += currSCCB->Sccb_XferCnt;
3803 
3804 		currSCCB->Sccb_XferCnt = 0;
3805 	}
3806 
3807 	if ((RDW_HARPOON((port + hp_intstat)) & PARITY) &&
3808 	    (currSCCB->HostStatus == SCCB_COMPLETE)) {
3809 
3810 		currSCCB->HostStatus = SCCB_PARITY_ERR;
3811 		WRW_HARPOON((port + hp_intstat), PARITY);
3812 	}
3813 
3814 	FPT_hostDataXferAbort(port, p_card, currSCCB);
3815 
3816 	while (RD_HARPOON(port + hp_scsisig) & SCSI_ACK) {
3817 	}
3818 
3819 	TimeOutLoop = 0;
3820 
3821 	while (RD_HARPOON(port + hp_xferstat) & FIFO_EMPTY) {
3822 		if (RDW_HARPOON((port + hp_intstat)) & BUS_FREE) {
3823 			return;
3824 		}
3825 		if (RD_HARPOON(port + hp_offsetctr) & (unsigned char)0x1F) {
3826 			break;
3827 		}
3828 		if (RDW_HARPOON((port + hp_intstat)) & RESET) {
3829 			return;
3830 		}
3831 		if ((RD_HARPOON(port + hp_scsisig) & SCSI_REQ)
3832 		    || (TimeOutLoop++ > 0x3000))
3833 			break;
3834 	}
3835 
3836 	sPhase = RD_HARPOON(port + hp_scsisig) & (SCSI_BSY | S_SCSI_PHZ);
3837 	if ((!(RD_HARPOON(port + hp_xferstat) & FIFO_EMPTY)) ||
3838 	    (RD_HARPOON(port + hp_offsetctr) & (unsigned char)0x1F) ||
3839 	    (sPhase == (SCSI_BSY | S_DATAO_PH)) ||
3840 	    (sPhase == (SCSI_BSY | S_DATAI_PH))) {
3841 
3842 		WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
3843 
3844 		if (!(currSCCB->Sccb_XferState & F_ALL_XFERRED)) {
3845 			if (currSCCB->Sccb_XferState & F_HOST_XFER_DIR) {
3846 				FPT_phaseDataIn(port, p_card);
3847 			}
3848 
3849 			else {
3850 				FPT_phaseDataOut(port, p_card);
3851 			}
3852 		} else {
3853 			FPT_sxfrp(port, p_card);
3854 			if (!(RDW_HARPOON((port + hp_intstat)) &
3855 			      (BUS_FREE | ICMD_COMP | ITAR_DISC | RESET))) {
3856 				WRW_HARPOON((port + hp_intstat), AUTO_INT);
3857 				FPT_phaseDecode(port, p_card);
3858 			}
3859 		}
3860 
3861 	}
3862 
3863 	else {
3864 		WR_HARPOON(port + hp_portctrl_0, 0x00);
3865 	}
3866 }
3867 
3868 /*---------------------------------------------------------------------
3869  *
3870  * Function: FPT_sinits
3871  *
3872  * Description: Setup SCCB manager fields in this SCCB.
3873  *
3874  *---------------------------------------------------------------------*/
3875 
FPT_sinits(struct sccb * p_sccb,unsigned char p_card)3876 static void FPT_sinits(struct sccb *p_sccb, unsigned char p_card)
3877 {
3878 	struct sccb_mgr_tar_info *currTar_Info;
3879 
3880 	if ((p_sccb->TargID >= MAX_SCSI_TAR) || (p_sccb->Lun >= MAX_LUN)) {
3881 		return;
3882 	}
3883 	currTar_Info = &FPT_sccbMgrTbl[p_card][p_sccb->TargID];
3884 
3885 	p_sccb->Sccb_XferState = 0x00;
3886 	p_sccb->Sccb_XferCnt = p_sccb->DataLength;
3887 
3888 	if ((p_sccb->OperationCode == SCATTER_GATHER_COMMAND) ||
3889 	    (p_sccb->OperationCode == RESIDUAL_SG_COMMAND)) {
3890 
3891 		p_sccb->Sccb_SGoffset = 0;
3892 		p_sccb->Sccb_XferState = F_SG_XFER;
3893 		p_sccb->Sccb_XferCnt = 0x00;
3894 	}
3895 
3896 	if (p_sccb->DataLength == 0x00)
3897 
3898 		p_sccb->Sccb_XferState |= F_ALL_XFERRED;
3899 
3900 	if (p_sccb->ControlByte & F_USE_CMD_Q) {
3901 		if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_REJECT)
3902 			p_sccb->ControlByte &= ~F_USE_CMD_Q;
3903 
3904 		else
3905 			currTar_Info->TarStatus |= TAG_Q_TRYING;
3906 	}
3907 
3908 /*      For !single SCSI device in system  & device allow Disconnect
3909 	or command is tag_q type then send Cmd with Disconnect Enable
3910 	else send Cmd with Disconnect Disable */
3911 
3912 /*
3913    if (((!(FPT_BL_Card[p_card].globalFlags & F_SINGLE_DEVICE)) &&
3914       (currTar_Info->TarStatus & TAR_ALLOW_DISC)) ||
3915       (currTar_Info->TarStatus & TAG_Q_TRYING)) {
3916 */
3917 	if ((currTar_Info->TarStatus & TAR_ALLOW_DISC) ||
3918 	    (currTar_Info->TarStatus & TAG_Q_TRYING)) {
3919 		p_sccb->Sccb_idmsg = IDENTIFY(true, p_sccb->Lun);
3920 	} else {
3921 		p_sccb->Sccb_idmsg = IDENTIFY(false, p_sccb->Lun);
3922 	}
3923 
3924 	p_sccb->HostStatus = 0x00;
3925 	p_sccb->TargetStatus = 0x00;
3926 	p_sccb->Sccb_tag = 0x00;
3927 	p_sccb->Sccb_MGRFlags = 0x00;
3928 	p_sccb->Sccb_sgseg = 0x00;
3929 	p_sccb->Sccb_ATC = 0x00;
3930 	p_sccb->Sccb_savedATC = 0x00;
3931 /*
3932    p_sccb->SccbVirtDataPtr    = 0x00;
3933    p_sccb->Sccb_forwardlink   = NULL;
3934    p_sccb->Sccb_backlink      = NULL;
3935  */
3936 	p_sccb->Sccb_scsistat = BUS_FREE_ST;
3937 	p_sccb->SccbStatus = SCCB_IN_PROCESS;
3938 	p_sccb->Sccb_scsimsg = NOP;
3939 
3940 }
3941 
3942 /*---------------------------------------------------------------------
3943  *
3944  * Function: Phase Decode
3945  *
3946  * Description: Determine the phase and call the appropriate function.
3947  *
3948  *---------------------------------------------------------------------*/
3949 
FPT_phaseDecode(u32 p_port,unsigned char p_card)3950 static void FPT_phaseDecode(u32 p_port, unsigned char p_card)
3951 {
3952 	unsigned char phase_ref;
3953 	void (*phase) (u32, unsigned char);
3954 
3955 	DISABLE_AUTO(p_port);
3956 
3957 	phase_ref =
3958 	    (unsigned char)(RD_HARPOON(p_port + hp_scsisig) & S_SCSI_PHZ);
3959 
3960 	phase = FPT_s_PhaseTbl[phase_ref];
3961 
3962 	(*phase) (p_port, p_card);	/* Call the correct phase func */
3963 }
3964 
3965 /*---------------------------------------------------------------------
3966  *
3967  * Function: Data Out Phase
3968  *
3969  * Description: Start up both the BusMaster and Xbow.
3970  *
3971  *---------------------------------------------------------------------*/
3972 
FPT_phaseDataOut(u32 port,unsigned char p_card)3973 static void FPT_phaseDataOut(u32 port, unsigned char p_card)
3974 {
3975 
3976 	struct sccb *currSCCB;
3977 
3978 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
3979 	if (currSCCB == NULL) {
3980 		return;		/* Exit if No SCCB record */
3981 	}
3982 
3983 	currSCCB->Sccb_scsistat = DATA_OUT_ST;
3984 	currSCCB->Sccb_XferState &= ~(F_HOST_XFER_DIR | F_NO_DATA_YET);
3985 
3986 	WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
3987 
3988 	WRW_HARPOON((port + hp_intstat), XFER_CNT_0);
3989 
3990 	WR_HARPOON(port + hp_autostart_0, (END_DATA + END_DATA_START));
3991 
3992 	FPT_dataXferProcessor(port, &FPT_BL_Card[p_card]);
3993 
3994 	if (currSCCB->Sccb_XferCnt == 0) {
3995 
3996 		if ((currSCCB->ControlByte & SCCB_DATA_XFER_OUT) &&
3997 		    (currSCCB->HostStatus == SCCB_COMPLETE))
3998 			currSCCB->HostStatus = SCCB_DATA_OVER_RUN;
3999 
4000 		FPT_sxfrp(port, p_card);
4001 		if (!(RDW_HARPOON((port + hp_intstat)) & (BUS_FREE | RESET)))
4002 			FPT_phaseDecode(port, p_card);
4003 	}
4004 }
4005 
4006 /*---------------------------------------------------------------------
4007  *
4008  * Function: Data In Phase
4009  *
4010  * Description: Startup the BusMaster and the XBOW.
4011  *
4012  *---------------------------------------------------------------------*/
4013 
FPT_phaseDataIn(u32 port,unsigned char p_card)4014 static void FPT_phaseDataIn(u32 port, unsigned char p_card)
4015 {
4016 
4017 	struct sccb *currSCCB;
4018 
4019 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4020 
4021 	if (currSCCB == NULL) {
4022 		return;		/* Exit if No SCCB record */
4023 	}
4024 
4025 	currSCCB->Sccb_scsistat = DATA_IN_ST;
4026 	currSCCB->Sccb_XferState |= F_HOST_XFER_DIR;
4027 	currSCCB->Sccb_XferState &= ~F_NO_DATA_YET;
4028 
4029 	WR_HARPOON(port + hp_portctrl_0, SCSI_PORT);
4030 
4031 	WRW_HARPOON((port + hp_intstat), XFER_CNT_0);
4032 
4033 	WR_HARPOON(port + hp_autostart_0, (END_DATA + END_DATA_START));
4034 
4035 	FPT_dataXferProcessor(port, &FPT_BL_Card[p_card]);
4036 
4037 	if (currSCCB->Sccb_XferCnt == 0) {
4038 
4039 		if ((currSCCB->ControlByte & SCCB_DATA_XFER_IN) &&
4040 		    (currSCCB->HostStatus == SCCB_COMPLETE))
4041 			currSCCB->HostStatus = SCCB_DATA_OVER_RUN;
4042 
4043 		FPT_sxfrp(port, p_card);
4044 		if (!(RDW_HARPOON((port + hp_intstat)) & (BUS_FREE | RESET)))
4045 			FPT_phaseDecode(port, p_card);
4046 
4047 	}
4048 }
4049 
4050 /*---------------------------------------------------------------------
4051  *
4052  * Function: Command Phase
4053  *
4054  * Description: Load the CDB into the automation and start it up.
4055  *
4056  *---------------------------------------------------------------------*/
4057 
FPT_phaseCommand(u32 p_port,unsigned char p_card)4058 static void FPT_phaseCommand(u32 p_port, unsigned char p_card)
4059 {
4060 	struct sccb *currSCCB;
4061 	u32 cdb_reg;
4062 	unsigned char i;
4063 
4064 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4065 
4066 	if (currSCCB->OperationCode == RESET_COMMAND) {
4067 
4068 		currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
4069 		currSCCB->CdbLength = SIX_BYTE_CMD;
4070 	}
4071 
4072 	WR_HARPOON(p_port + hp_scsisig, 0x00);
4073 
4074 	ARAM_ACCESS(p_port);
4075 
4076 	cdb_reg = p_port + CMD_STRT;
4077 
4078 	for (i = 0; i < currSCCB->CdbLength; i++) {
4079 
4080 		if (currSCCB->OperationCode == RESET_COMMAND)
4081 
4082 			WRW_HARPOON(cdb_reg, (MPM_OP + ACOMMAND + 0x00));
4083 
4084 		else
4085 			WRW_HARPOON(cdb_reg,
4086 				    (MPM_OP + ACOMMAND + currSCCB->Cdb[i]));
4087 		cdb_reg += 2;
4088 	}
4089 
4090 	if (currSCCB->CdbLength != TWELVE_BYTE_CMD)
4091 		WRW_HARPOON(cdb_reg, (BRH_OP + ALWAYS + NP));
4092 
4093 	WR_HARPOON(p_port + hp_portctrl_0, (SCSI_PORT));
4094 
4095 	currSCCB->Sccb_scsistat = COMMAND_ST;
4096 
4097 	WR_HARPOON(p_port + hp_autostart_3, (AUTO_IMMED | CMD_ONLY_STRT));
4098 	SGRAM_ACCESS(p_port);
4099 }
4100 
4101 /*---------------------------------------------------------------------
4102  *
4103  * Function: Status phase
4104  *
4105  * Description: Bring in the status and command complete message bytes
4106  *
4107  *---------------------------------------------------------------------*/
4108 
FPT_phaseStatus(u32 port,unsigned char p_card)4109 static void FPT_phaseStatus(u32 port, unsigned char p_card)
4110 {
4111 	/* Start-up the automation to finish off this command and let the
4112 	   isr handle the interrupt for command complete when it comes in.
4113 	   We could wait here for the interrupt to be generated?
4114 	 */
4115 
4116 	WR_HARPOON(port + hp_scsisig, 0x00);
4117 
4118 	WR_HARPOON(port + hp_autostart_0, (AUTO_IMMED + END_DATA_START));
4119 }
4120 
4121 /*---------------------------------------------------------------------
4122  *
4123  * Function: Phase Message Out
4124  *
4125  * Description: Send out our message (if we have one) and handle whatever
4126  *              else is involed.
4127  *
4128  *---------------------------------------------------------------------*/
4129 
FPT_phaseMsgOut(u32 port,unsigned char p_card)4130 static void FPT_phaseMsgOut(u32 port, unsigned char p_card)
4131 {
4132 	unsigned char message, scsiID;
4133 	struct sccb *currSCCB;
4134 	struct sccb_mgr_tar_info *currTar_Info;
4135 
4136 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4137 
4138 	if (currSCCB != NULL) {
4139 
4140 		message = currSCCB->Sccb_scsimsg;
4141 		scsiID = currSCCB->TargID;
4142 
4143 		if (message == TARGET_RESET) {
4144 
4145 			currTar_Info = &FPT_sccbMgrTbl[p_card][scsiID];
4146 			currTar_Info->TarSyncCtrl = 0;
4147 			FPT_sssyncv(port, scsiID, NARROW_SCSI, currTar_Info);
4148 
4149 			if (FPT_sccbMgrTbl[p_card][scsiID].
4150 			    TarEEValue & EE_SYNC_MASK) {
4151 
4152 				FPT_sccbMgrTbl[p_card][scsiID].TarStatus &=
4153 				    ~TAR_SYNC_MASK;
4154 
4155 			}
4156 
4157 			if (FPT_sccbMgrTbl[p_card][scsiID].
4158 			    TarEEValue & EE_WIDE_SCSI) {
4159 
4160 				FPT_sccbMgrTbl[p_card][scsiID].TarStatus &=
4161 				    ~TAR_WIDE_MASK;
4162 			}
4163 
4164 			FPT_queueFlushSccb(p_card, SCCB_COMPLETE);
4165 			FPT_SccbMgrTableInitTarget(p_card, scsiID);
4166 		} else if (currSCCB->Sccb_scsistat == ABORT_ST) {
4167 			currSCCB->HostStatus = SCCB_COMPLETE;
4168 			if (FPT_BL_Card[p_card].discQ_Tbl[currSCCB->Sccb_tag] !=
4169 			    NULL) {
4170 				FPT_BL_Card[p_card].discQ_Tbl[currSCCB->
4171 							      Sccb_tag] = NULL;
4172 				FPT_sccbMgrTbl[p_card][scsiID].TarTagQ_Cnt--;
4173 			}
4174 
4175 		}
4176 
4177 		else if (currSCCB->Sccb_scsistat < COMMAND_ST) {
4178 
4179 			if (message == NOP) {
4180 				currSCCB->Sccb_MGRFlags |= F_DEV_SELECTED;
4181 
4182 				FPT_ssel(port, p_card);
4183 				return;
4184 			}
4185 		} else {
4186 
4187 			if (message == ABORT_TASK_SET)
4188 
4189 				FPT_queueFlushSccb(p_card, SCCB_COMPLETE);
4190 		}
4191 
4192 	} else {
4193 		message = ABORT_TASK_SET;
4194 	}
4195 
4196 	WRW_HARPOON((port + hp_intstat), (BUS_FREE | PHASE | XFER_CNT_0));
4197 
4198 	WR_HARPOON(port + hp_portctrl_0, SCSI_BUS_EN);
4199 
4200 	WR_HARPOON(port + hp_scsidata_0, message);
4201 
4202 	WR_HARPOON(port + hp_scsisig, (SCSI_ACK + S_ILL_PH));
4203 
4204 	ACCEPT_MSG(port);
4205 
4206 	WR_HARPOON(port + hp_portctrl_0, 0x00);
4207 
4208 	if ((message == ABORT_TASK_SET) || (message == TARGET_RESET) ||
4209 	    (message == ABORT_TASK)) {
4210 
4211 		while (!(RDW_HARPOON((port + hp_intstat)) & (BUS_FREE | PHASE))) {
4212 		}
4213 
4214 		if (RDW_HARPOON((port + hp_intstat)) & BUS_FREE) {
4215 			WRW_HARPOON((port + hp_intstat), BUS_FREE);
4216 
4217 			if (currSCCB != NULL) {
4218 
4219 				if ((FPT_BL_Card[p_card].
4220 				     globalFlags & F_CONLUN_IO)
4221 				    &&
4222 				    ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4223 				      TarStatus & TAR_TAG_Q_MASK) !=
4224 				     TAG_Q_TRYING))
4225 					FPT_sccbMgrTbl[p_card][currSCCB->
4226 							       TargID].
4227 					    TarLUNBusy[currSCCB->Lun] = 0;
4228 				else
4229 					FPT_sccbMgrTbl[p_card][currSCCB->
4230 							       TargID].
4231 					    TarLUNBusy[0] = 0;
4232 
4233 				FPT_queueCmdComplete(&FPT_BL_Card[p_card],
4234 						     currSCCB, p_card);
4235 			}
4236 
4237 			else {
4238 				FPT_BL_Card[p_card].globalFlags |=
4239 				    F_NEW_SCCB_CMD;
4240 			}
4241 		}
4242 
4243 		else {
4244 
4245 			FPT_sxfrp(port, p_card);
4246 		}
4247 	}
4248 
4249 	else {
4250 
4251 		if (message == MSG_PARITY_ERROR) {
4252 			currSCCB->Sccb_scsimsg = NOP;
4253 			WR_HARPOON(port + hp_autostart_1,
4254 				   (AUTO_IMMED + DISCONNECT_START));
4255 		} else {
4256 			FPT_sxfrp(port, p_card);
4257 		}
4258 	}
4259 }
4260 
4261 /*---------------------------------------------------------------------
4262  *
4263  * Function: Message In phase
4264  *
4265  * Description: Bring in the message and determine what to do with it.
4266  *
4267  *---------------------------------------------------------------------*/
4268 
FPT_phaseMsgIn(u32 port,unsigned char p_card)4269 static void FPT_phaseMsgIn(u32 port, unsigned char p_card)
4270 {
4271 	unsigned char message;
4272 	struct sccb *currSCCB;
4273 
4274 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4275 
4276 	if (FPT_BL_Card[p_card].globalFlags & F_HOST_XFER_ACT) {
4277 
4278 		FPT_phaseChkFifo(port, p_card);
4279 	}
4280 
4281 	message = RD_HARPOON(port + hp_scsidata_0);
4282 	if ((message == DISCONNECT) || (message == SAVE_POINTERS)) {
4283 
4284 		WR_HARPOON(port + hp_autostart_1,
4285 			   (AUTO_IMMED + END_DATA_START));
4286 
4287 	}
4288 
4289 	else {
4290 
4291 		message = FPT_sfm(port, currSCCB);
4292 		if (message) {
4293 
4294 			FPT_sdecm(message, port, p_card);
4295 
4296 		} else {
4297 			if (currSCCB->Sccb_scsimsg != MSG_PARITY_ERROR)
4298 				ACCEPT_MSG(port);
4299 			WR_HARPOON(port + hp_autostart_1,
4300 				   (AUTO_IMMED + DISCONNECT_START));
4301 		}
4302 	}
4303 
4304 }
4305 
4306 /*---------------------------------------------------------------------
4307  *
4308  * Function: Illegal phase
4309  *
4310  * Description: Target switched to some illegal phase, so all we can do
4311  *              is report an error back to the host (if that is possible)
4312  *              and send an ABORT message to the misbehaving target.
4313  *
4314  *---------------------------------------------------------------------*/
4315 
FPT_phaseIllegal(u32 port,unsigned char p_card)4316 static void FPT_phaseIllegal(u32 port, unsigned char p_card)
4317 {
4318 	struct sccb *currSCCB;
4319 
4320 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4321 
4322 	WR_HARPOON(port + hp_scsisig, RD_HARPOON(port + hp_scsisig));
4323 	if (currSCCB != NULL) {
4324 
4325 		currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
4326 		currSCCB->Sccb_scsistat = ABORT_ST;
4327 		currSCCB->Sccb_scsimsg = ABORT_TASK_SET;
4328 	}
4329 
4330 	ACCEPT_MSG_ATN(port);
4331 }
4332 
4333 /*---------------------------------------------------------------------
4334  *
4335  * Function: Phase Check FIFO
4336  *
4337  * Description: Make sure data has been flushed from both FIFOs and abort
4338  *              the operations if necessary.
4339  *
4340  *---------------------------------------------------------------------*/
4341 
FPT_phaseChkFifo(u32 port,unsigned char p_card)4342 static void FPT_phaseChkFifo(u32 port, unsigned char p_card)
4343 {
4344 	u32 xfercnt;
4345 	struct sccb *currSCCB;
4346 
4347 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4348 
4349 	if (currSCCB->Sccb_scsistat == DATA_IN_ST) {
4350 
4351 		while ((!(RD_HARPOON(port + hp_xferstat) & FIFO_EMPTY)) &&
4352 		       (RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY)) {
4353 		}
4354 
4355 		if (!(RD_HARPOON(port + hp_xferstat) & FIFO_EMPTY)) {
4356 			currSCCB->Sccb_ATC += currSCCB->Sccb_XferCnt;
4357 
4358 			currSCCB->Sccb_XferCnt = 0;
4359 
4360 			if ((RDW_HARPOON((port + hp_intstat)) & PARITY) &&
4361 			    (currSCCB->HostStatus == SCCB_COMPLETE)) {
4362 				currSCCB->HostStatus = SCCB_PARITY_ERR;
4363 				WRW_HARPOON((port + hp_intstat), PARITY);
4364 			}
4365 
4366 			FPT_hostDataXferAbort(port, p_card, currSCCB);
4367 
4368 			FPT_dataXferProcessor(port, &FPT_BL_Card[p_card]);
4369 
4370 			while ((!(RD_HARPOON(port + hp_xferstat) & FIFO_EMPTY))
4371 			       && (RD_HARPOON(port + hp_ext_status) &
4372 				   BM_CMD_BUSY)) {
4373 			}
4374 
4375 		}
4376 	}
4377 
4378 	/*End Data In specific code. */
4379 	GET_XFER_CNT(port, xfercnt);
4380 
4381 	WR_HARPOON(port + hp_xfercnt_0, 0x00);
4382 
4383 	WR_HARPOON(port + hp_portctrl_0, 0x00);
4384 
4385 	currSCCB->Sccb_ATC += (currSCCB->Sccb_XferCnt - xfercnt);
4386 
4387 	currSCCB->Sccb_XferCnt = xfercnt;
4388 
4389 	if ((RDW_HARPOON((port + hp_intstat)) & PARITY) &&
4390 	    (currSCCB->HostStatus == SCCB_COMPLETE)) {
4391 
4392 		currSCCB->HostStatus = SCCB_PARITY_ERR;
4393 		WRW_HARPOON((port + hp_intstat), PARITY);
4394 	}
4395 
4396 	FPT_hostDataXferAbort(port, p_card, currSCCB);
4397 
4398 	WR_HARPOON(port + hp_fifowrite, 0x00);
4399 	WR_HARPOON(port + hp_fiforead, 0x00);
4400 	WR_HARPOON(port + hp_xferstat, 0x00);
4401 
4402 	WRW_HARPOON((port + hp_intstat), XFER_CNT_0);
4403 }
4404 
4405 /*---------------------------------------------------------------------
4406  *
4407  * Function: Phase Bus Free
4408  *
4409  * Description: We just went bus free so figure out if it was
4410  *              because of command complete or from a disconnect.
4411  *
4412  *---------------------------------------------------------------------*/
FPT_phaseBusFree(u32 port,unsigned char p_card)4413 static void FPT_phaseBusFree(u32 port, unsigned char p_card)
4414 {
4415 	struct sccb *currSCCB;
4416 
4417 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4418 
4419 	if (currSCCB != NULL) {
4420 
4421 		DISABLE_AUTO(port);
4422 
4423 		if (currSCCB->OperationCode == RESET_COMMAND) {
4424 
4425 			if ((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
4426 			    ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4427 			      TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
4428 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4429 				    TarLUNBusy[currSCCB->Lun] = 0;
4430 			else
4431 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4432 				    TarLUNBusy[0] = 0;
4433 
4434 			FPT_queueCmdComplete(&FPT_BL_Card[p_card], currSCCB,
4435 					     p_card);
4436 
4437 			FPT_queueSearchSelect(&FPT_BL_Card[p_card], p_card);
4438 
4439 		}
4440 
4441 		else if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
4442 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarStatus |=
4443 			    (unsigned char)SYNC_SUPPORTED;
4444 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarEEValue &=
4445 			    ~EE_SYNC_MASK;
4446 		}
4447 
4448 		else if (currSCCB->Sccb_scsistat == SELECT_WN_ST) {
4449 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarStatus =
4450 			    (FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4451 			     TarStatus & ~WIDE_ENABLED) | WIDE_NEGOCIATED;
4452 
4453 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarEEValue &=
4454 			    ~EE_WIDE_SCSI;
4455 		}
4456 
4457 		else if (currSCCB->Sccb_scsistat == SELECT_Q_ST) {
4458 			/* Make sure this is not a phony BUS_FREE.  If we were
4459 			   reselected or if BUSY is NOT on then this is a
4460 			   valid BUS FREE.  SRR Wednesday, 5/10/1995.     */
4461 
4462 			if ((!(RD_HARPOON(port + hp_scsisig) & SCSI_BSY)) ||
4463 			    (RDW_HARPOON((port + hp_intstat)) & RSEL)) {
4464 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4465 				    TarStatus &= ~TAR_TAG_Q_MASK;
4466 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4467 				    TarStatus |= TAG_Q_REJECT;
4468 			}
4469 
4470 			else {
4471 				return;
4472 			}
4473 		}
4474 
4475 		else {
4476 
4477 			currSCCB->Sccb_scsistat = BUS_FREE_ST;
4478 
4479 			if (!currSCCB->HostStatus) {
4480 				currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
4481 			}
4482 
4483 			if ((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
4484 			    ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4485 			      TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
4486 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4487 				    TarLUNBusy[currSCCB->Lun] = 0;
4488 			else
4489 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4490 				    TarLUNBusy[0] = 0;
4491 
4492 			FPT_queueCmdComplete(&FPT_BL_Card[p_card], currSCCB,
4493 					     p_card);
4494 			return;
4495 		}
4496 
4497 		FPT_BL_Card[p_card].globalFlags |= F_NEW_SCCB_CMD;
4498 
4499 	}			/*end if !=null */
4500 }
4501 
4502 /*---------------------------------------------------------------------
4503  *
4504  * Function: Auto Load Default Map
4505  *
4506  * Description: Load the Automation RAM with the default map values.
4507  *
4508  *---------------------------------------------------------------------*/
FPT_autoLoadDefaultMap(u32 p_port)4509 static void FPT_autoLoadDefaultMap(u32 p_port)
4510 {
4511 	u32 map_addr;
4512 
4513 	ARAM_ACCESS(p_port);
4514 	map_addr = p_port + hp_aramBase;
4515 
4516 	WRW_HARPOON(map_addr, (MPM_OP + AMSG_OUT + 0xC0));	/*ID MESSAGE */
4517 	map_addr += 2;
4518 	WRW_HARPOON(map_addr, (MPM_OP + AMSG_OUT + 0x20));	/*SIMPLE TAG QUEUEING MSG */
4519 	map_addr += 2;
4520 	WRW_HARPOON(map_addr, RAT_OP);	/*RESET ATTENTION */
4521 	map_addr += 2;
4522 	WRW_HARPOON(map_addr, (MPM_OP + AMSG_OUT + 0x00));	/*TAG ID MSG */
4523 	map_addr += 2;
4524 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 0 */
4525 	map_addr += 2;
4526 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 1 */
4527 	map_addr += 2;
4528 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 2 */
4529 	map_addr += 2;
4530 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 3 */
4531 	map_addr += 2;
4532 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 4 */
4533 	map_addr += 2;
4534 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 5 */
4535 	map_addr += 2;
4536 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 6 */
4537 	map_addr += 2;
4538 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 7 */
4539 	map_addr += 2;
4540 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 8 */
4541 	map_addr += 2;
4542 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 9 */
4543 	map_addr += 2;
4544 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 10 */
4545 	map_addr += 2;
4546 	WRW_HARPOON(map_addr, (MPM_OP + ACOMMAND + 0x00));	/*CDB BYTE 11 */
4547 	map_addr += 2;
4548 	WRW_HARPOON(map_addr, (CPE_OP + ADATA_OUT + DINT));	/*JUMP IF DATA OUT */
4549 	map_addr += 2;
4550 	WRW_HARPOON(map_addr, (TCB_OP + FIFO_0 + DI));	/*JUMP IF NO DATA IN FIFO */
4551 	map_addr += 2;		/*This means AYNC DATA IN */
4552 	WRW_HARPOON(map_addr, (SSI_OP + SSI_IDO_STRT));	/*STOP AND INTERRUPT */
4553 	map_addr += 2;
4554 	WRW_HARPOON(map_addr, (CPE_OP + ADATA_IN + DINT));	/*JUMP IF NOT DATA IN PHZ */
4555 	map_addr += 2;
4556 	WRW_HARPOON(map_addr, (CPN_OP + AMSG_IN + ST));	/*IF NOT MSG IN CHECK 4 DATA IN */
4557 	map_addr += 2;
4558 	WRW_HARPOON(map_addr, (CRD_OP + SDATA + 0x02));	/*SAVE DATA PTR MSG? */
4559 	map_addr += 2;
4560 	WRW_HARPOON(map_addr, (BRH_OP + NOT_EQ + DC));	/*GO CHECK FOR DISCONNECT MSG */
4561 	map_addr += 2;
4562 	WRW_HARPOON(map_addr, (MRR_OP + SDATA + D_AR1));	/*SAVE DATA PTRS MSG */
4563 	map_addr += 2;
4564 	WRW_HARPOON(map_addr, (CPN_OP + AMSG_IN + ST));	/*IF NOT MSG IN CHECK DATA IN */
4565 	map_addr += 2;
4566 	WRW_HARPOON(map_addr, (CRD_OP + SDATA + 0x04));	/*DISCONNECT MSG? */
4567 	map_addr += 2;
4568 	WRW_HARPOON(map_addr, (BRH_OP + NOT_EQ + UNKNWN));	/*UKNKNOWN MSG */
4569 	map_addr += 2;
4570 	WRW_HARPOON(map_addr, (MRR_OP + SDATA + D_BUCKET));	/*XFER DISCONNECT MSG */
4571 	map_addr += 2;
4572 	WRW_HARPOON(map_addr, (SSI_OP + SSI_ITAR_DISC));	/*STOP AND INTERRUPT */
4573 	map_addr += 2;
4574 	WRW_HARPOON(map_addr, (CPN_OP + ASTATUS + UNKNWN));	/*JUMP IF NOT STATUS PHZ. */
4575 	map_addr += 2;
4576 	WRW_HARPOON(map_addr, (MRR_OP + SDATA + D_AR0));	/*GET STATUS BYTE */
4577 	map_addr += 2;
4578 	WRW_HARPOON(map_addr, (CPN_OP + AMSG_IN + CC));	/*ERROR IF NOT MSG IN PHZ */
4579 	map_addr += 2;
4580 	WRW_HARPOON(map_addr, (CRD_OP + SDATA + 0x00));	/*CHECK FOR CMD COMPLETE MSG. */
4581 	map_addr += 2;
4582 	WRW_HARPOON(map_addr, (BRH_OP + NOT_EQ + CC));	/*ERROR IF NOT CMD COMPLETE MSG. */
4583 	map_addr += 2;
4584 	WRW_HARPOON(map_addr, (MRR_OP + SDATA + D_BUCKET));	/*GET CMD COMPLETE MSG */
4585 	map_addr += 2;
4586 	WRW_HARPOON(map_addr, (SSI_OP + SSI_ICMD_COMP));	/*END OF COMMAND */
4587 	map_addr += 2;
4588 
4589 	WRW_HARPOON(map_addr, (SSI_OP + SSI_IUNKWN));	/*RECEIVED UNKNOWN MSG BYTE */
4590 	map_addr += 2;
4591 	WRW_HARPOON(map_addr, (SSI_OP + SSI_INO_CC));	/*NO COMMAND COMPLETE AFTER STATUS */
4592 	map_addr += 2;
4593 	WRW_HARPOON(map_addr, (SSI_OP + SSI_ITICKLE));	/*BIOS Tickled the Mgr */
4594 	map_addr += 2;
4595 	WRW_HARPOON(map_addr, (SSI_OP + SSI_IRFAIL));	/*EXPECTED ID/TAG MESSAGES AND */
4596 	map_addr += 2;		/* DIDN'T GET ONE */
4597 	WRW_HARPOON(map_addr, (CRR_OP + AR3 + S_IDREG));	/* comp SCSI SEL ID & AR3 */
4598 	map_addr += 2;
4599 	WRW_HARPOON(map_addr, (BRH_OP + EQUAL + 0x00));	/*SEL ID OK then Conti. */
4600 	map_addr += 2;
4601 	WRW_HARPOON(map_addr, (SSI_OP + SSI_INO_CC));	/*NO COMMAND COMPLETE AFTER STATUS */
4602 
4603 	SGRAM_ACCESS(p_port);
4604 }
4605 
4606 /*---------------------------------------------------------------------
4607  *
4608  * Function: Auto Command Complete
4609  *
4610  * Description: Post command back to host and find another command
4611  *              to execute.
4612  *
4613  *---------------------------------------------------------------------*/
4614 
FPT_autoCmdCmplt(u32 p_port,unsigned char p_card)4615 static void FPT_autoCmdCmplt(u32 p_port, unsigned char p_card)
4616 {
4617 	struct sccb *currSCCB;
4618 	unsigned char status_byte;
4619 
4620 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
4621 
4622 	status_byte = RD_HARPOON(p_port + hp_gp_reg_0);
4623 
4624 	FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarLUN_CA = 0;
4625 
4626 	if (status_byte != SAM_STAT_GOOD) {
4627 
4628 		if (status_byte == SAM_STAT_TASK_SET_FULL) {
4629 
4630 			if (((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
4631 			     ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4632 			       TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))) {
4633 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4634 				    TarLUNBusy[currSCCB->Lun] = 1;
4635 				if (FPT_BL_Card[p_card].discQCount != 0)
4636 					FPT_BL_Card[p_card].discQCount--;
4637 				FPT_BL_Card[p_card].
4638 				    discQ_Tbl[FPT_sccbMgrTbl[p_card]
4639 					      [currSCCB->TargID].
4640 					      LunDiscQ_Idx[currSCCB->Lun]] =
4641 				    NULL;
4642 			} else {
4643 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4644 				    TarLUNBusy[0] = 1;
4645 				if (currSCCB->Sccb_tag) {
4646 					if (FPT_BL_Card[p_card].discQCount != 0)
4647 						FPT_BL_Card[p_card].
4648 						    discQCount--;
4649 					FPT_BL_Card[p_card].discQ_Tbl[currSCCB->
4650 								      Sccb_tag]
4651 					    = NULL;
4652 				} else {
4653 					if (FPT_BL_Card[p_card].discQCount != 0)
4654 						FPT_BL_Card[p_card].
4655 						    discQCount--;
4656 					FPT_BL_Card[p_card].
4657 					    discQ_Tbl[FPT_sccbMgrTbl[p_card]
4658 						      [currSCCB->TargID].
4659 						      LunDiscQ_Idx[0]] = NULL;
4660 				}
4661 			}
4662 
4663 			currSCCB->Sccb_MGRFlags |= F_STATUSLOADED;
4664 
4665 			FPT_queueSelectFail(&FPT_BL_Card[p_card], p_card);
4666 
4667 			return;
4668 		}
4669 
4670 		if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
4671 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarStatus |=
4672 			    (unsigned char)SYNC_SUPPORTED;
4673 
4674 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarEEValue &=
4675 			    ~EE_SYNC_MASK;
4676 			FPT_BL_Card[p_card].globalFlags |= F_NEW_SCCB_CMD;
4677 
4678 			if (((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
4679 			     ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4680 			       TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))) {
4681 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4682 				    TarLUNBusy[currSCCB->Lun] = 1;
4683 				if (FPT_BL_Card[p_card].discQCount != 0)
4684 					FPT_BL_Card[p_card].discQCount--;
4685 				FPT_BL_Card[p_card].
4686 				    discQ_Tbl[FPT_sccbMgrTbl[p_card]
4687 					      [currSCCB->TargID].
4688 					      LunDiscQ_Idx[currSCCB->Lun]] =
4689 				    NULL;
4690 			} else {
4691 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4692 				    TarLUNBusy[0] = 1;
4693 				if (currSCCB->Sccb_tag) {
4694 					if (FPT_BL_Card[p_card].discQCount != 0)
4695 						FPT_BL_Card[p_card].
4696 						    discQCount--;
4697 					FPT_BL_Card[p_card].discQ_Tbl[currSCCB->
4698 								      Sccb_tag]
4699 					    = NULL;
4700 				} else {
4701 					if (FPT_BL_Card[p_card].discQCount != 0)
4702 						FPT_BL_Card[p_card].
4703 						    discQCount--;
4704 					FPT_BL_Card[p_card].
4705 					    discQ_Tbl[FPT_sccbMgrTbl[p_card]
4706 						      [currSCCB->TargID].
4707 						      LunDiscQ_Idx[0]] = NULL;
4708 				}
4709 			}
4710 			return;
4711 
4712 		}
4713 
4714 		if (currSCCB->Sccb_scsistat == SELECT_WN_ST) {
4715 
4716 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarStatus =
4717 			    (FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4718 			     TarStatus & ~WIDE_ENABLED) | WIDE_NEGOCIATED;
4719 
4720 			FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarEEValue &=
4721 			    ~EE_WIDE_SCSI;
4722 			FPT_BL_Card[p_card].globalFlags |= F_NEW_SCCB_CMD;
4723 
4724 			if (((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
4725 			     ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4726 			       TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))) {
4727 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4728 				    TarLUNBusy[currSCCB->Lun] = 1;
4729 				if (FPT_BL_Card[p_card].discQCount != 0)
4730 					FPT_BL_Card[p_card].discQCount--;
4731 				FPT_BL_Card[p_card].
4732 				    discQ_Tbl[FPT_sccbMgrTbl[p_card]
4733 					      [currSCCB->TargID].
4734 					      LunDiscQ_Idx[currSCCB->Lun]] =
4735 				    NULL;
4736 			} else {
4737 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4738 				    TarLUNBusy[0] = 1;
4739 				if (currSCCB->Sccb_tag) {
4740 					if (FPT_BL_Card[p_card].discQCount != 0)
4741 						FPT_BL_Card[p_card].
4742 						    discQCount--;
4743 					FPT_BL_Card[p_card].discQ_Tbl[currSCCB->
4744 								      Sccb_tag]
4745 					    = NULL;
4746 				} else {
4747 					if (FPT_BL_Card[p_card].discQCount != 0)
4748 						FPT_BL_Card[p_card].
4749 						    discQCount--;
4750 					FPT_BL_Card[p_card].
4751 					    discQ_Tbl[FPT_sccbMgrTbl[p_card]
4752 						      [currSCCB->TargID].
4753 						      LunDiscQ_Idx[0]] = NULL;
4754 				}
4755 			}
4756 			return;
4757 
4758 		}
4759 
4760 		if (status_byte == SAM_STAT_CHECK_CONDITION) {
4761 			if (FPT_BL_Card[p_card].globalFlags & F_DO_RENEGO) {
4762 				if (FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4763 				    TarEEValue & EE_SYNC_MASK) {
4764 					FPT_sccbMgrTbl[p_card][currSCCB->
4765 							       TargID].
4766 					    TarStatus &= ~TAR_SYNC_MASK;
4767 				}
4768 				if (FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4769 				    TarEEValue & EE_WIDE_SCSI) {
4770 					FPT_sccbMgrTbl[p_card][currSCCB->
4771 							       TargID].
4772 					    TarStatus &= ~TAR_WIDE_MASK;
4773 				}
4774 			}
4775 		}
4776 
4777 		if (!(currSCCB->Sccb_XferState & F_AUTO_SENSE)) {
4778 
4779 			currSCCB->SccbStatus = SCCB_ERROR;
4780 			currSCCB->TargetStatus = status_byte;
4781 
4782 			if (status_byte == SAM_STAT_CHECK_CONDITION) {
4783 
4784 				FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4785 				    TarLUN_CA = 1;
4786 
4787 				if (currSCCB->RequestSenseLength !=
4788 				    NO_AUTO_REQUEST_SENSE) {
4789 
4790 					if (currSCCB->RequestSenseLength == 0)
4791 						currSCCB->RequestSenseLength =
4792 						    14;
4793 
4794 					FPT_ssenss(&FPT_BL_Card[p_card]);
4795 					FPT_BL_Card[p_card].globalFlags |=
4796 					    F_NEW_SCCB_CMD;
4797 
4798 					if (((FPT_BL_Card[p_card].
4799 					      globalFlags & F_CONLUN_IO)
4800 					     &&
4801 					     ((FPT_sccbMgrTbl[p_card]
4802 					       [currSCCB->TargID].
4803 					       TarStatus & TAR_TAG_Q_MASK) !=
4804 					      TAG_Q_TRYING))) {
4805 						FPT_sccbMgrTbl[p_card]
4806 						    [currSCCB->TargID].
4807 						    TarLUNBusy[currSCCB->Lun] =
4808 						    1;
4809 						if (FPT_BL_Card[p_card].
4810 						    discQCount != 0)
4811 							FPT_BL_Card[p_card].
4812 							    discQCount--;
4813 						FPT_BL_Card[p_card].
4814 						    discQ_Tbl[FPT_sccbMgrTbl
4815 							      [p_card]
4816 							      [currSCCB->
4817 							       TargID].
4818 							      LunDiscQ_Idx
4819 							      [currSCCB->Lun]] =
4820 						    NULL;
4821 					} else {
4822 						FPT_sccbMgrTbl[p_card]
4823 						    [currSCCB->TargID].
4824 						    TarLUNBusy[0] = 1;
4825 						if (currSCCB->Sccb_tag) {
4826 							if (FPT_BL_Card[p_card].
4827 							    discQCount != 0)
4828 								FPT_BL_Card
4829 								    [p_card].
4830 								    discQCount--;
4831 							FPT_BL_Card[p_card].
4832 							    discQ_Tbl[currSCCB->
4833 								      Sccb_tag]
4834 							    = NULL;
4835 						} else {
4836 							if (FPT_BL_Card[p_card].
4837 							    discQCount != 0)
4838 								FPT_BL_Card
4839 								    [p_card].
4840 								    discQCount--;
4841 							FPT_BL_Card[p_card].
4842 							    discQ_Tbl
4843 							    [FPT_sccbMgrTbl
4844 							     [p_card][currSCCB->
4845 								      TargID].
4846 							     LunDiscQ_Idx[0]] =
4847 							    NULL;
4848 						}
4849 					}
4850 					return;
4851 				}
4852 			}
4853 		}
4854 	}
4855 
4856 	if ((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
4857 	    ((FPT_sccbMgrTbl[p_card][currSCCB->TargID].
4858 	      TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
4859 		FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarLUNBusy[currSCCB->
4860 								    Lun] = 0;
4861 	else
4862 		FPT_sccbMgrTbl[p_card][currSCCB->TargID].TarLUNBusy[0] = 0;
4863 
4864 	FPT_queueCmdComplete(&FPT_BL_Card[p_card], currSCCB, p_card);
4865 }
4866 
4867 #define SHORT_WAIT   0x0000000F
4868 #define LONG_WAIT    0x0000FFFFL
4869 
4870 /*---------------------------------------------------------------------
4871  *
4872  * Function: Data Transfer Processor
4873  *
4874  * Description: This routine performs two tasks.
4875  *              (1) Start data transfer by calling HOST_DATA_XFER_START
4876  *              function.  Once data transfer is started, (2) Depends
4877  *              on the type of data transfer mode Scatter/Gather mode
4878  *              or NON Scatter/Gather mode.  In NON Scatter/Gather mode,
4879  *              this routine checks Sccb_MGRFlag (F_HOST_XFER_ACT bit) for
4880  *              data transfer done.  In Scatter/Gather mode, this routine
4881  *              checks bus master command complete and dual rank busy
4882  *              bit to keep chaining SC transfer command.  Similarly,
4883  *              in Scatter/Gather mode, it checks Sccb_MGRFlag
4884  *              (F_HOST_XFER_ACT bit) for data transfer done.
4885  *
4886  *---------------------------------------------------------------------*/
4887 
FPT_dataXferProcessor(u32 port,struct sccb_card * pCurrCard)4888 static void FPT_dataXferProcessor(u32 port, struct sccb_card *pCurrCard)
4889 {
4890 	struct sccb *currSCCB;
4891 
4892 	currSCCB = pCurrCard->currentSCCB;
4893 
4894 	if (currSCCB->Sccb_XferState & F_SG_XFER) {
4895 		if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
4896 		{
4897 			currSCCB->Sccb_sgseg += (unsigned char)SG_BUF_CNT;
4898 			currSCCB->Sccb_SGoffset = 0x00;
4899 		}
4900 		pCurrCard->globalFlags |= F_HOST_XFER_ACT;
4901 
4902 		FPT_busMstrSGDataXferStart(port, currSCCB);
4903 	}
4904 
4905 	else {
4906 		if (!(pCurrCard->globalFlags & F_HOST_XFER_ACT)) {
4907 			pCurrCard->globalFlags |= F_HOST_XFER_ACT;
4908 
4909 			FPT_busMstrDataXferStart(port, currSCCB);
4910 		}
4911 	}
4912 }
4913 
4914 /*---------------------------------------------------------------------
4915  *
4916  * Function: BusMaster Scatter Gather Data Transfer Start
4917  *
4918  * Description:
4919  *
4920  *---------------------------------------------------------------------*/
FPT_busMstrSGDataXferStart(u32 p_port,struct sccb * pcurrSCCB)4921 static void FPT_busMstrSGDataXferStart(u32 p_port, struct sccb *pcurrSCCB)
4922 {
4923 	u32 count, addr, tmpSGCnt;
4924 	unsigned int sg_index;
4925 	unsigned char sg_count, i;
4926 	u32 reg_offset;
4927 	struct blogic_sg_seg *segp;
4928 
4929 	if (pcurrSCCB->Sccb_XferState & F_HOST_XFER_DIR)
4930 		count = ((u32)HOST_RD_CMD) << 24;
4931 	else
4932 		count = ((u32)HOST_WRT_CMD) << 24;
4933 
4934 	sg_count = 0;
4935 	tmpSGCnt = 0;
4936 	sg_index = pcurrSCCB->Sccb_sgseg;
4937 	reg_offset = hp_aramBase;
4938 
4939 	i = (unsigned char)(RD_HARPOON(p_port + hp_page_ctrl) &
4940 			    ~(SGRAM_ARAM | SCATTER_EN));
4941 
4942 	WR_HARPOON(p_port + hp_page_ctrl, i);
4943 
4944 	while ((sg_count < (unsigned char)SG_BUF_CNT) &&
4945 			((sg_index * (unsigned int)SG_ELEMENT_SIZE) <
4946 			pcurrSCCB->DataLength)) {
4947 
4948 		segp = (struct blogic_sg_seg *)(pcurrSCCB->DataPointer) +
4949 				sg_index;
4950 		tmpSGCnt += segp->segbytes;
4951 		count |= segp->segbytes;
4952 		addr = segp->segdata;
4953 
4954 		if ((!sg_count) && (pcurrSCCB->Sccb_SGoffset)) {
4955 			addr +=
4956 			    ((count & 0x00FFFFFFL) - pcurrSCCB->Sccb_SGoffset);
4957 			count =
4958 			    (count & 0xFF000000L) | pcurrSCCB->Sccb_SGoffset;
4959 			tmpSGCnt = count & 0x00FFFFFFL;
4960 		}
4961 
4962 		WR_HARP32(p_port, reg_offset, addr);
4963 		reg_offset += 4;
4964 
4965 		WR_HARP32(p_port, reg_offset, count);
4966 		reg_offset += 4;
4967 
4968 		count &= 0xFF000000L;
4969 		sg_index++;
4970 		sg_count++;
4971 
4972 	}			/*End While */
4973 
4974 	pcurrSCCB->Sccb_XferCnt = tmpSGCnt;
4975 
4976 	WR_HARPOON(p_port + hp_sg_addr, (sg_count << 4));
4977 
4978 	if (pcurrSCCB->Sccb_XferState & F_HOST_XFER_DIR) {
4979 
4980 		WR_HARP32(p_port, hp_xfercnt_0, tmpSGCnt);
4981 
4982 		WR_HARPOON(p_port + hp_portctrl_0,
4983 			   (DMA_PORT | SCSI_PORT | SCSI_INBIT));
4984 		WR_HARPOON(p_port + hp_scsisig, S_DATAI_PH);
4985 	}
4986 
4987 	else {
4988 
4989 		if ((!(RD_HARPOON(p_port + hp_synctarg_0) & NARROW_SCSI)) &&
4990 		    (tmpSGCnt & 0x000000001)) {
4991 
4992 			pcurrSCCB->Sccb_XferState |= F_ODD_BALL_CNT;
4993 			tmpSGCnt--;
4994 		}
4995 
4996 		WR_HARP32(p_port, hp_xfercnt_0, tmpSGCnt);
4997 
4998 		WR_HARPOON(p_port + hp_portctrl_0,
4999 			   (SCSI_PORT | DMA_PORT | DMA_RD));
5000 		WR_HARPOON(p_port + hp_scsisig, S_DATAO_PH);
5001 	}
5002 
5003 	WR_HARPOON(p_port + hp_page_ctrl, (unsigned char)(i | SCATTER_EN));
5004 
5005 }
5006 
5007 /*---------------------------------------------------------------------
5008  *
5009  * Function: BusMaster Data Transfer Start
5010  *
5011  * Description:
5012  *
5013  *---------------------------------------------------------------------*/
FPT_busMstrDataXferStart(u32 p_port,struct sccb * pcurrSCCB)5014 static void FPT_busMstrDataXferStart(u32 p_port, struct sccb *pcurrSCCB)
5015 {
5016 	u32 addr, count;
5017 
5018 	if (!(pcurrSCCB->Sccb_XferState & F_AUTO_SENSE)) {
5019 
5020 		count = pcurrSCCB->Sccb_XferCnt;
5021 
5022 		addr = (u32)(unsigned long)pcurrSCCB->DataPointer + pcurrSCCB->Sccb_ATC;
5023 	}
5024 
5025 	else {
5026 		addr = pcurrSCCB->SensePointer;
5027 		count = pcurrSCCB->RequestSenseLength;
5028 
5029 	}
5030 
5031 	HP_SETUP_ADDR_CNT(p_port, addr, count);
5032 
5033 	if (pcurrSCCB->Sccb_XferState & F_HOST_XFER_DIR) {
5034 
5035 		WR_HARPOON(p_port + hp_portctrl_0,
5036 			   (DMA_PORT | SCSI_PORT | SCSI_INBIT));
5037 		WR_HARPOON(p_port + hp_scsisig, S_DATAI_PH);
5038 
5039 		WR_HARPOON(p_port + hp_xfer_cmd,
5040 			   (XFER_DMA_HOST | XFER_HOST_AUTO | XFER_DMA_8BIT));
5041 	}
5042 
5043 	else {
5044 
5045 		WR_HARPOON(p_port + hp_portctrl_0,
5046 			   (SCSI_PORT | DMA_PORT | DMA_RD));
5047 		WR_HARPOON(p_port + hp_scsisig, S_DATAO_PH);
5048 
5049 		WR_HARPOON(p_port + hp_xfer_cmd,
5050 			   (XFER_HOST_DMA | XFER_HOST_AUTO | XFER_DMA_8BIT));
5051 
5052 	}
5053 }
5054 
5055 /*---------------------------------------------------------------------
5056  *
5057  * Function: BusMaster Timeout Handler
5058  *
5059  * Description: This function is called after a bus master command busy time
5060  *               out is detected.  This routines issue halt state machine
5061  *               with a software time out for command busy.  If command busy
5062  *               is still asserted at the end of the time out, it issues
5063  *               hard abort with another software time out.  It hard abort
5064  *               command busy is also time out, it'll just give up.
5065  *
5066  *---------------------------------------------------------------------*/
FPT_busMstrTimeOut(u32 p_port)5067 static unsigned char FPT_busMstrTimeOut(u32 p_port)
5068 {
5069 	unsigned long timeout;
5070 
5071 	timeout = LONG_WAIT;
5072 
5073 	WR_HARPOON(p_port + hp_sys_ctrl, HALT_MACH);
5074 
5075 	while ((!(RD_HARPOON(p_port + hp_ext_status) & CMD_ABORTED))
5076 	       && timeout--) {
5077 	}
5078 
5079 	if (RD_HARPOON(p_port + hp_ext_status) & BM_CMD_BUSY) {
5080 		WR_HARPOON(p_port + hp_sys_ctrl, HARD_ABORT);
5081 
5082 		timeout = LONG_WAIT;
5083 		while ((RD_HARPOON(p_port + hp_ext_status) & BM_CMD_BUSY)
5084 		       && timeout--) {
5085 		}
5086 	}
5087 
5088 	RD_HARPOON(p_port + hp_int_status);	/*Clear command complete */
5089 
5090 	if (RD_HARPOON(p_port + hp_ext_status) & BM_CMD_BUSY) {
5091 		return 1;
5092 	}
5093 
5094 	else {
5095 		return 0;
5096 	}
5097 }
5098 
5099 /*---------------------------------------------------------------------
5100  *
5101  * Function: Host Data Transfer Abort
5102  *
5103  * Description: Abort any in progress transfer.
5104  *
5105  *---------------------------------------------------------------------*/
FPT_hostDataXferAbort(u32 port,unsigned char p_card,struct sccb * pCurrSCCB)5106 static void FPT_hostDataXferAbort(u32 port, unsigned char p_card,
5107 				  struct sccb *pCurrSCCB)
5108 {
5109 
5110 	unsigned long timeout;
5111 	unsigned long remain_cnt;
5112 	u32 sg_ptr;
5113 	struct blogic_sg_seg *segp;
5114 
5115 	FPT_BL_Card[p_card].globalFlags &= ~F_HOST_XFER_ACT;
5116 
5117 	if (pCurrSCCB->Sccb_XferState & F_AUTO_SENSE) {
5118 
5119 		if (!(RD_HARPOON(port + hp_int_status) & INT_CMD_COMPL)) {
5120 
5121 			WR_HARPOON(port + hp_bm_ctrl,
5122 				   (RD_HARPOON(port + hp_bm_ctrl) |
5123 				    FLUSH_XFER_CNTR));
5124 			timeout = LONG_WAIT;
5125 
5126 			while ((RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY)
5127 			       && timeout--) {
5128 			}
5129 
5130 			WR_HARPOON(port + hp_bm_ctrl,
5131 				   (RD_HARPOON(port + hp_bm_ctrl) &
5132 				    ~FLUSH_XFER_CNTR));
5133 
5134 			if (RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY) {
5135 
5136 				if (FPT_busMstrTimeOut(port)) {
5137 
5138 					if (pCurrSCCB->HostStatus == 0x00)
5139 
5140 						pCurrSCCB->HostStatus =
5141 						    SCCB_BM_ERR;
5142 
5143 				}
5144 
5145 				if (RD_HARPOON(port + hp_int_status) &
5146 				    INT_EXT_STATUS)
5147 
5148 					if (RD_HARPOON(port + hp_ext_status) &
5149 					    BAD_EXT_STATUS)
5150 
5151 						if (pCurrSCCB->HostStatus ==
5152 						    0x00)
5153 						{
5154 							pCurrSCCB->HostStatus =
5155 							    SCCB_BM_ERR;
5156 						}
5157 			}
5158 		}
5159 	}
5160 
5161 	else if (pCurrSCCB->Sccb_XferCnt) {
5162 
5163 		if (pCurrSCCB->Sccb_XferState & F_SG_XFER) {
5164 
5165 			WR_HARPOON(port + hp_page_ctrl,
5166 				   (RD_HARPOON(port + hp_page_ctrl) &
5167 				    ~SCATTER_EN));
5168 
5169 			WR_HARPOON(port + hp_sg_addr, 0x00);
5170 
5171 			sg_ptr = pCurrSCCB->Sccb_sgseg + SG_BUF_CNT;
5172 
5173 			if (sg_ptr >
5174 			    (unsigned int)(pCurrSCCB->DataLength /
5175 					   SG_ELEMENT_SIZE)) {
5176 
5177 				sg_ptr = (u32)(pCurrSCCB->DataLength /
5178 							SG_ELEMENT_SIZE);
5179 			}
5180 
5181 			remain_cnt = pCurrSCCB->Sccb_XferCnt;
5182 
5183 			while (remain_cnt < 0x01000000L) {
5184 
5185 				sg_ptr--;
5186 				segp = (struct blogic_sg_seg *)(pCurrSCCB->
5187 						DataPointer) + (sg_ptr * 2);
5188 				if (remain_cnt > (unsigned long)segp->segbytes)
5189 					remain_cnt -=
5190 						(unsigned long)segp->segbytes;
5191 				else
5192 					break;
5193 			}
5194 
5195 			if (remain_cnt < 0x01000000L) {
5196 
5197 				pCurrSCCB->Sccb_SGoffset = remain_cnt;
5198 
5199 				pCurrSCCB->Sccb_sgseg = (unsigned short)sg_ptr;
5200 
5201 				if ((unsigned long)(sg_ptr * SG_ELEMENT_SIZE) ==
5202 				    pCurrSCCB->DataLength && (remain_cnt == 0))
5203 
5204 					pCurrSCCB->Sccb_XferState |=
5205 					    F_ALL_XFERRED;
5206 			}
5207 
5208 			else {
5209 
5210 				if (pCurrSCCB->HostStatus == 0x00) {
5211 
5212 					pCurrSCCB->HostStatus =
5213 					    SCCB_GROSS_FW_ERR;
5214 				}
5215 			}
5216 		}
5217 
5218 		if (!(pCurrSCCB->Sccb_XferState & F_HOST_XFER_DIR)) {
5219 
5220 			if (RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY) {
5221 
5222 				FPT_busMstrTimeOut(port);
5223 			}
5224 
5225 			else {
5226 
5227 				if (RD_HARPOON(port + hp_int_status) &
5228 				    INT_EXT_STATUS) {
5229 
5230 					if (RD_HARPOON(port + hp_ext_status) &
5231 					    BAD_EXT_STATUS) {
5232 
5233 						if (pCurrSCCB->HostStatus ==
5234 						    0x00) {
5235 
5236 							pCurrSCCB->HostStatus =
5237 							    SCCB_BM_ERR;
5238 						}
5239 					}
5240 				}
5241 
5242 			}
5243 		}
5244 
5245 		else {
5246 
5247 			if ((RD_HARPOON(port + hp_fifo_cnt)) >= BM_THRESHOLD) {
5248 
5249 				timeout = SHORT_WAIT;
5250 
5251 				while ((RD_HARPOON(port + hp_ext_status) &
5252 					BM_CMD_BUSY)
5253 				       && ((RD_HARPOON(port + hp_fifo_cnt)) >=
5254 					   BM_THRESHOLD) && timeout--) {
5255 				}
5256 			}
5257 
5258 			if (RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY) {
5259 
5260 				WR_HARPOON(port + hp_bm_ctrl,
5261 					   (RD_HARPOON(port + hp_bm_ctrl) |
5262 					    FLUSH_XFER_CNTR));
5263 
5264 				timeout = LONG_WAIT;
5265 
5266 				while ((RD_HARPOON(port + hp_ext_status) &
5267 					BM_CMD_BUSY) && timeout--) {
5268 				}
5269 
5270 				WR_HARPOON(port + hp_bm_ctrl,
5271 					   (RD_HARPOON(port + hp_bm_ctrl) &
5272 					    ~FLUSH_XFER_CNTR));
5273 
5274 				if (RD_HARPOON(port + hp_ext_status) &
5275 				    BM_CMD_BUSY) {
5276 
5277 					if (pCurrSCCB->HostStatus == 0x00) {
5278 
5279 						pCurrSCCB->HostStatus =
5280 						    SCCB_BM_ERR;
5281 					}
5282 
5283 					FPT_busMstrTimeOut(port);
5284 				}
5285 			}
5286 
5287 			if (RD_HARPOON(port + hp_int_status) & INT_EXT_STATUS) {
5288 
5289 				if (RD_HARPOON(port + hp_ext_status) &
5290 				    BAD_EXT_STATUS) {
5291 
5292 					if (pCurrSCCB->HostStatus == 0x00) {
5293 
5294 						pCurrSCCB->HostStatus =
5295 						    SCCB_BM_ERR;
5296 					}
5297 				}
5298 			}
5299 		}
5300 
5301 	}
5302 
5303 	else {
5304 
5305 		if (RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY) {
5306 
5307 			timeout = LONG_WAIT;
5308 
5309 			while ((RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY)
5310 			       && timeout--) {
5311 			}
5312 
5313 			if (RD_HARPOON(port + hp_ext_status) & BM_CMD_BUSY) {
5314 
5315 				if (pCurrSCCB->HostStatus == 0x00) {
5316 
5317 					pCurrSCCB->HostStatus = SCCB_BM_ERR;
5318 				}
5319 
5320 				FPT_busMstrTimeOut(port);
5321 			}
5322 		}
5323 
5324 		if (RD_HARPOON(port + hp_int_status) & INT_EXT_STATUS) {
5325 
5326 			if (RD_HARPOON(port + hp_ext_status) & BAD_EXT_STATUS) {
5327 
5328 				if (pCurrSCCB->HostStatus == 0x00) {
5329 
5330 					pCurrSCCB->HostStatus = SCCB_BM_ERR;
5331 				}
5332 			}
5333 
5334 		}
5335 
5336 		if (pCurrSCCB->Sccb_XferState & F_SG_XFER) {
5337 
5338 			WR_HARPOON(port + hp_page_ctrl,
5339 				   (RD_HARPOON(port + hp_page_ctrl) &
5340 				    ~SCATTER_EN));
5341 
5342 			WR_HARPOON(port + hp_sg_addr, 0x00);
5343 
5344 			pCurrSCCB->Sccb_sgseg += SG_BUF_CNT;
5345 
5346 			pCurrSCCB->Sccb_SGoffset = 0x00;
5347 
5348 			if ((u32)(pCurrSCCB->Sccb_sgseg * SG_ELEMENT_SIZE) >=
5349 					pCurrSCCB->DataLength) {
5350 
5351 				pCurrSCCB->Sccb_XferState |= F_ALL_XFERRED;
5352 				pCurrSCCB->Sccb_sgseg =
5353 				    (unsigned short)(pCurrSCCB->DataLength /
5354 						     SG_ELEMENT_SIZE);
5355 			}
5356 		}
5357 
5358 		else {
5359 			if (!(pCurrSCCB->Sccb_XferState & F_AUTO_SENSE))
5360 				pCurrSCCB->Sccb_XferState |= F_ALL_XFERRED;
5361 		}
5362 	}
5363 
5364 	WR_HARPOON(port + hp_int_mask, (INT_CMD_COMPL | SCSI_INTERRUPT));
5365 }
5366 
5367 /*---------------------------------------------------------------------
5368  *
5369  * Function: Host Data Transfer Restart
5370  *
5371  * Description: Reset the available count due to a restore data
5372  *              pointers message.
5373  *
5374  *---------------------------------------------------------------------*/
FPT_hostDataXferRestart(struct sccb * currSCCB)5375 static void FPT_hostDataXferRestart(struct sccb *currSCCB)
5376 {
5377 	unsigned long data_count;
5378 	unsigned int sg_index;
5379 	struct blogic_sg_seg *segp;
5380 
5381 	if (currSCCB->Sccb_XferState & F_SG_XFER) {
5382 
5383 		currSCCB->Sccb_XferCnt = 0;
5384 
5385 		sg_index = 0xffff;	/*Index by long words into sg list. */
5386 		data_count = 0;		/*Running count of SG xfer counts. */
5387 
5388 
5389 		while (data_count < currSCCB->Sccb_ATC) {
5390 
5391 			sg_index++;
5392 			segp = (struct blogic_sg_seg *)(currSCCB->DataPointer) +
5393 						(sg_index * 2);
5394 			data_count += segp->segbytes;
5395 		}
5396 
5397 		if (data_count == currSCCB->Sccb_ATC) {
5398 
5399 			currSCCB->Sccb_SGoffset = 0;
5400 			sg_index++;
5401 		}
5402 
5403 		else {
5404 			currSCCB->Sccb_SGoffset =
5405 			    data_count - currSCCB->Sccb_ATC;
5406 		}
5407 
5408 		currSCCB->Sccb_sgseg = (unsigned short)sg_index;
5409 	}
5410 
5411 	else {
5412 		currSCCB->Sccb_XferCnt =
5413 		    currSCCB->DataLength - currSCCB->Sccb_ATC;
5414 	}
5415 }
5416 
5417 /*---------------------------------------------------------------------
5418  *
5419  * Function: FPT_scini
5420  *
5421  * Description: Setup all data structures necessary for SCAM selection.
5422  *
5423  *---------------------------------------------------------------------*/
5424 
FPT_scini(unsigned char p_card,unsigned char p_our_id,unsigned char p_power_up)5425 static void FPT_scini(unsigned char p_card, unsigned char p_our_id,
5426 		      unsigned char p_power_up)
5427 {
5428 
5429 	unsigned char loser, assigned_id;
5430 	u32 p_port;
5431 
5432 	unsigned char i, k, ScamFlg;
5433 	struct sccb_card *currCard;
5434 	struct nvram_info *pCurrNvRam;
5435 
5436 	currCard = &FPT_BL_Card[p_card];
5437 	p_port = currCard->ioPort;
5438 	pCurrNvRam = currCard->pNvRamInfo;
5439 
5440 	if (pCurrNvRam) {
5441 		ScamFlg = pCurrNvRam->niScamConf;
5442 		i = pCurrNvRam->niSysConf;
5443 	} else {
5444 		ScamFlg =
5445 		    (unsigned char)FPT_utilEERead(p_port, SCAM_CONFIG / 2);
5446 		i = (unsigned
5447 		     char)(FPT_utilEERead(p_port, (SYSTEM_CONFIG / 2)));
5448 	}
5449 	if (!(i & 0x02))	/* check if reset bus in AutoSCSI parameter set */
5450 		return;
5451 
5452 	FPT_inisci(p_card, p_port, p_our_id);
5453 
5454 	/* Force to wait 1 sec after SCSI bus reset. Some SCAM device FW
5455 	   too slow to return to SCAM selection */
5456 
5457 	/* if (p_power_up)
5458 	   FPT_Wait1Second(p_port);
5459 	   else
5460 	   FPT_Wait(p_port, TO_250ms); */
5461 
5462 	FPT_Wait1Second(p_port);
5463 
5464 	if ((ScamFlg & SCAM_ENABLED) && (ScamFlg & SCAM_LEVEL2)) {
5465 		while (!(FPT_scarb(p_port, INIT_SELTD))) {
5466 		}
5467 
5468 		FPT_scsel(p_port);
5469 
5470 		do {
5471 			FPT_scxferc(p_port, SYNC_PTRN);
5472 			FPT_scxferc(p_port, DOM_MSTR);
5473 			loser =
5474 			    FPT_scsendi(p_port,
5475 					&FPT_scamInfo[p_our_id].id_string[0]);
5476 		} while (loser == 0xFF);
5477 
5478 		FPT_scbusf(p_port);
5479 
5480 		if ((p_power_up) && (!loser)) {
5481 			FPT_sresb(p_port, p_card);
5482 			FPT_Wait(p_port, TO_250ms);
5483 
5484 			while (!(FPT_scarb(p_port, INIT_SELTD))) {
5485 			}
5486 
5487 			FPT_scsel(p_port);
5488 
5489 			do {
5490 				FPT_scxferc(p_port, SYNC_PTRN);
5491 				FPT_scxferc(p_port, DOM_MSTR);
5492 				loser =
5493 				    FPT_scsendi(p_port,
5494 						&FPT_scamInfo[p_our_id].
5495 						id_string[0]);
5496 			} while (loser == 0xFF);
5497 
5498 			FPT_scbusf(p_port);
5499 		}
5500 	}
5501 
5502 	else {
5503 		loser = 0;
5504 	}
5505 
5506 	if (!loser) {
5507 
5508 		FPT_scamInfo[p_our_id].state = ID_ASSIGNED;
5509 
5510 		if (ScamFlg & SCAM_ENABLED) {
5511 
5512 			for (i = 0; i < MAX_SCSI_TAR; i++) {
5513 				if ((FPT_scamInfo[i].state == ID_UNASSIGNED) ||
5514 				    (FPT_scamInfo[i].state == ID_UNUSED)) {
5515 					if (FPT_scsell(p_port, i)) {
5516 						FPT_scamInfo[i].state = LEGACY;
5517 						if ((FPT_scamInfo[i].
5518 						     id_string[0] != 0xFF)
5519 						    || (FPT_scamInfo[i].
5520 							id_string[1] != 0xFA)) {
5521 
5522 							FPT_scamInfo[i].
5523 							    id_string[0] = 0xFF;
5524 							FPT_scamInfo[i].
5525 							    id_string[1] = 0xFA;
5526 							if (pCurrNvRam == NULL)
5527 								currCard->
5528 								    globalFlags
5529 								    |=
5530 								    F_UPDATE_EEPROM;
5531 						}
5532 					}
5533 				}
5534 			}
5535 
5536 			FPT_sresb(p_port, p_card);
5537 			FPT_Wait1Second(p_port);
5538 			while (!(FPT_scarb(p_port, INIT_SELTD))) {
5539 			}
5540 			FPT_scsel(p_port);
5541 			FPT_scasid(p_card, p_port);
5542 		}
5543 
5544 	}
5545 
5546 	else if ((loser) && (ScamFlg & SCAM_ENABLED)) {
5547 		FPT_scamInfo[p_our_id].id_string[0] = SLV_TYPE_CODE0;
5548 		assigned_id = 0;
5549 		FPT_scwtsel(p_port);
5550 
5551 		do {
5552 			while (FPT_scxferc(p_port, 0x00) != SYNC_PTRN) {
5553 			}
5554 
5555 			i = FPT_scxferc(p_port, 0x00);
5556 			if (i == ASSIGN_ID) {
5557 				if (!
5558 				    (FPT_scsendi
5559 				     (p_port,
5560 				      &FPT_scamInfo[p_our_id].id_string[0]))) {
5561 					i = FPT_scxferc(p_port, 0x00);
5562 					if (FPT_scvalq(i)) {
5563 						k = FPT_scxferc(p_port, 0x00);
5564 
5565 						if (FPT_scvalq(k)) {
5566 							currCard->ourId =
5567 							    ((unsigned char)(i
5568 									     <<
5569 									     3)
5570 							     +
5571 							     (k &
5572 							      (unsigned char)7))
5573 							    & (unsigned char)
5574 							    0x3F;
5575 							FPT_inisci(p_card,
5576 								   p_port,
5577 								   p_our_id);
5578 							FPT_scamInfo[currCard->
5579 								     ourId].
5580 							    state = ID_ASSIGNED;
5581 							FPT_scamInfo[currCard->
5582 								     ourId].
5583 							    id_string[0]
5584 							    = SLV_TYPE_CODE0;
5585 							assigned_id = 1;
5586 						}
5587 					}
5588 				}
5589 			}
5590 
5591 			else if (i == SET_P_FLAG) {
5592 				if (!(FPT_scsendi(p_port,
5593 						  &FPT_scamInfo[p_our_id].
5594 						  id_string[0])))
5595 					FPT_scamInfo[p_our_id].id_string[0] |=
5596 					    0x80;
5597 			}
5598 		} while (!assigned_id);
5599 
5600 		while (FPT_scxferc(p_port, 0x00) != CFG_CMPLT) {
5601 		}
5602 	}
5603 
5604 	if (ScamFlg & SCAM_ENABLED) {
5605 		FPT_scbusf(p_port);
5606 		if (currCard->globalFlags & F_UPDATE_EEPROM) {
5607 			FPT_scsavdi(p_card, p_port);
5608 			currCard->globalFlags &= ~F_UPDATE_EEPROM;
5609 		}
5610 	}
5611 
5612 /*
5613    for (i=0,k=0; i < MAX_SCSI_TAR; i++)
5614       {
5615       if ((FPT_scamInfo[i].state == ID_ASSIGNED) ||
5616          (FPT_scamInfo[i].state == LEGACY))
5617          k++;
5618       }
5619 
5620    if (k==2)
5621       currCard->globalFlags |= F_SINGLE_DEVICE;
5622    else
5623       currCard->globalFlags &= ~F_SINGLE_DEVICE;
5624 */
5625 }
5626 
5627 /*---------------------------------------------------------------------
5628  *
5629  * Function: FPT_scarb
5630  *
5631  * Description: Gain control of the bus and wait SCAM select time (250ms)
5632  *
5633  *---------------------------------------------------------------------*/
5634 
FPT_scarb(u32 p_port,unsigned char p_sel_type)5635 static int FPT_scarb(u32 p_port, unsigned char p_sel_type)
5636 {
5637 	if (p_sel_type == INIT_SELTD) {
5638 
5639 		while (RD_HARPOON(p_port + hp_scsisig) & (SCSI_SEL | SCSI_BSY)) {
5640 		}
5641 
5642 		if (RD_HARPOON(p_port + hp_scsisig) & SCSI_SEL)
5643 			return 0;
5644 
5645 		if (RD_HARPOON(p_port + hp_scsidata_0) != 00)
5646 			return 0;
5647 
5648 		WR_HARPOON(p_port + hp_scsisig,
5649 			   (RD_HARPOON(p_port + hp_scsisig) | SCSI_BSY));
5650 
5651 		if (RD_HARPOON(p_port + hp_scsisig) & SCSI_SEL) {
5652 
5653 			WR_HARPOON(p_port + hp_scsisig,
5654 				   (RD_HARPOON(p_port + hp_scsisig) &
5655 				    ~SCSI_BSY));
5656 			return 0;
5657 		}
5658 
5659 		WR_HARPOON(p_port + hp_scsisig,
5660 			   (RD_HARPOON(p_port + hp_scsisig) | SCSI_SEL));
5661 
5662 		if (RD_HARPOON(p_port + hp_scsidata_0) != 00) {
5663 
5664 			WR_HARPOON(p_port + hp_scsisig,
5665 				   (RD_HARPOON(p_port + hp_scsisig) &
5666 				    ~(SCSI_BSY | SCSI_SEL)));
5667 			return 0;
5668 		}
5669 	}
5670 
5671 	WR_HARPOON(p_port + hp_clkctrl_0, (RD_HARPOON(p_port + hp_clkctrl_0)
5672 					   & ~ACTdeassert));
5673 	WR_HARPOON(p_port + hp_scsireset, SCAM_EN);
5674 	WR_HARPOON(p_port + hp_scsidata_0, 0x00);
5675 	WR_HARPOON(p_port + hp_scsidata_1, 0x00);
5676 	WR_HARPOON(p_port + hp_portctrl_0, SCSI_BUS_EN);
5677 
5678 	WR_HARPOON(p_port + hp_scsisig,
5679 		   (RD_HARPOON(p_port + hp_scsisig) | SCSI_MSG));
5680 
5681 	WR_HARPOON(p_port + hp_scsisig, (RD_HARPOON(p_port + hp_scsisig)
5682 					 & ~SCSI_BSY));
5683 
5684 	FPT_Wait(p_port, TO_250ms);
5685 
5686 	return 1;
5687 }
5688 
5689 /*---------------------------------------------------------------------
5690  *
5691  * Function: FPT_scbusf
5692  *
5693  * Description: Release the SCSI bus and disable SCAM selection.
5694  *
5695  *---------------------------------------------------------------------*/
5696 
FPT_scbusf(u32 p_port)5697 static void FPT_scbusf(u32 p_port)
5698 {
5699 	WR_HARPOON(p_port + hp_page_ctrl,
5700 		   (RD_HARPOON(p_port + hp_page_ctrl) | G_INT_DISABLE));
5701 
5702 	WR_HARPOON(p_port + hp_scsidata_0, 0x00);
5703 
5704 	WR_HARPOON(p_port + hp_portctrl_0, (RD_HARPOON(p_port + hp_portctrl_0)
5705 					    & ~SCSI_BUS_EN));
5706 
5707 	WR_HARPOON(p_port + hp_scsisig, 0x00);
5708 
5709 	WR_HARPOON(p_port + hp_scsireset, (RD_HARPOON(p_port + hp_scsireset)
5710 					   & ~SCAM_EN));
5711 
5712 	WR_HARPOON(p_port + hp_clkctrl_0, (RD_HARPOON(p_port + hp_clkctrl_0)
5713 					   | ACTdeassert));
5714 
5715 	WRW_HARPOON((p_port + hp_intstat), (BUS_FREE | AUTO_INT | SCAM_SEL));
5716 
5717 	WR_HARPOON(p_port + hp_page_ctrl,
5718 		   (RD_HARPOON(p_port + hp_page_ctrl) & ~G_INT_DISABLE));
5719 }
5720 
5721 /*---------------------------------------------------------------------
5722  *
5723  * Function: FPT_scasid
5724  *
5725  * Description: Assign an ID to all the SCAM devices.
5726  *
5727  *---------------------------------------------------------------------*/
5728 
FPT_scasid(unsigned char p_card,u32 p_port)5729 static void FPT_scasid(unsigned char p_card, u32 p_port)
5730 {
5731 	unsigned char temp_id_string[ID_STRING_LENGTH];
5732 
5733 	unsigned char i, k, scam_id;
5734 	unsigned char crcBytes[3];
5735 	struct nvram_info *pCurrNvRam;
5736 	unsigned short *pCrcBytes;
5737 
5738 	pCurrNvRam = FPT_BL_Card[p_card].pNvRamInfo;
5739 
5740 	i = 0;
5741 
5742 	while (!i) {
5743 
5744 		for (k = 0; k < ID_STRING_LENGTH; k++) {
5745 			temp_id_string[k] = (unsigned char)0x00;
5746 		}
5747 
5748 		FPT_scxferc(p_port, SYNC_PTRN);
5749 		FPT_scxferc(p_port, ASSIGN_ID);
5750 
5751 		if (!(FPT_sciso(p_port, &temp_id_string[0]))) {
5752 			if (pCurrNvRam) {
5753 				pCrcBytes = (unsigned short *)&crcBytes[0];
5754 				*pCrcBytes = FPT_CalcCrc16(&temp_id_string[0]);
5755 				crcBytes[2] = FPT_CalcLrc(&temp_id_string[0]);
5756 				temp_id_string[1] = crcBytes[2];
5757 				temp_id_string[2] = crcBytes[0];
5758 				temp_id_string[3] = crcBytes[1];
5759 				for (k = 4; k < ID_STRING_LENGTH; k++)
5760 					temp_id_string[k] = (unsigned char)0x00;
5761 			}
5762 			i = FPT_scmachid(p_card, temp_id_string);
5763 
5764 			if (i == CLR_PRIORITY) {
5765 				FPT_scxferc(p_port, MISC_CODE);
5766 				FPT_scxferc(p_port, CLR_P_FLAG);
5767 				i = 0;	/*Not the last ID yet. */
5768 			}
5769 
5770 			else if (i != NO_ID_AVAIL) {
5771 				if (i < 8)
5772 					FPT_scxferc(p_port, ID_0_7);
5773 				else
5774 					FPT_scxferc(p_port, ID_8_F);
5775 
5776 				scam_id = (i & (unsigned char)0x07);
5777 
5778 				for (k = 1; k < 0x08; k <<= 1)
5779 					if (!(k & i))
5780 						scam_id += 0x08;	/*Count number of zeros in DB0-3. */
5781 
5782 				FPT_scxferc(p_port, scam_id);
5783 
5784 				i = 0;	/*Not the last ID yet. */
5785 			}
5786 		}
5787 
5788 		else {
5789 			i = 1;
5790 		}
5791 
5792 	}			/*End while */
5793 
5794 	FPT_scxferc(p_port, SYNC_PTRN);
5795 	FPT_scxferc(p_port, CFG_CMPLT);
5796 }
5797 
5798 /*---------------------------------------------------------------------
5799  *
5800  * Function: FPT_scsel
5801  *
5802  * Description: Select all the SCAM devices.
5803  *
5804  *---------------------------------------------------------------------*/
5805 
FPT_scsel(u32 p_port)5806 static void FPT_scsel(u32 p_port)
5807 {
5808 
5809 	WR_HARPOON(p_port + hp_scsisig, SCSI_SEL);
5810 	FPT_scwiros(p_port, SCSI_MSG);
5811 
5812 	WR_HARPOON(p_port + hp_scsisig, (SCSI_SEL | SCSI_BSY));
5813 
5814 	WR_HARPOON(p_port + hp_scsisig,
5815 		   (SCSI_SEL | SCSI_BSY | SCSI_IOBIT | SCSI_CD));
5816 	WR_HARPOON(p_port + hp_scsidata_0,
5817 		   (unsigned char)(RD_HARPOON(p_port + hp_scsidata_0) |
5818 				   (unsigned char)(BIT(7) + BIT(6))));
5819 
5820 	WR_HARPOON(p_port + hp_scsisig, (SCSI_BSY | SCSI_IOBIT | SCSI_CD));
5821 	FPT_scwiros(p_port, SCSI_SEL);
5822 
5823 	WR_HARPOON(p_port + hp_scsidata_0,
5824 		   (unsigned char)(RD_HARPOON(p_port + hp_scsidata_0) &
5825 				   ~(unsigned char)BIT(6)));
5826 	FPT_scwirod(p_port, BIT(6));
5827 
5828 	WR_HARPOON(p_port + hp_scsisig,
5829 		   (SCSI_SEL | SCSI_BSY | SCSI_IOBIT | SCSI_CD));
5830 }
5831 
5832 /*---------------------------------------------------------------------
5833  *
5834  * Function: FPT_scxferc
5835  *
5836  * Description: Handshake the p_data (DB4-0) across the bus.
5837  *
5838  *---------------------------------------------------------------------*/
5839 
FPT_scxferc(u32 p_port,unsigned char p_data)5840 static unsigned char FPT_scxferc(u32 p_port, unsigned char p_data)
5841 {
5842 	unsigned char curr_data, ret_data;
5843 
5844 	curr_data = p_data | BIT(7) | BIT(5);	/*Start with DB7 & DB5 asserted. */
5845 
5846 	WR_HARPOON(p_port + hp_scsidata_0, curr_data);
5847 
5848 	curr_data &= ~BIT(7);
5849 
5850 	WR_HARPOON(p_port + hp_scsidata_0, curr_data);
5851 
5852 	FPT_scwirod(p_port, BIT(7));	/*Wait for DB7 to be released. */
5853 	while (!(RD_HARPOON(p_port + hp_scsidata_0) & BIT(5))) ;
5854 
5855 	ret_data = (RD_HARPOON(p_port + hp_scsidata_0) & (unsigned char)0x1F);
5856 
5857 	curr_data |= BIT(6);
5858 
5859 	WR_HARPOON(p_port + hp_scsidata_0, curr_data);
5860 
5861 	curr_data &= ~BIT(5);
5862 
5863 	WR_HARPOON(p_port + hp_scsidata_0, curr_data);
5864 
5865 	FPT_scwirod(p_port, BIT(5));	/*Wait for DB5 to be released. */
5866 
5867 	curr_data &= ~(BIT(4) | BIT(3) | BIT(2) | BIT(1) | BIT(0));	/*Release data bits */
5868 	curr_data |= BIT(7);
5869 
5870 	WR_HARPOON(p_port + hp_scsidata_0, curr_data);
5871 
5872 	curr_data &= ~BIT(6);
5873 
5874 	WR_HARPOON(p_port + hp_scsidata_0, curr_data);
5875 
5876 	FPT_scwirod(p_port, BIT(6));	/*Wait for DB6 to be released. */
5877 
5878 	return ret_data;
5879 }
5880 
5881 /*---------------------------------------------------------------------
5882  *
5883  * Function: FPT_scsendi
5884  *
5885  * Description: Transfer our Identification string to determine if we
5886  *              will be the dominant master.
5887  *
5888  *---------------------------------------------------------------------*/
5889 
FPT_scsendi(u32 p_port,unsigned char p_id_string[])5890 static unsigned char FPT_scsendi(u32 p_port, unsigned char p_id_string[])
5891 {
5892 	unsigned char ret_data, byte_cnt, bit_cnt, defer;
5893 
5894 	defer = 0;
5895 
5896 	for (byte_cnt = 0; byte_cnt < ID_STRING_LENGTH; byte_cnt++) {
5897 
5898 		for (bit_cnt = 0x80; bit_cnt != 0; bit_cnt >>= 1) {
5899 
5900 			if (defer)
5901 				ret_data = FPT_scxferc(p_port, 00);
5902 
5903 			else if (p_id_string[byte_cnt] & bit_cnt)
5904 
5905 				ret_data = FPT_scxferc(p_port, 02);
5906 
5907 			else {
5908 
5909 				ret_data = FPT_scxferc(p_port, 01);
5910 				if (ret_data & 02)
5911 					defer = 1;
5912 			}
5913 
5914 			if ((ret_data & 0x1C) == 0x10)
5915 				return 0x00;	/*End of isolation stage, we won! */
5916 
5917 			if (ret_data & 0x1C)
5918 				return 0xFF;
5919 
5920 			if ((defer) && (!(ret_data & 0x1F)))
5921 				return 0x01;	/*End of isolation stage, we lost. */
5922 
5923 		}		/*bit loop */
5924 
5925 	}			/*byte loop */
5926 
5927 	if (defer)
5928 		return 0x01;	/*We lost */
5929 	else
5930 		return 0;	/*We WON! Yeeessss! */
5931 }
5932 
5933 /*---------------------------------------------------------------------
5934  *
5935  * Function: FPT_sciso
5936  *
5937  * Description: Transfer the Identification string.
5938  *
5939  *---------------------------------------------------------------------*/
5940 
FPT_sciso(u32 p_port,unsigned char p_id_string[])5941 static unsigned char FPT_sciso(u32 p_port, unsigned char p_id_string[])
5942 {
5943 	unsigned char ret_data, the_data, byte_cnt, bit_cnt;
5944 
5945 	the_data = 0;
5946 
5947 	for (byte_cnt = 0; byte_cnt < ID_STRING_LENGTH; byte_cnt++) {
5948 
5949 		for (bit_cnt = 0; bit_cnt < 8; bit_cnt++) {
5950 
5951 			ret_data = FPT_scxferc(p_port, 0);
5952 
5953 			if (ret_data & 0xFC)
5954 				return 0xFF;
5955 
5956 			else {
5957 
5958 				the_data <<= 1;
5959 				if (ret_data & BIT(1)) {
5960 					the_data |= 1;
5961 				}
5962 			}
5963 
5964 			if ((ret_data & 0x1F) == 0) {
5965 /*
5966 				if(bit_cnt != 0 || bit_cnt != 8)
5967 				{
5968 					byte_cnt = 0;
5969 					bit_cnt = 0;
5970 					FPT_scxferc(p_port, SYNC_PTRN);
5971 					FPT_scxferc(p_port, ASSIGN_ID);
5972 					continue;
5973 				}
5974 */
5975 				if (byte_cnt)
5976 					return 0x00;
5977 				else
5978 					return 0xFF;
5979 			}
5980 
5981 		}		/*bit loop */
5982 
5983 		p_id_string[byte_cnt] = the_data;
5984 
5985 	}			/*byte loop */
5986 
5987 	return 0;
5988 }
5989 
5990 /*---------------------------------------------------------------------
5991  *
5992  * Function: FPT_scwirod
5993  *
5994  * Description: Sample the SCSI data bus making sure the signal has been
5995  *              deasserted for the correct number of consecutive samples.
5996  *
5997  *---------------------------------------------------------------------*/
5998 
FPT_scwirod(u32 p_port,unsigned char p_data_bit)5999 static void FPT_scwirod(u32 p_port, unsigned char p_data_bit)
6000 {
6001 	unsigned char i;
6002 
6003 	i = 0;
6004 	while (i < MAX_SCSI_TAR) {
6005 
6006 		if (RD_HARPOON(p_port + hp_scsidata_0) & p_data_bit)
6007 
6008 			i = 0;
6009 
6010 		else
6011 
6012 			i++;
6013 
6014 	}
6015 }
6016 
6017 /*---------------------------------------------------------------------
6018  *
6019  * Function: FPT_scwiros
6020  *
6021  * Description: Sample the SCSI Signal lines making sure the signal has been
6022  *              deasserted for the correct number of consecutive samples.
6023  *
6024  *---------------------------------------------------------------------*/
6025 
FPT_scwiros(u32 p_port,unsigned char p_data_bit)6026 static void FPT_scwiros(u32 p_port, unsigned char p_data_bit)
6027 {
6028 	unsigned char i;
6029 
6030 	i = 0;
6031 	while (i < MAX_SCSI_TAR) {
6032 
6033 		if (RD_HARPOON(p_port + hp_scsisig) & p_data_bit)
6034 
6035 			i = 0;
6036 
6037 		else
6038 
6039 			i++;
6040 
6041 	}
6042 }
6043 
6044 /*---------------------------------------------------------------------
6045  *
6046  * Function: FPT_scvalq
6047  *
6048  * Description: Make sure we received a valid data byte.
6049  *
6050  *---------------------------------------------------------------------*/
6051 
FPT_scvalq(unsigned char p_quintet)6052 static unsigned char FPT_scvalq(unsigned char p_quintet)
6053 {
6054 	unsigned char count;
6055 
6056 	for (count = 1; count < 0x08; count <<= 1) {
6057 		if (!(p_quintet & count))
6058 			p_quintet -= 0x80;
6059 	}
6060 
6061 	if (p_quintet & 0x18)
6062 		return 0;
6063 
6064 	else
6065 		return 1;
6066 }
6067 
6068 /*---------------------------------------------------------------------
6069  *
6070  * Function: FPT_scsell
6071  *
6072  * Description: Select the specified device ID using a selection timeout
6073  *              less than 4ms.  If somebody responds then it is a legacy
6074  *              drive and this ID must be marked as such.
6075  *
6076  *---------------------------------------------------------------------*/
6077 
FPT_scsell(u32 p_port,unsigned char targ_id)6078 static unsigned char FPT_scsell(u32 p_port, unsigned char targ_id)
6079 {
6080 	unsigned long i;
6081 
6082 	WR_HARPOON(p_port + hp_page_ctrl,
6083 		   (RD_HARPOON(p_port + hp_page_ctrl) | G_INT_DISABLE));
6084 
6085 	ARAM_ACCESS(p_port);
6086 
6087 	WR_HARPOON(p_port + hp_addstat,
6088 		   (RD_HARPOON(p_port + hp_addstat) | SCAM_TIMER));
6089 	WR_HARPOON(p_port + hp_seltimeout, TO_4ms);
6090 
6091 	for (i = p_port + CMD_STRT; i < p_port + CMD_STRT + 12; i += 2) {
6092 		WRW_HARPOON(i, (MPM_OP + ACOMMAND));
6093 	}
6094 	WRW_HARPOON(i, (BRH_OP + ALWAYS + NP));
6095 
6096 	WRW_HARPOON((p_port + hp_intstat),
6097 		    (RESET | TIMEOUT | SEL | BUS_FREE | AUTO_INT));
6098 
6099 	WR_HARPOON(p_port + hp_select_id, targ_id);
6100 
6101 	WR_HARPOON(p_port + hp_portctrl_0, SCSI_PORT);
6102 	WR_HARPOON(p_port + hp_autostart_3, (SELECT | CMD_ONLY_STRT));
6103 	WR_HARPOON(p_port + hp_scsictrl_0, (SEL_TAR | ENA_RESEL));
6104 
6105 	while (!(RDW_HARPOON((p_port + hp_intstat)) &
6106 		 (RESET | PROG_HLT | TIMEOUT | AUTO_INT))) {
6107 	}
6108 
6109 	if (RDW_HARPOON((p_port + hp_intstat)) & RESET)
6110 		FPT_Wait(p_port, TO_250ms);
6111 
6112 	DISABLE_AUTO(p_port);
6113 
6114 	WR_HARPOON(p_port + hp_addstat,
6115 		   (RD_HARPOON(p_port + hp_addstat) & ~SCAM_TIMER));
6116 	WR_HARPOON(p_port + hp_seltimeout, TO_290ms);
6117 
6118 	SGRAM_ACCESS(p_port);
6119 
6120 	if (RDW_HARPOON((p_port + hp_intstat)) & (RESET | TIMEOUT)) {
6121 
6122 		WRW_HARPOON((p_port + hp_intstat),
6123 			    (RESET | TIMEOUT | SEL | BUS_FREE | PHASE));
6124 
6125 		WR_HARPOON(p_port + hp_page_ctrl,
6126 			   (RD_HARPOON(p_port + hp_page_ctrl) &
6127 			    ~G_INT_DISABLE));
6128 
6129 		return 0;	/*No legacy device */
6130 	}
6131 
6132 	else {
6133 
6134 		while (!(RDW_HARPOON((p_port + hp_intstat)) & BUS_FREE)) {
6135 			if (RD_HARPOON(p_port + hp_scsisig) & SCSI_REQ) {
6136 				WR_HARPOON(p_port + hp_scsisig,
6137 					   (SCSI_ACK + S_ILL_PH));
6138 				ACCEPT_MSG(p_port);
6139 			}
6140 		}
6141 
6142 		WRW_HARPOON((p_port + hp_intstat), CLR_ALL_INT_1);
6143 
6144 		WR_HARPOON(p_port + hp_page_ctrl,
6145 			   (RD_HARPOON(p_port + hp_page_ctrl) &
6146 			    ~G_INT_DISABLE));
6147 
6148 		return 1;	/*Found one of them oldies! */
6149 	}
6150 }
6151 
6152 /*---------------------------------------------------------------------
6153  *
6154  * Function: FPT_scwtsel
6155  *
6156  * Description: Wait to be selected by another SCAM initiator.
6157  *
6158  *---------------------------------------------------------------------*/
6159 
FPT_scwtsel(u32 p_port)6160 static void FPT_scwtsel(u32 p_port)
6161 {
6162 	while (!(RDW_HARPOON((p_port + hp_intstat)) & SCAM_SEL)) {
6163 	}
6164 }
6165 
6166 /*---------------------------------------------------------------------
6167  *
6168  * Function: FPT_inisci
6169  *
6170  * Description: Setup the data Structure with the info from the EEPROM.
6171  *
6172  *---------------------------------------------------------------------*/
6173 
FPT_inisci(unsigned char p_card,u32 p_port,unsigned char p_our_id)6174 static void FPT_inisci(unsigned char p_card, u32 p_port, unsigned char p_our_id)
6175 {
6176 	unsigned char i, k, max_id;
6177 	unsigned short ee_data;
6178 	struct nvram_info *pCurrNvRam;
6179 
6180 	pCurrNvRam = FPT_BL_Card[p_card].pNvRamInfo;
6181 
6182 	if (RD_HARPOON(p_port + hp_page_ctrl) & NARROW_SCSI_CARD)
6183 		max_id = 0x08;
6184 
6185 	else
6186 		max_id = 0x10;
6187 
6188 	if (pCurrNvRam) {
6189 		for (i = 0; i < max_id; i++) {
6190 
6191 			for (k = 0; k < 4; k++)
6192 				FPT_scamInfo[i].id_string[k] =
6193 				    pCurrNvRam->niScamTbl[i][k];
6194 			for (k = 4; k < ID_STRING_LENGTH; k++)
6195 				FPT_scamInfo[i].id_string[k] =
6196 				    (unsigned char)0x00;
6197 
6198 			if (FPT_scamInfo[i].id_string[0] == 0x00)
6199 				FPT_scamInfo[i].state = ID_UNUSED;	/*Default to unused ID. */
6200 			else
6201 				FPT_scamInfo[i].state = ID_UNASSIGNED;	/*Default to unassigned ID. */
6202 
6203 		}
6204 	} else {
6205 		for (i = 0; i < max_id; i++) {
6206 			for (k = 0; k < ID_STRING_LENGTH; k += 2) {
6207 				ee_data =
6208 				    FPT_utilEERead(p_port,
6209 						   (unsigned
6210 						    short)((EE_SCAMBASE / 2) +
6211 							   (unsigned short)(i *
6212 									    ((unsigned short)ID_STRING_LENGTH / 2)) + (unsigned short)(k / 2)));
6213 				FPT_scamInfo[i].id_string[k] =
6214 				    (unsigned char)ee_data;
6215 				ee_data >>= 8;
6216 				FPT_scamInfo[i].id_string[k + 1] =
6217 				    (unsigned char)ee_data;
6218 			}
6219 
6220 			if ((FPT_scamInfo[i].id_string[0] == 0x00) ||
6221 			    (FPT_scamInfo[i].id_string[0] == 0xFF))
6222 
6223 				FPT_scamInfo[i].state = ID_UNUSED;	/*Default to unused ID. */
6224 
6225 			else
6226 				FPT_scamInfo[i].state = ID_UNASSIGNED;	/*Default to unassigned ID. */
6227 
6228 		}
6229 	}
6230 	for (k = 0; k < ID_STRING_LENGTH; k++)
6231 		FPT_scamInfo[p_our_id].id_string[k] = FPT_scamHAString[k];
6232 
6233 }
6234 
6235 /*---------------------------------------------------------------------
6236  *
6237  * Function: FPT_scmachid
6238  *
6239  * Description: Match the Device ID string with our values stored in
6240  *              the EEPROM.
6241  *
6242  *---------------------------------------------------------------------*/
6243 
FPT_scmachid(unsigned char p_card,unsigned char p_id_string[])6244 static unsigned char FPT_scmachid(unsigned char p_card,
6245 				  unsigned char p_id_string[])
6246 {
6247 
6248 	unsigned char i, k, match;
6249 
6250 	for (i = 0; i < MAX_SCSI_TAR; i++) {
6251 
6252 		match = 1;
6253 
6254 		for (k = 0; k < ID_STRING_LENGTH; k++) {
6255 			if (p_id_string[k] != FPT_scamInfo[i].id_string[k])
6256 				match = 0;
6257 		}
6258 
6259 		if (match) {
6260 			FPT_scamInfo[i].state = ID_ASSIGNED;
6261 			return i;
6262 		}
6263 
6264 	}
6265 
6266 	if (p_id_string[0] & BIT(5))
6267 		i = 8;
6268 	else
6269 		i = MAX_SCSI_TAR;
6270 
6271 	if (((p_id_string[0] & 0x06) == 0x02)
6272 	    || ((p_id_string[0] & 0x06) == 0x04))
6273 		match = p_id_string[1] & (unsigned char)0x1F;
6274 	else
6275 		match = 7;
6276 
6277 	while (i > 0) {
6278 		i--;
6279 
6280 		if (FPT_scamInfo[match].state == ID_UNUSED) {
6281 			for (k = 0; k < ID_STRING_LENGTH; k++) {
6282 				FPT_scamInfo[match].id_string[k] =
6283 				    p_id_string[k];
6284 			}
6285 
6286 			FPT_scamInfo[match].state = ID_ASSIGNED;
6287 
6288 			if (FPT_BL_Card[p_card].pNvRamInfo == NULL)
6289 				FPT_BL_Card[p_card].globalFlags |=
6290 				    F_UPDATE_EEPROM;
6291 			return match;
6292 
6293 		}
6294 
6295 		match--;
6296 
6297 		if (match == 0xFF) {
6298 			if (p_id_string[0] & BIT(5))
6299 				match = 7;
6300 			else
6301 				match = MAX_SCSI_TAR - 1;
6302 		}
6303 	}
6304 
6305 	if (p_id_string[0] & BIT(7)) {
6306 		return CLR_PRIORITY;
6307 	}
6308 
6309 	if (p_id_string[0] & BIT(5))
6310 		i = 8;
6311 	else
6312 		i = MAX_SCSI_TAR;
6313 
6314 	if (((p_id_string[0] & 0x06) == 0x02)
6315 	    || ((p_id_string[0] & 0x06) == 0x04))
6316 		match = p_id_string[1] & (unsigned char)0x1F;
6317 	else
6318 		match = 7;
6319 
6320 	while (i > 0) {
6321 
6322 		i--;
6323 
6324 		if (FPT_scamInfo[match].state == ID_UNASSIGNED) {
6325 			for (k = 0; k < ID_STRING_LENGTH; k++) {
6326 				FPT_scamInfo[match].id_string[k] =
6327 				    p_id_string[k];
6328 			}
6329 
6330 			FPT_scamInfo[match].id_string[0] |= BIT(7);
6331 			FPT_scamInfo[match].state = ID_ASSIGNED;
6332 			if (FPT_BL_Card[p_card].pNvRamInfo == NULL)
6333 				FPT_BL_Card[p_card].globalFlags |=
6334 				    F_UPDATE_EEPROM;
6335 			return match;
6336 
6337 		}
6338 
6339 		match--;
6340 
6341 		if (match == 0xFF) {
6342 			if (p_id_string[0] & BIT(5))
6343 				match = 7;
6344 			else
6345 				match = MAX_SCSI_TAR - 1;
6346 		}
6347 	}
6348 
6349 	return NO_ID_AVAIL;
6350 }
6351 
6352 /*---------------------------------------------------------------------
6353  *
6354  * Function: FPT_scsavdi
6355  *
6356  * Description: Save off the device SCAM ID strings.
6357  *
6358  *---------------------------------------------------------------------*/
6359 
FPT_scsavdi(unsigned char p_card,u32 p_port)6360 static void FPT_scsavdi(unsigned char p_card, u32 p_port)
6361 {
6362 	unsigned char i, k, max_id;
6363 	unsigned short ee_data, sum_data;
6364 
6365 	sum_data = 0x0000;
6366 
6367 	for (i = 1; i < EE_SCAMBASE / 2; i++) {
6368 		sum_data += FPT_utilEERead(p_port, i);
6369 	}
6370 
6371 	FPT_utilEEWriteOnOff(p_port, 1);	/* Enable write access to the EEPROM */
6372 
6373 	if (RD_HARPOON(p_port + hp_page_ctrl) & NARROW_SCSI_CARD)
6374 		max_id = 0x08;
6375 
6376 	else
6377 		max_id = 0x10;
6378 
6379 	for (i = 0; i < max_id; i++) {
6380 
6381 		for (k = 0; k < ID_STRING_LENGTH; k += 2) {
6382 			ee_data = FPT_scamInfo[i].id_string[k + 1];
6383 			ee_data <<= 8;
6384 			ee_data |= FPT_scamInfo[i].id_string[k];
6385 			sum_data += ee_data;
6386 			FPT_utilEEWrite(p_port, ee_data,
6387 					(unsigned short)((EE_SCAMBASE / 2) +
6388 							 (unsigned short)(i *
6389 									  ((unsigned short)ID_STRING_LENGTH / 2)) + (unsigned short)(k / 2)));
6390 		}
6391 	}
6392 
6393 	FPT_utilEEWrite(p_port, sum_data, EEPROM_CHECK_SUM / 2);
6394 	FPT_utilEEWriteOnOff(p_port, 0);	/* Turn off write access */
6395 }
6396 
6397 /*---------------------------------------------------------------------
6398  *
6399  * Function: FPT_XbowInit
6400  *
6401  * Description: Setup the Xbow for normal operation.
6402  *
6403  *---------------------------------------------------------------------*/
6404 
FPT_XbowInit(u32 port,unsigned char ScamFlg)6405 static void FPT_XbowInit(u32 port, unsigned char ScamFlg)
6406 {
6407 	unsigned char i;
6408 
6409 	i = RD_HARPOON(port + hp_page_ctrl);
6410 	WR_HARPOON(port + hp_page_ctrl, (unsigned char)(i | G_INT_DISABLE));
6411 
6412 	WR_HARPOON(port + hp_scsireset, 0x00);
6413 	WR_HARPOON(port + hp_portctrl_1, HOST_MODE8);
6414 
6415 	WR_HARPOON(port + hp_scsireset, (DMA_RESET | HPSCSI_RESET | PROG_RESET |
6416 					 FIFO_CLR));
6417 
6418 	WR_HARPOON(port + hp_scsireset, SCSI_INI);
6419 
6420 	WR_HARPOON(port + hp_clkctrl_0, CLKCTRL_DEFAULT);
6421 
6422 	WR_HARPOON(port + hp_scsisig, 0x00);	/*  Clear any signals we might */
6423 	WR_HARPOON(port + hp_scsictrl_0, ENA_SCAM_SEL);
6424 
6425 	WRW_HARPOON((port + hp_intstat), CLR_ALL_INT);
6426 
6427 	FPT_default_intena = RESET | RSEL | PROG_HLT | TIMEOUT |
6428 	    BUS_FREE | XFER_CNT_0 | AUTO_INT;
6429 
6430 	if ((ScamFlg & SCAM_ENABLED) && (ScamFlg & SCAM_LEVEL2))
6431 		FPT_default_intena |= SCAM_SEL;
6432 
6433 	WRW_HARPOON((port + hp_intena), FPT_default_intena);
6434 
6435 	WR_HARPOON(port + hp_seltimeout, TO_290ms);
6436 
6437 	/* Turn on SCSI_MODE8 for narrow cards to fix the
6438 	   strapping issue with the DUAL CHANNEL card */
6439 	if (RD_HARPOON(port + hp_page_ctrl) & NARROW_SCSI_CARD)
6440 		WR_HARPOON(port + hp_addstat, SCSI_MODE8);
6441 
6442 	WR_HARPOON(port + hp_page_ctrl, i);
6443 
6444 }
6445 
6446 /*---------------------------------------------------------------------
6447  *
6448  * Function: FPT_BusMasterInit
6449  *
6450  * Description: Initialize the BusMaster for normal operations.
6451  *
6452  *---------------------------------------------------------------------*/
6453 
FPT_BusMasterInit(u32 p_port)6454 static void FPT_BusMasterInit(u32 p_port)
6455 {
6456 
6457 	WR_HARPOON(p_port + hp_sys_ctrl, DRVR_RST);
6458 	WR_HARPOON(p_port + hp_sys_ctrl, 0x00);
6459 
6460 	WR_HARPOON(p_port + hp_host_blk_cnt, XFER_BLK64);
6461 
6462 	WR_HARPOON(p_port + hp_bm_ctrl, (BMCTRL_DEFAULT));
6463 
6464 	WR_HARPOON(p_port + hp_ee_ctrl, (SCSI_TERM_ENA_H));
6465 
6466 	RD_HARPOON(p_port + hp_int_status);	/*Clear interrupts. */
6467 	WR_HARPOON(p_port + hp_int_mask, (INT_CMD_COMPL | SCSI_INTERRUPT));
6468 	WR_HARPOON(p_port + hp_page_ctrl, (RD_HARPOON(p_port + hp_page_ctrl) &
6469 					   ~SCATTER_EN));
6470 }
6471 
6472 /*---------------------------------------------------------------------
6473  *
6474  * Function: FPT_DiagEEPROM
6475  *
6476  * Description: Verfiy checksum and 'Key' and initialize the EEPROM if
6477  *              necessary.
6478  *
6479  *---------------------------------------------------------------------*/
6480 
FPT_DiagEEPROM(u32 p_port)6481 static void FPT_DiagEEPROM(u32 p_port)
6482 {
6483 	unsigned short index, temp, max_wd_cnt;
6484 
6485 	if (RD_HARPOON(p_port + hp_page_ctrl) & NARROW_SCSI_CARD)
6486 		max_wd_cnt = EEPROM_WD_CNT;
6487 	else
6488 		max_wd_cnt = EEPROM_WD_CNT * 2;
6489 
6490 	temp = FPT_utilEERead(p_port, FW_SIGNATURE / 2);
6491 
6492 	if (temp == 0x4641) {
6493 
6494 		for (index = 2; index < max_wd_cnt; index++) {
6495 
6496 			temp += FPT_utilEERead(p_port, index);
6497 
6498 		}
6499 
6500 		if (temp == FPT_utilEERead(p_port, EEPROM_CHECK_SUM / 2)) {
6501 
6502 			return;	/*EEPROM is Okay so return now! */
6503 		}
6504 	}
6505 
6506 	FPT_utilEEWriteOnOff(p_port, (unsigned char)1);
6507 
6508 	for (index = 0; index < max_wd_cnt; index++) {
6509 
6510 		FPT_utilEEWrite(p_port, 0x0000, index);
6511 	}
6512 
6513 	temp = 0;
6514 
6515 	FPT_utilEEWrite(p_port, 0x4641, FW_SIGNATURE / 2);
6516 	temp += 0x4641;
6517 	FPT_utilEEWrite(p_port, 0x3920, MODEL_NUMB_0 / 2);
6518 	temp += 0x3920;
6519 	FPT_utilEEWrite(p_port, 0x3033, MODEL_NUMB_2 / 2);
6520 	temp += 0x3033;
6521 	FPT_utilEEWrite(p_port, 0x2020, MODEL_NUMB_4 / 2);
6522 	temp += 0x2020;
6523 	FPT_utilEEWrite(p_port, 0x70D3, SYSTEM_CONFIG / 2);
6524 	temp += 0x70D3;
6525 	FPT_utilEEWrite(p_port, 0x0010, BIOS_CONFIG / 2);
6526 	temp += 0x0010;
6527 	FPT_utilEEWrite(p_port, 0x0003, SCAM_CONFIG / 2);
6528 	temp += 0x0003;
6529 	FPT_utilEEWrite(p_port, 0x0007, ADAPTER_SCSI_ID / 2);
6530 	temp += 0x0007;
6531 
6532 	FPT_utilEEWrite(p_port, 0x0000, IGNORE_B_SCAN / 2);
6533 	temp += 0x0000;
6534 	FPT_utilEEWrite(p_port, 0x0000, SEND_START_ENA / 2);
6535 	temp += 0x0000;
6536 	FPT_utilEEWrite(p_port, 0x0000, DEVICE_ENABLE / 2);
6537 	temp += 0x0000;
6538 
6539 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBL01 / 2);
6540 	temp += 0x4242;
6541 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBL23 / 2);
6542 	temp += 0x4242;
6543 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBL45 / 2);
6544 	temp += 0x4242;
6545 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBL67 / 2);
6546 	temp += 0x4242;
6547 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBL89 / 2);
6548 	temp += 0x4242;
6549 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBLab / 2);
6550 	temp += 0x4242;
6551 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBLcd / 2);
6552 	temp += 0x4242;
6553 	FPT_utilEEWrite(p_port, 0x4242, SYNC_RATE_TBLef / 2);
6554 	temp += 0x4242;
6555 
6556 	FPT_utilEEWrite(p_port, 0x6C46, 64 / 2);	/*PRODUCT ID */
6557 	temp += 0x6C46;
6558 	FPT_utilEEWrite(p_port, 0x7361, 66 / 2);	/* FlashPoint LT   */
6559 	temp += 0x7361;
6560 	FPT_utilEEWrite(p_port, 0x5068, 68 / 2);
6561 	temp += 0x5068;
6562 	FPT_utilEEWrite(p_port, 0x696F, 70 / 2);
6563 	temp += 0x696F;
6564 	FPT_utilEEWrite(p_port, 0x746E, 72 / 2);
6565 	temp += 0x746E;
6566 	FPT_utilEEWrite(p_port, 0x4C20, 74 / 2);
6567 	temp += 0x4C20;
6568 	FPT_utilEEWrite(p_port, 0x2054, 76 / 2);
6569 	temp += 0x2054;
6570 	FPT_utilEEWrite(p_port, 0x2020, 78 / 2);
6571 	temp += 0x2020;
6572 
6573 	index = ((EE_SCAMBASE / 2) + (7 * 16));
6574 	FPT_utilEEWrite(p_port, (0x0700 + TYPE_CODE0), index);
6575 	temp += (0x0700 + TYPE_CODE0);
6576 	index++;
6577 	FPT_utilEEWrite(p_port, 0x5542, index);	/*Vendor ID code */
6578 	temp += 0x5542;		/* BUSLOGIC      */
6579 	index++;
6580 	FPT_utilEEWrite(p_port, 0x4C53, index);
6581 	temp += 0x4C53;
6582 	index++;
6583 	FPT_utilEEWrite(p_port, 0x474F, index);
6584 	temp += 0x474F;
6585 	index++;
6586 	FPT_utilEEWrite(p_port, 0x4349, index);
6587 	temp += 0x4349;
6588 	index++;
6589 	FPT_utilEEWrite(p_port, 0x5442, index);	/*Vendor unique code */
6590 	temp += 0x5442;		/* BT- 930           */
6591 	index++;
6592 	FPT_utilEEWrite(p_port, 0x202D, index);
6593 	temp += 0x202D;
6594 	index++;
6595 	FPT_utilEEWrite(p_port, 0x3339, index);
6596 	temp += 0x3339;
6597 	index++;		/*Serial #          */
6598 	FPT_utilEEWrite(p_port, 0x2030, index);	/* 01234567         */
6599 	temp += 0x2030;
6600 	index++;
6601 	FPT_utilEEWrite(p_port, 0x5453, index);
6602 	temp += 0x5453;
6603 	index++;
6604 	FPT_utilEEWrite(p_port, 0x5645, index);
6605 	temp += 0x5645;
6606 	index++;
6607 	FPT_utilEEWrite(p_port, 0x2045, index);
6608 	temp += 0x2045;
6609 	index++;
6610 	FPT_utilEEWrite(p_port, 0x202F, index);
6611 	temp += 0x202F;
6612 	index++;
6613 	FPT_utilEEWrite(p_port, 0x4F4A, index);
6614 	temp += 0x4F4A;
6615 	index++;
6616 	FPT_utilEEWrite(p_port, 0x204E, index);
6617 	temp += 0x204E;
6618 	index++;
6619 	FPT_utilEEWrite(p_port, 0x3539, index);
6620 	temp += 0x3539;
6621 
6622 	FPT_utilEEWrite(p_port, temp, EEPROM_CHECK_SUM / 2);
6623 
6624 	FPT_utilEEWriteOnOff(p_port, (unsigned char)0);
6625 
6626 }
6627 
6628 /*---------------------------------------------------------------------
6629  *
6630  * Function: Queue Search Select
6631  *
6632  * Description: Try to find a new command to execute.
6633  *
6634  *---------------------------------------------------------------------*/
6635 
FPT_queueSearchSelect(struct sccb_card * pCurrCard,unsigned char p_card)6636 static void FPT_queueSearchSelect(struct sccb_card *pCurrCard,
6637 				  unsigned char p_card)
6638 {
6639 	unsigned char scan_ptr, lun;
6640 	struct sccb_mgr_tar_info *currTar_Info;
6641 	struct sccb *pOldSccb;
6642 
6643 	scan_ptr = pCurrCard->scanIndex;
6644 	do {
6645 		currTar_Info = &FPT_sccbMgrTbl[p_card][scan_ptr];
6646 		if ((pCurrCard->globalFlags & F_CONLUN_IO) &&
6647 		    ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) !=
6648 		     TAG_Q_TRYING)) {
6649 			if (currTar_Info->TarSelQ_Cnt != 0) {
6650 
6651 				scan_ptr++;
6652 				if (scan_ptr == MAX_SCSI_TAR)
6653 					scan_ptr = 0;
6654 
6655 				for (lun = 0; lun < MAX_LUN; lun++) {
6656 					if (currTar_Info->TarLUNBusy[lun] == 0) {
6657 
6658 						pCurrCard->currentSCCB =
6659 						    currTar_Info->TarSelQ_Head;
6660 						pOldSccb = NULL;
6661 
6662 						while ((pCurrCard->
6663 							currentSCCB != NULL)
6664 						       && (lun !=
6665 							   pCurrCard->
6666 							   currentSCCB->Lun)) {
6667 							pOldSccb =
6668 							    pCurrCard->
6669 							    currentSCCB;
6670 							pCurrCard->currentSCCB =
6671 							    (struct sccb
6672 							     *)(pCurrCard->
6673 								currentSCCB)->
6674 							    Sccb_forwardlink;
6675 						}
6676 						if (pCurrCard->currentSCCB ==
6677 						    NULL)
6678 							continue;
6679 						if (pOldSccb != NULL) {
6680 							pOldSccb->
6681 							    Sccb_forwardlink =
6682 							    (struct sccb
6683 							     *)(pCurrCard->
6684 								currentSCCB)->
6685 							    Sccb_forwardlink;
6686 							pOldSccb->
6687 							    Sccb_backlink =
6688 							    (struct sccb
6689 							     *)(pCurrCard->
6690 								currentSCCB)->
6691 							    Sccb_backlink;
6692 							currTar_Info->
6693 							    TarSelQ_Cnt--;
6694 						} else {
6695 							currTar_Info->
6696 							    TarSelQ_Head =
6697 							    (struct sccb
6698 							     *)(pCurrCard->
6699 								currentSCCB)->
6700 							    Sccb_forwardlink;
6701 
6702 							if (currTar_Info->
6703 							    TarSelQ_Head ==
6704 							    NULL) {
6705 								currTar_Info->
6706 								    TarSelQ_Tail
6707 								    = NULL;
6708 								currTar_Info->
6709 								    TarSelQ_Cnt
6710 								    = 0;
6711 							} else {
6712 								currTar_Info->
6713 								    TarSelQ_Cnt--;
6714 								currTar_Info->
6715 								    TarSelQ_Head->
6716 								    Sccb_backlink
6717 								    =
6718 								    (struct sccb
6719 								     *)NULL;
6720 							}
6721 						}
6722 						pCurrCard->scanIndex = scan_ptr;
6723 
6724 						pCurrCard->globalFlags |=
6725 						    F_NEW_SCCB_CMD;
6726 
6727 						break;
6728 					}
6729 				}
6730 			}
6731 
6732 			else {
6733 				scan_ptr++;
6734 				if (scan_ptr == MAX_SCSI_TAR) {
6735 					scan_ptr = 0;
6736 				}
6737 			}
6738 
6739 		} else {
6740 			if ((currTar_Info->TarSelQ_Cnt != 0) &&
6741 			    (currTar_Info->TarLUNBusy[0] == 0)) {
6742 
6743 				pCurrCard->currentSCCB =
6744 				    currTar_Info->TarSelQ_Head;
6745 
6746 				currTar_Info->TarSelQ_Head =
6747 				    (struct sccb *)(pCurrCard->currentSCCB)->
6748 				    Sccb_forwardlink;
6749 
6750 				if (currTar_Info->TarSelQ_Head == NULL) {
6751 					currTar_Info->TarSelQ_Tail = NULL;
6752 					currTar_Info->TarSelQ_Cnt = 0;
6753 				} else {
6754 					currTar_Info->TarSelQ_Cnt--;
6755 					currTar_Info->TarSelQ_Head->
6756 					    Sccb_backlink = (struct sccb *)NULL;
6757 				}
6758 
6759 				scan_ptr++;
6760 				if (scan_ptr == MAX_SCSI_TAR)
6761 					scan_ptr = 0;
6762 
6763 				pCurrCard->scanIndex = scan_ptr;
6764 
6765 				pCurrCard->globalFlags |= F_NEW_SCCB_CMD;
6766 
6767 				break;
6768 			}
6769 
6770 			else {
6771 				scan_ptr++;
6772 				if (scan_ptr == MAX_SCSI_TAR) {
6773 					scan_ptr = 0;
6774 				}
6775 			}
6776 		}
6777 	} while (scan_ptr != pCurrCard->scanIndex);
6778 }
6779 
6780 /*---------------------------------------------------------------------
6781  *
6782  * Function: Queue Select Fail
6783  *
6784  * Description: Add the current SCCB to the head of the Queue.
6785  *
6786  *---------------------------------------------------------------------*/
6787 
FPT_queueSelectFail(struct sccb_card * pCurrCard,unsigned char p_card)6788 static void FPT_queueSelectFail(struct sccb_card *pCurrCard,
6789 				unsigned char p_card)
6790 {
6791 	unsigned char thisTarg;
6792 	struct sccb_mgr_tar_info *currTar_Info;
6793 
6794 	if (pCurrCard->currentSCCB != NULL) {
6795 		thisTarg =
6796 		    (unsigned char)(((struct sccb *)(pCurrCard->currentSCCB))->
6797 				    TargID);
6798 		currTar_Info = &FPT_sccbMgrTbl[p_card][thisTarg];
6799 
6800 		pCurrCard->currentSCCB->Sccb_backlink = (struct sccb *)NULL;
6801 
6802 		pCurrCard->currentSCCB->Sccb_forwardlink =
6803 		    currTar_Info->TarSelQ_Head;
6804 
6805 		if (currTar_Info->TarSelQ_Cnt == 0) {
6806 			currTar_Info->TarSelQ_Tail = pCurrCard->currentSCCB;
6807 		}
6808 
6809 		else {
6810 			currTar_Info->TarSelQ_Head->Sccb_backlink =
6811 			    pCurrCard->currentSCCB;
6812 		}
6813 
6814 		currTar_Info->TarSelQ_Head = pCurrCard->currentSCCB;
6815 
6816 		pCurrCard->currentSCCB = NULL;
6817 		currTar_Info->TarSelQ_Cnt++;
6818 	}
6819 }
6820 
6821 /*---------------------------------------------------------------------
6822  *
6823  * Function: Queue Command Complete
6824  *
6825  * Description: Call the callback function with the current SCCB.
6826  *
6827  *---------------------------------------------------------------------*/
6828 
FPT_queueCmdComplete(struct sccb_card * pCurrCard,struct sccb * p_sccb,unsigned char p_card)6829 static void FPT_queueCmdComplete(struct sccb_card *pCurrCard,
6830 				 struct sccb *p_sccb, unsigned char p_card)
6831 {
6832 
6833 	unsigned char i, SCSIcmd;
6834 	CALL_BK_FN callback;
6835 	struct sccb_mgr_tar_info *currTar_Info;
6836 
6837 	SCSIcmd = p_sccb->Cdb[0];
6838 
6839 	if (!(p_sccb->Sccb_XferState & F_ALL_XFERRED)) {
6840 
6841 		if ((p_sccb->
6842 		     ControlByte & (SCCB_DATA_XFER_OUT | SCCB_DATA_XFER_IN))
6843 		    && (p_sccb->HostStatus == SCCB_COMPLETE)
6844 		    && (p_sccb->TargetStatus != SAM_STAT_CHECK_CONDITION))
6845 
6846 			if ((SCSIcmd == READ_6) ||
6847 			    (SCSIcmd == WRITE_6) ||
6848 			    (SCSIcmd == READ_10) ||
6849 			    (SCSIcmd == WRITE_10) ||
6850 			    (SCSIcmd == WRITE_VERIFY) ||
6851 			    (SCSIcmd == START_STOP) ||
6852 			    (pCurrCard->globalFlags & F_NO_FILTER)
6853 			    )
6854 				p_sccb->HostStatus = SCCB_DATA_UNDER_RUN;
6855 	}
6856 
6857 	if (p_sccb->SccbStatus == SCCB_IN_PROCESS) {
6858 		if (p_sccb->HostStatus || p_sccb->TargetStatus)
6859 			p_sccb->SccbStatus = SCCB_ERROR;
6860 		else
6861 			p_sccb->SccbStatus = SCCB_SUCCESS;
6862 	}
6863 
6864 	if (p_sccb->Sccb_XferState & F_AUTO_SENSE) {
6865 
6866 		p_sccb->CdbLength = p_sccb->Save_CdbLen;
6867 		for (i = 0; i < 6; i++) {
6868 			p_sccb->Cdb[i] = p_sccb->Save_Cdb[i];
6869 		}
6870 	}
6871 
6872 	if ((p_sccb->OperationCode == RESIDUAL_SG_COMMAND) ||
6873 	    (p_sccb->OperationCode == RESIDUAL_COMMAND)) {
6874 
6875 		FPT_utilUpdateResidual(p_sccb);
6876 	}
6877 
6878 	pCurrCard->cmdCounter--;
6879 	if (!pCurrCard->cmdCounter) {
6880 
6881 		if (pCurrCard->globalFlags & F_GREEN_PC) {
6882 			WR_HARPOON(pCurrCard->ioPort + hp_clkctrl_0,
6883 				   (PWR_DWN | CLKCTRL_DEFAULT));
6884 			WR_HARPOON(pCurrCard->ioPort + hp_sys_ctrl, STOP_CLK);
6885 		}
6886 
6887 		WR_HARPOON(pCurrCard->ioPort + hp_semaphore,
6888 			   (RD_HARPOON(pCurrCard->ioPort + hp_semaphore) &
6889 			    ~SCCB_MGR_ACTIVE));
6890 
6891 	}
6892 
6893 	if (pCurrCard->discQCount != 0) {
6894 		currTar_Info = &FPT_sccbMgrTbl[p_card][p_sccb->TargID];
6895 		if (((pCurrCard->globalFlags & F_CONLUN_IO) &&
6896 		     ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) !=
6897 		      TAG_Q_TRYING))) {
6898 			pCurrCard->discQCount--;
6899 			pCurrCard->discQ_Tbl[currTar_Info->
6900 					     LunDiscQ_Idx[p_sccb->Lun]] = NULL;
6901 		} else {
6902 			if (p_sccb->Sccb_tag) {
6903 				pCurrCard->discQCount--;
6904 				pCurrCard->discQ_Tbl[p_sccb->Sccb_tag] = NULL;
6905 			} else {
6906 				pCurrCard->discQCount--;
6907 				pCurrCard->discQ_Tbl[currTar_Info->
6908 						     LunDiscQ_Idx[0]] = NULL;
6909 			}
6910 		}
6911 
6912 	}
6913 
6914 	callback = (CALL_BK_FN) p_sccb->SccbCallback;
6915 	callback(p_sccb);
6916 	pCurrCard->globalFlags |= F_NEW_SCCB_CMD;
6917 	pCurrCard->currentSCCB = NULL;
6918 }
6919 
6920 /*---------------------------------------------------------------------
6921  *
6922  * Function: Queue Disconnect
6923  *
6924  * Description: Add SCCB to our disconnect array.
6925  *
6926  *---------------------------------------------------------------------*/
FPT_queueDisconnect(struct sccb * p_sccb,unsigned char p_card)6927 static void FPT_queueDisconnect(struct sccb *p_sccb, unsigned char p_card)
6928 {
6929 	struct sccb_mgr_tar_info *currTar_Info;
6930 
6931 	currTar_Info = &FPT_sccbMgrTbl[p_card][p_sccb->TargID];
6932 
6933 	if (((FPT_BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
6934 	     ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))) {
6935 		FPT_BL_Card[p_card].discQ_Tbl[currTar_Info->
6936 					      LunDiscQ_Idx[p_sccb->Lun]] =
6937 		    p_sccb;
6938 	} else {
6939 		if (p_sccb->Sccb_tag) {
6940 			FPT_BL_Card[p_card].discQ_Tbl[p_sccb->Sccb_tag] =
6941 			    p_sccb;
6942 			FPT_sccbMgrTbl[p_card][p_sccb->TargID].TarLUNBusy[0] =
6943 			    0;
6944 			FPT_sccbMgrTbl[p_card][p_sccb->TargID].TarTagQ_Cnt++;
6945 		} else {
6946 			FPT_BL_Card[p_card].discQ_Tbl[currTar_Info->
6947 						      LunDiscQ_Idx[0]] = p_sccb;
6948 		}
6949 	}
6950 	FPT_BL_Card[p_card].currentSCCB = NULL;
6951 }
6952 
6953 /*---------------------------------------------------------------------
6954  *
6955  * Function: Queue Flush SCCB
6956  *
6957  * Description: Flush all SCCB's back to the host driver for this target.
6958  *
6959  *---------------------------------------------------------------------*/
6960 
FPT_queueFlushSccb(unsigned char p_card,unsigned char error_code)6961 static void FPT_queueFlushSccb(unsigned char p_card, unsigned char error_code)
6962 {
6963 	unsigned char qtag, thisTarg;
6964 	struct sccb *currSCCB;
6965 	struct sccb_mgr_tar_info *currTar_Info;
6966 
6967 	currSCCB = FPT_BL_Card[p_card].currentSCCB;
6968 	if (currSCCB != NULL) {
6969 		thisTarg = (unsigned char)currSCCB->TargID;
6970 		currTar_Info = &FPT_sccbMgrTbl[p_card][thisTarg];
6971 
6972 		for (qtag = 0; qtag < QUEUE_DEPTH; qtag++) {
6973 
6974 			if (FPT_BL_Card[p_card].discQ_Tbl[qtag] &&
6975 			    (FPT_BL_Card[p_card].discQ_Tbl[qtag]->TargID ==
6976 			     thisTarg)) {
6977 
6978 				FPT_BL_Card[p_card].discQ_Tbl[qtag]->
6979 				    HostStatus = (unsigned char)error_code;
6980 
6981 				FPT_queueCmdComplete(&FPT_BL_Card[p_card],
6982 						     FPT_BL_Card[p_card].
6983 						     discQ_Tbl[qtag], p_card);
6984 
6985 				FPT_BL_Card[p_card].discQ_Tbl[qtag] = NULL;
6986 				currTar_Info->TarTagQ_Cnt--;
6987 
6988 			}
6989 		}
6990 	}
6991 
6992 }
6993 
6994 /*---------------------------------------------------------------------
6995  *
6996  * Function: Queue Flush Target SCCB
6997  *
6998  * Description: Flush all SCCB's back to the host driver for this target.
6999  *
7000  *---------------------------------------------------------------------*/
7001 
FPT_queueFlushTargSccb(unsigned char p_card,unsigned char thisTarg,unsigned char error_code)7002 static void FPT_queueFlushTargSccb(unsigned char p_card, unsigned char thisTarg,
7003 				   unsigned char error_code)
7004 {
7005 	unsigned char qtag;
7006 	struct sccb_mgr_tar_info *currTar_Info;
7007 
7008 	currTar_Info = &FPT_sccbMgrTbl[p_card][thisTarg];
7009 
7010 	for (qtag = 0; qtag < QUEUE_DEPTH; qtag++) {
7011 
7012 		if (FPT_BL_Card[p_card].discQ_Tbl[qtag] &&
7013 		    (FPT_BL_Card[p_card].discQ_Tbl[qtag]->TargID == thisTarg)) {
7014 
7015 			FPT_BL_Card[p_card].discQ_Tbl[qtag]->HostStatus =
7016 			    (unsigned char)error_code;
7017 
7018 			FPT_queueCmdComplete(&FPT_BL_Card[p_card],
7019 					     FPT_BL_Card[p_card].
7020 					     discQ_Tbl[qtag], p_card);
7021 
7022 			FPT_BL_Card[p_card].discQ_Tbl[qtag] = NULL;
7023 			currTar_Info->TarTagQ_Cnt--;
7024 
7025 		}
7026 	}
7027 
7028 }
7029 
FPT_queueAddSccb(struct sccb * p_SCCB,unsigned char p_card)7030 static void FPT_queueAddSccb(struct sccb *p_SCCB, unsigned char p_card)
7031 {
7032 	struct sccb_mgr_tar_info *currTar_Info;
7033 	currTar_Info = &FPT_sccbMgrTbl[p_card][p_SCCB->TargID];
7034 
7035 	p_SCCB->Sccb_forwardlink = NULL;
7036 
7037 	p_SCCB->Sccb_backlink = currTar_Info->TarSelQ_Tail;
7038 
7039 	if (currTar_Info->TarSelQ_Cnt == 0) {
7040 
7041 		currTar_Info->TarSelQ_Head = p_SCCB;
7042 	}
7043 
7044 	else {
7045 
7046 		currTar_Info->TarSelQ_Tail->Sccb_forwardlink = p_SCCB;
7047 	}
7048 
7049 	currTar_Info->TarSelQ_Tail = p_SCCB;
7050 	currTar_Info->TarSelQ_Cnt++;
7051 }
7052 
7053 /*---------------------------------------------------------------------
7054  *
7055  * Function: Queue Find SCCB
7056  *
7057  * Description: Search the target select Queue for this SCCB, and
7058  *              remove it if found.
7059  *
7060  *---------------------------------------------------------------------*/
7061 
FPT_queueFindSccb(struct sccb * p_SCCB,unsigned char p_card)7062 static unsigned char FPT_queueFindSccb(struct sccb *p_SCCB,
7063 				       unsigned char p_card)
7064 {
7065 	struct sccb *q_ptr;
7066 	struct sccb_mgr_tar_info *currTar_Info;
7067 
7068 	currTar_Info = &FPT_sccbMgrTbl[p_card][p_SCCB->TargID];
7069 
7070 	q_ptr = currTar_Info->TarSelQ_Head;
7071 
7072 	while (q_ptr != NULL) {
7073 
7074 		if (q_ptr == p_SCCB) {
7075 
7076 			if (currTar_Info->TarSelQ_Head == q_ptr) {
7077 
7078 				currTar_Info->TarSelQ_Head =
7079 				    q_ptr->Sccb_forwardlink;
7080 			}
7081 
7082 			if (currTar_Info->TarSelQ_Tail == q_ptr) {
7083 
7084 				currTar_Info->TarSelQ_Tail =
7085 				    q_ptr->Sccb_backlink;
7086 			}
7087 
7088 			if (q_ptr->Sccb_forwardlink != NULL) {
7089 				q_ptr->Sccb_forwardlink->Sccb_backlink =
7090 				    q_ptr->Sccb_backlink;
7091 			}
7092 
7093 			if (q_ptr->Sccb_backlink != NULL) {
7094 				q_ptr->Sccb_backlink->Sccb_forwardlink =
7095 				    q_ptr->Sccb_forwardlink;
7096 			}
7097 
7098 			currTar_Info->TarSelQ_Cnt--;
7099 
7100 			return 1;
7101 		}
7102 
7103 		else {
7104 			q_ptr = q_ptr->Sccb_forwardlink;
7105 		}
7106 	}
7107 
7108 	return 0;
7109 
7110 }
7111 
7112 /*---------------------------------------------------------------------
7113  *
7114  * Function: Utility Update Residual Count
7115  *
7116  * Description: Update the XferCnt to the remaining byte count.
7117  *              If we transferred all the data then just write zero.
7118  *              If Non-SG transfer then report Total Cnt - Actual Transfer
7119  *              Cnt.  For SG transfers add the count fields of all
7120  *              remaining SG elements, as well as any partial remaining
7121  *              element.
7122  *
7123  *---------------------------------------------------------------------*/
7124 
FPT_utilUpdateResidual(struct sccb * p_SCCB)7125 static void FPT_utilUpdateResidual(struct sccb *p_SCCB)
7126 {
7127 	unsigned long partial_cnt;
7128 	unsigned int sg_index;
7129 	struct blogic_sg_seg *segp;
7130 
7131 	if (p_SCCB->Sccb_XferState & F_ALL_XFERRED) {
7132 
7133 		p_SCCB->DataLength = 0x0000;
7134 	}
7135 
7136 	else if (p_SCCB->Sccb_XferState & F_SG_XFER) {
7137 
7138 		partial_cnt = 0x0000;
7139 
7140 		sg_index = p_SCCB->Sccb_sgseg;
7141 
7142 
7143 		if (p_SCCB->Sccb_SGoffset) {
7144 
7145 			partial_cnt = p_SCCB->Sccb_SGoffset;
7146 			sg_index++;
7147 		}
7148 
7149 		while (((unsigned long)sg_index *
7150 			(unsigned long)SG_ELEMENT_SIZE) < p_SCCB->DataLength) {
7151 			segp = (struct blogic_sg_seg *)(p_SCCB->DataPointer) +
7152 					(sg_index * 2);
7153 			partial_cnt += segp->segbytes;
7154 			sg_index++;
7155 		}
7156 
7157 		p_SCCB->DataLength = partial_cnt;
7158 	}
7159 
7160 	else {
7161 
7162 		p_SCCB->DataLength -= p_SCCB->Sccb_ATC;
7163 	}
7164 }
7165 
7166 /*---------------------------------------------------------------------
7167  *
7168  * Function: Wait 1 Second
7169  *
7170  * Description: Wait for 1 second.
7171  *
7172  *---------------------------------------------------------------------*/
7173 
FPT_Wait1Second(u32 p_port)7174 static void FPT_Wait1Second(u32 p_port)
7175 {
7176 	unsigned char i;
7177 
7178 	for (i = 0; i < 4; i++) {
7179 
7180 		FPT_Wait(p_port, TO_250ms);
7181 
7182 		if ((RD_HARPOON(p_port + hp_scsictrl_0) & SCSI_RST))
7183 			break;
7184 
7185 		if ((RDW_HARPOON((p_port + hp_intstat)) & SCAM_SEL))
7186 			break;
7187 	}
7188 }
7189 
7190 /*---------------------------------------------------------------------
7191  *
7192  * Function: FPT_Wait
7193  *
7194  * Description: Wait the desired delay.
7195  *
7196  *---------------------------------------------------------------------*/
7197 
FPT_Wait(u32 p_port,unsigned char p_delay)7198 static void FPT_Wait(u32 p_port, unsigned char p_delay)
7199 {
7200 	unsigned char old_timer;
7201 	unsigned char green_flag;
7202 
7203 	old_timer = RD_HARPOON(p_port + hp_seltimeout);
7204 
7205 	green_flag = RD_HARPOON(p_port + hp_clkctrl_0);
7206 	WR_HARPOON(p_port + hp_clkctrl_0, CLKCTRL_DEFAULT);
7207 
7208 	WR_HARPOON(p_port + hp_seltimeout, p_delay);
7209 	WRW_HARPOON((p_port + hp_intstat), TIMEOUT);
7210 	WRW_HARPOON((p_port + hp_intena), (FPT_default_intena & ~TIMEOUT));
7211 
7212 	WR_HARPOON(p_port + hp_portctrl_0,
7213 		   (RD_HARPOON(p_port + hp_portctrl_0) | START_TO));
7214 
7215 	while (!(RDW_HARPOON((p_port + hp_intstat)) & TIMEOUT)) {
7216 
7217 		if ((RD_HARPOON(p_port + hp_scsictrl_0) & SCSI_RST))
7218 			break;
7219 
7220 		if ((RDW_HARPOON((p_port + hp_intstat)) & SCAM_SEL))
7221 			break;
7222 	}
7223 
7224 	WR_HARPOON(p_port + hp_portctrl_0,
7225 		   (RD_HARPOON(p_port + hp_portctrl_0) & ~START_TO));
7226 
7227 	WRW_HARPOON((p_port + hp_intstat), TIMEOUT);
7228 	WRW_HARPOON((p_port + hp_intena), FPT_default_intena);
7229 
7230 	WR_HARPOON(p_port + hp_clkctrl_0, green_flag);
7231 
7232 	WR_HARPOON(p_port + hp_seltimeout, old_timer);
7233 }
7234 
7235 /*---------------------------------------------------------------------
7236  *
7237  * Function: Enable/Disable Write to EEPROM
7238  *
7239  * Description: The EEPROM must first be enabled for writes
7240  *              A total of 9 clocks are needed.
7241  *
7242  *---------------------------------------------------------------------*/
7243 
FPT_utilEEWriteOnOff(u32 p_port,unsigned char p_mode)7244 static void FPT_utilEEWriteOnOff(u32 p_port, unsigned char p_mode)
7245 {
7246 	unsigned char ee_value;
7247 
7248 	ee_value =
7249 	    (unsigned char)(RD_HARPOON(p_port + hp_ee_ctrl) &
7250 			    (EXT_ARB_ACK | SCSI_TERM_ENA_H));
7251 
7252 	if (p_mode)
7253 
7254 		FPT_utilEESendCmdAddr(p_port, EWEN, EWEN_ADDR);
7255 
7256 	else
7257 
7258 		FPT_utilEESendCmdAddr(p_port, EWDS, EWDS_ADDR);
7259 
7260 	WR_HARPOON(p_port + hp_ee_ctrl, (ee_value | SEE_MS));	/*Turn off CS */
7261 	WR_HARPOON(p_port + hp_ee_ctrl, ee_value);	/*Turn off Master Select */
7262 }
7263 
7264 /*---------------------------------------------------------------------
7265  *
7266  * Function: Write EEPROM
7267  *
7268  * Description: Write a word to the EEPROM at the specified
7269  *              address.
7270  *
7271  *---------------------------------------------------------------------*/
7272 
FPT_utilEEWrite(u32 p_port,unsigned short ee_data,unsigned short ee_addr)7273 static void FPT_utilEEWrite(u32 p_port, unsigned short ee_data,
7274 			    unsigned short ee_addr)
7275 {
7276 
7277 	unsigned char ee_value;
7278 	unsigned short i;
7279 
7280 	ee_value =
7281 	    (unsigned
7282 	     char)((RD_HARPOON(p_port + hp_ee_ctrl) &
7283 		    (EXT_ARB_ACK | SCSI_TERM_ENA_H)) | (SEE_MS | SEE_CS));
7284 
7285 	FPT_utilEESendCmdAddr(p_port, EE_WRITE, ee_addr);
7286 
7287 	ee_value |= (SEE_MS + SEE_CS);
7288 
7289 	for (i = 0x8000; i != 0; i >>= 1) {
7290 
7291 		if (i & ee_data)
7292 			ee_value |= SEE_DO;
7293 		else
7294 			ee_value &= ~SEE_DO;
7295 
7296 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7297 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7298 		ee_value |= SEE_CLK;	/* Clock  data! */
7299 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7300 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7301 		ee_value &= ~SEE_CLK;
7302 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7303 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7304 	}
7305 	ee_value &= (EXT_ARB_ACK | SCSI_TERM_ENA_H);
7306 	WR_HARPOON(p_port + hp_ee_ctrl, (ee_value | SEE_MS));
7307 
7308 	FPT_Wait(p_port, TO_10ms);
7309 
7310 	WR_HARPOON(p_port + hp_ee_ctrl, (ee_value | SEE_MS | SEE_CS));	/* Set CS to EEPROM */
7311 	WR_HARPOON(p_port + hp_ee_ctrl, (ee_value | SEE_MS));	/* Turn off CS */
7312 	WR_HARPOON(p_port + hp_ee_ctrl, ee_value);	/* Turn off Master Select */
7313 }
7314 
7315 /*---------------------------------------------------------------------
7316  *
7317  * Function: Read EEPROM
7318  *
7319  * Description: Read a word from the EEPROM at the desired
7320  *              address.
7321  *
7322  *---------------------------------------------------------------------*/
7323 
FPT_utilEERead(u32 p_port,unsigned short ee_addr)7324 static unsigned short FPT_utilEERead(u32 p_port,
7325 				     unsigned short ee_addr)
7326 {
7327 	unsigned short i, ee_data1, ee_data2;
7328 
7329 	i = 0;
7330 	ee_data1 = FPT_utilEEReadOrg(p_port, ee_addr);
7331 	do {
7332 		ee_data2 = FPT_utilEEReadOrg(p_port, ee_addr);
7333 
7334 		if (ee_data1 == ee_data2)
7335 			return ee_data1;
7336 
7337 		ee_data1 = ee_data2;
7338 		i++;
7339 
7340 	} while (i < 4);
7341 
7342 	return ee_data1;
7343 }
7344 
7345 /*---------------------------------------------------------------------
7346  *
7347  * Function: Read EEPROM Original
7348  *
7349  * Description: Read a word from the EEPROM at the desired
7350  *              address.
7351  *
7352  *---------------------------------------------------------------------*/
7353 
FPT_utilEEReadOrg(u32 p_port,unsigned short ee_addr)7354 static unsigned short FPT_utilEEReadOrg(u32 p_port, unsigned short ee_addr)
7355 {
7356 
7357 	unsigned char ee_value;
7358 	unsigned short i, ee_data;
7359 
7360 	ee_value =
7361 	    (unsigned
7362 	     char)((RD_HARPOON(p_port + hp_ee_ctrl) &
7363 		    (EXT_ARB_ACK | SCSI_TERM_ENA_H)) | (SEE_MS | SEE_CS));
7364 
7365 	FPT_utilEESendCmdAddr(p_port, EE_READ, ee_addr);
7366 
7367 	ee_value |= (SEE_MS + SEE_CS);
7368 	ee_data = 0;
7369 
7370 	for (i = 1; i <= 16; i++) {
7371 
7372 		ee_value |= SEE_CLK;	/* Clock  data! */
7373 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7374 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7375 		ee_value &= ~SEE_CLK;
7376 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7377 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7378 
7379 		ee_data <<= 1;
7380 
7381 		if (RD_HARPOON(p_port + hp_ee_ctrl) & SEE_DI)
7382 			ee_data |= 1;
7383 	}
7384 
7385 	ee_value &= ~(SEE_MS + SEE_CS);
7386 	WR_HARPOON(p_port + hp_ee_ctrl, (ee_value | SEE_MS));	/*Turn off CS */
7387 	WR_HARPOON(p_port + hp_ee_ctrl, ee_value);	/*Turn off Master Select */
7388 
7389 	return ee_data;
7390 }
7391 
7392 /*---------------------------------------------------------------------
7393  *
7394  * Function: Send EE command and Address to the EEPROM
7395  *
7396  * Description: Transfers the correct command and sends the address
7397  *              to the eeprom.
7398  *
7399  *---------------------------------------------------------------------*/
7400 
FPT_utilEESendCmdAddr(u32 p_port,unsigned char ee_cmd,unsigned short ee_addr)7401 static void FPT_utilEESendCmdAddr(u32 p_port, unsigned char ee_cmd,
7402 				  unsigned short ee_addr)
7403 {
7404 	unsigned char ee_value;
7405 	unsigned char narrow_flg;
7406 
7407 	unsigned short i;
7408 
7409 	narrow_flg =
7410 	    (unsigned char)(RD_HARPOON(p_port + hp_page_ctrl) &
7411 			    NARROW_SCSI_CARD);
7412 
7413 	ee_value = SEE_MS;
7414 	WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7415 
7416 	ee_value |= SEE_CS;	/* Set CS to EEPROM */
7417 	WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7418 
7419 	for (i = 0x04; i != 0; i >>= 1) {
7420 
7421 		if (i & ee_cmd)
7422 			ee_value |= SEE_DO;
7423 		else
7424 			ee_value &= ~SEE_DO;
7425 
7426 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7427 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7428 		ee_value |= SEE_CLK;	/* Clock  data! */
7429 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7430 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7431 		ee_value &= ~SEE_CLK;
7432 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7433 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7434 	}
7435 
7436 	if (narrow_flg)
7437 		i = 0x0080;
7438 
7439 	else
7440 		i = 0x0200;
7441 
7442 	while (i != 0) {
7443 
7444 		if (i & ee_addr)
7445 			ee_value |= SEE_DO;
7446 		else
7447 			ee_value &= ~SEE_DO;
7448 
7449 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7450 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7451 		ee_value |= SEE_CLK;	/* Clock  data! */
7452 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7453 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7454 		ee_value &= ~SEE_CLK;
7455 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7456 		WR_HARPOON(p_port + hp_ee_ctrl, ee_value);
7457 
7458 		i >>= 1;
7459 	}
7460 }
7461 
FPT_CalcCrc16(unsigned char buffer[])7462 static unsigned short FPT_CalcCrc16(unsigned char buffer[])
7463 {
7464 	unsigned short crc = 0;
7465 	int i, j;
7466 	unsigned short ch;
7467 	for (i = 0; i < ID_STRING_LENGTH; i++) {
7468 		ch = (unsigned short)buffer[i];
7469 		for (j = 0; j < 8; j++) {
7470 			if ((crc ^ ch) & 1)
7471 				crc = (crc >> 1) ^ CRCMASK;
7472 			else
7473 				crc >>= 1;
7474 			ch >>= 1;
7475 		}
7476 	}
7477 	return crc;
7478 }
7479 
FPT_CalcLrc(unsigned char buffer[])7480 static unsigned char FPT_CalcLrc(unsigned char buffer[])
7481 {
7482 	int i;
7483 	unsigned char lrc;
7484 	lrc = 0;
7485 	for (i = 0; i < ID_STRING_LENGTH; i++)
7486 		lrc ^= buffer[i];
7487 	return lrc;
7488 }
7489 
7490 /*
7491   The following inline definitions avoid type conflicts.
7492 */
7493 
7494 static inline unsigned char
FlashPoint__ProbeHostAdapter(struct fpoint_info * FlashPointInfo)7495 FlashPoint__ProbeHostAdapter(struct fpoint_info *FlashPointInfo)
7496 {
7497 	return FlashPoint_ProbeHostAdapter((struct sccb_mgr_info *)
7498 					   FlashPointInfo);
7499 }
7500 
7501 static inline void *
FlashPoint__HardwareResetHostAdapter(struct fpoint_info * FlashPointInfo)7502 FlashPoint__HardwareResetHostAdapter(struct fpoint_info *FlashPointInfo)
7503 {
7504 	return FlashPoint_HardwareResetHostAdapter((struct sccb_mgr_info *)
7505 						   FlashPointInfo);
7506 }
7507 
7508 static inline void
FlashPoint__ReleaseHostAdapter(void * CardHandle)7509 FlashPoint__ReleaseHostAdapter(void *CardHandle)
7510 {
7511 	FlashPoint_ReleaseHostAdapter(CardHandle);
7512 }
7513 
7514 static inline void
FlashPoint__StartCCB(void * CardHandle,struct blogic_ccb * CCB)7515 FlashPoint__StartCCB(void *CardHandle, struct blogic_ccb *CCB)
7516 {
7517 	FlashPoint_StartCCB(CardHandle, (struct sccb *)CCB);
7518 }
7519 
7520 static inline void
FlashPoint__AbortCCB(void * CardHandle,struct blogic_ccb * CCB)7521 FlashPoint__AbortCCB(void *CardHandle, struct blogic_ccb *CCB)
7522 {
7523 	FlashPoint_AbortCCB(CardHandle, (struct sccb *)CCB);
7524 }
7525 
7526 static inline bool
FlashPoint__InterruptPending(void * CardHandle)7527 FlashPoint__InterruptPending(void *CardHandle)
7528 {
7529 	return FlashPoint_InterruptPending(CardHandle);
7530 }
7531 
7532 static inline int
FlashPoint__HandleInterrupt(void * CardHandle)7533 FlashPoint__HandleInterrupt(void *CardHandle)
7534 {
7535 	return FlashPoint_HandleInterrupt(CardHandle);
7536 }
7537 
7538 #define FlashPoint_ProbeHostAdapter	    FlashPoint__ProbeHostAdapter
7539 #define FlashPoint_HardwareResetHostAdapter FlashPoint__HardwareResetHostAdapter
7540 #define FlashPoint_ReleaseHostAdapter	    FlashPoint__ReleaseHostAdapter
7541 #define FlashPoint_StartCCB		    FlashPoint__StartCCB
7542 #define FlashPoint_AbortCCB		    FlashPoint__AbortCCB
7543 #define FlashPoint_InterruptPending	    FlashPoint__InterruptPending
7544 #define FlashPoint_HandleInterrupt	    FlashPoint__HandleInterrupt
7545 
7546 #else				/* !CONFIG_SCSI_FLASHPOINT */
7547 
7548 /*
7549   Define prototypes for the FlashPoint SCCB Manager Functions.
7550 */
7551 
7552 extern unsigned char FlashPoint_ProbeHostAdapter(struct fpoint_info *);
7553 extern void *FlashPoint_HardwareResetHostAdapter(struct fpoint_info *);
7554 extern void FlashPoint_StartCCB(void *, struct blogic_ccb *);
7555 extern int FlashPoint_AbortCCB(void *, struct blogic_ccb *);
7556 extern bool FlashPoint_InterruptPending(void *);
7557 extern int FlashPoint_HandleInterrupt(void *);
7558 extern void FlashPoint_ReleaseHostAdapter(void *);
7559 
7560 #endif				/* CONFIG_SCSI_FLASHPOINT */
7561