Eric Lee / linux-smarc-t335x-v3.2

1

/*

1

/*

2

*

2

*

3

* Common boot and setup code.

3

* Common boot and setup code.

4

*

4

*

5

6

*

6

*

7

* This program is free software; you can redistribute it and/or

7

* This program is free software; you can redistribute it and/or

8

* modify it under the terms of the GNU General Public License

8

* modify it under the terms of the GNU General Public License

9

* as published by the Free Software Foundation; either version

9

* as published by the Free Software Foundation; either version

10

* 2 of the License, or (at your option) any later version.

10

* 2 of the License, or (at your option) any later version.

11

*/

11

*/

12

13

#undef DEBUG

13

#undef DEBUG

14

15

#include <linux/config.h>

15

#include <linux/config.h>

16

#include <linux/module.h>

16

#include <linux/module.h>

17

#include <linux/string.h>

17

#include <linux/string.h>

18

#include <linux/sched.h>

18

#include <linux/sched.h>

19

#include <linux/init.h>

19

#include <linux/init.h>

20

#include <linux/kernel.h>

20

#include <linux/kernel.h>

21

#include <linux/reboot.h>

21

#include <linux/reboot.h>

22

#include <linux/delay.h>

22

#include <linux/delay.h>

23

#include <linux/initrd.h>

23

#include <linux/initrd.h>

24

#include <linux/ide.h>

24

#include <linux/ide.h>

25

#include <linux/seq_file.h>

25

#include <linux/seq_file.h>

26

#include <linux/ioport.h>

26

#include <linux/ioport.h>

27

#include <linux/console.h>

27

#include <linux/console.h>

28

#include <linux/version.h>

28

#include <linux/version.h>

29

#include <linux/tty.h>

29

#include <linux/tty.h>

30

#include <linux/root_dev.h>

30

#include <linux/root_dev.h>

31

#include <linux/notifier.h>

31

#include <linux/notifier.h>

32

#include <linux/cpu.h>

32

#include <linux/cpu.h>

33

#include <linux/unistd.h>

33

#include <linux/unistd.h>

34

#include <linux/serial.h>

34

#include <linux/serial.h>

35

#include <linux/serial_8250.h>

35

#include <linux/serial_8250.h>

36

#include <asm/io.h>

36

#include <asm/io.h>

37

#include <asm/prom.h>

37

#include <asm/prom.h>

38

#include <asm/processor.h>

38

#include <asm/processor.h>

39

#include <asm/pgtable.h>

39

#include <asm/pgtable.h>

40

#include <asm/bootinfo.h>

40

#include <asm/bootinfo.h>

41

#include <asm/smp.h>

41

#include <asm/smp.h>

42

#include <asm/elf.h>

42

#include <asm/elf.h>

43

#include <asm/machdep.h>

43

#include <asm/machdep.h>

44

#include <asm/paca.h>

44

#include <asm/paca.h>

45

#include <asm/ppcdebug.h>

45

#include <asm/ppcdebug.h>

46

#include <asm/time.h>

46

#include <asm/time.h>

47

#include <asm/cputable.h>

47

#include <asm/cputable.h>

48

#include <asm/sections.h>

48

#include <asm/sections.h>

49

#include <asm/btext.h>

49

#include <asm/btext.h>

50

#include <asm/nvram.h>

50

#include <asm/nvram.h>

51

#include <asm/setup.h>

51

#include <asm/setup.h>

52

#include <asm/system.h>

52

#include <asm/system.h>

53

#include <asm/rtas.h>

53

#include <asm/rtas.h>

54

#include <asm/iommu.h>

54

#include <asm/iommu.h>

55

#include <asm/serial.h>

55

#include <asm/serial.h>

56

#include <asm/cache.h>

56

#include <asm/cache.h>

57

#include <asm/page.h>

57

#include <asm/page.h>

58

#include <asm/mmu.h>

58

#include <asm/mmu.h>

59

#include <asm/lmb.h>

59

#include <asm/lmb.h>

60

#include <asm/iSeries/ItLpNaca.h>

60

#include <asm/iSeries/ItLpNaca.h>

61

62

#ifdef DEBUG

62

#ifdef DEBUG

63

#define DBG(fmt...) udbg_printf(fmt)

63

#define DBG(fmt...) udbg_printf(fmt)

64

#else

64

#else

65

#define DBG(fmt...)

65

#define DBG(fmt...)

66

#endif

66

#endif

67

68

/*

68

/*

69

* Here are some early debugging facilities. You can enable one

69

* Here are some early debugging facilities. You can enable one

70

* but your kernel will not boot on anything else if you do so

70

* but your kernel will not boot on anything else if you do so

71

*/

71

*/

72

73

/* This one is for use on LPAR machines that support an HVC console

73

/* This one is for use on LPAR machines that support an HVC console

74

* on vterm 0

74

* on vterm 0

75

*/

75

*/

76

extern void udbg_init_debug_lpar(void);

76

extern void udbg_init_debug_lpar(void);

77

/* This one is for use on Apple G5 machines

77

/* This one is for use on Apple G5 machines

78

*/

78

*/

79

extern void udbg_init_pmac_realmode(void);

79

extern void udbg_init_pmac_realmode(void);

80

/* That's RTAS panel debug */

80

/* That's RTAS panel debug */

81

extern void call_rtas_display_status_delay(unsigned char c);

81

extern void call_rtas_display_status_delay(unsigned char c);

82

/* Here's maple real mode debug */

82

/* Here's maple real mode debug */

83

extern void udbg_init_maple_realmode(void);

83

extern void udbg_init_maple_realmode(void);

84

85

#define EARLY_DEBUG_INIT() do {} while(0)

85

#define EARLY_DEBUG_INIT() do {} while(0)

86

87

#if 0

87

#if 0

88

#define EARLY_DEBUG_INIT() udbg_init_debug_lpar()

88

#define EARLY_DEBUG_INIT() udbg_init_debug_lpar()

89

#define EARLY_DEBUG_INIT() udbg_init_maple_realmode()

89

#define EARLY_DEBUG_INIT() udbg_init_maple_realmode()

90

#define EARLY_DEBUG_INIT() udbg_init_pmac_realmode()

90

#define EARLY_DEBUG_INIT() udbg_init_pmac_realmode()

91

#define EARLY_DEBUG_INIT() \

91

#define EARLY_DEBUG_INIT() \

92

do { udbg_putc = call_rtas_display_status_delay; } while(0)

92

do { udbg_putc = call_rtas_display_status_delay; } while(0)

93

#endif

93

#endif

94

95

/* extern void *stab; */

95

/* extern void *stab; */

96

extern unsigned long klimit;

96

extern unsigned long klimit;

97

98

extern void mm_init_ppc64(void);

98

extern void mm_init_ppc64(void);

99

extern void stab_initialize(unsigned long stab);

99

extern void stab_initialize(unsigned long stab);

100

extern void htab_initialize(void);

100

extern void htab_initialize(void);

101

extern void early_init_devtree(void *flat_dt);

101

extern void early_init_devtree(void *flat_dt);

102

extern void unflatten_device_tree(void);

102

extern void unflatten_device_tree(void);

103

104

extern void smp_release_cpus(void);

104

extern void smp_release_cpus(void);

105

106

int have_of = 1;

106

int have_of = 1;

107

int boot_cpuid = 0;

107

int boot_cpuid = 0;

108

int boot_cpuid_phys = 0;

108

int boot_cpuid_phys = 0;

109

dev_t boot_dev;

109

dev_t boot_dev;

110

u64 ppc64_pft_size;

110

u64 ppc64_pft_size;

111

u64 ppc64_debug_switch;

112

111

113

struct ppc64_caches ppc64_caches;

112

struct ppc64_caches ppc64_caches;

114

EXPORT_SYMBOL_GPL(ppc64_caches);

113

EXPORT_SYMBOL_GPL(ppc64_caches);

115

114

116

/*

115

/*

117

* These are used in binfmt_elf.c to put aux entries on the stack

116

* These are used in binfmt_elf.c to put aux entries on the stack

118

* for each elf executable being started.

117

* for each elf executable being started.

119

*/

118

*/

120

int dcache_bsize;

119

int dcache_bsize;

121

int icache_bsize;

120

int icache_bsize;

122

int ucache_bsize;

121

int ucache_bsize;

123

122

124

/* The main machine-dep calls structure

123

/* The main machine-dep calls structure

125

*/

124

*/

126

struct machdep_calls ppc_md;

125

struct machdep_calls ppc_md;

127

EXPORT_SYMBOL(ppc_md);

126

EXPORT_SYMBOL(ppc_md);

128

127

129

#ifdef CONFIG_MAGIC_SYSRQ

128

#ifdef CONFIG_MAGIC_SYSRQ

130

unsigned long SYSRQ_KEY;

129

unsigned long SYSRQ_KEY;

131

#endif /* CONFIG_MAGIC_SYSRQ */

130

#endif /* CONFIG_MAGIC_SYSRQ */

132

131

133

132

134

static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);

133

static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);

135

static struct notifier_block ppc64_panic_block = {

134

static struct notifier_block ppc64_panic_block = {

136

.notifier_call = ppc64_panic_event,

135

.notifier_call = ppc64_panic_event,

137

.priority = INT_MIN /* may not return; must be done last */

136

.priority = INT_MIN /* may not return; must be done last */

138

};

137

};

139

138

140

/*

139

/*

141

* Perhaps we can put the pmac screen_info[] here

140

* Perhaps we can put the pmac screen_info[] here

142

* on pmac as well so we don't need the ifdef's.

141

* on pmac as well so we don't need the ifdef's.

143

* Until we get multiple-console support in here

142

* Until we get multiple-console support in here

144

* that is. -- Cort

143

* that is. -- Cort

145

* Maybe tie it to serial consoles, since this is really what

144

* Maybe tie it to serial consoles, since this is really what

146

* these processors use on existing boards. -- Dan

145

* these processors use on existing boards. -- Dan

147

*/

146

*/

148

struct screen_info screen_info = {

147

struct screen_info screen_info = {

149

.orig_x = 0,

148

.orig_x = 0,

150

.orig_y = 25,

149

.orig_y = 25,

151

.orig_video_cols = 80,

150

.orig_video_cols = 80,

152

.orig_video_lines = 25,

151

.orig_video_lines = 25,

153

.orig_video_isVGA = 1,

152

.orig_video_isVGA = 1,

154

.orig_video_points = 16

153

.orig_video_points = 16

155

};

154

};

156

155

157

/*

158

* Initialize the PPCDBG state. Called before relocation has been enabled.

159

*/

160

void __init ppcdbg_initialize(void)

161

{

162

ppc64_debug_switch = PPC_DEBUG_DEFAULT; /* | PPCDBG_BUSWALK | */

163

/* PPCDBG_PHBINIT | PPCDBG_MM | PPCDBG_MMINIT | PPCDBG_TCEINIT | PPCDBG_TCE */;

164

}

165

166

/*

167

* Early boot console based on udbg

168

*/

169

static struct console udbg_console = {

170

.name = "udbg",

171

.write = udbg_console_write,

172

.flags = CON_PRINTBUFFER,

173

.index = -1,

174

};

175

static int early_console_initialized;

176

177

void __init disable_early_printk(void)

178

{

179

if (!early_console_initialized)

180

return;

181

unregister_console(&udbg_console);

182

early_console_initialized = 0;

183

}

184

185

#if defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP)

156

#if defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP)

186

157

187

static int smt_enabled_cmdline;

158

static int smt_enabled_cmdline;

188

159

189

/* Look for ibm,smt-enabled OF option */

160

/* Look for ibm,smt-enabled OF option */

190

static void check_smt_enabled(void)

161

static void check_smt_enabled(void)

191

{

162

{

192

struct device_node *dn;

163

struct device_node *dn;

193

char *smt_option;

164

char *smt_option;

194

165

195

/* Allow the command line to overrule the OF option */

166

/* Allow the command line to overrule the OF option */

196

if (smt_enabled_cmdline)

167

if (smt_enabled_cmdline)

197

return;

168

return;

198

169

199

dn = of_find_node_by_path("/options");

170

dn = of_find_node_by_path("/options");

200

171

201

if (dn) {

172

if (dn) {

202

smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);

173

smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);

203

174

204

if (smt_option) {

175

if (smt_option) {

205

if (!strcmp(smt_option, "on"))

176

if (!strcmp(smt_option, "on"))

206

smt_enabled_at_boot = 1;

177

smt_enabled_at_boot = 1;

207

else if (!strcmp(smt_option, "off"))

178

else if (!strcmp(smt_option, "off"))

208

smt_enabled_at_boot = 0;

179

smt_enabled_at_boot = 0;

209

}

180

}

210

}

181

}

211

}

182

}

212

183

213

/* Look for smt-enabled= cmdline option */

184

/* Look for smt-enabled= cmdline option */

214

static int __init early_smt_enabled(char *p)

185

static int __init early_smt_enabled(char *p)

215

{

186

{

216

smt_enabled_cmdline = 1;

187

smt_enabled_cmdline = 1;

217

188

218

if (!p)

189

if (!p)

219

return 0;

190

return 0;

220

191

221

if (!strcmp(p, "on") || !strcmp(p, "1"))

192

if (!strcmp(p, "on") || !strcmp(p, "1"))

222

smt_enabled_at_boot = 1;

193

smt_enabled_at_boot = 1;

223

else if (!strcmp(p, "off") || !strcmp(p, "0"))

194

else if (!strcmp(p, "off") || !strcmp(p, "0"))

224

smt_enabled_at_boot = 0;

195

smt_enabled_at_boot = 0;

225

196

226

return 0;

197

return 0;

227

}

198

}

228

early_param("smt-enabled", early_smt_enabled);

199

early_param("smt-enabled", early_smt_enabled);

229

200

230

/**

201

/**

231

* setup_cpu_maps - initialize the following cpu maps:

202

* setup_cpu_maps - initialize the following cpu maps:

232

* cpu_possible_map

203

* cpu_possible_map

233

* cpu_present_map

204

* cpu_present_map

234

* cpu_sibling_map

205

* cpu_sibling_map

235

*

206

*

236

* Having the possible map set up early allows us to restrict allocations

207

* Having the possible map set up early allows us to restrict allocations

237

* of things like irqstacks to num_possible_cpus() rather than NR_CPUS.

208

* of things like irqstacks to num_possible_cpus() rather than NR_CPUS.

238

*

209

*

239

* We do not initialize the online map here; cpus set their own bits in

210

* We do not initialize the online map here; cpus set their own bits in

240

* cpu_online_map as they come up.

211

* cpu_online_map as they come up.

241

*

212

*

242

* This function is valid only for Open Firmware systems. finish_device_tree

213

* This function is valid only for Open Firmware systems. finish_device_tree

243

* must be called before using this.

214

* must be called before using this.

244

*

215

*

245

* While we're here, we may as well set the "physical" cpu ids in the paca.

216

* While we're here, we may as well set the "physical" cpu ids in the paca.

246

*/

217

*/

247

static void __init setup_cpu_maps(void)

218

static void __init setup_cpu_maps(void)

248

