2 * Copyright (c) 1998, 1999 Nicolas Souchu
3 * Copyright (c) 2001 Alcove - Nicolas Souchu
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * $FreeBSD: src/sys/dev/ppbus/immio.c,v 1.10.2.3 2001/10/02 05:27:20 nsouch Exp $
28 * $DragonFly: src/sys/dev/disk/vpo/immio.c,v 1.7 2006/12/22 23:26:17 swildner Exp $
33 * Iomega ZIP+ Matchmaker Parallel Port Interface driver
35 * Thanks to David Campbell work on the Linux driver and the Iomega specs
36 * Thanks to Thiebault Moeglin for the drive
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/module.h>
43 #include <sys/malloc.h>
49 #include <bus/ppbus/ppbio.h>
50 #include <bus/ppbus/ppbconf.h>
51 #include <bus/ppbus/ppb_msq.h>
53 #include <bus/ppbus/ppb_1284.h>
57 #define VP0_SELTMO 5000 /* select timeout */
58 #define VP0_FAST_SPINTMO 500000 /* wait status timeout */
59 #define VP0_LOW_SPINTMO 5000000 /* wait status timeout */
61 #define VP0_SECTOR_SIZE 512
64 * Microcode to execute very fast I/O sequences at the lowest bus level.
67 #define WAIT_RET MS_PARAM(7, 2, MS_TYP_PTR)
68 #define WAIT_TMO MS_PARAM(1, 0, MS_TYP_INT)
70 #define DECLARE_WAIT_MICROSEQUENCE \
71 struct ppb_microseq wait_microseq[] = { \
75 MS_BRSET(nBUSY, 4 /* ready */), \
76 MS_DBRA(-2 /* loop */), \
78 MS_RET(1), /* timed out */ \
81 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN ), \
82 MS_RET(0) /* no error */ \
85 #define SELECT_TARGET MS_PARAM(6, 1, MS_TYP_CHA)
87 #define DECLARE_SELECT_MICROSEQUENCE \
88 struct ppb_microseq select_microseq[] = { \
90 /* first, check there is nothing holding onto the bus */ \
93 MS_BRCLEAR(0x8, 2 /* _ready */), \
94 MS_DBRA(-2 /* _loop */), \
95 MS_RET(2), /* bus busy */ \
98 MS_DASS(MS_UNKNOWN /* 0x80 | 1 << target */), \
102 /* now, wait until the drive is ready */ \
103 MS_SET(VP0_SELTMO), \
105 MS_BRSET(0x8, 3 /* ready */), \
106 MS_DBRA(-2 /* loop */), \
109 MS_RET(VP0_ESELECT_TIMEOUT), \
115 static struct ppb_microseq transfer_epilog
[] = {
123 #define CPP_S1 MS_PARAM(10, 2, MS_TYP_PTR)
124 #define CPP_S2 MS_PARAM(13, 2, MS_TYP_PTR)
125 #define CPP_S3 MS_PARAM(16, 2, MS_TYP_PTR)
126 #define CPP_PARAM MS_PARAM(17, 1, MS_TYP_CHA)
128 #define DECLARE_CPP_MICROSEQ \
129 struct ppb_microseq cpp_microseq[] = { \
130 MS_CASS(0x0c), MS_DELAY(2), \
131 MS_DASS(0xaa), MS_DELAY(10), \
132 MS_DASS(0x55), MS_DELAY(10), \
133 MS_DASS(0x00), MS_DELAY(10), \
134 MS_DASS(0xff), MS_DELAY(10), \
135 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s1 */), \
136 MS_DASS(0x87), MS_DELAY(10), \
137 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s2 */), \
138 MS_DASS(0x78), MS_DELAY(10), \
139 MS_RFETCH(MS_REG_STR, 0x38, MS_UNKNOWN /* &s3 */), \
140 MS_DASS(MS_UNKNOWN /* param */), \
142 MS_CASS(0x0c), MS_DELAY(10), \
143 MS_CASS(0x0d), MS_DELAY(2), \
144 MS_CASS(0x0c), MS_DELAY(10), \
145 MS_DASS(0xff), MS_DELAY(10), \
149 #define NEGOCIATED_MODE MS_PARAM(2, 1, MS_TYP_CHA)
151 #define DECLARE_NEGOCIATE_MICROSEQ \
152 struct ppb_microseq negociate_microseq[] = { \
155 MS_DASS(MS_UNKNOWN /* mode */), \
159 MS_BRSET(0x20, 5 /* continue */), \
164 MS_RET(VP0_ENEGOCIATE), \
173 #define INB_NIBBLE_L MS_PARAM(3, 2, MS_TYP_PTR)
174 #define INB_NIBBLE_H MS_PARAM(6, 2, MS_TYP_PTR)
175 #define INB_NIBBLE_F MS_PARAM(9, 0, MS_TYP_FUN)
176 #define INB_NIBBLE_P MS_PARAM(9, 1, MS_TYP_PTR)
179 * This is the sub-microseqence for MS_GET in NIBBLE mode
180 * Retrieve the two nibbles and call the C function to generate the character
181 * and store it in the buffer (see nibble_inbyte_hook())
184 #define DECLARE_NIBBLE_INBYTE_SUBMICROSEQ \
185 struct ppb_microseq nibble_inbyte_submicroseq[] = { \
190 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\
193 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\
196 /* do a C call to format the received nibbles */ \
197 MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */), \
198 MS_DBRA(-7 /* loop */), \
202 static struct ppb_microseq reset_microseq
[] = {
215 * nibble_inbyte_hook()
217 * Formats high and low nibble into a character
220 nibble_inbyte_hook (void *p
, char *ptr
)
222 struct vpo_nibble
*s
= (struct vpo_nibble
*)p
;
224 /* increment the buffer pointer */
225 *ptr
= ((s
->l
>> 4) & 0x0f) + (s
->h
& 0xf0);
231 * This is the sub-microseqence for MS_GET in PS2 mode
233 static struct ppb_microseq ps2_inbyte_submicroseq
[] = {
238 MS_RFETCH_P(1, MS_REG_DTR
, MS_FETCH_ALL
),
240 MS_DBRA(-4 /* loop */),
246 * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes
248 static struct ppb_microseq spp_outbyte_submicroseq
[] = {
252 MS_RASSERT_P(1, MS_REG_DTR
),
254 MS_DBRA(0), /* decrement counter */
255 MS_RASSERT_P(1, MS_REG_DTR
),
257 MS_DBRA(-6 /* loop */),
259 /* return from the put call */
264 /* EPP 1.7 microsequences, ptr and len set at runtime */
265 static struct ppb_microseq epp17_outstr
[] = {
267 MS_RASSERT_P(MS_ACCUM
, MS_REG_EPP_D
),
272 static struct ppb_microseq epp17_instr
[] = {
274 MS_RFETCH_P(MS_ACCUM
, MS_REG_EPP_D
, MS_FETCH_ALL
),
280 imm_disconnect(struct vpoio_data
*vpo
, int *connected
, int release_bus
)
282 DECLARE_CPP_MICROSEQ
;
284 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
288 /* all should be ok */
292 ppb_MS_init_msq(cpp_microseq
, 4, CPP_S1
, (void *)&s1
,
293 CPP_S2
, (void *)&s2
, CPP_S3
, (void *)&s3
,
296 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, cpp_microseq
, &ret
);
298 if ((s1
!= (char)0xb8 || s2
!= (char)0x18 || s3
!= (char)0x38)) {
300 kprintf("imm%d: (disconnect) s1=0x%x s2=0x%x, s3=0x%x\n",
301 vpo
->vpo_unit
, s1
& 0xff, s2
& 0xff, s3
& 0xff);
303 *connected
= VP0_ECONNECT
;
307 return (ppb_release_bus(ppbus
, vpo
->vpo_dev
));
313 * how : PPB_WAIT or PPB_DONTWAIT
316 imm_connect(struct vpoio_data
*vpo
, int how
, int *disconnected
, int request_bus
)
318 DECLARE_CPP_MICROSEQ
;
320 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
325 /* all should be ok */
330 if ((error
= ppb_request_bus(ppbus
, vpo
->vpo_dev
, how
)))
333 ppb_MS_init_msq(cpp_microseq
, 3, CPP_S1
, (void *)&s1
,
334 CPP_S2
, (void *)&s2
, CPP_S3
, (void *)&s3
);
336 /* select device 0 in compatible mode */
337 ppb_MS_init_msq(cpp_microseq
, 1, CPP_PARAM
, 0xe0);
338 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, cpp_microseq
, &ret
);
340 /* disconnect all devices */
341 ppb_MS_init_msq(cpp_microseq
, 1, CPP_PARAM
, 0x30);
342 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, cpp_microseq
, &ret
);
344 if (PPB_IN_EPP_MODE(ppbus
))
345 ppb_MS_init_msq(cpp_microseq
, 1, CPP_PARAM
, 0x28);
347 ppb_MS_init_msq(cpp_microseq
, 1, CPP_PARAM
, 0xe0);
349 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, cpp_microseq
, &ret
);
351 if ((s1
!= (char)0xb8 || s2
!= (char)0x18 || s3
!= (char)0x30)) {
353 kprintf("imm%d: (connect) s1=0x%x s2=0x%x, s3=0x%x\n",
354 vpo
->vpo_unit
, s1
& 0xff, s2
& 0xff, s3
& 0xff);
356 *disconnected
= VP0_ECONNECT
;
365 * Detect and initialise the VP0 adapter.
368 imm_detect(struct vpoio_data
*vpo
)
370 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
373 if ((error
= ppb_request_bus(ppbus
, vpo
->vpo_dev
, PPB_DONTWAIT
)))
376 /* disconnect the drive, keep the bus */
377 imm_disconnect(vpo
, NULL
, 0);
379 vpo
->vpo_mode_found
= VP0_MODE_UNDEFINED
;
382 /* try to enter EPP mode since vpoio failure put the bus in NIBBLE */
383 if (ppb_set_mode(ppbus
, PPB_EPP
) != -1) {
384 imm_connect(vpo
, PPB_DONTWAIT
, &error
, 0);
387 /* if connection failed try PS/2 then NIBBLE modes */
389 if (ppb_set_mode(ppbus
, PPB_PS2
) != -1) {
390 imm_connect(vpo
, PPB_DONTWAIT
, &error
, 0);
393 if (ppb_set_mode(ppbus
, PPB_NIBBLE
) != -1) {
394 imm_connect(vpo
, PPB_DONTWAIT
, &error
, 0);
397 vpo
->vpo_mode_found
= VP0_MODE_NIBBLE
;
399 kprintf("imm%d: NIBBLE mode unavailable!\n", vpo
->vpo_unit
);
403 vpo
->vpo_mode_found
= VP0_MODE_PS2
;
406 vpo
->vpo_mode_found
= VP0_MODE_EPP
;
409 /* send SCSI reset signal */
410 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, reset_microseq
, NULL
);
412 /* release the bus now */
413 imm_disconnect(vpo
, &error
, 1);
415 /* ensure we are disconnected or daisy chained peripheral
416 * may cause serious problem to the disk */
420 kprintf("imm%d: can't disconnect from the drive\n",
428 ppb_release_bus(ppbus
, vpo
->vpo_dev
);
429 return (VP0_EINITFAILED
);
436 imm_outstr(struct vpoio_data
*vpo
, char *buffer
, int size
)
438 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
441 if (PPB_IN_EPP_MODE(ppbus
))
442 ppb_reset_epp_timeout(ppbus
);
444 ppb_MS_exec(ppbus
, vpo
->vpo_dev
, MS_OP_PUT
, (union ppb_insarg
)buffer
,
445 (union ppb_insarg
)size
, (union ppb_insarg
)MS_UNKNOWN
, &error
);
454 imm_instr(struct vpoio_data
*vpo
, char *buffer
, int size
)
456 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
459 if (PPB_IN_EPP_MODE(ppbus
))
460 ppb_reset_epp_timeout(ppbus
);
462 ppb_MS_exec(ppbus
, vpo
->vpo_dev
, MS_OP_GET
, (union ppb_insarg
)buffer
,
463 (union ppb_insarg
)size
, (union ppb_insarg
)MS_UNKNOWN
, &error
);
469 imm_select(struct vpoio_data
*vpo
, int initiator
, int target
)
471 DECLARE_SELECT_MICROSEQUENCE
;
472 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
475 /* initialize the select microsequence */
476 ppb_MS_init_msq(select_microseq
, 1,
477 SELECT_TARGET
, 1 << initiator
| 1 << target
);
479 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, select_microseq
, &ret
);
487 * H_SELIN must be low.
491 imm_wait(struct vpoio_data
*vpo
, int tmo
)
493 DECLARE_WAIT_MICROSEQUENCE
;
495 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
499 * Return some status information.
500 * Semantics : 0x88 = ZIP+ wants more data
501 * 0x98 = ZIP+ wants to send more data
502 * 0xa8 = ZIP+ wants command
503 * 0xb8 = end of transfer, ZIP+ is sending status
506 ppb_MS_init_msq(wait_microseq
, 2,
507 WAIT_RET
, (void *)&ret
,
510 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, wait_microseq
, &err
);
513 return (0); /* command timed out */
519 imm_negociate(struct vpoio_data
*vpo
)
521 DECLARE_NEGOCIATE_MICROSEQ
;
522 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
526 if (PPB_IN_NIBBLE_MODE(ppbus
))
528 else if (PPB_IN_PS2_MODE(ppbus
))
533 #if 0 /* XXX use standalone code not to depend on ppb_1284 code yet */
534 ret
= ppb_1284_negociate(ppbus
, negociate_mode
);
537 return (VP0_ENEGOCIATE
);
540 ppb_MS_init_msq(negociate_microseq
, 1,
541 NEGOCIATED_MODE
, negociate_mode
);
543 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, negociate_microseq
, &ret
);
551 * Low level probe of vpo device
555 imm_probe(device_t dev
, struct vpoio_data
*vpo
)
559 /* ppbus dependent initialisation */
562 /* now, try to initialise the drive */
563 if ((error
= imm_detect(vpo
))) {
573 * Low level attachment of vpo device
577 imm_attach(struct vpoio_data
*vpo
)
579 DECLARE_NIBBLE_INBYTE_SUBMICROSEQ
;
580 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
584 * Initialize microsequence code
586 vpo
->vpo_nibble_inbyte_msq
= kmalloc(sizeof(nibble_inbyte_submicroseq
),
589 bcopy((void *)nibble_inbyte_submicroseq
,
590 (void *)vpo
->vpo_nibble_inbyte_msq
,
591 sizeof(nibble_inbyte_submicroseq
));
593 ppb_MS_init_msq(vpo
->vpo_nibble_inbyte_msq
, 4,
594 INB_NIBBLE_H
, (void *)&(vpo
)->vpo_nibble
.h
,
595 INB_NIBBLE_L
, (void *)&(vpo
)->vpo_nibble
.l
,
596 INB_NIBBLE_F
, nibble_inbyte_hook
,
597 INB_NIBBLE_P
, (void *)&(vpo
)->vpo_nibble
);
600 * Initialize mode dependent in/out microsequences
602 if ((error
= ppb_request_bus(ppbus
, vpo
->vpo_dev
, PPB_WAIT
)))
605 /* ppbus automatically restore the last mode entered during detection */
606 switch (vpo
->vpo_mode_found
) {
608 ppb_MS_GET_init(ppbus
, vpo
->vpo_dev
, epp17_instr
);
609 ppb_MS_PUT_init(ppbus
, vpo
->vpo_dev
, epp17_outstr
);
610 kprintf("imm%d: EPP mode\n", vpo
->vpo_unit
);
613 ppb_MS_GET_init(ppbus
, vpo
->vpo_dev
, ps2_inbyte_submicroseq
);
614 ppb_MS_PUT_init(ppbus
, vpo
->vpo_dev
, spp_outbyte_submicroseq
);
615 kprintf("imm%d: PS2 mode\n", vpo
->vpo_unit
);
617 case VP0_MODE_NIBBLE
:
618 ppb_MS_GET_init(ppbus
, vpo
->vpo_dev
, vpo
->vpo_nibble_inbyte_msq
);
619 ppb_MS_PUT_init(ppbus
, vpo
->vpo_dev
, spp_outbyte_submicroseq
);
620 kprintf("imm%d: NIBBLE mode\n", vpo
->vpo_unit
);
623 panic("imm: unknown mode %d", vpo
->vpo_mode_found
);
626 ppb_release_bus(ppbus
, vpo
->vpo_dev
);
636 imm_reset_bus(struct vpoio_data
*vpo
)
638 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
641 /* first, connect to the drive and request the bus */
642 imm_connect(vpo
, PPB_WAIT
|PPB_INTR
, &disconnected
, 1);
646 /* reset the SCSI bus */
647 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, reset_microseq
, NULL
);
649 /* then disconnect */
650 imm_disconnect(vpo
, NULL
, 1);
659 * Send an SCSI command
663 imm_do_scsi(struct vpoio_data
*vpo
, int host
, int target
, char *command
,
664 int clen
, char *buffer
, int blen
, int *result
, int *count
,
667 device_t ppbus
= device_get_parent(vpo
->vpo_dev
);
670 int len
, error
= 0, not_connected
= 0;
675 * enter disk state, allocate the ppbus
678 * Should we allow this call to be interruptible?
679 * The only way to report the interruption is to return
680 * EIO to upper SCSI code :^(
682 if ((error
= imm_connect(vpo
, PPB_WAIT
|PPB_INTR
, ¬_connected
, 1)))
686 *ret
= VP0_ECONNECT
; goto error
;
690 * Select the drive ...
692 if ((*ret
= imm_select(vpo
,host
,target
)))
696 * Send the command ...
698 for (k
= 0; k
< clen
; k
+=2) {
699 if (imm_wait(vpo
, VP0_FAST_SPINTMO
) != (char)0xa8) {
700 *ret
= VP0_ECMD_TIMEOUT
;
703 if (imm_outstr(vpo
, &command
[k
], 2)) {
704 *ret
= VP0_EPPDATA_TIMEOUT
;
709 if (!(r
= imm_wait(vpo
, VP0_LOW_SPINTMO
))) {
710 *ret
= VP0_ESTATUS_TIMEOUT
; goto error
;
713 if ((r
& 0x30) == 0x10) {
714 if (imm_negociate(vpo
)) {
715 *ret
= VP0_ENEGOCIATE
;
722 * Complete transfer ...
727 if (!(r
= imm_wait(vpo
, VP0_LOW_SPINTMO
))) {
728 *ret
= VP0_ESTATUS_TIMEOUT
; goto error
;
731 /* stop when the ZIP+ wants to send status */
735 if (*count
>= blen
) {
736 *ret
= VP0_EDATA_OVERFLOW
;
740 /* ZIP+ wants to send data? */
741 if (r
== (char)0x88) {
742 len
= (((blen
- *count
) >= VP0_SECTOR_SIZE
)) ?
745 error
= imm_outstr(vpo
, &buffer
[*count
], len
);
747 if (!PPB_IN_EPP_MODE(ppbus
))
750 len
= (((blen
- *count
) >= VP0_SECTOR_SIZE
)) ?
753 error
= imm_instr(vpo
, &buffer
[*count
], len
);
764 if ((PPB_IN_NIBBLE_MODE(ppbus
) ||
765 PPB_IN_PS2_MODE(ppbus
)) && negociated
)
766 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, transfer_epilog
, NULL
);
769 * Retrieve status ...
771 if (imm_negociate(vpo
)) {
772 *ret
= VP0_ENEGOCIATE
;
777 if (imm_instr(vpo
, &l
, 1)) {
778 *ret
= VP0_EOTHER
; goto error
;
781 /* check if the ZIP+ wants to send more status */
782 if (imm_wait(vpo
, VP0_FAST_SPINTMO
) == (char)0xb8)
783 if (imm_instr(vpo
, &h
, 1)) {
784 *ret
= VP0_EOTHER
+2; goto error
;
787 /* Experience showed that we should discard this */
791 *result
= ((int) h
<< 8) | ((int) l
& 0xff);
794 if ((PPB_IN_NIBBLE_MODE(ppbus
) ||
795 PPB_IN_PS2_MODE(ppbus
)) && negociated
)
796 ppb_MS_microseq(ppbus
, vpo
->vpo_dev
, transfer_epilog
, NULL
);
798 /* return to printer state, release the ppbus */
799 imm_disconnect(vpo
, NULL
, 1);