saa1064.c

Philips芯片saa1064驱动.saa1064是I2C接口控制的LED控制芯片,一般做为前面板的控制芯片

        }
        scroll_enable = 0;
    }
}

static void saa1064_setMessage(char* inputMessage, unsigned int length)
{
    int i = 0;

    messageLength = 0;
    while(i<length)
    {
        int added = 0;
        dprintk(1, "Adding character '%c'\n", inputMessage[i]);
        if (inputMessage[i] >= '0' && inputMessage[i] <= '9')
        {
            messageStore[messageLength] = numbers[inputMessage[i] - '0'];
            added = 1;
        }
        if (inputMessage[i] >= 'a' && inputMessage[i] <= 'z')
        {
            messageStore[messageLength] = lower_case_characters[inputMessage[i] - 'a'];
            added = 1;
        }
        if (inputMessage[i] >= 'A' && inputMessage[i] <= 'Z')
        {
            messageStore[messageLength] = upper_case_characters[inputMessage[i] - 'A'];
            added = 1;
        }
        if (inputMessage[i] == ' ')
        {
            messageStore[messageLength] = 0x00;
            added = 1;
        }
        /* Add '.' to the current character */
        if (inputMessage[i] == '.')
        {
            messageStore[messageLength] = 0x02;
            added = 1;
        }
        else
        if ((i+1)<length && inputMessage[i+1] == '.') 
        {
            messageStore[messageLength] |= 0x02;
            added = 1;
            i++;
        }

        if (added) 
        {
            messageLength++;
        }
        i++;
    }
    if (debug)
    {
        saa1064_dumpMessageStore();
    }

    if (scroll_enable == 0) 
    {
        scrollPosition = 0;
        saa1064_updateDisplay();
    }
    else
    {
        restartMessage = 1;
    }
}

static ssize_t saa1064_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
    unsigned char message[MAX_MESSAGE*2];

    if (count > MAX_MESSAGE*2) 
    {
        count = MAX_MESSAGE*2;
    }
    /* Copy the data into the buffer */
    if ( copy_from_user(message, buf, count) )
    {
        printk(KERN_WARNING "saa1064_Write: Unable to copy_from_user all data during write.\n");
        return -EFAULT;
    }

    saa1064_setMessage(message, count);

    return count;
}

/* Handle the SAA1064_IOCTL_SET_SCROLLING_ENABLE ioctl */
static int saa1064_setScrollingEnable(unsigned long arg)
{
    int value = (int)arg;

    if (scroll_enable == 0) 
    {
        /* Scolling is not enabled */
        if (value) 
        {
            /* Try enabling it */
            return saa1064_startScrolling();
        }
    }
    else
    {
        /* Scroilling is enabled */
        if (value == 0) 
        {
            /* Disable scrolling */
            saa1064_stopScrolling();
        }
    }

    return 0;
}

/* Handle the SAA1064_IOCTL_GET_SCROLLING_ENABLE ioctl */
static int saa1064_getScrollingEnable(unsigned long arg)
{
    int *data = (int*)arg;
    *data = scroll_enable;

    return 0;
}

/* Handle the SAA1064_IOCTL_SET_SCROLLING_DIRECTION ioctl */
static int saa1064_setScrollingDirection(unsigned long arg)
{
    scroll_forwards = (int)arg;
    return 0;
}

/* Handle the SAA1064_IOCTL_GET_SCROLLING_DIRECTION ioctl */
static int saa1064_getScrollingDirection(unsigned long arg)
{
    int *data = (int*)arg;
    *data = scroll_forwards;

    return 0;
}

/* Handle the SAA1064_IOCTL_SET_SCROLLING_DELAY ioctl */
static int saa1064_setScrollingDelay(unsigned long arg)
{
    scroll_delay = (int)arg;
    return 0;
}

/* Handle the SAA1064_IOCTL_GET_SCROLLING_DELAY ioctl */
static int saa1064_getScrollingDelay(unsigned long arg)
{
    int *data = (int*)arg;
    *data = scroll_delay;

    return 0;
}

/* Handle the SAA1064_IOCTL_SET_DISPLAY_BRIGHTNESS ioctl */
static int saa1064_setDisplayBrightness(unsigned long arg)
{
    if ((int)arg >= 0 && (int)arg <=7) 
    {
        display_brightness = (int)arg;

        if (scroll_enable == 0) 
        {
            saa1064_updateDisplay();
        }

        return 0;
    }

    return -EINVAL;
}

/* Handle the SAA1064_IOCTL_GET_DISPLAY_BRIGHTNESS ioctl */
static int saa1064_getDisplayBrightness(unsigned long arg)
{
    int *data = (int*)arg;
    *data = display_brightness;

    return 0;
}

