?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
disable debug
[AROS.git] / rom / devs / trackdisk / trackdisk_device.c
blobd53508ac5d523924688dd5ea9fab0d4627d56921
1 /*
2 Copyright © 1995-2014, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Amiga-style device for trackdisk
6 Lang: English
7 */
8
9 #include <devices/trackdisk.h>
10 #include <exec/resident.h>
11 #include <exec/errors.h>
12 #include <exec/memory.h>
13 #include <exec/lists.h>
14 #include <exec/alerts.h>
15 #include <exec/tasks.h>
16 #include <libraries/expansion.h>
17 #include <libraries/expansionbase.h>
18 #include <libraries/configvars.h>
19 #include <dos/filehandler.h>
20 #include <dos/dosextens.h>
21 #include <dos/dostags.h>
22 #include <clib/alib_protos.h>
23 #include <aros/symbolsets.h>
24 #include <aros/bootloader.h>
25 #include <oop/oop.h>
26
27 #include <proto/oop.h>
28 #include <proto/exec.h>
29 #include <proto/expansion.h>
30 #include <proto/utility.h>
31 #include <proto/bootloader.h>
32 #include <proto/dos.h>
33 #include <asm/io.h>
34
35 #include <SDI/SDI_interrupt.h>
36
37 #include "trackdisk_device.h"
38 #include "trackdisk_hw.h"
39
40 #include LC_LIBDEFS_FILE
41
42 #define DEBUG 0
43 #include <aros/debug.h>
44
45 #undef kprintf
46
47 int td_getbyte(unsigned char *, struct TrackDiskBase *);
48 int td_sendbyte(unsigned char, struct TrackDiskBase *);
49 ULONG TD_InitTask(struct TrackDiskBase *);
50 static void TD_DevTask();
51 BOOL TD_PerformIO( struct IOExtTD *, struct TrackDiskBase *);
52
53 struct TDU *TD_InitUnit(ULONG num, struct TrackDiskBase *tdb)
54 {
55 struct TDU *unit;
56 struct ExpansionBase *ExpansionBase = NULL;
57 struct DeviceNode *devnode;
58 IPTR *pp;
59 TEXT dosdevname[4] = "DF0", *handler = "FastFileSystem";
60 UWORD len;
61
62 /* Try to get memory for structure */
63 unit = AllocMem(sizeof(struct TDU), MEMF_PUBLIC | MEMF_CLEAR);
64
65 if (!tdb->td_nomount)
66 ExpansionBase = (struct ExpansionBase *)OpenLibrary("expansion.library",40);
67 if (unit)
68 {
69 unit->tdu_DiskIn = TDU_NODISK; /* Assume there is no floppy in there */
70 unit->pub.tdu_StepDelay = 4; /* Standard values here */
71 unit->pub.tdu_SettleDelay = 16;
72 unit->pub.tdu_RetryCnt = 3;
73 unit->pub.tdu_CalibrateDelay = 4;
74 unit->tdu_UnitNum=num;
75 unit->tdu_lastcyl = -1;
76 unit->tdu_lasthd = -1;
77 NEWLIST(&unit->tdu_Listeners);
78
79 /* Alloc memory for track buffering */
80 unit->td_DMABuffer = AllocMem(DP_SECTORS * 512, MEMF_CLEAR | MEMF_24BITDMA);
81
82 if (!unit->td_DMABuffer)
83 {
84 Alert(AT_DeadEnd | AO_TrackDiskDev | AG_NoMemory);
85 }
86
87 /* If buffer doesn't fit into DMA page realloc it */
88 /* FIXME: we should ensure that the buffer is suitable the first time,
89 either by using an aligned memory allocation function or by
90 allocating twice as much as needed and manually aligning */
91 if (( (((ULONG)(IPTR)unit->td_DMABuffer + DP_SECTORS*512) & 0xffff0000) -
92 ((ULONG)(IPTR)unit->td_DMABuffer&0xffff0000) ) != 0)
93 {
94 APTR buffer;
95
96 buffer = AllocMem(DP_SECTORS * 512, MEMF_CLEAR | MEMF_24BITDMA);
97 if (!buffer)
98 {
99 Alert(AT_DeadEnd | AO_TrackDiskDev | AG_NoMemory);
100 }
101
102 FreeMem(unit->td_DMABuffer, DP_SECTORS*512);
103 unit->td_DMABuffer = buffer;
104 }
105 /* Store the unit in TDBase */
106 tdb->td_Units[num] = unit;
107
108 if (ExpansionBase)
109 {
110 D(bug("TD: Adding bootnode\n"));
111 pp = (IPTR *)AllocMem(sizeof(struct DosEnvec)+sizeof(IPTR)*4,MEMF_PUBLIC|MEMF_CLEAR);
112
113 if (pp)
114 {
115 dosdevname[2] += num;
116 pp[0] = (IPTR)dosdevname;
117 pp[1] = (IPTR)MOD_NAME_STRING;
118 pp[2] = num;
119 pp[DE_TABLESIZE + 4] = DE_BOOTBLOCKS;
120 pp[DE_SIZEBLOCK + 4] = 128;
121 pp[DE_NUMHEADS + 4] = 2;
122 pp[DE_SECSPERBLOCK + 4] = 1;
123 pp[DE_BLKSPERTRACK + 4] = 18;
124 pp[DE_RESERVEDBLKS + 4] = 2;
125 pp[DE_LOWCYL + 4] = 0;
126 pp[DE_HIGHCYL + 4] = 79;
127 pp[DE_NUMBUFFERS + 4] = 10;
128 pp[DE_BUFMEMTYPE + 4] = MEMF_PUBLIC | MEMF_24BITDMA;
129 pp[DE_MAXTRANSFER + 4] = 0x00200000;
130 pp[DE_MASK + 4] = 0x7FFFFFFE;
131 pp[DE_BOOTPRI + 4] = 5;
132 pp[DE_DOSTYPE + 4] = 0;
133 pp[DE_BOOTBLOCKS + 4] = 2;
134 devnode = MakeDosNode(pp);
135
136 if (devnode)
137 {
138 len = strlen(handler);
139 devnode->dn_Handler = MKBADDR(AllocMem(
140 AROS_BSTR_MEMSIZE4LEN(len), MEMF_PUBLIC | MEMF_CLEAR)
141 );
142
143 if (devnode->dn_Handler != BNULL)
144 {
145 CopyMem(handler, AROS_BSTR_ADDR(devnode->dn_Handler),
146 len);
147 AROS_BSTR_setstrlen(devnode->dn_Handler, len);
148 AddBootNode(pp[DE_BOOTPRI + 4], 0, devnode, NULL);
149 }
150 }
151 }
152 }
153 }
154 if (ExpansionBase)
155 {
156 CloseLibrary((struct Library *)ExpansionBase);
157 }
158 return (unit);
159 }
160
161 static AROS_INTH1(td_floppytimer, struct TrackDiskBase *, TDBase)
162 {
163 AROS_INTFUNC_INIT
164
165 // Does anyone wait for io?
166 if (TDBase->td_inttmo)
167 {
168 // Decrease timeout
169 TDBase->td_inttmo--;
170 // timeout?
171 if (!TDBase->td_inttmo)
172 {
173 Signal(&TDBase->td_TaskData->td_Task,(1L << TDBase->td_TmoBit));
174 }
175 }
176
177 return FALSE;
178
179 AROS_INTFUNC_EXIT
180 }
181
182 static AROS_INTH1(td_floppyint, struct TrackDiskBase *, TDBase)
183 {
184 AROS_INTFUNC_INIT
185
186 Signal(&TDBase->td_TaskData->td_Task,(1L << TDBase->td_IntBit));
187
188 return FALSE;
189
190 AROS_INTFUNC_EXIT
191 }
192
193 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR TDBase)
194 {
195 struct BootLoaderBase *BootLoaderBase;
196 ULONG i;
197 UBYTE drives;
198 struct Interrupt *irq;
199
200 D(bug("TD: Init\n"));
201
202 /* First thing, are we disabled from the bootloader? */
203 if ((BootLoaderBase = OpenResource("bootloader.resource")))
204 {
205 struct List *list;
206 struct Node *node;
207
208 list = (struct List *)GetBootInfo(BL_Args);
209 if (list)
210 {
211 ForeachNode(list,node)
212 {
213 if (0 == strncmp(node->ln_Name,"floppy=",5))
214 {
215 if (strstr(&node->ln_Name[7], "disabled"))
216 {
217 D(bug("[Floppy] Disabled with bootloader argument\n"));
218 return FALSE;
219 }
220 TDBase->td_nomount = (strstr(&node->ln_Name[7], "nomount") != NULL);
221 }
222 }
223 }
224 }
225
226 /* First we check if there are any floppy drives configured in BIOS */
227 /* We do this by reading CMOS byte 0x10 */
228 /* It should really reside in battclock.resource */
229 outb(0x10,0x70);
230 drives = inb(0x71);
231
232 if (drives == 0)
233 {
234 /* No drives here. abort */
235 D(bug("TD: No drives defined in BIOS\n"));
236 return FALSE;
237 }
238
239 for (i=0; i<TD_NUMUNITS; i++)
240 TDBase->td_Units[i] = NULL;
241
242 irq = &TDBase->td_FloppyInt;
243 irq->is_Node.ln_Type = NT_INTERRUPT;
244 irq->is_Node.ln_Pri=127; /* Set the highest pri */
245 irq->is_Node.ln_Name = (STRPTR)MOD_NAME_STRING;
246 irq->is_Code = (VOID_FUNC)td_floppyint;
247 irq->is_Data = (APTR)TDBase;
248
249 AddIntServer(INTB_KERNEL + 6, irq);
250
251 irq = &TDBase->td_TimerInt;
252 irq->is_Node.ln_Type = NT_INTERRUPT;
253 irq->is_Node.ln_Pri=10; /* Set the highest pri */
254 irq->is_Node.ln_Name = (STRPTR)MOD_NAME_STRING;
255 irq->is_Code = (VOID_FUNC)td_floppytimer;
256 irq->is_Data = (APTR)TDBase;
257
258 AddIntServer(INTB_KERNEL + 0, irq);
259
260 /* Swap drivebits around */
261 drives = ( (drives&0xf0)>>4 | (drives&0x0f)<<4 );
262
263 for (i=0;i<TD_NUMUNITS;i++)
264 {
265 /* We only want 3.5" 1.44MB drives */
266 if (((drives >> (4*i))&0x0f) == 4)
267 {
268 kprintf("[Floppy] Unit %d is a 1.44MB drive\n",i);
269 TD_InitUnit(i,TDBase);
270 }
271 }
272
273 /* Create the message processor task */
274 TD_InitTask(TDBase);
275
276 return TRUE;
277 }
278
279 static int GM_UNIQUENAME(Open)
280 (
281 LIBBASETYPEPTR TDBase,
282 struct IOExtTD *iotd,
283 ULONG unitnum,
284 ULONG flags
285 )
286 {
287 D(bug("TD: Open\n"));
288 iotd->iotd_Req.io_Error = IOERR_OPENFAIL;
289
290 /* Is the requested unitNumber valid? */
291 if (unitnum < TD_NUMUNITS)
292 {
293 struct TDU *unit;
294
295 iotd->iotd_Req.io_Device = (struct Device *)TDBase;
296
297 /* Get TDU structure */
298 unit = TDBase->td_Units[unitnum];
299 if (unit && (unit->tdu_Present)) {
300 iotd->iotd_Req.io_Unit = (struct Unit *)unit;
301 ((struct Unit *)unit)->unit_OpenCnt++;
302 iotd->iotd_Req.io_Error = 0;
303 }
304 }
305
306 return iotd->iotd_Req.io_Error == 0;
307
308 }
309
310 static int GM_UNIQUENAME(Close)
311 (
312 LIBBASETYPEPTR TDBase,
313 struct IOExtTD *iotd
314 )
315 {
316 iotd->iotd_Req.io_Unit->unit_OpenCnt --;
317
318 return TRUE;
319 }
320
321 ADD2INITLIB(GM_UNIQUENAME(Init), 0)
322 ADD2OPENDEV(GM_UNIQUENAME(Open), 0)
323 ADD2CLOSEDEV(GM_UNIQUENAME(Close), 0)
324
325 AROS_LH1(void, beginio,
326 AROS_LHA(struct IOExtTD *, iotd, A1),
327 struct TrackDiskBase *, TDBase, 5, TrackDisk)
328 {
329 AROS_LIBFUNC_INIT
330 struct TDU *tdu;
331
332 if (iotd->iotd_Req.io_Flags & IOF_QUICK)
333 {
334 switch(iotd->iotd_Req.io_Command)
335 {
336 case TD_CHANGESTATE:
337 tdu = (struct TDU *)iotd->iotd_Req.io_Unit;
338 if ((!(tdu->pub.tdu_PubFlags & TDPF_NOCLICK)) || (tdu->tdu_DiskIn == TDU_DISK))
339 break;
340 case CMD_READ:
341 case CMD_UPDATE:
342 case CMD_WRITE:
343 case TD_FORMAT:
344 case TD_MOTOR:
345 case TD_SEEK:
346 case ETD_READ:
347 case ETD_UPDATE:
348 case ETD_WRITE:
349 case ETD_FORMAT:
350 case ETD_MOTOR:
351 case ETD_SEEK:
352 PutMsg(&TDBase->td_TaskData->td_Port, &iotd->iotd_Req.io_Message);
353 iotd->iotd_Req.io_Flags &= ~IOF_QUICK;
354 return;
355 }
356 TD_PerformIO(iotd,TDBase);
357 return;
358 }
359 else
360 {
361 /* Forward to devicetask */
362 PutMsg(&TDBase->td_TaskData->td_Port, &iotd->iotd_Req.io_Message);
363 /* Not done quick */
364 iotd->iotd_Req.io_Flags &= ~IOF_QUICK;
365 return;
366 }
367 AROS_LIBFUNC_EXIT
368 }
369
370 AROS_LH1(LONG, abortio,
371 AROS_LHA(struct IOExtTD *, iotd, A1),
372 struct TrackDiskBase *, TDBase, 6, TrackDisk)
373 {
374 AROS_LIBFUNC_INIT
375 D(bug("TD: AbortIO\n"));
376 return IOERR_NOCMD;
377 AROS_LIBFUNC_EXIT
378 }
379
380 void TestInsert(struct TrackDiskBase *tdb, struct TDU *tdu)
381 {
382 UBYTE dir;
383 struct IOExtTD *iotd;
384
385 td_rseek(tdu->tdu_UnitNum,tdu->tdu_stepdir,1,tdb);
386 tdu->tdu_stepdir = !tdu->tdu_stepdir;
387 dir = (inb(FDC_DIR)>>7);
388 if (dir == 0)
389 {
390 D(bug("[Floppy] Insertion detected\n"));
391 td_recalibrate(tdu->tdu_UnitNum,1,0,tdb);
392 tdu->tdu_DiskIn = TDU_DISK;
393 tdu->pub.tdu_Counter++;
394 tdu->tdu_ProtStatus = td_getprotstatus(tdu->tdu_UnitNum,tdb);
395 Forbid();
396 ForeachNode(&tdu->tdu_Listeners,iotd)
397 {
398 Cause((struct Interrupt *)((struct IOExtTD *)iotd->iotd_Req.io_Data));
399 }
400 Permit();
401 }
402 }
403
404 BOOL TD_PerformIO( struct IOExtTD *iotd, struct TrackDiskBase *tdb)
405 {
406 struct TDU *tdu;
407 struct DriveGeometry *geo;
408 UBYTE temp;
409 BOOL reply;
410
411 reply = TRUE;
412 tdu = (struct TDU *)iotd->iotd_Req.io_Unit;
413 switch(iotd->iotd_Req.io_Command)
414 {
415 case ETD_CLEAR:
416 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
417 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
418 break;
419 }
420 case CMD_CLEAR:
421 tdu->tdu_flags = 0;
422 tdu->tdu_lastcyl = -1;
423 tdu->tdu_lasthd = -1;
424 iotd->iotd_Req.io_Error = 0;
425 break;
426 case ETD_READ:
427 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
428 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
429 break;
430 }
431 case CMD_READ:
432 tdu->tdu_Busy = TRUE;
433 iotd->iotd_Req.io_Error = td_read(iotd, tdb);
434 tdu->tdu_Busy = FALSE;
435 break;
436 case ETD_UPDATE:
437 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
438 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
439 break;
440 }
441 case CMD_UPDATE:
442 tdu->tdu_Busy = TRUE;
443 iotd->iotd_Req.io_Error = td_update(tdu, tdb);
444 tdu->tdu_Busy = FALSE;
445 break;
446 case ETD_WRITE:
447 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
448 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
449 break;
450 }
451 case CMD_WRITE:
452 tdu->tdu_Busy = TRUE;
453 iotd->iotd_Req.io_Error = td_write(iotd, tdb);
454 tdu->tdu_Busy = FALSE;
455 break;
456 case TD_ADDCHANGEINT:
457 Forbid();
458 AddTail(&tdu->tdu_Listeners,(struct Node *)iotd);
459 Permit();
460 reply = FALSE;
461 break;
462 case TD_CHANGENUM:
463 iotd->iotd_Req.io_Actual = tdu->pub.tdu_Counter;
464 iotd->iotd_Req.io_Error=0;
465 break;
466 case TD_CHANGESTATE:
467 if ((tdu->pub.tdu_PubFlags & TDPF_NOCLICK) && (tdu->tdu_DiskIn == TDU_NODISK)) {
468 TestInsert(tdb, tdu);
469 if (!tdu->tdu_MotorOn)
470 td_motoroff(tdu->tdu_UnitNum, tdb);
471 }
472 if (tdu->tdu_DiskIn == TDU_DISK)
473 {
474 /* test if disk is still in there */
475 temp = td_getDiskChange();
476 iotd->iotd_Req.io_Actual = temp;
477 tdu->tdu_DiskIn = temp ^ 1;
478 }
479 else
480 {
481 /* No disk in drive */
482 iotd->iotd_Req.io_Actual = 1;
483 }
484 iotd->iotd_Req.io_Error=0;
485 break;
486 case ETD_FORMAT:
487 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
488 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
489 break;
490 }
491 case TD_FORMAT:
492 tdu->tdu_Busy = TRUE;
493 iotd->iotd_Req.io_Error = td_format(iotd,tdb);
494 tdu->tdu_Busy = FALSE;
495 break;
496 case ETD_MOTOR:
497 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
498 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
499 break;
500 }
501 case TD_MOTOR:
502 iotd->iotd_Req.io_Error=0;
503 switch (iotd->iotd_Req.io_Length)
504 {
505 case 0:
506 tdu->tdu_MotorOn = 0;
507 td_motoroff(tdu->tdu_UnitNum,tdb);
508 break;
509 case 1:
510 tdu->tdu_MotorOn = 1;
511 td_motoron(tdu->tdu_UnitNum,tdb,TRUE);
512 break;
513 default:
514 iotd->iotd_Req.io_Error = TDERR_NotSpecified;
515 break;
516 }
517 break;
518 case TD_PROTSTATUS:
519 iotd->iotd_Req.io_Actual = tdu->tdu_ProtStatus;
520 iotd->iotd_Req.io_Error=0;
521 break;
522 case TD_REMCHANGEINT:
523 Forbid();
524 Remove((struct Node *)iotd);
525 Permit();
526 break;
527 case TD_GETGEOMETRY:
528 geo = (struct DriveGeometry *)iotd->iotd_Req.io_Data;
529 geo->dg_SectorSize = 512;
530 geo->dg_TotalSectors = DP_STOTAL;
531 geo->dg_Cylinders = DP_TRACKS;
532 geo->dg_CylSectors = DP_SECTORS*2;
533 geo->dg_Heads = 2;
534 geo->dg_TrackSectors = DP_SECTORS;
535 geo->dg_BufMemType = MEMF_PUBLIC;
536 geo->dg_DeviceType = DG_DIRECT_ACCESS;
537 geo->dg_Flags = DGF_REMOVABLE;
538 iotd->iotd_Req.io_Error=0;
539 break;
540 case TD_GETDRIVETYPE:
541 iotd->iotd_Req.io_Actual = DRIVE3_5;
542 iotd->iotd_Req.io_Error=0;
543 break;
544 case TD_GETNUMTRACKS:
545 iotd->iotd_Req.io_Actual = DP_TRACKS*2;
546 iotd->iotd_Req.io_Error=0;
547 break;
548 case ETD_SEEK:
549 if (iotd->iotd_Count > tdu->pub.tdu_Counter) {
550 iotd->iotd_Req.io_Error = TDERR_DiskChanged;
551 break;
552 }
553 case TD_SEEK:
554 temp = (iotd->iotd_Req.io_Offset >> 10) / DP_SECTORS;
555 tdu->tdu_MotorOn = 1;
556 iotd->iotd_Req.io_Error = td_recalibrate(tdu->tdu_UnitNum, 0, temp, tdb);
557 break;
558 default:
559 /* Not supported */
560 D(bug("TD: Unknown command received\n"));
561 iotd->iotd_Req.io_Error = IOERR_NOCMD;
562 break;
563 } /* switch(iotd->iotd_Req.io_Command) */
564 return (reply);
565 }
566
567 ULONG TD_InitTask(struct TrackDiskBase *tdb)
568 {
569 struct TaskData *t;
570 struct MemList *ml;
571 struct Task *me;
572
573 /* Allocate Task Data structure */
574 t = AllocMem(sizeof(struct TaskData), MEMF_PUBLIC|MEMF_CLEAR);
575 /* Allocate Stack space */
576 if ((t) && ((t->td_Stack = AllocMem(STACK_SIZE, MEMF_PUBLIC|MEMF_CLEAR)) == NULL))
577 {
578 FreeMem(t, sizeof(struct TaskData));
579 t = NULL;
580 }
581 /* Allocate MemEntry for this task */
582 ml = (struct MemList *)AllocMem(sizeof(struct MemList), MEMF_PUBLIC|MEMF_CLEAR);
583
584 /* Find the current task */
585 me = FindTask(NULL);
586
587 if (t && ml)
588 {
589 D(bug("TD: Creating devicetask..."));
590 /* Save stack info into task structure */
591 t->td_Task.tc_SPLower = t->td_Stack;
592 t->td_Task.tc_SPUpper = (BYTE *)t->td_Stack + STACK_SIZE;
593 t->td_Task.tc_SPReg = (BYTE *)t->td_Task.tc_SPUpper - SP_OFFSET - sizeof(APTR);
594
595 /* Init MsgPort */
596 NEWLIST(&t->td_Port.mp_MsgList);
597 t->td_Port.mp_Node.ln_Type = NT_MSGPORT;
598 t->td_Port.mp_Flags = PA_SIGNAL;
599 t->td_Port.mp_SigBit = SIGBREAKB_CTRL_F;
600 t->td_Port.mp_SigTask = &t->td_Task;
601 t->td_Port.mp_Node.ln_Name = "trackdisk.device";
602
603 /* Init MemList */
604 ml->ml_NumEntries = 1;
605 ml->ml_ME[0].me_Addr = t;
606 ml->ml_ME[0].me_Length = sizeof(struct TaskData);
607 NEWLIST(&t->td_Task.tc_MemEntry);
608 AddHead(&t->td_Task.tc_MemEntry, &ml->ml_Node);
609
610 /* Init Task structure */
611 t->td_Task.tc_Node.ln_Name = "trackdisk.task";
612 t->td_Task.tc_Node.ln_Type = NT_TASK;
613 t->td_Task.tc_Node.ln_Pri = 5;
614 t->td_Task.tc_UserData = me;
615
616 tdb->td_TaskData = t;
617
618 struct TagItem task_Tags[] = {
619 { TASKTAG_ARG1, (IPTR)tdb },
620 { TAG_DONE, 0 },
621 };
622 /* Add task to system task list */
623 NewAddTask(&t->td_Task, &TD_DevTask, NULL, task_Tags );
624
625 /* Wait until started */
626 Wait(SIGBREAKF_CTRL_F);
627
628 D(bug(" OK\n"));
629
630 return 1;
631 }
632 else
633 {
634 if (t)
635 {
636 if (t->td_Stack) FreeMem(t->td_Stack, STACK_SIZE);
637 FreeMem(t, sizeof(struct TaskData));
638 }
639 if (ml) FreeMem(ml, sizeof(struct MemList));
640 }
641
642 return 0;
643 }
644
645 static void TD_DevTask(struct TrackDiskBase *tdb)
646 {
647 struct TaskData *td;
648 struct IOExtTD *iotd;
649 struct TDU *tdu;
650 ULONG tasig,tisig,sigs,i;
651 UBYTE dir;
652
653 D(bug("[TDTask] TD_DevTask(tdb=%p)\n", tdb));
654
655 td = tdb->td_TaskData;
656
657 D(bug("[TDTask] TD_DevTask: struct TaskData @ %p\n", td));
658
659 tdb->td_IntBit = AllocSignal(-1);
660 tdb->td_TmoBit = AllocSignal(-1);
661 tdb->td_TimerMP = CreateMsgPort();
662 tdb->td_TimerIO = (struct timerequest *) CreateIORequest(tdb->td_TimerMP, sizeof(struct timerequest));
663 OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)tdb->td_TimerIO, 0);
664
665 /* Initialize FDC */
666 td_dinit(tdb);
667
668 /* Initial check for floppies */
669 for (i=0;i<TD_NUMUNITS;i++)
670 {
671 if(tdb->td_Units[i])
672 {
673 td_rseek(i, 0, 1, tdb);
674 tdb->td_Units[i]->tdu_Present = !td_recalibrate(tdb->td_Units[i]->tdu_UnitNum,1,0,tdb);
675 tdb->td_Units[i]->pub.tdu_CurrTrk = 0;
676 tdb->td_Units[i]->tdu_DiskIn = (td_getDiskChange() ^ 1);
677 tdb->td_Units[i]->tdu_ProtStatus = td_getprotstatus(i,tdb);
678 tdb->td_Units[i]->tdu_Busy = FALSE;
679 tdb->td_Units[i]->tdu_stepdir = 0;
680 if (((tdb->td_Units[i]->pub.tdu_PubFlags & TDPF_NOCLICK) && (tdb->td_Units[i]->tdu_DiskIn == TDU_NODISK))
681 || (!tdb->td_Units[i]->tdu_Present))
682 td_motoroff(i, tdb);
683 D(bug("Drive %d presence: %ld\n", i, tdb->td_Units[i]->tdu_Present));
684 }
685 }
686
687 tasig = 1L << td->td_Port.mp_SigBit;
688 tisig = 1L << tdb->td_TimerMP->mp_SigBit;
689
690 /* Reply to startup message */
691 Signal(td->td_Task.tc_UserData,SIGBREAKF_CTRL_F);
692
693 tdb->td_TimerIO->tr_node.io_Command = TR_ADDREQUEST;
694 tdb->td_TimerIO->tr_time.tv_secs = 2;
695 tdb->td_TimerIO->tr_time.tv_micro = 500000;
696 SendIO((struct IORequest *)tdb->td_TimerIO);
697
698 /* Endless task loop */
699 for(;;)
700 {
701 sigs = 0L;
702 sigs = Wait(tasig | tisig); /* Wait for a message */
703 /* If unit was not active process message */
704 if (sigs & tasig)
705 {
706 /* We received a message. Deal with it */
707 while((iotd = (struct IOExtTD *)GetMsg(&td->td_Port)) != NULL)
708 {
709 /* Execute command */
710 if (TD_PerformIO( iotd, tdb))
711 {
712 /* Finish message */
713 ReplyMsg((struct Message *)iotd);
714 }
715 }
716 }
717 if (sigs & tisig)
718 {
719 /* We were woken up by the timer. */
720 WaitIO((struct IORequest *)tdb->td_TimerIO);
721 for(i=0;i<TD_NUMUNITS;i++)
722 {
723 /* If there is no floppy in drive, scan for changes */
724 if (tdb->td_Units[i])
725 {
726 tdu = tdb->td_Units[i];
727 switch (tdu->tdu_DiskIn)
728 {
729 case TDU_NODISK:
730 /*
731 Unfortunately "NoClick" technology which works on Amiga will not
732 work on PC because i82077 does not send step pulse when told to
733 seek to "-1" track and the drive can't recognize disk insertion.
734 Many thanks to Intel! :-(((
735
736 Here we use another technique: in NoClick mode we just do nothing
737 if the disk is not in drive. We can perform this test only once
738 inside TD_CHANGESTATE command which is invoked by DISKCHANGE
739 CLI command. This means that we'll have to issue DISKCHANGE command
740 manually after we insert the disk, but this is probably better
741 than those clicks.
742 */
743 if (tdu->pub.tdu_PubFlags & TDPF_NOCLICK) {
744 if (!tdu->tdu_MotorOn)
745 td_motoroff(tdu->tdu_UnitNum, tdb);
746 } else
747 TestInsert(tdb, tdu);
748 break;
749 case TDU_DISK:
750 /*
751 Fortunately this part is completely silent so we don't have to
752 do any extra mess here
753 */
754 if (!tdu->tdu_Busy)
755 {
756 if (!tdu->tdu_MotorOn)
757 td_motoron(tdu->tdu_UnitNum,tdb,FALSE);
758 dir = (inb(FDC_DIR)>>7);
759 if (!tdu->tdu_MotorOn)
760 td_motoroff(tdu->tdu_UnitNum,tdb);
761 if (dir == 1)
762 {
763 D(bug("[Floppy] Removal detected\n"));
764 /* Go to cylinder 0 */
765 td_recalibrate(tdu->tdu_UnitNum,1,0,tdb);
766 tdu->tdu_DiskIn = TDU_NODISK;
767 tdu->pub.tdu_Counter++;
768 Forbid();
769 ForeachNode(&tdu->tdu_Listeners,iotd)
770 {
771 Cause((struct Interrupt *)((struct IOExtTD *)iotd->iotd_Req.io_Data));
772 }
773 Permit();
774 tdu->tdu_stepdir = 0;
775 }
776 }
777 break;
778 }
779 }
780 }
781
782 /* Reload the timer again */
783 GetMsg(tdb->td_TimerMP);
784 tdb->td_TimerIO->tr_node.io_Command = TR_ADDREQUEST;
785 tdb->td_TimerIO->tr_time.tv_secs = 2;
786 tdb->td_TimerIO->tr_time.tv_micro = 500000;
787 SendIO((struct IORequest *)tdb->td_TimerIO);
788 }
789 }
790 }
791
792
Mirror of AROS' svn.