OpenCores
URL https://opencores.org/ocsvn/s6soc/s6soc/trunk

Subversion Repositories s6soc

[/] [s6soc/] [trunk/] [sw/] [host/] [deppbus.cpp] - Blame information for rev 11

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 8 dgisselq
////////////////////////////////////////////////////////////////////////////////
2
//
3
// Filename:    deppbus.cpp
4
//
5
// Project:     CMod S6 System on a Chip, ZipCPU demonstration project
6
//
7
// Purpose:     This is a *very* simple Depp to Wishbone driver conversion.
8
//              Look in devbus.cpp for a description of how to use the driver.
9
//
10
//      The driver is simple: there are 9 registers of interest to run this
11
//      driver.  The first four registers, 0-3, are address registers, MSB
12
//      first.  Place your 32-bit address into these registers.  The next four
13
//      registers, 4-7, are data registers.  If writing data, place the data
14
//      to write into these registers.  The last register, 16, is a strobe
15
//      register.  Write a 1 to read, and a 3 to write, to this register.  A
16
//      bus transaction will then take place.  Once completed, registers 4-7
17
//      will contain the resulting data.
18
//
19
//      That's the internal workings of this driver.  The above description is
20
//      accomplished in the readio() and writeio() routines.
21
//
22
//      This is *not* a fully featured DEVBUS class--it does not support
23
//      pipelined reads or writes.  It does not support compression.  It does,
24
//      however, support reading and writing a simple 32-bit wishbone bus.
25
//      That is good enough, of itself, for now.
26
//
27
// Creator:     Dan Gisselquist, Ph.D.
28
//              Gisselquist Technology, LLC
29
//
30
////////////////////////////////////////////////////////////////////////////////
31
//
32
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
33
//
34
// This program is free software (firmware): you can redistribute it and/or
35
// modify it under the terms of  the GNU General Public License as published
36
// by the Free Software Foundation, either version 3 of the License, or (at
37
// your option) any later version.
38
//
39
// This program is distributed in the hope that it will be useful, but WITHOUT
40
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
41
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
42
// for more details.
43
//
44
// You should have received a copy of the GNU General Public License along
45
// with this program.  (It's in the $(ROOT)/doc directory, run make with no
46
// target there if the PDF file isn't present.)  If not, see
47
// <http://www.gnu.org/licenses/> for a copy.
48
//
49
// License:     GPL, v3, as defined and found on www.gnu.org,
50
//              http://www.gnu.org/licenses/gpl.html
51
//
52
//
53
////////////////////////////////////////////////////////////////////////////////
54
//
55
//
56
#include <stdlib.h>
57
#include <stdio.h>
58
#include "dpcdecl.h"
59
#include "dmgr.h"
60
#include "depp.h"
61
#include "deppbus.h"
62
 
63
DEPPBUS::DEPPBUS(char *szSel) {
64
        if (!DmgrOpen(&m_dev, szSel)) {
65
                fprintf(stderr, "Open failed!\n");
66
                exit(EXIT_FAILURE);
67
        }
68
 
69
        if (!DeppEnable(m_dev)) {
70
                fprintf(stderr, "Could not enable DEPP interface\n");
71
                exit(EXIT_FAILURE);
72
        }
73
 
74
        m_int = false, m_err = false;
75
}
76
 
77
DEPPBUS::~DEPPBUS(void) {
78
        if (m_dev)
79
                DmgrClose(m_dev);
80
        m_dev = 0;
81
}
82
 
83
void DEPPBUS::kill(void) { close(); }
84
void DEPPBUS::close(void) { DmgrClose(m_dev); m_dev = 0; }
85
 
86
void    DEPPBUS::depperr(void) {
87
        ERC     erc = DmgrGetLastError();
88
        if (erc != ercNoErc) {
89
                char    scode[cchErcMax], msg[cchErcMsgMax];
90
                DmgrSzFromErc(erc,scode,msg);
91
                fprintf(stderr, "ErrCode   : %s\n", scode);
92
                fprintf(stderr, "ErrMessage: %s\n", msg);
93
                close();
94
                exit(EXIT_FAILURE);
95
        }
96
}
97
 
