I got something working by having a dummy (hidden) column to indicate
whether it is a footer row or not (well, actually it just uses a
hidden preliminary sort, so it would also work for headers etc)...
It works by hiding an extra (first) sort in IBindingList and
IBindingListView... it has to be hidden for the reversal to work
properly.
here is the usage example; I'll post the implementation
(CustomDataView) in a second post (it's a bit long... but most of it
was auto-generated)

   static void Main() {
       Application.EnableVisualStyles();
       // declare table
       DataTable dt = new DataTable("Test");
       dt.Columns.Add("IsFooter", typeof(bool));
       dt.Columns.Add("Caption", typeof(string));
       dt.Columns.Add("Value", typeof(int));
       // fill with some random data
       Random rand = new Random();
       int sum = 0;
       for (int i = 0; i < 20; i++) {
           int val = rand.Next(50);
           dt.Rows.Add(false, "Row " + i.ToString(), val);
           sum += val;
       }
       // add footer row
       dt.Rows.Add(true, "Total", sum);

       // display
       using(Form form = new Form())
       using (DataGridView grid = new DataGridView()) {
           grid.Dock = DockStyle.Fill;
           grid.AllowUserToAddRows = false;
           form.Controls.Add(grid);
           grid.DataSource = new CustomDataView(dt.DefaultView,
"IsFooter", ListSortDirection.Ascending);
           grid.Columns[0].Visible = false;
           Application.Run(form);
       }
   }

