Search
lxdream.org :: lxdream/src/maple/maple.c
Latest Version
lxdream 0.9.1
released Jun 29
Download Now
Navigation
News Download Mailing Lists Mercurial Issues Dreamcast Wiki FAQ Forums
tree revision 850:28782ebbd01d
Jump to:
summary | tree | shortlog | changelog | graph | changeset

 

filename src/maple/maple.c
changeset 850:28782ebbd01d
prev838:9abb2fa58934
next1034:7044e01148f0
author nkeynes
date Mon Sep 08 07:56:33 2008 +0000 (15 years ago)
permissions -rw-r--r--
last change Add lightgun support
view annotate diff log raw 
     1 /**

     2  * $Id$

     3  *

     4  * Implements the core Maple bus, including DMA transfers to and from the bus.

     5  *

     6  * Copyright (c) 2005 Nathan Keynes.

     7  *

     8  * This program is free software; you can redistribute it and/or modify

     9  * it under the terms of the GNU General Public License as published by

    10  * the Free Software Foundation; either version 2 of the License, or

    11  * (at your option) any later version.

    12  *

    13  * This program is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16  * GNU General Public License for more details.

    17  */

    18 #define MODULE maple_module

    19 

    20 #include <assert.h>

    21 #include <glib/gstrfuncs.h>

    22 #include "dream.h"

    23 #include "mem.h"

    24 #include "asic.h"

    25 #include "maple.h"

    26 

    27 void maple_init( void );

    28 

    29 struct dreamcast_module maple_module = { "Maple", maple_init, NULL, NULL, NULL,

    30         NULL, NULL, NULL };

    31 

    32 struct maple_device_class *maple_device_classes[] = { 

    33         &controller_class, &keyboard_class, &lightgun_class, &mouse_class, NULL };

    34 

    35 void maple_init( void )

    36 {

    37 

    38 }

    39 

    40 maple_device_t maple_new_device( const gchar *name )

    41 {

    42     maple_device_class_t clz = maple_get_device_class(name);

    43     if( clz != NULL ) {

    44         return clz->new_device();

    45     } 

    46     return NULL;

    47 }

    48 

    49 maple_device_class_t maple_get_device_class( const gchar *name )

    50 {

    51     int i;

    52     for( i=0; maple_device_classes[i] != NULL; i++ ) {

    53         if( g_strcasecmp(maple_device_classes[i]->name, name ) == 0 )

    54             return maple_device_classes[i];

    55     }

    56     return NULL;

    57 }

    58 

    59 const struct maple_device_class **maple_get_device_classes()

    60 {

    61     return (const struct maple_device_class **)maple_device_classes;

    62 }

    63 

    64 lxdream_config_entry_t maple_get_device_config( maple_device_t dev )

    65 {

    66     if( dev->get_config == NULL )

    67         return NULL;

    68     return dev->get_config(dev);

    69 }

    70 

    71 /**

    72  * Input data looks like this:

    73  *    0: transfer control word

    74  *      0: length of data in words (not including 3 word header)

    75  *      1: low bit = lightgun mode

    76  *      2: low 2 bits = port # (0..3)

    77  *      3: 0x80 = last packet, 0x00 = normal packet

    78  *    4: output buffer address

    79  *    8: Command word

    80  *      8: command code

    81  *      9: destination address

    82  *     10: source address

    83  *     11: length of data in words (not including 3 word header)

    84  *   12: command-specific data

    85  */

    86 

    87 /**

    88  * array is [port][subperipheral], so [0][0] is main peripheral on port A,

    89  * [1][2] is the second subperipheral on port B and so on.

    90  */

    91 maple_device_t maple_devices[4][6];

    92 int maple_periph_mask[4];

    93 #define GETBYTE(n) ((uint32_t)(buf[n]))

    94 #define GETWORD(n) (*((uint32_t *)(buf+(n))))

    95 #define PUTBYTE(n,x) (buf[n] = (char)x)

    96 #define PUTWORD(n,x) (*((uint32_t *)(return_buf+(n))) = (x))

    97 

    98 maple_device_t maple_get_device( unsigned int port, unsigned int periph ) {

    99     if( port >= 4 )

   100         return NULL;

   101     if( periph >= 6 )

   102         return NULL;

   103     return maple_devices[port][periph];

   104 }

   105 

   106 void maple_handle_buffer( uint32_t address ) {

   107     unsigned char *buf = (unsigned char *)mem_get_region(address);

   108     if( buf == NULL ) {

   109         ERROR( "Invalid or unmapped buffer passed to maple (0x%08X)", address );

   110     } else {

   111         unsigned int last = 0;

   112         int i = 0, count;

   113         for( count=0; !last; count++ ) {

   114             unsigned int port, length, mode, periph, periph_id, out_length;

   115             unsigned int cmd, recv_addr, send_addr;

   116             uint32_t return_addr;

   117             unsigned char *return_buf;

   118             maple_device_t dev;

   119 

   120             last = GETBYTE(3) & 0x80; /* indicates last packet */

   121             port = GETBYTE(2) & 0x03;

   122             mode = GETBYTE(1) & 0x07;

   123             length = GETBYTE(0) & 0xFF;

   124             return_addr = GETWORD(4);

   125 

   126             switch( mode ) {

   127             case 2: /* lightgun */

   128                 dev = maple_devices[port][0];

   129                 if( dev != NULL && dev->start_gun != NULL ) {

   130                     dev->start_gun(dev);

   131                     return; // Pending

   132                 } else {

   133                     asic_event( EVENT_MAPLE_DMA );

   134                     return;

   135                 }

   136             case 7: /* skip */

   137                 buf += 4;

   138                 address +=4; 

   139                 continue;

   140             }

   141             if( (return_addr & 0x1C000000) != 0x0C000000 ) {

   142                 ERROR( "Bad return address in maple packet: %08X", return_addr );

   143                 break;

   144             }

   145             return_buf = mem_get_region(return_addr);

   146             cmd = GETBYTE(8);

   147             recv_addr = GETBYTE(9);

   148             send_addr = GETBYTE(10);

   149             /* Sanity checks */

   150             if( GETBYTE(11) != length ||

   151                     send_addr >> 6 != port ||

   152                     recv_addr >> 6 != port ||

   153                     return_buf == NULL ) {

   154                 ERROR( "Received bad packet: %02X %02X %02X %02X  %02X %02X %02X %02X  %02X %02X %02X %02X",

   155                         buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],

   156                         buf[8], buf[9], buf[10], buf[11] );

   157                 break;

   158             }

   159             periph = 0;

   160             periph_id = recv_addr & 0x3F;

   161             if( periph_id != 0x20 ) {

   162                 for( i=0;i<5;i++ ) {

   163                     if( periph_id == (1<<i) ) {

   164                         periph = i+1;

   165                         break;

   166                     }

   167                 }

   168                 if( periph == 0 ) { /* Bad setting */

   169                     /* ERROR */

   170                 }

   171             }

   172 

   173             dev = maple_devices[port][periph];

   174             if( dev == NULL ) {

   175                 /* no device attached */

   176                 *((uint32_t *)return_buf) = -1;

   177             } else {

   178                 int status, func, block;

   179                 out_length = 0;

   180                 switch( cmd ) {

   181                 case MAPLE_CMD_INFO:

   182                     status = MAPLE_RESP_INFO;

   183                     memcpy( return_buf+4, dev->ident, 112 );

   184                     out_length = 0x1C;

   185                     break;

   186                 case MAPLE_CMD_EXT_INFO:

   187                     status = MAPLE_RESP_EXT_INFO;

   188                     memcpy( return_buf+4, dev->ident, 192 );

   189                     out_length = 0x30;

   190                     break;

   191                 case MAPLE_CMD_RESET:

   192                     if( dev->reset == NULL )

   193                         status = MAPLE_RESP_ACK;

   194                     else status = dev->reset(dev);

   195                     break;

   196                 case MAPLE_CMD_SHUTDOWN:

   197                     if( dev->shutdown == NULL )

   198                         status = MAPLE_RESP_ACK;

   199                     else status = dev->shutdown(dev);

   200                     break;

   201                 case MAPLE_CMD_GET_COND:

   202                     func = GETWORD(12);

   203                     if( dev->get_condition == NULL )

   204                         status = MAPLE_ERR_CMD_UNKNOWN;

   205                     else status = dev->get_condition(dev, func,

   206                             return_buf+8,

   207                             &out_length );

   208                     if( status == 0 ) {

   209                         out_length++;

   210                         status = MAPLE_RESP_DATA;

   211                         PUTWORD(4,func);

   212                     }

   213                     break;

   214                 case MAPLE_CMD_SET_COND:

   215                     func = GETWORD(12);

   216                     if( dev->set_condition == NULL )

   217                         status = MAPLE_ERR_CMD_UNKNOWN;

   218                     else status = dev->set_condition(dev, func,

   219                             buf+16,

   220                             length);

   221                     if( status == 0 )

   222                         status = MAPLE_RESP_ACK;

   223                     break;

   224                 case MAPLE_CMD_READ_BLOCK:

   225                     func = GETWORD(12);

   226                     block = GETWORD(16);

   227                     if( dev->read_block == NULL )

   228                         status = MAPLE_ERR_CMD_UNKNOWN;

   229                     else status = dev->read_block(dev, func, block,

   230                             return_buf+12,

   231                             &out_length );

   232                     if( status == 0 ) {

   233                         status = MAPLE_RESP_DATA;

   234                         PUTWORD(4,func);

   235                         PUTWORD(8,block);

   236                     }

   237                     break;

   238                 case MAPLE_CMD_WRITE_BLOCK:

   239                     func = GETWORD(12);

   240                     block = GETWORD(16);

   241                     if( dev->write_block == NULL )

   242                         status = MAPLE_ERR_CMD_UNKNOWN;

   243                     else {

   244                         status = dev->write_block(dev, func, block, 

   245                                 buf+20, length);

   246                         if( status == 0 )

   247                             status = MAPLE_RESP_ACK;

   248                     }

   249                     break;

   250                 default:

   251                     status = MAPLE_ERR_CMD_UNKNOWN;

   252                 }

   253                 return_buf[0] = status;

   254                 return_buf[1] = send_addr;

   255                 return_buf[2] = recv_addr;

   256                 if( periph == 0 )

   257                     return_buf[2] |= maple_periph_mask[port];

   258                 return_buf[3] = out_length;

   259             }

   260             buf += 12 + (length<<2);

   261             address += 12 + (length<<2);

   262         }

   263         asic_event( EVENT_MAPLE_DMA );

   264     }

   265 }

   266 

   267 void maple_attach_device( maple_device_t dev, unsigned int port,

   268                           unsigned int periph ) {

   269     assert( port < 4 );

   270     assert( periph < 6 );

   271 

   272     if( maple_devices[port][periph] != NULL ) {

   273         /* Detach existing peripheral first */

   274         maple_detach_device( port, periph );

   275     }

   276 

   277     maple_devices[port][periph] = dev;

   278     if( periph != 0 )

   279         maple_periph_mask[port] |= (1<<(periph-1));

   280     else maple_periph_mask[port] |= 0x20;

   281     if( dev->attach != NULL ) {

   282         dev->attach( dev );

   283     }

   284 }

   285 

   286 void maple_detach_device( unsigned int port, unsigned int periph ) {

   287     assert( port < 4 );

   288     assert( periph < 6 );

   289 

   290     maple_device_t dev = maple_devices[port][periph];

   291     if( dev == NULL ) /* already detached */

   292         return;

   293     maple_devices[port][periph] = NULL;

   294     if( dev->detach != NULL ) {

   295         dev->detach(dev);

   296     }

   297     if( dev->destroy != NULL ) {

   298         dev->destroy(dev);

   299     }

   300     if( periph == 0 ) {

   301         /* If we detach the main peripheral, we also have to detach all the

   302          * subperipherals, or the system could get quite confused

   303          */

   304         int i;

   305         maple_periph_mask[port] = 0;

   306         for( i=1; i<6; i++ ) {

   307             maple_detach_device(port,i);

   308         }

   309     } else {

   310         maple_periph_mask[port] &= (~(1<<(periph-1)));

   311     }

   312 

   313 }

   314 

   315 void maple_detach_all() {

   316     int i, j;

   317     for( i=0; i<4; i++ ) {

   318         for( j=0; j<6; j++ ) {

   319             if( maple_devices[i][j] != NULL ) {

   320                 maple_device_t dev = maple_devices[i][j];

   321                 if( dev->detach != NULL )

   322                     dev->detach(dev);

   323                 if( dev->destroy != NULL )

   324                     dev->destroy(dev);

   325             }

   326         }

   327         maple_periph_mask[i] = 0;

   328     }

   329 }

   330 

   331 void maple_reattach_all() 

   332 {

   333     int i, j;

   334     for( i=0; i<4; i++ ) {

   335         for( j=0; j<6; j++ ) {

   336             if( maple_devices[i][j] != NULL ) {

   337                 maple_device_t dev = maple_devices[i][j];

   338                 if( dev->detach != NULL ) 

   339                     dev->detach(dev);

   340                 if( dev->attach != NULL )

   341                     dev->attach(dev);

   342             }

   343         }

   344     }

   345 }

   346 

   347 gboolean maple_should_grab()

   348 {

   349     int mode = MAPLE_GRAB_DONTCARE;

   350     int i,j;

   351     for( i=0; i<4; i++ ) {

   352         for( j=0; j<6; j++ ) {

   353             if( maple_devices[i][j] != NULL ) {

   354                 maple_device_t dev = maple_devices[i][j];

   355                 if( dev->grab_mode > mode ) {

   356                     mode = dev->grab_mode;

   357                 }

   358             }

   359         }

   360     }

   361     return mode == MAPLE_GRAB_YES;

   362 }

   363 

   364 void maple_set_device_config_value( maple_device_t dev, unsigned int key, const gchar *value )

   365 {

   366     if( dev != NULL && dev->set_config_value != NULL ) {

   367         dev->set_config_value( dev, key, value );

   368     }

   369 }

   370 

   371 void maple_default_destroy( maple_device_t mdev )

   372 {

   373     free(mdev);

   374 }
.