98
void DEPPBUS::writeio(const BUSW a, const BUSW v) {
99
        bool    good = true;
100
 
101
        // Set the address for our data
102
        good = good && DeppPutReg(m_dev, 0, (a>>24)&0x0ff, false);
103
        good = good && DeppPutReg(m_dev, 1, (a>>16)&0x0ff, false);
104
        good = good && DeppPutReg(m_dev, 2, (a>> 8)&0x0ff, false);
105
        good = good && DeppPutReg(m_dev, 3,  a     &0x0ff, false);
106
        if (!good) {
107
                fprintf(stderr, "BUS CYCLE FAILED\n");
108
                depperr(); close();
109
                exit(EXIT_FAILURE);
110
        }
111
 
112
        // Set the data to be transmitted
113
        good = good && DeppPutReg(m_dev, 4, (v>>24)&0x0ff, false);
114
        good = good && DeppPutReg(m_dev, 5, (v>>16)&0x0ff, false);
115
        good = good && DeppPutReg(m_dev, 6, (v>> 8)&0x0ff, false);
116
        good = good && DeppPutReg(m_dev, 7,  v     &0x0ff, false);
117
        if (!good) {
118
                fprintf(stderr, "BUS CYCLE FAILED\n");
119
                depperr(); close();
120
                exit(EXIT_FAILURE);
121
        }
122
 
123
        // Perform the operation
124
        good = good && DeppPutReg(m_dev,16,  0x3, false);
125
        if (!good) {
126
                fprintf(stderr, "BUS CYCLE FAILED\n");
127
                depperr(); close();
128
                exit(EXIT_FAILURE);
129
        }
130
 
131
        // Now, let's check for any bus errors and/or interrupts
132
        BYTE    retn;
133
        good = good && DeppGetReg(m_dev,16, &retn, false);
134
        m_err = m_err | (retn&1);
135
        m_int = m_int | (retn&2);
136
 
137
        if (!good) {
138
                fprintf(stderr, "BUS CYCLE FAILED\n");
139
                depperr(); close();
140
                exit(EXIT_FAILURE);
141
        }
142
 
143
        if (m_err)
144
                throw BUSERR(a);
145
}
146
 
147
DEVBUS::BUSW DEPPBUS::readio(const DEVBUS::BUSW a) {
148
        BUSW    v = 0;
149
        BYTE    retn;
150
        bool    good = true;
151
 
152
        // Set the address for our data
153
        good = good && DeppPutReg(m_dev, 0, (a>>24)&0x0ff, false);
154
        good = good && DeppPutReg(m_dev, 1, (a>>16)&0x0ff, false);
155
        good = good && DeppPutReg(m_dev, 2, (a>> 8)&0x0ff, false);
156
        good = good && DeppPutReg(m_dev, 3,  a     &0x0ff, false);
157
 
158
        if (!good) {
159
                fprintf(stderr, "BUS CYCLE FAILED\n");
160
                depperr(); close();
161
                exit(EXIT_FAILURE);
162
        }
163
 
164
        // Run the bus cycle
165
        good = good && DeppPutReg(m_dev,16,  0x1, false);
166
        if (!good) {
167
                fprintf(stderr, "BUS CYCLE FAILED\n");
168
                depperr(); close();
169
                exit(EXIT_FAILURE);
170
        }
171
 
172
        // Check for any bus errors and/or interrupts
173
        good = good && DeppGetReg(m_dev,16, &retn, false);
174
        if (!good) {
175
                fprintf(stderr, "BUS CYCLE FAILED\n");
176
                depperr(); close();
177
                exit(EXIT_FAILURE);
178
        }
179
 
180
        m_err = m_err | (retn&1);
181
        m_int = m_int | (retn&2);
182
 
183
        if (m_err)
184
                throw BUSERR(a);
185
 
186
        // Otherwise let's get our result
187
        good = good && DeppGetReg(m_dev, 4, &retn, false); v = (retn & 0x0ff);
188
        good = good && DeppGetReg(m_dev, 5, &retn, false); v = (v<<8)|(retn & 0x0ff);
189
        good = good && DeppGetReg(m_dev, 6, &retn, false); v = (v<<8)|(retn & 0x0ff);
190
        good = good && DeppGetReg(m_dev, 7, &retn, false); v = (v<<8)|(retn & 0x0ff);
191
        if (!good) {
192
                fprintf(stderr, "BUS CYCLE FAILED\n");
193
                depperr(); close();
194
                exit(EXIT_FAILURE);
195
        }
196
 
197
        return v;
198
}
199
 
200
void    DEPPBUS::readi(const BUSW a, const int len, BUSW *buf) {
201
        for(int i=0; i<len; i++)
202
                buf[i] = readio(a+i);
203
} void  DEPPBUS::readz(const BUSW a, const int len, BUSW *buf) {
204
        for(int i=0; i<len; i++)
205
                buf[i] = readio(a);
206
}
207
 
208
void    DEPPBUS::writei(const BUSW a, const int len, const BUSW *buf) {
209
        for(int i=0; i<len; i++)
210
                writeio(a+i, buf[i]);
211
} void  DEPPBUS::writez(const BUSW a, const int len, const BUSW *buf) {
212
        for(int i=0; i<len; i++)
213
                writeio(a, buf[i]);
214
}
215
 
216
bool    DEPPBUS::poll(void) {
217
        if (m_int)
218
                return true;
219
 
220
        // Check for any bus errors and/or interrupts
221
        BYTE    retn;
222
        DeppGetReg(m_dev,16, &retn, false);
223
        m_err = m_err | (retn&1);
224
        m_int = m_int | (retn&2);
225
 
226
        if (m_int)
227
                return true;
228
        return false;
229
} void  DEPPBUS::usleep(unsigned msec) {
230
        if (!poll())
231
                usleep(msec);
232
} void  DEPPBUS::wait(void) {
233
        while(!poll())
234
                usleep(5);
235
} bool  DEPPBUS::bus_err(void) const {
236
        return m_err;
237
} void  DEPPBUS::reset_err(void) {
238
        m_err = false;
239
} void  DEPPBUS::clear(void) {
240
        m_int = false;
241
        m_err = false;
242
}
243
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.