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     struct DosEnvec *newde;
 110     ULONG  desize;
 111     STRPTR s1, s2 = 0;
 112     BSTR   bs1, bs2;
 113     int    strLen1, strLen2, sz1, sz2;
 114     int    i;                   /* Loop variable */
 115
 116     if (parmPacket == NULL)
 117     {
 118         return NULL;
 119     }
 120
 121     /* This is the environment structure */
 122     de = (struct DosEnvec *)((IPTR *)parmPacket + 4);
 123     desize = sizeof(IPTR) * (de->de_TableSize + 1);
 124     newde = AllocMem(desize, MEMF_CLEAR | MEMF_PUBLIC);
 125     if(de == NULL)
 126     {
 127         return NULL;
 128     }
 129     CopyMemQuick(de, newde, desize);
 130
 131     dn = AllocMem(sizeof(struct DeviceNode), MEMF_CLEAR | MEMF_PUBLIC);
 132
 133     if (dn == NULL)
 134     {
 135         FreeMem(newde, desize);
 136         return NULL;
 137     }
 138
 139     fssm = AllocMem(sizeof(struct FileSysStartupMsg),
 140                     MEMF_CLEAR | MEMF_PUBLIC);
 141
 142     if (fssm == NULL)
 143     {
 144         FreeMem(newde, desize);
 145         FreeMem(dn, sizeof(struct DeviceNode));
 146
 147         return NULL;
 148     }
 149
 150     /* To help prevent fragmentation I will allocate both strings in the
 151        same block of memory.
 152     */
 153
 154     strLen1 = strlen((STRPTR)((IPTR *)parmPacket)[0]);
 155     /* Round size to alloc to nearest mutiple of 4 */
 156     sz1 = (AROS_BSTR_MEMSIZE4LEN(strLen1) + 3) & ~3;
 157
 158     /* There doesn't have to exist an underlying block device */
 159     if ((STRPTR)((IPTR *)parmPacket)[1] != NULL)
 160     {
 161         strLen2 = strlen((STRPTR)((IPTR *)parmPacket)[1]);
 162     }
 163     else
 164     {
 165         strLen2 = 0;
 166     }
 167     sz2 = AROS_BSTR_MEMSIZE4LEN(strLen2);
 168
 169     s1 = AllocVec(sz1 + sz2, MEMF_CLEAR | MEMF_PUBLIC);
 170
 171     if (s1 == NULL)
 172     {
 173         FreeMem(newde, desize);
 174         FreeMem(dn, sizeof(struct DeviceNode));
 175         FreeMem(fssm, sizeof(struct FileSysStartupMsg));
 176
 177         return NULL;
 178     }
 179
 180     /* We have no more allocations */
 181     s2 = s1 + sz1;
 182
 183     bs1 = MKBADDR(s1);
 184     bs2 = MKBADDR(s2);
 185
 186     for (i = 0; i < strLen1; i++)
 187     {
 188         AROS_BSTR_putchar(bs1, i, ((STRPTR)((IPTR *)parmPacket)[0])[i]);
 189     }
 190
 191     for (i = 0; i < strLen2; i++)
 192     {
 193         AROS_BSTR_putchar(bs2, i, ((STRPTR)((IPTR *)parmPacket)[1])[i]);
 194     }
 195
 196     AROS_BSTR_setstrlen(bs1, strLen1 > 255 ? 255 : strLen1);
 197     AROS_BSTR_setstrlen(bs2, strLen2 > 255 ? 255 : strLen2);
 198
 199     /* Strings are done, now the FileSysStartupMsg */
 200     fssm->fssm_Unit = ((IPTR *)parmPacket)[2];
 201     fssm->fssm_Device = bs2;
 202     fssm->fssm_Environ = MKBADDR(newde);
 203     fssm->fssm_Flags = ((IPTR *)parmPacket)[3];
 204
 205     /* FSSM is done, now the DeviceNode */
 206     dn->dn_Startup = MKBADDR(fssm);
 207     dn->dn_Type = DLT_DEVICE;
 208     dn->dn_Name = bs1;
 209     dn->dn_Ext.dn_AROS.dn_DevName = AROS_BSTR_ADDR(bs1);
 210
 211     return dn;
 212
 213     AROS_LIBFUNC_EXIT
 214 } /* MakeDosNode */