convert can_sys_clock in can_device to be Hz based

git-svn-id: svn://svn.berlios.de//socketcan/trunk@20 030b6a49-0b11-0410-94ab-b0dab22257f2

diff --git a/kernel/2.6/drivers/net/can/can_device.c b/kernel/2.6/drivers/net/can/can_device.c
index 1634d3f52ce82bbd6c7198990aaa235f5f909f27..0339614e1e4a0a573503765dec22366b3d0415cc 100644 (file)
--- a/kernel/2.6/drivers/net/can/can_device.c
+++ b/kernel/2.6/drivers/net/can/can_device.c
@@ -22,7 +22,7 @@
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
 #include <linux/can/can.h>
-#include <linux/can/can_device.h>
+#include <can/can_device.h>
 
 /*
  Abstract:
@@ -52,20 +52,23 @@
 #define MAX_PHASE_SEG1 8U
 #define MAX_PHASE_SEG2 8U
 
-int can_calc_bit_time(struct can_device *can, u32 bit_time_nsec,
+int can_calc_bit_time(struct can_device *can, u32 baudrate,
                                          struct can_bittime_std *bit_time)
 {
-       unsigned best_error = UINT_MAX; /* Ariphmetic error */
+       int best_error = -1; /* Ariphmetic error */
        int df, best_df = -1; /* oscillator's tolerance range, greater is better*/
        u32 quanta;     /*in tq units*/
        u32 brp, phase_seg1, phase_seg2, sjw, prop_seg;
        u32 brp_min, brp_max, brp_expected;
+       u64 tmp;
 
-       /* bit time range [1KHz,1MHz] */
-       if (bit_time_nsec > 1000000UL || bit_time_nsec < 1000)
+       /* baudrate range [1Kbaud,1Mbaud] */
+       if (baudrate < 1000 || baudrate > 1000000UL)
                return -EINVAL;
 
-       brp_expected = can->can_sys_clock * bit_time_nsec;
+       tmp = (u64)can->can_sys_clock*1000;
+       do_div(tmp, baudrate);
+       brp_expected = (u32)tmp;
 
        brp_min = brp_expected/(1000*MAX_BIT_TIME);
        if(brp_min == 0)
@@ -113,7 +116,7 @@ int can_calc_bit_time(struct can_device *can, u32 bit_time_nsec,
                                        unsigned error = abs(brp_expected*10/
                                                           (brp*(1+prop_seg+phase_seg1+phase_seg2))-10000);
 
-                                       if( error > best_error )
+                                       if( error > 10 || error > best_error )
                                                continue;
 
                                        if( error == best_error && prop_seg < bit_time->prop_seg )
@@ -133,7 +136,7 @@ int can_calc_bit_time(struct can_device *can, u32 bit_time_nsec,
        next_brp:       ;
        }
 
-       if(best_error>=10)
+       if( best_error < 0 )
                return -EDOM;
        return 0;
 }
