With respect John, I was trying to keep things simple. Whenever data is
written/read from a storage device, to avoid loss of data, buffers have to
be used. Buffers are invariably configured to read/write one or more blocks
(in the context of SD/SDHC the block and cluster size varies card to card).
This is where I was coming from when I spoke of buffers. If you require a
more geeky treatment, I can do no better than to quote what is described in
Wikki (but please - do put it in the context of reading/writing blocks from
cards).

QUOTE
Compatibility issues with 4 GB and larger cards

Devices that use SD cards identify the card by requesting a 128-bit
identification string from the card. For standard-capacity SD cards, 12 of
the bits are used to identify the number of memory clusters (ranging from 1
to 4096) and 3 of the bits are used to identify the number of blocks per
cluster (which decode to 4, 8, 16, 32, 64, 128, 256 or 512 blocks per
cluster).

In older 1.x implementations the standard capacity block was exactly 512
bytes. This gives 4096 x 512 x 512 = 1 gigabyte of storage memory. A later
revision of the 1.x standard allowed a 4-bit field to indicate 1024 or 2048
bytes per block instead, yielding up to 4 gigabyte of memory storage.
Devices designed before this change may incorrectly identify such cards,
usually by misidentifying a card with lower capacity than is the case by
assuming 512 bytes per block rather than 1024 or 2048.

For the new SDHC high capacity card (2.0) implementation, 22 bits of the
identification string are used to indicate the memory size in increments of
512 kBytes. Currently 16 of the 22 bits are allowed to be used, giving a
maximum size of 32 GB. All SD cards with a capacity larger than 4 GB must
use the 2.0 implementation at minimum. Two bits that were previously
reserved and fixed at 0 are now used for identifying the type of card,
0=standard, 1=SDHC, 2=reserved, 3=reserved. Non-SDHC devices are not
programmed to read this code and therefore cannot correctly identify SDHC or
SDXC cards.

All SDHC readers work with standard SD cards.

Many older devices will not accept the 2 or 4 GB size even though it is in
the revised standard. The following statement is from the SD association
specification:

"To make 2 GByte card, the Maximum Block Length
(READ_BL_LEN=WRITE_BL_LEN) shall be set to 1024 bytes. However, the
Block Length, set by CMD16, shall be up to 512 bytes to keep consistency
with 512 bytes Maximum Block Length cards (Less than and equal 2 Gbyte
cards)."

[edit] Standard-SD cards (non-SDHC) with greater than 1 GB capacity

The SD Card Association's current specifications define how a standard SD
(non-SDHC) card with more than 1 GB and up to 4 GB capacity should be
designed. These cards should be readable in any SD 1.01 devices that take
the block length data into account. Any 1 GB or lesser card should always
work. (So the key question is how one's reader handles block length).

According to the specification, the maximum capacity of a standard SD card
is defined by (BLOCKNR x BLOCK_LEN), where BLOCKNR may be (4096 x 512) and
BLOCK_LEN may be up to 2048. This allows a capacity of 4 GB. The main
problem is that some of the card readers support only a block (aka. sector)
size of 512 bytes, so greater than 1 GB non-SDHC cards may cause
compatibility difficulties for users of some devices.
[edit] SDHC cards with greater than 32 GB capacity

Similarly to the above, as of version 2.00 of the specification, the
capacity of an SDHC card is limited to 32 GB. However, while not strictly
adhering to that standard, it is in principle possible to create SDHC-like
cards of up to 2048 GB capacity. SDHC cards have fixed sector size of 512
bytes.
[edit]

/QUOTE

You'll note from above, SD cards are limited to 4GB. And although you may
have done, I have never seen an SD card higher than Class 4.

Regards