OpenSolaris_b135/lib/libsmedia/plugins/floppy/common/f_format.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* f_format.c :
* This file contains the format functions for floppy plug-in for
* library libsm.so.
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/dklabel.h>
#include <sys/dkio.h>
#include <sys/fdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <locale.h>
#include <errno.h>
#include <sys/param.h>
#include <stdlib.h>
#include <sys/smedia.h>
#include "../../../library/inc/rmedia.h"
#include "f_defines.h"
/*
* extern functions
*/
extern void my_perror(char *err_string);
/*
* local functions
*/
static void restore_default_chars(int32_t fd,
struct fd_char save_fdchar,
struct dk_allmap save_allmap);
static int32_t
format_floppy(int32_t fd, void *ip)
{
struct format_track *ft = (struct format_track *)ip;
int32_t format_flags;
int32_t transfer_rate = 1000; /* transfer rate code */
int32_t sec_size = 512; /* sector size */
uchar_t gap = 0x54; /* format gap size */
uchar_t *fbuf, *p;
int32_t cyl_size;
int32_t i;
int32_t chgd; /* for testing disk changed/present */
int32_t cyl, hd;
int32_t size_of_part, size_of_dev;
int32_t spt = 36; /* sectors per track */
int32_t drive_size;
uchar_t num_cyl = 80; /* max number of cylinders */
struct fd_char save_fdchar; /* original diskette characteristics */
struct dk_allmap save_allmap; /* original diskette partition info */
int32_t D_flag = 0; /* double (aka low) density flag */
int32_t E_flag = 0; /* extended density */
int32_t H_flag = 0; /* high density */
int32_t M_flag = 0; /* medium density */
struct fd_char fdchar;
struct dk_geom fdgeom;
struct dk_allmap allmap;
struct dk_cinfo dkinfo;
int32_t start_head, end_head, start_cyl, end_cyl;
/* for verify buffers */
static uchar_t *obuf;
/* FDRAW ioctl command structures for seeking and formatting */
struct fd_raw fdr_seek = {
FDRAW_SEEK, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0
};
struct fd_raw fdr_form = {
0x4D, 0, 2, 0, 0x54, (char)0xA5, 0, 0, 0, 0,
6,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, /* nbytes */
0 /* addr */
};
format_flags = ft->flag;
DPRINTF1("Format flag is %d\n", format_flags);
if (format_flags == SM_FORMAT_HD) {
H_flag = 1;
} else if (format_flags == SM_FORMAT_DD) {
D_flag = 1;
} else if (format_flags == SM_FORMAT_ED) {
E_flag = 1;
} else if (format_flags == SM_FORMAT_MD) {
M_flag = 1;
} else {
DPRINTF("Invalid operation \n");
errno = ENOTSUP;
return (-1);
}
/*
* restore drive to default geometry and characteristics
* (probably not implemented on sparc)
*/
(void) ioctl(fd, FDDEFGEOCHAR, NULL);
if (ioctl(fd, DKIOCINFO, &dkinfo) < 0) {
PERROR("DKIOCINFO failed.");
exit(3);
}
/* get the default partititon maps */
if (ioctl(fd, DKIOCGAPART, &allmap) < 0) {
PERROR("DKIOCGAPART failed.");
return (-1);
}
/* Save the original default partition maps */
save_allmap = allmap;
/* find out the characteristics of the default diskette */
if (ioctl(fd, FDIOGCHAR, &fdchar) < 0) {
PERROR("FDIOGCHAR failed.");
return (-1);
}
/* Save the original characteristics of the default diskette */
save_fdchar = fdchar;
/*
* The user may only format the entire diskette.
* formatting partion a or b is not allowed
*/
size_of_part = allmap.dka_map[dkinfo.dki_partition].dkl_nblk
* DEV_BSIZE;
size_of_dev = fdchar.fdc_ncyl * fdchar.fdc_nhead
* fdchar.fdc_secptrack * fdchar.fdc_sec_size;
if (size_of_part != size_of_dev) {
DPRINTF("The entire diskette must be formatted\n");
DPRINTF1("size_of_part %d\n", size_of_part);
DPRINTF1("size_of_dev %d\n", size_of_dev);
errno = ENOTSUP;
return (-1);
}
/* find out the geometry of the drive */
if (ioctl(fd, DKIOCGGEOM, &fdgeom) < 0) {
PERROR("DKIOCGGEOM failed.");
return (-1);
}
#ifdef sparc
fdchar.fdc_medium = 3;
#endif
if (fdchar.fdc_medium == 5)
drive_size = 5;
else
drive_size = 3;
/*
* set proper density flag in case we're formating to default
* characteristics because no density switch was input
*/
/* XXX */
if ((E_flag | H_flag | D_flag | M_flag) == 0) {
switch (fdchar.fdc_transfer_rate) {
case 1000:
/* assumes only ED uses 1.0 MB/sec */
E_flag++;
break;
case 500:
default:
/*
* default to HD even though High density and
* "medium" density both use 500 KB/sec
*/
H_flag++;
break;
#ifndef sparc
case 250:
/* assumes only DD uses 250 KB/sec */
D_flag++;
break;
#endif
}
}
if (H_flag) {
transfer_rate = 500;
num_cyl = 80;
sec_size = 512;
if (drive_size == 5) {
spt = 15;
} else {
spt = 18;
}
gap = 0x54;
} else if (D_flag) {
transfer_rate = 250;
if (drive_size == 5) {
if (fdchar.fdc_transfer_rate == 500) {
/*
* formatting a 360KB DD diskette in
* a 1.2MB drive is not a good idea
*/
transfer_rate = 300;
fdchar.fdc_steps = 2;
}
num_cyl = 40;
gap = 0x50;
} else {
num_cyl = 80;
gap = 0x54;
}
sec_size = 512;
spt = 9;
} else if (M_flag) {
#ifdef sparc
transfer_rate = 500;
#else
/*
* 416.67 KB/sec is the effective transfer rate of a "medium"
* density diskette spun at 300 rpm instead of 360 rpm
*/
transfer_rate = 417;
#endif
num_cyl = 77;
sec_size = 1024;
spt = 8;
gap = 0x74;
} else if (E_flag) {
transfer_rate = 1000;
num_cyl = 80;
sec_size = 512;
spt = 36;
gap = 0x54;
}
/*
* Medium density diskettes have 1024 byte blocks. The dk_map
* structure in dklabel.h assumes the blocks size is DEVBSIZE (512)
* bytes. The dkl_nblk field is in terms of DEVBSIZE byte blocks
* while the spt variable is in terms of the true block size on
* the diskette.
*/
if (allmap.dka_map[2].dkl_nblk !=
(2 * num_cyl * spt * (M_flag ? 2 : 1))) {
allmap.dka_map[1].dkl_cylno = num_cyl - 1;
allmap.dka_map[0].dkl_nblk = 2 * (num_cyl - 1) * spt *
(M_flag ? 2 : 1);
allmap.dka_map[1].dkl_nblk = 2 * spt * (M_flag ? 2 : 1);
allmap.dka_map[2].dkl_nblk = 2 * num_cyl * spt *
(M_flag ? 2 : 1);
if (allmap.dka_map[3].dkl_nblk)
allmap.dka_map[3].dkl_nblk = 2 * (num_cyl - 1) * spt *
(M_flag ? 2 : 1);
if (allmap.dka_map[4].dkl_nblk)
allmap.dka_map[4].dkl_nblk =
2 * spt * (M_flag ? 2 : 1);
}
#ifndef sparc
if (num_cyl > fdchar.fdc_ncyl || spt > fdchar.fdc_secptrack ||
transfer_rate > fdchar.fdc_transfer_rate) {
PERROR("drive not capable of requested density");
return (-1);
}
#endif
if (num_cyl != fdchar.fdc_ncyl || spt != fdchar.fdc_secptrack ||
transfer_rate != fdchar.fdc_transfer_rate) {
/*
* -- CAUTION --
* The SPARC fd driver is using a non-zero value in
* fdc_medium to indicate the 360 rpm, 77 track,
* 9 sectors/track, 1024 bytes/sector mode of operation
* (similar to an 8", DS/DD, 1.2 MB floppy).
*
* The x86 fd driver uses fdc_medium as the diameter
* indicator, either 3 or 5. It should not be modified.
*/
#ifdef sparc
fdchar.fdc_medium = M_flag ? 1 : 0;
#endif
fdchar.fdc_transfer_rate = transfer_rate;
fdchar.fdc_ncyl = num_cyl;
fdchar.fdc_sec_size = sec_size;
fdchar.fdc_secptrack = spt;
if (ioctl(fd, FDIOSCHAR, &fdchar) < 0) {
PERROR("FDIOSCHAR (density selection) failed");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
if (ioctl(fd, DKIOCSAPART, &allmap) < 0) {
PERROR("DKIOCSAPART failed");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
}
cyl_size = 2 * sec_size * spt;
if ((obuf = (uchar_t *)malloc((size_t)cyl_size)) == 0) {
PERROR("car't malloc verify buffer");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
/*
* for those systems that support this ioctl, they will
* return whether or not a diskette is in the drive.
*/
if (ioctl(fd, FDGETCHANGE, &chgd) == 0) {
if (chgd & FDGC_CURRENT) {
(void) fprintf(stderr,
gettext("no diskette in drive \n"));
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
if (chgd & FDGC_CURWPROT) {
(void) fprintf(stderr,
gettext("Media is write protected\n"));
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
}
if ((fbuf = (uchar_t *)malloc((unsigned)(4 * spt))) == 0) {
PERROR("Could not malloc format header buffer");
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
/*
* do the format, a track at a time
*/
if (ft->track_no == -1) {
start_cyl = 0;
end_cyl = num_cyl;
start_head = 0;
end_head = fdchar.fdc_nhead;
} else {
start_cyl = ft->track_no;
end_cyl = ft->track_no + 1;
start_head = ft->head;
end_head = ft->head + 1;
if ((end_cyl > num_cyl) || (end_head > fdchar.fdc_nhead)) {
errno = EINVAL;
return (-1);
}
}
for (cyl = start_cyl; cyl < (int32_t)end_cyl; cyl++) {
/*
* This is not the optimal ioctl to format the floppy.
* The device driver should do do the work,
* instead of this program mucking with a lot
* of low-level, device-dependent code.
*/
fdr_seek.fdr_cmd[2] = cyl;
if (ioctl(fd, FDRAW, &fdr_seek) < 0) {
(void) fprintf(stderr,
gettext(" seek to cyl %d failed\n"),
cyl);
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
/*
* Assume that the fd driver has issued a SENSE_INT
* command to complete the seek operation.
*/
for (hd = start_head; hd < end_head; hd++) {
p = (uchar_t *)fbuf;
for (i = 1; i <= spt; i++) {
*p++ = (uchar_t)cyl;
*p++ = (uchar_t)hd;
*p++ = (uchar_t)i; /* sector # */
*p++ = (sec_size == 1024) ? 3 : 2;
}
/*
* ASSUME the fd driver is going to set drive-select
* bits in the second command byte
*/
fdr_form.fdr_cmd[1] = hd << 2;
fdr_form.fdr_cmd[2] = (sec_size == 1024) ? 3 : 2;
fdr_form.fdr_cmd[3] = spt;
fdr_form.fdr_cmd[4] = gap;
fdr_form.fdr_nbytes = 4 * spt;
fdr_form.fdr_addr = (char *)fbuf;
if (ioctl(fd, FDRAW, &fdr_form) < 0) {
(void) fprintf(stderr,
gettext(
"format of cyl %d head %d failed\n"),
cyl, hd);
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
if (fdr_form.fdr_result[0] & 0xC0) {
if (fdr_form.fdr_result[1] & 0x02) {
(void) fprintf(stderr, gettext(
/*CSTYLED*/
"diskette is write protected\n"));
/*
* restore the default
* characteristics
*/
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
(void) fprintf(stderr,
gettext(
"format of cyl %d head %d failed\n"),
cyl, hd);
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
}
/*
* do a quick verify
*/
if (llseek(fd, cyl * cyl_size, 0) != cyl * cyl_size) {
PERROR(" bad seek to format verify, ");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
if (fdchar.fdc_nhead == end_head) {
if (read(fd, obuf, cyl_size) != cyl_size) {
PERROR("Could not read format data");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
}
}
if (llseek(fd, (off_t)0, 0) != 0) {
PERROR("seek to blk 0 failed");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
return (0);
}
/*
* Restore the default characteristics of the floppy diskette.
* Fdformat changes the characteristics in the process of formatting.
* If fdformat fails while in the process of doing the format, fdformat
* should clean up after itself and reset the driver back to the original
* state.
*/
static void
restore_default_chars(int32_t fd,
struct fd_char save_fdchar,
struct dk_allmap save_allmap)
{
/*
* When this function is called, fdformat is failing anyways,
* so the errors are not processed.
*/
(void) ioctl(fd, FDIOSCHAR, &save_fdchar);
(void) ioctl(fd, DKIOCSAPART, &save_allmap);
/*
* Before looking at the diskette's characteristics, format_floppy()
* sets the x86 floppy driver to the default characteristics.
* restore drive to default geometry and
* characteristics. This ioctl isn't implemented on
* sparc.
*/
(void) ioctl(fd, FDDEFGEOCHAR, NULL);
}
int32_t
_m_media_format(rmedia_handle_t *handle, void *ip) {
struct format_track ft;
/* Check for valid handle */
if (handle == NULL) {
DPRINTF("Null Handle\n");
errno = EINVAL;
return (-1);
}
if (handle->sm_signature != (int32_t)LIBSMEDIA_SIGNATURE) {
DPRINTF("Invalid signature in handle.\n");
DPRINTF2(
"Signature expected=0x%x, found=0x%x\n",
LIBSMEDIA_SIGNATURE, handle->sm_signature);
errno = EINVAL;
return (-1);
}
if (handle->sm_fd < 0) {
DPRINTF("Invalid file handle.\n");
errno = EINVAL;
return (-1);
}
DPRINTF("Format floppy called \n");
ft.track_no = (-1);
ft.head = (-1);
ft.flag = ((struct format_flags *)ip)->flavor;
return (format_floppy(handle->sm_fd, &ft));
}
int32_t
_m_media_format_track(rmedia_handle_t *handle, void *ip)
{
/* Check for valid handle */
if (handle == NULL) {
DPRINTF("Null Handle\n");
errno = EINVAL;
return (-1);
}
if (handle->sm_signature != (int32_t)LIBSMEDIA_SIGNATURE) {
DPRINTF("Invalid signature in handle.\n");
DPRINTF2(
"Signature expected=0x%x, found=0x%x\n",
LIBSMEDIA_SIGNATURE, handle->sm_signature);
errno = EINVAL;
return (-1);
}
if (handle->sm_fd < 0) {
DPRINTF("Invalid file handle.\n");
errno = EINVAL;
return (-1);
}
#ifdef DEBUG
if (ip != NULL) {
struct format_track *ft = (struct format_track *)ip;
DPRINTF2("Format track %d head %d\n", ft->track_no, ft->head);
}
#endif /* DEBUG */
return (format_floppy(handle->sm_fd, ip));
}