1

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

     2

# $Id$

     3

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

     4

     5

AC_PREREQ(2.59)

     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=stable

    18

    19

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

    20

AC_SUBST(BRANCH, [$branch])

    21

    22

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

    23

# Linux sources

    24

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

    25

    26

AC_ARG_WITH([linux-dir],

    27

    AC_HELP_STRING(

    28

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

    29

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

    30

    ),

    31

    [

    32

        sourcedir=[$withval]

    33

    ],

    34

    [

    35

        version=[`uname -r`]

    36

        modulesdir=/lib/modules/${version}

    37

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

    38

           echo

    39

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

    40

        fi

    41

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

    42

    ]

    43

)

    44

    45

AC_MSG_CHECKING([for Linux kernel sources])

    46

    47

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

    48

    echo

    49

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

    50

fi

    51

    52

# Try to get kernel release string

    53

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

    54

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

    55

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

    56

    kernelrelease=`cat $sourcedir/.kernelrelease`

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

fi

    64

    65

if test -z "$kernelrelease"; then

    66

    echo

    67

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

    68

fi

    69

    70

# Extract three numbers from kernel release string

    71

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

    72

    73

AC_SUBST(LINUX_SOURCE_DIR,[$sourcedir])

    74

AC_SUBST(LINUX_KERNEL_RELEASE,[$kernelrelease])

    75

AC_SUBST(LINUX_KERNEL_VERSION,[$linuxversion])

    76

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

    77

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

    78

    79

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

    80

# 8139too driver

    81

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

    82

    83

AC_ARG_ENABLE([8139too],

    84

    AS_HELP_STRING([--enable-8139too],

    85

                   [Enable 8139too driver]),

    86

    [

    87

        case "${enableval}" in

    88

            yes) enable8139too=1

    89

                ;;

    90

            no) enable8139too=0

    91

                ;;

    92

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

    93

                ;;

    94

        esac

    95

    ],

    96

    [enable8139too=1]

    97

)

    98

    99

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

   100

   101

AC_ARG_WITH([8139too-kernel],

   102

    AC_HELP_STRING(

   103

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

   104

        [8139too kernel (only if differing)]

   105

    ),

   106

    [

   107

        kernel8139too=[$withval]

   108

    ],

   109

    [

   110

        kernel8139too=$linuxversion

   111

    ]

   112

)

   113

   114

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

   115

    AC_MSG_CHECKING([for kernel for 8139too driver])

   116

   117

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

   118

    found=0

   119

    for k in $kernels; do

   120

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

   121

            found=1

   122

        fi

   123

    done

   124

    if test $found -ne 1; then

   125

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

   126

    fi

   127

   128

    AC_MSG_RESULT([$kernel8139too])

   129

fi

   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

   153

AC_ARG_WITH([e100-kernel],

   154

    AC_HELP_STRING(

   155

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

   156

        [e100 kernel (only if differing)]

   157

    ),

   158

    [

   159

        kernele100=[$withval]

   160

    ],

   161

    [

   162

        kernele100=$linuxversion

   163

    ]

   164

)

   165

   166

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

   167

    AC_MSG_CHECKING([for kernel for e100 driver])

   168

   169

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

   170

    found=0

   171

    for k in $kernels; do

   172

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

   173

            found=1

   174

        fi

   175

    done

   176

    if test $found -ne 1; then

   177

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

   178

    fi

   179

   180

    AC_MSG_RESULT([$kernele100])

   181

fi

   182

   183

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

   184

# forcedeth driver

   185

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

   186

   187

AC_ARG_ENABLE([forcedeth],

   188

    AS_HELP_STRING([--enable-forcedeth],

   189

                   [Enable forcedeth driver]),

   190

    [

   191

        case "${enableval}" in

   192

            yes) enableforcedeth=1

   193

                ;;

   194

            no) enableforcedeth=0

   195

                ;;

   196

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

   197

                ;;

   198

        esac

   199

    ],

   200

    [enableforcedeth=0] # disabled by default!

   201

)

   202

   203

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

   204

   205

AC_ARG_WITH([forcedeth-kernel],

   206

    AC_HELP_STRING(

   207

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

   208

        [forcedeth kernel (only if differing)]

   209

    ),

   210

    [

   211

        kernelforcedeth=[$withval]

   212

    ],

   213

    [

   214

        kernelforcedeth=$linuxversion

   215

    ]

   216

)

   217

   218

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

   219

    AC_MSG_CHECKING([for kernel for forcedeth driver])

   220

   221

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

   222

    found=0

   223

    for k in $kernels; do

   224

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

   225

            found=1

   226

        fi

   227

    done

   228

    if test $found -ne 1; then

   229

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

   230

    fi

   231

   232

    AC_MSG_RESULT([$kernelforcedeth])

   233

fi

   234

   235

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

   236

# e1000 driver

   237

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

   238

   239

AC_ARG_ENABLE([e1000],

   240

    AS_HELP_STRING([--enable-e1000],

   241

                   [Enable e1000 driver]),

   242

    [

   243

        case "${enableval}" in

   244

            yes) enablee1000=1

   245

                ;;

   246

            no) enablee1000=0

   247

                ;;

   248

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

   249

                ;;

   250

        esac

   251

    ],

   252

    [enablee1000=0] # disabled by default

   253

)

   254

   255

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

   256

   257

