usr_blk_dev.c

包含MMC协议,驱动源码. 在LINUX操作系统下通过.

    {
        info_p->media_state = USR_BLK_DEV_MEDIA_STATE_INITIALIZED;
    }
    tracemsg("changed: %d\n", changed);
    usr_blk_dev_cmd_data_processed(info_p, USR_BLK_DEV_CMD_SRC_GEN);
    return changed;
}

/*!
 * @brief Handles revalidation of the device.
 *
 * The file system/kernel will call this function when a part change is detected
 * (this includes the initial part detection).   It will clear out the
 * partition information and re-initialize it by calling register_disk(). Once
 * register_disk() returns the partition information will be set up.  It should
 * be noted, that the devices partition table will be read through the request
 * queue before register disk returns.  Thus, calls to this function cannot
 * lock up any resources used by the request queue mechanism or the partition
 * table will not be read and the device will lock up.
 *
 * @param i_rdev Kernel device information
 *
 * @return Always returns 0.
 */
static int usr_blk_dev_revalidate(kdev_t i_rdev)
{
    USR_BLK_DEV_INFO_T *info_p;
    unsigned int dev_num;
    unsigned int i;

    tracemsg("\n");
    dev_num = USR_BLK_DEV_DEVICE_NR(i_rdev);
    info_p = &usr_blk_dev_info[dev_num];

    if (info_p->params.device_size != 0)
    {
        /* Send the revalidate command to user space. */
        usr_blk_dev_send_cmd_to_thread_and_wait(info_p, USR_BLK_DEV_CMD_ID_REVALIDATE,
                                                dev_num, USR_BLK_DEV_CMD_SRC_GEN);
        usr_blk_dev_cmd_data_processed(info_p, USR_BLK_DEV_CMD_SRC_GEN);
        if (info_p->media_state != USR_BLK_DEV_MEDIA_STATE_ERROR)
        {
            i = dev_num<<USR_BLK_DEV_SHIFT;
            /*
             * Reset the sizes and partition data based on the data which was received from
             * device during the initialization sequence.
             */
            while (i < (dev_num+1)<<USR_BLK_DEV_SHIFT)
            {
                memset(&usr_blk_dev_partitions[i], 0, sizeof(usr_blk_dev_partitions[0]));
                usr_blk_dev_sizes[i] = 0;
                usr_blk_dev_max_sectors[i] = USR_BLK_DEV_MAX_SECTORS_PER_REQ;
                usr_blk_dev_blksizes[i] = info_p->params.read_block_len;
                usr_blk_dev_gendisk.part[i].nr_sects = 0;
                i++;
            }
            /* Get the partition data from the device which is attached. */
            register_disk(&usr_blk_dev_gendisk,
                          i_rdev,
                          dev_num<<USR_BLK_DEV_SHIFT,
                          (struct block_device_operations *)&usr_blk_dev_ops,
                          info_p->params.device_size);
            info_p->media_state = USR_BLK_DEV_MEDIA_STATE_VALIDATED;
            tracemsg("Disk registered\n");
            for (i=dev_num<<USR_BLK_DEV_SHIFT; i<(dev_num+1)<<USR_BLK_DEV_SHIFT; i++)
            {
                tracemsg("%02d: nr_sects: %010ld start_sect: %010ld blk_size: %08d part_size: %08d\n", i,
                         usr_blk_dev_gendisk.part[i].nr_sects,
                         usr_blk_dev_gendisk.part[i].start_sect,
                         usr_blk_dev_blksizes[i],
                         usr_blk_dev_sizes[i]);
            }
        }
        else
        {
            printk(KERN_ERR "usr_blk_dev: Media error encountered while attempting to revalidate device %d.\n", dev_num);
        }
    }
    else
    {
        printk(KERN_WARNING "usr_blk_dev: Attempt to revalidate an uninitialized device %d.\n", dev_num);
    }
    return 0;
}

/*!
 * @brief Handles the i/o control calls for the device.
 *
 * Handles the following ioctl requests:<BR>
 *   BLKRRPART   - Reread the partition table.<BR>
 *   HDIO_GETGEO - Return the disk geometry.  In this case the number of
 *                 cylinders is set to the number if sectors on the disk and
 *                 the start value of the geometry is set to the start sector.
 *                 See struct hd_geometry in the kernel for more information.<BR>
 *   General     - Many other requests are handled by the the general purpose
 *                 block device ioctl handler blk_ioctl().
 *
 * @param inode_p A pointer to the files inode.
 * @param file_p  Pointer to the file structure for the operation.
 * @param cmd     The IOCTL command to operate on.
 * @param arg     The argument information for cmd.
 *
 * @return General:<BR>
 *            -EFAULT upon a copy to or from user problem.<BR>
 *            -EACCES upon an user access problem.<BR>
 *            -ENOTTY if an unsupported request is made.<BR>
 *         BLKRRPART:<BR>
 *             Returns 0 upon success.<BR>
 *         HDIO_GETGEO:<BR>
 *             Returns 0 upon success.
 *             
 */