{

219

{

249

struct device_node *dn = NULL;

220

struct device_node *dn = NULL;

250

int cpu = 0;

221

int cpu = 0;

251

int swap_cpuid = 0;

222

int swap_cpuid = 0;

252

223

253

check_smt_enabled();

224

check_smt_enabled();

254

225

255

while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {

226

while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {

256

u32 *intserv;

227

u32 *intserv;

257

int j, len = sizeof(u32), nthreads;

228

int j, len = sizeof(u32), nthreads;

258

229

259

intserv = (u32 *)get_property(dn, "ibm,ppc-interrupt-server#s",

230

intserv = (u32 *)get_property(dn, "ibm,ppc-interrupt-server#s",

260

&len);

231

&len);

261

if (!intserv)

232

if (!intserv)

262

intserv = (u32 *)get_property(dn, "reg", NULL);

233

intserv = (u32 *)get_property(dn, "reg", NULL);

263

234

264

nthreads = len / sizeof(u32);

235

nthreads = len / sizeof(u32);

265

236

266

for (j = 0; j < nthreads && cpu < NR_CPUS; j++) {

237

for (j = 0; j < nthreads && cpu < NR_CPUS; j++) {

267

cpu_set(cpu, cpu_present_map);

238

cpu_set(cpu, cpu_present_map);

268

set_hard_smp_processor_id(cpu, intserv[j]);

239

set_hard_smp_processor_id(cpu, intserv[j]);

269

240

270

if (intserv[j] == boot_cpuid_phys)

241

if (intserv[j] == boot_cpuid_phys)

271

swap_cpuid = cpu;

242

swap_cpuid = cpu;

272

cpu_set(cpu, cpu_possible_map);

243

cpu_set(cpu, cpu_possible_map);

273

cpu++;

244

cpu++;

274

}

245

}

275

}

246

}

276

247

277

/* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that

248

/* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that

278

* boot cpu is logical 0.

249

* boot cpu is logical 0.

279

*/

250

*/

280

if (boot_cpuid_phys != get_hard_smp_processor_id(0)) {

251

if (boot_cpuid_phys != get_hard_smp_processor_id(0)) {

281

u32 tmp;

252

u32 tmp;

282

tmp = get_hard_smp_processor_id(0);

253

tmp = get_hard_smp_processor_id(0);

283

set_hard_smp_processor_id(0, boot_cpuid_phys);

254

set_hard_smp_processor_id(0, boot_cpuid_phys);

284

set_hard_smp_processor_id(swap_cpuid, tmp);

255

set_hard_smp_processor_id(swap_cpuid, tmp);

285

}

256

}

286

257

287

/*

258

/*

288

* On pSeries LPAR, we need to know how many cpus

259

* On pSeries LPAR, we need to know how many cpus

289

* could possibly be added to this partition.

260

* could possibly be added to this partition.

290

*/

261

*/

291

if (systemcfg->platform == PLATFORM_PSERIES_LPAR &&

262

if (systemcfg->platform == PLATFORM_PSERIES_LPAR &&

292

(dn = of_find_node_by_path("/rtas"))) {

263

(dn = of_find_node_by_path("/rtas"))) {

293

int num_addr_cell, num_size_cell, maxcpus;

264

int num_addr_cell, num_size_cell, maxcpus;

294

unsigned int *ireg;

265

unsigned int *ireg;

295

266

296

num_addr_cell = prom_n_addr_cells(dn);

267

num_addr_cell = prom_n_addr_cells(dn);

297

num_size_cell = prom_n_size_cells(dn);

268

num_size_cell = prom_n_size_cells(dn);

298

269

299

ireg = (unsigned int *)

270

ireg = (unsigned int *)

300

get_property(dn, "ibm,lrdr-capacity", NULL);

271

get_property(dn, "ibm,lrdr-capacity", NULL);

301

272

302

if (!ireg)

273

if (!ireg)

303

goto out;

274

goto out;

304

275

305

maxcpus = ireg[num_addr_cell + num_size_cell];

276

maxcpus = ireg[num_addr_cell + num_size_cell];

306

277

307

/* Double maxcpus for processors which have SMT capability */

278

/* Double maxcpus for processors which have SMT capability */

308

if (cpu_has_feature(CPU_FTR_SMT))

279

if (cpu_has_feature(CPU_FTR_SMT))

309

maxcpus *= 2;

280

maxcpus *= 2;

310

281

311

if (maxcpus > NR_CPUS) {

282

if (maxcpus > NR_CPUS) {

312

printk(KERN_WARNING

283

printk(KERN_WARNING

313

"Partition configured for %d cpus, "

284

"Partition configured for %d cpus, "

314

"operating system maximum is %d.\n",

285

"operating system maximum is %d.\n",

315

maxcpus, NR_CPUS);

286

maxcpus, NR_CPUS);

316

maxcpus = NR_CPUS;

287

maxcpus = NR_CPUS;

317

} else

288

} else

318

printk(KERN_INFO "Partition configured for %d cpus.\n",

289

printk(KERN_INFO "Partition configured for %d cpus.\n",

319

maxcpus);

290

maxcpus);

320

291

321

for (cpu = 0; cpu < maxcpus; cpu++)

292

for (cpu = 0; cpu < maxcpus; cpu++)

322

cpu_set(cpu, cpu_possible_map);

293

cpu_set(cpu, cpu_possible_map);

323

out:

294

out:

324

of_node_put(dn);

295

of_node_put(dn);

325

}

296

}

326

297

327

/*

298

/*

328

* Do the sibling map; assume only two threads per processor.

299

* Do the sibling map; assume only two threads per processor.

329

*/

300

*/

330

for_each_cpu(cpu) {

301

for_each_cpu(cpu) {

331

cpu_set(cpu, cpu_sibling_map[cpu]);

302

cpu_set(cpu, cpu_sibling_map[cpu]);

332

if (cpu_has_feature(CPU_FTR_SMT))

303

if (cpu_has_feature(CPU_FTR_SMT))

333

cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]);

304

cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]);

334

}

305

}

335

306

336

systemcfg->processorCount = num_present_cpus();

307

systemcfg->processorCount = num_present_cpus();

337

}

308

}

338

#endif /* defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP) */

309

#endif /* defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP) */

339

310

340

311

341

#ifdef CONFIG_PPC_MULTIPLATFORM

312

#ifdef CONFIG_PPC_MULTIPLATFORM

342

313

343

extern struct machdep_calls pSeries_md;

314

extern struct machdep_calls pSeries_md;

344

extern struct machdep_calls pmac_md;

315

extern struct machdep_calls pmac_md;

345

extern struct machdep_calls maple_md;

316

extern struct machdep_calls maple_md;

346

extern struct machdep_calls bpa_md;

317

extern struct machdep_calls bpa_md;

347

318

348

/* Ultimately, stuff them in an elf section like initcalls... */

319

/* Ultimately, stuff them in an elf section like initcalls... */

349

static struct machdep_calls __initdata *machines[] = {

320

static struct machdep_calls __initdata *machines[] = {

350

#ifdef CONFIG_PPC_PSERIES

321

#ifdef CONFIG_PPC_PSERIES

351

&pSeries_md,

322

&pSeries_md,

352

#endif /* CONFIG_PPC_PSERIES */

323

#endif /* CONFIG_PPC_PSERIES */

353

#ifdef CONFIG_PPC_PMAC

324

#ifdef CONFIG_PPC_PMAC

354

&pmac_md,

325

&pmac_md,

355

#endif /* CONFIG_PPC_PMAC */

326

#endif /* CONFIG_PPC_PMAC */

356

#ifdef CONFIG_PPC_MAPLE

327

#ifdef CONFIG_PPC_MAPLE

357

&maple_md,

328

&maple_md,

358

#endif /* CONFIG_PPC_MAPLE */

329

#endif /* CONFIG_PPC_MAPLE */

359

#ifdef CONFIG_PPC_BPA

330

#ifdef CONFIG_PPC_BPA

360

&bpa_md,

331

&bpa_md,

361

#endif

332

#endif

362

NULL

333

NULL

363

};

334

};

364

335

365

/*

336

/*

366

* Early initialization entry point. This is called by head.S

337

* Early initialization entry point. This is called by head.S

367

* with MMU translation disabled. We rely on the "feature" of

338

* with MMU translation disabled. We rely on the "feature" of

368

* the CPU that ignores the top 2 bits of the address in real

339

* the CPU that ignores the top 2 bits of the address in real

369

* mode so we can access kernel globals normally provided we

340

* mode so we can access kernel globals normally provided we

370

* only toy with things in the RMO region. From here, we do

341

* only toy with things in the RMO region. From here, we do

371

* some early parsing of the device-tree to setup out LMB

342

* some early parsing of the device-tree to setup out LMB

372

* data structures, and allocate & initialize the hash table

343

* data structures, and allocate & initialize the hash table

373

* and segment tables so we can start running with translation

344

* and segment tables so we can start running with translation

374

* enabled.

345

* enabled.

375

*

346

*

376

* It is this function which will call the probe() callback of

347

* It is this function which will call the probe() callback of

377

* the various platform types and copy the matching one to the

348

* the various platform types and copy the matching one to the

378

* global ppc_md structure. Your platform can eventually do

349

* global ppc_md structure. Your platform can eventually do

379

* some very early initializations from the probe() routine, but

350

* some very early initializations from the probe() routine, but

380

* this is not recommended, be very careful as, for example, the

351

* this is not recommended, be very careful as, for example, the

381

* device-tree is not accessible via normal means at this point.

352

* device-tree is not accessible via normal means at this point.

382

*/

353

*/

383

354

384

void __init early_setup(unsigned long dt_ptr)

355

void __init early_setup(unsigned long dt_ptr)

385

{

356

{

386

struct paca_struct *lpaca = get_paca();

357

struct paca_struct *lpaca = get_paca();

387

static struct machdep_calls **mach;

358

static struct machdep_calls **mach;

388

359

389

/*

360

/*

390

* Enable early debugging if any specified (see top of

361

* Enable early debugging if any specified (see top of

391

* this file)

362

* this file)

392

*/

363

*/

393

EARLY_DEBUG_INIT();

364

EARLY_DEBUG_INIT();

394

365

395

DBG(" -> early_setup()\n");

366

DBG(" -> early_setup()\n");

396

367

397

/*

368

/*

398

* Fill the default DBG level (do we want to keep

369

* Fill the default DBG level (do we want to keep

399

* that old mecanism around forever ?)

370

* that old mecanism around forever ?)

400

*/

371

*/

401

ppcdbg_initialize();

372

ppcdbg_initialize();

402

373

403

/*

374

/*

404

* Do early initializations using the flattened device

375

* Do early initializations using the flattened device

405

* tree, like retreiving the physical memory map or

376

* tree, like retreiving the physical memory map or

406

* calculating/retreiving the hash table size

377

* calculating/retreiving the hash table size

407

*/

378

*/

408

early_init_devtree(__va(dt_ptr));

379

early_init_devtree(__va(dt_ptr));

409

380

410

/*

381

/*

411

* Iterate all ppc_md structures until we find the proper

382

* Iterate all ppc_md structures until we find the proper

412

* one for the current machine type

383

* one for the current machine type

413

*/

384

*/

414

DBG("Probing machine type for platform %x...\n",

385

DBG("Probing machine type for platform %x...\n",

415

systemcfg->platform);

386

systemcfg->platform);

416

387

417

for (mach = machines; *mach; mach++) {

388

for (mach = machines; *mach; mach++) {

418

if ((*mach)->probe(systemcfg->platform))

389

if ((*mach)->probe(systemcfg->platform))

419

break;

390

break;

420

}

391

}

421

/* What can we do if we didn't find ? */

392

/* What can we do if we didn't find ? */

422

if (*mach == NULL) {

393

if (*mach == NULL) {

423

DBG("No suitable machine found !\n");

394

DBG("No suitable machine found !\n");

424

for (;;);

395

for (;;);

425

}

396

}

426

ppc_md = **mach;

397

ppc_md = **mach;

427

398

428

DBG("Found, Initializing memory management...\n");

399

DBG("Found, Initializing memory management...\n");

429

400

430

/*

401

/*

431

* Initialize stab / SLB management

402

* Initialize stab / SLB management

432

*/

403

*/

433

stab_initialize(lpaca->stab_real);

404

stab_initialize(lpaca->stab_real);

434

405

435

/*

406

/*

436

* Initialize the MMU Hash table and create the linear mapping

407

* Initialize the MMU Hash table and create the linear mapping

437

* of memory

408

* of memory

438

*/

409

*/

439

htab_initialize();

410

htab_initialize();

440

411

441

DBG(" <- early_setup()\n");

412

DBG(" <- early_setup()\n");

442

}

413

}

443

414

444

415

445

/*

416

/*

446

* Initialize some remaining members of the ppc64_caches and systemcfg structures

417

* Initialize some remaining members of the ppc64_caches and systemcfg structures

447

* (at least until we get rid of them completely). This is mostly some

418

* (at least until we get rid of them completely). This is mostly some

448

* cache informations about the CPU that will be used by cache flush

419

* cache informations about the CPU that will be used by cache flush

449

* routines and/or provided to userland

420

* routines and/or provided to userland

450

*/

421

*/

451

static void __init initialize_cache_info(void)

422

static void __init initialize_cache_info(void)

452

{

423

{

453

struct device_node *np;

424

struct device_node *np;

454

unsigned long num_cpus = 0;

425

unsigned long num_cpus = 0;

455

426

456

DBG(" -> initialize_cache_info()\n");

427

DBG(" -> initialize_cache_info()\n");

457

428

458

for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {

429

for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {

459

num_cpus += 1;

430

num_cpus += 1;

460

431

461

/* We're assuming *all* of the CPUs have the same

432

/* We're assuming *all* of the CPUs have the same

462

* d-cache and i-cache sizes... -Peter

433

* d-cache and i-cache sizes... -Peter

463

*/

434

*/

464

435

465

if ( num_cpus == 1 ) {

436

if ( num_cpus == 1 ) {

466

u32 *sizep, *lsizep;

437

u32 *sizep, *lsizep;

467

u32 size, lsize;

438

u32 size, lsize;

468

const char *dc, *ic;

439

const char *dc, *ic;

469

440

470

/* Then read cache informations */

441

/* Then read cache informations */

471

if (systemcfg->platform == PLATFORM_POWERMAC) {

442

if (systemcfg->platform == PLATFORM_POWERMAC) {

472

dc = "d-cache-block-size";

443

dc = "d-cache-block-size";

473

ic = "i-cache-block-size";

444

ic = "i-cache-block-size";

474

} else {

445

} else {

475

dc = "d-cache-line-size";

446

dc = "d-cache-line-size";

476

ic = "i-cache-line-size";

447

ic = "i-cache-line-size";

477

}

448

}

478

449

479

size = 0;

450

size = 0;

480

lsize = cur_cpu_spec->dcache_bsize;

451

lsize = cur_cpu_spec->dcache_bsize;

481

sizep = (u32 *)get_property(np, "d-cache-size", NULL);

452

sizep = (u32 *)get_property(np, "d-cache-size", NULL);

482

if (sizep != NULL)

453

if (sizep != NULL)

483

size = *sizep;

454

size = *sizep;

484

lsizep = (u32 *) get_property(np, dc, NULL);

455

lsizep = (u32 *) get_property(np, dc, NULL);

485

if (lsizep != NULL)

456

if (lsizep != NULL)

486

lsize = *lsizep;

457

lsize = *lsizep;

487

if (sizep == 0 || lsizep == 0)

458

if (sizep == 0 || lsizep == 0)

488

DBG("Argh, can't find dcache properties ! "

459

DBG("Argh, can't find dcache properties ! "

489

"sizep: %p, lsizep: %p\n", sizep, lsizep);

460

"sizep: %p, lsizep: %p\n", sizep, lsizep);

490

461

491

systemcfg->dcache_size = ppc64_caches.dsize = size;

462

systemcfg->dcache_size = ppc64_caches.dsize = size;

492

systemcfg->dcache_line_size =

463

systemcfg->dcache_line_size =

493

ppc64_caches.dline_size = lsize;

464

ppc64_caches.dline_size = lsize;

494

ppc64_caches.log_dline_size = __ilog2(lsize);

465

ppc64_caches.log_dline_size = __ilog2(lsize);

495

ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;

466

ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;

496

467

497

size = 0;

468

size = 0;

498

lsize = cur_cpu_spec->icache_bsize;

469

lsize = cur_cpu_spec->icache_bsize;

499

sizep = (u32 *)get_property(np, "i-cache-size", NULL);

470

sizep = (u32 *)get_property(np, "i-cache-size", NULL);

500

if (sizep != NULL)

471

if (sizep != NULL)

501

size = *sizep;

472

size = *sizep;

502

lsizep = (u32 *)get_property(np, ic, NULL);

473

lsizep = (u32 *)get_property(np, ic, NULL);

503

if (lsizep != NULL)

474

if (lsizep != NULL)

504

lsize = *lsizep;

475

lsize = *lsizep;

505

if (sizep == 0 || lsizep == 0)

476

if (sizep == 0 || lsizep == 0)

506

DBG("Argh, can't find icache properties ! "

477

DBG("Argh, can't find icache properties ! "

507

"sizep: %p, lsizep: %p\n", sizep, lsizep);

478

"sizep: %p, lsizep: %p\n", sizep, lsizep);

508

479

509

systemcfg->icache_size = ppc64_caches.isize = size;

480

systemcfg->icache_size = ppc64_caches.isize = size;

510

systemcfg->icache_line_size =

481

systemcfg->icache_line_size =

511

ppc64_caches.iline_size = lsize;

482

ppc64_caches.iline_size = lsize;

512

ppc64_caches.log_iline_size = __ilog2(lsize);

483

ppc64_caches.log_iline_size = __ilog2(lsize);

513

ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;

484

ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;

514

}

485

}

515

}

486

}

516

487

517

/* Add an eye catcher and the systemcfg layout version number */

488

/* Add an eye catcher and the systemcfg layout version number */

518

strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64");

489

strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64");

519

systemcfg->version.major = SYSTEMCFG_MAJOR;

490

systemcfg->version.major = SYSTEMCFG_MAJOR;

520

systemcfg->version.minor = SYSTEMCFG_MINOR;

491

systemcfg->version.minor = SYSTEMCFG_MINOR;

521

systemcfg->processor = mfspr(SPRN_PVR);

492

systemcfg->processor = mfspr(SPRN_PVR);

522

493

523

DBG(" <- initialize_cache_info()\n");

494

DBG(" <- initialize_cache_info()\n");

524

}

495

}

