Skip to content

L
linux
Commit 6f85a703 authored by Shahar Avidar's avatar Shahar Avidar Committed by Greg Kroah-Hartman
Browse files
Options

staging: pi433: Rename struct pi433_device instances to pi433. 

Just as other devices use specific names for instantiation,
struct_pi433 should also have a distinct name.
Moreover, some other structs use the "dev" or "device" in their naming
conventions for members, which can be confusing.
Signed-off-by: default avatarShahar Avidar <ikobh7@gmail.com>
Reviewed-by: default avatarDan Carpenter <dan.carpenter@linaro.org>
Link: https://lore.kernel.org/r/20240405074000.3481217-3-ikobh7@gmail.comSigned-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 80f91c82
Hide whitespace changes
Inline Side-by-side
Showing with 327 additions and 327 deletions
drivers/staging/pi433/pi433_if.c
View file @ 6f85a703
...@@ -112,7 +112,7 @@ struct pi433_device { ...@@ -112,7 +112,7 @@ struct pi433_device {
}; };
struct pi433_instance { struct pi433_instance {
struct pi433_device *device; struct pi433_device *pi433;
struct pi433_tx_cfg tx_cfg; struct pi433_tx_cfg tx_cfg;
/* control flags */ /* control flags */
...@@ -124,19 +124,19 @@ struct pi433_instance { ...@@ -124,19 +124,19 @@ struct pi433_instance {
/* GPIO interrupt handlers */ /* GPIO interrupt handlers */
static irqreturn_t DIO0_irq_handler(int irq, void *dev_id) static irqreturn_t DIO0_irq_handler(int irq, void *dev_id)
{ {
struct pi433_device *device = dev_id; struct pi433_device *pi433 = dev_id;
if (device->irq_state[DIO0] == DIO_PACKET_SENT) { if (pi433->irq_state[DIO0] == DIO_PACKET_SENT) {
device->free_in_fifo = FIFO_SIZE; pi433->free_in_fifo = FIFO_SIZE;
dev_dbg(device->dev, "DIO0 irq: Packet sent\n"); dev_dbg(pi433->dev, "DIO0 irq: Packet sent\n");
wake_up_interruptible(&device->fifo_wait_queue); wake_up_interruptible(&pi433->fifo_wait_queue);
} else if (device->irq_state[DIO0] == DIO_RSSI_DIO0) { } else if (pi433->irq_state[DIO0] == DIO_RSSI_DIO0) {
dev_dbg(device->dev, "DIO0 irq: RSSI level over threshold\n"); dev_dbg(pi433->dev, "DIO0 irq: RSSI level over threshold\n");
wake_up_interruptible(&device->rx_wait_queue); wake_up_interruptible(&pi433->rx_wait_queue);
} else if (device->irq_state[DIO0] == DIO_PAYLOAD_READY) { } else if (pi433->irq_state[DIO0] == DIO_PAYLOAD_READY) {
dev_dbg(device->dev, "DIO0 irq: Payload ready\n"); dev_dbg(pi433->dev, "DIO0 irq: Payload ready\n");
device->free_in_fifo = 0; pi433->free_in_fifo = 0;
wake_up_interruptible(&device->fifo_wait_queue); wake_up_interruptible(&pi433->fifo_wait_queue);
} }
return IRQ_HANDLED; return IRQ_HANDLED;
...@@ -144,19 +144,19 @@ static irqreturn_t DIO0_irq_handler(int irq, void *dev_id) ...@@ -144,19 +144,19 @@ static irqreturn_t DIO0_irq_handler(int irq, void *dev_id)
static irqreturn_t DIO1_irq_handler(int irq, void *dev_id) static irqreturn_t DIO1_irq_handler(int irq, void *dev_id)
{ {
struct pi433_device *device = dev_id; struct pi433_device *pi433 = dev_id;
if (device->irq_state[DIO1] == DIO_FIFO_NOT_EMPTY_DIO1) { if (pi433->irq_state[DIO1] == DIO_FIFO_NOT_EMPTY_DIO1) {
device->free_in_fifo = FIFO_SIZE; pi433->free_in_fifo = FIFO_SIZE;
} else if (device->irq_state[DIO1] == DIO_FIFO_LEVEL) { } else if (pi433->irq_state[DIO1] == DIO_FIFO_LEVEL) {
if (device->rx_active) if (pi433->rx_active)
device->free_in_fifo = FIFO_THRESHOLD - 1; pi433->free_in_fifo = FIFO_THRESHOLD - 1;
else else
device->free_in_fifo = FIFO_SIZE - FIFO_THRESHOLD - 1; pi433->free_in_fifo = FIFO_SIZE - FIFO_THRESHOLD - 1;
} }
dev_dbg(device->dev, dev_dbg(pi433->dev,
"DIO1 irq: %d bytes free in fifo\n", device->free_in_fifo); "DIO1 irq: %d bytes free in fifo\n", pi433->free_in_fifo);
wake_up_interruptible(&device->fifo_wait_queue); wake_up_interruptible(&pi433->fifo_wait_queue);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
...@@ -164,94 +164,94 @@ static irqreturn_t DIO1_irq_handler(int irq, void *dev_id) ...@@ -164,94 +164,94 @@ static irqreturn_t DIO1_irq_handler(int irq, void *dev_id)
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int static int
rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg) rf69_set_rx_cfg(struct pi433_device *pi433, struct pi433_rx_cfg *rx_cfg)
{ {
int ret; int ret;
int payload_length; int payload_length;
/* receiver config */ /* receiver config */
ret = rf69_set_frequency(dev->spi, rx_cfg->frequency); ret = rf69_set_frequency(pi433->spi, rx_cfg->frequency);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_modulation(dev->spi, rx_cfg->modulation); ret = rf69_set_modulation(pi433->spi, rx_cfg->modulation);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_bit_rate(dev->spi, rx_cfg->bit_rate); ret = rf69_set_bit_rate(pi433->spi, rx_cfg->bit_rate);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_antenna_impedance(dev->spi, rx_cfg->antenna_impedance); ret = rf69_set_antenna_impedance(pi433->spi, rx_cfg->antenna_impedance);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_rssi_threshold(dev->spi, rx_cfg->rssi_threshold); ret = rf69_set_rssi_threshold(pi433->spi, rx_cfg->rssi_threshold);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_ook_threshold_dec(dev->spi, rx_cfg->threshold_decrement); ret = rf69_set_ook_threshold_dec(pi433->spi, rx_cfg->threshold_decrement);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_bandwidth(dev->spi, rx_cfg->bw_mantisse, ret = rf69_set_bandwidth(pi433->spi, rx_cfg->bw_mantisse,
rx_cfg->bw_exponent); rx_cfg->bw_exponent);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_bandwidth_during_afc(dev->spi, rx_cfg->bw_mantisse, ret = rf69_set_bandwidth_during_afc(pi433->spi, rx_cfg->bw_mantisse,
rx_cfg->bw_exponent); rx_cfg->bw_exponent);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_dagc(dev->spi, rx_cfg->dagc); ret = rf69_set_dagc(pi433->spi, rx_cfg->dagc);
if (ret < 0) if (ret < 0)
return ret; return ret;
dev->rx_bytes_to_drop = rx_cfg->bytes_to_drop; pi433->rx_bytes_to_drop = rx_cfg->bytes_to_drop;
/* packet config */ /* packet config */
/* enable */ /* enable */
if (rx_cfg->enable_sync == OPTION_ON) { if (rx_cfg->enable_sync == OPTION_ON) {
ret = rf69_enable_sync(dev->spi); ret = rf69_enable_sync(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_fifo_fill_condition(dev->spi, ret = rf69_set_fifo_fill_condition(pi433->spi,
after_sync_interrupt); after_sync_interrupt);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_disable_sync(dev->spi); ret = rf69_disable_sync(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_fifo_fill_condition(dev->spi, always); ret = rf69_set_fifo_fill_condition(pi433->spi, always);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (rx_cfg->enable_length_byte == OPTION_ON) { if (rx_cfg->enable_length_byte == OPTION_ON) {
ret = rf69_set_packet_format(dev->spi, packet_length_var); ret = rf69_set_packet_format(pi433->spi, packet_length_var);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_set_packet_format(dev->spi, packet_length_fix); ret = rf69_set_packet_format(pi433->spi, packet_length_fix);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
ret = rf69_set_address_filtering(dev->spi, ret = rf69_set_address_filtering(pi433->spi,
rx_cfg->enable_address_filtering); rx_cfg->enable_address_filtering);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (rx_cfg->enable_crc == OPTION_ON) { if (rx_cfg->enable_crc == OPTION_ON) {
ret = rf69_enable_crc(dev->spi); ret = rf69_enable_crc(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_disable_crc(dev->spi); ret = rf69_disable_crc(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
/* lengths */ /* lengths */
ret = rf69_set_sync_size(dev->spi, rx_cfg->sync_length); ret = rf69_set_sync_size(pi433->spi, rx_cfg->sync_length);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (rx_cfg->enable_length_byte == OPTION_ON) { if (rx_cfg->enable_length_byte == OPTION_ON) {
ret = rf69_set_payload_length(dev->spi, 0xff); ret = rf69_set_payload_length(pi433->spi, 0xff);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else if (rx_cfg->fixed_message_length != 0) { } else if (rx_cfg->fixed_message_length != 0) {
...@@ -260,26 +260,26 @@ rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg) ...@@ -260,26 +260,26 @@ rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg)
payload_length++; payload_length++;
if (rx_cfg->enable_address_filtering != filtering_off) if (rx_cfg->enable_address_filtering != filtering_off)
payload_length++; payload_length++;
ret = rf69_set_payload_length(dev->spi, payload_length); ret = rf69_set_payload_length(pi433->spi, payload_length);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_set_payload_length(dev->spi, 0); ret = rf69_set_payload_length(pi433->spi, 0);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
/* values */ /* values */
if (rx_cfg->enable_sync == OPTION_ON) { if (rx_cfg->enable_sync == OPTION_ON) {
ret = rf69_set_sync_values(dev->spi, rx_cfg->sync_pattern); ret = rf69_set_sync_values(pi433->spi, rx_cfg->sync_pattern);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (rx_cfg->enable_address_filtering != filtering_off) { if (rx_cfg->enable_address_filtering != filtering_off) {
ret = rf69_set_node_address(dev->spi, rx_cfg->node_address); ret = rf69_set_node_address(pi433->spi, rx_cfg->node_address);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_broadcast_address(dev->spi, ret = rf69_set_broadcast_address(pi433->spi,
rx_cfg->broadcast_address); rx_cfg->broadcast_address);
if (ret < 0) if (ret < 0)
return ret; return ret;
...@@ -289,76 +289,76 @@ rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg) ...@@ -289,76 +289,76 @@ rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg)
} }
static int static int
rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg) rf69_set_tx_cfg(struct pi433_device *pi433, struct pi433_tx_cfg *tx_cfg)
{ {
int ret; int ret;
ret = rf69_set_frequency(dev->spi, tx_cfg->frequency); ret = rf69_set_frequency(pi433->spi, tx_cfg->frequency);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_modulation(dev->spi, tx_cfg->modulation); ret = rf69_set_modulation(pi433->spi, tx_cfg->modulation);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_bit_rate(dev->spi, tx_cfg->bit_rate); ret = rf69_set_bit_rate(pi433->spi, tx_cfg->bit_rate);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_deviation(dev->spi, tx_cfg->dev_frequency); ret = rf69_set_deviation(pi433->spi, tx_cfg->dev_frequency);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_pa_ramp(dev->spi, tx_cfg->pa_ramp); ret = rf69_set_pa_ramp(pi433->spi, tx_cfg->pa_ramp);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_modulation_shaping(dev->spi, tx_cfg->mod_shaping); ret = rf69_set_modulation_shaping(pi433->spi, tx_cfg->mod_shaping);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_tx_start_condition(dev->spi, tx_cfg->tx_start_condition); ret = rf69_set_tx_start_condition(pi433->spi, tx_cfg->tx_start_condition);
if (ret < 0) if (ret < 0)
return ret; return ret;
/* packet format enable */ /* packet format enable */
if (tx_cfg->enable_preamble == OPTION_ON) { if (tx_cfg->enable_preamble == OPTION_ON) {
ret = rf69_set_preamble_length(dev->spi, ret = rf69_set_preamble_length(pi433->spi,
tx_cfg->preamble_length); tx_cfg->preamble_length);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_set_preamble_length(dev->spi, 0); ret = rf69_set_preamble_length(pi433->spi, 0);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (tx_cfg->enable_sync == OPTION_ON) { if (tx_cfg->enable_sync == OPTION_ON) {
ret = rf69_set_sync_size(dev->spi, tx_cfg->sync_length); ret = rf69_set_sync_size(pi433->spi, tx_cfg->sync_length);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern); ret = rf69_set_sync_values(pi433->spi, tx_cfg->sync_pattern);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = rf69_enable_sync(dev->spi); ret = rf69_enable_sync(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_disable_sync(dev->spi); ret = rf69_disable_sync(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (tx_cfg->enable_length_byte == OPTION_ON) { if (tx_cfg->enable_length_byte == OPTION_ON) {
ret = rf69_set_packet_format(dev->spi, packet_length_var); ret = rf69_set_packet_format(pi433->spi, packet_length_var);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_set_packet_format(dev->spi, packet_length_fix); ret = rf69_set_packet_format(pi433->spi, packet_length_fix);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (tx_cfg->enable_crc == OPTION_ON) { if (tx_cfg->enable_crc == OPTION_ON) {
ret = rf69_enable_crc(dev->spi); ret = rf69_enable_crc(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else { } else {
ret = rf69_disable_crc(dev->spi); ret = rf69_disable_crc(pi433->spi);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
...@@ -368,38 +368,38 @@ rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg) ...@@ -368,38 +368,38 @@ rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg)
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int pi433_start_rx(struct pi433_device *dev) static int pi433_start_rx(struct pi433_device *pi433)
{ {
int retval; int retval;
/* return without action, if no pending read request */ /* return without action, if no pending read request */
if (!dev->rx_active) if (!pi433->rx_active)
return 0; return 0;
/* setup for receiving */ /* setup for receiving */
retval = rf69_set_rx_cfg(dev, &dev->rx_cfg); retval = rf69_set_rx_cfg(pi433, &pi433->rx_cfg);
if (retval) if (retval)
return retval; return retval;
/* setup rssi irq */ /* setup rssi irq */
retval = rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0); retval = rf69_set_dio_mapping(pi433->spi, DIO0, DIO_RSSI_DIO0);
if (retval < 0) if (retval < 0)
return retval; return retval;
dev->irq_state[DIO0] = DIO_RSSI_DIO0; pi433->irq_state[DIO0] = DIO_RSSI_DIO0;
irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); irq_set_irq_type(pi433->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
/* setup fifo level interrupt */ /* setup fifo level interrupt */
retval = rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD); retval = rf69_set_fifo_threshold(pi433->spi, FIFO_SIZE - FIFO_THRESHOLD);
if (retval < 0) if (retval < 0)
return retval; return retval;
retval = rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL); retval = rf69_set_dio_mapping(pi433->spi, DIO1, DIO_FIFO_LEVEL);
if (retval < 0) if (retval < 0)
return retval; return retval;
dev->irq_state[DIO1] = DIO_FIFO_LEVEL; pi433->irq_state[DIO1] = DIO_FIFO_LEVEL;
irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING); irq_set_irq_type(pi433->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);
/* set module to receiving mode */ /* set module to receiving mode */
retval = rf69_set_mode(dev->spi, receive); retval = rf69_set_mode(pi433->spi, receive);
if (retval < 0) if (retval < 0)
return retval; return retval;
...@@ -410,50 +410,50 @@ static int pi433_start_rx(struct pi433_device *dev) ...@@ -410,50 +410,50 @@ static int pi433_start_rx(struct pi433_device *dev)
static int pi433_receive(void *data) static int pi433_receive(void *data)
{ {
struct pi433_device *dev = data; struct pi433_device *pi433 = data;
struct spi_device *spi = dev->spi; struct spi_device *spi = pi433->spi;
int bytes_to_read, bytes_total; int bytes_to_read, bytes_total;
int retval; int retval;
dev->interrupt_rx_allowed = false; pi433->interrupt_rx_allowed = false;
/* wait for any tx to finish */ /* wait for any tx to finish */
dev_dbg(dev->dev, "rx: going to wait for any tx to finish\n"); dev_dbg(pi433->dev, "rx: going to wait for any tx to finish\n");
retval = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active); retval = wait_event_interruptible(pi433->rx_wait_queue, !pi433->tx_active);
if (retval) { if (retval) {
/* wait was interrupted */ /* wait was interrupted */
dev->interrupt_rx_allowed = true; pi433->interrupt_rx_allowed = true;
wake_up_interruptible(&dev->tx_wait_queue); wake_up_interruptible(&pi433->tx_wait_queue);
return retval; return retval;
} }
/* prepare status vars */ /* prepare status vars */
dev->free_in_fifo = FIFO_SIZE; pi433->free_in_fifo = FIFO_SIZE;
dev->rx_position = 0; pi433->rx_position = 0;
dev->rx_bytes_dropped = 0; pi433->rx_bytes_dropped = 0;
/* setup radio module to listen for something "in the air" */ /* setup radio module to listen for something "in the air" */
retval = pi433_start_rx(dev); retval = pi433_start_rx(pi433);
if (retval) if (retval)
return retval; return retval;
/* now check RSSI, if low wait for getting high (RSSI interrupt) */ /* now check RSSI, if low wait for getting high (RSSI interrupt) */
while (!(rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI)) { while (!(rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI)) {
/* allow tx to interrupt us while waiting for high RSSI */ /* allow tx to interrupt us while waiting for high RSSI */
dev->interrupt_rx_allowed = true; pi433->interrupt_rx_allowed = true;
wake_up_interruptible(&dev->tx_wait_queue); wake_up_interruptible(&pi433->tx_wait_queue);
/* wait for RSSI level to become high */ /* wait for RSSI level to become high */
dev_dbg(dev->dev, "rx: going to wait for high RSSI level\n"); dev_dbg(pi433->dev, "rx: going to wait for high RSSI level\n");
retval = wait_event_interruptible(dev->rx_wait_queue, retval = wait_event_interruptible(pi433->rx_wait_queue,
rf69_read_reg(spi, REG_IRQFLAGS1) & rf69_read_reg(spi, REG_IRQFLAGS1) &
MASK_IRQFLAGS1_RSSI); MASK_IRQFLAGS1_RSSI);
if (retval) /* wait was interrupted */ if (retval) /* wait was interrupted */
goto abort; goto abort;
dev->interrupt_rx_allowed = false; pi433->interrupt_rx_allowed = false;
/* cross check for ongoing tx */ /* cross check for ongoing tx */
if (!dev->tx_active) if (!pi433->tx_active)
break; break;
} }
...@@ -461,97 +461,97 @@ static int pi433_receive(void *data) ...@@ -461,97 +461,97 @@ static int pi433_receive(void *data)
retval = rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY); retval = rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY);
if (retval < 0) if (retval < 0)
goto abort; goto abort;
dev->irq_state[DIO0] = DIO_PAYLOAD_READY; pi433->irq_state[DIO0] = DIO_PAYLOAD_READY;
irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); irq_set_irq_type(pi433->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
/* fixed or unlimited length? */ /* fixed or unlimited length? */
if (dev->rx_cfg.fixed_message_length != 0) { if (pi433->rx_cfg.fixed_message_length != 0) {
if (dev->rx_cfg.fixed_message_length > dev->rx_buffer_size) { if (pi433->rx_cfg.fixed_message_length > pi433->rx_buffer_size) {
retval = -1; retval = -1;
goto abort; goto abort;
} }
bytes_total = dev->rx_cfg.fixed_message_length; bytes_total = pi433->rx_cfg.fixed_message_length;
dev_dbg(dev->dev, "rx: msg len set to %d by fixed length\n", dev_dbg(pi433->dev, "rx: msg len set to %d by fixed length\n",
bytes_total); bytes_total);
} else { } else {
bytes_total = dev->rx_buffer_size; bytes_total = pi433->rx_buffer_size;
dev_dbg(dev->dev, "rx: msg len set to %d as requested by read\n", dev_dbg(pi433->dev, "rx: msg len set to %d as requested by read\n",
bytes_total); bytes_total);
} }
/* length byte enabled? */ /* length byte enabled? */
if (dev->rx_cfg.enable_length_byte == OPTION_ON) { if (pi433->rx_cfg.enable_length_byte == OPTION_ON) {
retval = wait_event_interruptible(dev->fifo_wait_queue, retval = wait_event_interruptible(pi433->fifo_wait_queue,
dev->free_in_fifo < FIFO_SIZE); pi433->free_in_fifo < FIFO_SIZE);
if (retval) /* wait was interrupted */ if (retval) /* wait was interrupted */
goto abort; goto abort;
rf69_read_fifo(spi, (u8 *)&bytes_total, 1); rf69_read_fifo(spi, (u8 *)&bytes_total, 1);
if (bytes_total > dev->rx_buffer_size) { if (bytes_total > pi433->rx_buffer_size) {
retval = -1; retval = -1;
goto abort; goto abort;
} }
dev->free_in_fifo++; pi433->free_in_fifo++;
dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte\n", dev_dbg(pi433->dev, "rx: msg len reset to %d due to length byte\n",
bytes_total); bytes_total);
} }
/* address byte enabled? */ /* address byte enabled? */
if (dev->rx_cfg.enable_address_filtering != filtering_off) { if (pi433->rx_cfg.enable_address_filtering != filtering_off) {
u8 dummy; u8 dummy;
bytes_total--; bytes_total--;
retval = wait_event_interruptible(dev->fifo_wait_queue, retval = wait_event_interruptible(pi433->fifo_wait_queue,
dev->free_in_fifo < FIFO_SIZE); pi433->free_in_fifo < FIFO_SIZE);
if (retval) /* wait was interrupted */ if (retval) /* wait was interrupted */
goto abort; goto abort;
rf69_read_fifo(spi, &dummy, 1); rf69_read_fifo(spi, &dummy, 1);
dev->free_in_fifo++; pi433->free_in_fifo++;
dev_dbg(dev->dev, "rx: address byte stripped off\n"); dev_dbg(pi433->dev, "rx: address byte stripped off\n");
} }
/* get payload */ /* get payload */
while (dev->rx_position < bytes_total) { while (pi433->rx_position < bytes_total) {
if (!(rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_PAYLOAD_READY)) { if (!(rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_PAYLOAD_READY)) {
retval = wait_event_interruptible(dev->fifo_wait_queue, retval = wait_event_interruptible(pi433->fifo_wait_queue,
dev->free_in_fifo < FIFO_SIZE); pi433->free_in_fifo < FIFO_SIZE);
if (retval) /* wait was interrupted */ if (retval) /* wait was interrupted */
goto abort; goto abort;
} }
/* need to drop bytes or acquire? */ /* need to drop bytes or acquire? */
if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped) if (pi433->rx_bytes_to_drop > pi433->rx_bytes_dropped)
bytes_to_read = dev->rx_bytes_to_drop - bytes_to_read = pi433->rx_bytes_to_drop -
dev->rx_bytes_dropped; pi433->rx_bytes_dropped;
else else
bytes_to_read = bytes_total - dev->rx_position; bytes_to_read = bytes_total - pi433->rx_position;
/* access the fifo */ /* access the fifo */
if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo) if (bytes_to_read > FIFO_SIZE - pi433->free_in_fifo)
bytes_to_read = FIFO_SIZE - dev->free_in_fifo; bytes_to_read = FIFO_SIZE - pi433->free_in_fifo;
retval = rf69_read_fifo(spi, retval = rf69_read_fifo(spi,
&dev->rx_buffer[dev->rx_position], &pi433->rx_buffer[pi433->rx_position],
bytes_to_read); bytes_to_read);
if (retval) /* read failed */ if (retval) /* read failed */
goto abort; goto abort;
dev->free_in_fifo += bytes_to_read; pi433->free_in_fifo += bytes_to_read;
/* adjust status vars */ /* adjust status vars */
if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped) if (pi433->rx_bytes_to_drop > pi433->rx_bytes_dropped)
dev->rx_bytes_dropped += bytes_to_read; pi433->rx_bytes_dropped += bytes_to_read;
else else
dev->rx_position += bytes_to_read; pi433->rx_position += bytes_to_read;
} }
/* rx done, wait was interrupted or error occurred */ /* rx done, wait was interrupted or error occurred */
abort: abort:
dev->interrupt_rx_allowed = true; pi433->interrupt_rx_allowed = true;
if (rf69_set_mode(dev->spi, standby)) if (rf69_set_mode(pi433->spi, standby))
pr_err("rf69_set_mode(): radio module failed to go standby\n"); pr_err("rf69_set_mode(): radio module failed to go standby\n");
wake_up_interruptible(&dev->tx_wait_queue); wake_up_interruptible(&pi433->tx_wait_queue);
if (retval) if (retval)
return retval; return retval;
...@@ -561,8 +561,8 @@ static int pi433_receive(void *data) ...@@ -561,8 +561,8 @@ static int pi433_receive(void *data)
static int pi433_tx_thread(void *data) static int pi433_tx_thread(void *data)
{ {
struct pi433_device *device = data; struct pi433_device *pi433 = data;
struct spi_device *spi = device->spi; struct spi_device *spi = pi433->spi;
struct pi433_tx_cfg tx_cfg; struct pi433_tx_cfg tx_cfg;
size_t size; size_t size;
bool rx_interrupted = false; bool rx_interrupted = false;
...@@ -571,9 +571,9 @@ static int pi433_tx_thread(void *data) ...@@ -571,9 +571,9 @@ static int pi433_tx_thread(void *data)
while (1) { while (1) {
/* wait for fifo to be populated or for request to terminate*/ /* wait for fifo to be populated or for request to terminate*/
dev_dbg(device->dev, "thread: going to wait for new messages\n"); dev_dbg(pi433->dev, "thread: going to wait for new messages\n");
wait_event_interruptible(device->tx_wait_queue, wait_event_interruptible(pi433->tx_wait_queue,
(!kfifo_is_empty(&device->tx_fifo) || (!kfifo_is_empty(&pi433->tx_fifo) ||
kthread_should_stop())); kthread_should_stop()));
if (kthread_should_stop()) if (kthread_should_stop())
return 0; return 0;
...@@ -584,17 +584,17 @@ static int pi433_tx_thread(void *data) ...@@ -584,17 +584,17 @@ static int pi433_tx_thread(void *data)
* - size of message * - size of message
* - message * - message
*/ */
retval = kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg)); retval = kfifo_out(&pi433->tx_fifo, &tx_cfg, sizeof(tx_cfg));
if (retval != sizeof(tx_cfg)) { if (retval != sizeof(tx_cfg)) {
dev_dbg(device->dev, dev_dbg(pi433->dev,
"reading tx_cfg from fifo failed: got %d byte(s), expected %d\n", "reading tx_cfg from fifo failed: got %d byte(s), expected %d\n",
retval, (unsigned int)sizeof(tx_cfg)); retval, (unsigned int)sizeof(tx_cfg));
continue; continue;
} }
retval = kfifo_out(&device->tx_fifo, &size, sizeof(size_t)); retval = kfifo_out(&pi433->tx_fifo, &size, sizeof(size_t));
if (retval != sizeof(size_t)) { if (retval != sizeof(size_t)) {
dev_dbg(device->dev, dev_dbg(pi433->dev,
"reading msg size from fifo failed: got %d, expected %d\n", "reading msg size from fifo failed: got %d, expected %d\n",
retval, (unsigned int)sizeof(size_t)); retval, (unsigned int)sizeof(size_t));
continue; continue;
...@@ -613,7 +613,7 @@ static int pi433_tx_thread(void *data) ...@@ -613,7 +613,7 @@ static int pi433_tx_thread(void *data)
size++; size++;
/* prime tx_buffer */ /* prime tx_buffer */
memset(device->tx_buffer, 0, size); memset(pi433->tx_buffer, 0, size);
position = 0; position = 0;
/* add length byte, if requested */ /* add length byte, if requested */
...@@ -622,16 +622,16 @@ static int pi433_tx_thread(void *data) ...@@ -622,16 +622,16 @@ static int pi433_tx_thread(void *data)
* according to spec, length byte itself must be * according to spec, length byte itself must be
* excluded from the length calculation * excluded from the length calculation
*/ */
device->tx_buffer[position++] = size - 1; pi433->tx_buffer[position++] = size - 1;
/* add adr byte, if requested */ /* add adr byte, if requested */
if (tx_cfg.enable_address_byte == OPTION_ON) if (tx_cfg.enable_address_byte == OPTION_ON)
device->tx_buffer[position++] = tx_cfg.address_byte; pi433->tx_buffer[position++] = tx_cfg.address_byte;
/* finally get message data from fifo */ /* finally get message data from fifo */
retval = kfifo_out(&device->tx_fifo, &device->tx_buffer[position], retval = kfifo_out(&pi433->tx_fifo, &pi433->tx_buffer[position],
sizeof(device->tx_buffer) - position); sizeof(pi433->tx_buffer) - position);
dev_dbg(device->dev, dev_dbg(pi433->dev,
"read %d message byte(s) from fifo queue.\n", retval); "read %d message byte(s) from fifo queue.\n", retval);
/* /*
...@@ -641,23 +641,23 @@ static int pi433_tx_thread(void *data) ...@@ -641,23 +641,23 @@ static int pi433_tx_thread(void *data)
* place otherwise we need to wait for the incoming telegram * place otherwise we need to wait for the incoming telegram
* to finish * to finish
*/ */
wait_event_interruptible(device->tx_wait_queue, wait_event_interruptible(pi433->tx_wait_queue,
!device->rx_active || !pi433->rx_active ||
device->interrupt_rx_allowed); pi433->interrupt_rx_allowed);
/* /*
* prevent race conditions * prevent race conditions
* irq will be re-enabled after tx config is set * irq will be re-enabled after tx config is set
*/ */
disable_irq(device->irq_num[DIO0]); disable_irq(pi433->irq_num[DIO0]);
device->tx_active = true; pi433->tx_active = true;
/* clear fifo, set fifo threshold, set payload length */ /* clear fifo, set fifo threshold, set payload length */
retval = rf69_set_mode(spi, standby); /* this clears the fifo */ retval = rf69_set_mode(spi, standby); /* this clears the fifo */
if (retval < 0) if (retval < 0)
goto abort; goto abort;
if (device->rx_active && !rx_interrupted) { if (pi433->rx_active && !rx_interrupted) {
/* /*
* rx is currently waiting for a telegram; * rx is currently waiting for a telegram;
* we need to set the radio module to standby * we need to set the radio module to standby
...@@ -679,7 +679,7 @@ static int pi433_tx_thread(void *data) ...@@ -679,7 +679,7 @@ static int pi433_tx_thread(void *data)
} }
/* configure the rf chip */ /* configure the rf chip */
retval = rf69_set_tx_cfg(device, &tx_cfg); retval = rf69_set_tx_cfg(pi433, &tx_cfg);
if (retval < 0) if (retval < 0)
goto abort; goto abort;
...@@ -687,16 +687,16 @@ static int pi433_tx_thread(void *data) ...@@ -687,16 +687,16 @@ static int pi433_tx_thread(void *data)
retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL); retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL);
if (retval < 0) if (retval < 0)
goto abort; goto abort;
device->irq_state[DIO1] = DIO_FIFO_LEVEL; pi433->irq_state[DIO1] = DIO_FIFO_LEVEL;
irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING); irq_set_irq_type(pi433->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING);
/* enable packet sent interrupt */ /* enable packet sent interrupt */
retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT); retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT);
if (retval < 0) if (retval < 0)
goto abort; goto abort;
device->irq_state[DIO0] = DIO_PACKET_SENT; pi433->irq_state[DIO0] = DIO_PACKET_SENT;
irq_set_irq_type(device->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); irq_set_irq_type(pi433->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
enable_irq(device->irq_num[DIO0]); /* was disabled by rx active check */ enable_irq(pi433->irq_num[DIO0]); /* was disabled by rx active check */
/* enable transmission */ /* enable transmission */
retval = rf69_set_mode(spi, transmit); retval = rf69_set_mode(spi, transmit);
...@@ -704,61 +704,61 @@ static int pi433_tx_thread(void *data) ...@@ -704,61 +704,61 @@ static int pi433_tx_thread(void *data)
goto abort; goto abort;
/* transfer this msg (and repetitions) to chip fifo */ /* transfer this msg (and repetitions) to chip fifo */
device->free_in_fifo = FIFO_SIZE; pi433->free_in_fifo = FIFO_SIZE;
position = 0; position = 0;
repetitions = tx_cfg.repetitions; repetitions = tx_cfg.repetitions;
while ((repetitions > 0) && (size > position)) { while ((repetitions > 0) && (size > position)) {
if ((size - position) > device->free_in_fifo) { if ((size - position) > pi433->free_in_fifo) {
/* msg to big for fifo - take a part */ /* msg to big for fifo - take a part */
int write_size = device->free_in_fifo; int write_size = pi433->free_in_fifo;
device->free_in_fifo = 0; pi433->free_in_fifo = 0;
rf69_write_fifo(spi, rf69_write_fifo(spi,
&device->tx_buffer[position], &pi433->tx_buffer[position],
write_size); write_size);
position += write_size; position += write_size;
} else { } else {
/* msg fits into fifo - take all */ /* msg fits into fifo - take all */
device->free_in_fifo -= size; pi433->free_in_fifo -= size;
repetitions--; repetitions--;
rf69_write_fifo(spi, rf69_write_fifo(spi,
&device->tx_buffer[position], &pi433->tx_buffer[position],
(size - position)); (size - position));
position = 0; /* reset for next repetition */ position = 0; /* reset for next repetition */
} }
retval = wait_event_interruptible(device->fifo_wait_queue, retval = wait_event_interruptible(pi433->fifo_wait_queue,
device->free_in_fifo > 0); pi433->free_in_fifo > 0);
if (retval) { if (retval) {
dev_dbg(device->dev, "ABORT\n"); dev_dbg(pi433->dev, "ABORT\n");
goto abort; goto abort;
} }
} }
/* we are done. Wait for packet to get sent */ /* we are done. Wait for packet to get sent */
dev_dbg(device->dev, dev_dbg(pi433->dev,
"thread: wait for packet to get sent/fifo to be empty\n"); "thread: wait for packet to get sent/fifo to be empty\n");
wait_event_interruptible(device->fifo_wait_queue, wait_event_interruptible(pi433->fifo_wait_queue,
device->free_in_fifo == FIFO_SIZE || pi433->free_in_fifo == FIFO_SIZE ||
kthread_should_stop()); kthread_should_stop());
if (kthread_should_stop()) if (kthread_should_stop())
return 0; return 0;
/* STOP_TRANSMISSION */ /* STOP_TRANSMISSION */
dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.\n"); dev_dbg(pi433->dev, "thread: Packet sent. Set mode to stby.\n");
retval = rf69_set_mode(spi, standby); retval = rf69_set_mode(spi, standby);
if (retval < 0) if (retval < 0)
goto abort; goto abort;
/* everything sent? */ /* everything sent? */
if (kfifo_is_empty(&device->tx_fifo)) { if (kfifo_is_empty(&pi433->tx_fifo)) {
abort: abort:
if (rx_interrupted) { if (rx_interrupted) {
rx_interrupted = false; rx_interrupted = false;
pi433_start_rx(device); pi433_start_rx(pi433);
} }
device->tx_active = false; pi433->tx_active = false;
wake_up_interruptible(&device->rx_wait_queue); wake_up_interruptible(&pi433->rx_wait_queue);
} }
} }
} }
...@@ -769,7 +769,7 @@ static ssize_t ...@@ -769,7 +769,7 @@ static ssize_t
pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos) pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
{ {
struct pi433_instance *instance; struct pi433_instance *instance;
struct pi433_device *device; struct pi433_device *pi433;
int bytes_received; int bytes_received;
ssize_t retval; ssize_t retval;
...@@ -778,31 +778,31 @@ pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos) ...@@ -778,31 +778,31 @@ pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
return -EMSGSIZE; return -EMSGSIZE;
instance = filp->private_data; instance = filp->private_data;
device = instance->device; pi433 = instance->pi433;
/* just one read request at a time */ /* just one read request at a time */
mutex_lock(&device->rx_lock); mutex_lock(&pi433->rx_lock);
if (device->rx_active) { if (pi433->rx_active) {
mutex_unlock(&device->rx_lock); mutex_unlock(&pi433->rx_lock);
return -EAGAIN; return -EAGAIN;
} }
device->rx_active = true; pi433->rx_active = true;
mutex_unlock(&device->rx_lock); mutex_unlock(&pi433->rx_lock);
/* start receiving */ /* start receiving */
/* will block until something was received*/ /* will block until something was received*/
device->rx_buffer_size = size; pi433->rx_buffer_size = size;
bytes_received = pi433_receive(device); bytes_received = pi433_receive(pi433);
/* release rx */ /* release rx */
mutex_lock(&device->rx_lock); mutex_lock(&pi433->rx_lock);
device->rx_active = false; pi433->rx_active = false;
mutex_unlock(&device->rx_lock); mutex_unlock(&pi433->rx_lock);
/* if read was successful copy to user space*/ /* if read was successful copy to user space*/
if (bytes_received > 0) { if (bytes_received > 0) {
retval = copy_to_user(buf, device->rx_buffer, bytes_received); retval = copy_to_user(buf, pi433->rx_buffer, bytes_received);
if (retval) if (retval)
return -EFAULT; return -EFAULT;
} }
...@@ -815,12 +815,12 @@ pi433_write(struct file *filp, const char __user *buf, ...@@ -815,12 +815,12 @@ pi433_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos) size_t count, loff_t *f_pos)
{ {
struct pi433_instance *instance; struct pi433_instance *instance;
struct pi433_device *device; struct pi433_device *pi433;
int retval; int retval;
unsigned int required, available, copied; unsigned int required, available, copied;
instance = filp->private_data; instance = filp->private_data;
device = instance->device; pi433 = instance->pi433;
/* /*
* check, whether internal buffer (tx thread) is big enough * check, whether internal buffer (tx thread) is big enough
...@@ -834,7 +834,7 @@ pi433_write(struct file *filp, const char __user *buf, ...@@ -834,7 +834,7 @@ pi433_write(struct file *filp, const char __user *buf,
* config the RF trasmitter correctly due to invalid settings * config the RF trasmitter correctly due to invalid settings
*/ */
if (!instance->tx_cfg_initialized) { if (!instance->tx_cfg_initialized) {
dev_notice_once(device->dev, dev_notice_once(pi433->dev,
"write: failed due to unconfigured tx_cfg (see PI433_IOC_WR_TX_CFG)\n"); "write: failed due to unconfigured tx_cfg (see PI433_IOC_WR_TX_CFG)\n");
return -EINVAL; return -EINVAL;
} }
...@@ -845,49 +845,49 @@ pi433_write(struct file *filp, const char __user *buf, ...@@ -845,49 +845,49 @@ pi433_write(struct file *filp, const char __user *buf,
* - size of message * - size of message
* - message * - message
*/ */
mutex_lock(&device->tx_fifo_lock); mutex_lock(&pi433->tx_fifo_lock);
required = sizeof(instance->tx_cfg) + sizeof(size_t) + count; required = sizeof(instance->tx_cfg) + sizeof(size_t) + count;
available = kfifo_avail(&device->tx_fifo); available = kfifo_avail(&pi433->tx_fifo);
if (required > available) { if (required > available) {
dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d available\n", dev_dbg(pi433->dev, "write to fifo failed: %d bytes required but %d available\n",
required, available); required, available);
mutex_unlock(&device->tx_fifo_lock); mutex_unlock(&pi433->tx_fifo_lock);
return -EAGAIN; return -EAGAIN;
} }
retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg, retval = kfifo_in(&pi433->tx_fifo, &instance->tx_cfg,
sizeof(instance->tx_cfg)); sizeof(instance->tx_cfg));
if (retval != sizeof(instance->tx_cfg)) if (retval != sizeof(instance->tx_cfg))
goto abort; goto abort;
retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t)); retval = kfifo_in(&pi433->tx_fifo, &count, sizeof(size_t));
if (retval != sizeof(size_t)) if (retval != sizeof(size_t))
goto abort; goto abort;
retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied); retval = kfifo_from_user(&pi433->tx_fifo, buf, count, &copied);
if (retval || copied != count) if (retval || copied != count)
goto abort; goto abort;
mutex_unlock(&device->tx_fifo_lock); mutex_unlock(&pi433->tx_fifo_lock);
/* start transfer */ /* start transfer */
wake_up_interruptible(&device->tx_wait_queue); wake_up_interruptible(&pi433->tx_wait_queue);
dev_dbg(device->dev, "write: generated new msg with %d bytes.\n", copied); dev_dbg(pi433->dev, "write: generated new msg with %d bytes.\n", copied);
return copied; return copied;
abort: abort:
dev_warn(device->dev, dev_warn(pi433->dev,
"write to fifo failed, non recoverable: 0x%x\n", retval); "write to fifo failed, non recoverable: 0x%x\n", retval);
mutex_unlock(&device->tx_fifo_lock); mutex_unlock(&pi433->tx_fifo_lock);
return -EAGAIN; return -EAGAIN;
} }
static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{ {
struct pi433_instance *instance; struct pi433_instance *instance;
struct pi433_device *device; struct pi433_device *pi433;
struct pi433_tx_cfg tx_cfg; struct pi433_tx_cfg tx_cfg;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
...@@ -896,9 +896,9 @@ static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -896,9 +896,9 @@ static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
return -ENOTTY; return -ENOTTY;
instance = filp->private_data; instance = filp->private_data;
device = instance->device; pi433 = instance->pi433;
if (!device) if (!pi433)
return -ESHUTDOWN; return -ESHUTDOWN;
switch (cmd) { switch (cmd) {
...@@ -910,32 +910,32 @@ static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -910,32 +910,32 @@ static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
case PI433_IOC_WR_TX_CFG: case PI433_IOC_WR_TX_CFG:
if (copy_from_user(&tx_cfg, argp, sizeof(struct pi433_tx_cfg))) if (copy_from_user(&tx_cfg, argp, sizeof(struct pi433_tx_cfg)))
return -EFAULT; return -EFAULT;
mutex_lock(&device->tx_fifo_lock); mutex_lock(&pi433->tx_fifo_lock);
memcpy(&instance->tx_cfg, &tx_cfg, sizeof(struct pi433_tx_cfg)); memcpy(&instance->tx_cfg, &tx_cfg, sizeof(struct pi433_tx_cfg));
instance->tx_cfg_initialized = true; instance->tx_cfg_initialized = true;
mutex_unlock(&device->tx_fifo_lock); mutex_unlock(&pi433->tx_fifo_lock);
break; break;
case PI433_IOC_RD_RX_CFG: case PI433_IOC_RD_RX_CFG:
if (copy_to_user(argp, &device->rx_cfg, if (copy_to_user(argp, &pi433->rx_cfg,
sizeof(struct pi433_rx_cfg))) sizeof(struct pi433_rx_cfg)))
return -EFAULT; return -EFAULT;
break; break;
case PI433_IOC_WR_RX_CFG: case PI433_IOC_WR_RX_CFG:
mutex_lock(&device->rx_lock); mutex_lock(&pi433->rx_lock);
/* during pending read request, change of config not allowed */ /* during pending read request, change of config not allowed */
if (device->rx_active) { if (pi433->rx_active) {
mutex_unlock(&device->rx_lock); mutex_unlock(&pi433->rx_lock);
return -EAGAIN; return -EAGAIN;
} }
if (copy_from_user(&device->rx_cfg, argp, if (copy_from_user(&pi433->rx_cfg, argp,
sizeof(struct pi433_rx_cfg))) { sizeof(struct pi433_rx_cfg))) {
mutex_unlock(&device->rx_lock); mutex_unlock(&pi433->rx_lock);
return -EFAULT; return -EFAULT;
} }
mutex_unlock(&device->rx_lock); mutex_unlock(&pi433->rx_lock);
break; break;
default: default:
return -EINVAL; return -EINVAL;
...@@ -948,13 +948,13 @@ static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -948,13 +948,13 @@ static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
static int pi433_open(struct inode *inode, struct file *filp) static int pi433_open(struct inode *inode, struct file *filp)
{ {
struct pi433_device *device; struct pi433_device *pi433;
struct pi433_instance *instance; struct pi433_instance *instance;
mutex_lock(&minor_lock); mutex_lock(&minor_lock);
device = idr_find(&pi433_idr, iminor(inode)); pi433 = idr_find(&pi433_idr, iminor(inode));
mutex_unlock(&minor_lock); mutex_unlock(&minor_lock);
if (!device) { if (!pi433) {
pr_debug("device: minor %d unknown.\n", iminor(inode)); pr_debug("device: minor %d unknown.\n", iminor(inode));
return -ENODEV; return -ENODEV;
} }
...@@ -964,7 +964,7 @@ static int pi433_open(struct inode *inode, struct file *filp) ...@@ -964,7 +964,7 @@ static int pi433_open(struct inode *inode, struct file *filp)
return -ENOMEM; return -ENOMEM;
/* setup instance data*/ /* setup instance data*/
instance->device = device; instance->pi433 = pi433;
/* instance data as context */ /* instance data as context */
filp->private_data = instance; filp->private_data = instance;
...@@ -986,7 +986,7 @@ static int pi433_release(struct inode *inode, struct file *filp) ...@@ -986,7 +986,7 @@ static int pi433_release(struct inode *inode, struct file *filp)
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int setup_gpio(struct pi433_device *device) static int setup_gpio(struct pi433_device *pi433)
{ {
char name[5]; char name[5];
int retval; int retval;
...@@ -999,89 +999,89 @@ static int setup_gpio(struct pi433_device *device) ...@@ -999,89 +999,89 @@ static int setup_gpio(struct pi433_device *device)
for (i = 0; i < NUM_DIO; i++) { for (i = 0; i < NUM_DIO; i++) {
/* "construct" name and get the gpio descriptor */ /* "construct" name and get the gpio descriptor */
snprintf(name, sizeof(name), "DIO%d", i); snprintf(name, sizeof(name), "DIO%d", i);
device->gpiod[i] = gpiod_get(&device->spi->dev, name, pi433->gpiod[i] = gpiod_get(&pi433->spi->dev, name,
0 /*GPIOD_IN*/); 0 /*GPIOD_IN*/);
if (device->gpiod[i] == ERR_PTR(-ENOENT)) { if (pi433->gpiod[i] == ERR_PTR(-ENOENT)) {
dev_dbg(&device->spi->dev, dev_dbg(&pi433->spi->dev,
"Could not find entry for %s. Ignoring.\n", name); "Could not find entry for %s. Ignoring.\n", name);
continue; continue;
} }
if (device->gpiod[i] == ERR_PTR(-EBUSY)) if (pi433->gpiod[i] == ERR_PTR(-EBUSY))
dev_dbg(&device->spi->dev, "%s is busy.\n", name); dev_dbg(&pi433->spi->dev, "%s is busy.\n", name);
if (IS_ERR(device->gpiod[i])) { if (IS_ERR(pi433->gpiod[i])) {
retval = PTR_ERR(device->gpiod[i]); retval = PTR_ERR(pi433->gpiod[i]);
/* release already allocated gpios */ /* release already allocated gpios */
for (i--; i >= 0; i--) { for (i--; i >= 0; i--) {
free_irq(device->irq_num[i], device); free_irq(pi433->irq_num[i], pi433);
gpiod_put(device->gpiod[i]); gpiod_put(pi433->gpiod[i]);
} }
return retval; return retval;
} }
/* configure the pin */ /* configure the pin */
retval = gpiod_direction_input(device->gpiod[i]); retval = gpiod_direction_input(pi433->gpiod[i]);
if (retval) if (retval)
return retval; return retval;
/* configure irq */ /* configure irq */
device->irq_num[i] = gpiod_to_irq(device->gpiod[i]); pi433->irq_num[i] = gpiod_to_irq(pi433->gpiod[i]);
if (device->irq_num[i] < 0) { if (pi433->irq_num[i] < 0) {
device->gpiod[i] = ERR_PTR(-EINVAL); pi433->gpiod[i] = ERR_PTR(-EINVAL);
return device->irq_num[i]; return pi433->irq_num[i];
} }
retval = request_irq(device->irq_num[i], retval = request_irq(pi433->irq_num[i],
DIO_irq_handler[i], DIO_irq_handler[i],
0, /* flags */ 0, /* flags */
name, name,
device); pi433);
if (retval) if (retval)
return retval; return retval;
dev_dbg(&device->spi->dev, "%s successfully configured\n", name); dev_dbg(&pi433->spi->dev, "%s successfully configured\n", name);
} }
return 0; return 0;
} }
static void free_gpio(struct pi433_device *device) static void free_gpio(struct pi433_device *pi433)
{ {
int i; int i;
for (i = 0; i < NUM_DIO; i++) { for (i = 0; i < NUM_DIO; i++) {
/* check if gpiod is valid */ /* check if gpiod is valid */
if (IS_ERR(device->gpiod[i])) if (IS_ERR(pi433->gpiod[i]))
continue; continue;
free_irq(device->irq_num[i], device); free_irq(pi433->irq_num[i], pi433);
gpiod_put(device->gpiod[i]); gpiod_put(pi433->gpiod[i]);
} }
} }
static int pi433_get_minor(struct pi433_device *device) static int pi433_get_minor(struct pi433_device *pi433)
{ {
int retval = -ENOMEM; int retval = -ENOMEM;
mutex_lock(&minor_lock); mutex_lock(&minor_lock);
retval = idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL); retval = idr_alloc(&pi433_idr, pi433, 0, N_PI433_MINORS, GFP_KERNEL);
if (retval >= 0) { if (retval >= 0) {
device->minor = retval; pi433->minor = retval;
retval = 0; retval = 0;
} else if (retval == -ENOSPC) { } else if (retval == -ENOSPC) {
dev_err(&device->spi->dev, "too many pi433 devices\n"); dev_err(&pi433->spi->dev, "too many pi433 devices\n");
retval = -EINVAL; retval = -EINVAL;
} }
mutex_unlock(&minor_lock); mutex_unlock(&minor_lock);
return retval; return retval;
} }
static void pi433_free_minor(struct pi433_device *dev) static void pi433_free_minor(struct pi433_device *pi433)
{ {
mutex_lock(&minor_lock); mutex_lock(&minor_lock);
idr_remove(&pi433_idr, dev->minor); idr_remove(&pi433_idr, pi433->minor);
mutex_unlock(&minor_lock); mutex_unlock(&minor_lock);
} }
...@@ -1105,35 +1105,35 @@ static const struct file_operations pi433_fops = { ...@@ -1105,35 +1105,35 @@ static const struct file_operations pi433_fops = {
static int pi433_debugfs_regs_show(struct seq_file *m, void *p) static int pi433_debugfs_regs_show(struct seq_file *m, void *p)
{ {
struct pi433_device *dev; struct pi433_device *pi433;
u8 reg_data[114]; u8 reg_data[114];
int i; int i;
char *fmt = "0x%02x, 0x%02x\n"; char *fmt = "0x%02x, 0x%02x\n";
int ret; int ret;
dev = m->private; pi433 = m->private;
mutex_lock(&dev->tx_fifo_lock); mutex_lock(&pi433->tx_fifo_lock);
mutex_lock(&dev->rx_lock); mutex_lock(&pi433->rx_lock);
// wait for on-going operations to finish // wait for on-going operations to finish
ret = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active); ret = wait_event_interruptible(pi433->rx_wait_queue, !pi433->tx_active);
if (ret) if (ret)
goto out_unlock; goto out_unlock;
ret = wait_event_interruptible(dev->tx_wait_queue, !dev->rx_active); ret = wait_event_interruptible(pi433->tx_wait_queue, !pi433->rx_active);
if (ret) if (ret)
goto out_unlock; goto out_unlock;
// skip FIFO register (0x0) otherwise this can affect some of uC ops // skip FIFO register (0x0) otherwise this can affect some of uC ops
for (i = 1; i < 0x50; i++) for (i = 1; i < 0x50; i++)
reg_data[i] = rf69_read_reg(dev->spi, i); reg_data[i] = rf69_read_reg(pi433->spi, i);
reg_data[REG_TESTLNA] = rf69_read_reg(dev->spi, REG_TESTLNA); reg_data[REG_TESTLNA] = rf69_read_reg(pi433->spi, REG_TESTLNA);
reg_data[REG_TESTPA1] = rf69_read_reg(dev->spi, REG_TESTPA1); reg_data[REG_TESTPA1] = rf69_read_reg(pi433->spi, REG_TESTPA1);
reg_data[REG_TESTPA2] = rf69_read_reg(dev->spi, REG_TESTPA2); reg_data[REG_TESTPA2] = rf69_read_reg(pi433->spi, REG_TESTPA2);
reg_data[REG_TESTDAGC] = rf69_read_reg(dev->spi, REG_TESTDAGC); reg_data[REG_TESTDAGC] = rf69_read_reg(pi433->spi, REG_TESTDAGC);
reg_data[REG_TESTAFC] = rf69_read_reg(dev->spi, REG_TESTAFC); reg_data[REG_TESTAFC] = rf69_read_reg(pi433->spi, REG_TESTAFC);
seq_puts(m, "# reg, val\n"); seq_puts(m, "# reg, val\n");
...@@ -1147,8 +1147,8 @@ static int pi433_debugfs_regs_show(struct seq_file *m, void *p) ...@@ -1147,8 +1147,8 @@ static int pi433_debugfs_regs_show(struct seq_file *m, void *p)
seq_printf(m, fmt, REG_TESTAFC, reg_data[REG_TESTAFC]); seq_printf(m, fmt, REG_TESTAFC, reg_data[REG_TESTAFC]);
out_unlock: out_unlock:
mutex_unlock(&dev->rx_lock); mutex_unlock(&pi433->rx_lock);
mutex_unlock(&dev->tx_fifo_lock); mutex_unlock(&pi433->tx_fifo_lock);
return ret; return ret;
} }
...@@ -1158,7 +1158,7 @@ DEFINE_SHOW_ATTRIBUTE(pi433_debugfs_regs); ...@@ -1158,7 +1158,7 @@ DEFINE_SHOW_ATTRIBUTE(pi433_debugfs_regs);
static int pi433_probe(struct spi_device *spi) static int pi433_probe(struct spi_device *spi)
{ {
struct pi433_device *device; struct pi433_device *pi433;
int retval; int retval;
struct dentry *entry; struct dentry *entry;
...@@ -1195,37 +1195,37 @@ static int pi433_probe(struct spi_device *spi) ...@@ -1195,37 +1195,37 @@ static int pi433_probe(struct spi_device *spi)
} }
/* Allocate driver data */ /* Allocate driver data */
device = kzalloc(sizeof(*device), GFP_KERNEL); pi433 = kzalloc(sizeof(*pi433), GFP_KERNEL);
if (!device) if (!pi433)
return -ENOMEM; return -ENOMEM;
/* Initialize the driver data */ /* Initialize the driver data */
device->spi = spi; pi433->spi = spi;
device->rx_active = false; pi433->rx_active = false;
device->tx_active = false; pi433->tx_active = false;
device->interrupt_rx_allowed = false; pi433->interrupt_rx_allowed = false;
/* init rx buffer */ /* init rx buffer */
device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL); pi433->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL);
if (!device->rx_buffer) { if (!pi433->rx_buffer) {
retval = -ENOMEM; retval = -ENOMEM;
goto RX_failed; goto RX_failed;
} }
/* init wait queues */ /* init wait queues */
init_waitqueue_head(&device->tx_wait_queue); init_waitqueue_head(&pi433->tx_wait_queue);
init_waitqueue_head(&device->rx_wait_queue); init_waitqueue_head(&pi433->rx_wait_queue);
init_waitqueue_head(&device->fifo_wait_queue); init_waitqueue_head(&pi433->fifo_wait_queue);
/* init fifo */ /* init fifo */
INIT_KFIFO(device->tx_fifo); INIT_KFIFO(pi433->tx_fifo);
/* init mutexes and locks */ /* init mutexes and locks */
mutex_init(&device->tx_fifo_lock); mutex_init(&pi433->tx_fifo_lock);
mutex_init(&device->rx_lock); mutex_init(&pi433->rx_lock);
/* setup GPIO (including irq_handler) for the different DIOs */ /* setup GPIO (including irq_handler) for the different DIOs */
retval = setup_gpio(device); retval = setup_gpio(pi433);
if (retval) { if (retval) {
dev_dbg(&spi->dev, "setup of GPIOs failed\n"); dev_dbg(&spi->dev, "setup of GPIOs failed\n");
goto GPIO_failed; goto GPIO_failed;
...@@ -1255,105 +1255,105 @@ static int pi433_probe(struct spi_device *spi) ...@@ -1255,105 +1255,105 @@ static int pi433_probe(struct spi_device *spi)
goto minor_failed; goto minor_failed;
/* determ minor number */ /* determ minor number */
retval = pi433_get_minor(device); retval = pi433_get_minor(pi433);
if (retval) { if (retval) {
dev_dbg(&spi->dev, "get of minor number failed\n"); dev_dbg(&spi->dev, "get of minor number failed\n");
goto minor_failed; goto minor_failed;
} }
/* create device */ /* create device */
device->devt = MKDEV(MAJOR(pi433_dev), device->minor); pi433->devt = MKDEV(MAJOR(pi433_dev), pi433->minor);
device->dev = device_create(&pi433_class, pi433->dev = device_create(&pi433_class,
&spi->dev, &spi->dev,
device->devt, pi433->devt,
device, pi433,
"pi433.%d", "pi433.%d",
device->minor); pi433->minor);
if (IS_ERR(device->dev)) { if (IS_ERR(pi433->dev)) {
pr_err("pi433: device register failed\n"); pr_err("pi433: device register failed\n");
retval = PTR_ERR(device->dev); retval = PTR_ERR(pi433->dev);
goto device_create_failed; goto device_create_failed;
} else { } else {
dev_dbg(device->dev, dev_dbg(pi433->dev,
"created device for major %d, minor %d\n", "created device for major %d, minor %d\n",
MAJOR(pi433_dev), MAJOR(pi433_dev),
device->minor); pi433->minor);
} }
/* start tx thread */ /* start tx thread */
device->tx_task_struct = kthread_run(pi433_tx_thread, pi433->tx_task_struct = kthread_run(pi433_tx_thread,
device, pi433,
"pi433.%d_tx_task", "pi433.%d_tx_task",
device->minor); pi433->minor);
if (IS_ERR(device->tx_task_struct)) { if (IS_ERR(pi433->tx_task_struct)) {
dev_dbg(device->dev, "start of send thread failed\n"); dev_dbg(pi433->dev, "start of send thread failed\n");
retval = PTR_ERR(device->tx_task_struct); retval = PTR_ERR(pi433->tx_task_struct);
goto send_thread_failed; goto send_thread_failed;
} }
/* create cdev */ /* create cdev */
device->cdev = cdev_alloc(); pi433->cdev = cdev_alloc();
if (!device->cdev) { if (!pi433->cdev) {
dev_dbg(device->dev, "allocation of cdev failed\n"); dev_dbg(pi433->dev, "allocation of cdev failed\n");
retval = -ENOMEM; retval = -ENOMEM;
goto cdev_failed; goto cdev_failed;
} }
device->cdev->owner = THIS_MODULE; pi433->cdev->owner = THIS_MODULE;
cdev_init(device->cdev, &pi433_fops); cdev_init(pi433->cdev, &pi433_fops);
retval = cdev_add(device->cdev, device->devt, 1); retval = cdev_add(pi433->cdev, pi433->devt, 1);
if (retval) { if (retval) {
dev_dbg(device->dev, "register of cdev failed\n"); dev_dbg(pi433->dev, "register of cdev failed\n");
goto del_cdev; goto del_cdev;
} }
/* spi setup */ /* spi setup */
spi_set_drvdata(spi, device); spi_set_drvdata(spi, pi433);
entry = debugfs_create_dir(dev_name(device->dev), root_dir); entry = debugfs_create_dir(dev_name(pi433->dev), root_dir);
debugfs_create_file("regs", 0400, entry, device, &pi433_debugfs_regs_fops); debugfs_create_file("regs", 0400, entry, pi433, &pi433_debugfs_regs_fops);
return 0; return 0;
del_cdev: del_cdev:
cdev_del(device->cdev); cdev_del(pi433->cdev);
cdev_failed: cdev_failed:
kthread_stop(device->tx_task_struct); kthread_stop(pi433->tx_task_struct);
send_thread_failed: send_thread_failed:
device_destroy(&pi433_class, device->devt); device_destroy(&pi433_class, pi433->devt);
device_create_failed: device_create_failed:
pi433_free_minor(device); pi433_free_minor(pi433);
minor_failed: minor_failed:
free_gpio(device); free_gpio(pi433);
GPIO_failed: GPIO_failed:
kfree(device->rx_buffer); kfree(pi433->rx_buffer);
RX_failed: RX_failed:
kfree(device); kfree(pi433);
return retval; return retval;
} }
static void pi433_remove(struct spi_device *spi) static void pi433_remove(struct spi_device *spi)
{ {
struct pi433_device *device = spi_get_drvdata(spi); struct pi433_device *pi433 = spi_get_drvdata(spi);
debugfs_lookup_and_remove(dev_name(device->dev), root_dir); debugfs_lookup_and_remove(dev_name(pi433->dev), root_dir);
/* free GPIOs */ /* free GPIOs */
free_gpio(device); free_gpio(pi433);
/* make sure ops on existing fds can abort cleanly */ /* make sure ops on existing fds can abort cleanly */
device->spi = NULL; pi433->spi = NULL;
kthread_stop(device->tx_task_struct); kthread_stop(pi433->tx_task_struct);
device_destroy(&pi433_class, device->devt); device_destroy(&pi433_class, pi433->devt);
cdev_del(device->cdev); cdev_del(pi433->cdev);
pi433_free_minor(device); pi433_free_minor(pi433);
kfree(device->rx_buffer); kfree(pi433->rx_buffer);
kfree(device); kfree(pi433);
} }
static const struct of_device_id pi433_dt_ids[] = { static const struct of_device_id pi433_dt_ids[] = {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7