![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoestand|
Return to hd.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoestand |
1.1 root 1: /*
2: * Copyright (c) 1988 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Harris Corp.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that the above copyright notice and this paragraph are
10: * duplicated in all such forms and that any documentation,
11: * advertising materials, and other materials related to such
12: * distribution and use acknowledge that the software was developed
13: * by the University of California, Berkeley. The name of the
14: * University may not be used to endorse or promote products derived
15: * from this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)hd.c 7.6 (Berkeley) 5/1/89
21: */
22:
23: #include "param.h"
24: #include "inode.h"
25: #include "fs.h"
26: #include "buf.h"
27: #include "ioctl.h"
28: #include "disklabel.h"
29: #include "saio.h"
30: #include "../tahoe/mtpr.h"
31: #include "../tahoevba/hdreg.h"
32:
33: static struct registers *hdc_regs[HDC_MAXCTLR][HDC_MAXBUS];
34: static struct disklabel dklabel[HDC_MAXDRIVE][HDC_MAXCTLR][HDC_MAXBUS];
35:
36: hdopen(io)
37: register struct iob *io;
38: {
39: register struct disklabel *dlp;
40: struct status status;
41: struct module_id id;
42: struct registers *hr;
43: struct mcb mcb;
44: long junk, dlbuf[DEV_BSIZE/sizeof(long)];
45:
46: /* validate the device specification */
47: if ((u_int)io->i_bus >= HDC_MAXBUS)
48: return(EADAPT);
49: if ((u_int)io->i_ctlr >= HDC_MAXCTLR)
50: return(ECTLR);
51: if ((u_int)io->i_unit >= HDC_MAXDRIVE)
52: return(EUNIT);
53: if ((u_int)io->i_part > 7)
54: return(EPART);
55:
56: /* init drive structure. */
57: hdc_regs[io->i_ctlr][io->i_bus] = hr = (struct registers *)(io->i_bus ?
58: 0x80000000 | io->i_ctlr << 24 | HDC_MID << 16 :
59: 0xC0000000 | io->i_ctlr << 24 | HDC_MID << 16);
60:
61: /* insure that this is an hdc, then reset the hdc. */
62: if (wbadaddr(&hr->module_id, 4, &junk)) {
63: printf("hd%d: %x: invalid csr\n", io->i_ctlr, (u_int)hr);
64: return(ENXIO);
65: }
66: hr->soft_reset = 0;
67: DELAY(1000000);
68:
69: /*
70: * read in the hdc module id word. The controller is bad if the
71: * hdc's writeable control store is not loaded or if the hdc failed
72: * the functional integrity test for any reason.
73: */
74: hr->module_id = (u_long)&id;
75: DELAY(10000);
76: mtpr(PADC, 0);
77: if (id.module_id != (u_char)HDC_MID) {
78: printf("hdc: controller bad module id: id = %x\n",
79: id.module_id);
80: return(ENXIO);
81: }
82: if (id.code_rev == (u_char)0xff) {
83: printf("hdc: controller micro-code is not loaded.\n");
84: return(ENXIO);
85: }
86: if (id.fit != (u_char)0xff) {
87: printf("hdc: controller FIT test failed: error= %x\n",
88: id.fit);
89: return(ENXIO);
90: }
91:
92: /* read the drive status */
93: mcb.command = HCMD_STATUS;
94: mcb.drive = io->i_unit;
95: mcb.cyl = 0;
96: mcb.head = 0;
97: mcb.sector = 0;
98: mcb.chain[0].wcount = (long)(sizeof(struct status) / sizeof(long));
99: mcb.chain[0].memadr = (long)&status;
100: if (hdimcb(&mcb, io))
101: return(EIO);
102:
103: /*
104: * Report drive down if anything in the drive status is bad.
105: * If fault condition, reading will try to clear the fault.
106: */
107: if (status.drs&DRS_FAULT)
108: printf("hdc: clearing drive fault.\n");
109: if (!(status.drs&DRS_ONLINE)) {
110: printf("hdc: drive is not online.\n");
111: return(EIO);
112: }
113:
114: /* read in the pack label */
115: mcb.command = HCMD_READ;
116: mcb.drive = io->i_unit;
117: mcb.cyl = 0;
118: mcb.head = 0;
119: mcb.sector = LABELSECTOR;
120: mcb.chain[0].wcount = (long)(DEV_BSIZE / sizeof(long));
121: mcb.chain[0].memadr = (long)dlbuf;
122: if (hdimcb(&mcb, io))
123: return(ERDLAB);
124: dlp = (struct disklabel *)(dlbuf + (LABELOFFSET / sizeof(long)));
125: if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC)
126: #ifdef COMPAT_42
127: {
128: int error;
129:
130: if (error = hdmaptype(io, dlp, &status, io->i_unit))
131: return(error);
132: }
133: #else
134: return(EUNLAB);
135: #endif
136: dklabel[io->i_unit][io->i_ctlr][io->i_bus] = *dlp;
137: if (io->i_part >= dlp->d_npartitions ||
138: dlp->d_partitions[io->i_part].p_size == 0)
139: return(EPART);
140: io->i_boff = (dlp->d_partitions[io->i_part].p_offset *
141: dlp->d_secsize) / DEV_BSIZE;
142: return(0);
143: }
144:
145: hdstrategy(io, cmd)
146: register struct iob *io;
147: int cmd;
148: {
149: register struct disklabel *dlp;
150: struct mcb mcb;
151: long sector;
152:
153: if (io->i_cc&3) {
154: printf("hd%d: i/o not a longword multiple.\n", io->i_unit);
155: return(0);
156: }
157: dlp = &dklabel[io->i_unit][io->i_ctlr][io->i_bus];
158: sector = io->i_bn * HDC_SPB;
159: mcb.command = (cmd == READ) ? HCMD_READ : HCMD_WRITE;
160: mcb.drive = io->i_unit;
161: mcb.cyl = sector / dlp->d_secpercyl;
162: mcb.head = (sector / dlp->d_nsectors) % dlp->d_ntracks;
163: mcb.sector = sector % dlp->d_nsectors;
164: mcb.chain[0].wcount = io->i_cc / sizeof(long);
165: mcb.chain[0].memadr = (u_long)io->i_ma;
166: return(hdimcb(&mcb, io) ? -1 : io->i_cc);
167: }
168:
169: hdimcb(mcb, io)
170: register struct mcb *mcb;
171: register struct iob *io;
172: {
173: struct master_mcb master;
174: int timeout;
175:
176: /* fill in mcb */
177: mcb->interrupt = 0;
178: mcb->forw_phaddr = 0;
179:
180: /* fill in master mcb */
181: master.mcw = MCL_IMMEDIATE;
182: master.forw_phaddr = (u_long)mcb;
183: master.mcs = 0;
184:
185: hdc_regs[io->i_ctlr][io->i_bus]->master_mcb = (u_long)&master;
186: for (timeout = 15000; timeout; --timeout) {
187: DELAY(1000);
188: mtpr(PADC, 0);
189: if (master.mcs&MCS_FATALERROR) {
190: printf("hdc%d: fatal error.\n", io->i_ctlr);
191: return(1);
192: }
193: if (master.mcs&MCS_DONE)
194: return(0);
195: }
196: printf("hdc%d: timed out.\n", io->i_ctlr);
197: return(1);
198: }
199:
200: #ifdef COMPAT_42
201: hdmaptype(io, dlp, status, unit)
202: register struct iob *io;
203: register struct disklabel *dlp;
204: struct status *status;
205: int unit;
206: {
207: geometry_sector geometry;
208: geometry_block *geo;
209: struct mcb mcb;
210: int cnt;
211: char *strcpy();
212:
213: printf("hd%d: unlabeled\n", unit);
214: /*
215: * Read the geometry block (at head = 0 sector = 0 of the drive
216: * definition cylinder), validate it (must have the correct version
217: * number, header, and checksum).
218: */
219: mcb.command = HCMD_READ;
220: mcb.drive = unit;
221: mcb.cyl = status->def_cyl;
222: mcb.head = 0;
223: mcb.sector = 0;
224: mcb.chain[0].wcount = (long)(sizeof(geometry_sector) / sizeof(long));
225: mcb.chain[0].memadr = (long)&geometry;
226: if (hdimcb(&mcb, io)) {
227: printf("hd%d: can't read default geometry.\n", io->i_unit);
228: return(ERDLAB);
229: }
230: geo = &geometry.geometry_block;
231: if (geo->version > 64000 || geo->version < 0) {
232: printf("hd%d: bad default geometry version#.\n", io->i_unit);
233: return(ENXIO);
234: }
235: if (strcmp(&geo->id[0], GB_ID)) {
236: printf("hd%d: bad default geometry header.\n", io->i_unit);
237: return(ENXIO);
238: }
239: GB_CHECKSUM(geo, cnt);
240: if (geometry.checksum != cnt) {
241: printf("hd%d: bad default geometry checksum.\n", io->i_unit);
242: return(ENXIO);
243: }
244: for (cnt = 0; cnt < GB_MAXPART; cnt++) {
245: dlp->d_partitions[cnt].p_offset = geo->partition[cnt].start;
246: dlp->d_partitions[cnt].p_size = geo->partition[cnt].length;
247: }
248: #ifdef RAW_SIZE
249: dlp->d_secsize = status->bytes_per_sec;
250: #else
251: dlp->d_secsize = 512;
252: #endif
253: dlp->d_nsectors = status->max_sector + 1;
254: dlp->d_ncylinders = status->max_cyl + 1;
255: dlp->d_ntracks = status->max_head + 1;
256: dlp->d_secpercyl = dlp->d_ntracks * dlp->d_nsectors;
257: dlp->d_npartitions = GB_MAXPART;
258: dlp->d_rpm = status->rpm;
259: (void)strcpy(dlp->d_typename, "hdc (prom)");
260: return(0);
261: }
262: #endif /* COMPAT_42 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.