static int usr_blk_dev_ioctl(struct inode *inode_p, struct file *file_p,
                             unsigned int cmd, unsigned long arg)
{
    int minor;
    int dev_num;
    int ret_val;
    long ret;
    long tmp;
    USR_BLK_DEV_INFO_T *info_p;
    struct hd_geometry geometry;

    tracemsg("cmd: %08x\n", cmd);
    minor = MINOR(inode_p->i_rdev);
    dev_num = USR_BLK_DEV_DEVICE_NR(inode_p->i_rdev);
    info_p = &usr_blk_dev_info[dev_num];
    switch (cmd)
    {
        case BLKRRPART:
            if (!capable(CAP_SYS_ADMIN))
            {
                return -EACCES;
            }
            return usr_blk_dev_revalidate(inode_p->i_rdev);
            
        case HDIO_GETGEO:
            geometry.cylinders = usr_blk_dev_partitions[minor].nr_sects;
            geometry.heads = 1;
            geometry.sectors = 1;
            geometry.start = usr_blk_dev_partitions[minor].start_sect;
            if (copy_to_user((void *)arg, &geometry, sizeof(geometry)))
            {
                return -EFAULT;
            }
            tracemsg("geometry.cylinders: %d geometry.start: %ld\n", geometry.cylinders, geometry.start);
            return 0;

        case _IOR('I', 0x0f05, int):  /* Temporary support for old MMC defines. */
        case IOCMMCGETCARDSTATUS:
            /*
             * The existing MMC driver returns the following statuses:
             *   0x01 - Card is write protected
             *   0x02 - Card is locked
             *   0x04 - Attempt at a the last lock failed  
             *   0x08 - Locking not supported
             *
             * The following is new to this driver:
             *   0x10 - Card has changed since the last call.  To clear this bit, it must be set before
             *          ioctl is called (see comment below).
             */
            if (get_user(tmp, (unsigned long *)arg))
            {
                return -EFAULT;
            }
            ret = IOCMMC_STATUS_LOCK_NOT_SUPPORTED;
            ret |= (info_p->ioctl_media_changed ? IOCMMC_STATUS_MEDIA_CHANGED : 0);
            /* Clear the bit if it was requested. */
            if (tmp & IOCMMC_STATUS_MEDIA_CHANGED)
            {
                info_p->ioctl_media_changed = false;
            }
            return put_user(ret, (unsigned long *)arg);
            
        case _IOR('I', 0x0f06, int):  /* Temporary support for old MMC defines. */
        case IOCMMCGETCARDTYPE:
            /*
             * Return the card type as follows (this is the same as the MMC driver):
             *  0 - MMC Card
             *  1 - SD Card
             */
            /* TODO - Needs to be updated to get the information from the user driver. */
            return put_user((unsigned long)IOCMMC_TYPE_SD, (unsigned long *)arg);

        case _IOR('I', 0x0f09, int):  /* Temporary support for old MMC defines. */
        case IOCMMCGETSIZE:
            /*
             * Returns the size in bytes as opposed to block as is done by BLKGETSIZE.
             */
            return put_user(usr_blk_dev_partitions[minor].nr_sects*usr_blk_dev_blksizes[minor], (unsigned long *)arg);

        case _IOR('I', 0x0f02, int):   /* Temporary support for old MMC defines. */
        case IOCMMCGETCARDCID:
            /*
             * Returns the 16 byte CID register as read in the user space driver.  For devices
             * which do not have a CID an array of 16 0's will be returned.
             */
            memset(info_p->cmd[USR_BLK_DEV_CMD_SRC_GEN].data.cmd_data_from_usr.cid,
                   0, sizeof(info_p->cmd[USR_BLK_DEV_CMD_SRC_GEN].data.cmd_data_from_usr.cid));
            usr_blk_dev_send_cmd_to_thread_and_wait(info_p, USR_BLK_DEV_CMD_ID_READ_CID,
                                                    dev_num, USR_BLK_DEV_CMD_SRC_GEN);
            ret_val = copy_to_user((void *)arg,
                                   info_p->cmd[USR_BLK_DEV_CMD_SRC_GEN].data.cmd_data_from_usr.cid,
                                   sizeof(info_p->cmd[USR_BLK_DEV_CMD_SRC_GEN].data.cmd_data_from_usr.cid));
            usr_blk_dev_cmd_data_processed(info_p, USR_BLK_DEV_CMD_SRC_GEN);
            if (info_p->media_state != USR_BLK_DEV_MEDIA_STATE_ERROR)
            {
                return -EIO;
            }
            if (ret_val)
            {
                return -EFAULT;
            }
            return 0;
            
        default:
            return blk_ioctl(inode_p->i_rdev, cmd, arg);
    }
    return -ENOTTY;
}

