OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or1ksim/] [peripheral/] [atahost.c] - Blame information for rev 22

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 19 jeremybenn
/* atahost.c -- ATA Host code simulation
2
 
3
   Copyright (C) 2002 Richard Herveille, rherveille@opencores.org
4
   Copyright (C) 2008 Embecosm Limited
5
 
6
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
7
 
8
   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.
9
 
10
   This program is free software; you can redistribute it and/or modify it
11
   under the terms of the GNU General Public License as published by the Free
12
   Software Foundation; either version 3 of the License, or (at your option)
13
   any later version.
14
 
15
   This program is distributed in the hope that it will be useful, but WITHOUT
16
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18
   more details.
19
 
20
   You should have received a copy of the GNU General Public License along
21
   with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
/* This program is commented throughout in a fashion suitable for processing
24
   with Doxygen. */
25
 
26
 
27
/* Autoconf and/or portability configuration */
28
#include "config.h"
29
#include "port.h"
30
 
31
/* System includes */
32
#include <stdlib.h>
33
 
34
/* Package includes */
35
#include "atahost.h"
36
#include "sim-config.h"
37
#include "abstract.h"
38
#include "pic.h"
39
#include "toplevel-support.h"
40
#include "sim-cmd.h"
41
 
42
 
43
/* default timing reset values */
44
#define PIO_MODE0_T1 6
45
#define PIO_MODE0_T2 28
46
#define PIO_MODE0_T4 2
47
#define PIO_MODE0_TEOC 23
48
 
49
#define DMA_MODE0_TM 4
50
#define DMA_MODE0_TD 21
51
#define DMA_MODE0_TEOC 21
52
 
53
 
54
/* reset and initialize ATA host core(s) */
55
static void
56
ata_reset (void *dat)
57
{
58
  struct ata_host *ata = dat;
59
 
60
  // reset the core registers
61
  ata->regs.ctrl = 0x0001;
62
  ata->regs.stat = (ata->dev_id << 28) | (ata->rev << 24);
63
  ata->regs.pctr = (ata->pio_mode0_teoc << ATA_TEOC) |
64
    (ata->pio_mode0_t4 << ATA_T4) |
65
    (ata->pio_mode0_t2 << ATA_T2) | (ata->pio_mode0_t1 << ATA_T1);
66
  ata->regs.pftr0 = ata->regs.pctr;
67
  ata->regs.pftr1 = ata->regs.pctr;
68
  ata->regs.dtr0 = (ata->dma_mode0_teoc << ATA_TEOC) |
69
    (ata->dma_mode0_td << ATA_TD) | (ata->dma_mode0_tm << ATA_TM);
70
  ata->regs.dtr1 = ata->regs.dtr0;
71
  ata->regs.txb = 0;
72
 
73
  // inform simulator about new read/write delay timings
74
  adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),
75
                   ata_pio_delay (ata->regs.pctr));
76
 
77
  /* the reset bit in the control register 'ctrl' is set, reset connect ata-devices */
78
  ata_devices_hw_reset (&ata->devices, 1);
79
}
80
 
81
/* ========================================================================= */
82
 
83
 
84
/* Assert interrupt */
85
void
86
ata_int (void *dat)
87
{
88
  struct ata_host *ata = dat;
89
  if (!(ata->regs.stat & ATA_IDEIS))
90
    {
91
      ata->regs.stat |= ATA_IDEIS;
92
      report_interrupt (ata->irq);
93
    }
94
}
95
 
96
/* ========================================================================= */
97
 
98
 
