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

AM_PROG_CC_C_O

    44

m4_ifdef([AM_PROG_AR], [AM_PROG_AR])

    45

AC_PROG_CXX

    46

AC_PROG_LIBTOOL

    47

    48

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

    49

# Linux sources

    50

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

    51

    52

AC_ARG_WITH([linux-dir],

    53

    AC_HELP_STRING(

    54

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

    55

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

    56

    ),

    57

    [

    58

        sourcedir=[$withval]

    59

    ],

    60

    [

    61

        version=[`uname -r`]

    62

        modulesdir=/lib/modules/${version}

    63

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

    64

           echo

    65

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

    66

        fi

    67

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

    68

    ]

    69

)

    70

    71

AC_MSG_CHECKING([for Linux kernel sources])

    72

    73

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

    74

    echo

    75

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

    76

fi

    77

    78

# Try to get kernel release string

    79

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

    80

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

    81

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

    82

    kernelrelease=`cat $sourcedir/.kernelrelease`

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

fi

    90

    91

if test -z "$kernelrelease"; then

    92

    echo

    93

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

    94

fi

    95

    96

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

    97

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

    98

else

    99

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

   100

fi

   101

   102

# Extract numbers from kernel release

   103

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

   104

   105

AC_SUBST(LINUX_SOURCE_DIR,[$sourcedir])

   106

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

   107

   108

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

   109

# Linux module installation subdirectory

   110

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

   111

   112

AC_ARG_WITH([module-dir],

   113

    AC_HELP_STRING(

   114

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

   115

        [Linux module installation dir. Default: ethercat]

   116

    ),

   117

    [moddir=[$withval]],

   118

    [moddir="ethercat"]

   119

)

   120

AC_SUBST(INSTALL_MOD_DIR,[$moddir])

   121

   122

AC_MSG_CHECKING([for Linux modules installation directory])

   123

AC_MSG_RESULT([$INSTALL_MOD_DIR])

   124

   125

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

   126

# Generic Ethernet driver

   127

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

   128

   129

AC_ARG_ENABLE([generic],

   130

    AS_HELP_STRING([--enable-generic],

   131

                   [Enable generic Ethernet driver]),

   132

    [

   133

        case "${enableval}" in

   134

            yes) enablegeneric=1

   135

                ;;

   136

            no) enablegeneric=0

   137

                ;;

   138

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

   139

                ;;

   140

        esac

   141

    ],

   142

    [enablegeneric=1]

   143

)

   144

   145

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

   146

AC_SUBST(ENABLE_GENERIC,[$enablegeneric])

   147

   148

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

   149

# 8139too driver

   150

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

   151

   152

AC_ARG_ENABLE([8139too],

   153

    AS_HELP_STRING([--enable-8139too],

   154

                   [Enable 8139too driver]),

   155

    [

   156

        case "${enableval}" in

   157

            yes) enable8139too=1

   158

                ;;

   159

            no) enable8139too=0

   160

                ;;

   161

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

   162

                ;;

   163

        esac

   164

    ],

   165

    [enable8139too=1]

   166

)

   167

   168

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

   169

AC_SUBST(ENABLE_8139TOO,[$enable8139too])

   170

   171

AC_ARG_WITH([8139too-kernel],

   172

    AC_HELP_STRING(

   173

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

   174

        [8139too kernel (only if differing)]

   175

    ),

   176

    [

   177

        kernel8139too=[$withval]

   178

    ],

   179

    [

   180

        kernel8139too=$linuxversion

   181

    ]

   182

)

   183

   184

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

   185

    AC_MSG_CHECKING([for kernel for 8139too driver])

   186

   187

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

   188

    found=0

   189

    for k in $kernels; do

   190

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

   191

            found=1

   192

        fi

   193

    done

   194

    if test $found -ne 1; then

   195

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

   196

    fi

   197

   198

    AC_MSG_RESULT([$kernel8139too])

   199

fi

   200

   201

AC_SUBST(KERNEL_8139TOO,[$kernel8139too])

   202

   203

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

   204

# e100 driver

   205

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

   206

   207

AC_ARG_ENABLE([e100],

   208

    AS_HELP_STRING([--enable-e100],

   209

                   [Enable e100 driver]),

   210

    [

   211

        case "${enableval}" in

   212

            yes) enablee100=1

   213

                ;;

   214

            no) enablee100=0

   215

                ;;

   216

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

   217

                ;;

   218

        esac

   219

    ],

   220

    [enablee100=0] # disabled by default

   221

)

   222

   223

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

   224

AC_SUBST(ENABLE_E100,[$enablee100])

   225

   226

AC_ARG_WITH([e100-kernel],

   227

    AC_HELP_STRING(

   228

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

   229

        [e100 kernel (only if differing)]

   230

    ),

   231

    [

   232

        kernele100=[$withval]

   233

    ],

   234

    [

   235

        kernele100=$linuxversion

   236

    ]

   237

)

   238

   239

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

   240

    AC_MSG_CHECKING([for kernel for e100 driver])

   241

   242

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

   243

    found=0

   244

    for k in $kernels; do

   245

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

   246

            found=1

   247

        fi

   248

    done

   249

    if test $found -ne 1; then

   250

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

   251

    fi

   252

   253

    AC_MSG_RESULT([$kernele100])

   254

fi

   255

   256

AC_SUBST(KERNEL_E100,[$kernele100])

   257

   258

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

   259

# e1000 driver

   260

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

   261

   262

