Subversion Repositories shark

/*
 * Project: S.Ha.R.K.
 *
 * Coordinators:
 *   Giorgio Buttazzo    <giorgio@sssup.it>
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *
 * Authors     :
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
 *   Luca Abeni          <luca@gandalf.sssup.it>
 *   (see the web pages for full authors list)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://shark.sssup.it
 */

/**
 ------------
 CVS :        $Id: mouse.c,v 1.2 2004-06-03 09:51:45 giacomo Exp $

 File:        $File$
 Revision:    $Revision: 1.2 $
 Last update: $Date: 2004-06-03 09:51:45 $
 ------------

 Author:        Gerardo Lamastra
 Date:  9/5/96

 Revision:      1.1b
 Last update: 14/apr/1999

 Serial mouse driver
 The mouse driver receives data from the serial RxServer()
 Then it processes the mouse packet and sets the variables
 representing the external mouse status.

**/

/*
 * Copyright (C) 2000 Paolo Gai
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/* Revision 1.1                    
 * Author:      Massimiliano Giorgi
 *
 * -- added support for PS/2 mouse  
 *
 * Detailed changed from 1.0g:
 * -- now mouse.c use "virtual operation"
 * -- all procedure changed to use "virtual operation"
 * ("virtual operation" are indipendent of the phisical device that
 * is used to comunicate with mouse so it can handle serial mouse, ps/2 mouse)
 * (all changed marked with a "MG")
 */

/* Revision 1.1b
 * Author:      Massimiliano Giorgi
 *
 * Changed to compile on 3.2.0
 * -- added wcet time
 * -- RECEIVE ports now are STREAM ports
 */

/*
 * Changelog:
 * -- Added support for various serial mouse
 * -- Virtual operations changed
 * -- Added support for auto-pointer
 */

/*
 * auto-pointer functions now are into
 * mcurtxt.c and mcurgrx.c
 * (to prevent automatic graphical library inclusion)
 */

//#include <string.h>
//#include <stdlib.h>
//#include <cons.h>
//#include <mem.h>

//#include "vm.h"
#include <kernel/kern.h>
//#include "exc.h"

#include <drivers/mouse.h>

/*if defined: then a trace of the initialization is performed */
// #define __DEBUG_INIT__

/* if defined: when a byte is received is displayed on the screen */
//#define __XTRA_DEBUG_MOUSE__

/*
 *
 * Operation on a virtual mouse
 * (added by MG)
 *
 */

#include "_mouse.h"
#include "sermouse.h"
#include "ps2mouse.h"

struct mouse_operations vmouse[]={

  {"ms",   "The original ms protocol, with a middle-button extension.",
           {0x40, 0x40, 0x40, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_ms
  },