99
/*
100
  Read a register
101
*/
102
static uint32_t
103
ata_read32 (oraddr_t addr, void *dat)
104
{
105
  struct ata_host *ata = dat;
106
 
107
  /* determine if ata_host or ata_device addressed */
108
  if (is_ata_hostadr (addr))
109
    {
110
      // Accesses to internal register take 2cycles
111
      adjust_rw_delay (ata->mem, 2, 2);
112
 
113
      switch (addr)
114
        {
115
        case ATA_CTRL:
116
          return ata->regs.ctrl;
117
 
118
        case ATA_STAT:
119
          return ata->regs.stat;
120
 
121
        case ATA_PCTR:
122
          return ata->regs.pctr;
123
 
124
        case ATA_PFTR0:
125
          return ata->dev_id > 1 ? ata->regs.pftr0 : 0;
126
 
127
        case ATA_PFTR1:
128
          return ata->dev_id > 1 ? ata->regs.pftr1 : 0;
129
 
130
        case ATA_DTR0:
131
          return ata->dev_id > 2 ? ata->regs.dtr0 : 0;
132
 
133
        case ATA_DTR1:
134
          return ata->dev_id > 2 ? ata->regs.dtr1 : 0;
135
 
136
        case ATA_RXB:
137
          return ata->dev_id > 2 ? ata->regs.rxb : 0;
138
 
139
        default:
140
          return 0;
141
        }
142
    }
143
 
144
  /* check if the controller is enabled */
145
  if (ata->regs.ctrl & ATA_IDE_EN)
146
    {
147
      // make sure simulator uses correct read/write delay timings
148
      if (((addr & 0x7f) == ATA_DR) && ata->dev_id > 1)
149
        {
150
          if (ata->dev_sel)
151
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr1),
152
                             ata_pio_delay (ata->regs.pftr1));
153
          else
154
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr0),
155
                             ata_pio_delay (ata->regs.pftr0));
156
        }
157
      else
158
        adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),
159
                         ata_pio_delay (ata->regs.pctr));
160
 
161
      return ata_devices_read (&ata->devices, addr & 0x7f);
162
    }
163
  return 0;
164
}
165
 
166
/* ========================================================================= */
167
 
168
 
169
/*
170
  Write a register
171
*/
172
static void
173
ata_write32 (oraddr_t addr, uint32_t value, void *dat)
174
{
175
  struct ata_host *ata = dat;
176
 
177
  /* determine if ata_host or ata_device addressed */
178
  if (is_ata_hostadr (addr))
179
    {
180
      // Accesses to internal register take 2cycles
181
      adjust_rw_delay (ata->mem, 2, 2);
182
 
183
      switch (addr)
184
        {
185
        case ATA_CTRL:
186
          ata->regs.ctrl = value;
187
 
188
          /* check if reset bit set, if so reset ata-devices    */
189
          if (value & ATA_RST)
190
            ata_devices_hw_reset (&ata->devices, 1);
191
          else
192
            ata_devices_hw_reset (&ata->devices, 0);
193
          break;
194
 
195
        case ATA_STAT:
196
          if (!(value & ATA_IDEIS) && (ata->regs.stat & ATA_IDEIS))
197
            {
198
              clear_interrupt (ata->irq);
199
              ata->regs.stat &= ~ATA_IDEIS;
200
            }
201
          break;
202
 
203
        case ATA_PCTR:
204
          ata->regs.pctr = value;
205
          break;
206
 
207
        case ATA_PFTR0:
208
          ata->regs.pftr0 = value;
209
          break;
210
 
211
        case ATA_PFTR1:
212
          ata->regs.pftr1 = value;
213
          break;
214
 
215
        case ATA_DTR0:
216
          ata->regs.dtr0 = value;
217
          break;
218
 
219
        case ATA_DTR1:
220
          ata->regs.dtr1 = value;
221
          break;
222
 
223
        case ATA_TXB:
224
          ata->regs.txb = value;
225
          break;
226
 
227
        default:
228
          /* ERROR-macro currently only supports simple strings. */
229
          /*
230
             fprintf(stderr, "ERROR  : Unknown register for OCIDEC(%1d).\n", DEV_ID );
231
 
232
             Tried to show some useful info here.
233
             But when using 'DM'-simulator-command, the screen gets filled with these messages.
234
             Thereby eradicating the usefulness of the message
235
           */
236
          break;
237
        }
238
      return;
239
    }
240
 
241
  /* check if the controller is enabled */
242
  if (ata->regs.ctrl & ATA_IDE_EN)
243
    {
244
      // make sure simulator uses correct read/write delay timings
245
      if (((addr & 0x7f) == ATA_DR) && (ata->dev_id > 1))
246
        {
247
          if (ata->dev_sel)
248
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr1),
249
                             ata_pio_delay (ata->regs.pftr1));
250
          else
251
            adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pftr0),
252
                             ata_pio_delay (ata->regs.pftr0));
253
        }
254
      else
255
        adjust_rw_delay (ata->mem, ata_pio_delay (ata->regs.pctr),
256
                         ata_pio_delay (ata->regs.pctr));
257
 
