操作系统开发

开发平台：

C/C++

COMPLETE.TXT：源码内容

18834
18835
18836 /***** esdi i/o adapter ports */
18837
18838 #define CMD_REG 0x3510 /* command interface register */
18839 #define STAT_REG 0x3510 /* status interface register */
18840 #define BCTL_REG 0x3512 /* basic control register */
18841 #define BST_REG 0x3512 /* basic status register */
18842 #define ATT_REG 0x3513 /* attention register */
18843 #define INT_REG 0x3513 /* interrupt status register */
18844
18845
18846 /***** basic status register bits */
18847
18848 #define DMA_ENA 0x80 /* DMA enabled? */
18849 #define INT_PND 0x40 /* interrupt pending? */
18850 #define CMD_PRG 0x20 /* command in progress? */
18851 #define BUSY 0x10 /* is adapter busy? */
18852 #define STR_FUL 0x08 /* status interface register set? */
18853 #define CMD_FUL 0x04 /* command interface register full? */
18854 #define XFR_REQ 0x02 /* data transfer operation ready? */
18855 #define INT_SET 0x01 /* adapter sending interrupt? */
18856
18857
18858 /***** attention register commands */
18859
18860 #define ATT_CMD 0x01 /* command request */
18861 #define ATT_EOI 0x02 /* end of interrupt processing */
18862 #define ATT_ABT 0x03 /* abort the current command */
18863 #define ATT_RST 0xE4 /* reset the esdi adapter */
18864
18865
18866 /***** dma register addresses */
18867
18868 #define DMA_EXTCMD 0x18 /* extended function register */
18869 #define DMA_EXEC 0x1A /* extended function execute */
18870
18871
18872 /***** miscellaneous */
18873
18874 #define ERR (-1) /* general error code */
18875 #define ERR_BAD_SECTOR (-2) /* block marked bad detected */
18876 #define MAX_ERRORS 4 /* maximum number of read/write retries */
18877 #define MAX_DRIVES 2 /* maximum number of physical drives */
18878 #define NR_DEVICES (MAX_DRIVES*DEV_PER_DRIVE)
18879 /* Maximum number of logical devices */
18880 #define SUB_PER_DRIVE (NR_PARTITIONS * NR_PARTITIONS)
18881 #define NR_SUBDEVS (MAX_DRIVES * SUB_PER_DRIVE)
18882
18883 #define SYS_PORTA 0x92 /* system control port a */
18884 #define LIGHT_ON 0xC0 /* fixed-disk activity light reg. mask */
18885
18886
18887 /***** variables */
18888
18889 PRIVATE struct wini { /* disk/partition information */
18890 unsigned open_ct; /* in-use count */
18891 struct device part[DEV_PER_DRIVE]; /* primary partitions: hd[0-4] */
18892 struct device subpart[SUB_PER_DRIVE]; /* subpartitions: hd[1-4][a-d] */
18893 } wini[MAX_DRIVES], *w_wn;
18894
18895 PRIVATE struct trans {
18896 struct iorequest_s *iop; /* belongs to this I/O request */
18897 unsigned long block; /* first sector to transfer */
18898 unsigned count; /* byte count */
18899 phys_bytes phys; /* user physical address */
18900 phys_bytes dma; /* DMA physical address */
18901 } wtrans[NR_IOREQS];
18902
18903 PRIVATE int nr_drives; /* actual number of physical disk drive */
18904 PRIVATE int command[4]; /* controller command buffer */
18905 PRIVATE unsigned int status_block[9]; /* status block output from a command */
18906 PRIVATE int dma_channel; /* fixed disk dma channel number */
18907 PRIVATE struct trans *w_tp; /* to add transfer requests */
18908 PRIVATE unsigned w_count; /* number of bytes to transfer */
18909 PRIVATE unsigned long w_nextblock; /* next block on disk to transfer */
18910 PRIVATE int w_opcode; /* DEV_READ or DEV_WRITE */
18911 PRIVATE int w_drive; /* selected drive */
18912 PRIVATE int w_istat; /* interrupt status of last command */
18913 PRIVATE struct device *w_dv; /* device's base and size */
18914
18915
18916 /***** functions */
18917
18918 FORWARD _PROTOTYPE( struct device *w_prepare, (int device) );
18919 FORWARD _PROTOTYPE( char *w_name, (void) );
18920 FORWARD _PROTOTYPE( int w_do_open, (struct driver *dp, message *m_ptr) );
18921 FORWARD _PROTOTYPE( int w_do_close, (struct driver *dp, message *m_ptr) );
18922 FORWARD _PROTOTYPE( void w_init, (void) );
18923 FORWARD _PROTOTYPE( int w_command, (int device, int cmd, int num_words) );
18924 FORWARD _PROTOTYPE( int w_schedule, (int proc_nr, struct iorequest_s *iop) );
18925 FORWARD _PROTOTYPE( int w_finish, (void) );
18926 FORWARD _PROTOTYPE( int w_transfer, (struct trans *tp, unsigned count) );
18927 FORWARD _PROTOTYPE( int w_att_write, (int value) );
18928 FORWARD _PROTOTYPE( void w_interrupt, (int dma) );
18929 FORWARD _PROTOTYPE( int w_handler, (int irq) );
18930 FORWARD _PROTOTYPE( void w_dma_setup, (struct trans *tp, unsigned count) );
18931 FORWARD _PROTOTYPE( void w_geometry, (struct partition *entry));
18932
18933
18934 /* Entry points to this driver. */
18935 PRIVATE struct driver w_dtab = {
18936 w_name, /* current device's name */
18937 w_do_open, /* open or mount request, initialize device */
18938 w_do_close, /* release device */
18939 do_diocntl, /* get or set a partition's geometry */
18940 w_prepare, /* prepare for I/O on a given minor device */
18941 w_schedule, /* precompute cylinder, head, sector, etc. */
18942 w_finish, /* do the I/O */
18943 nop_cleanup, /* no cleanup needed */
18944 w_geometry /* tell the geometry of the disk */
18945 };
18946
18947
18948 /*===========================================================================*
18949 * esdi_winchester_task *
18950 *===========================================================================*/
18951 PUBLIC void esdi_winchester_task()
18952 {
18953 driver_task(&w_dtab);
18954 }
18957 /*===========================================================================*
18958 * w_prepare *
18959 *===========================================================================*/
18960 PRIVATE struct device *w_prepare(device)
18961 int device;
18962 {
18963 /* Prepare for I/O on a device. */
18964
18965 /* Nothing to transfer as yet. */
18966 w_count = 0;
18967
18968 if (device < NR_DEVICES) { /* hd0, hd1, ... */
18969 w_drive = device / DEV_PER_DRIVE; /* save drive number */
18970 w_wn = &wini[w_drive];
18971 w_dv = &w_wn->part[device % DEV_PER_DRIVE];
18972 } else
18973 if ((unsigned) (device -= MINOR_hd1a) < NR_SUBDEVS) { /* hd1a, hd1b, ... */
18974 w_drive = device / SUB_PER_DRIVE;
18975 w_wn = &wini[w_drive];
18976 w_dv = &w_wn->subpart[device % SUB_PER_DRIVE];
18977 } else {
18978 return(NIL_DEV);
18979 }
18980 return(w_drive < nr_drives ? w_dv : NIL_DEV);
18981 }
18984 /*===========================================================================*
18985 * w_name *
18986 *===========================================================================*/
18987 PRIVATE char *w_name()
18988 {
18989 /* Return a name for the current device. */
18990 static char name[] = "esdi-hd5";
18991
18992 name[7] = '0' + w_drive * DEV_PER_DRIVE;
18993 return name;
18994 }
18997 /*============================================================================*
18998 * w_do_open *
18999 *============================================================================*/
19000 PRIVATE int w_do_open(dp, m_ptr)
19001 struct driver *dp;
19002 message *m_ptr;
19003 {
19004 /* Device open: Initialize the controller and read the partition table. */
19005
19006 static int init_done = FALSE;
19007
19008 if (!init_done) { w_init(); init_done = TRUE; }
19009
19010 if (w_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
19011
19012 if (w_wn->open_ct++ == 0) {
19013 /* partition the disk */
19014 partition(&w_dtab, w_drive * DEV_PER_DRIVE, P_PRIMARY);
19015 }
19016 return(OK);
19017 }
19020 /*============================================================================*
19021 * w_do_close *
19022 *============================================================================*/
19023 PRIVATE int w_do_close(dp, m_ptr)
19024 struct driver *dp;
19025 message *m_ptr;
19026 {
19027 /* Device close: Release a device. */
19028
19029 if (w_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
19030 w_wn->open_ct--;
19031 return(OK);
19032 }
19035 /*============================================================================*
19036 * w_init *
19037 *============================================================================*/
19038 PRIVATE void w_init()
19039 {
19040 /* initializes everything needed to run the hard disk
19041 *
19042 * the following items are initialized:
19043 * -- hard disk attributes stored in bios
19044 * -- dma transfer channel, read from system register
19045 * -- dma transfer and interrupts [disabled]
19046 *
19047 * the hard disk adapter is initialized when the ibm ps/2 is turned on,
19048 * using the programmable option select registers. thus the only
19049 * additional initialization is making sure the dma transfer and interrupts
19050 * are disabled. other initialization problems could be checked for, such
19051 * as an operation underway. the paranoid could add a check for adapter
19052 * activity and abort the operations. the truly paranoid can reset the
19053 * adapter. until such worries are proven, why bother?
19054 */
19055 unsigned int drive; /* hard disk drive number */
19056 unsigned long size; /* hard disk size */
19057
19058 /* get the number of drives from the bios */
19059 phys_copy(0x475L, tmp_phys, 1L);
19060 nr_drives = tmp_buf[0];
19061 if (nr_drives > MAX_DRIVES) nr_drives = MAX_DRIVES;
19062
19063 put_irq_handler(AT_WINI_IRQ, w_handler);
19064 enable_irq(AT_WINI_IRQ); /* ready for winchester interrupts */
19065
19066 for (drive = 0; drive < nr_drives; ++drive) {
19067 (void) w_prepare(drive * DEV_PER_DRIVE);
19068 if (w_command(drive, 0x0609, 6) != OK) {
19069 printf("%s: unable to get parametersn", w_name());
19070 nr_drives = drive;
19071 break;
19072 }
19073 /* size of the drive */
19074 size = ((unsigned long) status_block[2] << 0) |
19075 ((unsigned long) status_block[3] << 16);
19076 if (drive == 0) {
19077 if (w_command(7, 0x060A, 5) != OK) {
19078 printf("%s: unable to get dma channeln", w_name());
19079 nr_drives = 0;
19080 return;
19081 }
19082 dma_channel = (status_block[2] & 0x3C00) >> 10;
19083 }
19084 printf("%s: %lu sectorsn", w_name(), size);
19085 w_wn->part[0].dv_size = size << SECTOR_SHIFT;
19086 }
19087 }
19090 /*===========================================================================*
19091 * w_command *
19092 *===========================================================================*/
19093 PRIVATE int w_command(device, cmd, num_words)
19094 int device; /* i device to operate on */
19095 /* 1-2 physical disk drive number */
19096 /* 7 hard disk controller */
19097 int cmd; /* i command to execute */
19098 int num_words; /* i expected size of status block */
19099 {
19100 /* executes a command for a particular device
19101 *
19102 * the operation is conducted as follows:
19103 * -- create the command block
19104 * -- initialize for command reading by the controller
19105 * -- write the command block to the controller, making sure the
19106 * controller has digested the previous command word, before shoving
19107 * the next down its throat
19108 * -- wait for an interrupt
19109 * -- read expected number of words of command status information
19110 * -- return the command status block
19111 *
19112 * reading and writing registers is accompanied by enabling and disabling
19113 * interrupts to ensure that the status register contents still apply when
19114 * the desired register is read/written.
19115 */
19116 register int ki; /* -- scratch -- */
19117 int status; /* disk adapter status register value */
19118
19119 device <<= 5; /* adjust device for our use */
19120 command[0] = cmd | device; /* build command block */
19121 command[1] = 0;
19122
19123 w_att_write(device | ATT_CMD);
19124
19125 for (ki = 0; ki < 2; ++ki) {
19126 out_word(CMD_REG, command[ki]);
19127 unlock();
19128 while (TRUE) {
19129 lock();
19130 status = in_byte(BST_REG);
19131 if (!(status & CMD_FUL)) break;
19132 unlock();
19133 }
19134 }
19135 unlock();
19136
19137 w_interrupt(0);
19138 if (w_istat != (device | 0x01)) {
19139 w_att_write(device | ATT_ABT);
19140 w_interrupt(0);
19141 return(ERR);
19142 }
19143 for (ki = 0; ki < num_words; ++ki) {
19144 while (TRUE) {
19145 lock();
19146 status = in_byte(BST_REG);
19147 if (status & STR_FUL) break;
19148 unlock();
19149 }
19150 status_block[ki] = in_word(STAT_REG);
19151 unlock();
19152 }
19153 w_att_write(device | ATT_EOI);
19154
19155 return(OK);
19156 }
19159 /*===========================================================================*
19160 * w_schedule *
19161 *===========================================================================*/
19162 PRIVATE int w_schedule(proc_nr, iop)
19163 int proc_nr; /* process doing the request */
19164 struct iorequest_s *iop; /* pointer to read or write request */
19165 {
19166 /* Gather I/O requests on consecutive blocks so they may be read/written
19167 * in one command if using a buffer. Check and gather all the requests
19168 * and try to finish them as fast as possible if unbuffered.
19169 */
19170 int r, opcode;
19171 unsigned long pos;
19172 unsigned nbytes, count;
19173 unsigned long block;
19174 phys_bytes user_phys, dma_phys;
19175
19176 /* This many bytes to read/write */
19177 nbytes = iop->io_nbytes;
19178 if ((nbytes & SECTOR_MASK) != 0) return(iop->io_nbytes = EINVAL);
19179
19180 /* From/to this position on the device */
19181 pos = iop->io_position;
19182 if ((pos & SECTOR_MASK) != 0) return(iop->io_nbytes = EINVAL);
19183
19184 /* To/from this user address */
19185 user_phys = numap(proc_nr, (vir_bytes) iop->io_buf, nbytes);
19186 if (user_phys == 0) return(iop->io_nbytes = EINVAL);
19187
19188 /* Read or write? */
19189 opcode = iop->io_request & ~OPTIONAL_IO;
19190
19191 /* Which block on disk and how close to EOF? */
19192 if (pos >= w_dv->dv_size) return(OK); /* At EOF */
19193 if (pos + nbytes > w_dv->dv_size) nbytes = w_dv->dv_size - pos;
19194 block = (w_dv->dv_base + pos) >> SECTOR_SHIFT;
19195
19196 if (USE_BUF && w_count > 0 && block != w_nextblock) {
19197 /* This new request can't be chained to the job being built */
19198 if ((r = w_finish()) != OK) return(r);
19199 }
19200
19201 /* The next consecutive block */
19202 if (USE_BUF) w_nextblock = block + (nbytes >> SECTOR_SHIFT);
19203
19204 /* While there are "unscheduled" bytes in the request: */
19205 do {
19206 count = nbytes;
19207
19208 if (USE_BUF) {
19209 if (w_count == DMA_BUF_SIZE) {
19210 /* Can't transfer more than the buffer allows. */
19211 if ((r = w_finish()) != OK) return(r);
19212 }
19213
19214 if (w_count + count > DMA_BUF_SIZE)
19215 count = DMA_BUF_SIZE - w_count;
19216 } else {
19217 if (w_tp == wtrans + NR_IOREQS) {
19218 /* All transfer slots in use. */
19219 if ((r = w_finish()) != OK) return(r);
19220 }
19221 }
19222
19223 if (w_count == 0) {
19224 /* The first request in a row, initialize. */
19225 w_opcode = opcode;
19226 w_tp = wtrans;
19227 }
19228
19229 if (USE_BUF) {
19230 dma_phys = tmp_phys + w_count;
19231 } else {
19232 /* Note: No 64K boundary problem, the better PS/2's have a
19233 * working DMA chip.
19234 */
19235 dma_phys = user_phys;
19236 }
19237
19238 /* Store I/O parameters */
19239 w_tp->iop = iop;
19240 w_tp->block = block;
19241 w_tp->count = count;
19242 w_tp->phys = user_phys;
19243 w_tp->dma = dma_phys;
19244
19245 /* Update counters */
19246 w_tp++;
19247 w_count += count;
19248 block += count >> SECTOR_SHIFT;
19249 user_phys += count;
19250 nbytes -= count;
19251 } while (nbytes > 0);
19252
19253 return(OK);
19254 }
19257 /*===========================================================================*
19258 * w_finish *
19259 *===========================================================================*/
19260 PRIVATE int w_finish()
19261 {
19262 /* carries out the I/O requests gathered in wtrans[]
19263 *
19264 * fills the disk information structure for one block at a time or many
19265 * in a row before calling 'w_transfer' to do the dirty work. while
19266 * unsuccessful operations are re-tried, this may be superfluous, since
19267 * the controller does the same on its own. turns on the fixed disk
19268 * activity light, while busy. computers need blinking lights, right?
19269 */
19270
19271 struct trans *tp = wtrans, *tp2;
19272 unsigned count;
19273 int r, errors = 0, many = USE_BUF;
19274
19275 if (w_count == 0) return(OK); /* Spurious finish. */
19276
19277 do {
19278 if (w_opcode == DEV_WRITE) {
19279 tp2 = tp;
19280 count = 0;
19281 do {
19282 if (USE_BUF || tp2->dma == tmp_phys) {
19283 phys_copy(tp2->phys, tp2->dma,
19284 (phys_bytes) tp2->count);
19285 }
19286 count += tp2->count;
19287 tp2++;
19288 } while (many && count < w_count);
19289 } else {
19290 count = many ? w_count : tp->count;
19291 }
19292
19293 /* Turn on the disk activity light. */
19294 out_byte(SYS_PORTA, in_byte(SYS_PORTA) | LIGHT_ON);
19295
19296 /* Perform the transfer. */
19297 r = w_transfer(tp, count);
19298
19299 /* Turn off the disk activity light. */
19300 out_byte(SYS_PORTA, in_byte(SYS_PORTA) & ~LIGHT_ON);
19301
19302 if (r != OK) {
19303 /* An error occurred, try again block by block unless */
19304 if (r == ERR_BAD_SECTOR || ++errors == MAX_ERRORS)
19305 return(tp->iop->io_nbytes = EIO);
19306
19307 many = 0;
19308 continue;
19309 }
19310 errors = 0;
19311
19312 w_count -= count;
19313
19314 do {
19315 if (w_opcode == DEV_READ) {
19316 if (USE_BUF || tp->dma == tmp_phys) {
19317 phys_copy(tp->dma, tp->phys,
19318 (phys_bytes) tp->count);
19319 }
19320 }
19321 tp->iop->io_nbytes -= tp->count;
19322 count -= tp->count;
19323 tp++;
19324 } while (count > 0);
19325 } while (w_count > 0);
19326
19327 return(OK);
19328 }
19331 /*===========================================================================*
19332 * w_transfer *
19333 *===========================================================================*/
19334 PRIVATE int w_transfer(tp, count)
19335 struct trans *tp; /* pointer to the transfer struct */
19336 unsigned int count; /* bytes to transfer */
19337 {
19338 /* reads/writes a single block of data from/to the hard disk
19339 *
19340 * the read/write operation performs the following steps:
19341 * -- create the command block
19342 * -- initialize the command reading by the controller
19343 * -- write the command block to the controller, making sure the
19344 * controller has digested the previous command word, before
19345 * shoving the next down its throat.
19346 * -- wait for an interrupt, which must return a 'data transfer ready'
19347 * status. abort the command if it doesn't.
19348 * -- set up and start up the direct memory transfer
19349 * -- wait for an interrupt, signalling the end of the transfer
19350 */
19351 int device; /* device mask for the command register */
19352 int ki; /* -- scratch -- */
19353 int status; /* basic status register value */
19354
19355 device = w_drive << 5;
19356 command[0] = (w_opcode == DEV_WRITE ? 0x4602 : 0x4601) | device;
19357 command[1] = count >> SECTOR_SHIFT;
19358 command[2] = (int) (tp->block & 0xFFFF);
19359 command[3] = (int) (tp->block >> 16);
19360
19361 w_att_write(device | ATT_CMD);
19362
19363 for (ki = 0; ki < 4; ++ki) {
19364 out_word(CMD_REG, command[ki]);
19365 unlock();
19366 while (TRUE) {
19367 lock();
19368 status = in_byte(BST_REG);
19369 if (!(status & CMD_FUL)) break;
19370 unlock();
19371 }
19372 }
19373 unlock();
19374
19375 w_interrupt(0);
19376 if (w_istat != (device | 0x0B)) {
19377 w_att_write(device | ATT_ABT);
19378 w_interrupt(0);
19379 return(ERR);
19380 }
19381 w_dma_setup(tp, count);
19382
19383 w_interrupt(1);
19384
19385 w_att_write(device | ATT_EOI);
19386
19387 if ((w_istat & 0x0F) > 8) return(ERR);
19388 return(OK);
19389 }
19393 /*==========================================================================*
19394 * w_att_write *
19395 *==========================================================================*/
19396 PRIVATE int w_att_write(value)
19397 register int value;
19398 {
19399 /* writes a command to the esdi attention register
19400 *
19401 * waits for the controller to finish its business before sending the
19402 * command to the controller. note that the interrupts must be off to read
19403 * the basic status register and, if the controller is ready, must not be
19404 * turned back on until the attention register command is sent.
19405 */
19406 int status; /* basic status register value */
19407
19408 while (TRUE) {
19409 lock();
19410 status = in_byte(BST_REG);
19411 if (!(status & (INT_PND | BUSY))) break;
19412 unlock();
19413 }
19414 out_byte(ATT_REG, value);
19415 unlock();
19416
19417 return(OK);
19418 }
19422 /*===========================================================================*
19423 * w_interrupt *
19424 *===========================================================================*/
19425 PRIVATE void w_interrupt(dma)
19426 int dma; /* i dma transfer is underway */
19427 {
19428 /* waits for an interrupt from the hard disk controller
19429 *
19430 * enable interrupts on the hard disk and interrupt controllers (and dma if
19431 * necessary). wait for an interrupt. when received, return the interrupt
19432 * status register value.
19433 *
19434 * an interrupt can be detected either from the basic status register or
19435 * through a system interrupt handler. the handler is used for all
19436 * interrupts, due to the expected long times to process reads and writes
19437 * and to avoid busy waits.
19438 */
19439 message dummy; /* -- scratch -- */
19440
19441 out_byte(BCTL_REG, dma ? 0x03 : 0x01);
19442
19443 receive(HARDWARE, &dummy);
19444
19445 out_byte(BCTL_REG, 0);
19446 if (dma) out_byte(DMA_EXTCMD, 0x90 + dma_channel);
19447 }
19451 /*==========================================================================*
19452 * w_handler *
19453 *==========================================================================*/
19454 PRIVATE int w_handler(irq)
19455 int irq;
19456 {
19457 /* Disk interrupt, send message to winchester task and reenable interrupts. */
19458
19459 w_istat = in_byte(INT_REG);
19460 interrupt(WINCHESTER);
19461 return 1;
19462 }
19466 /*==========================================================================*
19467 * w_dma_setup *
19468 *==========================================================================*/
19469 PRIVATE void w_dma_setup(tp, count)
19470 struct trans *tp;
19471 unsigned int count;
19472 {
19473 /* programs the dma controller to move data to and from the hard disk.
19474 *
19475 * uses the extended mode operation of the ibm ps/2 interrupt controller
19476 * chip, rather than the intel 8237 (pc/at) compatible mode.
19477 */
19478
19479 lock();
19480 out_byte(DMA_EXTCMD, 0x90 + dma_channel);
19481 /* Disable access to dma channel 5 */
19482 out_byte(DMA_EXTCMD, 0x20 + dma_channel);
19483 /* Clear the address byte pointer */
19484 out_byte(DMA_EXEC, (int) tp->dma >> 0); /* address bits 0..7 */
19485 out_byte(DMA_EXEC, (int) tp->dma >> 8); /* address bits 8..15 */
19486 out_byte(DMA_EXEC, (int) (tp->dma >> 16)); /* address bits 16..19 */
19487 out_byte(DMA_EXTCMD, 0x40 + dma_channel);
19488 /* Clear the count byte pointer */
19489 out_byte(DMA_EXEC, (count - 1) >> 0); /* count bits 0..7 */
19490 out_byte(DMA_EXEC, (count - 1) >> 8); /* count bits 8..15 */
19491 out_byte(DMA_EXTCMD, 0x70 + dma_channel);
19492 /* Set the transfer mode */
19493 out_byte(DMA_EXEC, w_opcode == DEV_WRITE ? 0x44 : 0x4C);
19494 out_byte(DMA_EXTCMD, 0xA0 + dma_channel);
19495 /* Enable access to dma channel 5 */
19496 unlock();
19497 }
19500 /*============================================================================*
19501 * w_geometry *
19502 *============================================================================*/
19503 PRIVATE void w_geometry(entry)
19504 struct partition *entry;
19505 {
19506 entry->cylinders = (w_wn->part[0].dv_size >> SECTOR_SHIFT) / (64 * 32);
19507 entry->heads = 64;
19508 entry->sectors = 32;
19509 }
19510 #endif /* ENABLE_ESDI_WINI */
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/kernel/exception.c
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
19600 /* This file contains a simple exception handler. Exceptions in user
19601 * processes are converted to signals. Exceptions in the kernel, MM and
19602 * FS cause a panic.
19603 */
19604
19605 #include "kernel.h"
19606 #include <signal.h>
19607 #include "proc.h"
19608
19609 /*==========================================================================*
19610 * exception *
19611 *==========================================================================*/
19612 PUBLIC void exception(vec_nr)
19613 unsigned vec_nr;
19614 {
19615 /* An exception or unexpected interrupt has occurred. */
19616
19617 struct ex_s {
19618 char *msg;
19619 int signum;
19620 int minprocessor;
19621 };
19622 static struct ex_s ex_data[] = {
19623 "Divide error", SIGFPE, 86,
19624 "Debug exception", SIGTRAP, 86,
19625 "Nonmaskable interrupt", SIGBUS, 86,
19626 "Breakpoint", SIGEMT, 86,
19627 "Overflow", SIGFPE, 86,
19628 "Bounds check", SIGFPE, 186,
19629 "Invalid opcode", SIGILL, 186,
19630 "Coprocessor not available", SIGFPE, 186,
19631 "Double fault", SIGBUS, 286,
19632 "Copressor segment overrun", SIGSEGV, 286,
19633 "Invalid TSS", SIGSEGV, 286,
19634 "Segment not present", SIGSEGV, 286,
19635 "Stack exception", SIGSEGV, 286, /* STACK_FAULT already used */
19636 "General protection", SIGSEGV, 286,
19637 "Page fault", SIGSEGV, 386, /* not close */
19638 NIL_PTR, SIGILL, 0, /* probably software trap */
19639 "Coprocessor error", SIGFPE, 386,
19640 };
19641 register struct ex_s *ep;
19642 struct proc *saved_proc;
19643
19644 saved_proc= proc_ptr; /* Save proc_ptr, because it may be changed by debug
19645 * statements.
19646 */
19647
19648 ep = &ex_data[vec_nr];
19649
19650 if (vec_nr == 2) { /* spurious NMI on some machines */
19651 printf("got spurious NMIn");
19652 return;
19653 }
19654
19655 if (k_reenter == 0 && isuserp(saved_proc)) {
19656 unlock(); /* this is protected like sys_call() */
19657 cause_sig(proc_number(saved_proc), ep->signum);
19658 return;
19659 }
19660
19661 /* This is not supposed to happen. */
19662 if (ep->msg == NIL_PTR || processor < ep->minprocessor)
19663 printf("nIntel-reserved exception %dn", vec_nr);
19664 else
19665 printf("n%sn", ep->msg);
19666 printf("process number %d, pc = 0x%04x:0x%08xn",
19667 proc_number(saved_proc),
19668 (unsigned) saved_proc->p_reg.cs,
19669 (unsigned) saved_proc->p_reg.pc);
19670 panic("exception in system code", NO_NUM);
19671 }
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/kernel/floppy.c
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
19700 /* This file contains the device dependent part of the driver for the Floppy
19701 * Disk Controller (FDC) using the NEC PD765 chip.
19702 *
19703 * The file contains one entry point:
19704 *
19705 * floppy_task: main entry when system is brought up
19706 * floppy_stop: stop all activity
19707 *
19708 * Changes:
19709 * 27 Oct. 1986 by Jakob Schripsema: fdc_results fixed for 8 MHz
19710 * 28 Nov. 1986 by Peter Kay: better resetting for 386
19711 * 06 Jan. 1988 by Al Crew: allow 1.44 MB diskettes
19712 * 1989 by Bruce Evans: I/O vector to keep up with 1-1 interleave
19713 * 13 May 1991 by Don Chapman: renovated the errors loop.
19714 * 1991 by Bruce Evans: len[] / motors / reset / step rate / ...
19715 * 14 Feb 1992 by Andy Tanenbaum: check drive density on opens only
19716 * 27 Mar 1992 by Kees J. Bot: last details on density checking
19717 * 04 Apr 1992 by Kees J. Bot: device dependent/independent split
19718 */
19719
19720 #include "kernel.h"
19721 #include "driver.h"
19722 #include "drvlib.h"
19723 #include <ibm/diskparm.h>
19724
19725 /* I/O Ports used by floppy disk task. */
19726 #define DOR 0x3F2 /* motor drive control bits */
19727 #define FDC_STATUS 0x3F4 /* floppy disk controller status register */
19728 #define FDC_DATA 0x3F5 /* floppy disk controller data register */
19729 #define FDC_RATE 0x3F7 /* transfer rate register */
19730 #define DMA_ADDR 0x004 /* port for low 16 bits of DMA address */
19731 #define DMA_TOP 0x081 /* port for top 4 bits of 20-bit DMA addr */
19732 #define DMA_COUNT 0x005 /* port for DMA count (count = bytes - 1) */
19733 #define DMA_FLIPFLOP 0x00C /* DMA byte pointer flip-flop */
19734 #define DMA_MODE 0x00B /* DMA mode port */
19735 #define DMA_INIT 0x00A /* DMA init port */
19736 #define DMA_RESET_VAL 0x06
19737
19738 /* Status registers returned as result of operation. */
19739 #define ST0 0x00 /* status register 0 */
19740 #define ST1 0x01 /* status register 1 */
19741 #define ST2 0x02 /* status register 2 */
19742 #define ST3 0x00 /* status register 3 (return by DRIVE_SENSE) */
19743 #define ST_CYL 0x03 /* slot where controller reports cylinder */
19744 #define ST_HEAD 0x04 /* slot where controller reports head */
19745 #define ST_SEC 0x05 /* slot where controller reports sector */
19746 #define ST_PCN 0x01 /* slot where controller reports present cyl */
19747
19748 /* Fields within the I/O ports. */
19749 /* Main status register. */
19750 #define CTL_BUSY 0x10 /* bit is set when read or write in progress */
19751 #define DIRECTION 0x40 /* bit is set when reading data reg is valid */
19752 #define MASTER 0x80 /* bit is set when data reg can be accessed */
19753
19754 /* Digital output port (DOR). */
19755 #define MOTOR_SHIFT 4 /* high 4 bits control the motors in DOR */
19756 #define ENABLE_INT 0x0C /* used for setting DOR port */
19757
19758 /* ST0. */
19759 #define ST0_BITS 0xF8 /* check top 5 bits of seek status */
19760 #define TRANS_ST0 0x00 /* top 5 bits of ST0 for READ/WRITE */
19761 #define SEEK_ST0 0x20 /* top 5 bits of ST0 for SEEK */
19762
19763 /* ST1. */
19764 #define BAD_SECTOR 0x05 /* if these bits are set in ST1, recalibrate */
19765 #define WRITE_PROTECT 0x02 /* bit is set if diskette is write protected */
19766
19767 /* ST2. */
19768 #define BAD_CYL 0x1F /* if any of these bits are set, recalibrate */
19769
19770 /* ST3 (not used). */
19771 #define ST3_FAULT 0x80 /* if this bit is set, drive is sick */
19772 #define ST3_WR_PROTECT 0x40 /* set when diskette is write protected */
19773 #define ST3_READY 0x20 /* set when drive is ready */
19774
19775 /* Floppy disk controller command bytes. */
19776 #define FDC_SEEK 0x0F /* command the drive to seek */
19777 #define FDC_READ 0xE6 /* command the drive to read */
19778 #define FDC_WRITE 0xC5 /* command the drive to write */
19779 #define FDC_SENSE 0x08 /* command the controller to tell its status */
19780 #define FDC_RECALIBRATE 0x07 /* command the drive to go to cyl 0 */
19781 #define FDC_SPECIFY 0x03 /* command the drive to accept params */
19782 #define FDC_READ_ID 0x4A /* command the drive to read sector identity */
19783 #define FDC_FORMAT 0x4D /* command the drive to format a track */
19784
19785 /* DMA channel commands. */
19786 #define DMA_READ 0x46 /* DMA read opcode */
19787 #define DMA_WRITE 0x4A /* DMA write opcode */
19788
19789 /* Parameters for the disk drive. */
19790 #define HC_SIZE 2880 /* # sectors on largest legal disk (1.44MB) */
19791 #define NR_HEADS 0x02 /* two heads (i.e., two tracks/cylinder) */
19792 #define MAX_SECTORS 18 /* largest # sectors per track */
19793 #define DTL 0xFF /* determines data length (sector size) */
19794 #define SPEC2 0x02 /* second parameter to SPECIFY */
19795 #define MOTOR_OFF 3*HZ /* how long to wait before stopping motor */
19796 #define WAKEUP 2*HZ /* timeout on I/O, FDC won't quit. */
19797
19798 /* Error codes */
19799 #define ERR_SEEK (-1) /* bad seek */
19800 #define ERR_TRANSFER (-2) /* bad transfer */
19801 #define ERR_STATUS (-3) /* something wrong when getting status */
19802 #define ERR_READ_ID (-4) /* bad read id */
19803 #define ERR_RECALIBRATE (-5) /* recalibrate didn't work properly */
19804 #define ERR_DRIVE (-6) /* something wrong with a drive */
19805 #define ERR_WR_PROTECT (-7) /* diskette is write protected */
19806 #define ERR_TIMEOUT (-8) /* interrupt timeout */
19807
19808 /* No retries on some errors. */
19809 #define err_no_retry(err) ((err) <= ERR_WR_PROTECT)
19810
19811 /* Encoding of drive type in minor device number. */
19812 #define DEV_TYPE_BITS 0x7C /* drive type + 1, if nonzero */
19813 #define DEV_TYPE_SHIFT 2 /* right shift to normalize type bits */
19814 #define FORMAT_DEV_BIT 0x80 /* bit in minor to turn write into format */
19815
19816 /* Miscellaneous. */
19817 #define MAX_ERRORS 6 /* how often to try rd/wt before quitting */
19818 #define MAX_RESULTS 7 /* max number of bytes controller returns */
19819 #define NR_DRIVES 2 /* maximum number of drives */
19820 #define DIVISOR 128 /* used for sector size encoding */
19821 #define SECTOR_SIZE_CODE 2 /* code to say "512" to the controller */
19822 #define TIMEOUT 500 /* milliseconds waiting for FDC */
19823 #define NT 7 /* number of diskette/drive combinations */
19824 #define UNCALIBRATED 0 /* drive needs to be calibrated at next use */
19825 #define CALIBRATED 1 /* no calibration needed */
19826 #define BASE_SECTOR 1 /* sectors are numbered starting at 1 */
19827 #define NO_SECTOR 0 /* current sector unknown */
19828 #define NO_CYL (-1) /* current cylinder unknown, must seek */
19829 #define NO_DENS 100 /* current media unknown */
19830 #define BSY_IDLE 0 /* busy doing nothing */
19831 #define BSY_IO 1 /* doing I/O */
19832 #define BSY_WAKEN 2 /* got a wakeup call */
19833
19834 /* Variables. */
19835 PRIVATE struct floppy { /* main drive struct, one entry per drive */
19836 int fl_curcyl; /* current cylinder */
19837 int fl_hardcyl; /* hardware cylinder, as opposed to: */
19838 int fl_cylinder; /* cylinder number addressed */
19839 int fl_sector; /* sector addressed */
19840 int fl_head; /* head number addressed */
19841 char fl_calibration; /* CALIBRATED or UNCALIBRATED */
19842 char fl_density; /* NO_DENS = ?, 0 = 360K; 1 = 360K/1.2M; etc.*/
19843 char fl_class; /* bitmap for possible densities */
19844 struct device fl_geom; /* Geometry of the drive */
19845 struct device fl_part[NR_PARTITIONS]; /* partition's base & size */
19846 } floppy[NR_DRIVES], *f_fp;
19847
19848 /* Gather transfer data for each sector. */
19849 PRIVATE struct trans { /* precomputed transfer params */
19850 unsigned tr_count; /* byte count */
19851 struct iorequest_s *tr_iop; /* belongs to this I/O request */
19852 phys_bytes tr_phys; /* user physical address */
19853 phys_bytes tr_dma; /* DMA physical address */
19854 } ftrans[MAX_SECTORS];
19855
19856 PRIVATE unsigned f_count; /* this many bytes to transfer */
19857 PRIVATE unsigned f_nexttrack; /* don't do blocks above this */
19858 PRIVATE int motor_status; /* bitmap of current motor status */
19859 PRIVATE int motor_goal; /* bitmap of desired motor status */
19860 PRIVATE int need_reset; /* set to 1 when controller must be reset */
19861 PRIVATE int d; /* diskette/drive combination */
19862 PRIVATE int f_drive; /* selected drive */
19863 PRIVATE int f_device; /* selected minor device */
19864 PRIVATE int f_opcode; /* DEV_READ or DEV_WRITE */
19865 PRIVATE int f_sectors; /* sectors per track of the floppy */
19866 PRIVATE int f_must; /* must do part of the next track? */
19867 PRIVATE int f_busy; /* BSY_IDLE, BSY_IO, BSY_WAKEN */
19868 PRIVATE int current_spec1; /* latest spec1 sent to the controller */
19869 PRIVATE struct device *f_dv; /* device's base and size */
19870 PRIVATE struct disk_parameter_s fmt_param; /* parameters for format */
19871 PRIVATE char f_results[MAX_RESULTS];/* the controller can give lots of output */
19872
19873
19874 /* Seven combinations of diskette/drive are supported.
19875 *
19876 * # Drive diskette Sectors Tracks Rotation Data-rate Comment
19877 * 0 360K 360K 9 40 300 RPM 250 kbps Standard PC DSDD
19878 * 1 1.2M 1.2M 15 80 360 RPM 500 kbps AT disk in AT drive
19879 * 2 720K 360K 9 40 300 RPM 250 kbps Quad density PC
19880 * 3 720K 720K 9 80 300 RPM 250 kbps Toshiba, et al.
19881 * 4 1.2M 360K 9 40 360 RPM 300 kbps PC disk in AT drive
19882 * 5 1.2M 720K 9 80 360 RPM 300 kbps Toshiba in AT drive
19883 * 6 1.44M 1.44M 18 80 300 RPM 500 kbps PS/2, et al.
19884 *
19885 * In addition, 720K diskettes can be read in 1.44MB drives, but that does
19886 * not need a different set of parameters. This combination uses
19887 *
19888 * X 1.44M 720K 9 80 300 RPM 250 kbps PS/2, et al.
19889 */
19890 PRIVATE char gap[NT] =
19891 {0x2A, 0x1B, 0x2A, 0x2A, 0x23, 0x23, 0x1B}; /* gap size */
19892 PRIVATE char rate[NT] =
19893 {0x02, 0x00, 0x02, 0x02, 0x01, 0x01, 0x00}; /* 2=250,1=300,0=500 kbps*/
19894 PRIVATE char nr_sectors[NT] =
19895 {9, 15, 9, 9, 9, 9, 18}; /* sectors/track */
19896 PRIVATE int nr_blocks[NT] =
19897 {720, 2400, 720, 1440, 720, 1440, 2880}; /* sectors/diskette*/
19898 PRIVATE char steps_per_cyl[NT] =
19899 {1, 1, 2, 1, 2, 1, 1}; /* 2 = dbl step */
19900 PRIVATE char mtr_setup[NT] =
19901 {1*HZ/4,3*HZ/4,1*HZ/4,4*HZ/4,3*HZ/4,3*HZ/4,4*HZ/4}; /* in ticks */
19902 PRIVATE char spec1[NT] =
19903 {0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF}; /* step rate, etc. */
19904 PRIVATE char test_sector[NT] =
19905 {4*9, 14, 2*9, 4*9, 2*9, 4*9, 17}; /* to recognize it */
19906
19907 #define b(d) (1 << (d)) /* bit for density d. */
19908
19909 /* The following table is used with the test_sector array to recognize a
19910 * drive/floppy combination. The sector to test has been determined by
19911 * looking at the differences in gap size, sectors/track, and double stepping.
19912 * This means that types 0 and 3 can't be told apart, only the motor start
19913 * time differs. If a read test succeeds then the drive is limited to the
19914 * set of densities it can support to avoid unnecessary tests in the future.
19915 */
19916
19917 PRIVATE struct test_order {
19918 char t_density; /* floppy/drive type */
19919 char t_class; /* limit drive to this class of densities */
19920 } test_order[NT-1] = {
19921 { 6, b(3) | b(6) }, /* 1.44M {720K, 1.44M} */
19922 { 1, b(1) | b(4) | b(5) }, /* 1.2M {1.2M, 360K, 720K} */
19923 { 3, b(2) | b(3) | b(6) }, /* 720K {360K, 720K, 1.44M} */
19924 { 4, b(1) | b(4) | b(5) }, /* 360K {1.2M, 360K, 720K} */
19925 { 5, b(1) | b(4) | b(5) }, /* 720K {1.2M, 360K, 720K} */
19926 { 2, b(2) | b(3) }, /* 360K {360K, 720K} */
19927 /* Note that type 0 is missing, type 3 can read/write it too (alas). */
19928 };
19929
19930 FORWARD _PROTOTYPE( struct device *f_prepare, (int device) );
19931 FORWARD _PROTOTYPE( char *f_name, (void) );
19932 FORWARD _PROTOTYPE( void f_cleanup, (void) );
19933 FORWARD _PROTOTYPE( int f_schedule, (int proc_nr, struct iorequest_s *iop) );
19934 FORWARD _PROTOTYPE( int f_finish, (void) );
19935 FORWARD _PROTOTYPE( void defuse, (void) );
19936 FORWARD _PROTOTYPE( void dma_setup, (struct trans *tp) );
19937 FORWARD _PROTOTYPE( void start_motor, (void) );
19938 FORWARD _PROTOTYPE( void stop_motor, (void) );
19939 FORWARD _PROTOTYPE( int seek, (struct floppy *fp) );
19940 FORWARD _PROTOTYPE( int f_transfer, (struct floppy *fp, struct trans *tp) );
19941 FORWARD _PROTOTYPE( int fdc_results, (void) );
19942 FORWARD _PROTOTYPE( int f_handler, (int irq) );
19943 FORWARD _PROTOTYPE( void fdc_out, (int val) );
19944 FORWARD _PROTOTYPE( int recalibrate, (struct floppy *fp) );
19945 FORWARD _PROTOTYPE( void f_reset, (void) );
19946 FORWARD _PROTOTYPE( void send_mess, (void) );
19947 FORWARD _PROTOTYPE( int f_intr_wait, (void) );
19948 FORWARD _PROTOTYPE( void f_timeout, (void) );
19949 FORWARD _PROTOTYPE( int read_id, (struct floppy *fp) );
19950 FORWARD _PROTOTYPE( int f_do_open, (struct driver *dp, message *m_ptr) );
19951 FORWARD _PROTOTYPE( int test_read, (int density) );
19952 FORWARD _PROTOTYPE( void f_geometry, (struct partition *entry));
19953
19954
19955 /* Entry points to this driver. */
19956 PRIVATE struct driver f_dtab = {
19957 f_name, /* current device's name */
19958 f_do_open, /* open or mount request, sense type of diskette */
19959 do_nop, /* nothing on a close */
19960 do_diocntl, /* get or set a partitions geometry */
19961 f_prepare, /* prepare for I/O on a given minor device */
19962 f_schedule, /* precompute cylinder, head, sector, etc. */
19963 f_finish, /* do the I/O */
19964 f_cleanup, /* cleanup before sending reply to user process */
19965 f_geometry /* tell the geometry of the diskette */
19966 };
19967
19968
19969 /*===========================================================================*
19970 * floppy_task *
19971 *===========================================================================*/
19972 PUBLIC void floppy_task()
19973 {
19974 /* Initialize the floppy structure. */
19975
19976 struct floppy *fp;
19977
19978 for (fp = &floppy[0]; fp < &floppy[NR_DRIVES]; fp++) {
19979 fp->fl_curcyl = NO_CYL;
19980 fp->fl_density = NO_DENS;
19981 fp->fl_class = ~0;
19982 }
19983
19984 put_irq_handler(FLOPPY_IRQ, f_handler);
19985 enable_irq(FLOPPY_IRQ); /* ready for floppy interrupts */
19986
19987 driver_task(&f_dtab);
19988 }
19991 /*===========================================================================*
19992 * f_prepare *
19993 *===========================================================================*/
19994 PRIVATE struct device *f_prepare(device)
19995 int device;
19996 {
19997 /* Prepare for I/O on a device. */
19998
19999 /* Leftover jobs after an I/O error must be removed */
20000 if (f_count > 0) defuse();
20001
20002 f_device = device;
20003 f_drive = device & ~(DEV_TYPE_BITS | FORMAT_DEV_BIT);
20004 if (f_drive < 0 || f_drive >= NR_DRIVES) return(NIL_DEV);
20005
20006 f_fp = &floppy[f_drive];
20007 f_dv = &f_fp->fl_geom;
20008 d = f_fp->fl_density;
20009 f_sectors = nr_sectors[d];
20010
20011 f_must = TRUE; /* the first transfers must be done */
20012
20013 /* A partition? */
20014 if ((device &= DEV_TYPE_BITS) >= MINOR_fd0a)
20015 f_dv = &f_fp->fl_part[(device - MINOR_fd0a) >> DEV_TYPE_SHIFT];
20016
20017 return f_dv;
20018 }
20021 /*===========================================================================*
20022 * f_name *
20023 *===========================================================================*/
20024 PRIVATE char *f_name()
20025 {
20026 /* Return a name for the current device. */
20027 static char name[] = "fd3";
20028
20029 name[2] = '0' + f_drive;
20030 return name;
20031 }
20034 /*===========================================================================*
20035 * f_cleanup *
20036 *===========================================================================*/
20037 PRIVATE void f_cleanup()
20038 {
20039 /* Start watchdog timer to turn all motors off in a few seconds.
20040 * There is a race here. An old watchdog might bite before the
20041 * new delay is installed, and turn of the motors prematurely.
20042 * This cannot be solved simply by resetting motor_goal after
20043 * sending the message, because the new watchdog might bite
20044 * before motor_goal is reset. Then the motors would stay on
20045 * until after the next floppy access. This could be fixed with
20046 * extra code (call the clock task twice in some cases). Or
20047 * stop_motor() could be replaced by send_mess(), and send a
20048 * STOP_MOTOR message to be accepted by the clock task. This
20049 * would be slower but have the advantage that this comment could
20050 * be deleted!
20051 *
20052 * Since it is not likely and not serious for an old watchdog to
20053 * bite, accept that possibility for now. A full solution to the
20054 * motor madness requires a lots of extra work anyway, such as
20055 * a separate timer for each motor, and smaller delays for motors
20056 * that have just been turned off or start faster than the spec.
20057 * (is there a motor-ready bit?).
20058 */
20059 motor_goal = 0;
20060 clock_mess(MOTOR_OFF, stop_motor);
20061 }
20064 /*===========================================================================*
20065 * f_schedule *
20066 *===========================================================================*/
20067 PRIVATE int f_schedule(proc_nr, iop)
20068 int proc_nr; /* process doing the request */
20069 struct iorequest_s *iop; /* pointer to read or write request */
20070 {
20071 int r, opcode, spanning;
20072 unsigned long pos;
20073 unsigned block; /* Seen any 32M floppies lately? */
20074 unsigned nbytes, count, dma_count;
20075 phys_bytes user_phys, dma_phys;
20076 struct trans *tp, *tp0;
20077
20078 /* Ignore any alarm to turn motor off, now there is work to do. */
20079 motor_goal = motor_status;
20080
20081 /* This many bytes to read/write */
20082 nbytes = iop->io_nbytes;
20083 if ((nbytes & SECTOR_MASK) != 0) return(iop->io_nbytes = EINVAL);
20084
20085 /* From/to this position on disk */
20086 pos = iop->io_position;
20087 if ((pos & SECTOR_MASK) != 0) return(iop->io_nbytes = EINVAL);
20088
20089 /* To/from this user address */
20090 user_phys = numap(proc_nr, (vir_bytes) iop->io_buf, nbytes);
20091 if (user_phys == 0) return(iop->io_nbytes = EINVAL);
20092
20093 /* Read, write or format? */
20094 opcode = iop->io_request & ~OPTIONAL_IO;
20095 if (f_device & FORMAT_DEV_BIT) {
20096 if (opcode != DEV_WRITE) return(iop->io_nbytes = EIO);
20097 if (nbytes != BLOCK_SIZE) return(iop->io_nbytes = EINVAL);
20098
20099 phys_copy(user_phys + SECTOR_SIZE, vir2phys(&fmt_param),
20100 (phys_bytes) sizeof fmt_param);
20101
20102 /* Check that the number of sectors in the data is reasonable, to
20103 * avoid division by 0. Leave checking of other data to the FDC.
20104 */
20105 if (fmt_param.sectors_per_cylinder == 0)
20106 return(iop->io_nbytes = EIO);
20107
20108 /* Only the first sector of the parameters now needed. */
20109 iop->io_nbytes = nbytes = SECTOR_SIZE;
20110 }
20111
20112 /* Which block on disk and how close to EOF? */
20113 if (pos >= f_dv->dv_size) return(OK); /* At EOF */
20114 if (pos + nbytes > f_dv->dv_size) nbytes = f_dv->dv_size - pos;
20115 block = (f_dv->dv_base + pos) >> SECTOR_SHIFT;
20116
20117 spanning = FALSE; /* set if the block spans a track */
20118
20119 /* While there are "unscheduled" bytes in the request: */
20120 do {
20121 count = nbytes;
20122
20123 if (f_count > 0 && block >= f_nexttrack) {
20124 /* The new job leaves the track, finish all gathered jobs */
20125 if ((r = f_finish()) != OK) return(r);
20126 f_must = spanning;
20127 }
20128
20129 if (f_count == 0) {
20130 /* This is the first job, compute cylinder and head */
20131 f_opcode = opcode;
20132 f_fp->fl_cylinder = block / (NR_HEADS * f_sectors);
20133 f_fp->fl_hardcyl = f_fp->fl_cylinder * steps_per_cyl[d];
20134 f_fp->fl_head = (block % (NR_HEADS * f_sectors)) / f_sectors;
20135
20136 /* See where the next track starts, one is trouble enough */
20137 f_nexttrack = (f_fp->fl_cylinder * NR_HEADS
20138 + f_fp->fl_head + 1) * f_sectors;
20139 }
20140
20141 /* Don't do track spanning I/O. */
20142 if (block + (count >> SECTOR_SHIFT) > f_nexttrack)
20143 count = (f_nexttrack - block) << SECTOR_SHIFT;
20144
20145 /* Memory chunk to DMA. */
20146 dma_phys = user_phys;
20147 dma_count = dma_bytes_left(dma_phys);
20148
20149 #if _WORD_SIZE > 2
20150 /* The DMA chip uses a 24 bit address, so don't DMA above 16MB. */
20151 if (dma_phys >= 0x1000000) dma_count = 0;
20152 #endif
20153 if (dma_count < count) {
20154 /* Nearing a 64K boundary. */
20155 if (dma_count >= SECTOR_SIZE) {
20156 /* Can read a few sectors before hitting the
20157 * boundary.
20158 */
20159 count = dma_count & ~SECTOR_MASK;
20160 } else {
20161 /* Must use the special buffer for this. */
20162 count = SECTOR_SIZE;
20163 dma_phys = tmp_phys;
20164 }
20165 }
20166
20167 /* Store the I/O parameters in the ftrans slots for the sectors to
20168 * read. The first slot specifies all sectors, the ones following
20169 * it each specify one sector less. This allows I/O to be started
20170 * in the middle of a block.
20171 */
20172 tp = tp0 = &ftrans[block % f_sectors];
20173
20174 block += count >> SECTOR_SHIFT;
20175 nbytes -= count;
20176 f_count += count;
20177 if (!(iop->io_request & OPTIONAL_IO)) f_must = TRUE;
20178
20179 do {
20180 tp->tr_count = count;
20181 tp->tr_iop = iop;
20182 tp->tr_phys = user_phys;
20183 tp->tr_dma = dma_phys;
20184 tp++;
20185
20186 user_phys += SECTOR_SIZE;
20187 dma_phys += SECTOR_SIZE;
20188 count -= SECTOR_SIZE;
20189 } while (count > 0);
20190
20191 spanning = TRUE; /* the rest of the block may span a track */
20192 } while (nbytes > 0);
20193
20194 return(OK);
20195 }
20198 /*===========================================================================*
20199 * f_finish *
20200 *===========================================================================*/
20201 PRIVATE int f_finish()
20202 {
20203 /* Carry out the I/O requests gathered in ftrans[]. */
20204
20205 struct floppy *fp = f_fp;
20206 struct trans *tp;
20207 int r, errors;
20208
20209 if (f_count == 0) return(OK); /* Spurious finish. */
20210
20211 /* If all the requests are optional then don't read from the next track.
20212 * (There may be enough buffers to read the next track, but doing so is
20213 * unwise. It's no good to be greedy on a slow device.)
20214 */
20215 if (!f_must) {
20216 defuse();
20217 return(EAGAIN);
20218 }
20219
20220 /* See if motor is running; if not, turn it on and wait */
20221 start_motor();
20222
20223 /* Let read_id find out the next sector to read/write if it pays to do so.
20224 * Note that no read_id is done while formatting if there is one format
20225 * request per track as there should be.
20226 */
20227 fp->fl_sector = f_count >= (6 * SECTOR_SIZE) ? 0 : BASE_SECTOR;
20228
20229 do {
20230 /* This loop allows a failed operation to be repeated. */
20231 errors = 0;
20232 for (;;) {
20233 /* First check to see if a reset is needed. */
20234 if (need_reset) f_reset();
20235
20236 /* Set the stepping rate */
20237 if (current_spec1 != spec1[d]) {
20238 fdc_out(FDC_SPECIFY);
20239 current_spec1 = spec1[d];
20240 fdc_out(current_spec1);
20241 fdc_out(SPEC2);
20242 }
20243
20244 /* Set the data rate */
20245 if (pc_at) out_byte(FDC_RATE, rate[d]);
20246
20247 /* If we are going to a new cylinder, perform a seek. */
20248 r = seek(fp);
20249
20250 if (fp->fl_sector == NO_SECTOR) {
20251 /* Don't retry read_id too often, we need tp soon */
20252 if (errors > 0) fp->fl_sector = BASE_SECTOR;
20253
20254 /* Find out what the current sector is */
20255 if (r == OK) r = read_id(fp);
20256 }
20257
20258 /* Look for the next job in ftrans[] */
20259 if (fp->fl_sector != NO_SECTOR) {
20260 for (;;) {
20261 if (fp->fl_sector >= BASE_SECTOR + f_sectors)
20262 fp->fl_sector = BASE_SECTOR;
20263
20264 tp = &ftrans[fp->fl_sector - BASE_SECTOR];
20265 if (tp->tr_count > 0) break;
20266 fp->fl_sector++;
20267 }
20268 /* Do not transfer more than f_count bytes. */
20269 if (tp->tr_count > f_count) tp->tr_count = f_count;
20270 }
20271
20272 if (r == OK && tp->tr_dma == tmp_phys
20273 && f_opcode == DEV_WRITE) {
20274 /* Copy the bad user buffer to the DMA buffer. */
20275 phys_copy(tp->tr_phys, tp->tr_dma,
20276 (phys_bytes) tp->tr_count);
20277 }
20278
20279 /* Set up the DMA chip and perform the transfer. */
20280 if (r == OK) {
20281 dma_setup(tp);
20282 r = f_transfer(fp, tp);
20283 }
20284
20285 if (r == OK && tp->tr_dma == tmp_phys
20286 && f_opcode == DEV_READ) {
20287 /* Copy the DMA buffer to the bad user buffer. */
20288 phys_copy(tp->tr_dma, tp->tr_phys,
20289 (phys_bytes) tp->tr_count);
20290 }
20291
20292 if (r == OK) break; /* if successful, exit loop */
20293
20294 /* Don't retry if write protected or too many errors. */
20295 if (err_no_retry(r) || ++errors == MAX_ERRORS) {
20296 if (fp->fl_sector != 0) tp->tr_iop->io_nbytes = EIO;
20297 return(EIO);
20298 }
20299
20300 /* Recalibrate if halfway, but bail out if optional I/O. */
20301 if (errors == MAX_ERRORS / 2) {
20302 fp->fl_calibration = UNCALIBRATED;
20303 if (tp->tr_iop->io_request & OPTIONAL_IO)
20304 return(tp->tr_iop->io_nbytes = EIO);
20305 }
20306 }
20307 f_count -= tp->tr_count;
20308 tp->tr_iop->io_nbytes -= tp->tr_count;
20309 } while (f_count > 0);
20310
20311 /* Defuse the leftover partial jobs. */
20312 defuse();
20313
20314 return(OK);
20315 }
20318 /*===========================================================================*
20319 * defuse *
20320 *===========================================================================*/
20321 PRIVATE void defuse()
20322 {
20323 /* Invalidate leftover requests in the transfer array. */
20324
20325 struct trans *tp;
20326
20327 for (tp = ftrans; tp < ftrans + MAX_SECTORS; tp++) tp->tr_count = 0;
20328 f_count = 0;
20329 }
20332 /*===========================================================================*
20333 * dma_setup *
20334 *===========================================================================*/
20335 PRIVATE void dma_setup(tp)
20336 struct trans *tp; /* pointer to the transfer struct */
20337 {
20338 /* The IBM PC can perform DMA operations by using the DMA chip. To use it,
20339 * the DMA (Direct Memory Access) chip is loaded with the 20-bit memory address
20340 * to be read from or written to, the byte count minus 1, and a read or write
20341 * opcode. This routine sets up the DMA chip. Note that the chip is not
20342 * capable of doing a DMA across a 64K boundary (e.g., you can't read a
20343 * 512-byte block starting at physical address 65520).
20344 */
20345
20346 /* Set up the DMA registers. (The comment on the reset is a bit strong,
20347 * it probably only resets the floppy channel.)
20348 */
20349 out_byte(DMA_INIT, DMA_RESET_VAL); /* reset the dma controller */
20350 out_byte(DMA_FLIPFLOP, 0); /* write anything to reset it */
20351 out_byte(DMA_MODE, f_opcode == DEV_WRITE ? DMA_WRITE : DMA_READ);
20352 out_byte(DMA_ADDR, (int) tp->tr_dma >> 0);
20353 out_byte(DMA_ADDR, (int) tp->tr_dma >> 8);
20354 out_byte(DMA_TOP, (int) (tp->tr_dma >> 16));
20355 out_byte(DMA_COUNT, (tp->tr_count - 1) >> 0);
20356 out_byte(DMA_COUNT, (tp->tr_count - 1) >> 8);
20357 out_byte(DMA_INIT, 2); /* some sort of enable */
20358 }
20361 /*===========================================================================*
20362 * start_motor *
20363 *===========================================================================*/
20364 PRIVATE void start_motor()
20365 {
20366 /* Control of the floppy disk motors is a big pain. If a motor is off, you
20367 * have to turn it on first, which takes 1/2 second. You can't leave it on
20368 * all the time, since that would wear out the diskette. However, if you turn
20369 * the motor off after each operation, the system performance will be awful.
20370 * The compromise used here is to leave it on for a few seconds after each
20371 * operation. If a new operation is started in that interval, it need not be
20372 * turned on again. If no new operation is started, a timer goes off and the
20373 * motor is turned off. I/O port DOR has bits to control each of 4 drives.
20374 * The timer cannot go off while we are changing with the bits, since the
20375 * clock task cannot run while another (this) task is active, so there is no
20376 * need to lock().
20377 */
20378
20379 int motor_bit, running;
20380 message mess;
20381
20382 motor_bit = 1 << f_drive; /* bit mask for this drive */
20383 running = motor_status & motor_bit; /* nonzero if this motor is running */
20384 motor_goal = motor_status | motor_bit;/* want this drive running too */
20385
20386 out_byte(DOR, (motor_goal << MOTOR_SHIFT) | ENABLE_INT | f_drive);
20387 motor_status = motor_goal;
20388
20389 /* If the motor was already running, we don't have to wait for it. */
20390 if (running) return; /* motor was already running */
20391 clock_mess(mtr_setup[d], send_mess); /* motor was not running */
20392 receive(CLOCK, &mess); /* wait for clock interrupt */
20393 }
20396 /*===========================================================================*
20397 * stop_motor *
20398 *===========================================================================*/
20399 PRIVATE void stop_motor()
20400 {
20401 /* This routine is called by the clock interrupt after several seconds have
20402 * elapsed with no floppy disk activity. It checks to see if any drives are
20403 * supposed to be turned off, and if so, turns them off.
20404 */
20405
20406 if (motor_goal != motor_status) {
20407 out_byte(DOR, (motor_goal << MOTOR_SHIFT) | ENABLE_INT);
20408 motor_status = motor_goal;
20409 }
20410 }
20413 /*===========================================================================*
20414 * floppy_stop *
20415 *===========================================================================*/
20416 PUBLIC void floppy_stop()
20417 {
20418 /* Stop all activity. */
20419
20420 motor_goal = 0;
20421 stop_motor();
20422 }
20425 /*===========================================================================*
20426 * seek *
20427 *===========================================================================*/
20428 PRIVATE int seek(fp)
20429 struct floppy *fp; /* pointer to the drive struct */
20430 {
20431 /* Issue a SEEK command on the indicated drive unless the arm is already
20432 * positioned on the correct cylinder.
20433 */
20434
20435 int r;
20436 message mess;
20437
20438 /* Are we already on the correct cylinder? */
20439 if (fp->fl_calibration == UNCALIBRATED)
20440 if (recalibrate(fp) != OK) return(ERR_SEEK);
20441 if (fp->fl_curcyl == fp->fl_hardcyl) return(OK);
20442
20443 /* No. Wrong cylinder. Issue a SEEK and wait for interrupt. */
20444 fdc_out(FDC_SEEK);
20445 fdc_out((fp->fl_head << 2) | f_drive);
20446 fdc_out(fp->fl_hardcyl);
20447 if (need_reset) return(ERR_SEEK); /* if controller is sick, abort seek */
20448 if (f_intr_wait() != OK) return(ERR_TIMEOUT);
20449
20450 /* Interrupt has been received. Check drive status. */
20451 fdc_out(FDC_SENSE); /* probe FDC to make it return status */
20452 r = fdc_results(); /* get controller status bytes */
20453 if (r != OK || (f_results[ST0] & ST0_BITS) != SEEK_ST0
20454 || f_results[ST1] != fp->fl_hardcyl) {
20455 /* seek failed, may need a recalibrate */
20456 return(ERR_SEEK);
20457 }
20458 /* give head time to settle on a format, no retrying here! */
20459 if (f_device & FORMAT_DEV_BIT) {
20460 clock_mess(2, send_mess);
20461 receive(CLOCK, &mess);
20462 }
20463 fp->fl_curcyl = fp->fl_hardcyl;
20464 return(OK);
20465 }
20468 /*===========================================================================*
20469 * f_transfer *
20470 *===========================================================================*/
20471 PRIVATE int f_transfer(fp, tp)
20472 struct floppy *fp; /* pointer to the drive struct */
20473 struct trans *tp; /* pointer to the transfer struct */
20474 {
20475 /* The drive is now on the proper cylinder. Read, write or format 1 block. */
20476
20477 int r, s;
20478
20479 /* Never attempt a transfer if the drive is uncalibrated or motor is off. */
20480 if (fp->fl_calibration == UNCALIBRATED) return(ERR_TRANSFER);
20481 if ((motor_status & (1 << f_drive)) == 0) return(ERR_TRANSFER);
20482
20483 /* The command is issued by outputting several bytes to the controller chip.
20484 */
20485 if (f_device & FORMAT_DEV_BIT) {
20486 fdc_out(FDC_FORMAT);
20487 fdc_out((fp->fl_head << 2) | f_drive);
20488 fdc_out(fmt_param.sector_size_code);
20489 fdc_out(fmt_param.sectors_per_cylinder);
20490 fdc_out(fmt_param.gap_length_for_format);
20491 fdc_out(fmt_param.fill_byte_for_format);
20492 } else {
20493 fdc_out(f_opcode == DEV_WRITE ? FDC_WRITE : FDC_READ);
20494 fdc_out((fp->fl_head << 2) | f_drive);
20495 fdc_out(fp->fl_cylinder);
20496 fdc_out(fp->fl_head);
20497 fdc_out(fp->fl_sector);
20498 fdc_out(SECTOR_SIZE_CODE);
20499 fdc_out(f_sectors);
20500 fdc_out(gap[d]); /* sector gap */
20501 fdc_out(DTL); /* data length */
20502 }
20503
20504 /* Block, waiting for disk interrupt. */
20505 if (need_reset) return(ERR_TRANSFER); /* if controller is sick, abort op */
20506
20507 if (f_intr_wait() != OK) return(ERR_TIMEOUT);
20508
20509 /* Get controller status and check for errors. */
20510 r = fdc_results();
20511 if (r != OK) return(r);
20512
20513 if (f_results[ST1] & WRITE_PROTECT) {
20514 printf("%s: diskette is write protected.n", f_name());
20515 return(ERR_WR_PROTECT);
20516 }
20517
20518 if ((f_results[ST0] & ST0_BITS) != TRANS_ST0) return(ERR_TRANSFER);
20519 if (f_results[ST1] | f_results[ST2]) return(ERR_TRANSFER);
20520
20521 if (f_device & FORMAT_DEV_BIT) return(OK);
20522
20523 /* Compare actual numbers of sectors transferred with expected number. */
20524 s = (f_results[ST_CYL] - fp->fl_cylinder) * NR_HEADS * f_sectors;
20525 s += (f_results[ST_HEAD] - fp->fl_head) * f_sectors;
20526 s += (f_results[ST_SEC] - fp->fl_sector);
20527 if ((s << SECTOR_SHIFT) != tp->tr_count) return(ERR_TRANSFER);
20528
20529 /* This sector is next for I/O: */
20530 fp->fl_sector = f_results[ST_SEC];
20531 return(OK);
20532 }
20535 /*==========================================================================*
20536 * fdc_results *
20537 *==========================================================================*/
20538 PRIVATE int fdc_results()
20539 {
20540 /* Extract results from the controller after an operation, then allow floppy
20541 * interrupts again.
20542 */
20543
20544 int result_nr, status;
20545 struct milli_state ms;
20546
20547 /* Extract bytes from FDC until it says it has no more. The loop is
20548 * really an outer loop on result_nr and an inner loop on status.
20549 */
20550 result_nr = 0;
20551 milli_start(&ms);
20552 do {
20553 /* Reading one byte is almost a mirror of fdc_out() - the DIRECTION
20554 * bit must be set instead of clear, but the CTL_BUSY bit destroys
20555 * the perfection of the mirror.
20556 */
20557 status = in_byte(FDC_STATUS) & (MASTER | DIRECTION | CTL_BUSY);
20558 if (status == (MASTER | DIRECTION | CTL_BUSY)) {
20559 if (result_nr >= MAX_RESULTS) break; /* too many results */
20560 f_results[result_nr++] = in_byte(FDC_DATA);
20561 continue;
20562 }
20563 if (status == MASTER) { /* all read */
20564 enable_irq(FLOPPY_IRQ);
20565 return(OK); /* only good exit */
20566 }
20567 } while (milli_elapsed(&ms) < TIMEOUT);
20568 need_reset = TRUE; /* controller chip must be reset */
20569 enable_irq(FLOPPY_IRQ);
20570 return(ERR_STATUS);
20571 }
20574 /*==========================================================================*
20575 * f_handler *
20576 *==========================================================================*/
20577 PRIVATE int f_handler(irq)
20578 int irq;
20579 {
20580 /* FDC interrupt, send message to floppy task. */
20581
20582 interrupt(FLOPPY);
20583 return 0;
20584 }
20587 /*===========================================================================*
20588 * fdc_out *
20589 *===========================================================================*/
20590 PRIVATE void fdc_out(val)
20591 int val; /* write this byte to floppy disk controller */
20592 {
20593 /* Output a byte to the controller. This is not entirely trivial, since you
20594 * can only write to it when it is listening, and it decides when to listen.
20595 * If the controller refuses to listen, the FDC chip is given a hard reset.
20596 */
20597
20598 struct milli_state ms;
20599
20600 if (need_reset) return; /* if controller is not listening, return */
20601
20602 /* It may take several tries to get the FDC to accept a command. */
20603 milli_start(&ms);
20604 while ((in_byte(FDC_STATUS) & (MASTER | DIRECTION)) != (MASTER | 0)) {
20605 if (milli_elapsed(&ms) >= TIMEOUT) {
20606 /* Controller is not listening. Hit it over the head. */
20607 need_reset = TRUE;
20608 return;
20609 }
20610 }
20611 out_byte(FDC_DATA, val);
20612 }
20615 /*===========================================================================*
20616 * recalibrate *
20617 *===========================================================================*/
20618 PRIVATE int recalibrate(fp)
20619 struct floppy *fp; /* pointer tot he drive struct */
20620 {
20621 /* The floppy disk controller has no way of determining its absolute arm
20622 * position (cylinder). Instead, it steps the arm a cylinder at a time and
20623 * keeps track of where it thinks it is (in software). However, after a
20624 * SEEK, the hardware reads information from the diskette telling where the
20625 * arm actually is. If the arm is in the wrong place, a recalibration is done,
20626 * which forces the arm to cylinder 0. This way the controller can get back
20627 * into sync with reality.
20628 */
20629
20630 int r;
20631
20632 /* Issue the RECALIBRATE command and wait for the interrupt. */
20633 start_motor(); /* can't recalibrate with motor off */
20634 fdc_out(FDC_RECALIBRATE); /* tell drive to recalibrate itself */
20635 fdc_out(f_drive); /* specify drive */
20636 if (need_reset) return(ERR_SEEK); /* don't wait if controller is sick */
20637 if (f_intr_wait() != OK) return(ERR_TIMEOUT);
20638
20639 /* Determine if the recalibration succeeded. */
20640 fdc_out(FDC_SENSE); /* issue SENSE command to request results */
20641 r = fdc_results(); /* get results of the FDC_RECALIBRATE command*/
20642 fp->fl_curcyl = NO_CYL; /* force a SEEK next time */
20643 if (r != OK || /* controller would not respond */
20644 (f_results[ST0] & ST0_BITS) != SEEK_ST0 || f_results[ST_PCN] != 0) {
20645 /* Recalibration failed. FDC must be reset. */
20646 need_reset = TRUE;
20647 return(ERR_RECALIBRATE);
20648 } else {
20649 /* Recalibration succeeded. */
20650 fp->fl_calibration = CALIBRATED;
20651 return(OK);
20652 }
20653 }
20656 /*===========================================================================*
20657 * f_reset *
20658 *===========================================================================*/
20659 PRIVATE void f_reset()
20660 {
20661 /* Issue a reset to the controller. This is done after any catastrophe,
20662 * like the controller refusing to respond.
20663 */
20664
20665 int i;
20666 message mess;
20667
20668 /* Disable interrupts and strobe reset bit low. */
20669 need_reset = FALSE;
20670
20671 /* It is not clear why the next lock is needed. Writing 0 to DOR causes
20672 * interrupt, while the PC documentation says turning bit 8 off disables
20673 * interrupts. Without the lock:
20674 * 1) the interrupt handler sets the floppy mask bit in the 8259.
20675 * 2) writing ENABLE_INT to DOR causes the FDC to assert the interrupt
20676 * line again, but the mask stops the cpu being interrupted.
20677 * 3) the sense interrupt clears the interrupt (not clear which one).
20678 * and for some reason the reset does not work.
20679 */
20680 lock();
20681 motor_status = 0;
20682 motor_goal = 0;
20683 out_byte(DOR, 0); /* strobe reset bit low */
20684 out_byte(DOR, ENABLE_INT); /* strobe it high again */
20685 unlock();
20686 receive(HARDWARE, &mess); /* collect the RESET interrupt */
20687
20688 /* The controller supports 4 drives and returns a result for each of them.
20689 * Collect all the results now. The old version only collected the first
20690 * result. This happens to work for 2 drives, but it doesn't work for 3
20691 * or more drives, at least with only drives 0 and 2 actually connected
20692 * (the controller generates an extra interrupt for the middle drive when
20693 * drive 2 is accessed and the driver panics).
20694 *
20695 * It would be better to keep collecting results until there are no more.
20696 * For this, fdc_results needs to return the number of results (instead
20697 * of OK) when it succeeds.
20698 */
20699 for (i = 0; i < 4; i++) {
20700 fdc_out(FDC_SENSE); /* probe FDC to make it return status */
20701 (void) fdc_results(); /* flush controller */
20702 }
20703 for (i = 0; i < NR_DRIVES; i++) /* clear each drive */
20704 floppy[i].fl_calibration = UNCALIBRATED;
20705
20706 /* The current timing parameters must be specified again. */
20707 current_spec1 = 0;
20708 }
20711 /*===========================================================================*
20712 * send_mess *
20713 *===========================================================================*/
20714 PRIVATE void send_mess()
20715 {
20716 /* This routine is called when the clock task has timed out on motor startup.*/
20717
20718 message mess;
20719
20720 send(FLOPPY, &mess);
20721 }
20724 /*===========================================================================*
20725 * f_intr_wait *
20726 *===========================================================================*/
20727 PRIVATE int f_intr_wait()
20728 {
20729 /* Wait for an interrupt, but not forever. The FDC may have all the time of
20730 * the world, but we humans do not.
20731 */
20732 message mess;
20733
20734 f_busy = BSY_IO;
20735 clock_mess(WAKEUP, f_timeout);
20736 receive(HARDWARE, &mess);
20737
20738 if (f_busy == BSY_WAKEN) {
20739 /* No interrupt from the FDC, this means that there is probably no
20740 * floppy in the drive. Get the FDC down to earth and return error.
20741 */
20742 f_reset();
20743 return(ERR_TIMEOUT);
20744 }
20745 f_busy = BSY_IDLE;
20746 return(OK);
20747 }
20750 /*===========================================================================*
20751 * f_timeout *
20752 *===========================================================================*/
20753 PRIVATE void f_timeout()
20754 {
20755 /* When it takes too long for the FDC to get an interrupt (no floppy in the
20756 * drive), this routine is called. It sets a flag and fakes a hardware
20757 * interrupt.
20758 */
20759 if (f_busy == BSY_IO) {
20760 f_busy = BSY_WAKEN;
20761 interrupt(FLOPPY);
20762 }
20763 }
20766 /*==========================================================================*
20767 * read_id *
20768 *==========================================================================*/
20769 PRIVATE int read_id(fp)
20770 struct floppy *fp; /* pointer to the drive struct */
20771 {
20772 /* Determine current cylinder and sector. */
20773
20774 int result;
20775
20776 /* Never attempt a read id if the drive is uncalibrated or motor is off. */
20777 if (fp->fl_calibration == UNCALIBRATED) return(ERR_READ_ID);
20778 if ((motor_status & (1 << f_drive)) == 0) return(ERR_READ_ID);
20779
20780 /* The command is issued by outputting 2 bytes to the controller chip. */
20781 fdc_out(FDC_READ_ID); /* issue the read id command */
20782 fdc_out( (f_fp->fl_head << 2) | f_drive);
20783
20784 /* Block, waiting for disk interrupt. */
20785 if (need_reset) return(ERR_READ_ID); /* if controller is sick, abort op */
20786
20787 if (f_intr_wait() != OK) return(ERR_TIMEOUT);
20788
20789 /* Get controller status and check for errors. */
20790 result = fdc_results();
20791 if (result != OK) return(result);
20792
20793 if ((f_results[ST0] & ST0_BITS) != TRANS_ST0) return(ERR_READ_ID);
20794 if (f_results[ST1] | f_results[ST2]) return(ERR_READ_ID);
20795
20796 /* The next sector is next for I/O: */
20797 f_fp->fl_sector = f_results[ST_SEC] + 1;
20798 return(OK);
20799 }
20802 /*==========================================================================*
20803 * f_do_open *
20804 *==========================================================================*/
20805 PRIVATE int f_do_open(dp, m_ptr)
20806 struct driver *dp;
20807 message *m_ptr; /* pointer to open message */
20808 {
20809 /* Handle an open on a floppy. Determine diskette type if need be. */
20810
20811 int dtype;
20812 struct test_order *top;
20813
20814 /* Decode the message parameters. */
20815 if (f_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
20816
20817 dtype = f_device & DEV_TYPE_BITS; /* get density from minor dev */
20818 if (dtype >= MINOR_fd0a) dtype = 0;
20819 if (dtype != 0) {
20820 /* All types except 0 indicate a specific drive/medium combination.*/
20821 dtype = (dtype >> DEV_TYPE_SHIFT) - 1;
20822 if (dtype >= NT) return(ENXIO);
20823 f_fp->fl_density = dtype;
20824 f_fp->fl_geom.dv_size = (long) nr_blocks[dtype] << SECTOR_SHIFT;
20825 return(OK);
20826 }
20827 if (f_device & FORMAT_DEV_BIT) return(EIO); /* Can't format /dev/fdx */
20828
20829 /* No need to test if the motor is still running. */
20830 if (motor_status & (1 << f_drive)) return(OK);
20831
20832 /* The device opened is /dev/fdx. Experimentally determine drive/medium.
20833 * First check fl_density. If it is not NO_DENS, the drive has been used
20834 * before and the value of fl_density tells what was found last time. Try
20835 * that first.
20836 */
20837 if (f_fp->fl_density != NO_DENS && test_read(f_fp->fl_density) == OK)
20838 return(OK);
20839
20840 /* Either drive type is unknown or a different diskette is now present.
20841 * Use test_order to try them one by one.
20842 */
20843 for (top = &test_order[0]; top < &test_order[NT-1]; top++) {
20844 dtype = top->t_density;
20845
20846 /* Skip densities that have been proven to be impossible */
20847 if (!(f_fp->fl_class & (1 << dtype))) continue;
20848
20849 if (test_read(dtype) == OK) {
20850 /* The test succeeded, use this knowledge to limit the
20851 * drive class to match the density just read.
20852 */
20853 f_fp->fl_class &= top->t_class;
20854 return(OK);
20855 }
20856 /* Test failed, wrong density or did it time out? */
20857 if (f_busy == BSY_WAKEN) break;
20858 }
20859 f_fp->fl_density = NO_DENS;
20860 return(EIO); /* nothing worked */
20861 }
20864 /*==========================================================================*
20865 * test_read *
20866 *==========================================================================*/
20867 PRIVATE int test_read(density)
20868 int density;
20869 {
20870 /* Try to read the highest numbered sector on cylinder 2. Not all floppy
20871 * types have as many sectors per track, and trying cylinder 2 finds the
20872 * ones that need double stepping.
20873 */
20874
20875 message m;
20876 int r, device;
20877
20878 f_fp->fl_density = density;
20879 device = ((density + 1) << DEV_TYPE_SHIFT) + f_drive;
20880 f_fp->fl_geom.dv_size = (long) nr_blocks[density] << SECTOR_SHIFT;
20881 m.m_type = DEV_READ;
20882 m.DEVICE = device;
20883 m.PROC_NR = FLOPPY;
20884 m.COUNT = SECTOR_SIZE;
20885 m.POSITION = (long) test_sector[density] * SECTOR_SIZE;
20886 m.ADDRESS = (char *) tmp_buf;
20887 r = do_rdwt(&f_dtab, &m);
20888 if (r != SECTOR_SIZE) return(EIO);
20889
20890 partition(&f_dtab, f_drive, P_FLOPPY);
20891 return(OK);
20892 }
20895 /*============================================================================*
20896 * f_geometry *
20897 *============================================================================*/
20898 PRIVATE void f_geometry(entry)
20899 struct partition *entry;
20900 {
20901 entry->cylinders = nr_blocks[d] / (NR_HEADS * f_sectors);
20902 entry->heads = NR_HEADS;
20903 entry->sectors = f_sectors;
20904 }
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/kernel/i8259.c
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
21000 /* This file contains routines for initializing the 8259 interrupt controller:
21001 * get_irq_handler: address of handler for a given interrupt
21002 * put_irq_handler: register an interrupt handler
21003 * intr_init: initialize the interrupt controller(s)
21004 */
21005
21006 #include "kernel.h"
21007
21008 #define ICW1_AT 0x11 /* edge triggered, cascade, need ICW4 */
21009 #define ICW1_PC 0x13 /* edge triggered, no cascade, need ICW4 */
21010 #define ICW1_PS 0x19 /* level triggered, cascade, need ICW4 */
21011 #define ICW4_AT 0x01 /* not SFNM, not buffered, normal EOI, 8086 */
21012 #define ICW4_PC 0x09 /* not SFNM, buffered, normal EOI, 8086 */
21013
21014 FORWARD _PROTOTYPE( int spurious_irq, (int irq) );
21015
21016 #if _WORD_SIZE == 2
21017 typedef _PROTOTYPE( void (*vecaddr_t), (void) );
21018
21019 FORWARD _PROTOTYPE( void set_vec, (int vec_nr, vecaddr_t addr) );
21020
21021 PRIVATE vecaddr_t int_vec[] = {
21022 int00, int01, int02, int03, int04, int05, int06, int07,
21023 };
21024
21025 PRIVATE vecaddr_t irq_vec[] = {
21026 hwint00, hwint01, hwint02, hwint03, hwint04, hwint05, hwint06, hwint07,
21027 hwint08, hwint09, hwint10, hwint11, hwint12, hwint13, hwint14, hwint15,
21028 };
21029 #else
21030 #define set_vec(nr, addr) ((void)0)
21031 #endif
21032
21033
21034 /*==========================================================================*
21035 * intr_init *
21036 *==========================================================================*/
21037 PUBLIC void intr_init(mine)
21038 int mine;
21039 {
21040 /* Initialize the 8259s, finishing with all interrupts disabled. This is
21041 * only done in protected mode, in real mode we don't touch the 8259s, but
21042 * use the BIOS locations instead. The flag "mine" is set if the 8259s are
21043 * to be programmed for Minix, or to be reset to what the BIOS expects.
21044 */
21045
21046 int i;
21047
21048 lock();
21049 if (protected_mode) {
21050 /* The AT and newer PS/2 have two interrupt controllers, one master,
21051 * one slaved at IRQ 2. (We don't have to deal with the PC that
21052 * has just one controller, because it must run in real mode.)
21053 */
21054 out_byte(INT_CTL, ps_mca ? ICW1_PS : ICW1_AT);
21055 out_byte(INT_CTLMASK, mine ? IRQ0_VECTOR : BIOS_IRQ0_VEC);
21056 /* ICW2 for master */
21057 out_byte(INT_CTLMASK, (1 << CASCADE_IRQ)); /* ICW3 tells slaves */
21058 out_byte(INT_CTLMASK, ICW4_AT);
21059 out_byte(INT_CTLMASK, ~(1 << CASCADE_IRQ)); /* IRQ 0-7 mask */
21060 out_byte(INT2_CTL, ps_mca ? ICW1_PS : ICW1_AT);
21061 out_byte(INT2_CTLMASK, mine ? IRQ8_VECTOR : BIOS_IRQ8_VEC);
21062 /* ICW2 for slave */
21063 out_byte(INT2_CTLMASK, CASCADE_IRQ); /* ICW3 is slave nr */
21064 out_byte(INT2_CTLMASK, ICW4_AT);
21065 out_byte(INT2_CTLMASK, ~0); /* IRQ 8-15 mask */
21066 } else {
21067 /* Use the BIOS interrupt vectors in real mode. We only reprogram the
21068 * exceptions here, the interrupt vectors are reprogrammed on demand.
21069 * SYS_VECTOR is the Minix system call for message passing.
21070 */
21071 for (i = 0; i < 8; i++) set_vec(i, int_vec[i]);
21072 set_vec(SYS_VECTOR, s_call);
21073 }
21074
21075 /* Initialize the table of interrupt handlers. */
21076 for (i = 0; i < NR_IRQ_VECTORS; i++) irq_table[i] = spurious_irq;
21077 }
21079 /*=========================================================================*
21080 * spurious_irq *
21081 *=========================================================================*/
21082 PRIVATE int spurious_irq(irq)
21083 int irq;
21084 {
21085 /* Default interrupt handler. It complains a lot. */
21086
21087 if (irq < 0 || irq >= NR_IRQ_VECTORS)
21088 panic("invalid call to spurious_irq", irq);
21089
21090 printf("spurious irq %dn", irq);
21091
21092 return 1; /* Reenable interrupt */
21093 }
21095 /*=========================================================================*
21096 * put_irq_handler *
21097 *=========================================================================*/
21098 PUBLIC void put_irq_handler(irq, handler)
21099 int irq;
21100 irq_handler_t handler;
21101 {
21102 /* Register an interrupt handler. */
21103
21104 if (irq < 0 || irq >= NR_IRQ_VECTORS)
21105 panic("invalid call to put_irq_handler", irq);
21106
21107 if (irq_table[irq] == handler)
21108 return; /* extra initialization */
21109
21110 if (irq_table[irq] != spurious_irq)
21111 panic("attempt to register second irq handler for irq", irq);
21112
21113 disable_irq(irq);
21114 if (!protected_mode) set_vec(BIOS_VECTOR(irq), irq_vec[irq]);
21115 irq_table[irq]= handler;
21116 irq_use |= 1 << irq;
21117 }
21120 #if _WORD_SIZE == 2
21121 /*===========================================================================*
21122 * set_vec *
21123 *===========================================================================*/
21124 PRIVATE void set_vec(vec_nr, addr)
21125 int vec_nr; /* which vector */
21126 vecaddr_t addr; /* where to start */
21127 {
21128 /* Set up a real mode interrupt vector. */
21129
21130 u16_t vec[2];
21131
21132 /* Build the vector in the array 'vec'. */
21133 vec[0] = (u16_t) addr;
21134 vec[1] = (u16_t) physb_to_hclick(code_base);
21135
21136 /* Copy the vector into place. */
21137 phys_copy(vir2phys(vec), vec_nr * 4L, 4L);
21138 }
21139 #endif /* _WORD_SIZE == 2 */
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/kernel/keyboard.c
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
21200 /* Keyboard driver for PC's and AT's.
21201 *
21202 * Changed by Marcus Hampel (04/02/1994)
21203 * - Loadable keymaps
21204 */
21205
21206 #include "kernel.h"
21207 #include <termios.h>
21208 #include <signal.h>
21209 #include <unistd.h>
21210 #include <minix/callnr.h>
21211 #include <minix/com.h>
21212 #include <minix/keymap.h>
21213 #include "tty.h"
21214 #include "keymaps/us-std.src"
21215
21216 /* Standard and AT keyboard. (PS/2 MCA implies AT throughout.) */
21217 #define KEYBD 0x60 /* I/O port for keyboard data */
21218
21219 /* AT keyboard. */
21220 #define KB_COMMAND 0x64 /* I/O port for commands on AT */
21221 #define KB_GATE_A20 0x02 /* bit in output port to enable A20 line */
21222 #define KB_PULSE_OUTPUT 0xF0 /* base for commands to pulse output port */
21223 #define KB_RESET 0x01 /* bit in output port to reset CPU */
21224 #define KB_STATUS 0x64 /* I/O port for status on AT */
21225 #define KB_ACK 0xFA /* keyboard ack response */
21226 #define KB_BUSY 0x02 /* status bit set when KEYBD port ready */
21227 #define LED_CODE 0xED /* command to keyboard to set LEDs */
21228 #define MAX_KB_ACK_RETRIES 0x1000 /* max #times to wait for kb ack */
21229 #define MAX_KB_BUSY_RETRIES 0x1000 /* max #times to loop while kb busy */
21230 #define KBIT 0x80 /* bit used to ack characters to keyboard */
21231
21232 /* Miscellaneous. */
21233 #define ESC_SCAN 1 /* Reboot key when panicking */
21234 #define SLASH_SCAN 53 /* to recognize numeric slash */
21235 #define HOME_SCAN 71 /* first key on the numeric keypad */
21236 #define DEL_SCAN 83 /* DEL for use in CTRL-ALT-DEL reboot */
21237 #define CONSOLE 0 /* line number for console */
21238 #define MEMCHECK_ADR 0x472 /* address to stop memory check after reboot */
21239 #define MEMCHECK_MAG 0x1234 /* magic number to stop memory check */
21240
21241 #define kb_addr() (&kb_lines[0]) /* there is only one keyboard */
21242 #define KB_IN_BYTES 32 /* size of keyboard input buffer */
21243
21244 PRIVATE int alt1; /* left alt key state */
21245 PRIVATE int alt2; /* right alt key state */
21246 PRIVATE int capslock; /* caps lock key state */
21247 PRIVATE int esc; /* escape scan code detected? */
21248 PRIVATE int control; /* control key state */
21249 PRIVATE int caps_off; /* 1 = normal position, 0 = depressed */
21250 PRIVATE int numlock; /* number lock key state */
21251 PRIVATE int num_off; /* 1 = normal position, 0 = depressed */
21252 PRIVATE int slock; /* scroll lock key state */
21253 PRIVATE int slock_off; /* 1 = normal position, 0 = depressed */
21254 PRIVATE int shift; /* shift key state */
21255
21256 PRIVATE char numpad_map[] =
21257 {'H', 'Y', 'A', 'B', 'D', 'C', 'V', 'U', 'G', 'S', 'T', '@'};
21258
21259 /* Keyboard structure, 1 per console. */
21260 struct kb_s {
21261 char *ihead; /* next free spot in input buffer */
21262 char *itail; /* scan code to return to TTY */
21263 int icount; /* # codes in buffer */
21264 char ibuf[KB_IN_BYTES]; /* input buffer */
21265 };
21266
21267 PRIVATE struct kb_s kb_lines[NR_CONS];
21268
21269 FORWARD _PROTOTYPE( int kb_ack, (void) );
21270 FORWARD _PROTOTYPE( int kb_wait, (void) );
21271 FORWARD _PROTOTYPE( int func_key, (int scode) );
21272 FORWARD _PROTOTYPE( int scan_keyboard, (void) );
21273 FORWARD _PROTOTYPE( unsigned make_break, (int scode) );
21274 FORWARD _PROTOTYPE( void set_leds, (void) );
21275 FORWARD _PROTOTYPE( int kbd_hw_int, (int irq) );
21276 FORWARD _PROTOTYPE( void kb_read, (struct tty *tp) );
21277 FORWARD _PROTOTYPE( unsigned map_key, (int scode) );
21278
21279
21280 /*===========================================================================*
21281 * map_key0 *
21282 *===========================================================================*/
21283 /* Map a scan code to an ASCII code ignoring modifiers. */
21284 #define map_key0(scode)
21285 ((unsigned) keymap[(scode) * MAP_COLS])
21286
21287
21288 /*===========================================================================*
21289 * map_key *
21290 *===========================================================================*/
21291 PRIVATE unsigned map_key(scode)
21292 int scode;
21293 {
21294 /* Map a scan code to an ASCII code. */
21295
21296 int caps, column;
21297 u16_t *keyrow;
21298
21299 if (scode == SLASH_SCAN && esc) return '/'; /* don't map numeric slash */
21300
21301 keyrow = &keymap[scode * MAP_COLS];
21302
21303 caps = shift;
21304 if (numlock && HOME_SCAN <= scode && scode <= DEL_SCAN) caps = !caps;
21305 if (capslock && (keyrow[0] & HASCAPS)) caps = !caps;
21306
21307 if (alt1 || alt2) {
21308 column = 2;
21309 if (control || alt2) column = 3; /* Ctrl + Alt1 == Alt2 */
21310 if (caps) column = 4;
21311 } else {
21312 column = 0;
21313 if (caps) column = 1;
21314 if (control) column = 5;
21315 }
21316 return keyrow[column] & ~HASCAPS;
21317 }
21320 /*===========================================================================*
21321 * kbd_hw_int *
21322 *===========================================================================*/
21323 PRIVATE int kbd_hw_int(irq)
21324 int irq;
21325 {
21326 /* A keyboard interrupt has occurred. Process it. */
21327
21328 int code;
21329 unsigned km;
21330 register struct kb_s *kb;
21331
21332 /* Fetch the character from the keyboard hardware and acknowledge it. */
21333 code = scan_keyboard();
21334
21335 /* The IBM keyboard interrupts twice per key, once when depressed, once when
21336 * released. Filter out the latter, ignoring all but the shift-type keys.
21337 * The shift-type keys 29, 42, 54, 56, 58, and 69 must be processed normally.
21338 */
21339
21340 if (code & 0200) {
21341 /* A key has been released (high bit is set). */
21342 km = map_key0(code & 0177);
21343 if (km != CTRL && km != SHIFT && km != ALT && km != CALOCK
21344 && km != NLOCK && km != SLOCK && km != EXTKEY)
21345 return 1;
21346 }
21347
21348 /* Store the character in memory so the task can get at it later. */
21349 kb = kb_addr();
21350 if (kb->icount < KB_IN_BYTES) {
21351 *kb->ihead++ = code;
21352 if (kb->ihead == kb->ibuf + KB_IN_BYTES) kb->ihead = kb->ibuf;
21353 kb->icount++;
21354 tty_table[current].tty_events = 1;
21355 force_timeout();
21356 }
21357 /* Else it doesn't fit - discard it. */
21358 return 1; /* Reenable keyboard interrupt */
21359 }
21362 /*==========================================================================*
21363 * kb_read *
21364 *==========================================================================*/
21365 PRIVATE void kb_read(tp)
21366 tty_t *tp;
21367 {
21368 /* Process characters from the circular keyboard buffer. */
21369
21370 struct kb_s *kb;
21371 char buf[3];
21372 int scode;
21373 unsigned ch;
21374
21375 kb = kb_addr();
21376 tp = &tty_table[current]; /* always use the current console */
21377
21378 while (kb->icount > 0) {
21379 scode = *kb->itail++; /* take one key scan code */
21380 if (kb->itail == kb->ibuf + KB_IN_BYTES) kb->itail = kb->ibuf;
21381 lock();
21382 kb->icount--;
21383 unlock();
21384
21385 /* Function keys are being used for debug dumps. */
21386 if (func_key(scode)) continue;
21387
21388 /* Perform make/break processing. */
21389 ch = make_break(scode);
21390
21391 if (ch <= 0xFF) {
21392 /* A normal character. */
21393 buf[0] = ch;
21394 (void) in_process(tp, buf, 1);
21395 } else
21396 if (HOME <= ch && ch <= INSRT) {
21397 /* An ASCII escape sequence generated by the numeric pad. */
21398 buf[0] = ESC;
21399 buf[1] = '[';
21400 buf[2] = numpad_map[ch - HOME];
21401 (void) in_process(tp, buf, 3);
21402 } else
21403 if (ch == ALEFT) {
21404 /* Choose lower numbered console as current console. */
21405 select_console(current - 1);
21406 } else
21407 if (ch == ARIGHT) {
21408 /* Choose higher numbered console as current console. */
21409 select_console(current + 1);
21410 } else
21411 if (AF1 <= ch && ch <= AF12) {
21412 /* Alt-F1 is console, Alt-F2 is ttyc1, etc. */
21413 select_console(ch - AF1);
21414 }
21415 }
21416 }
21419 /*===========================================================================*
21420 * make_break *
21421 *===========================================================================*/
21422 PRIVATE unsigned make_break(scode)
21423 int scode; /* scan code of key just struck or released */
21424 {
21425 /* This routine can handle keyboards that interrupt only on key depression,
21426 * as well as keyboards that interrupt on key depression and key release.
21427 * For efficiency, the interrupt routine filters out most key releases.
21428 */
21429 int ch, make;
21430 static int CAD_count = 0;
21431
21432 /* Check for CTRL-ALT-DEL, and if found, halt the computer. This would
21433 * be better done in keyboard() in case TTY is hung, except control and
21434 * alt are set in the high level code.
21435 */
21436 if (control && (alt1 || alt2) && scode == DEL_SCAN)
21437 {
21438 if (++CAD_count == 3) wreboot(RBT_HALT);
21439 cause_sig(INIT_PROC_NR, SIGABRT);
21440 return -1;
21441 }
21442
21443 /* High-order bit set on key release. */
21444 make = (scode & 0200 ? 0 : 1); /* 0 = release, 1 = press */
21445
21446 ch = map_key(scode & 0177); /* map to ASCII */
21447
21448 switch (ch) {
21449 case CTRL:
21450 control = make;
21451 ch = -1;
21452 break;
21453 case SHIFT:
21454 shift = make;
21455 ch = -1;
21456 break;
21457 case ALT:
21458 if (make) {
21459 if (esc) alt2 = 1; else alt1 = 1;
21460 } else {
21461 alt1 = alt2 = 0;
21462 }
21463 ch = -1;
21464 break;
21465 case CALOCK:
21466 if (make && caps_off) {
21467 capslock = 1 - capslock;
21468 set_leds();
21469 }
21470 caps_off = 1 - make;
21471 ch = -1;
21472 break;
21473 case NLOCK:
21474 if (make && num_off) {
21475 numlock = 1 - numlock;
21476 set_leds();
21477 }
21478 num_off = 1 - make;
21479 ch = -1;
21480 break;
21481 case SLOCK:
21482 if (make & slock_off) {
21483 slock = 1 - slock;
21484 set_leds();
21485 }
21486 slock_off = 1 - make;
21487 ch = -1;
21488 break;
21489 case EXTKEY:
21490 esc = 1;
21491 return(-1);
21492 default:
21493 if (!make) ch = -1;
21494 }
21495 esc = 0;
21496 return(ch);
21497 }
21500 /*===========================================================================*
21501 * set_leds *
21502 *===========================================================================*/
21503 PRIVATE void set_leds()
21504 {
21505 /* Set the LEDs on the caps lock and num lock keys */
21506
21507 unsigned leds;
21508
21509 if (!pc_at) return; /* PC/XT doesn't have LEDs */
21510
21511 /* encode LED bits */
21512 leds = (slock << 0) | (numlock << 1) | (capslock << 2);
21513
21514 kb_wait(); /* wait for buffer empty */
21515 out_byte(KEYBD, LED_CODE); /* prepare keyboard to accept LED values */
21516 kb_ack(); /* wait for ack response */
21517
21518 kb_wait(); /* wait for buffer empty */
21519 out_byte(KEYBD, leds); /* give keyboard LED values */
21520 kb_ack(); /* wait for ack response */
21521 }
21524 /*==========================================================================*
21525 * kb_wait *
21526 *==========================================================================*/
21527 PRIVATE int kb_wait()
21528 {
21529 /* Wait until the controller is ready; return zero if this times out. */
21530
21531 int retries;
21532
21533 retries = MAX_KB_BUSY_RETRIES + 1;
21534 while (--retries != 0 && in_byte(KB_STATUS) & KB_BUSY)
21535 ; /* wait until not busy */
21536 return(retries); /* nonzero if ready */
21537 }
21540 /*==========================================================================*
21541 * kb_ack *
21542 *==========================================================================*/
21543 PRIVATE int kb_ack()
21544 {
21545 /* Wait until kbd acknowledges last command; return zero if this times out. */
21546
21547 int retries;
21548
21549 retries = MAX_KB_ACK_RETRIES + 1;
21550 while (--retries != 0 && in_byte(KEYBD) != KB_ACK)
21551 ; /* wait for ack */
21552 return(retries); /* nonzero if ack received */
21553 }
21555 /*===========================================================================*
21556 * kb_init *
21557 *===========================================================================*/
21558 PUBLIC void kb_init(tp)
21559 tty_t *tp;
21560 {
21561 /* Initialize the keyboard driver. */
21562
21563 register struct kb_s *kb;
21564
21565 /* Input function. */
21566 tp->tty_devread = kb_read;
21567
21568 kb = kb_addr();
21569
21570 /* Set up input queue. */
21571 kb->ihead = kb->itail = kb->ibuf;
21572
21573 /* Set initial values. */
21574 caps_off = 1;
21575 num_off = 1;
21576 slock_off = 1;
21577 esc = 0;
21578
21579 set_leds(); /* turn off numlock led */
21580
21581 scan_keyboard(); /* stop lockup from leftover keystroke */
21582
21583 put_irq_handler(KEYBOARD_IRQ, kbd_hw_int); /* set the interrupt handler */
21584 enable_irq(KEYBOARD_IRQ); /* safe now everything initialised! */
21585 }
21588 /*===========================================================================*
21589 * kbd_loadmap *
21590 *===========================================================================*/
21591 PUBLIC int kbd_loadmap(user_phys)
21592 phys_bytes user_phys;
21593 {
21594 /* Load a new keymap. */
21595
21596 phys_copy(user_phys, vir2phys(keymap), (phys_bytes) sizeof(keymap));
21597 return(OK);
21598 }
21601 /*===========================================================================*
21602 * func_key *
21603 *===========================================================================*/
21604 PRIVATE int func_key(scode)
21605 int scode; /* scan code for a function key */
21606 {
21607 /* This procedure traps function keys for debugging and control purposes. */
21608
21609 unsigned code;
21610
21611 code = map_key0(scode); /* first ignore modifiers */
21612 if (code < F1 || code > F12) return(FALSE); /* not our job */
21613
21614 switch (map_key(scode)) { /* include modifiers */
21615
21616 case F1: p_dmp(); break; /* print process table */
21617 case F2: map_dmp(); break; /* print memory map */
21618 case F3: toggle_scroll(); break; /* hardware vs. software scrolling */
21619
21620 #if ENABLE_NETWORKING
21621 case F5: dp_dump(); break; /* network statistics */
21622 #endif
21623 case CF7: sigchar(&tty_table[CONSOLE], SIGQUIT); break;
21624 case CF8: sigchar(&tty_table[CONSOLE], SIGINT); break;
21625 case CF9: sigchar(&tty_table[CONSOLE], SIGKILL); break;
21626 default: return(FALSE);
21627 }
21628 return(TRUE);
21629 }
21632 /*==========================================================================*
21633 * scan_keyboard *
21634 *==========================================================================*/
21635 PRIVATE int scan_keyboard()
21636 {
21637 /* Fetch the character from the keyboard hardware and acknowledge it. */
21638
21639 int code;
21640 int val;
21641
21642 code = in_byte(KEYBD); /* get the scan code for the key struck */
21643 val = in_byte(PORT_B); /* strobe the keyboard to ack the char */
21644 out_byte(PORT_B, val | KBIT); /* strobe the bit high */
21645 out_byte(PORT_B, val); /* now strobe it low */
21646 return code;
21647 }
21650 /*==========================================================================*
21651 * wreboot *
21652 *==========================================================================*/
21653 PUBLIC void wreboot(how)
21654 int how; /* 0 = halt, 1 = reboot, 2 = panic!, ... */
21655 {
21656 /* Wait for keystrokes for printing debugging info and reboot. */
21657
21658 int quiet, code;
21659 static u16_t magic = MEMCHECK_MAG;
21660 struct tasktab *ttp;
21661
21662 /* Mask all interrupts. */
21663 out_byte(INT_CTLMASK, ~0);
21664
21665 /* Tell several tasks to stop. */
21666 cons_stop();
21667 #if ENABLE_NETWORKING
21668 dp8390_stop();
21669 #endif
21670 floppy_stop();
21671 clock_stop();
21672
21673 if (how == RBT_HALT) {
21674 printf("System Haltedn");
21675 if (!mon_return) how = RBT_PANIC;
21676 }
21677
21678 if (how == RBT_PANIC) {
21679 /* A panic! */
21680 printf("Hit ESC to reboot, F-keys for debug dumpsn");
21681
21682 (void) scan_keyboard(); /* ack any old input */
21683 quiet = scan_keyboard();/* quiescent value (0 on PC, last code on AT)*/
21684 for (;;) {
21685 milli_delay(100); /* pause for a decisecond */
21686 code = scan_keyboard();
21687 if (code != quiet) {
21688 /* A key has been pressed. */
21689 if (code == ESC_SCAN) break; /* reboot if ESC typed */
21690 (void) func_key(code); /* process function key */
21691 quiet = scan_keyboard();
21692 }
21693 }
21694 how = RBT_REBOOT;
21695 }
21696
21697 if (how == RBT_REBOOT) printf("Rebootingn");
21698
21699 if (mon_return && how != RBT_RESET) {
21700 /* Reinitialize the interrupt controllers to the BIOS defaults. */
21701 intr_init(0);
21702 out_byte(INT_CTLMASK, 0);
21703 out_byte(INT2_CTLMASK, 0);
21704
21705 /* Return to the boot monitor. */
21706 if (how == RBT_HALT) {
21707 reboot_code = vir2phys("");
21708 } else
21709 if (how == RBT_REBOOT) {
21710 reboot_code = vir2phys("delay;boot");
21711 }
21712 level0(monitor);
21713 }
21714
21715 /* Stop BIOS memory test. */
21716 phys_copy(vir2phys(&magic), (phys_bytes) MEMCHECK_ADR,
21717 (phys_bytes) sizeof(magic));
21718
21719 if (protected_mode) {
21720 /* Use the AT keyboard controller to reset the processor.
21721 * The A20 line is kept enabled in case this code is ever
21722 * run from extended memory, and because some machines
21723 * appear to drive the fake A20 high instead of low just
21724 * after reset, leading to an illegal opode trap. This bug
21725 * is more of a problem if the fake A20 is in use, as it
21726 * would be if the keyboard reset were used for real mode.
21727 */
21728 kb_wait();
21729 out_byte(KB_COMMAND,
21730 KB_PULSE_OUTPUT | (0x0F & ~(KB_GATE_A20 | KB_RESET)));
21731 milli_delay(10);
21732
21733 /* If the nice method fails then do a reset. In protected
21734 * mode this means a processor shutdown.
21735 */
21736 printf("Hard reset...n");
21737 milli_delay(250);
21738 }
21739 /* In real mode, jumping to the reset address is good enough. */
21740 level0(reset);
21741 }
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/kernel/main.c
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
21800 /* This file contains the main program of MINIX. The routine main()
21801 * initializes the system and starts the ball rolling by setting up the proc
21802 * table, interrupt vectors, and scheduling each task to run to initialize
21803 * itself.
21804 *
21805 * The entries into this file are:
21806 * main: MINIX main program
21807 * panic: abort MINIX due to a fatal error
21808 */
21809
21810 #include "kernel.h"
21811 #include <signal.h>
21812 #include <unistd.h>
21813 #include <minix/callnr.h>
21814 #include <minix/com.h>
21815 #include "proc.h"
21816
21817
21818 /*===========================================================================*
21819 * main *
21820 *===========================================================================*/
21821 PUBLIC void main()
21822 {
21823 /* Start the ball rolling. */
21824
21825 register struct proc *rp;
21826 register int t;
21827 int sizeindex;
21828 phys_clicks text_base;
21829 vir_clicks text_clicks;
21830 vir_clicks data_clicks;
21831 phys_bytes phys_b;
21832 reg_t ktsb; /* kernel task stack base */
21833 struct memory *memp;
21834 struct tasktab *ttp;
21835
21836 /* Initialize the interrupt controller. */
21837 intr_init(1);
21838
21839 /* Interpret memory sizes. */
21840 mem_init();
21841
21842 /* Clear the process table.
21843 * Set up mappings for proc_addr() and proc_number() macros.
21844 */
21845 for (rp = BEG_PROC_ADDR, t = -NR_TASKS; rp < END_PROC_ADDR; ++rp, ++t) {
21846 rp->p_flags = P_SLOT_FREE;
21847 rp->p_nr = t; /* proc number from ptr */
21848 (pproc_addr + NR_TASKS)[t] = rp; /* proc ptr from number */
21849 }
21850
21851 /* Set up proc table entries for tasks and servers. The stacks of the
21852 * kernel tasks are initialized to an array in data space. The stacks
21853 * of the servers have been added to the data segment by the monitor, so
21854 * the stack pointer is set to the end of the data segment. All the
21855 * processes are in low memory on the 8086. On the 386 only the kernel
21856 * is in low memory, the rest if loaded in extended memory.
21857 */
21858
21859 /* Task stacks. */
21860 ktsb = (reg_t) t_stack;
21861
21862 for (t = -NR_TASKS; t <= LOW_USER; ++t) {
21863 rp = proc_addr(t); /* t's process slot */
21864 ttp = &tasktab[t + NR_TASKS]; /* t's task attributes */
21865 strcpy(rp->p_name, ttp->name);
21866 if (t < 0) {
21867 if (ttp->stksize > 0) {
21868 rp->p_stguard = (reg_t *) ktsb;
21869 *rp->p_stguard = STACK_GUARD;
21870 }
21871 ktsb += ttp->stksize;
21872 rp->p_reg.sp = ktsb;
21873 text_base = code_base >> CLICK_SHIFT;
21874 /* tasks are all in the kernel */
21875 sizeindex = 0; /* and use the full kernel sizes */
21876 memp = &mem[0]; /* remove from this memory chunk */
21877 } else {
21878 sizeindex = 2 * t + 2; /* MM, FS, INIT have their own sizes */
21879 }
21880 rp->p_reg.pc = (reg_t) ttp->initial_pc;
21881 rp->p_reg.psw = istaskp(rp) ? INIT_TASK_PSW : INIT_PSW;
21882
21883 text_clicks = sizes[sizeindex];
21884 data_clicks = sizes[sizeindex + 1];
21885 rp->p_map[T].mem_phys = text_base;
21886 rp->p_map[T].mem_len = text_clicks;
21887 rp->p_map[D].mem_phys = text_base + text_clicks;
21888 rp->p_map[D].mem_len = data_clicks;
21889 rp->p_map[S].mem_phys = text_base + text_clicks + data_clicks;
21890 rp->p_map[S].mem_vir = data_clicks; /* empty - stack is in data */
21891 text_base += text_clicks + data_clicks; /* ready for next, if server */
21892 memp->size -= (text_base - memp->base);
21893 memp->base = text_base; /* memory no longer free */
21894
21895 if (t >= 0) {
21896 /* Initialize the server stack pointer. Take it down one word
21897 * to give crtso.s something to use as "argc".
21898 */
21899 rp->p_reg.sp = (rp->p_map[S].mem_vir +
21900 rp->p_map[S].mem_len) << CLICK_SHIFT;
21901 rp->p_reg.sp -= sizeof(reg_t);
21902 }
21903
21904 #if _WORD_SIZE == 4
21905 /* Servers are loaded in extended memory if in 386 mode. */
21906 if (t < 0) {
21907 memp = &mem[1];
21908 text_base = 0x100000 >> CLICK_SHIFT;
21909 }
21910 #endif
21911 if (!isidlehardware(t)) lock_ready(rp); /* IDLE, HARDWARE neveready */
21912 rp->p_flags = 0;
21913
21914 alloc_segments(rp);
21915 }
21916
21917 proc[NR_TASKS+INIT_PROC_NR].p_pid = 1;/* INIT of course has pid 1 */
21918 bill_ptr = proc_addr(IDLE); /* it has to point somewhere */
21919 lock_pick_proc();
21920
21921 /* Now go to the assembly code to start running the current process. */
21922 restart();
21923 }
21926 /*===========================================================================*
21927 * panic *
21928 *===========================================================================*/
21929 PUBLIC void panic(s,n)
21930 _CONST char *s;
21931 int n;
21932 {
21933 /* The system has run aground of a fatal error. Terminate execution.
21934 * If the panic originated in MM or FS, the string will be empty and the
21935 * file system already syncked. If the panic originates in the kernel, we are
21936 * kind of stuck.
21937 */
21938
21939 if (*s != 0) {
21940 printf("nKernel panic: %s",s);
21941 if (n != NO_NUM) printf(" %d", n);
21942 printf("n");
21943 }
21944 wreboot(RBT_PANIC);
21945 }
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
src/kernel/mcd.c
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
22000 /* This file contains the driver for a Mitsumi cdrom controller.
22001 *
22002 * The file contains one entry point:
22003 *
22004 * mcd_task: main entry when system is brought up
22005 *
22006 * Mar 30 1995 Author: Michel R. Prevenier
22007 */
22008
22009
22010 #include "kernel.h"
22011 #include "driver.h"
22012 #include "drvlib.h"
22013 #include <minix/cdrom.h>
22014 #include <sys/ioctl.h>
22015
22016 #if ENABLE_MITSUMI_CDROM
22017
22018 #define MCD_DEBUG 0 /* debug level */
22019
22020 /* Default IRQ. */
22021 #define MCD_IRQ 10
22022
22023 /* Default I/O ports (offset from base address */
22024 #define MCD_IO_BASE_ADDRESS 0x300
22025 #define MCD_DATA_PORT (mcd_io_base+0)
22026 #define MCD_FLAG_PORT (mcd_io_base+1)
22027 #define MCD_CONTROL_PORT (mcd_io_base+2)
22028
22029
22030 /* Miscellaneous constants. */
22031 #define MCD_SKIP 150 /* Skip first 150 blocks on cdrom */
22032 #define MCD_BLOCK_SIZE 2048 /* Block size in cooked mode */
22033 #define MCD_BLOCK_SHIFT 11 /* for division */
22034 #define MCD_BLOCK_MASK 2047 /* and remainder */
22035 #define BYTES_PER_SECTOR 2048 /* Nr. of bytes in a sector */
22036 #define SECTORS_PER_SECOND 75 /* Nr. of sectors in a second */
22037 #define SECONDS_PER_MINUTE 60 /* You never know, things change :-) */
22038 #define MCD_RETRIES 2 /* Number of retries for a command */
22039 #define REPLY_DELAY 5000 /* Count to wait for a reply */
22040 #define MAX_TRACKS 104 /* Maximum nr. of tracks */
22041 #define LEAD_OUT 0xAA /* Lead out track is always 0xAA */
22042 #define SUB_PER_DRIVE (NR_PARTITIONS * NR_PARTITIONS)
22043
22044
22045 /* Drive commands */
22046 #define MCD_GET_VOL_INFO 0x10 /* Read volume information */
22047 #define MCD_GET_Q_CHANNEL 0x20 /* Read q-channel information */
22048 #define MCD_GET_STATUS 0x40 /* Read status of drive */
22049 #define MCD_SET_MODE 0x50 /* Set transmission mode */
22050 #define MCD_RESET 0x60 /* Reset controller */
22051 #define MCD_STOP_AUDIO 0x70 /* Stop audio playing */
22052 #define MCD_SET_DRIVE_MODE 0xA0 /* Set drive mode */
22053 #define MCD_READ_FROM_TO 0xC0 /* Read from .. to .. */
22054 #define MCD_GET_VERSION 0xDC /* Get version number */
22055 #define MCD_STOP 0xF0 /* Stop everything */
22056 #define MCD_EJECT 0xF6 /* Eject cd */
22057 #define MCD_PICKLE 0x04 /* Needed for newer drive models */
22058
22059
22060 /* Command bits for MCD_SET_MODE command */
22061 #define MCD_MUTE_DATA 0x01 /* 1 = Don't play back data as audio */
22062 #define MCD_GET_TOC 0x04 /* 0 = Get toc on next GET_Q_CHANNEL */
22063 #define MCD_ECC_MODE 0x20 /* 0 = Use secondary ecc */
22064 #define MCD_DATALENGTH 0x40 /* 0 = Read user data only */
22065 #define MCD_COOKED (MCD_MUTE_DATA)
22066 #define MCD_TOC (MCD_MUTE_DATA | MCD_GET_TOC)
22067
22068
22069 /* Status bits */
22070 #define MCD_CMD_ERROR 0x01 /* Command error */
22071 #define MCD_AUDIO_BUSY 0x02 /* Audio disk is playing */
22072 #define MCD_READ_ERROR 0x04 /* Read error */
22073 #define MCD_AUDIO_DISK 0x08 /* Audio disk is in */
22074 #define MCD_SPINNING 0x10 /* Motor is spinning */
22075 #define MCD_DISK_CHANGED 0x20 /* Disk has been removed or changed */