/*!
 * @brief Handle media requests for the block device.
 *
 * Handles media requests which are sent to the driver via the request queue.
 * Two different types of requests can be sent, they are for reads and writes
 * to the device.  In general this driver is set up to allow multiple request
 * queues, one per physical device attached.  All of these queues go through
 * this handler function.  Since multiple queues are supported none of the
 * general purpose handlers in blk.h can be used.
 *
 * This handler is called by the kernel when it needs to read or write data
 * to the device.  This may or may not be in a user context.  As a result
 * it cannot block under any circumstances.  This is accomplished by sending
 * the request to the user block thread for handling.  Once the thread receives
 * a read or write command the queue is operated on by the function
 * usr_blk_dev_thread_rw_cmd() which will loop until all requests have been
 * removed from the queue.
 *
 * If a request is received while the user block thread is currently acting
 * on a read or write command, nothing is done.  The transfer will be
 * handled by the user block thread.
 *
 * @param req_queue_p Pointer to the head node on the request queue.
 */
static void usr_blk_dev_request(request_queue_t *req_queue_p)
{
    USR_BLK_DEV_INFO_T *info_p;
    struct request *req_p;
    unsigned int dev_num;

    tracemsg("\n");
    req_p = blkdev_entry_next_request(&req_queue_p->queue_head);
    if (req_p == NULL)
    {
        tracemsg("Error: request pointer is NULL.\n");
        return;
    }
    dev_num = USR_BLK_DEV_DEVICE_NR(req_p->rq_dev);
    info_p = &usr_blk_dev_info[dev_num];
    tracemsg("Request for device %d state: %d\n", dev_num, (int)info_p->cmd[USR_BLK_DEV_CMD_SRC_REQ].state);
    if (info_p->media_state <= USR_BLK_DEV_MEDIA_STATE_ERROR)
    {
        tracemsg("Error: Request made while device not attached.\n");
    }
    if ((info_p->cmd[USR_BLK_DEV_CMD_SRC_REQ].state == USR_BLK_DEV_CMD_STATE_NONE) &&
        (!list_empty(&req_queue_p->queue_head)))
    {
        /*
         * At this point a valid request can be sent to the user mode driver.  Since
         * this function cannot block, the usr block dev thread is used to send the
         * command and complete the request.
         */
        usr_blk_dev_send_cmd_to_thread((req_p->cmd == WRITE) ? USR_BLK_DEV_CMD_ID_WRITE : USR_BLK_DEV_CMD_ID_READ,
                                       dev_num,
                                       USR_BLK_DEV_CMD_SRC_REQ);
    }
}

/*!
 * @brief Returns a pointer to the request queue for the device.
 *
 * @param dev Kernel device information
 *
 * @return A pointer to the request queue for the device
 */
request_queue_t *usr_blk_dev_find_req_queue(kdev_t dev)
{
    unsigned int dev_num;
    static int count = 0;

    dev_num = USR_BLK_DEV_DEVICE_NR(dev);
    if (dev_num >= USR_BLK_DEV_NUM_DEVICES)
    {
        if (count < 5)
        {
            count++;
            printk(KERN_WARNING "usr_blk_dev: Request for unknown device: %d", dev_num);
        }
        return NULL;
    }
    return &usr_blk_dev_info[dev_num].req_queue;
}

/*!
 * @brief Defines the file operations supported by the user space block
 *        driver device. 
 */
static const struct block_device_operations usr_blk_dev_ops =
{
    .check_media_change = usr_blk_dev_check_media_change,
    .ioctl              = usr_blk_dev_ioctl,
    .open               = usr_blk_dev_open,
    .release            = usr_blk_dev_release,
    .revalidate         = usr_blk_dev_revalidate
};

/*!
 * @brief Defines the files operations supported by the proc entry
 *        used for communication with user space.
 */
static const struct file_operations usr_blk_dev_proc_ops =
{
    .open =    usr_blk_dev_proc_open,
    .poll =    usr_blk_dev_proc_poll,
    .read =    usr_blk_dev_proc_read,
    .release = usr_blk_dev_proc_release,
    .write =   usr_blk_dev_proc_write
};

/*!
 * @brief Handles the init command from within the user block device thread.
 *
 * Handles the init command from the user block thread.  This will pass the init
 * command on to user space and wait for a response.  Once the response is
 * received the necessary data will be copied into the devices information
 * structure and hotplug will be called.
 *
 * @param info_p  Pointer to the devices information structure
 * @param dev_num The device number (not the minor number)
 */
static void usr_blk_dev_thread_init_cmd(