258
      if ((addr & 0x7f) == ATA_DHR)
259
        ata->dev_sel = value & ATA_DHR_DEV;
260
 
261
      ata_devices_write (&ata->devices, addr & 0x7f, value);
262
    }
263
}
264
 
265
/* ========================================================================= */
266
 
267
 
268
/* Dump status */
269
static void
270
ata_status (void *dat)
271
{
272
  struct ata_host *ata = dat;
273
 
274
  if (ata->baseaddr == 0)
275
    return;
276
 
277
  PRINTF ("\nOCIDEC-%1d at: 0x%" PRIxADDR "\n", ata->dev_id, ata->baseaddr);
278
  PRINTF ("ATA CTRL     : 0x%08" PRIx32 "\n", ata->regs.ctrl);
279
  PRINTF ("ATA STAT     : 0x%08" PRIx32 "\n", ata->regs.stat);
280
  PRINTF ("ATA PCTR     : 0x%08" PRIx32 "n", ata->regs.pctr);
281
 
282
  if (ata->dev_id > 1)
283
    {
284
      PRINTF ("ATA FCTR0    : 0x%08" PRIx32 "\n", ata->regs.pftr0);
285
      PRINTF ("ATA FCTR1    : 0x%08" PRIx32 "\n", ata->regs.pftr1);
286
    }
287
 
288
  if (ata->dev_id > 2)
289
    {
290
      PRINTF ("ATA DTR0     : 0x%08" PRIx32 "\n", ata->regs.dtr0);
291
      PRINTF ("ATA DTR1     : 0x%08" PRIx32 "\n", ata->regs.dtr1);
292
      PRINTF ("ATA TXD      : 0x%08" PRIx32 "\n", ata->regs.txb);
293
      PRINTF ("ATA RXD      : 0x%08" PRIx32 "\n", ata->regs.rxb);
294
    }
295
}
296
 
297
/* ========================================================================= */
298
 
299
/*----------------------------------------------------[ ATA Configuration ]---*/
300
static unsigned int conf_dev;
301
 
302
static void
303
ata_baseaddr (union param_val val, void *dat)
304
{
305
  struct ata_host *ata = dat;
306
  ata->baseaddr = val.addr_val;
307
}
308
 
309
static void
310
ata_irq (union param_val val, void *dat)
311
{
312
  struct ata_host *ata = dat;
313
  ata->irq = val.int_val;
314
}
315
 
316
static void
317
ata_dev_id (union param_val val, void *dat)
318
{
319
  struct ata_host *ata = dat;
320
  if (val.int_val < 1 || val.int_val > 3)
321
    {
322
      fprintf (stderr, "Peripheral ATA: Unknown device id %d, useing 1\n",
323
               val.int_val);
324
      ata->dev_id = 1;
325
      return;
326
    }
327
 
328
  ata->dev_id = val.int_val;
329
}
330
 
331
 
332
/*---------------------------------------------------------------------------*/
333
/*!Set the ATA revision
334
 
335
   This must be in the range 0-15, to fit in the relevant field. Anything
336
   larger is truncated with a warning.
337
 
338
   @param[in] val  The value to use
339
   @param[in] dat  The config data structure                                 */
340
/*---------------------------------------------------------------------------*/
341
static void
342
ata_rev (union param_val val, void *dat)
343
{
344
  struct ata_host *ata = dat;
345
 
346
  if (val.int_val > 0xf)
347
    {
348
      fprintf (stderr, "Warning: ATA rev > 4 bits: truncated\n");
349
    }
350
 
351
  ata->rev = val.int_val & 0xf;
352
}
353
 
354
static void
355
ata_pio_mode0_t1 (union param_val val, void *dat)
356
{
357
  struct ata_host *ata = dat;
358
 
359
  if (val.int_val < 0 || val.int_val > 255)
360
    {
361
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t1: %d\n",
362
               val.int_val);
363
      return;
364
    }
365
 
366
  ata->pio_mode0_t1 = val.int_val;
367
}
368
 
369
static void
370
ata_pio_mode0_t2 (union param_val val, void *dat)
371
{
372
  struct ata_host *ata = dat;
373
 
374
  if (val.int_val < 0 || val.int_val > 255)
375
    {
376
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t2: %d\n",
377
               val.int_val);
378
      return;
379
    }
380
 
381
  ata->pio_mode0_t2 = val.int_val;