public class CustomDataView : IBindingListView, IBindingList, IList,
ICollection, IEnumerable, ITypedList, ISupportInitializeNotification,
ISupportInitialize {
       readonly DataView parent;
       readonly ListSortDescription fixedSort;
       public CustomDataView(DataView parent, string sortProperty,
ListSortDirection sortDirection) {
           if (parent == null) throw new ArgumentNullException();
           this.parent = parent;
           if (!SupportsSorting || !SupportsAdvancedSorting) {
               throw new InvalidOperationException("Advanced sorting
is required");
           }
           fixedSort = new
ListSortDescription(GetItemProperties(null)[sortProperty],
sortDirection);
           RemoveSort();
       }

       #region IBindingListView Members

       void IBindingListView.ApplySort(ListSortDescriptionCollection
sorts) {
           ListSortDescription[] sortArray = new
ListSortDescription[sorts.Count + 1];
           sorts.CopyTo(sortArray, 1);
           sortArray[0] = fixedSort;
           ApplySort(sortArray);
       }

       string IBindingListView.Filter {
           get {
               return ((IBindingListView)parent).Filter;
           }
           set {
               ((IBindingListView)parent).Filter = value;
           }
       }

       void IBindingListView.RemoveFilter() {
           ((IBindingListView)parent).RemoveFilter();
       }

       ListSortDescriptionCollection
IBindingListView.SortDescriptions {
           get {
               ListSortDescriptionCollection sorts =
((IBindingListView)parent).SortDescriptions;
               if(sorts == null || sorts.Count == 0) return sorts;
               ListSortDescription[] sortArray = new
ListSortDescription[sorts.Count - 1];
               for (int i = 1; i < sorts.Count; i++) {
                   sortArray[i - 1] = sorts[i];
               }
               return new ListSortDescriptionCollection(sortArray);
           }
       }

       public bool SupportsAdvancedSorting {
           get { return
((IBindingListView)parent).SupportsAdvancedSorting; }
       }

       bool IBindingListView.SupportsFiltering {
           get { return
((IBindingListView)parent).SupportsFiltering; }
       }

       #endregion

       #region IBindingList Members

       void IBindingList.AddIndex(PropertyDescriptor property) {
           ((IBindingList)parent).AddIndex(property);
       }

       object IBindingList.AddNew() {
           return ((IBindingList)parent).AddNew();
       }

       bool IBindingList.AllowEdit {
           get { return ((IBindingList)parent).AllowEdit; }
       }

       bool IBindingList.AllowNew {
           get { return ((IBindingList)parent).AllowNew; }
       }

       bool IBindingList.AllowRemove {
           get { return ((IBindingList)parent).AllowRemove; }
       }

       void IBindingList.ApplySort(PropertyDescriptor property,
ListSortDirection direction) {
           ApplySort(fixedSort, new ListSortDescription(property,
direction));
       }
       void ApplySort(params ListSortDescription[] sorts) {
           ((IBindingListView)parent).ApplySort(new
ListSortDescriptionCollection(sorts));
       }

       int IBindingList.Find(PropertyDescriptor property, object key)
{
           return ((IBindingList)parent).Find(property, key);
       }

       public bool IsSorted {
           get { return ((IBindingList)parent).IsSorted &&
((IBindingListView)parent).SortDescriptions.Count > 1; }
       }

       event ListChangedEventHandler IBindingList.ListChanged {
           add { ((IBindingList)parent).ListChanged += value; }
           remove { ((IBindingList)parent).ListChanged -= value; }
       }

       void IBindingList.RemoveIndex(PropertyDescriptor property) {
           ((IBindingList)parent).RemoveIndex(property);
       }

       public void RemoveSort() {
           ApplySort(fixedSort);
       }

       ListSortDirection IBindingList.SortDirection {
           get {
               if (IsSorted) {
                   return
((IBindingListView)parent).SortDescriptions[1].SortDirection;
               } else {
                   return ListSortDirection.Ascending;
               }
           }
       }

       PropertyDescriptor IBindingList.SortProperty {
           get {
               if (IsSorted) {
                   return
((IBindingListView)parent).SortDescriptions[1].PropertyDescriptor;
               } else {
                   return null;
               }
           }
       }

       bool IBindingList.SupportsChangeNotification {
           get { return
((IBindingList)parent).SupportsChangeNotification; }
       }

       bool IBindingList.SupportsSearching {
           get { return ((IBindingList)parent).SupportsSearching; }
       }

       public bool SupportsSorting {
           get { return ((IBindingList)parent).SupportsSorting; }
       }

       #endregion

       #region IList Members

       int System.Collections.IList.Add(object value) {
           return ((IList)parent).Add(value);
       }

       void System.Collections.IList.Clear() {
           ((IList)parent).Clear();
       }

       bool System.Collections.IList.Contains(object value) {
           return ((IList)parent).Contains(value);
       }

       int System.Collections.IList.IndexOf(object value) {
           return ((IList)parent).IndexOf(value);
       }

       void System.Collections.IList.Insert(int index, object value)
{
           ((IList)parent).Insert(index, value);
       }

       bool System.Collections.IList.IsFixedSize {
           get { return ((IList)parent).IsFixedSize; }
       }

       bool System.Collections.IList.IsReadOnly {
           get { return ((IList)parent).IsReadOnly; }
       }

       void System.Collections.IList.Remove(object value) {
           ((IList)parent).Remove(value);
       }

       void System.Collections.IList.RemoveAt(int index) {
           ((IList)parent).RemoveAt(index);
       }

       object System.Collections.IList.this[int index] {
           get {
               return ((IList)parent)[index];
           }
           set {
               ((IList)parent)[index] = value;
           }
       }

       #endregion

       #region ICollection Members

       void System.Collections.ICollection.CopyTo(Array array, int
index) {
           ((ICollection)parent).CopyTo(array, index);
       }

       int System.Collections.ICollection.Count {
           get { return ((ICollection)parent).Count; }
       }

       bool System.Collections.ICollection.IsSynchronized {
           get { return ((ICollection)parent).IsSynchronized; }
       }

       object System.Collections.ICollection.SyncRoot {
           get { return ((ICollection)parent).SyncRoot; }
       }

       #endregion

       #region IEnumerable Members

       System.Collections.IEnumerator
System.Collections.IEnumerable.GetEnumerator() {
           return ((IEnumerable)parent).GetEnumerator();
       }

       #endregion

       #region ITypedList Members

       PropertyDescriptorCollection
ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors) {
           return GetItemProperties(listAccessors);
       }
       private PropertyDescriptorCollection
GetItemProperties(PropertyDescriptor[] listAccessors) {
           return
((ITypedList)parent).GetItemProperties(listAccessors);
       }

       string ITypedList.GetListName(PropertyDescriptor[]
listAccessors) {
           return ((ITypedList)parent).GetListName(listAccessors);
       }

       #endregion

       #region ISupportInitializeNotification Members

       event EventHandler ISupportInitializeNotification.Initialized
{
           add { ((ISupportInitializeNotification)parent).Initialized
+= value; }
           remove {
((ISupportInitializeNotification)parent).Initialized -= value; }
       }

       bool ISupportInitializeNotification.IsInitialized {
           get { return
((ISupportInitializeNotification)parent).IsInitialized; }
       }

       #endregion

       #region ISupportInitialize Members

       void ISupportInitialize.BeginInit() {
           ((ISupportInitialize)parent).BeginInit();
       }

       void ISupportInitialize.EndInit() {
           ((ISupportInitialize)parent).EndInit();
       }

       #endregion
   }