XXX Put text here.

- What is it
- What's in it?
- What's it running?
- What comes with it?
- What do I do with it?
  - Plugging the nail board into your laptop.
    - Find the serial and jtag devices.
    - If you get ethernet too, Linux is running on the nail board.

  - Using minicom to log in to your nail board.
    - Using the ethernet device to ssh to your nail board.

  - Using JTAG to reflash your nail board.
    Now that you've found the preinstalled Linux system, let's destroy it!
    - Prebuilt bootloader, kernel, root filesystem.
    - Script to reflash the nail board.
      - Yes, this is slow.  Faster closed source library, but eh.
    - Proving you reflashed it (boot message BLAH="hello")

  - Using JTAG to back up your nail board.
    You probably never need to do this, but it's nice to know you can.
    Why loopback mounting jffs2 is a pain in the ass.

  - Compiling your own "hello world" program to run on the Nail board.
    - "hello world"
    - Installing the prebuilt cross compiler toolchain

  - Compiling and installing your own ARM kernel on the Nail board.
    - kernel actually slightly easier, doesn't use libc or stdinc.
    - .config
    - Installing a new kernel.

  - Fiddling with the bootloader
      - Why not just boot the new kernel directly?
      - Installing a new kernel with the bootloader instead of the JTAG.
      - Booting a kernel via tftp
        - Setting up a TFTP server
      - Changing the bootloader's default actions.
      - Rebuilding the bootloader from source.

  - Where did this cross compiler toolchain come from?
    - Building it yourself from source.

  - Building your own root filesystem for the nail board.
    - What's in a root filesystem?
    - Linux From Scratch.
    - Firmware Linux

  - Fun with QEMU

  - Driving the hardware on the nail board
    - Serial console
    - USB Gadget
    - Blinky lights
    - Making it beep



[15:22]  You misunderstand, your device can potentially be _useful_ to Linus and Andrew.
[15:22]  "Here's a little toy you can use to test an arm kernel".
[15:22]  It's portable, self-contained, unbrickable, and here's a script to reflash it trivially.
[15:22]  landley: indeed, just hard to stand out from the crowd with so many other "samples" that linus probably gets
[15:23]  That's why you need lwn and linux devices reviews first.
[15:23]  Don't send an unsolicited sample, it'll stay in a box on his floor.
[15:24]  Get jonathan corbett excited, then tell him you'd like to send one to Linux because you think it'll help arm support for Linux if he has a convenient and portable test system he can take with him on airplanes.
[15:24]  landley: yea, thats what i figured
[15:24]  landley: and since i've never spoken to linus , it would be unsolicited, hehe
[15:25]  prpplague: which is why you need the lwn review.
[15:25]  Does Jonathan do hardware reviews at all?
[15:25]  occasionally.  Not often.
[15:25]  He may delegate.
[15:26]  But keep in mind, he co-authored a book on device drivers.
[15:26]  Hook him with the "look, a usb gadget host"
[15:26]  There are a half-dozen major hurdles to doing embedded development.
[15:26]  You've got to be able to set up a cross compiler toolchain, which stops most people.
[15:26]  You've got to be able to build your own root filesystem.
[15:27]  You've got to be able to configure a kernel for hardware you've never used before.
[15:27]  You've got to be able to _install_ this kernel -- flashing the device is a huge roadblock for a lot of people.
[15:27]  It's intimidating due to brickability.
[15:27]  You need to be able to obtain a device to play with and make sure that all of the above is correct for that specific device.
[15:28]  You've got to set up some way to get feedback from the device; minicom is evil.
[15:28]  And setting up serial ports is rapidly becoming a lost art, even assuming your machine still _has_ a serial port anymore.
[15:29]  And all that's just to get the device to a shell prompt, which isn't inherently all that _interesting_.
[15:31]  prpplague: the point is, a device that just plugs into USB makes about 1/3 of those problems go away.
[15:31]  You have hardware, no problem obtaining a serial port or wiring up the cables right.
[15:32]  (Heck, finding _flat_space_ to set the device up is a bit of a challenge for most geeks.)
[15:32]  The "dangerous evil jtag" can be hidden behind a script.
[15:33]  As for getting software on the device, the approach I'm taking with firmware linux evolved for a reason.
[15:33]  You need binaries, but binaries by themselves aren't enough.
[15:33]  You need the source and build scripts to reproduce them.
[15:34]  Build scripts are better than makefiles because you can read the scripts as a form of documentation.
[15:34]  It does this, this, and this.  In that order.
[15:34]  You can chop bits out, modify them, etc.
[15:34]  (Some of that's personal preference, of course.  But not all.)
[15:35]  You need documentation explaning not just what to do but what the _options_ are.
[15:35]  "Here are the capabilities of the device.  It has the potential to do X, Y, and Z."
[15:36]  And from a software geek's point of view, "plug the device into a USB port" and it's all software from there...
[15:41]  prpplague: on the nail board page, could you give a bullet point list of the hardware in the thing?
[15:42]  Preferably with "hammer module" and sub-bullets, and then "nail board" and sub-bullets for what's on that?