525

496

526

static void __init check_for_initrd(void)

497

static void __init check_for_initrd(void)

527

{

498

{

528

#ifdef CONFIG_BLK_DEV_INITRD

499

#ifdef CONFIG_BLK_DEV_INITRD

529

u64 *prop;

500

u64 *prop;

530

501

531

DBG(" -> check_for_initrd()\n");

502

DBG(" -> check_for_initrd()\n");

532

503

533

if (of_chosen) {

504

if (of_chosen) {

534

prop = (u64 *)get_property(of_chosen,

505

prop = (u64 *)get_property(of_chosen,

535

"linux,initrd-start", NULL);

506

"linux,initrd-start", NULL);

536

if (prop != NULL) {

507

if (prop != NULL) {

537

initrd_start = (unsigned long)__va(*prop);

508

initrd_start = (unsigned long)__va(*prop);

538

prop = (u64 *)get_property(of_chosen,

509

prop = (u64 *)get_property(of_chosen,

539

"linux,initrd-end", NULL);

510

"linux,initrd-end", NULL);

540

if (prop != NULL) {

511

if (prop != NULL) {

541

initrd_end = (unsigned long)__va(*prop);

512

initrd_end = (unsigned long)__va(*prop);

542

initrd_below_start_ok = 1;

513

initrd_below_start_ok = 1;

543

} else

514

} else

544

initrd_start = 0;

515

initrd_start = 0;

545

}

516

}

546

}

517

}

547

518

548

/* If we were passed an initrd, set the ROOT_DEV properly if the values

519

/* If we were passed an initrd, set the ROOT_DEV properly if the values

549

* look sensible. If not, clear initrd reference.

520

* look sensible. If not, clear initrd reference.

550

*/

521

*/

551

if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&

522

if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&

552

initrd_end > initrd_start)

523

initrd_end > initrd_start)

553

ROOT_DEV = Root_RAM0;

524

ROOT_DEV = Root_RAM0;

554

else

525

else

555

initrd_start = initrd_end = 0;

526

initrd_start = initrd_end = 0;

556

527

557

if (initrd_start)

528

if (initrd_start)

558

printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);

529

printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);

559

530

560

DBG(" <- check_for_initrd()\n");

531

DBG(" <- check_for_initrd()\n");

561

#endif /* CONFIG_BLK_DEV_INITRD */

532

#endif /* CONFIG_BLK_DEV_INITRD */

562

}

533

}

563

534

564

#endif /* CONFIG_PPC_MULTIPLATFORM */

535

#endif /* CONFIG_PPC_MULTIPLATFORM */

565

536

566

/*

537

/*

567

* Do some initial setup of the system. The parameters are those which

538

* Do some initial setup of the system. The parameters are those which

568

* were passed in from the bootloader.

539

* were passed in from the bootloader.

569

*/

540

*/

570

void __init setup_system(void)

541

void __init setup_system(void)

571

{

542

{

572

DBG(" -> setup_system()\n");

543

DBG(" -> setup_system()\n");

573

544

574

#ifdef CONFIG_PPC_ISERIES

545

#ifdef CONFIG_PPC_ISERIES

575

/* pSeries systems are identified in prom.c via OF. */

546

/* pSeries systems are identified in prom.c via OF. */

576

if (itLpNaca.xLparInstalled == 1)

547

if (itLpNaca.xLparInstalled == 1)

577

systemcfg->platform = PLATFORM_ISERIES_LPAR;

548

systemcfg->platform = PLATFORM_ISERIES_LPAR;

578

549

579

ppc_md.init_early();

550

ppc_md.init_early();

580

#else /* CONFIG_PPC_ISERIES */

551

#else /* CONFIG_PPC_ISERIES */

581

552

582

/*

553

/*

583

* Unflatten the device-tree passed by prom_init or kexec

554

* Unflatten the device-tree passed by prom_init or kexec

584

*/

555

*/

585

unflatten_device_tree();

556

unflatten_device_tree();

586

557

587

/*

558

/*

588

* Fill the ppc64_caches & systemcfg structures with informations

559

* Fill the ppc64_caches & systemcfg structures with informations

589

* retreived from the device-tree. Need to be called before

560

* retreived from the device-tree. Need to be called before

590

* finish_device_tree() since the later requires some of the

561

* finish_device_tree() since the later requires some of the

591

* informations filled up here to properly parse the interrupt

562

* informations filled up here to properly parse the interrupt

592

* tree.

563

* tree.

593

* It also sets up the cache line sizes which allows to call

564

* It also sets up the cache line sizes which allows to call

594

* routines like flush_icache_range (used by the hash init

565

* routines like flush_icache_range (used by the hash init

595

* later on).

566

* later on).

596

*/

567

*/

597

initialize_cache_info();

568

initialize_cache_info();

598

569

599

#ifdef CONFIG_PPC_RTAS

570

#ifdef CONFIG_PPC_RTAS

600

/*

571

/*

601

* Initialize RTAS if available

572

* Initialize RTAS if available

602

*/

573

*/

603

rtas_initialize();

574

rtas_initialize();

604

#endif /* CONFIG_PPC_RTAS */

575

#endif /* CONFIG_PPC_RTAS */

605

576

606

/*

577

/*

607

* Check if we have an initrd provided via the device-tree

578

* Check if we have an initrd provided via the device-tree

608

*/

579

*/

609

check_for_initrd();

580

check_for_initrd();

610

581

611

/*

582

/*

612

* Do some platform specific early initializations, that includes

583

* Do some platform specific early initializations, that includes

613

* setting up the hash table pointers. It also sets up some interrupt-mapping

584

* setting up the hash table pointers. It also sets up some interrupt-mapping

614

* related options that will be used by finish_device_tree()

585

* related options that will be used by finish_device_tree()

615

*/

586

*/

616

ppc_md.init_early();

587

ppc_md.init_early();

617

588

618

/*

589

/*

619

* "Finish" the device-tree, that is do the actual parsing of

590

* "Finish" the device-tree, that is do the actual parsing of

620

* some of the properties like the interrupt map

591

* some of the properties like the interrupt map

621

*/

592

*/

622

finish_device_tree();

593

finish_device_tree();

623

594

624

/*

595

/*

625

* Initialize xmon

596

* Initialize xmon

626

*/

597

*/

627

#ifdef CONFIG_XMON_DEFAULT

598

#ifdef CONFIG_XMON_DEFAULT

628

xmon_init(1);

599

xmon_init(1);

629

#endif

600

#endif

630

/*

601

/*

631

* Register early console

602

* Register early console

632

*/

603

*/

633

early_console_initialized = 1;

604

register_early_udbg_console();

634

register_console(&udbg_console);

635

605

636

/* Save unparsed command line copy for /proc/cmdline */

606

/* Save unparsed command line copy for /proc/cmdline */

637

strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);

607

strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);

638

608

639

parse_early_param();

609

parse_early_param();

640

#endif /* !CONFIG_PPC_ISERIES */

610

#endif /* !CONFIG_PPC_ISERIES */

641

611

642

#if defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES)

612

#if defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES)

643

/*

613

/*

644

* iSeries has already initialized the cpu maps at this point.

614

* iSeries has already initialized the cpu maps at this point.

645

*/

615

*/

646

setup_cpu_maps();

616

setup_cpu_maps();

647

617

648

/* Release secondary cpus out of their spinloops at 0x60 now that

618

/* Release secondary cpus out of their spinloops at 0x60 now that

649

* we can map physical -> logical CPU ids

619

* we can map physical -> logical CPU ids

650

*/

620

*/

651

smp_release_cpus();

621

smp_release_cpus();

652

#endif /* defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) */

622

#endif /* defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) */

653

623

654

printk("Starting Linux PPC64 %s\n", UTS_RELEASE);

624

printk("Starting Linux PPC64 %s\n", UTS_RELEASE);

655

625

656

printk("-----------------------------------------------------\n");

626

printk("-----------------------------------------------------\n");

657

printk("ppc64_pft_size = 0x%lx\n", ppc64_pft_size);

627

printk("ppc64_pft_size = 0x%lx\n", ppc64_pft_size);

658

printk("ppc64_debug_switch = 0x%lx\n", ppc64_debug_switch);

628

printk("ppc64_debug_switch = 0x%lx\n", ppc64_debug_switch);

659

printk("ppc64_interrupt_controller = 0x%ld\n", ppc64_interrupt_controller);

629

printk("ppc64_interrupt_controller = 0x%ld\n", ppc64_interrupt_controller);

660

printk("systemcfg = 0x%p\n", systemcfg);

630

printk("systemcfg = 0x%p\n", systemcfg);

661

printk("systemcfg->platform = 0x%x\n", systemcfg->platform);

631

printk("systemcfg->platform = 0x%x\n", systemcfg->platform);

662

printk("systemcfg->processorCount = 0x%lx\n", systemcfg->processorCount);

632

printk("systemcfg->processorCount = 0x%lx\n", systemcfg->processorCount);

663

printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize);

633

printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize);

664

printk("ppc64_caches.dcache_line_size = 0x%x\n",

634

printk("ppc64_caches.dcache_line_size = 0x%x\n",

665

ppc64_caches.dline_size);

635

ppc64_caches.dline_size);

666

printk("ppc64_caches.icache_line_size = 0x%x\n",

636

printk("ppc64_caches.icache_line_size = 0x%x\n",

667

ppc64_caches.iline_size);

637

ppc64_caches.iline_size);

668

printk("htab_address = 0x%p\n", htab_address);

638

printk("htab_address = 0x%p\n", htab_address);

669

printk("htab_hash_mask = 0x%lx\n", htab_hash_mask);

639

printk("htab_hash_mask = 0x%lx\n", htab_hash_mask);

670

printk("-----------------------------------------------------\n");

640

printk("-----------------------------------------------------\n");

671

641

672

mm_init_ppc64();

642

mm_init_ppc64();

673

643

674

DBG(" <- setup_system()\n");

644

DBG(" <- setup_system()\n");

675

}

645

}

676

646

677

/* also used by kexec */

647

/* also used by kexec */

678

void machine_shutdown(void)

648

void machine_shutdown(void)

679

{

649

{

680

if (ppc_md.nvram_sync)

650

if (ppc_md.nvram_sync)

681

ppc_md.nvram_sync();

651

ppc_md.nvram_sync();

682

}

652

}

683

653

684

void machine_restart(char *cmd)

654

void machine_restart(char *cmd)

685

{

655

{

686

machine_shutdown();

656

machine_shutdown();

687

ppc_md.restart(cmd);

657

ppc_md.restart(cmd);

688

#ifdef CONFIG_SMP

658

#ifdef CONFIG_SMP

689

smp_send_stop();

659

smp_send_stop();

690

#endif

660

#endif

691

printk(KERN_EMERG "System Halted, OK to turn off power\n");

661

printk(KERN_EMERG "System Halted, OK to turn off power\n");

692

local_irq_disable();

662

local_irq_disable();

693

while (1) ;

663

while (1) ;

694

}

664

}

695

665

696

void machine_power_off(void)

666

void machine_power_off(void)

697

{

667

{

698

machine_shutdown();

668

machine_shutdown();

699

ppc_md.power_off();

669

ppc_md.power_off();

700

#ifdef CONFIG_SMP

670

#ifdef CONFIG_SMP

701

smp_send_stop();

671

smp_send_stop();

702

#endif

672

#endif

703

printk(KERN_EMERG "System Halted, OK to turn off power\n");

673

printk(KERN_EMERG "System Halted, OK to turn off power\n");

704

local_irq_disable();

674

local_irq_disable();

705

while (1) ;

675

while (1) ;

706

}

676

}

707

/* Used by the G5 thermal driver */

677

/* Used by the G5 thermal driver */

708

EXPORT_SYMBOL_GPL(machine_power_off);

678

EXPORT_SYMBOL_GPL(machine_power_off);

709

679

710

void machine_halt(void)

680

void machine_halt(void)

711

{

681

{

712

machine_shutdown();

682

machine_shutdown();

713

ppc_md.halt();

683

ppc_md.halt();

714

#ifdef CONFIG_SMP

684

#ifdef CONFIG_SMP

715

smp_send_stop();

685

smp_send_stop();

716

#endif

686

#endif

717

printk(KERN_EMERG "System Halted, OK to turn off power\n");

687

printk(KERN_EMERG "System Halted, OK to turn off power\n");

718

local_irq_disable();

688

local_irq_disable();

719

while (1) ;

689

while (1) ;

720

}

690

}

721

691

722

static int ppc64_panic_event(struct notifier_block *this,

692

static int ppc64_panic_event(struct notifier_block *this,

723

unsigned long event, void *ptr)

693

unsigned long event, void *ptr)

724

{

694

{

725

ppc_md.panic((char *)ptr); /* May not return */

695

ppc_md.panic((char *)ptr); /* May not return */

726

return NOTIFY_DONE;

696

return NOTIFY_DONE;

727

}

697

}

728

698

729

699

730

#ifdef CONFIG_SMP

700

#ifdef CONFIG_SMP

731

DEFINE_PER_CPU(unsigned int, pvr);

701

DEFINE_PER_CPU(unsigned int, pvr);

732

#endif

702

#endif

733

703

734

static int show_cpuinfo(struct seq_file *m, void *v)

704

static int show_cpuinfo(struct seq_file *m, void *v)

735

{

705

{

736

unsigned long cpu_id = (unsigned long)v - 1;

706

unsigned long cpu_id = (unsigned long)v - 1;

737

unsigned int pvr;

707

unsigned int pvr;

738

unsigned short maj;

708

unsigned short maj;

739

unsigned short min;

709

unsigned short min;

740

710

741

if (cpu_id == NR_CPUS) {

711

if (cpu_id == NR_CPUS) {

742

seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);

712

seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);

743

713

744

if (ppc_md.get_cpuinfo != NULL)

714

if (ppc_md.get_cpuinfo != NULL)

745

ppc_md.get_cpuinfo(m);

715

ppc_md.get_cpuinfo(m);

746

716

747

return 0;

717

return 0;

748

}

718

}

749

719

750

/* We only show online cpus: disable preempt (overzealous, I

720

/* We only show online cpus: disable preempt (overzealous, I

751

* knew) to prevent cpu going down. */

721

* knew) to prevent cpu going down. */

752

preempt_disable();

722

preempt_disable();

753

if (!cpu_online(cpu_id)) {

723

if (!cpu_online(cpu_id)) {

754

preempt_enable();

724

preempt_enable();

755

return 0;

725

return 0;

756

}

726

}

757

727

758

#ifdef CONFIG_SMP

728

#ifdef CONFIG_SMP

759

pvr = per_cpu(pvr, cpu_id);

729

pvr = per_cpu(pvr, cpu_id);

760

#else

730

#else

761

pvr = mfspr(SPRN_PVR);

731

pvr = mfspr(SPRN_PVR);

762

#endif

732

#endif

763

maj = (pvr >> 8) & 0xFF;

733

maj = (pvr >> 8) & 0xFF;

764

min = pvr & 0xFF;

734

min = pvr & 0xFF;

765

735

766

seq_printf(m, "processor\t: %lu\n", cpu_id);

736

seq_printf(m, "processor\t: %lu\n", cpu_id);

767

seq_printf(m, "cpu\t\t: ");

737

seq_printf(m, "cpu\t\t: ");

768

738

769

if (cur_cpu_spec->pvr_mask)

739

if (cur_cpu_spec->pvr_mask)

770

seq_printf(m, "%s", cur_cpu_spec->cpu_name);

740

seq_printf(m, "%s", cur_cpu_spec->cpu_name);

771

else

741

else

772

seq_printf(m, "unknown (%08x)", pvr);

742

seq_printf(m, "unknown (%08x)", pvr);

773

743

774

#ifdef CONFIG_ALTIVEC

744

#ifdef CONFIG_ALTIVEC

775

if (cpu_has_feature(CPU_FTR_ALTIVEC))

745

if (cpu_has_feature(CPU_FTR_ALTIVEC))

776

seq_printf(m, ", altivec supported");

746

seq_printf(m, ", altivec supported");

777

#endif /* CONFIG_ALTIVEC */

747

#endif /* CONFIG_ALTIVEC */

778

748

779

seq_printf(m, "\n");

749

seq_printf(m, "\n");

780

750

781

/*

751

/*

782

* Assume here that all clock rates are the same in a

752

* Assume here that all clock rates are the same in a

783

* smp system. -- Cort

753

* smp system. -- Cort

784

*/

