Mirror
/
ardupilot
mirror of https://github.com/ArduPilot/ardupilot
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ardupilot/libraries/AP_HAL_Linux/SPIDevice.h

108 lines
2.8 KiB
C
Raw Normal View History

AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
/// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
/*
* Copyright (C) 2015 Intel Corporation. All rights reserved.
*
* This file is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <inttypes.h>
AP_HAL_Linux: remove SPIDriver SPIDevice now controls all accesses to SPI bus.
2016-07-22 11:18:25 -03:00
#include <vector>
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
#include <AP_HAL/HAL.h>
#include <AP_HAL/SPIDevice.h>
namespace Linux {
class SPIBus;
AP_HAL_Linux: remove SPIDriver SPIDevice now controls all accesses to SPI bus.
2016-07-22 11:18:25 -03:00
class SPIDesc;
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
class SPIDevice : public AP_HAL::SPIDevice {
public:
AP_HAL_Linux: remove SPIDriver SPIDevice now controls all accesses to SPI bus.
2016-07-22 11:18:25 -03:00
SPIDevice(SPIBus &bus, SPIDesc &device_desc);
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
virtual ~SPIDevice();
/* AP_HAL::SPIDevice implementation */
/* See AP_HAL::Device::set_speed() */
bool set_speed(AP_HAL::Device::Speed speed) override;
/* See AP_HAL::Device::transfer() */
bool transfer(const uint8_t *send, uint32_t send_len,
uint8_t *recv, uint32_t recv_len) override;
AP_HAL_Linux: SPIDevice: implement fullduplex transfer
2016-07-22 01:50:10 -03:00
/* See AP_HAL::SPIDevice::transfer_fullduplex() */
bool transfer_fullduplex(const uint8_t *send, uint8_t *recv,
uint32_t len) override;
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
/* See AP_HAL::Device::get_semaphore() */
AP_HAL::Semaphore *get_semaphore() override;
/* See AP_HAL::Device::register_periodic_callback() */
AP_HAL_Linux: update Device interface
2016-07-19 09:44:52 -03:00
AP_HAL::Device::PeriodicHandle register_periodic_callback(
uint32_t period_usec, AP_HAL::Device::PeriodicCb) override
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
{
return nullptr;
}
/* See AP_HAL::Device::get_fd() */
int get_fd() override;
protected:
SPIBus &_bus;
AP_HAL_Linux: remove SPIDriver SPIDevice now controls all accesses to SPI bus.
2016-07-22 11:18:25 -03:00
SPIDesc &_desc;
AP_HAL::DigitalSource *_cs;
uint32_t _speed;
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
/*
* Select device if using userspace CS
*/
void _cs_assert();
/*
* Deselect device if using userspace CS
*/
void _cs_release();
};
AP_HAL_Linux: remove SPIDriver SPIDevice now controls all accesses to SPI bus.
2016-07-22 11:18:25 -03:00
class SPIDeviceManager : public AP_HAL::SPIDeviceManager {
public:
friend class SPIDevice;
static SPIDeviceManager *from(AP_HAL::SPIDeviceManager *spi_mgr)
{
return static_cast<SPIDeviceManager*>(spi_mgr);
}
SPIDeviceManager()
{
/* Reserve space up-front for 3 buses */
_buses.reserve(3);
}
AP_HAL::OwnPtr<AP_HAL::SPIDevice> get_device(const char *name);
protected:
void _unregister(SPIBus &b);
AP_HAL::OwnPtr<AP_HAL::SPIDevice> _create_device(SPIBus &b, SPIDesc &device_desc) const;
std::vector<SPIBus*> _buses;
static const uint8_t _n_device_desc;
static SPIDesc _device[];
};
AP_HAL_Linux: implement SPIDevice The way this code is structured is a little bit different from the SPIDriver implementation: - We only open the bus once, no matter how many devices we have in it - There's a single transfer() method which uses half-duplex mode instead of full duplex. The reason is that for all cases in the codebase we are using half-duplex transfers using the full-duplex API, i.e. a single SPI msg with both tx and rx buffers. This is cumbersome because the buffers need to be of the same size and the receive buffer using an offset of the same length as the actux data being written. This means the high level APIs need to copy buffers around. If later we have uses for a real full duplex case it's just a matter of adding another transfer_fullduplex() method or something like this. - The methods are implemented in the SPIDevice class instead of having proxy methods to SPIDeviceManager as is the case of SPIDriver Also from now on we refer to the SPIDriver objects as "descriptors" because they have the parameters of each device in the SPIDeviceManager::devices[] table. When SPIDeviceDriver is completely replaced we can rename them to SPIDeviceProperties.
2015-12-22 16:22:45 -04:00
}