AC_ARG_WITH([e1000-kernel],

   258

    AC_HELP_STRING(

   259

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

   260

        [e1000 kernel (only if differing)]

   261

    ),

   262

    [

   263

        kernele1000=[$withval]

   264

    ],

   265

    [

   266

        kernele1000=$linuxversion

   267

    ]

   268

)

   269

   270

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

   271

    AC_MSG_CHECKING([for kernel for e1000 driver])

   272

   273

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

   274

    found=0

   275

    for k in $kernels; do

   276

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

   277

            found=1

   278

        fi

   279

    done

   280

    if test $found -ne 1; then

   281

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

   282

    fi

   283

   284

    AC_MSG_RESULT([$kernele1000])

   285

fi

   286

   287

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

   288

# RTAI path (optional)

   289

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

   290

   291

AC_ARG_WITH([rtai-dir],

   292

    AC_HELP_STRING(

   293

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

   294

        [RTAI path (only for RTAI examples)]

   295

    ),

   296

    [

   297

        rtaidir=[$withval]

   298

    ],

   299

    [

   300

        rtaidir=""

   301

    ]

   302

)

   303

   304

AC_MSG_CHECKING([for RTAI path])

   305

   306

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

   307

    AC_MSG_RESULT([not specified.])

   308

else

   309

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

   310

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

   311

    fi

   312

    AC_MSG_RESULT([$rtaidir])

   313

    AC_SUBST(RTAI_DIR,[$rtaidir])

   314

fi

   315

   316

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

   317

# MSR path (optional)

   318

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

   319

   320

AC_ARG_WITH([msr-dir],

   321

    AC_HELP_STRING(

   322

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

   323

        [MSR path (only for MSR example)]

   324

    ),

   325

    [

   326

        msrdir=[$withval]

   327

    ],

   328

    [

   329

        msrdir=""

   330

    ]

   331

)

   332

   333

AC_MSG_CHECKING([for MSR path])

   334

   335

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

   336

    AC_MSG_RESULT([not specified.])

   337

else

   338

    if test \! -r ${msrdir}/include/msr.h; then

   339

        AC_MSG_ERROR([no MSR installation found in ${msrdir}!])

   340

    fi

   341

    AC_MSG_RESULT([$msrdir])

   342

    AC_SUBST(MSR_DIR,[$msrdir])

   343

fi

   344

   345

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

   346

# Debug interface

   347

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

   348

   349

AC_ARG_ENABLE([debug-if],

   350

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

   351

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

   352

    [

   353

        case "${enableval}" in

   354

            yes) dbg=1

   355

                ;;

   356

            no) dbg=0

   357

                ;;

   358

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

   359

                ;;

   360

        esac

   361

    ],

   362

    [dbg=0]

   363

)

   364

   365

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

   366

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

   367

fi

   368

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

   369

   370

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

   371

# Debug ring

   372

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

   373

   374

AC_ARG_ENABLE([debug-ring],

   375

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

   376

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

   377

    [

   378

        case "${enableval}" in

   379

            yes) debugring=1

   380

                ;;

   381

            no) debugring=0

   382

                ;;

   383

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

   384

                ;;

   385

        esac

   386

    ],

   387

    [debugring=0]

   388

)

   389

   390

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

   391

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

   392

fi

   393

   394

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

   395

# Dummy master module

   396

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

   397

   398

AC_ARG_ENABLE([dummy],

   399

    AS_HELP_STRING([--enable-dummy],

   400

                   [Build the dummy master module @<:@NO@:>@]),

   401

    [

   402

        case "${enableval}" in

   403

            yes) dummy=1

   404

                ;;

   405

            no) dummy=0

   406

                ;;

   407

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

   408

                ;;

   409

        esac

   410

    ],

   411

    [dummy=0]

   412

)

   413

   414

AM_CONDITIONAL(ENABLE_DUMMY, test "x$dummy" = "x1")

   415

   416

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

   442

   443

# Create config.kbuild

   444

   445

echo configure: creating config.kbuild...

   446

   447

cat > config.kbuild <<EOF

   448

# config.kbuild - created by configure

   449

ENABLE_8139TOO := ${enable8139too}

   450

KERNEL_8139TOO := ${kernel8139too}

   451

ENABLE_E100 := ${enablee100}

   452

KERNEL_E100 := ${kernele100}

   453

ENABLE_FORCEDETH := ${enableforcedeth}

   454

KERNEL_FORCEDETH := ${kernelforcedeth}

   455

ENABLE_E1000 := ${enablee1000}

   456

KERNEL_E1000 := ${kernele1000}

   457

RTAI_DIR := "${rtaidir}"

   458

MSR_DIR := "${msrdir}"

   459

ENABLE_DEBUG_IF := ${dbg}

   460

ENABLE_DUMMY := ${dummy}

   462

EOF

   463

   464

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

   465

   466

AC_CONFIG_FILES([

   467

        Makefile

   468

        master/Makefile

   469

        devices/Makefile

   470

        devices/e1000/Makefile

   471

        script/Makefile

   472

        script/init.d/Makefile

   473

        script/sysconfig/Makefile

   474

        include/Makefile

   475

        examples/Makefile

   476

        examples/mini/Makefile

   477

        examples/rtai/Makefile

   478

        examples/msr/Makefile

   479

        dummy/Makefile

   480

])

   481

AC_OUTPUT

   482

   483

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