1

#------------------------------------------------------------------------------

     2

#

     3

#  $Id$

     4

#

     5

#  Copyright (C) 2006-2012  Florian Pose, Ingenieurgemeinschaft IgH

     6

#

     7

#  This file is part of the IgH EtherCAT Master.

     8

#

     9

#  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

#  modify it under the terms of the GNU General Public License version 2, as

    11

#  published by the Free Software Foundation.

    12

#

    13

#  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

#  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

#  Public License for more details.

    17

#

    18

#  You should have received a copy of the GNU General Public License along

    19

#  with the IgH EtherCAT Master; if not, write to the Free Software

    20

#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

#

    22

#  ---

    23

#

    24

#  The license mentioned above concerns the source code only. Using the

    25

#  EtherCAT technology and brand is only permitted in compliance with the

    26

#  industrial property and similar rights of Beckhoff Automation GmbH.

    27

#

    28

#------------------------------------------------------------------------------

    29

    30

AC_PREREQ(2.59)

    31

AC_INIT([ethercat],[1.5.1],[fp@igh-essen.com])

    32

AC_CONFIG_AUX_DIR([autoconf])

    33

AM_INIT_AUTOMAKE([-Wall -Werror dist-bzip2])

    34

AC_PREFIX_DEFAULT([/opt/etherlab])

    35

AC_CONFIG_HEADERS([config.h])

    36

AC_CONFIG_SRCDIR([config.h.in])

    37

AC_CONFIG_MACRO_DIR([m4])

    38

    39

#------------------------------------------------------------------------------

    40

# Global

    41

#------------------------------------------------------------------------------

    42

    43

AC_PROG_CXX

    44

AC_PROG_LIBTOOL

    45

AM_PROG_CC_C_O

    46

    47

#------------------------------------------------------------------------------

    48

# Linux sources

    49

#------------------------------------------------------------------------------

    50

    51

AC_ARG_WITH([linux-dir],

    52

    AC_HELP_STRING(

    53

        [--with-linux-dir=<DIR>],

    54

        [Linux kernel sources @<:@running kernel@:>@]

    55

    ),

    56

    [

    57

        sourcedir=[$withval]

    58

    ],

    59

    [

    60

        version=[`uname -r`]

    61

        modulesdir=/lib/modules/${version}

    62

        if test \! -d ${modulesdir} || test \! -d ${modulesdir}/build; then

    63

           echo

    64

           AC_MSG_ERROR([Failed to find Linux sources. Use --with-linux-dir!])

    65

        fi

    66

        sourcedir=`cd ${modulesdir}/build && pwd -P`

    67

    ]

    68

)

    69

    70

AC_MSG_CHECKING([for Linux kernel sources])

    71

    72

if test \! -r ${sourcedir}/.config; then

    73

    echo

    74

    AC_MSG_ERROR([No configured Linux kernel sources in $sourcedir])

    75

fi

    76

    77

# Try to get kernel release string

    78

if test -r ${sourcedir}/include/config/kernel.release; then

    79

    kernelrelease=`cat $sourcedir/include/config/kernel.release`

    80

elif test -r ${sourcedir}/.kernelrelease; then

    81

    kernelrelease=`cat $sourcedir/.kernelrelease`

    82

elif test -r ${sourcedir}/include/linux/utsrelease.h; then

    83

    hdr=${sourcedir}/include/linux/utsrelease.h

    84

    kernelrelease=`grep UTS_RELEASE $hdr | cut -d " " -f 3- | tr -d \"`

    85

elif test -r ${sourcedir}/include/linux/version.h; then

    86

    hdr=${sourcedir}/include/linux/version.h

    87

    kernelrelease=`grep UTS_RELEASE $hdr | cut -d " " -f 3- | tr -d \"`

    88

fi

    89

    90

if test -z "$kernelrelease"; then

    91

    echo

    92

    AC_MSG_ERROR([Failed to extract Linux kernel version!])

    93

fi

    94

    95

if test ${kernelrelease%%.*} -gt 2; then

    96

    regex="^[[0-9]]+\.[[0-9]]+"

    97

else

    98

    regex="^[[0-9]]+\.[[0-9]]+\.[[0-9]]+"

    99

fi

   100

   101

# Extract numbers from kernel release

   102

linuxversion=`echo $kernelrelease | grep -oE "$regex"`

   103

   104

AC_SUBST(LINUX_SOURCE_DIR,[$sourcedir])

   105

AC_MSG_RESULT([$LINUX_SOURCE_DIR (Kernel $linuxversion)])

   106

   107

#------------------------------------------------------------------------------

   108

# Linux module installation subdirectory

   109

#------------------------------------------------------------------------------

   110

   111

