1

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

     2

# $Id$

     3

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

     4

     5

AC_PREREQ(2.59)

     6

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

     7

AC_CONFIG_AUX_DIR([autoconf])

     8

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

     9

AC_PREFIX_DEFAULT([/opt/etherlab])

    10

AC_CONFIG_HEADERS([config.h])

    11

AC_CONFIG_SRCDIR([config.h.in])

    12

    13

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

    14

# Global

    15

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

    16

    17

branch=trunk

    18

    19

AC_DEFINE_UNQUOTED(BRANCH, ["$branch"], [Subversion branch])

    20

AC_SUBST(BRANCH, [$branch])

    21

    22

AC_PROG_CXX

    23

    24

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

    25

# Linux sources

    26

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

    27

    28

AC_ARG_WITH([linux-dir],

    29

    AC_HELP_STRING(

    30

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

    31

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

    32

    ),

    33

    [

    34

        sourcedir=[$withval]

    35

    ],

    36

    [

    37

        version=[`uname -r`]

    38

        modulesdir=/lib/modules/${version}

    39

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

    40

           echo

    41

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

    42

        fi

    43

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

    44

    ]

    45

)

    46

    47

AC_MSG_CHECKING([for Linux kernel sources])

    48

    49

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

    50

    echo

    51

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

    52

fi

    53

    54

# Try to get kernel release string

    55

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

    56

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

    57

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

    58

    kernelrelease=`cat $sourcedir/.kernelrelease`

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

fi

    66

    67

if test -z "$kernelrelease"; then

    68

    echo

    69

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

    70

fi

    71

    72

# Extract three numbers from kernel release string

    73

linuxversion=`echo $kernelrelease | grep -oE "^[[0-9]]+\.[[0-9]]+\.[[0-9]]+"`

    74

    75

AC_SUBST(LINUX_SOURCE_DIR,[$sourcedir])

    76

AC_SUBST(LINUX_KERNEL_RELEASE,[$kernelrelease])

    77

AC_SUBST(LINUX_KERNEL_VERSION,[$linuxversion])

    78

AC_SUBST(LINUX_MOD_PATH,[/lib/modules/$kernelrelease/ethercat])

    79

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

    80

    81

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

    82

# 8139too driver

    83

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

    84

    85

AC_ARG_ENABLE([8139too],

    86

    AS_HELP_STRING([--enable-8139too],

    87

                   [Enable 8139too driver]),

    88

    [

    89

        case "${enableval}" in

    90

            yes) enable8139too=1

    91

                ;;

    92

            no) enable8139too=0

    93

                ;;

    94

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

    95

                ;;

    96

        esac

    97

    ],

    98

    [enable8139too=1]

    99

)

   100

   101

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

   102

AC_SUBST(ENABLE_8139TOO,[$enable8139too])

   103

   104

AC_ARG_WITH([8139too-kernel],

   105

    AC_HELP_STRING(

   106

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

   107

        [8139too kernel (only if differing)]

   108

    ),

   109

    [

   110

        kernel8139too=[$withval]

   111

    ],

   112

    [

   113

        kernel8139too=$linuxversion

   114

    ]

   115

)

   116

   117

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

   118

    AC_MSG_CHECKING([for kernel for 8139too driver])

   119

   120

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

   121

    found=0

   122

    for k in $kernels; do

   123

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

   124

            found=1

   125

        fi

   126

    done

   127

    if test $found -ne 1; then

   128

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

   129

    fi

   130

   131

    AC_MSG_RESULT([$kernel8139too])

   132

fi

   133

   134

AC_SUBST(KERNEL_8139TOO,[$kernel8139too])

   135

   136

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

   137

# e100 driver

   138

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

   139

   140

AC_ARG_ENABLE([e100],

   141

    AS_HELP_STRING([--enable-e100],

   142

                   [Enable e100 driver]),

   143

    [

   144

        case "${enableval}" in

   145

            yes) enablee100=1

   146

                ;;

   147

            no) enablee100=0

   148

                ;;

   149

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

   150

                ;;

   151

        esac

   152

    ],

   153

    [enablee100=0] # disabled by default

   154

)

   155

   156

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

   157

AC_SUBST(ENABLE_E100,[$enablee100])

   158

   159

