Merge branch 'master' of git://gitorious.org/linux-can/linux-can-next
authorDavid S. Miller <davem@davemloft.net>
Wed, 6 Jun 2012 18:13:26 +0000 (11:13 -0700)
committerDavid S. Miller <davem@davemloft.net>
Wed, 6 Jun 2012 18:13:26 +0000 (11:13 -0700)
1  2 
Documentation/networking/can.txt
drivers/net/can/flexcan.c

index ac295399f0d4e99d9042d32c3a0a8ebf137c72cc,28d9b14c34ecb1541684109c3342a7850c83e80d..a06741898f29f99ed6a766f50647c34521968b35
@@@ -232,16 -232,16 +232,16 @@@ solution for a couple of reasons
    arbitration problems and error frames caused by the different
    ECUs. The occurrence of detected errors are important for diagnosis
    and have to be logged together with the exact timestamp. For this
-   reason the CAN interface driver can generate so called Error Frames
-   that can optionally be passed to the user application in the same
-   way as other CAN frames. Whenever an error on the physical layer
+   reason the CAN interface driver can generate so called Error Message
+   Frames that can optionally be passed to the user application in the
+   same way as other CAN frames. Whenever an error on the physical layer
    or the MAC layer is detected (e.g. by the CAN controller) the driver
-   creates an appropriate error frame. Error frames can be requested by
-   the user application using the common CAN filter mechanisms. Inside
-   this filter definition the (interested) type of errors may be
-   selected. The reception of error frames is disabled by default.
-   The format of the CAN error frame is briefly described in the Linux
-   header file "include/linux/can/error.h".
+   creates an appropriate error message frame. Error messages frames can
+   be requested by the user application using the common CAN filter
+   mechanisms. Inside this filter definition the (interested) type of
+   errors may be selected. The reception of error messages is disabled
+   by default. The format of the CAN error message frame is briefly
+   described in the Linux header file "include/linux/can/error.h".
  
  4. How to use Socket CAN
  ------------------------
    defaults are set at RAW socket binding time:
  
    - The filters are set to exactly one filter receiving everything
-   - The socket only receives valid data frames (=> no error frames)
+   - The socket only receives valid data frames (=> no error message frames)
    - The loopback of sent CAN frames is enabled (see chapter 3.2)
    - The socket does not receive its own sent frames (in loopback mode)
  
    4.1.2 RAW socket option CAN_RAW_ERR_FILTER
  
    As described in chapter 3.4 the CAN interface driver can generate so
-   called Error Frames that can optionally be passed to the user
+   called Error Message Frames that can optionally be passed to the user
    application in the same way as other CAN frames. The possible
    errors are divided into different error classes that may be filtered
    using the appropriate error mask. To register for every possible
  
      rcvlist_all - list for unfiltered entries (no filter operations)
      rcvlist_eff - list for single extended frame (EFF) entries
-     rcvlist_err - list for error frames masks
+     rcvlist_err - list for error message frames masks
      rcvlist_fil - list for mask/value filters
      rcvlist_inv - list for mask/value filters (inverse semantic)
      rcvlist_sff - list for single standard frame (SFF) entries
    The CAN device must be configured via netlink interface. The supported
    netlink message types are defined and briefly described in
    "include/linux/can/netlink.h". CAN link support for the program "ip"
 -  of the IPROUTE2 utility suite is avaiable and it can be used as shown
 +  of the IPROUTE2 utility suite is available and it can be used as shown
    below:
  
    - Setting CAN device properties:
      $ ip link set canX type can restart-ms 100
  
    Alternatively, the application may realize the "bus-off" condition
-   by monitoring CAN error frames and do a restart when appropriate with
-   the command:
+   by monitoring CAN error message frames and do a restart when
+   appropriate with the command:
  
      $ ip link set canX type can restart
  
-   Note that a restart will also create a CAN error frame (see also
-   chapter 3.4).
+   Note that a restart will also create a CAN error message frame (see
+   also chapter 3.4).
  
    6.6 Supported CAN hardware
  
index 38c0690df5c8ae9ae283bde27eb523ca55bf8b19,0d058b0a3cb65c5e25461b12088e662297c2c858..d465fd4546f09c9b8322955f21e829d182551082
@@@ -35,7 -35,6 +35,7 @@@
  #include <linux/module.h>
  #include <linux/of.h>
  #include <linux/platform_device.h>
 +#include <linux/pinctrl/consumer.h>
  
  #define DRV_NAME                      "flexcan"
  
@@@ -928,16 -927,11 +928,16 @@@ static int __devinit flexcan_probe(stru
        struct flexcan_priv *priv;
        struct resource *mem;
        struct clk *clk = NULL;
 +      struct pinctrl *pinctrl;
        void __iomem *base;
        resource_size_t mem_size;
        int err, irq;
        u32 clock_freq = 0;
  
 +      pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
 +      if (IS_ERR(pinctrl))
 +              return PTR_ERR(pinctrl);
 +
        if (pdev->dev.of_node) {
                const u32 *clock_freq_p;
  
@@@ -1056,6 -1050,42 +1056,42 @@@ static struct of_device_id flexcan_of_m
        {},
  };
  
+ #ifdef CONFIG_PM
+ static int flexcan_suspend(struct platform_device *pdev, pm_message_t state)
+ {
+       struct net_device *dev = platform_get_drvdata(pdev);
+       struct flexcan_priv *priv = netdev_priv(dev);
+       flexcan_chip_disable(priv);
+       if (netif_running(dev)) {
+               netif_stop_queue(dev);
+               netif_device_detach(dev);
+       }
+       priv->can.state = CAN_STATE_SLEEPING;
+       return 0;
+ }
+ static int flexcan_resume(struct platform_device *pdev)
+ {
+       struct net_device *dev = platform_get_drvdata(pdev);
+       struct flexcan_priv *priv = netdev_priv(dev);
+       priv->can.state = CAN_STATE_ERROR_ACTIVE;
+       if (netif_running(dev)) {
+               netif_device_attach(dev);
+               netif_start_queue(dev);
+       }
+       flexcan_chip_enable(priv);
+       return 0;
+ }
+ #else
+ #define flexcan_suspend NULL
+ #define flexcan_resume NULL
+ #endif
  static struct platform_driver flexcan_driver = {
        .driver = {
                .name = DRV_NAME,
        },
        .probe = flexcan_probe,
        .remove = __devexit_p(flexcan_remove),
+       .suspend = flexcan_suspend,
+       .resume = flexcan_resume,
  };
  
  module_platform_driver(flexcan_driver);