From commits-return-7169-archive-asf-public=cust-asf.ponee.io@nuttx.apache.org Tue Apr 14 20:00:52 2020 Return-Path: X-Original-To: archive-asf-public@cust-asf.ponee.io Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [207.244.88.153]) by mx-eu-01.ponee.io (Postfix) with SMTP id 3AA3A1806C4 for ; Tue, 14 Apr 2020 22:00:50 +0200 (CEST) Received: (qmail 13735 invoked by uid 500); 14 Apr 2020 20:00:49 -0000 Mailing-List: contact commits-help@nuttx.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@nuttx.apache.org Delivered-To: mailing list commits@nuttx.apache.org Received: (qmail 13323 invoked by uid 99); 14 Apr 2020 20:00:48 -0000 Received: from ec2-52-202-80-70.compute-1.amazonaws.com (HELO gitbox.apache.org) (52.202.80.70) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 14 Apr 2020 20:00:48 +0000 Received: by gitbox.apache.org (ASF Mail Server at gitbox.apache.org, from userid 33) id 6606A8B6AA; Tue, 14 Apr 2020 20:00:48 +0000 (UTC) Date: Tue, 14 Apr 2020 20:00:54 +0000 To: "commits@nuttx.apache.org" Subject: [incubator-nuttx] 08/31: PR350 Coding Standard Corrections MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit From: gnutt@apache.org In-Reply-To: <158689444651.3074.17147407354404335857@gitbox.apache.org> References: <158689444651.3074.17147407354404335857@gitbox.apache.org> X-Git-Host: gitbox.apache.org X-Git-Repo: incubator-nuttx X-Git-Refname: refs/heads/SocketCAN X-Git-Reftype: branch X-Git-Rev: 3f8c22a64d545fbf19d4a61b08e187685f4434b7 X-Git-NotificationType: diff X-Git-Multimail-Version: 1.5.dev Auto-Submitted: auto-generated Message-Id: <20200414200048.6606A8B6AA@gitbox.apache.org> This is an automated email from the ASF dual-hosted git repository. gnutt pushed a commit to branch SocketCAN in repository https://gitbox.apache.org/repos/asf/incubator-nuttx.git commit 3f8c22a64d545fbf19d4a61b08e187685f4434b7 Author: Gregory Nutt AuthorDate: Fri Feb 21 11:17:10 2020 -0600 PR350 Coding Standard Corrections Run all .c and .h files in PR350 through tools/nxstyle and correct all (relevant) errors reported by the tool. Somes files like arch/arm/src/s32k1xx/s32k1xx_flexcan.c did not following the coding standard and received substantial modification. Nothing may enter the NuttX repositories that does not conform to the coding standard! See https://cwiki.apache.org/confluence/display/NUTTX/Coding+Standard --- arch/arm/src/s32k1xx/s32k1xx_flexcan.c | 1027 ++++++++++++++++---------------- include/netpacket/can.h | 10 +- include/nuttx/can.h | 150 ++--- include/nuttx/mm/iob.h | 1 + include/sys/socket.h | 28 +- net/can/can.h | 14 +- net/can/can_callback.c | 80 +-- net/can/can_getsockopt.c | 73 +-- net/can/can_input.c | 50 +- net/can/can_poll.c | 47 +- net/can/can_recvfrom.c | 88 ++- net/can/can_setsockopt.c | 70 +-- net/can/can_sockif.c | 135 +++-- net/socket/getsockopt.c | 8 +- 14 files changed, 844 insertions(+), 937 deletions(-) diff --git a/arch/arm/src/s32k1xx/s32k1xx_flexcan.c b/arch/arm/src/s32k1xx/s32k1xx_flexcan.c index 9c7a7d7..50a5c18 100644 --- a/arch/arm/src/s32k1xx/s32k1xx_flexcan.c +++ b/arch/arm/src/s32k1xx/s32k1xx_flexcan.c @@ -1,35 +1,20 @@ /**************************************************************************** * arch/arm/src/s32k1xx/s32k1xx_flexcan.c * - * Copyright (C) 2019 Gregory Nutt. All rights reserved. - * Authors: Gregory Nutt - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * 3. Neither the name NuttX nor the names of its contributors may be - * used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -102,7 +87,8 @@ /* CONFIG_S32K1XX_FLEXCAN_NETHIFS determines the number of physical interfaces * that will be supported. */ -/* + +#if 0 #if CONFIG_S32K1XX_FLEXCAN_NETHIFS != 1 # error "CONFIG_S32K1XX_FLEXCAN_NETHIFS must be one for now" #endif @@ -113,20 +99,22 @@ #if CONFIG_S32K1XX_FLEXCAN_NRXBUFFERS < 1 # error "Need at least one RX buffer" -#endif*/ +#endif +#endif + +#define MASKSTDID 0x000007ff +#define MASKEXTID 0x1fffffff +#define FLAGEFF (1 << 31) /* Extended frame format */ +#define FLAGRTR (1 << 30) /* Remote transmission request */ -#define MaskStdID 0x000007FF -#define MaskExtID 0x1FFFFFFF -#define FlagEFF (1 << 31) /* Extended frame format */ -#define FlagRTR (1 << 30) /* Remote transmission request */ +/* Fixme nice variables/constants */ -//Fixme nice variables/constants -#define RxMBCount 6 -#define FilterCount 0 -#define RxandFilterMBCount (RxMBCount + FilterCount) -#define TxMBCount 12 //???????????? why 12 idk it works -#define TotalMBcount RxandFilterMBCount + TxMBCount -#define TXMBMask (((1 << TxMBCount)-1) << RxandFilterMBCount) +#define RXMBCOUNT 6 +#define FILTERCOUNT 0 +#define RXANDFILTERMBCOUNT (RXMBCOUNT + FILTERCOUNT) +#define TXMBCOUNT 12 //???????????? why 12 idk it works +#define TOTALMBCOUNT RXANDFILTERMBCOUNT + TXMBCOUNT +#define TXMBMASK (((1 << TXMBCOUNT)-1) << RXANDFILTERMBCOUNT) #define CAN_FIFO_NE (1 << 5) #define CAN_FIFO_OV (1 << 6) @@ -135,9 +123,6 @@ static int peak_tx_mailbox_index_ = 0; - - - /* Normally you would clean the cache after writing new values to the DMA * memory so assure that the dirty cache lines are flushed to memory * before the DMA occurs. And you would invalid the cache after a data is @@ -208,82 +193,81 @@ static int peak_tx_mailbox_index_ = 0; * Private Types ****************************************************************************/ - -union TXcsType +union txcs_e { - volatile uint32_t w; - struct - { - volatile uint32_t time_stamp : 16; - volatile uint32_t dlc : 4; - volatile uint32_t rtr : 1; - volatile uint32_t ide : 1; - volatile uint32_t srr : 1; - volatile uint32_t res : 1; - volatile uint32_t code : 4; - volatile uint32_t res2 : 4; - }; + volatile uint32_t w; + struct + { + volatile uint32_t time_stamp : 16; + volatile uint32_t dlc : 4; + volatile uint32_t rtr : 1; + volatile uint32_t ide : 1; + volatile uint32_t srr : 1; + volatile uint32_t res : 1; + volatile uint32_t code : 4; + volatile uint32_t res2 : 4; + }; }; -union RXcsType +union rxcs_e { - volatile uint32_t cs; - struct - { - volatile uint32_t time_stamp : 16; - volatile uint32_t dlc : 4; - volatile uint32_t rtr : 1; - volatile uint32_t ide : 1; - volatile uint32_t srr : 1; - volatile uint32_t res : 9; - }; + volatile uint32_t cs; + struct + { + volatile uint32_t time_stamp : 16; + volatile uint32_t dlc : 4; + volatile uint32_t rtr : 1; + volatile uint32_t ide : 1; + volatile uint32_t srr : 1; + volatile uint32_t res : 9; + }; }; -union IDType +union id_e { - volatile uint32_t w; - struct - { - volatile uint32_t ext : 29; - volatile uint32_t resex : 3; - }; - struct - { - volatile uint32_t res : 18; - volatile uint32_t std : 11; - volatile uint32_t resstd : 3; - }; + volatile uint32_t w; + struct + { + volatile uint32_t ext : 29; + volatile uint32_t resex : 3; + }; + struct + { + volatile uint32_t res : 18; + volatile uint32_t std : 11; + volatile uint32_t resstd : 3; + }; }; -union DataType +union data_e { - volatile uint32_t l; - volatile uint32_t h; - struct - { - volatile uint32_t b3 : 8; - volatile uint32_t b2 : 8; - volatile uint32_t b1 : 8; - volatile uint32_t b0 : 8; - volatile uint32_t b7 : 8; - volatile uint32_t b6 : 8; - volatile uint32_t b5 : 8; - volatile uint32_t b4 : 8; - }; + volatile uint32_t l; + volatile uint32_t h; + struct + { + volatile uint32_t b3 : 8; + volatile uint32_t b2 : 8; + volatile uint32_t b1 : 8; + volatile uint32_t b0 : 8; + volatile uint32_t b7 : 8; + volatile uint32_t b6 : 8; + volatile uint32_t b5 : 8; + volatile uint32_t b4 : 8; + }; }; -struct MbTx +struct mbtx_s { - union TXcsType CS; - union IDType ID; - union DataType data; + union txcs_e cs; + union id_e id; + union data_e data; }; -struct MbRx +struct mbrx_s { - union RXcsType CS; - union IDType ID; - union DataType data; + union rxcs_e cs; + union id_e id; + union data_e data; }; /* The s32k1xx_driver_s encapsulates all state information for a single @@ -308,12 +292,10 @@ struct s32k1xx_driver_s struct net_driver_s dev; /* Interface understood by the network */ - struct MbRx *rx; - struct MbTx *tx; - + struct mbrx_s *rx; + struct mbtx_s *tx; }; - /**************************************************************************** * Private Data ****************************************************************************/ @@ -323,7 +305,6 @@ static struct s32k1xx_driver_s g_flexcan[CONFIG_S32K1XX_ENET_NETHIFS]; static uint8_t g_desc_pool[2000] __attribute__((aligned(ARMV7M_DCACHE_LINESIZE))); - /**************************************************************************** * Private Function Prototypes ****************************************************************************/ @@ -350,10 +331,11 @@ static int s32k1xx_transmit(FAR struct s32k1xx_driver_s *priv); static int s32k1xx_txpoll(struct net_driver_s *dev); /* Helper functions */ + static void s32k1xx_setenable(uint32_t enable); static void s32k1xx_setfreeze(uint32_t freeze); static uint32_t s32k1xx_waitmcr_change(uint32_t mask, - uint32_t target_state); + uint32_t target_state); /* Interrupt handling */ @@ -363,7 +345,7 @@ static void s32k1xx_txdone(FAR struct s32k1xx_driver_s *priv); static void s32k1xx_flexcan_interrupt_work(FAR void *arg); static int s32k1xx_flexcan_interrupt(int irq, FAR void *context, - FAR void *arg); + FAR void *arg); /* Watchdog timer expirations */ @@ -383,13 +365,13 @@ static int s32k1xx_txavail(struct net_driver_s *dev); #ifdef CONFIG_NET_MCASTGROUP static int s32k1xx_addmac(struct net_driver_s *dev, - FAR const uint8_t *mac); + FAR const uint8_t *mac); static int s32k1xx_rmmac(struct net_driver_s *dev, FAR const uint8_t *mac); #endif #ifdef CONFIG_NETDEV_IOCTL static int s32k1xx_ioctl(struct net_driver_s *dev, int cmd, - unsigned long arg); + unsigned long arg); #endif /* Initialization */ @@ -402,7 +384,6 @@ static void s32k1xx_reset(struct s32k1xx_driver_s *priv); * Private Functions ****************************************************************************/ - /**************************************************************************** * Function: s32k1xx_txringfull * @@ -428,7 +409,7 @@ static bool s32k1xx_txringfull(FAR struct s32k1xx_driver_s *priv) */ txnext = priv->txhead + 1; - + return priv->txtail == txnext; } @@ -452,69 +433,79 @@ static bool s32k1xx_txringfull(FAR struct s32k1xx_driver_s *priv) * ****************************************************************************/ - static int s32k1xx_transmit(FAR struct s32k1xx_driver_s *priv) { #warning Missing logic - struct can_frame *frame = (struct can_frame*)priv->dev.d_buf; + struct can_frame *frame = (struct can_frame *)priv->dev.d_buf; - /*ninfo("CAN id: %i dlc: %i", frame->can_id, frame->can_dlc); +#if 0 + ninfo("CAN id: %i dlc: %i", frame->can_id, frame->can_dlc); - for(int i = 0; i < frame->can_dlc; i++){ - ninfo(" %02X", frame->data[i]); - } - ninfo("\r\n");*/ + for (int i = 0; i < frame->can_dlc; i++) + { + ninfo(" %02X", frame->data[i]); + } + + ninfo("\r\n"); +#endif /* Attempt to write frame */ + uint32_t mbi = 0; - if ((getreg32(S32K1XX_CAN0_ESR2) & (CAN_ESR2_IMB | CAN_ESR2_VPS)) == (CAN_ESR2_IMB | CAN_ESR2_VPS)) - { - mbi = (getreg32(S32K1XX_CAN0_ESR2) & CAN_ESR2_LPTM_MASK) >> CAN_ESR2_LPTM_SHIFT; - } + if ((getreg32(S32K1XX_CAN0_ESR2) & (CAN_ESR2_IMB | CAN_ESR2_VPS)) == + (CAN_ESR2_IMB | CAN_ESR2_VPS)) + { + mbi = (getreg32(S32K1XX_CAN0_ESR2) & CAN_ESR2_LPTM_MASK) >> + CAN_ESR2_LPTM_SHIFT; + } - uint32_t mb_bit = 1 << (RxandFilterMBCount + mbi); + uint32_t mb_bit = 1 << (RXANDFILTERMBCOUNT + mbi); - while (mbi < TxMBCount) - { + while (mbi < TXMBCOUNT) + { + if (priv->tx[mbi].cs.code != CAN_TXMB_DATAORREMOTE) + { + putreg32(mb_bit, S32K1XX_CAN0_IFLAG1); + break; + } - if (priv->tx[mbi].CS.code != CAN_TXMB_DATAORREMOTE) - { - putreg32(mb_bit, S32K1XX_CAN0_IFLAG1); - break; - } - mb_bit <<= 1; - mbi++; - } + mb_bit <<= 1; + mbi++; + } - if ((mbi-RxandFilterMBCount) == TxMBCount) - { - nwarn("No TX MB available mbi %i\r\n", mbi); - return 0; // No transmission for you! - } + if ((mbi - RXANDFILTERMBCOUNT) == TXMBCOUNT) + { + nwarn("No TX MB available mbi %i\r\n", mbi); + return 0; /* No transmission for you! */ + } - peak_tx_mailbox_index_ = (peak_tx_mailbox_index_ > mbi ? peak_tx_mailbox_index_ : mbi ); + peak_tx_mailbox_index_ = + (peak_tx_mailbox_index_ > mbi ? peak_tx_mailbox_index_ : mbi); - union TXcsType cs; + union txcs_e cs; cs.code = CAN_TXMB_DATAORREMOTE; - struct MbTx* mb = &priv->tx[mbi]; - mb->CS.code = CAN_TXMB_INACTIVE; + struct mbtx_s *mb = &priv->tx[mbi]; + mb->cs.code = CAN_TXMB_INACTIVE; - if (0) //FIXME detect Std or Ext id - { - cs.ide = 1; - mb->ID.ext = frame->can_id & MaskExtID; - } + if (0) /* FIXME detect Std or Ext id */ + { + cs.ide = 1; + mb->id.ext = frame->can_id & MASKEXTID; + } else - { - mb->ID.std = frame->can_id & MaskStdID; - } + { + mb->id.std = frame->can_id & MASKSTDID; + } - //cs.rtr = frame.isRemoteTransmissionRequest(); +#if 0 + cs.rtr = frame.isRemoteTransmissionRequest(); +#endif cs.dlc = frame->can_dlc; - //FIXME endian swap instruction or somekind takes 1.5us right now + /* FIXME endian swap instruction or somekind takes 1.5us right now */ + mb->data.b0 = frame->data[0]; mb->data.b1 = frame->data[1]; mb->data.b2 = frame->data[2]; @@ -524,20 +515,22 @@ static int s32k1xx_transmit(FAR struct s32k1xx_driver_s *priv) mb->data.b6 = frame->data[6]; mb->data.b7 = frame->data[7]; - /* - * Registering the pending transmission so we can track its deadline and loopback it as needed +#if 0 + /* Registering the pending transmission so we can track its deadline and + * loopback it as needed */ - /*TxItem& txi = pending_tx_[mbi]; + + txitem& txi = pending_tx_[mbi]; txi.deadline = tx_deadline; txi.frame = frame; txi.loopback = (flags & uavcan::CanIOFlagLoopback) != 0; txi.abort_on_error = (flags & uavcan::CanIOFlagAbortOnError) != 0; - txi.pending = TxItem::busy;*/ - + txi.pending = txitem::busy; +#endif s32k1xx_gpiowrite(PIN_PORTD | PIN31, 0); - mb->CS = cs; // Go. + mb->cs = cs; /* Go. */ uint32_t regval; regval = getreg32(S32K1XX_CAN0_IMASK1); @@ -585,14 +578,15 @@ static int s32k1xx_txpoll(struct net_driver_s *dev) if (priv->dev.d_len > 0) { - if (!devif_loopback(&priv->dev)) { /* Send the packet */ s32k1xx_transmit(priv); - /*priv->dev.d_buf = - (uint8_t *)s32k1xx_swap32((uint32_t)priv->txdesc[priv->txhead].data);*/ +#if 0 + priv->dev.d_buf = + (uint8_t *)s32k1xx_swap32((uint32_t)priv->txdesc[priv->txhead].data); +#endif /* Check if there is room in the device to hold another packet. If * not, return a non-zero value to terminate the poll. @@ -632,7 +626,6 @@ static int s32k1xx_txpoll(struct net_driver_s *dev) static inline void s32k1xx_dispatch(FAR struct s32k1xx_driver_s *priv) { - #warning Missing logic } @@ -656,96 +649,90 @@ static inline void s32k1xx_dispatch(FAR struct s32k1xx_driver_s *priv) static void s32k1xx_receive(FAR struct s32k1xx_driver_s *priv) { #warning Missing logic - //ninfo("FLEXCAN: receive\r\n"); - - s32k1xx_gpiowrite(PIN_PORTD | PIN31, 1); - - struct can_frame frame; - uint32_t flags = getreg32(S32K1XX_CAN0_IFLAG1); - - if ((flags & FIFO_IFLAG1) == 0) - { - // Weird, IRQ is here but no data to read - return; - } + s32k1xx_gpiowrite(PIN_PORTD | PIN31, 1); - if (flags & CAN_FIFO_OV) - { - //error_cnt_++; - putreg32(CAN_FIFO_OV, S32K1XX_CAN0_IFLAG1); - } + struct can_frame frame; + uint32_t flags = getreg32(S32K1XX_CAN0_IFLAG1); - if (flags & CAN_FIFO_WARN) - { - //fifo_warn_cnt_++; - putreg32(CAN_FIFO_WARN, S32K1XX_CAN0_IFLAG1); - } - - if (flags & CAN_FIFO_NE) - { - struct MbRx *rf = priv->rx; + if ((flags & FIFO_IFLAG1) == 0) + { + /* Weird, IRQ is here but no data to read */ - /* - * Read the frame contents - */ + return; + } - if (rf->CS.ide) - { - frame.can_id = MaskExtID & rf->ID.ext; - frame.can_id |= FlagEFF; - } - else - { - frame.can_id = MaskStdID & rf->ID.std; - } + if (flags & CAN_FIFO_OV) + { +#if 0 + error_cnt_++; +#endif + putreg32(CAN_FIFO_OV, S32K1XX_CAN0_IFLAG1); + } - if (rf->CS.rtr) - { - frame.can_id |= FlagRTR; - } + if (flags & CAN_FIFO_WARN) + { +#if 0 + fifo_warn_cnt_++; +#endif + putreg32(CAN_FIFO_WARN, S32K1XX_CAN0_IFLAG1); + } - frame.can_dlc = rf->CS.dlc; + if (flags & CAN_FIFO_NE) + { + struct mbrx_s *rf = priv->rx; - frame.data[0] = rf->data.b0; - frame.data[1] = rf->data.b1; - frame.data[2] = rf->data.b2; - frame.data[3] = rf->data.b3; - frame.data[4] = rf->data.b4; - frame.data[5] = rf->data.b5; - frame.data[6] = rf->data.b6; - frame.data[7] = rf->data.b7; + /* Read the frame contents */ + if (rf->cs.ide) + { + frame.can_id = MASKEXTID & rf->id.ext; + frame.can_id |= FLAGEFF; + } + else + { + frame.can_id = MASKSTDID & rf->id.std; + } - putreg32(CAN_FIFO_NE, S32K1XX_CAN0_IFLAG1); + if (rf->cs.rtr) + { + frame.can_id |= FLAGRTR; + } - /* Copy the buffer pointer to priv->dev.d_buf. Set amount of data - * in priv->dev.d_len - */ + frame.can_dlc = rf->cs.dlc; - priv->dev.d_len = sizeof(struct can_frame); - priv->dev.d_buf = - (uint8_t *)s32k1xx_swap32((uint32_t)&frame); //FIXME + frame.data[0] = rf->data.b0; + frame.data[1] = rf->data.b1; + frame.data[2] = rf->data.b2; + frame.data[3] = rf->data.b3; + frame.data[4] = rf->data.b4; + frame.data[5] = rf->data.b5; + frame.data[6] = rf->data.b6; + frame.data[7] = rf->data.b7; - /* Invalidate the buffer so that the correct packet will be re-read - * from memory when the packet content is accessed. - */ + putreg32(CAN_FIFO_NE, S32K1XX_CAN0_IFLAG1); - up_invalidate_dcache((uintptr_t)priv->dev.d_buf, - (uintptr_t)priv->dev.d_buf + priv->dev.d_len); + /* Copy the buffer pointer to priv->dev.d_buf. Set amount of data + * in priv->dev.d_len + */ - /* Send to socket interface */ - NETDEV_RXPACKETS(&priv->dev); + priv->dev.d_len = sizeof(struct can_frame); + priv->dev.d_buf = (uint8_t *)s32k1xx_swap32((uint32_t)&frame); /* FIXME */ - can_input(&priv->dev); + /* Invalidate the buffer so that the correct packet will be re-read + * from memory when the packet content is accessed. + */ + up_invalidate_dcache((uintptr_t)priv->dev.d_buf, + (uintptr_t)priv->dev.d_buf + priv->dev.d_len); + /* Send to socket interface */ + NETDEV_RXPACKETS(&priv->dev); - /* - * Store with timeout into the FIFO buffer and signal update event - */ + can_input(&priv->dev); - } + /* Store with timeout into the FIFO buffer and signal update event */ + } } /**************************************************************************** @@ -771,24 +758,27 @@ static void s32k1xx_txdone(FAR struct s32k1xx_driver_s *priv) #warning Missing logic uint32_t tx_iflags; - tx_iflags = getreg32(S32K1XX_CAN0_IFLAG1) & TXMBMask; + tx_iflags = getreg32(S32K1XX_CAN0_IFLAG1) & TXMBMASK; - //FIXME process aborts + /* FIXME process aborts */ /* Process TX completions */ - uint32_t mb_bit = 1 << RxMBCount; - for(uint32_t mbi = 0; tx_iflags && mbi < TxMBCount; mbi++) - { + uint32_t mb_bit = 1 << RXMBCOUNT; + for (uint32_t mbi = 0; tx_iflags && mbi < TXMBCOUNT; mbi++) + { if (tx_iflags & mb_bit) - { - putreg32(mb_bit, S32K1XX_CAN0_IFLAG1); + { + putreg32(mb_bit, S32K1XX_CAN0_IFLAG1); tx_iflags &= ~mb_bit; - //const bool txok = priv->tx[mbi].CS.code != CAN_TXMB_ABORT; - //handleTxMailboxInterrupt(mbi, txok, utc_usec); - } +#if 0 + const bool txok = priv->tx[mbi].cs.code != CAN_TXMB_ABORT; + handleTxMailboxInterrupt(mbi, txok, utc_usec); +#endif + } + mb_bit <<= 1; - } + } } /**************************************************************************** @@ -833,27 +823,26 @@ static void s32k1xx_flexcan_interrupt_work(FAR void *arg) * ****************************************************************************/ - static int s32k1xx_flexcan_interrupt(int irq, FAR void *context, FAR void *arg) { #warning Missing logic - FAR struct s32k1xx_driver_s *priv = &g_flexcan[0]; - uint32_t flags; - flags = getreg32(S32K1XX_CAN0_IFLAG1); - flags &= FIFO_IFLAG1; - - if(flags) - { - s32k1xx_receive(priv); - } - - flags = getreg32(S32K1XX_CAN0_IFLAG1); - flags &= TXMBMask; - - if(flags) - { - s32k1xx_txdone(priv); - } + FAR struct s32k1xx_driver_s *priv = &g_flexcan[0]; + uint32_t flags; + flags = getreg32(S32K1XX_CAN0_IFLAG1); + flags &= FIFO_IFLAG1; + + if (flags) + { + s32k1xx_receive(priv); + } + + flags = getreg32(S32K1XX_CAN0_IFLAG1); + flags &= TXMBMASK; + + if (flags) + { + s32k1xx_txdone(priv); + } } /**************************************************************************** @@ -875,7 +864,7 @@ static int s32k1xx_flexcan_interrupt(int irq, FAR void *context, FAR void *arg) static void s32k1xx_txtimeout_work(FAR void *arg) { #warning Missing logic - ninfo("FLEXCAN: tx timeout work\r\n"); + ninfo("FLEXCAN: tx timeout work\r\n"); } /**************************************************************************** @@ -900,7 +889,7 @@ static void s32k1xx_txtimeout_work(FAR void *arg) static void s32k1xx_txtimeout_expiry(int argc, uint32_t arg, ...) { #warning Missing logic - ninfo("FLEXCAN: tx timeout expiry\r\n"); + ninfo("FLEXCAN: tx timeout expiry\r\n"); } /**************************************************************************** @@ -923,32 +912,29 @@ static void s32k1xx_txtimeout_expiry(int argc, uint32_t arg, ...) static void s32k1xx_poll_work(FAR void *arg) { #warning Missing logic - //ninfo("FLEXCAN: poll work\r\n"); - - FAR struct s32k1xx_driver_s *priv = (FAR struct s32k1xx_driver_s *)arg; - - /* Check if there is there is a transmission in progress. We cannot - * perform the TX poll if he are unable to accept another packet for - * transmission. - */ + FAR struct s32k1xx_driver_s *priv = (FAR struct s32k1xx_driver_s *)arg; - net_lock(); - if (1) //!s32k1xx_txringfull(priv)) - { - /* If so, update TCP timing states and poll the network for new XMIT - * data. Hmmm.. might be bug here. Does this mean if there is a - * transmit in progress, we will missing TCP time state updates? - */ + /* Check if there is there is a transmission in progress. We cannot + * perform the TX poll if he are unable to accept another packet for + * transmission. + */ - devif_timer(&priv->dev, S32K1XX_WDDELAY, s32k1xx_txpoll); - } + net_lock(); + if (1) /* !s32k1xx_txringfull(priv)) */ + { + /* If so, update TCP timing states and poll the network for new XMIT + * data. Hmmm.. might be bug here. Does this mean if there is a + * transmit in progress, we will missing TCP time state updates? + */ - /* Setup the watchdog poll timer again in any case */ + devif_timer(&priv->dev, S32K1XX_WDDELAY, s32k1xx_txpoll); + } - wd_start(priv->txpoll, S32K1XX_WDDELAY, s32k1xx_polltimer_expiry, - 1, (wdparm_t)priv); - net_unlock(); + /* Setup the watchdog poll timer again in any case */ + wd_start(priv->txpoll, S32K1XX_WDDELAY, s32k1xx_polltimer_expiry, + 1, (wdparm_t)priv); + net_unlock(); } /**************************************************************************** @@ -981,62 +967,67 @@ static void s32k1xx_polltimer_expiry(int argc, uint32_t arg, ...) static void s32k1xx_setenable(uint32_t enable) { - uint32_t regval; - if(enable) - { - regval = getreg32(S32K1XX_CAN0_MCR); - regval &= ~(CAN_MCR_MDIS); - putreg32(regval, S32K1XX_CAN0_MCR); - } - else - { - regval = getreg32(S32K1XX_CAN0_MCR); - regval |= CAN_MCR_MDIS; - putreg32(regval, S32K1XX_CAN0_MCR); - } - s32k1xx_waitmcr_change(CAN_MCR_LPMACK,1); + uint32_t regval; + + if (enable) + { + regval = getreg32(S32K1XX_CAN0_MCR); + regval &= ~(CAN_MCR_MDIS); + putreg32(regval, S32K1XX_CAN0_MCR); + } + else + { + regval = getreg32(S32K1XX_CAN0_MCR); + regval |= CAN_MCR_MDIS; + putreg32(regval, S32K1XX_CAN0_MCR); + } + + s32k1xx_waitmcr_change(CAN_MCR_LPMACK, 1); } static void s32k1xx_setfreeze(uint32_t freeze) { - uint32_t regval; - if(freeze) - { - /* Enter freeze mode */ - regval = getreg32(S32K1XX_CAN0_MCR); - regval |= (CAN_MCR_HALT | CAN_MCR_FRZ); - putreg32(regval, S32K1XX_CAN0_MCR); - } - else - { - /* Exit freeze mode */ - regval = getreg32(S32K1XX_CAN0_MCR); - regval &= ~(CAN_MCR_HALT | CAN_MCR_FRZ); - putreg32(regval, S32K1XX_CAN0_MCR); - } + uint32_t regval; + if (freeze) + { + /* Enter freeze mode */ + + regval = getreg32(S32K1XX_CAN0_MCR); + regval |= (CAN_MCR_HALT | CAN_MCR_FRZ); + putreg32(regval, S32K1XX_CAN0_MCR); + } + else + { + /* Exit freeze mode */ + + regval = getreg32(S32K1XX_CAN0_MCR); + regval &= ~(CAN_MCR_HALT | CAN_MCR_FRZ); + putreg32(regval, S32K1XX_CAN0_MCR); + } } static uint32_t s32k1xx_waitmcr_change(uint32_t mask, uint32_t target_state) { - const unsigned Timeout = 1000; - for (unsigned wait_ack = 0; wait_ack < Timeout; wait_ack++) - { - const bool state = (getreg32(S32K1XX_CAN0_MCR) & mask) != 0; - if (state == target_state) - { - return true; - } - up_udelay(10); - } - return false; + const unsigned timeout = 1000; + for (unsigned wait_ack = 0; wait_ack < timeout; wait_ack++) + { + const bool state = (getreg32(S32K1XX_CAN0_MCR) & mask) != 0; + if (state == target_state) + { + return true; + } + + up_udelay(10); + } + + return false; } static uint32_t s32k1xx_waitfreezeack_change(uint32_t target_state) { - return s32k1xx_waitmcr_change(CAN_MCR_FRZACK, target_state); + return s32k1xx_waitmcr_change(CAN_MCR_FRZACK, target_state); } - /**************************************************************************** * Function: s32k1xx_ifup * @@ -1057,16 +1048,16 @@ static uint32_t s32k1xx_waitfreezeack_change(uint32_t target_state) static int s32k1xx_ifup(struct net_driver_s *dev) { FAR struct s32k1xx_driver_s *priv = - (FAR struct s32k1xx_driver_s *)dev->d_private; + (FAR struct s32k1xx_driver_s *)dev->d_private; uint32_t regval; #warning Missing logic - if(!s32k1xx_initialize(priv)) - { - nerr("initialize failed"); - return -1; - } + if (!s32k1xx_initialize(priv)) + { + nerr("initialize failed"); + return -1; + } /* Set and activate a timer process */ @@ -1078,6 +1069,7 @@ static int s32k1xx_ifup(struct net_driver_s *dev) priv->dev.d_buf = &g_desc_pool; /* Set interrupts */ + up_enable_irq(S32K1XX_IRQ_CAN0_BUS); up_enable_irq(S32K1XX_IRQ_CAN0_ERROR); up_enable_irq(S32K1XX_IRQ_CAN0_LPRX); @@ -1127,28 +1119,28 @@ static int s32k1xx_ifdown(struct net_driver_s *dev) static void s32k1xx_txavail_work(FAR void *arg) { - FAR struct s32k1xx_driver_s *priv = (FAR struct s32k1xx_driver_s *)arg; + FAR struct s32k1xx_driver_s *priv = (FAR struct s32k1xx_driver_s *)arg; - /* Ignore the notification if the interface is not yet up */ + /* Ignore the notification if the interface is not yet up */ - net_lock(); - if (priv->bifup) - { - /* Check if there is room in the hardware to hold another outgoing - * packet. - */ + net_lock(); + if (priv->bifup) + { + /* Check if there is room in the hardware to hold another outgoing + * packet. + */ - if (!s32k1xx_txringfull(priv)) - { - /* No, there is space for another transfer. Poll the network for - * new XMIT data. - */ + if (!s32k1xx_txringfull(priv)) + { + /* No, there is space for another transfer. Poll the network for + * new XMIT data. + */ - devif_poll(&priv->dev, s32k1xx_txpoll); - } - } + devif_poll(&priv->dev, s32k1xx_txpoll); + } + } - net_unlock(); + net_unlock(); } /**************************************************************************** @@ -1183,8 +1175,9 @@ static int s32k1xx_txavail(struct net_driver_s *dev) if (work_available(&priv->pollwork)) { /* Schedule to serialize the poll on the worker thread. */ + #ifdef WORK_QUEUE_BYPASS - s32k1xx_txavail_work(priv); + s32k1xx_txavail_work(priv); #else work_queue(ETHWORK, &priv->pollwork, s32k1xx_txavail_work, priv, 0); #endif @@ -1193,7 +1186,6 @@ static int s32k1xx_txavail(struct net_driver_s *dev) return OK; } - /**************************************************************************** * Function: s32k1xx_ioctl * @@ -1247,119 +1239,131 @@ static int s32k1xx_ioctl(struct net_driver_s *dev, int cmd, static int s32k1xx_initialize(struct s32k1xx_driver_s *priv) { - uint32_t regval; - uint32_t i; + uint32_t regval; + uint32_t i; - /* initialize CAN device */ - //FIXME we only support a single can device for now + /* initialize CAN device */ - //TEST GPIO tming - s32k1xx_pinconfig(PIN_PORTD | PIN31 | GPIO_OUTPUT); + /* FIXME we only support a single can device for now */ + /* TEST GPIO tming */ - s32k1xx_setenable(0); + s32k1xx_pinconfig(PIN_PORTD | PIN31 | GPIO_OUTPUT); - /* Set SYS_CLOCK src */ - regval = getreg32(S32K1XX_CAN0_CTRL1); - regval |= CAN_CTRL1_CLKSRC; - putreg32(regval, S32K1XX_CAN0_CTRL1); + s32k1xx_setenable(0); - s32k1xx_setenable(1); + /* Set SYS_CLOCK src */ - s32k1xx_reset(priv); + regval = getreg32(S32K1XX_CAN0_CTRL1); + regval |= CAN_CTRL1_CLKSRC; + putreg32(regval, S32K1XX_CAN0_CTRL1); - /* Enter freeze mode */ - s32k1xx_setfreeze(1); - if(!s32k1xx_waitfreezeack_change(1)) - { - ninfo("FLEXCAN: freeze fail\r\n"); - return -1; - } + s32k1xx_setenable(1); - /*regval = getreg32(S32K1XX_CAN0_CTRL1); - regval |= ((0 << CAN_CTRL1_PRESDIV_SHIFT) & CAN_CTRL1_PRESDIV_MASK) - | ((46 << CAN_CTRL1_ROPSEG_SHIFT) & CAN_CTRL1_ROPSEG_MASK) - | ((18 << CAN_CTRL1_PSEG1_SHIFT) & CAN_CTRL1_PSEG1_MASK) - | ((12 << CAN_CTRL1_PSEG2_SHIFT) & CAN_CTRL1_PSEG2_MASK) - | ((12 << CAN_CTRL1_RJW_SHIFT) & CAN_CTRL1_RJW_MASK) - | CAN_CTRL1_ERRMSK - | CAN_CTRL1_TWRNMSK - | CAN_CTRL1_RWRNMSK; + s32k1xx_reset(priv); - putreg32(regval, S32K1XX_CAN0_CTRL1);*/ + /* Enter freeze mode */ + + s32k1xx_setfreeze(1); + if (!s32k1xx_waitfreezeack_change(1)) + { + ninfo("FLEXCAN: freeze fail\r\n"); + return -1; + } + +#if 0 + regval = getreg32(S32K1XX_CAN0_CTRL1); + regval |= ((0 << CAN_CTRL1_PRESDIV_SHIFT) & CAN_CTRL1_PRESDIV_MASK) | + ((46 << CAN_CTRL1_ROPSEG_SHIFT) & CAN_CTRL1_ROPSEG_MASK) | + ((18 << CAN_CTRL1_PSEG1_SHIFT) & CAN_CTRL1_PSEG1_MASK) | + ((12 << CAN_CTRL1_PSEG2_SHIFT) & CAN_CTRL1_PSEG2_MASK) | + ((12 << CAN_CTRL1_RJW_SHIFT) & CAN_CTRL1_RJW_MASK) | + CAN_CTRL1_ERRMSK | + CAN_CTRL1_TWRNMSK | + CAN_CTRL1_RWRNMSK; + + putreg32(regval, S32K1XX_CAN0_CTRL1); +#endif #define BIT_METHOD2 #ifdef BIT_METHOD2 - /* CAN Bit Timing (CBT) configuration for a nominal phase of 1 Mbit/s - * with 80 time quantas,in accordance with Bosch 2012 specification, - * sample point at 83.75% */ - regval = getreg32(S32K1XX_CAN0_CBT); - regval |= CAN_CBT_BTF | /* Enable extended bit timing configurations for CAN-FD - for setting up separetely nominal and data phase */ - CAN_CBT_EPRESDIV(0) | /* Prescaler divisor factor of 1 */ - CAN_CBT_EPROPSEG(46) | /* Propagation segment of 47 time quantas */ - CAN_CBT_EPSEG1(18) | /* Phase buffer segment 1 of 19 time quantas */ - CAN_CBT_EPSEG2(12) | /* Phase buffer segment 2 of 13 time quantas */ - CAN_CBT_ERJW(12); /* Resynchronization jump width same as PSEG2 */ - putreg32(regval, S32K1XX_CAN0_CBT); + /* CAN Bit Timing (CBT) configuration for a nominal phase of 1 Mbit/s + * with 80 time quantas,in accordance with Bosch 2012 specification, + * sample point at 83.75% + */ + + regval = getreg32(S32K1XX_CAN0_CBT); + regval |= CAN_CBT_BTF | /* Enable extended bit timing configurations + * for CAN-FD for setting up separately + * nominal and data phase */ + CAN_CBT_EPRESDIV(0) | /* Prescaler divisor factor of 1 */ + CAN_CBT_EPROPSEG(46) | /* Propagation segment of 47 time quantas */ + CAN_CBT_EPSEG1(18) | /* Phase buffer segment 1 of 19 time quantas */ + CAN_CBT_EPSEG2(12) | /* Phase buffer segment 2 of 13 time quantas */ + CAN_CBT_ERJW(12); /* Resynchronization jump width same as PSEG2 */ + putreg32(regval, S32K1XX_CAN0_CBT); #endif #ifdef CAN_FD + /* Enable CAN FD feature */ + + regval = getreg32(S32K1XX_CAN0_MCR); + regval |= CAN_MCR_FDEN; + putreg32(regval, S32K1XX_CAN0_MCR); + + /* CAN-FD Bit Timing (FDCBT) for a data phase of 4 Mbit/s with 20 time quantas, + * in accordance with Bosch 2012 specification, sample point at 75% + */ + + regval = getreg32(S32K1XX_CAN0_FDCBT); + regval |= CAN_FDCBT_FPRESDIV(0) | /* Prescaler divisor factor of 1 */ + CAN_FDCBT_FPROPSEG(7) | /* Propagation semgment of 7 time quantas + * (only register that doesn't add 1) */ + CAN_FDCBT_FPSEG1(6) | /* Phase buffer segment 1 of 7 time quantas */ + CAN_FDCBT_FPSEG2(4) | /* Phase buffer segment 2 of 5 time quantas */ + CAN_FDCBT_FRJW(4); /* Resynchorinzation jump width same as PSEG2 */ + putreg32(regval, S32K1XX_CAN0_FDCBT); + + /* Additional CAN-FD configurations */ + + regval = getreg32(S32K1XX_CAN0_FDCTRL); - /* Enable CAN FD feature */ - regval = getreg32(S32K1XX_CAN0_MCR); - regval |= CAN_MCR_FDEN; - putreg32(regval, S32K1XX_CAN0_MCR); - - /* CAN-FD Bit Timing (FDCBT) for a data phase of 4 Mbit/s with 20 time quantas, - in accordance with Bosch 2012 specification, sample point at 75% */ - regval = getreg32(S32K1XX_CAN0_FDCBT); - regval |= CAN_FDCBT_FPRESDIV(0) | /* Prescaler divisor factor of 1 */ - CAN_FDCBT_FPROPSEG(7) | /* Propagation semgment of 7 time quantas - (only register that doesn't add 1) */ - CAN_FDCBT_FPSEG1(6) | /* Phase buffer segment 1 of 7 time quantas */ - CAN_FDCBT_FPSEG2(4) | /* Phase buffer segment 2 of 5 time quantas */ - CAN_FDCBT_FRJW(4); /* Resynchorinzation jump width same as PSEG2 */ - putreg32(regval, S32K1XX_CAN0_FDCBT); - - /* Additional CAN-FD configurations */ - regval = getreg32(S32K1XX_CAN0_FDCTRL); - regval |= CAN_FDCTRL_FDRATE | /* Enable bit rate switch in data phase of frame */ - CAN_FDCTRL_TDCEN | /* Enable transceiver delay compensation */ - CAN_FDCTRL_TDCOFF(5) | /* Setup 5 cycles for data phase sampling delay */ - CAN_FDCTRL_MBDSR0(3); /* Setup 64 bytes per message buffer (7 MB's) */ - putreg32(regval, S32K1XX_CAN0_FDCTRL); - - regval = getreg32(S32K1XX_CAN0_CTRL2); - regval |= CAN_CTRL2_ISOCANFDEN; - putreg32(regval, S32K1XX_CAN0_CTRL2); + regval |= CAN_FDCTRL_FDRATE | /* Enable bit rate switch in data phase of frame */ + CAN_FDCTRL_TDCEN | /* Enable transceiver delay compensation */ + CAN_FDCTRL_TDCOFF(5) | /* Setup 5 cycles for data phase sampling delay */ + CAN_FDCTRL_MBDSR0(3); /* Setup 64 bytes per message buffer (7 MB's) */ + putreg32(regval, S32K1XX_CAN0_FDCTRL); + + regval = getreg32(S32K1XX_CAN0_CTRL2); + regval |= CAN_CTRL2_ISOCANFDEN; + putreg32(regval, S32K1XX_CAN0_CTRL2); #endif - for(i = TxMBCount; i < TotalMBcount; i++) - { - priv->rx[i].ID.w = 0x0; - } + for (i = TXMBCOUNT; i < TOTALMBCOUNT; i++) + { + priv->rx[i].id.w = 0x0; + } - putreg32(0x0, S32K1XX_CAN0_RXFGMASK); + putreg32(0x0, S32K1XX_CAN0_RXFGMASK); - for(i = 0; i < TotalMBcount; i++) - { - putreg32(0,S32K1XX_CAN0_RXIMR(i)); - } + for (i = 0; i < TOTALMBCOUNT; i++) + { + putreg32(0, S32K1XX_CAN0_RXIMR(i)); + } - putreg32(FIFO_IFLAG1 | TXMBMask, S32K1XX_CAN0_IFLAG1); - putreg32(FIFO_IFLAG1, S32K1XX_CAN0_IMASK1); + putreg32(FIFO_IFLAG1 | TXMBMASK, S32K1XX_CAN0_IFLAG1); + putreg32(FIFO_IFLAG1, S32K1XX_CAN0_IMASK1); + /* Exit freeze mode */ - /* Exit freeze mode */ - s32k1xx_setfreeze(0); - if(!s32k1xx_waitfreezeack_change(0)) - { - ninfo("FLEXCAN: unfreeze fail\r\n"); - return -1; - } + s32k1xx_setfreeze(0); + if (!s32k1xx_waitfreezeack_change(0)) + { + ninfo("FLEXCAN: unfreeze fail\r\n"); + return -1; + } - return 1; + return 1; } /**************************************************************************** @@ -1401,57 +1405,57 @@ static void s32k1xx_initbuffers(struct s32k1xx_driver_s *priv) static void s32k1xx_reset(struct s32k1xx_driver_s *priv) { - uint32_t regval; - uint32_t i; - - regval = getreg32(S32K1XX_CAN0_MCR); - regval |= CAN_MCR_SOFTRST; - putreg32(regval, S32K1XX_CAN0_MCR); - - if(!s32k1xx_waitmcr_change(CAN_MCR_SOFTRST, 0)) - { - nerr("Reset failed"); - return; - } - - /* TODO calculate TASD */ - - - regval = getreg32(S32K1XX_CAN0_MCR); - regval &= ~(CAN_MCR_SUPV); - putreg32(regval, S32K1XX_CAN0_MCR); - - /* Initialize all MB rx and tx */ - for(i = 0; i < TotalMBcount; i++) - { - ninfo("MB %i %p\r\n", i, &priv->rx[i]); - ninfo("MB %i %p\r\n", i, &priv->rx[i].ID.w); - priv->rx[i].CS.cs = 0x0; - priv->rx[i].ID.w = 0x0; - priv->rx[i].data.l = 0x0; - priv->rx[i].data.h = 0x0; - } - - regval = getreg32(S32K1XX_CAN0_MCR); - regval |= CAN_MCR_RFEN | CAN_MCR_SLFWAK | CAN_MCR_WRNEN | CAN_MCR_SRXDIS - | CAN_MCR_IRMQ | CAN_MCR_AEN | - (((TotalMBcount - 1) << CAN_MCR_MAXMB_SHIFT) & CAN_MCR_MAXMB_MASK); - putreg32(regval, S32K1XX_CAN0_MCR); - - regval = CAN_CTRL2_RRS | CAN_CTRL2_EACEN | CAN_CTRL2_RFFN_16MB; //FIXME TASD - putreg32(regval, S32K1XX_CAN0_CTRL2); - - - for(i = 0; i < TotalMBcount; i++) - { - putreg32(0,S32K1XX_CAN0_RXIMR(i)); - } - - /* Filtering catchall */ - putreg32(0x3FFFFFFF, S32K1XX_CAN0_RX14MASK); - putreg32(0x3FFFFFFF, S32K1XX_CAN0_RX15MASK); - putreg32(0x3FFFFFFF, S32K1XX_CAN0_RXMGMASK); - putreg32(0x0, S32K1XX_CAN0_RXFGMASK); + uint32_t regval; + uint32_t i; + + regval = getreg32(S32K1XX_CAN0_MCR); + regval |= CAN_MCR_SOFTRST; + putreg32(regval, S32K1XX_CAN0_MCR); + + if (!s32k1xx_waitmcr_change(CAN_MCR_SOFTRST, 0)) + { + nerr("Reset failed"); + return; + } + + /* TODO calculate TASD */ + + regval = getreg32(S32K1XX_CAN0_MCR); + regval &= ~(CAN_MCR_SUPV); + putreg32(regval, S32K1XX_CAN0_MCR); + + /* Initialize all MB rx and tx */ + + for (i = 0; i < TOTALMBCOUNT; i++) + { + ninfo("MB %i %p\r\n", i, &priv->rx[i]); + ninfo("MB %i %p\r\n", i, &priv->rx[i].id.w); + priv->rx[i].cs.cs = 0x0; + priv->rx[i].id.w = 0x0; + priv->rx[i].data.l = 0x0; + priv->rx[i].data.h = 0x0; + } + + regval = getreg32(S32K1XX_CAN0_MCR); + regval |= CAN_MCR_RFEN | CAN_MCR_SLFWAK | CAN_MCR_WRNEN | CAN_MCR_SRXDIS | + CAN_MCR_IRMQ | CAN_MCR_AEN | + (((TOTALMBCOUNT - 1) << CAN_MCR_MAXMB_SHIFT) & CAN_MCR_MAXMB_MASK); + putreg32(regval, S32K1XX_CAN0_MCR); + + regval = CAN_CTRL2_RRS | CAN_CTRL2_EACEN | CAN_CTRL2_RFFN_16MB; /* FIXME TASD */ + putreg32(regval, S32K1XX_CAN0_CTRL2); + + for (i = 0; i < TOTALMBCOUNT; i++) + { + putreg32(0, S32K1XX_CAN0_RXIMR(i)); + } + + /* Filtering catchall */ + + putreg32(0x3fffffff, S32K1XX_CAN0_RX14MASK); + putreg32(0x3fffffff, S32K1XX_CAN0_RX15MASK); + putreg32(0x3fffffff, S32K1XX_CAN0_RXMGMASK); + putreg32(0x0, S32K1XX_CAN0_RXFGMASK); } /**************************************************************************** @@ -1480,7 +1484,8 @@ int s32k1xx_netinitialize(int intf) struct s32k1xx_driver_s *priv; int ret; - //FIXME dynamic board config + /* FIXME dynamic board config */ + s32k1xx_pinconfig(PIN_CAN0_TX_4); s32k1xx_pinconfig(PIN_CAN0_RX_4); @@ -1490,10 +1495,10 @@ int s32k1xx_netinitialize(int intf) /* Get the interface structure associated with this interface number. */ - #warning Missing logic - +#warning Missing logic /* Attach the flexcan interrupt handler */ + if (irq_attach(S32K1XX_IRQ_CAN0_BUS, s32k1xx_flexcan_interrupt, NULL)) { /* We could not attach the ISR to the interrupt */ @@ -1501,6 +1506,7 @@ int s32k1xx_netinitialize(int intf) nerr("ERROR: Failed to attach CAN bus IRQ\n"); return -EAGAIN; } + if (irq_attach(S32K1XX_IRQ_CAN0_ERROR, s32k1xx_flexcan_interrupt, NULL)) { /* We could not attach the ISR to the interrupt */ @@ -1508,6 +1514,7 @@ int s32k1xx_netinitialize(int intf) nerr("ERROR: Failed to attach CAN error IRQ\n"); return -EAGAIN; } + if (irq_attach(S32K1XX_IRQ_CAN0_LPRX, s32k1xx_flexcan_interrupt, NULL)) { /* We could not attach the ISR to the interrupt */ @@ -1515,6 +1522,7 @@ int s32k1xx_netinitialize(int intf) nerr("ERROR: Failed to attach CAN LPRX IRQ\n"); return -EAGAIN; } + if (irq_attach(S32K1XX_IRQ_CAN0_0_15, s32k1xx_flexcan_interrupt, NULL)) { /* We could not attach the ISR to the interrupt */ @@ -1526,20 +1534,21 @@ int s32k1xx_netinitialize(int intf) /* Initialize the driver structure */ memset(priv, 0, sizeof(struct s32k1xx_driver_s)); - priv->dev.d_ifup = s32k1xx_ifup; /* I/F up (new IP address) callback */ - priv->dev.d_ifdown = s32k1xx_ifdown; /* I/F down callback */ - priv->dev.d_txavail = s32k1xx_txavail; /* New TX data callback */ + priv->dev.d_ifup = s32k1xx_ifup; /* I/F up (new IP address) callback */ + priv->dev.d_ifdown = s32k1xx_ifdown; /* I/F down callback */ + priv->dev.d_txavail = s32k1xx_txavail; /* New TX data callback */ #ifdef CONFIG_NETDEV_IOCTL - priv->dev.d_ioctl = s32k1xx_ioctl; /* Support PHY ioctl() calls */ + priv->dev.d_ioctl = s32k1xx_ioctl; /* Support PHY ioctl() calls */ #endif - priv->dev.d_private = (void *)g_flexcan; /* Used to recover private state from dev */ + priv->dev.d_private = (void *)g_flexcan; /* Used to recover private state from dev */ /* Create a watchdog for timing polling for and timing of transmissions */ - priv->txpoll = wd_create(); /* Create periodic poll timer */ - priv->txtimeout = wd_create(); /* Create TX timeout timer */ - priv->rx = (struct MbRx *)(S32K1XX_CAN0_MB); - priv->tx = (struct MbTx *)(S32K1XX_CAN0_MB + (sizeof(struct MbRx) - * RxMBCount) ); + + priv->txpoll = wd_create(); /* Create periodic poll timer */ + priv->txtimeout = wd_create(); /* Create TX timeout timer */ + priv->rx = (struct mbrx_s *)(S32K1XX_CAN0_MB); + priv->tx = (struct mbtx_s *)(S32K1XX_CAN0_MB + + (sizeof(struct mbrx_s) * RXMBCOUNT)); /* Put the interface in the down state. This usually amounts to resetting * the device and/or calling s32k1xx_ifdown(). @@ -1568,7 +1577,7 @@ int s32k1xx_netinitialize(int intf) * ****************************************************************************/ -//FIXME CONFIG_S32K1XX_FLEXCAN_NETHIFS == 1 && +/* FIXME CONFIG_S32K1XX_FLEXCAN_NETHIFS == 1 && */ #if !defined(CONFIG_NETDEV_LATEINIT) void up_netinitialize(void) diff --git a/include/netpacket/can.h b/include/netpacket/can.h index 45edab5..0b4c7b9 100644 --- a/include/netpacket/can.h +++ b/include/netpacket/can.h @@ -126,13 +126,13 @@ struct sockaddr_can * 1 bit: reserved */ - uint32_t pgn; + uint32_t pgn; - /* 1 byte address */ + /* 1 byte address */ - uint8_t addr; - } j1939; - } can_addr; + uint8_t addr; + } j1939; + } can_addr; }; #endif /* __INCLUDE_NETPACKET_CAN_H */ diff --git a/include/nuttx/can.h b/include/nuttx/can.h index 02f80a8..7a66a65 100644 --- a/include/nuttx/can.h +++ b/include/nuttx/can.h @@ -53,7 +53,6 @@ * Pre-processor Definitions ************************************************************************************/ - /* Ioctl Commands *******************************************************************/ /* Ioctl commands supported by the upper half CAN driver. @@ -185,61 +184,17 @@ * CAN_B_NCMDS 77 <- Number of commands */ -/************************************************************************************ - * Public Types - ************************************************************************************/ - -typedef FAR void *CAN_HANDLE; - -struct can_response_s -{ - sq_entry_t flink; - - /* Message-specific data may follow */ -}; //FIXME remvoe - - -typedef uint32_t canid_t; - -/* - * Controller Area Network Error Message Frame Mask structure - * - * bit 0-28 : error class mask (see include/uapi/linux/can/error.h) - * bit 29-31 : set to zero - */ -typedef uint32_t can_err_mask_t; - /* CAN payload length and DLC definitions according to ISO 11898-1 */ + #define CAN_MAX_DLC 8 #define CAN_MAX_DLEN 8 /* CAN FD payload length and DLC definitions according to ISO 11898-7 */ + #define CANFD_MAX_DLC 15 #define CANFD_MAX_DLEN 64 - -/** - * struct can_frame - basic CAN frame structure - * @can_id: CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition - * @can_dlc: frame payload length in byte (0 .. 8) aka data length code - * N.B. the DLC field from ISO 11898-1 Chapter 8.4.2.3 has a 1:1 - * mapping of the 'data length code' to the real payload length - * @__pad: padding - * @__res0: reserved / padding - * @__res1: reserved / padding - * @data: CAN frame payload (up to 8 byte) - */ -struct can_frame { - canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ - uint8_t can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */ - uint8_t __pad; /* padding */ - uint8_t __res0; /* reserved / padding */ - uint8_t __res1; /* reserved / padding */ - uint8_t data[CAN_MAX_DLEN] __attribute__((aligned(8))); -}; - -/* - * defined bits for canfd_frame.flags +/* Defined bits for canfd_frame.flags * * The use of struct canfd_frame implies the Extended Data Length (EDL) bit to * be set in the CAN frame bitstream on the wire. The EDL bit switch turns @@ -254,48 +209,94 @@ struct can_frame { * building a CAN FD frame for transmission. Setting the CANFD_ESI bit can make * sense for virtual CAN interfaces to test applications with echoed frames. */ + #define CANFD_BRS 0x01 /* bit rate switch (second bitrate for payload data) */ #define CANFD_ESI 0x02 /* error state indicator of the transmitting node */ -/** - * struct canfd_frame - CAN flexible data rate frame structure - * @can_id: CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition - * @len: frame payload length in byte (0 .. CANFD_MAX_DLEN) - * @flags: additional flags for CAN FD - * @__res0: reserved / padding - * @__res1: reserved / padding - * @data: CAN FD frame payload (up to CANFD_MAX_DLEN byte) +#define CAN_INV_FILTER 0x20000000U /* to be set in can_filter.can_id */ +#define CAN_RAW_FILTER_MAX 512 /* maximum number of can_filter set via setsockopt() */ + +/************************************************************************************ + * Public Types + ************************************************************************************/ + +typedef FAR void *CAN_HANDLE; + +struct can_response_s +{ + sq_entry_t flink; + + /* Message-specific data may follow */ +}; /* FIXME remove */ + +typedef uint32_t canid_t; + +/* Controller Area Network Error Message Frame Mask structure + * + * bit 0-28 : error class mask (see include/uapi/linux/can/error.h) + * bit 29-31 : set to zero */ -struct canfd_frame { - canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ - uint8_t len; /* frame payload length in byte */ - uint8_t flags; /* additional flags for CAN FD */ - uint8_t __res0; /* reserved / padding */ - uint8_t __res1; /* reserved / padding */ - uint8_t data[CANFD_MAX_DLEN] __attribute__((aligned(8))); + +typedef uint32_t can_err_mask_t; + +/* struct can_frame - basic CAN frame structure + * can_id: CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition + * can_dlc: frame payload length in byte (0 .. 8) aka data length code + * N.B. the DLC field from ISO 11898-1 Chapter 8.4.2.3 has a 1:1 + * mapping of the 'data length code' to the real payload length + * __pad: padding + * __res0: reserved / padding + * __res1: reserved / padding + * data: CAN frame payload (up to 8 byte) + */ + +struct can_frame +{ + canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ + uint8_t can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */ + uint8_t __pad; /* padding */ + uint8_t __res0; /* reserved / padding */ + uint8_t __res1; /* reserved / padding */ + uint8_t data[CAN_MAX_DLEN] __attribute__((aligned(8))); }; +/* struct canfd_frame - CAN flexible data rate frame structure + * can_id: CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition + * len: frame payload length in byte (0 .. CANFD_MAX_DLEN) + * flags: additional flags for CAN FD + * __res0: reserved / padding + * __res1: reserved / padding + * data: CAN FD frame payload (up to CANFD_MAX_DLEN byte) + */ + +struct canfd_frame +{ + canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */ + uint8_t len; /* frame payload length in byte */ + uint8_t flags; /* additional flags for CAN FD */ + uint8_t __res0; /* reserved / padding */ + uint8_t __res1; /* reserved / padding */ + uint8_t data[CANFD_MAX_DLEN] __attribute__((aligned(8))); +}; -/** - * struct can_filter - CAN ID based filter in can_register(). - * @can_id: relevant bits of CAN ID which are not masked out. - * @can_mask: CAN mask (see description) +/* struct can_filter - CAN ID based filter in can_register(). + * can_id: relevant bits of CAN ID which are not masked out. + * can_mask: CAN mask (see description) * * Description: * A filter matches, when * - * & mask == can_id & mask + * & mask == can_id & mask * * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can * filter for error message frames (CAN_ERR_FLAG bit set in mask). */ -struct can_filter { - canid_t can_id; - canid_t can_mask; -}; -#define CAN_INV_FILTER 0x20000000U /* to be set in can_filter.can_id */ -#define CAN_RAW_FILTER_MAX 512 /* maximum number of can_filter set via setsockopt() */ +struct can_filter +{ + canid_t can_id; + canid_t can_mask; +}; /************************************************************************************ * Public Function Prototypes @@ -310,7 +311,6 @@ extern "C" #define EXTERN extern #endif - #undef EXTERN #if defined(__cplusplus) } diff --git a/include/nuttx/mm/iob.h b/include/nuttx/mm/iob.h index cabd2ff..5903c50 100644 --- a/include/nuttx/mm/iob.h +++ b/include/nuttx/mm/iob.h @@ -54,6 +54,7 @@ /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ + /* Configuration ************************************************************/ /* I/O buffer allocation logic supports a throttle value for read-ahead diff --git a/include/sys/socket.h b/include/sys/socket.h index efba67f..ff9f181 100644 --- a/include/sys/socket.h +++ b/include/sys/socket.h @@ -131,7 +131,7 @@ /* Protocol levels supported by get/setsockopt(): */ -#define SOL_SOCKET 0 /* Only socket-level options supported */ +#define SOL_SOCKET 0 /* Only socket-level options supported */ /* Socket-level options */ @@ -202,13 +202,13 @@ * return: int */ - /* The options are unsupported but included for compatibility * and portability */ + #define SO_TIMESTAMP 29 -#define SO_SNDBUFFORCE 32 -#define SO_RCVBUFFORCE 33 +#define SO_SNDBUFFORCE 32 +#define SO_RCVBUFFORCE 33 #define SO_RXQ_OVFL 40 /* Protocol-level socket operations. */ @@ -266,14 +266,14 @@ * Type Definitions ****************************************************************************/ - /* sockaddr_storage structure. This structure must be (1) large enough to - * accommodate all supported protocol-specific address structures, and (2) - * aligned at an appropriate boundary so that pointers to it can be cast - * as pointers to protocol-specific address structures and used to access - * the fields of those structures without alignment problems. - * - * REVISIT: sizeof(struct sockaddr_storge) should be 128 bytes. - */ +/* sockaddr_storage structure. This structure must be (1) large enough to + * accommodate all supported protocol-specific address structures, and (2) + * aligned at an appropriate boundary so that pointers to it can be cast + * as pointers to protocol-specific address structures and used to access + * the fields of those structures without alignment problems. + * + * REVISIT: sizeof(struct sockaddr_storge) should be 128 bytes. + */ #ifdef CONFIG_NET_IPv6 struct sockaddr_storage @@ -336,7 +336,9 @@ static inline FAR struct cmsghdr *__cmsg_nxthdr(FAR void *__ctl, { FAR struct cmsghdr *__ptr; - __ptr = (FAR struct cmsghdr *)(((FAR char *)__cmsg) + CMSG_ALIGN(__cmsg->cmsg_len)); + __ptr = (FAR struct cmsghdr *) + (((FAR char *)__cmsg) + CMSG_ALIGN(__cmsg->cmsg_len)); + if ((unsigned long)((FAR char *)(__ptr + 1) - (FAR char *)__ctl) > __size) { return (FAR struct cmsghdr *)NULL; diff --git a/net/can/can.h b/net/can/can.h index 46c7425..67c8d6f 100644 --- a/net/can/can.h +++ b/net/can/can.h @@ -85,26 +85,25 @@ struct can_conn_s FAR struct devif_callback_s *list; /* NetLink callbacks */ FAR struct net_driver_s *dev; /* Reference to CAN device */ - + /* Read-ahead buffering. * * readahead - A singly linked list of type struct iob_qentry_s * where the CAN/IP read-ahead data is retained. */ - struct iob_queue_s readahead; /* remove Read-ahead buffering */ + struct iob_queue_s readahead; /* remove Read-ahead buffering */ /* CAN-specific content follows */ uint8_t protocol; /* Selected CAN protocol */ int16_t crefs; /* Reference count */ - /* The following is a list of poll structures of threads waiting for * socket events. */ - struct can_poll_s pollinfo[4]; //FIXME make dynamic + struct can_poll_s pollinfo[4]; /* FIXME make dynamic */ }; /**************************************************************************** @@ -223,9 +222,9 @@ uint16_t can_datahandler(FAR struct can_conn_s *conn, FAR uint8_t *buffer, * Name: can_recvfrom * * Description: - * Implements the socket recvfrom interface pkt_recvfrom() receives messages from - * a socket, and may be used to receive data on a socket whether or not it - * is connection-oriented. + * Implements the socket recvfrom interface pkt_recvfrom() receives + * messages from a socket, and may be used to receive data on a socket + * whether or not it is connection-oriented. * * Input Parameters: * psock A pointer to a NuttX-specific, internal socket structure @@ -315,7 +314,6 @@ ssize_t psock_can_send(FAR struct socket *psock, FAR const void *buf, void can_readahead_signal(FAR struct can_conn_s *conn); #endif - #undef EXTERN #ifdef __cplusplus } diff --git a/net/can/can_callback.c b/net/can/can_callback.c index 6f3ae93..c61bdce 100644 --- a/net/can/can_callback.c +++ b/net/can/can_callback.c @@ -1,35 +1,20 @@ /**************************************************************************** * net/pkt/pkt_callback.c * - * Copyright (C) 2014 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * 3. Neither the name NuttX nor the names of its contributors may be - * used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -72,17 +57,15 @@ can_data_event(FAR struct net_driver_s *dev, FAR struct can_conn_s *conn, uint16_t flags) { uint16_t ret; - uint8_t *buffer = dev->d_appdata; - int buflen = dev->d_len; + FAR uint8_t *buffer = dev->d_appdata; + int buflen = dev->d_len; uint16_t recvlen; ret = (flags & ~CAN_NEWDATA); - //ninfo("No listener on connection\n"); - - /* Save as the packet data as in the read-ahead buffer. NOTE that - * partial packets will not be buffered. - */ + /* Save as the packet data as in the read-ahead buffer. NOTE that + * partial packets will not be buffered. + */ recvlen = can_datahandler(conn, buffer, buflen); if (recvlen < buflen) @@ -94,10 +77,11 @@ can_data_event(FAR struct net_driver_s *dev, FAR struct can_conn_s *conn, ninfo("Dropped %d bytes\n", dev->d_len); #ifdef CONFIG_NET_STATISTICS - //g_netstats.tcp.drop++; + /* g_netstats.tcp.drop++; */ + #endif } - + /* In any event, the new data has now been handled */ dev->d_len = 0; @@ -132,15 +116,15 @@ uint16_t can_callback(FAR struct net_driver_s *dev, /* Perform the callback */ flags = devif_conn_event(dev, conn, flags, conn->list); - - if ((flags & CAN_NEWDATA) != 0) - { - /* Data was not handled.. dispose of it appropriately */ - - flags = can_data_event(dev, conn, flags); - } - } - + + if ((flags & CAN_NEWDATA) != 0) + { + /* Data was not handled.. dispose of it appropriately */ + + flags = can_data_event(dev, conn, flags); + } + } + return flags; } @@ -214,7 +198,7 @@ uint16_t can_datahandler(FAR struct can_conn_s *conn, FAR uint8_t *buffer, iob_free_chain(iob, IOBUSER_NET_TCP_READAHEAD); return 0; } - + #ifdef CONFIG_NET_CAN_NOTIFIER /* Provide notification(s) that additional CAN read-ahead data is * available. diff --git a/net/can/can_getsockopt.c b/net/can/can_getsockopt.c index d9e19f8..1fe8218 100644 --- a/net/can/can_getsockopt.c +++ b/net/can/can_getsockopt.c @@ -1,35 +1,20 @@ /**************************************************************************** * net/can/can_setsockopt.c * - * Copyright (C) 2018 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: + * http://www.apache.org/licenses/LICENSE-2.0 * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * 3. Neither the name NuttX nor the names of its contributors may be - * used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -89,10 +74,9 @@ * ****************************************************************************/ -int can_getsockopt (FAR struct socket *psock, int option, +int can_getsockopt(FAR struct socket *psock, int option, FAR void *value, FAR socklen_t *value_len) { - FAR struct can_conn_s *conn; int ret; int count = 0; @@ -107,38 +91,37 @@ int can_getsockopt (FAR struct socket *psock, int option, return -ENOTCONN; } - switch (option) { - case CAN_RAW_FILTER: if (*value_len % sizeof(struct can_filter) != 0) - { - ret = -EINVAL; - } - + { + ret = -EINVAL; + } + if (value_len > CAN_RAW_FILTER_MAX * sizeof(struct can_filter)) - { - ret = -EINVAL; - } + { + ret = -EINVAL; + } + + count = *value_len / sizeof(struct can_filter); - count = *value_len / sizeof(struct can_filter); - /* FIXME pass filter to driver */ + break; - + case CAN_RAW_ERR_FILTER: break; - + case CAN_RAW_LOOPBACK: break; - + case CAN_RAW_RECV_OWN_MSGS: break; - + case CAN_RAW_FD_FRAMES: break; - + case CAN_RAW_JOIN_FILTERS: break; diff --git a/net/can/can_input.c b/net/can/can_input.c index 32dcebf..30e2507 100644 --- a/net/can/can_input.c +++ b/net/can/can_input.c @@ -2,39 +2,20 @@ * net/can/can_input.c * Handling incoming packet input * - * Copyright (C) 2014, 2020 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at * - * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * http://www.apache.org/licenses/LICENSE-2.0 * - * Original author Adam Dunkels - * Copyright () 2001-2003, Adam Dunkels. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS - * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -55,11 +36,6 @@ #include "can/can.h" /**************************************************************************** - * Pre-processor Definitions - ****************************************************************************/ - - -/**************************************************************************** * Public Functions ****************************************************************************/ @@ -88,7 +64,7 @@ int can_input(struct net_driver_s *dev) FAR struct can_conn_s *conn; int ret = OK; - conn = can_nextconn(NULL); //FIXME + conn = can_nextconn(NULL); /* FIXME */ if (conn) { uint16_t flags; diff --git a/net/can/can_poll.c b/net/can/can_poll.c index 80e59a2..77fe24c 100644 --- a/net/can/can_poll.c +++ b/net/can/can_poll.c @@ -2,39 +2,20 @@ * net/pkt/pkt_poll.c * Poll for the availability of packet TX data * - * Copyright (C) 2014 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at * - * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * http://www.apache.org/licenses/LICENSE-2.0 * - * Original author Adam Dunkels - * Copyright () 2001-2003, Adam Dunkels. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS - * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -88,13 +69,15 @@ void can_poll(FAR struct net_driver_s *dev, FAR struct can_conn_s *conn) dev->d_sndlen = 0; /* Perform the application callback */ + can_callback(dev, conn, CAN_POLL); /* Check if the application has data to send */ if (dev->d_sndlen > 0) { - //FIXME missing logic + /* FIXME missing logic */ + return; } } diff --git a/net/can/can_recvfrom.c b/net/can/can_recvfrom.c index 990786d..d2f71a6 100644 --- a/net/can/can_recvfrom.c +++ b/net/can/can_recvfrom.c @@ -1,36 +1,20 @@ /**************************************************************************** * net/can/can_recvfrom.c * - * Copyright (C) 2007-2009, 2011-2017, 2020 Gregory Nutt. All rights - * reserved. - * Author: Gregory Nutt - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * 3. Neither the name NuttX nor the names of its contributors may be - * used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -146,7 +130,6 @@ static size_t can_recvfrom_newdata(FAR struct net_driver_s *dev, /* Copy the new packet data into the user buffer */ memcpy(pstate->pr_buffer, dev->d_buf, recvlen); - //ninfo("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len); /* Update the accumulated size of the data read */ @@ -155,7 +138,6 @@ static size_t can_recvfrom_newdata(FAR struct net_driver_s *dev, return recvlen; } - /**************************************************************************** * Name: can_newdata * @@ -187,7 +169,8 @@ static inline void can_newdata(FAR struct net_driver_s *dev, if (recvlen < dev->d_len) { - FAR struct can_conn_s *conn = (FAR struct can_conn_s *)pstate->pr_sock->s_conn; + FAR struct can_conn_s *conn = + (FAR struct can_conn_s *)pstate->pr_sock->s_conn; FAR uint8_t *buffer = (FAR uint8_t *)dev->d_appdata + recvlen; uint16_t buflen = dev->d_len - recvlen; #ifdef CONFIG_DEBUG_NET @@ -249,8 +232,8 @@ static inline int can_readahead(struct can_recvfrom_s *pstate) * buffer. */ - if((iob = iob_peek_queue(&conn->readahead)) != NULL && - pstate->pr_buflen > 0) + if ((iob = iob_peek_queue(&conn->readahead)) != NULL && + pstate->pr_buflen > 0) { DEBUGASSERT(iob->io_pktlen > 0); @@ -292,9 +275,11 @@ static inline int can_readahead(struct can_recvfrom_s *pstate) iob_trimhead_queue(&conn->readahead, recvlen, IOBUSER_NET_CAN_READAHEAD); } - return recvlen; + + return recvlen; } - return 0; + + return 0; } static uint16_t can_recvfrom_eventhandler(FAR struct net_driver_s *dev, @@ -303,8 +288,6 @@ static uint16_t can_recvfrom_eventhandler(FAR struct net_driver_s *dev, { struct can_recvfrom_s *pstate = (struct can_recvfrom_s *)pvpriv; - //ninfo("flags: %04x\n", flags); - /* 'priv' might be null in some race conditions (?) */ if (pstate) @@ -319,17 +302,17 @@ static uint16_t can_recvfrom_eventhandler(FAR struct net_driver_s *dev, /* We are finished. */ - //ninfo("CAN done\n"); - /* Don't allow any further call backs. */ pstate->pr_cb->flags = 0; pstate->pr_cb->priv = NULL; pstate->pr_cb->event = NULL; +#if 0 /* Save the sender's address in the caller's 'from' location */ - //pkt_recvfrom_sender(dev, pstate); + pkt_recvfrom_sender(dev, pstate); +#endif /* indicate that the data has been consumed */ @@ -429,16 +412,15 @@ ssize_t can_recvfrom(FAR struct socket *psock, FAR void *buf, (fromlen != NULL && *fromlen >= sizeof(struct sockaddr_can))); conn = (FAR struct can_conn_s *)psock->s_conn; - + if (psock->s_type != SOCK_RAW) { nerr("ERROR: Unsupported socket type: %d\n", psock->s_type); ret = -ENOSYS; } - - + net_lock(); - + /* Initialize the state structure. */ memset(&state, 0, sizeof(struct can_recvfrom_s)); @@ -453,19 +435,20 @@ ssize_t can_recvfrom(FAR struct socket *psock, FAR void *buf, state.pr_buflen = len; state.pr_buffer = buf; state.pr_sock = psock; - + /* Handle any any CAN data already buffered in a read-ahead buffer. NOTE * that there may be read-ahead data to be retrieved even after the * socket has been disconnected. */ + ret = can_readahead(&state); - if(ret > 0) - { + if (ret > 0) + { net_unlock(); nxsem_destroy(&state.pr_sem); return ret; - } - + } + /* Get the device driver that will service this transfer */ dev = conn->dev; @@ -474,7 +457,7 @@ ssize_t can_recvfrom(FAR struct socket *psock, FAR void *buf, ret = -ENODEV; goto errout_with_state; } - + /* Set up the callback in the connection */ state.pr_cb = can_callback_alloc(dev, conn); @@ -502,7 +485,6 @@ ssize_t can_recvfrom(FAR struct socket *psock, FAR void *buf, ret = -EBUSY; } - errout_with_state: net_unlock(); nxsem_destroy(&state.pr_sem); diff --git a/net/can/can_setsockopt.c b/net/can/can_setsockopt.c index db4cb76..2d117a8 100644 --- a/net/can/can_setsockopt.c +++ b/net/can/can_setsockopt.c @@ -1,35 +1,20 @@ /**************************************************************************** * net/can/can_setsockopt.c * - * Copyright (C) 2018, 2020 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The + * ASF licenses this file to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the + * License. You may obtain a copy of the License at * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: + * http://www.apache.org/licenses/LICENSE-2.0 * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * 3. Neither the name NuttX nor the names of its contributors may be - * used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. * ****************************************************************************/ @@ -87,7 +72,6 @@ int can_setsockopt(FAR struct socket *psock, int option, FAR const void *value, socklen_t value_len) { - FAR struct can_conn_s *conn; int ret; int count = 0; @@ -101,37 +85,37 @@ int can_setsockopt(FAR struct socket *psock, int option, return -ENOTCONN; } - switch (option) { case CAN_RAW_FILTER: if (value_len % sizeof(struct can_filter) != 0) - { - ret = -EINVAL; - } - + { + ret = -EINVAL; + } + if (value_len > CAN_RAW_FILTER_MAX * sizeof(struct can_filter)) - { - ret = -EINVAL; - } + { + ret = -EINVAL; + } + + count = value_len / sizeof(struct can_filter); - count = value_len / sizeof(struct can_filter); - /* FIXME pass filter to driver */ + break; - + case CAN_RAW_ERR_FILTER: break; - + case CAN_RAW_LOOPBACK: break; - + case CAN_RAW_RECV_OWN_MSGS: break; - + case CAN_RAW_FD_FRAMES: break; - + case CAN_RAW_JOIN_FILTERS: break; diff --git a/net/can/can_sockif.c b/net/can/can_sockif.c index 5c8415e..573ddd8 100644 --- a/net/can/can_sockif.c +++ b/net/can/can_sockif.c @@ -96,7 +96,6 @@ const struct sock_intf_s g_can_sockif = can_close /* si_close */ }; - /**************************************************************************** * Private Functions ****************************************************************************/ @@ -149,12 +148,14 @@ static uint16_t can_poll_eventhandler(FAR struct net_driver_s *dev, eventset |= (POLLHUP | POLLERR); } +#if 0 /* A poll is a sign that we are free to send data. */ - /* else if ((flags & CAN_POLL) != 0 && psock_udp_cansend(info->psock) >= 0) + else if ((flags & CAN_POLL) != 0 && psock_udp_cansend(info->psock) >= 0) { eventset |= (POLLOUT & info->fds->events); - }*/ + } +#endif /* Awaken the caller of poll() is requested event occurred. */ @@ -326,23 +327,23 @@ static void can_addref(FAR struct socket *psock) ****************************************************************************/ static int can_bind(FAR struct socket *psock, - FAR const struct sockaddr *addr, socklen_t addrlen) + FAR const struct sockaddr *addr, socklen_t addrlen) { FAR struct sockaddr_can *canaddr; FAR struct can_conn_s *conn; + char netdev_name[6]; DEBUGASSERT(psock != NULL && psock->s_conn != NULL && addr != NULL && addrlen >= sizeof(struct sockaddr_can)); /* Save the address information in the connection structure */ - canaddr = (FAR struct sockaddr_can *)addr; - conn = (FAR struct can_conn_s *)psock->s_conn; + canaddr = (FAR struct sockaddr_can *)addr; + conn = (FAR struct can_conn_s *)psock->s_conn; /* Bind CAN device to socket */ - //TODO better support for CONFIG_NETDEV_IFINDEX - char netdev_name[6]; + /* TODO better support for CONFIG_NETDEV_IFINDEX */ sprintf(netdev_name, "can%i", canaddr->can_ifindex); @@ -374,8 +375,8 @@ static int can_bind(FAR struct socket *psock, ****************************************************************************/ static int can_getsockname(FAR struct socket *psock, - FAR struct sockaddr *addr, - FAR socklen_t *addrlen) + FAR struct sockaddr *addr, + FAR socklen_t *addrlen) { FAR struct sockaddr_can *canaddr; @@ -430,8 +431,8 @@ static int can_getsockname(FAR struct socket *psock, ****************************************************************************/ static int can_getpeername(FAR struct socket *psock, - FAR struct sockaddr *addr, - FAR socklen_t *addrlen) + FAR struct sockaddr *addr, + FAR socklen_t *addrlen) { #warning Missing logic return -EOPNOTSUPP; /* Or maybe return -EAFNOSUPPORT; */ @@ -488,8 +489,8 @@ static int can_listen(FAR struct socket *psock, int backlog) ****************************************************************************/ static int can_connect(FAR struct socket *psock, - FAR const struct sockaddr *addr, - socklen_t addrlen) + FAR const struct sockaddr *addr, + socklen_t addrlen) { #warning Missing logic return -EOPNOTSUPP; @@ -540,7 +541,7 @@ static int can_connect(FAR struct socket *psock, ****************************************************************************/ static int can_accept(FAR struct socket *psock, FAR struct sockaddr *addr, - FAR socklen_t *addrlen, FAR struct socket *newsock) + FAR socklen_t *addrlen, FAR struct socket *newsock) { #warning Missing logic return -EOPNOTSUPP; @@ -570,7 +571,7 @@ static int can_accept(FAR struct socket *psock, FAR struct sockaddr *addr, ****************************************************************************/ static int can_poll_local(FAR struct socket *psock, FAR struct pollfd *fds, - bool setup) + bool setup) { FAR struct can_conn_s *conn; FAR struct can_poll_s *info; @@ -580,18 +581,17 @@ static int can_poll_local(FAR struct socket *psock, FAR struct pollfd *fds, DEBUGASSERT(psock != NULL && psock->s_conn != NULL); conn = (FAR struct can_conn_s *)psock->s_conn; info = conn->pollinfo; - - //FIXME add NETDEV_DOWN support + + /* FIXME add NETDEV_DOWN support */ /* Check if we are setting up or tearing down the poll */ if (setup) { - net_lock(); - + info->dev = conn->dev; - + cb = can_callback_alloc(info->dev, conn); if (cb == NULL) { @@ -600,82 +600,84 @@ static int can_poll_local(FAR struct socket *psock, FAR struct pollfd *fds, } /* Initialize the poll info container */ - + info->psock = psock; info->fds = fds; info->cb = cb; - + /* Initialize the callback structure. Save the reference to the info * structure as callback private data so that it will be available during * callback processing. */ - + cb->flags = NETDEV_DOWN; cb->priv = (FAR void *)info; cb->event = can_poll_eventhandler; - + if ((fds->events & POLLOUT) != 0) { cb->flags |= CAN_POLL; } - + if ((fds->events & POLLIN) != 0) { cb->flags |= CAN_NEWDATA; } - + /* Save the reference in the poll info structure as fds private as well * for use during poll teardown as well. */ - + fds->priv = (FAR void *)info; - + /* Check for read data availability now */ - + if (!IOB_QEMPTY(&conn->readahead)) { /* Normal data may be read without blocking. */ - + fds->revents |= (POLLRDNORM & fds->events); } - + #if 0 if (psock_udp_cansend(psock) >= 0) { /* Normal data may be sent without blocking (at least one byte). */ - + fds->revents |= (POLLWRNORM & fds->events); } #endif - + /* Check if any requested events are already in effect */ - + if (fds->revents != 0) { /* Yes.. then signal the poll logic */ + nxsem_post(fds->sem); } - + errout_with_lock: net_unlock(); } - else + else { info = (FAR struct can_poll_s *)fds->priv; - + if (info != NULL) - { - /* Cancel any response notifications */ - can_callback_free(info->dev, conn, info->cb); + { + /* Cancel any response notifications */ + + can_callback_free(info->dev, conn, info->cb); - /* Release the poll/select data slot */ + /* Release the poll/select data slot */ - info->fds->priv = NULL; + info->fds->priv = NULL; - /* Then free the poll info container */ + /* Then free the poll info container */ - info->psock = NULL; - } + info->psock = NULL; + } } return ret; @@ -702,27 +704,28 @@ errout_with_lock: ****************************************************************************/ static ssize_t can_send(FAR struct socket *psock, FAR const void *buf, - size_t len, int flags) + size_t len, int flags) { - ssize_t ret; + ssize_t ret; - /* Only SOCK_RAW is supported */ + /* Only SOCK_RAW is supported */ - if (psock->s_type == SOCK_RAW) - { - /* Raw packet send */ - ret = psock_can_send(psock, buf, len); - } - else - { - /* EDESTADDRREQ. Signifies that the socket is not connection-mode and - * no peer address is set. - */ + if (psock->s_type == SOCK_RAW) + { + /* Raw packet send */ - ret = -EDESTADDRREQ; - } + ret = psock_can_send(psock, buf, len); + } + else + { + /* EDESTADDRREQ. Signifies that the socket is not connection-mode and + * no peer address is set. + */ + + ret = -EDESTADDRREQ; + } - return ret; + return ret; } /**************************************************************************** @@ -750,11 +753,11 @@ static ssize_t can_send(FAR struct socket *psock, FAR const void *buf, ****************************************************************************/ static ssize_t can_sendto(FAR struct socket *psock, FAR const void *buf, - size_t len, int flags, - FAR const struct sockaddr *to, socklen_t tolen) + size_t len, int flags, + FAR const struct sockaddr *to, socklen_t tolen) { - nerr("ERROR: sendto() not supported for raw packet sockets\n"); - return -EAFNOSUPPORT; + nerr("ERROR: sendto() not supported for raw packet sockets\n"); + return -EAFNOSUPPORT; } /**************************************************************************** diff --git a/net/socket/getsockopt.c b/net/socket/getsockopt.c index f28c80b..fa1aff2 100644 --- a/net/socket/getsockopt.c +++ b/net/socket/getsockopt.c @@ -121,7 +121,8 @@ static int psock_socketlevel_option(FAR struct socket *psock, int option, default: /* Other options are passed to usrsock daemon. */ { - return usrsock_getsockopt(conn, SOL_SOCKET, option, value, value_len); + return usrsock_getsockopt(conn, SOL_SOCKET, option, value, + value_len); } } } @@ -372,7 +373,7 @@ int psock_getsockopt(FAR struct socket *psock, int level, int option, ret = can_getsockopt(psock, option, value, value_len); #endif break; - + /* These levels are defined in sys/socket.h, but are not yet * implemented. */ @@ -437,7 +438,8 @@ int psock_getsockopt(FAR struct socket *psock, int level, int option, * ****************************************************************************/ -int getsockopt(int sockfd, int level, int option, void *value, socklen_t *value_len) +int getsockopt(int sockfd, int level, int option, FAR void *value, + FAR socklen_t *value_len) { FAR struct socket *psock; int ret;