754

*/

785

seq_printf(m, "clock\t\t: %lu.%06luMHz\n", ppc_proc_freq / 1000000,

755

seq_printf(m, "clock\t\t: %lu.%06luMHz\n", ppc_proc_freq / 1000000,

786

ppc_proc_freq % 1000000);

756

ppc_proc_freq % 1000000);

787

757

788

seq_printf(m, "revision\t: %hd.%hd\n\n", maj, min);

758

seq_printf(m, "revision\t: %hd.%hd\n\n", maj, min);

789

759

790

preempt_enable();

760

preempt_enable();

791

return 0;

761

return 0;

792

}

762

}

793

763

794

static void *c_start(struct seq_file *m, loff_t *pos)

764

static void *c_start(struct seq_file *m, loff_t *pos)

795

{

765

{

796

return *pos <= NR_CPUS ? (void *)((*pos)+1) : NULL;

766

return *pos <= NR_CPUS ? (void *)((*pos)+1) : NULL;

797

}

767

}

798

static void *c_next(struct seq_file *m, void *v, loff_t *pos)

768

static void *c_next(struct seq_file *m, void *v, loff_t *pos)

799

{

769

{

800

++*pos;

770

++*pos;

801

return c_start(m, pos);

771

return c_start(m, pos);

802

}

772

}

803

static void c_stop(struct seq_file *m, void *v)

773

static void c_stop(struct seq_file *m, void *v)

804

{

774

{

805

}

775

}

806

struct seq_operations cpuinfo_op = {

776

struct seq_operations cpuinfo_op = {

807

.start =c_start,

777

.start =c_start,

808

.next = c_next,

778

.next = c_next,

809

.stop = c_stop,

779

.stop = c_stop,

810

.show = show_cpuinfo,

780

.show = show_cpuinfo,

811

};

781

};

812

782

813

/*

783

/*

814

* These three variables are used to save values passed to us by prom_init()

784

* These three variables are used to save values passed to us by prom_init()

815

* via the device tree. The TCE variables are needed because with a memory_limit

785

* via the device tree. The TCE variables are needed because with a memory_limit

816

* in force we may need to explicitly map the TCE are at the top of RAM.

786

* in force we may need to explicitly map the TCE are at the top of RAM.

817

*/

787

*/

818

unsigned long memory_limit;

788

unsigned long memory_limit;

819

unsigned long tce_alloc_start;

789

unsigned long tce_alloc_start;

820

unsigned long tce_alloc_end;

790

unsigned long tce_alloc_end;

821

791

822

#ifdef CONFIG_PPC_ISERIES

792

#ifdef CONFIG_PPC_ISERIES

823

/*

793

/*

824

* On iSeries we just parse the mem=X option from the command line.

794

* On iSeries we just parse the mem=X option from the command line.

825

* On pSeries it's a bit more complicated, see prom_init_mem()

795

* On pSeries it's a bit more complicated, see prom_init_mem()

826

*/

796

*/

827

static int __init early_parsemem(char *p)

797

static int __init early_parsemem(char *p)

828

{

798

{

829

if (!p)

799

if (!p)

830

return 0;

800

return 0;

831

801

832

memory_limit = ALIGN(memparse(p, &p), PAGE_SIZE);

802

memory_limit = ALIGN(memparse(p, &p), PAGE_SIZE);

833

803

834

return 0;

804

return 0;

835

}

805

}

836

early_param("mem", early_parsemem);

806

early_param("mem", early_parsemem);

837

#endif /* CONFIG_PPC_ISERIES */

807

#endif /* CONFIG_PPC_ISERIES */

838

808

839

#ifdef CONFIG_PPC_MULTIPLATFORM

809

#ifdef CONFIG_PPC_MULTIPLATFORM

840

static int __init set_preferred_console(void)

810

static int __init set_preferred_console(void)

841

{

811

{

842

struct device_node *prom_stdout = NULL;

812

struct device_node *prom_stdout = NULL;

843

char *name;

813

char *name;

844

u32 *spd;

814

u32 *spd;

845

int offset = 0;

815

int offset = 0;

846

816

847

DBG(" -> set_preferred_console()\n");

817

DBG(" -> set_preferred_console()\n");

848

818

849

/* The user has requested a console so this is already set up. */

819

/* The user has requested a console so this is already set up. */

850

if (strstr(saved_command_line, "console=")) {

820

if (strstr(saved_command_line, "console=")) {

851

DBG(" console was specified !\n");

821

DBG(" console was specified !\n");

852

return -EBUSY;

822

return -EBUSY;

853

}

823

}

854

824

855

if (!of_chosen) {

825

if (!of_chosen) {

856

DBG(" of_chosen is NULL !\n");

826

DBG(" of_chosen is NULL !\n");

857

return -ENODEV;

827

return -ENODEV;

858

}

828

}

859

/* We are getting a weird phandle from OF ... */

829

/* We are getting a weird phandle from OF ... */

860

/* ... So use the full path instead */

830

/* ... So use the full path instead */

861

name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);

831

name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);

862

if (name == NULL) {

832

if (name == NULL) {

863

DBG(" no linux,stdout-path !\n");

833

DBG(" no linux,stdout-path !\n");

864

return -ENODEV;

834

return -ENODEV;

865

}

835

}

866

prom_stdout = of_find_node_by_path(name);

836

prom_stdout = of_find_node_by_path(name);

867

if (!prom_stdout) {

837

if (!prom_stdout) {

868

DBG(" can't find stdout package %s !\n", name);

838

DBG(" can't find stdout package %s !\n", name);

869

return -ENODEV;

839

return -ENODEV;

870

}

840

}

871

DBG("stdout is %s\n", prom_stdout->full_name);

841

DBG("stdout is %s\n", prom_stdout->full_name);

872

842

873

name = (char *)get_property(prom_stdout, "name", NULL);

843

name = (char *)get_property(prom_stdout, "name", NULL);

874

if (!name) {

844

if (!name) {

875

DBG(" stdout package has no name !\n");

845

DBG(" stdout package has no name !\n");

876

goto not_found;

846

goto not_found;

877

}

847

}

878

spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);

848

spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);

879

849

880

if (0)

850

if (0)

881

;

851

;

882

#ifdef CONFIG_SERIAL_8250_CONSOLE

852

#ifdef CONFIG_SERIAL_8250_CONSOLE

883

else if (strcmp(name, "serial") == 0) {

853

else if (strcmp(name, "serial") == 0) {

884

int i;

854

int i;

885

u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);

855

u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);

886

if (i > 8) {

856

if (i > 8) {

887

switch (reg[1]) {

857

switch (reg[1]) {

888

case 0x3f8:

858

case 0x3f8:

889

offset = 0;

859

offset = 0;

890

break;

860

break;

891

case 0x2f8:

861

case 0x2f8:

892

offset = 1;

862

offset = 1;

893

break;

863

break;

894

case 0x898:

864

case 0x898:

895

offset = 2;

865

offset = 2;

896

break;

866

break;

897

case 0x890:

867

case 0x890:

898

offset = 3;

868

offset = 3;

899

break;

869

break;

900

default:

870

default:

901

/* We dont recognise the serial port */

871

/* We dont recognise the serial port */

902

goto not_found;

872

goto not_found;

903

}

873

}

904

}

874

}

905

}

875

}

906

#endif /* CONFIG_SERIAL_8250_CONSOLE */

876

#endif /* CONFIG_SERIAL_8250_CONSOLE */

907

#ifdef CONFIG_PPC_PSERIES

877

#ifdef CONFIG_PPC_PSERIES

908

else if (strcmp(name, "vty") == 0) {

878

else if (strcmp(name, "vty") == 0) {

909

u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL);

879

u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL);

910

char *compat = (char *)get_property(prom_stdout, "compatible", NULL);

880

char *compat = (char *)get_property(prom_stdout, "compatible", NULL);

911

881

912

if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) {

882

if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) {

913

/* Host Virtual Serial Interface */

883

/* Host Virtual Serial Interface */

914

int offset;

884

int offset;

915

switch (reg[0]) {

885

switch (reg[0]) {

916

case 0x30000000:

886

case 0x30000000:

917

offset = 0;

887

offset = 0;

918

break;

888

break;

919

case 0x30000001:

889

case 0x30000001:

920

offset = 1;

890

offset = 1;

921

break;

891

break;

922

default:

892

default:

923

goto not_found;

893

goto not_found;

924

}

894

}

925

of_node_put(prom_stdout);

895

of_node_put(prom_stdout);

926

DBG("Found hvsi console at offset %d\n", offset);

896

DBG("Found hvsi console at offset %d\n", offset);

927

return add_preferred_console("hvsi", offset, NULL);

897

return add_preferred_console("hvsi", offset, NULL);

928

} else {

898

} else {

929

/* pSeries LPAR virtual console */

899

/* pSeries LPAR virtual console */

930

of_node_put(prom_stdout);

900

of_node_put(prom_stdout);

931

DBG("Found hvc console\n");

901

DBG("Found hvc console\n");

932

return add_preferred_console("hvc", 0, NULL);

902

return add_preferred_console("hvc", 0, NULL);

933

}

903

}

934

}

904

}

935

#endif /* CONFIG_PPC_PSERIES */

905

#endif /* CONFIG_PPC_PSERIES */

936

#ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE

906

#ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE

937

else if (strcmp(name, "ch-a") == 0)

907

else if (strcmp(name, "ch-a") == 0)

938

offset = 0;

908

offset = 0;

939

else if (strcmp(name, "ch-b") == 0)

909

else if (strcmp(name, "ch-b") == 0)

940

offset = 1;

910

offset = 1;

941

#endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */

911

#endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */

942

else

912

else

943

goto not_found;

913

goto not_found;

944

of_node_put(prom_stdout);

914

of_node_put(prom_stdout);

945

915

946

DBG("Found serial console at ttyS%d\n", offset);

916

DBG("Found serial console at ttyS%d\n", offset);

947

917

948

if (spd) {

918

if (spd) {

949

static char __initdata opt[16];

919

static char __initdata opt[16];

950

sprintf(opt, "%d", *spd);

920

sprintf(opt, "%d", *spd);

951

return add_preferred_console("ttyS", offset, opt);

921

return add_preferred_console("ttyS", offset, opt);

952

} else

922

} else

953

return add_preferred_console("ttyS", offset, NULL);

923

return add_preferred_console("ttyS", offset, NULL);

954

924

955

not_found:

925

not_found:

956

DBG("No preferred console found !\n");

926

DBG("No preferred console found !\n");

957

of_node_put(prom_stdout);

927

of_node_put(prom_stdout);

958

return -ENODEV;

928

return -ENODEV;

959

}

929

}

960

console_initcall(set_preferred_console);

930

console_initcall(set_preferred_console);

961

#endif /* CONFIG_PPC_MULTIPLATFORM */

931

#endif /* CONFIG_PPC_MULTIPLATFORM */

962

932

963

#ifdef CONFIG_IRQSTACKS

933

#ifdef CONFIG_IRQSTACKS

964

static void __init irqstack_early_init(void)

934

static void __init irqstack_early_init(void)

965

{

935

{

966

unsigned int i;

936

unsigned int i;

967

937

968

/*

938

/*

969

* interrupt stacks must be under 256MB, we cannot afford to take

939

* interrupt stacks must be under 256MB, we cannot afford to take

970

* SLB misses on them.

940

* SLB misses on them.

971

*/

941

*/

972

for_each_cpu(i) {

942

for_each_cpu(i) {

973

softirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,

943

softirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,

974

THREAD_SIZE, 0x10000000));

944

THREAD_SIZE, 0x10000000));

975

hardirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,

945

hardirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,

976

THREAD_SIZE, 0x10000000));

946

THREAD_SIZE, 0x10000000));

977

}

947

}

978

}

948

}

979

#else

949

#else

980

#define irqstack_early_init()

950

#define irqstack_early_init()

981

#endif

951

#endif

982

952

983

/*

953

/*

984

* Stack space used when we detect a bad kernel stack pointer, and

954

* Stack space used when we detect a bad kernel stack pointer, and

985

* early in SMP boots before relocation is enabled.

955

* early in SMP boots before relocation is enabled.

986

*/

956

*/

987

static void __init emergency_stack_init(void)

957

static void __init emergency_stack_init(void)

988

{

958

{

989

unsigned long limit;

959

unsigned long limit;

990

unsigned int i;

960

unsigned int i;

991

961

992

/*

962

/*

993

* Emergency stacks must be under 256MB, we cannot afford to take

963

* Emergency stacks must be under 256MB, we cannot afford to take

994

* SLB misses on them. The ABI also requires them to be 128-byte

964

* SLB misses on them. The ABI also requires them to be 128-byte

995

* aligned.

965

* aligned.

996

*

966

*

997

* Since we use these as temporary stacks during secondary CPU

967

* Since we use these as temporary stacks during secondary CPU

998

* bringup, we need to get at them in real mode. This means they

968

* bringup, we need to get at them in real mode. This means they

999

* must also be within the RMO region.

969

* must also be within the RMO region.

1000

*/

970

*/

1001

limit = min(0x10000000UL, lmb.rmo_size);

971

limit = min(0x10000000UL, lmb.rmo_size);

1002

972

1003

for_each_cpu(i)

973

for_each_cpu(i)

1004

paca[i].emergency_sp = __va(lmb_alloc_base(PAGE_SIZE, 128,

974

paca[i].emergency_sp = __va(lmb_alloc_base(PAGE_SIZE, 128,

1005

limit)) + PAGE_SIZE;

975

limit)) + PAGE_SIZE;

1006

}

976

}

1007

977

1008

/*

978

/*

1009

* Called from setup_arch to initialize the bitmap of available

979

* Called from setup_arch to initialize the bitmap of available

1010

* syscalls in the systemcfg page

980

* syscalls in the systemcfg page

1011

*/

981

*/

1012

void __init setup_syscall_map(void)

982

void __init setup_syscall_map(void)

1013

{

983

{

1014

unsigned int i, count64 = 0, count32 = 0;

984

unsigned int i, count64 = 0, count32 = 0;

1015

extern unsigned long *sys_call_table;

985

extern unsigned long *sys_call_table;

1016

extern unsigned long *sys_call_table32;

986

extern unsigned long *sys_call_table32;

1017

extern unsigned long sys_ni_syscall;

987

extern unsigned long sys_ni_syscall;

1018

988

1019

989

1020

for (i = 0; i < __NR_syscalls; i++) {

990

for (i = 0; i < __NR_syscalls; i++) {

1021

if (sys_call_table[i] == sys_ni_syscall)

991

if (sys_call_table[i] == sys_ni_syscall)

1022

continue;

992

continue;

1023

count64++;

993

count64++;

1024

systemcfg->syscall_map_64[i >> 5] |= 0x80000000UL >> (i & 0x1f);

994

systemcfg->syscall_map_64[i >> 5] |= 0x80000000UL >> (i & 0x1f);

1025

}

995

}

1026

for (i = 0; i < __NR_syscalls; i++) {

996

for (i = 0; i < __NR_syscalls; i++) {

1027

if (sys_call_table32[i] == sys_ni_syscall)

997

if (sys_call_table32[i] == sys_ni_syscall)

1028

continue;

998

continue;

1029

count32++;

999

count32++;

1030

systemcfg->syscall_map_32[i >> 5] |= 0x80000000UL >> (i & 0x1f);

1000

systemcfg->syscall_map_32[i >> 5] |= 0x80000000UL >> (i & 0x1f);

1031

}

1001

}

1032

printk(KERN_INFO "Syscall map setup, %d 32 bits and %d 64 bits syscalls\n",

1002

printk(KERN_INFO "Syscall map setup, %d 32 bits and %d 64 bits syscalls\n",

1033

count32, count64);

1003

count32, count64);

1034

}

1004

}

1035

1005

1036

/*

1006

/*

1037

* Called into from start_kernel, after lock_kernel has been called.

1007

* Called into from start_kernel, after lock_kernel has been called.

1038

* Initializes bootmem, which is unsed to manage page allocation until

1008

* Initializes bootmem, which is unsed to manage page allocation until

1039

* mem_init is called.

1009

* mem_init is called.

1040

*/

1010

*/

1041

void __init setup_arch(char **cmdline_p)

1011

void __init setup_arch(char **cmdline_p)

1042