AC_ARG_WITH([e100-kernel],

   160

    AC_HELP_STRING(

   161

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

   162

        [e100 kernel (only if differing)]

   163

    ),

   164

    [

   165

        kernele100=[$withval]

   166

    ],

   167

    [

   168

        kernele100=$linuxversion

   169

    ]

   170

)

   171

   172

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

   173

    AC_MSG_CHECKING([for kernel for e100 driver])

   174

   175

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

   176

    found=0

   177

    for k in $kernels; do

   178

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

   179

            found=1

   180

        fi

   181

    done

   182

    if test $found -ne 1; then

   183

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

   184

    fi

   185

   186

    AC_MSG_RESULT([$kernele100])

   187

fi

   188

   189

AC_SUBST(KERNEL_E100,[$kernele100])

   190

   191

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

   192

# forcedeth driver

   193

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

   194

   195

AC_ARG_ENABLE([forcedeth],

   196

    AS_HELP_STRING([--enable-forcedeth],

   197

                   [Enable forcedeth driver]),

   198

    [

   199

        case "${enableval}" in

   200

            yes) enableforcedeth=1

   201

                ;;

   202

            no) enableforcedeth=0

   203

                ;;

   204

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

   205

                ;;

   206

        esac

   207

    ],

   208

    [enableforcedeth=0] # disabled by default!

   209

)

   210

   211

AM_CONDITIONAL(ENABLE_FORCEDETH, test "x$enableforcedeth" = "x1")

   212

AC_SUBST(ENABLE_FORCEDETH,[$enableforcedeth])

   213

   214

AC_ARG_WITH([forcedeth-kernel],

   215

    AC_HELP_STRING(

   216

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

   217

        [forcedeth kernel (only if differing)]

   218

    ),

   219

    [

   220

        kernelforcedeth=[$withval]

   221

    ],

   222

    [

   223

        kernelforcedeth=$linuxversion

   224

    ]

   225

)

   226

   227

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

   228

    AC_MSG_CHECKING([for kernel for forcedeth driver])

   229

   230

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

   231

    found=0

   232

    for k in $kernels; do

   233

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

   234

            found=1

   235

        fi

   236

    done

   237

    if test $found -ne 1; then

   238

        AC_MSG_ERROR([kernel $kernelforcedeth not available for forcedeth driver!])

   239

    fi

   240

   241

    AC_MSG_RESULT([$kernelforcedeth])

   242

fi

   243

   244

AC_SUBST(KERNEL_FORCEDETH,[$kernelforcedeth])

   245

   246

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

   247

# e1000 driver

   248

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

   249

   250

AC_ARG_ENABLE([e1000],

   251

    AS_HELP_STRING([--enable-e1000],

   252

                   [Enable e1000 driver]),

   253

    [

   254

        case "${enableval}" in

   255

            yes) enablee1000=1

   256

                ;;

   257

            no) enablee1000=0

   258

                ;;

   259

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

   260

                ;;

   261

        esac

   262

    ],

   263

    [enablee1000=0] # disabled by default

   264

)

   265

   266

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

   267

AC_SUBST(ENABLE_E1000,[$enablee1000])

   268

   269

AC_ARG_WITH([e1000-kernel],

   270

    AC_HELP_STRING(

   271

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

   272

        [e1000 kernel (only if differing)]

   273

    ),

   274

    [

   275

        kernele1000=[$withval]

   276

    ],

   277

    [

   278

        kernele1000=$linuxversion

   279

    ]

   280

)

   281

   282

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

   283

    AC_MSG_CHECKING([for kernel for e1000 driver])

   284

   285

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

   286

    found=0

   287

    for k in $kernels; do

   288

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

   289

            found=1

   290

        fi

   291

    done

   292

    if test $found -ne 1; then

   293

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

   294

    fi

   295

   296

    AC_MSG_RESULT([$kernele1000])

   297

fi

   298

   299

AC_SUBST(KERNEL_E1000,[$kernele1000])

   300

   301

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

   302

# r8169 driver

   303

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

   304

   305

AC_ARG_ENABLE([r8169],

   306

    AS_HELP_STRING([--enable-r8169],

   307

                   [Enable r8169 driver]),

   308

    [

   309

        case "${enableval}" in

   310

            yes) enabler8169=1

   311

                ;;

   312

            no) enabler8169=0

   313

                ;;

   314

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

   315

                ;;

   316

        esac

   317

    ],

   318

    [enabler8169=0] # disabled by default

   319

)

   320

   321

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

   322

AC_SUBST(ENABLE_R8169,[$enabler8169])

   323

   324

