usb-pkk-backlight.c v4

#include <linux/init.h>

#include <linux/module.h>
#include <linux/backlight.h>
#include <linux/usb.h>

#include <linux/kernel.h>
#include <linux/slab.h>

#include "usb-pkk-backlight.h"

static usb_complete_t urb_out_complete(struct urb *urb)
{
    return;
}

static int pkk_bl_get_brightness(struct backlight_device *bdev)
{
    struct pkk_bl_data *data = bl_get_data(bdev);
    //uint8_t *brightness = &bdev->props.brightness; //Not sure, that this is right
    uint8_t *brightness = &data->brightness;

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Brightness get function called. Current brightness: %d.\n", *brightness);
    return *brightness;
}

static int pkk_bl_set_brightness(struct backlight_device *bdev)
{
    struct pkk_bl_data *data = bl_get_data(bdev);
    //uint8_t *brightness = &bdev->props.brightness; //Not sure, that this is right
    uint8_t *brightness = &data->brightness;
    unsigned char *transfer_buffer_out = data->transfer_buffer_out;
    int error;

    *brightness = bdev->props.brightness;
    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Brightness set function called. New brightness: %d.\n", *brightness);

    *transfer_buffer_out = PKK_BL_CMD_SET_BRIGHTNESS;
    transfer_buffer_out++;
    *transfer_buffer_out = *brightness;

    error = usb_submit_urb(data->urb, GFP_KERNEL);
    if (data->urb->status != 0 || error != 0)
    {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Urb submit failled. Urb status: %d. Usb_submit_urb returned:%d./n", data->urb->status, error);
    }

    return 0;
}

static const struct backlight_ops pkk_bl_blops = {
    .update_status  = pkk_bl_set_brightness,
    .get_brightness = pkk_bl_get_brightness,
};


static int pkk_bl_init_backlight(struct pkk_bl_data *data) // I'm not sure that it should be static
{
    struct device *dev = &data->intf->dev;
    struct backlight_device *bdev;
    struct backlight_properties props;

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Backlight device initialization...\n");

    /* PicoLCD - There was sommething for hid_report */

    memset(&props, 0, sizeof(props));
    props.type = BACKLIGHT_RAW; //I don't know what is it
    props.max_brightness = PKK_BL_MAX_BRIGHTNESS;

    bdev = backlight_device_register(dev_name(dev), dev, data, &pkk_bl_blops, &props);
    if (IS_ERR(bdev))
    {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Failed to register backlight.\n");
        return PTR_ERR(bdev);
    }

    bdev->props.brightness  = PKK_BL_DEFAULT_BRIGHTNESS;
    data->bdev = bdev;

    pkk_bl_set_brightness(bdev);

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Backlight device initialized.");

    return 0;
}

static void pkk_bl_exit_backlight(struct pkk_bl_data *data) // I'm not sure that it should be static
{
    struct backlight_device *bdev = data->bdev;

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Backlight device unregistering...");

    data->bdev = NULL;
    if (bdev)
        backlight_device_unregister(bdev);

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Backlight device unregistered successfully.");
}

static int pkk_bl_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
    struct pkk_bl_data *data;
    int error = 0;
    struct urb *urb;
    unsigned char *transfer_buffer_out;
    struct usb_device *udev = interface_to_usbdev(intf);

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Hardware probe...\n");

    /* Varibles initialization and assigments */
    data = kzalloc(sizeof(struct pkk_bl_data), GFP_KERNEL);
    if (data == NULL)
    {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't allocate space for device data.\n");
        error = -ENOMEM;
        goto err_no_cleanup;
    }

    /* PicoLCD - There was synchronization elements (initialization & using) */

    dev_set_drvdata(&intf->dev, data);

    /* Filling data structure */

    data->udev_id = id;
    data->udev = udev;

    /* Modules initialization */
    error = pkk_bl_init_backlight(data);
    if (error)
    {
        pkk_bl_exit_backlight(data);
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't initializate backlight device.\n");
        goto err_cleanup_data;
    }

    urb = usb_alloc_urb(0, GFP_KERNEL);
    if (urb == NULL)
    {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't initializate urb.\n");
        goto err_exit_backlight;
    }
    data->urb = urb;

    transfer_buffer_out = kzalloc(sizeof(unsigned char) * PKK_BL_TRANSFER_BUFFER_OUT_SIZE, GFP_KERNEL);
    if (transfer_buffer_out == NULL)
    {
        printk(KERN_ERR PKK_BL_DRIVER_NAME "Can't allocate space for transfer buffer (out).\n");
        error = -ENOMEM;
        goto err_urb_cleanup;
    }
    data->transfer_buffer_out = transfer_buffer_out;

    usb_fill_int_urb(urb, udev, usb_rcvintpipe(&intf->dev, PKK_BL_OUT_ENDPOINT), transfer_buffer_out, PKK_BL_TRANSFER_BUFFER_OUT_SIZE, urb_out_complete, data, PKK_BL_OUT_INTERVAL);

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Device activated and initialized.");

    return 0;

err_urb_cleanup:
    usb_free_urb(urb);
err_exit_backlight:
    pkk_bl_exit_backlight(data);
err_cleanup_data:
    kfree(data);
err_no_cleanup:
    //dev_set_drvdata(&intf->dev, NULL); - intf->dev->data Wasn't assigned in this step(dev_setdrvdata wasn't called)

    return error;
}

static void pkk_bl_disconnect(struct usb_interface *intf)
{
    struct pkk_bl_data *data = dev_get_drvdata(&intf->dev);

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Hardware remove...");

    /* PicoLCD - There was synchronization elements (removing & using) */

    pkk_bl_exit_backlight(data);
    dev_set_drvdata(&intf->dev, NULL);

    usb_free_urb(data->urb);
    kfree(data->transfer_buffer_out);
    kfree(data);

    printk(KERN_DEBUG PKK_BL_DRIVER_NAME "Device disconnected successfully.");
}

static struct usb_device_id pkk_bl_devices [] = {
    { USB_DEVICE(USB_VENDOR_ID_PKK_BL, USB_DEVICE_ID_PKK_BL) },
    {}
};
MODULE_DEVICE_TABLE (usb, pkk_bl_devices);

static struct usb_driver pkk_bl_driver = {
    .name = "usb_pkk_backlight",
    .id_table = pkk_bl_devices,
    .probe = pkk_bl_probe,
    .disconnect = pkk_bl_disconnect,
};
module_usb_driver(pkk_bl_driver);

MODULE_DESCRIPTION("PKK USB backlight driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Dmitry Chepurovskiy <dm3chip@gmail.com>");