21ca87605bb482563b6610e8b21ae3b97bc8159b
[dragonfly.git] / sys / dev / disk / vpo / vpoio.c
1 /*-
2  * Copyright (c) 1998, 1999 Nicolas Souchu
3  * Copyright (c) 2000 Alcove - Nicolas Souchu
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
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.
14  *
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
25  * SUCH DAMAGE.
26  *
27  * $FreeBSD: src/sys/dev/ppbus/vpoio.c,v 1.10.2.3 2001/10/02 05:27:20 nsouch Exp $
28  * $DragonFly: src/sys/dev/disk/vpo/vpoio.c,v 1.8 2006/12/22 23:26:17 swildner Exp $
29  *
30  */
31
32 #ifdef _KERNEL
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/module.h>
36 #include <sys/bus.h>
37 #include <sys/malloc.h>
38
39 #include <machine/clock.h>
40
41 #endif
42
43 #ifdef  _KERNEL
44 #endif
45
46 #include "opt_vpo.h"
47
48 #include <bus/ppbus/ppbio.h>
49 #include <bus/ppbus/ppbconf.h>
50 #include <bus/ppbus/ppb_msq.h>
51 #include "vpoio.h"
52
53 #include "ppbus_if.h"
54
55 /*
56  * The driver pools the drive. We may add a timeout queue to avoid
57  * active polling on nACK. I've tried this but it leads to unreliable
58  * transfers
59  */
60 #define VP0_SELTMO              5000    /* select timeout */
61 #define VP0_FAST_SPINTMO        500000  /* wait status timeout */
62 #define VP0_LOW_SPINTMO         5000000 /* wait status timeout */
63
64 /*
65  * Actually, VP0 timings are more accurate (about few 16MHZ cycles),
66  * but succeeding in respecting such timings leads to architecture
67  * dependent considerations.
68  */
69 #define VP0_PULSE               1
70
71 #define VP0_SECTOR_SIZE 512
72 #define VP0_BUFFER_SIZE 0x12000
73
74 #define n(flags) (~(flags) & (flags))
75
76 /*
77  * VP0 connections.
78  */
79 #define H_AUTO          n(AUTOFEED)
80 #define H_nAUTO         AUTOFEED
81 #define H_STROBE        n(STROBE)
82 #define H_nSTROBE       STROBE
83 #define H_BSY           n(nBUSY)
84 #define H_nBSY          nBUSY
85 #define H_SEL           SELECT
86 #define H_nSEL          n(SELECT)
87 #define H_ERR           PERROR
88 #define H_nERR          n(PERROR)
89 #define H_ACK           nACK
90 #define H_nACK          n(nACK)
91 #define H_FLT           nFAULT
92 #define H_nFLT          n(nFAULT)
93 #define H_SELIN         n(SELECTIN)
94 #define H_nSELIN        SELECTIN
95 #define H_INIT          nINIT
96 #define H_nINIT         n(nINIT)
97
98 /*
99  * Microcode to execute very fast I/O sequences at the lowest bus level.
100  */
101
102 #define WAIT_RET        MS_PARAM(4, 2, MS_TYP_PTR)
103 #define WAIT_TMO        MS_PARAM(0, 0, MS_TYP_INT)
104
105 #define DECLARE_WAIT_MICROSEQUENCE                      \
106 struct ppb_microseq wait_microseq[] = {                 \
107         MS_SET(MS_UNKNOWN),                             \
108         /* loop */                                      \
109         MS_BRSET(nBUSY, 2 /* ready */),                 \
110         MS_DBRA(-2 /* loop */),                         \
111         MS_RET(1), /* timed out */                      \
112         /* ready */                                     \
113         MS_RFETCH(MS_REG_STR, 0xf0, MS_UNKNOWN),        \
114         MS_RET(0) /* no error */                        \
115 }
116
117 /* call this macro to initialize connect/disconnect microsequences */
118 #define INIT_TRIG_MICROSEQ {                                            \
119         int i;                                                          \
120         for (i=1; i <= 7; i+=2) {                                       \
121                 disconnect_microseq[i].arg[2] = (union ppb_insarg)d_pulse; \
122                 connect_epp_microseq[i].arg[2] =                        \
123                 connect_spp_microseq[i].arg[2] = (union ppb_insarg)c_pulse; \
124         }                                                               \
125 }
126
127 #define trig_d_pulse MS_TRIG(MS_REG_CTR,5,MS_UNKNOWN /* d_pulse */)
128 static char d_pulse[] = {
129          H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
130         H_nAUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE,
131          H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
132          H_AUTO |  H_SELIN | H_INIT | H_STROBE, VP0_PULSE,
133          H_AUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE
134 };
135
136 #define trig_c_pulse MS_TRIG(MS_REG_CTR,5,MS_UNKNOWN /* c_pulse */)
137 static char c_pulse[] = {
138          H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
139          H_AUTO |  H_SELIN | H_INIT | H_STROBE, 0,
140         H_nAUTO |  H_SELIN | H_INIT | H_STROBE, VP0_PULSE,
141          H_AUTO |  H_SELIN | H_INIT | H_STROBE, 0,
142          H_AUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE
143 };
144
145 static struct ppb_microseq disconnect_microseq[] = {
146           MS_DASS(0x0), trig_d_pulse, MS_DASS(0x3c), trig_d_pulse,
147           MS_DASS(0x20), trig_d_pulse, MS_DASS(0xf), trig_d_pulse, MS_RET(0)
148 };
149
150 static struct ppb_microseq connect_epp_microseq[] = {
151           MS_DASS(0x0), trig_c_pulse, MS_DASS(0x3c), trig_c_pulse,
152           MS_DASS(0x20), trig_c_pulse, MS_DASS(0xcf), trig_c_pulse, MS_RET(0)
153 };
154
155 static struct ppb_microseq connect_spp_microseq[] = {
156           MS_DASS(0x0), trig_c_pulse, MS_DASS(0x3c), trig_c_pulse,
157           MS_DASS(0x20), trig_c_pulse, MS_DASS(0x8f), trig_c_pulse, MS_RET(0)
158 };
159
160 /*
161  * nibble_inbyte_hook()
162  *
163  * Formats high and low nibble into a character
164  */
165 static int
166 nibble_inbyte_hook (void *p, char *ptr)
167 {
168         struct vpo_nibble *s = (struct vpo_nibble *)p;
169
170         /* increment the buffer pointer */
171         *ptr++ = ((s->l >> 4) & 0x0f) + (s->h & 0xf0);
172
173         return (0);
174 }
175
176 #define INB_NIBBLE_H MS_PARAM(2, 2, MS_TYP_PTR)
177 #define INB_NIBBLE_L MS_PARAM(4, 2, MS_TYP_PTR)
178 #define INB_NIBBLE_F MS_PARAM(5, 0, MS_TYP_FUN)
179 #define INB_NIBBLE_P MS_PARAM(5, 1, MS_TYP_PTR)
180
181 /*
182  * This is the sub-microseqence for MS_GET in NIBBLE mode
183  * Retrieve the two nibbles and call the C function to generate the character
184  * and store it in the buffer (see nibble_inbyte_hook())
185  */
186
187 #define DECLARE_NIBBLE_INBYTE_SUBMICROSEQ                       \
188 struct ppb_microseq nibble_inbyte_submicroseq[] = {             \
189 /* loop: */                                                     \
190           MS_CASS( H_AUTO | H_SELIN | H_INIT | H_STROBE),       \
191           MS_DELAY(VP0_PULSE),                                  \
192           MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\
193           MS_CASS(H_nAUTO | H_SELIN | H_INIT | H_STROBE),       \
194           MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\
195           /* do a C call to format the received nibbles */      \
196           MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */),\
197           MS_DBRA(-7 /* loop */),                               \
198           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),       \
199           MS_RET(0)                                             \
200 }
201
202 /*
203  * This is the sub-microseqence for MS_GET in PS2 mode
204  */
205 static struct ppb_microseq ps2_inbyte_submicroseq[] = {
206           MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_nSTROBE),
207
208 /* loop: */
209           MS_RFETCH_P(1, MS_REG_DTR, MS_FETCH_ALL),
210           MS_CASS(PCD | H_nAUTO | H_SELIN | H_INIT | H_nSTROBE),
211           MS_CASS(PCD |  H_AUTO | H_SELIN | H_INIT | H_nSTROBE),
212           MS_DBRA(-4 /* loop */),
213
214           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
215           MS_RET(0)
216 };
217
218 /*
219  * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes
220  */
221 static struct ppb_microseq spp_outbyte_submicroseq[] = {
222
223 /* loop: */
224           MS_RASSERT_P(1, MS_REG_DTR), 
225           MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
226           MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
227           MS_DELAY(VP0_PULSE),
228           MS_DBRA(-5 /* loop */),
229
230           /* return from the put call */
231           MS_RET(0)
232 };
233
234 /* EPP 1.7 microsequences, ptr and len set at runtime */
235 static struct ppb_microseq epp17_outstr_body[] = {
236           MS_CASS(H_AUTO | H_SELIN | H_INIT | H_STROBE),
237
238 /* loop: */
239           MS_RASSERT_P(1, MS_REG_EPP_D), 
240           MS_BRSET(TIMEOUT, 3 /* error */),     /* EPP timeout? */
241           MS_DBRA(-3 /* loop */),
242
243           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
244           MS_RET(0),
245 /* error: */
246           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
247           MS_RET(1)
248 };
249
250 static struct ppb_microseq epp17_instr_body[] = {
251           MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_STROBE),
252
253 /* loop: */
254           MS_RFETCH_P(1, MS_REG_EPP_D, MS_FETCH_ALL), 
255           MS_BRSET(TIMEOUT, 3 /* error */),     /* EPP timeout? */
256           MS_DBRA(-3 /* loop */),
257
258           MS_CASS(PCD | H_AUTO | H_nSELIN | H_INIT | H_STROBE),
259           MS_RET(0),
260 /* error: */
261           MS_CASS(PCD | H_AUTO | H_nSELIN | H_INIT | H_STROBE),
262           MS_RET(1)
263 };
264
265 static struct ppb_microseq in_disk_mode[] = {
266           MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
267           MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
268
269           MS_BRCLEAR(H_FLT, 3 /* error */),
270           MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
271           MS_BRSET(H_FLT, 1 /* error */),
272
273           MS_RET(1),
274 /* error: */
275           MS_RET(0)
276 };
277
278 static int
279 vpoio_disconnect(struct vpoio_data *vpo)
280 {
281         device_t ppbus = device_get_parent(vpo->vpo_dev);
282         int ret;
283
284         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
285         return (ppb_release_bus(ppbus, vpo->vpo_dev));
286 }
287
288 /*
289  * how  : PPB_WAIT or PPB_DONTWAIT
290  */
291 static int
292 vpoio_connect(struct vpoio_data *vpo, int how)
293 {
294         device_t ppbus = device_get_parent(vpo->vpo_dev);
295         int error;
296         int ret;
297
298         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, how))) {
299
300 #ifdef VP0_DEBUG
301                 kprintf("%s: can't request bus!\n", __func__);
302 #endif
303                 return error;
304         }
305
306         if (PPB_IN_EPP_MODE(ppbus))
307                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_epp_microseq, &ret);
308         else
309                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_spp_microseq, &ret);
310
311         return (0);
312 }
313
314 /*
315  * vpoio_reset()
316  *
317  * SCSI reset signal, the drive must be in disk mode
318  */
319 static void
320 vpoio_reset (struct vpoio_data *vpo)
321 {
322         device_t ppbus = device_get_parent(vpo->vpo_dev);
323         int ret;
324
325         struct ppb_microseq reset_microseq[] = {
326
327                 #define INITIATOR       MS_PARAM(0, 1, MS_TYP_INT)
328
329                 MS_DASS(MS_UNKNOWN),
330                 MS_CASS(H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
331                 MS_DELAY(25),
332                 MS_CASS(H_AUTO | H_nSELIN |  H_INIT | H_STROBE),
333                 MS_RET(0)
334         };
335
336         ppb_MS_init_msq(reset_microseq, 1, INITIATOR, 1 << VP0_INITIATOR);
337         ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, &ret);
338
339         return;
340 }
341
342 /*
343  * vpoio_in_disk_mode()
344  */
345 static int
346 vpoio_in_disk_mode(struct vpoio_data *vpo)
347 {
348         device_t ppbus = device_get_parent(vpo->vpo_dev);
349         int ret;
350
351         ppb_MS_microseq(ppbus, vpo->vpo_dev, in_disk_mode, &ret);
352
353         return (ret);
354 }
355
356 /*
357  * vpoio_detect()
358  *
359  * Detect and initialise the VP0 adapter.
360  */
361 static int
362 vpoio_detect(struct vpoio_data *vpo)
363 {
364         device_t ppbus = device_get_parent(vpo->vpo_dev);
365         int error, ret;
366
367         /* allocate the bus, then apply microsequences */
368         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_DONTWAIT)))
369                 return (error);
370
371         /* Force disconnection */
372         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
373
374         /* Try to enter EPP mode, then connect to the drive in EPP mode */
375         if (ppb_set_mode(ppbus, PPB_EPP) != -1) {
376                 /* call manually the microseq instead of using the appropriate function
377                  * since we already requested the ppbus */
378                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_epp_microseq, &ret);
379         }
380
381         /* If EPP mode switch failed or ZIP connection in EPP mode failed,
382          * try to connect in NIBBLE mode */
383         if (!vpoio_in_disk_mode(vpo)) {
384
385                 /* The interface must be at least PS/2 or NIBBLE capable.
386                  * There is no way to know if the ZIP will work with
387                  * PS/2 mode since PS/2 and SPP both use the same connect
388                  * sequence. One must supress PS/2 with boot flags if
389                  * PS/2 mode fails (see ppc(4)).
390                  */
391                 if (ppb_set_mode(ppbus, PPB_PS2) != -1) {
392                         vpo->vpo_mode_found = VP0_MODE_PS2;
393                 } else {
394                         if (ppb_set_mode(ppbus, PPB_NIBBLE) == -1)
395                                 goto error;
396
397                         vpo->vpo_mode_found = VP0_MODE_NIBBLE;
398                 }
399
400                 /* Can't know if the interface is capable of PS/2 yet */
401                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_spp_microseq, &ret);
402                 if (!vpoio_in_disk_mode(vpo)) {
403                         vpo->vpo_mode_found = VP0_MODE_UNDEFINED;
404                         if (bootverbose)
405                                 kprintf("vpo%d: can't connect to the drive\n",
406                                         vpo->vpo_unit);
407
408                         /* disconnect and release the bus */
409                         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq,
410                                         &ret);
411                         goto error;
412                 }
413         } else {
414                 vpo->vpo_mode_found = VP0_MODE_EPP;
415         }
416
417         /* send SCSI reset signal */
418         vpoio_reset(vpo);
419
420         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
421
422         /* ensure we are disconnected or daisy chained peripheral 
423          * may cause serious problem to the disk */
424         if (vpoio_in_disk_mode(vpo)) {
425                 if (bootverbose)
426                         kprintf("vpo%d: can't disconnect from the drive\n",
427                                 vpo->vpo_unit);
428                 goto error;
429         }
430
431         ppb_release_bus(ppbus, vpo->vpo_dev);
432         return (0);
433
434 error:
435         ppb_release_bus(ppbus, vpo->vpo_dev);
436         return (VP0_EINITFAILED);
437 }
438
439 /*
440  * vpoio_outstr()
441  */
442 static int
443 vpoio_outstr(struct vpoio_data *vpo, char *buffer, int size)
444 {
445         device_t ppbus = device_get_parent(vpo->vpo_dev);
446         int error = 0;
447
448         ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_PUT, (union ppb_insarg)buffer,
449                 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
450
451         ppb_ecp_sync(ppbus);
452
453         return (error);
454 }
455
456 /*
457  * vpoio_instr()
458  */
459 static int
460 vpoio_instr(struct vpoio_data *vpo, char *buffer, int size)
461 {
462         device_t ppbus = device_get_parent(vpo->vpo_dev);
463         int error = 0;
464
465         ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_GET, (union ppb_insarg)buffer,
466                 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
467
468         ppb_ecp_sync(ppbus);
469
470         return (error);
471 }
472
473 static char
474 vpoio_select(struct vpoio_data *vpo, int initiator, int target)
475 {
476         device_t ppbus = device_get_parent(vpo->vpo_dev);
477         int ret;
478
479         struct ppb_microseq select_microseq[] = {
480
481                 /* parameter list
482                  */
483                 #define SELECT_TARGET           MS_PARAM(0, 1, MS_TYP_INT)
484                 #define SELECT_INITIATOR        MS_PARAM(3, 1, MS_TYP_INT)
485
486                 /* send the select command to the drive */
487                 MS_DASS(MS_UNKNOWN),
488                 MS_CASS(H_nAUTO | H_nSELIN |  H_INIT | H_STROBE),
489                 MS_CASS( H_AUTO | H_nSELIN |  H_INIT | H_STROBE),
490                 MS_DASS(MS_UNKNOWN),
491                 MS_CASS( H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
492
493                 /* now, wait until the drive is ready */
494                 MS_SET(VP0_SELTMO),
495 /* loop: */     MS_BRSET(H_ACK, 2 /* ready */),
496                 MS_DBRA(-2 /* loop */),
497 /* error: */    MS_RET(1),
498 /* ready: */    MS_RET(0)
499         };
500
501         /* initialize the select microsequence */
502         ppb_MS_init_msq(select_microseq, 2,
503                         SELECT_TARGET, 1 << target,
504                         SELECT_INITIATOR, 1 << initiator);
505                                 
506         ppb_MS_microseq(ppbus, vpo->vpo_dev, select_microseq, &ret);
507
508         if (ret)
509                 return (VP0_ESELECT_TIMEOUT);
510
511         return (0);
512 }
513
514 /*
515  * vpoio_wait()
516  *
517  * H_SELIN must be low.
518  *
519  * XXX should be ported to microseq
520  */
521 static char
522 vpoio_wait(struct vpoio_data *vpo, int tmo)
523 {
524         DECLARE_WAIT_MICROSEQUENCE;
525
526         device_t ppbus = device_get_parent(vpo->vpo_dev);
527         int ret, err;
528
529 #if 0   /* broken */
530         if (ppb_poll_device(ppbus, 150, nBUSY, nBUSY, PPB_INTR))
531                 return (0);
532
533         return (ppb_rstr(ppbus) & 0xf0);
534 #endif
535
536         /*
537          * Return some status information.
538          * Semantics :  0xc0 = ZIP wants more data
539          *              0xd0 = ZIP wants to send more data
540          *              0xe0 = ZIP wants command
541          *              0xf0 = end of transfer, ZIP is sending status
542          */
543
544         ppb_MS_init_msq(wait_microseq, 2,
545                         WAIT_RET, (void *)&ret,
546                         WAIT_TMO, tmo);
547
548         ppb_MS_microseq(ppbus, vpo->vpo_dev, wait_microseq, &err);
549
550         if (err)
551                 return (0);      /* command timed out */        
552
553         return(ret);
554 }
555
556 /*
557  * vpoio_probe()
558  *
559  * Low level probe of vpo device
560  *
561  */
562 int
563 vpoio_probe(device_t dev, struct vpoio_data *vpo)
564 {
565         int error;
566
567         /* ppbus dependent initialisation */
568         vpo->vpo_dev = dev;
569
570         /*
571          * Initialize microsequence code
572          */
573         INIT_TRIG_MICROSEQ;
574
575         /* now, try to initialise the drive */
576         if ((error = vpoio_detect(vpo))) {
577                 return (error);
578         }
579
580         return (0);
581 }
582
583 /*
584  * vpoio_attach()
585  *
586  * Low level attachment of vpo device
587  *
588  */
589 int
590 vpoio_attach(struct vpoio_data *vpo)
591 {
592         DECLARE_NIBBLE_INBYTE_SUBMICROSEQ;      
593         device_t ppbus = device_get_parent(vpo->vpo_dev);
594         int error = 0;
595
596         vpo->vpo_nibble_inbyte_msq = kmalloc(sizeof(nibble_inbyte_submicroseq),
597                                                 M_DEVBUF, M_WAITOK);
598
599         bcopy((void *)nibble_inbyte_submicroseq,
600                 (void *)vpo->vpo_nibble_inbyte_msq,
601                 sizeof(nibble_inbyte_submicroseq));
602
603         ppb_MS_init_msq(vpo->vpo_nibble_inbyte_msq, 4,
604                 INB_NIBBLE_H, (void *)&(vpo)->vpo_nibble.h,
605                 INB_NIBBLE_L, (void *)&(vpo)->vpo_nibble.l,
606                 INB_NIBBLE_F, nibble_inbyte_hook,
607                 INB_NIBBLE_P, (void *)&(vpo)->vpo_nibble); 
608
609         /*
610          * Initialize mode dependent in/out microsequences
611          */
612         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_WAIT)))
613                 goto error;
614
615         /* ppbus sets automatically the last mode entered during detection */
616         switch (vpo->vpo_mode_found) {
617         case VP0_MODE_EPP:
618                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, epp17_instr_body);
619                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, epp17_outstr_body);
620                 kprintf("vpo%d: EPP mode\n", vpo->vpo_unit);
621                 break;
622         case VP0_MODE_PS2:
623                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, ps2_inbyte_submicroseq);
624                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
625                 kprintf("vpo%d: PS2 mode\n", vpo->vpo_unit);
626                 break;
627         case VP0_MODE_NIBBLE:
628                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, vpo->vpo_nibble_inbyte_msq);
629                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
630                 kprintf("vpo%d: NIBBLE mode\n", vpo->vpo_unit);
631                 break;
632         default:
633                 panic("vpo: unknown mode %d", vpo->vpo_mode_found);
634         }
635
636         ppb_release_bus(ppbus, vpo->vpo_dev);
637
638 error:
639         return (error);
640 }
641
642 /*
643  * vpoio_reset_bus()
644  *
645  */
646 int
647 vpoio_reset_bus(struct vpoio_data *vpo)
648 {
649         /* first, connect to the drive */
650         if (vpoio_connect(vpo, PPB_WAIT|PPB_INTR) || !vpoio_in_disk_mode(vpo)) {
651
652 #ifdef VP0_DEBUG
653                 kprintf("%s: not in disk mode!\n", __func__);
654 #endif
655                 /* release ppbus */
656                 vpoio_disconnect(vpo);
657                 return (1);
658         }
659
660         /* reset the SCSI bus */
661         vpoio_reset(vpo);
662
663         /* then disconnect */
664         vpoio_disconnect(vpo);
665
666         return (0);
667 }
668
669 /*
670  * vpoio_do_scsi()
671  *
672  * Send an SCSI command
673  *
674  */
675 int 
676 vpoio_do_scsi(struct vpoio_data *vpo, int host, int target, char *command,
677                 int clen, char *buffer, int blen, int *result, int *count,
678                 int *ret)
679 {
680         device_t ppbus = device_get_parent(vpo->vpo_dev);
681         char r;
682         char l, h = 0;
683         int len, error = 0;
684         int k;
685
686         /*
687          * enter disk state, allocate the ppbus
688          *
689          * XXX
690          * Should we allow this call to be interruptible?
691          * The only way to report the interruption is to return
692          * EIO do upper SCSI code :^(
693          */
694         if ((error = vpoio_connect(vpo, PPB_WAIT|PPB_INTR)))
695                 return (error);
696
697         if (!vpoio_in_disk_mode(vpo)) {
698                 *ret = VP0_ECONNECT; goto error;
699         }
700
701         if ((*ret = vpoio_select(vpo,host,target)))
702                 goto error;
703
704         /*
705          * Send the command ...
706          *
707          * set H_SELIN low for vpoio_wait().
708          */
709         ppb_wctr(ppbus, H_AUTO | H_nSELIN | H_INIT | H_STROBE);
710
711         for (k = 0; k < clen; k++) {
712                 if (vpoio_wait(vpo, VP0_FAST_SPINTMO) != (char)0xe0) {
713                         *ret = VP0_ECMD_TIMEOUT;
714                         goto error;
715                 }
716                 if (vpoio_outstr(vpo, &command[k], 1)) {
717                         *ret = VP0_EPPDATA_TIMEOUT;
718                         goto error;
719                 }
720         }
721
722         /* 
723          * Completion ... 
724          */
725
726         *count = 0;
727         for (;;) {
728
729                 if (!(r = vpoio_wait(vpo, VP0_LOW_SPINTMO))) {
730                         *ret = VP0_ESTATUS_TIMEOUT; goto error;
731                 }
732
733                 /* stop when the ZIP wants to send status */
734                 if (r == (char)0xf0)
735                         break;
736
737                 if (*count >= blen) {
738                         *ret = VP0_EDATA_OVERFLOW;
739                         goto error;
740                 }
741
742                 /* if in EPP mode or writing bytes, try to transfer a sector
743                  * otherwise, just send one byte
744                  */
745                 if (PPB_IN_EPP_MODE(ppbus) || r == (char)0xc0)
746                         len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
747                                 VP0_SECTOR_SIZE : 1;
748                 else
749                         len = 1;
750
751                 /* ZIP wants to send data? */
752                 if (r == (char)0xc0)
753                         error = vpoio_outstr(vpo, &buffer[*count], len);
754                 else
755                         error = vpoio_instr(vpo, &buffer[*count], len);
756
757                 if (error) {
758                         *ret = error;
759                         goto error;
760                 }
761
762                 *count += len;
763         }
764
765         if (vpoio_instr(vpo, &l, 1)) {
766                 *ret = VP0_EOTHER; goto error;
767         }
768
769         /* check if the ZIP wants to send more status */
770         if (vpoio_wait(vpo, VP0_FAST_SPINTMO) == (char)0xf0)
771                 if (vpoio_instr(vpo, &h, 1)) {
772                         *ret = VP0_EOTHER+2; goto error;
773                 }
774
775         *result = ((int) h << 8) | ((int) l & 0xff);
776
777 error:
778         /* return to printer state, release the ppbus */
779         vpoio_disconnect(vpo);
780         return (0);
781 }