External Monitor under Pismo

[jason@openinformatics.com (Jason E. Stewart)]

[-- Attachment #1: Type: text/plain, Size: 806 bytes --]

Hey All,

So after 7 months of flailing I finally got my Pismo to run it's
external monitor port, yeah!!!

3 days before I had a talk to give about our OpenSource project, I
realized I was going to be using OpenOffice under linux, and I
couldn't actually drive a projector... So after I got done panicing I
hit google. I find a link on the YDL lists about the 'mirror' program
that appears to have been originally written by Paul Mackeras.

It gives me the functionality I need, but unfortunately it doesn't
seem to work with 2.4 kernels, only 2.2. The program is doing some
pretty low-level memory mojo which I am clueless about.

Could someone slightly wiser point out what would change between 2.2
and 2.4 that would cause this to break? Is it the base memory offset
for the framebuffer?

Cheers!
jas.


[-- Attachment #2: mirror2.c --]
[-- Type: application/octet-stream, Size: 3644 bytes --]

/*
*  Copyright (C) 1996 Paul Mackerras (paulus@linuxcare.com.au)
*
*  This program is free software; you can redistribute it and/or
*  modify it under the terms of the GNU General Public License
*  as published by the Free Software Foundation; either version
*  2 of the License, or (at your option) any later version.
*
*  Minor changes made by Stewart J Sadler (stewart.sadler@roke.co.uk) Oct 2000 
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/mman.h>

/* SJS apparently not used 
static inline void eieio()
{
   asm volatile("eieio" : :);
} */

unsigned long regs;

/************************************************************************/
static inline unsigned int ld(int regno)
{
    unsigned int x;

    asm volatile ("lwbrx %0,0,%1; eieio" : "=r" (x) : "r" (regs + regno));
    return x;
}

/************************************************************************/
static inline void st(int regno, unsigned int x)
{
    asm volatile ("stwbrx %0,0,%1; eieio" : : "r" (x), "r" (regs + regno));
}

/************************************************************************/
static void print_usage(void)
{
  printf("Usage = mirror2 [-h ][-o mirror_level ][-m offset]\n");
  printf("  -h Help/ print usage\n");
  printf("  -o Set mirroring to mirror_level (0=off 1=on ?)\n");
  printf("  -m PCI offset for device as a Hex number\n");
}


/************************************************************************/
static void get_arguments(int ac, char **av,int *on,unsigned long *offset)
{
  int arg;
  char *thisArg;
  
  /* defaults */
  *on=1;
  *offset=0xa0000000;
  
  if(ac==1)
  {
     print_usage();
  }
  for(arg=1;arg<ac;arg++)
  {
     thisArg=av[arg];
     if(thisArg[0]=='-')
     {
        switch(tolower(thisArg[1]))
        {
        case 'o':
           *on=1;
           if(arg+1<ac)
           {
                arg++;
                *on=atoi(av[arg]);
                printf("Mirroring level = %d\n",*on);
           }
           break;
        case 'm':
           if(arg+1<ac)
           {
                arg++;
                sscanf(av[arg],"%lx",offset);
                printf("Mirror Offset = %lX\n",*offset);
           }
           break;
        case 'h':
           print_usage();
           break;
        }
     }
  }
}

/************************************************************************/
int main(int ac, char **av)
{
    int fd, on;
    int a, x;
    unsigned long memoryOffset=0x81000000;
    
    if ((fd = open("/dev/mem", O_RDWR)) < 0) {
         perror("/dev/mem");
         exit(1);
    }

    get_arguments(ac,av,&on,&memoryOffset);

    regs = (unsigned long)
        mmap(0, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, memoryOffset);
    if (regs == -1) {
         perror("mmap");
         exit(1);
    }

    st(0x300, ld(0x200));
    st(0x304, ld(0x204));
    st(0x308, ld(0x208));
    st(0x30c, ld(0x20c));
    st(0x324, ld(0x224));
    st(0x32c, ld(0x22c));

    st(0x3f8, on? ((ld(0x50) & 0x700) | 0x2210000): 0x4000000);

    st(0x3e0, ld(0x2e0));
    st(0x3e4, ld(0x2e4));

    x = ld(0x8) & ~0xff;
    st(0x8, x | 2);
    a = ld(0x9);
    st(0x8, x | 0xaa);
    st(0x9, a & ~0x20000);

    st(0x8, x | 3);
    a = ld(0x9);
    st(0x8, x | 0xab);
    st(0x9, a);

    st(0x8, x | 4);
    a = ld(0x9);
    st(0x8, 0xac);
    st(0x9, a);

    st(0x58, (ld(0x58) & ~0x10));

    st(0x54, on? (ld(0x54) | 0x8000): (ld(0x54) & ~0x8000));

    exit(0);
}

[-- Attachment #3: Type: text/plain, Size: 1 bytes --]