rom/expansion/makedosnode.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: MakeDosNode() - Create a DOS DeviceNode structure.
   6     Lang: English
   7 */
   8
   9 #include "expansion_intern.h"
  10 #include <exec/memory.h>
  11 #include <dos/dos.h>
  12 #include <dos/dosextens.h>
  13 #include <proto/exec.h>
  14 #include <string.h>
  15
  16 # define  DEBUG 0
  17 # include <aros/debug.h>
  18
  19 /*****************************************************************************
  20
  21     NAME */
  22 #include <dos/filehandler.h>
  23 #include <proto/expansion.h>
  24
  25         AROS_LH1(struct DeviceNode *, MakeDosNode,
  26
  27 /*  SYNOPSIS */
  28         AROS_LHA(APTR, parmPacket, A0),
  29
  30 /*  LOCATION */
  31         struct ExpansionBase *, ExpansionBase, 24, Expansion)
  32
  33 /*  FUNCTION
  34         MakeDosNode() will create a DeviceNode structure suitable for
  35         passing to dos.library which contains all the information about
  36         a device stored in the parmPacket array. This will allow you to
  37         enter a DOS device into the system from the information contained
  38         in a DosEnvec structure (such as in a RigidDiskBlock PartitionBlock
  39         structure).
  40
  41         MakeDosNode() will allocate the memory that it needs to construct
  42         the DeviceNode, the strings and a FileSysStartupMsg that is passed
  43         to the filesystem handler on startup.
  44
  45         You can use AddBootNode() to add a node to the system.
  46
  47     INPUTS
  48         parmPacket  -   an IPTR array containing the device parameters
  49                         required to initialize the structures. This is a
  50                         variable length structure. See also the DosEnvec
  51                         structure in dos/filehandler.h
  52
  53             Index       Description
  54             --------    -----------
  55             0           Exec string with dos device name (eg. DH0)
  56             1           Exec string with exec device name (eg. fdsk.device)
  57             2           unit number of device to open
  58             3           flags (for OpenDevice())
  59             4           length of the remaining data
  60             5-n         environment data - consists of:
  61
  62             5           Size of standard device block in 32 bit longwords
  63             6           not used; 0
  64             7           # of heads - drive specific
  65             8           # of sectors per block - not used; 0
  66             9           # of blocks per track - drive specific
  67             10          # of reserved blocks at the start of the partition
  68             11          # of reserved blocks at the end of the partition
  69             12          device interleave
  70             13          starting cylinder of partition
  71             14          end cylinder of partition
  72             15          initial number of buffers
  73             16          type of memory for buffers (CHIP, FAST,...)
  74             17          max number of bytes to transfer at one time
  75             18          address mask allowable for DMA transfers
  76             19          boot priority for autobootable devices
  77             20          standard DOS filesystem ID (eg 'DOS\1')
  78             21          baud rate for serial handler
  79             22          control word for handler/filesystem
  80             23          number of boot blocks on this partition
  81
  82     RESULT
  83         deviceNode  -   An initialized DeviceNode structure, or NULL if
  84                         the required memory could not be allocated. The
  85                         caller will have to modify this structure before
  86                         passing it to AddBootNode().
  87
  88     NOTES
  89         There are a number of fields of the DeviceNode structure that this
  90         function cannot initialize due to a lack of information. You
  91         should fill these in yourself.
  92
  93     EXAMPLE
  94
  95     BUGS
  96
  97     SEE ALSO
  98         AddBootNode(), AddDosNode(), dos.library/MakeDosEntry()
  99
 100     INTERNALS
 101
 102 *****************************************************************************/
 103 {
 104     AROS_LIBFUNC_INIT
 105
 106     struct DeviceNode *dn;
 107     struct FileSysStartupMsg *fssm;
 108     struct DosEnvec *de;
 109     STRPTR s1, s2 = 0;
 110     BSTR   bs1, bs2;
 111     int    strLen1, strLen2, sz1, sz2;
 112     int    i;                   /* Loop variable */
 113
 114     if (parmPacket == NULL)
 115     {
 116         return NULL;
 117     }
 118
 119     /* This is the environment structure */
 120     de = (struct DosEnvec *)((IPTR *)parmPacket + 4);
 121
 122     dn = AllocMem(sizeof(struct DeviceNode), MEMF_CLEAR | MEMF_PUBLIC);
 123
 124     if (dn == NULL)
 125     {
 126         return NULL;
 127     }
 128
 129     fssm = AllocMem(sizeof(struct FileSysStartupMsg),
 130                     MEMF_CLEAR | MEMF_PUBLIC);
 131
 132     if (fssm == NULL)
 133     {
 134         FreeMem(dn, sizeof(struct DeviceNode));
 135
 136         return NULL;
 137     }
 138
 139     /* To help prevent fragmentation I will allocate both strings in the
 140        same block of memory.
 141     */
 142
 143     strLen1 = strlen((STRPTR)((IPTR *)parmPacket)[0]);
 144     /* Round size to alloc to nearest mutiple of 4 */
 145     sz1 = (AROS_BSTR_MEMSIZE4LEN(strLen1) + 3) & ~3;
 146
 147     /* There doesn't have to exist an underlying block device */
 148     if ((STRPTR)((IPTR *)parmPacket)[1] != NULL)
 149     {
 150         strLen2 = strlen((STRPTR)((IPTR *)parmPacket)[1]);
 151     }
 152     else
 153     {
 154         strLen2 = 0;
 155     }
 156     sz2 = AROS_BSTR_MEMSIZE4LEN(strLen2);
 157
 158     s1 = AllocVec(sz1 + sz2, MEMF_CLEAR | MEMF_PUBLIC);
 159
 160     if (s1 == NULL)
 161     {
 162         FreeMem(dn, sizeof(struct DeviceNode));
 163         FreeMem(fssm, sizeof(struct FileSysStartupMsg));
 164
 165         return NULL;
 166     }
 167
 168     /* We have no more allocations */
 169     s2 = s1 + sz1;
 170
 171     bs1 = MKBADDR(s1);
 172     bs2 = MKBADDR(s2);
 173
 174     for (i = 0; i < strLen1; i++)
 175     {
 176         AROS_BSTR_putchar(bs1, i, ((STRPTR)((IPTR *)parmPacket)[0])[i]);
 177     }
 178
 179     for (i = 0; i < strLen2; i++)
 180     {
 181         AROS_BSTR_putchar(bs2, i, ((STRPTR)((IPTR *)parmPacket)[1])[i]);
 182     }
 183
 184     AROS_BSTR_setstrlen(bs1, strLen1 > 255 ? 255 : strLen1);
 185     AROS_BSTR_setstrlen(bs2, strLen2 > 255 ? 255 : strLen2);
 186
 187     /* Strings are done, now the FileSysStartupMsg */
 188     fssm->fssm_Unit = ((IPTR *)parmPacket)[2];
 189     fssm->fssm_Device = bs2;
 190     fssm->fssm_Environ = MKBADDR(de);
 191     fssm->fssm_Flags = ((IPTR *)parmPacket)[3];
 192
 193     /* FSSM is done, now the DeviceNode */
 194     dn->dn_Startup = MKBADDR(fssm);
 195     dn->dn_Type = DLT_DEVICE;
 196     dn->dn_Name = bs1;
 197     dn->dn_Ext.dn_AROS.dn_DevName = AROS_BSTR_ADDR(bs1);
 198
 199     return dn;
 200
 201     AROS_LIBFUNC_EXIT
 202 } /* MakeDosNode */