dosfun/sb_detect.cpp at master · usrlocalben/dosfun · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include "sb_detect.hpp"

#include <cstdlib>

// using std::cout;

namespace rqdq {
namespace {

int hexToDec(char ch) {
	if ('0' <= ch && ch <= '9') {
		return ch - '0'; }
	/*if ('a' <= ch && ch <= 'f') {
		return ch - 'a' + 10; }*/
	if ('A' <= ch && ch <= 'F') {
		return ch - 'A' + 10; }
	std::exit(1); }


char toupper(char ch) {
	if ('a' <= ch && ch <= 'z') {
		return 'A' + (ch - 'a'); }
	return ch; }


}  // namespace

namespace hw {

BlasterSerializer::BlasterSerializer(const char *data)
	:params_(-1,-1,-1,-1), valid_(-1), curField_(0), ax_(0), base_(10) {
	if (data != NULL) {
		Deserialize(data); }}


void BlasterSerializer::Deserialize(const char* text) {
	for (; *text!=0; text++) {
		const char ch = toupper(*text);
		if (ch == 'A') {
			curField_ = ch;
			base_ = 16; }
		else if (ch == 'I') {
			curField_ = ch;
			base_ = 10; }
		else if (ch == 'D') {
			curField_ = ch;
			base_ = 10; }
		else if (ch == 'H') {
			curField_ = ch;
			base_ = 10; }
		else if (ch == ' ') {
			MaybeSaveCurrentField(); }
		else {
			if (base_ == 10) {
				ax_ = ax_*10 + ch - '0'; }
			else {
				ax_ = ax_*16 + hexToDec(ch); }}}
	MaybeSaveCurrentField(); }


void BlasterSerializer::MaybeSaveCurrentField() {
	if (curField_ == 'A') {
		params_.ioAddr = ax_; }
	else if (curField_ == 'I') {
		params_.irqNum = ax_; }
	else if (curField_ == 'D') {
		params_.dmaLow = ax_; }
	else if (curField_ == 'H') {
		params_.dmaHigh = ax_; }
	curField_ = 0;
	ax_ = 0;
	base_ = 10; }


bool BlasterSerializer::IsValid() {
	if (valid_ != -1) {
// cout << "already validated, valid_==" << valid_ << "\n";
		return valid_ == 1; }

	const int ioAddr = params_.ioAddr;
	const int irqNum = params_.irqNum;
	const int dmaLow = params_.dmaLow;
	const int dmaHigh = params_.dmaHigh;

	if (!(0x200 <= ioAddr && ioAddr < 0x300)) {
		// not a reasonable looking io base addr
// cout << "bad ioaddr\n";
		valid_ = 0; return false; }
	if (!(3 <= irqNum && irqNum <= 15)) {
		// not a reasonable looking irq num
// cout << "bad irqnum\n";
		valid_ = 0; return false; }
	if (!(dmaLow != -1 || dmaHigh != -1)) {
		// must have at least one dma value
// cout << "no dma values\n";
		valid_ = 0; return false; }
	if (dmaLow != -1) {
		if (!(1 <= dmaLow && dmaLow <= 3)) {
// cout << "dmalow is set but bad\n";
			valid_ = 0; return false; }}
	if (dmaHigh != -1) {
		if (!(5 <= dmaHigh && dmaHigh <= 7)) {
// cout << "dmahigh is set but bad\n";
			valid_ = 0; return false; }}
// cout << "seems valid to me\n";
	valid_ = 1;
	return true; }


BlasterDetectResult DetectBlaster() {
	char* blasterStr = std::getenv("BLASTER");
	if (blasterStr != NULL) {
// cout << "blaster is \"" << blasterStr << "\"\n";
		BlasterSerializer serializer(/*data=*/blasterStr);
		if (serializer.IsValid()) {
// cout << "serializer is valid\n";
			return BlasterDetectResult( true, serializer.Save() ); }}

	return BlasterDetectResult( false, BlasterParams() ); }


}  // namespace hw
}  // namespace rqdq