AC_ARG_WITH([module-dir],

   112

    AC_HELP_STRING(

   113

        [--with-module-dir=<DIR>],

   114

        [Linux module installation dir. Default: ethercat]

   115

    ),

   116

    [moddir=[$withval]],

   117

    [moddir="ethercat"]

   118

)

   119

AC_SUBST(INSTALL_MOD_DIR,[$moddir])

   120

   121

AC_MSG_CHECKING([for Linux modules installation directory])

   122

AC_MSG_RESULT([$INSTALL_MOD_DIR])

   123

   124

#------------------------------------------------------------------------------

   125

# Generic Ethernet driver

   126

#------------------------------------------------------------------------------

   127

   128

AC_ARG_ENABLE([generic],

   129

    AS_HELP_STRING([--enable-generic],

   130

                   [Enable generic Ethernet driver]),

   131

    [

   132

        case "${enableval}" in

   133

            yes) enablegeneric=1

   134

                ;;

   135

            no) enablegeneric=0

   136

                ;;

   137

            *) AC_MSG_ERROR([Invalid value for --enable-generic])

   138

                ;;

   139

        esac

   140

    ],

   141

    [enablegeneric=1]

   142

)

   143

   144

AM_CONDITIONAL(ENABLE_GENERIC, test "x$enablegeneric" = "x1")

   145

AC_SUBST(ENABLE_GENERIC,[$enablegeneric])

   146

   147

#------------------------------------------------------------------------------

   148

# 8139too driver

   149

#------------------------------------------------------------------------------

   150

   151

AC_ARG_ENABLE([8139too],

   152

    AS_HELP_STRING([--enable-8139too],

   153

                   [Enable 8139too driver]),

   154

    [

   155

        case "${enableval}" in

   156

            yes) enable8139too=1

   157

                ;;

   158

            no) enable8139too=0

   159

                ;;

   160

            *) AC_MSG_ERROR([Invalid value for --enable-8139too])

   161

                ;;

   162

        esac

   163

    ],

   164

    [enable8139too=1]

   165

)

   166

   167

AM_CONDITIONAL(ENABLE_8139TOO, test "x$enable8139too" = "x1")

   168

AC_SUBST(ENABLE_8139TOO,[$enable8139too])

   169

   170

AC_ARG_WITH([8139too-kernel],

   171

    AC_HELP_STRING(

   172

        [--with-8139too-kernel=<X.Y.Z>],

   173

        [8139too kernel (only if differing)]

   174

    ),

   175

    [

   176

        kernel8139too=[$withval]

   177

    ],

   178

    [

   179

        kernel8139too=$linuxversion

   180

    ]

   181

)

   182

   183

if test "x${enable8139too}" = "x1"; then

   184

    AC_MSG_CHECKING([for kernel for 8139too driver])

   185

   186

    kernels=`ls -1 ${srcdir}/devices/ | grep -oE "^8139too-.*-" | cut -d "-" -f 2 | uniq`

   187

    found=0

   188

    for k in $kernels; do

   189

        if test "$kernel8139too" = "$k"; then

   190

            found=1

   191

        fi

   192

    done

   193

    if test $found -ne 1; then

   194

        AC_MSG_ERROR([kernel $kernel8139too not available for 8139too driver!])

   195

    fi

   196

   197

    AC_MSG_RESULT([$kernel8139too])

   198

fi

   199

   200

AC_SUBST(KERNEL_8139TOO,[$kernel8139too])

   201

   202

#------------------------------------------------------------------------------

   203

# e100 driver

   204

#------------------------------------------------------------------------------

   205

   206

AC_ARG_ENABLE([e100],

   207

    AS_HELP_STRING([--enable-e100],

   208

                   [Enable e100 driver]),

   209

    [

   210

        case "${enableval}" in

   211

            yes) enablee100=1

   212

                ;;

   213

            no) enablee100=0

   214

                ;;

   215

            *) AC_MSG_ERROR([Invalid value for --enable-e100])

   216

                ;;

   217

        esac

   218

    ],

   219

    [enablee100=0] # disabled by default

   220

)

   221

   222

AM_CONDITIONAL(ENABLE_E100, test "x$enablee100" = "x1")

   223

AC_SUBST(ENABLE_E100,[$enablee100])

   224

   225

AC_ARG_WITH([e100-kernel],

   226

    AC_HELP_STRING(

   227

        [--with-e100-kernel=<X.Y.Z>],

   228

        [e100 kernel (only if differing)]

   229

    ),

   230

    [

   231

        kernele100=[$withval]

   232

    ],

   233

    [

   234

        kernele100=$linuxversion

   235

    ]

   236

)

   237

   238

