1

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

     2

# $Id$

     3

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

     4

     5

AC_PREREQ(2.59)

     6

AC_INIT([ethercat],[devel],[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

AC_PROG_CXX

    18

    19

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

    20

# Linux sources

    21

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

    22

    23

AC_ARG_WITH([linux-dir],

    24

    AC_HELP_STRING(

    25

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

    26

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

    27

    ),

    28

    [

    29

        sourcedir=[$withval]

    30

    ],

    31

    [

    32

        version=[`uname -r`]

    33

        modulesdir=/lib/modules/${version}

    34

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

    35

           echo

    36

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

    37

        fi

    38

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

    39

    ]

    40

)

    41

    42

AC_MSG_CHECKING([for Linux kernel sources])

    43

    44

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

    45

    echo

    46

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

    47

fi

    48

    49

# Try to get kernel release string

    50

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

    51

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

    52

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

    53

    kernelrelease=`cat $sourcedir/.kernelrelease`

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

fi

    61

    62

if test -z "$kernelrelease"; then

    63

    echo

    64

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

    65

fi

    66

    67

# Extract three numbers from kernel release string

    68

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

    69

    70

AC_SUBST(LINUX_SOURCE_DIR,[$sourcedir])

    71

AC_SUBST(LINUX_KERNEL_RELEASE,[$kernelrelease])

    72

AC_SUBST(LINUX_KERNEL_VERSION,[$linuxversion])

    73

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

    74

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

    75

    76

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

    77

# 8139too driver

    78

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

    79

    80

AC_ARG_ENABLE([8139too],

    81

    AS_HELP_STRING([--enable-8139too],

    82

                   [Enable 8139too driver]),

    83

    [

    84

        case "${enableval}" in

    85

            yes) enable8139too=1

    86

                ;;

    87

            no) enable8139too=0

    88

                ;;

    89

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

    90

                ;;

    91

        esac

    92

    ],

    93

    [enable8139too=1]

    94

)

    95

    96

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

    97

AC_SUBST(ENABLE_8139TOO,[$enable8139too])

    98

    99

AC_ARG_WITH([8139too-kernel],

   100

    AC_HELP_STRING(

   101

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

   102

        [8139too kernel (only if differing)]

   103

    ),

   104

    [

   105

        kernel8139too=[$withval]

   106

    ],

   107

    [

   108

        kernel8139too=$linuxversion

   109

    ]

   110

)

   111

   112

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

   113

    AC_MSG_CHECKING([for kernel for 8139too driver])

   114

   115

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

   116

    found=0

   117

    for k in $kernels; do

   118

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

   119

            found=1

   120

        fi

   121

    done

   122

    if test $found -ne 1; then

   123

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

   124

    fi

   125

   126

    AC_MSG_RESULT([$kernel8139too])

   127

fi

   128

   129

AC_SUBST(KERNEL_8139TOO,[$kernel8139too])

   130

   131

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

   132

# e100 driver

   133

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

   134

   135

AC_ARG_ENABLE([e100],

   136

    AS_HELP_STRING([--enable-e100],

   137

                   [Enable e100 driver]),

   138

    [

   139

        case "${enableval}" in

   140

            yes) enablee100=1

   141

                ;;

   142

            no) enablee100=0

   143

                ;;

   144

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

   145

                ;;

   146

        esac

   147

    ],

   148

    [enablee100=0] # disabled by default

   149

)

   150

   151

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

   152

AC_SUBST(ENABLE_E100,[$enablee100])

   153

   154

AC_ARG_WITH([e100-kernel],

   155

    AC_HELP_STRING(

   156

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

   157

        [e100 kernel (only if differing)]

   158

    ),

   159

    [

   160

        kernele100=[$withval]

   161

    ],

   162

    [

   163

        kernele100=$linuxversion

   164

    ]

   165

)

   166

   167

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

   168

    AC_MSG_CHECKING([for kernel for e100 driver])

   169

   170

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

   171

    found=0

   172

    for k in $kernels; do

   173

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

   174

            found=1

   175

        fi

   176

    done

   177

    if test $found -ne 1; then

   178

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

   179

    fi

   180

   181

    AC_MSG_RESULT([$kernele100])

   182

