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 238:6af4cc93b137
Jump to:
summary | tree | shortlog | changelog | graph | changeset

 

filename src/maple/maple.c
changeset 159:406161fea392
prev144:7f0714e89aaa
next447:3e095bfcb476
author nkeynes
date Fri Dec 15 10:17:08 2006 +0000 (17 years ago)
permissions -rw-r--r--
last change Add UI for the trace flag
view annotate diff log raw 
     1 /**

     2  * $Id: maple.c,v 1.9 2006-06-15 10:33:05 nkeynes Exp $

     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 "dream.h"

    22 #include "mem.h"

    23 #include "asic.h"

    24 #include "maple.h"

    25 

    26 void maple_init( void );

    27 

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

    29 					 NULL, NULL, NULL };

    30 

    31 struct maple_device_class *maple_device_classes[] = { &controller_class, NULL };

    32 

    33 void maple_init( void )

    34 {

    35 

    36 }

    37 

    38 maple_device_t maple_new_device( const gchar *name )

    39 {

    40     int i;

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

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

    43 	    return maple_device_classes[i]->new_device();

    44     }

    45     return NULL;

    46 }

    47 

    48 dreamcast_config_entry_t maple_get_device_config( maple_device_t dev )

    49 {

    50     if( dev->get_config == NULL )

    51 	return NULL;

    52     return dev->get_config(dev);

    53 }

    54 

    55 /**

    56  * Input data looks like this:

    57  *    0: transfer control word

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

    59  *      1: low bit = lightgun mode

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

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

    62  *    4: output buffer address

    63  *    8: Command word

    64  *      8: command code

    65  *      9: destination address

    66  *     10: source address

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

    68  *   12: command-specific data

    69  */

    70 

    71 /**

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

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

    74  */

    75 maple_device_t maple_devices[4][6];

    76 int maple_periph_mask[4];

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

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

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

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

    81 

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

    83     if( port >= 4 )

    84 	return NULL;

    85     if( periph >= 6 )

    86 	return NULL;

    87     return maple_devices[port][periph];

    88 }

    89 

    90 void maple_handle_buffer( uint32_t address ) {

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

    92     if( buf == NULL ) {

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

    94     } else {

    95         unsigned int last = 0;

    96         int i = 0, count;

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

    98             unsigned int port, length, gun, periph, periph_id, out_length;

    99             unsigned int cmd, recv_addr, send_addr;

   100             uint32_t return_addr;

   101             unsigned char *return_buf;

   102             

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

   104             port = GETBYTE(2) & 0x03;

   105             gun = GETBYTE(1) & 0x01;

   106             length = GETBYTE(0) & 0xFF;

   107             return_addr = GETWORD(4);

   108             if( return_addr == 0 ) {

   109                 /* ERROR */

   110             }

   111             return_buf = mem_get_region(return_addr);

   112             cmd = GETBYTE(8);

   113             recv_addr = GETBYTE(9);

   114             send_addr = GETBYTE(10);

   115             /* Sanity checks */

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

   117                 send_addr != (port<<6) ||

   118                 recv_addr >> 6 != port ||

   119                 return_buf == NULL ) {

   120                 /* ERROR */

   121             }

   122             periph = 0;

   123             periph_id = recv_addr & 0x3F;

   124             if( periph_id != 0x20 ) {

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

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

   127                         periph = i+1;

   128                         break;

   129                     }

   130                 }

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

   132                     /* ERROR */

   133                 }

   134             }

   135 

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

   137             if( dev == NULL ) {

   138                 /* no device attached */

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

   140             } else {

   141                 int status, func, block;

   142                 out_length = 0;

   143                 switch( cmd ) {

   144                     case MAPLE_CMD_INFO:

   145                         status = MAPLE_RESP_INFO;

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

   147                         out_length = 0x1C;

   148                         break;

   149                     case MAPLE_CMD_EXT_INFO:

   150                         status = MAPLE_RESP_EXT_INFO;

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

   152                         out_length = 0x30;

   153                         break;

   154                     case MAPLE_CMD_RESET:

   155                         if( dev->reset == NULL )

   156                             status = MAPLE_RESP_ACK;

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

   158                         break;

   159                     case MAPLE_CMD_SHUTDOWN:

   160                         if( dev->shutdown == NULL )

   161                             status = MAPLE_RESP_ACK;

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

   163                         break;

   164                     case MAPLE_CMD_GET_COND:

   165                         func = GETWORD(12);

   166                         if( dev->get_condition == NULL )

   167                             status = MAPLE_ERR_CMD_UNKNOWN;

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

   169                                                          return_buf+8,

   170                                                          &out_length );

   171 			out_length++;

   172                         if( status == 0 ) {

   173                             status = MAPLE_RESP_DATA;

   174                             PUTWORD(4,func);

   175                         }

   176                         break;

   177                     case MAPLE_CMD_SET_COND:

   178                         func = GETWORD(12);

   179                         if( dev->set_condition == NULL )

   180                             status = MAPLE_ERR_CMD_UNKNOWN;

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

   182                                                          buf+16,

   183                                                          length);

   184                         if( status == 0 )

   185                             status = MAPLE_RESP_ACK;

   186                         break;

   187                     case MAPLE_CMD_READ_BLOCK:

   188                         func = GETWORD(12);

   189                         block = GETWORD(16);

   190                         if( dev->read_block == NULL )

   191                             status = MAPLE_ERR_CMD_UNKNOWN;

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

   193                                                       return_buf+12,

   194                                                       &out_length );

   195                         if( status == 0 ) {

   196                             status = MAPLE_RESP_DATA;

   197                             PUTWORD(4,func);

   198                             PUTWORD(8,block);

   199                         }

   200                         break;

   201                     case MAPLE_CMD_WRITE_BLOCK:

   202                         func = GETWORD(12);

   203                         block = GETWORD(16);

   204                         if( dev->write_block == NULL )

   205                             status = MAPLE_ERR_CMD_UNKNOWN;

   206                         else {

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

   208                                                       buf+20, length);

   209                             if( status == 0 )

   210                                 status = MAPLE_RESP_ACK;

   211                         }

   212                         break;

   213                     default:

   214                         status = MAPLE_ERR_CMD_UNKNOWN;

   215                 }

   216                 return_buf[0] = status;

   217                 return_buf[1] = send_addr;

   218                 return_buf[2] = recv_addr;

   219                 if( periph == 0 )

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

   221                 return_buf[3] = out_length;

   222             }

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

   224         }

   225         asic_event( EVENT_MAPLE_DMA );

   226     }

   227 }

   228 

   229 void maple_attach_device( maple_device_t dev, unsigned int port,

   230                           unsigned int periph ) {

   231     assert( port < 4 );

   232     assert( periph < 6 );

   233 

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

   235         /* Detach existing peripheral first */

   236         maple_detach_device( port, periph );

   237     }

   238     

   239     maple_devices[port][periph] = dev;

   240     if( periph != 0 )

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

   242     else maple_periph_mask[port] |= 0x20;

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

   244         dev->attach( dev );

   245     }

   246 }

   247 

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

   249     assert( port < 4 );

   250     assert( periph < 6 );

   251 

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

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

   254         return;

   255     maple_devices[port][periph] = NULL;

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

   257         dev->detach(dev);

   258     }

   259     if( periph == 0 ) {

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

   261          * subperipherals, or the system could get quite confused

   262          */

   263         int i;

   264         maple_periph_mask[port] = 0;

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

   266             maple_detach_device(port,i);

   267         }

   268     } else {

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

   270     }

   271     

   272 }

   273 

   274 void maple_detach_all() {

   275     int i, j;

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

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

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

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

   280 		if( dev->detach != NULL )

   281 		    dev->detach(dev);

   282 		if( dev->destroy != NULL )

   283 		    dev->destroy(dev);

   284 	    }

   285 	}

   286 	maple_periph_mask[i] = 0;

   287     }

   288 }

   289 

   290 void maple_reattach_all() {

   291     int i, j;

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

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

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

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

   296 		if( dev->attach != NULL )

   297 		    dev->attach(dev);

   298 	    }

   299 	}

   300     }

   301 }
.