I think you need to realize that the OpenGL specification, and the hardware that tries to implement it, are two different things.
If an OpenGL driver claims to support a certain version of OpenGL and some extensions, then it needs to follow the specification(s) to the point. Sometimes the hardware is not capable of doing all of the rendering. This does not necessarily have to be the lack of a certain function of the GL (say, clipping planes or vertex shaders), but a certain state of the GL that it can not cope with (e.g. more than two active clipping planes in combination with a vertex shader program longer than 100 machine level instructions) [NOTE: those examples are purely fictional].
In such situations, the OpenGL driver will decide what it can do (e.g. rasterization) and what it can’t do (e.g. vertex processing) on the GPU, and the driver (that is running on the CPU!) will emulate parts of the GPU in software.
As you can imagine, these limitations are different for different graphic cards, depending on things like number of texturing “units”, onboard video memory, and of course implementation specific limitations & features.
Usually a graphic chip is designed with more features than is exposed by the current available OpenGL version (which is why an old GeForce 256 card can run OpenGL 1.5), but also with some OpenGL functions missing (e.g. an accumulator buffer) since these are deemed “too costly for the common user, and not interesting enough to run on hardware”. That is why all NVIDIA cards (at least RIVA 128 to GeForce 4) emulate accumulator buffers in software.
This usually leads to a situation where the OpenGL specification and the graphics hardware do not match in a 1:1 fashion, but the hardware is tweaked and turned by the driver to support as many situations as possible in hardware.
As for shaders, things are still not fully mature, so every new generation of hardware will support more things than the previous generation (higher instructions counts, different conditional execution methods, etc), but they will all try to implement the same specifications (e.g. vertex & fragment shaders/GLSL). Needless to say, newer cards will succeed more often than older cards…