fi

   183

   184

AC_SUBST(KERNEL_E100,[$kernele100])

   185

   186

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

   187

# forcedeth driver

   188

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

   189

   190

AC_ARG_ENABLE([forcedeth],

   191

    AS_HELP_STRING([--enable-forcedeth],

   192

                   [Enable forcedeth driver]),

   193

    [

   194

        case "${enableval}" in

   195

            yes) enableforcedeth=1

   196

                ;;

   197

            no) enableforcedeth=0

   198

                ;;

   199

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

   200

                ;;

   201

        esac

   202

    ],

   203

    [enableforcedeth=0] # disabled by default!

   204

)

   205

   206

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

   207

AC_SUBST(ENABLE_FORCEDETH,[$enableforcedeth])

   208

   209

AC_ARG_WITH([forcedeth-kernel],

   210

    AC_HELP_STRING(

   211

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

   212

        [forcedeth kernel (only if differing)]

   213

    ),

   214

    [

   215

        kernelforcedeth=[$withval]

   216

    ],

   217

    [

   218

        kernelforcedeth=$linuxversion

   219

    ]

   220

)

   221

   222

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

   223

    AC_MSG_CHECKING([for kernel for forcedeth driver])

   224

   225

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

   226

    found=0

   227

    for k in $kernels; do

   228

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

   229

            found=1

   230

        fi

   231

    done

   232

    if test $found -ne 1; then

   233

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

   234

    fi

   235

   236

    AC_MSG_RESULT([$kernelforcedeth])

   237

fi

   238

   239

AC_SUBST(KERNEL_FORCEDETH,[$kernelforcedeth])

   240

   241

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

   242

# e1000 driver

   243

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

   244

   245

AC_ARG_ENABLE([e1000],

   246

    AS_HELP_STRING([--enable-e1000],

   247

                   [Enable e1000 driver]),

   248

    [

   249

        case "${enableval}" in

   250

            yes) enablee1000=1

   251

                ;;

   252

            no) enablee1000=0

   253

                ;;

   254

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

   255

                ;;

   256

        esac

   257

    ],

   258

    [enablee1000=0] # disabled by default

   259

)

   260

   261

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

   262

AC_SUBST(ENABLE_E1000,[$enablee1000])

   263

   264

AC_ARG_WITH([e1000-kernel],

   265

    AC_HELP_STRING(

   266

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

   267

        [e1000 kernel (only if differing)]

   268

    ),

   269

    [

   270

        kernele1000=[$withval]

   271

    ],

   272

    [

   273

        kernele1000=$linuxversion

   274

    ]

   275

)

   276

   277

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

   278

    AC_MSG_CHECKING([for kernel for e1000 driver])

   279

   280

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

   281

    found=0

   282

    for k in $kernels; do

   283

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

   284

            found=1

   285

        fi

   286

    done

   287

    if test $found -ne 1; then

   288

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

   289

    fi

   290

   291

    AC_MSG_RESULT([$kernele1000])

   292

fi

   293

   294

AC_SUBST(KERNEL_E1000,[$kernele1000])

   295

   296

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

   297

# r8169 driver

   298

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

   299

   300

AC_ARG_ENABLE([r8169],

   301

    AS_HELP_STRING([--enable-r8169],

   302

                   [Enable r8169 driver]),

   303

    [

   304

        case "${enableval}" in

   305

            yes) enabler8169=1

   306

                ;;

   307

            no) enabler8169=0

   308

                ;;

   309

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

   310

                ;;

   311

        esac

   312

    ],

   313

    [enabler8169=0] # disabled by default

   314

)

   315

   316

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

   317

AC_SUBST(ENABLE_R8169,[$enabler8169])

   318

   319