@@ -156,27 +159,35 @@ static int can_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
 
        switch (cmd) {
        case SIOCSCANCUSTOMBITTIME:
-               if (can->do_set_bit_time)
-                       return can->do_set_bit_time(can, bt);
+               if (can->do_set_bit_time) {
+                       ret = can->do_set_bit_time(can, bt);
+                       if ( !ret ) {
+                               can->bit_time = *bt;
+                               if (bt->type == CAN_BITTIME_STD && bt->std.brp) {
+                                 can->baudrate = can->can_sys_clock/(bt->std.brp*
+                                 (1+bt->std.prop_seg+bt->std.phase_seg1+bt->std.phase_seg2));
+                               }
+                               else
+                                       can->baudrate = CAN_BAUDRATE_UNKNOWN;
+                       }
+               }
+               break;
+       case SIOCGCANCUSTOMBITTIME:
+               *bt = can->bit_time;
                break;
        case SIOCSCANBAUDRATE:
-          if (!can->do_set_bit_time)
-                       break;
-          if ( *baudrate >= 1000UL && *baudrate <= 1000000UL)
-          {
+          if (can->do_set_bit_time) {
                        struct can_bittime bit_time;
-                       u32 bit_time_nsec = (2000000000UL+(*baudrate))/(2*(*baudrate));
-                       ret = can_calc_bit_time(can, bit_time_nsec, &bit_time.std);
+                       ret = can_calc_bit_time(can, *baudrate, &bit_time.std);
                        if (ret != 0)
                                break;
                        bit_time.type = CAN_BITTIME_STD;
-                       return can->do_set_bit_time(can, &bit_time);
+                       ret = can->do_set_bit_time(can, &bit_time);
+                       if ( !ret ) {
+                               can->baudrate = *baudrate;
+                               can->bit_time = bit_time;
+                       }
                }
-               else
-                       ret = -EINVAL;
-               break;
-       case SIOCGCANCUSTOMBITTIME:
-               *bt = can->bit_time;
                break;
        case SIOCGCANBAUDRATE:
            *baudrate = can->baudrate;

diff --git a/kernel/2.6/drivers/net/can/can_device.h b/kernel/2.6/drivers/net/can/can_device.h
index f71e6379ec89fee54faddfe5499f68cc3eb59c35..890ce15329bb299d754937e5690371b212990e2f 100644 (file)
--- a/kernel/2.6/drivers/net/can/can_device.h
+++ b/kernel/2.6/drivers/net/can/can_device.h
@@ -38,11 +38,11 @@ struct can_device {
        struct net_device_stats stats;
        struct net_device               *net_dev;
 
-       /* can-bus oscillator frequency, in MHz,
+       /* can-bus oscillator frequency, in Hz,
           BE CAREFUL! SOME CONTROLLERS (LIKE SJA1000)
           FOOLISH ABOUT THIS FRQ (for sja1000 as ex. this
           clock must be xtal clock divided by 2). */
-       u8      can_sys_clock;
+       u32     can_sys_clock;
 
        /* by default max_brp is equal 64,
           but for a Freescale TouCAN, as ex., it can be 255*/
@@ -51,10 +51,13 @@ struct can_device {
           some, hmm, CAN implementations hardwared it to 1 */
        u8      max_sjw;
 
-       u32             baudrate;       /* in bauds */
+       u32     baudrate;       /* in bauds */
        struct can_bittime      bit_time;
 
-       spinlock_t      irq_lock;
+       spinlock_t irq_lock;
+
+       can_state_t state;
+       can_mode_t  mode;
 
        int     (*do_set_bit_time)(struct can_device *dev, struct can_bittime *br);
        int (*do_get_state)(struct can_device *dev,     enum CAN_STATE *state);
@@ -69,7 +72,7 @@ struct can_device {
 struct can_device *alloc_candev(int sizeof_priv);
 void free_candev(struct can_device *);
 
-int can_calc_bit_time(struct can_device *can, u32 bit_time_nsec,
+int can_calc_bit_time(struct can_device *can, u32 baudrate,
                                          struct can_bittime_std *bit_time);
 
 #endif /* __CAN_DEVICE_H__ */

diff --git a/kernel/2.6/include/linux/can/can_ioctl.h b/kernel/2.6/include/linux/can/can_ioctl.h
index 58e9d27a2b94b8437e073fd127f495f9eb5a98fe..5358261d52d56af1e80c04ba0ebb592067699841 100644 (file)
--- a/kernel/2.6/include/linux/can/can_ioctl.h
+++ b/kernel/2.6/include/linux/can/can_ioctl.h
@@ -108,7 +108,7 @@ struct can_bittime {
                struct can_bittime_btr btr;
        };
 };
-
+#define CAN_BAUDRATE_UNKNOWN 0
 
 /* SIOC[SG]CANMODE */
 
@@ -133,7 +133,7 @@ typedef __u32 can_filter_t;
 
 /* filter modes (may vary due to controller specific capabilities) */
 #define CAN_FILTER_CAPAB       0  /* get filter type capabilities (32 Bit value) */
-#define CAN_FILTER_MASK_VALUE  1  /* easy bit filter (see struct can_filter) */  
+#define CAN_FILTER_MASK_VALUE  1  /* easy bit filter (see struct can_filter) */
 #define CAN_FILTER_SFF_BITMASK 2  /* bitfield with 2048 bit SFF filter */
                                  /* filters 3 - 31 currently undefined */