  {"ms+",  "Like 'ms', but allows dragging with the middle button.",
           {0x40, 0x40, 0x40, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_ms_plus
  },

  {"ms+lr", "'ms+', but you can reset m by pressing lr.",
            {0x40, 0x40, 0x40, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_ms_plus_lr
  },

  {"bare", "Unadorned ms protocol. Needed with some 2-buttons mice.",
           {0x40, 0x40, 0x40, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_bare
  },

  {"msc",  "Mouse-Systems-Compatible (5bytes). Most 3-button mice.",
           {0xf8, 0x80, 0x00, 0x00}, 5, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_msc
  },

  {"sun",  "'msc' protocol, but only 3 bytes per packet.",
           {0xf8, 0x80, 0x00, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_sun
  },

  {"mm",   "MM series. Probably an old protocol...",
           {0xe0, 0x80, 0x80, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_mm
  },

  {"logi", "Used in some Logitech devices (only serial).",
           {0xe0, 0x80, 0x80, 0x00}, 3, 1, 0, 0, 0,
    sermouse_open,
    sermouse_close,
    sermouse_wait,
    sermouse_get,
    sermouse_enable,
    sermouse_disable,
    M_logi
  },

  {"ps2",  "Busmice of the ps/2 series. Most busmice, actually.",
           {0xc0, 0x00, 0x00, 0x00}, 3, 1, 0, 0, 0,
    ps2mouse_open,
    ps2mouse_close,
    ps2mouse_wait,
    ps2mouse_get,
    ps2mouse_enable,
    ps2mouse_disable,
    M_ps2
  },

  {"\0",     "",
           {0, 0, 0, 0}, 0, 0, 0, 0, 0,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL
  }

};

int  (*open_mouse)(void*);    /* open comunication device */
void (*close_mouse)(void);    /* close comunication device */
void (*wait_mouse)(void);     /* wait to have a BYTE (blocking operation)*/
int  (*get_mouse)(BYTE *);      /* get last BYTE */
void (*enable_mouse)(void);   /* enable interface */
void (*disable_mouse)(void);  /* disable interface */

char *name_mouse;             /* mouse name */
char *desc_mouse;             /* mouse description */
BYTE *proto_mouse;            /* mouse protocol (see below) */
int  packetlen_mouse;         /* mouse packet lenght */

int (*decode_mouse)(MOUSE_EVT *evt,unsigned char *data);

/*
 * proto_mouse is used to syncronize the device driver:
 * if A is the first byte read and B the second, this is a valid
 * start of a mouse protocol packet if
 * (A&proto_mouse[0])==proto_mouse[1])&&(b&proto_mouse[2])==proto_mouse[3])
 */

/* type of mouse to use for virtual operation */
int mousetype=NOMOUSE;

/* fill the variabled used to call the virtuals operations */
static void mouse_settype(int type)
{
    mousetype=type;

    open_mouse   =vmouse[mousetype].open;
    close_mouse  =vmouse[mousetype].close;
    wait_mouse   =vmouse[mousetype].wait;
    get_mouse    =vmouse[mousetype].get;
    enable_mouse =vmouse[mousetype].enable;
    disable_mouse=vmouse[mousetype].disable;

    name_mouse     =vmouse[mousetype].name;
    desc_mouse     =vmouse[mousetype].desc;
    proto_mouse    =vmouse[mousetype].proto;
    packetlen_mouse=vmouse[mousetype].packetlen;

    decode_mouse=vmouse[mousetype].decode;
}

/*
 *
 * end (operation on a virtual mouse)
 *
 */

/* MG: this are no "static" (they are used by sermouse.c, ps2mouse.c) */
/*     "threshold" renamed "mouse_thresholdlim" */
short int mouse_lim_x1 = 0;
short int mouse_lim_y1 = 0;
short int mouse_lim_x2 = 79;
short int mouse_lim_y2 = 24;
short int mouse_x = 40;
short int mouse_x_mick = 0;
short int mouse_y = 12;
short int mouse_y_mick = 0;
short int mouse_buttons = 0;
short int mouse_thresholdlim = 5;
MOUSE_HANDLER mouse_handler = NULL;

MOUSE_HANDLER user_mouse_handler = NULL;
int autocursormode=DISABLE;

static PID mouse_pid = NIL;

/*
 * this is a general mouse server
 * useable by most mouse protocol implementation
 */

TASK generalmouse_server(void)
{
  static MOUSE_EVT event;
  BYTE data[8];
  int index;
  int mickey;

#ifdef __XTRA_DEBUG_MOUSE__
  char str[40];
#endif
   
  index=0;
  for(;;) {
#ifdef __XTRA_DEBUG_MOUSE__
    puts_xy(0,11,WHITE,"Waiting..");
#endif

    /* wait for mouse data */
    wait_mouse();

    /* get mouse data */
    //data[index]=get_mouse();
    index+=get_mouse(data+index);
   
#ifdef __XTRA_DEBUG_MOUSE__
    sprintf(str,"Mouse data[%01d]: %2x",index,data[index]);
    puts_xy(0,12+index,WHITE,str);
#endif

    switch (index) {
      case 1:
        if ((data[0]&proto_mouse[0])!=proto_mouse[1]) index=0;
        break;
      case 2:
        if ((data[1]&proto_mouse[2])==proto_mouse[3]) index=0;
        break;
      default:
        if (index<packetlen_mouse) break;
       
        if (decode_mouse(&event,data)==0) {

          /* Y */
          mickey=event.dy;
          mouse_y_mick += mickey;
          while (mouse_y_mick > mouse_thresholdlim) {
            mouse_y++;
            mouse_y_mick -= mouse_thresholdlim;
          }
          while (mouse_y_mick < -mouse_thresholdlim) {
            mouse_y--;
            mouse_y_mick += mouse_thresholdlim;
          }
          if (mouse_y > mouse_lim_y2) mouse_y = mouse_lim_y2;
          else if (mouse_y < mouse_lim_y1) mouse_y = mouse_lim_y1;
          event.y=mouse_y;

          /* X */
          mickey = event.dx;
          mouse_x_mick += mickey;
          while (mouse_x_mick > mouse_thresholdlim) {
            mouse_x++;
            mouse_x_mick -= mouse_thresholdlim;
          }
          while (mouse_x_mick < -mouse_thresholdlim) {
            mouse_x--;
            mouse_x_mick += mouse_thresholdlim;
          }
          if (mouse_x > mouse_lim_x2) mouse_x = mouse_lim_x2;
          else if (mouse_x < mouse_lim_x1) mouse_x = mouse_lim_x1;
          event.x=mouse_x;

          /* mouse handler */
          if (mouse_handler!=NULL) mouse_handler(&event);
        }

        index-=packetlen_mouse;
        if (index!=0) memcpy(data,data+packetlen_mouse,index);
        break;

    } /* switch */
  } /* for */
}

/* [for SERIAL MOUSE] */
/* Well, this implementation is a little dispendious as we use  */
/* two different tasks, one as serial receiver, the other as    */
/* mouse-protocol decoder; this has been chosen in order to     */
/* make any mouse-protocol easier. We only need to rewrite the  */
/* the appropriate mouse packet interpreter                     */

/*
 * MG: rewritten to handle serial and PS/2 mouse and other mouses
 */

/* changed user interface */


int mouse_init(MOUSE_PARMS *parms)
{
  int status=0;
  TASK_MODEL *m;
  SOFT_TASK_MODEL base_m;
  MOUSE_PARMS mparms=BASE_MOUSE;

#ifdef __DEBUG_INIT__
  cprintf("mouse_init: START\n");
#endif

  if (mouse_pid != NIL) return -1;
  if (parms==NULL) parms=&mparms;

  /* default values */

#ifdef __DEBUG_INIT__
  cprintf("mouse_init: default values\n");
#endif

  if (parms->tm == (TASK_MODEL *)MOUSE_DEFAULT) {
    soft_task_default_model(base_m);
    soft_task_def_wcet(base_m,2000);
    soft_task_def_met(base_m,500);
    soft_task_def_period(base_m,8000);
    soft_task_def_system(base_m);
    soft_task_def_nokill(base_m);
    soft_task_def_aperiodic(base_m);
    m = (TASK_MODEL *)&base_m;
  }
  else
    m = parms->tm;

  /* try autodetect mouse() */
  if (parms->type==MOUSE_DEFAULT) {
    SERMOUSE_INFO *sinfoptr;

#ifdef __DEBUG_INIT__
    cprintf("mouse_init: try autodetecting\n");
#endif

    if (ps2mouse_present()) parms->type=PS2MOUSE;
    else {
      sinfoptr=sermouse_present();
      if (sinfoptr==NULL) return -2;
      parms->type=sinfoptr->type;
      parms->port=sinfoptr->port;
    }
  }

  mouse_settype(parms->type);
  switch(mousetype) {
  case PS2MOUSE:
    /* max PS/2 mouse rate: 40 event per second with 3 bytes per event */
    /* 120 bytes/sec -> 8 msec between activation (I hope)*/

#ifdef __DEBUG_INIT__
    cprintf("mouse_init: creating ps2 server task\n");
#endif

    if (parms->tm==(TASK_MODEL *)MOUSE_DEFAULT)
      soft_task_def_period(base_m,8000);
    mouse_pid=task_create("PS2Mouse",
                          ps2mouse_getserveraddr(),
                          m, NULL);
    if (mouse_pid==-1) return -3;

    //task_activate(mouse_pid);
   
#ifdef __DEBUG_INIT__
    cprintf("mouse_init: opening mouse\n");
#endif

    status=open_mouse((void*)&mouse_pid);
    break;

  case MSMOUSE:
  case MSPMOUSE:
  case MSPLRMOUSE:
  case BAREMOUSE:
  case MSCMOUSE:
  case SUNMOUSE:
  case LOGIMOUSE:
  case MMMOUSE:
    break;
  }

  if (status!=0) {
    task_kill(mouse_pid);
    mouse_pid=NIL;
    return -4;
  }

#ifdef __DEBUG_INIT__
  cputs("mouse_init: mouse activated\n");
#endif

  return 0;
}

void mouse_end(void)
{
  if (mouse_pid==NIL) return;
  task_kill(mouse_pid);
  mouse_pid=NIL;
  close_mouse();
}

/* MG: all the following procedure are modified */
/*     to use virtual operation                 */

void mouse_disable(void)
{
  disable_mouse();
}

void mouse_enable(void)
{
  enable_mouse();
}

void mouse_get(int *x,int *y,BYTE *button)
{
    if (x != NULL) *x = mouse_x;
    if (y != NULL) *y = mouse_y;
    if (button != NULL) *button = mouse_buttons;
}

void mouse_position(int x,int y)
{
    disable_mouse();
    mouse_x = x;
    mouse_y = y;
    enable_mouse();
}

void mouse_limit(int x1,int y1,int x2,int y2)
{
    disable_mouse();
    mouse_lim_x1 = x1;
    mouse_lim_y1 = y1;
    mouse_lim_x2 = x2;
    mouse_lim_y2 = y2;
    mouse_x = (x1+x2)/2;
    mouse_y = (y1+y2)/2;
    enable_mouse();
}

void mouse_threshold(unsigned t)
{
    disable_mouse();
    if (t < 1) t = 1;
    else if (t > 100) t = 100;
    mouse_thresholdlim = t;
    enable_mouse();
}

void mouse_hook(MOUSE_HANDLER h)
{
  /* changed to use the autocursor functions */
  if ((autocursormode&STATUSMASK)==DISABLE) {
    mouse_handler = h;
  } else {
    user_mouse_handler = h;
  }
}