Return to probeAndInit.m CVS log

Up to [Apple Darwin 0.x] / driverkit / Examples / probeAndInit

Annotation of driverkit/Examples/probeAndInit/probeAndInit.m, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
        !             7:  * Reserved.  This file contains Original Code and/or Modifications of
        !             8:  * Original Code as defined in and that are subject to the Apple Public
        !             9:  * Source License Version 1.1 (the "License").  You may not use this file
        !            10:  * except in compliance with the License.  Please obtain a copy of the
        !            11:  * License at http://www.apple.com/publicsource and read it before using
        !            12:  * this file.
        !            13:  * 
        !            14:  * The Original Code and all software distributed under the License are
        !            15:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            16:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            17:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            18:  * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
        !            19:  * License for the specific language governing rights and limitations
        !            20:  * under the License.
        !            21:  * 
        !            22:  * @APPLE_LICENSE_HEADER_END@
        !            23:  */
        !            24: /*
        !            25:  * probeAndInit.m.
        !            26:  * +probe: and init example, nrw kernel driver.
        !            27:  */
        !            28: 
        !            29: #import "probeAndInit.h"
        !            30: 
        !            31: /*
        !            32:  * Probe and initialization of direct device, kernel mode.
        !            33:  */
        !            34: 
        !            35: static int myDeviceNum = 0;
        !            36: 
        !            37: @implementation MyDevice
        !            38: 
        !            39: /*
        !            40:  * Probe:deviceMaster: is called out during early system autoconfig when
        !            41:  * the autoconfig module finds a hardware device with a valid mapping
        !            42:  * in the internalDevMap[] table.
        !            43:  */
        !            44: + (BOOL)probe:deviceDescription
        !            45: {
        !            46:        MyDevice *myDev;
        !            47:        char devName[20];
        !            48:        
        !            49:        /*
        !            50:         * Instantiate and set common IODevice instance variables.
        !            51:         */
        !            52:        myDev = [self alloc];
        !            53:        [myDev setDeviceDescription:deviceDescription];
        !            54:        [myDev setUnit:myDeviceNum];
        !            55:        sprintf(devName, "myDevice%d", myDeviceNum++);
        !            56:        [myDev setName:devName];
        !            57:        [myDev setDeviceKind:"Example Driver"];
        !            58:        
        !            59:        /*
        !            60:         * Proceed with device-specific initialization.
        !            61:         */
        !            62:        if([myDev myDeviceInit]) {
        !            63:                return YES;
        !            64:        }
        !            65:        else {
        !            66:                return NO;
        !            67:        }
        !            68: }
        !            69: 
        !            70: /*
        !            71:  * Device-specific initialization. Returns nil on error. Assumes valid 
        !            72:  * deviceDescription on entry.
        !            73:  */
        !            74: - myDeviceInit
        !            75: {
        !            76:        IOReturn rtn;
        !            77:        unsigned intr;
        !            78:        char location[15];
        !            79:        
        !            80:        /*
        !            81:         * ...Initialize instance variables here...
        !            82:         */
        !            83:         
        !            84:        /*
        !            85:         * Perform one-time only hardware initialization. First set up 
        !            86:         * register pointer.
        !            87:         */
        !            88:        rtn = [self mapDevicePage:(vm_offset_t *)&devicePage
        !            89:                anywhere:YES
        !            90:                cache:IO_CacheOff];
        !            91:        if(rtn) {
        !            92:                IOLog("MyDevice: Error on mapDevicePage (%s)\n", 
        !            93:                        [self stringFromReturn:rtn]);
        !            94:                return nil;
        !            95:        }
        !            96:        
        !            97:        sprintf(location, "0x%x", (unsigned)devicePage);
        !            98:        [self setLocation:location];
        !            99:        
        !           100:        /*
        !           101:         * Clear and disable interrupts.
        !           102:         */
        !           103:        intr = chan_intr_cause(devicePage, MY_DEVICE_CHANNEL);
        !           104:        set_chan_intr_cause(devicePage, MY_DEVICE_CHANNEL, intr);
        !           105:        set_chan_intr_mask(devicePage, MY_DEVICE_CHANNEL, 0);
        !           106:        set_dev_intr_mask(devicePage, 0);
        !           107:        
        !           108:        /*
        !           109:         * Prepare for interrupt notification.
        !           110:         */
        !           111:        rtn = [self attachInterrupt];
        !           112:        if(rtn) {
        !           113:                IOLog("%s attachInterrupt returned %s\n", 
        !           114:                        [self stringFromReturn:rtn]);
        !           115:                return nil;
        !           116:        }
        !           117:                
        !           118:        /*
        !           119:         * Get a DMA channel.
        !           120:         */
        !           121:        rtn = [self attachChannel:MY_DEVICE_CHANNEL
        !           122:                streamMode:NO
        !           123:                bufferSize:MY_DEVICE_BUFSIZE];
        !           124:        if(rtn) {
        !           125:                IOLog("MyDevice: Error on attachChannel (%s)\n", 
        !           126:                        [self stringFromReturn:rtn]);
        !           127:                return nil;
        !           128:        }
        !           129: 
        !           130:        /*
        !           131:         * ...configure device-specific hardware...
        !           132:         */
        !           133:         
        !           134:        /*
        !           135:         * Enable interrupts at the channel, device, and kernel level.
        !           136:         */
        !           137:        set_chan_intr_mask(devicePage, MY_DEVICE_CHANNEL,
        !           138:                MY_DEVICE_CHAN_INTR_MASK);
        !           139:        set_dev_intr_mask(devicePage, MY_DEVICE_DEV_INTR_MASK);
        !           140:        [self enableInterruptsForChannel:MY_DEVICE_CHANNEL];
        !           141: 
        !           142:        /*
        !           143:         * Register with IODevice-level code.
        !           144:         */
        !           145:        [super init];
        !           146:        [self registerDevice];
        !           147:        return self;
        !           148: }
        !           149: 
        !           150: @end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.