{

1012

{

1043

extern void do_init_bootmem(void);

1013

extern void do_init_bootmem(void);

1044

1014

1045

ppc64_boot_msg(0x12, "Setup Arch");

1015

ppc64_boot_msg(0x12, "Setup Arch");

1046

1016

1047

*cmdline_p = cmd_line;

1017

*cmdline_p = cmd_line;

1048

1018

1049

/*

1019

/*

1050

* Set cache line size based on type of cpu as a default.

1020

* Set cache line size based on type of cpu as a default.

1051

* Systems with OF can look in the properties on the cpu node(s)

1021

* Systems with OF can look in the properties on the cpu node(s)

1052

* for a possibly more accurate value.

1022

* for a possibly more accurate value.

1053

*/

1023

*/

1054

dcache_bsize = ppc64_caches.dline_size;

1024

dcache_bsize = ppc64_caches.dline_size;

1055

icache_bsize = ppc64_caches.iline_size;

1025

icache_bsize = ppc64_caches.iline_size;

1056

1026

1057

/* reboot on panic */

1027

/* reboot on panic */

1058

panic_timeout = 180;

1028

panic_timeout = 180;

1059

1029

1060

if (ppc_md.panic)

1030

if (ppc_md.panic)

1061

notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);

1031

notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);

1062

1032

1063

init_mm.start_code = PAGE_OFFSET;

1033

init_mm.start_code = PAGE_OFFSET;

1064

init_mm.end_code = (unsigned long) _etext;

1034

init_mm.end_code = (unsigned long) _etext;

1065

init_mm.end_data = (unsigned long) _edata;

1035

init_mm.end_data = (unsigned long) _edata;

1066

init_mm.brk = klimit;

1036

init_mm.brk = klimit;

1067

1037

1068

irqstack_early_init();

1038

irqstack_early_init();

1069

emergency_stack_init();

1039

emergency_stack_init();

1070

1040

1071

stabs_alloc();

1041

stabs_alloc();

1072

1042

1073

/* set up the bootmem stuff with available memory */

1043

/* set up the bootmem stuff with available memory */

1074

do_init_bootmem();

1044

do_init_bootmem();

1075

sparse_init();

1045

sparse_init();

1076

1046

1077

/* initialize the syscall map in systemcfg */

1047

/* initialize the syscall map in systemcfg */

1078

setup_syscall_map();

1048

setup_syscall_map();

1079

1049

1080

ppc_md.setup_arch();

1050

ppc_md.setup_arch();

1081

1051

1082

/* Use the default idle loop if the platform hasn't provided one. */

1052

/* Use the default idle loop if the platform hasn't provided one. */

1083

if (NULL == ppc_md.idle_loop) {

1053

if (NULL == ppc_md.idle_loop) {

1084

ppc_md.idle_loop = default_idle;

1054

ppc_md.idle_loop = default_idle;

1085

printk(KERN_INFO "Using default idle loop\n");

1055

printk(KERN_INFO "Using default idle loop\n");

1086

}

1056

}

1087

1057

1088

paging_init();

1058

paging_init();

1089

ppc64_boot_msg(0x15, "Setup Done");

1059

ppc64_boot_msg(0x15, "Setup Done");

1090

}

1060

}

1091

1061

1092

1062

1093

/* ToDo: do something useful if ppc_md is not yet setup. */

1063

/* ToDo: do something useful if ppc_md is not yet setup. */

1094

#define PPC64_LINUX_FUNCTION 0x0f000000

1064

#define PPC64_LINUX_FUNCTION 0x0f000000

1095

#define PPC64_IPL_MESSAGE 0xc0000000

1065

#define PPC64_IPL_MESSAGE 0xc0000000

1096

#define PPC64_TERM_MESSAGE 0xb0000000

1066

#define PPC64_TERM_MESSAGE 0xb0000000

1097

#define PPC64_ATTN_MESSAGE 0xa0000000

1067

#define PPC64_ATTN_MESSAGE 0xa0000000

1098

#define PPC64_DUMP_MESSAGE 0xd0000000

1068

#define PPC64_DUMP_MESSAGE 0xd0000000

1099

1069

1100

static void ppc64_do_msg(unsigned int src, const char *msg)

1070

static void ppc64_do_msg(unsigned int src, const char *msg)

1101

{

1071

{

1102

if (ppc_md.progress) {

1072

if (ppc_md.progress) {

1103

char buf[128];

1073

char buf[128];

1104

1074

1105

sprintf(buf, "%08X\n", src);

1075

sprintf(buf, "%08X\n", src);

1106

ppc_md.progress(buf, 0);

1076

ppc_md.progress(buf, 0);

1107

snprintf(buf, 128, "%s", msg);

1077

snprintf(buf, 128, "%s", msg);

1108

ppc_md.progress(buf, 0);

1078

ppc_md.progress(buf, 0);

1109

}

1079

}

1110

}

1080

}

1111

1081

1112

/* Print a boot progress message. */

1082

/* Print a boot progress message. */

1113

void ppc64_boot_msg(unsigned int src, const char *msg)

1083

void ppc64_boot_msg(unsigned int src, const char *msg)

1114

{

1084

{

1115

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);

1085

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);

1116

printk("[boot]%04x %s\n", src, msg);

1086

printk("[boot]%04x %s\n", src, msg);

1117

}

1087

}

1118

1088

1119

/* Print a termination message (print only -- does not stop the kernel) */

1089

/* Print a termination message (print only -- does not stop the kernel) */

1120

void ppc64_terminate_msg(unsigned int src, const char *msg)

1090

void ppc64_terminate_msg(unsigned int src, const char *msg)

1121

{

1091

{

1122

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg);

1092

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg);

1123

printk("[terminate]%04x %s\n", src, msg);

1093

printk("[terminate]%04x %s\n", src, msg);

1124

}

1094

}

1125

1095

1126

/* Print something that needs attention (device error, etc) */

1096

/* Print something that needs attention (device error, etc) */

1127

void ppc64_attention_msg(unsigned int src, const char *msg)

1097

void ppc64_attention_msg(unsigned int src, const char *msg)

1128

{

1098

{

1129

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_ATTN_MESSAGE|src, msg);

1099

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_ATTN_MESSAGE|src, msg);

1130

printk("[attention]%04x %s\n", src, msg);

1100

printk("[attention]%04x %s\n", src, msg);

1131

}

1101

}

1132

1102

1133

/* Print a dump progress message. */

1103

/* Print a dump progress message. */

1134

void ppc64_dump_msg(unsigned int src, const char *msg)

1104

void ppc64_dump_msg(unsigned int src, const char *msg)

1135

{

1105

{

1136

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_DUMP_MESSAGE|src, msg);

1106

ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_DUMP_MESSAGE|src, msg);

1137

printk("[dump]%04x %s\n", src, msg);

1107

printk("[dump]%04x %s\n", src, msg);

1138

}

1108

}

1139

1109

1140

/* This should only be called on processor 0 during calibrate decr */

1110

/* This should only be called on processor 0 during calibrate decr */

1141

void __init setup_default_decr(void)

1111

void __init setup_default_decr(void)

1142

{

1112

{

1143

struct paca_struct *lpaca = get_paca();

1113

struct paca_struct *lpaca = get_paca();

1144

1114

1145

lpaca->default_decr = tb_ticks_per_jiffy;

1115

lpaca->default_decr = tb_ticks_per_jiffy;

1146

lpaca->next_jiffy_update_tb = get_tb() + tb_ticks_per_jiffy;

1116

lpaca->next_jiffy_update_tb = get_tb() + tb_ticks_per_jiffy;

1147

}

1117

}

1148

1118

1149

#ifndef CONFIG_PPC_ISERIES

1119

#ifndef CONFIG_PPC_ISERIES

1150

/*

1120

/*

1151

* This function can be used by platforms to "find" legacy serial ports.

1121

* This function can be used by platforms to "find" legacy serial ports.

1152

* It works for "serial" nodes under an "isa" node, and will try to

1122

* It works for "serial" nodes under an "isa" node, and will try to

1153

* respect the "ibm,aix-loc" property if any. It works with up to 8

1123

* respect the "ibm,aix-loc" property if any. It works with up to 8

1154

* ports.

1124

* ports.

1155

*/

1125

*/

1156

1126

1157

#define MAX_LEGACY_SERIAL_PORTS 8

1127

#define MAX_LEGACY_SERIAL_PORTS 8

1158

static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1];

1128

static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1];

1159

static unsigned int old_serial_count;

1129

static unsigned int old_serial_count;

1160

1130

1161

void __init generic_find_legacy_serial_ports(u64 *physport,

1131

void __init generic_find_legacy_serial_ports(u64 *physport,

1162

unsigned int *default_speed)

1132

unsigned int *default_speed)

1163

{

1133

{

1164

struct device_node *np;

1134

struct device_node *np;

1165

u32 *sizeprop;

1135

u32 *sizeprop;

1166

1136

1167

struct isa_reg_property {

1137

struct isa_reg_property {

1168

u32 space;

1138

u32 space;

1169

u32 address;

1139

u32 address;

1170

u32 size;

1140

u32 size;

1171

};

1141

};

1172

struct pci_reg_property {

1142

struct pci_reg_property {

1173

struct pci_address addr;

1143

struct pci_address addr;

1174

u32 size_hi;

1144

u32 size_hi;

1175

u32 size_lo;

1145

u32 size_lo;

1176

};

1146

};

1177

1147

1178

DBG(" -> generic_find_legacy_serial_port()\n");

1148

DBG(" -> generic_find_legacy_serial_port()\n");

1179

1149

1180

*physport = 0;

1150

*physport = 0;

1181

if (default_speed)

1151

if (default_speed)

1182

*default_speed = 0;

1152

*default_speed = 0;

1183

1153

1184

np = of_find_node_by_path("/");

1154

np = of_find_node_by_path("/");

1185

if (!np)

1155

if (!np)

1186

return;

1156

return;

1187

1157

1188

/* First fill our array */

1158

/* First fill our array */

1189

for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {

1159

for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {

1190

struct device_node *isa, *pci;

1160

struct device_node *isa, *pci;

1191

struct isa_reg_property *reg;

1161

struct isa_reg_property *reg;

1192

unsigned long phys_size, addr_size, io_base;

1162

unsigned long phys_size, addr_size, io_base;

1193

u32 *rangesp;

1163

u32 *rangesp;

1194

u32 *interrupts, *clk, *spd;

1164

u32 *interrupts, *clk, *spd;

1195

char *typep;

1165

char *typep;

1196

int index, rlen, rentsize;

1166

int index, rlen, rentsize;

1197

1167

1198

/* Ok, first check if it's under an "isa" parent */

1168

/* Ok, first check if it's under an "isa" parent */

1199

isa = of_get_parent(np);

1169

isa = of_get_parent(np);

1200

if (!isa || strcmp(isa->name, "isa")) {

1170

if (!isa || strcmp(isa->name, "isa")) {

1201

DBG("%s: no isa parent found\n", np->full_name);

1171

DBG("%s: no isa parent found\n", np->full_name);

1202

continue;

1172

continue;

1203

}

1173

}

1204

1174

1205

/* Now look for an "ibm,aix-loc" property that gives us ordering

1175

/* Now look for an "ibm,aix-loc" property that gives us ordering

1206

* if any...

1176

* if any...

1207

*/

1177

*/

1208

typep = (char *)get_property(np, "ibm,aix-loc", NULL);

1178

typep = (char *)get_property(np, "ibm,aix-loc", NULL);

1209

1179

1210

/* Get the ISA port number */

1180

/* Get the ISA port number */

1211

reg = (struct isa_reg_property *)get_property(np, "reg", NULL);

1181

reg = (struct isa_reg_property *)get_property(np, "reg", NULL);

1212

if (reg == NULL)

1182

if (reg == NULL)

1213

goto next_port;

1183

goto next_port;

1214

/* We assume the interrupt number isn't translated ... */

1184

/* We assume the interrupt number isn't translated ... */

1215

interrupts = (u32 *)get_property(np, "interrupts", NULL);

1185

interrupts = (u32 *)get_property(np, "interrupts", NULL);

1216

/* get clock freq. if present */

1186

/* get clock freq. if present */

1217

clk = (u32 *)get_property(np, "clock-frequency", NULL);

1187

clk = (u32 *)get_property(np, "clock-frequency", NULL);

1218

/* get default speed if present */

1188

/* get default speed if present */

1219

spd = (u32 *)get_property(np, "current-speed", NULL);

1189

spd = (u32 *)get_property(np, "current-speed", NULL);

1220

/* Default to locate at end of array */

1190

/* Default to locate at end of array */

1221

index = old_serial_count; /* end of the array by default */

1191

index = old_serial_count; /* end of the array by default */

1222

1192

1223

/* If we have a location index, then use it */

1193

/* If we have a location index, then use it */

1224

if (typep && *typep == 'S') {

1194

if (typep && *typep == 'S') {

1225

index = simple_strtol(typep+1, NULL, 0) - 1;

1195

index = simple_strtol(typep+1, NULL, 0) - 1;

1226

/* if index is out of range, use end of array instead */

1196

/* if index is out of range, use end of array instead */

1227

if (index >= MAX_LEGACY_SERIAL_PORTS)

1197

if (index >= MAX_LEGACY_SERIAL_PORTS)

1228

index = old_serial_count;

1198

index = old_serial_count;

1229

/* if our index is still out of range, that mean that

1199

/* if our index is still out of range, that mean that

1230

* array is full, we could scan for a free slot but that

1200

* array is full, we could scan for a free slot but that

1231

* make little sense to bother, just skip the port

1201

* make little sense to bother, just skip the port

1232

*/

1202

*/

1233

if (index >= MAX_LEGACY_SERIAL_PORTS)

1203

if (index >= MAX_LEGACY_SERIAL_PORTS)

1234

goto next_port;

1204

goto next_port;

1235

if (index >= old_serial_count)

1205

if (index >= old_serial_count)

1236

old_serial_count = index + 1;

1206

old_serial_count = index + 1;

1237

/* Check if there is a port who already claimed our slot */

1207

/* Check if there is a port who already claimed our slot */

1238

if (serial_ports[index].iobase != 0) {

1208

if (serial_ports[index].iobase != 0) {

1239

/* if we still have some room, move it, else override */

1209

/* if we still have some room, move it, else override */

1240

if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) {

1210

if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) {

1241

DBG("Moved legacy port %d -> %d\n", index,

1211

DBG("Moved legacy port %d -> %d\n", index,

1242

old_serial_count);

1212

old_serial_count);

1243

serial_ports[old_serial_count++] =

1213

serial_ports[old_serial_count++] =

1244

serial_ports[index];

1214

serial_ports[index];

1245

} else {

1215

} else {

1246

DBG("Replacing legacy port %d\n", index);

1216

DBG("Replacing legacy port %d\n", index);

1247

}

1217

}

1248

}

1218

}

1249

}

1219

}

1250

if (index >= MAX_LEGACY_SERIAL_PORTS)

1220

if (index >= MAX_LEGACY_SERIAL_PORTS)

1251

goto next_port;

1221

goto next_port;

1252

if (index >= old_serial_count)

1222

if (index >= old_serial_count)

1253

old_serial_count = index + 1;

1223

old_serial_count = index + 1;

1254

1224

1255

/* Now fill the entry */

1225

/* Now fill the entry */

1256

memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port));

1226

memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port));

1257

serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16;

1227

serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16;

1258

serial_ports[index].iobase = reg->address;

1228

serial_ports[index].iobase = reg->address;

1259

serial_ports[index].irq = interrupts ? interrupts[0] : 0;

1229

serial_ports[index].irq = interrupts ? interrupts[0] : 0;

1260

serial_ports[index].flags = ASYNC_BOOT_AUTOCONF;

1230

serial_ports[index].flags = ASYNC_BOOT_AUTOCONF;

1261

1231

1262

DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n",

1232

DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n",

1263

index,

1233

index,

1264

serial_ports[index].iobase,

1234

serial_ports[index].iobase,

1265

serial_ports[index].irq,

1235

serial_ports[index].irq,

1266

serial_ports[index].uartclk);

1236

serial_ports[index].uartclk);

1267

1237

1268

/* Get phys address of IO reg for port 1 */

1238

/* Get phys address of IO reg for port 1 */

1269

if (index != 0)

1239

if (index != 0)

1270

goto next_port;

1240

goto next_port;

1271

1241

1272

pci = of_get_parent(isa);

1242

pci = of_get_parent(isa);

1273

if (!pci) {

1243

if (!pci) {

1274

DBG("%s: no pci parent found\n", np->full_name);

1244

DBG("%s: no pci parent found\n", np->full_name);

1275

goto next_port;

1245

goto next_port;

1276

}

1246

}

1277

1247

1278

rangesp = (u32 *)get_property(pci, "ranges", &rlen);

1248

rangesp = (u32 *)get_property(pci, "ranges", &rlen);

1279

if (rangesp == NULL) {

1249

if (rangesp == NULL) {

1280

of_node_put(pci);

1250

of_node_put(pci);

1281

goto next_port;

1251

goto next_port;

1282

}

1252

}

