README: Minor fixes, typos.
[pulseview.git] / pv / prop / binding / hwcap.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 #include <boost/bind.hpp>
22
23 #include "hwcap.h"
24
25 #include <pv/prop/enum.h>
26
27 using namespace boost;
28 using namespace std;
29
30 namespace pv {
31 namespace prop {
32 namespace binding {
33
34 HwCap::HwCap(struct sr_dev_inst *sdi) :
35         _sdi(sdi)
36 {
37         const int *hwcaps;
38
39         if ((sr_info_get(sdi->driver, SR_DI_HWCAPS, (const void **)&hwcaps,
40                         sdi) != SR_OK) || !hwcaps)
41                 /* Driver supports no device instance options. */
42                 return;
43
44         for (int cap = 0; hwcaps[cap]; cap++) {
45                 const struct sr_hwcap_option *const hwo =
46                         sr_devopt_get(hwcaps[cap]);
47
48                 if (!hwo)
49                         continue;
50
51                 switch(hwo->hwcap)
52                 {
53                 case SR_HWCAP_PATTERN_MODE:
54                         bind_stropt(hwo, SR_DI_PATTERNS,
55                                 SR_HWCAP_PATTERN_MODE);
56                         break;
57
58                 case SR_HWCAP_BUFFERSIZE:
59                         bind_buffer_size(hwo);
60                         break;
61
62                 case SR_HWCAP_TIMEBASE:
63                         bind_time_base(hwo);
64                         break;
65
66                 case SR_HWCAP_TRIGGER_SOURCE:
67                         bind_stropt(hwo, SR_DI_TRIGGER_SOURCES,
68                                 SR_HWCAP_TRIGGER_SOURCE);
69                         break;
70
71                 case SR_HWCAP_FILTER:
72                         bind_stropt(hwo, SR_DI_FILTERS, SR_HWCAP_FILTER);
73                         break;
74
75                 case SR_HWCAP_VDIV:
76                         bind_vdiv(hwo);
77                         break;
78
79                 case SR_HWCAP_COUPLING:
80                         bind_stropt(hwo, SR_DI_COUPLING, SR_HWCAP_FILTER);
81                         break;
82                 }
83         }
84 }
85
86 void HwCap::expose_enum(const struct sr_hwcap_option *hwo,
87         const vector< pair<const void*, QString> > &values, int opt)
88 {
89         _properties.push_back(shared_ptr<Property>(
90                 new Enum(QString(hwo->shortname), values,
91                         function<const void* ()>(),
92                         bind(sr_dev_config_set, _sdi, opt, _1))));
93 }
94
95 void HwCap::bind_stropt(const struct sr_hwcap_option *hwo, int id, int opt)
96 {
97         const char **stropts;
98         if (sr_info_get(_sdi->driver, id,
99                 (const void **)&stropts, _sdi) != SR_OK)
100                 return;
101
102         vector< pair<const void*, QString> > values;
103         for (int i = 0; stropts[i]; i++)
104                 values.push_back(make_pair(stropts[i], stropts[i]));
105
106         expose_enum(hwo, values, opt);
107 }
108
109 void HwCap::bind_buffer_size(const struct sr_hwcap_option *hwo)
110 {
111         const uint64_t *sizes;
112         if (sr_info_get(_sdi->driver, SR_DI_BUFFERSIZES,
113                         (const void **)&sizes, _sdi) != SR_OK)
114                 return;
115
116         vector< pair<const void*, QString> > values;
117         for (int i = 0; sizes[i]; i++)
118                 values.push_back(make_pair(sizes + i,
119                         QString("%1").arg(sizes[i])));
120
121         expose_enum(hwo, values, SR_HWCAP_BUFFERSIZE);
122 }
123
124 void HwCap::bind_time_base(const struct sr_hwcap_option *hwo)
125 {
126         struct sr_rational *timebases;
127         if (sr_info_get(_sdi->driver, SR_DI_TIMEBASES,
128                         (const void **)&timebases, _sdi) != SR_OK)
129                 return;
130
131         vector< pair<const void*, QString> > values;
132         for (int i = 0; timebases[i].p && timebases[i].q; i++)
133                 values.push_back(make_pair(timebases + i,
134                         QString(sr_period_string(
135                                 timebases[i].p * timebases[i].q))));
136
137         expose_enum(hwo, values, SR_HWCAP_TIMEBASE);
138 }
139
140 void HwCap::bind_vdiv(const struct sr_hwcap_option *hwo)
141 {
142         struct sr_rational *vdivs;
143         if (sr_info_get(_sdi->driver, SR_DI_VDIVS,
144                         (const void **)&vdivs, _sdi) != SR_OK)
145                 return;
146
147         vector< pair<const void*, QString> > values;
148         for (int i = 0; vdivs[i].p && vdivs[i].q; i++)
149                 values.push_back(make_pair(vdivs + i,
150                         QString(sr_voltage_string(vdivs + i))));
151
152         expose_enum(hwo, values, SR_HWCAP_VDIV);
153 }
154
155 } // binding
156 } // prop
157 } // pv
158