382
}
383
 
384
static void
385
ata_pio_mode0_t4 (union param_val val, void *dat)
386
{
387
  struct ata_host *ata = dat;
388
 
389
  if (val.int_val < 0 || val.int_val > 255)
390
    {
391
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_t4: %d\n",
392
               val.int_val);
393
      return;
394
    }
395
 
396
  ata->pio_mode0_t4 = val.int_val;
397
}
398
 
399
static void
400
ata_pio_mode0_teoc (union param_val val, void *dat)
401
{
402
  struct ata_host *ata = dat;
403
 
404
  if (val.int_val < 0 || val.int_val > 255)
405
    {
406
      fprintf (stderr, "Peripheral ATA: Invalid pio_mode0_teoc: %d\n",
407
               val.int_val);
408
      return;
409
    }
410
 
411
  ata->pio_mode0_teoc = val.int_val;
412
}
413
 
414
static void
415
ata_dma_mode0_tm (union param_val val, void *dat)
416
{
417
  struct ata_host *ata = dat;
418
 
419
  if (val.int_val < 0 || val.int_val > 255)
420
    {
421
      fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_tm: %d\n",
422
               val.int_val);
423
      return;
424
    }
425
 
426
  ata->dma_mode0_tm = val.int_val;
427
}
428
 
429
static void
430
ata_dma_mode0_td (union param_val val, void *dat)
431
{
432
  struct ata_host *ata = dat;
433
 
434
  if (val.int_val < 0 || val.int_val > 255)
435
    {
436
      fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_td: %d\n",
437
               val.int_val);
438
      return;
439
    }
440
 
441
  ata->dma_mode0_td = val.int_val;
442
}
443
 
444
static void
445
ata_dma_mode0_teoc (union param_val val, void *dat)
446
{
447
  struct ata_host *ata = dat;
448
 
449
  if (val.int_val < 0 || val.int_val > 255)
450
    {
451
      fprintf (stderr, "Peripheral ATA: Invalid dma_mode0_teoc: %d\n",
452
               val.int_val);
453
      return;
454
    }
455
 
456
  ata->dma_mode0_teoc = val.int_val;
457
}
458
 
459
static void
460
ata_type (union param_val val, void *dat)
461
{
462
  struct ata_host *ata = dat;
463
  if (conf_dev <= 1)
464
    ata->devices.device[conf_dev].conf.type = val.int_val;
465
}
466
 
467
 
468
/*---------------------------------------------------------------------------*/
469
/*!Set the ATA file
470
 
471
   Free any previously allocated value. Only used if device type is 1.
472
 
473
   @param[in] val  The value to use
474
   @param[in] dat  The config data structure                                 */
475
/*---------------------------------------------------------------------------*/
476
static void
477
ata_file (union param_val val, void *dat)
478
{
479
  struct ata_host *ata = dat;
480
 
481
  if (conf_dev <= 1)
482
    {
483
      if (NULL != ata->devices.device[conf_dev].conf.file)
484
        {
485
          free (ata->devices.device[conf_dev].conf.file);
486
          ata->devices.device[conf_dev].conf.file = NULL;
487
        }
488
 
489
      if (!(ata->devices.device[conf_dev].conf.file = strdup (val.str_val)))
490
        {
491
          fprintf (stderr, "Peripheral ATA: Run out of memory\n");
492
          exit (-1);
493
        }
494
    }
495
}       /* ata_file() */
496
 
497
 
498
static void
499
ata_size (union param_val val, void *dat)
500
{
501
  struct ata_host *ata = dat;
502
  if (conf_dev <= 1)
503
    ata->devices.device[conf_dev].conf.size = val.int_val << 20;
504
}
505
 
506
static void
507
ata_packet (union param_val val, void *dat)
508
{
509
  struct ata_host *ata = dat;
510
  if (conf_dev <= 1)
511
    ata->devices.device[conf_dev].conf.packet = val.int_val;
512
}
513
 
514
static void
515
ata_enabled (union param_val val, void *dat)
516
{
517
  struct ata_host *ata = dat;
518
  ata->enabled = val.int_val;
519
}
520
 
521
static void
522
ata_heads (union param_val val, void *dat)
523
{
524
  struct ata_host *ata = dat;
525
  if (conf_dev <= 1)
526
    ata->devices.device[conf_dev].conf.heads = val.int_val;
527
}
528
 