1283

rlen /= 4;

1253

rlen /= 4;

1284

1254

1285

/* we need the #size-cells of the PCI bridge node itself */

1255

/* we need the #size-cells of the PCI bridge node itself */

1286

phys_size = 1;

1256

phys_size = 1;

1287

sizeprop = (u32 *)get_property(pci, "#size-cells", NULL);

1257

sizeprop = (u32 *)get_property(pci, "#size-cells", NULL);

1288

if (sizeprop != NULL)

1258

if (sizeprop != NULL)

1289

phys_size = *sizeprop;

1259

phys_size = *sizeprop;

1290

/* we need the parent #addr-cells */

1260

/* we need the parent #addr-cells */

1291

addr_size = prom_n_addr_cells(pci);

1261

addr_size = prom_n_addr_cells(pci);

1292

rentsize = 3 + addr_size + phys_size;

1262

rentsize = 3 + addr_size + phys_size;

1293

io_base = 0;

1263

io_base = 0;

1294

for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) {

1264

for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) {

1295

if (((rangesp[0] >> 24) & 0x3) != 1)

1265

if (((rangesp[0] >> 24) & 0x3) != 1)

1296

continue; /* not IO space */

1266

continue; /* not IO space */

1297

io_base = rangesp[3];

1267

io_base = rangesp[3];

1298

if (addr_size == 2)

1268

if (addr_size == 2)

1299

io_base = (io_base << 32) | rangesp[4];

1269

io_base = (io_base << 32) | rangesp[4];

1300

}

1270

}

1301

if (io_base != 0) {

1271

if (io_base != 0) {

1302

*physport = io_base + reg->address;

1272

*physport = io_base + reg->address;

1303

if (default_speed && spd)

1273

if (default_speed && spd)

1304

*default_speed = *spd;

1274

*default_speed = *spd;

1305

}

1275

}

1306

of_node_put(pci);

1276

of_node_put(pci);

1307

next_port:

1277

next_port:

1308

of_node_put(isa);

1278

of_node_put(isa);

1309

}

1279

}

1310

1280

1311

DBG(" <- generic_find_legacy_serial_port()\n");

1281

DBG(" <- generic_find_legacy_serial_port()\n");

1312

}

1282

}

1313

1283

1314

static struct platform_device serial_device = {

1284

static struct platform_device serial_device = {

1315

.name = "serial8250",

1285

.name = "serial8250",

1316

.id = 0,

1286

.id = 0,

1317

.dev = {

1287

.dev = {

1318

.platform_data = serial_ports,

1288

.platform_data = serial_ports,

1319

},

1289

},

1320

};

1290

};

1321

1291

1322

static int __init serial_dev_init(void)

1292

static int __init serial_dev_init(void)

1323

{

1293

{

1324

return platform_device_register(&serial_device);

1294

return platform_device_register(&serial_device);

1325

}

1295

}

1326

arch_initcall(serial_dev_init);

1296

arch_initcall(serial_dev_init);

1327

1297

1328

#endif /* CONFIG_PPC_ISERIES */

1298

#endif /* CONFIG_PPC_ISERIES */

1329

1299

1330

int check_legacy_ioport(unsigned long base_port)

1300

int check_legacy_ioport(unsigned long base_port)

1331

{

1301

{

1332

if (ppc_md.check_legacy_ioport == NULL)

1302

if (ppc_md.check_legacy_ioport == NULL)

1333

return 0;

1303

return 0;

1334

return ppc_md.check_legacy_ioport(base_port);

1304

return ppc_md.check_legacy_ioport(base_port);

1335

}

1305

}

1336

EXPORT_SYMBOL(check_legacy_ioport);

1306

EXPORT_SYMBOL(check_legacy_ioport);

1337

1307

1338

#ifdef CONFIG_XMON

1308

#ifdef CONFIG_XMON

1339

static int __init early_xmon(char *p)

1309

static int __init early_xmon(char *p)

1340

{

1310

{

1341

/* ensure xmon is enabled */

1311

/* ensure xmon is enabled */

1342

if (p) {

1312

if (p) {

1343

if (strncmp(p, "on", 2) == 0)

1313

if (strncmp(p, "on", 2) == 0)

1344

xmon_init(1);

1314

xmon_init(1);

1345

if (strncmp(p, "off", 3) == 0)

1315

if (strncmp(p, "off", 3) == 0)

1346

xmon_init(0);

1316

xmon_init(0);

1347

if (strncmp(p, "early", 5) != 0)

1317

if (strncmp(p, "early", 5) != 0)

1348

return 0;

1318

return 0;

1349

}

1319

}

1350

xmon_init(1);

1320

xmon_init(1);

1351

debugger(NULL);

1321

debugger(NULL);

1352

1322

1353

return 0;

1323

return 0;

1354

}

1324

}

1355

early_param("xmon", early_xmon);

1325

early_param("xmon", early_xmon);

1356

#endif

1326

#endif

1357

1327

1358

void cpu_die(void)

1328

void cpu_die(void)

1359

{

1329

{

1360

if (ppc_md.cpu_die)

1330

if (ppc_md.cpu_die)

1361

ppc_md.cpu_die();

1331

ppc_md.cpu_die();

1362

}

1332

}

1363

1333

GITLAB

Eric Lee / linux-smarc-t335x-v3.2

[PATCH] ppc64: Consolidate early console and PPCDBG code

 /*
  *
  * Common boot and setup code.
  *
  * Copyright (C) 2001 PPC64 Team, IBM Corp
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 #undef DEBUG
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/seq_file.h>
 #include <linux/ioport.h>
 #include <linux/console.h>
 #include <linux/version.h>
 #include <linux/tty.h>
 #include <linux/root_dev.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/unistd.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/bootinfo.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/machdep.h>
 #include <asm/paca.h>
 #include <asm/ppcdebug.h>
 #include <asm/time.h>
 #include <asm/cputable.h>
 #include <asm/sections.h>
 #include <asm/btext.h>
 #include <asm/nvram.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/rtas.h>
 #include <asm/iommu.h>
 #include <asm/serial.h>
 #include <asm/cache.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 #include <asm/lmb.h>
 #include <asm/iSeries/ItLpNaca.h>
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
 #else
 #define DBG(fmt...)
 #endif
 /*
  * Here are some early debugging facilities. You can enable one
  * but your kernel will not boot on anything else if you do so
  */
 /* This one is for use on LPAR machines that support an HVC console
  * on vterm 0
  */
 extern void udbg_init_debug_lpar(void);
 /* This one is for use on Apple G5 machines
  */
 extern void udbg_init_pmac_realmode(void);
 /* That's RTAS panel debug */
 extern void call_rtas_display_status_delay(unsigned char c);
 /* Here's maple real mode debug */
 extern void udbg_init_maple_realmode(void);
 #define EARLY_DEBUG_INIT() do {} while(0)
 #if 0
 #define EARLY_DEBUG_INIT() udbg_init_debug_lpar()
 #define EARLY_DEBUG_INIT() udbg_init_maple_realmode()
 #define EARLY_DEBUG_INIT() udbg_init_pmac_realmode()
 #define EARLY_DEBUG_INIT()						\
 	do { udbg_putc = call_rtas_display_status_delay; } while(0)
 #endif
 /* extern void *stab; */
 extern unsigned long klimit;
 extern void mm_init_ppc64(void);
 extern void stab_initialize(unsigned long stab);
 extern void htab_initialize(void);
 extern void early_init_devtree(void *flat_dt);
 extern void unflatten_device_tree(void);
 extern void smp_release_cpus(void);
 int have_of = 1;
 int boot_cpuid = 0;
 int boot_cpuid_phys = 0;
 dev_t boot_dev;
 u64 ppc64_pft_size;
-u64 ppc64_debug_switch;
 struct ppc64_caches ppc64_caches;
 EXPORT_SYMBOL_GPL(ppc64_caches);
 /*
  * These are used in binfmt_elf.c to put aux entries on the stack
  * for each elf executable being started.
  */
 int dcache_bsize;
 int icache_bsize;
 int ucache_bsize;
 /* The main machine-dep calls structure
  */
 struct machdep_calls ppc_md;
 EXPORT_SYMBOL(ppc_md);
 #ifdef CONFIG_MAGIC_SYSRQ
 unsigned long SYSRQ_KEY;
 #endif /* CONFIG_MAGIC_SYSRQ */
 static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);
 static struct notifier_block ppc64_panic_block = {
 	.notifier_call = ppc64_panic_event,
 	.priority = INT_MIN /* may not return; must be done last */
 };
 /*
  * Perhaps we can put the pmac screen_info[] here
  * on pmac as well so we don't need the ifdef's.
  * Until we get multiple-console support in here
  * that is.  -- Cort
  * Maybe tie it to serial consoles, since this is really what
  * these processors use on existing boards.  -- Dan
  */
 struct screen_info screen_info = {
 	.orig_x = 0,
 	.orig_y = 25,
 	.orig_video_cols = 80,
 	.orig_video_lines = 25,
 	.orig_video_isVGA = 1,
 	.orig_video_points = 16
 };