if test "x${enablee100}" = "x1"; then

   239

    AC_MSG_CHECKING([for kernel for e100 driver])

   240

   241

    kernels=`ls -1 ${srcdir}/devices/ | grep -oE "^e100-.*-" | cut -d "-" -f 2 | uniq`

   242

    found=0

   243

    for k in $kernels; do

   244

        if test "$kernele100" = "$k"; then

   245

            found=1

   246

        fi

   247

    done

   248

    if test $found -ne 1; then

   249

        AC_MSG_ERROR([kernel $kernele100 not available for e100 driver!])

   250

    fi

   251

   252

    AC_MSG_RESULT([$kernele100])

   253

fi

   254

   255

AC_SUBST(KERNEL_E100,[$kernele100])

   256

   257

#------------------------------------------------------------------------------

   258

# e1000 driver

   259

#------------------------------------------------------------------------------

   260

   261

AC_ARG_ENABLE([e1000],

   262

    AS_HELP_STRING([--enable-e1000],

   263

                   [Enable e1000 driver]),

   264

    [

   265

        case "${enableval}" in

   266

            yes) enablee1000=1

   267

                ;;

   268

            no) enablee1000=0

   269

                ;;

   270

            *) AC_MSG_ERROR([Invalid value for --enable-e1000])

   271

                ;;

   272

        esac

   273

    ],

   274

    [enablee1000=0] # disabled by default

   275

)

   276

   277

AM_CONDITIONAL(ENABLE_E1000, test "x$enablee1000" = "x1")

   278

AC_SUBST(ENABLE_E1000,[$enablee1000])

   279

   280

AC_ARG_WITH([e1000-kernel],

   281

    AC_HELP_STRING(

   282

        [--with-e1000-kernel=<X.Y.Z>],

   283

        [e1000 kernel (only if differing)]

   284

    ),

   285

    [

   286

        kernele1000=[$withval]

   287

    ],

   288

    [

   289

        kernele1000=$linuxversion

   290

    ]

   291

)

   292

   293

if test "x${enablee1000}" = "x1"; then

   294

    AC_MSG_CHECKING([for kernel for e1000 driver])

   295

   296

    kernels=`ls -1 ${srcdir}/devices/e1000/ | grep -oE "^e1000_main-.*" | cut -d "-" -f 2 | uniq`

   297

    found=0

   298

    for k in $kernels; do

   299

        if test "$kernele1000" = "$k"; then

   300

            found=1

   301

        fi

   302

    done

   303

    if test $found -ne 1; then

   304

        AC_MSG_ERROR([kernel $kernele1000 not available for e1000 driver!])

   305

    fi

   306

   307

    AC_MSG_RESULT([$kernele1000])

   308

fi

   309

   310

AC_SUBST(KERNEL_E1000,[$kernele1000])

   311

   312

#------------------------------------------------------------------------------

   313

# e1000e driver

   314

#------------------------------------------------------------------------------

   315

   316

AC_ARG_ENABLE([e1000e],

   317

    AS_HELP_STRING([--enable-e1000e],

   318

                   [Enable e1000e driver]),

   319

    [

   320

        case "${enableval}" in

   321

            yes) enablee1000e=1

   322

                ;;

   323

            no) enablee1000e=0

   324

                ;;

   325

            *) AC_MSG_ERROR([Invalid value for --enable-e1000e])

   326

                ;;

   327

        esac

   328

    ],

   329

    [enablee1000e=0] # disabled by default

   330

)

   331

   332

AM_CONDITIONAL(ENABLE_E1000E, test "x$enablee1000e" = "x1")

   333

AC_SUBST(ENABLE_E1000E,[$enablee1000e])

   334

   335

AC_ARG_WITH([e1000e-kernel],

   336

    AC_HELP_STRING(

   337

        [--with-e1000e-kernel=<X.Y.Z>],

   338

        [e1000e kernel (only if differing)]

   339

    ),

   340

    [

   341

        kernele1000e=[$withval]

   342

    ],

   343

    [

   344

        kernele1000e=$linuxversion

   345

    ]

   346

)

   347

   348

if test "x${enablee1000e}" = "x1"; then

   349

    AC_MSG_CHECKING([for kernel for e1000e driver])

   350

   351

    kernels=`ls -1 ${srcdir}/devices/e1000e/ | grep -oE "^netdev-.*" | cut -d "-" -f 2 | uniq`

   352

    found=0

   353

    for k in $kernels; do

   354

        if test "$kernele1000e" = "$k"; then

   355

            found=1

   356

        fi

   357

    done

   358

    if test $found -ne 1; then

   359

        AC_MSG_ERROR([kernel $kernele1000e not available for e1000e driver!])

   360

    fi

   361

   362

    AC_MSG_RESULT([$kernele1000e])

   363

fi

   364

   365

AC_SUBST(KERNEL_E1000E,[$kernele1000e])

   366

   367

#------------------------------------------------------------------------------

   368

# r8169 driver

   369

#------------------------------------------------------------------------------

   370

   371

