jcs.org
"Das U-Boot" Source Tree
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * (C) Copyright 2000
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 */
6
7/*
8 * Support for harddisk partitions.
9 *
10 * To be compatible with LinuxPPC and Apple we use the standard Apple
11 * SCSI disk partitioning scheme. For more information see:
12 * http://developer.apple.com/techpubs/mac/Devices/Devices-126.html#MARKER-14-92
13 */
14
15#include <command.h>
16#include <log.h>
17#include <memalign.h>
18#include <ide.h>
19#include "part_mac.h"
20#include <part.h>
21
22/* stdlib.h causes some compatibility problems; should fixe these! -- wd */
23#ifndef __ldiv_t_defined
24typedef struct {
25 long int quot; /* Quotient */
26 long int rem; /* Remainder */
27} ldiv_t;
28extern ldiv_t ldiv (long int __numer, long int __denom);
29# define __ldiv_t_defined 1
30#endif
31
32static int part_mac_read_ddb(struct blk_desc *desc, mac_driver_desc_t *ddb_p);
33static int part_mac_read_pdb(struct blk_desc *desc, int part,
34 mac_partition_t *pdb_p);
35
36/*
37 * Test for a valid MAC partition
38 */
39static int part_test_mac(struct blk_desc *desc)
40{
41 ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1);
42 ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1);
43 ulong i, n;
44
45 if (part_mac_read_ddb(desc, ddesc)) {
46 /*
47 * error reading Driver Descriptor Block,
48 * or no valid Signature
49 */
50 return (-1);
51 }
52
53 n = 1; /* assuming at least one partition */
54 for (i=1; i<=n; ++i) {
55 if ((blk_dread(desc, i, 1, (ulong *)mpart) != 1) ||
56 mpart->signature != MAC_PARTITION_MAGIC) {
57 return (-1);
58 }
59 /* update partition count */
60 n = mpart->map_count;
61 }
62 return (0);
63}
64
65static void part_print_mac(struct blk_desc *desc)
66{
67 ulong i, n;
68 ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1);
69 ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1);
70 ldiv_t mb, gb;
71
72 if (part_mac_read_ddb(desc, ddesc)) {
73 /*
74 * error reading Driver Descriptor Block,
75 * or no valid Signature
76 */
77 return;
78 }
79
80 n = ddesc->blk_count;
81
82 mb = ldiv(n, ((1024 * 1024) / ddesc->blk_size)); /* MB */
83 /* round to 1 digit */
84 mb.rem *= 10 * ddesc->blk_size;
85 mb.rem += 512 * 1024;
86 mb.rem /= 1024 * 1024;
87
88 gb = ldiv(10 * mb.quot + mb.rem, 10240);
89 gb.rem += 512;
90 gb.rem /= 1024;
91
92 printf ("Block Size=%d, Number of Blocks=%d, "
93 "Total Capacity: %ld.%ld MB = %ld.%ld GB\n"
94 "DeviceType=0x%x, DeviceId=0x%x\n\n"
95 " #: type name"
96 " length base (size)\n",
97 ddesc->blk_size,
98 ddesc->blk_count,
99 mb.quot, mb.rem, gb.quot, gb.rem,
100 ddesc->dev_type, ddesc->dev_id
101 );
102
103 n = 1; /* assuming at least one partition */
104 for (i=1; i<=n; ++i) {
105 ulong bytes;
106 char c;
107
108 printf ("%4ld: ", i);
109 if (blk_dread(desc, i, 1, (ulong *)mpart) != 1) {
110 printf ("** Can't read Partition Map on %d:%ld **\n",
111 desc->devnum, i);
112 return;
113 }
114
115 if (mpart->signature != MAC_PARTITION_MAGIC) {
116 printf("** Bad Signature on %d:%ld - expected 0x%04x, got 0x%04x\n",
117 desc->devnum, i, MAC_PARTITION_MAGIC,
118 mpart->signature);
119 return;
120 }
121
122 /* update partition count */
123 n = mpart->map_count;
124
125 c = 'k';
126 bytes = mpart->block_count;
127 bytes /= (1024 / ddesc->blk_size); /* kB; assumes blk_size == 512 */
128 if (bytes >= 1024) {
129 bytes >>= 10;
130 c = 'M';
131 }
132 if (bytes >= 1024) {
133 bytes >>= 10;
134 c = 'G';
135 }
136
137 printf ("%20.32s %-18.32s %10u @ %-10u (%3ld%c)\n",
138 mpart->type,
139 mpart->name,
140 mpart->block_count,
141 mpart->start_block,
142 bytes, c
143 );
144 }
145
146 return;
147}
148
149/*
150 * Read Device Descriptor Block
151 */
152static int part_mac_read_ddb(struct blk_desc *desc, mac_driver_desc_t *ddb_p)
153{
154 if (blk_dread(desc, 0, 1, (ulong *)ddb_p) != 1) {
155 debug("** Can't read Driver Descriptor Block **\n");
156 return (-1);
157 }
158
159 if (ddb_p->signature != MAC_DRIVER_MAGIC) {
160 return (-1);
161 }
162 return (0);
163}
164
165/*
166 * Read Partition Descriptor Block
167 */
168static int part_mac_read_pdb(struct blk_desc *desc, int part,
169 mac_partition_t *pdb_p)
170{
171 int n = 1;
172
173 for (;;) {
174 /*
175 * We must always read the descritpor block for
176 * partition 1 first since this is the only way to
177 * know how many partitions we have.
178 */
179 if (blk_dread(desc, n, 1, (ulong *)pdb_p) != 1) {
180 printf("** Can't read Partition Map on %d:%d **\n",
181 desc->devnum, n);
182 return (-1);
183 }
184
185 if (pdb_p->signature != MAC_PARTITION_MAGIC) {
186 printf("** Bad Signature on %d:%d: expected 0x%04x, got 0x%04x\n",
187 desc->devnum, n, MAC_PARTITION_MAGIC,
188 pdb_p->signature);
189 return (-1);
190 }
191
192 if (n == part)
193 return (0);
194
195 if ((part < 1) || (part > pdb_p->map_count)) {
196 printf("** Invalid partition %d:%d [%d:1...%d:%d only]\n",
197 desc->devnum, part, desc->devnum, desc->devnum,
198 pdb_p->map_count);
199 return (-1);
200 }
201
202 /* update partition count */
203 n = part;
204 }
205
206 /* NOTREACHED */
207}
208
209static int part_get_info_mac(struct blk_desc *desc, int part,
210 struct disk_partition *info)
211{
212 ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1);
213 ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1);
214
215 if (part_mac_read_ddb(desc, ddesc))
216 return -1;
217
218 info->blksz = ddesc->blk_size;
219
220 if (part_mac_read_pdb(desc, part, mpart))
221 return -1;
222
223 info->start = mpart->start_block;
224 info->size = mpart->block_count;
225 memcpy (info->type, mpart->type, sizeof(info->type));
226 memcpy (info->name, mpart->name, sizeof(info->name));
227
228 return (0);
229}
230
231U_BOOT_PART_TYPE(mac) = {
232 .name = "MAC",
233 .part_type = PART_TYPE_MAC,
234 .max_entries = MAC_ENTRY_NUMBERS,
235 .get_info = part_get_info_mac,
236 .print = part_print_mac,
237 .test = part_test_mac,
238};