-/*
- * Initialize the PPCDBG state.  Called before relocation has been enabled.
- */
-void __init ppcdbg_initialize(void)
-{
-	ppc64_debug_switch = PPC_DEBUG_DEFAULT; /* | PPCDBG_BUSWALK | */
-	/* PPCDBG_PHBINIT | PPCDBG_MM | PPCDBG_MMINIT | PPCDBG_TCEINIT | PPCDBG_TCE */;
-}
-/*
- * Early boot console based on udbg
- */
-static struct console udbg_console = {
-	.name	= "udbg",
-	.write	= udbg_console_write,
-	.flags	= CON_PRINTBUFFER,
-	.index	= -1,
-};
-static int early_console_initialized;
-void __init disable_early_printk(void)
-{
-	if (!early_console_initialized)
-		return;
-	unregister_console(&udbg_console);
-	early_console_initialized = 0;
-}
 #if defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP)
 static int smt_enabled_cmdline;
 /* Look for ibm,smt-enabled OF option */
 static void check_smt_enabled(void)
 {
 	struct device_node *dn;
 	char *smt_option;
 	/* Allow the command line to overrule the OF option */
 	if (smt_enabled_cmdline)
 		return;
 	dn = of_find_node_by_path("/options");
 	if (dn) {
 		smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);
                 if (smt_option) {
 			if (!strcmp(smt_option, "on"))
 				smt_enabled_at_boot = 1;
 			else if (!strcmp(smt_option, "off"))
 				smt_enabled_at_boot = 0;
                 }
         }
 }
 /* Look for smt-enabled= cmdline option */
 static int __init early_smt_enabled(char *p)
 {
 	smt_enabled_cmdline = 1;
 	if (!p)
 		return 0;
 	if (!strcmp(p, "on") || !strcmp(p, "1"))
 		smt_enabled_at_boot = 1;
 	else if (!strcmp(p, "off") || !strcmp(p, "0"))
 		smt_enabled_at_boot = 0;
 	return 0;
 }
 early_param("smt-enabled", early_smt_enabled);
 /**
  * setup_cpu_maps - initialize the following cpu maps:
  *                  cpu_possible_map
  *                  cpu_present_map
  *                  cpu_sibling_map
  *
  * Having the possible map set up early allows us to restrict allocations
  * of things like irqstacks to num_possible_cpus() rather than NR_CPUS.
  *
  * We do not initialize the online map here; cpus set their own bits in
  * cpu_online_map as they come up.
  *
  * This function is valid only for Open Firmware systems.  finish_device_tree
  * must be called before using this.
  *
  * While we're here, we may as well set the "physical" cpu ids in the paca.
  */
 static void __init setup_cpu_maps(void)
 {
 	struct device_node *dn = NULL;
 	int cpu = 0;
 	int swap_cpuid = 0;
 	check_smt_enabled();
 	while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {
 		u32 *intserv;
 		int j, len = sizeof(u32), nthreads;
 		intserv = (u32 *)get_property(dn, "ibm,ppc-interrupt-server#s",
 					      &len);
 		if (!intserv)
 			intserv = (u32 *)get_property(dn, "reg", NULL);
 		nthreads = len / sizeof(u32);
 		for (j = 0; j < nthreads && cpu < NR_CPUS; j++) {
 			cpu_set(cpu, cpu_present_map);
 			set_hard_smp_processor_id(cpu, intserv[j]);
 			if (intserv[j] == boot_cpuid_phys)
 				swap_cpuid = cpu;
 			cpu_set(cpu, cpu_possible_map);
 			cpu++;
 		}
 	}
 	/* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that
 	 * boot cpu is logical 0.
 	 */
 	if (boot_cpuid_phys != get_hard_smp_processor_id(0)) {
 		u32 tmp;
 		tmp = get_hard_smp_processor_id(0);
 		set_hard_smp_processor_id(0, boot_cpuid_phys);
 		set_hard_smp_processor_id(swap_cpuid, tmp);
 	}
 	/*
 	 * On pSeries LPAR, we need to know how many cpus
 	 * could possibly be added to this partition.
 	 */
 	if (systemcfg->platform == PLATFORM_PSERIES_LPAR &&
 				(dn = of_find_node_by_path("/rtas"))) {
 		int num_addr_cell, num_size_cell, maxcpus;
 		unsigned int *ireg;
 		num_addr_cell = prom_n_addr_cells(dn);
 		num_size_cell = prom_n_size_cells(dn);
 		ireg = (unsigned int *)
 			get_property(dn, "ibm,lrdr-capacity", NULL);
 		if (!ireg)
 			goto out;
 		maxcpus = ireg[num_addr_cell + num_size_cell];
 		/* Double maxcpus for processors which have SMT capability */
 		if (cpu_has_feature(CPU_FTR_SMT))
 			maxcpus *= 2;
 		if (maxcpus > NR_CPUS) {
 			printk(KERN_WARNING
 			       "Partition configured for %d cpus, "
 			       "operating system maximum is %d.\n",
 			       maxcpus, NR_CPUS);
 			maxcpus = NR_CPUS;
 		} else
 			printk(KERN_INFO "Partition configured for %d cpus.\n",
 			       maxcpus);
 		for (cpu = 0; cpu < maxcpus; cpu++)
 			cpu_set(cpu, cpu_possible_map);
 	out:
 		of_node_put(dn);
 	}
 	/*
 	 * Do the sibling map; assume only two threads per processor.
 	 */
 	for_each_cpu(cpu) {
 		cpu_set(cpu, cpu_sibling_map[cpu]);
 		if (cpu_has_feature(CPU_FTR_SMT))
 			cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]);
 	}
 	systemcfg->processorCount = num_present_cpus();
 }
 #endif /* defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP) */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 extern struct machdep_calls pSeries_md;
 extern struct machdep_calls pmac_md;
 extern struct machdep_calls maple_md;
 extern struct machdep_calls bpa_md;
 /* Ultimately, stuff them in an elf section like initcalls... */
 static struct machdep_calls __initdata *machines[] = {
 #ifdef CONFIG_PPC_PSERIES
 	&pSeries_md,
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_PPC_PMAC
 	&pmac_md,
 #endif /* CONFIG_PPC_PMAC */
 #ifdef CONFIG_PPC_MAPLE
 	&maple_md,
 #endif /* CONFIG_PPC_MAPLE */
 #ifdef CONFIG_PPC_BPA
 	&bpa_md,
 #endif
 	NULL
 };
 /*
  * Early initialization entry point. This is called by head.S
  * with MMU translation disabled. We rely on the "feature" of
  * the CPU that ignores the top 2 bits of the address in real
  * mode so we can access kernel globals normally provided we
  * only toy with things in the RMO region. From here, we do
  * some early parsing of the device-tree to setup out LMB
  * data structures, and allocate & initialize the hash table
  * and segment tables so we can start running with translation
  * enabled.
  *
  * It is this function which will call the probe() callback of
  * the various platform types and copy the matching one to the
  * global ppc_md structure. Your platform can eventually do
  * some very early initializations from the probe() routine, but
  * this is not recommended, be very careful as, for example, the
  * device-tree is not accessible via normal means at this point.
  */
 void __init early_setup(unsigned long dt_ptr)
 {
 	struct paca_struct *lpaca = get_paca();
 	static struct machdep_calls **mach;
 	/*
 	 * Enable early debugging if any specified (see top of
 	 * this file)
 	 */
 	EARLY_DEBUG_INIT();
 	DBG(" -> early_setup()\n");
 	/*
 	 * Fill the default DBG level (do we want to keep
 	 * that old mecanism around forever ?)
 	 */
 	ppcdbg_initialize();
 	/*
 	 * Do early initializations using the flattened device
 	 * tree, like retreiving the physical memory map or
 	 * calculating/retreiving the hash table size
 	 */
 	early_init_devtree(__va(dt_ptr));
 	/*
 	 * Iterate all ppc_md structures until we find the proper
 	 * one for the current machine type
 	 */
 	DBG("Probing machine type for platform %x...\n",
 	    systemcfg->platform);
 	for (mach = machines; *mach; mach++) {
 		if ((*mach)->probe(systemcfg->platform))
 			break;
 	}
 	/* What can we do if we didn't find ? */
 	if (*mach == NULL) {
 		DBG("No suitable machine found !\n");
 		for (;;);
 	}
 	ppc_md = **mach;
 	DBG("Found, Initializing memory management...\n");
 	/*
 	 * Initialize stab / SLB management
 	 */
 	stab_initialize(lpaca->stab_real);
 	/*
 	 * Initialize the MMU Hash table and create the linear mapping
 	 * of memory
 	 */
 	htab_initialize();
 	DBG(" <- early_setup()\n");
 }
 /*
  * Initialize some remaining members of the ppc64_caches and systemcfg structures
  * (at least until we get rid of them completely). This is mostly some
  * cache informations about the CPU that will be used by cache flush
  * routines and/or provided to userland
  */
 static void __init initialize_cache_info(void)
 {
 	struct device_node *np;
 	unsigned long num_cpus = 0;
 	DBG(" -> initialize_cache_info()\n");
 	for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {
 		num_cpus += 1;
 		/* We're assuming *all* of the CPUs have the same
 		 * d-cache and i-cache sizes... -Peter
 		 */
 		if ( num_cpus == 1 ) {
 			u32 *sizep, *lsizep;
 			u32 size, lsize;
 			const char *dc, *ic;
 			/* Then read cache informations */
 			if (systemcfg->platform == PLATFORM_POWERMAC) {
 				dc = "d-cache-block-size";
 				ic = "i-cache-block-size";
 			} else {
 				dc = "d-cache-line-size";
 				ic = "i-cache-line-size";
 			}
 			size = 0;
 			lsize = cur_cpu_spec->dcache_bsize;
 			sizep = (u32 *)get_property(np, "d-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *) get_property(np, dc, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find dcache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->dcache_size = ppc64_caches.dsize = size;
 			systemcfg->dcache_line_size =
 				ppc64_caches.dline_size = lsize;
 			ppc64_caches.log_dline_size = __ilog2(lsize);
 			ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;
 			size = 0;
 			lsize = cur_cpu_spec->icache_bsize;
 			sizep = (u32 *)get_property(np, "i-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *)get_property(np, ic, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find icache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->icache_size = ppc64_caches.isize = size;
 			systemcfg->icache_line_size =
 				ppc64_caches.iline_size = lsize;
 			ppc64_caches.log_iline_size = __ilog2(lsize);
 			ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;
 		}
 	}
 	/* Add an eye catcher and the systemcfg layout version number */
 	strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64");
 	systemcfg->version.major = SYSTEMCFG_MAJOR;
 	systemcfg->version.minor = SYSTEMCFG_MINOR;
 	systemcfg->processor = mfspr(SPRN_PVR);
 	DBG(" <- initialize_cache_info()\n");
 }
 static void __init check_for_initrd(void)
 {
 #ifdef CONFIG_BLK_DEV_INITRD
 	u64 *prop;
 	DBG(" -> check_for_initrd()\n");
 	if (of_chosen) {
 		prop = (u64 *)get_property(of_chosen,
 				"linux,initrd-start", NULL);
 		if (prop != NULL) {
 			initrd_start = (unsigned long)__va(*prop);
 			prop = (u64 *)get_property(of_chosen,
 					"linux,initrd-end", NULL);
 			if (prop != NULL) {
 				initrd_end = (unsigned long)__va(*prop);
 				initrd_below_start_ok = 1;
 			} else
 				initrd_start = 0;
 		}
 	}
 	/* If we were passed an initrd, set the ROOT_DEV properly if the values
 	 * look sensible. If not, clear initrd reference.
 	 */
 	if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
 	    initrd_end > initrd_start)
 		ROOT_DEV = Root_RAM0;
 	else
 		initrd_start = initrd_end = 0;
 	if (initrd_start)
 		printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);
 	DBG(" <- check_for_initrd()\n");
 #endif /* CONFIG_BLK_DEV_INITRD */
 }
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 /*
  * Do some initial setup of the system.  The parameters are those which
  * were passed in from the bootloader.
  */
 void __init setup_system(void)
 {
 	DBG(" -> setup_system()\n");
 #ifdef CONFIG_PPC_ISERIES
 	/* pSeries systems are identified in prom.c via OF. */
 	if (itLpNaca.xLparInstalled == 1)
 		systemcfg->platform = PLATFORM_ISERIES_LPAR;
 	ppc_md.init_early();
 #else /* CONFIG_PPC_ISERIES */
 	/*
 	 * Unflatten the device-tree passed by prom_init or kexec
 	 */
 	unflatten_device_tree();
 	/*
 	 * Fill the ppc64_caches & systemcfg structures with informations
 	 * retreived from the device-tree. Need to be called before
 	 * finish_device_tree() since the later requires some of the
 	 * informations filled up here to properly parse the interrupt
 	 * tree.
 	 * It also sets up the cache line sizes which allows to call
 	 * routines like flush_icache_range (used by the hash init
 	 * later on).
 	 */
 	initialize_cache_info();
 #ifdef CONFIG_PPC_RTAS
 	/*
 	 * Initialize RTAS if available
 	 */
 	rtas_initialize();
 #endif /* CONFIG_PPC_RTAS */
 	/*
 	 * Check if we have an initrd provided via the device-tree
 	 */
 	check_for_initrd();
 	/*
 	 * Do some platform specific early initializations, that includes
 	 * setting up the hash table pointers. It also sets up some interrupt-mapping
 	 * related options that will be used by finish_device_tree()
 	 */
 	ppc_md.init_early();
 	/*
 	 * "Finish" the device-tree, that is do the actual parsing of
 	 * some of the properties like the interrupt map
 	 */
 	finish_device_tree();
 	/*
 	 * Initialize xmon
 	 */
 #ifdef CONFIG_XMON_DEFAULT
 	xmon_init(1);
 #endif
 	/*
 	 * Register early console
 	 */
-	early_console_initialized = 1;
+	register_early_udbg_console();
-	register_console(&udbg_console);
 	/* Save unparsed command line copy for /proc/cmdline */
 	strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
 	parse_early_param();
 #endif /* !CONFIG_PPC_ISERIES */
 #if defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES)
 	/*
 	 * iSeries has already initialized the cpu maps at this point.
 	 */
 	setup_cpu_maps();
 	/* Release secondary cpus out of their spinloops at 0x60 now that
 	 * we can map physical -> logical CPU ids
 	 */
 	smp_release_cpus();
 #endif /* defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) */
 	printk("Starting Linux PPC64 %s\n", UTS_RELEASE);
 	printk("-----------------------------------------------------\n");
 	printk("ppc64_pft_size                = 0x%lx\n", ppc64_pft_size);
 	printk("ppc64_debug_switch            = 0x%lx\n", ppc64_debug_switch);
 	printk("ppc64_interrupt_controller    = 0x%ld\n", ppc64_interrupt_controller);
 	printk("systemcfg                     = 0x%p\n", systemcfg);
 	printk("systemcfg->platform           = 0x%x\n", systemcfg->platform);
 	printk("systemcfg->processorCount     = 0x%lx\n", systemcfg->processorCount);
 	printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize);
 	printk("ppc64_caches.dcache_line_size = 0x%x\n",
 			ppc64_caches.dline_size);
 	printk("ppc64_caches.icache_line_size = 0x%x\n",
 			ppc64_caches.iline_size);
 	printk("htab_address                  = 0x%p\n", htab_address);
 	printk("htab_hash_mask                = 0x%lx\n", htab_hash_mask);
 	printk("-----------------------------------------------------\n");
 	mm_init_ppc64();
 	DBG(" <- setup_system()\n");
 }
 /* also used by kexec */
 void machine_shutdown(void)
 {
 	if (ppc_md.nvram_sync)
 		ppc_md.nvram_sync();
 }
 void machine_restart(char *cmd)
 {
 	machine_shutdown();
 	ppc_md.restart(cmd);
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 void machine_power_off(void)
 {
 	machine_shutdown();
 	ppc_md.power_off();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 /* Used by the G5 thermal driver */
 EXPORT_SYMBOL_GPL(machine_power_off);
 void machine_halt(void)
 {
 	machine_shutdown();
 	ppc_md.halt();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 static int ppc64_panic_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
 	ppc_md.panic((char *)ptr);  /* May not return */
 	return NOTIFY_DONE;
 }
 #ifdef CONFIG_SMP
 DEFINE_PER_CPU(unsigned int, pvr);
 #endif
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
 	unsigned long cpu_id = (unsigned long)v - 1;
 	unsigned int pvr;
 	unsigned short maj;
 	unsigned short min;
 	if (cpu_id == NR_CPUS) {
 		seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);
 		if (ppc_md.get_cpuinfo != NULL)
 			ppc_md.get_cpuinfo(m);
 		return 0;
 	}
 	/* We only show online cpus: disable preempt (overzealous, I
 	 * knew) to prevent cpu going down. */
 	preempt_disable();
 	if (!cpu_online(cpu_id)) {
 		preempt_enable();
 		return 0;
 	}
 #ifdef CONFIG_SMP
 	pvr = per_cpu(pvr, cpu_id);
 #else
 	pvr = mfspr(SPRN_PVR);
 #endif
 	maj = (pvr >> 8) & 0xFF;
 	min = pvr & 0xFF;
 	seq_printf(m, "processor\t: %lu\n", cpu_id);
 	seq_printf(m, "cpu\t\t: ");
 	if (cur_cpu_spec->pvr_mask)
 		seq_printf(m, "%s", cur_cpu_spec->cpu_name);
 	else
 		seq_printf(m, "unknown (%08x)", pvr);
 #ifdef CONFIG_ALTIVEC
 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
 		seq_printf(m, ", altivec supported");
 #endif /* CONFIG_ALTIVEC */
 	seq_printf(m, "\n");
 	/*
 	 * Assume here that all clock rates are the same in a
 	 * smp system.  -- Cort
 	 */
 	seq_printf(m, "clock\t\t: %lu.%06luMHz\n", ppc_proc_freq / 1000000,
 		   ppc_proc_freq % 1000000);
 	seq_printf(m, "revision\t: %hd.%hd\n\n", maj, min);
 	preempt_enable();
 	return 0;
 }
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	return *pos <= NR_CPUS ? (void *)((*pos)+1) : NULL;
 }
 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return c_start(m, pos);
 }
 static void c_stop(struct seq_file *m, void *v)
 {
 }
 struct seq_operations cpuinfo_op = {
 	.start =c_start,
 	.next =	c_next,
 	.stop =	c_stop,
 	.show =	show_cpuinfo,
 };
 /*
  * These three variables are used to save values passed to us by prom_init()
  * via the device tree. The TCE variables are needed because with a memory_limit
  * in force we may need to explicitly map the TCE are at the top of RAM.
  */
 unsigned long memory_limit;
 unsigned long tce_alloc_start;
 unsigned long tce_alloc_end;
 #ifdef CONFIG_PPC_ISERIES
 /*
  * On iSeries we just parse the mem=X option from the command line.
  * On pSeries it's a bit more complicated, see prom_init_mem()
  */
 static int __init early_parsemem(char *p)
 {
 	if (!p)
 		return 0;
 	memory_limit = ALIGN(memparse(p, &p), PAGE_SIZE);
 	return 0;
 }
 early_param("mem", early_parsemem);
 #endif /* CONFIG_PPC_ISERIES */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static int __init set_preferred_console(void)
 {
 	struct device_node *prom_stdout = NULL;
 	char *name;
 	u32 *spd;
 	int offset = 0;
 	DBG(" -> set_preferred_console()\n");
 	/* The user has requested a console so this is already set up. */
 	if (strstr(saved_command_line, "console=")) {
 		DBG(" console was specified !\n");
 		return -EBUSY;
 	}
 	if (!of_chosen) {
 		DBG(" of_chosen is NULL !\n");
 		return -ENODEV;
 	}
 	/* We are getting a weird phandle from OF ... */
 	/* ... So use the full path instead */
 	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
 	if (name == NULL) {
 		DBG(" no linux,stdout-path !\n");
 		return -ENODEV;
 	}
 	prom_stdout = of_find_node_by_path(name);
 	if (!prom_stdout) {
 		DBG(" can't find stdout package %s !\n", name);
 		return -ENODEV;
 	}
 	DBG("stdout is %s\n", prom_stdout->full_name);
 	name = (char *)get_property(prom_stdout, "name", NULL);
 	if (!name) {
 		DBG(" stdout package has no name !\n");
 		goto not_found;
 	}
 	spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);
 	if (0)
 		;
 #ifdef CONFIG_SERIAL_8250_CONSOLE
 	else if (strcmp(name, "serial") == 0) {
 		int i;
 		u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);
 		if (i > 8) {
 			switch (reg[1]) {
 				case 0x3f8:
 					offset = 0;
 					break;
 				case 0x2f8:
 					offset = 1;
 					break;
 				case 0x898:
 					offset = 2;
 					break;
 				case 0x890:
 					offset = 3;
 					break;
 				default:
 					/* We dont recognise the serial port */
 					goto not_found;
 			}
 		}
 	}
 #endif /* CONFIG_SERIAL_8250_CONSOLE */
 #ifdef CONFIG_PPC_PSERIES
 	else if (strcmp(name, "vty") == 0) {
  		u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL);
  		char *compat = (char *)get_property(prom_stdout, "compatible", NULL);
  		if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) {
  			/* Host Virtual Serial Interface */
  			int offset;
  			switch (reg[0]) {
  				case 0x30000000:
  					offset = 0;
  					break;
  				case 0x30000001:
  					offset = 1;
  					break;
  				default:
 					goto not_found;
  			}
 			of_node_put(prom_stdout);
 			DBG("Found hvsi console at offset %d\n", offset);
  			return add_preferred_console("hvsi", offset, NULL);
  		} else {
  			/* pSeries LPAR virtual console */
 			of_node_put(prom_stdout);
 			DBG("Found hvc console\n");
  			return add_preferred_console("hvc", 0, NULL);
  		}
 	}
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
 	else if (strcmp(name, "ch-a") == 0)
 		offset = 0;
 	else if (strcmp(name, "ch-b") == 0)
 		offset = 1;
 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
 	else
 		goto not_found;
 	of_node_put(prom_stdout);
 	DBG("Found serial console at ttyS%d\n", offset);
 	if (spd) {
 		static char __initdata opt[16];
 		sprintf(opt, "%d", *spd);
 		return add_preferred_console("ttyS", offset, opt);
 	} else
 		return add_preferred_console("ttyS", offset, NULL);
  not_found:
 	DBG("No preferred console found !\n");
 	of_node_put(prom_stdout);
 	return -ENODEV;
 }
 console_initcall(set_preferred_console);
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 #ifdef CONFIG_IRQSTACKS
 static void __init irqstack_early_init(void)
 {
 	unsigned int i;
 	/*
 	 * interrupt stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them.
 	 */
 	for_each_cpu(i) {
 		softirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,
 					THREAD_SIZE, 0x10000000));
 		hardirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,
 					THREAD_SIZE, 0x10000000));
 	}
 }
 #else
 #define irqstack_early_init()
 #endif
 /*
  * Stack space used when we detect a bad kernel stack pointer, and
  * early in SMP boots before relocation is enabled.
  */
 static void __init emergency_stack_init(void)
 {
 	unsigned long limit;
 	unsigned int i;
 	/*
 	 * Emergency stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them. The ABI also requires them to be 128-byte
 	 * aligned.
 	 *
 	 * Since we use these as temporary stacks during secondary CPU
 	 * bringup, we need to get at them in real mode. This means they
 	 * must also be within the RMO region.
 	 */
 	limit = min(0x10000000UL, lmb.rmo_size);
 	for_each_cpu(i)
 		paca[i].emergency_sp = __va(lmb_alloc_base(PAGE_SIZE, 128,
 						limit)) + PAGE_SIZE;
 }
 /*
  * Called from setup_arch to initialize the bitmap of available
  * syscalls in the systemcfg page
  */
 void __init setup_syscall_map(void)
 {
 	unsigned int i, count64 = 0, count32 = 0;
 	extern unsigned long *sys_call_table;
 	extern unsigned long *sys_call_table32;
 	extern unsigned long sys_ni_syscall;
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table[i] == sys_ni_syscall)
 			continue;
 		count64++;
 		systemcfg->syscall_map_64[i >> 5] |= 0x80000000UL >> (i & 0x1f);
 	}
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table32[i] == sys_ni_syscall)
 			continue;
 		count32++;
 		systemcfg->syscall_map_32[i >> 5] |= 0x80000000UL >> (i & 0x1f);
 	}
 	printk(KERN_INFO "Syscall map setup, %d 32 bits and %d 64 bits syscalls\n",
 	       count32, count64);
 }
 /*
  * Called into from start_kernel, after lock_kernel has been called.
  * Initializes bootmem, which is unsed to manage page allocation until
  * mem_init is called.
  */
 void __init setup_arch(char **cmdline_p)
 {
 	extern void do_init_bootmem(void);
 	ppc64_boot_msg(0x12, "Setup Arch");
 	*cmdline_p = cmd_line;
 	/*
 	 * Set cache line size based on type of cpu as a default.
 	 * Systems with OF can look in the properties on the cpu node(s)
 	 * for a possibly more accurate value.
 	 */
 	dcache_bsize = ppc64_caches.dline_size;
 	icache_bsize = ppc64_caches.iline_size;
 	/* reboot on panic */
 	panic_timeout = 180;
 	if (ppc_md.panic)
 		notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) _etext;
 	init_mm.end_data = (unsigned long) _edata;
 	init_mm.brk = klimit;
 	irqstack_early_init();
 	emergency_stack_init();
 	stabs_alloc();
 	/* set up the bootmem stuff with available memory */
 	do_init_bootmem();
 	sparse_init();
 	/* initialize the syscall map in systemcfg */
 	setup_syscall_map();
 	ppc_md.setup_arch();
 	/* Use the default idle loop if the platform hasn't provided one. */
 	if (NULL == ppc_md.idle_loop) {
 		ppc_md.idle_loop = default_idle;
 		printk(KERN_INFO "Using default idle loop\n");
 	}
 	paging_init();
 	ppc64_boot_msg(0x15, "Setup Done");
 }
 /* ToDo: do something useful if ppc_md is not yet setup. */
 #define PPC64_LINUX_FUNCTION 0x0f000000
 #define PPC64_IPL_MESSAGE 0xc0000000
 #define PPC64_TERM_MESSAGE 0xb0000000
 #define PPC64_ATTN_MESSAGE 0xa0000000
 #define PPC64_DUMP_MESSAGE 0xd0000000
 static void ppc64_do_msg(unsigned int src, const char *msg)
 {
 	if (ppc_md.progress) {
 		char buf[128];
 		sprintf(buf, "%08X\n", src);
 		ppc_md.progress(buf, 0);
 		snprintf(buf, 128, "%s", msg);
 		ppc_md.progress(buf, 0);
 	}
 }
 /* Print a boot progress message. */
 void ppc64_boot_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);
 	printk("[boot]%04x %s\n", src, msg);
 }
 /* Print a termination message (print only -- does not stop the kernel) */
 void ppc64_terminate_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg);
 	printk("[terminate]%04x %s\n", src, msg);
 }
 /* Print something that needs attention (device error, etc) */
 void ppc64_attention_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_ATTN_MESSAGE|src, msg);
 	printk("[attention]%04x %s\n", src, msg);
 }
 /* Print a dump progress message. */
 void ppc64_dump_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_DUMP_MESSAGE|src, msg);
 	printk("[dump]%04x %s\n", src, msg);
 }
 /* This should only be called on processor 0 during calibrate decr */
 void __init setup_default_decr(void)
 {
 	struct paca_struct *lpaca = get_paca();
 	lpaca->default_decr = tb_ticks_per_jiffy;
 	lpaca->next_jiffy_update_tb = get_tb() + tb_ticks_per_jiffy;
 }
 #ifndef CONFIG_PPC_ISERIES
 /*
  * This function can be used by platforms to "find" legacy serial ports.
  * It works for "serial" nodes under an "isa" node, and will try to
  * respect the "ibm,aix-loc" property if any. It works with up to 8
  * ports.
  */
 #define MAX_LEGACY_SERIAL_PORTS	8
 static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1];
 static unsigned int old_serial_count;
 void __init generic_find_legacy_serial_ports(u64 *physport,
 		unsigned int *default_speed)
 {
 	struct device_node *np;
 	u32 *sizeprop;
 	struct isa_reg_property {
 		u32 space;
 		u32 address;
 		u32 size;
 	};
 	struct pci_reg_property {
 		struct pci_address addr;
 		u32 size_hi;
 		u32 size_lo;
 	};
 	DBG(" -> generic_find_legacy_serial_port()\n");
 	*physport = 0;
 	if (default_speed)
 		*default_speed = 0;
 	np = of_find_node_by_path("/");
 	if (!np)
 		return;
 	/* First fill our array */
 	for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {
 		struct device_node *isa, *pci;
 		struct isa_reg_property *reg;
 		unsigned long phys_size, addr_size, io_base;
 		u32 *rangesp;
 		u32 *interrupts, *clk, *spd;
 		char *typep;
 		int index, rlen, rentsize;
 		/* Ok, first check if it's under an "isa" parent */
 		isa = of_get_parent(np);
 		if (!isa || strcmp(isa->name, "isa")) {
 			DBG("%s: no isa parent found\n", np->full_name);
 			continue;
 		}
 		/* Now look for an "ibm,aix-loc" property that gives us ordering
 		 * if any...
 		 */
 	 	typep = (char *)get_property(np, "ibm,aix-loc", NULL);
 		/* Get the ISA port number */
 		reg = (struct isa_reg_property *)get_property(np, "reg", NULL);
 		if (reg == NULL)
 			goto next_port;
 		/* We assume the interrupt number isn't translated ... */
 		interrupts = (u32 *)get_property(np, "interrupts", NULL);
 		/* get clock freq. if present */
 		clk = (u32 *)get_property(np, "clock-frequency", NULL);
 		/* get default speed if present */
 		spd = (u32 *)get_property(np, "current-speed", NULL);
 		/* Default to locate at end of array */
 		index = old_serial_count; /* end of the array by default */
 		/* If we have a location index, then use it */
 		if (typep && *typep == 'S') {
 			index = simple_strtol(typep+1, NULL, 0) - 1;
 			/* if index is out of range, use end of array instead */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				index = old_serial_count;
 			/* if our index is still out of range, that mean that
 			 * array is full, we could scan for a free slot but that
 			 * make little sense to bother, just skip the port
 			 */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				goto next_port;
 			if (index >= old_serial_count)
 				old_serial_count = index + 1;
 			/* Check if there is a port who already claimed our slot */
 			if (serial_ports[index].iobase != 0) {
 				/* if we still have some room, move it, else override */
 				if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) {
 					DBG("Moved legacy port %d -> %d\n", index,
 					    old_serial_count);
 					serial_ports[old_serial_count++] =
 						serial_ports[index];
 				} else {
 					DBG("Replacing legacy port %d\n", index);
 				}
 			}
 		}
 		if (index >= MAX_LEGACY_SERIAL_PORTS)
 			goto next_port;
 		if (index >= old_serial_count)
 			old_serial_count = index + 1;
 		/* Now fill the entry */
 		memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port));
 		serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16;
 		serial_ports[index].iobase = reg->address;
 		serial_ports[index].irq = interrupts ? interrupts[0] : 0;
 		serial_ports[index].flags = ASYNC_BOOT_AUTOCONF;
 		DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n",
 		    index,
 		    serial_ports[index].iobase,
 		    serial_ports[index].irq,
 		    serial_ports[index].uartclk);
 		/* Get phys address of IO reg for port 1 */
 		if (index != 0)
 			goto next_port;
 		pci = of_get_parent(isa);
 		if (!pci) {
 			DBG("%s: no pci parent found\n", np->full_name);
 			goto next_port;
 		}
 		rangesp = (u32 *)get_property(pci, "ranges", &rlen);
 		if (rangesp == NULL) {
 			of_node_put(pci);
 			goto next_port;
 		}
 		rlen /= 4;
 		/* we need the #size-cells of the PCI bridge node itself */
 		phys_size = 1;
 		sizeprop = (u32 *)get_property(pci, "#size-cells", NULL);
 		if (sizeprop != NULL)
 			phys_size = *sizeprop;
 		/* we need the parent #addr-cells */
 		addr_size = prom_n_addr_cells(pci);
 		rentsize = 3 + addr_size + phys_size;
 		io_base = 0;
 		for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) {
 			if (((rangesp[0] >> 24) & 0x3) != 1)
 				continue; /* not IO space */
 			io_base = rangesp[3];
 			if (addr_size == 2)
 				io_base = (io_base << 32) | rangesp[4];
 		}
 		if (io_base != 0) {
 			*physport = io_base + reg->address;
 			if (default_speed && spd)
 				*default_speed = *spd;
 		}
 		of_node_put(pci);
 	next_port:
 		of_node_put(isa);
 	}
 	DBG(" <- generic_find_legacy_serial_port()\n");
 }
 static struct platform_device serial_device = {
 	.name	= "serial8250",
 	.id	= 0,
 	.dev	= {
 		.platform_data = serial_ports,
 	},
 };
 static int __init serial_dev_init(void)
 {
 	return platform_device_register(&serial_device);
 }
 arch_initcall(serial_dev_init);
 #endif /* CONFIG_PPC_ISERIES */
 int check_legacy_ioport(unsigned long base_port)
 {
 	if (ppc_md.check_legacy_ioport == NULL)
 		return 0;
 	return ppc_md.check_legacy_ioport(base_port);
 }
 EXPORT_SYMBOL(check_legacy_ioport);
 #ifdef CONFIG_XMON
 static int __init early_xmon(char *p)
 {
 	/* ensure xmon is enabled */
 	if (p) {
 		if (strncmp(p, "on", 2) == 0)
 			xmon_init(1);
 		if (strncmp(p, "off", 3) == 0)
 			xmon_init(0);
 		if (strncmp(p, "early", 5) != 0)
 			return 0;
 	}
 	xmon_init(1);
 	debugger(NULL);
 	return 0;
 }
 early_param("xmon", early_xmon);
 #endif
 void cpu_die(void)
 {
 	if (ppc_md.cpu_die)
 		ppc_md.cpu_die();
 }

 /*
  * polling mode stateless debugging stuff, originally for NS16550 Serial Ports
  *
  * c 2001 PPC 64 Team, IBM Corp
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 #include <stdarg.h>
 #define WANT_PPCDBG_TAB /* Only defined here */
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/sched.h>
+#include <linux/console.h>
 #include <asm/ppcdebug.h>
 #include <asm/processor.h>
 void (*udbg_putc)(unsigned char c);
 unsigned char (*udbg_getc)(void);
 int (*udbg_getc_poll)(void);