AC_ARG_ENABLE([r8169],

   372

    AS_HELP_STRING([--enable-r8169],

   373

                   [Enable r8169 driver]),

   374

    [

   375

        case "${enableval}" in

   376

            yes) enable_r8169=1

   377

                ;;

   378

            no) enable_r8169=0

   379

                ;;

   380

            *) AC_MSG_ERROR([Invalid value for --enable-r8169])

   381

                ;;

   382

        esac

   383

    ],

   384

    [enable_r8169=0] # disabled by default

   385

)

   386

   387

AM_CONDITIONAL(ENABLE_R8169, test "x$enable_r8169" = "x1")

   388

AC_SUBST(ENABLE_R8169,[$enable_r8169])

   389

   390

AC_ARG_WITH([r8169-kernel],

   391

    AC_HELP_STRING(

   392

        [--with-r8169-kernel=<X.Y.Z>],

   393

        [r8169 kernel (only if differing)]

   394

    ),

   395

    [

   396

        kernel_r8169=[$withval]

   397

    ],

   398

    [

   399

        kernel_r8169=$linuxversion

   400

    ]

   401

)

   402

   403

if test "x${enable_r8169}" = "x1"; then

   404

    AC_MSG_CHECKING([for kernel for r8169 driver])

   405

   406

    kernels=`ls -1 ${srcdir}/devices/ | grep -oE "^r8169-.*-" | cut -d "-" -f 2 | uniq`

   407

    found=0

   408

    for k in $kernels; do

   409

        if test "$kernel_r8169" = "$k"; then

   410

            found=1

   411

        fi

   412

    done

   413

    if test $found -ne 1; then

   414

        AC_MSG_ERROR([kernel $kernel_r8169 not available for r8169 driver!])

   415

    fi

   416

   417

    AC_MSG_RESULT([$kernel_r8169])

   418

fi

   419

   420

AC_SUBST(KERNEL_R8169,[$kernel_r8169])

   421

   422

#------------------------------------------------------------------------------

   423

# RTAI path (optional)

   424

#------------------------------------------------------------------------------

   425

   426

AC_ARG_WITH([rtai-dir],

   427

    AC_HELP_STRING(

   428

        [--with-rtai-dir=<DIR>],

   429

        [RTAI path, for RTDM interface and RTAI examples]

   430

    ),

   431

    [

   432

        rtaidir=[$withval]

   433

        rtai=1

   434

    ],

   435

    [

   436

        rtaidir=""

   437

        rtai=0

   438

    ]

   439

)

   440

   441

AC_MSG_CHECKING([for RTAI path])

   442

   443

if test -z "${rtaidir}"; then

   444

    AC_MSG_RESULT([not specified.])

   445

else

   446

    if test \! -r ${rtaidir}/include/rtai.h; then

   447

        AC_MSG_ERROR([no RTAI installation found in ${rtaidir}!])

   448

    fi

   449

    AC_MSG_RESULT([$rtaidir])

   450

   451

    rtai_lxrt_cflags=`$rtaidir/bin/rtai-config --lxrt-cflags`

   452

    rtai_lxrt_ldflags=`$rtaidir/bin/rtai-config --lxrt-ldflags`

   453

fi

   454

   455

AC_SUBST(RTAI_DIR,[$rtaidir])

   456

AM_CONDITIONAL(ENABLE_RTAI, test "x$rtai" = "x1")

   457

AC_SUBST(ENABLE_RTAI,[$rtai])

   458

   459

AC_SUBST(RTAI_LXRT_CFLAGS,[$rtai_lxrt_cflags])

   460

AC_SUBST(RTAI_LXRT_LDFLAGS,[$rtai_lxrt_ldflags])

   461

   462

#------------------------------------------------------------------------------

   463

# Xenomai path (optional)

   464

#------------------------------------------------------------------------------

   465

   466

AC_ARG_WITH([xenomai-dir],

   467

    AC_HELP_STRING(

   468

        [--with-xenomai-dir=<DIR>],

   469

        [Xenomai path, for RTDM interface and Xenomai examples]

   470

    ),

   471

    [

   472

        xenomaidir=[$withval]

   473

        xeno=1

   474

    ],

   475

    [

   476

        xenomaidir=""

   477

        xeno=0

   478

    ]

   479

)

   480

   481

AC_MSG_CHECKING([for Xenomai path])

   482

   483

if test -z "${xenomaidir}"; then

   484

    AC_MSG_RESULT([not specified.])

   485

else

   486

    if test \! -r ${xenomaidir}/include/xeno_config.h; then

   487

        AC_MSG_ERROR([no Xenomai installation found in ${xenomaidir}!])

   488

    fi

   489

    AC_MSG_RESULT([$xenomaidir])

   490

   491

    xeno_native_cflags=`$xenomaidir/bin/xeno-config --skin native --cflags`