From nobody Sun Feb 8 20:33:13 2026 Received: from mail-wm1-f47.google.com (mail-wm1-f47.google.com [209.85.128.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 773227EF16 for ; Thu, 28 Mar 2024 12:12:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711627977; cv=none; b=sPaU431CYdfTjfOREH65NL0xa8owJbnTM65h6dInOlWEQal72Ih9LbLu8L/iHhvJOZyT/iZcfgpknXWwX5Pyii+uizQlqzRX3t1T4+Wqu3OuzXEiiLRwMshmqWK/6UyqHs+o+VNPd44stb0EThfB2X+J9HNnYhauoEZpfiH0O8U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711627977; c=relaxed/simple; bh=WfR3fzgOc+lYO6U7TgwGQD81mZqIEEtqO9tFKn6iuM4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=f4AyIq9x2C74DC+SCD/uEeDkl9EVfII45o/4vKE5W7OIt/dGr+pjmJh+wtgGigowrekWPmrLEzlyH0lxbETh/CmFqaXcEQFu/q2jnhibHTcClogpvWRYwU59GtNtnPgpKnR3M7KUDyuLZlVYFbTz1R+DVyJQb8UxHkVRm7ZFQ7g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=FAiS6c6n; arc=none smtp.client-ip=209.85.128.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="FAiS6c6n" Received: by mail-wm1-f47.google.com with SMTP id 5b1f17b1804b1-415482308f8so2137265e9.1 for ; Thu, 28 Mar 2024 05:12:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1711627973; x=1712232773; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=9LP7LwhNxKs9alceF3MwlRSStgVkDK9Wscv2B2RIGfw=; b=FAiS6c6nKDiH6o8M6tf/TOKeTFqpovwdJiwLCA6+Yf4tKD+5G5JoCb/H9+83m6rVp8 XSFVWLbOF1v9xXvGdri63LdF5C78n/vuhwY/JXcEGAyk/wpiWefoNR9iNH8yzCtrUq9H NXtLTGSN+bwywb9A+RUWIExFZwLDcGEoc5PG9zJs+ejOIeIyNbvmdVT3vxcvd2Ey9oYH 5HUQ6vWiwuSsQbmsLg6rC1JKAmP+4feTp/CYg8q8zwxuUYTC+H8s6X2r8+i2EBtyNNza ORjuGst5zHC3bfILw4Y7lLNa50B7i+TO12ERihCHfvQV0rnTn4YPNTdTOt/5zGlu5bRR PEJA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1711627973; x=1712232773; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=9LP7LwhNxKs9alceF3MwlRSStgVkDK9Wscv2B2RIGfw=; b=lL5fztzsp35l3B8a4aGXcmQI0yoA0XpXiXBaPCKCBnQV6XrnwyEzM3aZLzO+SBZxGI wrFEfyQfXVPSxuJgcRq/G2aDgIGKadKpwNpk31YqvAnbra+9bt78x+abrRjb0Zugzoij Wz1I9loLcCtVHPHqCNBHMIRu8sPHf9k503S0jOlRz7nM7bC1PXuhSxzKsu4YlhEi5zlX ztEdR7rZ6rW226afJugRn9mL5RwFcd3U8yvs6lOfM1yBhDQKUJESE6AC9vb3VZwW0PC0 0cScoQcWkfMaADqv1cF5IUMD68BHEDpWnZg4L5pZk+0OsNc3kD1Pr412FasUJafaYrQk PtOA== X-Forwarded-Encrypted: i=1; AJvYcCW3sRo21lN4pOAMciIJNT+YL/kKPO8H/Oo2KIFe1p74w1cAPcIa926xJ/vD2ndzZiBmx10A/28BC9H3lScFt3SvCnDHOboNg3mJQy+s X-Gm-Message-State: AOJu0YztiDQtYl0+i6MQBAfrESB4V6Qr3z6/uvPSYffLCxioZjLBMNvJ uiWjA9dMhJPB4rYQREDtd1lrUZeQFU0rp+WYWK/zJ+cfBmjXbgqv X-Google-Smtp-Source: AGHT+IFeSgatKUgor7KYQX1DQeEUnNehC9VQbJ+N+wPhlx4V09Lqjq5yJBhLrCmtV8Nes5RO2g5GnQ== X-Received: by 2002:a05:600c:4688:b0:414:69ae:bcfc with SMTP id p8-20020a05600c468800b0041469aebcfcmr1844704wmo.24.1711627972367; Thu, 28 Mar 2024 05:12:52 -0700 (PDT) Received: from YOGA.local ([2a06:c701:736b:f200:125e:963c:4e4b:b7c5]) by smtp.gmail.com with ESMTPSA id bd11-20020a05600c1f0b00b00415460a63ebsm1416456wmb.29.2024.03.28.05.12.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 28 Mar 2024 05:12:51 -0700 (PDT) From: Shahar Avidar To: gregkh@linuxfoundation.org, hverkuil-cisco@xs4all.nl, andriy.shevchenko@linux.intel.com, robh@kernel.org, felixkimbu1@gmail.com Cc: linux-staging@lists.linux.dev, linux-kernel@vger.kernel.org Subject: [PATCH 2/5] staging: pi433: Rename struct pi433_device instances to pi433. Date: Thu, 28 Mar 2024 14:12:40 +0200 Message-Id: <20240328121244.1244719-3-ikobh7@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240328121244.1244719-1-ikobh7@gmail.com> References: <20240328121244.1244719-1-ikobh7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" 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: Shahar Avidar --- drivers/staging/pi433/pi433_if.c | 654 +++++++++++++++---------------- 1 file changed, 327 insertions(+), 327 deletions(-) diff --git a/drivers/staging/pi433/pi433_if.c b/drivers/staging/pi433/pi433= _if.c index 13b464ab7db8..7efe6b8501e3 100644 --- a/drivers/staging/pi433/pi433_if.c +++ b/drivers/staging/pi433/pi433_if.c @@ -113,7 +113,7 @@ struct pi433_device { }; =20 struct pi433_instance { - struct pi433_device *device; + struct pi433_device *pi433; struct pi433_tx_cfg tx_cfg; =20 /* control flags */ @@ -125,19 +125,19 @@ struct pi433_instance { /* GPIO interrupt handlers */ static irqreturn_t DIO0_irq_handler(int irq, void *dev_id) { - struct pi433_device *device =3D dev_id; - - if (device->irq_state[DIO0] =3D=3D DIO_PACKET_SENT) { - device->free_in_fifo =3D FIFO_SIZE; - dev_dbg(device->dev, "DIO0 irq: Packet sent\n"); - wake_up_interruptible(&device->fifo_wait_queue); - } else if (device->irq_state[DIO0] =3D=3D DIO_RSSI_DIO0) { - dev_dbg(device->dev, "DIO0 irq: RSSI level over threshold\n"); - wake_up_interruptible(&device->rx_wait_queue); - } else if (device->irq_state[DIO0] =3D=3D DIO_PAYLOAD_READY) { - dev_dbg(device->dev, "DIO0 irq: Payload ready\n"); - device->free_in_fifo =3D 0; - wake_up_interruptible(&device->fifo_wait_queue); + struct pi433_device *pi433 =3D dev_id; + + if (pi433->irq_state[DIO0] =3D=3D DIO_PACKET_SENT) { + pi433->free_in_fifo =3D FIFO_SIZE; + dev_dbg(pi433->dev, "DIO0 irq: Packet sent\n"); + wake_up_interruptible(&pi433->fifo_wait_queue); + } else if (pi433->irq_state[DIO0] =3D=3D DIO_RSSI_DIO0) { + dev_dbg(pi433->dev, "DIO0 irq: RSSI level over threshold\n"); + wake_up_interruptible(&pi433->rx_wait_queue); + } else if (pi433->irq_state[DIO0] =3D=3D DIO_PAYLOAD_READY) { + dev_dbg(pi433->dev, "DIO0 irq: Payload ready\n"); + pi433->free_in_fifo =3D 0; + wake_up_interruptible(&pi433->fifo_wait_queue); } =20 return IRQ_HANDLED; @@ -145,19 +145,19 @@ static irqreturn_t DIO0_irq_handler(int irq, void *de= v_id) =20 static irqreturn_t DIO1_irq_handler(int irq, void *dev_id) { - struct pi433_device *device =3D dev_id; + struct pi433_device *pi433 =3D dev_id; =20 - if (device->irq_state[DIO1] =3D=3D DIO_FIFO_NOT_EMPTY_DIO1) { - device->free_in_fifo =3D FIFO_SIZE; - } else if (device->irq_state[DIO1] =3D=3D DIO_FIFO_LEVEL) { - if (device->rx_active) - device->free_in_fifo =3D FIFO_THRESHOLD - 1; + if (pi433->irq_state[DIO1] =3D=3D DIO_FIFO_NOT_EMPTY_DIO1) { + pi433->free_in_fifo =3D FIFO_SIZE; + } else if (pi433->irq_state[DIO1] =3D=3D DIO_FIFO_LEVEL) { + if (pi433->rx_active) + pi433->free_in_fifo =3D FIFO_THRESHOLD - 1; else - device->free_in_fifo =3D FIFO_SIZE - FIFO_THRESHOLD - 1; + pi433->free_in_fifo =3D FIFO_SIZE - FIFO_THRESHOLD - 1; } - dev_dbg(device->dev, - "DIO1 irq: %d bytes free in fifo\n", device->free_in_fifo); - wake_up_interruptible(&device->fifo_wait_queue); + dev_dbg(pi433->dev, + "DIO1 irq: %d bytes free in fifo\n", pi433->free_in_fifo); + wake_up_interruptible(&pi433->fifo_wait_queue); =20 return IRQ_HANDLED; } @@ -165,94 +165,94 @@ static irqreturn_t DIO1_irq_handler(int irq, void *de= v_id) /*------------------------------------------------------------------------= -*/ =20 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 payload_length; =20 /* receiver config */ - ret =3D rf69_set_frequency(dev->spi, rx_cfg->frequency); + ret =3D rf69_set_frequency(pi433->spi, rx_cfg->frequency); if (ret < 0) return ret; - ret =3D rf69_set_modulation(dev->spi, rx_cfg->modulation); + ret =3D rf69_set_modulation(pi433->spi, rx_cfg->modulation); if (ret < 0) return ret; - ret =3D rf69_set_bit_rate(dev->spi, rx_cfg->bit_rate); + ret =3D rf69_set_bit_rate(pi433->spi, rx_cfg->bit_rate); if (ret < 0) return ret; - ret =3D rf69_set_antenna_impedance(dev->spi, rx_cfg->antenna_impedance); + ret =3D rf69_set_antenna_impedance(pi433->spi, rx_cfg->antenna_impedance); if (ret < 0) return ret; - ret =3D rf69_set_rssi_threshold(dev->spi, rx_cfg->rssi_threshold); + ret =3D rf69_set_rssi_threshold(pi433->spi, rx_cfg->rssi_threshold); if (ret < 0) return ret; - ret =3D rf69_set_ook_threshold_dec(dev->spi, rx_cfg->threshold_decrement); + ret =3D rf69_set_ook_threshold_dec(pi433->spi, rx_cfg->threshold_decremen= t); if (ret < 0) return ret; - ret =3D rf69_set_bandwidth(dev->spi, rx_cfg->bw_mantisse, + ret =3D rf69_set_bandwidth(pi433->spi, rx_cfg->bw_mantisse, rx_cfg->bw_exponent); if (ret < 0) return ret; - ret =3D rf69_set_bandwidth_during_afc(dev->spi, rx_cfg->bw_mantisse, + ret =3D rf69_set_bandwidth_during_afc(pi433->spi, rx_cfg->bw_mantisse, rx_cfg->bw_exponent); if (ret < 0) return ret; - ret =3D rf69_set_dagc(dev->spi, rx_cfg->dagc); + ret =3D rf69_set_dagc(pi433->spi, rx_cfg->dagc); if (ret < 0) return ret; =20 - dev->rx_bytes_to_drop =3D rx_cfg->bytes_to_drop; + pi433->rx_bytes_to_drop =3D rx_cfg->bytes_to_drop; =20 /* packet config */ /* enable */ if (rx_cfg->enable_sync =3D=3D OPTION_ON) { - ret =3D rf69_enable_sync(dev->spi); + ret =3D rf69_enable_sync(pi433->spi); if (ret < 0) return ret; =20 - ret =3D rf69_set_fifo_fill_condition(dev->spi, + ret =3D rf69_set_fifo_fill_condition(pi433->spi, after_sync_interrupt); if (ret < 0) return ret; } else { - ret =3D rf69_disable_sync(dev->spi); + ret =3D rf69_disable_sync(pi433->spi); if (ret < 0) return ret; =20 - ret =3D rf69_set_fifo_fill_condition(dev->spi, always); + ret =3D rf69_set_fifo_fill_condition(pi433->spi, always); if (ret < 0) return ret; } if (rx_cfg->enable_length_byte =3D=3D OPTION_ON) { - ret =3D rf69_set_packet_format(dev->spi, packet_length_var); + ret =3D rf69_set_packet_format(pi433->spi, packet_length_var); if (ret < 0) return ret; } else { - ret =3D rf69_set_packet_format(dev->spi, packet_length_fix); + ret =3D rf69_set_packet_format(pi433->spi, packet_length_fix); if (ret < 0) return ret; } - ret =3D rf69_set_address_filtering(dev->spi, + ret =3D rf69_set_address_filtering(pi433->spi, rx_cfg->enable_address_filtering); if (ret < 0) return ret; =20 if (rx_cfg->enable_crc =3D=3D OPTION_ON) { - ret =3D rf69_enable_crc(dev->spi); + ret =3D rf69_enable_crc(pi433->spi); if (ret < 0) return ret; } else { - ret =3D rf69_disable_crc(dev->spi); + ret =3D rf69_disable_crc(pi433->spi); if (ret < 0) return ret; } =20 /* lengths */ - ret =3D rf69_set_sync_size(dev->spi, rx_cfg->sync_length); + ret =3D rf69_set_sync_size(pi433->spi, rx_cfg->sync_length); if (ret < 0) return ret; if (rx_cfg->enable_length_byte =3D=3D OPTION_ON) { - ret =3D rf69_set_payload_length(dev->spi, 0xff); + ret =3D rf69_set_payload_length(pi433->spi, 0xff); if (ret < 0) return ret; } else if (rx_cfg->fixed_message_length !=3D 0) { @@ -261,26 +261,26 @@ rf69_set_rx_cfg(struct pi433_device *dev, struct pi43= 3_rx_cfg *rx_cfg) payload_length++; if (rx_cfg->enable_address_filtering !=3D filtering_off) payload_length++; - ret =3D rf69_set_payload_length(dev->spi, payload_length); + ret =3D rf69_set_payload_length(pi433->spi, payload_length); if (ret < 0) return ret; } else { - ret =3D rf69_set_payload_length(dev->spi, 0); + ret =3D rf69_set_payload_length(pi433->spi, 0); if (ret < 0) return ret; } =20 /* values */ if (rx_cfg->enable_sync =3D=3D OPTION_ON) { - ret =3D rf69_set_sync_values(dev->spi, rx_cfg->sync_pattern); + ret =3D rf69_set_sync_values(pi433->spi, rx_cfg->sync_pattern); if (ret < 0) return ret; } if (rx_cfg->enable_address_filtering !=3D filtering_off) { - ret =3D rf69_set_node_address(dev->spi, rx_cfg->node_address); + ret =3D rf69_set_node_address(pi433->spi, rx_cfg->node_address); if (ret < 0) return ret; - ret =3D rf69_set_broadcast_address(dev->spi, + ret =3D rf69_set_broadcast_address(pi433->spi, rx_cfg->broadcast_address); if (ret < 0) return ret; @@ -290,76 +290,76 @@ rf69_set_rx_cfg(struct pi433_device *dev, struct pi43= 3_rx_cfg *rx_cfg) } =20 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; =20 - ret =3D rf69_set_frequency(dev->spi, tx_cfg->frequency); + ret =3D rf69_set_frequency(pi433->spi, tx_cfg->frequency); if (ret < 0) return ret; - ret =3D rf69_set_modulation(dev->spi, tx_cfg->modulation); + ret =3D rf69_set_modulation(pi433->spi, tx_cfg->modulation); if (ret < 0) return ret; - ret =3D rf69_set_bit_rate(dev->spi, tx_cfg->bit_rate); + ret =3D rf69_set_bit_rate(pi433->spi, tx_cfg->bit_rate); if (ret < 0) return ret; - ret =3D rf69_set_deviation(dev->spi, tx_cfg->dev_frequency); + ret =3D rf69_set_deviation(pi433->spi, tx_cfg->dev_frequency); if (ret < 0) return ret; - ret =3D rf69_set_pa_ramp(dev->spi, tx_cfg->pa_ramp); + ret =3D rf69_set_pa_ramp(pi433->spi, tx_cfg->pa_ramp); if (ret < 0) return ret; - ret =3D rf69_set_modulation_shaping(dev->spi, tx_cfg->mod_shaping); + ret =3D rf69_set_modulation_shaping(pi433->spi, tx_cfg->mod_shaping); if (ret < 0) return ret; - ret =3D rf69_set_tx_start_condition(dev->spi, tx_cfg->tx_start_condition); + ret =3D rf69_set_tx_start_condition(pi433->spi, tx_cfg->tx_start_conditio= n); if (ret < 0) return ret; =20 /* packet format enable */ if (tx_cfg->enable_preamble =3D=3D OPTION_ON) { - ret =3D rf69_set_preamble_length(dev->spi, + ret =3D rf69_set_preamble_length(pi433->spi, tx_cfg->preamble_length); if (ret < 0) return ret; } else { - ret =3D rf69_set_preamble_length(dev->spi, 0); + ret =3D rf69_set_preamble_length(pi433->spi, 0); if (ret < 0) return ret; } =20 if (tx_cfg->enable_sync =3D=3D OPTION_ON) { - ret =3D rf69_set_sync_size(dev->spi, tx_cfg->sync_length); + ret =3D rf69_set_sync_size(pi433->spi, tx_cfg->sync_length); if (ret < 0) return ret; - ret =3D rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern); + ret =3D rf69_set_sync_values(pi433->spi, tx_cfg->sync_pattern); if (ret < 0) return ret; - ret =3D rf69_enable_sync(dev->spi); + ret =3D rf69_enable_sync(pi433->spi); if (ret < 0) return ret; } else { - ret =3D rf69_disable_sync(dev->spi); + ret =3D rf69_disable_sync(pi433->spi); if (ret < 0) return ret; } =20 if (tx_cfg->enable_length_byte =3D=3D OPTION_ON) { - ret =3D rf69_set_packet_format(dev->spi, packet_length_var); + ret =3D rf69_set_packet_format(pi433->spi, packet_length_var); if (ret < 0) return ret; } else { - ret =3D rf69_set_packet_format(dev->spi, packet_length_fix); + ret =3D rf69_set_packet_format(pi433->spi, packet_length_fix); if (ret < 0) return ret; } =20 if (tx_cfg->enable_crc =3D=3D OPTION_ON) { - ret =3D rf69_enable_crc(dev->spi); + ret =3D rf69_enable_crc(pi433->spi); if (ret < 0) return ret; } else { - ret =3D rf69_disable_crc(dev->spi); + ret =3D rf69_disable_crc(pi433->spi); if (ret < 0) return ret; } @@ -369,38 +369,38 @@ rf69_set_tx_cfg(struct pi433_device *dev, struct pi43= 3_tx_cfg *tx_cfg) =20 /*------------------------------------------------------------------------= -*/ =20 -static int pi433_start_rx(struct pi433_device *dev) +static int pi433_start_rx(struct pi433_device *pi433) { int retval; =20 /* return without action, if no pending read request */ - if (!dev->rx_active) + if (!pi433->rx_active) return 0; =20 /* setup for receiving */ - retval =3D rf69_set_rx_cfg(dev, &dev->rx_cfg); + retval =3D rf69_set_rx_cfg(pi433, &pi433->rx_cfg); if (retval) return retval; =20 /* setup rssi irq */ - retval =3D rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0); + retval =3D rf69_set_dio_mapping(pi433->spi, DIO0, DIO_RSSI_DIO0); if (retval < 0) return retval; - dev->irq_state[DIO0] =3D DIO_RSSI_DIO0; - irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); + pi433->irq_state[DIO0] =3D DIO_RSSI_DIO0; + irq_set_irq_type(pi433->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); =20 /* setup fifo level interrupt */ - retval =3D rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD); + retval =3D rf69_set_fifo_threshold(pi433->spi, FIFO_SIZE - FIFO_THRESHOLD= ); if (retval < 0) return retval; - retval =3D rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL); + retval =3D rf69_set_dio_mapping(pi433->spi, DIO1, DIO_FIFO_LEVEL); if (retval < 0) return retval; - dev->irq_state[DIO1] =3D DIO_FIFO_LEVEL; - irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING); + pi433->irq_state[DIO1] =3D DIO_FIFO_LEVEL; + irq_set_irq_type(pi433->irq_num[DIO1], IRQ_TYPE_EDGE_RISING); =20 /* set module to receiving mode */ - retval =3D rf69_set_mode(dev->spi, receive); + retval =3D rf69_set_mode(pi433->spi, receive); if (retval < 0) return retval; =20 @@ -411,50 +411,50 @@ static int pi433_start_rx(struct pi433_device *dev) =20 static int pi433_receive(void *data) { - struct pi433_device *dev =3D data; - struct spi_device *spi =3D dev->spi; + struct pi433_device *pi433 =3D data; + struct spi_device *spi =3D pi433->spi; int bytes_to_read, bytes_total; int retval; =20 - dev->interrupt_rx_allowed =3D false; + pi433->interrupt_rx_allowed =3D false; =20 /* wait for any tx to finish */ - dev_dbg(dev->dev, "rx: going to wait for any tx to finish\n"); - retval =3D wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active); + dev_dbg(pi433->dev, "rx: going to wait for any tx to finish\n"); + retval =3D wait_event_interruptible(pi433->rx_wait_queue, !pi433->tx_acti= ve); if (retval) { /* wait was interrupted */ - dev->interrupt_rx_allowed =3D true; - wake_up_interruptible(&dev->tx_wait_queue); + pi433->interrupt_rx_allowed =3D true; + wake_up_interruptible(&pi433->tx_wait_queue); return retval; } =20 /* prepare status vars */ - dev->free_in_fifo =3D FIFO_SIZE; - dev->rx_position =3D 0; - dev->rx_bytes_dropped =3D 0; + pi433->free_in_fifo =3D FIFO_SIZE; + pi433->rx_position =3D 0; + pi433->rx_bytes_dropped =3D 0; =20 /* setup radio module to listen for something "in the air" */ - retval =3D pi433_start_rx(dev); + retval =3D pi433_start_rx(pi433); if (retval) return retval; =20 /* now check RSSI, if low wait for getting high (RSSI interrupt) */ while (!(rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI)) { /* allow tx to interrupt us while waiting for high RSSI */ - dev->interrupt_rx_allowed =3D true; - wake_up_interruptible(&dev->tx_wait_queue); + pi433->interrupt_rx_allowed =3D true; + wake_up_interruptible(&pi433->tx_wait_queue); =20 /* wait for RSSI level to become high */ - dev_dbg(dev->dev, "rx: going to wait for high RSSI level\n"); - retval =3D wait_event_interruptible(dev->rx_wait_queue, + dev_dbg(pi433->dev, "rx: going to wait for high RSSI level\n"); + retval =3D wait_event_interruptible(pi433->rx_wait_queue, rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI); if (retval) /* wait was interrupted */ goto abort; - dev->interrupt_rx_allowed =3D false; + pi433->interrupt_rx_allowed =3D false; =20 /* cross check for ongoing tx */ - if (!dev->tx_active) + if (!pi433->tx_active) break; } =20 @@ -462,97 +462,97 @@ static int pi433_receive(void *data) retval =3D rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY); if (retval < 0) goto abort; - dev->irq_state[DIO0] =3D DIO_PAYLOAD_READY; - irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); + pi433->irq_state[DIO0] =3D DIO_PAYLOAD_READY; + irq_set_irq_type(pi433->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); =20 /* fixed or unlimited length? */ - if (dev->rx_cfg.fixed_message_length !=3D 0) { - if (dev->rx_cfg.fixed_message_length > dev->rx_buffer_size) { + if (pi433->rx_cfg.fixed_message_length !=3D 0) { + if (pi433->rx_cfg.fixed_message_length > pi433->rx_buffer_size) { retval =3D -1; goto abort; } - bytes_total =3D dev->rx_cfg.fixed_message_length; - dev_dbg(dev->dev, "rx: msg len set to %d by fixed length\n", + bytes_total =3D pi433->rx_cfg.fixed_message_length; + dev_dbg(pi433->dev, "rx: msg len set to %d by fixed length\n", bytes_total); } else { - bytes_total =3D dev->rx_buffer_size; - dev_dbg(dev->dev, "rx: msg len set to %d as requested by read\n", + bytes_total =3D pi433->rx_buffer_size; + dev_dbg(pi433->dev, "rx: msg len set to %d as requested by read\n", bytes_total); } =20 /* length byte enabled? */ - if (dev->rx_cfg.enable_length_byte =3D=3D OPTION_ON) { - retval =3D wait_event_interruptible(dev->fifo_wait_queue, - dev->free_in_fifo < FIFO_SIZE); + if (pi433->rx_cfg.enable_length_byte =3D=3D OPTION_ON) { + retval =3D wait_event_interruptible(pi433->fifo_wait_queue, + pi433->free_in_fifo < FIFO_SIZE); if (retval) /* wait was interrupted */ goto abort; =20 rf69_read_fifo(spi, (u8 *)&bytes_total, 1); - if (bytes_total > dev->rx_buffer_size) { + if (bytes_total > pi433->rx_buffer_size) { retval =3D -1; goto abort; } - dev->free_in_fifo++; - dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte\n", + pi433->free_in_fifo++; + dev_dbg(pi433->dev, "rx: msg len reset to %d due to length byte\n", bytes_total); } =20 /* address byte enabled? */ - if (dev->rx_cfg.enable_address_filtering !=3D filtering_off) { + if (pi433->rx_cfg.enable_address_filtering !=3D filtering_off) { u8 dummy; =20 bytes_total--; =20 - retval =3D wait_event_interruptible(dev->fifo_wait_queue, - dev->free_in_fifo < FIFO_SIZE); + retval =3D wait_event_interruptible(pi433->fifo_wait_queue, + pi433->free_in_fifo < FIFO_SIZE); if (retval) /* wait was interrupted */ goto abort; =20 rf69_read_fifo(spi, &dummy, 1); - dev->free_in_fifo++; - dev_dbg(dev->dev, "rx: address byte stripped off\n"); + pi433->free_in_fifo++; + dev_dbg(pi433->dev, "rx: address byte stripped off\n"); } =20 /* 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))= { - retval =3D wait_event_interruptible(dev->fifo_wait_queue, - dev->free_in_fifo < FIFO_SIZE); + retval =3D wait_event_interruptible(pi433->fifo_wait_queue, + pi433->free_in_fifo < FIFO_SIZE); if (retval) /* wait was interrupted */ goto abort; } =20 /* need to drop bytes or acquire? */ - if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped) - bytes_to_read =3D dev->rx_bytes_to_drop - - dev->rx_bytes_dropped; + if (pi433->rx_bytes_to_drop > pi433->rx_bytes_dropped) + bytes_to_read =3D pi433->rx_bytes_to_drop - + pi433->rx_bytes_dropped; else - bytes_to_read =3D bytes_total - dev->rx_position; + bytes_to_read =3D bytes_total - pi433->rx_position; =20 /* access the fifo */ - if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo) - bytes_to_read =3D FIFO_SIZE - dev->free_in_fifo; + if (bytes_to_read > FIFO_SIZE - pi433->free_in_fifo) + bytes_to_read =3D FIFO_SIZE - pi433->free_in_fifo; retval =3D rf69_read_fifo(spi, - &dev->rx_buffer[dev->rx_position], + &pi433->rx_buffer[pi433->rx_position], bytes_to_read); if (retval) /* read failed */ goto abort; =20 - dev->free_in_fifo +=3D bytes_to_read; + pi433->free_in_fifo +=3D bytes_to_read; =20 /* adjust status vars */ - if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped) - dev->rx_bytes_dropped +=3D bytes_to_read; + if (pi433->rx_bytes_to_drop > pi433->rx_bytes_dropped) + pi433->rx_bytes_dropped +=3D bytes_to_read; else - dev->rx_position +=3D bytes_to_read; + pi433->rx_position +=3D bytes_to_read; } =20 /* rx done, wait was interrupted or error occurred */ abort: - dev->interrupt_rx_allowed =3D true; - if (rf69_set_mode(dev->spi, standby)) + pi433->interrupt_rx_allowed =3D true; + if (rf69_set_mode(pi433->spi, standby)) 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); =20 if (retval) return retval; @@ -562,8 +562,8 @@ static int pi433_receive(void *data) =20 static int pi433_tx_thread(void *data) { - struct pi433_device *device =3D data; - struct spi_device *spi =3D device->spi; + struct pi433_device *pi433 =3D data; + struct spi_device *spi =3D pi433->spi; struct pi433_tx_cfg tx_cfg; size_t size; bool rx_interrupted =3D false; @@ -572,9 +572,9 @@ static int pi433_tx_thread(void *data) =20 while (1) { /* wait for fifo to be populated or for request to terminate*/ - dev_dbg(device->dev, "thread: going to wait for new messages\n"); - wait_event_interruptible(device->tx_wait_queue, - (!kfifo_is_empty(&device->tx_fifo) || + dev_dbg(pi433->dev, "thread: going to wait for new messages\n"); + wait_event_interruptible(pi433->tx_wait_queue, + (!kfifo_is_empty(&pi433->tx_fifo) || kthread_should_stop())); if (kthread_should_stop()) return 0; @@ -585,17 +585,17 @@ static int pi433_tx_thread(void *data) * - size of message * - message */ - retval =3D kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg)); + retval =3D kfifo_out(&pi433->tx_fifo, &tx_cfg, sizeof(tx_cfg)); if (retval !=3D sizeof(tx_cfg)) { - dev_dbg(device->dev, + dev_dbg(pi433->dev, "reading tx_cfg from fifo failed: got %d byte(s), expected %d\n", retval, (unsigned int)sizeof(tx_cfg)); continue; } =20 - retval =3D kfifo_out(&device->tx_fifo, &size, sizeof(size_t)); + retval =3D kfifo_out(&pi433->tx_fifo, &size, sizeof(size_t)); if (retval !=3D sizeof(size_t)) { - dev_dbg(device->dev, + dev_dbg(pi433->dev, "reading msg size from fifo failed: got %d, expected %d\n", retval, (unsigned int)sizeof(size_t)); continue; @@ -614,7 +614,7 @@ static int pi433_tx_thread(void *data) size++; =20 /* prime tx_buffer */ - memset(device->tx_buffer, 0, size); + memset(pi433->tx_buffer, 0, size); position =3D 0; =20 /* add length byte, if requested */ @@ -623,16 +623,16 @@ static int pi433_tx_thread(void *data) * according to spec, length byte itself must be * excluded from the length calculation */ - device->tx_buffer[position++] =3D size - 1; + pi433->tx_buffer[position++] =3D size - 1; =20 /* add adr byte, if requested */ if (tx_cfg.enable_address_byte =3D=3D OPTION_ON) - device->tx_buffer[position++] =3D tx_cfg.address_byte; + pi433->tx_buffer[position++] =3D tx_cfg.address_byte; =20 /* finally get message data from fifo */ - retval =3D kfifo_out(&device->tx_fifo, &device->tx_buffer[position], - sizeof(device->tx_buffer) - position); - dev_dbg(device->dev, + retval =3D kfifo_out(&pi433->tx_fifo, &pi433->tx_buffer[position], + sizeof(pi433->tx_buffer) - position); + dev_dbg(pi433->dev, "read %d message byte(s) from fifo queue.\n", retval); =20 /* @@ -642,23 +642,23 @@ static int pi433_tx_thread(void *data) * place otherwise we need to wait for the incoming telegram * to finish */ - wait_event_interruptible(device->tx_wait_queue, - !device->rx_active || - device->interrupt_rx_allowed); + wait_event_interruptible(pi433->tx_wait_queue, + !pi433->rx_active || + pi433->interrupt_rx_allowed); =20 /* * prevent race conditions * irq will be re-enabled after tx config is set */ - disable_irq(device->irq_num[DIO0]); - device->tx_active =3D true; + disable_irq(pi433->irq_num[DIO0]); + pi433->tx_active =3D true; =20 /* clear fifo, set fifo threshold, set payload length */ retval =3D rf69_set_mode(spi, standby); /* this clears the fifo */ if (retval < 0) goto abort; =20 - if (device->rx_active && !rx_interrupted) { + if (pi433->rx_active && !rx_interrupted) { /* * rx is currently waiting for a telegram; * we need to set the radio module to standby @@ -680,7 +680,7 @@ static int pi433_tx_thread(void *data) } =20 /* configure the rf chip */ - retval =3D rf69_set_tx_cfg(device, &tx_cfg); + retval =3D rf69_set_tx_cfg(pi433, &tx_cfg); if (retval < 0) goto abort; =20 @@ -688,16 +688,16 @@ static int pi433_tx_thread(void *data) retval =3D rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL); if (retval < 0) goto abort; - device->irq_state[DIO1] =3D DIO_FIFO_LEVEL; - irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING); + pi433->irq_state[DIO1] =3D DIO_FIFO_LEVEL; + irq_set_irq_type(pi433->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING); =20 /* enable packet sent interrupt */ retval =3D rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT); if (retval < 0) goto abort; - device->irq_state[DIO0] =3D DIO_PACKET_SENT; - irq_set_irq_type(device->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); - enable_irq(device->irq_num[DIO0]); /* was disabled by rx active check */ + pi433->irq_state[DIO0] =3D DIO_PACKET_SENT; + irq_set_irq_type(pi433->irq_num[DIO0], IRQ_TYPE_EDGE_RISING); + enable_irq(pi433->irq_num[DIO0]); /* was disabled by rx active check */ =20 /* enable transmission */ retval =3D rf69_set_mode(spi, transmit); @@ -705,61 +705,61 @@ static int pi433_tx_thread(void *data) goto abort; =20 /* transfer this msg (and repetitions) to chip fifo */ - device->free_in_fifo =3D FIFO_SIZE; + pi433->free_in_fifo =3D FIFO_SIZE; position =3D 0; repetitions =3D tx_cfg.repetitions; 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 */ - int write_size =3D device->free_in_fifo; + int write_size =3D pi433->free_in_fifo; =20 - device->free_in_fifo =3D 0; + pi433->free_in_fifo =3D 0; rf69_write_fifo(spi, - &device->tx_buffer[position], + &pi433->tx_buffer[position], write_size); position +=3D write_size; } else { /* msg fits into fifo - take all */ - device->free_in_fifo -=3D size; + pi433->free_in_fifo -=3D size; repetitions--; rf69_write_fifo(spi, - &device->tx_buffer[position], + &pi433->tx_buffer[position], (size - position)); position =3D 0; /* reset for next repetition */ } =20 - retval =3D wait_event_interruptible(device->fifo_wait_queue, - device->free_in_fifo > 0); + retval =3D wait_event_interruptible(pi433->fifo_wait_queue, + pi433->free_in_fifo > 0); if (retval) { - dev_dbg(device->dev, "ABORT\n"); + dev_dbg(pi433->dev, "ABORT\n"); goto abort; } } =20 /* 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"); - wait_event_interruptible(device->fifo_wait_queue, - device->free_in_fifo =3D=3D FIFO_SIZE || + wait_event_interruptible(pi433->fifo_wait_queue, + pi433->free_in_fifo =3D=3D FIFO_SIZE || kthread_should_stop()); if (kthread_should_stop()) return 0; =20 /* 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 =3D rf69_set_mode(spi, standby); if (retval < 0) goto abort; =20 /* everything sent? */ - if (kfifo_is_empty(&device->tx_fifo)) { + if (kfifo_is_empty(&pi433->tx_fifo)) { abort: if (rx_interrupted) { rx_interrupted =3D false; - pi433_start_rx(device); + pi433_start_rx(pi433); } - device->tx_active =3D false; - wake_up_interruptible(&device->rx_wait_queue); + pi433->tx_active =3D false; + wake_up_interruptible(&pi433->rx_wait_queue); } } } @@ -770,7 +770,7 @@ static ssize_t pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos) { struct pi433_instance *instance; - struct pi433_device *device; + struct pi433_device *pi433; int bytes_received; ssize_t retval; =20 @@ -779,31 +779,31 @@ pi433_read(struct file *filp, char __user *buf, size_= t size, loff_t *f_pos) return -EMSGSIZE; =20 instance =3D filp->private_data; - device =3D instance->device; + pi433 =3D instance->pi433; =20 /* just one read request at a time */ - mutex_lock(&device->rx_lock); - if (device->rx_active) { - mutex_unlock(&device->rx_lock); + mutex_lock(&pi433->rx_lock); + if (pi433->rx_active) { + mutex_unlock(&pi433->rx_lock); return -EAGAIN; } =20 - device->rx_active =3D true; - mutex_unlock(&device->rx_lock); + pi433->rx_active =3D true; + mutex_unlock(&pi433->rx_lock); =20 /* start receiving */ /* will block until something was received*/ - device->rx_buffer_size =3D size; - bytes_received =3D pi433_receive(device); + pi433->rx_buffer_size =3D size; + bytes_received =3D pi433_receive(pi433); =20 /* release rx */ - mutex_lock(&device->rx_lock); - device->rx_active =3D false; - mutex_unlock(&device->rx_lock); + mutex_lock(&pi433->rx_lock); + pi433->rx_active =3D false; + mutex_unlock(&pi433->rx_lock); =20 /* if read was successful copy to user space*/ if (bytes_received > 0) { - retval =3D copy_to_user(buf, device->rx_buffer, bytes_received); + retval =3D copy_to_user(buf, pi433->rx_buffer, bytes_received); if (retval) return -EFAULT; } @@ -816,12 +816,12 @@ pi433_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { struct pi433_instance *instance; - struct pi433_device *device; + struct pi433_device *pi433; int retval; unsigned int required, available, copied; =20 instance =3D filp->private_data; - device =3D instance->device; + pi433 =3D instance->pi433; =20 /* * check, whether internal buffer (tx thread) is big enough @@ -835,7 +835,7 @@ pi433_write(struct file *filp, const char __user *buf, * config the RF trasmitter correctly due to invalid settings */ 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"= ); return -EINVAL; } @@ -846,49 +846,49 @@ pi433_write(struct file *filp, const char __user *buf, * - size of message * - message */ - mutex_lock(&device->tx_fifo_lock); + mutex_lock(&pi433->tx_fifo_lock); =20 required =3D sizeof(instance->tx_cfg) + sizeof(size_t) + count; - available =3D kfifo_avail(&device->tx_fifo); + available =3D kfifo_avail(&pi433->tx_fifo); if (required > available) { - dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d ava= ilable\n", + dev_dbg(pi433->dev, "write to fifo failed: %d bytes required but %d avai= lable\n", required, available); - mutex_unlock(&device->tx_fifo_lock); + mutex_unlock(&pi433->tx_fifo_lock); return -EAGAIN; } =20 - retval =3D kfifo_in(&device->tx_fifo, &instance->tx_cfg, + retval =3D kfifo_in(&pi433->tx_fifo, &instance->tx_cfg, sizeof(instance->tx_cfg)); if (retval !=3D sizeof(instance->tx_cfg)) goto abort; =20 - retval =3D kfifo_in(&device->tx_fifo, &count, sizeof(size_t)); + retval =3D kfifo_in(&pi433->tx_fifo, &count, sizeof(size_t)); if (retval !=3D sizeof(size_t)) goto abort; =20 - retval =3D kfifo_from_user(&device->tx_fifo, buf, count, &copied); + retval =3D kfifo_from_user(&pi433->tx_fifo, buf, count, &copied); if (retval || copied !=3D count) goto abort; =20 - mutex_unlock(&device->tx_fifo_lock); + mutex_unlock(&pi433->tx_fifo_lock); =20 /* start transfer */ - wake_up_interruptible(&device->tx_wait_queue); - dev_dbg(device->dev, "write: generated new msg with %d bytes.\n", copied); + wake_up_interruptible(&pi433->tx_wait_queue); + dev_dbg(pi433->dev, "write: generated new msg with %d bytes.\n", copied); =20 return copied; =20 abort: - dev_warn(device->dev, + dev_warn(pi433->dev, "write to fifo failed, non recoverable: 0x%x\n", retval); - mutex_unlock(&device->tx_fifo_lock); + mutex_unlock(&pi433->tx_fifo_lock); return -EAGAIN; } =20 static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long= arg) { struct pi433_instance *instance; - struct pi433_device *device; + struct pi433_device *pi433; struct pi433_tx_cfg tx_cfg; void __user *argp =3D (void __user *)arg; =20 @@ -897,9 +897,9 @@ static long pi433_ioctl(struct file *filp, unsigned int= cmd, unsigned long arg) return -ENOTTY; =20 instance =3D filp->private_data; - device =3D instance->device; + pi433 =3D instance->pi433; =20 - if (!device) + if (!pi433) return -ESHUTDOWN; =20 switch (cmd) { @@ -911,32 +911,32 @@ static long pi433_ioctl(struct file *filp, unsigned i= nt cmd, unsigned long arg) case PI433_IOC_WR_TX_CFG: if (copy_from_user(&tx_cfg, argp, sizeof(struct pi433_tx_cfg))) 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)); instance->tx_cfg_initialized =3D true; - mutex_unlock(&device->tx_fifo_lock); + mutex_unlock(&pi433->tx_fifo_lock); break; 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))) return -EFAULT; break; case PI433_IOC_WR_RX_CFG: - mutex_lock(&device->rx_lock); + mutex_lock(&pi433->rx_lock); =20 /* during pending read request, change of config not allowed */ - if (device->rx_active) { - mutex_unlock(&device->rx_lock); + if (pi433->rx_active) { + mutex_unlock(&pi433->rx_lock); return -EAGAIN; } =20 - if (copy_from_user(&device->rx_cfg, argp, + if (copy_from_user(&pi433->rx_cfg, argp, sizeof(struct pi433_rx_cfg))) { - mutex_unlock(&device->rx_lock); + mutex_unlock(&pi433->rx_lock); return -EFAULT; } =20 - mutex_unlock(&device->rx_lock); + mutex_unlock(&pi433->rx_lock); break; default: return -EINVAL; @@ -949,13 +949,13 @@ static long pi433_ioctl(struct file *filp, unsigned i= nt cmd, unsigned long arg) =20 static int pi433_open(struct inode *inode, struct file *filp) { - struct pi433_device *device; + struct pi433_device *pi433; struct pi433_instance *instance; =20 mutex_lock(&minor_lock); - device =3D idr_find(&pi433_idr, iminor(inode)); + pi433 =3D idr_find(&pi433_idr, iminor(inode)); mutex_unlock(&minor_lock); - if (!device) { + if (!pi433) { pr_debug("device: minor %d unknown.\n", iminor(inode)); return -ENODEV; } @@ -965,7 +965,7 @@ static int pi433_open(struct inode *inode, struct file = *filp) return -ENOMEM; =20 /* setup instance data*/ - instance->device =3D device; + instance->pi433 =3D pi433; =20 /* instance data as context */ filp->private_data =3D instance; @@ -987,7 +987,7 @@ static int pi433_release(struct inode *inode, struct fi= le *filp) =20 /*------------------------------------------------------------------------= -*/ =20 -static int setup_gpio(struct pi433_device *device) +static int setup_gpio(struct pi433_device *pi433) { char name[5]; int retval; @@ -1000,89 +1000,89 @@ static int setup_gpio(struct pi433_device *device) for (i =3D 0; i < NUM_DIO; i++) { /* "construct" name and get the gpio descriptor */ snprintf(name, sizeof(name), "DIO%d", i); - device->gpiod[i] =3D gpiod_get(&device->spi->dev, name, - 0 /*GPIOD_IN*/); + pi433->gpiod[i] =3D gpiod_get(&pi433->spi->dev, name, + 0 /*GPIOD_IN*/); =20 - if (device->gpiod[i] =3D=3D ERR_PTR(-ENOENT)) { - dev_dbg(&device->spi->dev, + if (pi433->gpiod[i] =3D=3D ERR_PTR(-ENOENT)) { + dev_dbg(&pi433->spi->dev, "Could not find entry for %s. Ignoring.\n", name); continue; } =20 - if (device->gpiod[i] =3D=3D ERR_PTR(-EBUSY)) - dev_dbg(&device->spi->dev, "%s is busy.\n", name); + if (pi433->gpiod[i] =3D=3D ERR_PTR(-EBUSY)) + dev_dbg(&pi433->spi->dev, "%s is busy.\n", name); =20 - if (IS_ERR(device->gpiod[i])) { - retval =3D PTR_ERR(device->gpiod[i]); + if (IS_ERR(pi433->gpiod[i])) { + retval =3D PTR_ERR(pi433->gpiod[i]); /* release already allocated gpios */ for (i--; i >=3D 0; i--) { - free_irq(device->irq_num[i], device); - gpiod_put(device->gpiod[i]); + free_irq(pi433->irq_num[i], pi433); + gpiod_put(pi433->gpiod[i]); } return retval; } =20 /* configure the pin */ - retval =3D gpiod_direction_input(device->gpiod[i]); + retval =3D gpiod_direction_input(pi433->gpiod[i]); if (retval) return retval; =20 /* configure irq */ - device->irq_num[i] =3D gpiod_to_irq(device->gpiod[i]); - if (device->irq_num[i] < 0) { - device->gpiod[i] =3D ERR_PTR(-EINVAL); - return device->irq_num[i]; + pi433->irq_num[i] =3D gpiod_to_irq(pi433->gpiod[i]); + if (pi433->irq_num[i] < 0) { + pi433->gpiod[i] =3D ERR_PTR(-EINVAL); + return pi433->irq_num[i]; } - retval =3D request_irq(device->irq_num[i], + retval =3D request_irq(pi433->irq_num[i], DIO_irq_handler[i], 0, /* flags */ name, - device); + pi433); =20 if (retval) return retval; =20 - dev_dbg(&device->spi->dev, "%s successfully configured\n", name); + dev_dbg(&pi433->spi->dev, "%s successfully configured\n", name); } =20 return 0; } =20 -static void free_gpio(struct pi433_device *device) +static void free_gpio(struct pi433_device *pi433) { int i; =20 for (i =3D 0; i < NUM_DIO; i++) { /* check if gpiod is valid */ - if (IS_ERR(device->gpiod[i])) + if (IS_ERR(pi433->gpiod[i])) continue; =20 - free_irq(device->irq_num[i], device); - gpiod_put(device->gpiod[i]); + free_irq(pi433->irq_num[i], pi433); + gpiod_put(pi433->gpiod[i]); } } =20 -static int pi433_get_minor(struct pi433_device *device) +static int pi433_get_minor(struct pi433_device *pi433) { int retval =3D -ENOMEM; =20 mutex_lock(&minor_lock); - retval =3D idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL); + retval =3D idr_alloc(&pi433_idr, pi433, 0, N_PI433_MINORS, GFP_KERNEL); if (retval >=3D 0) { - device->minor =3D retval; + pi433->minor =3D retval; retval =3D 0; } else if (retval =3D=3D -ENOSPC) { - dev_err(&device->spi->dev, "too many pi433 devices\n"); + dev_err(&pi433->spi->dev, "too many pi433 devices\n"); retval =3D -EINVAL; } mutex_unlock(&minor_lock); return retval; } =20 -static void pi433_free_minor(struct pi433_device *dev) +static void pi433_free_minor(struct pi433_device *pi433) { mutex_lock(&minor_lock); - idr_remove(&pi433_idr, dev->minor); + idr_remove(&pi433_idr, pi433->minor); mutex_unlock(&minor_lock); } =20 @@ -1106,35 +1106,35 @@ static const struct file_operations pi433_fops =3D { =20 static int pi433_debugfs_regs_show(struct seq_file *m, void *p) { - struct pi433_device *dev; + struct pi433_device *pi433; u8 reg_data[114]; int i; char *fmt =3D "0x%02x, 0x%02x\n"; int ret; =20 - dev =3D m->private; + pi433 =3D m->private; =20 - mutex_lock(&dev->tx_fifo_lock); - mutex_lock(&dev->rx_lock); + mutex_lock(&pi433->tx_fifo_lock); + mutex_lock(&pi433->rx_lock); =20 // wait for on-going operations to finish - ret =3D wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active); + ret =3D wait_event_interruptible(pi433->rx_wait_queue, !pi433->tx_active); if (ret) goto out_unlock; =20 - ret =3D wait_event_interruptible(dev->tx_wait_queue, !dev->rx_active); + ret =3D wait_event_interruptible(pi433->tx_wait_queue, !pi433->rx_active); if (ret) goto out_unlock; =20 // skip FIFO register (0x0) otherwise this can affect some of uC ops for (i =3D 1; i < 0x50; i++) - reg_data[i] =3D rf69_read_reg(dev->spi, i); + reg_data[i] =3D rf69_read_reg(pi433->spi, i); =20 - reg_data[REG_TESTLNA] =3D rf69_read_reg(dev->spi, REG_TESTLNA); - reg_data[REG_TESTPA1] =3D rf69_read_reg(dev->spi, REG_TESTPA1); - reg_data[REG_TESTPA2] =3D rf69_read_reg(dev->spi, REG_TESTPA2); - reg_data[REG_TESTDAGC] =3D rf69_read_reg(dev->spi, REG_TESTDAGC); - reg_data[REG_TESTAFC] =3D rf69_read_reg(dev->spi, REG_TESTAFC); + reg_data[REG_TESTLNA] =3D rf69_read_reg(pi433->spi, REG_TESTLNA); + reg_data[REG_TESTPA1] =3D rf69_read_reg(pi433->spi, REG_TESTPA1); + reg_data[REG_TESTPA2] =3D rf69_read_reg(pi433->spi, REG_TESTPA2); + reg_data[REG_TESTDAGC] =3D rf69_read_reg(pi433->spi, REG_TESTDAGC); + reg_data[REG_TESTAFC] =3D rf69_read_reg(pi433->spi, REG_TESTAFC); =20 seq_puts(m, "# reg, val\n"); =20 @@ -1148,8 +1148,8 @@ static int pi433_debugfs_regs_show(struct seq_file *m= , void *p) seq_printf(m, fmt, REG_TESTAFC, reg_data[REG_TESTAFC]); =20 out_unlock: - mutex_unlock(&dev->rx_lock); - mutex_unlock(&dev->tx_fifo_lock); + mutex_unlock(&pi433->rx_lock); + mutex_unlock(&pi433->tx_fifo_lock); =20 return ret; } @@ -1159,7 +1159,7 @@ DEFINE_SHOW_ATTRIBUTE(pi433_debugfs_regs); =20 static int pi433_probe(struct spi_device *spi) { - struct pi433_device *device; + struct pi433_device *pi433; int retval; struct dentry *entry; =20 @@ -1196,37 +1196,37 @@ static int pi433_probe(struct spi_device *spi) } =20 /* Allocate driver data */ - device =3D kzalloc(sizeof(*device), GFP_KERNEL); - if (!device) + pi433 =3D kzalloc(sizeof(*pi433), GFP_KERNEL); + if (!pi433) return -ENOMEM; =20 /* Initialize the driver data */ - device->spi =3D spi; - device->rx_active =3D false; - device->tx_active =3D false; - device->interrupt_rx_allowed =3D false; + pi433->spi =3D spi; + pi433->rx_active =3D false; + pi433->tx_active =3D false; + pi433->interrupt_rx_allowed =3D false; =20 /* init rx buffer */ - device->rx_buffer =3D kmalloc(MAX_MSG_SIZE, GFP_KERNEL); - if (!device->rx_buffer) { + pi433->rx_buffer =3D kmalloc(MAX_MSG_SIZE, GFP_KERNEL); + if (!pi433->rx_buffer) { retval =3D -ENOMEM; goto RX_failed; } =20 /* init wait queues */ - init_waitqueue_head(&device->tx_wait_queue); - init_waitqueue_head(&device->rx_wait_queue); - init_waitqueue_head(&device->fifo_wait_queue); + init_waitqueue_head(&pi433->tx_wait_queue); + init_waitqueue_head(&pi433->rx_wait_queue); + init_waitqueue_head(&pi433->fifo_wait_queue); =20 /* init fifo */ - INIT_KFIFO(device->tx_fifo); + INIT_KFIFO(pi433->tx_fifo); =20 /* init mutexes and locks */ - mutex_init(&device->tx_fifo_lock); - mutex_init(&device->rx_lock); + mutex_init(&pi433->tx_fifo_lock); + mutex_init(&pi433->rx_lock); =20 /* setup GPIO (including irq_handler) for the different DIOs */ - retval =3D setup_gpio(device); + retval =3D setup_gpio(pi433); if (retval) { dev_dbg(&spi->dev, "setup of GPIOs failed\n"); goto GPIO_failed; @@ -1256,105 +1256,105 @@ static int pi433_probe(struct spi_device *spi) goto minor_failed; =20 /* determ minor number */ - retval =3D pi433_get_minor(device); + retval =3D pi433_get_minor(pi433); if (retval) { dev_dbg(&spi->dev, "get of minor number failed\n"); goto minor_failed; } =20 /* create device */ - device->devt =3D MKDEV(MAJOR(pi433_dev), device->minor); - device->dev =3D device_create(&pi433_class, - &spi->dev, - device->devt, - device, - "pi433.%d", - device->minor); - if (IS_ERR(device->dev)) { + pi433->devt =3D MKDEV(MAJOR(pi433_dev), pi433->minor); + pi433->dev =3D device_create(&pi433_class, + &spi->dev, + pi433->devt, + pi433, + "pi433.%d", + pi433->minor); + if (IS_ERR(pi433->dev)) { pr_err("pi433: device register failed\n"); - retval =3D PTR_ERR(device->dev); + retval =3D PTR_ERR(pi433->dev); goto device_create_failed; } else { - dev_dbg(device->dev, + dev_dbg(pi433->dev, "created device for major %d, minor %d\n", MAJOR(pi433_dev), - device->minor); + pi433->minor); } =20 /* start tx thread */ - device->tx_task_struct =3D kthread_run(pi433_tx_thread, - device, - "pi433.%d_tx_task", - device->minor); - if (IS_ERR(device->tx_task_struct)) { - dev_dbg(device->dev, "start of send thread failed\n"); - retval =3D PTR_ERR(device->tx_task_struct); + pi433->tx_task_struct =3D kthread_run(pi433_tx_thread, + pi433, + "pi433.%d_tx_task", + pi433->minor); + if (IS_ERR(pi433->tx_task_struct)) { + dev_dbg(pi433->dev, "start of send thread failed\n"); + retval =3D PTR_ERR(pi433->tx_task_struct); goto send_thread_failed; } =20 /* create cdev */ - device->cdev =3D cdev_alloc(); - if (!device->cdev) { - dev_dbg(device->dev, "allocation of cdev failed\n"); + pi433->cdev =3D cdev_alloc(); + if (!pi433->cdev) { + dev_dbg(pi433->dev, "allocation of cdev failed\n"); retval =3D -ENOMEM; goto cdev_failed; } - device->cdev->owner =3D THIS_MODULE; - cdev_init(device->cdev, &pi433_fops); - retval =3D cdev_add(device->cdev, device->devt, 1); + pi433->cdev->owner =3D THIS_MODULE; + cdev_init(pi433->cdev, &pi433_fops); + retval =3D cdev_add(pi433->cdev, pi433->devt, 1); if (retval) { - dev_dbg(device->dev, "register of cdev failed\n"); + dev_dbg(pi433->dev, "register of cdev failed\n"); goto del_cdev; } =20 /* spi setup */ - spi_set_drvdata(spi, device); + spi_set_drvdata(spi, pi433); =20 - entry =3D debugfs_create_dir(dev_name(device->dev), root_dir); - debugfs_create_file("regs", 0400, entry, device, &pi433_debugfs_regs_fops= ); + entry =3D debugfs_create_dir(dev_name(pi433->dev), root_dir); + debugfs_create_file("regs", 0400, entry, pi433, &pi433_debugfs_regs_fops); =20 return 0; =20 del_cdev: - cdev_del(device->cdev); + cdev_del(pi433->cdev); cdev_failed: - kthread_stop(device->tx_task_struct); + kthread_stop(pi433->tx_task_struct); send_thread_failed: - device_destroy(&pi433_class, device->devt); + device_destroy(&pi433_class, pi433->devt); device_create_failed: - pi433_free_minor(device); + pi433_free_minor(pi433); minor_failed: - free_gpio(device); + free_gpio(pi433); GPIO_failed: - kfree(device->rx_buffer); + kfree(pi433->rx_buffer); RX_failed: - kfree(device); + kfree(pi433); =20 return retval; } =20 static void pi433_remove(struct spi_device *spi) { - struct pi433_device *device =3D spi_get_drvdata(spi); + struct pi433_device *pi433 =3D spi_get_drvdata(spi); =20 - debugfs_lookup_and_remove(dev_name(device->dev), root_dir); + debugfs_lookup_and_remove(dev_name(pi433->dev), root_dir); =20 /* free GPIOs */ - free_gpio(device); + free_gpio(pi433); =20 /* make sure ops on existing fds can abort cleanly */ - device->spi =3D NULL; + pi433->spi =3D NULL; =20 - kthread_stop(device->tx_task_struct); + kthread_stop(pi433->tx_task_struct); =20 - device_destroy(&pi433_class, device->devt); + device_destroy(&pi433_class, pi433->devt); =20 - cdev_del(device->cdev); + cdev_del(pi433->cdev); =20 - pi433_free_minor(device); + pi433_free_minor(pi433); =20 - kfree(device->rx_buffer); - kfree(device); + kfree(pi433->rx_buffer); + kfree(pi433); } =20 static const struct of_device_id pi433_dt_ids[] =3D { --=20 2.34.1