/* Handle all ioctls supported by the device */
static int saa1064_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    int result = -ENOTTY;

    switch (cmd)
    {
    case SAA1064_IOCTL_SET_SCROLLING_ENABLE:
        result = saa1064_setScrollingEnable(arg);
        break;

    case SAA1064_IOCTL_GET_SCROLLING_ENABLE:
        result = saa1064_getScrollingEnable(arg);
        break;

    case SAA1064_IOCTL_SET_SCROLLING_DIRECTION:
        result = saa1064_setScrollingDirection(arg);
        break;

    case SAA1064_IOCTL_GET_SCROLLING_DIRECTION:
        result = saa1064_getScrollingDirection(arg);
        break;

    case SAA1064_IOCTL_SET_SCROLLING_DELAY:
        result = saa1064_setScrollingDelay(arg);
        break;

    case SAA1064_IOCTL_GET_SCROLLING_DELAY:
        result = saa1064_getScrollingDelay(arg);
        break;

    case SAA1064_IOCTL_SET_DISPLAY_BRIGHTNESS:
        result = saa1064_setDisplayBrightness(arg);
        break;

    case SAA1064_IOCTL_GET_DISPLAY_BRIGHTNESS:
        result = saa1064_getDisplayBrightness(arg);
        break;

    default:
        break;
    }

    return result;
}

//  ----------------------- saa1064 I2C Detection Function (Detect) ------------
static int saa1064_detectClient (struct i2c_adapter *adapter, int address, int kind)
{
    int result;

    dprintk(1,
        KERN_INFO
        "saa1064.c: detecting saa1064 client on address 0x%x\n",
        address << 1);

    /* Check if the adapter supports the needed features */
    if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
    {
        return 0;
    }

    /* Create the I2C client data structure */
    saa1064_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
    if (saa1064_client == 0)
    {
        return -ENOMEM;
    }
    memset(saa1064_client, 0, sizeof(struct i2c_client));
    saa1064_client->addr = address;
    saa1064_client->adapter = adapter;
    saa1064_client->driver = &i2c_driver_saa1064;
    snprintf(I2C_NAME(saa1064_client), sizeof(I2C_NAME(saa1064_client)) - 1, "saa1064");

    /* Attach the device to the I2C adapter */
    result = i2c_attach_client(saa1064_client);
    if (result) {
        dprintk(1,
            KERN_INFO
            "saa1064.c: Failed to attach to client on adapter %s (0x%x) - 0x%02X\n",
            I2C_NAME(adapter), adapter->id, result);
        kfree(saa1064_client);
        return result;
    }

    result = misc_register( &saa1064_MiscDev );
    if (result < 0)
    {
        printk(KERN_WARNING "%s: Can't register misc device (minor %d)!\n", THIS_MODULE->name, saa1064_MiscDev.minor);
        return result;
    }

    saa1064_present = 1;
    dprintk(1,
        KERN_INFO
        "saa1064.c: found device SAA1064 on adapter %s (0x%x) - 0x%02X\n",
        I2C_NAME(adapter), adapter->id, result);

    return 0;
}

//  ----------------------- saa1064 I2C Detection Function (Attach)     --------
static int saa1064_attachAdapter (struct i2c_adapter *adapter)
{
    return i2c_probe(adapter, &addr_data, &saa1064_detectClient);
}

//  ----------------------- saa1064 I2C Detection Function (Detach)     --------
static int saa1064_detachClient (struct i2c_client *client)
{
    int err;

    err = i2c_detach_client(client);
    if (err)
    {
        return err;
    }

    kfree(client);

    return 0;
}

//  ----------------------- MODULE INIT     ------------------------------------
static int __init saa1064_init (void)
{
    int result;

    result = i2c_add_driver(&i2c_driver_saa1064);

    if (result == 0)
    {
        unsigned char initMessage[1];

        initMessage[0] = (display_brightness << 4) | 0x07;
        
        saa1064_sendI2C ( saa1064_client, initMessage, 0, 1);

        if (scroll_enable) 
        {
            result = saa1064_startScrolling();
            if (result < 0)
            {
                return result;
            }
        }

        saa1064_setMessage("225...Stb", 9);

        printk ("%s (%s-%s)\n",
                THIS_MODULE_DESCRIPTION,
                __DATE__,
                __TIME__);
    }
    return result;
}

//  ----------------------- MODULE EXIT     ------------------------------------
static void __exit saa1064_exit (void)
{
    i2c_del_driver(&i2c_driver_saa1064);

    if (saa1064_present) 
    {
        saa1064_stopScrolling();

        misc_deregister( &saa1064_MiscDev );
    }
    printk("Shutting down %s\n", THIS_MODULE_DESCRIPTION);
}
//  ****************************************************************************
//  *                                                                          *
//  *                       P U B L I C    O B J E C T S                       *
//  *                                                                          *
//  ****************************************************************************

//  ****************************************************************************
//  *                                                                          *
//  *                       E X P O R T E D    S Y M B O L S                   *
//  *                                                                          *
//  ****************************************************************************

//  ----------------------- MODULE MANAGEMENT   --------------------------------
module_init(saa1064_init);
module_exit(saa1064_exit);