529
static void
530
ata_sectors (union param_val val, void *dat)
531
{
532
  struct ata_host *ata = dat;
533
  if (conf_dev <= 1)
534
    ata->devices.device[conf_dev].conf.sectors = val.int_val;
535
}
536
 
537
static void
538
ata_firmware (union param_val val, void *dat)
539
{
540
  struct ata_host *ata = dat;
541
  if (conf_dev <= 1)
542
    if (!(ata->devices.device[conf_dev].conf.firmware = strdup (val.str_val)))
543
      {
544
        fprintf (stderr, "Peripheral ATA: Run out of memory\n");
545
        exit (-1);
546
      }
547
}
548
 
549
 
550
/*---------------------------------------------------------------------------*/
551
/*!Set the ATA multi-word DMA mode
552
 
553
   Must be -1, 0, 1 or 2.
554
 
555
   @param[in] val  The value to use
556
   @param[in] dat  The config data structure                                 */
557
/*---------------------------------------------------------------------------*/
558
static void
559
ata_mwdma (union param_val  val,
560
           void            *dat)
561
{
562
  struct ata_host *ata = dat;
563
 
564
  if ((val.int_val >= -1) && (val.int_val <= 2))
565
    {
566
      ata->devices.device[conf_dev].conf.mwdma = val.int_val;
567
    }
568
  else
569
    {
570
      fprintf (stderr, "Warning: invalid ATA multi-word DMA mode: ignored\n");
571
    }
572
}       /* ata_mwdma() */
573
 
574
 
575
/*---------------------------------------------------------------------------*/
576
/*!Set the ATA programmed I/O mode
577
 
578
   Must be 0, 1, 2, 3 or 4.
579
 
580
   @param[in] val  The value to use
581
   @param[in] dat  The config data structure                                 */
582
/*---------------------------------------------------------------------------*/
583
static void
584
ata_pio (union param_val  val,
585
         void            *dat)
586
{
587
  struct ata_host *ata = dat;
588
 
589
  if ((val.int_val >= 0) && (val.int_val <= 4))
590
    {
591
      ata->devices.device[conf_dev].conf.pio = val.int_val;
592
    }
593
  else
594
    {
595
      fprintf (stderr, "Warning: invalid ATA programmed I/O mode: ignored\n");
596
    }
597
}       /* ata_pio() */
598
 
599
 
600
static void
601
ata_start_device (union param_val val, void *dat)
602
{
603
  conf_dev = val.int_val;
604
 
605
  if (conf_dev > 1)
606
    fprintf (stderr, "Device %d out-of-range\n", conf_dev);
607
}
608
 
609
static void
610
ata_enddevice (union param_val val, void *dat)
611
{
612
  conf_dev = 2;
613
}
614
 
615
/*---------------------------------------------------------------------------*/
616
/*!Initialize a new ATA configuration
617
 
618
   ALL parameters are set explicitly to default values.                      */
619
/*---------------------------------------------------------------------------*/
620
static void *
621
ata_sec_start (void)
622
{
623
  struct ata_host *new = malloc (sizeof (struct ata_host));
624
 
625
  if (!new)
626
    {
627
      fprintf (stderr, "Peripheral ATA: Run out of memory\n");
628
      exit (-1);
629
    }
630
 
631
  memset (new, 0, sizeof (struct ata_host));
632
 
633
  new->enabled        = 1;
634
  new->baseaddr       = 0;
635
  new->irq            = 0;
636
  new->dev_id         = 1;
637
  new->rev            = 0;
638
 
639
  new->pio_mode0_t1   = PIO_MODE0_T1;
640
  new->pio_mode0_t2   = PIO_MODE0_T2;
641
  new->pio_mode0_t4   = PIO_MODE0_T4;
642
  new->pio_mode0_teoc = PIO_MODE0_TEOC;
643
 
644
  new->dma_mode0_tm   = DMA_MODE0_TM;
645
  new->dma_mode0_td   = DMA_MODE0_TD;
646
  new->dma_mode0_teoc = DMA_MODE0_TEOC;
647
 
648
  new->devices.device[0].conf.type     = 0;
649
  new->devices.device[0].conf.file     = strdup ("ata_file0");
650
  new->devices.device[0].conf.size     = 0;
651
  new->devices.device[0].conf.packet   = 0;
652
  new->devices.device[0].conf.heads    = 7;
653
  new->devices.device[0].conf.sectors  = 32;
654
  new->devices.device[0].conf.firmware = "02207031";
655
  new->devices.device[0].conf.mwdma    = 2;
656
  new->devices.device[0].conf.pio      = 4;
657
 
658
  new->devices.device[1].conf.type     = 0;
659
  new->devices.device[1].conf.file     = strdup ("ata_file1");
660
  new->devices.device[1].conf.size     = 0;
661
  new->devices.device[1].conf.packet   = 0;
662
  new->devices.device[1].conf.heads    = 7;
663
  new->devices.device[1].conf.sectors  = 32;
664
  new->devices.device[1].conf.firmware = "02207031";
665
  new->devices.device[1].conf.mwdma    = 2;
666
  new->devices.device[1].conf.pio      = 4;
667
 
668
  return new;
669
 
670
}       /* ata_sec_start() */
671
 
