File:
[DragonFly] /
src /
sys /
dev /
raid /
dpt /
dpt_control.c
Revision
1.7:
download - view:
text,
annotated -
select for diffs
Wed May 19 22:52:47 2004 UTC (9 years ago) by
dillon
Branches:
MAIN
CVS tags:
HEAD,
DragonFly_Stable,
DragonFly_Snap29Sep2004,
DragonFly_Snap13Sep2004,
DragonFly_RELEASE_1_2_Slip,
DragonFly_RELEASE_1_2,
DragonFly_1_0_REL,
DragonFly_1_0_RC1,
DragonFly_1_0A_REL
Device layer rollup commit.
* cdevsw_add() is now required. cdevsw_add() and cdevsw_remove() may specify
a mask/match indicating the range of supported minor numbers. Multiple
cdevsw_add()'s using the same major number, but distinctly different
ranges, may be issued. All devices that failed to call cdevsw_add() before
now do.
* cdevsw_remove() now automatically marks all devices within its supported
range as being destroyed.
* vnode->v_rdev is no longer resolved when the vnode is created. Instead,
only v_udev (a newly added field) is resolved. v_rdev is resolved when
the vnode is opened and cleared on the last close.
* A great deal of code was making rather dubious assumptions with regards
to the validity of devices associated with vnodes, primarily due to
the persistence of a device structure due to being indexed by (major, minor)
instead of by (cdevsw, major, minor). In particular, if you run a program
which connects to a USB device and then you pull the USB device and plug
it back in, the vnode subsystem will continue to believe that the device
is open when, in fact, it isn't (because it was destroyed and recreated).
In particular, note that all the VFS mount procedures now check devices
via v_udev instead of v_rdev prior to calling VOP_OPEN(), since v_rdev
is NULL prior to the first open.
* The disk layer's device interaction has been rewritten. The disk layer
(i.e. the slice and disklabel management layer) no longer overloads
its data onto the device structure representing the underlying physical
disk. Instead, the disk layer uses the new cdevsw_add() functionality
to register its own cdevsw using the underlying device's major number,
and simply does NOT register the underlying device's cdevsw. No
confusion is created because the device hash is now based on
(cdevsw,major,minor) rather then (major,minor).
NOTE: This also means that underlying raw disk devices may use the entire
device minor number instead of having to reserve the bits used by the disk
layer, and also means that can we (theoretically) stack a fully
disklabel-supported 'disk' on top of any block device.
* The new reference counting scheme prevents this by associating a device
with a cdevsw and disconnecting the device from its cdevsw when the cdevsw
is removed. Additionally, all udev2dev() lookups run through the cdevsw
mask/match and only successfully find devices still associated with an
active cdevsw.
* Major work on MFS: MFS no longer shortcuts vnode and device creation. It
now creates a real vnode and a real device and implements real open and
close VOPs. Additionally, due to the disk layer changes, MFS is no longer
limited to 255 mounts. The new limit is 16 million. Since MFS creates a
real device node, mount_mfs will now create a real /dev/mfs<PID> device
that can be read from userland (e.g. so you can dump an MFS filesystem).
* BUF AND DEVICE STRATEGY changes. The struct buf contains a b_dev field.
In order to properly handle stacked devices we now require that the b_dev
field be initialized before the device strategy routine is called. This
required some additional work in various VFS implementations. To enforce
this requirement, biodone() now sets b_dev to NODEV. The new disk layer
will adjust b_dev before forwarding a request to the actual physical
device.
* A bug in the ISO CD boot sequence which resulted in a panic has been fixed.
Testing by: lots of people, but David Rhodus found the most aggregious bugs.
1: /**
2: * Copyright (c) 1997 by Simon Shapiro
3: * All Rights Reserved
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions, and the following disclaimer,
10: * without modification, immediately at the beginning of the file.
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: * 3. The name of the author may not be used to endorse or promote products
15: * derived from this software without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: *
29: */
30:
31: /**
32: * dpt_control.c: Control Functions and /dev entry points for /dev/dpt*
33: *
34: * Caveat Emptor! This is work in progress. The interfaces and
35: * functionality of this code will change (possibly radically) in the
36: * future.
37: */
38:
39: #ident "$FreeBSD: src/sys/dev/dpt/dpt_control.c,v 1.16 1999/09/25 18:23:48 phk Exp $"
40: #ident "$DragonFly: src/sys/dev/raid/dpt/dpt_control.c,v 1.7 2004/05/19 22:52:47 dillon Exp $"
41:
42: #include "opt_dpt.h"
43:
44: #include <i386/include/cputypes.h>
45: #include <sys/param.h>
46: #include <sys/systm.h>
47: #include <sys/malloc.h>
48: #include <sys/kernel.h>
49: #include <sys/buf.h>
50: #include <sys/uio.h>
51: #include <sys/conf.h>
52: #include <vm/vm.h>
53: #include <vm/vm_kern.h>
54: #include <vm/vm_extern.h>
55: #include <vm/pmap.h>
56: #include <scsi/scsiconf.h>
57:
58: #include "dpt.h"
59:
60: #define INLINE __inline
61:
62: extern char osrelease[];
63:
64: enum dpt_message dpt_message;
65: enum dpt_immediate_cmd dpt_immediate_cmd;
66:
67: static dpt_sysinfo_t dpt_sysinfo;
68:
69: /* Entry points and other prototypes */
70: static vm_offset_t dpt_physmap(u_int32_t paddr, vm_size_t size);
71: static void dpt_unphysmap(u_int8_t * vaddr, vm_size_t size);
72:
73: static void dpt_get_sysinfo(void);
74:
75: static int dpt_open(dev_t dev, int flags, int fmt, struct proc * p);
76: static int dpt_close(dev_t dev, int flags, int fmt, struct proc * p);
77: static int dpt_write(dev_t dev, struct uio * uio, int ioflag);
78: static int dpt_read(dev_t dev, struct uio * uio, int ioflag);
79: static int dpt_ioctl(dev_t dev, u_long cmd, caddr_t cmdarg, int flags, struct proc * p);
80:
81:
82: /* This has to be modified as the processor and CPU are not known yet */
83: static dpt_sig_t dpt_sig = {
84: 'd', 'P', 't', 'S', 'i', 'G',
85: SIG_VERSION, PROC_INTEL, PROC_386,
86: FT_HBADRVR, FTF_PROTECTED,
87: OEM_DPT, OS_FREEBSD,
88: CAP_PASS | CAP_OVERLAP | CAP_RAID0 | CAP_RAID1 | CAP_RAID5 | CAP_ASPI,
89: DEV_ALL, ADF_SC4_PCI | ADF_SC3_PCI, 0, 0,
90: DPT_RELEASE, DPT_VERSION, DPT_PATCH,
91: DPT_MONTH, DPT_DAY, DPT_YEAR,
92: "DPT FreeBSD Driver (c) 1997 Simon Shapiro"
93: };
94:
95: #define CDEV_MAJOR DPT_CDEV_MAJOR
96:
97: /* Normally, this is a static structure. But we need it in pci/dpt_pci.c */
98: static struct cdevsw dpt_cdevsw = {
99: /* name */ "dpt",
100: /* maj */ CDEV_MAJOR,
101: /* flags */ 0,
102: /* port */ NULL,
103: /* clone */ NULL,
104:
105: /* open */ dpt_open,
106: /* close */ dpt_close,
107: /* read */ dpt_read,
108: /* write */ dpt_write,
109: /* ioctl */ dpt_ioctl,
110: /* poll */ nopoll,
111: /* mmap */ nommap,
112: /* strategy */ nostrategy,
113: /* dump */ nodump,
114: /* psize */ nopsize
115: };
116:
117: static struct buf *dpt_inbuf[DPT_MAX_ADAPTERS];
118: static char dpt_rw_command[DPT_MAX_ADAPTERS][DPT_RW_CMD_LEN + 1];
119:
120:
121: /*
122: * Given a minor device number,
123: * return the pointer to its softc structure
124: */
125:
126: dpt_softc_t *
127: dpt_minor2softc(int minor_no)
128: {
129: dpt_softc_t *dpt;
130:
131: if (dpt_minor2unit(minor_no & ~SCSI_CONTROL_MASK) == -1)
132: return (NULL);
133:
134: for (dpt = TAILQ_FIRST(&dpt_softc_list);
135: (dpt != NULL) && (dpt->unit != (minor_no & ~SCSI_CONTROL_MASK));
136: dpt = TAILQ_NEXT(dpt, links));
137:
138: return (dpt);
139: }
140:
141: /**
142: * Map a physical address to virtual one.
143: * This is a first cut, experimental thing
144: *
145: * Paddr is the physical address to map
146: * size is the size of the region, in bytes.
147: * Because of alignment problems, we actually round up the size requested to
148: * the next page count.
149: */
150:
151: static vm_offset_t
152: dpt_physmap(u_int32_t req_paddr, vm_size_t req_size)
153: {
154: vm_offset_t va;
155: int ndx;
156: vm_size_t size;
157: u_int32_t paddr;
158: u_int32_t offset;
159:
160:
161:
162: size = (req_size / PAGE_SIZE + 1) * PAGE_SIZE;
163: paddr = req_paddr & 0xfffff000;
164: offset = req_paddr - paddr;
165:
166: va = kmem_alloc_pageable(kernel_map, size);
167: if (va == (vm_offset_t) 0)
168: return (va);
169:
170: for (ndx = 0; ndx < size; ndx += PAGE_SIZE) {
171: pmap_kenter(va + ndx, paddr + ndx);
172: invltlb();
173: }
174:
175: return (va + offset);
176: }
177:
178:
179: /*
180: * Release virtual space allocated by physmap We ASSUME that the correct
181: * start address and the correct LENGTH are given.
182: *
183: * Disaster will follow if these assumptions are false!
184: */
185:
186: static void
187: dpt_unphysmap(u_int8_t * vaddr, vm_size_t size)
188: {
189: int ndx;
190:
191: for (ndx = 0; ndx < size; ndx += PAGE_SIZE) {
192: pmap_kremove((vm_offset_t) vaddr + ndx);
193: }
194:
195: kmem_free(kernel_map, (vm_offset_t) vaddr, size);
196: }
197:
198: /**
199: * Collect interesting system information
200: * The following is one of the worst hacks I have ever allowed my
201: * name to be associated with.
202: * There MUST be a system structure that provides this data.
203: */
204:
205: static void
206: dpt_get_sysinfo(void)
207: {
208: int i;
209: int j;
210: int ospl;
211: char *addr;
212:
213: bzero(&dpt_sysinfo, sizeof(dpt_sysinfo_t));
214:
215: /**
216: * This is really silly, but we better run this in splhigh as we
217: * have no clue what we bump into.
218: * Let's hope anyone else who does this sort of things protects them
219: * with splhigh too.
220: */
221: ospl = splhigh();
222:
223: switch (cpu_class) {
224: case CPUCLASS_386:
225: dpt_sig.Processor = dpt_sysinfo.processorType = PROC_386;
226: break;
227: case CPUCLASS_486:
228: dpt_sig.Processor = dpt_sysinfo.processorType = PROC_486;
229: break;
230: case CPUCLASS_586:
231: dpt_sig.Processor = dpt_sysinfo.processorType = PROC_PENTIUM;
232: break;
233: case CPUCLASS_686:
234: dpt_sig.Processor = dpt_sysinfo.processorType = PROC_P6;
235: break;
236: default:
237: dpt_sig.Processor = dpt_sysinfo.flags &= ~SI_ProcessorValid;
238: break;
239: }
240:
241: /* Get The First Drive Type From CMOS */
242: outb(0x70, 0x12);
243: i = inb(0x71);
244: j = i >> 4;
245:
246: if (i == 0x0f) {
247: outb(0x70, 0x19);
248: j = inb(0x71);
249: }
250: dpt_sysinfo.drive0CMOS = j;
251:
252: /* Get The Second Drive Type From CMOS */
253: j = i & 0x0f;
254: if (i == 0x0f) {
255: outb(0x70, 0x1a);
256: j = inb(0x71);
257: }
258: dpt_sysinfo.drive1CMOS = j;
259:
260: /* Get The Number Of Drives From The Bios Data Area */
261: if ((addr = (char *) dpt_physmap(0x0475, 1024)) == NULL) {
262: printf("DPT: Cannot map BIOS address 0x0475. No sysinfo... :-(\n");
263: return;
264: }
265: dpt_sysinfo.numDrives = *addr;
266: dpt_unphysmap(addr, 1024);
267:
268: /* Get the processor fields from the SIG structure, and set the flags */
269: dpt_sysinfo.processorFamily = dpt_sig.ProcessorFamily;
270: dpt_sysinfo.flags = SI_CMOS_Valid | SI_NumDrivesValid;
271:
272: /* Go out and look for SmartROM */
273: for (i = 0; i < 3; ++i) {
274: switch (i) {
275: case 0:
276: addr = (char *) dpt_physmap(0xC8000, 1024);
277: case 1:
278: addr = (char *) dpt_physmap(0xD8000, 1024);
279: default:
280: addr = (char *) dpt_physmap(0xDC000, 1024);
281: }
282:
283: if (addr == NULL)
284: continue;
285:
286: if (*((u_int16_t *) addr) == 0xaa55) {
287: if ((*((u_int32_t *) (addr + 6)) == 0x00202053)
288: && (*((u_int32_t *) (addr + 10)) == 0x00545044)) {
289: break;
290: }
291: }
292: dpt_unphysmap(addr, 1024);
293: addr = NULL;
294: }
295:
296: /**
297: * If i < 3, we founday it so set up a pointer to the starting
298: * version digit by searching for it.
299: */
300: if (addr != NULL) {
301: addr += 0x15;
302: for (i = 0; i < 64; ++i)
303: if ((addr[i] == ' ') && (addr[i + 1] == 'v'))
304: break;
305: if (i < 64) {
306: addr += (i + 4);
307: } else {
308: dpt_unphysmap(addr, 1024);
309: addr = NULL;
310: }
311: }
312: /* If all is well, set up the SmartROM version fields */
313: if (addr != NULL) {
314: dpt_sysinfo.smartROMMajorVersion = *addr - '0'; /* Assumes ASCII */
315: dpt_sysinfo.smartROMMinorVersion = *(addr + 2);
316: dpt_sysinfo.smartROMRevision = *(addr + 3);
317: dpt_sysinfo.flags |= SI_SmartROMverValid;
318: } else {
319: dpt_sysinfo.flags |= SI_NO_SmartROM;
320: }
321:
322: /* Get the conventional memory size from CMOS */
323: outb(0x70, 0x16);
324: j = inb(0x71);
325: j <<= 8;
326: outb(0x70, 0x15);
327: j |= inb(0x71);
328: dpt_sysinfo.conventionalMemSize = j;
329:
330: /**
331: * Get the extended memory found at power on from CMOS
332: */
333: outb(0x70, 0x31);
334: j = inb(0x71);
335: j <<= 8;
336: outb(0x70, 0x30);
337: j |= inb(0x71);
338: dpt_sysinfo.extendedMemSize = j;
339: dpt_sysinfo.flags |= SI_MemorySizeValid;
340:
341: /* If there is 1 or 2 drives found, set up the drive parameters */
342: if (dpt_sysinfo.numDrives > 0) {
343: /* Get the pointer from int 41 for the first drive parameters */
344: addr = (char *) dpt_physmap(0x0104, 1024);
345:
346: if (addr != NULL) {
347: j = *((ushort *) (addr + 2));
348: j *= 16;
349: j += *((ushort *) (addr));
350: dpt_unphysmap(addr, 1024);
351: addr = (char *) dpt_physmap(j, 1024);
352:
353: if (addr != NULL) {
354: dpt_sysinfo.drives[0].cylinders = *((ushort *) addr);
355: dpt_sysinfo.drives[0].heads = *(addr + 2);
356: dpt_sysinfo.drives[0].sectors = *(addr + 14);
357: dpt_unphysmap(addr, 1024);
358: }
359: }
360: if (dpt_sysinfo.numDrives > 1) {
361: /*
362: * Get the pointer from Int 46 for the second drive
363: * parameters
364: */
365: addr = (char *) dpt_physmap(0x01118, 1024);
366: j = *((ushort *) (addr + 2));
367: j *= 16;
368: j += *((ushort *) (addr));
369: dpt_unphysmap(addr, 1024);
370: addr = (char *) dpt_physmap(j, 1024);
371:
372: if (addr != NULL) {
373: dpt_sysinfo.drives[1].cylinders = *((ushort *) addr);
374: dpt_sysinfo.drives[1].heads = *(addr + 2);
375: dpt_sysinfo.drives[1].sectors = *(addr + 14);
376: dpt_unphysmap(addr, 1024);
377: }
378: }
379: dpt_sysinfo.flags |= SI_DriveParamsValid;
380: }
381: splx(ospl);
382:
383: /* Get the processor information */
384: dpt_sysinfo.flags |= SI_ProcessorValid;
385:
386: /* Get the bus I/O bus information */
387: dpt_sysinfo.flags |= SI_BusTypeValid;
388: dpt_sysinfo.busType = HBA_BUS_PCI;
389:
390: /* XXX Use _FreeBSD_Version_ */
391: dpt_sysinfo.osType = OS_FREEBSD;
392: dpt_sysinfo.osMajorVersion = osrelease[0] - '0';
393: if (osrelease[1] == '.')
394: dpt_sysinfo.osMinorVersion = osrelease[2] - '0';
395: else
396: dpt_sysinfo.osMinorVersion = 0;
397: if (osrelease[3] == '.')
398: dpt_sysinfo.osRevision = osrelease[4] - '0';
399: else
400: dpt_sysinfo.osMinorVersion = 0;
401: if (osrelease[5] == '.')
402: dpt_sysinfo.osSubRevision = osrelease[6] - '0';
403: else
404: dpt_sysinfo.osMinorVersion = 0;
405:
406:
407: dpt_sysinfo.flags |= SI_OSversionValid;
408: }
409:
410: static int
411: dpt_open(dev_t dev, int flags, int fmt, struct proc * p)
412: {
413: int minor_no;
414: int ospl;
415: dpt_softc_t *dpt;
416:
417: minor_no = minor(dev);
418:
419: if (dpt_minor2unit(minor_no) == -1)
420: return (ENXIO);
421: else
422: dpt = dpt_minor2softc(minor_no);
423:
424: if (dpt == NULL)
425: return (ENXIO);
426:
427: ospl = splbio();
428:
429: if (dpt->state & DPT_HA_CONTROL_ACTIVE) {
430: splx(ospl);
431: return (EBUSY);
432: } else {
433: if ((dpt_inbuf[minor_no & ~SCSI_CONTROL_MASK] = geteblk(PAGE_SIZE))
434: == NULL) {
435: #ifdef DPT_DEBUG_CONTROL
436: printf("dpt%d: Failed to obtain an I/O buffer\n",
437: minor_no & ~SCSI_CONTROL_MASK);
438: #endif
439: splx(ospl);
440: return (EINVAL);
441: }
442: }
443:
444: dpt->state |= DPT_HA_CONTROL_ACTIVE;
445: splx(ospl);
446: return (0);
447: }
448:
449: static int
450: dpt_close(dev_t dev, int flags, int fmt, struct proc * p)
451: {
452: int minor_no;
453: dpt_softc_t *dpt;
454:
455: minor_no = minor(dev);
456: dpt = dpt_minor2softc(minor_no);
457:
458: if ((dpt_minor2unit(minor_no) == -1) || (dpt == NULL))
459: return (ENXIO);
460: else {
461: brelse(dpt_inbuf[minor_no & ~SCSI_CONTROL_MASK]);
462: dpt->state &= ~DPT_HA_CONTROL_ACTIVE;
463: return (0);
464: }
465: }
466:
467: static int
468: dpt_write(dev_t dev, struct uio * uio, int ioflag)
469: {
470: int minor_no;
471: int unit;
472: int error;
473:
474: minor_no = minor(dev);
475:
476: if (minor_no & SCSI_CONTROL_MASK) {
477: #ifdef DPT_DEBUG_CONTROL
478: printf("dpt%d: I/O attempted to control channel (%x)\n",
479: dpt_minor2unit(minor_no), minor_no);
480: #endif
481: return (ENXIO);
482: }
483: unit = dpt_minor2unit(minor_no);
484:
485: if (unit == -1) {
486: return (ENXIO);
487: } else if (uio->uio_resid > DPT_RW_CMD_LEN) {
488: return (E2BIG);
489: } else {
490: char *cp;
491: int length;
492:
493: cp = dpt_inbuf[minor_no]->b_data;
494: length = uio->uio_resid; /* uiomove will change it! */
495:
496: if ((error = uiomove(cp, length, uio) != 0)) {
497: #ifdef DPT_DEBUG_CONTROL
498: printf("dpt%d: uiomove(%x, %d, %x) failed (%d)\n",
499: minor_no, cp, length, uio, error);
500: #endif
501: return (error);
502: } else {
503: cp[length] = '\0';
504:
505: /* A real kludge, to allow plain echo(1) to work */
506: if (cp[length - 1] == '\n')
507: cp[length - 1] = '\0';
508:
509: strncpy(dpt_rw_command[unit], cp, DPT_RW_CMD_LEN);
510: #ifdef DPT_DEBUG_CONTROL
511: /**
512: * For lack of anything better to do;
513: * For now, dump the data so we can look at it and rejoice
514: */
515: printf("dpt%d: Command \"%s\" arrived\n",
516: unit, dpt_rw_command[unit]);
517: #endif
518: }
519: }
520:
521: return (error);
522: }
523:
524: static int
525: dpt_read(dev_t dev, struct uio * uio, int ioflag)
526: {
527: dpt_softc_t *dpt;
528: int error;
529: int minor_no;
530: int ospl;
531:
532: minor_no = minor(dev);
533: error = 0;
534:
535: #ifdef DPT_DEBUG_CONTROL
536: printf("dpt%d: read, count = %d, dev = %08x\n",
537: minor_no, uio->uio_resid, dev);
538: #endif
539:
540: if (minor_no & SCSI_CONTROL_MASK) {
541: #ifdef DPT_DEBUG_CONTROL
542: printf("dpt%d: I/O attempted to control channel (%x)\n",
543: dpt_minor2unit(minor_no), minor_no);
544: #endif
545: return (ENXIO);
546: }
547: if (dpt_minor2unit(minor_no) == -1) {
548: return (ENXIO);
549: }
550: /*
551: * else if ( uio->uio_resid > PAGE_SIZE ) { return(E2BIG); }
552: */
553: else {
554: char *work_buffer;
555: char *wbp;
556: char *command;
557: int work_size;
558: int ndx;
559: int x;
560:
561: if ((dpt = dpt_minor2softc(minor_no)) == NULL)
562: return (ENXIO);
563:
564: work_buffer = (u_int8_t *) malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
565: wbp = work_buffer;
566: work_size = 0;
567:
568: ospl = splbio();
569:
570: command = dpt_rw_command[dpt->unit];
571: if (strcmp(command, DPT_RW_CMD_DUMP_SOFTC) == 0) {
572: x = sprintf(wbp, "dpt%d:%s:%s:%s:%s:%x\n",
573: dpt->unit,
574: dpt->board_data.vendor,
575: dpt->board_data.modelNum,
576: dpt->board_data.firmware,
577: dpt->board_data.protocol,
578: dpt->EATA_revision);
579: work_size += x;
580: wbp += x;
581:
582: } else if (strcmp(command, DPT_RW_CMD_DUMP_SYSINFO) == 0) {
583: x = sprintf(wbp, "dpt%d:%d:%d:%d:%d:%d:%d:%d:%d:%s:"
584: "%d:%d:%d:%d:%d:%d:%d:%d\n",
585: dpt->unit,
586: dpt_sysinfo.drive0CMOS,
587: dpt_sysinfo.drive1CMOS,
588: dpt_sysinfo.numDrives,
589: dpt_sysinfo.processorFamily,
590: dpt_sysinfo.processorType,
591: dpt_sysinfo.smartROMMajorVersion,
592: dpt_sysinfo.smartROMMinorVersion,
593: dpt_sysinfo.smartROMRevision,
594: i2bin(dpt_sysinfo.flags,
595: sizeof(dpt->queue_status) * 8),
596: dpt_sysinfo.conventionalMemSize,
597: dpt_sysinfo.extendedMemSize,
598: dpt_sysinfo.osType, dpt_sysinfo.osMajorVersion,
599: dpt_sysinfo.osMinorVersion, dpt_sysinfo.osRevision,
600: dpt_sysinfo.osSubRevision, dpt_sysinfo.busType);
601: work_size += x;
602: wbp += x;
603:
604: for (ndx = 0; ndx < 16; ndx++) {
605: if (dpt_sysinfo.drives[ndx].cylinders != 0) {
606: x = sprintf(wbp, "dpt%d:d%dc%dh%ds%d\n",
607: dpt->unit,
608: ndx,
609: dpt_sysinfo.drives[ndx].cylinders,
610: dpt_sysinfo.drives[ndx].heads,
611: dpt_sysinfo.drives[ndx].sectors);
612: work_size += x;
613: wbp += x;
614: }
615: }
616: } else if (strcmp(command, DPT_RW_CMD_DUMP_METRICS) == 0) {
617: x = sprintf(wbp,
618: "dpt%d: No metrics available.\n"
619: "Run the dpt_dm command, or use the\n"
620: "DPT_IOCTL_INTERNAL_METRICS ioctl system call\n",
621: dpt->unit);
622: work_size += x;
623: wbp += x;
624: } else if (strcmp(command, DPT_RW_CMD_CLEAR_METRICS) == 0) {
625: #ifdef DPT_MEASURE_PERFORMANCE
626: dpt_reset_performance(dpt);
627: #endif /* DPT_MEASURE_PERFORMANCE */
628:
629: x = sprintf(wbp, "dpt%d: Metrics have been cleared\n",
630: dpt->unit);
631: work_size += x;
632: wbp += x;
633: } else if (strcmp(command, DPT_RW_CMD_SHOW_LED) == 0) {
634:
635: x = sprintf(wbp, "dpt%d:%s\n",
636: dpt->unit, i2bin(dpt_blinking_led(dpt), 8));
637: work_size += x;
638: wbp += x;
639: } else {
640: #ifdef DPT_DEBUG_CONTROL
641: printf("dpt%d: Bad READ state (%s)\n", minor_no, command);
642: #endif
643: splx(ospl);
644: error = EINVAL;
645: }
646:
647: if (error == 0) {
648: work_buffer[work_size++] = '\0';
649: error = uiomove(work_buffer, work_size, uio);
650: uio->uio_resid = 0;
651: #ifdef DPT_DEBUG_CONTROL
652: if (error) {
653: printf("dpt%d: READ uimove failed (%d)\n", dpt->unit, error);
654: }
655: #endif
656: }
657: }
658: splx(ospl);
659: return (error);
660: }
661:
662: /**
663: * This is the control syscall interface.
664: * It should be binary compatible with UnixWare,
665: * if not totally syntatically so.
666: */
667:
668: static int
669: dpt_ioctl(dev_t dev, u_long cmd, caddr_t cmdarg, int flags, struct proc * p)
670: {
671: int minor_no;
672: dpt_softc_t *dpt;
673: dpt_user_softc_t udpt;
674: int result;
675: int ndx;
676: eata_pt_t *eata_pass_thru;
677:
678: minor_no = minor(dev);
679: result = 0;
680:
681: if (!(minor_no & SCSI_CONTROL_MASK)) {
682: #ifdef DPT_DEBUG_CONTROL
683: printf("dpt%d: Control attempted to I/O channel (%x)\n",
684: dpt_minor2unit(minor_no), minor_no);
685: #endif /* DEBUG */
686: return (ENXIO);
687: } else
688: minor_no &= ~SCSI_CONTROL_MASK;
689:
690: #ifdef DPT_DEBUG_CONTROL
691: printf("dpt%d: IOCTL(%x, %x, %p, %x, %p)\n",
692: minor_no, dev, cmd, cmdarg, flags, p);
693: #endif /* DEBUG */
694:
695: if ((dpt = dpt_minor2softc(minor_no)) == NULL)
696: return (result);
697:
698: switch (cmd) {
699: #ifdef DPT_MEASURE_PERFORMANCE
700: case DPT_IOCTL_INTERNAL_METRICS:
701: memcpy(cmdarg, &dpt->performance, sizeof(dpt->performance));
702: return (0);
703: #endif /* DPT_MEASURE_PERFORMANCE */
704: case DPT_IOCTL_SOFTC:
705: udpt.unit = dpt->unit;
706: udpt.handle_interrupts = dpt->handle_interrupts;
707: udpt.target_mode_enabled = dpt->target_mode_enabled;
708: udpt.spare = dpt->spare;
709:
710: udpt.total_ccbs_count = dpt->total_ccbs_count;
711: udpt.free_ccbs_count = dpt->free_ccbs_count;
712: udpt.waiting_ccbs_count = dpt->waiting_ccbs_count;
713: udpt.submitted_ccbs_count = dpt->submitted_ccbs_count;
714: udpt.completed_ccbs_count = dpt->completed_ccbs_count;
715:
716: udpt.queue_status = dpt->queue_status;
717: udpt.free_lock = dpt->free_lock;
718: udpt.waiting_lock = dpt->waiting_lock;
719: udpt.submitted_lock = dpt->submitted_lock;
720: udpt.completed_lock = dpt->completed_lock;
721:
722: udpt.commands_processed = dpt->commands_processed;
723: udpt.lost_interrupts = dpt->lost_interrupts;
724:
725: udpt.channels = dpt->channels;
726: udpt.max_id = dpt->max_id;
727: udpt.max_lun = dpt->max_lun;
728:
729: udpt.io_base = dpt->io_base;
730: udpt.v_membase = (u_int8_t *) dpt->v_membase;
731: udpt.p_membase = (u_int8_t *) dpt->p_membase;
732:
733: udpt.irq = dpt->irq;
734: udpt.dma_channel = dpt->dma_channel;
735:
736: udpt.board_data = dpt->board_data;
737: udpt.EATA_revision = dpt->EATA_revision;
738: udpt.bustype = dpt->bustype;
739: udpt.state = dpt->state;
740:
741: udpt.primary = dpt->primary;
742: udpt.more_support = dpt->more_support;
743: udpt.immediate_support = dpt->immediate_support;
744: udpt.broken_INQUIRY = dpt->broken_INQUIRY;
745: udpt.spare2 = dpt->spare2;
746:
747: for (ndx = 0; ndx < MAX_CHANNELS; ndx++) {
748: udpt.resetlevel[ndx] = dpt->resetlevel[ndx];
749: udpt.hostid[ndx] = dpt->hostid[ndx];
750: }
751:
752: udpt.last_ccb = dpt->last_ccb;
753: udpt.cplen = dpt->cplen;
754: udpt.cppadlen = dpt->cppadlen;
755: udpt.queuesize = dpt->queuesize;
756: udpt.sgsize = dpt->sgsize;
757: udpt.cache_type = dpt->cache_type;
758: udpt.cache_size = dpt->cache_size;
759:
760: memcpy(cmdarg, &udpt, sizeof(dpt_user_softc_t));
761: return (0);
762: case SDI_SEND:
763: case DPT_IOCTL_SEND:
764: eata_pass_thru = (eata_pt_t *) cmdarg;
765:
766: if ((eata_pass_thru->eataID[0] != 'E')
767: || (eata_pass_thru->eataID[1] != 'A')
768: || (eata_pass_thru->eataID[2] != 'T')
769: || (eata_pass_thru->eataID[3] != 'A')) {
770: return (EFAULT);
771: }
772: switch (eata_pass_thru->command) {
773: case DPT_SIGNATURE:
774: return (copyout((char *) &dpt_sig,
775: (caddr_t *) eata_pass_thru->command_buffer,
776: sizeof(dpt_sig)));
777: case DPT_NUMCTRLS:
778: return (copyout((char *) &dpt_controllers_present,
779: (caddr_t *) eata_pass_thru->command_buffer,
780: sizeof(dpt_controllers_present)));
781: case DPT_CTRLINFO:
782: {
783: dpt_compat_ha_t compat_softc;
784: int ndx;
785:
786: compat_softc.ha_state = dpt->state; /* Different Meaning! */
787: for (ndx = 0; ndx < MAX_CHANNELS; ndx++)
788: compat_softc.ha_id[ndx] = dpt->hostid[ndx];
789:
790: compat_softc.ha_vect = dpt->irq;
791: compat_softc.ha_base = BaseRegister(dpt);
792: compat_softc.ha_max_jobs = dpt->total_ccbs_count;
793: compat_softc.ha_cache = dpt->cache_type;
794: compat_softc.ha_cachesize = dpt->cache_size;
795: compat_softc.ha_nbus = dpt->dma_channel + 1;
796: compat_softc.ha_ntargets = dpt->max_id + 1;
797: compat_softc.ha_nluns = dpt->max_lun + 1;
798: compat_softc.ha_tshift = (dpt->max_id == 7) ? 3 : 4;
799: compat_softc.ha_bshift = 2;
800: compat_softc.ha_npend = dpt->submitted_ccbs_count;
801: compat_softc.ha_active_jobs = dpt->waiting_ccbs_count;
802: strncpy(compat_softc.ha_fw_version,
803: dpt->board_data.firmware,
804: sizeof(compat_softc.ha_fw_version));
805: compat_softc.ha_ccb = NULL;
806: compat_softc.ha_cblist = NULL;
807: compat_softc.ha_dev = NULL;
808: compat_softc.ha_StPkt_lock = NULL;
809: compat_softc.ha_ccb_lock = NULL;
810: compat_softc.ha_LuQWaiting = NULL;
811: compat_softc.ha_QWait_lock = NULL;
812: compat_softc.ha_QWait_opri = NULL;
813:
814: return (copyout((char *) &compat_softc,
815: (caddr_t *) eata_pass_thru->command_buffer,
816: sizeof(dpt_compat_ha_t)));
817: }
818: break;
819:
820: case DPT_SYSINFO:
821: return (copyout((char *) &dpt_sysinfo,
822: (caddr_t *) eata_pass_thru->command_buffer,
823: sizeof(dpt_sysinfo)));
824: case EATAUSRCMD:
825: result = dpt_user_cmd(dpt, eata_pass_thru, cmdarg, minor_no);
826: return (result);
827: case DPT_BLINKLED:
828: result = dpt_blinking_led(dpt);
829: return (copyout((caddr_t) & result,
830: (caddr_t *) eata_pass_thru->command_buffer,
831: sizeof(result)));
832: default:
833: printf("dpt%d: Invalid (%x) pass-throu command\n",
834: dpt->unit, eata_pass_thru->command);
835: result = EINVAL;
836: }
837:
838: default:
839: printf("dpt%d: Invalid (%lx) IOCTL\n", dpt->unit, cmd);
840: return (EINVAL);
841:
842: }
843:
844: return (result);
845: }
846:
847: static dpt_devsw_installed = 0;
848:
849: static void
850: dpt_drvinit(void *unused)
851: {
852: if (!dpt_devsw_installed) {
853: if (bootverbose)
854: printf("DPT: RAID Manager driver, Version %d.%d.%d\n",
855: DPT_CTL_RELEASE, DPT_CTL_VERSION, DPT_CTL_PATCH);
856:
857: /* Add the I/O (data) channel */
858: cdevsw_add(&dpt_cdevsw, 0, 0);
859:
860: dpt_devsw_installed = 1;
861: }
862: dpt_get_sysinfo();
863: }
864:
865: SYSINIT(dpt_dev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE + CDEV_MAJOR, dpt_drvinit, NULL)
866: /* End of the dpt_control driver */
![[BACK]](/icons//back.gif){kind=icon}
Return to dpt_control.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / sys / dev / raid / dpt