www.infradead.org Git - users/willy/pagecache.git/blob

1 /*

2 * sca3000_ring.c -- support VTI sca3000 series accelerometers via SPI

3 *

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

5 * under the terms of the GNU General Public License version 2 as published by

6 * the Free Software Foundation.

7 *

9 *

10 */

12 #include <linux/interrupt.h>

13 #include <linux/fs.h>

14 #include <linux/slab.h>

15 #include <linux/kernel.h>

16 #include <linux/spi/spi.h>

17 #include <linux/sysfs.h>

18 #include <linux/sched.h>

19 #include <linux/poll.h>

21 #include <linux/iio/iio.h>

22 #include <linux/iio/sysfs.h>

23 #include <linux/iio/buffer.h>

24 #include "../ring_hw.h"

25 #include "sca3000.h"

27 /* RFC / future work

28 *

29 * The internal ring buffer doesn't actually change what it holds depending

30 * on which signals are enabled etc, merely whether you can read them.

31 * As such the scan mode selection is somewhat different than for a software

32 * ring buffer and changing it actually covers any data already in the buffer.

33 * Currently scan elements aren't configured so it doesn't matter.

34 */

36 static int sca3000_read_data(struct sca3000_state *st,

37 uint8_t reg_address_high,

38 u8 **rx_p,

39 int len)

40 {

41 int ret;

42 struct spi_transfer xfer[2] = {

43 {

44 .len = 1,

45 .tx_buf = st->tx,

46 }, {

47 .len = len,

48 }

49 };

50 *rx_p = kmalloc(len, GFP_KERNEL);

51 if (*rx_p == NULL) {

52 ret = -ENOMEM;

53 goto error_ret;

54 }

55 xfer[1].rx_buf = *rx_p;

56 st->tx[0] = SCA3000_READ_REG(reg_address_high);

57 ret = spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer));

58 if (ret) {

59 dev_err(get_device(&st->us->dev), "problem reading register");

60 goto error_free_rx;

61 }

63 return 0;

64 error_free_rx:

65 kfree(*rx_p);

66 error_ret:

67 return ret;

68 }

70 /**

71 * sca3000_read_first_n_hw_rb() - main ring access, pulls data from ring

72 * @r: the ring

73 * @count: number of samples to try and pull

74 * @data: output the actual samples pulled from the hw ring

75 *

76 * Currently does not provide timestamps. As the hardware doesn't add them they

77 * can only be inferred approximately from ring buffer events such as 50% full

78 * and knowledge of when buffer was last emptied. This is left to userspace.

79 **/

80 static int sca3000_read_first_n_hw_rb(struct iio_buffer *r,

81 size_t count, char __user *buf)

82 {

83 struct iio_hw_buffer *hw_ring = iio_to_hw_buf(r);

84 struct iio_dev *indio_dev = hw_ring->private;

85 struct sca3000_state *st = iio_priv(indio_dev);

86 u8 *rx;

87 int ret, i, num_available, num_read = 0;

88 int bytes_per_sample = 1;

90 if (st->bpse == 11)

91 bytes_per_sample = 2;

93 mutex_lock(&st->lock);

94 if (count % bytes_per_sample) {

95 ret = -EINVAL;

96 goto error_ret;

97 }

99 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_BUF_COUNT, 1);

100 if (ret)

101 goto error_ret;

102 else

103 num_available = st->rx[0];

104 /*

105 * num_available is the total number of samples available

106 * i.e. number of time points * number of channels.

107 */

108 if (count > num_available * bytes_per_sample)

109 num_read = num_available*bytes_per_sample;

110 else

111 num_read = count;

112

113 ret = sca3000_read_data(st,

114 SCA3000_REG_ADDR_RING_OUT,

115 &rx, num_read);

116 if (ret)

117 goto error_ret;

118

119 for (i = 0; i < num_read; i++)

120 *(((u16 *)rx) + i) = be16_to_cpup((__be16 *)rx + i);

121

122 if (copy_to_user(buf, rx, num_read))

123 ret = -EFAULT;

124 kfree(rx);

125 r->stufftoread = 0;

126 error_ret:

127 mutex_unlock(&st->lock);