672
 
673
static void
674
ata_sec_end (void *dat)
675
{
676
  struct ata_host *ata = dat;
677
  struct mem_ops ops;
678
 
679
  if (!ata->enabled)
680
    {
681
      free (dat);
682
      return;
683
    }
684
 
685
  /* Connect ata_devices.                                            */
686
  ata_devices_init (&ata->devices);
687
  ata->devices.device[0].internals.host = ata;
688
  ata->devices.device[1].internals.host = ata;
689
 
690
  memset (&ops, 0, sizeof (struct mem_ops));
691
 
692
  ops.readfunc32 = ata_read32;
693
  ops.read_dat32 = dat;
694
  ops.writefunc32 = ata_write32;
695
  ops.write_dat32 = dat;
696
 
697
  /* Delays will be readjusted later */
698
  ops.delayr = 2;
699
  ops.delayw = 2;
700
 
701
  ata->mem = reg_mem_area (ata->baseaddr, ATA_ADDR_SPACE, 0, &ops);
702
 
703
  reg_sim_reset (ata_reset, dat);
704
  reg_sim_stat (ata_status, dat);
705
}
706
 
707
void
708
reg_ata_sec ()
709
{
710
  struct config_section *sec =
711
    reg_config_sec ("ata", ata_sec_start, ata_sec_end);
712
 
713
  reg_config_param (sec, "enabled", paramt_int, ata_enabled);
714
  reg_config_param (sec, "baseaddr", paramt_addr, ata_baseaddr);
715
  reg_config_param (sec, "irq", paramt_int, ata_irq);
716
  reg_config_param (sec, "dev_id", paramt_int, ata_dev_id);
717
  reg_config_param (sec, "rev", paramt_int, ata_rev);
718
 
719
  reg_config_param (sec, "pio_mode0_t1", paramt_int, ata_pio_mode0_t1);
720
  reg_config_param (sec, "pio_mode0_t2", paramt_int, ata_pio_mode0_t2);
721
  reg_config_param (sec, "pio_mode0_t4", paramt_int, ata_pio_mode0_t4);
722
  reg_config_param (sec, "pio_mode0_teoc", paramt_int, ata_pio_mode0_teoc);
723
 
724
  reg_config_param (sec, "dma_mode0_tm", paramt_int, ata_dma_mode0_tm);
725
  reg_config_param (sec, "dma_mode0_td", paramt_int, ata_dma_mode0_td);
726
  reg_config_param (sec, "dma_mode0_teoc", paramt_int, ata_dma_mode0_teoc);
727
 
728
  reg_config_param (sec, "device", paramt_int, ata_start_device);
729
  reg_config_param (sec, "enddevice", paramt_int, ata_enddevice);
730
 
731
  reg_config_param (sec, "type", paramt_int, ata_type);
732
  reg_config_param (sec, "file", paramt_str, ata_file);
733
  reg_config_param (sec, "size", paramt_int, ata_size);
734
  reg_config_param (sec, "packet", paramt_int, ata_packet);
735
  reg_config_param (sec, "heads", paramt_int, ata_heads);
736
  reg_config_param (sec, "sectors", paramt_int, ata_sectors);
737
  reg_config_param (sec, "firmware", paramt_str, ata_firmware);
738
  reg_config_param (sec, "mwdma", paramt_int, ata_mwdma);
739
  reg_config_param (sec, "pio", paramt_int, ata_pio);
740
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.