AC_ARG_ENABLE([e1000],

   263

    AS_HELP_STRING([--enable-e1000],

   264

                   [Enable e1000 driver]),

   265

    [

   266

        case "${enableval}" in

   267

            yes) enablee1000=1

   268

                ;;

   269

            no) enablee1000=0

   270

                ;;

   271

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

   272

                ;;

   273

        esac

   274

    ],

   275

    [enablee1000=0] # disabled by default

   276

)

   277

   278

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

   279

AC_SUBST(ENABLE_E1000,[$enablee1000])

   280

   281

AC_ARG_WITH([e1000-kernel],

   282

    AC_HELP_STRING(

   283

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

   284

        [e1000 kernel (only if differing)]

   285

    ),

   286

    [

   287

        kernele1000=[$withval]

   288

    ],

   289

    [

   290

        kernele1000=$linuxversion

   291

    ]

   292

)

   293

   294

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

   295

    AC_MSG_CHECKING([for kernel for e1000 driver])

   296

   297

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

   298

    found=0

   299

    for k in $kernels; do

   300

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

   301

            found=1

   302

        fi

   303

    done

   304

    if test $found -ne 1; then

   305

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

   306

    fi

   307

   308

    AC_MSG_RESULT([$kernele1000])

   309

fi

   310

   311

AC_SUBST(KERNEL_E1000,[$kernele1000])

   312

   313

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

   314

# e1000e driver

   315

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

   316

   317

AC_ARG_ENABLE([e1000e],

   318

    AS_HELP_STRING([--enable-e1000e],

   319

                   [Enable e1000e driver]),

   320

    [

   321

        case "${enableval}" in

   322

            yes) enablee1000e=1

   323

                ;;

   324

            no) enablee1000e=0

   325

                ;;

   326

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

   327

                ;;

   328

        esac

   329

    ],

   330

    [enablee1000e=0] # disabled by default

   331

)

   332

   333

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

   334

AC_SUBST(ENABLE_E1000E,[$enablee1000e])

   335

   336

AC_ARG_WITH([e1000e-kernel],

   337

    AC_HELP_STRING(

   338

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

   339

        [e1000e kernel (only if differing)]

   340

    ),

   341

    [

   342

        kernele1000e=[$withval]

   343

    ],

   344

    [

   345

        kernele1000e=$linuxversion

   346

    ]

   347

)

   348

   351

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

   352

    AC_MSG_CHECKING([for kernel for e1000e driver])

   353

   354

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

   355

    found=0

   356

    for k in $kernels; do

   357

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

   358

            found=1

   359

        fi

   360

    done

   361

    if test $found -ne 1; then

   362

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

   363

    fi

   364

   365

    AC_MSG_RESULT([$kernele1000e])

   379

fi

   380

   381

AC_SUBST(KERNEL_E1000E,[$kernele1000e])

   383

   384

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

   385

# r8169 driver

   386

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

   387

   388

AC_ARG_ENABLE([r8169],

   389

    AS_HELP_STRING([--enable-r8169],

   390

                   [Enable r8169 driver]),

   391

    [

   392

        case "${enableval}" in

   393

            yes) enable_r8169=1

   394

                ;;

   395

            no) enable_r8169=0

   396

                ;;

   397

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

   398

                ;;

   399

        esac

   400

    ],

   401

    [enable_r8169=0] # disabled by default

   402

)

   403

   404

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

   405

AC_SUBST(ENABLE_R8169,[$enable_r8169])

   406

   407

AC_ARG_WITH([r8169-kernel],

   408

    AC_HELP_STRING(

   409

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

   410

        [r8169 kernel (only if differing)]

   411

    ),

   412

    [

   413

        kernel_r8169=[$withval]

   414

    ],

   415

    [

   416

        kernel_r8169=$linuxversion

   417

    ]

   418

)

   419

   420

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

   421

    AC_MSG_CHECKING([for kernel for r8169 driver])

   422

   423

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

   424

    found=0

   425

    for k in $kernels; do

   426

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

   427

            found=1

   428

        fi

   429

    done

   430

    if test $found -ne 1; then

   431

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

   432

    fi

   433

   434

    AC_MSG_RESULT([$kernel_r8169])

   435

fi

   436

   437

AC_SUBST(KERNEL_R8169,[$kernel_r8169])

   438

   439

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

   440

# RTAI path (optional)

   441

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

   442

   443

AC_ARG_WITH([rtai-dir],

   444

    AC_HELP_STRING(

   445

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

   446

        [RTAI path, for RTDM interface and RTAI examples]

   447

    ),

   448

    [

   449

        rtaidir=[$withval]

   450

        rtai=1

   451

    ],

   452

    [

   453

        rtaidir=""

   454

        rtai=0

   455

    ]

   456

)

   457

   458

AC_MSG_CHECKING([for RTAI path])

   459

   460

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

   461

    AC_MSG_RESULT([not specified.])

   462

else

   463

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

   464

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

   465

    fi

   466

    AC_MSG_RESULT([$rtaidir])

   467

   468

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

   469

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

   470

fi

   471

   472

AC_SUBST(RTAI_DIR,[$rtaidir])

   473

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

   474

AC_SUBST(ENABLE_RTAI,[$rtai])

   475

   476

AC_SUBST(RTAI_LXRT_CFLAGS,[$rtai_lxrt_cflags])

   477

AC_SUBST(RTAI_LXRT_LDFLAGS,[$rtai_lxrt_ldflags])

   478

   479

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

   480

# Xenomai path (optional)

   481

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

   482

   483

AC_ARG_WITH([xenomai-dir],

   484

    AC_HELP_STRING(

   485

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

   486

        [Xenomai path, for RTDM interface and Xenomai examples]

   487

    ),

   488

    [

   489

        xenomaidir=[$withval]

   490

        xeno=1

   491

    ],