128

129 return ret ? ret : num_read;

130 }

131

132 /* This is only valid with all 3 elements enabled */

133 static int sca3000_ring_get_length(struct iio_buffer *r)

134 {

135 return 64;

136 }

137

138 /* only valid if resolution is kept at 11bits */

139 static int sca3000_ring_get_bytes_per_datum(struct iio_buffer *r)

140 {

141 return 6;

142 }

143

144 static bool sca3000_ring_buf_data_available(struct iio_buffer *r)

145 {

146 return r->stufftoread;

147 }

148

149 static IIO_BUFFER_ENABLE_ATTR;

150 static IIO_BUFFER_LENGTH_ATTR;

151

152 /**

153 * sca3000_query_ring_int() is the hardware ring status interrupt enabled

154 **/

155 static ssize_t sca3000_query_ring_int(struct device *dev,

156 struct device_attribute *attr,

157 char *buf)

158 {

159 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);

160 int ret, val;

161 struct iio_dev *indio_dev = dev_to_iio_dev(dev);

162 struct sca3000_state *st = iio_priv(indio_dev);

163

164 mutex_lock(&st->lock);

165 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);

166 val = st->rx[0];

167 mutex_unlock(&st->lock);

168 if (ret)

169 return ret;

170

171 return sprintf(buf, "%d\n", !!(val & this_attr->address));

172 }

173

174 /**

175 * sca3000_set_ring_int() set state of ring status interrupt

176 **/

177 static ssize_t sca3000_set_ring_int(struct device *dev,

178 struct device_attribute *attr,

179 const char *buf,

180 size_t len)

181 {

182 struct iio_dev *indio_dev = dev_to_iio_dev(dev);

183 struct sca3000_state *st = iio_priv(indio_dev);

184 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);

185 u8 val;

186 int ret;

187

188 mutex_lock(&st->lock);

189 ret = kstrtou8(buf, 10, &val);

190 if (ret)

191 goto error_ret;

192 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);

193 if (ret)

194 goto error_ret;

195 if (val)

196 ret = sca3000_write_reg(st,

197 SCA3000_REG_ADDR_INT_MASK,

198 st->rx[0] | this_attr->address);

199 else

200 ret = sca3000_write_reg(st,

201 SCA3000_REG_ADDR_INT_MASK,

202 st->rx[0] & ~this_attr->address);

203 error_ret:

204 mutex_unlock(&st->lock);

205

206 return ret ? ret : len;

207 }

208

209 static IIO_DEVICE_ATTR(50_percent, S_IRUGO | S_IWUSR,

210 sca3000_query_ring_int,

211 sca3000_set_ring_int,

212 SCA3000_INT_MASK_RING_HALF);

213

214 static IIO_DEVICE_ATTR(75_percent, S_IRUGO | S_IWUSR,

215 sca3000_query_ring_int,

216 sca3000_set_ring_int,

217 SCA3000_INT_MASK_RING_THREE_QUARTER);

218

219 static ssize_t sca3000_show_buffer_scale(struct device *dev,

220 struct device_attribute *attr,

221 char *buf)

222 {

223 struct iio_dev *indio_dev = dev_to_iio_dev(dev);

224 struct sca3000_state *st = iio_priv(indio_dev);

225

226 return sprintf(buf, "0.%06d\n", 4*st->info->scale);

227 }

228

229 static IIO_DEVICE_ATTR(in_accel_scale,

230 S_IRUGO,

231 sca3000_show_buffer_scale,

232 NULL,

233 0);

234

235 /*

236 * Ring buffer attributes

237 * This device is a bit unusual in that the sampling frequency and bpse

238 * only apply to the ring buffer. At all times full rate and accuracy

239 * is available via direct reading from registers.

240 */

241 static struct attribute *sca3000_ring_attributes[] = {

242 &dev_attr_length.attr,

243 &dev_attr_enable.attr,

244 &iio_dev_attr_50_percent.dev_attr.attr,

245 &iio_dev_attr_75_percent.dev_attr.attr,

246 &iio_dev_attr_in_accel_scale.dev_attr.attr,

247 NULL,

248 };

249

