hdc9224.c revision 1.51.18.2 1 /* $NetBSD: hdc9224.c,v 1.51.18.2 2014/08/20 00:03:28 tls Exp $ */
2 /*
3 * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
4 * All rights reserved.
5 *
6 * This code is derived from software contributed to Ludd by Bertram Barth.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed at Ludd, University of
19 * Lule}, Sweden and its contributors.
20 * 4. The name of the author may not be used to endorse or promote products
21 * derived from this software without specific prior written permission
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 /*
36 * with much help from (in alphabetical order):
37 * Jeremy
38 * Roger Ivie
39 * Rick Macklem
40 * Mike Young
41 *
42 * Rewritten by Ragge 25 Jun 2000. New features:
43 * - Uses interrupts instead of polling to signal ready.
44 * - Can cooperate with the SCSI routines WRT. the DMA area.
45 *
46 * TODO:
47 * - Floppy support missing.
48 * - Bad block forwarding missing.
49 * - Statistics collection.
50 */
51 #undef RDDEBUG
52
53 #include <sys/cdefs.h>
54 __KERNEL_RCSID(0, "$NetBSD: hdc9224.c,v 1.51.18.2 2014/08/20 00:03:28 tls Exp $");
55
56 #include <sys/param.h>
57 #include <sys/systm.h>
58 #include <sys/buf.h>
59 #include <sys/bufq.h>
60 #include <sys/cpu.h>
61 #include <sys/conf.h>
62 #include <sys/device.h>
63 #include <sys/disklabel.h>
64 #include <sys/disk.h>
65 #include <sys/file.h>
66 #include <sys/ioctl.h>
67 #include <sys/proc.h>
68 #include <sys/stat.h>
69 #include <sys/syslog.h>
70
71 #include <uvm/uvm_extern.h>
72
73 #include <ufs/ufs/dinode.h> /* For BBSIZE */
74 #include <ufs/ffs/fs.h>
75
76 #include <machine/sid.h>
77 #include <machine/ka410.h>
78 #include <machine/vsbus.h>
79 #include <machine/rpb.h>
80 #include <machine/scb.h>
81
82 #include <dev/mscp/mscp.h> /* For DEC disk encoding */
83
84 #include <vax/vsa/hdc9224.h>
85
86 #include "ioconf.h"
87 #include "locators.h"
88
89
90 /*
91 * on-disk geometry block
92 */
93 #define _aP __attribute__ ((packed)) /* force byte-alignment */
94 struct rdgeom {
95 char mbz[10]; /* 10 bytes of zero */
96 long xbn_count _aP; /* number of XBNs */
97 long dbn_count _aP; /* number of DBNs */
98 long lbn_count _aP; /* number of LBNs (Logical-Block-Numbers) */
99 long rbn_count _aP; /* number of RBNs (Replacement-Block-Numbers) */
100 short nspt; /* number of sectors per track */
101 short ntracks; /* number of tracks */
102 short ncylinders; /* number of cylinders */
103 short precomp; /* first cylinder for write precompensation */
104 short reduced; /* first cylinder for reduced write current */
105 short seek_rate; /* seek rate or zero for buffered seeks */
106 short crc_eec; /* 0 if CRC, 1 if ECC is being used */
107 short rct; /* "replacement control table" (RCT) */
108 short rct_ncopies; /* number of copies of the RCT */
109 long media_id _aP; /* media identifier */
110 short interleave; /* sector-to-sector interleave */
111 short headskew; /* head-to-head skew */
112 short cylskew; /* cylinder-to-cylinder skew */
113 short gap0_size; /* size of GAP 0 in the MFM format */
114 short gap1_size; /* size of GAP 1 in the MFM format */
115 short gap2_size; /* size of GAP 2 in the MFM format */
116 short gap3_size; /* size of GAP 3 in the MFM format */
117 short sync_value; /* sync value used when formatting */
118 char reserved[32]; /* reserved for use by the RQDX formatter */
119 short serial_number; /* serial number */
120 #if 0 /* we don't need these 412 useless bytes ... */
121 char fill[412-2]; /* Filler bytes to the end of the block */
122 short checksum; /* checksum over the XBN */
123 #endif
124 };
125
126 /*
127 * Software status
128 */
129 struct rdsoftc {
130 device_t sc_dev; /* must be here! (pseudo-OOP:) */
131 struct hdcsoftc *sc_hdc;
132 struct disk sc_disk; /* disklabel etc. */
133 struct rdgeom sc_xbn; /* on-disk geometry information */
134 int sc_drive; /* physical unit number */
135 };
136
137 struct hdcsoftc {
138 device_t sc_dev; /* must be here (pseudo-OOP:) */
139 struct evcnt sc_intrcnt;
140 struct vsbus_dma sc_vd;
141 vaddr_t sc_regs; /* register addresses */
142 struct bufq_state *sc_q;
143 struct buf *sc_active;
144 struct hdc9224_UDCreg sc_creg; /* (command) registers to be written */
145 struct hdc9224_UDCreg sc_sreg; /* (status) registers being read */
146 void * sc_dmabase; /* */
147 int sc_dmasize;
148 void *sc_bufaddr; /* Current in-core address */
149 int sc_diskblk; /* Current block on disk */
150 int sc_bytecnt; /* How much left to transfer */
151 int sc_xfer; /* Current transfer size */
152 int sc_retries;
153 volatile u_char sc_status; /* last status from interrupt */
154 char sc_intbit;
155 };
156
157 struct hdc_attach_args {
158 int ha_drive;
159 };
160
161 /*
162 * prototypes for (almost) all the internal routines
163 */
164 static int hdcmatch(device_t, cfdata_t, void *);
165 static void hdcattach(device_t, device_t, void *);
166 static int hdcprint(void *, const char *);
167 static int rdmatch(device_t, cfdata_t, void *);
168 static void rdattach(device_t, device_t, void *);
169 static void hdcintr(void *);
170 static int hdc_command(struct hdcsoftc *, int);
171 static void rd_readgeom(struct hdcsoftc *, struct rdsoftc *);
172 #ifdef RDDEBUG
173 static void hdc_printgeom( struct rdgeom *);
174 #endif
175 static void hdc_writeregs(struct hdcsoftc *);
176 static void hdcstart(struct hdcsoftc *, struct buf *);
177 static int hdc_rdselect(struct hdcsoftc *, int);
178 static void rdmakelabel(struct disklabel *, struct rdgeom *);
179 static void hdc_writeregs(struct hdcsoftc *);
180 static void hdc_readregs(struct hdcsoftc *);
181 static void hdc_qstart(void *);
182
183 CFATTACH_DECL_NEW(hdc, sizeof(struct hdcsoftc),
184 hdcmatch, hdcattach, NULL, NULL);
185
186 CFATTACH_DECL_NEW(rd, sizeof(struct rdsoftc),
187 rdmatch, rdattach, NULL, NULL);
188
189 static dev_type_open(rdopen);
190 static dev_type_close(rdclose);
191 static dev_type_read(rdread);
192 static dev_type_write(rdwrite);
193 static dev_type_ioctl(rdioctl);
194 static dev_type_strategy(rdstrategy);
195 static dev_type_size(rdpsize);
196
197 const struct bdevsw rd_bdevsw = {
198 .d_open = rdopen,
199 .d_close = rdclose,
200 .d_strategy = rdstrategy,
201 .d_ioctl = rdioctl,
202 .d_dump = nulldump,
203 .d_psize = rdpsize,
204 .d_discard = nodiscard,
205 .d_flag = D_DISK
206 };
207
208 const struct cdevsw rd_cdevsw = {
209 .d_open = rdopen,
210 .d_close = rdclose,
211 .d_read = rdread,
212 .d_write = rdwrite,
213 .d_ioctl = rdioctl,
214 .d_stop = nostop,
215 .d_tty = notty,
216 .d_poll = nopoll,
217 .d_mmap = nommap,
218 .d_kqfilter = nokqfilter,
219 .d_discard = nodiscard,
220 .d_flag = D_DISK
221 };
222
223 /* At least 0.7 uS between register accesses */
224 static int rd_dmasize, inq = 0;
225 static volatile int u;
226 #define WAIT __asm("movl %0,%0;movl %0,%0;movl %0,%0; movl %0,%0" :: "m"(u))
227
228 #define HDC_WREG(x) *(volatile char *)(sc->sc_regs) = (x)
229 #define HDC_RREG *(volatile char *)(sc->sc_regs)
230 #define HDC_WCMD(x) *(volatile char *)(sc->sc_regs + 4) = (x)
231 #define HDC_RSTAT *(volatile char *)(sc->sc_regs + 4)
232
233 static void
234 rdminphys(struct buf *bp)
235 {
236 if (bp->b_bcount > rd_dmasize)
237 bp->b_bcount = rd_dmasize;
238 }
239
240 const struct dkdriver rd_dkdriver = { rdstrategy, rdminphys };
241 /*
242 * new-config's hdcmatch() is similiar to old-config's hdcprobe(),
243 * thus we probe for the existence of the controller and reset it.
244 * NB: we can't initialize the controller yet, since space for hdcsoftc
245 * is not yet allocated. Thus we do this in hdcattach()...
246 */
247 int
248 hdcmatch(device_t parent, cfdata_t cf, void *aux)
249 {
250 struct vsbus_attach_args * const va = aux;
251 volatile char * const hdc_csr = (volatile char *)va->va_addr;
252 int i;
253
254 u = 8; /* !!! - GCC */
255
256 if (vax_boardtype == VAX_BTYP_49 || vax_boardtype == VAX_BTYP_46
257 || vax_boardtype == VAX_BTYP_48 || vax_boardtype == VAX_BTYP_53)
258 return 0;
259
260 hdc_csr[4] = DKC_CMD_RESET; /* reset chip */
261 for (i = 0; i < 1000; i++) {
262 DELAY(1000);
263 if (hdc_csr[4] & DKC_ST_DONE)
264 break;
265 }
266 if (i == 100)
267 return 0; /* No response to reset */
268
269 hdc_csr[4] = DKC_CMD_SETREGPTR|UDC_TERM;
270 WAIT;
271 hdc_csr[0] = UDC_TC_CRCPRE|UDC_TC_INTDONE;
272 WAIT;
273 hdc_csr[4] = DKC_CMD_DRDESELECT; /* Should be harmless */
274 DELAY(1000);
275 return (1);
276 }
277
278 int
279 hdcprint(void *aux, const char *name)
280 {
281 struct hdc_attach_args * const ha = aux;
282
283 if (name)
284 aprint_normal ("RD?? at %s drive %d", name, ha->ha_drive);
285 return UNCONF;
286 }
287
288 /*
289 * hdc_attach() probes for all possible devices
290 */
291 void
292 hdcattach(device_t parent, device_t self, void *aux)
293 {
294 struct vsbus_attach_args * const va = aux;
295 struct hdcsoftc * const sc = device_private(self);
296 struct hdc_attach_args ha;
297 int status, i;
298
299 aprint_normal("\n");
300
301 sc->sc_dev = self;
302
303 /*
304 * Get interrupt vector, enable instrumentation.
305 */
306 scb_vecalloc(va->va_cvec, hdcintr, sc, SCB_ISTACK, &sc->sc_intrcnt);
307 evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
308 device_xname(self), "intr");
309
310 sc->sc_regs = vax_map_physmem(va->va_paddr, 1);
311 sc->sc_dmabase = (void *)va->va_dmaaddr;
312 sc->sc_dmasize = va->va_dmasize;
313 sc->sc_intbit = va->va_maskno;
314 rd_dmasize = min(MAXPHYS, sc->sc_dmasize); /* Used in rdminphys */
315
316 sc->sc_vd.vd_go = hdc_qstart;
317 sc->sc_vd.vd_arg = sc;
318 /*
319 * Reset controller.
320 */
321 HDC_WCMD(DKC_CMD_RESET);
322 DELAY(1000);
323 status = HDC_RSTAT;
324 if (status != (DKC_ST_DONE|DKC_TC_SUCCESS)) {
325 aprint_error_dev(self, "RESET failed, status 0x%x\n", status);
326 return;
327 }
328 bufq_alloc(&sc->sc_q, "disksort", BUFQ_SORT_CYLINDER);
329
330 /*
331 * now probe for all possible hard drives
332 */
333 for (i = 0; i < 4; i++) {
334 if (i == 2) /* Floppy, needs special handling */
335 continue;
336 HDC_WCMD(DKC_CMD_DRSELECT | i);
337 DELAY(1000);
338 status = HDC_RSTAT;
339 ha.ha_drive = i;
340 if ((status & DKC_ST_TERMCOD) == DKC_TC_SUCCESS)
341 config_found(self, (void *)&ha, hdcprint);
342 }
343 }
344
345 /*
346 * rdmatch() probes for the existence of a RD-type disk/floppy
347 */
348 int
349 rdmatch(device_t parent, cfdata_t cf, void *aux)
350 {
351 struct hdc_attach_args * const ha = aux;
352
353 if (cf->cf_loc[HDCCF_DRIVE] != HDCCF_DRIVE_DEFAULT &&
354 cf->cf_loc[HDCCF_DRIVE] != ha->ha_drive)
355 return 0;
356
357 if (ha->ha_drive == 2) /* Always floppy, not supported */
358 return 0;
359
360 return 1;
361 }
362
363 void
364 rdattach(device_t parent, device_t self, void *aux)
365 {
366 struct hdcsoftc * const sc = device_private(parent);
367 struct rdsoftc * const rd = device_private(self);
368 struct hdc_attach_args * const ha = aux;
369 struct disklabel *dl;
370 const char *msg;
371
372 rd->sc_dev = self;
373 rd->sc_drive = ha->ha_drive;
374 rd->sc_hdc = sc;
375 /*
376 * Initialize and attach the disk structure.
377 */
378 disk_init(&rd->sc_disk, device_xname(rd->sc_dev), &rd_dkdriver);
379 disk_attach(&rd->sc_disk);
380
381 /*
382 * if it's not a floppy then evaluate the on-disk geometry.
383 * if necessary correct the label...
384 */
385 rd_readgeom(sc, rd);
386 disk_printtype(rd->sc_drive, rd->sc_xbn.media_id);
387 dl = rd->sc_disk.dk_label;
388 rdmakelabel(dl, &rd->sc_xbn);
389 msg = readdisklabel(MAKEDISKDEV(cdevsw_lookup_major(&rd_cdevsw),
390 device_unit(rd->sc_dev), RAW_PART),
391 rdstrategy, dl, NULL);
392 if (msg)
393 aprint_normal_dev(self, "%s: size %u sectors",
394 msg, dl->d_secperunit);
395 else
396 aprint_normal_dev(self, "size %u sectors\n", dl->d_secperunit);
397 #ifdef RDDEBUG
398 hdc_printgeom(&rd->sc_xbn);
399 #endif
400 }
401
402 void
403 hdcintr(void *arg)
404 {
405 struct hdcsoftc * const sc = arg;
406 struct buf *bp;
407
408 sc->sc_status = HDC_RSTAT;
409 if (sc->sc_active == 0)
410 return; /* Complain? */
411
412 if ((sc->sc_status & (DKC_ST_INTPEND|DKC_ST_DONE)) !=
413 (DKC_ST_INTPEND|DKC_ST_DONE))
414 return; /* Why spurious ints sometimes??? */
415
416 bp = sc->sc_active;
417 sc->sc_active = 0;
418 if ((sc->sc_status & DKC_ST_TERMCOD) != DKC_TC_SUCCESS) {
419 int i;
420 u_char *g = (u_char *)&sc->sc_sreg;
421
422 if (sc->sc_retries++ < 3) { /* Allow 3 retries */
423 hdcstart(sc, bp);
424 return;
425 }
426 aprint_error_dev(sc->sc_dev, "failed, status 0x%x\n",
427 sc->sc_status);
428 hdc_readregs(sc);
429 for (i = 0; i < 10; i++)
430 aprint_error("%i: %x\n", i, g[i]);
431 bp->b_error = ENXIO;
432 bp->b_resid = bp->b_bcount;
433 biodone(bp);
434 vsbus_dma_intr();
435 return;
436 }
437
438 if (bp->b_flags & B_READ) {
439 vsbus_copytoproc(bp->b_proc, sc->sc_dmabase, sc->sc_bufaddr,
440 sc->sc_xfer);
441 }
442 sc->sc_diskblk += (sc->sc_xfer/DEV_BSIZE);
443 sc->sc_bytecnt -= sc->sc_xfer;
444 sc->sc_bufaddr = (char *)sc->sc_bufaddr + sc->sc_xfer;
445
446 if (sc->sc_bytecnt == 0) { /* Finished transfer */
447 biodone(bp);
448 vsbus_dma_intr();
449 } else
450 hdcstart(sc, bp);
451 }
452
453 /*
454 *
455 */
456 void
457 rdstrategy(struct buf *bp)
458 {
459 struct rdsoftc *rd;
460 struct hdcsoftc *sc;
461 struct disklabel *lp;
462 int s;
463
464 if ((rd = device_lookup_private(&rd_cd, DISKUNIT(bp->b_dev))) == NULL) {
465 bp->b_error = ENXIO;
466 goto done;
467 }
468 sc = rd->sc_hdc;
469
470 lp = rd->sc_disk.dk_label;
471 if ((bounds_check_with_label(&rd->sc_disk, bp, 1)) <= 0)
472 goto done;
473
474 if (bp->b_bcount == 0)
475 goto done;
476
477 bp->b_rawblkno =
478 bp->b_blkno + lp->d_partitions[DISKPART(bp->b_dev)].p_offset;
479 bp->b_cylinder = bp->b_rawblkno / lp->d_secpercyl;
480
481 s = splbio();
482 bufq_put(sc->sc_q, bp);
483 if (inq == 0) {
484 inq = 1;
485 vsbus_dma_start(&sc->sc_vd);
486 }
487 splx(s);
488 return;
489
490 done: biodone(bp);
491 }
492
493 void
494 hdc_qstart(void *arg)
495 {
496 struct hdcsoftc * const sc = arg;
497
498 inq = 0;
499
500 hdcstart(sc, 0);
501 if (bufq_peek(sc->sc_q)) {
502 vsbus_dma_start(&sc->sc_vd); /* More to go */
503 inq = 1;
504 }
505 }
506
507 void
508 hdcstart(struct hdcsoftc *sc, struct buf *ob)
509 {
510 struct hdc9224_UDCreg * const p = &sc->sc_creg;
511 struct disklabel *lp;
512 struct rdsoftc *rd;
513 struct buf *bp;
514 int cn, sn, tn, bn, blks;
515
516 if (sc->sc_active)
517 return; /* Already doing something */
518
519 if (ob == 0) {
520 bp = bufq_get(sc->sc_q);
521 if (bp == NULL)
522 return; /* Nothing to do */
523 sc->sc_bufaddr = bp->b_data;
524 sc->sc_diskblk = bp->b_rawblkno;
525 sc->sc_bytecnt = bp->b_bcount;
526 sc->sc_retries = 0;
527 bp->b_resid = 0;
528 } else
529 bp = ob;
530
531 rd = device_lookup_private(&rd_cd, DISKUNIT(bp->b_dev));
532 hdc_rdselect(sc, rd->sc_drive);
533 sc->sc_active = bp;
534
535 bn = sc->sc_diskblk;
536 lp = rd->sc_disk.dk_label;
537 if (bn) {
538 cn = bn / lp->d_secpercyl;
539 sn = bn % lp->d_secpercyl;
540 tn = sn / lp->d_nsectors;
541 sn = sn % lp->d_nsectors;
542 } else
543 cn = sn = tn = 0;
544
545 cn++; /* first cylinder is reserved */
546
547 memset(p, 0, sizeof(struct hdc9224_UDCreg));
548
549 /*
550 * Tricky thing: the controller do itself only increase the sector
551 * number, not the track or cylinder number. Therefore the driver
552 * is not allowed to have transfers that crosses track boundaries.
553 */
554 blks = sc->sc_bytecnt/DEV_BSIZE;
555 if ((sn + blks) > lp->d_nsectors)
556 blks = lp->d_nsectors - sn;
557
558 p->udc_dsect = sn;
559 p->udc_dcyl = cn & 0xff;
560 p->udc_dhead = ((cn >> 4) & 0x70) | tn;
561 p->udc_scnt = blks;
562
563 p->udc_rtcnt = UDC_RC_RTRYCNT;
564 p->udc_mode = UDC_MD_HDD;
565 p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWRFLT;
566 hdc_writeregs(sc);
567
568 /* Count up vars */
569 sc->sc_xfer = blks * DEV_BSIZE;
570
571 (void)HDC_RSTAT; /* Avoid pending interrupts */
572 WAIT;
573 vsbus_clrintr(sc->sc_intbit); /* Clear pending int's */
574
575 if (bp->b_flags & B_READ) {
576 HDC_WCMD(DKC_CMD_READ_HDD);
577 } else {
578 vsbus_copyfromproc(bp->b_proc, sc->sc_bufaddr, sc->sc_dmabase,
579 sc->sc_xfer);
580 HDC_WCMD(DKC_CMD_WRITE_HDD);
581 }
582 }
583
584 void
585 rd_readgeom(struct hdcsoftc *sc, struct rdsoftc *rd)
586 {
587 struct hdc9224_UDCreg * const p = &sc->sc_creg;
588
589 hdc_rdselect(sc, rd->sc_drive); /* select drive right now */
590
591 memset(p, 0, sizeof(*p));
592
593 p->udc_scnt = 1;
594 p->udc_rtcnt = UDC_RC_RTRYCNT;
595 p->udc_mode = UDC_MD_HDD;
596 p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWPROT;
597 hdc_writeregs(sc);
598 sc->sc_status = 0;
599 HDC_WCMD(DKC_CMD_READ_HDD|2);
600 while ((sc->sc_status & DKC_ST_INTPEND) == 0)
601 ;
602 memcpy(&rd->sc_xbn, sc->sc_dmabase, sizeof(struct rdgeom));
603 }
604
605 #ifdef RDDEBUG
606 /*
607 * display the contents of the on-disk geometry structure
608 */
609 void
610 hdc_printgeom(struct rdgeom *p)
611 {
612 printf ("**DiskData** XBNs: %ld, DBNs: %ld, LBNs: %ld, RBNs: %ld\n",
613 p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count);
614 printf ("sec/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n",
615 p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced);
616 printf ("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n",
617 p->seek_rate, p->crc_eec?"EEC":"CRC", p->rct, p->rct_ncopies);
618 printf ("media-ID: %lx, interleave: %d, headskew: %d, cylskew: %d\n",
619 p->media_id, p->interleave, p->headskew, p->cylskew);
620 printf ("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n",
621 p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size,
622 p->sync_value);
623 }
624 #endif
625
626 /*
627 * Return the size of a partition, if known, or -1 if not.
628 */
629 int
630 rdpsize(dev_t dev)
631 {
632 struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
633 const int part = DISKPART(dev);
634
635 if (rd == NULL || part >= rd->sc_disk.dk_label->d_npartitions)
636 return -1;
637
638 return rd->sc_disk.dk_label->d_partitions[part].p_size *
639 (rd->sc_disk.dk_label->d_secsize / DEV_BSIZE);
640 }
641
642 /*
643 *
644 */
645 int
646 rdopen(dev_t dev, int flag, int fmt, struct lwp *l)
647 {
648 struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
649 const int part = DISKPART(dev);
650
651 if (rd == NULL || part >= rd->sc_disk.dk_label->d_npartitions)
652 return ENXIO;
653
654 switch (fmt) {
655 case S_IFCHR:
656 rd->sc_disk.dk_copenmask |= (1 << part);
657 break;
658 case S_IFBLK:
659 rd->sc_disk.dk_bopenmask |= (1 << part);
660 break;
661 }
662 rd->sc_disk.dk_openmask =
663 rd->sc_disk.dk_copenmask | rd->sc_disk.dk_bopenmask;
664
665 return 0;
666 }
667
668 /*
669 *
670 */
671 int
672 rdclose(dev_t dev, int flag, int fmt, struct lwp *l)
673 {
674 struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
675 const int part = DISKPART(dev);
676
677 switch (fmt) {
678 case S_IFCHR:
679 rd->sc_disk.dk_copenmask &= ~(1 << part);
680 break;
681 case S_IFBLK:
682 rd->sc_disk.dk_bopenmask &= ~(1 << part);
683 break;
684 }
685 rd->sc_disk.dk_openmask =
686 rd->sc_disk.dk_copenmask | rd->sc_disk.dk_bopenmask;
687
688 return (0);
689 }
690
691 /*
692 *
693 */
694 int
695 rdioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
696 {
697 struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
698 struct disklabel * const lp = rd->sc_disk.dk_label;
699 int error = 0;
700
701 switch (cmd) {
702 case DIOCGDINFO:
703 *(struct disklabel *)addr = *lp;
704 break;
705
706 case DIOCGPART:
707 ((struct partinfo *)addr)->disklab = lp;
708 ((struct partinfo *)addr)->part =
709 &lp->d_partitions[DISKPART(dev)];
710 break;
711
712 case DIOCWDINFO:
713 case DIOCSDINFO:
714 if ((flag & FWRITE) == 0)
715 return EBADF;
716 error = (cmd == DIOCSDINFO ?
717 setdisklabel(lp, (struct disklabel *)addr, 0, 0) :
718 writedisklabel(dev, rdstrategy, lp, 0));
719 break;
720
721 case DIOCGDEFLABEL:
722 memset(lp, 0, sizeof(*lp));
723 rdmakelabel(lp, &rd->sc_xbn);
724 break;
725
726 case DIOCWLABEL:
727 if ((flag & FWRITE) == 0)
728 error = EBADF;
729 break;
730
731 default:
732 error = ENOTTY;
733 }
734 return error;
735 }
736
737 /*
738 *
739 */
740 int
741 rdread(dev_t dev, struct uio *uio, int flag)
742 {
743 return (physio (rdstrategy, NULL, dev, B_READ, minphys, uio));
744 }
745
746 /*
747 *
748 */
749 int
750 rdwrite(dev_t dev, struct uio *uio, int flag)
751 {
752 return (physio (rdstrategy, NULL, dev, B_WRITE, minphys, uio));
753 }
754
755 /*
756 * we have to wait 0.7 usec between two accesses to any of the
757 * dkc-registers, on a VS2000 with 1 MIPS, this is roughly one
758 * instruction. Thus the loop-overhead will be enough...
759 */
760 static void
761 hdc_readregs(struct hdcsoftc *sc)
762 {
763 int i;
764 char *p;
765
766 HDC_WCMD(DKC_CMD_SETREGPTR);
767 WAIT;
768 p = (void*)&sc->sc_sreg;
769 for (i=0; i<10; i++) {
770 *p++ = HDC_RREG; /* dkc_reg auto-increments */
771 WAIT;
772 }
773 }
774
775 static void
776 hdc_writeregs(struct hdcsoftc *sc)
777 {
778 int i;
779 char *p;
780
781 HDC_WCMD(DKC_CMD_SETREGPTR);
782 p = (void*)&sc->sc_creg;
783 for (i=0; i<10; i++) {
784 HDC_WREG(*p++); /* dkc_reg auto-increments */
785 WAIT;
786 }
787 }
788
789 /*
790 * hdc_command() issues a command and polls the intreq-register
791 * to find when command has completed
792 */
793 int
794 hdc_command(struct hdcsoftc *sc, int cmd)
795 {
796 hdc_writeregs(sc); /* write the prepared registers */
797 HDC_WCMD(cmd);
798 WAIT;
799 return (0);
800 }
801
802 int
803 hdc_rdselect(struct hdcsoftc *sc, int unit)
804 {
805 struct hdc9224_UDCreg * const p = &sc->sc_creg;
806 int error;
807
808 /*
809 * bring "creg" in some known-to-work state and
810 * select the drive with the DRIVE SELECT command.
811 */
812 memset(p, 0, sizeof(*p));
813
814 p->udc_rtcnt = UDC_RC_HDD_READ;
815 p->udc_mode = UDC_MD_HDD;
816 p->udc_term = UDC_TC_HDD;
817
818 error = hdc_command(sc, DKC_CMD_DRSEL_HDD | unit);
819
820 return error;
821 }
822
823 void
824 rdmakelabel(struct disklabel *dl, struct rdgeom *g)
825 {
826 int n, p = 0;
827
828 dl->d_bbsize = BBSIZE;
829 dl->d_sbsize = SBLOCKSIZE;
830 dl->d_typename[p++] = MSCP_MID_CHAR(2, g->media_id);
831 dl->d_typename[p++] = MSCP_MID_CHAR(1, g->media_id);
832 if (MSCP_MID_ECH(0, g->media_id))
833 dl->d_typename[p++] = MSCP_MID_CHAR(0, g->media_id);
834 n = MSCP_MID_NUM(g->media_id);
835 if (n > 99) {
836 dl->d_typename[p++] = '1';
837 n -= 100;
838 }
839 if (n > 9) {
840 dl->d_typename[p++] = (n / 10) + '0';
841 n %= 10;
842 }
843 dl->d_typename[p++] = n + '0';
844 dl->d_typename[p] = 0;
845 dl->d_type = DTYPE_MSCP; /* XXX - what to use here??? */
846 dl->d_rpm = 3600;
847 dl->d_secsize = DEV_BSIZE;
848
849 dl->d_secperunit = g->lbn_count;
850 dl->d_nsectors = g->nspt;
851 dl->d_ntracks = g->ntracks;
852 dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks;
853 dl->d_ncylinders = dl->d_secperunit / dl->d_secpercyl;
854
855 dl->d_npartitions = MAXPARTITIONS;
856 dl->d_partitions[0].p_size = dl->d_partitions[2].p_size =
857 dl->d_secperunit;
858 dl->d_partitions[0].p_offset = dl->d_partitions[2].p_offset = 0;
859 dl->d_interleave = dl->d_headswitch = 1;
860 dl->d_magic = dl->d_magic2 = DISKMAGIC;
861 dl->d_checksum = dkcksum(dl);
862 }
863