+/* udbg library, used by xmon et al */
 void udbg_puts(const char *s)
 {
 	if (udbg_putc) {
 		char c;
 		if (s && *s != '\0') {
 			while ((c = *s++) != '\0')
 				udbg_putc(c);
 		}
 	}
 #if 0
 	else {
 		printk("%s", s);
 	}
 #endif
 }
 int udbg_write(const char *s, int n)
 {
 	int remain = n;
 	char c;
 	if (!udbg_putc)
 		return 0;
 	if (s && *s != '\0') {
 		while (((c = *s++) != '\0') && (remain-- > 0)) {
 			udbg_putc(c);
 		}
 	}
 	return n - remain;
 }
 int udbg_read(char *buf, int buflen)
 {
 	char c, *p = buf;
 	int i;
 	if (!udbg_getc)
 		return 0;
 	for (i = 0; i < buflen; ++i) {
 		do {
 			c = udbg_getc();
 		} while (c == 0x11 || c == 0x13);
 		if (c == 0)
 			break;
 		*p++ = c;
 	}
 	return i;
 }
-void udbg_console_write(struct console *con, const char *s, unsigned int n)
-{
-	udbg_write(s, n);
-}
 #define UDBG_BUFSIZE 256
 void udbg_printf(const char *fmt, ...)
 {
 	unsigned char buf[UDBG_BUFSIZE];
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(buf, UDBG_BUFSIZE, fmt, args);
 	udbg_puts(buf);
 	va_end(args);
 }
+/* PPCDBG stuff */
+u64 ppc64_debug_switch;
 /* Special print used by PPCDBG() macro */
 void udbg_ppcdbg(unsigned long debug_flags, const char *fmt, ...)
 {
 	unsigned long active_debugs = debug_flags & ppc64_debug_switch;
 	if (active_debugs) {
 		va_list ap;
 		unsigned char buf[UDBG_BUFSIZE];
 		unsigned long i, len = 0;
 		for (i=0; i < PPCDBG_NUM_FLAGS; i++) {
 			if (((1U << i) & active_debugs) &&
 			    trace_names[i]) {
 				len += strlen(trace_names[i]);
 				udbg_puts(trace_names[i]);
 				break;
 			}
 		}
 		snprintf(buf, UDBG_BUFSIZE, " [%s]: ", current->comm);
 		len += strlen(buf);
 		udbg_puts(buf);
 		while (len < 18) {
 			udbg_puts(" ");
 			len++;
 		}
 		va_start(ap, fmt);
 		vsnprintf(buf, UDBG_BUFSIZE, fmt, ap);
 		udbg_puts(buf);
 		va_end(ap);
 	}
 }
 unsigned long udbg_ifdebug(unsigned long flags)
 {
 	return (flags & ppc64_debug_switch);
 }
+/*
+ * Initialize the PPCDBG state.  Called before relocation has been enabled.
+ */
+void __init ppcdbg_initialize(void)
+{
+	ppc64_debug_switch = PPC_DEBUG_DEFAULT; /* | PPCDBG_BUSWALK | */
+	/* PPCDBG_PHBINIT | PPCDBG_MM | PPCDBG_MMINIT | PPCDBG_TCEINIT | PPCDBG_TCE */;
+}
+/*
+ * Early boot console based on udbg
+ */
+static void udbg_console_write(struct console *con, const char *s,
+		unsigned int n)
+{
+	udbg_write(s, n);
+}
+static struct console udbg_console = {
+	.name	= "udbg",
+	.write	= udbg_console_write,
+	.flags	= CON_PRINTBUFFER,
+	.index	= -1,
+};
+void __init disable_early_printk(void)
+{
+	unregister_console(&udbg_console);
+}
+/* called by setup_system */
+void register_early_udbg_console(void)
+{
+	register_console(&udbg_console);
+}

1	#ifndef __UDBG_HDR	1	#ifndef __UDBG_HDR
2	#define __UDBG_HDR	2	#define __UDBG_HDR
3		3
4	#include <linux/compiler.h>	4	#include <linux/compiler.h>
		5	#include <linux/init.h>
5		6
6	/*	7	/*
7	* c 2001 PPC 64 Team, IBM Corp	8	* c 2001 PPC 64 Team, IBM Corp
8	*	9	*
9	* This program is free software; you can redistribute it and/or	10	* This program is free software; you can redistribute it and/or
10	* modify it under the terms of the GNU General Public License	11	* modify it under the terms of the GNU General Public License
11	* as published by the Free Software Foundation; either version	12	* as published by the Free Software Foundation; either version
12	* 2 of the License, or (at your option) any later version.	13	* 2 of the License, or (at your option) any later version.
13	*/	14	*/
14		15
15	extern void (*udbg_putc)(unsigned char c);	16	extern void (*udbg_putc)(unsigned char c);
16	extern unsigned char (*udbg_getc)(void);	17	extern unsigned char (*udbg_getc)(void);
17	extern int (*udbg_getc_poll)(void);	18	extern int (*udbg_getc_poll)(void);
18		19
19	extern void udbg_puts(const char *s);	20	extern void udbg_puts(const char *s);
20	extern int udbg_write(const char *s, int n);	21	extern int udbg_write(const char *s, int n);
21	extern int udbg_read(char *buf, int buflen);	22	extern int udbg_read(char *buf, int buflen);
22		23
23	struct console;	24	extern void register_early_udbg_console(void);
24	extern void udbg_console_write(struct console con, const char s, unsigned int n);
25	extern void udbg_printf(const char *fmt, ...);	25	extern void udbg_printf(const char *fmt, ...);
26	extern void udbg_ppcdbg(unsigned long flags, const char *fmt, ...);	26	extern void udbg_ppcdbg(unsigned long flags, const char *fmt, ...);
27	extern unsigned long udbg_ifdebug(unsigned long flags);	27	extern unsigned long udbg_ifdebug(unsigned long flags);
28		28	extern void __init ppcdbg_initialize(void);
29		29
30	extern void udbg_init_uart(void __iomem *comport, unsigned int speed);	30	extern void udbg_init_uart(void __iomem *comport, unsigned int speed);
31	#endif	31	#endif