AC_ARG_WITH([r8169-kernel],

   325

    AC_HELP_STRING(

   326

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

   327

        [r8169 kernel (only if differing)]

   328

    ),

   329

    [

   330

        kernelr8169=[$withval]

   331

    ],

   332

    [

   333

        kernelr8169=$linuxversion

   334

    ]

   335

)

   336

   337

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

   338

    AC_MSG_CHECKING([for kernel for r8169 driver])

   339

   340

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

   341

    found=0

   342

    for k in $kernels; do

   343

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

   344

            found=1

   345

        fi

   346

    done

   347

    if test $found -ne 1; then

   348

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

   349

    fi

   350

   351

    AC_MSG_RESULT([$kernelr8169])

   352

fi

   353

   354

AC_SUBST(KERNEL_R8169,[$kernelr8169])

   355

   356

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

   357

# RTAI path (optional)

   358

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

   359

   360

AC_ARG_WITH([rtai-dir],

   361

    AC_HELP_STRING(

   362

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

   363

        [RTAI path (only for RTAI examples)]

   364

    ),

   365

    [

   366

        rtaidir=[$withval]

   367

    ],

   368

    [

   369

        rtaidir=""

   370

    ]

   371

)

   372

   373

AC_MSG_CHECKING([for RTAI path])

   374

   375

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

   376

    AC_MSG_RESULT([not specified.])

   377

else

   378

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

   379

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

   380

    fi

   381

    AC_MSG_RESULT([$rtaidir])

   382

fi

   383

   384

AC_SUBST(RTAI_DIR,[$rtaidir])

   385

   386

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

   387

# Debug interface

   388

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

   389

   390

AC_ARG_ENABLE([debug-if],

   391

    AS_HELP_STRING([--enable-debug-if],

   392

                   [Create a debug interface for each master @<:@NO@:>@]),

   393

    [

   394

        case "${enableval}" in

   395

            yes) dbg=1

   396

                ;;

   397

            no) dbg=0

   398

                ;;

   399

            *) AC_MSG_ERROR([Invalid value for --enable-debug-if])

   400

                ;;

   401

        esac

   402

    ],

   403

    [dbg=0]

   404

)

   405

   406

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

   407

    AC_DEFINE([EC_DEBUG_IF], [1], [Debug interfaces enabled])

   408

fi

   409

AM_CONDITIONAL(ENABLE_DEBUG_IF, test "x$dbg" = "x1")

   410

AC_SUBST(ENABLE_DEBUG_IF,[$dbg])

   411

   412

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

   413

# Debug ring

   414

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

   415

   416

AC_ARG_ENABLE([debug-ring],

   417

    AS_HELP_STRING([--enable-debug-ring],

   418

                   [Create a debug ring to record frames @<:@NO@:>@]),

   419

    [

   420

        case "${enableval}" in

   421

            yes) debugring=1

   422

                ;;

   423

            no) debugring=0

   424

                ;;

   425

            *) AC_MSG_ERROR([Invalid value for --enable-debug-ring])

   426

                ;;

   427

        esac

   428

    ],

   429

    [debugring=0]

   430

)

   431

   432

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

   433

    AC_DEFINE([EC_DEBUG_RING], [1], [Debug ring enabled])

   434

fi

   435

   436

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

   437

# Ethernet-over-EtherCAT support

   438

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

   439

   440

AC_ARG_ENABLE([eoe],

   441

    AS_HELP_STRING([--enable-eoe],

   442

                   [Enable EoE support (default: yes)]),

   443

    [

   444

        case "${enableval}" in

   445

            yes) eoe=1

   446

                ;;

   447

            no) eoe=0

   448

                ;;

   449

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

   450

                ;;

   451

        esac

   452

    ],

   453

    [eoe=1]

   454

)

   455

   456

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

   457

    AC_DEFINE([EC_EOE], [1], [EoE support enabled])

   458

fi

   459

AM_CONDITIONAL(ENABLE_EOE, test "x$eoe" = "x1")

   460

AC_SUBST(ENABLE_EOE,[$eoe])

   461

   462

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

   463

# CPU timestamp counter support

   464

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

   465

   466

AC_ARG_ENABLE([cycles],

   467

    AS_HELP_STRING([--enable-cycles],

   468

                   [Use CPU timestamp counter (default: no)]),

   469

    [

   470

        case "${enableval}" in

   471

            yes) cycles=1

   472

                ;;

   473

            no) cycles=0

   474

                ;;

   475

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

   476

                ;;

   477

        esac

   478

    ],

   479

    [cycles=0]

   480

)

   481

   482

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

   483

    AC_DEFINE([EC_HAVE_CYCLES], [1], [Use CPU timestamp counter])

   484

fi

   485

   486

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

   487

   488

AC_CONFIG_FILES([

   489

        Doxyfile

   490

        Kbuild

   491

        Makefile