gerrit.automotivelinux Code Review - AGL/documentation.git/blob - docs/0_Getting_Started/1_Quickstart/Using_Ready_Made

1 ---

2 title: Using Ready Made Images

3 ---

4

5 AGL provides a number of pre-built ready-made images of various versions.

6

7 ## x86 (Emulation and Hardware)

8

9 ### 1. QEMU (Emulation)

10

11 1. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemux86-64/deploy/images/qemux86-64/agl-demo-platform-crosssdk-qemux86-64.ext4.xz).

12

13 2. Download the [compressed kernel image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemux86-64/deploy/images/qemux86-64/bzImage).

14

15 3. Install [QEMU](https://www.qemu.org/download/) :

16

17 ```sh

18 $ apt-get install qemu

19 ```

20

21 4. Install [vinagre](https://wiki.gnome.org/Apps/Vinagre) :

22

23 ```sh

24 $ sudo apt install vinagre

25 ```

26

27 5. Create boot directory and copy compressed images (prebuilt & kernel) into them :

28

29 ```sh

30 $ mkdir ~/agl-demo/

31 $ cp ~/Downloads/agl-demo-platform-crosssdk-qemux86-64.ext4.xz ~/agl-demo/

32 $ cp ~/Downloads/bzImage ~/agl-demo/

33 $ cd ~/agl-demo

34 $ sync

35 ```

36

37 6. Extract prebuilt compressed image :

38

39 ```sh

40 $ xz -v -d agl-demo-platform-crosssdk-qemux86-64.ext4.xz

41 ```

42

43 7. Launch QEMU with vinagre (for scaling), remove `- snapshot \` if you want to save changes to the image files :

44

45 ```sh

46 $ ( sleep 5 && vinagre --vnc-scale localhost ) > /tmp/vinagre.log 2>&1 &

47 qemu-system-x86_64 -device virtio-net-pci,netdev=net0,mac=52:54:00:12:35:02 -netdev user,id=net0,hostfwd=tcp::2222-:22 \

48 -drive file=agl-demo-platform-crosssdk-qemux86-64.ext4,if=virtio,format=raw -show-cursor -usb -usbdevice tablet -device virtio-rng-pci \

49 -snapshot -vga virtio \

50 -vnc :0 -soundhw hda -machine q35 -cpu kvm64 -cpu qemu64,+ssse3,+sse4.1,+sse4.2,+popcnt -enable-kvm \

51 -m 2048 -serial mon:vc -serial mon:stdio -serial null -kernel bzImage \

52 -append 'root=/dev/vda rw console=tty0 mem=2048M ip=dhcp oprofile.timer=1 console=ttyS0,115200n8 verbose fstab=no'

53 ```

54

55 - Login into AGL :

56

57 ```sh

58 Automotive Grade Linux 11.0.0+snapshot qemux86-64 ttyS1

59

60 qemux86-64 login: root

61 ```

62

63

64 - Shutdown QEMU : `$ poweroff`, otherwise QEMU will run in the background.

65 - To use vnc-viewer instead of vinagre :

66 ```sh

67 $ ( sleep 5 && vncviewer ) &

68 qemu-system-x86_64 -device virtio-net-pci,netdev=net0,mac=52:54:00:12:35:02 -netdev user,id=net0,hostfwd=tcp::2222-:22 \

69 -drive file=agl-demo-platform-crosssdk-qemux86-64.ext4,if=virtio,format=raw -show-cursor -usb -usbdevice tablet -device virtio-rng-pci \

70 -snapshot -vga virtio \

71 -vnc :0 -soundhw hda -machine q35 -cpu kvm64 -cpu qemu64,+ssse3,+sse4.1,+sse4.2,+popcnt -enable-kvm \

72 -m 2048 -serial mon:vc -serial mon:stdio -serial null -kernel bzImage \

73 -append 'root=/dev/vda rw console=tty0 mem=2048M ip=dhcp oprofile.timer=1 console=ttyS0,115200n8 verbose fstab=no'

74 ```

75

76 ### 2. Virtual Box (Emulation)

77

78 1. Download the [compressed vbox disk image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemux86-64/deploy/images/qemux86-64/agl-demo-platform-crosssdk-qemux86-64.wic.vmdk.xz).

79

80 2. Install and set up [Virtual Box](https://www.virtualbox.org/wiki/Linux_Downloads).

81

82 3. Extract the vmdk file : `$ xz -v -d agl-demo-platform-crosssdk-qemux86-64.wic.vmdk.xz`

83

84 4. Configure virtual box for AGL :

85 - Click on `New` or `Add`.

86 - Enter Name as `agl-demo`.

87 - Type as `Linux`.

88 - Version as `Other Linux (64-bit)`, click on `Next`.

89 ![vbox-step-1](images/vbox-1.png)

90 - Select Memory size. Recommended is `2048 MB`, click on `Next`.

91 ![vbox-step-2](images/vbox-2.png)

92 - Click on `Use an existing virtual hard disk file`, and select the extracted `agl-demo-platform-crosssdk-qemux86-64.wic.vmdk` file, click on `Create`.

93 ![vbox-step-3](images/vbox-3.png)

94 - Go to `Settings`, and into `System`. Select `Chipset : IHC9`. Check on `Enable EFI (special OSes only)` and click on `OK`.

95 ![vbox-step-4](images/vbox-4.png)

96 - Go to `Storage`, and change the attribute to `Type : AHCI` and click on `OK`.

97 ![vbox-step-5](images/vbox-5.png)

98 - Next go to `Display` and change the attribute to 'VMSVGA' for the graphics driver. Change the graphics memory to be at least 64MB.

99 - Click on `Start`.

100 - For troubleshooting, you can refer [here](https://lists.automotivelinux.org/g/agl-dev-community/message/8474).

101

102 ### 3. x86 physical system

103

104 **NOTE :** UEFI enabled system is required.

105

106 1. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemux86-64/deploy/images/qemux86-64/agl-demo-platform-crosssdk-qemux86-64.wic.xz).

107

108 2. Extract the image into USB drive :

109

110 ```sh

111 $ lsblk

112 $ sudo umount <usb_device_name>

113 $ xzcat agl-demo-platform-crosssdk-qemux86-64.wic.xz | sudo dd of=<usb_device_name> bs=4M

114 $ sync

115 ```

116

117

118 3. Boot from USB drive on the x86 system.

119

120 ## ARM 32 bit (Emulation and Hardware)

121

122 ### 1. QEMU (Emulation)

123

124 1. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemuarm/deploy/images/qemuarm/agl-demo-platform-crosssdk-qemuarm.ext4.xz).

125

126 2. Download the [compressed kernel image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemuarm/deploy/images/qemuarm/zImage).

127

128 3. Install [QEMU](https://www.qemu.org/download/) :

129

130 ```sh

131 $ apt-get install qemu

132 ```

133

134 4. Install [vinagre](https://wiki.gnome.org/Apps/Vinagre) :

135

136 ```sh

137 $ sudo apt install vinagre

138 ```

139

140 5. Create boot directory and copy compressed images (prebuilt & kernel) into them :

141

142 ```sh

143 $ mkdir ~/agl-demo/

144 $ cp ~/Downloads/agl-demo-platform-crosssdk-qemuarm.ext4.xz ~/agl-demo/

145 $ cp ~/Downloads/zImage ~/agl-demo/

146 $ cd ~/agl-demo

147 $ sync

148 ```

149

150 6. Extract prebuilt compressed image :

151

152 ```sh

153 $ xz -v -d agl-demo-platform-crosssdk-qemuarm.ext4.xz

154 ```

155

156 7. Launch QEMU with vinagre (for scaling), remove `- snapshot` if you want to save changes to the image files :

157

158 ```sh

159 $ ( sleep 5 && vinagre --vnc-scale localhost ) > /tmp/vinagre.log 2>&1 &

160 qemu-system-arm -cpu cortex-a15 -machine virt-2.11 -nographic \

161 -net nic,model=virtio,macaddr=52:54:00:12:34:58 \

162 -net user -m 2048 -monitor none -soundhw hda -device usb-ehci \

163 -device virtio-rng-pci -device VGA,vgamem_mb=64,edid=on -vnc :0 \

164 -device qemu-xhci -device usb-tablet -device usb-kbd \

165 -kernel zImage -append "console=ttyAMA0,115200 root=/dev/vda verbose systemd.log_color=false" \

166 -drive format=raw,file=agl-demo-platform-crosssdk-qemuarm.ext4 \

167 -snapshot

168 ```

169

170 - Login into AGL :

171

172 ```sh

173 Automotive Grade Linux 11.0.0+snapshot qemux86-64 ttyS1

174

175 qemux86-64 login: root

176 ```

177

178

179 - Shutdown QEMU : `$ poweroff`, otherwise QEMU will run in the background.

180 - To use vnc-viewer instead of vinagre :

181 ```sh

182 $ ( sleep 5 && vncviewer ) &

183 qemu-system-arm -cpu cortex-a15 -machine virt-2.11 -nographic \

184 -net nic,model=virtio,macaddr=52:54:00:12:34:58 \

185 -net user -m 2048 -monitor none -soundhw hda -device usb-ehci \

186 -device virtio-rng-pci -device VGA,vgamem_mb=64,edid=on -vnc :0 \

187 -device qemu-xhci -device usb-tablet -device usb-kbd \

188 -kernel zImage -append "console=ttyAMA0,115200 root=/dev/vda verbose systemd.log_color=false" \

189 -drive format=raw,file=agl-demo-platform-crosssdk-qemuarm.ext4 \

190 -snapshot

191 ```

192

193 ### 2. BeagleBone Enhanced (BBE)

194

195 1. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/bbe/deploy/images/bbe/agl-demo-platform-crosssdk-bbe.wic.xz).

196

197 2. Extract the image into the SD card of BeagleBone Enhanced :

198

199 ```sh

200 $ lsblk

201 $ sudo umount <sdcard_device_name>

202 $ xzcat agl-demo-platform-crosssdk-bbe.wic.xz | sudo dd of=<sdcard_device_name> bs=4M

203 $ sync

204 ```

205

206 **IMPORTANT NOTE:** Before re-writing any device on your Build Host, you need to

207 be sure you are actually writing to the removable MicroSD card and not some other

208 device.

209 Each computer is different and removable devices can change from time to time.

210 Consequently, you should repeat the previous operation with the MicroSD card to

211 confirm the device name every time you write to the card.

212

213 To summarize this example so far, we have the following:

214 The first SATA drive is `/dev/sda` and `/dev/sdc` corresponds to the MicroSD card, and is also marked as a removable device.You can see this in the output of the `lsblk` command where "1" appears in the "RM" column for that device.

215

216 ## AARCH64 - ARM 64bit

217

218 ### 1. QEMU (Emulation)

219

220 1. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemuarm64/deploy/images/qemuarm64/agl-demo-platform-crosssdk-qemuarm64.ext4.xz).

221

222 2. Download the [compressed kernel image](https://download.automotivelinux.org/AGL/snapshots/master/latest/qemuarm64/deploy/images/qemuarm64/Image).

223

224 3. Install [QEMU](https://www.qemu.org/download/) :

225

226 ```sh

227 $ apt-get install qemu

228 ```

229

230 4. Install [vinagre](https://wiki.gnome.org/Apps/Vinagre) :

231

232 ```sh

233 $ sudo apt install vinagre

234 ```

235

236 5. Create boot directory and copy compressed images (prebuilt & kernel) into them :

237

238 ```sh

239 $ mkdir ~/agl-demo/

240 $ cp ~/Downloads/agl-demo-platform-crosssdk-qemuarm64.ext4.xz ~/agl-demo/

241 $ cp ~/Downloads/zImage ~/agl-demo/

242 $ cd ~/agl-demo

243 $ sync

244 ```

245

246 6. Extract prebuilt compressed image :

247

248 ```sh

249 $ xz -v -d agl-demo-platform-crosssdk-qemuarm64.ext4.xz

250 ```

251

252 7. Launch QEMU with vinagre (for scaling), remove `- snapshot \` if you want to save changes to the image files :

253

254 ```sh

255 $ ( sleep 5 && vinagre --vnc-scale localhost ) > /tmp/vinagre.log 2>&1 &

256 qemu-system-aarch64 -cpu cortex-a57 -machine virt -nographic \

257 -net nic,model=virtio,macaddr=52:54:00:12:34:58 \

258 -net user -m 2048 -monitor none -smp 2 -soundhw hda -device usb-ehci \

259 -device virtio-rng-pci -device VGA,vgamem_mb=64,edid=on \

260 -device qemu-xhci -device usb-tablet -device usb-kbd -vnc :0 \

261 -kernel Image -append "console=ttyAMA0,115200 root=/dev/vda verbose systemd.log_color=false " \

262 -drive format=raw,file=agl-demo-platform-crosssdk-qemuarm64.ext4 \

263 -snapshot

264 ```

265

266 - Login into AGL :

267

268 ```sh

269 Automotive Grade Linux 11.0.0+snapshot qemux86-64 ttyS1

270

271 qemux86-64 login: root

272 ```

273

274

275 - Shutdown QEMU : `$ poweroff`, otherwise QEMU will run in the background.

276 - To use vnc-viewer instead of vinagre :

277 ```sh

278 $ ( sleep 5 && vncviewer ) &

279 qemu-system-aarch64 -cpu cortex-a57 -machine virt -nographic \

280 -net nic,model=virtio,macaddr=52:54:00:12:34:58 \

281 -net user -m 2048 -monitor none -smp 2 -soundhw hda -device usb-ehci \

282 -device virtio-rng-pci -device VGA,vgamem_mb=64,edid=on \

283 -device qemu-xhci -device usb-tablet -device usb-kbd -vnc :0 \

284 -kernel Image -append "console=ttyAMA0,115200 root=/dev/vda verbose systemd.log_color=false " \

285 -drive format=raw,file=agl-demo-platform-crosssdk-qemuarm64.ext4 \

286 -snapshot

287 ```

288

289 ### 2. Raspberry Pi 4

290

291 1. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/raspberrypi4/deploy/images/raspberrypi4-64/agl-demo-platform-crosssdk-raspberrypi4-64.wic.xz).

292

293 2. Extract the image into the SD card of Raspberry Pi 4 :

294

295 ```sh

296 $ lsblk

297 $ sudo umount <sdcard_device_name>

298 $ xzcat agl-demo-platform-crosssdk-raspberrypi4-64.wic.xz | sudo dd of=<sdcard_device_name> bs=4M

299 $ sync

300 ```

301

302 **IMPORTANT NOTE:** Before re-writing any device on your Build Host, you need to

303 be sure you are actually writing to the removable MicroSD card and not some other

304 device.

305 Each computer is different and removable devices can change from time to time.

306 Consequently, you should repeat the previous operation with the MicroSD card to

307 confirm the device name every time you write to the card.

308

309 To summarize this example so far, we have the following:

310 The first SATA drive is `/dev/sda` and `/dev/sdc` corresponds to the MicroSD card, and is also marked as a removable device.You can see this in the output of the `lsblk` command where "1" appears in the "RM" column for that device.

311

312 3. SSH into Raspberry Pi :

313 - Connect Raspberry Pi to network : `Homescreen > Settings`, IP address mentioned here.

314 - `ssh root@<Raspberry-Pi-ip-address>`

315

316

317 4. Serial Debugging :

318

319 When things go wrong, you can take steps to debug your Raspberry Pi.

320 For debugging, you need a 3.3 Volt USB Serial cable to fascilitate

321 communication between your Raspberry Pi board and your build host.

322

323 You can reference the following diagram for information on the following steps:

324

325 ![](images/RaspberryPi2-ModelB-debug-serial-cable.png)

326

327 1. Connect the TTL cable to the Universal Asynchronous Receiver-Transmitter

328 (UART) connection on your Raspberry Pi board.

329 Do not connect the USB side of the cable to your build host at this time.

330

331 **CAUTION:** No warranty is provided using the following procedure.

332 Pay particular attention to the collors of your cable as they could

333 vary depending on the vendor.

334

335 2. Connect the cable's BLUE wire to pin 6 (i.e. Ground) of the UART.

336

337 3. Connect the able's GREEN RX line to pin 8 (i.e. the TXD line) of

338 the UART.

339

340 4. Connect the cable's RED TX line to pin 10 (i.e. the RXD line) of

341 the UART.

342

343 5. Plug the USB connector of the cable into your build host's USB port.

344

345 6. Use your favorite tool for serial communication between your build host

346 and your Raspberry Pi.

347 For example, if your build host is a native Linux machine (e.g. Ubuntu)

348 you could use `screen` as follows from a terminal on the build host:

349

350 ```sh

351 $ sudo screen /dev/ttyUSB0 115200

352 ```

353

354 ### 3. R-Car H3SK (H3ULCB board)

355

356 **NOTE :** The prebuilt image doesn't support graphics (as of yet) and will run headless. For graphical support, a local build with the neccesary graphics driver is required.

357

358

359 1. Update the [firmware](https://elinux.org/R-Car/Boards/H3SK#Flashing_firmware) using files from [here](https://download.automotivelinux.org/AGL/snapshots/master/latest/h3ulcb-nogfx/deploy/images/h3ulcb/).

360

361 2. Download the [compressed prebuilt image](https://download.automotivelinux.org/AGL/snapshots/master/latest/h3ulcb-nogfx/deploy/images/h3ulcb/agl-image-ivi-crosssdk-h3ulcb.wic.xz).

362

363 3. Extract the image into the boot device :

364

365 ```sh

366 $ lsblk

367 $ sudo umount <boot_device_name>

368 $ xzcat agl-image-ivi-crosssdk-h3ulcb.wic.xz | sudo dd of=<boot_device_name> bs=4M

369 $ sync

370 ```

371

372 3. [Serial](https://elinux.org/R-Car/Boards/H3SK) into the board for debugging.

373 For example, if your build host is a native Linux machine (e.g. Ubuntu)

374 you could use `screen` as follows from a terminal on the build host:

375

376 ```sh

377 $ sudo screen /dev/ttyUSB0 115200

378 ```