250 static struct attribute_group sca3000_ring_attr = {

251 .attrs = sca3000_ring_attributes,

252 .name = "buffer",

253 };

254

255 static struct iio_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev)

256 {

257 struct iio_buffer *buf;

258 struct iio_hw_buffer *ring;

259

260 ring = kzalloc(sizeof(*ring), GFP_KERNEL);

261 if (!ring)

262 return NULL;

263

264 ring->private = indio_dev;

265 buf = &ring->buf;

266 buf->stufftoread = 0;

267 buf->attrs = &sca3000_ring_attr;

268 iio_buffer_init(buf);

269

270 return buf;

271 }

272

273 static void sca3000_ring_release(struct iio_buffer *r)

274 {

275 kfree(iio_to_hw_buf(r));

276 }

277

278 static const struct iio_buffer_access_funcs sca3000_ring_access_funcs = {

279 .read_first_n = &sca3000_read_first_n_hw_rb,

280 .get_length = &sca3000_ring_get_length,

281 .get_bytes_per_datum = &sca3000_ring_get_bytes_per_datum,

282 .data_available = sca3000_ring_buf_data_available,

283 .release = sca3000_ring_release,

284 };

285

286 int sca3000_configure_ring(struct iio_dev *indio_dev)

287 {

288 struct iio_buffer *buffer;

289

290 buffer = sca3000_rb_allocate(indio_dev);

291 if (buffer == NULL)

292 return -ENOMEM;

293 indio_dev->modes |= INDIO_BUFFER_HARDWARE;

294

295 indio_dev->buffer->access = &sca3000_ring_access_funcs;

296

297 iio_device_attach_buffer(indio_dev, buffer);

298

299 return 0;

300 }

301

302 void sca3000_unconfigure_ring(struct iio_dev *indio_dev)

303 {

304 iio_buffer_put(indio_dev->buffer);

305 }

306

307 static inline

308 int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state)

309 {

310 struct sca3000_state *st = iio_priv(indio_dev);

311 int ret;

312

313 mutex_lock(&st->lock);

314 ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);

315 if (ret)

316 goto error_ret;

317 if (state) {

318 dev_info(&indio_dev->dev, "supposedly enabling ring buffer\n");

319 ret = sca3000_write_reg(st,

320 SCA3000_REG_ADDR_MODE,

321 (st->rx[0] | SCA3000_RING_BUF_ENABLE));

322 } else

323 ret = sca3000_write_reg(st,

324 SCA3000_REG_ADDR_MODE,

325 (st->rx[0] & ~SCA3000_RING_BUF_ENABLE));

326 error_ret:

327 mutex_unlock(&st->lock);

328

329 return ret;

330 }

331 /**

332 * sca3000_hw_ring_preenable() hw ring buffer preenable function

333 *

334 * Very simple enable function as the chip will allows normal reads

335 * during ring buffer operation so as long as it is indeed running

336 * before we notify the core, the precise ordering does not matter.

337 **/

338 static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev)

339 {

340 return __sca3000_hw_ring_state_set(indio_dev, 1);

341 }

342

343 static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev)

344 {

345 return __sca3000_hw_ring_state_set(indio_dev, 0);

346 }

347

348 static const struct iio_buffer_setup_ops sca3000_ring_setup_ops = {

349 .preenable = &sca3000_hw_ring_preenable,

350 .postdisable = &sca3000_hw_ring_postdisable,

351 };

352

353 void sca3000_register_ring_funcs(struct iio_dev *indio_dev)

354 {

355 indio_dev->setup_ops = &sca3000_ring_setup_ops;

356 }

357

358 /**

359 * sca3000_ring_int_process() ring specific interrupt handling.

360 *

361 * This is only split from the main interrupt handler so as to

362 * reduce the amount of code if the ring buffer is not enabled.

363 **/

364 void sca3000_ring_int_process(u8 val, struct iio_buffer *ring)

365 {

366 if (val & (SCA3000_INT_STATUS_THREE_QUARTERS |

367 SCA3000_INT_STATUS_HALF)) {

368 ring->stufftoread = true;

369 wake_up_interruptible(&ring->pollq);

370 }

371 }