AC_ARG_WITH([r8169-kernel],

   320

    AC_HELP_STRING(

   321

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

   322

        [r8169 kernel (only if differing)]

   323

    ),

   324

    [

   325

        kernelr8169=[$withval]

   326

    ],

   327

    [

   328

        kernelr8169=$linuxversion

   329

    ]

   330

)

   331

   332

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

   333

    AC_MSG_CHECKING([for kernel for r8169 driver])

   334

   335

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

   336

    found=0

   337

    for k in $kernels; do

   338

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

   339

            found=1

   340

        fi

   341

    done

   342

    if test $found -ne 1; then

   343

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

   344

    fi

   345

   346

    AC_MSG_RESULT([$kernelr8169])

   347

fi

   348

   349

AC_SUBST(KERNEL_R8169,[$kernelr8169])

   350

   351

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

   352

# RTAI path (optional)

   353

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

   354

   355

AC_ARG_WITH([rtai-dir],

   356

    AC_HELP_STRING(

   357

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

   358

        [RTAI path (only for RTAI examples)]

   359

    ),

   360

    [

   361

        rtaidir=[$withval]

   362

    ],

   363

    [

   364

        rtaidir=""

   365

    ]

   366

)

   367

   368

AC_MSG_CHECKING([for RTAI path])

   369

   370

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

   371

    AC_MSG_RESULT([not specified.])

   372

else

   373

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

   374

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

   375

    fi

   376

    AC_MSG_RESULT([$rtaidir])

   377

fi

   378

   379

AC_SUBST(RTAI_DIR,[$rtaidir])

   380

   381

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

   382

# Debug interface

   383

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

   384

   385

AC_ARG_ENABLE([debug-if],

   386

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

   387

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

   388

    [

   389

        case "${enableval}" in

   390

            yes) dbg=1

   391

                ;;

   392

            no) dbg=0

   393

                ;;

   394

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

   395

                ;;

   396

        esac

   397

    ],

   398

    [dbg=0]

   399

)

   400

   401

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

   402

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

   403

fi

   404

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

   405

AC_SUBST(ENABLE_DEBUG_IF,[$dbg])

   406

   407

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

   408

# Debug ring

   409

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

   410

   411

AC_ARG_ENABLE([debug-ring],

   412

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

   413

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

   414

    [

   415

        case "${enableval}" in

   416

            yes) debugring=1

   417

                ;;

   418

            no) debugring=0

   419

                ;;

   420

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

   421

                ;;

   422

        esac

   423

    ],

   424

    [debugring=0]

   425

)

   426

   427

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

   428

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

   429

fi

   430

   431

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

   432

# Ethernet-over-EtherCAT support

   433

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

   434

   435

AC_ARG_ENABLE([eoe],

   436

    AS_HELP_STRING([--enable-eoe],

   437

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

   438

    [

   439

        case "${enableval}" in

   440

            yes) eoe=1

   441

                ;;

   442

            no) eoe=0

   443

                ;;

   444

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

   445

                ;;

   446

        esac

   447

    ],

   448

    [eoe=1]

   449

)

   450

   451

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

   452

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

   453

fi

   454

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

   455

AC_SUBST(ENABLE_EOE,[$eoe])

   456

   457

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

   458

# CPU timestamp counter support

   459

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

   460

   461

AC_ARG_ENABLE([cycles],

   462

    AS_HELP_STRING([--enable-cycles],

   463

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

   464

    [

   465

        case "${enableval}" in

   466

            yes) cycles=1

   467

                ;;

   468

            no) cycles=0

   469

                ;;

   470

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

   471

                ;;

   472

        esac

   473

    ],

   474

    [cycles=0]

   475

)

   476

   477

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

   478

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

   479

fi

   480

   481

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

   482

   483

AC_CONFIG_FILES([

   484

        Doxyfile

   485

        Kbuild

   486

        Makefile

   487

        devices/Kbuild

   488

        devices/Makefile

   489

        devices/e1000/Kbuild

   490

        devices/e1000/Makefile

   491

        examples/Makefile