diff options
99 files changed, 4222 insertions, 2514 deletions
diff --git a/drivers/block/brd.c b/drivers/block/brd.c index 85364804364f..7bd76639544c 100644 --- a/drivers/block/brd.c +++ b/drivers/block/brd.c | |||
@@ -108,7 +108,7 @@ static struct page *brd_insert_page(struct brd_device *brd, sector_t sector) | |||
108 | #ifndef CONFIG_BLK_DEV_XIP | 108 | #ifndef CONFIG_BLK_DEV_XIP |
109 | gfp_flags |= __GFP_HIGHMEM; | 109 | gfp_flags |= __GFP_HIGHMEM; |
110 | #endif | 110 | #endif |
111 | page = alloc_page(GFP_NOIO | __GFP_HIGHMEM | __GFP_ZERO); | 111 | page = alloc_page(gfp_flags); |
112 | if (!page) | 112 | if (!page) |
113 | return NULL; | 113 | return NULL; |
114 | 114 | ||
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index f0b00ec1e47e..e03c67dd3e63 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c | |||
@@ -44,8 +44,8 @@ | |||
44 | 44 | ||
45 | #ifdef CONFIG_HID_DEBUG | 45 | #ifdef CONFIG_HID_DEBUG |
46 | int hid_debug = 0; | 46 | int hid_debug = 0; |
47 | module_param_named(debug, hid_debug, bool, 0600); | 47 | module_param_named(debug, hid_debug, int, 0600); |
48 | MODULE_PARM_DESC(debug, "Turn HID debugging mode on and off"); | 48 | MODULE_PARM_DESC(debug, "HID debugging (0=off, 1=probing info, 2=continuous data dumping)"); |
49 | EXPORT_SYMBOL_GPL(hid_debug); | 49 | EXPORT_SYMBOL_GPL(hid_debug); |
50 | #endif | 50 | #endif |
51 | 51 | ||
@@ -97,7 +97,7 @@ static struct hid_field *hid_register_field(struct hid_report *report, unsigned | |||
97 | field->index = report->maxfield++; | 97 | field->index = report->maxfield++; |
98 | report->field[field->index] = field; | 98 | report->field[field->index] = field; |
99 | field->usage = (struct hid_usage *)(field + 1); | 99 | field->usage = (struct hid_usage *)(field + 1); |
100 | field->value = (unsigned *)(field->usage + usages); | 100 | field->value = (s32 *)(field->usage + usages); |
101 | field->report = report; | 101 | field->report = report; |
102 | 102 | ||
103 | return field; | 103 | return field; |
@@ -830,7 +830,8 @@ static void hid_process_event(struct hid_device *hid, struct hid_field *field, s | |||
830 | * reporting to the layer). | 830 | * reporting to the layer). |
831 | */ | 831 | */ |
832 | 832 | ||
833 | void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, int interrupt) | 833 | static void hid_input_field(struct hid_device *hid, struct hid_field *field, |
834 | __u8 *data, int interrupt) | ||
834 | { | 835 | { |
835 | unsigned n; | 836 | unsigned n; |
836 | unsigned count = field->report_count; | 837 | unsigned count = field->report_count; |
@@ -876,7 +877,6 @@ void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data | |||
876 | exit: | 877 | exit: |
877 | kfree(value); | 878 | kfree(value); |
878 | } | 879 | } |
879 | EXPORT_SYMBOL_GPL(hid_input_field); | ||
880 | 880 | ||
881 | /* | 881 | /* |
882 | * Output the field into the report. | 882 | * Output the field into the report. |
@@ -988,8 +988,13 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i | |||
988 | 988 | ||
989 | if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event) | 989 | if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event) |
990 | hid->hiddev_report_event(hid, report); | 990 | hid->hiddev_report_event(hid, report); |
991 | if (hid->claimed & HID_CLAIMED_HIDRAW) | 991 | if (hid->claimed & HID_CLAIMED_HIDRAW) { |
992 | hidraw_report_event(hid, data, size); | 992 | /* numbered reports need to be passed with the report num */ |
993 | if (report_enum->numbered) | ||
994 | hidraw_report_event(hid, data - 1, size + 1); | ||
995 | else | ||
996 | hidraw_report_event(hid, data, size); | ||
997 | } | ||
993 | 998 | ||
994 | for (n = 0; n < report->maxfield; n++) | 999 | for (n = 0; n < report->maxfield; n++) |
995 | hid_input_field(hid, report->field[n], data, interrupt); | 1000 | hid_input_field(hid, report->field[n], data, interrupt); |
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c index 5c24fe46d8eb..f88714b06000 100644 --- a/drivers/hid/hid-debug.c +++ b/drivers/hid/hid-debug.c | |||
@@ -498,7 +498,7 @@ void hid_dump_device(struct hid_device *device) { | |||
498 | EXPORT_SYMBOL_GPL(hid_dump_device); | 498 | EXPORT_SYMBOL_GPL(hid_dump_device); |
499 | 499 | ||
500 | void hid_dump_input(struct hid_usage *usage, __s32 value) { | 500 | void hid_dump_input(struct hid_usage *usage, __s32 value) { |
501 | if (!hid_debug) | 501 | if (hid_debug < 2) |
502 | return; | 502 | return; |
503 | 503 | ||
504 | printk(KERN_DEBUG "hid-debug: input "); | 504 | printk(KERN_DEBUG "hid-debug: input "); |
diff --git a/drivers/hid/hid-input-quirks.c b/drivers/hid/hid-input-quirks.c index dceadd0c1419..4c2052c658f1 100644 --- a/drivers/hid/hid-input-quirks.c +++ b/drivers/hid/hid-input-quirks.c | |||
@@ -276,6 +276,21 @@ static int quirk_btc_8193(struct hid_usage *usage, struct input_dev *input, | |||
276 | return 1; | 276 | return 1; |
277 | } | 277 | } |
278 | 278 | ||
279 | static int quirk_sunplus_wdesktop(struct hid_usage *usage, struct input_dev *input, | ||
280 | unsigned long **bit, int *max) | ||
281 | { | ||
282 | if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) | ||
283 | return 0; | ||
284 | |||
285 | switch (usage->hid & HID_USAGE) { | ||
286 | case 0x2003: map_key_clear(KEY_ZOOMIN); break; | ||
287 | case 0x2103: map_key_clear(KEY_ZOOMOUT); break; | ||
288 | default: | ||
289 | return 0; | ||
290 | } | ||
291 | return 1; | ||
292 | } | ||
293 | |||
279 | #define VENDOR_ID_BELKIN 0x1020 | 294 | #define VENDOR_ID_BELKIN 0x1020 |
280 | #define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD 0x0006 | 295 | #define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD 0x0006 |
281 | 296 | ||
@@ -306,6 +321,9 @@ static int quirk_btc_8193(struct hid_usage *usage, struct input_dev *input, | |||
306 | #define VENDOR_ID_PETALYNX 0x18b1 | 321 | #define VENDOR_ID_PETALYNX 0x18b1 |
307 | #define DEVICE_ID_PETALYNX_MAXTER_REMOTE 0x0037 | 322 | #define DEVICE_ID_PETALYNX_MAXTER_REMOTE 0x0037 |
308 | 323 | ||
324 | #define VENDOR_ID_SUNPLUS 0x04fc | ||
325 | #define DEVICE_ID_SUNPLUS_WDESKTOP 0x05d8 | ||
326 | |||
309 | static const struct hid_input_blacklist { | 327 | static const struct hid_input_blacklist { |
310 | __u16 idVendor; | 328 | __u16 idVendor; |
311 | __u16 idProduct; | 329 | __u16 idProduct; |
@@ -332,8 +350,10 @@ static const struct hid_input_blacklist { | |||
332 | { VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e }, | 350 | { VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e }, |
333 | 351 | ||
334 | { VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote }, | 352 | { VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote }, |
335 | 353 | ||
336 | { 0, 0, 0 } | 354 | { VENDOR_ID_SUNPLUS, DEVICE_ID_SUNPLUS_WDESKTOP, quirk_sunplus_wdesktop }, |
355 | |||
356 | { 0, 0, NULL } | ||
337 | }; | 357 | }; |
338 | 358 | ||
339 | int hidinput_mapping_quirks(struct hid_usage *usage, | 359 | int hidinput_mapping_quirks(struct hid_usage *usage, |
diff --git a/drivers/hid/usbhid/Kconfig b/drivers/hid/usbhid/Kconfig index 7160fa65d79b..18f09104765c 100644 --- a/drivers/hid/usbhid/Kconfig +++ b/drivers/hid/usbhid/Kconfig | |||
@@ -71,6 +71,14 @@ config LOGITECH_FF | |||
71 | Note: if you say N here, this device will still be supported, but without | 71 | Note: if you say N here, this device will still be supported, but without |
72 | force feedback. | 72 | force feedback. |
73 | 73 | ||
74 | config LOGIRUMBLEPAD2_FF | ||
75 | bool "Logitech Rumblepad 2 support" | ||
76 | depends on HID_FF | ||
77 | select INPUT_FF_MEMLESS if USB_HID | ||
78 | help | ||
79 | Say Y here if you want to enable force feedback support for Logitech | ||
80 | Rumblepad 2 devices. | ||
81 | |||
74 | config PANTHERLORD_FF | 82 | config PANTHERLORD_FF |
75 | bool "PantherLord/GreenAsia based device support" | 83 | bool "PantherLord/GreenAsia based device support" |
76 | depends on HID_FF | 84 | depends on HID_FF |
@@ -80,8 +88,8 @@ config PANTHERLORD_FF | |||
80 | or adapter and want to enable force feedback support for it. | 88 | or adapter and want to enable force feedback support for it. |
81 | 89 | ||
82 | config THRUSTMASTER_FF | 90 | config THRUSTMASTER_FF |
83 | bool "ThrustMaster devices support (EXPERIMENTAL)" | 91 | bool "ThrustMaster devices support" |
84 | depends on HID_FF && EXPERIMENTAL | 92 | depends on HID_FF |
85 | select INPUT_FF_MEMLESS if USB_HID | 93 | select INPUT_FF_MEMLESS if USB_HID |
86 | help | 94 | help |
87 | Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or | 95 | Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or |
diff --git a/drivers/hid/usbhid/Makefile b/drivers/hid/usbhid/Makefile index 8e6ab5b164a2..00a7b7090192 100644 --- a/drivers/hid/usbhid/Makefile +++ b/drivers/hid/usbhid/Makefile | |||
@@ -16,6 +16,9 @@ endif | |||
16 | ifeq ($(CONFIG_LOGITECH_FF),y) | 16 | ifeq ($(CONFIG_LOGITECH_FF),y) |
17 | usbhid-objs += hid-lgff.o | 17 | usbhid-objs += hid-lgff.o |
18 | endif | 18 | endif |
19 | ifeq ($(CONFIG_LOGIRUMBLEPAD2_FF),y) | ||
20 | usbhid-objs += hid-lg2ff.o | ||
21 | endif | ||
19 | ifeq ($(CONFIG_PANTHERLORD_FF),y) | 22 | ifeq ($(CONFIG_PANTHERLORD_FF),y) |
20 | usbhid-objs += hid-plff.o | 23 | usbhid-objs += hid-plff.o |
21 | endif | 24 | endif |
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c index d95979f0e028..e0d805f1b2bf 100644 --- a/drivers/hid/usbhid/hid-core.c +++ b/drivers/hid/usbhid/hid-core.c | |||
@@ -82,6 +82,7 @@ static int hid_start_in(struct hid_device *hid) | |||
82 | 82 | ||
83 | spin_lock_irqsave(&usbhid->inlock, flags); | 83 | spin_lock_irqsave(&usbhid->inlock, flags); |
84 | if (hid->open > 0 && !test_bit(HID_SUSPENDED, &usbhid->iofl) && | 84 | if (hid->open > 0 && !test_bit(HID_SUSPENDED, &usbhid->iofl) && |
85 | !test_bit(HID_DISCONNECTED, &usbhid->iofl) && | ||
85 | !test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) { | 86 | !test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) { |
86 | rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC); | 87 | rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC); |
87 | if (rc != 0) | 88 | if (rc != 0) |
@@ -155,7 +156,7 @@ static void hid_io_error(struct hid_device *hid) | |||
155 | spin_lock_irqsave(&usbhid->inlock, flags); | 156 | spin_lock_irqsave(&usbhid->inlock, flags); |
156 | 157 | ||
157 | /* Stop when disconnected */ | 158 | /* Stop when disconnected */ |
158 | if (usb_get_intfdata(usbhid->intf) == NULL) | 159 | if (test_bit(HID_DISCONNECTED, &usbhid->iofl)) |
159 | goto done; | 160 | goto done; |
160 | 161 | ||
161 | /* If it has been a while since the last error, we'll assume | 162 | /* If it has been a while since the last error, we'll assume |
@@ -341,7 +342,7 @@ static void hid_irq_out(struct urb *urb) | |||
341 | if (usbhid->outhead != usbhid->outtail) { | 342 | if (usbhid->outhead != usbhid->outtail) { |
342 | if (hid_submit_out(hid)) { | 343 | if (hid_submit_out(hid)) { |
343 | clear_bit(HID_OUT_RUNNING, &usbhid->iofl); | 344 | clear_bit(HID_OUT_RUNNING, &usbhid->iofl); |
344 | wake_up(&hid->wait); | 345 | wake_up(&usbhid->wait); |
345 | } | 346 | } |
346 | spin_unlock_irqrestore(&usbhid->outlock, flags); | 347 | spin_unlock_irqrestore(&usbhid->outlock, flags); |
347 | return; | 348 | return; |
@@ -349,7 +350,7 @@ static void hid_irq_out(struct urb *urb) | |||
349 | 350 | ||
350 | clear_bit(HID_OUT_RUNNING, &usbhid->iofl); | 351 | clear_bit(HID_OUT_RUNNING, &usbhid->iofl); |
351 | spin_unlock_irqrestore(&usbhid->outlock, flags); | 352 | spin_unlock_irqrestore(&usbhid->outlock, flags); |
352 | wake_up(&hid->wait); | 353 | wake_up(&usbhid->wait); |
353 | } | 354 | } |
354 | 355 | ||
355 | /* | 356 | /* |
@@ -391,7 +392,7 @@ static void hid_ctrl(struct urb *urb) | |||
391 | if (usbhid->ctrlhead != usbhid->ctrltail) { | 392 | if (usbhid->ctrlhead != usbhid->ctrltail) { |
392 | if (hid_submit_ctrl(hid)) { | 393 | if (hid_submit_ctrl(hid)) { |
393 | clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); | 394 | clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); |
394 | wake_up(&hid->wait); | 395 | wake_up(&usbhid->wait); |
395 | } | 396 | } |
396 | spin_unlock_irqrestore(&usbhid->ctrllock, flags); | 397 | spin_unlock_irqrestore(&usbhid->ctrllock, flags); |
397 | return; | 398 | return; |
@@ -399,7 +400,7 @@ static void hid_ctrl(struct urb *urb) | |||
399 | 400 | ||
400 | clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); | 401 | clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); |
401 | spin_unlock_irqrestore(&usbhid->ctrllock, flags); | 402 | spin_unlock_irqrestore(&usbhid->ctrllock, flags); |
402 | wake_up(&hid->wait); | 403 | wake_up(&usbhid->wait); |
403 | } | 404 | } |
404 | 405 | ||
405 | void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir) | 406 | void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir) |
@@ -478,8 +479,9 @@ int usbhid_wait_io(struct hid_device *hid) | |||
478 | { | 479 | { |
479 | struct usbhid_device *usbhid = hid->driver_data; | 480 | struct usbhid_device *usbhid = hid->driver_data; |
480 | 481 | ||
481 | if (!wait_event_timeout(hid->wait, (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) && | 482 | if (!wait_event_timeout(usbhid->wait, |
482 | !test_bit(HID_OUT_RUNNING, &usbhid->iofl)), | 483 | (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) && |
484 | !test_bit(HID_OUT_RUNNING, &usbhid->iofl)), | ||
483 | 10*HZ)) { | 485 | 10*HZ)) { |
484 | dbg_hid("timeout waiting for ctrl or out queue to clear\n"); | 486 | dbg_hid("timeout waiting for ctrl or out queue to clear\n"); |
485 | return -1; | 487 | return -1; |
@@ -610,10 +612,11 @@ static void usbhid_set_leds(struct hid_device *hid) | |||
610 | /* | 612 | /* |
611 | * Traverse the supplied list of reports and find the longest | 613 | * Traverse the supplied list of reports and find the longest |
612 | */ | 614 | */ |
613 | static void hid_find_max_report(struct hid_device *hid, unsigned int type, int *max) | 615 | static void hid_find_max_report(struct hid_device *hid, unsigned int type, |
616 | unsigned int *max) | ||
614 | { | 617 | { |
615 | struct hid_report *report; | 618 | struct hid_report *report; |
616 | int size; | 619 | unsigned int size; |
617 | 620 | ||
618 | list_for_each_entry(report, &hid->report_enum[type].report_list, list) { | 621 | list_for_each_entry(report, &hid->report_enum[type].report_list, list) { |
619 | size = ((report->size - 1) >> 3) + 1; | 622 | size = ((report->size - 1) >> 3) + 1; |
@@ -705,9 +708,9 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf) | |||
705 | struct hid_descriptor *hdesc; | 708 | struct hid_descriptor *hdesc; |
706 | struct hid_device *hid; | 709 | struct hid_device *hid; |
707 | u32 quirks = 0; | 710 | u32 quirks = 0; |
708 | unsigned rsize = 0; | 711 | unsigned int insize = 0, rsize = 0; |
709 | char *rdesc; | 712 | char *rdesc; |
710 | int n, len, insize = 0; | 713 | int n, len; |
711 | struct usbhid_device *usbhid; | 714 | struct usbhid_device *usbhid; |
712 | 715 | ||
713 | quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor), | 716 | quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor), |
@@ -800,6 +803,22 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf) | |||
800 | goto fail; | 803 | goto fail; |
801 | } | 804 | } |
802 | 805 | ||
806 | hid->name[0] = 0; | ||
807 | |||
808 | if (dev->manufacturer) | ||
809 | strlcpy(hid->name, dev->manufacturer, sizeof(hid->name)); | ||
810 | |||
811 | if (dev->product) { | ||
812 | if (dev->manufacturer) | ||
813 | strlcat(hid->name, " ", sizeof(hid->name)); | ||
814 | strlcat(hid->name, dev->product, sizeof(hid->name)); | ||
815 | } | ||
816 | |||
817 | if (!strlen(hid->name)) | ||
818 | snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x", | ||
819 | le16_to_cpu(dev->descriptor.idVendor), | ||
820 | le16_to_cpu(dev->descriptor.idProduct)); | ||
821 | |||
803 | for (n = 0; n < interface->desc.bNumEndpoints; n++) { | 822 | for (n = 0; n < interface->desc.bNumEndpoints; n++) { |
804 | 823 | ||
805 | struct usb_endpoint_descriptor *endpoint; | 824 | struct usb_endpoint_descriptor *endpoint; |
@@ -812,6 +831,14 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf) | |||
812 | 831 | ||
813 | interval = endpoint->bInterval; | 832 | interval = endpoint->bInterval; |
814 | 833 | ||
834 | /* Some vendors give fullspeed interval on highspeed devides */ | ||
835 | if (quirks & HID_QUIRK_FULLSPEED_INTERVAL && | ||
836 | dev->speed == USB_SPEED_HIGH) { | ||
837 | interval = fls(endpoint->bInterval*8); | ||
838 | printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n", | ||
839 | hid->name, endpoint->bInterval, interval); | ||
840 | } | ||
841 | |||
815 | /* Change the polling interval of mice. */ | 842 | /* Change the polling interval of mice. */ |
816 | if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0) | 843 | if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0) |
817 | interval = hid_mousepoll_interval; | 844 | interval = hid_mousepoll_interval; |
@@ -844,8 +871,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf) | |||
844 | goto fail; | 871 | goto fail; |
845 | } | 872 | } |
846 | 873 | ||
847 | init_waitqueue_head(&hid->wait); | 874 | init_waitqueue_head(&usbhid->wait); |
848 | |||
849 | INIT_WORK(&usbhid->reset_work, hid_reset); | 875 | INIT_WORK(&usbhid->reset_work, hid_reset); |
850 | setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid); | 876 | setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid); |
851 | 877 | ||
@@ -859,22 +885,6 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf) | |||
859 | usbhid->intf = intf; | 885 | usbhid->intf = intf; |
860 | usbhid->ifnum = interface->desc.bInterfaceNumber; | 886 | usbhid->ifnum = interface->desc.bInterfaceNumber; |
861 | 887 | ||
862 | hid->name[0] = 0; | ||
863 | |||
864 | if (dev->manufacturer) | ||
865 | strlcpy(hid->name, dev->manufacturer, sizeof(hid->name)); | ||
866 | |||
867 | if (dev->product) { | ||
868 | if (dev->manufacturer) | ||
869 | strlcat(hid->name, " ", sizeof(hid->name)); | ||
870 | strlcat(hid->name, dev->product, sizeof(hid->name)); | ||
871 | } | ||
872 | |||
873 | if (!strlen(hid->name)) | ||
874 | snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x", | ||
875 | le16_to_cpu(dev->descriptor.idVendor), | ||
876 | le16_to_cpu(dev->descriptor.idProduct)); | ||
877 | |||
878 | hid->bus = BUS_USB; | 888 | hid->bus = BUS_USB; |
879 | hid->vendor = le16_to_cpu(dev->descriptor.idVendor); | 889 | hid->vendor = le16_to_cpu(dev->descriptor.idVendor); |
880 | hid->product = le16_to_cpu(dev->descriptor.idProduct); | 890 | hid->product = le16_to_cpu(dev->descriptor.idProduct); |
@@ -932,6 +942,7 @@ static void hid_disconnect(struct usb_interface *intf) | |||
932 | 942 | ||
933 | spin_lock_irq(&usbhid->inlock); /* Sync with error handler */ | 943 | spin_lock_irq(&usbhid->inlock); /* Sync with error handler */ |
934 | usb_set_intfdata(intf, NULL); | 944 | usb_set_intfdata(intf, NULL); |
945 | set_bit(HID_DISCONNECTED, &usbhid->iofl); | ||
935 | spin_unlock_irq(&usbhid->inlock); | 946 | spin_unlock_irq(&usbhid->inlock); |
936 | usb_kill_urb(usbhid->urbin); | 947 | usb_kill_urb(usbhid->urbin); |
937 | usb_kill_urb(usbhid->urbout); | 948 | usb_kill_urb(usbhid->urbout); |
diff --git a/drivers/hid/usbhid/hid-ff.c b/drivers/hid/usbhid/hid-ff.c index 4c210e16b1b4..1d0dac52f166 100644 --- a/drivers/hid/usbhid/hid-ff.c +++ b/drivers/hid/usbhid/hid-ff.c | |||
@@ -59,6 +59,9 @@ static struct hid_ff_initializer inits[] = { | |||
59 | { 0x46d, 0xc295, hid_lgff_init }, /* Logitech MOMO force wheel */ | 59 | { 0x46d, 0xc295, hid_lgff_init }, /* Logitech MOMO force wheel */ |
60 | { 0x46d, 0xca03, hid_lgff_init }, /* Logitech MOMO force wheel */ | 60 | { 0x46d, 0xca03, hid_lgff_init }, /* Logitech MOMO force wheel */ |
61 | #endif | 61 | #endif |
62 | #ifdef CONFIG_LOGIRUMBLEPAD2_FF | ||
63 | { 0x46d, 0xc218, hid_lg2ff_init }, /* Logitech Rumblepad 2 */ | ||
64 | #endif | ||
62 | #ifdef CONFIG_PANTHERLORD_FF | 65 | #ifdef CONFIG_PANTHERLORD_FF |
63 | { 0x810, 0x0001, hid_plff_init }, /* "Twin USB Joystick" */ | 66 | { 0x810, 0x0001, hid_plff_init }, /* "Twin USB Joystick" */ |
64 | { 0xe8f, 0x0003, hid_plff_init }, /* "GreenAsia Inc. USB Joystick " */ | 67 | { 0xe8f, 0x0003, hid_plff_init }, /* "GreenAsia Inc. USB Joystick " */ |
diff --git a/drivers/hid/usbhid/hid-lg2ff.c b/drivers/hid/usbhid/hid-lg2ff.c new file mode 100644 index 000000000000..d469bd0061c9 --- /dev/null +++ b/drivers/hid/usbhid/hid-lg2ff.c | |||
@@ -0,0 +1,114 @@ | |||
1 | /* | ||
2 | * Force feedback support for Logitech Rumblepad 2 | ||
3 | * | ||
4 | * Copyright (c) 2008 Anssi Hannula <anssi.hannula@gmail.com> | ||
5 | */ | ||
6 | |||
7 | /* | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2 of the License, or | ||
11 | * (at your option) any later version. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software | ||
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
21 | */ | ||
22 | |||
23 | |||
24 | #include <linux/input.h> | ||
25 | #include <linux/usb.h> | ||
26 | #include <linux/hid.h> | ||
27 | #include "usbhid.h" | ||
28 | |||
29 | struct lg2ff_device { | ||
30 | struct hid_report *report; | ||
31 | }; | ||
32 | |||
33 | static int play_effect(struct input_dev *dev, void *data, | ||
34 | struct ff_effect *effect) | ||
35 | { | ||
36 | struct hid_device *hid = input_get_drvdata(dev); | ||
37 | struct lg2ff_device *lg2ff = data; | ||
38 | int weak, strong; | ||
39 | |||
40 | strong = effect->u.rumble.strong_magnitude; | ||
41 | weak = effect->u.rumble.weak_magnitude; | ||
42 | |||
43 | if (weak || strong) { | ||
44 | weak = weak * 0xff / 0xffff; | ||
45 | strong = strong * 0xff / 0xffff; | ||
46 | |||
47 | lg2ff->report->field[0]->value[0] = 0x51; | ||
48 | lg2ff->report->field[0]->value[2] = weak; | ||
49 | lg2ff->report->field[0]->value[4] = strong; | ||
50 | } else { | ||
51 | lg2ff->report->field[0]->value[0] = 0xf3; | ||
52 | lg2ff->report->field[0]->value[2] = 0x00; | ||
53 | lg2ff->report->field[0]->value[4] = 0x00; | ||
54 | } | ||
55 | |||
56 | usbhid_submit_report(hid, lg2ff->report, USB_DIR_OUT); | ||
57 | return 0; | ||
58 | } | ||
59 | |||
60 | int hid_lg2ff_init(struct hid_device *hid) | ||
61 | { | ||
62 | struct lg2ff_device *lg2ff; | ||
63 | struct hid_report *report; | ||
64 | struct hid_input *hidinput = list_entry(hid->inputs.next, | ||
65 | struct hid_input, list); | ||
66 | struct list_head *report_list = | ||
67 | &hid->report_enum[HID_OUTPUT_REPORT].report_list; | ||
68 | struct input_dev *dev = hidinput->input; | ||
69 | int error; | ||
70 | |||
71 | if (list_empty(report_list)) { | ||
72 | printk(KERN_ERR "hid-lg2ff: no output report found\n"); | ||
73 | return -ENODEV; | ||
74 | } | ||
75 | |||
76 | report = list_entry(report_list->next, struct hid_report, list); | ||
77 | |||
78 | if (report->maxfield < 1) { | ||
79 | printk(KERN_ERR "hid-lg2ff: output report is empty\n"); | ||
80 | return -ENODEV; | ||
81 | } | ||
82 | if (report->field[0]->report_count < 7) { | ||
83 | printk(KERN_ERR "hid-lg2ff: not enough values in the field\n"); | ||
84 | return -ENODEV; | ||
85 | } | ||
86 | |||
87 | lg2ff = kmalloc(sizeof(struct lg2ff_device), GFP_KERNEL); | ||
88 | if (!lg2ff) | ||
89 | return -ENOMEM; | ||
90 | |||
91 | set_bit(FF_RUMBLE, dev->ffbit); | ||
92 | |||
93 | error = input_ff_create_memless(dev, lg2ff, play_effect); | ||
94 | if (error) { | ||
95 | kfree(lg2ff); | ||
96 | return error; | ||
97 | } | ||
98 | |||
99 | lg2ff->report = report; | ||
100 | report->field[0]->value[0] = 0xf3; | ||
101 | report->field[0]->value[1] = 0x00; | ||
102 | report->field[0]->value[2] = 0x00; | ||
103 | report->field[0]->value[3] = 0x00; | ||
104 | report->field[0]->value[4] = 0x00; | ||
105 | report->field[0]->value[5] = 0x00; | ||
106 | report->field[0]->value[6] = 0x00; | ||
107 | |||
108 | usbhid_submit_report(hid, report, USB_DIR_OUT); | ||
109 | |||
110 | printk(KERN_INFO "Force feedback for Logitech Rumblepad 2 by " | ||
111 | "Anssi Hannula <anssi.hannula@gmail.com>\n"); | ||
112 | |||
113 | return 0; | ||
114 | } | ||
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c index e29a057cbea2..28ddc3fdd3d1 100644 --- a/drivers/hid/usbhid/hid-quirks.c +++ b/drivers/hid/usbhid/hid-quirks.c | |||
@@ -32,6 +32,9 @@ | |||
32 | #define USB_VENDOR_ID_ADS_TECH 0x06e1 | 32 | #define USB_VENDOR_ID_ADS_TECH 0x06e1 |
33 | #define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X 0xa155 | 33 | #define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X 0xa155 |
34 | 34 | ||
35 | #define USB_VENDOR_ID_AFATECH 0x15a4 | ||
36 | #define USB_DEVICE_ID_AFATECH_AF9016 0x9016 | ||
37 | |||
35 | #define USB_VENDOR_ID_AIPTEK 0x08ca | 38 | #define USB_VENDOR_ID_AIPTEK 0x08ca |
36 | #define USB_DEVICE_ID_AIPTEK_01 0x0001 | 39 | #define USB_DEVICE_ID_AIPTEK_01 0x0001 |
37 | #define USB_DEVICE_ID_AIPTEK_10 0x0010 | 40 | #define USB_DEVICE_ID_AIPTEK_10 0x0010 |
@@ -124,6 +127,9 @@ | |||
124 | #define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100 | 127 | #define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100 |
125 | #define USB_DEVICE_ID_DELORME_EM_LT20 0x0200 | 128 | #define USB_DEVICE_ID_DELORME_EM_LT20 0x0200 |
126 | 129 | ||
130 | #define USB_VENDOR_ID_DMI 0x0c0b | ||
131 | #define USB_DEVICE_ID_DMI_ENC 0x5fab | ||
132 | |||
127 | #define USB_VENDOR_ID_ELO 0x04E7 | 133 | #define USB_VENDOR_ID_ELO 0x04E7 |
128 | #define USB_DEVICE_ID_ELO_TS2700 0x0020 | 134 | #define USB_DEVICE_ID_ELO_TS2700 0x0020 |
129 | 135 | ||
@@ -199,17 +205,6 @@ | |||
199 | #define USB_DEVICE_ID_GTCO_502 0x0502 | 205 | #define USB_DEVICE_ID_GTCO_502 0x0502 |
200 | #define USB_DEVICE_ID_GTCO_503 0x0503 | 206 | #define USB_DEVICE_ID_GTCO_503 0x0503 |
201 | #define USB_DEVICE_ID_GTCO_504 0x0504 | 207 | #define USB_DEVICE_ID_GTCO_504 0x0504 |
202 | #define USB_DEVICE_ID_GTCO_600 0x0600 | ||
203 | #define USB_DEVICE_ID_GTCO_601 0x0601 | ||
204 | #define USB_DEVICE_ID_GTCO_602 0x0602 | ||
205 | #define USB_DEVICE_ID_GTCO_603 0x0603 | ||
206 | #define USB_DEVICE_ID_GTCO_604 0x0604 | ||
207 | #define USB_DEVICE_ID_GTCO_605 0x0605 | ||
208 | #define USB_DEVICE_ID_GTCO_606 0x0606 | ||
209 | #define USB_DEVICE_ID_GTCO_607 0x0607 | ||
210 | #define USB_DEVICE_ID_GTCO_608 0x0608 | ||
211 | #define USB_DEVICE_ID_GTCO_609 0x0609 | ||
212 | #define USB_DEVICE_ID_GTCO_609 0x0609 | ||
213 | #define USB_DEVICE_ID_GTCO_1000 0x1000 | 208 | #define USB_DEVICE_ID_GTCO_1000 0x1000 |
214 | #define USB_DEVICE_ID_GTCO_1001 0x1001 | 209 | #define USB_DEVICE_ID_GTCO_1001 0x1001 |
215 | #define USB_DEVICE_ID_GTCO_1002 0x1002 | 210 | #define USB_DEVICE_ID_GTCO_1002 0x1002 |
@@ -320,6 +315,7 @@ | |||
320 | #define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500 0xc512 | 315 | #define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500 0xc512 |
321 | #define USB_DEVICE_ID_MX3000_RECEIVER 0xc513 | 316 | #define USB_DEVICE_ID_MX3000_RECEIVER 0xc513 |
322 | #define USB_DEVICE_ID_DINOVO_EDGE 0xc714 | 317 | #define USB_DEVICE_ID_DINOVO_EDGE 0xc714 |
318 | #define USB_DEVICE_ID_DINOVO_MINI 0xc71f | ||
323 | 319 | ||
324 | #define USB_VENDOR_ID_MCC 0x09db | 320 | #define USB_VENDOR_ID_MCC 0x09db |
325 | #define USB_DEVICE_ID_MCC_PMD1024LS 0x0076 | 321 | #define USB_DEVICE_ID_MCC_PMD1024LS 0x0076 |
@@ -332,6 +328,7 @@ | |||
332 | #define USB_VENDOR_ID_MICROSOFT 0x045e | 328 | #define USB_VENDOR_ID_MICROSOFT 0x045e |
333 | #define USB_DEVICE_ID_SIDEWINDER_GV 0x003b | 329 | #define USB_DEVICE_ID_SIDEWINDER_GV 0x003b |
334 | #define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d | 330 | #define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d |
331 | #define USB_DEVICE_ID_DESKTOP_RECV_1028 0x00f9 | ||
335 | #define USB_DEVICE_ID_MS_NE4K 0x00db | 332 | #define USB_DEVICE_ID_MS_NE4K 0x00db |
336 | #define USB_DEVICE_ID_MS_LK6K 0x00f9 | 333 | #define USB_DEVICE_ID_MS_LK6K 0x00f9 |
337 | 334 | ||
@@ -377,6 +374,9 @@ | |||
377 | #define USB_VENDOR_ID_SUN 0x0430 | 374 | #define USB_VENDOR_ID_SUN 0x0430 |
378 | #define USB_DEVICE_ID_RARITAN_KVM_DONGLE 0xcdab | 375 | #define USB_DEVICE_ID_RARITAN_KVM_DONGLE 0xcdab |
379 | 376 | ||
377 | #define USB_VENDOR_ID_SUNPLUS 0x04fc | ||
378 | #define USB_DEVICE_ID_SUNPLUS_WDESKTOP 0x05d8 | ||
379 | |||
380 | #define USB_VENDOR_ID_TOPMAX 0x0663 | 380 | #define USB_VENDOR_ID_TOPMAX 0x0663 |
381 | #define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103 | 381 | #define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103 |
382 | 382 | ||
@@ -435,9 +435,13 @@ static const struct hid_blacklist { | |||
435 | { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD }, | 435 | { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD }, |
436 | 436 | ||
437 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE, HID_QUIRK_DUPLICATE_USAGES }, | 437 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE, HID_QUIRK_DUPLICATE_USAGES }, |
438 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI, HID_QUIRK_DUPLICATE_USAGES }, | ||
439 | |||
440 | { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL }, | ||
438 | 441 | ||
439 | { USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM, HID_QUIRK_HIDDEV }, | 442 | { USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM, HID_QUIRK_HIDDEV }, |
440 | { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT }, | 443 | { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT }, |
444 | { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT }, | ||
441 | { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV, HID_QUIRK_HIDINPUT }, | 445 | { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV, HID_QUIRK_HIDINPUT }, |
442 | 446 | ||
443 | { USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193, HID_QUIRK_HWHEEL_WHEEL_INVERT }, | 447 | { USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193, HID_QUIRK_HWHEEL_WHEEL_INVERT }, |
@@ -518,16 +522,6 @@ static const struct hid_blacklist { | |||
518 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502, HID_QUIRK_IGNORE }, | 522 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502, HID_QUIRK_IGNORE }, |
519 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503, HID_QUIRK_IGNORE }, | 523 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503, HID_QUIRK_IGNORE }, |
520 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504, HID_QUIRK_IGNORE }, | 524 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504, HID_QUIRK_IGNORE }, |
521 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_600, HID_QUIRK_IGNORE }, | ||
522 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_601, HID_QUIRK_IGNORE }, | ||
523 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_602, HID_QUIRK_IGNORE }, | ||
524 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_603, HID_QUIRK_IGNORE }, | ||
525 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_604, HID_QUIRK_IGNORE }, | ||
526 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_605, HID_QUIRK_IGNORE }, | ||
527 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_606, HID_QUIRK_IGNORE }, | ||
528 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_607, HID_QUIRK_IGNORE }, | ||
529 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_608, HID_QUIRK_IGNORE }, | ||
530 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_609, HID_QUIRK_IGNORE }, | ||
531 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000, HID_QUIRK_IGNORE }, | 525 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000, HID_QUIRK_IGNORE }, |
532 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001, HID_QUIRK_IGNORE }, | 526 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001, HID_QUIRK_IGNORE }, |
533 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002, HID_QUIRK_IGNORE }, | 527 | { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002, HID_QUIRK_IGNORE }, |
@@ -601,6 +595,7 @@ static const struct hid_blacklist { | |||
601 | { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET }, | 595 | { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET }, |
602 | { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET }, | 596 | { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET }, |
603 | { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET }, | 597 | { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET }, |
598 | { USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET }, | ||
604 | { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET }, | 599 | { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET }, |
605 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D, HID_QUIRK_NOGET }, | 600 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D, HID_QUIRK_NOGET }, |
606 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL, HID_QUIRK_NOGET }, | 601 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL, HID_QUIRK_NOGET }, |
@@ -608,7 +603,7 @@ static const struct hid_blacklist { | |||
608 | { USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_NOGET }, | 603 | { USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_NOGET }, |
609 | { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET }, | 604 | { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET }, |
610 | { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET }, | 605 | { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET }, |
611 | { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, | 606 | { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS }, |
612 | { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, | 607 | { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, |
613 | 608 | ||
614 | { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, | 609 | { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, |
@@ -719,6 +714,7 @@ static const struct hid_rdesc_blacklist { | |||
719 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER, HID_QUIRK_RDESC_LOGITECH }, | 714 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER, HID_QUIRK_RDESC_LOGITECH }, |
720 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER, HID_QUIRK_RDESC_LOGITECH }, | 715 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER, HID_QUIRK_RDESC_LOGITECH }, |
721 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2, HID_QUIRK_RDESC_LOGITECH }, | 716 | { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2, HID_QUIRK_RDESC_LOGITECH }, |
717 | { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_DESKTOP_RECV_1028, HID_QUIRK_RDESC_MICROSOFT_RECV_1028 }, | ||
722 | 718 | ||
723 | { USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E, HID_QUIRK_RDESC_BUTTON_CONSUMER }, | 719 | { USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E, HID_QUIRK_RDESC_BUTTON_CONSUMER }, |
724 | 720 | ||
@@ -728,6 +724,8 @@ static const struct hid_rdesc_blacklist { | |||
728 | 724 | ||
729 | { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_RDESC_SAMSUNG_REMOTE }, | 725 | { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_RDESC_SAMSUNG_REMOTE }, |
730 | 726 | ||
727 | { USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP, HID_QUIRK_RDESC_SUNPLUS_WDESKTOP }, | ||
728 | |||
731 | { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1, HID_QUIRK_RDESC_SWAPPED_MIN_MAX }, | 729 | { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1, HID_QUIRK_RDESC_SWAPPED_MIN_MAX }, |
732 | { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2, HID_QUIRK_RDESC_SWAPPED_MIN_MAX }, | 730 | { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2, HID_QUIRK_RDESC_SWAPPED_MIN_MAX }, |
733 | 731 | ||
@@ -793,8 +791,8 @@ static struct hid_blacklist *usbhid_exists_dquirk(const u16 idVendor, | |||
793 | * | 791 | * |
794 | * Returns: 0 OK, -error on failure. | 792 | * Returns: 0 OK, -error on failure. |
795 | */ | 793 | */ |
796 | int usbhid_modify_dquirk(const u16 idVendor, const u16 idProduct, | 794 | static int usbhid_modify_dquirk(const u16 idVendor, const u16 idProduct, |
797 | const u32 quirks) | 795 | const u32 quirks) |
798 | { | 796 | { |
799 | struct quirks_list_struct *q_new, *q; | 797 | struct quirks_list_struct *q_new, *q; |
800 | int list_edited = 0; | 798 | int list_edited = 0; |
@@ -1002,6 +1000,17 @@ static void usbhid_fixup_logitech_descriptor(unsigned char *rdesc, int rsize) | |||
1002 | } | 1000 | } |
1003 | } | 1001 | } |
1004 | 1002 | ||
1003 | static void usbhid_fixup_sunplus_wdesktop(unsigned char *rdesc, int rsize) | ||
1004 | { | ||
1005 | if (rsize >= 107 && rdesc[104] == 0x26 | ||
1006 | && rdesc[105] == 0x80 | ||
1007 | && rdesc[106] == 0x03) { | ||
1008 | printk(KERN_INFO "Fixing up Sunplus Wireless Desktop report descriptor\n"); | ||
1009 | rdesc[105] = rdesc[110] = 0x03; | ||
1010 | rdesc[106] = rdesc[111] = 0x21; | ||
1011 | } | ||
1012 | } | ||
1013 | |||
1005 | /* | 1014 | /* |
1006 | * Samsung IrDA remote controller (reports as Cypress USB Mouse). | 1015 | * Samsung IrDA remote controller (reports as Cypress USB Mouse). |
1007 | * | 1016 | * |
@@ -1089,6 +1098,28 @@ static void usbhid_fixup_button_consumer_descriptor(unsigned char *rdesc, int rs | |||
1089 | } | 1098 | } |
1090 | } | 1099 | } |
1091 | 1100 | ||
1101 | /* | ||
1102 | * Microsoft Wireless Desktop Receiver (Model 1028) has several | ||
1103 | * 'Usage Min/Max' where it ought to have 'Physical Min/Max' | ||
1104 | */ | ||
1105 | static void usbhid_fixup_microsoft_descriptor(unsigned char *rdesc, int rsize) | ||
1106 | { | ||
1107 | if (rsize == 571 && rdesc[284] == 0x19 | ||
1108 | && rdesc[286] == 0x2a | ||
1109 | && rdesc[304] == 0x19 | ||
1110 | && rdesc[306] == 0x29 | ||
1111 | && rdesc[352] == 0x1a | ||
1112 | && rdesc[355] == 0x2a | ||
1113 | && rdesc[557] == 0x19 | ||
1114 | && rdesc[559] == 0x29) { | ||
1115 | printk(KERN_INFO "Fixing up Microsoft Wireless Receiver Model 1028 report descriptor\n"); | ||
1116 | rdesc[284] = rdesc[304] = rdesc[558] = 0x35; | ||
1117 | rdesc[352] = 0x36; | ||
1118 | rdesc[286] = rdesc[355] = 0x46; | ||
1119 | rdesc[306] = rdesc[559] = 0x45; | ||
1120 | } | ||
1121 | } | ||
1122 | |||
1092 | static void __usbhid_fixup_report_descriptor(__u32 quirks, char *rdesc, unsigned rsize) | 1123 | static void __usbhid_fixup_report_descriptor(__u32 quirks, char *rdesc, unsigned rsize) |
1093 | { | 1124 | { |
1094 | if ((quirks & HID_QUIRK_RDESC_CYMOTION)) | 1125 | if ((quirks & HID_QUIRK_RDESC_CYMOTION)) |
@@ -1112,6 +1143,11 @@ static void __usbhid_fixup_report_descriptor(__u32 quirks, char *rdesc, unsigned | |||
1112 | if (quirks & HID_QUIRK_RDESC_SAMSUNG_REMOTE) | 1143 | if (quirks & HID_QUIRK_RDESC_SAMSUNG_REMOTE) |
1113 | usbhid_fixup_samsung_irda_descriptor(rdesc, rsize); | 1144 | usbhid_fixup_samsung_irda_descriptor(rdesc, rsize); |
1114 | 1145 | ||
1146 | if (quirks & HID_QUIRK_RDESC_MICROSOFT_RECV_1028) | ||
1147 | usbhid_fixup_microsoft_descriptor(rdesc, rsize); | ||
1148 | |||
1149 | if (quirks & HID_QUIRK_RDESC_SUNPLUS_WDESKTOP) | ||
1150 | usbhid_fixup_sunplus_wdesktop(rdesc, rsize); | ||
1115 | } | 1151 | } |
1116 | 1152 | ||
1117 | /** | 1153 | /** |
@@ -1150,5 +1186,4 @@ void usbhid_fixup_report_descriptor(const u16 idVendor, const u16 idProduct, | |||
1150 | else if (paramVendor == idVendor && paramProduct == idProduct) | 1186 | else if (paramVendor == idVendor && paramProduct == idProduct) |
1151 | __usbhid_fixup_report_descriptor(quirks, rdesc, rsize); | 1187 | __usbhid_fixup_report_descriptor(quirks, rdesc, rsize); |
1152 | } | 1188 | } |
1153 | |||
1154 | } | 1189 | } |
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c index 5fc4019956ba..95cc192bc7af 100644 --- a/drivers/hid/usbhid/hiddev.c +++ b/drivers/hid/usbhid/hiddev.c | |||
@@ -393,6 +393,153 @@ static unsigned int hiddev_poll(struct file *file, poll_table *wait) | |||
393 | /* | 393 | /* |
394 | * "ioctl" file op | 394 | * "ioctl" file op |
395 | */ | 395 | */ |
396 | static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg) | ||
397 | { | ||
398 | struct hid_device *hid = hiddev->hid; | ||
399 | struct hiddev_report_info rinfo; | ||
400 | struct hiddev_usage_ref_multi *uref_multi = NULL; | ||
401 | struct hiddev_usage_ref *uref; | ||
402 | struct hid_report *report; | ||
403 | struct hid_field *field; | ||
404 | int i; | ||
405 | |||
406 | uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL); | ||
407 | if (!uref_multi) | ||
408 | return -ENOMEM; | ||
409 | uref = &uref_multi->uref; | ||
410 | if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) { | ||
411 | if (copy_from_user(uref_multi, user_arg, | ||
412 | sizeof(*uref_multi))) | ||
413 | goto fault; | ||
414 | } else { | ||
415 | if (copy_from_user(uref, user_arg, sizeof(*uref))) | ||
416 | goto fault; | ||
417 | } | ||
418 | |||
419 | switch (cmd) { | ||
420 | case HIDIOCGUCODE: | ||
421 | rinfo.report_type = uref->report_type; | ||
422 | rinfo.report_id = uref->report_id; | ||
423 | if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) | ||
424 | goto inval; | ||
425 | |||
426 | if (uref->field_index >= report->maxfield) | ||
427 | goto inval; | ||
428 | |||
429 | field = report->field[uref->field_index]; | ||
430 | if (uref->usage_index >= field->maxusage) | ||
431 | goto inval; | ||
432 | |||
433 | uref->usage_code = field->usage[uref->usage_index].hid; | ||
434 | |||
435 | if (copy_to_user(user_arg, uref, sizeof(*uref))) | ||
436 | goto fault; | ||
437 | |||
438 | kfree(uref_multi); | ||
439 | return 0; | ||
440 | |||
441 | default: | ||
442 | if (cmd != HIDIOCGUSAGE && | ||
443 | cmd != HIDIOCGUSAGES && | ||
444 | uref->report_type == HID_REPORT_TYPE_INPUT) | ||
445 | goto inval; | ||
446 | |||
447 | if (uref->report_id == HID_REPORT_ID_UNKNOWN) { | ||
448 | field = hiddev_lookup_usage(hid, uref); | ||
449 | if (field == NULL) | ||
450 | goto inval; | ||
451 | } else { | ||
452 | rinfo.report_type = uref->report_type; | ||
453 | rinfo.report_id = uref->report_id; | ||
454 | if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) | ||
455 | goto inval; | ||
456 | |||
457 | if (uref->field_index >= report->maxfield) | ||
458 | goto inval; | ||
459 | |||
460 | field = report->field[uref->field_index]; | ||
461 | |||
462 | if (cmd == HIDIOCGCOLLECTIONINDEX) { | ||
463 | if (uref->usage_index >= field->maxusage) | ||
464 | goto inval; | ||
465 | } else if (uref->usage_index >= field->report_count) | ||
466 | goto inval; | ||
467 | |||
468 | else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) && | ||
469 | (uref_multi->num_values > HID_MAX_MULTI_USAGES || | ||
470 | uref->usage_index + uref_multi->num_values > field->report_count)) | ||
471 | goto inval; | ||
472 | } | ||
473 | |||
474 | switch (cmd) { | ||
475 | case HIDIOCGUSAGE: | ||
476 | uref->value = field->value[uref->usage_index]; | ||
477 | if (copy_to_user(user_arg, uref, sizeof(*uref))) | ||
478 | goto fault; | ||
479 | goto goodreturn; | ||
480 | |||
481 | case HIDIOCSUSAGE: | ||
482 | field->value[uref->usage_index] = uref->value; | ||
483 | goto goodreturn; | ||
484 | |||
485 | case HIDIOCGCOLLECTIONINDEX: | ||
486 | kfree(uref_multi); | ||
487 | return field->usage[uref->usage_index].collection_index; | ||
488 | case HIDIOCGUSAGES: | ||
489 | for (i = 0; i < uref_multi->num_values; i++) | ||
490 | uref_multi->values[i] = | ||
491 | field->value[uref->usage_index + i]; | ||
492 | if (copy_to_user(user_arg, uref_multi, | ||
493 | sizeof(*uref_multi))) | ||
494 | goto fault; | ||
495 | goto goodreturn; | ||
496 | case HIDIOCSUSAGES: | ||
497 | for (i = 0; i < uref_multi->num_values; i++) | ||
498 | field->value[uref->usage_index + i] = | ||
499 | uref_multi->values[i]; | ||
500 | goto goodreturn; | ||
501 | } | ||
502 | |||
503 | goodreturn: | ||
504 | kfree(uref_multi); | ||
505 | return 0; | ||
506 | fault: | ||
507 | kfree(uref_multi); | ||
508 | return -EFAULT; | ||
509 | inval: | ||
510 | kfree(uref_multi); | ||
511 | return -EINVAL; | ||
512 | } | ||
513 | } | ||
514 | |||
515 | static noinline int hiddev_ioctl_string(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg) | ||
516 | { | ||
517 | struct hid_device *hid = hiddev->hid; | ||
518 | struct usb_device *dev = hid_to_usb_dev(hid); | ||
519 | int idx, len; | ||
520 | char *buf; | ||
521 | |||
522 | if (get_user(idx, (int __user *)user_arg)) | ||
523 | return -EFAULT; | ||
524 | |||
525 | if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL) | ||
526 | return -ENOMEM; | ||
527 | |||
528 | if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) { | ||
529 | kfree(buf); | ||
530 | return -EINVAL; | ||
531 | } | ||
532 | |||
533 | if (copy_to_user(user_arg+sizeof(int), buf, len+1)) { | ||
534 | kfree(buf); | ||
535 | return -EFAULT; | ||
536 | } | ||
537 | |||
538 | kfree(buf); | ||
539 | |||
540 | return len; | ||
541 | } | ||
542 | |||
396 | static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) | 543 | static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) |
397 | { | 544 | { |
398 | struct hiddev_list *list = file->private_data; | 545 | struct hiddev_list *list = file->private_data; |
@@ -402,8 +549,6 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd | |||
402 | struct hiddev_collection_info cinfo; | 549 | struct hiddev_collection_info cinfo; |
403 | struct hiddev_report_info rinfo; | 550 | struct hiddev_report_info rinfo; |
404 | struct hiddev_field_info finfo; | 551 | struct hiddev_field_info finfo; |
405 | struct hiddev_usage_ref_multi *uref_multi = NULL; | ||
406 | struct hiddev_usage_ref *uref; | ||
407 | struct hiddev_devinfo dinfo; | 552 | struct hiddev_devinfo dinfo; |
408 | struct hid_report *report; | 553 | struct hid_report *report; |
409 | struct hid_field *field; | 554 | struct hid_field *field; |
@@ -470,30 +615,7 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd | |||
470 | } | 615 | } |
471 | 616 | ||
472 | case HIDIOCGSTRING: | 617 | case HIDIOCGSTRING: |
473 | { | 618 | return hiddev_ioctl_string(hiddev, cmd, user_arg); |
474 | int idx, len; | ||
475 | char *buf; | ||
476 | |||
477 | if (get_user(idx, (int __user *)arg)) | ||
478 | return -EFAULT; | ||
479 | |||
480 | if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL) | ||
481 | return -ENOMEM; | ||
482 | |||
483 | if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) { | ||
484 | kfree(buf); | ||
485 | return -EINVAL; | ||
486 | } | ||
487 | |||
488 | if (copy_to_user(user_arg+sizeof(int), buf, len+1)) { | ||
489 | kfree(buf); | ||
490 | return -EFAULT; | ||
491 | } | ||
492 | |||
493 | kfree(buf); | ||
494 | |||
495 | return len; | ||
496 | } | ||
497 | 619 | ||
498 | case HIDIOCINITREPORT: | 620 | case HIDIOCINITREPORT: |
499 | usbhid_init_reports(hid); | 621 | usbhid_init_reports(hid); |
@@ -578,121 +700,13 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd | |||
578 | return 0; | 700 | return 0; |
579 | 701 | ||
580 | case HIDIOCGUCODE: | 702 | case HIDIOCGUCODE: |
581 | uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL); | 703 | /* fall through */ |
582 | if (!uref_multi) | ||
583 | return -ENOMEM; | ||
584 | uref = &uref_multi->uref; | ||
585 | if (copy_from_user(uref, user_arg, sizeof(*uref))) | ||
586 | goto fault; | ||
587 | |||
588 | rinfo.report_type = uref->report_type; | ||
589 | rinfo.report_id = uref->report_id; | ||
590 | if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) | ||
591 | goto inval; | ||
592 | |||
593 | if (uref->field_index >= report->maxfield) | ||
594 | goto inval; | ||
595 | |||
596 | field = report->field[uref->field_index]; | ||
597 | if (uref->usage_index >= field->maxusage) | ||
598 | goto inval; | ||
599 | |||
600 | uref->usage_code = field->usage[uref->usage_index].hid; | ||
601 | |||
602 | if (copy_to_user(user_arg, uref, sizeof(*uref))) | ||
603 | goto fault; | ||
604 | |||
605 | kfree(uref_multi); | ||
606 | return 0; | ||
607 | |||
608 | case HIDIOCGUSAGE: | 704 | case HIDIOCGUSAGE: |
609 | case HIDIOCSUSAGE: | 705 | case HIDIOCSUSAGE: |
610 | case HIDIOCGUSAGES: | 706 | case HIDIOCGUSAGES: |
611 | case HIDIOCSUSAGES: | 707 | case HIDIOCSUSAGES: |
612 | case HIDIOCGCOLLECTIONINDEX: | 708 | case HIDIOCGCOLLECTIONINDEX: |
613 | uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL); | 709 | return hiddev_ioctl_usage(hiddev, cmd, user_arg); |
614 | if (!uref_multi) | ||
615 | return -ENOMEM; | ||
616 | uref = &uref_multi->uref; | ||
617 | if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) { | ||
618 | if (copy_from_user(uref_multi, user_arg, | ||
619 | sizeof(*uref_multi))) | ||
620 | goto fault; | ||
621 | } else { | ||
622 | if (copy_from_user(uref, user_arg, sizeof(*uref))) | ||
623 | goto fault; | ||
624 | } | ||
625 | |||
626 | if (cmd != HIDIOCGUSAGE && | ||
627 | cmd != HIDIOCGUSAGES && | ||
628 | uref->report_type == HID_REPORT_TYPE_INPUT) | ||
629 | goto inval; | ||
630 | |||
631 | if (uref->report_id == HID_REPORT_ID_UNKNOWN) { | ||
632 | field = hiddev_lookup_usage(hid, uref); | ||
633 | if (field == NULL) | ||
634 | goto inval; | ||
635 | } else { | ||
636 | rinfo.report_type = uref->report_type; | ||
637 | rinfo.report_id = uref->report_id; | ||
638 | if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) | ||
639 | goto inval; | ||
640 | |||
641 | if (uref->field_index >= report->maxfield) | ||
642 | goto inval; | ||
643 | |||
644 | field = report->field[uref->field_index]; | ||
645 | |||
646 | if (cmd == HIDIOCGCOLLECTIONINDEX) { | ||
647 | if (uref->usage_index >= field->maxusage) | ||
648 | goto inval; | ||
649 | } else if (uref->usage_index >= field->report_count) | ||
650 | goto inval; | ||
651 | |||
652 | else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) && | ||
653 | (uref_multi->num_values > HID_MAX_MULTI_USAGES || | ||
654 | uref->usage_index + uref_multi->num_values > field->report_count)) | ||
655 | goto inval; | ||
656 | } | ||
657 | |||
658 | switch (cmd) { | ||
659 | case HIDIOCGUSAGE: | ||
660 | uref->value = field->value[uref->usage_index]; | ||
661 | if (copy_to_user(user_arg, uref, sizeof(*uref))) | ||
662 | goto fault; | ||
663 | goto goodreturn; | ||
664 | |||
665 | case HIDIOCSUSAGE: | ||
666 | field->value[uref->usage_index] = uref->value; | ||
667 | goto goodreturn; | ||
668 | |||
669 | case HIDIOCGCOLLECTIONINDEX: | ||
670 | kfree(uref_multi); | ||
671 | return field->usage[uref->usage_index].collection_index; | ||
672 | case HIDIOCGUSAGES: | ||
673 | for (i = 0; i < uref_multi->num_values; i++) | ||
674 | uref_multi->values[i] = | ||
675 | field->value[uref->usage_index + i]; | ||
676 | if (copy_to_user(user_arg, uref_multi, | ||
677 | sizeof(*uref_multi))) | ||
678 | goto fault; | ||
679 | goto goodreturn; | ||
680 | case HIDIOCSUSAGES: | ||
681 | for (i = 0; i < uref_multi->num_values; i++) | ||
682 | field->value[uref->usage_index + i] = | ||
683 | uref_multi->values[i]; | ||
684 | goto goodreturn; | ||
685 | } | ||
686 | |||
687 | goodreturn: | ||
688 | kfree(uref_multi); | ||
689 | return 0; | ||
690 | fault: | ||
691 | kfree(uref_multi); | ||
692 | return -EFAULT; | ||
693 | inval: | ||
694 | kfree(uref_multi); | ||
695 | return -EINVAL; | ||
696 | 710 | ||
697 | case HIDIOCGCOLLECTIONINFO: | 711 | case HIDIOCGCOLLECTIONINFO: |
698 | if (copy_from_user(&cinfo, user_arg, sizeof(cinfo))) | 712 | if (copy_from_user(&cinfo, user_arg, sizeof(cinfo))) |
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h index 0023f96d4294..62d2d7c925bd 100644 --- a/drivers/hid/usbhid/usbhid.h +++ b/drivers/hid/usbhid/usbhid.h | |||
@@ -28,6 +28,7 @@ | |||
28 | #include <linux/slab.h> | 28 | #include <linux/slab.h> |
29 | #include <linux/list.h> | 29 | #include <linux/list.h> |
30 | #include <linux/timer.h> | 30 | #include <linux/timer.h> |
31 | #include <linux/wait.h> | ||
31 | #include <linux/workqueue.h> | 32 | #include <linux/workqueue.h> |
32 | #include <linux/input.h> | 33 | #include <linux/input.h> |
33 | 34 | ||
@@ -77,7 +78,7 @@ struct usbhid_device { | |||
77 | unsigned long stop_retry; /* Time to give up, in jiffies */ | 78 | unsigned long stop_retry; /* Time to give up, in jiffies */ |
78 | unsigned int retry_delay; /* Delay length in ms */ | 79 | unsigned int retry_delay; /* Delay length in ms */ |
79 | struct work_struct reset_work; /* Task context for resets */ | 80 | struct work_struct reset_work; /* Task context for resets */ |
80 | 81 | wait_queue_head_t wait; /* For sleeping */ | |
81 | }; | 82 | }; |
82 | 83 | ||
83 | #define hid_to_usb_dev(hid_dev) \ | 84 | #define hid_to_usb_dev(hid_dev) \ |
diff --git a/drivers/i2c/algos/Kconfig b/drivers/i2c/algos/Kconfig index 014dfa575be7..7137a17402fe 100644 --- a/drivers/i2c/algos/Kconfig +++ b/drivers/i2c/algos/Kconfig | |||
@@ -1,45 +1,16 @@ | |||
1 | # | 1 | # |
2 | # Character device configuration | 2 | # I2C algorithm drivers configuration |
3 | # | 3 | # |
4 | 4 | ||
5 | menu "I2C Algorithms" | ||
6 | |||
7 | config I2C_ALGOBIT | 5 | config I2C_ALGOBIT |
8 | tristate "I2C bit-banging interfaces" | 6 | tristate |
9 | help | ||
10 | This allows you to use a range of I2C adapters called bit-banging | ||
11 | adapters. Say Y if you own an I2C adapter belonging to this class | ||
12 | and then say Y to the specific driver for you adapter below. | ||
13 | |||
14 | This support is also available as a module. If so, the module | ||
15 | will be called i2c-algo-bit. | ||
16 | 7 | ||
17 | config I2C_ALGOPCF | 8 | config I2C_ALGOPCF |
18 | tristate "I2C PCF 8584 interfaces" | 9 | tristate |
19 | help | ||
20 | This allows you to use a range of I2C adapters called PCF adapters. | ||
21 | Say Y if you own an I2C adapter belonging to this class and then say | ||
22 | Y to the specific driver for you adapter below. | ||
23 | |||
24 | This support is also available as a module. If so, the module | ||
25 | will be called i2c-algo-pcf. | ||
26 | 10 | ||
27 | config I2C_ALGOPCA | 11 | config I2C_ALGOPCA |
28 | tristate "I2C PCA 9564 interfaces" | 12 | tristate |
29 | help | ||
30 | This allows you to use a range of I2C adapters called PCA adapters. | ||
31 | Say Y if you own an I2C adapter belonging to this class and then say | ||
32 | Y to the specific driver for you adapter below. | ||
33 | |||
34 | This support is also available as a module. If so, the module | ||
35 | will be called i2c-algo-pca. | ||
36 | 13 | ||
37 | config I2C_ALGO_SGI | 14 | config I2C_ALGO_SGI |
38 | tristate "I2C SGI interfaces" | 15 | tristate |
39 | depends on SGI_IP22 || SGI_IP32 || X86_VISWS | 16 | depends on SGI_IP22 || SGI_IP32 || X86_VISWS |
40 | help | ||
41 | Supports the SGI interfaces like the ones found on SGI Indy VINO | ||
42 | or SGI O2 MACE. | ||
43 | |||
44 | endmenu | ||
45 | |||
diff --git a/drivers/i2c/algos/i2c-algo-pca.c b/drivers/i2c/algos/i2c-algo-pca.c index 2a16211f12e5..e954a20b97a6 100644 --- a/drivers/i2c/algos/i2c-algo-pca.c +++ b/drivers/i2c/algos/i2c-algo-pca.c | |||
@@ -1,6 +1,7 @@ | |||
1 | /* | 1 | /* |
2 | * i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters | 2 | * i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters |
3 | * Copyright (C) 2004 Arcom Control Systems | 3 | * Copyright (C) 2004 Arcom Control Systems |
4 | * Copyright (C) 2008 Pengutronix | ||
4 | * | 5 | * |
5 | * This program is free software; you can redistribute it and/or modify | 6 | * This program is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License as published by | 7 | * it under the terms of the GNU General Public License as published by |
@@ -21,14 +22,10 @@ | |||
21 | #include <linux/module.h> | 22 | #include <linux/module.h> |
22 | #include <linux/moduleparam.h> | 23 | #include <linux/moduleparam.h> |
23 | #include <linux/delay.h> | 24 | #include <linux/delay.h> |
24 | #include <linux/slab.h> | ||
25 | #include <linux/init.h> | 25 | #include <linux/init.h> |
26 | #include <linux/errno.h> | 26 | #include <linux/errno.h> |
27 | #include <linux/i2c.h> | 27 | #include <linux/i2c.h> |
28 | #include <linux/i2c-algo-pca.h> | 28 | #include <linux/i2c-algo-pca.h> |
29 | #include "i2c-algo-pca.h" | ||
30 | |||
31 | #define DRIVER "i2c-algo-pca" | ||
32 | 29 | ||
33 | #define DEB1(fmt, args...) do { if (i2c_debug>=1) printk(fmt, ## args); } while(0) | 30 | #define DEB1(fmt, args...) do { if (i2c_debug>=1) printk(fmt, ## args); } while(0) |
34 | #define DEB2(fmt, args...) do { if (i2c_debug>=2) printk(fmt, ## args); } while(0) | 31 | #define DEB2(fmt, args...) do { if (i2c_debug>=2) printk(fmt, ## args); } while(0) |
@@ -36,15 +33,15 @@ | |||
36 | 33 | ||
37 | static int i2c_debug; | 34 | static int i2c_debug; |
38 | 35 | ||
39 | #define pca_outw(adap, reg, val) adap->write_byte(adap, reg, val) | 36 | #define pca_outw(adap, reg, val) adap->write_byte(adap->data, reg, val) |
40 | #define pca_inw(adap, reg) adap->read_byte(adap, reg) | 37 | #define pca_inw(adap, reg) adap->read_byte(adap->data, reg) |
41 | 38 | ||
42 | #define pca_status(adap) pca_inw(adap, I2C_PCA_STA) | 39 | #define pca_status(adap) pca_inw(adap, I2C_PCA_STA) |
43 | #define pca_clock(adap) adap->get_clock(adap) | 40 | #define pca_clock(adap) adap->i2c_clock |
44 | #define pca_own(adap) adap->get_own(adap) | ||
45 | #define pca_set_con(adap, val) pca_outw(adap, I2C_PCA_CON, val) | 41 | #define pca_set_con(adap, val) pca_outw(adap, I2C_PCA_CON, val) |
46 | #define pca_get_con(adap) pca_inw(adap, I2C_PCA_CON) | 42 | #define pca_get_con(adap) pca_inw(adap, I2C_PCA_CON) |
47 | #define pca_wait(adap) adap->wait_for_interrupt(adap) | 43 | #define pca_wait(adap) adap->wait_for_completion(adap->data) |
44 | #define pca_reset(adap) adap->reset_chip(adap->data) | ||
48 | 45 | ||
49 | /* | 46 | /* |
50 | * Generate a start condition on the i2c bus. | 47 | * Generate a start condition on the i2c bus. |
@@ -99,7 +96,7 @@ static void pca_stop(struct i2c_algo_pca_data *adap) | |||
99 | * | 96 | * |
100 | * returns after the address has been sent | 97 | * returns after the address has been sent |
101 | */ | 98 | */ |
102 | static void pca_address(struct i2c_algo_pca_data *adap, | 99 | static void pca_address(struct i2c_algo_pca_data *adap, |
103 | struct i2c_msg *msg) | 100 | struct i2c_msg *msg) |
104 | { | 101 | { |
105 | int sta = pca_get_con(adap); | 102 | int sta = pca_get_con(adap); |
@@ -108,9 +105,9 @@ static void pca_address(struct i2c_algo_pca_data *adap, | |||
108 | addr = ( (0x7f & msg->addr) << 1 ); | 105 | addr = ( (0x7f & msg->addr) << 1 ); |
109 | if (msg->flags & I2C_M_RD ) | 106 | if (msg->flags & I2C_M_RD ) |
110 | addr |= 1; | 107 | addr |= 1; |
111 | DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n", | 108 | DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n", |
112 | msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr); | 109 | msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr); |
113 | 110 | ||
114 | pca_outw(adap, I2C_PCA_DAT, addr); | 111 | pca_outw(adap, I2C_PCA_DAT, addr); |
115 | 112 | ||
116 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); | 113 | sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); |
@@ -124,7 +121,7 @@ static void pca_address(struct i2c_algo_pca_data *adap, | |||
124 | * | 121 | * |
125 | * Returns after the byte has been transmitted | 122 | * Returns after the byte has been transmitted |
126 | */ | 123 | */ |
127 | static void pca_tx_byte(struct i2c_algo_pca_data *adap, | 124 | static void pca_tx_byte(struct i2c_algo_pca_data *adap, |
128 | __u8 b) | 125 | __u8 b) |
129 | { | 126 | { |
130 | int sta = pca_get_con(adap); | 127 | int sta = pca_get_con(adap); |
@@ -142,19 +139,19 @@ static void pca_tx_byte(struct i2c_algo_pca_data *adap, | |||
142 | * | 139 | * |
143 | * returns immediately. | 140 | * returns immediately. |
144 | */ | 141 | */ |
145 | static void pca_rx_byte(struct i2c_algo_pca_data *adap, | 142 | static void pca_rx_byte(struct i2c_algo_pca_data *adap, |
146 | __u8 *b, int ack) | 143 | __u8 *b, int ack) |
147 | { | 144 | { |
148 | *b = pca_inw(adap, I2C_PCA_DAT); | 145 | *b = pca_inw(adap, I2C_PCA_DAT); |
149 | DEB2("=== READ %#04x %s\n", *b, ack ? "ACK" : "NACK"); | 146 | DEB2("=== READ %#04x %s\n", *b, ack ? "ACK" : "NACK"); |
150 | } | 147 | } |
151 | 148 | ||
152 | /* | 149 | /* |
153 | * Setup ACK or NACK for next received byte and wait for it to arrive. | 150 | * Setup ACK or NACK for next received byte and wait for it to arrive. |
154 | * | 151 | * |
155 | * Returns after next byte has arrived. | 152 | * Returns after next byte has arrived. |
156 | */ | 153 | */ |
157 | static void pca_rx_ack(struct i2c_algo_pca_data *adap, | 154 | static void pca_rx_ack(struct i2c_algo_pca_data *adap, |
158 | int ack) | 155 | int ack) |
159 | { | 156 | { |
160 | int sta = pca_get_con(adap); | 157 | int sta = pca_get_con(adap); |
@@ -168,15 +165,6 @@ static void pca_rx_ack(struct i2c_algo_pca_data *adap, | |||
168 | pca_wait(adap); | 165 | pca_wait(adap); |
169 | } | 166 | } |
170 | 167 | ||
171 | /* | ||
172 | * Reset the i2c bus / SIO | ||
173 | */ | ||
174 | static void pca_reset(struct i2c_algo_pca_data *adap) | ||
175 | { | ||
176 | /* apparently only an external reset will do it. not a lot can be done */ | ||
177 | printk(KERN_ERR DRIVER ": Haven't figured out how to do a reset yet\n"); | ||
178 | } | ||
179 | |||
180 | static int pca_xfer(struct i2c_adapter *i2c_adap, | 168 | static int pca_xfer(struct i2c_adapter *i2c_adap, |
181 | struct i2c_msg *msgs, | 169 | struct i2c_msg *msgs, |
182 | int num) | 170 | int num) |
@@ -187,7 +175,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap, | |||
187 | int numbytes = 0; | 175 | int numbytes = 0; |
188 | int state; | 176 | int state; |
189 | int ret; | 177 | int ret; |
190 | int timeout = 100; | 178 | int timeout = i2c_adap->timeout; |
191 | 179 | ||
192 | while ((state = pca_status(adap)) != 0xf8 && timeout--) { | 180 | while ((state = pca_status(adap)) != 0xf8 && timeout--) { |
193 | msleep(10); | 181 | msleep(10); |
@@ -203,14 +191,14 @@ static int pca_xfer(struct i2c_adapter *i2c_adap, | |||
203 | for (curmsg = 0; curmsg < num; curmsg++) { | 191 | for (curmsg = 0; curmsg < num; curmsg++) { |
204 | int addr, i; | 192 | int addr, i; |
205 | msg = &msgs[curmsg]; | 193 | msg = &msgs[curmsg]; |
206 | 194 | ||
207 | addr = (0x7f & msg->addr) ; | 195 | addr = (0x7f & msg->addr) ; |
208 | 196 | ||
209 | if (msg->flags & I2C_M_RD ) | 197 | if (msg->flags & I2C_M_RD ) |
210 | printk(KERN_INFO " [%02d] RD %d bytes from %#02x [%#02x, ...]\n", | 198 | printk(KERN_INFO " [%02d] RD %d bytes from %#02x [%#02x, ...]\n", |
211 | curmsg, msg->len, addr, (addr<<1) | 1); | 199 | curmsg, msg->len, addr, (addr<<1) | 1); |
212 | else { | 200 | else { |
213 | printk(KERN_INFO " [%02d] WR %d bytes to %#02x [%#02x%s", | 201 | printk(KERN_INFO " [%02d] WR %d bytes to %#02x [%#02x%s", |
214 | curmsg, msg->len, addr, addr<<1, | 202 | curmsg, msg->len, addr, addr<<1, |
215 | msg->len == 0 ? "" : ", "); | 203 | msg->len == 0 ? "" : ", "); |
216 | for(i=0; i < msg->len; i++) | 204 | for(i=0; i < msg->len; i++) |
@@ -237,7 +225,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap, | |||
237 | case 0x10: /* A repeated start condition has been transmitted */ | 225 | case 0x10: /* A repeated start condition has been transmitted */ |
238 | pca_address(adap, msg); | 226 | pca_address(adap, msg); |
239 | break; | 227 | break; |
240 | 228 | ||
241 | case 0x18: /* SLA+W has been transmitted; ACK has been received */ | 229 | case 0x18: /* SLA+W has been transmitted; ACK has been received */ |
242 | case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */ | 230 | case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */ |
243 | if (numbytes < msg->len) { | 231 | if (numbytes < msg->len) { |
@@ -287,7 +275,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap, | |||
287 | case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */ | 275 | case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */ |
288 | DEB2("Arbitration lost\n"); | 276 | DEB2("Arbitration lost\n"); |
289 | goto out; | 277 | goto out; |
290 | 278 | ||
291 | case 0x58: /* Data byte has been received; NOT ACK has been returned */ | 279 | case 0x58: /* Data byte has been received; NOT ACK has been returned */ |
292 | if ( numbytes == msg->len - 1 ) { | 280 | if ( numbytes == msg->len - 1 ) { |
293 | pca_rx_byte(adap, &msg->buf[numbytes], 0); | 281 | pca_rx_byte(adap, &msg->buf[numbytes], 0); |
@@ -317,16 +305,16 @@ static int pca_xfer(struct i2c_adapter *i2c_adap, | |||
317 | pca_reset(adap); | 305 | pca_reset(adap); |
318 | goto out; | 306 | goto out; |
319 | default: | 307 | default: |
320 | printk(KERN_ERR DRIVER ": unhandled SIO state 0x%02x\n", state); | 308 | dev_err(&i2c_adap->dev, "unhandled SIO state 0x%02x\n", state); |
321 | break; | 309 | break; |
322 | } | 310 | } |
323 | 311 | ||
324 | } | 312 | } |
325 | 313 | ||
326 | ret = curmsg; | 314 | ret = curmsg; |
327 | out: | 315 | out: |
328 | DEB1(KERN_CRIT "}}} transfered %d/%d messages. " | 316 | DEB1(KERN_CRIT "}}} transfered %d/%d messages. " |
329 | "status is %#04x. control is %#04x\n", | 317 | "status is %#04x. control is %#04x\n", |
330 | curmsg, num, pca_status(adap), | 318 | curmsg, num, pca_status(adap), |
331 | pca_get_con(adap)); | 319 | pca_get_con(adap)); |
332 | return ret; | 320 | return ret; |
@@ -337,53 +325,65 @@ static u32 pca_func(struct i2c_adapter *adap) | |||
337 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; | 325 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; |
338 | } | 326 | } |
339 | 327 | ||
340 | static int pca_init(struct i2c_algo_pca_data *adap) | 328 | static const struct i2c_algorithm pca_algo = { |
329 | .master_xfer = pca_xfer, | ||
330 | .functionality = pca_func, | ||
331 | }; | ||
332 | |||
333 | static int pca_init(struct i2c_adapter *adap) | ||
341 | { | 334 | { |
342 | static int freqs[] = {330,288,217,146,88,59,44,36}; | 335 | static int freqs[] = {330,288,217,146,88,59,44,36}; |
343 | int own, clock; | 336 | int clock; |
337 | struct i2c_algo_pca_data *pca_data = adap->algo_data; | ||
338 | |||
339 | if (pca_data->i2c_clock > 7) { | ||
340 | printk(KERN_WARNING "%s: Invalid I2C clock speed selected. Trying default.\n", | ||
341 | adap->name); | ||
342 | pca_data->i2c_clock = I2C_PCA_CON_59kHz; | ||
343 | } | ||
344 | |||
345 | adap->algo = &pca_algo; | ||
344 | 346 | ||
345 | own = pca_own(adap); | 347 | pca_reset(pca_data); |
346 | clock = pca_clock(adap); | ||
347 | DEB1(KERN_INFO DRIVER ": own address is %#04x\n", own); | ||
348 | DEB1(KERN_INFO DRIVER ": clock freqeuncy is %dkHz\n", freqs[clock]); | ||
349 | 348 | ||
350 | pca_outw(adap, I2C_PCA_ADR, own << 1); | 349 | clock = pca_clock(pca_data); |
350 | DEB1(KERN_INFO "%s: Clock frequency is %dkHz\n", adap->name, freqs[clock]); | ||
351 | 351 | ||
352 | pca_set_con(adap, I2C_PCA_CON_ENSIO | clock); | 352 | pca_set_con(pca_data, I2C_PCA_CON_ENSIO | clock); |
353 | udelay(500); /* 500 µs for oscilator to stabilise */ | 353 | udelay(500); /* 500 us for oscilator to stabilise */ |
354 | 354 | ||
355 | return 0; | 355 | return 0; |
356 | } | 356 | } |
357 | 357 | ||
358 | static const struct i2c_algorithm pca_algo = { | 358 | /* |
359 | .master_xfer = pca_xfer, | 359 | * registering functions to load algorithms at runtime |
360 | .functionality = pca_func, | ||
361 | }; | ||
362 | |||
363 | /* | ||
364 | * registering functions to load algorithms at runtime | ||
365 | */ | 360 | */ |
366 | int i2c_pca_add_bus(struct i2c_adapter *adap) | 361 | int i2c_pca_add_bus(struct i2c_adapter *adap) |
367 | { | 362 | { |
368 | struct i2c_algo_pca_data *pca_adap = adap->algo_data; | ||
369 | int rval; | 363 | int rval; |
370 | 364 | ||
371 | /* register new adapter to i2c module... */ | 365 | rval = pca_init(adap); |
372 | adap->algo = &pca_algo; | 366 | if (rval) |
367 | return rval; | ||
373 | 368 | ||
374 | adap->timeout = 100; /* default values, should */ | 369 | return i2c_add_adapter(adap); |
375 | adap->retries = 3; /* be replaced by defines */ | 370 | } |
371 | EXPORT_SYMBOL(i2c_pca_add_bus); | ||
376 | 372 | ||
377 | if ((rval = pca_init(pca_adap))) | 373 | int i2c_pca_add_numbered_bus(struct i2c_adapter *adap) |
378 | return rval; | 374 | { |
375 | int rval; | ||
379 | 376 | ||
380 | rval = i2c_add_adapter(adap); | 377 | rval = pca_init(adap); |
378 | if (rval) | ||
379 | return rval; | ||
381 | 380 | ||
382 | return rval; | 381 | return i2c_add_numbered_adapter(adap); |
383 | } | 382 | } |
384 | EXPORT_SYMBOL(i2c_pca_add_bus); | 383 | EXPORT_SYMBOL(i2c_pca_add_numbered_bus); |
385 | 384 | ||
386 | MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>"); | 385 | MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>, " |
386 | "Wolfram Sang <w.sang@pengutronix.de>"); | ||
387 | MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm"); | 387 | MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm"); |
388 | MODULE_LICENSE("GPL"); | 388 | MODULE_LICENSE("GPL"); |
389 | 389 | ||
diff --git a/drivers/i2c/algos/i2c-algo-pca.h b/drivers/i2c/algos/i2c-algo-pca.h deleted file mode 100644 index 2fee07e05211..000000000000 --- a/drivers/i2c/algos/i2c-algo-pca.h +++ /dev/null | |||
@@ -1,26 +0,0 @@ | |||
1 | #ifndef I2C_PCA9564_H | ||
2 | #define I2C_PCA9564_H 1 | ||
3 | |||
4 | #define I2C_PCA_STA 0x00 /* STATUS Read Only */ | ||
5 | #define I2C_PCA_TO 0x00 /* TIMEOUT Write Only */ | ||
6 | #define I2C_PCA_DAT 0x01 /* DATA Read/Write */ | ||
7 | #define I2C_PCA_ADR 0x02 /* OWN ADR Read/Write */ | ||
8 | #define I2C_PCA_CON 0x03 /* CONTROL Read/Write */ | ||
9 | |||
10 | #define I2C_PCA_CON_AA 0x80 /* Assert Acknowledge */ | ||
11 | #define I2C_PCA_CON_ENSIO 0x40 /* Enable */ | ||
12 | #define I2C_PCA_CON_STA 0x20 /* Start */ | ||
13 | #define I2C_PCA_CON_STO 0x10 /* Stop */ | ||
14 | #define I2C_PCA_CON_SI 0x08 /* Serial Interrupt */ | ||
15 | #define I2C_PCA_CON_CR 0x07 /* Clock Rate (MASK) */ | ||
16 | |||
17 | #define I2C_PCA_CON_330kHz 0x00 | ||
18 | #define I2C_PCA_CON_288kHz 0x01 | ||
19 | #define I2C_PCA_CON_217kHz 0x02 | ||
20 | #define I2C_PCA_CON_146kHz 0x03 | ||
21 | #define I2C_PCA_CON_88kHz 0x04 | ||
22 | #define I2C_PCA_CON_59kHz 0x05 | ||
23 | #define I2C_PCA_CON_44kHz 0x06 | ||
24 | #define I2C_PCA_CON_36kHz 0x07 | ||
25 | |||
26 | #endif /* I2C_PCA9564_H */ | ||
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig index b04c99580d0d..48438cc5d0ca 100644 --- a/drivers/i2c/busses/Kconfig +++ b/drivers/i2c/busses/Kconfig | |||
@@ -100,9 +100,12 @@ config I2C_AU1550 | |||
100 | 100 | ||
101 | config I2C_BLACKFIN_TWI | 101 | config I2C_BLACKFIN_TWI |
102 | tristate "Blackfin TWI I2C support" | 102 | tristate "Blackfin TWI I2C support" |
103 | depends on BF534 || BF536 || BF537 | 103 | depends on BLACKFIN |
104 | help | 104 | help |
105 | This is the TWI I2C device driver for Blackfin 534/536/537/54x. | 105 | This is the TWI I2C device driver for Blackfin BF522, BF525, |
106 | BF527, BF534, BF536, BF537 and BF54x. For other Blackfin processors, | ||
107 | please don't use this driver. | ||
108 | |||
106 | This driver can also be built as a module. If so, the module | 109 | This driver can also be built as a module. If so, the module |
107 | will be called i2c-bfin-twi. | 110 | will be called i2c-bfin-twi. |
108 | 111 | ||
@@ -135,7 +138,7 @@ config I2C_ELEKTOR | |||
135 | This supports the PCF8584 ISA bus I2C adapter. Say Y if you own | 138 | This supports the PCF8584 ISA bus I2C adapter. Say Y if you own |
136 | such an adapter. | 139 | such an adapter. |
137 | 140 | ||
138 | This support is also available as a module. If so, the module | 141 | This support is also available as a module. If so, the module |
139 | will be called i2c-elektor. | 142 | will be called i2c-elektor. |
140 | 143 | ||
141 | config I2C_GPIO | 144 | config I2C_GPIO |
@@ -190,7 +193,7 @@ config I2C_I810 | |||
190 | select I2C_ALGOBIT | 193 | select I2C_ALGOBIT |
191 | help | 194 | help |
192 | If you say yes to this option, support will be included for the Intel | 195 | If you say yes to this option, support will be included for the Intel |
193 | 810/815 family of mainboard I2C interfaces. Specifically, the | 196 | 810/815 family of mainboard I2C interfaces. Specifically, the |
194 | following versions of the chipset are supported: | 197 | following versions of the chipset are supported: |
195 | i810AA | 198 | i810AA |
196 | i810AB | 199 | i810AB |
@@ -246,10 +249,10 @@ config I2C_PIIX4 | |||
246 | 249 | ||
247 | config I2C_IBM_IIC | 250 | config I2C_IBM_IIC |
248 | tristate "IBM PPC 4xx on-chip I2C interface" | 251 | tristate "IBM PPC 4xx on-chip I2C interface" |
249 | depends on IBM_OCP | 252 | depends on 4xx |
250 | help | 253 | help |
251 | Say Y here if you want to use IIC peripheral found on | 254 | Say Y here if you want to use IIC peripheral found on |
252 | embedded IBM PPC 4xx based systems. | 255 | embedded IBM PPC 4xx based systems. |
253 | 256 | ||
254 | This driver can also be built as a module. If so, the module | 257 | This driver can also be built as a module. If so, the module |
255 | will be called i2c-ibm_iic. | 258 | will be called i2c-ibm_iic. |
@@ -269,7 +272,7 @@ config I2C_IXP2000 | |||
269 | depends on ARCH_IXP2000 | 272 | depends on ARCH_IXP2000 |
270 | select I2C_ALGOBIT | 273 | select I2C_ALGOBIT |
271 | help | 274 | help |
272 | Say Y here if you have an Intel IXP2000 (2400, 2800, 2850) based | 275 | Say Y here if you have an Intel IXP2000 (2400, 2800, 2850) based |
273 | system and are using GPIO lines for an I2C bus. | 276 | system and are using GPIO lines for an I2C bus. |
274 | 277 | ||
275 | This support is also available as a module. If so, the module | 278 | This support is also available as a module. If so, the module |
@@ -354,7 +357,7 @@ config I2C_PARPORT | |||
354 | on the parport driver. This is meant for embedded systems. Don't say | 357 | on the parport driver. This is meant for embedded systems. Don't say |
355 | Y here if you intend to say Y or M there. | 358 | Y here if you intend to say Y or M there. |
356 | 359 | ||
357 | This support is also available as a module. If so, the module | 360 | This support is also available as a module. If so, the module |
358 | will be called i2c-parport. | 361 | will be called i2c-parport. |
359 | 362 | ||
360 | config I2C_PARPORT_LIGHT | 363 | config I2C_PARPORT_LIGHT |
@@ -372,12 +375,12 @@ config I2C_PARPORT_LIGHT | |||
372 | the clean but heavy parport handling is not an option. The | 375 | the clean but heavy parport handling is not an option. The |
373 | drawback is a reduced portability and the impossibility to | 376 | drawback is a reduced portability and the impossibility to |
374 | daisy-chain other parallel port devices. | 377 | daisy-chain other parallel port devices. |
375 | 378 | ||
376 | Don't say Y here if you said Y or M to i2c-parport. Saying M to | 379 | Don't say Y here if you said Y or M to i2c-parport. Saying M to |
377 | both is possible but both modules should not be loaded at the same | 380 | both is possible but both modules should not be loaded at the same |
378 | time. | 381 | time. |
379 | 382 | ||
380 | This support is also available as a module. If so, the module | 383 | This support is also available as a module. If so, the module |
381 | will be called i2c-parport-light. | 384 | will be called i2c-parport-light. |
382 | 385 | ||
383 | config I2C_PASEMI | 386 | config I2C_PASEMI |
@@ -401,7 +404,7 @@ config I2C_PROSAVAGE | |||
401 | 404 | ||
402 | This driver is deprecated in favor of the savagefb driver. | 405 | This driver is deprecated in favor of the savagefb driver. |
403 | 406 | ||
404 | This support is also available as a module. If so, the module | 407 | This support is also available as a module. If so, the module |
405 | will be called i2c-prosavage. | 408 | will be called i2c-prosavage. |
406 | 409 | ||
407 | config I2C_S3C2410 | 410 | config I2C_S3C2410 |
@@ -417,7 +420,7 @@ config I2C_SAVAGE4 | |||
417 | depends on PCI | 420 | depends on PCI |
418 | select I2C_ALGOBIT | 421 | select I2C_ALGOBIT |
419 | help | 422 | help |
420 | If you say yes to this option, support will be included for the | 423 | If you say yes to this option, support will be included for the |
421 | S3 Savage 4 I2C interface. | 424 | S3 Savage 4 I2C interface. |
422 | 425 | ||
423 | This driver is deprecated in favor of the savagefb driver. | 426 | This driver is deprecated in favor of the savagefb driver. |
@@ -452,7 +455,7 @@ config SCx200_I2C | |||
452 | 455 | ||
453 | If you don't know what to do here, say N. | 456 | If you don't know what to do here, say N. |
454 | 457 | ||
455 | This support is also available as a module. If so, the module | 458 | This support is also available as a module. If so, the module |
456 | will be called scx200_i2c. | 459 | will be called scx200_i2c. |
457 | 460 | ||
458 | This driver is deprecated and will be dropped soon. Use i2c-gpio | 461 | This driver is deprecated and will be dropped soon. Use i2c-gpio |
@@ -483,14 +486,14 @@ config SCx200_ACB | |||
483 | 486 | ||
484 | If you don't know what to do here, say N. | 487 | If you don't know what to do here, say N. |
485 | 488 | ||
486 | This support is also available as a module. If so, the module | 489 | This support is also available as a module. If so, the module |
487 | will be called scx200_acb. | 490 | will be called scx200_acb. |
488 | 491 | ||
489 | config I2C_SIS5595 | 492 | config I2C_SIS5595 |
490 | tristate "SiS 5595" | 493 | tristate "SiS 5595" |
491 | depends on PCI | 494 | depends on PCI |
492 | help | 495 | help |
493 | If you say yes to this option, support will be included for the | 496 | If you say yes to this option, support will be included for the |
494 | SiS5595 SMBus (a subset of I2C) interface. | 497 | SiS5595 SMBus (a subset of I2C) interface. |
495 | 498 | ||
496 | This driver can also be built as a module. If so, the module | 499 | This driver can also be built as a module. If so, the module |
@@ -500,7 +503,7 @@ config I2C_SIS630 | |||
500 | tristate "SiS 630/730" | 503 | tristate "SiS 630/730" |
501 | depends on PCI | 504 | depends on PCI |
502 | help | 505 | help |
503 | If you say yes to this option, support will be included for the | 506 | If you say yes to this option, support will be included for the |
504 | SiS630 and SiS730 SMBus (a subset of I2C) interface. | 507 | SiS630 and SiS730 SMBus (a subset of I2C) interface. |
505 | 508 | ||
506 | This driver can also be built as a module. If so, the module | 509 | This driver can also be built as a module. If so, the module |
@@ -632,9 +635,9 @@ config I2C_PCA_ISA | |||
632 | select I2C_ALGOPCA | 635 | select I2C_ALGOPCA |
633 | default n | 636 | default n |
634 | help | 637 | help |
635 | This driver supports ISA boards using the Philips PCA 9564 | 638 | This driver supports ISA boards using the Philips PCA9564 |
636 | Parallel bus to I2C bus controller | 639 | parallel bus to I2C bus controller. |
637 | 640 | ||
638 | This driver can also be built as a module. If so, the module | 641 | This driver can also be built as a module. If so, the module |
639 | will be called i2c-pca-isa. | 642 | will be called i2c-pca-isa. |
640 | 643 | ||
@@ -643,6 +646,17 @@ config I2C_PCA_ISA | |||
643 | delays when I2C/SMBus chip drivers are loaded (e.g. at boot | 646 | delays when I2C/SMBus chip drivers are loaded (e.g. at boot |
644 | time). If unsure, say N. | 647 | time). If unsure, say N. |
645 | 648 | ||
649 | config I2C_PCA_PLATFORM | ||
650 | tristate "PCA9564 as platform device" | ||
651 | select I2C_ALGOPCA | ||
652 | default n | ||
653 | help | ||
654 | This driver supports a memory mapped Philips PCA9564 | ||
655 | parallel bus to I2C bus controller. | ||
656 | |||
657 | This driver can also be built as a module. If so, the module | ||
658 | will be called i2c-pca-platform. | ||
659 | |||
646 | config I2C_MV64XXX | 660 | config I2C_MV64XXX |
647 | tristate "Marvell mv64xxx I2C Controller" | 661 | tristate "Marvell mv64xxx I2C Controller" |
648 | depends on (MV64X60 || PLAT_ORION) && EXPERIMENTAL | 662 | depends on (MV64X60 || PLAT_ORION) && EXPERIMENTAL |
@@ -672,4 +686,23 @@ config I2C_PMCMSP | |||
672 | This driver can also be built as module. If so, the module | 686 | This driver can also be built as module. If so, the module |
673 | will be called i2c-pmcmsp. | 687 | will be called i2c-pmcmsp. |
674 | 688 | ||
689 | config I2C_SH7760 | ||
690 | tristate "Renesas SH7760 I2C Controller" | ||
691 | depends on CPU_SUBTYPE_SH7760 | ||
692 | help | ||
693 | This driver supports the 2 I2C interfaces on the Renesas SH7760. | ||
694 | |||
695 | This driver can also be built as a module. If so, the module | ||
696 | will be called i2c-sh7760. | ||
697 | |||
698 | config I2C_SH_MOBILE | ||
699 | tristate "SuperH Mobile I2C Controller" | ||
700 | depends on SUPERH | ||
701 | help | ||
702 | If you say yes to this option, support will be included for the | ||
703 | built-in I2C interface on the Renesas SH-Mobile processor. | ||
704 | |||
705 | This driver can also be built as a module. If so, the module | ||
706 | will be called i2c-sh_mobile. | ||
707 | |||
675 | endmenu | 708 | endmenu |
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile index ea7068f1eb6b..e8c882a5ea66 100644 --- a/drivers/i2c/busses/Makefile +++ b/drivers/i2c/busses/Makefile | |||
@@ -30,6 +30,7 @@ obj-$(CONFIG_I2C_PARPORT) += i2c-parport.o | |||
30 | obj-$(CONFIG_I2C_PARPORT_LIGHT) += i2c-parport-light.o | 30 | obj-$(CONFIG_I2C_PARPORT_LIGHT) += i2c-parport-light.o |
31 | obj-$(CONFIG_I2C_PASEMI) += i2c-pasemi.o | 31 | obj-$(CONFIG_I2C_PASEMI) += i2c-pasemi.o |
32 | obj-$(CONFIG_I2C_PCA_ISA) += i2c-pca-isa.o | 32 | obj-$(CONFIG_I2C_PCA_ISA) += i2c-pca-isa.o |
33 | obj-$(CONFIG_I2C_PCA_PLATFORM) += i2c-pca-platform.o | ||
33 | obj-$(CONFIG_I2C_PIIX4) += i2c-piix4.o | 34 | obj-$(CONFIG_I2C_PIIX4) += i2c-piix4.o |
34 | obj-$(CONFIG_I2C_PMCMSP) += i2c-pmcmsp.o | 35 | obj-$(CONFIG_I2C_PMCMSP) += i2c-pmcmsp.o |
35 | obj-$(CONFIG_I2C_PNX) += i2c-pnx.o | 36 | obj-$(CONFIG_I2C_PNX) += i2c-pnx.o |
@@ -37,6 +38,8 @@ obj-$(CONFIG_I2C_PROSAVAGE) += i2c-prosavage.o | |||
37 | obj-$(CONFIG_I2C_PXA) += i2c-pxa.o | 38 | obj-$(CONFIG_I2C_PXA) += i2c-pxa.o |
38 | obj-$(CONFIG_I2C_S3C2410) += i2c-s3c2410.o | 39 | obj-$(CONFIG_I2C_S3C2410) += i2c-s3c2410.o |
39 | obj-$(CONFIG_I2C_SAVAGE4) += i2c-savage4.o | 40 | obj-$(CONFIG_I2C_SAVAGE4) += i2c-savage4.o |
41 | obj-$(CONFIG_I2C_SH7760) += i2c-sh7760.o | ||
42 | obj-$(CONFIG_I2C_SH_MOBILE) += i2c-sh_mobile.o | ||
40 | obj-$(CONFIG_I2C_SIBYTE) += i2c-sibyte.o | 43 | obj-$(CONFIG_I2C_SIBYTE) += i2c-sibyte.o |
41 | obj-$(CONFIG_I2C_SIMTEC) += i2c-simtec.o | 44 | obj-$(CONFIG_I2C_SIMTEC) += i2c-simtec.o |
42 | obj-$(CONFIG_I2C_SIS5595) += i2c-sis5595.o | 45 | obj-$(CONFIG_I2C_SIS5595) += i2c-sis5595.o |
diff --git a/drivers/i2c/busses/i2c-at91.c b/drivers/i2c/busses/i2c-at91.c index c09b036913bd..73d61946a534 100644 --- a/drivers/i2c/busses/i2c-at91.c +++ b/drivers/i2c/busses/i2c-at91.c | |||
@@ -298,7 +298,7 @@ static int at91_i2c_resume(struct platform_device *pdev) | |||
298 | #endif | 298 | #endif |
299 | 299 | ||
300 | /* work with "modprobe at91_i2c" from hotplugging or coldplugging */ | 300 | /* work with "modprobe at91_i2c" from hotplugging or coldplugging */ |
301 | MODULE_ALIAS("at91_i2c"); | 301 | MODULE_ALIAS("platform:at91_i2c"); |
302 | 302 | ||
303 | static struct platform_driver at91_i2c_driver = { | 303 | static struct platform_driver at91_i2c_driver = { |
304 | .probe = at91_i2c_probe, | 304 | .probe = at91_i2c_probe, |
diff --git a/drivers/i2c/busses/i2c-au1550.c b/drivers/i2c/busses/i2c-au1550.c index 1953b26da56a..491718fe46b7 100644 --- a/drivers/i2c/busses/i2c-au1550.c +++ b/drivers/i2c/busses/i2c-au1550.c | |||
@@ -472,6 +472,7 @@ i2c_au1550_exit(void) | |||
472 | MODULE_AUTHOR("Dan Malek, Embedded Edge, LLC."); | 472 | MODULE_AUTHOR("Dan Malek, Embedded Edge, LLC."); |
473 | MODULE_DESCRIPTION("SMBus adapter Alchemy pb1550"); | 473 | MODULE_DESCRIPTION("SMBus adapter Alchemy pb1550"); |
474 | MODULE_LICENSE("GPL"); | 474 | MODULE_LICENSE("GPL"); |
475 | MODULE_ALIAS("platform:au1xpsc_smbus"); | ||
475 | 476 | ||
476 | module_init (i2c_au1550_init); | 477 | module_init (i2c_au1550_init); |
477 | module_exit (i2c_au1550_exit); | 478 | module_exit (i2c_au1550_exit); |
diff --git a/drivers/i2c/busses/i2c-bfin-twi.c b/drivers/i2c/busses/i2c-bfin-twi.c index 7dbdaeb707a9..48d084bdf7c8 100644 --- a/drivers/i2c/busses/i2c-bfin-twi.c +++ b/drivers/i2c/busses/i2c-bfin-twi.c | |||
@@ -1,25 +1,11 @@ | |||
1 | /* | 1 | /* |
2 | * drivers/i2c/busses/i2c-bfin-twi.c | 2 | * Blackfin On-Chip Two Wire Interface Driver |
3 | * | 3 | * |
4 | * Description: Driver for Blackfin Two Wire Interface | 4 | * Copyright 2005-2007 Analog Devices Inc. |
5 | * | 5 | * |
6 | * Author: sonicz <sonic.zhang@analog.com> | 6 | * Enter bugs at http://blackfin.uclinux.org/ |
7 | * | 7 | * |
8 | * Copyright (c) 2005-2007 Analog Devices, Inc. | 8 | * Licensed under the GPL-2 or later. |
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with this program; if not, write to the Free Software | ||
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
23 | */ | 9 | */ |
24 | 10 | ||
25 | #include <linux/module.h> | 11 | #include <linux/module.h> |
@@ -34,14 +20,16 @@ | |||
34 | #include <linux/platform_device.h> | 20 | #include <linux/platform_device.h> |
35 | 21 | ||
36 | #include <asm/blackfin.h> | 22 | #include <asm/blackfin.h> |
23 | #include <asm/portmux.h> | ||
37 | #include <asm/irq.h> | 24 | #include <asm/irq.h> |
38 | 25 | ||
39 | #define POLL_TIMEOUT (2 * HZ) | 26 | #define POLL_TIMEOUT (2 * HZ) |
40 | 27 | ||
41 | /* SMBus mode*/ | 28 | /* SMBus mode*/ |
42 | #define TWI_I2C_MODE_STANDARD 0x01 | 29 | #define TWI_I2C_MODE_STANDARD 1 |
43 | #define TWI_I2C_MODE_STANDARDSUB 0x02 | 30 | #define TWI_I2C_MODE_STANDARDSUB 2 |
44 | #define TWI_I2C_MODE_COMBINED 0x04 | 31 | #define TWI_I2C_MODE_COMBINED 3 |
32 | #define TWI_I2C_MODE_REPEAT 4 | ||
45 | 33 | ||
46 | struct bfin_twi_iface { | 34 | struct bfin_twi_iface { |
47 | int irq; | 35 | int irq; |
@@ -58,39 +46,74 @@ struct bfin_twi_iface { | |||
58 | struct timer_list timeout_timer; | 46 | struct timer_list timeout_timer; |
59 | struct i2c_adapter adap; | 47 | struct i2c_adapter adap; |
60 | struct completion complete; | 48 | struct completion complete; |
49 | struct i2c_msg *pmsg; | ||
50 | int msg_num; | ||
51 | int cur_msg; | ||
52 | void __iomem *regs_base; | ||
61 | }; | 53 | }; |
62 | 54 | ||
63 | static struct bfin_twi_iface twi_iface; | 55 | |
56 | #define DEFINE_TWI_REG(reg, off) \ | ||
57 | static inline u16 read_##reg(struct bfin_twi_iface *iface) \ | ||
58 | { return bfin_read16(iface->regs_base + (off)); } \ | ||
59 | static inline void write_##reg(struct bfin_twi_iface *iface, u16 v) \ | ||
60 | { bfin_write16(iface->regs_base + (off), v); } | ||
61 | |||
62 | DEFINE_TWI_REG(CLKDIV, 0x00) | ||
63 | DEFINE_TWI_REG(CONTROL, 0x04) | ||
64 | DEFINE_TWI_REG(SLAVE_CTL, 0x08) | ||
65 | DEFINE_TWI_REG(SLAVE_STAT, 0x0C) | ||
66 | DEFINE_TWI_REG(SLAVE_ADDR, 0x10) | ||
67 | DEFINE_TWI_REG(MASTER_CTL, 0x14) | ||
68 | DEFINE_TWI_REG(MASTER_STAT, 0x18) | ||
69 | DEFINE_TWI_REG(MASTER_ADDR, 0x1C) | ||
70 | DEFINE_TWI_REG(INT_STAT, 0x20) | ||
71 | DEFINE_TWI_REG(INT_MASK, 0x24) | ||
72 | DEFINE_TWI_REG(FIFO_CTL, 0x28) | ||
73 | DEFINE_TWI_REG(FIFO_STAT, 0x2C) | ||
74 | DEFINE_TWI_REG(XMT_DATA8, 0x80) | ||
75 | DEFINE_TWI_REG(XMT_DATA16, 0x84) | ||
76 | DEFINE_TWI_REG(RCV_DATA8, 0x88) | ||
77 | DEFINE_TWI_REG(RCV_DATA16, 0x8C) | ||
78 | |||
79 | static const u16 pin_req[2][3] = { | ||
80 | {P_TWI0_SCL, P_TWI0_SDA, 0}, | ||
81 | {P_TWI1_SCL, P_TWI1_SDA, 0}, | ||
82 | }; | ||
64 | 83 | ||
65 | static void bfin_twi_handle_interrupt(struct bfin_twi_iface *iface) | 84 | static void bfin_twi_handle_interrupt(struct bfin_twi_iface *iface) |
66 | { | 85 | { |
67 | unsigned short twi_int_status = bfin_read_TWI_INT_STAT(); | 86 | unsigned short twi_int_status = read_INT_STAT(iface); |
68 | unsigned short mast_stat = bfin_read_TWI_MASTER_STAT(); | 87 | unsigned short mast_stat = read_MASTER_STAT(iface); |
69 | 88 | ||
70 | if (twi_int_status & XMTSERV) { | 89 | if (twi_int_status & XMTSERV) { |
71 | /* Transmit next data */ | 90 | /* Transmit next data */ |
72 | if (iface->writeNum > 0) { | 91 | if (iface->writeNum > 0) { |
73 | bfin_write_TWI_XMT_DATA8(*(iface->transPtr++)); | 92 | write_XMT_DATA8(iface, *(iface->transPtr++)); |
74 | iface->writeNum--; | 93 | iface->writeNum--; |
75 | } | 94 | } |
76 | /* start receive immediately after complete sending in | 95 | /* start receive immediately after complete sending in |
77 | * combine mode. | 96 | * combine mode. |
78 | */ | 97 | */ |
79 | else if (iface->cur_mode == TWI_I2C_MODE_COMBINED) { | 98 | else if (iface->cur_mode == TWI_I2C_MODE_COMBINED) |
80 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | 99 | write_MASTER_CTL(iface, |
81 | | MDIR | RSTART); | 100 | read_MASTER_CTL(iface) | MDIR | RSTART); |
82 | } else if (iface->manual_stop) | 101 | else if (iface->manual_stop) |
83 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | 102 | write_MASTER_CTL(iface, |
84 | | STOP); | 103 | read_MASTER_CTL(iface) | STOP); |
104 | else if (iface->cur_mode == TWI_I2C_MODE_REPEAT && | ||
105 | iface->cur_msg+1 < iface->msg_num) | ||
106 | write_MASTER_CTL(iface, | ||
107 | read_MASTER_CTL(iface) | RSTART); | ||
85 | SSYNC(); | 108 | SSYNC(); |
86 | /* Clear status */ | 109 | /* Clear status */ |
87 | bfin_write_TWI_INT_STAT(XMTSERV); | 110 | write_INT_STAT(iface, XMTSERV); |
88 | SSYNC(); | 111 | SSYNC(); |
89 | } | 112 | } |
90 | if (twi_int_status & RCVSERV) { | 113 | if (twi_int_status & RCVSERV) { |
91 | if (iface->readNum > 0) { | 114 | if (iface->readNum > 0) { |
92 | /* Receive next data */ | 115 | /* Receive next data */ |
93 | *(iface->transPtr) = bfin_read_TWI_RCV_DATA8(); | 116 | *(iface->transPtr) = read_RCV_DATA8(iface); |
94 | if (iface->cur_mode == TWI_I2C_MODE_COMBINED) { | 117 | if (iface->cur_mode == TWI_I2C_MODE_COMBINED) { |
95 | /* Change combine mode into sub mode after | 118 | /* Change combine mode into sub mode after |
96 | * read first data. | 119 | * read first data. |
@@ -105,28 +128,33 @@ static void bfin_twi_handle_interrupt(struct bfin_twi_iface *iface) | |||
105 | iface->transPtr++; | 128 | iface->transPtr++; |
106 | iface->readNum--; | 129 | iface->readNum--; |
107 | } else if (iface->manual_stop) { | 130 | } else if (iface->manual_stop) { |
108 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | 131 | write_MASTER_CTL(iface, |
109 | | STOP); | 132 | read_MASTER_CTL(iface) | STOP); |
133 | SSYNC(); | ||
134 | } else if (iface->cur_mode == TWI_I2C_MODE_REPEAT && | ||
135 | iface->cur_msg+1 < iface->msg_num) { | ||
136 | write_MASTER_CTL(iface, | ||
137 | read_MASTER_CTL(iface) | RSTART); | ||
110 | SSYNC(); | 138 | SSYNC(); |
111 | } | 139 | } |
112 | /* Clear interrupt source */ | 140 | /* Clear interrupt source */ |
113 | bfin_write_TWI_INT_STAT(RCVSERV); | 141 | write_INT_STAT(iface, RCVSERV); |
114 | SSYNC(); | 142 | SSYNC(); |
115 | } | 143 | } |
116 | if (twi_int_status & MERR) { | 144 | if (twi_int_status & MERR) { |
117 | bfin_write_TWI_INT_STAT(MERR); | 145 | write_INT_STAT(iface, MERR); |
118 | bfin_write_TWI_INT_MASK(0); | 146 | write_INT_MASK(iface, 0); |
119 | bfin_write_TWI_MASTER_STAT(0x3e); | 147 | write_MASTER_STAT(iface, 0x3e); |
120 | bfin_write_TWI_MASTER_CTL(0); | 148 | write_MASTER_CTL(iface, 0); |
121 | SSYNC(); | 149 | SSYNC(); |
122 | iface->result = -1; | 150 | iface->result = -EIO; |
123 | /* if both err and complete int stats are set, return proper | 151 | /* if both err and complete int stats are set, return proper |
124 | * results. | 152 | * results. |
125 | */ | 153 | */ |
126 | if (twi_int_status & MCOMP) { | 154 | if (twi_int_status & MCOMP) { |
127 | bfin_write_TWI_INT_STAT(MCOMP); | 155 | write_INT_STAT(iface, MCOMP); |
128 | bfin_write_TWI_INT_MASK(0); | 156 | write_INT_MASK(iface, 0); |
129 | bfin_write_TWI_MASTER_CTL(0); | 157 | write_MASTER_CTL(iface, 0); |
130 | SSYNC(); | 158 | SSYNC(); |
131 | /* If it is a quick transfer, only address bug no data, | 159 | /* If it is a quick transfer, only address bug no data, |
132 | * not an err, return 1. | 160 | * not an err, return 1. |
@@ -143,7 +171,7 @@ static void bfin_twi_handle_interrupt(struct bfin_twi_iface *iface) | |||
143 | return; | 171 | return; |
144 | } | 172 | } |
145 | if (twi_int_status & MCOMP) { | 173 | if (twi_int_status & MCOMP) { |
146 | bfin_write_TWI_INT_STAT(MCOMP); | 174 | write_INT_STAT(iface, MCOMP); |
147 | SSYNC(); | 175 | SSYNC(); |
148 | if (iface->cur_mode == TWI_I2C_MODE_COMBINED) { | 176 | if (iface->cur_mode == TWI_I2C_MODE_COMBINED) { |
149 | if (iface->readNum == 0) { | 177 | if (iface->readNum == 0) { |
@@ -152,28 +180,63 @@ static void bfin_twi_handle_interrupt(struct bfin_twi_iface *iface) | |||
152 | */ | 180 | */ |
153 | iface->readNum = 1; | 181 | iface->readNum = 1; |
154 | iface->manual_stop = 1; | 182 | iface->manual_stop = 1; |
155 | bfin_write_TWI_MASTER_CTL( | 183 | write_MASTER_CTL(iface, |
156 | bfin_read_TWI_MASTER_CTL() | 184 | read_MASTER_CTL(iface) | (0xff << 6)); |
157 | | (0xff << 6)); | ||
158 | } else { | 185 | } else { |
159 | /* set the readd number in other | 186 | /* set the readd number in other |
160 | * combine mode. | 187 | * combine mode. |
161 | */ | 188 | */ |
162 | bfin_write_TWI_MASTER_CTL( | 189 | write_MASTER_CTL(iface, |
163 | (bfin_read_TWI_MASTER_CTL() & | 190 | (read_MASTER_CTL(iface) & |
164 | (~(0xff << 6))) | | 191 | (~(0xff << 6))) | |
165 | ( iface->readNum << 6)); | 192 | (iface->readNum << 6)); |
193 | } | ||
194 | /* remove restart bit and enable master receive */ | ||
195 | write_MASTER_CTL(iface, | ||
196 | read_MASTER_CTL(iface) & ~RSTART); | ||
197 | write_MASTER_CTL(iface, | ||
198 | read_MASTER_CTL(iface) | MEN | MDIR); | ||
199 | SSYNC(); | ||
200 | } else if (iface->cur_mode == TWI_I2C_MODE_REPEAT && | ||
201 | iface->cur_msg+1 < iface->msg_num) { | ||
202 | iface->cur_msg++; | ||
203 | iface->transPtr = iface->pmsg[iface->cur_msg].buf; | ||
204 | iface->writeNum = iface->readNum = | ||
205 | iface->pmsg[iface->cur_msg].len; | ||
206 | /* Set Transmit device address */ | ||
207 | write_MASTER_ADDR(iface, | ||
208 | iface->pmsg[iface->cur_msg].addr); | ||
209 | if (iface->pmsg[iface->cur_msg].flags & I2C_M_RD) | ||
210 | iface->read_write = I2C_SMBUS_READ; | ||
211 | else { | ||
212 | iface->read_write = I2C_SMBUS_WRITE; | ||
213 | /* Transmit first data */ | ||
214 | if (iface->writeNum > 0) { | ||
215 | write_XMT_DATA8(iface, | ||
216 | *(iface->transPtr++)); | ||
217 | iface->writeNum--; | ||
218 | SSYNC(); | ||
219 | } | ||
220 | } | ||
221 | |||
222 | if (iface->pmsg[iface->cur_msg].len <= 255) | ||
223 | write_MASTER_CTL(iface, | ||
224 | iface->pmsg[iface->cur_msg].len << 6); | ||
225 | else { | ||
226 | write_MASTER_CTL(iface, 0xff << 6); | ||
227 | iface->manual_stop = 1; | ||
166 | } | 228 | } |
167 | /* remove restart bit and enable master receive */ | 229 | /* remove restart bit and enable master receive */ |
168 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() & | 230 | write_MASTER_CTL(iface, |
169 | ~RSTART); | 231 | read_MASTER_CTL(iface) & ~RSTART); |
170 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | | 232 | write_MASTER_CTL(iface, read_MASTER_CTL(iface) | |
171 | MEN | MDIR); | 233 | MEN | ((iface->read_write == I2C_SMBUS_READ) ? |
234 | MDIR : 0)); | ||
172 | SSYNC(); | 235 | SSYNC(); |
173 | } else { | 236 | } else { |
174 | iface->result = 1; | 237 | iface->result = 1; |
175 | bfin_write_TWI_INT_MASK(0); | 238 | write_INT_MASK(iface, 0); |
176 | bfin_write_TWI_MASTER_CTL(0); | 239 | write_MASTER_CTL(iface, 0); |
177 | SSYNC(); | 240 | SSYNC(); |
178 | complete(&iface->complete); | 241 | complete(&iface->complete); |
179 | } | 242 | } |
@@ -221,91 +284,85 @@ static int bfin_twi_master_xfer(struct i2c_adapter *adap, | |||
221 | { | 284 | { |
222 | struct bfin_twi_iface *iface = adap->algo_data; | 285 | struct bfin_twi_iface *iface = adap->algo_data; |
223 | struct i2c_msg *pmsg; | 286 | struct i2c_msg *pmsg; |
224 | int i, ret; | ||
225 | int rc = 0; | 287 | int rc = 0; |
226 | 288 | ||
227 | if (!(bfin_read_TWI_CONTROL() & TWI_ENA)) | 289 | if (!(read_CONTROL(iface) & TWI_ENA)) |
228 | return -ENXIO; | 290 | return -ENXIO; |
229 | 291 | ||
230 | while (bfin_read_TWI_MASTER_STAT() & BUSBUSY) { | 292 | while (read_MASTER_STAT(iface) & BUSBUSY) |
231 | yield(); | 293 | yield(); |
294 | |||
295 | iface->pmsg = msgs; | ||
296 | iface->msg_num = num; | ||
297 | iface->cur_msg = 0; | ||
298 | |||
299 | pmsg = &msgs[0]; | ||
300 | if (pmsg->flags & I2C_M_TEN) { | ||
301 | dev_err(&adap->dev, "10 bits addr not supported!\n"); | ||
302 | return -EINVAL; | ||
232 | } | 303 | } |
233 | 304 | ||
234 | ret = 0; | 305 | iface->cur_mode = TWI_I2C_MODE_REPEAT; |
235 | for (i = 0; rc >= 0 && i < num; i++) { | 306 | iface->manual_stop = 0; |
236 | pmsg = &msgs[i]; | 307 | iface->transPtr = pmsg->buf; |
237 | if (pmsg->flags & I2C_M_TEN) { | 308 | iface->writeNum = iface->readNum = pmsg->len; |
238 | dev_err(&(adap->dev), "i2c-bfin-twi: 10 bits addr " | 309 | iface->result = 0; |
239 | "not supported !\n"); | 310 | iface->timeout_count = 10; |
240 | rc = -EINVAL; | 311 | init_completion(&(iface->complete)); |
241 | break; | 312 | /* Set Transmit device address */ |
242 | } | 313 | write_MASTER_ADDR(iface, pmsg->addr); |
243 | 314 | ||
244 | iface->cur_mode = TWI_I2C_MODE_STANDARD; | 315 | /* FIFO Initiation. Data in FIFO should be |
245 | iface->manual_stop = 0; | 316 | * discarded before start a new operation. |
246 | iface->transPtr = pmsg->buf; | 317 | */ |
247 | iface->writeNum = iface->readNum = pmsg->len; | 318 | write_FIFO_CTL(iface, 0x3); |
248 | iface->result = 0; | 319 | SSYNC(); |
249 | iface->timeout_count = 10; | 320 | write_FIFO_CTL(iface, 0); |
250 | /* Set Transmit device address */ | 321 | SSYNC(); |
251 | bfin_write_TWI_MASTER_ADDR(pmsg->addr); | ||
252 | |||
253 | /* FIFO Initiation. Data in FIFO should be | ||
254 | * discarded before start a new operation. | ||
255 | */ | ||
256 | bfin_write_TWI_FIFO_CTL(0x3); | ||
257 | SSYNC(); | ||
258 | bfin_write_TWI_FIFO_CTL(0); | ||
259 | SSYNC(); | ||
260 | 322 | ||
261 | if (pmsg->flags & I2C_M_RD) | 323 | if (pmsg->flags & I2C_M_RD) |
262 | iface->read_write = I2C_SMBUS_READ; | 324 | iface->read_write = I2C_SMBUS_READ; |
263 | else { | 325 | else { |
264 | iface->read_write = I2C_SMBUS_WRITE; | 326 | iface->read_write = I2C_SMBUS_WRITE; |
265 | /* Transmit first data */ | 327 | /* Transmit first data */ |
266 | if (iface->writeNum > 0) { | 328 | if (iface->writeNum > 0) { |
267 | bfin_write_TWI_XMT_DATA8(*(iface->transPtr++)); | 329 | write_XMT_DATA8(iface, *(iface->transPtr++)); |
268 | iface->writeNum--; | 330 | iface->writeNum--; |
269 | SSYNC(); | 331 | SSYNC(); |
270 | } | ||
271 | } | 332 | } |
333 | } | ||
272 | 334 | ||
273 | /* clear int stat */ | 335 | /* clear int stat */ |
274 | bfin_write_TWI_INT_STAT(MERR|MCOMP|XMTSERV|RCVSERV); | 336 | write_INT_STAT(iface, MERR | MCOMP | XMTSERV | RCVSERV); |
275 | 337 | ||
276 | /* Interrupt mask . Enable XMT, RCV interrupt */ | 338 | /* Interrupt mask . Enable XMT, RCV interrupt */ |
277 | bfin_write_TWI_INT_MASK(MCOMP | MERR | | 339 | write_INT_MASK(iface, MCOMP | MERR | RCVSERV | XMTSERV); |
278 | ((iface->read_write == I2C_SMBUS_READ)? | 340 | SSYNC(); |
279 | RCVSERV : XMTSERV)); | ||
280 | SSYNC(); | ||
281 | 341 | ||
282 | if (pmsg->len > 0 && pmsg->len <= 255) | 342 | if (pmsg->len <= 255) |
283 | bfin_write_TWI_MASTER_CTL(pmsg->len << 6); | 343 | write_MASTER_CTL(iface, pmsg->len << 6); |
284 | else if (pmsg->len > 255) { | 344 | else { |
285 | bfin_write_TWI_MASTER_CTL(0xff << 6); | 345 | write_MASTER_CTL(iface, 0xff << 6); |
286 | iface->manual_stop = 1; | 346 | iface->manual_stop = 1; |
287 | } else | 347 | } |
288 | break; | ||
289 | 348 | ||
290 | iface->timeout_timer.expires = jiffies + POLL_TIMEOUT; | 349 | iface->timeout_timer.expires = jiffies + POLL_TIMEOUT; |
291 | add_timer(&iface->timeout_timer); | 350 | add_timer(&iface->timeout_timer); |
292 | 351 | ||
293 | /* Master enable */ | 352 | /* Master enable */ |
294 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | MEN | | 353 | write_MASTER_CTL(iface, read_MASTER_CTL(iface) | MEN | |
295 | ((iface->read_write == I2C_SMBUS_READ) ? MDIR : 0) | | 354 | ((iface->read_write == I2C_SMBUS_READ) ? MDIR : 0) | |
296 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ>100) ? FAST : 0)); | 355 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ > 100) ? FAST : 0)); |
297 | SSYNC(); | 356 | SSYNC(); |
298 | 357 | ||
299 | wait_for_completion(&iface->complete); | 358 | wait_for_completion(&iface->complete); |
300 | 359 | ||
301 | rc = iface->result; | 360 | rc = iface->result; |
302 | if (rc == 1) | ||
303 | ret++; | ||
304 | else if (rc == -1) | ||
305 | break; | ||
306 | } | ||
307 | 361 | ||
308 | return ret; | 362 | if (rc == 1) |
363 | return num; | ||
364 | else | ||
365 | return rc; | ||
309 | } | 366 | } |
310 | 367 | ||
311 | /* | 368 | /* |
@@ -319,12 +376,11 @@ int bfin_twi_smbus_xfer(struct i2c_adapter *adap, u16 addr, | |||
319 | struct bfin_twi_iface *iface = adap->algo_data; | 376 | struct bfin_twi_iface *iface = adap->algo_data; |
320 | int rc = 0; | 377 | int rc = 0; |
321 | 378 | ||
322 | if (!(bfin_read_TWI_CONTROL() & TWI_ENA)) | 379 | if (!(read_CONTROL(iface) & TWI_ENA)) |
323 | return -ENXIO; | 380 | return -ENXIO; |
324 | 381 | ||
325 | while (bfin_read_TWI_MASTER_STAT() & BUSBUSY) { | 382 | while (read_MASTER_STAT(iface) & BUSBUSY) |
326 | yield(); | 383 | yield(); |
327 | } | ||
328 | 384 | ||
329 | iface->writeNum = 0; | 385 | iface->writeNum = 0; |
330 | iface->readNum = 0; | 386 | iface->readNum = 0; |
@@ -392,19 +448,20 @@ int bfin_twi_smbus_xfer(struct i2c_adapter *adap, u16 addr, | |||
392 | iface->read_write = read_write; | 448 | iface->read_write = read_write; |
393 | iface->command = command; | 449 | iface->command = command; |
394 | iface->timeout_count = 10; | 450 | iface->timeout_count = 10; |
451 | init_completion(&(iface->complete)); | ||
395 | 452 | ||
396 | /* FIFO Initiation. Data in FIFO should be discarded before | 453 | /* FIFO Initiation. Data in FIFO should be discarded before |
397 | * start a new operation. | 454 | * start a new operation. |
398 | */ | 455 | */ |
399 | bfin_write_TWI_FIFO_CTL(0x3); | 456 | write_FIFO_CTL(iface, 0x3); |
400 | SSYNC(); | 457 | SSYNC(); |
401 | bfin_write_TWI_FIFO_CTL(0); | 458 | write_FIFO_CTL(iface, 0); |
402 | 459 | ||
403 | /* clear int stat */ | 460 | /* clear int stat */ |
404 | bfin_write_TWI_INT_STAT(MERR|MCOMP|XMTSERV|RCVSERV); | 461 | write_INT_STAT(iface, MERR | MCOMP | XMTSERV | RCVSERV); |
405 | 462 | ||
406 | /* Set Transmit device address */ | 463 | /* Set Transmit device address */ |
407 | bfin_write_TWI_MASTER_ADDR(addr); | 464 | write_MASTER_ADDR(iface, addr); |
408 | SSYNC(); | 465 | SSYNC(); |
409 | 466 | ||
410 | iface->timeout_timer.expires = jiffies + POLL_TIMEOUT; | 467 | iface->timeout_timer.expires = jiffies + POLL_TIMEOUT; |
@@ -412,60 +469,64 @@ int bfin_twi_smbus_xfer(struct i2c_adapter *adap, u16 addr, | |||
412 | 469 | ||
413 | switch (iface->cur_mode) { | 470 | switch (iface->cur_mode) { |
414 | case TWI_I2C_MODE_STANDARDSUB: | 471 | case TWI_I2C_MODE_STANDARDSUB: |
415 | bfin_write_TWI_XMT_DATA8(iface->command); | 472 | write_XMT_DATA8(iface, iface->command); |
416 | bfin_write_TWI_INT_MASK(MCOMP | MERR | | 473 | write_INT_MASK(iface, MCOMP | MERR | |
417 | ((iface->read_write == I2C_SMBUS_READ) ? | 474 | ((iface->read_write == I2C_SMBUS_READ) ? |
418 | RCVSERV : XMTSERV)); | 475 | RCVSERV : XMTSERV)); |
419 | SSYNC(); | 476 | SSYNC(); |
420 | 477 | ||
421 | if (iface->writeNum + 1 <= 255) | 478 | if (iface->writeNum + 1 <= 255) |
422 | bfin_write_TWI_MASTER_CTL((iface->writeNum + 1) << 6); | 479 | write_MASTER_CTL(iface, (iface->writeNum + 1) << 6); |
423 | else { | 480 | else { |
424 | bfin_write_TWI_MASTER_CTL(0xff << 6); | 481 | write_MASTER_CTL(iface, 0xff << 6); |
425 | iface->manual_stop = 1; | 482 | iface->manual_stop = 1; |
426 | } | 483 | } |
427 | /* Master enable */ | 484 | /* Master enable */ |
428 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | MEN | | 485 | write_MASTER_CTL(iface, read_MASTER_CTL(iface) | MEN | |
429 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ>100) ? FAST : 0)); | 486 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ>100) ? FAST : 0)); |
430 | break; | 487 | break; |
431 | case TWI_I2C_MODE_COMBINED: | 488 | case TWI_I2C_MODE_COMBINED: |
432 | bfin_write_TWI_XMT_DATA8(iface->command); | 489 | write_XMT_DATA8(iface, iface->command); |
433 | bfin_write_TWI_INT_MASK(MCOMP | MERR | RCVSERV | XMTSERV); | 490 | write_INT_MASK(iface, MCOMP | MERR | RCVSERV | XMTSERV); |
434 | SSYNC(); | 491 | SSYNC(); |
435 | 492 | ||
436 | if (iface->writeNum > 0) | 493 | if (iface->writeNum > 0) |
437 | bfin_write_TWI_MASTER_CTL((iface->writeNum + 1) << 6); | 494 | write_MASTER_CTL(iface, (iface->writeNum + 1) << 6); |
438 | else | 495 | else |
439 | bfin_write_TWI_MASTER_CTL(0x1 << 6); | 496 | write_MASTER_CTL(iface, 0x1 << 6); |
440 | /* Master enable */ | 497 | /* Master enable */ |
441 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | MEN | | 498 | write_MASTER_CTL(iface, read_MASTER_CTL(iface) | MEN | |
442 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ>100) ? FAST : 0)); | 499 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ>100) ? FAST : 0)); |
443 | break; | 500 | break; |
444 | default: | 501 | default: |
445 | bfin_write_TWI_MASTER_CTL(0); | 502 | write_MASTER_CTL(iface, 0); |
446 | if (size != I2C_SMBUS_QUICK) { | 503 | if (size != I2C_SMBUS_QUICK) { |
447 | /* Don't access xmit data register when this is a | 504 | /* Don't access xmit data register when this is a |
448 | * read operation. | 505 | * read operation. |
449 | */ | 506 | */ |
450 | if (iface->read_write != I2C_SMBUS_READ) { | 507 | if (iface->read_write != I2C_SMBUS_READ) { |
451 | if (iface->writeNum > 0) { | 508 | if (iface->writeNum > 0) { |
452 | bfin_write_TWI_XMT_DATA8(*(iface->transPtr++)); | 509 | write_XMT_DATA8(iface, |
510 | *(iface->transPtr++)); | ||
453 | if (iface->writeNum <= 255) | 511 | if (iface->writeNum <= 255) |
454 | bfin_write_TWI_MASTER_CTL(iface->writeNum << 6); | 512 | write_MASTER_CTL(iface, |
513 | iface->writeNum << 6); | ||
455 | else { | 514 | else { |
456 | bfin_write_TWI_MASTER_CTL(0xff << 6); | 515 | write_MASTER_CTL(iface, |
516 | 0xff << 6); | ||
457 | iface->manual_stop = 1; | 517 | iface->manual_stop = 1; |
458 | } | 518 | } |
459 | iface->writeNum--; | 519 | iface->writeNum--; |
460 | } else { | 520 | } else { |
461 | bfin_write_TWI_XMT_DATA8(iface->command); | 521 | write_XMT_DATA8(iface, iface->command); |
462 | bfin_write_TWI_MASTER_CTL(1 << 6); | 522 | write_MASTER_CTL(iface, 1 << 6); |
463 | } | 523 | } |
464 | } else { | 524 | } else { |
465 | if (iface->readNum > 0 && iface->readNum <= 255) | 525 | if (iface->readNum > 0 && iface->readNum <= 255) |
466 | bfin_write_TWI_MASTER_CTL(iface->readNum << 6); | 526 | write_MASTER_CTL(iface, |
527 | iface->readNum << 6); | ||
467 | else if (iface->readNum > 255) { | 528 | else if (iface->readNum > 255) { |
468 | bfin_write_TWI_MASTER_CTL(0xff << 6); | 529 | write_MASTER_CTL(iface, 0xff << 6); |
469 | iface->manual_stop = 1; | 530 | iface->manual_stop = 1; |
470 | } else { | 531 | } else { |
471 | del_timer(&iface->timeout_timer); | 532 | del_timer(&iface->timeout_timer); |
@@ -473,13 +534,13 @@ int bfin_twi_smbus_xfer(struct i2c_adapter *adap, u16 addr, | |||
473 | } | 534 | } |
474 | } | 535 | } |
475 | } | 536 | } |
476 | bfin_write_TWI_INT_MASK(MCOMP | MERR | | 537 | write_INT_MASK(iface, MCOMP | MERR | |
477 | ((iface->read_write == I2C_SMBUS_READ) ? | 538 | ((iface->read_write == I2C_SMBUS_READ) ? |
478 | RCVSERV : XMTSERV)); | 539 | RCVSERV : XMTSERV)); |
479 | SSYNC(); | 540 | SSYNC(); |
480 | 541 | ||
481 | /* Master enable */ | 542 | /* Master enable */ |
482 | bfin_write_TWI_MASTER_CTL(bfin_read_TWI_MASTER_CTL() | MEN | | 543 | write_MASTER_CTL(iface, read_MASTER_CTL(iface) | MEN | |
483 | ((iface->read_write == I2C_SMBUS_READ) ? MDIR : 0) | | 544 | ((iface->read_write == I2C_SMBUS_READ) ? MDIR : 0) | |
484 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ > 100) ? FAST : 0)); | 545 | ((CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ > 100) ? FAST : 0)); |
485 | break; | 546 | break; |
@@ -514,10 +575,10 @@ static struct i2c_algorithm bfin_twi_algorithm = { | |||
514 | 575 | ||
515 | static int i2c_bfin_twi_suspend(struct platform_device *dev, pm_message_t state) | 576 | static int i2c_bfin_twi_suspend(struct platform_device *dev, pm_message_t state) |
516 | { | 577 | { |
517 | /* struct bfin_twi_iface *iface = platform_get_drvdata(dev);*/ | 578 | struct bfin_twi_iface *iface = platform_get_drvdata(dev); |
518 | 579 | ||
519 | /* Disable TWI */ | 580 | /* Disable TWI */ |
520 | bfin_write_TWI_CONTROL(bfin_read_TWI_CONTROL() & ~TWI_ENA); | 581 | write_CONTROL(iface, read_CONTROL(iface) & ~TWI_ENA); |
521 | SSYNC(); | 582 | SSYNC(); |
522 | 583 | ||
523 | return 0; | 584 | return 0; |
@@ -525,24 +586,52 @@ static int i2c_bfin_twi_suspend(struct platform_device *dev, pm_message_t state) | |||
525 | 586 | ||
526 | static int i2c_bfin_twi_resume(struct platform_device *dev) | 587 | static int i2c_bfin_twi_resume(struct platform_device *dev) |
527 | { | 588 | { |
528 | /* struct bfin_twi_iface *iface = platform_get_drvdata(dev);*/ | 589 | struct bfin_twi_iface *iface = platform_get_drvdata(dev); |
529 | 590 | ||
530 | /* Enable TWI */ | 591 | /* Enable TWI */ |
531 | bfin_write_TWI_CONTROL(bfin_read_TWI_CONTROL() | TWI_ENA); | 592 | write_CONTROL(iface, read_CONTROL(iface) | TWI_ENA); |
532 | SSYNC(); | 593 | SSYNC(); |
533 | 594 | ||
534 | return 0; | 595 | return 0; |
535 | } | 596 | } |
536 | 597 | ||
537 | static int i2c_bfin_twi_probe(struct platform_device *dev) | 598 | static int i2c_bfin_twi_probe(struct platform_device *pdev) |
538 | { | 599 | { |
539 | struct bfin_twi_iface *iface = &twi_iface; | 600 | struct bfin_twi_iface *iface; |
540 | struct i2c_adapter *p_adap; | 601 | struct i2c_adapter *p_adap; |
602 | struct resource *res; | ||
541 | int rc; | 603 | int rc; |
542 | 604 | ||
605 | iface = kzalloc(sizeof(struct bfin_twi_iface), GFP_KERNEL); | ||
606 | if (!iface) { | ||
607 | dev_err(&pdev->dev, "Cannot allocate memory\n"); | ||
608 | rc = -ENOMEM; | ||
609 | goto out_error_nomem; | ||
610 | } | ||
611 | |||
543 | spin_lock_init(&(iface->lock)); | 612 | spin_lock_init(&(iface->lock)); |
544 | init_completion(&(iface->complete)); | 613 | |
545 | iface->irq = IRQ_TWI; | 614 | /* Find and map our resources */ |
615 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
616 | if (res == NULL) { | ||
617 | dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n"); | ||
618 | rc = -ENOENT; | ||
619 | goto out_error_get_res; | ||
620 | } | ||
621 | |||
622 | iface->regs_base = ioremap(res->start, res->end - res->start + 1); | ||
623 | if (iface->regs_base == NULL) { | ||
624 | dev_err(&pdev->dev, "Cannot map IO\n"); | ||
625 | rc = -ENXIO; | ||
626 | goto out_error_ioremap; | ||
627 | } | ||
628 | |||
629 | iface->irq = platform_get_irq(pdev, 0); | ||
630 | if (iface->irq < 0) { | ||
631 | dev_err(&pdev->dev, "No IRQ specified\n"); | ||
632 | rc = -ENOENT; | ||
633 | goto out_error_no_irq; | ||
634 | } | ||
546 | 635 | ||
547 | init_timer(&(iface->timeout_timer)); | 636 | init_timer(&(iface->timeout_timer)); |
548 | iface->timeout_timer.function = bfin_twi_timeout; | 637 | iface->timeout_timer.function = bfin_twi_timeout; |
@@ -550,39 +639,63 @@ static int i2c_bfin_twi_probe(struct platform_device *dev) | |||
550 | 639 | ||
551 | p_adap = &iface->adap; | 640 | p_adap = &iface->adap; |
552 | p_adap->id = I2C_HW_BLACKFIN; | 641 | p_adap->id = I2C_HW_BLACKFIN; |
553 | p_adap->nr = dev->id; | 642 | p_adap->nr = pdev->id; |
554 | strlcpy(p_adap->name, dev->name, sizeof(p_adap->name)); | 643 | strlcpy(p_adap->name, pdev->name, sizeof(p_adap->name)); |
555 | p_adap->algo = &bfin_twi_algorithm; | 644 | p_adap->algo = &bfin_twi_algorithm; |
556 | p_adap->algo_data = iface; | 645 | p_adap->algo_data = iface; |
557 | p_adap->class = I2C_CLASS_ALL; | 646 | p_adap->class = I2C_CLASS_ALL; |
558 | p_adap->dev.parent = &dev->dev; | 647 | p_adap->dev.parent = &pdev->dev; |
648 | |||
649 | rc = peripheral_request_list(pin_req[pdev->id], "i2c-bfin-twi"); | ||
650 | if (rc) { | ||
651 | dev_err(&pdev->dev, "Can't setup pin mux!\n"); | ||
652 | goto out_error_pin_mux; | ||
653 | } | ||
559 | 654 | ||
560 | rc = request_irq(iface->irq, bfin_twi_interrupt_entry, | 655 | rc = request_irq(iface->irq, bfin_twi_interrupt_entry, |
561 | IRQF_DISABLED, dev->name, iface); | 656 | IRQF_DISABLED, pdev->name, iface); |
562 | if (rc) { | 657 | if (rc) { |
563 | dev_err(&(p_adap->dev), "i2c-bfin-twi: can't get IRQ %d !\n", | 658 | dev_err(&pdev->dev, "Can't get IRQ %d !\n", iface->irq); |
564 | iface->irq); | 659 | rc = -ENODEV; |
565 | return -ENODEV; | 660 | goto out_error_req_irq; |
566 | } | 661 | } |
567 | 662 | ||
568 | /* Set TWI internal clock as 10MHz */ | 663 | /* Set TWI internal clock as 10MHz */ |
569 | bfin_write_TWI_CONTROL(((get_sclk() / 1024 / 1024 + 5) / 10) & 0x7F); | 664 | write_CONTROL(iface, ((get_sclk() / 1024 / 1024 + 5) / 10) & 0x7F); |
570 | 665 | ||
571 | /* Set Twi interface clock as specified */ | 666 | /* Set Twi interface clock as specified */ |
572 | bfin_write_TWI_CLKDIV((( 5*1024 / CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ ) | 667 | write_CLKDIV(iface, ((5*1024 / CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ) |
573 | << 8) | (( 5*1024 / CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ ) | 668 | << 8) | ((5*1024 / CONFIG_I2C_BLACKFIN_TWI_CLK_KHZ) |
574 | & 0xFF)); | 669 | & 0xFF)); |
575 | 670 | ||
576 | /* Enable TWI */ | 671 | /* Enable TWI */ |
577 | bfin_write_TWI_CONTROL(bfin_read_TWI_CONTROL() | TWI_ENA); | 672 | write_CONTROL(iface, read_CONTROL(iface) | TWI_ENA); |
578 | SSYNC(); | 673 | SSYNC(); |
579 | 674 | ||
580 | rc = i2c_add_numbered_adapter(p_adap); | 675 | rc = i2c_add_numbered_adapter(p_adap); |
581 | if (rc < 0) | 676 | if (rc < 0) { |
582 | free_irq(iface->irq, iface); | 677 | dev_err(&pdev->dev, "Can't add i2c adapter!\n"); |
583 | else | 678 | goto out_error_add_adapter; |
584 | platform_set_drvdata(dev, iface); | 679 | } |
680 | |||
681 | platform_set_drvdata(pdev, iface); | ||
585 | 682 | ||
683 | dev_info(&pdev->dev, "Blackfin BF5xx on-chip I2C TWI Contoller, " | ||
684 | "regs_base@%p\n", iface->regs_base); | ||
685 | |||
686 | return 0; | ||
687 | |||
688 | out_error_add_adapter: | ||
689 | free_irq(iface->irq, iface); | ||
690 | out_error_req_irq: | ||
691 | out_error_no_irq: | ||
692 | peripheral_free_list(pin_req[pdev->id]); | ||
693 | out_error_pin_mux: | ||
694 | iounmap(iface->regs_base); | ||
695 | out_error_ioremap: | ||
696 | out_error_get_res: | ||
697 | kfree(iface); | ||
698 | out_error_nomem: | ||
586 | return rc; | 699 | return rc; |
587 | } | 700 | } |
588 | 701 | ||
@@ -594,6 +707,9 @@ static int i2c_bfin_twi_remove(struct platform_device *pdev) | |||
594 | 707 | ||
595 | i2c_del_adapter(&(iface->adap)); | 708 | i2c_del_adapter(&(iface->adap)); |
596 | free_irq(iface->irq, iface); | 709 | free_irq(iface->irq, iface); |
710 | peripheral_free_list(pin_req[pdev->id]); | ||
711 | iounmap(iface->regs_base); | ||
712 | kfree(iface); | ||
597 | 713 | ||
598 | return 0; | 714 | return 0; |
599 | } | 715 | } |
@@ -611,8 +727,6 @@ static struct platform_driver i2c_bfin_twi_driver = { | |||
611 | 727 | ||
612 | static int __init i2c_bfin_twi_init(void) | 728 | static int __init i2c_bfin_twi_init(void) |
613 | { | 729 | { |
614 | pr_info("I2C: Blackfin I2C TWI driver\n"); | ||
615 | |||
616 | return platform_driver_register(&i2c_bfin_twi_driver); | 730 | return platform_driver_register(&i2c_bfin_twi_driver); |
617 | } | 731 | } |
618 | 732 | ||
@@ -621,9 +735,10 @@ static void __exit i2c_bfin_twi_exit(void) | |||
621 | platform_driver_unregister(&i2c_bfin_twi_driver); | 735 | platform_driver_unregister(&i2c_bfin_twi_driver); |
622 | } | 736 | } |
623 | 737 | ||
624 | MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>"); | ||
625 | MODULE_DESCRIPTION("I2C-Bus adapter routines for Blackfin TWI"); | ||
626 | MODULE_LICENSE("GPL"); | ||
627 | |||
628 | module_init(i2c_bfin_twi_init); | 738 | module_init(i2c_bfin_twi_init); |
629 | module_exit(i2c_bfin_twi_exit); | 739 | module_exit(i2c_bfin_twi_exit); |
740 | |||
741 | MODULE_AUTHOR("Bryan Wu, Sonic Zhang"); | ||
742 | MODULE_DESCRIPTION("Blackfin BF5xx on-chip I2C TWI Contoller Driver"); | ||
743 | MODULE_LICENSE("GPL"); | ||
744 | MODULE_ALIAS("platform:i2c-bfin-twi"); | ||
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c index fde26345a379..7ecbfc429b19 100644 --- a/drivers/i2c/busses/i2c-davinci.c +++ b/drivers/i2c/busses/i2c-davinci.c | |||
@@ -328,7 +328,7 @@ i2c_davinci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num) | |||
328 | int i; | 328 | int i; |
329 | int ret; | 329 | int ret; |
330 | 330 | ||
331 | dev_dbg(dev->dev, "%s: msgs: %d\n", __FUNCTION__, num); | 331 | dev_dbg(dev->dev, "%s: msgs: %d\n", __func__, num); |
332 | 332 | ||
333 | ret = i2c_davinci_wait_bus_not_busy(dev, 1); | 333 | ret = i2c_davinci_wait_bus_not_busy(dev, 1); |
334 | if (ret < 0) { | 334 | if (ret < 0) { |
@@ -342,7 +342,7 @@ i2c_davinci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num) | |||
342 | return ret; | 342 | return ret; |
343 | } | 343 | } |
344 | 344 | ||
345 | dev_dbg(dev->dev, "%s:%d ret: %d\n", __FUNCTION__, __LINE__, ret); | 345 | dev_dbg(dev->dev, "%s:%d ret: %d\n", __func__, __LINE__, ret); |
346 | 346 | ||
347 | return num; | 347 | return num; |
348 | } | 348 | } |
@@ -364,7 +364,7 @@ static irqreturn_t i2c_davinci_isr(int this_irq, void *dev_id) | |||
364 | u16 w; | 364 | u16 w; |
365 | 365 | ||
366 | while ((stat = davinci_i2c_read_reg(dev, DAVINCI_I2C_IVR_REG))) { | 366 | while ((stat = davinci_i2c_read_reg(dev, DAVINCI_I2C_IVR_REG))) { |
367 | dev_dbg(dev->dev, "%s: stat=0x%x\n", __FUNCTION__, stat); | 367 | dev_dbg(dev->dev, "%s: stat=0x%x\n", __func__, stat); |
368 | if (count++ == 100) { | 368 | if (count++ == 100) { |
369 | dev_warn(dev->dev, "Too much work in one IRQ\n"); | 369 | dev_warn(dev->dev, "Too much work in one IRQ\n"); |
370 | break; | 370 | break; |
@@ -553,6 +553,9 @@ static int davinci_i2c_remove(struct platform_device *pdev) | |||
553 | return 0; | 553 | return 0; |
554 | } | 554 | } |
555 | 555 | ||
556 | /* work with hotplug and coldplug */ | ||
557 | MODULE_ALIAS("platform:i2c_davinci"); | ||
558 | |||
556 | static struct platform_driver davinci_i2c_driver = { | 559 | static struct platform_driver davinci_i2c_driver = { |
557 | .probe = davinci_i2c_probe, | 560 | .probe = davinci_i2c_probe, |
558 | .remove = davinci_i2c_remove, | 561 | .remove = davinci_i2c_remove, |
diff --git a/drivers/i2c/busses/i2c-gpio.c b/drivers/i2c/busses/i2c-gpio.c index 3ca19fc234fb..7c1b762aa681 100644 --- a/drivers/i2c/busses/i2c-gpio.c +++ b/drivers/i2c/busses/i2c-gpio.c | |||
@@ -220,3 +220,4 @@ module_exit(i2c_gpio_exit); | |||
220 | MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>"); | 220 | MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>"); |
221 | MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver"); | 221 | MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver"); |
222 | MODULE_LICENSE("GPL"); | 222 | MODULE_LICENSE("GPL"); |
223 | MODULE_ALIAS("platform:i2c-gpio"); | ||
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c index 22bb247d0e60..85dbf34382e1 100644 --- a/drivers/i2c/busses/i2c-ibm_iic.c +++ b/drivers/i2c/busses/i2c-ibm_iic.c | |||
@@ -6,6 +6,9 @@ | |||
6 | * Copyright (c) 2003, 2004 Zultys Technologies. | 6 | * Copyright (c) 2003, 2004 Zultys Technologies. |
7 | * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net> | 7 | * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net> |
8 | * | 8 | * |
9 | * Copyright (c) 2008 PIKA Technologies | ||
10 | * Sean MacLennan <smaclennan@pikatech.com> | ||
11 | * | ||
9 | * Based on original work by | 12 | * Based on original work by |
10 | * Ian DaSilva <idasilva@mvista.com> | 13 | * Ian DaSilva <idasilva@mvista.com> |
11 | * Armin Kuster <akuster@mvista.com> | 14 | * Armin Kuster <akuster@mvista.com> |
@@ -39,12 +42,17 @@ | |||
39 | #include <asm/io.h> | 42 | #include <asm/io.h> |
40 | #include <linux/i2c.h> | 43 | #include <linux/i2c.h> |
41 | #include <linux/i2c-id.h> | 44 | #include <linux/i2c-id.h> |
45 | |||
46 | #ifdef CONFIG_IBM_OCP | ||
42 | #include <asm/ocp.h> | 47 | #include <asm/ocp.h> |
43 | #include <asm/ibm4xx.h> | 48 | #include <asm/ibm4xx.h> |
49 | #else | ||
50 | #include <linux/of_platform.h> | ||
51 | #endif | ||
44 | 52 | ||
45 | #include "i2c-ibm_iic.h" | 53 | #include "i2c-ibm_iic.h" |
46 | 54 | ||
47 | #define DRIVER_VERSION "2.1" | 55 | #define DRIVER_VERSION "2.2" |
48 | 56 | ||
49 | MODULE_DESCRIPTION("IBM IIC driver v" DRIVER_VERSION); | 57 | MODULE_DESCRIPTION("IBM IIC driver v" DRIVER_VERSION); |
50 | MODULE_LICENSE("GPL"); | 58 | MODULE_LICENSE("GPL"); |
@@ -650,13 +658,14 @@ static inline u8 iic_clckdiv(unsigned int opb) | |||
650 | opb /= 1000000; | 658 | opb /= 1000000; |
651 | 659 | ||
652 | if (opb < 20 || opb > 150){ | 660 | if (opb < 20 || opb > 150){ |
653 | printk(KERN_CRIT "ibm-iic: invalid OPB clock frequency %u MHz\n", | 661 | printk(KERN_WARNING "ibm-iic: invalid OPB clock frequency %u MHz\n", |
654 | opb); | 662 | opb); |
655 | opb = opb < 20 ? 20 : 150; | 663 | opb = opb < 20 ? 20 : 150; |
656 | } | 664 | } |
657 | return (u8)((opb + 9) / 10 - 1); | 665 | return (u8)((opb + 9) / 10 - 1); |
658 | } | 666 | } |
659 | 667 | ||
668 | #ifdef CONFIG_IBM_OCP | ||
660 | /* | 669 | /* |
661 | * Register single IIC interface | 670 | * Register single IIC interface |
662 | */ | 671 | */ |
@@ -672,7 +681,7 @@ static int __devinit iic_probe(struct ocp_device *ocp){ | |||
672 | ocp->def->index); | 681 | ocp->def->index); |
673 | 682 | ||
674 | if (!(dev = kzalloc(sizeof(*dev), GFP_KERNEL))) { | 683 | if (!(dev = kzalloc(sizeof(*dev), GFP_KERNEL))) { |
675 | printk(KERN_CRIT "ibm-iic%d: failed to allocate device data\n", | 684 | printk(KERN_ERR "ibm-iic%d: failed to allocate device data\n", |
676 | ocp->def->index); | 685 | ocp->def->index); |
677 | return -ENOMEM; | 686 | return -ENOMEM; |
678 | } | 687 | } |
@@ -687,7 +696,7 @@ static int __devinit iic_probe(struct ocp_device *ocp){ | |||
687 | } | 696 | } |
688 | 697 | ||
689 | if (!(dev->vaddr = ioremap(ocp->def->paddr, sizeof(struct iic_regs)))){ | 698 | if (!(dev->vaddr = ioremap(ocp->def->paddr, sizeof(struct iic_regs)))){ |
690 | printk(KERN_CRIT "ibm-iic%d: failed to ioremap device registers\n", | 699 | printk(KERN_ERR "ibm-iic%d: failed to ioremap device registers\n", |
691 | dev->idx); | 700 | dev->idx); |
692 | ret = -ENXIO; | 701 | ret = -ENXIO; |
693 | goto fail2; | 702 | goto fail2; |
@@ -745,7 +754,7 @@ static int __devinit iic_probe(struct ocp_device *ocp){ | |||
745 | adap->nr = dev->idx >= 0 ? dev->idx : 0; | 754 | adap->nr = dev->idx >= 0 ? dev->idx : 0; |
746 | 755 | ||
747 | if ((ret = i2c_add_numbered_adapter(adap)) < 0) { | 756 | if ((ret = i2c_add_numbered_adapter(adap)) < 0) { |
748 | printk(KERN_CRIT "ibm-iic%d: failed to register i2c adapter\n", | 757 | printk(KERN_ERR "ibm-iic%d: failed to register i2c adapter\n", |
749 | dev->idx); | 758 | dev->idx); |
750 | goto fail; | 759 | goto fail; |
751 | } | 760 | } |
@@ -778,7 +787,7 @@ static void __devexit iic_remove(struct ocp_device *ocp) | |||
778 | struct ibm_iic_private* dev = (struct ibm_iic_private*)ocp_get_drvdata(ocp); | 787 | struct ibm_iic_private* dev = (struct ibm_iic_private*)ocp_get_drvdata(ocp); |
779 | BUG_ON(dev == NULL); | 788 | BUG_ON(dev == NULL); |
780 | if (i2c_del_adapter(&dev->adap)){ | 789 | if (i2c_del_adapter(&dev->adap)){ |
781 | printk(KERN_CRIT "ibm-iic%d: failed to delete i2c adapter :(\n", | 790 | printk(KERN_ERR "ibm-iic%d: failed to delete i2c adapter :(\n", |
782 | dev->idx); | 791 | dev->idx); |
783 | /* That's *very* bad, just shutdown IRQ ... */ | 792 | /* That's *very* bad, just shutdown IRQ ... */ |
784 | if (dev->irq >= 0){ | 793 | if (dev->irq >= 0){ |
@@ -828,5 +837,181 @@ static void __exit iic_exit(void) | |||
828 | ocp_unregister_driver(&ibm_iic_driver); | 837 | ocp_unregister_driver(&ibm_iic_driver); |
829 | } | 838 | } |
830 | 839 | ||
840 | #else /* !CONFIG_IBM_OCP */ | ||
841 | |||
842 | static int __devinit iic_request_irq(struct of_device *ofdev, | ||
843 | struct ibm_iic_private *dev) | ||
844 | { | ||
845 | struct device_node *np = ofdev->node; | ||
846 | int irq; | ||
847 | |||
848 | if (iic_force_poll) | ||
849 | return NO_IRQ; | ||
850 | |||
851 | irq = irq_of_parse_and_map(np, 0); | ||
852 | if (irq == NO_IRQ) { | ||
853 | dev_err(&ofdev->dev, "irq_of_parse_and_map failed\n"); | ||
854 | return NO_IRQ; | ||
855 | } | ||
856 | |||
857 | /* Disable interrupts until we finish initialization, assumes | ||
858 | * level-sensitive IRQ setup... | ||
859 | */ | ||
860 | iic_interrupt_mode(dev, 0); | ||
861 | if (request_irq(irq, iic_handler, 0, "IBM IIC", dev)) { | ||
862 | dev_err(&ofdev->dev, "request_irq %d failed\n", irq); | ||
863 | /* Fallback to the polling mode */ | ||
864 | return NO_IRQ; | ||
865 | } | ||
866 | |||
867 | return irq; | ||
868 | } | ||
869 | |||
870 | /* | ||
871 | * Register single IIC interface | ||
872 | */ | ||
873 | static int __devinit iic_probe(struct of_device *ofdev, | ||
874 | const struct of_device_id *match) | ||
875 | { | ||
876 | struct device_node *np = ofdev->node; | ||
877 | struct ibm_iic_private *dev; | ||
878 | struct i2c_adapter *adap; | ||
879 | const u32 *indexp, *freq; | ||
880 | int ret; | ||
881 | |||
882 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); | ||
883 | if (!dev) { | ||
884 | dev_err(&ofdev->dev, "failed to allocate device data\n"); | ||
885 | return -ENOMEM; | ||
886 | } | ||
887 | |||
888 | dev_set_drvdata(&ofdev->dev, dev); | ||
889 | |||
890 | indexp = of_get_property(np, "index", NULL); | ||
891 | if (!indexp) { | ||
892 | dev_err(&ofdev->dev, "no index specified\n"); | ||
893 | ret = -EINVAL; | ||
894 | goto error_cleanup; | ||
895 | } | ||
896 | dev->idx = *indexp; | ||
897 | |||
898 | dev->vaddr = of_iomap(np, 0); | ||
899 | if (dev->vaddr == NULL) { | ||
900 | dev_err(&ofdev->dev, "failed to iomap device\n"); | ||
901 | ret = -ENXIO; | ||
902 | goto error_cleanup; | ||
903 | } | ||
904 | |||
905 | init_waitqueue_head(&dev->wq); | ||
906 | |||
907 | dev->irq = iic_request_irq(ofdev, dev); | ||
908 | if (dev->irq == NO_IRQ) | ||
909 | dev_warn(&ofdev->dev, "using polling mode\n"); | ||
910 | |||
911 | /* Board specific settings */ | ||
912 | if (iic_force_fast || of_get_property(np, "fast-mode", NULL)) | ||
913 | dev->fast_mode = 1; | ||
914 | |||
915 | freq = of_get_property(np, "clock-frequency", NULL); | ||
916 | if (freq == NULL) { | ||
917 | freq = of_get_property(np->parent, "clock-frequency", NULL); | ||
918 | if (freq == NULL) { | ||
919 | dev_err(&ofdev->dev, "Unable to get bus frequency\n"); | ||
920 | ret = -EINVAL; | ||
921 | goto error_cleanup; | ||
922 | } | ||
923 | } | ||
924 | |||
925 | dev->clckdiv = iic_clckdiv(*freq); | ||
926 | dev_dbg(&ofdev->dev, "clckdiv = %d\n", dev->clckdiv); | ||
927 | |||
928 | /* Initialize IIC interface */ | ||
929 | iic_dev_init(dev); | ||
930 | |||
931 | /* Register it with i2c layer */ | ||
932 | adap = &dev->adap; | ||
933 | adap->dev.parent = &ofdev->dev; | ||
934 | strlcpy(adap->name, "IBM IIC", sizeof(adap->name)); | ||
935 | i2c_set_adapdata(adap, dev); | ||
936 | adap->id = I2C_HW_OCP; | ||
937 | adap->class = I2C_CLASS_HWMON; | ||
938 | adap->algo = &iic_algo; | ||
939 | adap->timeout = 1; | ||
940 | adap->nr = dev->idx; | ||
941 | |||
942 | ret = i2c_add_numbered_adapter(adap); | ||
943 | if (ret < 0) { | ||
944 | dev_err(&ofdev->dev, "failed to register i2c adapter\n"); | ||
945 | goto error_cleanup; | ||
946 | } | ||
947 | |||
948 | dev_info(&ofdev->dev, "using %s mode\n", | ||
949 | dev->fast_mode ? "fast (400 kHz)" : "standard (100 kHz)"); | ||
950 | |||
951 | return 0; | ||
952 | |||
953 | error_cleanup: | ||
954 | if (dev->irq != NO_IRQ) { | ||
955 | iic_interrupt_mode(dev, 0); | ||
956 | free_irq(dev->irq, dev); | ||
957 | } | ||
958 | |||
959 | if (dev->vaddr) | ||
960 | iounmap(dev->vaddr); | ||
961 | |||
962 | dev_set_drvdata(&ofdev->dev, NULL); | ||
963 | kfree(dev); | ||
964 | return ret; | ||
965 | } | ||
966 | |||
967 | /* | ||
968 | * Cleanup initialized IIC interface | ||
969 | */ | ||
970 | static int __devexit iic_remove(struct of_device *ofdev) | ||
971 | { | ||
972 | struct ibm_iic_private *dev = dev_get_drvdata(&ofdev->dev); | ||
973 | |||
974 | dev_set_drvdata(&ofdev->dev, NULL); | ||
975 | |||
976 | i2c_del_adapter(&dev->adap); | ||
977 | |||
978 | if (dev->irq != NO_IRQ) { | ||
979 | iic_interrupt_mode(dev, 0); | ||
980 | free_irq(dev->irq, dev); | ||
981 | } | ||
982 | |||
983 | iounmap(dev->vaddr); | ||
984 | kfree(dev); | ||
985 | |||
986 | return 0; | ||
987 | } | ||
988 | |||
989 | static const struct of_device_id ibm_iic_match[] = { | ||
990 | { .compatible = "ibm,iic-405ex", }, | ||
991 | { .compatible = "ibm,iic-405gp", }, | ||
992 | { .compatible = "ibm,iic-440gp", }, | ||
993 | { .compatible = "ibm,iic-440gpx", }, | ||
994 | { .compatible = "ibm,iic-440grx", }, | ||
995 | {} | ||
996 | }; | ||
997 | |||
998 | static struct of_platform_driver ibm_iic_driver = { | ||
999 | .name = "ibm-iic", | ||
1000 | .match_table = ibm_iic_match, | ||
1001 | .probe = iic_probe, | ||
1002 | .remove = __devexit_p(iic_remove), | ||
1003 | }; | ||
1004 | |||
1005 | static int __init iic_init(void) | ||
1006 | { | ||
1007 | return of_register_platform_driver(&ibm_iic_driver); | ||
1008 | } | ||
1009 | |||
1010 | static void __exit iic_exit(void) | ||
1011 | { | ||
1012 | of_unregister_platform_driver(&ibm_iic_driver); | ||
1013 | } | ||
1014 | #endif /* CONFIG_IBM_OCP */ | ||
1015 | |||
831 | module_init(iic_init); | 1016 | module_init(iic_init); |
832 | module_exit(iic_exit); | 1017 | module_exit(iic_exit); |
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c index ab41400c883e..39884e797594 100644 --- a/drivers/i2c/busses/i2c-iop3xx.c +++ b/drivers/i2c/busses/i2c-iop3xx.c | |||
@@ -550,3 +550,4 @@ module_exit (i2c_iop3xx_exit); | |||
550 | MODULE_AUTHOR("D-TACQ Solutions Ltd <www.d-tacq.com>"); | 550 | MODULE_AUTHOR("D-TACQ Solutions Ltd <www.d-tacq.com>"); |
551 | MODULE_DESCRIPTION("IOP3xx iic algorithm and driver"); | 551 | MODULE_DESCRIPTION("IOP3xx iic algorithm and driver"); |
552 | MODULE_LICENSE("GPL"); | 552 | MODULE_LICENSE("GPL"); |
553 | MODULE_ALIAS("platform:IOP3xx-I2C"); | ||
diff --git a/drivers/i2c/busses/i2c-ixp2000.c b/drivers/i2c/busses/i2c-ixp2000.c index 6352121a2827..5af9e6521e6c 100644 --- a/drivers/i2c/busses/i2c-ixp2000.c +++ b/drivers/i2c/busses/i2c-ixp2000.c | |||
@@ -164,4 +164,5 @@ module_exit(ixp2000_i2c_exit); | |||
164 | MODULE_AUTHOR ("Deepak Saxena <dsaxena@plexity.net>"); | 164 | MODULE_AUTHOR ("Deepak Saxena <dsaxena@plexity.net>"); |
165 | MODULE_DESCRIPTION("IXP2000 GPIO-based I2C bus driver"); | 165 | MODULE_DESCRIPTION("IXP2000 GPIO-based I2C bus driver"); |
166 | MODULE_LICENSE("GPL"); | 166 | MODULE_LICENSE("GPL"); |
167 | MODULE_ALIAS("platform:IXP2000-I2C"); | ||
167 | 168 | ||
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c index bbe787b243b7..18beb0ad7bf3 100644 --- a/drivers/i2c/busses/i2c-mpc.c +++ b/drivers/i2c/busses/i2c-mpc.c | |||
@@ -392,6 +392,9 @@ static int fsl_i2c_remove(struct platform_device *pdev) | |||
392 | return 0; | 392 | return 0; |
393 | }; | 393 | }; |
394 | 394 | ||
395 | /* work with hotplug and coldplug */ | ||
396 | MODULE_ALIAS("platform:fsl-i2c"); | ||
397 | |||
395 | /* Structure for a device driver */ | 398 | /* Structure for a device driver */ |
396 | static struct platform_driver fsl_i2c_driver = { | 399 | static struct platform_driver fsl_i2c_driver = { |
397 | .probe = fsl_i2c_probe, | 400 | .probe = fsl_i2c_probe, |
diff --git a/drivers/i2c/busses/i2c-ocores.c b/drivers/i2c/busses/i2c-ocores.c index e417c2c3ca22..f145692cbb76 100644 --- a/drivers/i2c/busses/i2c-ocores.c +++ b/drivers/i2c/busses/i2c-ocores.c | |||
@@ -312,6 +312,9 @@ static int __devexit ocores_i2c_remove(struct platform_device* pdev) | |||
312 | return 0; | 312 | return 0; |
313 | } | 313 | } |
314 | 314 | ||
315 | /* work with hotplug and coldplug */ | ||
316 | MODULE_ALIAS("platform:ocores-i2c"); | ||
317 | |||
315 | static struct platform_driver ocores_i2c_driver = { | 318 | static struct platform_driver ocores_i2c_driver = { |
316 | .probe = ocores_i2c_probe, | 319 | .probe = ocores_i2c_probe, |
317 | .remove = __devexit_p(ocores_i2c_remove), | 320 | .remove = __devexit_p(ocores_i2c_remove), |
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c index 7ba31770d773..e7eb7bf9ddec 100644 --- a/drivers/i2c/busses/i2c-omap.c +++ b/drivers/i2c/busses/i2c-omap.c | |||
@@ -693,3 +693,4 @@ module_exit(omap_i2c_exit_driver); | |||
693 | MODULE_AUTHOR("MontaVista Software, Inc. (and others)"); | 693 | MODULE_AUTHOR("MontaVista Software, Inc. (and others)"); |
694 | MODULE_DESCRIPTION("TI OMAP I2C bus adapter"); | 694 | MODULE_DESCRIPTION("TI OMAP I2C bus adapter"); |
695 | MODULE_LICENSE("GPL"); | 695 | MODULE_LICENSE("GPL"); |
696 | MODULE_ALIAS("platform:i2c_omap"); | ||
diff --git a/drivers/i2c/busses/i2c-pca-isa.c b/drivers/i2c/busses/i2c-pca-isa.c index 496ee875eb4f..a119784bae10 100644 --- a/drivers/i2c/busses/i2c-pca-isa.c +++ b/drivers/i2c/busses/i2c-pca-isa.c | |||
@@ -1,6 +1,7 @@ | |||
1 | /* | 1 | /* |
2 | * i2c-pca-isa.c driver for PCA9564 on ISA boards | 2 | * i2c-pca-isa.c driver for PCA9564 on ISA boards |
3 | * Copyright (C) 2004 Arcom Control Systems | 3 | * Copyright (C) 2004 Arcom Control Systems |
4 | * Copyright (C) 2008 Pengutronix | ||
4 | * | 5 | * |
5 | * This program is free software; you can redistribute it and/or modify | 6 | * This program is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License as published by | 7 | * it under the terms of the GNU General Public License as published by |
@@ -22,11 +23,9 @@ | |||
22 | #include <linux/module.h> | 23 | #include <linux/module.h> |
23 | #include <linux/moduleparam.h> | 24 | #include <linux/moduleparam.h> |
24 | #include <linux/delay.h> | 25 | #include <linux/delay.h> |
25 | #include <linux/slab.h> | ||
26 | #include <linux/init.h> | 26 | #include <linux/init.h> |
27 | #include <linux/interrupt.h> | 27 | #include <linux/interrupt.h> |
28 | #include <linux/wait.h> | 28 | #include <linux/wait.h> |
29 | |||
30 | #include <linux/isa.h> | 29 | #include <linux/isa.h> |
31 | #include <linux/i2c.h> | 30 | #include <linux/i2c.h> |
32 | #include <linux/i2c-algo-pca.h> | 31 | #include <linux/i2c-algo-pca.h> |
@@ -34,13 +33,9 @@ | |||
34 | #include <asm/io.h> | 33 | #include <asm/io.h> |
35 | #include <asm/irq.h> | 34 | #include <asm/irq.h> |
36 | 35 | ||
37 | #include "../algos/i2c-algo-pca.h" | 36 | #define DRIVER "i2c-pca-isa" |
38 | |||
39 | #define IO_SIZE 4 | 37 | #define IO_SIZE 4 |
40 | 38 | ||
41 | #undef DEBUG_IO | ||
42 | //#define DEBUG_IO | ||
43 | |||
44 | static unsigned long base = 0x330; | 39 | static unsigned long base = 0x330; |
45 | static int irq = 10; | 40 | static int irq = 10; |
46 | 41 | ||
@@ -48,22 +43,9 @@ static int irq = 10; | |||
48 | * in the actual clock rate */ | 43 | * in the actual clock rate */ |
49 | static int clock = I2C_PCA_CON_59kHz; | 44 | static int clock = I2C_PCA_CON_59kHz; |
50 | 45 | ||
51 | static int own = 0x55; | ||
52 | |||
53 | static wait_queue_head_t pca_wait; | 46 | static wait_queue_head_t pca_wait; |
54 | 47 | ||
55 | static int pca_isa_getown(struct i2c_algo_pca_data *adap) | 48 | static void pca_isa_writebyte(void *pd, int reg, int val) |
56 | { | ||
57 | return (own); | ||
58 | } | ||
59 | |||
60 | static int pca_isa_getclock(struct i2c_algo_pca_data *adap) | ||
61 | { | ||
62 | return (clock); | ||
63 | } | ||
64 | |||
65 | static void | ||
66 | pca_isa_writebyte(struct i2c_algo_pca_data *adap, int reg, int val) | ||
67 | { | 49 | { |
68 | #ifdef DEBUG_IO | 50 | #ifdef DEBUG_IO |
69 | static char *names[] = { "T/O", "DAT", "ADR", "CON" }; | 51 | static char *names[] = { "T/O", "DAT", "ADR", "CON" }; |
@@ -72,44 +54,49 @@ pca_isa_writebyte(struct i2c_algo_pca_data *adap, int reg, int val) | |||
72 | outb(val, base+reg); | 54 | outb(val, base+reg); |
73 | } | 55 | } |
74 | 56 | ||
75 | static int | 57 | static int pca_isa_readbyte(void *pd, int reg) |
76 | pca_isa_readbyte(struct i2c_algo_pca_data *adap, int reg) | ||
77 | { | 58 | { |
78 | int res = inb(base+reg); | 59 | int res = inb(base+reg); |
79 | #ifdef DEBUG_IO | 60 | #ifdef DEBUG_IO |
80 | { | 61 | { |
81 | static char *names[] = { "STA", "DAT", "ADR", "CON" }; | 62 | static char *names[] = { "STA", "DAT", "ADR", "CON" }; |
82 | printk("*** read %s => %#04x\n", names[reg], res); | 63 | printk("*** read %s => %#04x\n", names[reg], res); |
83 | } | 64 | } |
84 | #endif | 65 | #endif |
85 | return res; | 66 | return res; |
86 | } | 67 | } |
87 | 68 | ||
88 | static int pca_isa_waitforinterrupt(struct i2c_algo_pca_data *adap) | 69 | static int pca_isa_waitforcompletion(void *pd) |
89 | { | 70 | { |
90 | int ret = 0; | 71 | int ret = 0; |
91 | 72 | ||
92 | if (irq > -1) { | 73 | if (irq > -1) { |
93 | ret = wait_event_interruptible(pca_wait, | 74 | ret = wait_event_interruptible(pca_wait, |
94 | pca_isa_readbyte(adap, I2C_PCA_CON) & I2C_PCA_CON_SI); | 75 | pca_isa_readbyte(pd, I2C_PCA_CON) & I2C_PCA_CON_SI); |
95 | } else { | 76 | } else { |
96 | while ((pca_isa_readbyte(adap, I2C_PCA_CON) & I2C_PCA_CON_SI) == 0) | 77 | while ((pca_isa_readbyte(pd, I2C_PCA_CON) & I2C_PCA_CON_SI) == 0) |
97 | udelay(100); | 78 | udelay(100); |
98 | } | 79 | } |
99 | return ret; | 80 | return ret; |
100 | } | 81 | } |
101 | 82 | ||
83 | static void pca_isa_resetchip(void *pd) | ||
84 | { | ||
85 | /* apparently only an external reset will do it. not a lot can be done */ | ||
86 | printk(KERN_WARNING DRIVER ": Haven't figured out how to do a reset yet\n"); | ||
87 | } | ||
88 | |||
102 | static irqreturn_t pca_handler(int this_irq, void *dev_id) { | 89 | static irqreturn_t pca_handler(int this_irq, void *dev_id) { |
103 | wake_up_interruptible(&pca_wait); | 90 | wake_up_interruptible(&pca_wait); |
104 | return IRQ_HANDLED; | 91 | return IRQ_HANDLED; |
105 | } | 92 | } |
106 | 93 | ||
107 | static struct i2c_algo_pca_data pca_isa_data = { | 94 | static struct i2c_algo_pca_data pca_isa_data = { |
108 | .get_own = pca_isa_getown, | 95 | /* .data intentionally left NULL, not needed with ISA */ |
109 | .get_clock = pca_isa_getclock, | ||
110 | .write_byte = pca_isa_writebyte, | 96 | .write_byte = pca_isa_writebyte, |
111 | .read_byte = pca_isa_readbyte, | 97 | .read_byte = pca_isa_readbyte, |
112 | .wait_for_interrupt = pca_isa_waitforinterrupt, | 98 | .wait_for_completion = pca_isa_waitforcompletion, |
99 | .reset_chip = pca_isa_resetchip, | ||
113 | }; | 100 | }; |
114 | 101 | ||
115 | static struct i2c_adapter pca_isa_ops = { | 102 | static struct i2c_adapter pca_isa_ops = { |
@@ -117,6 +104,7 @@ static struct i2c_adapter pca_isa_ops = { | |||
117 | .id = I2C_HW_A_ISA, | 104 | .id = I2C_HW_A_ISA, |
118 | .algo_data = &pca_isa_data, | 105 | .algo_data = &pca_isa_data, |
119 | .name = "PCA9564 ISA Adapter", | 106 | .name = "PCA9564 ISA Adapter", |
107 | .timeout = 100, | ||
120 | }; | 108 | }; |
121 | 109 | ||
122 | static int __devinit pca_isa_probe(struct device *dev, unsigned int id) | 110 | static int __devinit pca_isa_probe(struct device *dev, unsigned int id) |
@@ -144,6 +132,7 @@ static int __devinit pca_isa_probe(struct device *dev, unsigned int id) | |||
144 | } | 132 | } |
145 | } | 133 | } |
146 | 134 | ||
135 | pca_isa_data.i2c_clock = clock; | ||
147 | if (i2c_pca_add_bus(&pca_isa_ops) < 0) { | 136 | if (i2c_pca_add_bus(&pca_isa_ops) < 0) { |
148 | dev_err(dev, "Failed to add i2c bus\n"); | 137 | dev_err(dev, "Failed to add i2c bus\n"); |
149 | goto out_irq; | 138 | goto out_irq; |
@@ -178,7 +167,7 @@ static struct isa_driver pca_isa_driver = { | |||
178 | .remove = __devexit_p(pca_isa_remove), | 167 | .remove = __devexit_p(pca_isa_remove), |
179 | .driver = { | 168 | .driver = { |
180 | .owner = THIS_MODULE, | 169 | .owner = THIS_MODULE, |
181 | .name = "i2c-pca-isa", | 170 | .name = DRIVER, |
182 | } | 171 | } |
183 | }; | 172 | }; |
184 | 173 | ||
@@ -204,7 +193,5 @@ MODULE_PARM_DESC(irq, "IRQ"); | |||
204 | module_param(clock, int, 0); | 193 | module_param(clock, int, 0); |
205 | MODULE_PARM_DESC(clock, "Clock rate as described in table 1 of PCA9564 datasheet"); | 194 | MODULE_PARM_DESC(clock, "Clock rate as described in table 1 of PCA9564 datasheet"); |
206 | 195 | ||
207 | module_param(own, int, 0); /* the driver can't do slave mode, so there's no real point in this */ | ||
208 | |||
209 | module_init(pca_isa_init); | 196 | module_init(pca_isa_init); |
210 | module_exit(pca_isa_exit); | 197 | module_exit(pca_isa_exit); |
diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c new file mode 100644 index 000000000000..9d75f51e8f0e --- /dev/null +++ b/drivers/i2c/busses/i2c-pca-platform.c | |||
@@ -0,0 +1,298 @@ | |||
1 | /* | ||
2 | * i2c_pca_platform.c | ||
3 | * | ||
4 | * Platform driver for the PCA9564 I2C controller. | ||
5 | * | ||
6 | * Copyright (C) 2008 Pengutronix | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | |||
12 | */ | ||
13 | #include <linux/kernel.h> | ||
14 | #include <linux/module.h> | ||
15 | #include <linux/init.h> | ||
16 | #include <linux/slab.h> | ||
17 | #include <linux/delay.h> | ||
18 | #include <linux/errno.h> | ||
19 | #include <linux/i2c.h> | ||
20 | #include <linux/interrupt.h> | ||
21 | #include <linux/platform_device.h> | ||
22 | #include <linux/i2c-algo-pca.h> | ||
23 | #include <linux/i2c-pca-platform.h> | ||
24 | #include <linux/gpio.h> | ||
25 | |||
26 | #include <asm/irq.h> | ||
27 | #include <asm/io.h> | ||
28 | |||
29 | #define res_len(r) ((r)->end - (r)->start + 1) | ||
30 | |||
31 | struct i2c_pca_pf_data { | ||
32 | void __iomem *reg_base; | ||
33 | int irq; /* if 0, use polling */ | ||
34 | int gpio; | ||
35 | wait_queue_head_t wait; | ||
36 | struct i2c_adapter adap; | ||
37 | struct i2c_algo_pca_data algo_data; | ||
38 | unsigned long io_base; | ||
39 | unsigned long io_size; | ||
40 | }; | ||
41 | |||
42 | /* Read/Write functions for different register alignments */ | ||
43 | |||
44 | static int i2c_pca_pf_readbyte8(void *pd, int reg) | ||
45 | { | ||
46 | struct i2c_pca_pf_data *i2c = pd; | ||
47 | return ioread8(i2c->reg_base + reg); | ||
48 | } | ||
49 | |||
50 | static int i2c_pca_pf_readbyte16(void *pd, int reg) | ||
51 | { | ||
52 | struct i2c_pca_pf_data *i2c = pd; | ||
53 | return ioread8(i2c->reg_base + reg * 2); | ||
54 | } | ||
55 | |||
56 | static int i2c_pca_pf_readbyte32(void *pd, int reg) | ||
57 | { | ||
58 | struct i2c_pca_pf_data *i2c = pd; | ||
59 | return ioread8(i2c->reg_base + reg * 4); | ||
60 | } | ||
61 | |||
62 | static void i2c_pca_pf_writebyte8(void *pd, int reg, int val) | ||
63 | { | ||
64 | struct i2c_pca_pf_data *i2c = pd; | ||
65 | iowrite8(val, i2c->reg_base + reg); | ||
66 | } | ||
67 | |||
68 | static void i2c_pca_pf_writebyte16(void *pd, int reg, int val) | ||
69 | { | ||
70 | struct i2c_pca_pf_data *i2c = pd; | ||
71 | iowrite8(val, i2c->reg_base + reg * 2); | ||
72 | } | ||
73 | |||
74 | static void i2c_pca_pf_writebyte32(void *pd, int reg, int val) | ||
75 | { | ||
76 | struct i2c_pca_pf_data *i2c = pd; | ||
77 | iowrite8(val, i2c->reg_base + reg * 4); | ||
78 | } | ||
79 | |||
80 | |||
81 | static int i2c_pca_pf_waitforcompletion(void *pd) | ||
82 | { | ||
83 | struct i2c_pca_pf_data *i2c = pd; | ||
84 | int ret = 0; | ||
85 | |||
86 | if (i2c->irq) { | ||
87 | ret = wait_event_interruptible(i2c->wait, | ||
88 | i2c->algo_data.read_byte(i2c, I2C_PCA_CON) | ||
89 | & I2C_PCA_CON_SI); | ||
90 | } else { | ||
91 | /* | ||
92 | * Do polling... | ||
93 | * XXX: Could get stuck in extreme cases! | ||
94 | * Maybe add timeout, but using irqs is preferred anyhow. | ||
95 | */ | ||
96 | while ((i2c->algo_data.read_byte(i2c, I2C_PCA_CON) | ||
97 | & I2C_PCA_CON_SI) == 0) | ||
98 | udelay(100); | ||
99 | } | ||
100 | |||
101 | return ret; | ||
102 | } | ||
103 | |||
104 | static void i2c_pca_pf_dummyreset(void *pd) | ||
105 | { | ||
106 | struct i2c_pca_pf_data *i2c = pd; | ||
107 | printk(KERN_WARNING "%s: No reset-pin found. Chip may get stuck!\n", | ||
108 | i2c->adap.name); | ||
109 | } | ||
110 | |||
111 | static void i2c_pca_pf_resetchip(void *pd) | ||
112 | { | ||
113 | struct i2c_pca_pf_data *i2c = pd; | ||
114 | |||
115 | gpio_set_value(i2c->gpio, 0); | ||
116 | ndelay(100); | ||
117 | gpio_set_value(i2c->gpio, 1); | ||
118 | } | ||
119 | |||
120 | static irqreturn_t i2c_pca_pf_handler(int this_irq, void *dev_id) | ||
121 | { | ||
122 | struct i2c_pca_pf_data *i2c = dev_id; | ||
123 | |||
124 | if ((i2c->algo_data.read_byte(i2c, I2C_PCA_CON) & I2C_PCA_CON_SI) == 0) | ||
125 | return IRQ_NONE; | ||
126 | |||
127 | wake_up_interruptible(&i2c->wait); | ||
128 | |||
129 | return IRQ_HANDLED; | ||
130 | } | ||
131 | |||
132 | |||
133 | static int __devinit i2c_pca_pf_probe(struct platform_device *pdev) | ||
134 | { | ||
135 | struct i2c_pca_pf_data *i2c; | ||
136 | struct resource *res; | ||
137 | struct i2c_pca9564_pf_platform_data *platform_data = | ||
138 | pdev->dev.platform_data; | ||
139 | int ret = 0; | ||
140 | int irq; | ||
141 | |||
142 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
143 | irq = platform_get_irq(pdev, 0); | ||
144 | /* If irq is 0, we do polling. */ | ||
145 | |||
146 | if (res == NULL) { | ||
147 | ret = -ENODEV; | ||
148 | goto e_print; | ||
149 | } | ||
150 | |||
151 | if (!request_mem_region(res->start, res_len(res), res->name)) { | ||
152 | ret = -ENOMEM; | ||
153 | goto e_print; | ||
154 | } | ||
155 | |||
156 | i2c = kzalloc(sizeof(struct i2c_pca_pf_data), GFP_KERNEL); | ||
157 | if (!i2c) { | ||
158 | ret = -ENOMEM; | ||
159 | goto e_alloc; | ||
160 | } | ||
161 | |||
162 | init_waitqueue_head(&i2c->wait); | ||
163 | |||
164 | i2c->reg_base = ioremap(res->start, res_len(res)); | ||
165 | if (!i2c->reg_base) { | ||
166 | ret = -EIO; | ||
167 | goto e_remap; | ||
168 | } | ||
169 | i2c->io_base = res->start; | ||
170 | i2c->io_size = res_len(res); | ||
171 | i2c->irq = irq; | ||
172 | |||
173 | i2c->adap.nr = pdev->id >= 0 ? pdev->id : 0; | ||
174 | i2c->adap.owner = THIS_MODULE; | ||
175 | snprintf(i2c->adap.name, sizeof(i2c->adap.name), "PCA9564 at 0x%08lx", | ||
176 | (unsigned long) res->start); | ||
177 | i2c->adap.algo_data = &i2c->algo_data; | ||
178 | i2c->adap.dev.parent = &pdev->dev; | ||
179 | i2c->adap.timeout = platform_data->timeout; | ||
180 | |||
181 | i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed; | ||
182 | i2c->algo_data.data = i2c; | ||
183 | |||
184 | switch (res->flags & IORESOURCE_MEM_TYPE_MASK) { | ||
185 | case IORESOURCE_MEM_32BIT: | ||
186 | i2c->algo_data.write_byte = i2c_pca_pf_writebyte32; | ||
187 | i2c->algo_data.read_byte = i2c_pca_pf_readbyte32; | ||
188 | break; | ||
189 | case IORESOURCE_MEM_16BIT: | ||
190 | i2c->algo_data.write_byte = i2c_pca_pf_writebyte16; | ||
191 | i2c->algo_data.read_byte = i2c_pca_pf_readbyte16; | ||
192 | break; | ||
193 | case IORESOURCE_MEM_8BIT: | ||
194 | default: | ||
195 | i2c->algo_data.write_byte = i2c_pca_pf_writebyte8; | ||
196 | i2c->algo_data.read_byte = i2c_pca_pf_readbyte8; | ||
197 | break; | ||
198 | } | ||
199 | |||
200 | i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion; | ||
201 | |||
202 | i2c->gpio = platform_data->gpio; | ||
203 | i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset; | ||
204 | |||
205 | /* Use gpio_is_valid() when in mainline */ | ||
206 | if (i2c->gpio > -1) { | ||
207 | ret = gpio_request(i2c->gpio, i2c->adap.name); | ||
208 | if (ret == 0) { | ||
209 | gpio_direction_output(i2c->gpio, 1); | ||
210 | i2c->algo_data.reset_chip = i2c_pca_pf_resetchip; | ||
211 | } else { | ||
212 | printk(KERN_WARNING "%s: Registering gpio failed!\n", | ||
213 | i2c->adap.name); | ||
214 | i2c->gpio = ret; | ||
215 | } | ||
216 | } | ||
217 | |||
218 | if (irq) { | ||
219 | ret = request_irq(irq, i2c_pca_pf_handler, | ||
220 | IRQF_TRIGGER_FALLING, i2c->adap.name, i2c); | ||
221 | if (ret) | ||
222 | goto e_reqirq; | ||
223 | } | ||
224 | |||
225 | if (i2c_pca_add_numbered_bus(&i2c->adap) < 0) { | ||
226 | ret = -ENODEV; | ||
227 | goto e_adapt; | ||
228 | } | ||
229 | |||
230 | platform_set_drvdata(pdev, i2c); | ||
231 | |||
232 | printk(KERN_INFO "%s registered.\n", i2c->adap.name); | ||
233 | |||
234 | return 0; | ||
235 | |||
236 | e_adapt: | ||
237 | if (irq) | ||
238 | free_irq(irq, i2c); | ||
239 | e_reqirq: | ||
240 | if (i2c->gpio > -1) | ||
241 | gpio_free(i2c->gpio); | ||
242 | |||
243 | iounmap(i2c->reg_base); | ||
244 | e_remap: | ||
245 | kfree(i2c); | ||
246 | e_alloc: | ||
247 | release_mem_region(res->start, res_len(res)); | ||
248 | e_print: | ||
249 | printk(KERN_ERR "Registering PCA9564 FAILED! (%d)\n", ret); | ||
250 | return ret; | ||
251 | } | ||
252 | |||
253 | static int __devexit i2c_pca_pf_remove(struct platform_device *pdev) | ||
254 | { | ||
255 | struct i2c_pca_pf_data *i2c = platform_get_drvdata(pdev); | ||
256 | platform_set_drvdata(pdev, NULL); | ||
257 | |||
258 | i2c_del_adapter(&i2c->adap); | ||
259 | |||
260 | if (i2c->irq) | ||
261 | free_irq(i2c->irq, i2c); | ||
262 | |||
263 | if (i2c->gpio > -1) | ||
264 | gpio_free(i2c->gpio); | ||
265 | |||
266 | iounmap(i2c->reg_base); | ||
267 | release_mem_region(i2c->io_base, i2c->io_size); | ||
268 | kfree(i2c); | ||
269 | |||
270 | return 0; | ||
271 | } | ||
272 | |||
273 | static struct platform_driver i2c_pca_pf_driver = { | ||
274 | .probe = i2c_pca_pf_probe, | ||
275 | .remove = __devexit_p(i2c_pca_pf_remove), | ||
276 | .driver = { | ||
277 | .name = "i2c-pca-platform", | ||
278 | .owner = THIS_MODULE, | ||
279 | }, | ||
280 | }; | ||
281 | |||
282 | static int __init i2c_pca_pf_init(void) | ||
283 | { | ||
284 | return platform_driver_register(&i2c_pca_pf_driver); | ||
285 | } | ||
286 | |||
287 | static void __exit i2c_pca_pf_exit(void) | ||
288 | { | ||
289 | platform_driver_unregister(&i2c_pca_pf_driver); | ||
290 | } | ||
291 | |||
292 | MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>"); | ||
293 | MODULE_DESCRIPTION("I2C-PCA9564 platform driver"); | ||
294 | MODULE_LICENSE("GPL"); | ||
295 | |||
296 | module_init(i2c_pca_pf_init); | ||
297 | module_exit(i2c_pca_pf_exit); | ||
298 | |||
diff --git a/drivers/i2c/busses/i2c-pmcmsp.c b/drivers/i2c/busses/i2c-pmcmsp.c index b03af5653c65..63b3e2c11cff 100644 --- a/drivers/i2c/busses/i2c-pmcmsp.c +++ b/drivers/i2c/busses/i2c-pmcmsp.c | |||
@@ -467,7 +467,7 @@ static enum pmcmsptwi_xfer_result pmcmsptwi_xfer_cmd( | |||
467 | (cmd->read_len == 0 || cmd->write_len == 0))) { | 467 | (cmd->read_len == 0 || cmd->write_len == 0))) { |
468 | dev_err(&pmcmsptwi_adapter.dev, | 468 | dev_err(&pmcmsptwi_adapter.dev, |
469 | "%s: Cannot transfer less than 1 byte\n", | 469 | "%s: Cannot transfer less than 1 byte\n", |
470 | __FUNCTION__); | 470 | __func__); |
471 | return -EINVAL; | 471 | return -EINVAL; |
472 | } | 472 | } |
473 | 473 | ||
@@ -475,7 +475,7 @@ static enum pmcmsptwi_xfer_result pmcmsptwi_xfer_cmd( | |||
475 | cmd->write_len > MSP_MAX_BYTES_PER_RW) { | 475 | cmd->write_len > MSP_MAX_BYTES_PER_RW) { |
476 | dev_err(&pmcmsptwi_adapter.dev, | 476 | dev_err(&pmcmsptwi_adapter.dev, |
477 | "%s: Cannot transfer more than %d bytes\n", | 477 | "%s: Cannot transfer more than %d bytes\n", |
478 | __FUNCTION__, MSP_MAX_BYTES_PER_RW); | 478 | __func__, MSP_MAX_BYTES_PER_RW); |
479 | return -EINVAL; | 479 | return -EINVAL; |
480 | } | 480 | } |
481 | 481 | ||
@@ -627,6 +627,9 @@ static struct i2c_adapter pmcmsptwi_adapter = { | |||
627 | .name = DRV_NAME, | 627 | .name = DRV_NAME, |
628 | }; | 628 | }; |
629 | 629 | ||
630 | /* work with hotplug and coldplug */ | ||
631 | MODULE_ALIAS("platform:" DRV_NAME); | ||
632 | |||
630 | static struct platform_driver pmcmsptwi_driver = { | 633 | static struct platform_driver pmcmsptwi_driver = { |
631 | .probe = pmcmsptwi_probe, | 634 | .probe = pmcmsptwi_probe, |
632 | .remove = __devexit_p(pmcmsptwi_remove), | 635 | .remove = __devexit_p(pmcmsptwi_remove), |
diff --git a/drivers/i2c/busses/i2c-pnx.c b/drivers/i2c/busses/i2c-pnx.c index f8d0dff0de7e..1ca21084ffcf 100644 --- a/drivers/i2c/busses/i2c-pnx.c +++ b/drivers/i2c/busses/i2c-pnx.c | |||
@@ -76,7 +76,7 @@ static int i2c_pnx_start(unsigned char slave_addr, struct i2c_adapter *adap) | |||
76 | { | 76 | { |
77 | struct i2c_pnx_algo_data *alg_data = adap->algo_data; | 77 | struct i2c_pnx_algo_data *alg_data = adap->algo_data; |
78 | 78 | ||
79 | dev_dbg(&adap->dev, "%s(): addr 0x%x mode %d\n", __FUNCTION__, | 79 | dev_dbg(&adap->dev, "%s(): addr 0x%x mode %d\n", __func__, |
80 | slave_addr, alg_data->mif.mode); | 80 | slave_addr, alg_data->mif.mode); |
81 | 81 | ||
82 | /* Check for 7 bit slave addresses only */ | 82 | /* Check for 7 bit slave addresses only */ |
@@ -110,14 +110,14 @@ static int i2c_pnx_start(unsigned char slave_addr, struct i2c_adapter *adap) | |||
110 | iowrite32(ioread32(I2C_REG_STS(alg_data)) | mstatus_tdi | mstatus_afi, | 110 | iowrite32(ioread32(I2C_REG_STS(alg_data)) | mstatus_tdi | mstatus_afi, |
111 | I2C_REG_STS(alg_data)); | 111 | I2C_REG_STS(alg_data)); |
112 | 112 | ||
113 | dev_dbg(&adap->dev, "%s(): sending %#x\n", __FUNCTION__, | 113 | dev_dbg(&adap->dev, "%s(): sending %#x\n", __func__, |
114 | (slave_addr << 1) | start_bit | alg_data->mif.mode); | 114 | (slave_addr << 1) | start_bit | alg_data->mif.mode); |
115 | 115 | ||
116 | /* Write the slave address, START bit and R/W bit */ | 116 | /* Write the slave address, START bit and R/W bit */ |
117 | iowrite32((slave_addr << 1) | start_bit | alg_data->mif.mode, | 117 | iowrite32((slave_addr << 1) | start_bit | alg_data->mif.mode, |
118 | I2C_REG_TX(alg_data)); | 118 | I2C_REG_TX(alg_data)); |
119 | 119 | ||
120 | dev_dbg(&adap->dev, "%s(): exit\n", __FUNCTION__); | 120 | dev_dbg(&adap->dev, "%s(): exit\n", __func__); |
121 | 121 | ||
122 | return 0; | 122 | return 0; |
123 | } | 123 | } |
@@ -135,7 +135,7 @@ static void i2c_pnx_stop(struct i2c_adapter *adap) | |||
135 | long timeout = 1000; | 135 | long timeout = 1000; |
136 | 136 | ||
137 | dev_dbg(&adap->dev, "%s(): entering: stat = %04x.\n", | 137 | dev_dbg(&adap->dev, "%s(): entering: stat = %04x.\n", |
138 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 138 | __func__, ioread32(I2C_REG_STS(alg_data))); |
139 | 139 | ||
140 | /* Write a STOP bit to TX FIFO */ | 140 | /* Write a STOP bit to TX FIFO */ |
141 | iowrite32(0xff | stop_bit, I2C_REG_TX(alg_data)); | 141 | iowrite32(0xff | stop_bit, I2C_REG_TX(alg_data)); |
@@ -149,7 +149,7 @@ static void i2c_pnx_stop(struct i2c_adapter *adap) | |||
149 | } | 149 | } |
150 | 150 | ||
151 | dev_dbg(&adap->dev, "%s(): exiting: stat = %04x.\n", | 151 | dev_dbg(&adap->dev, "%s(): exiting: stat = %04x.\n", |
152 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 152 | __func__, ioread32(I2C_REG_STS(alg_data))); |
153 | } | 153 | } |
154 | 154 | ||
155 | /** | 155 | /** |
@@ -164,7 +164,7 @@ static int i2c_pnx_master_xmit(struct i2c_adapter *adap) | |||
164 | u32 val; | 164 | u32 val; |
165 | 165 | ||
166 | dev_dbg(&adap->dev, "%s(): entering: stat = %04x.\n", | 166 | dev_dbg(&adap->dev, "%s(): entering: stat = %04x.\n", |
167 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 167 | __func__, ioread32(I2C_REG_STS(alg_data))); |
168 | 168 | ||
169 | if (alg_data->mif.len > 0) { | 169 | if (alg_data->mif.len > 0) { |
170 | /* We still have something to talk about... */ | 170 | /* We still have something to talk about... */ |
@@ -179,7 +179,7 @@ static int i2c_pnx_master_xmit(struct i2c_adapter *adap) | |||
179 | alg_data->mif.len--; | 179 | alg_data->mif.len--; |
180 | iowrite32(val, I2C_REG_TX(alg_data)); | 180 | iowrite32(val, I2C_REG_TX(alg_data)); |
181 | 181 | ||
182 | dev_dbg(&adap->dev, "%s(): xmit %#x [%d]\n", __FUNCTION__, | 182 | dev_dbg(&adap->dev, "%s(): xmit %#x [%d]\n", __func__, |
183 | val, alg_data->mif.len + 1); | 183 | val, alg_data->mif.len + 1); |
184 | 184 | ||
185 | if (alg_data->mif.len == 0) { | 185 | if (alg_data->mif.len == 0) { |
@@ -197,7 +197,7 @@ static int i2c_pnx_master_xmit(struct i2c_adapter *adap) | |||
197 | del_timer_sync(&alg_data->mif.timer); | 197 | del_timer_sync(&alg_data->mif.timer); |
198 | 198 | ||
199 | dev_dbg(&adap->dev, "%s(): Waking up xfer routine.\n", | 199 | dev_dbg(&adap->dev, "%s(): Waking up xfer routine.\n", |
200 | __FUNCTION__); | 200 | __func__); |
201 | 201 | ||
202 | complete(&alg_data->mif.complete); | 202 | complete(&alg_data->mif.complete); |
203 | } | 203 | } |
@@ -213,13 +213,13 @@ static int i2c_pnx_master_xmit(struct i2c_adapter *adap) | |||
213 | /* Stop timer. */ | 213 | /* Stop timer. */ |
214 | del_timer_sync(&alg_data->mif.timer); | 214 | del_timer_sync(&alg_data->mif.timer); |
215 | dev_dbg(&adap->dev, "%s(): Waking up xfer routine after " | 215 | dev_dbg(&adap->dev, "%s(): Waking up xfer routine after " |
216 | "zero-xfer.\n", __FUNCTION__); | 216 | "zero-xfer.\n", __func__); |
217 | 217 | ||
218 | complete(&alg_data->mif.complete); | 218 | complete(&alg_data->mif.complete); |
219 | } | 219 | } |
220 | 220 | ||
221 | dev_dbg(&adap->dev, "%s(): exiting: stat = %04x.\n", | 221 | dev_dbg(&adap->dev, "%s(): exiting: stat = %04x.\n", |
222 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 222 | __func__, ioread32(I2C_REG_STS(alg_data))); |
223 | 223 | ||
224 | return 0; | 224 | return 0; |
225 | } | 225 | } |
@@ -237,14 +237,14 @@ static int i2c_pnx_master_rcv(struct i2c_adapter *adap) | |||
237 | u32 ctl = 0; | 237 | u32 ctl = 0; |
238 | 238 | ||
239 | dev_dbg(&adap->dev, "%s(): entering: stat = %04x.\n", | 239 | dev_dbg(&adap->dev, "%s(): entering: stat = %04x.\n", |
240 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 240 | __func__, ioread32(I2C_REG_STS(alg_data))); |
241 | 241 | ||
242 | /* Check, whether there is already data, | 242 | /* Check, whether there is already data, |
243 | * or we didn't 'ask' for it yet. | 243 | * or we didn't 'ask' for it yet. |
244 | */ | 244 | */ |
245 | if (ioread32(I2C_REG_STS(alg_data)) & mstatus_rfe) { | 245 | if (ioread32(I2C_REG_STS(alg_data)) & mstatus_rfe) { |
246 | dev_dbg(&adap->dev, "%s(): Write dummy data to fill " | 246 | dev_dbg(&adap->dev, "%s(): Write dummy data to fill " |
247 | "Rx-fifo...\n", __FUNCTION__); | 247 | "Rx-fifo...\n", __func__); |
248 | 248 | ||
249 | if (alg_data->mif.len == 1) { | 249 | if (alg_data->mif.len == 1) { |
250 | /* Last byte, do not acknowledge next rcv. */ | 250 | /* Last byte, do not acknowledge next rcv. */ |
@@ -276,7 +276,7 @@ static int i2c_pnx_master_rcv(struct i2c_adapter *adap) | |||
276 | if (alg_data->mif.len > 0) { | 276 | if (alg_data->mif.len > 0) { |
277 | val = ioread32(I2C_REG_RX(alg_data)); | 277 | val = ioread32(I2C_REG_RX(alg_data)); |
278 | *alg_data->mif.buf++ = (u8) (val & 0xff); | 278 | *alg_data->mif.buf++ = (u8) (val & 0xff); |
279 | dev_dbg(&adap->dev, "%s(): rcv 0x%x [%d]\n", __FUNCTION__, val, | 279 | dev_dbg(&adap->dev, "%s(): rcv 0x%x [%d]\n", __func__, val, |
280 | alg_data->mif.len); | 280 | alg_data->mif.len); |
281 | 281 | ||
282 | alg_data->mif.len--; | 282 | alg_data->mif.len--; |
@@ -300,7 +300,7 @@ static int i2c_pnx_master_rcv(struct i2c_adapter *adap) | |||
300 | } | 300 | } |
301 | 301 | ||
302 | dev_dbg(&adap->dev, "%s(): exiting: stat = %04x.\n", | 302 | dev_dbg(&adap->dev, "%s(): exiting: stat = %04x.\n", |
303 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 303 | __func__, ioread32(I2C_REG_STS(alg_data))); |
304 | 304 | ||
305 | return 0; | 305 | return 0; |
306 | } | 306 | } |
@@ -312,7 +312,7 @@ static irqreturn_t i2c_pnx_interrupt(int irq, void *dev_id) | |||
312 | struct i2c_pnx_algo_data *alg_data = adap->algo_data; | 312 | struct i2c_pnx_algo_data *alg_data = adap->algo_data; |
313 | 313 | ||
314 | dev_dbg(&adap->dev, "%s(): mstat = %x mctrl = %x, mode = %d\n", | 314 | dev_dbg(&adap->dev, "%s(): mstat = %x mctrl = %x, mode = %d\n", |
315 | __FUNCTION__, | 315 | __func__, |
316 | ioread32(I2C_REG_STS(alg_data)), | 316 | ioread32(I2C_REG_STS(alg_data)), |
317 | ioread32(I2C_REG_CTL(alg_data)), | 317 | ioread32(I2C_REG_CTL(alg_data)), |
318 | alg_data->mif.mode); | 318 | alg_data->mif.mode); |
@@ -336,7 +336,7 @@ static irqreturn_t i2c_pnx_interrupt(int irq, void *dev_id) | |||
336 | /* Slave did not acknowledge, generate a STOP */ | 336 | /* Slave did not acknowledge, generate a STOP */ |
337 | dev_dbg(&adap->dev, "%s(): " | 337 | dev_dbg(&adap->dev, "%s(): " |
338 | "Slave did not acknowledge, generating a STOP.\n", | 338 | "Slave did not acknowledge, generating a STOP.\n", |
339 | __FUNCTION__); | 339 | __func__); |
340 | i2c_pnx_stop(adap); | 340 | i2c_pnx_stop(adap); |
341 | 341 | ||
342 | /* Disable master interrupts. */ | 342 | /* Disable master interrupts. */ |
@@ -375,7 +375,7 @@ static irqreturn_t i2c_pnx_interrupt(int irq, void *dev_id) | |||
375 | iowrite32(stat | mstatus_tdi | mstatus_afi, I2C_REG_STS(alg_data)); | 375 | iowrite32(stat | mstatus_tdi | mstatus_afi, I2C_REG_STS(alg_data)); |
376 | 376 | ||
377 | dev_dbg(&adap->dev, "%s(): exiting, stat = %x ctrl = %x.\n", | 377 | dev_dbg(&adap->dev, "%s(): exiting, stat = %x ctrl = %x.\n", |
378 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data)), | 378 | __func__, ioread32(I2C_REG_STS(alg_data)), |
379 | ioread32(I2C_REG_CTL(alg_data))); | 379 | ioread32(I2C_REG_CTL(alg_data))); |
380 | 380 | ||
381 | return IRQ_HANDLED; | 381 | return IRQ_HANDLED; |
@@ -447,7 +447,7 @@ i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) | |||
447 | u32 stat = ioread32(I2C_REG_STS(alg_data)); | 447 | u32 stat = ioread32(I2C_REG_STS(alg_data)); |
448 | 448 | ||
449 | dev_dbg(&adap->dev, "%s(): entering: %d messages, stat = %04x.\n", | 449 | dev_dbg(&adap->dev, "%s(): entering: %d messages, stat = %04x.\n", |
450 | __FUNCTION__, num, ioread32(I2C_REG_STS(alg_data))); | 450 | __func__, num, ioread32(I2C_REG_STS(alg_data))); |
451 | 451 | ||
452 | bus_reset_if_active(adap); | 452 | bus_reset_if_active(adap); |
453 | 453 | ||
@@ -473,7 +473,7 @@ i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) | |||
473 | alg_data->mif.ret = 0; | 473 | alg_data->mif.ret = 0; |
474 | alg_data->last = (i == num - 1); | 474 | alg_data->last = (i == num - 1); |
475 | 475 | ||
476 | dev_dbg(&adap->dev, "%s(): mode %d, %d bytes\n", __FUNCTION__, | 476 | dev_dbg(&adap->dev, "%s(): mode %d, %d bytes\n", __func__, |
477 | alg_data->mif.mode, | 477 | alg_data->mif.mode, |
478 | alg_data->mif.len); | 478 | alg_data->mif.len); |
479 | 479 | ||
@@ -498,7 +498,7 @@ i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) | |||
498 | if (!(rc = alg_data->mif.ret)) | 498 | if (!(rc = alg_data->mif.ret)) |
499 | completed++; | 499 | completed++; |
500 | dev_dbg(&adap->dev, "%s(): Complete, return code = %d.\n", | 500 | dev_dbg(&adap->dev, "%s(): Complete, return code = %d.\n", |
501 | __FUNCTION__, rc); | 501 | __func__, rc); |
502 | 502 | ||
503 | /* Clear TDI and AFI bits in case they are set. */ | 503 | /* Clear TDI and AFI bits in case they are set. */ |
504 | if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) { | 504 | if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) { |
@@ -522,7 +522,7 @@ i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) | |||
522 | alg_data->mif.len = 0; | 522 | alg_data->mif.len = 0; |
523 | 523 | ||
524 | dev_dbg(&adap->dev, "%s(): exiting, stat = %x\n", | 524 | dev_dbg(&adap->dev, "%s(): exiting, stat = %x\n", |
525 | __FUNCTION__, ioread32(I2C_REG_STS(alg_data))); | 525 | __func__, ioread32(I2C_REG_STS(alg_data))); |
526 | 526 | ||
527 | if (completed != num) | 527 | if (completed != num) |
528 | return ((rc < 0) ? rc : -EREMOTEIO); | 528 | return ((rc < 0) ? rc : -EREMOTEIO); |
@@ -563,7 +563,7 @@ static int __devinit i2c_pnx_probe(struct platform_device *pdev) | |||
563 | 563 | ||
564 | if (!i2c_pnx || !i2c_pnx->adapter) { | 564 | if (!i2c_pnx || !i2c_pnx->adapter) { |
565 | dev_err(&pdev->dev, "%s: no platform data supplied\n", | 565 | dev_err(&pdev->dev, "%s: no platform data supplied\n", |
566 | __FUNCTION__); | 566 | __func__); |
567 | ret = -EINVAL; | 567 | ret = -EINVAL; |
568 | goto out; | 568 | goto out; |
569 | } | 569 | } |
@@ -697,6 +697,7 @@ static void __exit i2c_adap_pnx_exit(void) | |||
697 | MODULE_AUTHOR("Vitaly Wool, Dennis Kovalev <source@mvista.com>"); | 697 | MODULE_AUTHOR("Vitaly Wool, Dennis Kovalev <source@mvista.com>"); |
698 | MODULE_DESCRIPTION("I2C driver for Philips IP3204-based I2C busses"); | 698 | MODULE_DESCRIPTION("I2C driver for Philips IP3204-based I2C busses"); |
699 | MODULE_LICENSE("GPL"); | 699 | MODULE_LICENSE("GPL"); |
700 | MODULE_ALIAS("platform:pnx-i2c"); | ||
700 | 701 | ||
701 | /* We need to make sure I2C is initialized before USB */ | 702 | /* We need to make sure I2C is initialized before USB */ |
702 | subsys_initcall(i2c_adap_pnx_init); | 703 | subsys_initcall(i2c_adap_pnx_init); |
diff --git a/drivers/i2c/busses/i2c-powermac.c b/drivers/i2c/busses/i2c-powermac.c index 7813127649a1..22f6d5c00d80 100644 --- a/drivers/i2c/busses/i2c-powermac.c +++ b/drivers/i2c/busses/i2c-powermac.c | |||
@@ -263,6 +263,9 @@ static int __devexit i2c_powermac_probe(struct platform_device *dev) | |||
263 | } | 263 | } |
264 | 264 | ||
265 | 265 | ||
266 | /* work with hotplug and coldplug */ | ||
267 | MODULE_ALIAS("platform:i2c-powermac"); | ||
268 | |||
266 | static struct platform_driver i2c_powermac_driver = { | 269 | static struct platform_driver i2c_powermac_driver = { |
267 | .probe = i2c_powermac_probe, | 270 | .probe = i2c_powermac_probe, |
268 | .remove = __devexit_p(i2c_powermac_remove), | 271 | .remove = __devexit_p(i2c_powermac_remove), |
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c index 6fd2d6a84eff..eb69fbadc9cb 100644 --- a/drivers/i2c/busses/i2c-pxa.c +++ b/drivers/i2c/busses/i2c-pxa.c | |||
@@ -155,7 +155,7 @@ static void i2c_pxa_show_state(struct pxa_i2c *i2c, int lno, const char *fname) | |||
155 | readl(_ISR(i2c)), readl(_ICR(i2c)), readl(_IBMR(i2c))); | 155 | readl(_ISR(i2c)), readl(_ICR(i2c)), readl(_IBMR(i2c))); |
156 | } | 156 | } |
157 | 157 | ||
158 | #define show_state(i2c) i2c_pxa_show_state(i2c, __LINE__, __FUNCTION__) | 158 | #define show_state(i2c) i2c_pxa_show_state(i2c, __LINE__, __func__) |
159 | #else | 159 | #else |
160 | #define i2c_debug 0 | 160 | #define i2c_debug 0 |
161 | 161 | ||
@@ -1132,6 +1132,7 @@ static void __exit i2c_adap_pxa_exit(void) | |||
1132 | } | 1132 | } |
1133 | 1133 | ||
1134 | MODULE_LICENSE("GPL"); | 1134 | MODULE_LICENSE("GPL"); |
1135 | MODULE_ALIAS("platform:pxa2xx-i2c"); | ||
1135 | 1136 | ||
1136 | module_init(i2c_adap_pxa_init); | 1137 | module_init(i2c_adap_pxa_init); |
1137 | module_exit(i2c_adap_pxa_exit); | 1138 | module_exit(i2c_adap_pxa_exit); |
diff --git a/drivers/i2c/busses/i2c-s3c2410.c b/drivers/i2c/busses/i2c-s3c2410.c index c44ada5f4292..1305ef190fc1 100644 --- a/drivers/i2c/busses/i2c-s3c2410.c +++ b/drivers/i2c/busses/i2c-s3c2410.c | |||
@@ -276,12 +276,12 @@ static int i2s_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat) | |||
276 | switch (i2c->state) { | 276 | switch (i2c->state) { |
277 | 277 | ||
278 | case STATE_IDLE: | 278 | case STATE_IDLE: |
279 | dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __FUNCTION__); | 279 | dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__); |
280 | goto out; | 280 | goto out; |
281 | break; | 281 | break; |
282 | 282 | ||
283 | case STATE_STOP: | 283 | case STATE_STOP: |
284 | dev_err(i2c->dev, "%s: called in STATE_STOP\n", __FUNCTION__); | 284 | dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__); |
285 | s3c24xx_i2c_disable_irq(i2c); | 285 | s3c24xx_i2c_disable_irq(i2c); |
286 | goto out_ack; | 286 | goto out_ack; |
287 | 287 | ||
@@ -948,3 +948,4 @@ module_exit(i2c_adap_s3c_exit); | |||
948 | MODULE_DESCRIPTION("S3C24XX I2C Bus driver"); | 948 | MODULE_DESCRIPTION("S3C24XX I2C Bus driver"); |
949 | MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>"); | 949 | MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>"); |
950 | MODULE_LICENSE("GPL"); | 950 | MODULE_LICENSE("GPL"); |
951 | MODULE_ALIAS("platform:s3c2410-i2c"); | ||
diff --git a/drivers/i2c/busses/i2c-sh7760.c b/drivers/i2c/busses/i2c-sh7760.c new file mode 100644 index 000000000000..5e0e254976de --- /dev/null +++ b/drivers/i2c/busses/i2c-sh7760.c | |||
@@ -0,0 +1,577 @@ | |||
1 | /* | ||
2 | * I2C bus driver for the SH7760 I2C Interfaces. | ||
3 | * | ||
4 | * (c) 2005-2008 MSC Vertriebsges.m.b.H, Manuel Lauss <mlau@msc-ge.com> | ||
5 | * | ||
6 | * licensed under the terms outlined in the file COPYING. | ||
7 | * | ||
8 | */ | ||
9 | |||
10 | #include <linux/completion.h> | ||
11 | #include <linux/delay.h> | ||
12 | #include <linux/err.h> | ||
13 | #include <linux/i2c.h> | ||
14 | #include <linux/init.h> | ||
15 | #include <linux/interrupt.h> | ||
16 | #include <linux/ioport.h> | ||
17 | #include <linux/platform_device.h> | ||
18 | #include <linux/slab.h> | ||
19 | |||
20 | #include <asm/clock.h> | ||
21 | #include <asm/i2c-sh7760.h> | ||
22 | #include <asm/io.h> | ||
23 | |||
24 | /* register offsets */ | ||
25 | #define I2CSCR 0x0 /* slave ctrl */ | ||
26 | #define I2CMCR 0x4 /* master ctrl */ | ||
27 | #define I2CSSR 0x8 /* slave status */ | ||
28 | #define I2CMSR 0xC /* master status */ | ||
29 | #define I2CSIER 0x10 /* slave irq enable */ | ||
30 | #define I2CMIER 0x14 /* master irq enable */ | ||
31 | #define I2CCCR 0x18 /* clock dividers */ | ||
32 | #define I2CSAR 0x1c /* slave address */ | ||
33 | #define I2CMAR 0x20 /* master address */ | ||
34 | #define I2CRXTX 0x24 /* data port */ | ||
35 | #define I2CFCR 0x28 /* fifo control */ | ||
36 | #define I2CFSR 0x2C /* fifo status */ | ||
37 | #define I2CFIER 0x30 /* fifo irq enable */ | ||
38 | #define I2CRFDR 0x34 /* rx fifo count */ | ||
39 | #define I2CTFDR 0x38 /* tx fifo count */ | ||
40 | |||
41 | #define REGSIZE 0x3C | ||
42 | |||
43 | #define MCR_MDBS 0x80 /* non-fifo mode switch */ | ||
44 | #define MCR_FSCL 0x40 /* override SCL pin */ | ||
45 | #define MCR_FSDA 0x20 /* override SDA pin */ | ||
46 | #define MCR_OBPC 0x10 /* override pins */ | ||
47 | #define MCR_MIE 0x08 /* master if enable */ | ||
48 | #define MCR_TSBE 0x04 | ||
49 | #define MCR_FSB 0x02 /* force stop bit */ | ||
50 | #define MCR_ESG 0x01 /* en startbit gen. */ | ||
51 | |||
52 | #define MSR_MNR 0x40 /* nack received */ | ||
53 | #define MSR_MAL 0x20 /* arbitration lost */ | ||
54 | #define MSR_MST 0x10 /* sent a stop */ | ||
55 | #define MSR_MDE 0x08 | ||
56 | #define MSR_MDT 0x04 | ||
57 | #define MSR_MDR 0x02 | ||
58 | #define MSR_MAT 0x01 /* slave addr xfer done */ | ||
59 | |||
60 | #define MIE_MNRE 0x40 /* nack irq en */ | ||
61 | #define MIE_MALE 0x20 /* arblos irq en */ | ||
62 | #define MIE_MSTE 0x10 /* stop irq en */ | ||
63 | #define MIE_MDEE 0x08 | ||
64 | #define MIE_MDTE 0x04 | ||
65 | #define MIE_MDRE 0x02 | ||
66 | #define MIE_MATE 0x01 /* address sent irq en */ | ||
67 | |||
68 | #define FCR_RFRST 0x02 /* reset rx fifo */ | ||
69 | #define FCR_TFRST 0x01 /* reset tx fifo */ | ||
70 | |||
71 | #define FSR_TEND 0x04 /* last byte sent */ | ||
72 | #define FSR_RDF 0x02 /* rx fifo trigger */ | ||
73 | #define FSR_TDFE 0x01 /* tx fifo empty */ | ||
74 | |||
75 | #define FIER_TEIE 0x04 /* tx fifo empty irq en */ | ||
76 | #define FIER_RXIE 0x02 /* rx fifo trig irq en */ | ||
77 | #define FIER_TXIE 0x01 /* tx fifo trig irq en */ | ||
78 | |||
79 | #define FIFO_SIZE 16 | ||
80 | |||
81 | struct cami2c { | ||
82 | void __iomem *iobase; | ||
83 | struct i2c_adapter adap; | ||
84 | |||
85 | /* message processing */ | ||
86 | struct i2c_msg *msg; | ||
87 | #define IDF_SEND 1 | ||
88 | #define IDF_RECV 2 | ||
89 | #define IDF_STOP 4 | ||
90 | int flags; | ||
91 | |||
92 | #define IDS_DONE 1 | ||
93 | #define IDS_ARBLOST 2 | ||
94 | #define IDS_NACK 4 | ||
95 | int status; | ||
96 | struct completion xfer_done; | ||
97 | |||
98 | int irq; | ||
99 | struct resource *ioarea; | ||
100 | }; | ||
101 | |||
102 | static inline void OUT32(struct cami2c *cam, int reg, unsigned long val) | ||
103 | { | ||
104 | ctrl_outl(val, (unsigned long)cam->iobase + reg); | ||
105 | } | ||
106 | |||
107 | static inline unsigned long IN32(struct cami2c *cam, int reg) | ||
108 | { | ||
109 | return ctrl_inl((unsigned long)cam->iobase + reg); | ||
110 | } | ||
111 | |||
112 | static irqreturn_t sh7760_i2c_irq(int irq, void *ptr) | ||
113 | { | ||
114 | struct cami2c *id = ptr; | ||
115 | struct i2c_msg *msg = id->msg; | ||
116 | char *data = msg->buf; | ||
117 | unsigned long msr, fsr, fier, len; | ||
118 | |||
119 | msr = IN32(id, I2CMSR); | ||
120 | fsr = IN32(id, I2CFSR); | ||
121 | |||
122 | /* arbitration lost */ | ||
123 | if (msr & MSR_MAL) { | ||
124 | OUT32(id, I2CMCR, 0); | ||
125 | OUT32(id, I2CSCR, 0); | ||
126 | OUT32(id, I2CSAR, 0); | ||
127 | id->status |= IDS_DONE | IDS_ARBLOST; | ||
128 | goto out; | ||
129 | } | ||
130 | |||
131 | if (msr & MSR_MNR) { | ||
132 | /* NACK handling is very screwed up. After receiving a | ||
133 | * NAK IRQ one has to wait a bit before writing to any | ||
134 | * registers, or the ctl will lock up. After that delay | ||
135 | * do a normal i2c stop. Then wait at least 1 ms before | ||
136 | * attempting another transfer or ctl will stop working | ||
137 | */ | ||
138 | udelay(100); /* wait or risk ctl hang */ | ||
139 | OUT32(id, I2CFCR, FCR_RFRST | FCR_TFRST); | ||
140 | OUT32(id, I2CMCR, MCR_MIE | MCR_FSB); | ||
141 | OUT32(id, I2CFIER, 0); | ||
142 | OUT32(id, I2CMIER, MIE_MSTE); | ||
143 | OUT32(id, I2CSCR, 0); | ||
144 | OUT32(id, I2CSAR, 0); | ||
145 | id->status |= IDS_NACK; | ||
146 | msr &= ~MSR_MAT; | ||
147 | fsr = 0; | ||
148 | /* In some cases the MST bit is also set. */ | ||
149 | } | ||
150 | |||
151 | /* i2c-stop was sent */ | ||
152 | if (msr & MSR_MST) { | ||
153 | id->status |= IDS_DONE; | ||
154 | goto out; | ||
155 | } | ||
156 | |||
157 | /* i2c slave addr was sent; set to "normal" operation */ | ||
158 | if (msr & MSR_MAT) | ||
159 | OUT32(id, I2CMCR, MCR_MIE); | ||
160 | |||
161 | fier = IN32(id, I2CFIER); | ||
162 | |||
163 | if (fsr & FSR_RDF) { | ||
164 | len = IN32(id, I2CRFDR); | ||
165 | if (msg->len <= len) { | ||
166 | if (id->flags & IDF_STOP) { | ||
167 | OUT32(id, I2CMCR, MCR_MIE | MCR_FSB); | ||
168 | OUT32(id, I2CFIER, 0); | ||
169 | /* manual says: wait >= 0.5 SCL times */ | ||
170 | udelay(5); | ||
171 | /* next int should be MST */ | ||
172 | } else { | ||
173 | id->status |= IDS_DONE; | ||
174 | /* keep the RDF bit: ctrl holds SCL low | ||
175 | * until the setup for the next i2c_msg | ||
176 | * clears this bit. | ||
177 | */ | ||
178 | fsr &= ~FSR_RDF; | ||
179 | } | ||
180 | } | ||
181 | while (msg->len && len) { | ||
182 | *data++ = IN32(id, I2CRXTX); | ||
183 | msg->len--; | ||
184 | len--; | ||
185 | } | ||
186 | |||
187 | if (msg->len) { | ||
188 | len = (msg->len >= FIFO_SIZE) ? FIFO_SIZE - 1 | ||
189 | : msg->len - 1; | ||
190 | |||
191 | OUT32(id, I2CFCR, FCR_TFRST | ((len & 0xf) << 4)); | ||
192 | } | ||
193 | |||
194 | } else if (id->flags & IDF_SEND) { | ||
195 | if ((fsr & FSR_TEND) && (msg->len < 1)) { | ||
196 | if (id->flags & IDF_STOP) { | ||
197 | OUT32(id, I2CMCR, MCR_MIE | MCR_FSB); | ||
198 | } else { | ||
199 | id->status |= IDS_DONE; | ||
200 | /* keep the TEND bit: ctl holds SCL low | ||
201 | * until the setup for the next i2c_msg | ||
202 | * clears this bit. | ||
203 | */ | ||
204 | fsr &= ~FSR_TEND; | ||
205 | } | ||
206 | } | ||
207 | if (fsr & FSR_TDFE) { | ||
208 | while (msg->len && (IN32(id, I2CTFDR) < FIFO_SIZE)) { | ||
209 | OUT32(id, I2CRXTX, *data++); | ||
210 | msg->len--; | ||
211 | } | ||
212 | |||
213 | if (msg->len < 1) { | ||
214 | fier &= ~FIER_TXIE; | ||
215 | OUT32(id, I2CFIER, fier); | ||
216 | } else { | ||
217 | len = (msg->len >= FIFO_SIZE) ? 2 : 0; | ||
218 | OUT32(id, I2CFCR, | ||
219 | FCR_RFRST | ((len & 3) << 2)); | ||
220 | } | ||
221 | } | ||
222 | } | ||
223 | out: | ||
224 | if (id->status & IDS_DONE) { | ||
225 | OUT32(id, I2CMIER, 0); | ||
226 | OUT32(id, I2CFIER, 0); | ||
227 | id->msg = NULL; | ||
228 | complete(&id->xfer_done); | ||
229 | } | ||
230 | /* clear status flags and ctrl resumes work */ | ||
231 | OUT32(id, I2CMSR, ~msr); | ||
232 | OUT32(id, I2CFSR, ~fsr); | ||
233 | OUT32(id, I2CSSR, 0); | ||
234 | |||
235 | return IRQ_HANDLED; | ||
236 | } | ||
237 | |||
238 | |||
239 | /* prepare and start a master receive operation */ | ||
240 | static void sh7760_i2c_mrecv(struct cami2c *id) | ||
241 | { | ||
242 | int len; | ||
243 | |||
244 | id->flags |= IDF_RECV; | ||
245 | |||
246 | /* set the slave addr reg; otherwise rcv wont work! */ | ||
247 | OUT32(id, I2CSAR, 0xfe); | ||
248 | OUT32(id, I2CMAR, (id->msg->addr << 1) | 1); | ||
249 | |||
250 | /* adjust rx fifo trigger */ | ||
251 | if (id->msg->len >= FIFO_SIZE) | ||
252 | len = FIFO_SIZE - 1; /* trigger at fifo full */ | ||
253 | else | ||
254 | len = id->msg->len - 1; /* trigger before all received */ | ||
255 | |||
256 | OUT32(id, I2CFCR, FCR_RFRST | FCR_TFRST); | ||
257 | OUT32(id, I2CFCR, FCR_TFRST | ((len & 0xF) << 4)); | ||
258 | |||
259 | OUT32(id, I2CMSR, 0); | ||
260 | OUT32(id, I2CMCR, MCR_MIE | MCR_ESG); | ||
261 | OUT32(id, I2CMIER, MIE_MNRE | MIE_MALE | MIE_MSTE | MIE_MATE); | ||
262 | OUT32(id, I2CFIER, FIER_RXIE); | ||
263 | } | ||
264 | |||
265 | /* prepare and start a master send operation */ | ||
266 | static void sh7760_i2c_msend(struct cami2c *id) | ||
267 | { | ||
268 | int len; | ||
269 | |||
270 | id->flags |= IDF_SEND; | ||
271 | |||
272 | /* set the slave addr reg; otherwise xmit wont work! */ | ||
273 | OUT32(id, I2CSAR, 0xfe); | ||
274 | OUT32(id, I2CMAR, (id->msg->addr << 1) | 0); | ||
275 | |||
276 | /* adjust tx fifo trigger */ | ||
277 | if (id->msg->len >= FIFO_SIZE) | ||
278 | len = 2; /* trig: 2 bytes left in TX fifo */ | ||
279 | else | ||
280 | len = 0; /* trig: 8 bytes left in TX fifo */ | ||
281 | |||
282 | OUT32(id, I2CFCR, FCR_RFRST | FCR_TFRST); | ||
283 | OUT32(id, I2CFCR, FCR_RFRST | ((len & 3) << 2)); | ||
284 | |||
285 | while (id->msg->len && IN32(id, I2CTFDR) < FIFO_SIZE) { | ||
286 | OUT32(id, I2CRXTX, *(id->msg->buf)); | ||
287 | (id->msg->len)--; | ||
288 | (id->msg->buf)++; | ||
289 | } | ||
290 | |||
291 | OUT32(id, I2CMSR, 0); | ||
292 | OUT32(id, I2CMCR, MCR_MIE | MCR_ESG); | ||
293 | OUT32(id, I2CFSR, 0); | ||
294 | OUT32(id, I2CMIER, MIE_MNRE | MIE_MALE | MIE_MSTE | MIE_MATE); | ||
295 | OUT32(id, I2CFIER, FIER_TEIE | (id->msg->len ? FIER_TXIE : 0)); | ||
296 | } | ||
297 | |||
298 | static inline int sh7760_i2c_busy_check(struct cami2c *id) | ||
299 | { | ||
300 | return (IN32(id, I2CMCR) & MCR_FSDA); | ||
301 | } | ||
302 | |||
303 | static int sh7760_i2c_master_xfer(struct i2c_adapter *adap, | ||
304 | struct i2c_msg *msgs, | ||
305 | int num) | ||
306 | { | ||
307 | struct cami2c *id = adap->algo_data; | ||
308 | int i, retr; | ||
309 | |||
310 | if (sh7760_i2c_busy_check(id)) { | ||
311 | dev_err(&adap->dev, "sh7760-i2c%d: bus busy!\n", adap->nr); | ||
312 | return -EBUSY; | ||
313 | } | ||
314 | |||
315 | i = 0; | ||
316 | while (i < num) { | ||
317 | retr = adap->retries; | ||
318 | retry: | ||
319 | id->flags = ((i == (num-1)) ? IDF_STOP : 0); | ||
320 | id->status = 0; | ||
321 | id->msg = msgs; | ||
322 | init_completion(&id->xfer_done); | ||
323 | |||
324 | if (msgs->flags & I2C_M_RD) | ||
325 | sh7760_i2c_mrecv(id); | ||
326 | else | ||
327 | sh7760_i2c_msend(id); | ||
328 | |||
329 | wait_for_completion(&id->xfer_done); | ||
330 | |||
331 | if (id->status == 0) { | ||
332 | num = -EIO; | ||
333 | break; | ||
334 | } | ||
335 | |||
336 | if (id->status & IDS_NACK) { | ||
337 | /* wait a bit or i2c module stops working */ | ||
338 | mdelay(1); | ||
339 | num = -EREMOTEIO; | ||
340 | break; | ||
341 | } | ||
342 | |||
343 | if (id->status & IDS_ARBLOST) { | ||
344 | if (retr--) { | ||
345 | mdelay(2); | ||
346 | goto retry; | ||
347 | } | ||
348 | num = -EREMOTEIO; | ||
349 | break; | ||
350 | } | ||
351 | |||
352 | msgs++; | ||
353 | i++; | ||
354 | } | ||
355 | |||
356 | id->msg = NULL; | ||
357 | id->flags = 0; | ||
358 | id->status = 0; | ||
359 | |||
360 | OUT32(id, I2CMCR, 0); | ||
361 | OUT32(id, I2CMSR, 0); | ||
362 | OUT32(id, I2CMIER, 0); | ||
363 | OUT32(id, I2CFIER, 0); | ||
364 | |||
365 | /* reset slave module registers too: master mode enables slave | ||
366 | * module for receive ops (ack, data). Without this reset, | ||
367 | * eternal bus activity might be reported after NACK / ARBLOST. | ||
368 | */ | ||
369 | OUT32(id, I2CSCR, 0); | ||
370 | OUT32(id, I2CSAR, 0); | ||
371 | OUT32(id, I2CSSR, 0); | ||
372 | |||
373 | return num; | ||
374 | } | ||
375 | |||
376 | static u32 sh7760_i2c_func(struct i2c_adapter *adap) | ||
377 | { | ||
378 | return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK); | ||
379 | } | ||
380 | |||
381 | static const struct i2c_algorithm sh7760_i2c_algo = { | ||
382 | .master_xfer = sh7760_i2c_master_xfer, | ||
383 | .functionality = sh7760_i2c_func, | ||
384 | }; | ||
385 | |||
386 | /* calculate CCR register setting for a desired scl clock. SCL clock is | ||
387 | * derived from I2C module clock (iclk) which in turn is derived from | ||
388 | * peripheral module clock (mclk, usually around 33MHz): | ||
389 | * iclk = mclk/(CDF + 1). iclk must be < 20MHz. | ||
390 | * scl = iclk/(SCGD*8 + 20). | ||
391 | */ | ||
392 | static int __devinit calc_CCR(unsigned long scl_hz) | ||
393 | { | ||
394 | struct clk *mclk; | ||
395 | unsigned long mck, m1, dff, odff, iclk; | ||
396 | signed char cdf, cdfm; | ||
397 | int scgd, scgdm, scgds; | ||
398 | |||
399 | mclk = clk_get(NULL, "module_clk"); | ||
400 | if (IS_ERR(mclk)) { | ||
401 | return PTR_ERR(mclk); | ||
402 | } else { | ||
403 | mck = mclk->rate; | ||
404 | clk_put(mclk); | ||
405 | } | ||
406 | |||
407 | odff = scl_hz; | ||
408 | scgdm = cdfm = m1 = 0; | ||
409 | for (cdf = 3; cdf >= 0; cdf--) { | ||
410 | iclk = mck / (1 + cdf); | ||
411 | if (iclk >= 20000000) | ||
412 | continue; | ||
413 | scgds = ((iclk / scl_hz) - 20) >> 3; | ||
414 | for (scgd = scgds; (scgd < 63) && scgd <= scgds + 1; scgd++) { | ||
415 | m1 = iclk / (20 + (scgd << 3)); | ||
416 | dff = abs(scl_hz - m1); | ||
417 | if (dff < odff) { | ||
418 | odff = dff; | ||
419 | cdfm = cdf; | ||
420 | scgdm = scgd; | ||
421 | } | ||
422 | } | ||
423 | } | ||
424 | /* fail if more than 25% off of requested SCL */ | ||
425 | if (odff > (scl_hz >> 2)) | ||
426 | return -EINVAL; | ||
427 | |||
428 | /* create a CCR register value */ | ||
429 | return ((scgdm << 2) | cdfm); | ||
430 | } | ||
431 | |||
432 | static int __devinit sh7760_i2c_probe(struct platform_device *pdev) | ||
433 | { | ||
434 | struct sh7760_i2c_platdata *pd; | ||
435 | struct resource *res; | ||
436 | struct cami2c *id; | ||
437 | int ret; | ||
438 | |||
439 | pd = pdev->dev.platform_data; | ||
440 | if (!pd) { | ||
441 | dev_err(&pdev->dev, "no platform_data!\n"); | ||
442 | ret = -ENODEV; | ||
443 | goto out0; | ||
444 | } | ||
445 | |||
446 | id = kzalloc(sizeof(struct cami2c), GFP_KERNEL); | ||
447 | if (!id) { | ||
448 | dev_err(&pdev->dev, "no mem for private data\n"); | ||
449 | ret = -ENOMEM; | ||
450 | goto out0; | ||
451 | } | ||
452 | |||
453 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
454 | if (!res) { | ||
455 | dev_err(&pdev->dev, "no mmio resources\n"); | ||
456 | ret = -ENODEV; | ||
457 | goto out1; | ||
458 | } | ||
459 | |||
460 | id->ioarea = request_mem_region(res->start, REGSIZE, pdev->name); | ||
461 | if (!id->ioarea) { | ||
462 | dev_err(&pdev->dev, "mmio already reserved\n"); | ||
463 | ret = -EBUSY; | ||
464 | goto out1; | ||
465 | } | ||
466 | |||
467 | id->iobase = ioremap(res->start, REGSIZE); | ||
468 | if (!id->iobase) { | ||
469 | dev_err(&pdev->dev, "cannot ioremap\n"); | ||
470 | ret = -ENODEV; | ||
471 | goto out2; | ||
472 | } | ||
473 | |||
474 | id->irq = platform_get_irq(pdev, 0); | ||
475 | |||
476 | id->adap.nr = pdev->id; | ||
477 | id->adap.algo = &sh7760_i2c_algo; | ||
478 | id->adap.class = I2C_CLASS_ALL; | ||
479 | id->adap.retries = 3; | ||
480 | id->adap.algo_data = id; | ||
481 | id->adap.dev.parent = &pdev->dev; | ||
482 | snprintf(id->adap.name, sizeof(id->adap.name), | ||
483 | "SH7760 I2C at %08lx", (unsigned long)res->start); | ||
484 | |||
485 | OUT32(id, I2CMCR, 0); | ||
486 | OUT32(id, I2CMSR, 0); | ||
487 | OUT32(id, I2CMIER, 0); | ||
488 | OUT32(id, I2CMAR, 0); | ||
489 | OUT32(id, I2CSIER, 0); | ||
490 | OUT32(id, I2CSAR, 0); | ||
491 | OUT32(id, I2CSCR, 0); | ||
492 | OUT32(id, I2CSSR, 0); | ||
493 | OUT32(id, I2CFIER, 0); | ||
494 | OUT32(id, I2CFCR, FCR_RFRST | FCR_TFRST); | ||
495 | OUT32(id, I2CFSR, 0); | ||
496 | |||
497 | ret = calc_CCR(pd->speed_khz * 1000); | ||
498 | if (ret < 0) { | ||
499 | dev_err(&pdev->dev, "invalid SCL clock: %dkHz\n", | ||
500 | pd->speed_khz); | ||
501 | goto out3; | ||
502 | } | ||
503 | OUT32(id, I2CCCR, ret); | ||
504 | |||
505 | if (request_irq(id->irq, sh7760_i2c_irq, IRQF_DISABLED, | ||
506 | SH7760_I2C_DEVNAME, id)) { | ||
507 | dev_err(&pdev->dev, "cannot get irq %d\n", id->irq); | ||
508 | ret = -EBUSY; | ||
509 | goto out3; | ||
510 | } | ||
511 | |||
512 | ret = i2c_add_numbered_adapter(&id->adap); | ||
513 | if (ret < 0) { | ||
514 | dev_err(&pdev->dev, "reg adap failed: %d\n", ret); | ||
515 | goto out4; | ||
516 | } | ||
517 | |||
518 | platform_set_drvdata(pdev, id); | ||
519 | |||
520 | dev_info(&pdev->dev, "%d kHz mmio %08x irq %d\n", | ||
521 | pd->speed_khz, res->start, id->irq); | ||
522 | |||
523 | return 0; | ||
524 | |||
525 | out4: | ||
526 | free_irq(id->irq, id); | ||
527 | out3: | ||
528 | iounmap(id->iobase); | ||
529 | out2: | ||
530 | release_resource(id->ioarea); | ||
531 | kfree(id->ioarea); | ||
532 | out1: | ||
533 | kfree(id); | ||
534 | out0: | ||
535 | return ret; | ||
536 | } | ||
537 | |||
538 | static int __devexit sh7760_i2c_remove(struct platform_device *pdev) | ||
539 | { | ||
540 | struct cami2c *id = platform_get_drvdata(pdev); | ||
541 | |||
542 | i2c_del_adapter(&id->adap); | ||
543 | free_irq(id->irq, id); | ||
544 | iounmap(id->iobase); | ||
545 | release_resource(id->ioarea); | ||
546 | kfree(id->ioarea); | ||
547 | kfree(id); | ||
548 | platform_set_drvdata(pdev, NULL); | ||
549 | |||
550 | return 0; | ||
551 | } | ||
552 | |||
553 | static struct platform_driver sh7760_i2c_drv = { | ||
554 | .driver = { | ||
555 | .name = SH7760_I2C_DEVNAME, | ||
556 | .owner = THIS_MODULE, | ||
557 | }, | ||
558 | .probe = sh7760_i2c_probe, | ||
559 | .remove = __devexit_p(sh7760_i2c_remove), | ||
560 | }; | ||
561 | |||
562 | static int __init sh7760_i2c_init(void) | ||
563 | { | ||
564 | return platform_driver_register(&sh7760_i2c_drv); | ||
565 | } | ||
566 | |||
567 | static void __exit sh7760_i2c_exit(void) | ||
568 | { | ||
569 | platform_driver_unregister(&sh7760_i2c_drv); | ||
570 | } | ||
571 | |||
572 | module_init(sh7760_i2c_init); | ||
573 | module_exit(sh7760_i2c_exit); | ||
574 | |||
575 | MODULE_LICENSE("GPL"); | ||
576 | MODULE_DESCRIPTION("SH7760 I2C bus driver"); | ||
577 | MODULE_AUTHOR("Manuel Lauss <mano@roarinelk.homelinux.net>"); | ||
diff --git a/drivers/i2c/busses/i2c-sh_mobile.c b/drivers/i2c/busses/i2c-sh_mobile.c new file mode 100644 index 000000000000..840e634fa31f --- /dev/null +++ b/drivers/i2c/busses/i2c-sh_mobile.c | |||
@@ -0,0 +1,500 @@ | |||
1 | /* | ||
2 | * SuperH Mobile I2C Controller | ||
3 | * | ||
4 | * Copyright (C) 2008 Magnus Damm | ||
5 | * | ||
6 | * Portions of the code based on out-of-tree driver i2c-sh7343.c | ||
7 | * Copyright (c) 2006 Carlos Munoz <carlos@kenati.com> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; either version 2 of the License | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software | ||
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
21 | */ | ||
22 | |||
23 | #include <linux/kernel.h> | ||
24 | #include <linux/module.h> | ||
25 | #include <linux/init.h> | ||
26 | #include <linux/delay.h> | ||
27 | #include <linux/platform_device.h> | ||
28 | #include <linux/interrupt.h> | ||
29 | #include <linux/i2c.h> | ||
30 | #include <linux/err.h> | ||
31 | #include <linux/clk.h> | ||
32 | #include <linux/io.h> | ||
33 | |||
34 | enum sh_mobile_i2c_op { | ||
35 | OP_START = 0, | ||
36 | OP_TX_ONLY, | ||
37 | OP_TX_STOP, | ||
38 | OP_TX_TO_RX, | ||
39 | OP_RX_ONLY, | ||
40 | OP_RX_STOP, | ||
41 | }; | ||
42 | |||
43 | struct sh_mobile_i2c_data { | ||
44 | struct device *dev; | ||
45 | void __iomem *reg; | ||
46 | struct i2c_adapter adap; | ||
47 | |||
48 | struct clk *clk; | ||
49 | u_int8_t iccl; | ||
50 | u_int8_t icch; | ||
51 | |||
52 | spinlock_t lock; | ||
53 | wait_queue_head_t wait; | ||
54 | struct i2c_msg *msg; | ||
55 | int pos; | ||
56 | int sr; | ||
57 | }; | ||
58 | |||
59 | #define NORMAL_SPEED 100000 /* FAST_SPEED 400000 */ | ||
60 | |||
61 | /* Register offsets */ | ||
62 | #define ICDR(pd) (pd->reg + 0x00) | ||
63 | #define ICCR(pd) (pd->reg + 0x04) | ||
64 | #define ICSR(pd) (pd->reg + 0x08) | ||
65 | #define ICIC(pd) (pd->reg + 0x0c) | ||
66 | #define ICCL(pd) (pd->reg + 0x10) | ||
67 | #define ICCH(pd) (pd->reg + 0x14) | ||
68 | |||
69 | /* Register bits */ | ||
70 | #define ICCR_ICE 0x80 | ||
71 | #define ICCR_RACK 0x40 | ||
72 | #define ICCR_TRS 0x10 | ||
73 | #define ICCR_BBSY 0x04 | ||
74 | #define ICCR_SCP 0x01 | ||
75 | |||
76 | #define ICSR_SCLM 0x80 | ||
77 | #define ICSR_SDAM 0x40 | ||
78 | #define SW_DONE 0x20 | ||
79 | #define ICSR_BUSY 0x10 | ||
80 | #define ICSR_AL 0x08 | ||
81 | #define ICSR_TACK 0x04 | ||
82 | #define ICSR_WAIT 0x02 | ||
83 | #define ICSR_DTE 0x01 | ||
84 | |||
85 | #define ICIC_ALE 0x08 | ||
86 | #define ICIC_TACKE 0x04 | ||
87 | #define ICIC_WAITE 0x02 | ||
88 | #define ICIC_DTEE 0x01 | ||
89 | |||
90 | static void activate_ch(struct sh_mobile_i2c_data *pd) | ||
91 | { | ||
92 | /* Make sure the clock is enabled */ | ||
93 | clk_enable(pd->clk); | ||
94 | |||
95 | /* Enable channel and configure rx ack */ | ||
96 | iowrite8(ioread8(ICCR(pd)) | ICCR_ICE, ICCR(pd)); | ||
97 | |||
98 | /* Mask all interrupts */ | ||
99 | iowrite8(0, ICIC(pd)); | ||
100 | |||
101 | /* Set the clock */ | ||
102 | iowrite8(pd->iccl, ICCL(pd)); | ||
103 | iowrite8(pd->icch, ICCH(pd)); | ||
104 | } | ||
105 | |||
106 | static void deactivate_ch(struct sh_mobile_i2c_data *pd) | ||
107 | { | ||
108 | /* Clear/disable interrupts */ | ||
109 | iowrite8(0, ICSR(pd)); | ||
110 | iowrite8(0, ICIC(pd)); | ||
111 | |||
112 | /* Disable channel */ | ||
113 | iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd)); | ||
114 | |||
115 | /* Disable clock */ | ||
116 | clk_disable(pd->clk); | ||
117 | } | ||
118 | |||
119 | static unsigned char i2c_op(struct sh_mobile_i2c_data *pd, | ||
120 | enum sh_mobile_i2c_op op, unsigned char data) | ||
121 | { | ||
122 | unsigned char ret = 0; | ||
123 | unsigned long flags; | ||
124 | |||
125 | dev_dbg(pd->dev, "op %d, data in 0x%02x\n", op, data); | ||
126 | |||
127 | spin_lock_irqsave(&pd->lock, flags); | ||
128 | |||
129 | switch (op) { | ||
130 | case OP_START: | ||
131 | iowrite8(0x94, ICCR(pd)); | ||
132 | break; | ||
133 | case OP_TX_ONLY: | ||
134 | iowrite8(data, ICDR(pd)); | ||
135 | break; | ||
136 | case OP_TX_STOP: | ||
137 | iowrite8(data, ICDR(pd)); | ||
138 | iowrite8(0x90, ICCR(pd)); | ||
139 | iowrite8(ICIC_ALE | ICIC_TACKE, ICIC(pd)); | ||
140 | break; | ||
141 | case OP_TX_TO_RX: | ||
142 | iowrite8(data, ICDR(pd)); | ||
143 | iowrite8(0x81, ICCR(pd)); | ||
144 | break; | ||
145 | case OP_RX_ONLY: | ||
146 | ret = ioread8(ICDR(pd)); | ||
147 | break; | ||
148 | case OP_RX_STOP: | ||
149 | ret = ioread8(ICDR(pd)); | ||
150 | iowrite8(0xc0, ICCR(pd)); | ||
151 | break; | ||
152 | } | ||
153 | |||
154 | spin_unlock_irqrestore(&pd->lock, flags); | ||
155 | |||
156 | dev_dbg(pd->dev, "op %d, data out 0x%02x\n", op, ret); | ||
157 | return ret; | ||
158 | } | ||
159 | |||
160 | static irqreturn_t sh_mobile_i2c_isr(int irq, void *dev_id) | ||
161 | { | ||
162 | struct platform_device *dev = dev_id; | ||
163 | struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev); | ||
164 | struct i2c_msg *msg = pd->msg; | ||
165 | unsigned char data, sr; | ||
166 | int wakeup = 0; | ||
167 | |||
168 | sr = ioread8(ICSR(pd)); | ||
169 | pd->sr |= sr; | ||
170 | |||
171 | dev_dbg(pd->dev, "i2c_isr 0x%02x 0x%02x %s %d %d!\n", sr, pd->sr, | ||
172 | (msg->flags & I2C_M_RD) ? "read" : "write", | ||
173 | pd->pos, msg->len); | ||
174 | |||
175 | if (sr & (ICSR_AL | ICSR_TACK)) { | ||
176 | iowrite8(0, ICIC(pd)); /* disable interrupts */ | ||
177 | wakeup = 1; | ||
178 | goto do_wakeup; | ||
179 | } | ||
180 | |||
181 | if (pd->pos == msg->len) { | ||
182 | i2c_op(pd, OP_RX_ONLY, 0); | ||
183 | wakeup = 1; | ||
184 | goto do_wakeup; | ||
185 | } | ||
186 | |||
187 | if (pd->pos == -1) { | ||
188 | data = (msg->addr & 0x7f) << 1; | ||
189 | data |= (msg->flags & I2C_M_RD) ? 1 : 0; | ||
190 | } else | ||
191 | data = msg->buf[pd->pos]; | ||
192 | |||
193 | if ((pd->pos == -1) || !(msg->flags & I2C_M_RD)) { | ||
194 | if (msg->flags & I2C_M_RD) | ||
195 | i2c_op(pd, OP_TX_TO_RX, data); | ||
196 | else if (pd->pos == (msg->len - 1)) { | ||
197 | i2c_op(pd, OP_TX_STOP, data); | ||
198 | wakeup = 1; | ||
199 | } else | ||
200 | i2c_op(pd, OP_TX_ONLY, data); | ||
201 | } else { | ||
202 | if (pd->pos == (msg->len - 1)) | ||
203 | data = i2c_op(pd, OP_RX_STOP, 0); | ||
204 | else | ||
205 | data = i2c_op(pd, OP_RX_ONLY, 0); | ||
206 | |||
207 | msg->buf[pd->pos] = data; | ||
208 | } | ||
209 | pd->pos++; | ||
210 | |||
211 | do_wakeup: | ||
212 | if (wakeup) { | ||
213 | pd->sr |= SW_DONE; | ||
214 | wake_up(&pd->wait); | ||
215 | } | ||
216 | |||
217 | return IRQ_HANDLED; | ||
218 | } | ||
219 | |||
220 | static int start_ch(struct sh_mobile_i2c_data *pd, struct i2c_msg *usr_msg) | ||
221 | { | ||
222 | /* Initialize channel registers */ | ||
223 | iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd)); | ||
224 | |||
225 | /* Enable channel and configure rx ack */ | ||
226 | iowrite8(ioread8(ICCR(pd)) | ICCR_ICE, ICCR(pd)); | ||
227 | |||
228 | /* Set the clock */ | ||
229 | iowrite8(pd->iccl, ICCL(pd)); | ||
230 | iowrite8(pd->icch, ICCH(pd)); | ||
231 | |||
232 | pd->msg = usr_msg; | ||
233 | pd->pos = -1; | ||
234 | pd->sr = 0; | ||
235 | |||
236 | /* Enable all interrupts except wait */ | ||
237 | iowrite8(ioread8(ICIC(pd)) | ICIC_ALE | ICIC_TACKE | ICIC_DTEE, | ||
238 | ICIC(pd)); | ||
239 | return 0; | ||
240 | } | ||
241 | |||
242 | static int sh_mobile_i2c_xfer(struct i2c_adapter *adapter, | ||
243 | struct i2c_msg *msgs, | ||
244 | int num) | ||
245 | { | ||
246 | struct sh_mobile_i2c_data *pd = i2c_get_adapdata(adapter); | ||
247 | struct i2c_msg *msg; | ||
248 | int err = 0; | ||
249 | u_int8_t val; | ||
250 | int i, k, retry_count; | ||
251 | |||
252 | activate_ch(pd); | ||
253 | |||
254 | /* Process all messages */ | ||
255 | for (i = 0; i < num; i++) { | ||
256 | msg = &msgs[i]; | ||
257 | |||
258 | err = start_ch(pd, msg); | ||
259 | if (err) | ||
260 | break; | ||
261 | |||
262 | i2c_op(pd, OP_START, 0); | ||
263 | |||
264 | /* The interrupt handler takes care of the rest... */ | ||
265 | k = wait_event_timeout(pd->wait, | ||
266 | pd->sr & (ICSR_TACK | SW_DONE), | ||
267 | 5 * HZ); | ||
268 | if (!k) | ||
269 | dev_err(pd->dev, "Transfer request timed out\n"); | ||
270 | |||
271 | retry_count = 10; | ||
272 | again: | ||
273 | val = ioread8(ICSR(pd)); | ||
274 | |||
275 | dev_dbg(pd->dev, "val 0x%02x pd->sr 0x%02x\n", val, pd->sr); | ||
276 | |||
277 | if ((val | pd->sr) & (ICSR_TACK | ICSR_AL)) { | ||
278 | err = -EIO; | ||
279 | break; | ||
280 | } | ||
281 | |||
282 | /* the interrupt handler may wake us up before the | ||
283 | * transfer is finished, so poll the hardware | ||
284 | * until we're done. | ||
285 | */ | ||
286 | |||
287 | if (!(!(val & ICSR_BUSY) && (val & ICSR_SCLM) && | ||
288 | (val & ICSR_SDAM))) { | ||
289 | msleep(1); | ||
290 | if (retry_count--) | ||
291 | goto again; | ||
292 | |||
293 | err = -EIO; | ||
294 | dev_err(pd->dev, "Polling timed out\n"); | ||
295 | break; | ||
296 | } | ||
297 | } | ||
298 | |||
299 | deactivate_ch(pd); | ||
300 | |||
301 | if (!err) | ||
302 | err = num; | ||
303 | return err; | ||
304 | } | ||
305 | |||
306 | static u32 sh_mobile_i2c_func(struct i2c_adapter *adapter) | ||
307 | { | ||
308 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; | ||
309 | } | ||
310 | |||
311 | static struct i2c_algorithm sh_mobile_i2c_algorithm = { | ||
312 | .functionality = sh_mobile_i2c_func, | ||
313 | .master_xfer = sh_mobile_i2c_xfer, | ||
314 | }; | ||
315 | |||
316 | static void sh_mobile_i2c_setup_channel(struct platform_device *dev) | ||
317 | { | ||
318 | struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev); | ||
319 | unsigned long peripheral_clk = clk_get_rate(pd->clk); | ||
320 | u_int32_t num; | ||
321 | u_int32_t denom; | ||
322 | u_int32_t tmp; | ||
323 | |||
324 | spin_lock_init(&pd->lock); | ||
325 | init_waitqueue_head(&pd->wait); | ||
326 | |||
327 | /* Calculate the value for iccl. From the data sheet: | ||
328 | * iccl = (p clock / transfer rate) * (L / (L + H)) | ||
329 | * where L and H are the SCL low/high ratio (5/4 in this case). | ||
330 | * We also round off the result. | ||
331 | */ | ||
332 | num = peripheral_clk * 5; | ||
333 | denom = NORMAL_SPEED * 9; | ||
334 | tmp = num * 10 / denom; | ||
335 | if (tmp % 10 >= 5) | ||
336 | pd->iccl = (u_int8_t)((num/denom) + 1); | ||
337 | else | ||
338 | pd->iccl = (u_int8_t)(num/denom); | ||
339 | |||
340 | /* Calculate the value for icch. From the data sheet: | ||
341 | icch = (p clock / transfer rate) * (H / (L + H)) */ | ||
342 | num = peripheral_clk * 4; | ||
343 | tmp = num * 10 / denom; | ||
344 | if (tmp % 10 >= 5) | ||
345 | pd->icch = (u_int8_t)((num/denom) + 1); | ||
346 | else | ||
347 | pd->icch = (u_int8_t)(num/denom); | ||
348 | } | ||
349 | |||
350 | static int sh_mobile_i2c_hook_irqs(struct platform_device *dev, int hook) | ||
351 | { | ||
352 | struct resource *res; | ||
353 | int ret = -ENXIO; | ||
354 | int q, m; | ||
355 | int k = 0; | ||
356 | int n = 0; | ||
357 | |||
358 | while ((res = platform_get_resource(dev, IORESOURCE_IRQ, k))) { | ||
359 | for (n = res->start; hook && n <= res->end; n++) { | ||
360 | if (request_irq(n, sh_mobile_i2c_isr, IRQF_DISABLED, | ||
361 | dev->dev.bus_id, dev)) | ||
362 | goto rollback; | ||
363 | } | ||
364 | k++; | ||
365 | } | ||
366 | |||
367 | if (hook) | ||
368 | return k > 0 ? 0 : -ENOENT; | ||
369 | |||
370 | k--; | ||
371 | ret = 0; | ||
372 | |||
373 | rollback: | ||
374 | for (q = k; k >= 0; k--) { | ||
375 | for (m = n; m >= res->start; m--) | ||
376 | free_irq(m, dev); | ||
377 | |||
378 | res = platform_get_resource(dev, IORESOURCE_IRQ, k - 1); | ||
379 | m = res->end; | ||
380 | } | ||
381 | |||
382 | return ret; | ||
383 | } | ||
384 | |||
385 | static int sh_mobile_i2c_probe(struct platform_device *dev) | ||
386 | { | ||
387 | struct sh_mobile_i2c_data *pd; | ||
388 | struct i2c_adapter *adap; | ||
389 | struct resource *res; | ||
390 | int size; | ||
391 | int ret; | ||
392 | |||
393 | pd = kzalloc(sizeof(struct sh_mobile_i2c_data), GFP_KERNEL); | ||
394 | if (pd == NULL) { | ||
395 | dev_err(&dev->dev, "cannot allocate private data\n"); | ||
396 | return -ENOMEM; | ||
397 | } | ||
398 | |||
399 | pd->clk = clk_get(&dev->dev, "peripheral_clk"); | ||
400 | if (IS_ERR(pd->clk)) { | ||
401 | dev_err(&dev->dev, "cannot get peripheral clock\n"); | ||
402 | ret = PTR_ERR(pd->clk); | ||
403 | goto err; | ||
404 | } | ||
405 | |||
406 | ret = sh_mobile_i2c_hook_irqs(dev, 1); | ||
407 | if (ret) { | ||
408 | dev_err(&dev->dev, "cannot request IRQ\n"); | ||
409 | goto err_clk; | ||
410 | } | ||
411 | |||
412 | pd->dev = &dev->dev; | ||
413 | platform_set_drvdata(dev, pd); | ||
414 | |||
415 | res = platform_get_resource(dev, IORESOURCE_MEM, 0); | ||
416 | if (res == NULL) { | ||
417 | dev_err(&dev->dev, "cannot find IO resource\n"); | ||
418 | ret = -ENOENT; | ||
419 | goto err_irq; | ||
420 | } | ||
421 | |||
422 | size = (res->end - res->start) + 1; | ||
423 | |||
424 | pd->reg = ioremap(res->start, size); | ||
425 | if (pd->reg == NULL) { | ||
426 | dev_err(&dev->dev, "cannot map IO\n"); | ||
427 | ret = -ENXIO; | ||
428 | goto err_irq; | ||
429 | } | ||
430 | |||
431 | /* setup the private data */ | ||
432 | adap = &pd->adap; | ||
433 | i2c_set_adapdata(adap, pd); | ||
434 | |||
435 | adap->owner = THIS_MODULE; | ||
436 | adap->algo = &sh_mobile_i2c_algorithm; | ||
437 | adap->dev.parent = &dev->dev; | ||
438 | adap->retries = 5; | ||
439 | adap->nr = dev->id; | ||
440 | |||
441 | strlcpy(adap->name, dev->name, sizeof(adap->name)); | ||
442 | |||
443 | sh_mobile_i2c_setup_channel(dev); | ||
444 | |||
445 | ret = i2c_add_numbered_adapter(adap); | ||
446 | if (ret < 0) { | ||
447 | dev_err(&dev->dev, "cannot add numbered adapter\n"); | ||
448 | goto err_all; | ||
449 | } | ||
450 | |||
451 | return 0; | ||
452 | |||
453 | err_all: | ||
454 | iounmap(pd->reg); | ||
455 | err_irq: | ||
456 | sh_mobile_i2c_hook_irqs(dev, 0); | ||
457 | err_clk: | ||
458 | clk_put(pd->clk); | ||
459 | err: | ||
460 | kfree(pd); | ||
461 | return ret; | ||
462 | } | ||
463 | |||
464 | static int sh_mobile_i2c_remove(struct platform_device *dev) | ||
465 | { | ||
466 | struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev); | ||
467 | |||
468 | i2c_del_adapter(&pd->adap); | ||
469 | iounmap(pd->reg); | ||
470 | sh_mobile_i2c_hook_irqs(dev, 0); | ||
471 | clk_put(pd->clk); | ||
472 | kfree(pd); | ||
473 | return 0; | ||
474 | } | ||
475 | |||
476 | static struct platform_driver sh_mobile_i2c_driver = { | ||
477 | .driver = { | ||
478 | .name = "i2c-sh_mobile", | ||
479 | .owner = THIS_MODULE, | ||
480 | }, | ||
481 | .probe = sh_mobile_i2c_probe, | ||
482 | .remove = sh_mobile_i2c_remove, | ||
483 | }; | ||
484 | |||
485 | static int __init sh_mobile_i2c_adap_init(void) | ||
486 | { | ||
487 | return platform_driver_register(&sh_mobile_i2c_driver); | ||
488 | } | ||
489 | |||
490 | static void __exit sh_mobile_i2c_adap_exit(void) | ||
491 | { | ||
492 | platform_driver_unregister(&sh_mobile_i2c_driver); | ||
493 | } | ||
494 | |||
495 | module_init(sh_mobile_i2c_adap_init); | ||
496 | module_exit(sh_mobile_i2c_adap_exit); | ||
497 | |||
498 | MODULE_DESCRIPTION("SuperH Mobile I2C Bus Controller driver"); | ||
499 | MODULE_AUTHOR("Magnus Damm"); | ||
500 | MODULE_LICENSE("GPL v2"); | ||
diff --git a/drivers/i2c/busses/i2c-simtec.c b/drivers/i2c/busses/i2c-simtec.c index 10af8d31e12a..042fda295f3a 100644 --- a/drivers/i2c/busses/i2c-simtec.c +++ b/drivers/i2c/busses/i2c-simtec.c | |||
@@ -159,6 +159,9 @@ static int simtec_i2c_remove(struct platform_device *dev) | |||
159 | 159 | ||
160 | /* device driver */ | 160 | /* device driver */ |
161 | 161 | ||
162 | /* work with hotplug and coldplug */ | ||
163 | MODULE_ALIAS("platform:simtec-i2c"); | ||
164 | |||
162 | static struct platform_driver simtec_i2c_driver = { | 165 | static struct platform_driver simtec_i2c_driver = { |
163 | .driver = { | 166 | .driver = { |
164 | .name = "simtec-i2c", | 167 | .name = "simtec-i2c", |
diff --git a/drivers/i2c/busses/i2c-versatile.c b/drivers/i2c/busses/i2c-versatile.c index 081d9578ce10..4678babd3ce6 100644 --- a/drivers/i2c/busses/i2c-versatile.c +++ b/drivers/i2c/busses/i2c-versatile.c | |||
@@ -151,3 +151,4 @@ module_exit(i2c_versatile_exit); | |||
151 | 151 | ||
152 | MODULE_DESCRIPTION("ARM Versatile I2C bus driver"); | 152 | MODULE_DESCRIPTION("ARM Versatile I2C bus driver"); |
153 | MODULE_LICENSE("GPL"); | 153 | MODULE_LICENSE("GPL"); |
154 | MODULE_ALIAS("platform:versatile-i2c"); | ||
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c index f5e7a70da831..61abe0f33255 100644 --- a/drivers/i2c/busses/scx200_acb.c +++ b/drivers/i2c/busses/scx200_acb.c | |||
@@ -527,7 +527,7 @@ static int __init scx200_create_isa(const char *text, unsigned long base, | |||
527 | if (iface == NULL) | 527 | if (iface == NULL) |
528 | return -ENOMEM; | 528 | return -ENOMEM; |
529 | 529 | ||
530 | if (request_region(base, 8, iface->adapter.name) == 0) { | 530 | if (!request_region(base, 8, iface->adapter.name)) { |
531 | printk(KERN_ERR NAME ": can't allocate io 0x%lx-0x%lx\n", | 531 | printk(KERN_ERR NAME ": can't allocate io 0x%lx-0x%lx\n", |
532 | base, base + 8 - 1); | 532 | base, base + 8 - 1); |
533 | rc = -EBUSY; | 533 | rc = -EBUSY; |
diff --git a/drivers/i2c/chips/isp1301_omap.c b/drivers/i2c/chips/isp1301_omap.c index 2a3160153f54..b1b45dddb17e 100644 --- a/drivers/i2c/chips/isp1301_omap.c +++ b/drivers/i2c/chips/isp1301_omap.c | |||
@@ -658,7 +658,7 @@ pulldown: | |||
658 | OTG_CTRL_REG |= OTG_PULLUP; | 658 | OTG_CTRL_REG |= OTG_PULLUP; |
659 | } | 659 | } |
660 | 660 | ||
661 | check_state(isp, __FUNCTION__); | 661 | check_state(isp, __func__); |
662 | dump_regs(isp, "otg->isp1301"); | 662 | dump_regs(isp, "otg->isp1301"); |
663 | } | 663 | } |
664 | 664 | ||
@@ -782,7 +782,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp) | |||
782 | if (otg_ctrl & OTG_DRIVER_SEL) { | 782 | if (otg_ctrl & OTG_DRIVER_SEL) { |
783 | switch (isp->otg.state) { | 783 | switch (isp->otg.state) { |
784 | case OTG_STATE_A_IDLE: | 784 | case OTG_STATE_A_IDLE: |
785 | b_idle(isp, __FUNCTION__); | 785 | b_idle(isp, __func__); |
786 | break; | 786 | break; |
787 | default: | 787 | default: |
788 | break; | 788 | break; |
@@ -826,7 +826,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp) | |||
826 | isp->otg.host->otg_port); | 826 | isp->otg.host->otg_port); |
827 | } | 827 | } |
828 | 828 | ||
829 | check_state(isp, __FUNCTION__); | 829 | check_state(isp, __func__); |
830 | return ret; | 830 | return ret; |
831 | } | 831 | } |
832 | 832 | ||
@@ -837,7 +837,7 @@ static int otg_init(struct isp1301 *isp) | |||
837 | if (!otg_dev) | 837 | if (!otg_dev) |
838 | return -ENODEV; | 838 | return -ENODEV; |
839 | 839 | ||
840 | dump_regs(isp, __FUNCTION__); | 840 | dump_regs(isp, __func__); |
841 | /* some of these values are board-specific... */ | 841 | /* some of these values are board-specific... */ |
842 | OTG_SYSCON_2_REG |= OTG_EN | 842 | OTG_SYSCON_2_REG |= OTG_EN |
843 | /* for B-device: */ | 843 | /* for B-device: */ |
@@ -853,9 +853,9 @@ static int otg_init(struct isp1301 *isp) | |||
853 | update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE)); | 853 | update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE)); |
854 | update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS)); | 854 | update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS)); |
855 | 855 | ||
856 | check_state(isp, __FUNCTION__); | 856 | check_state(isp, __func__); |
857 | pr_debug("otg: %s, %s %06x\n", | 857 | pr_debug("otg: %s, %s %06x\n", |
858 | state_name(isp), __FUNCTION__, OTG_CTRL_REG); | 858 | state_name(isp), __func__, OTG_CTRL_REG); |
859 | 859 | ||
860 | OTG_IRQ_EN_REG = DRIVER_SWITCH | OPRT_CHG | 860 | OTG_IRQ_EN_REG = DRIVER_SWITCH | OPRT_CHG |
861 | | B_SRP_TMROUT | B_HNP_FAIL | 861 | | B_SRP_TMROUT | B_HNP_FAIL |
@@ -1041,11 +1041,11 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat) | |||
1041 | OTG1_DP_PULLDOWN); | 1041 | OTG1_DP_PULLDOWN); |
1042 | isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, | 1042 | isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, |
1043 | OTG1_DP_PULLUP); | 1043 | OTG1_DP_PULLUP); |
1044 | dump_regs(isp, __FUNCTION__); | 1044 | dump_regs(isp, __func__); |
1045 | #endif | 1045 | #endif |
1046 | /* FALLTHROUGH */ | 1046 | /* FALLTHROUGH */ |
1047 | case OTG_STATE_B_SRP_INIT: | 1047 | case OTG_STATE_B_SRP_INIT: |
1048 | b_idle(isp, __FUNCTION__); | 1048 | b_idle(isp, __func__); |
1049 | OTG_CTRL_REG &= OTG_CTRL_REG & OTG_XCEIV_OUTPUTS; | 1049 | OTG_CTRL_REG &= OTG_CTRL_REG & OTG_XCEIV_OUTPUTS; |
1050 | /* FALLTHROUGH */ | 1050 | /* FALLTHROUGH */ |
1051 | case OTG_STATE_B_IDLE: | 1051 | case OTG_STATE_B_IDLE: |
@@ -1077,7 +1077,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat) | |||
1077 | */ | 1077 | */ |
1078 | update_otg1(isp, isp_stat); | 1078 | update_otg1(isp, isp_stat); |
1079 | update_otg2(isp, isp_bstat); | 1079 | update_otg2(isp, isp_bstat); |
1080 | check_state(isp, __FUNCTION__); | 1080 | check_state(isp, __func__); |
1081 | #endif | 1081 | #endif |
1082 | 1082 | ||
1083 | dump_regs(isp, "isp1301->otg"); | 1083 | dump_regs(isp, "isp1301->otg"); |
@@ -1310,7 +1310,7 @@ isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host) | |||
1310 | */ | 1310 | */ |
1311 | isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV); | 1311 | isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV); |
1312 | 1312 | ||
1313 | dump_regs(isp, __FUNCTION__); | 1313 | dump_regs(isp, __func__); |
1314 | 1314 | ||
1315 | return 0; | 1315 | return 0; |
1316 | 1316 | ||
@@ -1365,7 +1365,7 @@ isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget) | |||
1365 | isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING, | 1365 | isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING, |
1366 | INTR_VBUS_VLD); | 1366 | INTR_VBUS_VLD); |
1367 | dev_info(&isp->client.dev, "B-Peripheral sessions ok\n"); | 1367 | dev_info(&isp->client.dev, "B-Peripheral sessions ok\n"); |
1368 | dump_regs(isp, __FUNCTION__); | 1368 | dump_regs(isp, __func__); |
1369 | 1369 | ||
1370 | /* If this has a Mini-AB connector, this mode is highly | 1370 | /* If this has a Mini-AB connector, this mode is highly |
1371 | * nonstandard ... but can be handy for testing, so long | 1371 | * nonstandard ... but can be handy for testing, so long |
@@ -1416,7 +1416,7 @@ isp1301_start_srp(struct otg_transceiver *dev) | |||
1416 | 1416 | ||
1417 | pr_debug("otg: SRP, %s ... %06x\n", state_name(isp), OTG_CTRL_REG); | 1417 | pr_debug("otg: SRP, %s ... %06x\n", state_name(isp), OTG_CTRL_REG); |
1418 | #ifdef CONFIG_USB_OTG | 1418 | #ifdef CONFIG_USB_OTG |
1419 | check_state(isp, __FUNCTION__); | 1419 | check_state(isp, __func__); |
1420 | #endif | 1420 | #endif |
1421 | return 0; | 1421 | return 0; |
1422 | } | 1422 | } |
@@ -1463,7 +1463,7 @@ isp1301_start_hnp(struct otg_transceiver *dev) | |||
1463 | } | 1463 | } |
1464 | pr_debug("otg: HNP %s, %06x ...\n", | 1464 | pr_debug("otg: HNP %s, %06x ...\n", |
1465 | state_name(isp), OTG_CTRL_REG); | 1465 | state_name(isp), OTG_CTRL_REG); |
1466 | check_state(isp, __FUNCTION__); | 1466 | check_state(isp, __func__); |
1467 | return 0; | 1467 | return 0; |
1468 | #else | 1468 | #else |
1469 | /* srp-only */ | 1469 | /* srp-only */ |
@@ -1601,7 +1601,7 @@ fail2: | |||
1601 | update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS)); | 1601 | update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS)); |
1602 | #endif | 1602 | #endif |
1603 | 1603 | ||
1604 | dump_regs(isp, __FUNCTION__); | 1604 | dump_regs(isp, __func__); |
1605 | 1605 | ||
1606 | #ifdef VERBOSE | 1606 | #ifdef VERBOSE |
1607 | mod_timer(&isp->timer, jiffies + TIMER_JIFFIES); | 1607 | mod_timer(&isp->timer, jiffies + TIMER_JIFFIES); |
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c index e186df657119..6c7fa8d53c0e 100644 --- a/drivers/i2c/i2c-core.c +++ b/drivers/i2c/i2c-core.c | |||
@@ -1506,7 +1506,7 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, | |||
1506 | read_write = I2C_SMBUS_READ; | 1506 | read_write = I2C_SMBUS_READ; |
1507 | if (data->block[0] > I2C_SMBUS_BLOCK_MAX) { | 1507 | if (data->block[0] > I2C_SMBUS_BLOCK_MAX) { |
1508 | dev_err(&adapter->dev, "%s called with invalid " | 1508 | dev_err(&adapter->dev, "%s called with invalid " |
1509 | "block proc call size (%d)\n", __FUNCTION__, | 1509 | "block proc call size (%d)\n", __func__, |
1510 | data->block[0]); | 1510 | data->block[0]); |
1511 | return -1; | 1511 | return -1; |
1512 | } | 1512 | } |
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c index 393e679d9faa..d34c14c81c29 100644 --- a/drivers/i2c/i2c-dev.c +++ b/drivers/i2c/i2c-dev.c | |||
@@ -200,16 +200,176 @@ static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr) | |||
200 | return device_for_each_child(&adapter->dev, &addr, i2cdev_check); | 200 | return device_for_each_child(&adapter->dev, &addr, i2cdev_check); |
201 | } | 201 | } |
202 | 202 | ||
203 | static int i2cdev_ioctl(struct inode *inode, struct file *file, | 203 | static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client, |
204 | unsigned int cmd, unsigned long arg) | 204 | unsigned long arg) |
205 | { | 205 | { |
206 | struct i2c_client *client = (struct i2c_client *)file->private_data; | ||
207 | struct i2c_rdwr_ioctl_data rdwr_arg; | 206 | struct i2c_rdwr_ioctl_data rdwr_arg; |
208 | struct i2c_smbus_ioctl_data data_arg; | ||
209 | union i2c_smbus_data temp; | ||
210 | struct i2c_msg *rdwr_pa; | 207 | struct i2c_msg *rdwr_pa; |
211 | u8 __user **data_ptrs; | 208 | u8 __user **data_ptrs; |
212 | int i,datasize,res; | 209 | int i, res; |
210 | |||
211 | if (copy_from_user(&rdwr_arg, | ||
212 | (struct i2c_rdwr_ioctl_data __user *)arg, | ||
213 | sizeof(rdwr_arg))) | ||
214 | return -EFAULT; | ||
215 | |||
216 | /* Put an arbitrary limit on the number of messages that can | ||
217 | * be sent at once */ | ||
218 | if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS) | ||
219 | return -EINVAL; | ||
220 | |||
221 | rdwr_pa = (struct i2c_msg *) | ||
222 | kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), | ||
223 | GFP_KERNEL); | ||
224 | if (!rdwr_pa) | ||
225 | return -ENOMEM; | ||
226 | |||
227 | if (copy_from_user(rdwr_pa, rdwr_arg.msgs, | ||
228 | rdwr_arg.nmsgs * sizeof(struct i2c_msg))) { | ||
229 | kfree(rdwr_pa); | ||
230 | return -EFAULT; | ||
231 | } | ||
232 | |||
233 | data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL); | ||
234 | if (data_ptrs == NULL) { | ||
235 | kfree(rdwr_pa); | ||
236 | return -ENOMEM; | ||
237 | } | ||
238 | |||
239 | res = 0; | ||
240 | for (i = 0; i < rdwr_arg.nmsgs; i++) { | ||
241 | /* Limit the size of the message to a sane amount; | ||
242 | * and don't let length change either. */ | ||
243 | if ((rdwr_pa[i].len > 8192) || | ||
244 | (rdwr_pa[i].flags & I2C_M_RECV_LEN)) { | ||
245 | res = -EINVAL; | ||
246 | break; | ||
247 | } | ||
248 | data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf; | ||
249 | rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL); | ||
250 | if (rdwr_pa[i].buf == NULL) { | ||
251 | res = -ENOMEM; | ||
252 | break; | ||
253 | } | ||
254 | if (copy_from_user(rdwr_pa[i].buf, data_ptrs[i], | ||
255 | rdwr_pa[i].len)) { | ||
256 | ++i; /* Needs to be kfreed too */ | ||
257 | res = -EFAULT; | ||
258 | break; | ||
259 | } | ||
260 | } | ||
261 | if (res < 0) { | ||
262 | int j; | ||
263 | for (j = 0; j < i; ++j) | ||
264 | kfree(rdwr_pa[j].buf); | ||
265 | kfree(data_ptrs); | ||
266 | kfree(rdwr_pa); | ||
267 | return res; | ||
268 | } | ||
269 | |||
270 | res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs); | ||
271 | while (i-- > 0) { | ||
272 | if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) { | ||
273 | if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf, | ||
274 | rdwr_pa[i].len)) | ||
275 | res = -EFAULT; | ||
276 | } | ||
277 | kfree(rdwr_pa[i].buf); | ||
278 | } | ||
279 | kfree(data_ptrs); | ||
280 | kfree(rdwr_pa); | ||
281 | return res; | ||
282 | } | ||
283 | |||
284 | static noinline int i2cdev_ioctl_smbus(struct i2c_client *client, | ||
285 | unsigned long arg) | ||
286 | { | ||
287 | struct i2c_smbus_ioctl_data data_arg; | ||
288 | union i2c_smbus_data temp; | ||
289 | int datasize, res; | ||
290 | |||
291 | if (copy_from_user(&data_arg, | ||
292 | (struct i2c_smbus_ioctl_data __user *) arg, | ||
293 | sizeof(struct i2c_smbus_ioctl_data))) | ||
294 | return -EFAULT; | ||
295 | if ((data_arg.size != I2C_SMBUS_BYTE) && | ||
296 | (data_arg.size != I2C_SMBUS_QUICK) && | ||
297 | (data_arg.size != I2C_SMBUS_BYTE_DATA) && | ||
298 | (data_arg.size != I2C_SMBUS_WORD_DATA) && | ||
299 | (data_arg.size != I2C_SMBUS_PROC_CALL) && | ||
300 | (data_arg.size != I2C_SMBUS_BLOCK_DATA) && | ||
301 | (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) && | ||
302 | (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) && | ||
303 | (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) { | ||
304 | dev_dbg(&client->adapter->dev, | ||
305 | "size out of range (%x) in ioctl I2C_SMBUS.\n", | ||
306 | data_arg.size); | ||
307 | return -EINVAL; | ||
308 | } | ||
309 | /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1, | ||
310 | so the check is valid if size==I2C_SMBUS_QUICK too. */ | ||
311 | if ((data_arg.read_write != I2C_SMBUS_READ) && | ||
312 | (data_arg.read_write != I2C_SMBUS_WRITE)) { | ||
313 | dev_dbg(&client->adapter->dev, | ||
314 | "read_write out of range (%x) in ioctl I2C_SMBUS.\n", | ||
315 | data_arg.read_write); | ||
316 | return -EINVAL; | ||
317 | } | ||
318 | |||
319 | /* Note that command values are always valid! */ | ||
320 | |||
321 | if ((data_arg.size == I2C_SMBUS_QUICK) || | ||
322 | ((data_arg.size == I2C_SMBUS_BYTE) && | ||
323 | (data_arg.read_write == I2C_SMBUS_WRITE))) | ||
324 | /* These are special: we do not use data */ | ||
325 | return i2c_smbus_xfer(client->adapter, client->addr, | ||
326 | client->flags, data_arg.read_write, | ||
327 | data_arg.command, data_arg.size, NULL); | ||
328 | |||
329 | if (data_arg.data == NULL) { | ||
330 | dev_dbg(&client->adapter->dev, | ||
331 | "data is NULL pointer in ioctl I2C_SMBUS.\n"); | ||
332 | return -EINVAL; | ||
333 | } | ||
334 | |||
335 | if ((data_arg.size == I2C_SMBUS_BYTE_DATA) || | ||
336 | (data_arg.size == I2C_SMBUS_BYTE)) | ||
337 | datasize = sizeof(data_arg.data->byte); | ||
338 | else if ((data_arg.size == I2C_SMBUS_WORD_DATA) || | ||
339 | (data_arg.size == I2C_SMBUS_PROC_CALL)) | ||
340 | datasize = sizeof(data_arg.data->word); | ||
341 | else /* size == smbus block, i2c block, or block proc. call */ | ||
342 | datasize = sizeof(data_arg.data->block); | ||
343 | |||
344 | if ((data_arg.size == I2C_SMBUS_PROC_CALL) || | ||
345 | (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || | ||
346 | (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) || | ||
347 | (data_arg.read_write == I2C_SMBUS_WRITE)) { | ||
348 | if (copy_from_user(&temp, data_arg.data, datasize)) | ||
349 | return -EFAULT; | ||
350 | } | ||
351 | if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) { | ||
352 | /* Convert old I2C block commands to the new | ||
353 | convention. This preserves binary compatibility. */ | ||
354 | data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA; | ||
355 | if (data_arg.read_write == I2C_SMBUS_READ) | ||
356 | temp.block[0] = I2C_SMBUS_BLOCK_MAX; | ||
357 | } | ||
358 | res = i2c_smbus_xfer(client->adapter, client->addr, client->flags, | ||
359 | data_arg.read_write, data_arg.command, data_arg.size, &temp); | ||
360 | if (!res && ((data_arg.size == I2C_SMBUS_PROC_CALL) || | ||
361 | (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || | ||
362 | (data_arg.read_write == I2C_SMBUS_READ))) { | ||
363 | if (copy_to_user(data_arg.data, &temp, datasize)) | ||
364 | return -EFAULT; | ||
365 | } | ||
366 | return res; | ||
367 | } | ||
368 | |||
369 | static int i2cdev_ioctl(struct inode *inode, struct file *file, | ||
370 | unsigned int cmd, unsigned long arg) | ||
371 | { | ||
372 | struct i2c_client *client = (struct i2c_client *)file->private_data; | ||
213 | unsigned long funcs; | 373 | unsigned long funcs; |
214 | 374 | ||
215 | dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n", | 375 | dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n", |
@@ -253,164 +413,11 @@ static int i2cdev_ioctl(struct inode *inode, struct file *file, | |||
253 | return put_user(funcs, (unsigned long __user *)arg); | 413 | return put_user(funcs, (unsigned long __user *)arg); |
254 | 414 | ||
255 | case I2C_RDWR: | 415 | case I2C_RDWR: |
256 | if (copy_from_user(&rdwr_arg, | 416 | return i2cdev_ioctl_rdrw(client, arg); |
257 | (struct i2c_rdwr_ioctl_data __user *)arg, | ||
258 | sizeof(rdwr_arg))) | ||
259 | return -EFAULT; | ||
260 | |||
261 | /* Put an arbitrary limit on the number of messages that can | ||
262 | * be sent at once */ | ||
263 | if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS) | ||
264 | return -EINVAL; | ||
265 | |||
266 | rdwr_pa = (struct i2c_msg *) | ||
267 | kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), | ||
268 | GFP_KERNEL); | ||
269 | |||
270 | if (rdwr_pa == NULL) return -ENOMEM; | ||
271 | |||
272 | if (copy_from_user(rdwr_pa, rdwr_arg.msgs, | ||
273 | rdwr_arg.nmsgs * sizeof(struct i2c_msg))) { | ||
274 | kfree(rdwr_pa); | ||
275 | return -EFAULT; | ||
276 | } | ||
277 | |||
278 | data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL); | ||
279 | if (data_ptrs == NULL) { | ||
280 | kfree(rdwr_pa); | ||
281 | return -ENOMEM; | ||
282 | } | ||
283 | |||
284 | res = 0; | ||
285 | for( i=0; i<rdwr_arg.nmsgs; i++ ) { | ||
286 | /* Limit the size of the message to a sane amount; | ||
287 | * and don't let length change either. */ | ||
288 | if ((rdwr_pa[i].len > 8192) || | ||
289 | (rdwr_pa[i].flags & I2C_M_RECV_LEN)) { | ||
290 | res = -EINVAL; | ||
291 | break; | ||
292 | } | ||
293 | data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf; | ||
294 | rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL); | ||
295 | if(rdwr_pa[i].buf == NULL) { | ||
296 | res = -ENOMEM; | ||
297 | break; | ||
298 | } | ||
299 | if(copy_from_user(rdwr_pa[i].buf, | ||
300 | data_ptrs[i], | ||
301 | rdwr_pa[i].len)) { | ||
302 | ++i; /* Needs to be kfreed too */ | ||
303 | res = -EFAULT; | ||
304 | break; | ||
305 | } | ||
306 | } | ||
307 | if (res < 0) { | ||
308 | int j; | ||
309 | for (j = 0; j < i; ++j) | ||
310 | kfree(rdwr_pa[j].buf); | ||
311 | kfree(data_ptrs); | ||
312 | kfree(rdwr_pa); | ||
313 | return res; | ||
314 | } | ||
315 | |||
316 | res = i2c_transfer(client->adapter, | ||
317 | rdwr_pa, | ||
318 | rdwr_arg.nmsgs); | ||
319 | while(i-- > 0) { | ||
320 | if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD)) { | ||
321 | if(copy_to_user( | ||
322 | data_ptrs[i], | ||
323 | rdwr_pa[i].buf, | ||
324 | rdwr_pa[i].len)) { | ||
325 | res = -EFAULT; | ||
326 | } | ||
327 | } | ||
328 | kfree(rdwr_pa[i].buf); | ||
329 | } | ||
330 | kfree(data_ptrs); | ||
331 | kfree(rdwr_pa); | ||
332 | return res; | ||
333 | 417 | ||
334 | case I2C_SMBUS: | 418 | case I2C_SMBUS: |
335 | if (copy_from_user(&data_arg, | 419 | return i2cdev_ioctl_smbus(client, arg); |
336 | (struct i2c_smbus_ioctl_data __user *) arg, | ||
337 | sizeof(struct i2c_smbus_ioctl_data))) | ||
338 | return -EFAULT; | ||
339 | if ((data_arg.size != I2C_SMBUS_BYTE) && | ||
340 | (data_arg.size != I2C_SMBUS_QUICK) && | ||
341 | (data_arg.size != I2C_SMBUS_BYTE_DATA) && | ||
342 | (data_arg.size != I2C_SMBUS_WORD_DATA) && | ||
343 | (data_arg.size != I2C_SMBUS_PROC_CALL) && | ||
344 | (data_arg.size != I2C_SMBUS_BLOCK_DATA) && | ||
345 | (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) && | ||
346 | (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) && | ||
347 | (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) { | ||
348 | dev_dbg(&client->adapter->dev, | ||
349 | "size out of range (%x) in ioctl I2C_SMBUS.\n", | ||
350 | data_arg.size); | ||
351 | return -EINVAL; | ||
352 | } | ||
353 | /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1, | ||
354 | so the check is valid if size==I2C_SMBUS_QUICK too. */ | ||
355 | if ((data_arg.read_write != I2C_SMBUS_READ) && | ||
356 | (data_arg.read_write != I2C_SMBUS_WRITE)) { | ||
357 | dev_dbg(&client->adapter->dev, | ||
358 | "read_write out of range (%x) in ioctl I2C_SMBUS.\n", | ||
359 | data_arg.read_write); | ||
360 | return -EINVAL; | ||
361 | } | ||
362 | |||
363 | /* Note that command values are always valid! */ | ||
364 | |||
365 | if ((data_arg.size == I2C_SMBUS_QUICK) || | ||
366 | ((data_arg.size == I2C_SMBUS_BYTE) && | ||
367 | (data_arg.read_write == I2C_SMBUS_WRITE))) | ||
368 | /* These are special: we do not use data */ | ||
369 | return i2c_smbus_xfer(client->adapter, client->addr, | ||
370 | client->flags, | ||
371 | data_arg.read_write, | ||
372 | data_arg.command, | ||
373 | data_arg.size, NULL); | ||
374 | |||
375 | if (data_arg.data == NULL) { | ||
376 | dev_dbg(&client->adapter->dev, | ||
377 | "data is NULL pointer in ioctl I2C_SMBUS.\n"); | ||
378 | return -EINVAL; | ||
379 | } | ||
380 | 420 | ||
381 | if ((data_arg.size == I2C_SMBUS_BYTE_DATA) || | ||
382 | (data_arg.size == I2C_SMBUS_BYTE)) | ||
383 | datasize = sizeof(data_arg.data->byte); | ||
384 | else if ((data_arg.size == I2C_SMBUS_WORD_DATA) || | ||
385 | (data_arg.size == I2C_SMBUS_PROC_CALL)) | ||
386 | datasize = sizeof(data_arg.data->word); | ||
387 | else /* size == smbus block, i2c block, or block proc. call */ | ||
388 | datasize = sizeof(data_arg.data->block); | ||
389 | |||
390 | if ((data_arg.size == I2C_SMBUS_PROC_CALL) || | ||
391 | (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || | ||
392 | (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) || | ||
393 | (data_arg.read_write == I2C_SMBUS_WRITE)) { | ||
394 | if (copy_from_user(&temp, data_arg.data, datasize)) | ||
395 | return -EFAULT; | ||
396 | } | ||
397 | if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) { | ||
398 | /* Convert old I2C block commands to the new | ||
399 | convention. This preserves binary compatibility. */ | ||
400 | data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA; | ||
401 | if (data_arg.read_write == I2C_SMBUS_READ) | ||
402 | temp.block[0] = I2C_SMBUS_BLOCK_MAX; | ||
403 | } | ||
404 | res = i2c_smbus_xfer(client->adapter,client->addr,client->flags, | ||
405 | data_arg.read_write, | ||
406 | data_arg.command,data_arg.size,&temp); | ||
407 | if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) || | ||
408 | (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || | ||
409 | (data_arg.read_write == I2C_SMBUS_READ))) { | ||
410 | if (copy_to_user(data_arg.data, &temp, datasize)) | ||
411 | return -EFAULT; | ||
412 | } | ||
413 | return res; | ||
414 | case I2C_RETRIES: | 421 | case I2C_RETRIES: |
415 | client->adapter->retries = arg; | 422 | client->adapter->retries = arg; |
416 | break; | 423 | break; |
diff --git a/fs/Kconfig b/fs/Kconfig index 028ae38ecc52..8b18a8758677 100644 --- a/fs/Kconfig +++ b/fs/Kconfig | |||
@@ -689,6 +689,7 @@ config ZISOFS | |||
689 | 689 | ||
690 | config UDF_FS | 690 | config UDF_FS |
691 | tristate "UDF file system support" | 691 | tristate "UDF file system support" |
692 | select CRC_ITU_T | ||
692 | help | 693 | help |
693 | This is the new file system used on some CD-ROMs and DVDs. Say Y if | 694 | This is the new file system used on some CD-ROMs and DVDs. Say Y if |
694 | you intend to mount DVD discs or CDRW's written in packet mode, or | 695 | you intend to mount DVD discs or CDRW's written in packet mode, or |
diff --git a/fs/dlm/Makefile b/fs/dlm/Makefile index d248e60951ba..ca1c9124c8ce 100644 --- a/fs/dlm/Makefile +++ b/fs/dlm/Makefile | |||
@@ -10,6 +10,7 @@ dlm-y := ast.o \ | |||
10 | midcomms.o \ | 10 | midcomms.o \ |
11 | netlink.o \ | 11 | netlink.o \ |
12 | lowcomms.o \ | 12 | lowcomms.o \ |
13 | plock.o \ | ||
13 | rcom.o \ | 14 | rcom.o \ |
14 | recover.o \ | 15 | recover.o \ |
15 | recoverd.o \ | 16 | recoverd.o \ |
diff --git a/fs/dlm/config.c b/fs/dlm/config.c index c3ad1dff3b25..eac23bd288b2 100644 --- a/fs/dlm/config.c +++ b/fs/dlm/config.c | |||
@@ -114,7 +114,7 @@ struct cluster_attribute { | |||
114 | }; | 114 | }; |
115 | 115 | ||
116 | static ssize_t cluster_set(struct cluster *cl, unsigned int *cl_field, | 116 | static ssize_t cluster_set(struct cluster *cl, unsigned int *cl_field, |
117 | unsigned int *info_field, int check_zero, | 117 | int *info_field, int check_zero, |
118 | const char *buf, size_t len) | 118 | const char *buf, size_t len) |
119 | { | 119 | { |
120 | unsigned int x; | 120 | unsigned int x; |
@@ -284,6 +284,7 @@ struct node { | |||
284 | struct list_head list; /* space->members */ | 284 | struct list_head list; /* space->members */ |
285 | int nodeid; | 285 | int nodeid; |
286 | int weight; | 286 | int weight; |
287 | int new; | ||
287 | }; | 288 | }; |
288 | 289 | ||
289 | static struct configfs_group_operations clusters_ops = { | 290 | static struct configfs_group_operations clusters_ops = { |
@@ -565,6 +566,7 @@ static struct config_item *make_node(struct config_group *g, const char *name) | |||
565 | config_item_init_type_name(&nd->item, name, &node_type); | 566 | config_item_init_type_name(&nd->item, name, &node_type); |
566 | nd->nodeid = -1; | 567 | nd->nodeid = -1; |
567 | nd->weight = 1; /* default weight of 1 if none is set */ | 568 | nd->weight = 1; /* default weight of 1 if none is set */ |
569 | nd->new = 1; /* set to 0 once it's been read by dlm_nodeid_list() */ | ||
568 | 570 | ||
569 | mutex_lock(&sp->members_lock); | 571 | mutex_lock(&sp->members_lock); |
570 | list_add(&nd->list, &sp->members); | 572 | list_add(&nd->list, &sp->members); |
@@ -805,12 +807,13 @@ static void put_comm(struct comm *cm) | |||
805 | } | 807 | } |
806 | 808 | ||
807 | /* caller must free mem */ | 809 | /* caller must free mem */ |
808 | int dlm_nodeid_list(char *lsname, int **ids_out) | 810 | int dlm_nodeid_list(char *lsname, int **ids_out, int *ids_count_out, |
811 | int **new_out, int *new_count_out) | ||
809 | { | 812 | { |
810 | struct space *sp; | 813 | struct space *sp; |
811 | struct node *nd; | 814 | struct node *nd; |
812 | int i = 0, rv = 0; | 815 | int i = 0, rv = 0, ids_count = 0, new_count = 0; |
813 | int *ids; | 816 | int *ids, *new; |
814 | 817 | ||
815 | sp = get_space(lsname); | 818 | sp = get_space(lsname); |
816 | if (!sp) | 819 | if (!sp) |
@@ -818,23 +821,50 @@ int dlm_nodeid_list(char *lsname, int **ids_out) | |||
818 | 821 | ||
819 | mutex_lock(&sp->members_lock); | 822 | mutex_lock(&sp->members_lock); |
820 | if (!sp->members_count) { | 823 | if (!sp->members_count) { |
821 | rv = 0; | 824 | rv = -EINVAL; |
825 | printk(KERN_ERR "dlm: zero members_count\n"); | ||
822 | goto out; | 826 | goto out; |
823 | } | 827 | } |
824 | 828 | ||
825 | ids = kcalloc(sp->members_count, sizeof(int), GFP_KERNEL); | 829 | ids_count = sp->members_count; |
830 | |||
831 | ids = kcalloc(ids_count, sizeof(int), GFP_KERNEL); | ||
826 | if (!ids) { | 832 | if (!ids) { |
827 | rv = -ENOMEM; | 833 | rv = -ENOMEM; |
828 | goto out; | 834 | goto out; |
829 | } | 835 | } |
830 | 836 | ||
831 | rv = sp->members_count; | 837 | list_for_each_entry(nd, &sp->members, list) { |
832 | list_for_each_entry(nd, &sp->members, list) | ||
833 | ids[i++] = nd->nodeid; | 838 | ids[i++] = nd->nodeid; |
839 | if (nd->new) | ||
840 | new_count++; | ||
841 | } | ||
842 | |||
843 | if (ids_count != i) | ||
844 | printk(KERN_ERR "dlm: bad nodeid count %d %d\n", ids_count, i); | ||
845 | |||
846 | if (!new_count) | ||
847 | goto out_ids; | ||
848 | |||
849 | new = kcalloc(new_count, sizeof(int), GFP_KERNEL); | ||
850 | if (!new) { | ||
851 | kfree(ids); | ||
852 | rv = -ENOMEM; | ||
853 | goto out; | ||
854 | } | ||
834 | 855 | ||
835 | if (rv != i) | 856 | i = 0; |
836 | printk("bad nodeid count %d %d\n", rv, i); | 857 | list_for_each_entry(nd, &sp->members, list) { |
858 | if (nd->new) { | ||
859 | new[i++] = nd->nodeid; | ||
860 | nd->new = 0; | ||
861 | } | ||
862 | } | ||
863 | *new_count_out = new_count; | ||
864 | *new_out = new; | ||
837 | 865 | ||
866 | out_ids: | ||
867 | *ids_count_out = ids_count; | ||
838 | *ids_out = ids; | 868 | *ids_out = ids; |
839 | out: | 869 | out: |
840 | mutex_unlock(&sp->members_lock); | 870 | mutex_unlock(&sp->members_lock); |
diff --git a/fs/dlm/config.h b/fs/dlm/config.h index a3170fe22090..4f1d6fce58c5 100644 --- a/fs/dlm/config.h +++ b/fs/dlm/config.h | |||
@@ -35,7 +35,8 @@ extern struct dlm_config_info dlm_config; | |||
35 | int dlm_config_init(void); | 35 | int dlm_config_init(void); |
36 | void dlm_config_exit(void); | 36 | void dlm_config_exit(void); |
37 | int dlm_node_weight(char *lsname, int nodeid); | 37 | int dlm_node_weight(char *lsname, int nodeid); |
38 | int dlm_nodeid_list(char *lsname, int **ids_out); | 38 | int dlm_nodeid_list(char *lsname, int **ids_out, int *ids_count_out, |
39 | int **new_out, int *new_count_out); | ||
39 | int dlm_nodeid_to_addr(int nodeid, struct sockaddr_storage *addr); | 40 | int dlm_nodeid_to_addr(int nodeid, struct sockaddr_storage *addr); |
40 | int dlm_addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid); | 41 | int dlm_addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid); |
41 | int dlm_our_nodeid(void); | 42 | int dlm_our_nodeid(void); |
diff --git a/fs/dlm/dlm_internal.h b/fs/dlm/dlm_internal.h index 7a8824f475f2..5a7ac33b629c 100644 --- a/fs/dlm/dlm_internal.h +++ b/fs/dlm/dlm_internal.h | |||
@@ -42,8 +42,6 @@ | |||
42 | #include <linux/dlm.h> | 42 | #include <linux/dlm.h> |
43 | #include "config.h" | 43 | #include "config.h" |
44 | 44 | ||
45 | #define DLM_LOCKSPACE_LEN 64 | ||
46 | |||
47 | /* Size of the temp buffer midcomms allocates on the stack. | 45 | /* Size of the temp buffer midcomms allocates on the stack. |
48 | We try to make this large enough so most messages fit. | 46 | We try to make this large enough so most messages fit. |
49 | FIXME: should sctp make this unnecessary? */ | 47 | FIXME: should sctp make this unnecessary? */ |
@@ -132,8 +130,10 @@ struct dlm_member { | |||
132 | 130 | ||
133 | struct dlm_recover { | 131 | struct dlm_recover { |
134 | struct list_head list; | 132 | struct list_head list; |
135 | int *nodeids; | 133 | int *nodeids; /* nodeids of all members */ |
136 | int node_count; | 134 | int node_count; |
135 | int *new; /* nodeids of new members */ | ||
136 | int new_count; | ||
137 | uint64_t seq; | 137 | uint64_t seq; |
138 | }; | 138 | }; |
139 | 139 | ||
@@ -579,6 +579,8 @@ static inline int dlm_no_directory(struct dlm_ls *ls) | |||
579 | int dlm_netlink_init(void); | 579 | int dlm_netlink_init(void); |
580 | void dlm_netlink_exit(void); | 580 | void dlm_netlink_exit(void); |
581 | void dlm_timeout_warn(struct dlm_lkb *lkb); | 581 | void dlm_timeout_warn(struct dlm_lkb *lkb); |
582 | int dlm_plock_init(void); | ||
583 | void dlm_plock_exit(void); | ||
582 | 584 | ||
583 | #ifdef CONFIG_DLM_DEBUG | 585 | #ifdef CONFIG_DLM_DEBUG |
584 | int dlm_register_debugfs(void); | 586 | int dlm_register_debugfs(void); |
diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c index 8f250ac8b928..2d3d1027ce2b 100644 --- a/fs/dlm/lock.c +++ b/fs/dlm/lock.c | |||
@@ -165,7 +165,7 @@ void dlm_print_lkb(struct dlm_lkb *lkb) | |||
165 | lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_ast_type); | 165 | lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_ast_type); |
166 | } | 166 | } |
167 | 167 | ||
168 | void dlm_print_rsb(struct dlm_rsb *r) | 168 | static void dlm_print_rsb(struct dlm_rsb *r) |
169 | { | 169 | { |
170 | printk(KERN_ERR "rsb: nodeid %d flags %lx first %x rlc %d name %s\n", | 170 | printk(KERN_ERR "rsb: nodeid %d flags %lx first %x rlc %d name %s\n", |
171 | r->res_nodeid, r->res_flags, r->res_first_lkid, | 171 | r->res_nodeid, r->res_flags, r->res_first_lkid, |
@@ -1956,8 +1956,7 @@ static void confirm_master(struct dlm_rsb *r, int error) | |||
1956 | list_del_init(&lkb->lkb_rsb_lookup); | 1956 | list_del_init(&lkb->lkb_rsb_lookup); |
1957 | r->res_first_lkid = lkb->lkb_id; | 1957 | r->res_first_lkid = lkb->lkb_id; |
1958 | _request_lock(r, lkb); | 1958 | _request_lock(r, lkb); |
1959 | } else | 1959 | } |
1960 | r->res_nodeid = -1; | ||
1961 | break; | 1960 | break; |
1962 | 1961 | ||
1963 | default: | 1962 | default: |
diff --git a/fs/dlm/lock.h b/fs/dlm/lock.h index 05d9c82e646b..88e93c80cc22 100644 --- a/fs/dlm/lock.h +++ b/fs/dlm/lock.h | |||
@@ -13,7 +13,6 @@ | |||
13 | #ifndef __LOCK_DOT_H__ | 13 | #ifndef __LOCK_DOT_H__ |
14 | #define __LOCK_DOT_H__ | 14 | #define __LOCK_DOT_H__ |
15 | 15 | ||
16 | void dlm_print_rsb(struct dlm_rsb *r); | ||
17 | void dlm_dump_rsb(struct dlm_rsb *r); | 16 | void dlm_dump_rsb(struct dlm_rsb *r); |
18 | void dlm_print_lkb(struct dlm_lkb *lkb); | 17 | void dlm_print_lkb(struct dlm_lkb *lkb); |
19 | void dlm_receive_message_saved(struct dlm_ls *ls, struct dlm_message *ms); | 18 | void dlm_receive_message_saved(struct dlm_ls *ls, struct dlm_message *ms); |
diff --git a/fs/dlm/main.c b/fs/dlm/main.c index 58487fb95a4c..b80e0aa3cfa5 100644 --- a/fs/dlm/main.c +++ b/fs/dlm/main.c | |||
@@ -46,10 +46,16 @@ static int __init init_dlm(void) | |||
46 | if (error) | 46 | if (error) |
47 | goto out_user; | 47 | goto out_user; |
48 | 48 | ||
49 | error = dlm_plock_init(); | ||
50 | if (error) | ||
51 | goto out_netlink; | ||
52 | |||
49 | printk("DLM (built %s %s) installed\n", __DATE__, __TIME__); | 53 | printk("DLM (built %s %s) installed\n", __DATE__, __TIME__); |
50 | 54 | ||
51 | return 0; | 55 | return 0; |
52 | 56 | ||
57 | out_netlink: | ||
58 | dlm_netlink_exit(); | ||
53 | out_user: | 59 | out_user: |
54 | dlm_user_exit(); | 60 | dlm_user_exit(); |
55 | out_debug: | 61 | out_debug: |
@@ -66,6 +72,7 @@ static int __init init_dlm(void) | |||
66 | 72 | ||
67 | static void __exit exit_dlm(void) | 73 | static void __exit exit_dlm(void) |
68 | { | 74 | { |
75 | dlm_plock_exit(); | ||
69 | dlm_netlink_exit(); | 76 | dlm_netlink_exit(); |
70 | dlm_user_exit(); | 77 | dlm_user_exit(); |
71 | dlm_config_exit(); | 78 | dlm_config_exit(); |
diff --git a/fs/dlm/member.c b/fs/dlm/member.c index fa17f5a27883..26133f05ae3a 100644 --- a/fs/dlm/member.c +++ b/fs/dlm/member.c | |||
@@ -210,6 +210,23 @@ int dlm_recover_members(struct dlm_ls *ls, struct dlm_recover *rv, int *neg_out) | |||
210 | } | 210 | } |
211 | } | 211 | } |
212 | 212 | ||
213 | /* Add an entry to ls_nodes_gone for members that were removed and | ||
214 | then added again, so that previous state for these nodes will be | ||
215 | cleared during recovery. */ | ||
216 | |||
217 | for (i = 0; i < rv->new_count; i++) { | ||
218 | if (!dlm_is_member(ls, rv->new[i])) | ||
219 | continue; | ||
220 | log_debug(ls, "new nodeid %d is a re-added member", rv->new[i]); | ||
221 | |||
222 | memb = kzalloc(sizeof(struct dlm_member), GFP_KERNEL); | ||
223 | if (!memb) | ||
224 | return -ENOMEM; | ||
225 | memb->nodeid = rv->new[i]; | ||
226 | list_add_tail(&memb->list, &ls->ls_nodes_gone); | ||
227 | neg++; | ||
228 | } | ||
229 | |||
213 | /* add new members to ls_nodes */ | 230 | /* add new members to ls_nodes */ |
214 | 231 | ||
215 | for (i = 0; i < rv->node_count; i++) { | 232 | for (i = 0; i < rv->node_count; i++) { |
@@ -314,15 +331,16 @@ int dlm_ls_stop(struct dlm_ls *ls) | |||
314 | int dlm_ls_start(struct dlm_ls *ls) | 331 | int dlm_ls_start(struct dlm_ls *ls) |
315 | { | 332 | { |
316 | struct dlm_recover *rv = NULL, *rv_old; | 333 | struct dlm_recover *rv = NULL, *rv_old; |
317 | int *ids = NULL; | 334 | int *ids = NULL, *new = NULL; |
318 | int error, count; | 335 | int error, ids_count = 0, new_count = 0; |
319 | 336 | ||
320 | rv = kzalloc(sizeof(struct dlm_recover), GFP_KERNEL); | 337 | rv = kzalloc(sizeof(struct dlm_recover), GFP_KERNEL); |
321 | if (!rv) | 338 | if (!rv) |
322 | return -ENOMEM; | 339 | return -ENOMEM; |
323 | 340 | ||
324 | error = count = dlm_nodeid_list(ls->ls_name, &ids); | 341 | error = dlm_nodeid_list(ls->ls_name, &ids, &ids_count, |
325 | if (error <= 0) | 342 | &new, &new_count); |
343 | if (error < 0) | ||
326 | goto fail; | 344 | goto fail; |
327 | 345 | ||
328 | spin_lock(&ls->ls_recover_lock); | 346 | spin_lock(&ls->ls_recover_lock); |
@@ -337,14 +355,19 @@ int dlm_ls_start(struct dlm_ls *ls) | |||
337 | } | 355 | } |
338 | 356 | ||
339 | rv->nodeids = ids; | 357 | rv->nodeids = ids; |
340 | rv->node_count = count; | 358 | rv->node_count = ids_count; |
359 | rv->new = new; | ||
360 | rv->new_count = new_count; | ||
341 | rv->seq = ++ls->ls_recover_seq; | 361 | rv->seq = ++ls->ls_recover_seq; |
342 | rv_old = ls->ls_recover_args; | 362 | rv_old = ls->ls_recover_args; |
343 | ls->ls_recover_args = rv; | 363 | ls->ls_recover_args = rv; |
344 | spin_unlock(&ls->ls_recover_lock); | 364 | spin_unlock(&ls->ls_recover_lock); |
345 | 365 | ||
346 | if (rv_old) { | 366 | if (rv_old) { |
367 | log_error(ls, "unused recovery %llx %d", | ||
368 | (unsigned long long)rv_old->seq, rv_old->node_count); | ||
347 | kfree(rv_old->nodeids); | 369 | kfree(rv_old->nodeids); |
370 | kfree(rv_old->new); | ||
348 | kfree(rv_old); | 371 | kfree(rv_old); |
349 | } | 372 | } |
350 | 373 | ||
@@ -354,6 +377,7 @@ int dlm_ls_start(struct dlm_ls *ls) | |||
354 | fail: | 377 | fail: |
355 | kfree(rv); | 378 | kfree(rv); |
356 | kfree(ids); | 379 | kfree(ids); |
380 | kfree(new); | ||
357 | return error; | 381 | return error; |
358 | } | 382 | } |
359 | 383 | ||
diff --git a/fs/gfs2/locking/dlm/plock.c b/fs/dlm/plock.c index 2ebd374b3143..d6d6e370f89c 100644 --- a/fs/gfs2/locking/dlm/plock.c +++ b/fs/dlm/plock.c | |||
@@ -1,17 +1,19 @@ | |||
1 | /* | 1 | /* |
2 | * Copyright (C) 2005 Red Hat, Inc. All rights reserved. | 2 | * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved. |
3 | * | 3 | * |
4 | * This copyrighted material is made available to anyone wishing to use, | 4 | * This copyrighted material is made available to anyone wishing to use, |
5 | * modify, copy, or redistribute it subject to the terms and conditions | 5 | * modify, copy, or redistribute it subject to the terms and conditions |
6 | * of the GNU General Public License version 2. | 6 | * of the GNU General Public License version 2. |
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include <linux/fs.h> | ||
9 | #include <linux/miscdevice.h> | 10 | #include <linux/miscdevice.h> |
10 | #include <linux/lock_dlm_plock.h> | ||
11 | #include <linux/poll.h> | 11 | #include <linux/poll.h> |
12 | #include <linux/dlm.h> | ||
13 | #include <linux/dlm_plock.h> | ||
12 | 14 | ||
13 | #include "lock_dlm.h" | 15 | #include "dlm_internal.h" |
14 | 16 | #include "lockspace.h" | |
15 | 17 | ||
16 | static spinlock_t ops_lock; | 18 | static spinlock_t ops_lock; |
17 | static struct list_head send_list; | 19 | static struct list_head send_list; |
@@ -22,7 +24,7 @@ static wait_queue_head_t recv_wq; | |||
22 | struct plock_op { | 24 | struct plock_op { |
23 | struct list_head list; | 25 | struct list_head list; |
24 | int done; | 26 | int done; |
25 | struct gdlm_plock_info info; | 27 | struct dlm_plock_info info; |
26 | }; | 28 | }; |
27 | 29 | ||
28 | struct plock_xop { | 30 | struct plock_xop { |
@@ -34,22 +36,22 @@ struct plock_xop { | |||
34 | }; | 36 | }; |
35 | 37 | ||
36 | 38 | ||
37 | static inline void set_version(struct gdlm_plock_info *info) | 39 | static inline void set_version(struct dlm_plock_info *info) |
38 | { | 40 | { |
39 | info->version[0] = GDLM_PLOCK_VERSION_MAJOR; | 41 | info->version[0] = DLM_PLOCK_VERSION_MAJOR; |
40 | info->version[1] = GDLM_PLOCK_VERSION_MINOR; | 42 | info->version[1] = DLM_PLOCK_VERSION_MINOR; |
41 | info->version[2] = GDLM_PLOCK_VERSION_PATCH; | 43 | info->version[2] = DLM_PLOCK_VERSION_PATCH; |
42 | } | 44 | } |
43 | 45 | ||
44 | static int check_version(struct gdlm_plock_info *info) | 46 | static int check_version(struct dlm_plock_info *info) |
45 | { | 47 | { |
46 | if ((GDLM_PLOCK_VERSION_MAJOR != info->version[0]) || | 48 | if ((DLM_PLOCK_VERSION_MAJOR != info->version[0]) || |
47 | (GDLM_PLOCK_VERSION_MINOR < info->version[1])) { | 49 | (DLM_PLOCK_VERSION_MINOR < info->version[1])) { |
48 | log_error("plock device version mismatch: " | 50 | log_print("plock device version mismatch: " |
49 | "kernel (%u.%u.%u), user (%u.%u.%u)", | 51 | "kernel (%u.%u.%u), user (%u.%u.%u)", |
50 | GDLM_PLOCK_VERSION_MAJOR, | 52 | DLM_PLOCK_VERSION_MAJOR, |
51 | GDLM_PLOCK_VERSION_MINOR, | 53 | DLM_PLOCK_VERSION_MINOR, |
52 | GDLM_PLOCK_VERSION_PATCH, | 54 | DLM_PLOCK_VERSION_PATCH, |
53 | info->version[0], | 55 | info->version[0], |
54 | info->version[1], | 56 | info->version[1], |
55 | info->version[2]); | 57 | info->version[2]); |
@@ -68,25 +70,31 @@ static void send_op(struct plock_op *op) | |||
68 | wake_up(&send_wq); | 70 | wake_up(&send_wq); |
69 | } | 71 | } |
70 | 72 | ||
71 | int gdlm_plock(void *lockspace, struct lm_lockname *name, | 73 | int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file, |
72 | struct file *file, int cmd, struct file_lock *fl) | 74 | int cmd, struct file_lock *fl) |
73 | { | 75 | { |
74 | struct gdlm_ls *ls = lockspace; | 76 | struct dlm_ls *ls; |
75 | struct plock_op *op; | 77 | struct plock_op *op; |
76 | struct plock_xop *xop; | 78 | struct plock_xop *xop; |
77 | int rv; | 79 | int rv; |
78 | 80 | ||
81 | ls = dlm_find_lockspace_local(lockspace); | ||
82 | if (!ls) | ||
83 | return -EINVAL; | ||
84 | |||
79 | xop = kzalloc(sizeof(*xop), GFP_KERNEL); | 85 | xop = kzalloc(sizeof(*xop), GFP_KERNEL); |
80 | if (!xop) | 86 | if (!xop) { |
81 | return -ENOMEM; | 87 | rv = -ENOMEM; |
88 | goto out; | ||
89 | } | ||
82 | 90 | ||
83 | op = &xop->xop; | 91 | op = &xop->xop; |
84 | op->info.optype = GDLM_PLOCK_OP_LOCK; | 92 | op->info.optype = DLM_PLOCK_OP_LOCK; |
85 | op->info.pid = fl->fl_pid; | 93 | op->info.pid = fl->fl_pid; |
86 | op->info.ex = (fl->fl_type == F_WRLCK); | 94 | op->info.ex = (fl->fl_type == F_WRLCK); |
87 | op->info.wait = IS_SETLKW(cmd); | 95 | op->info.wait = IS_SETLKW(cmd); |
88 | op->info.fsid = ls->id; | 96 | op->info.fsid = ls->ls_global_id; |
89 | op->info.number = name->ln_number; | 97 | op->info.number = number; |
90 | op->info.start = fl->fl_start; | 98 | op->info.start = fl->fl_start; |
91 | op->info.end = fl->fl_end; | 99 | op->info.end = fl->fl_end; |
92 | if (fl->fl_lmops && fl->fl_lmops->fl_grant) { | 100 | if (fl->fl_lmops && fl->fl_lmops->fl_grant) { |
@@ -107,12 +115,15 @@ int gdlm_plock(void *lockspace, struct lm_lockname *name, | |||
107 | 115 | ||
108 | if (xop->callback == NULL) | 116 | if (xop->callback == NULL) |
109 | wait_event(recv_wq, (op->done != 0)); | 117 | wait_event(recv_wq, (op->done != 0)); |
110 | else | 118 | else { |
111 | return -EINPROGRESS; | 119 | rv = -EINPROGRESS; |
120 | goto out; | ||
121 | } | ||
112 | 122 | ||
113 | spin_lock(&ops_lock); | 123 | spin_lock(&ops_lock); |
114 | if (!list_empty(&op->list)) { | 124 | if (!list_empty(&op->list)) { |
115 | printk(KERN_INFO "plock op on list\n"); | 125 | log_error(ls, "dlm_posix_lock: op on list %llx", |
126 | (unsigned long long)number); | ||
116 | list_del(&op->list); | 127 | list_del(&op->list); |
117 | } | 128 | } |
118 | spin_unlock(&ops_lock); | 129 | spin_unlock(&ops_lock); |
@@ -121,17 +132,19 @@ int gdlm_plock(void *lockspace, struct lm_lockname *name, | |||
121 | 132 | ||
122 | if (!rv) { | 133 | if (!rv) { |
123 | if (posix_lock_file_wait(file, fl) < 0) | 134 | if (posix_lock_file_wait(file, fl) < 0) |
124 | log_error("gdlm_plock: vfs lock error %x,%llx", | 135 | log_error(ls, "dlm_posix_lock: vfs lock error %llx", |
125 | name->ln_type, | 136 | (unsigned long long)number); |
126 | (unsigned long long)name->ln_number); | ||
127 | } | 137 | } |
128 | 138 | ||
129 | kfree(xop); | 139 | kfree(xop); |
140 | out: | ||
141 | dlm_put_lockspace(ls); | ||
130 | return rv; | 142 | return rv; |
131 | } | 143 | } |
144 | EXPORT_SYMBOL_GPL(dlm_posix_lock); | ||
132 | 145 | ||
133 | /* Returns failure iff a succesful lock operation should be canceled */ | 146 | /* Returns failure iff a succesful lock operation should be canceled */ |
134 | static int gdlm_plock_callback(struct plock_op *op) | 147 | static int dlm_plock_callback(struct plock_op *op) |
135 | { | 148 | { |
136 | struct file *file; | 149 | struct file *file; |
137 | struct file_lock *fl; | 150 | struct file_lock *fl; |
@@ -142,7 +155,8 @@ static int gdlm_plock_callback(struct plock_op *op) | |||
142 | 155 | ||
143 | spin_lock(&ops_lock); | 156 | spin_lock(&ops_lock); |
144 | if (!list_empty(&op->list)) { | 157 | if (!list_empty(&op->list)) { |
145 | printk(KERN_INFO "plock op on list\n"); | 158 | log_print("dlm_plock_callback: op on list %llx", |
159 | (unsigned long long)op->info.number); | ||
146 | list_del(&op->list); | 160 | list_del(&op->list); |
147 | } | 161 | } |
148 | spin_unlock(&ops_lock); | 162 | spin_unlock(&ops_lock); |
@@ -165,19 +179,19 @@ static int gdlm_plock_callback(struct plock_op *op) | |||
165 | * This can only happen in the case of kmalloc() failure. | 179 | * This can only happen in the case of kmalloc() failure. |
166 | * The filesystem's own lock is the authoritative lock, | 180 | * The filesystem's own lock is the authoritative lock, |
167 | * so a failure to get the lock locally is not a disaster. | 181 | * so a failure to get the lock locally is not a disaster. |
168 | * As long as GFS cannot reliably cancel locks (especially | 182 | * As long as the fs cannot reliably cancel locks (especially |
169 | * in a low-memory situation), we're better off ignoring | 183 | * in a low-memory situation), we're better off ignoring |
170 | * this failure than trying to recover. | 184 | * this failure than trying to recover. |
171 | */ | 185 | */ |
172 | log_error("gdlm_plock: vfs lock error file %p fl %p", | 186 | log_print("dlm_plock_callback: vfs lock error %llx file %p fl %p", |
173 | file, fl); | 187 | (unsigned long long)op->info.number, file, fl); |
174 | } | 188 | } |
175 | 189 | ||
176 | rv = notify(flc, NULL, 0); | 190 | rv = notify(flc, NULL, 0); |
177 | if (rv) { | 191 | if (rv) { |
178 | /* XXX: We need to cancel the fs lock here: */ | 192 | /* XXX: We need to cancel the fs lock here: */ |
179 | printk("gfs2 lock granted after lock request failed;" | 193 | log_print("dlm_plock_callback: lock granted after lock request " |
180 | " dangling lock!\n"); | 194 | "failed; dangling lock!\n"); |
181 | goto out; | 195 | goto out; |
182 | } | 196 | } |
183 | 197 | ||
@@ -186,25 +200,31 @@ out: | |||
186 | return rv; | 200 | return rv; |
187 | } | 201 | } |
188 | 202 | ||
189 | int gdlm_punlock(void *lockspace, struct lm_lockname *name, | 203 | int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, |
190 | struct file *file, struct file_lock *fl) | 204 | struct file_lock *fl) |
191 | { | 205 | { |
192 | struct gdlm_ls *ls = lockspace; | 206 | struct dlm_ls *ls; |
193 | struct plock_op *op; | 207 | struct plock_op *op; |
194 | int rv; | 208 | int rv; |
195 | 209 | ||
210 | ls = dlm_find_lockspace_local(lockspace); | ||
211 | if (!ls) | ||
212 | return -EINVAL; | ||
213 | |||
196 | op = kzalloc(sizeof(*op), GFP_KERNEL); | 214 | op = kzalloc(sizeof(*op), GFP_KERNEL); |
197 | if (!op) | 215 | if (!op) { |
198 | return -ENOMEM; | 216 | rv = -ENOMEM; |
217 | goto out; | ||
218 | } | ||
199 | 219 | ||
200 | if (posix_lock_file_wait(file, fl) < 0) | 220 | if (posix_lock_file_wait(file, fl) < 0) |
201 | log_error("gdlm_punlock: vfs unlock error %x,%llx", | 221 | log_error(ls, "dlm_posix_unlock: vfs unlock error %llx", |
202 | name->ln_type, (unsigned long long)name->ln_number); | 222 | (unsigned long long)number); |
203 | 223 | ||
204 | op->info.optype = GDLM_PLOCK_OP_UNLOCK; | 224 | op->info.optype = DLM_PLOCK_OP_UNLOCK; |
205 | op->info.pid = fl->fl_pid; | 225 | op->info.pid = fl->fl_pid; |
206 | op->info.fsid = ls->id; | 226 | op->info.fsid = ls->ls_global_id; |
207 | op->info.number = name->ln_number; | 227 | op->info.number = number; |
208 | op->info.start = fl->fl_start; | 228 | op->info.start = fl->fl_start; |
209 | op->info.end = fl->fl_end; | 229 | op->info.end = fl->fl_end; |
210 | if (fl->fl_lmops && fl->fl_lmops->fl_grant) | 230 | if (fl->fl_lmops && fl->fl_lmops->fl_grant) |
@@ -217,7 +237,8 @@ int gdlm_punlock(void *lockspace, struct lm_lockname *name, | |||
217 | 237 | ||
218 | spin_lock(&ops_lock); | 238 | spin_lock(&ops_lock); |
219 | if (!list_empty(&op->list)) { | 239 | if (!list_empty(&op->list)) { |
220 | printk(KERN_INFO "punlock op on list\n"); | 240 | log_error(ls, "dlm_posix_unlock: op on list %llx", |
241 | (unsigned long long)number); | ||
221 | list_del(&op->list); | 242 | list_del(&op->list); |
222 | } | 243 | } |
223 | spin_unlock(&ops_lock); | 244 | spin_unlock(&ops_lock); |
@@ -228,25 +249,34 @@ int gdlm_punlock(void *lockspace, struct lm_lockname *name, | |||
228 | rv = 0; | 249 | rv = 0; |
229 | 250 | ||
230 | kfree(op); | 251 | kfree(op); |
252 | out: | ||
253 | dlm_put_lockspace(ls); | ||
231 | return rv; | 254 | return rv; |
232 | } | 255 | } |
256 | EXPORT_SYMBOL_GPL(dlm_posix_unlock); | ||
233 | 257 | ||
234 | int gdlm_plock_get(void *lockspace, struct lm_lockname *name, | 258 | int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, |
235 | struct file *file, struct file_lock *fl) | 259 | struct file_lock *fl) |
236 | { | 260 | { |
237 | struct gdlm_ls *ls = lockspace; | 261 | struct dlm_ls *ls; |
238 | struct plock_op *op; | 262 | struct plock_op *op; |
239 | int rv; | 263 | int rv; |
240 | 264 | ||
265 | ls = dlm_find_lockspace_local(lockspace); | ||
266 | if (!ls) | ||
267 | return -EINVAL; | ||
268 | |||
241 | op = kzalloc(sizeof(*op), GFP_KERNEL); | 269 | op = kzalloc(sizeof(*op), GFP_KERNEL); |
242 | if (!op) | 270 | if (!op) { |
243 | return -ENOMEM; | 271 | rv = -ENOMEM; |
272 | goto out; | ||
273 | } | ||
244 | 274 | ||
245 | op->info.optype = GDLM_PLOCK_OP_GET; | 275 | op->info.optype = DLM_PLOCK_OP_GET; |
246 | op->info.pid = fl->fl_pid; | 276 | op->info.pid = fl->fl_pid; |
247 | op->info.ex = (fl->fl_type == F_WRLCK); | 277 | op->info.ex = (fl->fl_type == F_WRLCK); |
248 | op->info.fsid = ls->id; | 278 | op->info.fsid = ls->ls_global_id; |
249 | op->info.number = name->ln_number; | 279 | op->info.number = number; |
250 | op->info.start = fl->fl_start; | 280 | op->info.start = fl->fl_start; |
251 | op->info.end = fl->fl_end; | 281 | op->info.end = fl->fl_end; |
252 | if (fl->fl_lmops && fl->fl_lmops->fl_grant) | 282 | if (fl->fl_lmops && fl->fl_lmops->fl_grant) |
@@ -259,7 +289,8 @@ int gdlm_plock_get(void *lockspace, struct lm_lockname *name, | |||
259 | 289 | ||
260 | spin_lock(&ops_lock); | 290 | spin_lock(&ops_lock); |
261 | if (!list_empty(&op->list)) { | 291 | if (!list_empty(&op->list)) { |
262 | printk(KERN_INFO "plock_get op on list\n"); | 292 | log_error(ls, "dlm_posix_get: op on list %llx", |
293 | (unsigned long long)number); | ||
263 | list_del(&op->list); | 294 | list_del(&op->list); |
264 | } | 295 | } |
265 | spin_unlock(&ops_lock); | 296 | spin_unlock(&ops_lock); |
@@ -281,14 +312,17 @@ int gdlm_plock_get(void *lockspace, struct lm_lockname *name, | |||
281 | } | 312 | } |
282 | 313 | ||
283 | kfree(op); | 314 | kfree(op); |
315 | out: | ||
316 | dlm_put_lockspace(ls); | ||
284 | return rv; | 317 | return rv; |
285 | } | 318 | } |
319 | EXPORT_SYMBOL_GPL(dlm_posix_get); | ||
286 | 320 | ||
287 | /* a read copies out one plock request from the send list */ | 321 | /* a read copies out one plock request from the send list */ |
288 | static ssize_t dev_read(struct file *file, char __user *u, size_t count, | 322 | static ssize_t dev_read(struct file *file, char __user *u, size_t count, |
289 | loff_t *ppos) | 323 | loff_t *ppos) |
290 | { | 324 | { |
291 | struct gdlm_plock_info info; | 325 | struct dlm_plock_info info; |
292 | struct plock_op *op = NULL; | 326 | struct plock_op *op = NULL; |
293 | 327 | ||
294 | if (count < sizeof(info)) | 328 | if (count < sizeof(info)) |
@@ -315,7 +349,7 @@ static ssize_t dev_read(struct file *file, char __user *u, size_t count, | |||
315 | static ssize_t dev_write(struct file *file, const char __user *u, size_t count, | 349 | static ssize_t dev_write(struct file *file, const char __user *u, size_t count, |
316 | loff_t *ppos) | 350 | loff_t *ppos) |
317 | { | 351 | { |
318 | struct gdlm_plock_info info; | 352 | struct dlm_plock_info info; |
319 | struct plock_op *op; | 353 | struct plock_op *op; |
320 | int found = 0; | 354 | int found = 0; |
321 | 355 | ||
@@ -345,12 +379,12 @@ static ssize_t dev_write(struct file *file, const char __user *u, size_t count, | |||
345 | struct plock_xop *xop; | 379 | struct plock_xop *xop; |
346 | xop = (struct plock_xop *)op; | 380 | xop = (struct plock_xop *)op; |
347 | if (xop->callback) | 381 | if (xop->callback) |
348 | count = gdlm_plock_callback(op); | 382 | count = dlm_plock_callback(op); |
349 | else | 383 | else |
350 | wake_up(&recv_wq); | 384 | wake_up(&recv_wq); |
351 | } else | 385 | } else |
352 | printk(KERN_INFO "gdlm dev_write no op %x %llx\n", info.fsid, | 386 | log_print("dev_write no op %x %llx", info.fsid, |
353 | (unsigned long long)info.number); | 387 | (unsigned long long)info.number); |
354 | return count; | 388 | return count; |
355 | } | 389 | } |
356 | 390 | ||
@@ -377,11 +411,11 @@ static const struct file_operations dev_fops = { | |||
377 | 411 | ||
378 | static struct miscdevice plock_dev_misc = { | 412 | static struct miscdevice plock_dev_misc = { |
379 | .minor = MISC_DYNAMIC_MINOR, | 413 | .minor = MISC_DYNAMIC_MINOR, |
380 | .name = GDLM_PLOCK_MISC_NAME, | 414 | .name = DLM_PLOCK_MISC_NAME, |
381 | .fops = &dev_fops | 415 | .fops = &dev_fops |
382 | }; | 416 | }; |
383 | 417 | ||
384 | int gdlm_plock_init(void) | 418 | int dlm_plock_init(void) |
385 | { | 419 | { |
386 | int rv; | 420 | int rv; |
387 | 421 | ||
@@ -393,14 +427,13 @@ int gdlm_plock_init(void) | |||
393 | 427 | ||
394 | rv = misc_register(&plock_dev_misc); | 428 | rv = misc_register(&plock_dev_misc); |
395 | if (rv) | 429 | if (rv) |
396 | printk(KERN_INFO "gdlm_plock_init: misc_register failed %d", | 430 | log_print("dlm_plock_init: misc_register failed %d", rv); |
397 | rv); | ||
398 | return rv; | 431 | return rv; |
399 | } | 432 | } |
400 | 433 | ||
401 | void gdlm_plock_exit(void) | 434 | void dlm_plock_exit(void) |
402 | { | 435 | { |
403 | if (misc_deregister(&plock_dev_misc) < 0) | 436 | if (misc_deregister(&plock_dev_misc) < 0) |
404 | printk(KERN_INFO "gdlm_plock_exit: misc_deregister failed"); | 437 | log_print("dlm_plock_exit: misc_deregister failed"); |
405 | } | 438 | } |
406 | 439 | ||
diff --git a/fs/dlm/recoverd.c b/fs/dlm/recoverd.c index 997f9531d594..fd677c8c3d3b 100644 --- a/fs/dlm/recoverd.c +++ b/fs/dlm/recoverd.c | |||
@@ -257,6 +257,7 @@ static void do_ls_recovery(struct dlm_ls *ls) | |||
257 | if (rv) { | 257 | if (rv) { |
258 | ls_recover(ls, rv); | 258 | ls_recover(ls, rv); |
259 | kfree(rv->nodeids); | 259 | kfree(rv->nodeids); |
260 | kfree(rv->new); | ||
260 | kfree(rv); | 261 | kfree(rv); |
261 | } | 262 | } |
262 | } | 263 | } |
diff --git a/fs/gfs2/locking/dlm/Makefile b/fs/gfs2/locking/dlm/Makefile index 89b93b6b45cf..2609bb6cd013 100644 --- a/fs/gfs2/locking/dlm/Makefile +++ b/fs/gfs2/locking/dlm/Makefile | |||
@@ -1,3 +1,3 @@ | |||
1 | obj-$(CONFIG_GFS2_FS_LOCKING_DLM) += lock_dlm.o | 1 | obj-$(CONFIG_GFS2_FS_LOCKING_DLM) += lock_dlm.o |
2 | lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o plock.o | 2 | lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o |
3 | 3 | ||
diff --git a/fs/gfs2/locking/dlm/lock_dlm.h b/fs/gfs2/locking/dlm/lock_dlm.h index 58fcf8c5bf39..a243cf69c54e 100644 --- a/fs/gfs2/locking/dlm/lock_dlm.h +++ b/fs/gfs2/locking/dlm/lock_dlm.h | |||
@@ -25,6 +25,7 @@ | |||
25 | #include <net/sock.h> | 25 | #include <net/sock.h> |
26 | 26 | ||
27 | #include <linux/dlm.h> | 27 | #include <linux/dlm.h> |
28 | #include <linux/dlm_plock.h> | ||
28 | #include <linux/lm_interface.h> | 29 | #include <linux/lm_interface.h> |
29 | 30 | ||
30 | /* | 31 | /* |
@@ -173,17 +174,6 @@ void gdlm_cancel(void *); | |||
173 | int gdlm_hold_lvb(void *, char **); | 174 | int gdlm_hold_lvb(void *, char **); |
174 | void gdlm_unhold_lvb(void *, char *); | 175 | void gdlm_unhold_lvb(void *, char *); |
175 | 176 | ||
176 | /* plock.c */ | ||
177 | |||
178 | int gdlm_plock_init(void); | ||
179 | void gdlm_plock_exit(void); | ||
180 | int gdlm_plock(void *, struct lm_lockname *, struct file *, int, | ||
181 | struct file_lock *); | ||
182 | int gdlm_plock_get(void *, struct lm_lockname *, struct file *, | ||
183 | struct file_lock *); | ||
184 | int gdlm_punlock(void *, struct lm_lockname *, struct file *, | ||
185 | struct file_lock *); | ||
186 | |||
187 | /* mount.c */ | 177 | /* mount.c */ |
188 | 178 | ||
189 | extern const struct lm_lockops gdlm_ops; | 179 | extern const struct lm_lockops gdlm_ops; |
diff --git a/fs/gfs2/locking/dlm/main.c b/fs/gfs2/locking/dlm/main.c index 36a225850bd8..b9a03a7ff801 100644 --- a/fs/gfs2/locking/dlm/main.c +++ b/fs/gfs2/locking/dlm/main.c | |||
@@ -28,13 +28,6 @@ static int __init init_lock_dlm(void) | |||
28 | return error; | 28 | return error; |
29 | } | 29 | } |
30 | 30 | ||
31 | error = gdlm_plock_init(); | ||
32 | if (error) { | ||
33 | gdlm_sysfs_exit(); | ||
34 | gfs2_unregister_lockproto(&gdlm_ops); | ||
35 | return error; | ||
36 | } | ||
37 | |||
38 | printk(KERN_INFO | 31 | printk(KERN_INFO |
39 | "Lock_DLM (built %s %s) installed\n", __DATE__, __TIME__); | 32 | "Lock_DLM (built %s %s) installed\n", __DATE__, __TIME__); |
40 | return 0; | 33 | return 0; |
@@ -42,7 +35,6 @@ static int __init init_lock_dlm(void) | |||
42 | 35 | ||
43 | static void __exit exit_lock_dlm(void) | 36 | static void __exit exit_lock_dlm(void) |
44 | { | 37 | { |
45 | gdlm_plock_exit(); | ||
46 | gdlm_sysfs_exit(); | 38 | gdlm_sysfs_exit(); |
47 | gfs2_unregister_lockproto(&gdlm_ops); | 39 | gfs2_unregister_lockproto(&gdlm_ops); |
48 | } | 40 | } |
diff --git a/fs/gfs2/locking/dlm/mount.c b/fs/gfs2/locking/dlm/mount.c index f2efff424224..470bdf650b50 100644 --- a/fs/gfs2/locking/dlm/mount.c +++ b/fs/gfs2/locking/dlm/mount.c | |||
@@ -236,6 +236,27 @@ static void gdlm_withdraw(void *lockspace) | |||
236 | gdlm_kobject_release(ls); | 236 | gdlm_kobject_release(ls); |
237 | } | 237 | } |
238 | 238 | ||
239 | static int gdlm_plock(void *lockspace, struct lm_lockname *name, | ||
240 | struct file *file, int cmd, struct file_lock *fl) | ||
241 | { | ||
242 | struct gdlm_ls *ls = lockspace; | ||
243 | return dlm_posix_lock(ls->dlm_lockspace, name->ln_number, file, cmd, fl); | ||
244 | } | ||
245 | |||
246 | static int gdlm_punlock(void *lockspace, struct lm_lockname *name, | ||
247 | struct file *file, struct file_lock *fl) | ||
248 | { | ||
249 | struct gdlm_ls *ls = lockspace; | ||
250 | return dlm_posix_unlock(ls->dlm_lockspace, name->ln_number, file, fl); | ||
251 | } | ||
252 | |||
253 | static int gdlm_plock_get(void *lockspace, struct lm_lockname *name, | ||
254 | struct file *file, struct file_lock *fl) | ||
255 | { | ||
256 | struct gdlm_ls *ls = lockspace; | ||
257 | return dlm_posix_get(ls->dlm_lockspace, name->ln_number, file, fl); | ||
258 | } | ||
259 | |||
239 | const struct lm_lockops gdlm_ops = { | 260 | const struct lm_lockops gdlm_ops = { |
240 | .lm_proto_name = "lock_dlm", | 261 | .lm_proto_name = "lock_dlm", |
241 | .lm_mount = gdlm_mount, | 262 | .lm_mount = gdlm_mount, |
diff --git a/fs/read_write.c b/fs/read_write.c index 49a98718ecdf..f0d1240a5c69 100644 --- a/fs/read_write.c +++ b/fs/read_write.c | |||
@@ -33,7 +33,7 @@ EXPORT_SYMBOL(generic_ro_fops); | |||
33 | 33 | ||
34 | loff_t generic_file_llseek(struct file *file, loff_t offset, int origin) | 34 | loff_t generic_file_llseek(struct file *file, loff_t offset, int origin) |
35 | { | 35 | { |
36 | long long retval; | 36 | loff_t retval; |
37 | struct inode *inode = file->f_mapping->host; | 37 | struct inode *inode = file->f_mapping->host; |
38 | 38 | ||
39 | mutex_lock(&inode->i_mutex); | 39 | mutex_lock(&inode->i_mutex); |
@@ -60,7 +60,7 @@ EXPORT_SYMBOL(generic_file_llseek); | |||
60 | 60 | ||
61 | loff_t remote_llseek(struct file *file, loff_t offset, int origin) | 61 | loff_t remote_llseek(struct file *file, loff_t offset, int origin) |
62 | { | 62 | { |
63 | long long retval; | 63 | loff_t retval; |
64 | 64 | ||
65 | lock_kernel(); | 65 | lock_kernel(); |
66 | switch (origin) { | 66 | switch (origin) { |
@@ -91,7 +91,7 @@ EXPORT_SYMBOL(no_llseek); | |||
91 | 91 | ||
92 | loff_t default_llseek(struct file *file, loff_t offset, int origin) | 92 | loff_t default_llseek(struct file *file, loff_t offset, int origin) |
93 | { | 93 | { |
94 | long long retval; | 94 | loff_t retval; |
95 | 95 | ||
96 | lock_kernel(); | 96 | lock_kernel(); |
97 | switch (origin) { | 97 | switch (origin) { |
diff --git a/fs/seq_file.c b/fs/seq_file.c index 853770274f20..9943408b315e 100644 --- a/fs/seq_file.c +++ b/fs/seq_file.c | |||
@@ -239,7 +239,7 @@ Eoverflow: | |||
239 | loff_t seq_lseek(struct file *file, loff_t offset, int origin) | 239 | loff_t seq_lseek(struct file *file, loff_t offset, int origin) |
240 | { | 240 | { |
241 | struct seq_file *m = (struct seq_file *)file->private_data; | 241 | struct seq_file *m = (struct seq_file *)file->private_data; |
242 | long long retval = -EINVAL; | 242 | loff_t retval = -EINVAL; |
243 | 243 | ||
244 | mutex_lock(&m->lock); | 244 | mutex_lock(&m->lock); |
245 | m->version = file->f_version; | 245 | m->version = file->f_version; |
diff --git a/fs/udf/Makefile b/fs/udf/Makefile index be845e7540ef..0d4503f7446d 100644 --- a/fs/udf/Makefile +++ b/fs/udf/Makefile | |||
@@ -6,4 +6,4 @@ obj-$(CONFIG_UDF_FS) += udf.o | |||
6 | 6 | ||
7 | udf-objs := balloc.o dir.o file.o ialloc.o inode.o lowlevel.o namei.o \ | 7 | udf-objs := balloc.o dir.o file.o ialloc.o inode.o lowlevel.o namei.o \ |
8 | partition.o super.o truncate.o symlink.o fsync.o \ | 8 | partition.o super.o truncate.o symlink.o fsync.o \ |
9 | crc.o directory.o misc.o udftime.o unicode.o | 9 | directory.o misc.o udftime.o unicode.o |
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c index f855dcbbdfb8..1b809bd494bd 100644 --- a/fs/udf/balloc.c +++ b/fs/udf/balloc.c | |||
@@ -149,8 +149,7 @@ static bool udf_add_free_space(struct udf_sb_info *sbi, | |||
149 | return false; | 149 | return false; |
150 | 150 | ||
151 | lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; | 151 | lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; |
152 | lvid->freeSpaceTable[partition] = cpu_to_le32(le32_to_cpu( | 152 | le32_add_cpu(&lvid->freeSpaceTable[partition], cnt); |
153 | lvid->freeSpaceTable[partition]) + cnt); | ||
154 | return true; | 153 | return true; |
155 | } | 154 | } |
156 | 155 | ||
@@ -589,10 +588,8 @@ static void udf_table_free_blocks(struct super_block *sb, | |||
589 | sptr = oepos.bh->b_data + epos.offset; | 588 | sptr = oepos.bh->b_data + epos.offset; |
590 | aed = (struct allocExtDesc *) | 589 | aed = (struct allocExtDesc *) |
591 | oepos.bh->b_data; | 590 | oepos.bh->b_data; |
592 | aed->lengthAllocDescs = | 591 | le32_add_cpu(&aed->lengthAllocDescs, |
593 | cpu_to_le32(le32_to_cpu( | 592 | adsize); |
594 | aed->lengthAllocDescs) + | ||
595 | adsize); | ||
596 | } else { | 593 | } else { |
597 | sptr = iinfo->i_ext.i_data + | 594 | sptr = iinfo->i_ext.i_data + |
598 | epos.offset; | 595 | epos.offset; |
@@ -645,9 +642,7 @@ static void udf_table_free_blocks(struct super_block *sb, | |||
645 | mark_inode_dirty(table); | 642 | mark_inode_dirty(table); |
646 | } else { | 643 | } else { |
647 | aed = (struct allocExtDesc *)epos.bh->b_data; | 644 | aed = (struct allocExtDesc *)epos.bh->b_data; |
648 | aed->lengthAllocDescs = | 645 | le32_add_cpu(&aed->lengthAllocDescs, adsize); |
649 | cpu_to_le32(le32_to_cpu( | ||
650 | aed->lengthAllocDescs) + adsize); | ||
651 | udf_update_tag(epos.bh->b_data, epos.offset); | 646 | udf_update_tag(epos.bh->b_data, epos.offset); |
652 | mark_buffer_dirty(epos.bh); | 647 | mark_buffer_dirty(epos.bh); |
653 | } | 648 | } |
diff --git a/fs/udf/crc.c b/fs/udf/crc.c deleted file mode 100644 index b1661296e786..000000000000 --- a/fs/udf/crc.c +++ /dev/null | |||
@@ -1,172 +0,0 @@ | |||
1 | /* | ||
2 | * crc.c | ||
3 | * | ||
4 | * PURPOSE | ||
5 | * Routines to generate, calculate, and test a 16-bit CRC. | ||
6 | * | ||
7 | * DESCRIPTION | ||
8 | * The CRC code was devised by Don P. Mitchell of AT&T Bell Laboratories | ||
9 | * and Ned W. Rhodes of Software Systems Group. It has been published in | ||
10 | * "Design and Validation of Computer Protocols", Prentice Hall, | ||
11 | * Englewood Cliffs, NJ, 1991, Chapter 3, ISBN 0-13-539925-4. | ||
12 | * | ||
13 | * Copyright is held by AT&T. | ||
14 | * | ||
15 | * AT&T gives permission for the free use of the CRC source code. | ||
16 | * | ||
17 | * COPYRIGHT | ||
18 | * This file is distributed under the terms of the GNU General Public | ||
19 | * License (GPL). Copies of the GPL can be obtained from: | ||
20 | * ftp://prep.ai.mit.edu/pub/gnu/GPL | ||
21 | * Each contributing author retains all rights to their own work. | ||
22 | */ | ||
23 | |||
24 | #include "udfdecl.h" | ||
25 | |||
26 | static uint16_t crc_table[256] = { | ||
27 | 0x0000U, 0x1021U, 0x2042U, 0x3063U, 0x4084U, 0x50a5U, 0x60c6U, 0x70e7U, | ||
28 | 0x8108U, 0x9129U, 0xa14aU, 0xb16bU, 0xc18cU, 0xd1adU, 0xe1ceU, 0xf1efU, | ||
29 | 0x1231U, 0x0210U, 0x3273U, 0x2252U, 0x52b5U, 0x4294U, 0x72f7U, 0x62d6U, | ||
30 | 0x9339U, 0x8318U, 0xb37bU, 0xa35aU, 0xd3bdU, 0xc39cU, 0xf3ffU, 0xe3deU, | ||
31 | 0x2462U, 0x3443U, 0x0420U, 0x1401U, 0x64e6U, 0x74c7U, 0x44a4U, 0x5485U, | ||
32 | 0xa56aU, 0xb54bU, 0x8528U, 0x9509U, 0xe5eeU, 0xf5cfU, 0xc5acU, 0xd58dU, | ||
33 | 0x3653U, 0x2672U, 0x1611U, 0x0630U, 0x76d7U, 0x66f6U, 0x5695U, 0x46b4U, | ||
34 | 0xb75bU, 0xa77aU, 0x9719U, 0x8738U, 0xf7dfU, 0xe7feU, 0xd79dU, 0xc7bcU, | ||
35 | 0x48c4U, 0x58e5U, 0x6886U, 0x78a7U, 0x0840U, 0x1861U, 0x2802U, 0x3823U, | ||
36 | 0xc9ccU, 0xd9edU, 0xe98eU, 0xf9afU, 0x8948U, 0x9969U, 0xa90aU, 0xb92bU, | ||
37 | 0x5af5U, 0x4ad4U, 0x7ab7U, 0x6a96U, 0x1a71U, 0x0a50U, 0x3a33U, 0x2a12U, | ||
38 | 0xdbfdU, 0xcbdcU, 0xfbbfU, 0xeb9eU, 0x9b79U, 0x8b58U, 0xbb3bU, 0xab1aU, | ||
39 | 0x6ca6U, 0x7c87U, 0x4ce4U, 0x5cc5U, 0x2c22U, 0x3c03U, 0x0c60U, 0x1c41U, | ||
40 | 0xedaeU, 0xfd8fU, 0xcdecU, 0xddcdU, 0xad2aU, 0xbd0bU, 0x8d68U, 0x9d49U, | ||
41 | 0x7e97U, 0x6eb6U, 0x5ed5U, 0x4ef4U, 0x3e13U, 0x2e32U, 0x1e51U, 0x0e70U, | ||
42 | 0xff9fU, 0xefbeU, 0xdfddU, 0xcffcU, 0xbf1bU, 0xaf3aU, 0x9f59U, 0x8f78U, | ||
43 | 0x9188U, 0x81a9U, 0xb1caU, 0xa1ebU, 0xd10cU, 0xc12dU, 0xf14eU, 0xe16fU, | ||
44 | 0x1080U, 0x00a1U, 0x30c2U, 0x20e3U, 0x5004U, 0x4025U, 0x7046U, 0x6067U, | ||
45 | 0x83b9U, 0x9398U, 0xa3fbU, 0xb3daU, 0xc33dU, 0xd31cU, 0xe37fU, 0xf35eU, | ||
46 | 0x02b1U, 0x1290U, 0x22f3U, 0x32d2U, 0x4235U, 0x5214U, 0x6277U, 0x7256U, | ||
47 | 0xb5eaU, 0xa5cbU, 0x95a8U, 0x8589U, 0xf56eU, 0xe54fU, 0xd52cU, 0xc50dU, | ||
48 | 0x34e2U, 0x24c3U, 0x14a0U, 0x0481U, 0x7466U, 0x6447U, 0x5424U, 0x4405U, | ||
49 | 0xa7dbU, 0xb7faU, 0x8799U, 0x97b8U, 0xe75fU, 0xf77eU, 0xc71dU, 0xd73cU, | ||
50 | 0x26d3U, 0x36f2U, 0x0691U, 0x16b0U, 0x6657U, 0x7676U, 0x4615U, 0x5634U, | ||
51 | 0xd94cU, 0xc96dU, 0xf90eU, 0xe92fU, 0x99c8U, 0x89e9U, 0xb98aU, 0xa9abU, | ||
52 | 0x5844U, 0x4865U, 0x7806U, 0x6827U, 0x18c0U, 0x08e1U, 0x3882U, 0x28a3U, | ||
53 | 0xcb7dU, 0xdb5cU, 0xeb3fU, 0xfb1eU, 0x8bf9U, 0x9bd8U, 0xabbbU, 0xbb9aU, | ||
54 | 0x4a75U, 0x5a54U, 0x6a37U, 0x7a16U, 0x0af1U, 0x1ad0U, 0x2ab3U, 0x3a92U, | ||
55 | 0xfd2eU, 0xed0fU, 0xdd6cU, 0xcd4dU, 0xbdaaU, 0xad8bU, 0x9de8U, 0x8dc9U, | ||
56 | 0x7c26U, 0x6c07U, 0x5c64U, 0x4c45U, 0x3ca2U, 0x2c83U, 0x1ce0U, 0x0cc1U, | ||
57 | 0xef1fU, 0xff3eU, 0xcf5dU, 0xdf7cU, 0xaf9bU, 0xbfbaU, 0x8fd9U, 0x9ff8U, | ||
58 | 0x6e17U, 0x7e36U, 0x4e55U, 0x5e74U, 0x2e93U, 0x3eb2U, 0x0ed1U, 0x1ef0U | ||
59 | }; | ||
60 | |||
61 | /* | ||
62 | * udf_crc | ||
63 | * | ||
64 | * PURPOSE | ||
65 | * Calculate a 16-bit CRC checksum using ITU-T V.41 polynomial. | ||
66 | * | ||
67 | * DESCRIPTION | ||
68 | * The OSTA-UDF(tm) 1.50 standard states that using CRCs is mandatory. | ||
69 | * The polynomial used is: x^16 + x^12 + x^15 + 1 | ||
70 | * | ||
71 | * PRE-CONDITIONS | ||
72 | * data Pointer to the data block. | ||
73 | * size Size of the data block. | ||
74 | * | ||
75 | * POST-CONDITIONS | ||
76 | * <return> CRC of the data block. | ||
77 | * | ||
78 | * HISTORY | ||
79 | * July 21, 1997 - Andrew E. Mileski | ||
80 | * Adapted from OSTA-UDF(tm) 1.50 standard. | ||
81 | */ | ||
82 | uint16_t udf_crc(uint8_t *data, uint32_t size, uint16_t crc) | ||
83 | { | ||
84 | while (size--) | ||
85 | crc = crc_table[(crc >> 8 ^ *(data++)) & 0xffU] ^ (crc << 8); | ||
86 | |||
87 | return crc; | ||
88 | } | ||
89 | |||
90 | /****************************************************************************/ | ||
91 | #if defined(TEST) | ||
92 | |||
93 | /* | ||
94 | * PURPOSE | ||
95 | * Test udf_crc() | ||
96 | * | ||
97 | * HISTORY | ||
98 | * July 21, 1997 - Andrew E. Mileski | ||
99 | * Adapted from OSTA-UDF(tm) 1.50 standard. | ||
100 | */ | ||
101 | |||
102 | unsigned char bytes[] = { 0x70U, 0x6AU, 0x77U }; | ||
103 | |||
104 | int main(void) | ||
105 | { | ||
106 | unsigned short x; | ||
107 | |||
108 | x = udf_crc(bytes, sizeof bytes); | ||
109 | printf("udf_crc: calculated = %4.4x, correct = %4.4x\n", x, 0x3299U); | ||
110 | |||
111 | return 0; | ||
112 | } | ||
113 | |||
114 | #endif /* defined(TEST) */ | ||
115 | |||
116 | /****************************************************************************/ | ||
117 | #if defined(GENERATE) | ||
118 | |||
119 | /* | ||
120 | * PURPOSE | ||
121 | * Generate a table for fast 16-bit CRC calculations (any polynomial). | ||
122 | * | ||
123 | * DESCRIPTION | ||
124 | * The ITU-T V.41 polynomial is 010041. | ||
125 | * | ||
126 | * HISTORY | ||
127 | * July 21, 1997 - Andrew E. Mileski | ||
128 | * Adapted from OSTA-UDF(tm) 1.50 standard. | ||
129 | */ | ||
130 | |||
131 | #include <stdio.h> | ||
132 | |||
133 | int main(int argc, char **argv) | ||
134 | { | ||
135 | unsigned long crc, poly; | ||
136 | int n, i; | ||
137 | |||
138 | /* Get the polynomial */ | ||
139 | sscanf(argv[1], "%lo", &poly); | ||
140 | if (poly & 0xffff0000U) { | ||
141 | fprintf(stderr, "polynomial is too large\en"); | ||
142 | exit(1); | ||
143 | } | ||
144 | |||
145 | printf("/* CRC 0%o */\n", poly); | ||
146 | |||
147 | /* Create a table */ | ||
148 | printf("static unsigned short crc_table[256] = {\n"); | ||
149 | for (n = 0; n < 256; n++) { | ||
150 | if (n % 8 == 0) | ||
151 | printf("\t"); | ||
152 | crc = n << 8; | ||
153 | for (i = 0; i < 8; i++) { | ||
154 | if (crc & 0x8000U) | ||
155 | crc = (crc << 1) ^ poly; | ||
156 | else | ||
157 | crc <<= 1; | ||
158 | crc &= 0xFFFFU; | ||
159 | } | ||
160 | if (n == 255) | ||
161 | printf("0x%04xU ", crc); | ||
162 | else | ||
163 | printf("0x%04xU, ", crc); | ||
164 | if (n % 8 == 7) | ||
165 | printf("\n"); | ||
166 | } | ||
167 | printf("};\n"); | ||
168 | |||
169 | return 0; | ||
170 | } | ||
171 | |||
172 | #endif /* defined(GENERATE) */ | ||
diff --git a/fs/udf/dir.c b/fs/udf/dir.c index 8d8643ada199..62dc270c69d1 100644 --- a/fs/udf/dir.c +++ b/fs/udf/dir.c | |||
@@ -39,13 +39,13 @@ | |||
39 | static int do_udf_readdir(struct inode *dir, struct file *filp, | 39 | static int do_udf_readdir(struct inode *dir, struct file *filp, |
40 | filldir_t filldir, void *dirent) | 40 | filldir_t filldir, void *dirent) |
41 | { | 41 | { |
42 | struct udf_fileident_bh fibh; | 42 | struct udf_fileident_bh fibh = { .sbh = NULL, .ebh = NULL}; |
43 | struct fileIdentDesc *fi = NULL; | 43 | struct fileIdentDesc *fi = NULL; |
44 | struct fileIdentDesc cfi; | 44 | struct fileIdentDesc cfi; |
45 | int block, iblock; | 45 | int block, iblock; |
46 | loff_t nf_pos = (filp->f_pos - 1) << 2; | 46 | loff_t nf_pos = (filp->f_pos - 1) << 2; |
47 | int flen; | 47 | int flen; |
48 | char fname[UDF_NAME_LEN]; | 48 | char *fname = NULL; |
49 | char *nameptr; | 49 | char *nameptr; |
50 | uint16_t liu; | 50 | uint16_t liu; |
51 | uint8_t lfi; | 51 | uint8_t lfi; |
@@ -54,23 +54,32 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, | |||
54 | kernel_lb_addr eloc; | 54 | kernel_lb_addr eloc; |
55 | uint32_t elen; | 55 | uint32_t elen; |
56 | sector_t offset; | 56 | sector_t offset; |
57 | int i, num; | 57 | int i, num, ret = 0; |
58 | unsigned int dt_type; | 58 | unsigned int dt_type; |
59 | struct extent_position epos = { NULL, 0, {0, 0} }; | 59 | struct extent_position epos = { NULL, 0, {0, 0} }; |
60 | struct udf_inode_info *iinfo; | 60 | struct udf_inode_info *iinfo; |
61 | 61 | ||
62 | if (nf_pos >= size) | 62 | if (nf_pos >= size) |
63 | return 0; | 63 | goto out; |
64 | |||
65 | fname = kmalloc(UDF_NAME_LEN, GFP_NOFS); | ||
66 | if (!fname) { | ||
67 | ret = -ENOMEM; | ||
68 | goto out; | ||
69 | } | ||
64 | 70 | ||
65 | if (nf_pos == 0) | 71 | if (nf_pos == 0) |
66 | nf_pos = udf_ext0_offset(dir); | 72 | nf_pos = udf_ext0_offset(dir); |
67 | 73 | ||
68 | fibh.soffset = fibh.eoffset = nf_pos & (dir->i_sb->s_blocksize - 1); | 74 | fibh.soffset = fibh.eoffset = nf_pos & (dir->i_sb->s_blocksize - 1); |
69 | iinfo = UDF_I(dir); | 75 | iinfo = UDF_I(dir); |
70 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { | 76 | if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
71 | fibh.sbh = fibh.ebh = NULL; | 77 | if (inode_bmap(dir, nf_pos >> dir->i_sb->s_blocksize_bits, |
72 | } else if (inode_bmap(dir, nf_pos >> dir->i_sb->s_blocksize_bits, | 78 | &epos, &eloc, &elen, &offset) |
73 | &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) { | 79 | != (EXT_RECORDED_ALLOCATED >> 30)) { |
80 | ret = -ENOENT; | ||
81 | goto out; | ||
82 | } | ||
74 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); | 83 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); |
75 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { | 84 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { |
76 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) | 85 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
@@ -83,8 +92,8 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, | |||
83 | } | 92 | } |
84 | 93 | ||
85 | if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) { | 94 | if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) { |
86 | brelse(epos.bh); | 95 | ret = -EIO; |
87 | return -EIO; | 96 | goto out; |
88 | } | 97 | } |
89 | 98 | ||
90 | if (!(offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) { | 99 | if (!(offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) { |
@@ -105,9 +114,6 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, | |||
105 | brelse(bha[i]); | 114 | brelse(bha[i]); |
106 | } | 115 | } |
107 | } | 116 | } |
108 | } else { | ||
109 | brelse(epos.bh); | ||
110 | return -ENOENT; | ||
111 | } | 117 | } |
112 | 118 | ||
113 | while (nf_pos < size) { | 119 | while (nf_pos < size) { |
@@ -115,13 +121,8 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, | |||
115 | 121 | ||
116 | fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, | 122 | fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, |
117 | &elen, &offset); | 123 | &elen, &offset); |
118 | if (!fi) { | 124 | if (!fi) |
119 | if (fibh.sbh != fibh.ebh) | 125 | goto out; |
120 | brelse(fibh.ebh); | ||
121 | brelse(fibh.sbh); | ||
122 | brelse(epos.bh); | ||
123 | return 0; | ||
124 | } | ||
125 | 126 | ||
126 | liu = le16_to_cpu(cfi.lengthOfImpUse); | 127 | liu = le16_to_cpu(cfi.lengthOfImpUse); |
127 | lfi = cfi.lengthFileIdent; | 128 | lfi = cfi.lengthFileIdent; |
@@ -167,53 +168,23 @@ static int do_udf_readdir(struct inode *dir, struct file *filp, | |||
167 | dt_type = DT_UNKNOWN; | 168 | dt_type = DT_UNKNOWN; |
168 | } | 169 | } |
169 | 170 | ||
170 | if (flen) { | 171 | if (flen && filldir(dirent, fname, flen, filp->f_pos, |
171 | if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0) { | 172 | iblock, dt_type) < 0) |
172 | if (fibh.sbh != fibh.ebh) | 173 | goto out; |
173 | brelse(fibh.ebh); | ||
174 | brelse(fibh.sbh); | ||
175 | brelse(epos.bh); | ||
176 | return 0; | ||
177 | } | ||
178 | } | ||
179 | } /* end while */ | 174 | } /* end while */ |
180 | 175 | ||
181 | filp->f_pos = (nf_pos >> 2) + 1; | 176 | filp->f_pos = (nf_pos >> 2) + 1; |
182 | 177 | ||
178 | out: | ||
183 | if (fibh.sbh != fibh.ebh) | 179 | if (fibh.sbh != fibh.ebh) |
184 | brelse(fibh.ebh); | 180 | brelse(fibh.ebh); |
185 | brelse(fibh.sbh); | 181 | brelse(fibh.sbh); |
186 | brelse(epos.bh); | 182 | brelse(epos.bh); |
183 | kfree(fname); | ||
187 | 184 | ||
188 | return 0; | 185 | return ret; |
189 | } | 186 | } |
190 | 187 | ||
191 | /* | ||
192 | * udf_readdir | ||
193 | * | ||
194 | * PURPOSE | ||
195 | * Read a directory entry. | ||
196 | * | ||
197 | * DESCRIPTION | ||
198 | * Optional - sys_getdents() will return -ENOTDIR if this routine is not | ||
199 | * available. | ||
200 | * | ||
201 | * Refer to sys_getdents() in fs/readdir.c | ||
202 | * sys_getdents() -> . | ||
203 | * | ||
204 | * PRE-CONDITIONS | ||
205 | * filp Pointer to directory file. | ||
206 | * buf Pointer to directory entry buffer. | ||
207 | * filldir Pointer to filldir function. | ||
208 | * | ||
209 | * POST-CONDITIONS | ||
210 | * <return> >=0 on success. | ||
211 | * | ||
212 | * HISTORY | ||
213 | * July 1, 1997 - Andrew E. Mileski | ||
214 | * Written, tested, and released. | ||
215 | */ | ||
216 | |||
217 | static int udf_readdir(struct file *filp, void *dirent, filldir_t filldir) | 188 | static int udf_readdir(struct file *filp, void *dirent, filldir_t filldir) |
218 | { | 189 | { |
219 | struct inode *dir = filp->f_path.dentry->d_inode; | 190 | struct inode *dir = filp->f_path.dentry->d_inode; |
diff --git a/fs/udf/ecma_167.h b/fs/udf/ecma_167.h index 56387711589b..a0974df82b31 100644 --- a/fs/udf/ecma_167.h +++ b/fs/udf/ecma_167.h | |||
@@ -70,19 +70,6 @@ typedef struct { | |||
70 | uint8_t microseconds; | 70 | uint8_t microseconds; |
71 | } __attribute__ ((packed)) timestamp; | 71 | } __attribute__ ((packed)) timestamp; |
72 | 72 | ||
73 | typedef struct { | ||
74 | uint16_t typeAndTimezone; | ||
75 | int16_t year; | ||
76 | uint8_t month; | ||
77 | uint8_t day; | ||
78 | uint8_t hour; | ||
79 | uint8_t minute; | ||
80 | uint8_t second; | ||
81 | uint8_t centiseconds; | ||
82 | uint8_t hundredsOfMicroseconds; | ||
83 | uint8_t microseconds; | ||
84 | } __attribute__ ((packed)) kernel_timestamp; | ||
85 | |||
86 | /* Type and Time Zone (ECMA 167r3 1/7.3.1) */ | 73 | /* Type and Time Zone (ECMA 167r3 1/7.3.1) */ |
87 | #define TIMESTAMP_TYPE_MASK 0xF000 | 74 | #define TIMESTAMP_TYPE_MASK 0xF000 |
88 | #define TIMESTAMP_TYPE_CUT 0x0000 | 75 | #define TIMESTAMP_TYPE_CUT 0x0000 |
diff --git a/fs/udf/file.c b/fs/udf/file.c index 97c71ae7c689..0ed6e146a0d9 100644 --- a/fs/udf/file.c +++ b/fs/udf/file.c | |||
@@ -27,7 +27,6 @@ | |||
27 | 27 | ||
28 | #include "udfdecl.h" | 28 | #include "udfdecl.h" |
29 | #include <linux/fs.h> | 29 | #include <linux/fs.h> |
30 | #include <linux/udf_fs.h> | ||
31 | #include <asm/uaccess.h> | 30 | #include <asm/uaccess.h> |
32 | #include <linux/kernel.h> | 31 | #include <linux/kernel.h> |
33 | #include <linux/string.h> /* memset */ | 32 | #include <linux/string.h> /* memset */ |
@@ -144,40 +143,6 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov, | |||
144 | return retval; | 143 | return retval; |
145 | } | 144 | } |
146 | 145 | ||
147 | /* | ||
148 | * udf_ioctl | ||
149 | * | ||
150 | * PURPOSE | ||
151 | * Issue an ioctl. | ||
152 | * | ||
153 | * DESCRIPTION | ||
154 | * Optional - sys_ioctl() will return -ENOTTY if this routine is not | ||
155 | * available, and the ioctl cannot be handled without filesystem help. | ||
156 | * | ||
157 | * sys_ioctl() handles these ioctls that apply only to regular files: | ||
158 | * FIBMAP [requires udf_block_map()], FIGETBSZ, FIONREAD | ||
159 | * These ioctls are also handled by sys_ioctl(): | ||
160 | * FIOCLEX, FIONCLEX, FIONBIO, FIOASYNC | ||
161 | * All other ioctls are passed to the filesystem. | ||
162 | * | ||
163 | * Refer to sys_ioctl() in fs/ioctl.c | ||
164 | * sys_ioctl() -> . | ||
165 | * | ||
166 | * PRE-CONDITIONS | ||
167 | * inode Pointer to inode that ioctl was issued on. | ||
168 | * filp Pointer to file that ioctl was issued on. | ||
169 | * cmd The ioctl command. | ||
170 | * arg The ioctl argument [can be interpreted as a | ||
171 | * user-space pointer if desired]. | ||
172 | * | ||
173 | * POST-CONDITIONS | ||
174 | * <return> Success (>=0) or an error code (<=0) that | ||
175 | * sys_ioctl() will return. | ||
176 | * | ||
177 | * HISTORY | ||
178 | * July 1, 1997 - Andrew E. Mileski | ||
179 | * Written, tested, and released. | ||
180 | */ | ||
181 | int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, | 146 | int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, |
182 | unsigned long arg) | 147 | unsigned long arg) |
183 | { | 148 | { |
@@ -225,18 +190,6 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, | |||
225 | return result; | 190 | return result; |
226 | } | 191 | } |
227 | 192 | ||
228 | /* | ||
229 | * udf_release_file | ||
230 | * | ||
231 | * PURPOSE | ||
232 | * Called when all references to the file are closed | ||
233 | * | ||
234 | * DESCRIPTION | ||
235 | * Discard prealloced blocks | ||
236 | * | ||
237 | * HISTORY | ||
238 | * | ||
239 | */ | ||
240 | static int udf_release_file(struct inode *inode, struct file *filp) | 193 | static int udf_release_file(struct inode *inode, struct file *filp) |
241 | { | 194 | { |
242 | if (filp->f_mode & FMODE_WRITE) { | 195 | if (filp->f_mode & FMODE_WRITE) { |
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c index 84360315aca2..eb9cfa23dc3d 100644 --- a/fs/udf/ialloc.c +++ b/fs/udf/ialloc.c | |||
@@ -21,7 +21,6 @@ | |||
21 | #include "udfdecl.h" | 21 | #include "udfdecl.h" |
22 | #include <linux/fs.h> | 22 | #include <linux/fs.h> |
23 | #include <linux/quotaops.h> | 23 | #include <linux/quotaops.h> |
24 | #include <linux/udf_fs.h> | ||
25 | #include <linux/sched.h> | 24 | #include <linux/sched.h> |
26 | #include <linux/slab.h> | 25 | #include <linux/slab.h> |
27 | 26 | ||
@@ -47,11 +46,9 @@ void udf_free_inode(struct inode *inode) | |||
47 | struct logicalVolIntegrityDescImpUse *lvidiu = | 46 | struct logicalVolIntegrityDescImpUse *lvidiu = |
48 | udf_sb_lvidiu(sbi); | 47 | udf_sb_lvidiu(sbi); |
49 | if (S_ISDIR(inode->i_mode)) | 48 | if (S_ISDIR(inode->i_mode)) |
50 | lvidiu->numDirs = | 49 | le32_add_cpu(&lvidiu->numDirs, -1); |
51 | cpu_to_le32(le32_to_cpu(lvidiu->numDirs) - 1); | ||
52 | else | 50 | else |
53 | lvidiu->numFiles = | 51 | le32_add_cpu(&lvidiu->numFiles, -1); |
54 | cpu_to_le32(le32_to_cpu(lvidiu->numFiles) - 1); | ||
55 | 52 | ||
56 | mark_buffer_dirty(sbi->s_lvid_bh); | 53 | mark_buffer_dirty(sbi->s_lvid_bh); |
57 | } | 54 | } |
@@ -105,11 +102,9 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) | |||
105 | lvhd = (struct logicalVolHeaderDesc *) | 102 | lvhd = (struct logicalVolHeaderDesc *) |
106 | (lvid->logicalVolContentsUse); | 103 | (lvid->logicalVolContentsUse); |
107 | if (S_ISDIR(mode)) | 104 | if (S_ISDIR(mode)) |
108 | lvidiu->numDirs = | 105 | le32_add_cpu(&lvidiu->numDirs, 1); |
109 | cpu_to_le32(le32_to_cpu(lvidiu->numDirs) + 1); | ||
110 | else | 106 | else |
111 | lvidiu->numFiles = | 107 | le32_add_cpu(&lvidiu->numFiles, 1); |
112 | cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1); | ||
113 | iinfo->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID); | 108 | iinfo->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID); |
114 | if (!(++uniqueID & 0x00000000FFFFFFFFUL)) | 109 | if (!(++uniqueID & 0x00000000FFFFFFFFUL)) |
115 | uniqueID += 16; | 110 | uniqueID += 16; |
diff --git a/fs/udf/inode.c b/fs/udf/inode.c index 24cfa55d0fdc..6e74b117aaf0 100644 --- a/fs/udf/inode.c +++ b/fs/udf/inode.c | |||
@@ -37,6 +37,7 @@ | |||
37 | #include <linux/buffer_head.h> | 37 | #include <linux/buffer_head.h> |
38 | #include <linux/writeback.h> | 38 | #include <linux/writeback.h> |
39 | #include <linux/slab.h> | 39 | #include <linux/slab.h> |
40 | #include <linux/crc-itu-t.h> | ||
40 | 41 | ||
41 | #include "udf_i.h" | 42 | #include "udf_i.h" |
42 | #include "udf_sb.h" | 43 | #include "udf_sb.h" |
@@ -66,22 +67,7 @@ static void udf_update_extents(struct inode *, | |||
66 | struct extent_position *); | 67 | struct extent_position *); |
67 | static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int); | 68 | static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int); |
68 | 69 | ||
69 | /* | 70 | |
70 | * udf_delete_inode | ||
71 | * | ||
72 | * PURPOSE | ||
73 | * Clean-up before the specified inode is destroyed. | ||
74 | * | ||
75 | * DESCRIPTION | ||
76 | * This routine is called when the kernel destroys an inode structure | ||
77 | * ie. when iput() finds i_count == 0. | ||
78 | * | ||
79 | * HISTORY | ||
80 | * July 1, 1997 - Andrew E. Mileski | ||
81 | * Written, tested, and released. | ||
82 | * | ||
83 | * Called at the last iput() if i_nlink is zero. | ||
84 | */ | ||
85 | void udf_delete_inode(struct inode *inode) | 71 | void udf_delete_inode(struct inode *inode) |
86 | { | 72 | { |
87 | truncate_inode_pages(&inode->i_data, 0); | 73 | truncate_inode_pages(&inode->i_data, 0); |
@@ -323,9 +309,6 @@ static int udf_get_block(struct inode *inode, sector_t block, | |||
323 | 309 | ||
324 | lock_kernel(); | 310 | lock_kernel(); |
325 | 311 | ||
326 | if (block < 0) | ||
327 | goto abort_negative; | ||
328 | |||
329 | iinfo = UDF_I(inode); | 312 | iinfo = UDF_I(inode); |
330 | if (block == iinfo->i_next_alloc_block + 1) { | 313 | if (block == iinfo->i_next_alloc_block + 1) { |
331 | iinfo->i_next_alloc_block++; | 314 | iinfo->i_next_alloc_block++; |
@@ -347,10 +330,6 @@ static int udf_get_block(struct inode *inode, sector_t block, | |||
347 | abort: | 330 | abort: |
348 | unlock_kernel(); | 331 | unlock_kernel(); |
349 | return err; | 332 | return err; |
350 | |||
351 | abort_negative: | ||
352 | udf_warning(inode->i_sb, "udf_get_block", "block < 0"); | ||
353 | goto abort; | ||
354 | } | 333 | } |
355 | 334 | ||
356 | static struct buffer_head *udf_getblk(struct inode *inode, long block, | 335 | static struct buffer_head *udf_getblk(struct inode *inode, long block, |
@@ -1116,42 +1095,36 @@ static void __udf_read_inode(struct inode *inode) | |||
1116 | fe = (struct fileEntry *)bh->b_data; | 1095 | fe = (struct fileEntry *)bh->b_data; |
1117 | 1096 | ||
1118 | if (fe->icbTag.strategyType == cpu_to_le16(4096)) { | 1097 | if (fe->icbTag.strategyType == cpu_to_le16(4096)) { |
1119 | struct buffer_head *ibh = NULL, *nbh = NULL; | 1098 | struct buffer_head *ibh; |
1120 | struct indirectEntry *ie; | ||
1121 | 1099 | ||
1122 | ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1, | 1100 | ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1, |
1123 | &ident); | 1101 | &ident); |
1124 | if (ident == TAG_IDENT_IE) { | 1102 | if (ident == TAG_IDENT_IE && ibh) { |
1125 | if (ibh) { | 1103 | struct buffer_head *nbh = NULL; |
1126 | kernel_lb_addr loc; | 1104 | kernel_lb_addr loc; |
1127 | ie = (struct indirectEntry *)ibh->b_data; | 1105 | struct indirectEntry *ie; |
1128 | 1106 | ||
1129 | loc = lelb_to_cpu(ie->indirectICB.extLocation); | 1107 | ie = (struct indirectEntry *)ibh->b_data; |
1130 | 1108 | loc = lelb_to_cpu(ie->indirectICB.extLocation); | |
1131 | if (ie->indirectICB.extLength && | 1109 | |
1132 | (nbh = udf_read_ptagged(inode->i_sb, loc, 0, | 1110 | if (ie->indirectICB.extLength && |
1133 | &ident))) { | 1111 | (nbh = udf_read_ptagged(inode->i_sb, loc, 0, |
1134 | if (ident == TAG_IDENT_FE || | 1112 | &ident))) { |
1135 | ident == TAG_IDENT_EFE) { | 1113 | if (ident == TAG_IDENT_FE || |
1136 | memcpy(&iinfo->i_location, | 1114 | ident == TAG_IDENT_EFE) { |
1137 | &loc, | 1115 | memcpy(&iinfo->i_location, |
1138 | sizeof(kernel_lb_addr)); | 1116 | &loc, |
1139 | brelse(bh); | 1117 | sizeof(kernel_lb_addr)); |
1140 | brelse(ibh); | 1118 | brelse(bh); |
1141 | brelse(nbh); | ||
1142 | __udf_read_inode(inode); | ||
1143 | return; | ||
1144 | } else { | ||
1145 | brelse(nbh); | ||
1146 | brelse(ibh); | ||
1147 | } | ||
1148 | } else { | ||
1149 | brelse(ibh); | 1119 | brelse(ibh); |
1120 | brelse(nbh); | ||
1121 | __udf_read_inode(inode); | ||
1122 | return; | ||
1150 | } | 1123 | } |
1124 | brelse(nbh); | ||
1151 | } | 1125 | } |
1152 | } else { | ||
1153 | brelse(ibh); | ||
1154 | } | 1126 | } |
1127 | brelse(ibh); | ||
1155 | } else if (fe->icbTag.strategyType != cpu_to_le16(4)) { | 1128 | } else if (fe->icbTag.strategyType != cpu_to_le16(4)) { |
1156 | printk(KERN_ERR "udf: unsupported strategy type: %d\n", | 1129 | printk(KERN_ERR "udf: unsupported strategy type: %d\n", |
1157 | le16_to_cpu(fe->icbTag.strategyType)); | 1130 | le16_to_cpu(fe->icbTag.strategyType)); |
@@ -1168,8 +1141,6 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) | |||
1168 | { | 1141 | { |
1169 | struct fileEntry *fe; | 1142 | struct fileEntry *fe; |
1170 | struct extendedFileEntry *efe; | 1143 | struct extendedFileEntry *efe; |
1171 | time_t convtime; | ||
1172 | long convtime_usec; | ||
1173 | int offset; | 1144 | int offset; |
1174 | struct udf_sb_info *sbi = UDF_SB(inode->i_sb); | 1145 | struct udf_sb_info *sbi = UDF_SB(inode->i_sb); |
1175 | struct udf_inode_info *iinfo = UDF_I(inode); | 1146 | struct udf_inode_info *iinfo = UDF_I(inode); |
@@ -1257,29 +1228,15 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) | |||
1257 | inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) << | 1228 | inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) << |
1258 | (inode->i_sb->s_blocksize_bits - 9); | 1229 | (inode->i_sb->s_blocksize_bits - 9); |
1259 | 1230 | ||
1260 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1231 | if (!udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime)) |
1261 | lets_to_cpu(fe->accessTime))) { | ||
1262 | inode->i_atime.tv_sec = convtime; | ||
1263 | inode->i_atime.tv_nsec = convtime_usec * 1000; | ||
1264 | } else { | ||
1265 | inode->i_atime = sbi->s_record_time; | 1232 | inode->i_atime = sbi->s_record_time; |
1266 | } | ||
1267 | 1233 | ||
1268 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1234 | if (!udf_disk_stamp_to_time(&inode->i_mtime, |
1269 | lets_to_cpu(fe->modificationTime))) { | 1235 | fe->modificationTime)) |
1270 | inode->i_mtime.tv_sec = convtime; | ||
1271 | inode->i_mtime.tv_nsec = convtime_usec * 1000; | ||
1272 | } else { | ||
1273 | inode->i_mtime = sbi->s_record_time; | 1236 | inode->i_mtime = sbi->s_record_time; |
1274 | } | ||
1275 | 1237 | ||
1276 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1238 | if (!udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime)) |
1277 | lets_to_cpu(fe->attrTime))) { | ||
1278 | inode->i_ctime.tv_sec = convtime; | ||
1279 | inode->i_ctime.tv_nsec = convtime_usec * 1000; | ||
1280 | } else { | ||
1281 | inode->i_ctime = sbi->s_record_time; | 1239 | inode->i_ctime = sbi->s_record_time; |
1282 | } | ||
1283 | 1240 | ||
1284 | iinfo->i_unique = le64_to_cpu(fe->uniqueID); | 1241 | iinfo->i_unique = le64_to_cpu(fe->uniqueID); |
1285 | iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr); | 1242 | iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr); |
@@ -1289,37 +1246,18 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) | |||
1289 | inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << | 1246 | inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << |
1290 | (inode->i_sb->s_blocksize_bits - 9); | 1247 | (inode->i_sb->s_blocksize_bits - 9); |
1291 | 1248 | ||
1292 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1249 | if (!udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime)) |
1293 | lets_to_cpu(efe->accessTime))) { | ||
1294 | inode->i_atime.tv_sec = convtime; | ||
1295 | inode->i_atime.tv_nsec = convtime_usec * 1000; | ||
1296 | } else { | ||
1297 | inode->i_atime = sbi->s_record_time; | 1250 | inode->i_atime = sbi->s_record_time; |
1298 | } | ||
1299 | 1251 | ||
1300 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1252 | if (!udf_disk_stamp_to_time(&inode->i_mtime, |
1301 | lets_to_cpu(efe->modificationTime))) { | 1253 | efe->modificationTime)) |
1302 | inode->i_mtime.tv_sec = convtime; | ||
1303 | inode->i_mtime.tv_nsec = convtime_usec * 1000; | ||
1304 | } else { | ||
1305 | inode->i_mtime = sbi->s_record_time; | 1254 | inode->i_mtime = sbi->s_record_time; |
1306 | } | ||
1307 | 1255 | ||
1308 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1256 | if (!udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime)) |
1309 | lets_to_cpu(efe->createTime))) { | ||
1310 | iinfo->i_crtime.tv_sec = convtime; | ||
1311 | iinfo->i_crtime.tv_nsec = convtime_usec * 1000; | ||
1312 | } else { | ||
1313 | iinfo->i_crtime = sbi->s_record_time; | 1257 | iinfo->i_crtime = sbi->s_record_time; |
1314 | } | ||
1315 | 1258 | ||
1316 | if (udf_stamp_to_time(&convtime, &convtime_usec, | 1259 | if (!udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime)) |
1317 | lets_to_cpu(efe->attrTime))) { | ||
1318 | inode->i_ctime.tv_sec = convtime; | ||
1319 | inode->i_ctime.tv_nsec = convtime_usec * 1000; | ||
1320 | } else { | ||
1321 | inode->i_ctime = sbi->s_record_time; | 1260 | inode->i_ctime = sbi->s_record_time; |
1322 | } | ||
1323 | 1261 | ||
1324 | iinfo->i_unique = le64_to_cpu(efe->uniqueID); | 1262 | iinfo->i_unique = le64_to_cpu(efe->uniqueID); |
1325 | iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr); | 1263 | iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr); |
@@ -1338,6 +1276,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) | |||
1338 | case ICBTAG_FILE_TYPE_REALTIME: | 1276 | case ICBTAG_FILE_TYPE_REALTIME: |
1339 | case ICBTAG_FILE_TYPE_REGULAR: | 1277 | case ICBTAG_FILE_TYPE_REGULAR: |
1340 | case ICBTAG_FILE_TYPE_UNDEF: | 1278 | case ICBTAG_FILE_TYPE_UNDEF: |
1279 | case ICBTAG_FILE_TYPE_VAT20: | ||
1341 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) | 1280 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1342 | inode->i_data.a_ops = &udf_adinicb_aops; | 1281 | inode->i_data.a_ops = &udf_adinicb_aops; |
1343 | else | 1282 | else |
@@ -1363,6 +1302,15 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) | |||
1363 | inode->i_op = &page_symlink_inode_operations; | 1302 | inode->i_op = &page_symlink_inode_operations; |
1364 | inode->i_mode = S_IFLNK | S_IRWXUGO; | 1303 | inode->i_mode = S_IFLNK | S_IRWXUGO; |
1365 | break; | 1304 | break; |
1305 | case ICBTAG_FILE_TYPE_MAIN: | ||
1306 | udf_debug("METADATA FILE-----\n"); | ||
1307 | break; | ||
1308 | case ICBTAG_FILE_TYPE_MIRROR: | ||
1309 | udf_debug("METADATA MIRROR FILE-----\n"); | ||
1310 | break; | ||
1311 | case ICBTAG_FILE_TYPE_BITMAP: | ||
1312 | udf_debug("METADATA BITMAP FILE-----\n"); | ||
1313 | break; | ||
1366 | default: | 1314 | default: |
1367 | printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown " | 1315 | printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown " |
1368 | "file type=%d\n", inode->i_ino, | 1316 | "file type=%d\n", inode->i_ino, |
@@ -1416,21 +1364,6 @@ static mode_t udf_convert_permissions(struct fileEntry *fe) | |||
1416 | return mode; | 1364 | return mode; |
1417 | } | 1365 | } |
1418 | 1366 | ||
1419 | /* | ||
1420 | * udf_write_inode | ||
1421 | * | ||
1422 | * PURPOSE | ||
1423 | * Write out the specified inode. | ||
1424 | * | ||
1425 | * DESCRIPTION | ||
1426 | * This routine is called whenever an inode is synced. | ||
1427 | * Currently this routine is just a placeholder. | ||
1428 | * | ||
1429 | * HISTORY | ||
1430 | * July 1, 1997 - Andrew E. Mileski | ||
1431 | * Written, tested, and released. | ||
1432 | */ | ||
1433 | |||
1434 | int udf_write_inode(struct inode *inode, int sync) | 1367 | int udf_write_inode(struct inode *inode, int sync) |
1435 | { | 1368 | { |
1436 | int ret; | 1369 | int ret; |
@@ -1455,7 +1388,6 @@ static int udf_update_inode(struct inode *inode, int do_sync) | |||
1455 | uint32_t udfperms; | 1388 | uint32_t udfperms; |
1456 | uint16_t icbflags; | 1389 | uint16_t icbflags; |
1457 | uint16_t crclen; | 1390 | uint16_t crclen; |
1458 | kernel_timestamp cpu_time; | ||
1459 | int err = 0; | 1391 | int err = 0; |
1460 | struct udf_sb_info *sbi = UDF_SB(inode->i_sb); | 1392 | struct udf_sb_info *sbi = UDF_SB(inode->i_sb); |
1461 | unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; | 1393 | unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; |
@@ -1488,9 +1420,9 @@ static int udf_update_inode(struct inode *inode, int do_sync) | |||
1488 | iinfo->i_location. | 1420 | iinfo->i_location. |
1489 | logicalBlockNum); | 1421 | logicalBlockNum); |
1490 | use->descTag.descCRCLength = cpu_to_le16(crclen); | 1422 | use->descTag.descCRCLength = cpu_to_le16(crclen); |
1491 | use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + | 1423 | use->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)use + |
1492 | sizeof(tag), crclen, | 1424 | sizeof(tag), |
1493 | 0)); | 1425 | crclen)); |
1494 | use->descTag.tagChecksum = udf_tag_checksum(&use->descTag); | 1426 | use->descTag.tagChecksum = udf_tag_checksum(&use->descTag); |
1495 | 1427 | ||
1496 | mark_buffer_dirty(bh); | 1428 | mark_buffer_dirty(bh); |
@@ -1558,12 +1490,9 @@ static int udf_update_inode(struct inode *inode, int do_sync) | |||
1558 | (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >> | 1490 | (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >> |
1559 | (blocksize_bits - 9)); | 1491 | (blocksize_bits - 9)); |
1560 | 1492 | ||
1561 | if (udf_time_to_stamp(&cpu_time, inode->i_atime)) | 1493 | udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime); |
1562 | fe->accessTime = cpu_to_lets(cpu_time); | 1494 | udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime); |
1563 | if (udf_time_to_stamp(&cpu_time, inode->i_mtime)) | 1495 | udf_time_to_disk_stamp(&fe->attrTime, inode->i_ctime); |
1564 | fe->modificationTime = cpu_to_lets(cpu_time); | ||
1565 | if (udf_time_to_stamp(&cpu_time, inode->i_ctime)) | ||
1566 | fe->attrTime = cpu_to_lets(cpu_time); | ||
1567 | memset(&(fe->impIdent), 0, sizeof(regid)); | 1496 | memset(&(fe->impIdent), 0, sizeof(regid)); |
1568 | strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER); | 1497 | strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER); |
1569 | fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; | 1498 | fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; |
@@ -1598,14 +1527,10 @@ static int udf_update_inode(struct inode *inode, int do_sync) | |||
1598 | iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec)) | 1527 | iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec)) |
1599 | iinfo->i_crtime = inode->i_ctime; | 1528 | iinfo->i_crtime = inode->i_ctime; |
1600 | 1529 | ||
1601 | if (udf_time_to_stamp(&cpu_time, inode->i_atime)) | 1530 | udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime); |
1602 | efe->accessTime = cpu_to_lets(cpu_time); | 1531 | udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime); |
1603 | if (udf_time_to_stamp(&cpu_time, inode->i_mtime)) | 1532 | udf_time_to_disk_stamp(&efe->createTime, iinfo->i_crtime); |
1604 | efe->modificationTime = cpu_to_lets(cpu_time); | 1533 | udf_time_to_disk_stamp(&efe->attrTime, inode->i_ctime); |
1605 | if (udf_time_to_stamp(&cpu_time, iinfo->i_crtime)) | ||
1606 | efe->createTime = cpu_to_lets(cpu_time); | ||
1607 | if (udf_time_to_stamp(&cpu_time, inode->i_ctime)) | ||
1608 | efe->attrTime = cpu_to_lets(cpu_time); | ||
1609 | 1534 | ||
1610 | memset(&(efe->impIdent), 0, sizeof(regid)); | 1535 | memset(&(efe->impIdent), 0, sizeof(regid)); |
1611 | strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER); | 1536 | strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER); |
@@ -1660,8 +1585,8 @@ static int udf_update_inode(struct inode *inode, int do_sync) | |||
1660 | crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - | 1585 | crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - |
1661 | sizeof(tag); | 1586 | sizeof(tag); |
1662 | fe->descTag.descCRCLength = cpu_to_le16(crclen); | 1587 | fe->descTag.descCRCLength = cpu_to_le16(crclen); |
1663 | fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), | 1588 | fe->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)fe + sizeof(tag), |
1664 | crclen, 0)); | 1589 | crclen)); |
1665 | fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag); | 1590 | fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag); |
1666 | 1591 | ||
1667 | /* write the data blocks */ | 1592 | /* write the data blocks */ |
@@ -1778,9 +1703,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, | |||
1778 | 1703 | ||
1779 | if (epos->bh) { | 1704 | if (epos->bh) { |
1780 | aed = (struct allocExtDesc *)epos->bh->b_data; | 1705 | aed = (struct allocExtDesc *)epos->bh->b_data; |
1781 | aed->lengthAllocDescs = | 1706 | le32_add_cpu(&aed->lengthAllocDescs, adsize); |
1782 | cpu_to_le32(le32_to_cpu( | ||
1783 | aed->lengthAllocDescs) + adsize); | ||
1784 | } else { | 1707 | } else { |
1785 | iinfo->i_lenAlloc += adsize; | 1708 | iinfo->i_lenAlloc += adsize; |
1786 | mark_inode_dirty(inode); | 1709 | mark_inode_dirty(inode); |
@@ -1830,9 +1753,7 @@ int8_t udf_add_aext(struct inode *inode, struct extent_position *epos, | |||
1830 | mark_inode_dirty(inode); | 1753 | mark_inode_dirty(inode); |
1831 | } else { | 1754 | } else { |
1832 | aed = (struct allocExtDesc *)epos->bh->b_data; | 1755 | aed = (struct allocExtDesc *)epos->bh->b_data; |
1833 | aed->lengthAllocDescs = | 1756 | le32_add_cpu(&aed->lengthAllocDescs, adsize); |
1834 | cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + | ||
1835 | adsize); | ||
1836 | if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || | 1757 | if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || |
1837 | UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) | 1758 | UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) |
1838 | udf_update_tag(epos->bh->b_data, | 1759 | udf_update_tag(epos->bh->b_data, |
@@ -2046,9 +1967,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, | |||
2046 | mark_inode_dirty(inode); | 1967 | mark_inode_dirty(inode); |
2047 | } else { | 1968 | } else { |
2048 | aed = (struct allocExtDesc *)oepos.bh->b_data; | 1969 | aed = (struct allocExtDesc *)oepos.bh->b_data; |
2049 | aed->lengthAllocDescs = | 1970 | le32_add_cpu(&aed->lengthAllocDescs, -(2 * adsize)); |
2050 | cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - | ||
2051 | (2 * adsize)); | ||
2052 | if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || | 1971 | if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || |
2053 | UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) | 1972 | UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) |
2054 | udf_update_tag(oepos.bh->b_data, | 1973 | udf_update_tag(oepos.bh->b_data, |
@@ -2065,9 +1984,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos, | |||
2065 | mark_inode_dirty(inode); | 1984 | mark_inode_dirty(inode); |
2066 | } else { | 1985 | } else { |
2067 | aed = (struct allocExtDesc *)oepos.bh->b_data; | 1986 | aed = (struct allocExtDesc *)oepos.bh->b_data; |
2068 | aed->lengthAllocDescs = | 1987 | le32_add_cpu(&aed->lengthAllocDescs, -adsize); |
2069 | cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - | ||
2070 | adsize); | ||
2071 | if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || | 1988 | if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || |
2072 | UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) | 1989 | UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) |
2073 | udf_update_tag(oepos.bh->b_data, | 1990 | udf_update_tag(oepos.bh->b_data, |
@@ -2095,11 +2012,6 @@ int8_t inode_bmap(struct inode *inode, sector_t block, | |||
2095 | int8_t etype; | 2012 | int8_t etype; |
2096 | struct udf_inode_info *iinfo; | 2013 | struct udf_inode_info *iinfo; |
2097 | 2014 | ||
2098 | if (block < 0) { | ||
2099 | printk(KERN_ERR "udf: inode_bmap: block < 0\n"); | ||
2100 | return -1; | ||
2101 | } | ||
2102 | |||
2103 | iinfo = UDF_I(inode); | 2015 | iinfo = UDF_I(inode); |
2104 | pos->offset = 0; | 2016 | pos->offset = 0; |
2105 | pos->block = iinfo->i_location; | 2017 | pos->block = iinfo->i_location; |
diff --git a/fs/udf/lowlevel.c b/fs/udf/lowlevel.c index 579bae71e67e..703843f30ffd 100644 --- a/fs/udf/lowlevel.c +++ b/fs/udf/lowlevel.c | |||
@@ -23,7 +23,6 @@ | |||
23 | #include <linux/cdrom.h> | 23 | #include <linux/cdrom.h> |
24 | #include <asm/uaccess.h> | 24 | #include <asm/uaccess.h> |
25 | 25 | ||
26 | #include <linux/udf_fs.h> | ||
27 | #include "udf_sb.h" | 26 | #include "udf_sb.h" |
28 | 27 | ||
29 | unsigned int udf_get_last_session(struct super_block *sb) | 28 | unsigned int udf_get_last_session(struct super_block *sb) |
diff --git a/fs/udf/misc.c b/fs/udf/misc.c index a1d6da0caf71..84bf0fd4a4f1 100644 --- a/fs/udf/misc.c +++ b/fs/udf/misc.c | |||
@@ -23,8 +23,8 @@ | |||
23 | 23 | ||
24 | #include <linux/fs.h> | 24 | #include <linux/fs.h> |
25 | #include <linux/string.h> | 25 | #include <linux/string.h> |
26 | #include <linux/udf_fs.h> | ||
27 | #include <linux/buffer_head.h> | 26 | #include <linux/buffer_head.h> |
27 | #include <linux/crc-itu-t.h> | ||
28 | 28 | ||
29 | #include "udf_i.h" | 29 | #include "udf_i.h" |
30 | #include "udf_sb.h" | 30 | #include "udf_sb.h" |
@@ -136,8 +136,8 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size, | |||
136 | /* rewrite CRC + checksum of eahd */ | 136 | /* rewrite CRC + checksum of eahd */ |
137 | crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag); | 137 | crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag); |
138 | eahd->descTag.descCRCLength = cpu_to_le16(crclen); | 138 | eahd->descTag.descCRCLength = cpu_to_le16(crclen); |
139 | eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd + | 139 | eahd->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)eahd + |
140 | sizeof(tag), crclen, 0)); | 140 | sizeof(tag), crclen)); |
141 | eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag); | 141 | eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag); |
142 | iinfo->i_lenEAttr += size; | 142 | iinfo->i_lenEAttr += size; |
143 | return (struct genericFormat *)&ea[offset]; | 143 | return (struct genericFormat *)&ea[offset]; |
@@ -204,16 +204,15 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block, | |||
204 | { | 204 | { |
205 | tag *tag_p; | 205 | tag *tag_p; |
206 | struct buffer_head *bh = NULL; | 206 | struct buffer_head *bh = NULL; |
207 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
208 | 207 | ||
209 | /* Read the block */ | 208 | /* Read the block */ |
210 | if (block == 0xFFFFFFFF) | 209 | if (block == 0xFFFFFFFF) |
211 | return NULL; | 210 | return NULL; |
212 | 211 | ||
213 | bh = udf_tread(sb, block + sbi->s_session); | 212 | bh = udf_tread(sb, block); |
214 | if (!bh) { | 213 | if (!bh) { |
215 | udf_debug("block=%d, location=%d: read failed\n", | 214 | udf_debug("block=%d, location=%d: read failed\n", |
216 | block + sbi->s_session, location); | 215 | block, location); |
217 | return NULL; | 216 | return NULL; |
218 | } | 217 | } |
219 | 218 | ||
@@ -223,8 +222,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block, | |||
223 | 222 | ||
224 | if (location != le32_to_cpu(tag_p->tagLocation)) { | 223 | if (location != le32_to_cpu(tag_p->tagLocation)) { |
225 | udf_debug("location mismatch block %u, tag %u != %u\n", | 224 | udf_debug("location mismatch block %u, tag %u != %u\n", |
226 | block + sbi->s_session, | 225 | block, le32_to_cpu(tag_p->tagLocation), location); |
227 | le32_to_cpu(tag_p->tagLocation), location); | ||
228 | goto error_out; | 226 | goto error_out; |
229 | } | 227 | } |
230 | 228 | ||
@@ -244,13 +242,13 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block, | |||
244 | 242 | ||
245 | /* Verify the descriptor CRC */ | 243 | /* Verify the descriptor CRC */ |
246 | if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize || | 244 | if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize || |
247 | le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag), | 245 | le16_to_cpu(tag_p->descCRC) == crc_itu_t(0, |
248 | le16_to_cpu(tag_p->descCRCLength), 0)) | 246 | bh->b_data + sizeof(tag), |
247 | le16_to_cpu(tag_p->descCRCLength))) | ||
249 | return bh; | 248 | return bh; |
250 | 249 | ||
251 | udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", | 250 | udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", block, |
252 | block + sbi->s_session, le16_to_cpu(tag_p->descCRC), | 251 | le16_to_cpu(tag_p->descCRC), le16_to_cpu(tag_p->descCRCLength)); |
253 | le16_to_cpu(tag_p->descCRCLength)); | ||
254 | 252 | ||
255 | error_out: | 253 | error_out: |
256 | brelse(bh); | 254 | brelse(bh); |
@@ -270,7 +268,7 @@ void udf_update_tag(char *data, int length) | |||
270 | length -= sizeof(tag); | 268 | length -= sizeof(tag); |
271 | 269 | ||
272 | tptr->descCRCLength = cpu_to_le16(length); | 270 | tptr->descCRCLength = cpu_to_le16(length); |
273 | tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0)); | 271 | tptr->descCRC = cpu_to_le16(crc_itu_t(0, data + sizeof(tag), length)); |
274 | tptr->tagChecksum = udf_tag_checksum(tptr); | 272 | tptr->tagChecksum = udf_tag_checksum(tptr); |
275 | } | 273 | } |
276 | 274 | ||
diff --git a/fs/udf/namei.c b/fs/udf/namei.c index 112a5fb0b27b..ba5537d4bc15 100644 --- a/fs/udf/namei.c +++ b/fs/udf/namei.c | |||
@@ -31,6 +31,7 @@ | |||
31 | #include <linux/smp_lock.h> | 31 | #include <linux/smp_lock.h> |
32 | #include <linux/buffer_head.h> | 32 | #include <linux/buffer_head.h> |
33 | #include <linux/sched.h> | 33 | #include <linux/sched.h> |
34 | #include <linux/crc-itu-t.h> | ||
34 | 35 | ||
35 | static inline int udf_match(int len1, const char *name1, int len2, | 36 | static inline int udf_match(int len1, const char *name1, int len2, |
36 | const char *name2) | 37 | const char *name2) |
@@ -97,25 +98,23 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, | |||
97 | memset(fibh->ebh->b_data, 0x00, padlen + offset); | 98 | memset(fibh->ebh->b_data, 0x00, padlen + offset); |
98 | } | 99 | } |
99 | 100 | ||
100 | crc = udf_crc((uint8_t *)cfi + sizeof(tag), | 101 | crc = crc_itu_t(0, (uint8_t *)cfi + sizeof(tag), |
101 | sizeof(struct fileIdentDesc) - sizeof(tag), 0); | 102 | sizeof(struct fileIdentDesc) - sizeof(tag)); |
102 | 103 | ||
103 | if (fibh->sbh == fibh->ebh) { | 104 | if (fibh->sbh == fibh->ebh) { |
104 | crc = udf_crc((uint8_t *)sfi->impUse, | 105 | crc = crc_itu_t(crc, (uint8_t *)sfi->impUse, |
105 | crclen + sizeof(tag) - | 106 | crclen + sizeof(tag) - |
106 | sizeof(struct fileIdentDesc), crc); | 107 | sizeof(struct fileIdentDesc)); |
107 | } else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) { | 108 | } else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) { |
108 | crc = udf_crc(fibh->ebh->b_data + | 109 | crc = crc_itu_t(crc, fibh->ebh->b_data + |
109 | sizeof(struct fileIdentDesc) + | 110 | sizeof(struct fileIdentDesc) + |
110 | fibh->soffset, | 111 | fibh->soffset, |
111 | crclen + sizeof(tag) - | 112 | crclen + sizeof(tag) - |
112 | sizeof(struct fileIdentDesc), | 113 | sizeof(struct fileIdentDesc)); |
113 | crc); | ||
114 | } else { | 114 | } else { |
115 | crc = udf_crc((uint8_t *)sfi->impUse, | 115 | crc = crc_itu_t(crc, (uint8_t *)sfi->impUse, |
116 | -fibh->soffset - sizeof(struct fileIdentDesc), | 116 | -fibh->soffset - sizeof(struct fileIdentDesc)); |
117 | crc); | 117 | crc = crc_itu_t(crc, fibh->ebh->b_data, fibh->eoffset); |
118 | crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc); | ||
119 | } | 118 | } |
120 | 119 | ||
121 | cfi->descTag.descCRC = cpu_to_le16(crc); | 120 | cfi->descTag.descCRC = cpu_to_le16(crc); |
@@ -149,7 +148,7 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir, | |||
149 | struct fileIdentDesc *fi = NULL; | 148 | struct fileIdentDesc *fi = NULL; |
150 | loff_t f_pos; | 149 | loff_t f_pos; |
151 | int block, flen; | 150 | int block, flen; |
152 | char fname[UDF_NAME_LEN]; | 151 | char *fname = NULL; |
153 | char *nameptr; | 152 | char *nameptr; |
154 | uint8_t lfi; | 153 | uint8_t lfi; |
155 | uint16_t liu; | 154 | uint16_t liu; |
@@ -163,12 +162,12 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir, | |||
163 | size = udf_ext0_offset(dir) + dir->i_size; | 162 | size = udf_ext0_offset(dir) + dir->i_size; |
164 | f_pos = udf_ext0_offset(dir); | 163 | f_pos = udf_ext0_offset(dir); |
165 | 164 | ||
165 | fibh->sbh = fibh->ebh = NULL; | ||
166 | fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); | 166 | fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); |
167 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) | 167 | if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
168 | fibh->sbh = fibh->ebh = NULL; | 168 | if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos, |
169 | else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, | 169 | &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) |
170 | &epos, &eloc, &elen, &offset) == | 170 | goto out_err; |
171 | (EXT_RECORDED_ALLOCATED >> 30)) { | ||
172 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); | 171 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); |
173 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { | 172 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { |
174 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) | 173 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
@@ -179,25 +178,19 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir, | |||
179 | offset = 0; | 178 | offset = 0; |
180 | 179 | ||
181 | fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); | 180 | fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); |
182 | if (!fibh->sbh) { | 181 | if (!fibh->sbh) |
183 | brelse(epos.bh); | 182 | goto out_err; |
184 | return NULL; | ||
185 | } | ||
186 | } else { | ||
187 | brelse(epos.bh); | ||
188 | return NULL; | ||
189 | } | 183 | } |
190 | 184 | ||
185 | fname = kmalloc(UDF_NAME_LEN, GFP_NOFS); | ||
186 | if (!fname) | ||
187 | goto out_err; | ||
188 | |||
191 | while (f_pos < size) { | 189 | while (f_pos < size) { |
192 | fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, | 190 | fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, |
193 | &elen, &offset); | 191 | &elen, &offset); |
194 | if (!fi) { | 192 | if (!fi) |
195 | if (fibh->sbh != fibh->ebh) | 193 | goto out_err; |
196 | brelse(fibh->ebh); | ||
197 | brelse(fibh->sbh); | ||
198 | brelse(epos.bh); | ||
199 | return NULL; | ||
200 | } | ||
201 | 194 | ||
202 | liu = le16_to_cpu(cfi->lengthOfImpUse); | 195 | liu = le16_to_cpu(cfi->lengthOfImpUse); |
203 | lfi = cfi->lengthFileIdent; | 196 | lfi = cfi->lengthFileIdent; |
@@ -237,53 +230,22 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir, | |||
237 | 230 | ||
238 | flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi); | 231 | flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi); |
239 | if (flen && udf_match(flen, fname, dentry->d_name.len, | 232 | if (flen && udf_match(flen, fname, dentry->d_name.len, |
240 | dentry->d_name.name)) { | 233 | dentry->d_name.name)) |
241 | brelse(epos.bh); | 234 | goto out_ok; |
242 | return fi; | ||
243 | } | ||
244 | } | 235 | } |
245 | 236 | ||
237 | out_err: | ||
238 | fi = NULL; | ||
246 | if (fibh->sbh != fibh->ebh) | 239 | if (fibh->sbh != fibh->ebh) |
247 | brelse(fibh->ebh); | 240 | brelse(fibh->ebh); |
248 | brelse(fibh->sbh); | 241 | brelse(fibh->sbh); |
242 | out_ok: | ||
249 | brelse(epos.bh); | 243 | brelse(epos.bh); |
244 | kfree(fname); | ||
250 | 245 | ||
251 | return NULL; | 246 | return fi; |
252 | } | 247 | } |
253 | 248 | ||
254 | /* | ||
255 | * udf_lookup | ||
256 | * | ||
257 | * PURPOSE | ||
258 | * Look-up the inode for a given name. | ||
259 | * | ||
260 | * DESCRIPTION | ||
261 | * Required - lookup_dentry() will return -ENOTDIR if this routine is not | ||
262 | * available for a directory. The filesystem is useless if this routine is | ||
263 | * not available for at least the filesystem's root directory. | ||
264 | * | ||
265 | * This routine is passed an incomplete dentry - it must be completed by | ||
266 | * calling d_add(dentry, inode). If the name does not exist, then the | ||
267 | * specified inode must be set to null. An error should only be returned | ||
268 | * when the lookup fails for a reason other than the name not existing. | ||
269 | * Note that the directory inode semaphore is held during the call. | ||
270 | * | ||
271 | * Refer to lookup_dentry() in fs/namei.c | ||
272 | * lookup_dentry() -> lookup() -> real_lookup() -> . | ||
273 | * | ||
274 | * PRE-CONDITIONS | ||
275 | * dir Pointer to inode of parent directory. | ||
276 | * dentry Pointer to dentry to complete. | ||
277 | * nd Pointer to lookup nameidata | ||
278 | * | ||
279 | * POST-CONDITIONS | ||
280 | * <return> Zero on success. | ||
281 | * | ||
282 | * HISTORY | ||
283 | * July 1, 1997 - Andrew E. Mileski | ||
284 | * Written, tested, and released. | ||
285 | */ | ||
286 | |||
287 | static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, | 249 | static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, |
288 | struct nameidata *nd) | 250 | struct nameidata *nd) |
289 | { | 251 | { |
@@ -336,11 +298,9 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, | |||
336 | { | 298 | { |
337 | struct super_block *sb = dir->i_sb; | 299 | struct super_block *sb = dir->i_sb; |
338 | struct fileIdentDesc *fi = NULL; | 300 | struct fileIdentDesc *fi = NULL; |
339 | char name[UDF_NAME_LEN], fname[UDF_NAME_LEN]; | 301 | char *name = NULL; |
340 | int namelen; | 302 | int namelen; |
341 | loff_t f_pos; | 303 | loff_t f_pos; |
342 | int flen; | ||
343 | char *nameptr; | ||
344 | loff_t size = udf_ext0_offset(dir) + dir->i_size; | 304 | loff_t size = udf_ext0_offset(dir) + dir->i_size; |
345 | int nfidlen; | 305 | int nfidlen; |
346 | uint8_t lfi; | 306 | uint8_t lfi; |
@@ -352,16 +312,23 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, | |||
352 | struct extent_position epos = {}; | 312 | struct extent_position epos = {}; |
353 | struct udf_inode_info *dinfo; | 313 | struct udf_inode_info *dinfo; |
354 | 314 | ||
315 | fibh->sbh = fibh->ebh = NULL; | ||
316 | name = kmalloc(UDF_NAME_LEN, GFP_NOFS); | ||
317 | if (!name) { | ||
318 | *err = -ENOMEM; | ||
319 | goto out_err; | ||
320 | } | ||
321 | |||
355 | if (dentry) { | 322 | if (dentry) { |
356 | if (!dentry->d_name.len) { | 323 | if (!dentry->d_name.len) { |
357 | *err = -EINVAL; | 324 | *err = -EINVAL; |
358 | return NULL; | 325 | goto out_err; |
359 | } | 326 | } |
360 | namelen = udf_put_filename(sb, dentry->d_name.name, name, | 327 | namelen = udf_put_filename(sb, dentry->d_name.name, name, |
361 | dentry->d_name.len); | 328 | dentry->d_name.len); |
362 | if (!namelen) { | 329 | if (!namelen) { |
363 | *err = -ENAMETOOLONG; | 330 | *err = -ENAMETOOLONG; |
364 | return NULL; | 331 | goto out_err; |
365 | } | 332 | } |
366 | } else { | 333 | } else { |
367 | namelen = 0; | 334 | namelen = 0; |
@@ -373,11 +340,14 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, | |||
373 | 340 | ||
374 | fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); | 341 | fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); |
375 | dinfo = UDF_I(dir); | 342 | dinfo = UDF_I(dir); |
376 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) | 343 | if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
377 | fibh->sbh = fibh->ebh = NULL; | 344 | if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos, |
378 | else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, | 345 | &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) { |
379 | &epos, &eloc, &elen, &offset) == | 346 | block = udf_get_lb_pblock(dir->i_sb, |
380 | (EXT_RECORDED_ALLOCATED >> 30)) { | 347 | dinfo->i_location, 0); |
348 | fibh->soffset = fibh->eoffset = sb->s_blocksize; | ||
349 | goto add; | ||
350 | } | ||
381 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); | 351 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); |
382 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { | 352 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { |
383 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) | 353 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
@@ -389,17 +359,11 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, | |||
389 | 359 | ||
390 | fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); | 360 | fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); |
391 | if (!fibh->sbh) { | 361 | if (!fibh->sbh) { |
392 | brelse(epos.bh); | ||
393 | *err = -EIO; | 362 | *err = -EIO; |
394 | return NULL; | 363 | goto out_err; |
395 | } | 364 | } |
396 | 365 | ||
397 | block = dinfo->i_location.logicalBlockNum; | 366 | block = dinfo->i_location.logicalBlockNum; |
398 | } else { | ||
399 | block = udf_get_lb_pblock(dir->i_sb, dinfo->i_location, 0); | ||
400 | fibh->sbh = fibh->ebh = NULL; | ||
401 | fibh->soffset = fibh->eoffset = sb->s_blocksize; | ||
402 | goto add; | ||
403 | } | 367 | } |
404 | 368 | ||
405 | while (f_pos < size) { | 369 | while (f_pos < size) { |
@@ -407,41 +371,16 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, | |||
407 | &elen, &offset); | 371 | &elen, &offset); |
408 | 372 | ||
409 | if (!fi) { | 373 | if (!fi) { |
410 | if (fibh->sbh != fibh->ebh) | ||
411 | brelse(fibh->ebh); | ||
412 | brelse(fibh->sbh); | ||
413 | brelse(epos.bh); | ||
414 | *err = -EIO; | 374 | *err = -EIO; |
415 | return NULL; | 375 | goto out_err; |
416 | } | 376 | } |
417 | 377 | ||
418 | liu = le16_to_cpu(cfi->lengthOfImpUse); | 378 | liu = le16_to_cpu(cfi->lengthOfImpUse); |
419 | lfi = cfi->lengthFileIdent; | 379 | lfi = cfi->lengthFileIdent; |
420 | 380 | ||
421 | if (fibh->sbh == fibh->ebh) | ||
422 | nameptr = fi->fileIdent + liu; | ||
423 | else { | ||
424 | int poffset; /* Unpaded ending offset */ | ||
425 | |||
426 | poffset = fibh->soffset + sizeof(struct fileIdentDesc) + | ||
427 | liu + lfi; | ||
428 | |||
429 | if (poffset >= lfi) | ||
430 | nameptr = (char *)(fibh->ebh->b_data + | ||
431 | poffset - lfi); | ||
432 | else { | ||
433 | nameptr = fname; | ||
434 | memcpy(nameptr, fi->fileIdent + liu, | ||
435 | lfi - poffset); | ||
436 | memcpy(nameptr + lfi - poffset, | ||
437 | fibh->ebh->b_data, poffset); | ||
438 | } | ||
439 | } | ||
440 | |||
441 | if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { | 381 | if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { |
442 | if (((sizeof(struct fileIdentDesc) + | 382 | if (((sizeof(struct fileIdentDesc) + |
443 | liu + lfi + 3) & ~3) == nfidlen) { | 383 | liu + lfi + 3) & ~3) == nfidlen) { |
444 | brelse(epos.bh); | ||
445 | cfi->descTag.tagSerialNum = cpu_to_le16(1); | 384 | cfi->descTag.tagSerialNum = cpu_to_le16(1); |
446 | cfi->fileVersionNum = cpu_to_le16(1); | 385 | cfi->fileVersionNum = cpu_to_le16(1); |
447 | cfi->fileCharacteristics = 0; | 386 | cfi->fileCharacteristics = 0; |
@@ -449,27 +388,13 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir, | |||
449 | cfi->lengthOfImpUse = cpu_to_le16(0); | 388 | cfi->lengthOfImpUse = cpu_to_le16(0); |
450 | if (!udf_write_fi(dir, cfi, fi, fibh, NULL, | 389 | if (!udf_write_fi(dir, cfi, fi, fibh, NULL, |
451 | name)) | 390 | name)) |
452 | return fi; | 391 | goto out_ok; |
453 | else { | 392 | else { |
454 | *err = -EIO; | 393 | *err = -EIO; |
455 | return NULL; | 394 | goto out_err; |
456 | } | 395 | } |
457 | } | 396 | } |
458 | } | 397 | } |
459 | |||
460 | if (!lfi || !dentry) | ||
461 | continue; | ||
462 | |||
463 | flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi); | ||
464 | if (flen && udf_match(flen, fname, dentry->d_name.len, | ||
465 | dentry->d_name.name)) { | ||
466 | if (fibh->sbh != fibh->ebh) | ||
467 | brelse(fibh->ebh); | ||
468 | brelse(fibh->sbh); | ||
469 | brelse(epos.bh); | ||
470 | *err = -EEXIST; | ||
471 | return NULL; | ||
472 | } | ||
473 | } | 398 | } |
474 | 399 | ||
475 | add: | 400 | add: |
@@ -496,7 +421,7 @@ add: | |||
496 | fibh->sbh = fibh->ebh = | 421 | fibh->sbh = fibh->ebh = |
497 | udf_expand_dir_adinicb(dir, &block, err); | 422 | udf_expand_dir_adinicb(dir, &block, err); |
498 | if (!fibh->sbh) | 423 | if (!fibh->sbh) |
499 | return NULL; | 424 | goto out_err; |
500 | epos.block = dinfo->i_location; | 425 | epos.block = dinfo->i_location; |
501 | epos.offset = udf_file_entry_alloc_offset(dir); | 426 | epos.offset = udf_file_entry_alloc_offset(dir); |
502 | /* Load extent udf_expand_dir_adinicb() has created */ | 427 | /* Load extent udf_expand_dir_adinicb() has created */ |
@@ -537,11 +462,8 @@ add: | |||
537 | dir->i_sb->s_blocksize_bits); | 462 | dir->i_sb->s_blocksize_bits); |
538 | fibh->ebh = udf_bread(dir, | 463 | fibh->ebh = udf_bread(dir, |
539 | f_pos >> dir->i_sb->s_blocksize_bits, 1, err); | 464 | f_pos >> dir->i_sb->s_blocksize_bits, 1, err); |
540 | if (!fibh->ebh) { | 465 | if (!fibh->ebh) |
541 | brelse(epos.bh); | 466 | goto out_err; |
542 | brelse(fibh->sbh); | ||
543 | return NULL; | ||
544 | } | ||
545 | 467 | ||
546 | if (!fibh->soffset) { | 468 | if (!fibh->soffset) { |
547 | if (udf_next_aext(dir, &epos, &eloc, &elen, 1) == | 469 | if (udf_next_aext(dir, &epos, &eloc, &elen, 1) == |
@@ -572,20 +494,25 @@ add: | |||
572 | cfi->lengthFileIdent = namelen; | 494 | cfi->lengthFileIdent = namelen; |
573 | cfi->lengthOfImpUse = cpu_to_le16(0); | 495 | cfi->lengthOfImpUse = cpu_to_le16(0); |
574 | if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) { | 496 | if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) { |
575 | brelse(epos.bh); | ||
576 | dir->i_size += nfidlen; | 497 | dir->i_size += nfidlen; |
577 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) | 498 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
578 | dinfo->i_lenAlloc += nfidlen; | 499 | dinfo->i_lenAlloc += nfidlen; |
579 | mark_inode_dirty(dir); | 500 | mark_inode_dirty(dir); |
580 | return fi; | 501 | goto out_ok; |
581 | } else { | 502 | } else { |
582 | brelse(epos.bh); | ||
583 | if (fibh->sbh != fibh->ebh) | ||
584 | brelse(fibh->ebh); | ||
585 | brelse(fibh->sbh); | ||
586 | *err = -EIO; | 503 | *err = -EIO; |
587 | return NULL; | 504 | goto out_err; |
588 | } | 505 | } |
506 | |||
507 | out_err: | ||
508 | fi = NULL; | ||
509 | if (fibh->sbh != fibh->ebh) | ||
510 | brelse(fibh->ebh); | ||
511 | brelse(fibh->sbh); | ||
512 | out_ok: | ||
513 | brelse(epos.bh); | ||
514 | kfree(name); | ||
515 | return fi; | ||
589 | } | 516 | } |
590 | 517 | ||
591 | static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, | 518 | static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, |
@@ -940,7 +867,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, | |||
940 | char *ea; | 867 | char *ea; |
941 | int err; | 868 | int err; |
942 | int block; | 869 | int block; |
943 | char name[UDF_NAME_LEN]; | 870 | char *name = NULL; |
944 | int namelen; | 871 | int namelen; |
945 | struct buffer_head *bh; | 872 | struct buffer_head *bh; |
946 | struct udf_inode_info *iinfo; | 873 | struct udf_inode_info *iinfo; |
@@ -950,6 +877,12 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, | |||
950 | if (!inode) | 877 | if (!inode) |
951 | goto out; | 878 | goto out; |
952 | 879 | ||
880 | name = kmalloc(UDF_NAME_LEN, GFP_NOFS); | ||
881 | if (!name) { | ||
882 | err = -ENOMEM; | ||
883 | goto out_no_entry; | ||
884 | } | ||
885 | |||
953 | iinfo = UDF_I(inode); | 886 | iinfo = UDF_I(inode); |
954 | inode->i_mode = S_IFLNK | S_IRWXUGO; | 887 | inode->i_mode = S_IFLNK | S_IRWXUGO; |
955 | inode->i_data.a_ops = &udf_symlink_aops; | 888 | inode->i_data.a_ops = &udf_symlink_aops; |
@@ -1089,6 +1022,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, | |||
1089 | err = 0; | 1022 | err = 0; |
1090 | 1023 | ||
1091 | out: | 1024 | out: |
1025 | kfree(name); | ||
1092 | unlock_kernel(); | 1026 | unlock_kernel(); |
1093 | return err; | 1027 | return err; |
1094 | 1028 | ||
diff --git a/fs/udf/partition.c b/fs/udf/partition.c index fc533345ab89..63610f026ae1 100644 --- a/fs/udf/partition.c +++ b/fs/udf/partition.c | |||
@@ -24,7 +24,6 @@ | |||
24 | 24 | ||
25 | #include <linux/fs.h> | 25 | #include <linux/fs.h> |
26 | #include <linux/string.h> | 26 | #include <linux/string.h> |
27 | #include <linux/udf_fs.h> | ||
28 | #include <linux/slab.h> | 27 | #include <linux/slab.h> |
29 | #include <linux/buffer_head.h> | 28 | #include <linux/buffer_head.h> |
30 | 29 | ||
@@ -55,11 +54,10 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, | |||
55 | struct udf_sb_info *sbi = UDF_SB(sb); | 54 | struct udf_sb_info *sbi = UDF_SB(sb); |
56 | struct udf_part_map *map; | 55 | struct udf_part_map *map; |
57 | struct udf_virtual_data *vdata; | 56 | struct udf_virtual_data *vdata; |
58 | struct udf_inode_info *iinfo; | 57 | struct udf_inode_info *iinfo = UDF_I(sbi->s_vat_inode); |
59 | 58 | ||
60 | map = &sbi->s_partmaps[partition]; | 59 | map = &sbi->s_partmaps[partition]; |
61 | vdata = &map->s_type_specific.s_virtual; | 60 | vdata = &map->s_type_specific.s_virtual; |
62 | index = (sb->s_blocksize - vdata->s_start_offset) / sizeof(uint32_t); | ||
63 | 61 | ||
64 | if (block > vdata->s_num_entries) { | 62 | if (block > vdata->s_num_entries) { |
65 | udf_debug("Trying to access block beyond end of VAT " | 63 | udf_debug("Trying to access block beyond end of VAT " |
@@ -67,6 +65,12 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, | |||
67 | return 0xFFFFFFFF; | 65 | return 0xFFFFFFFF; |
68 | } | 66 | } |
69 | 67 | ||
68 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { | ||
69 | loc = le32_to_cpu(((__le32 *)(iinfo->i_ext.i_data + | ||
70 | vdata->s_start_offset))[block]); | ||
71 | goto translate; | ||
72 | } | ||
73 | index = (sb->s_blocksize - vdata->s_start_offset) / sizeof(uint32_t); | ||
70 | if (block >= index) { | 74 | if (block >= index) { |
71 | block -= index; | 75 | block -= index; |
72 | newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t))); | 76 | newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t))); |
@@ -89,7 +93,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, | |||
89 | 93 | ||
90 | brelse(bh); | 94 | brelse(bh); |
91 | 95 | ||
92 | iinfo = UDF_I(sbi->s_vat_inode); | 96 | translate: |
93 | if (iinfo->i_location.partitionReferenceNum == partition) { | 97 | if (iinfo->i_location.partitionReferenceNum == partition) { |
94 | udf_debug("recursive call to udf_get_pblock!\n"); | 98 | udf_debug("recursive call to udf_get_pblock!\n"); |
95 | return 0xFFFFFFFF; | 99 | return 0xFFFFFFFF; |
@@ -263,3 +267,58 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block) | |||
263 | 267 | ||
264 | return 0; | 268 | return 0; |
265 | } | 269 | } |
270 | |||
271 | static uint32_t udf_try_read_meta(struct inode *inode, uint32_t block, | ||
272 | uint16_t partition, uint32_t offset) | ||
273 | { | ||
274 | struct super_block *sb = inode->i_sb; | ||
275 | struct udf_part_map *map; | ||
276 | kernel_lb_addr eloc; | ||
277 | uint32_t elen; | ||
278 | sector_t ext_offset; | ||
279 | struct extent_position epos = {}; | ||
280 | uint32_t phyblock; | ||
281 | |||
282 | if (inode_bmap(inode, block, &epos, &eloc, &elen, &ext_offset) != | ||
283 | (EXT_RECORDED_ALLOCATED >> 30)) | ||
284 | phyblock = 0xFFFFFFFF; | ||
285 | else { | ||
286 | map = &UDF_SB(sb)->s_partmaps[partition]; | ||
287 | /* map to sparable/physical partition desc */ | ||
288 | phyblock = udf_get_pblock(sb, eloc.logicalBlockNum, | ||
289 | map->s_partition_num, ext_offset + offset); | ||
290 | } | ||
291 | |||
292 | brelse(epos.bh); | ||
293 | return phyblock; | ||
294 | } | ||
295 | |||
296 | uint32_t udf_get_pblock_meta25(struct super_block *sb, uint32_t block, | ||
297 | uint16_t partition, uint32_t offset) | ||
298 | { | ||
299 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
300 | struct udf_part_map *map; | ||
301 | struct udf_meta_data *mdata; | ||
302 | uint32_t retblk; | ||
303 | struct inode *inode; | ||
304 | |||
305 | udf_debug("READING from METADATA\n"); | ||
306 | |||
307 | map = &sbi->s_partmaps[partition]; | ||
308 | mdata = &map->s_type_specific.s_metadata; | ||
309 | inode = mdata->s_metadata_fe ? : mdata->s_mirror_fe; | ||
310 | |||
311 | /* We shouldn't mount such media... */ | ||
312 | BUG_ON(!inode); | ||
313 | retblk = udf_try_read_meta(inode, block, partition, offset); | ||
314 | if (retblk == 0xFFFFFFFF) { | ||
315 | udf_warning(sb, __func__, "error reading from METADATA, " | ||
316 | "trying to read from MIRROR"); | ||
317 | inode = mdata->s_mirror_fe; | ||
318 | if (!inode) | ||
319 | return 0xFFFFFFFF; | ||
320 | retblk = udf_try_read_meta(inode, block, partition, offset); | ||
321 | } | ||
322 | |||
323 | return retblk; | ||
324 | } | ||
diff --git a/fs/udf/super.c b/fs/udf/super.c index f3ac4abfc946..b564fc140fe4 100644 --- a/fs/udf/super.c +++ b/fs/udf/super.c | |||
@@ -55,9 +55,10 @@ | |||
55 | #include <linux/errno.h> | 55 | #include <linux/errno.h> |
56 | #include <linux/mount.h> | 56 | #include <linux/mount.h> |
57 | #include <linux/seq_file.h> | 57 | #include <linux/seq_file.h> |
58 | #include <linux/bitmap.h> | ||
59 | #include <linux/crc-itu-t.h> | ||
58 | #include <asm/byteorder.h> | 60 | #include <asm/byteorder.h> |
59 | 61 | ||
60 | #include <linux/udf_fs.h> | ||
61 | #include "udf_sb.h" | 62 | #include "udf_sb.h" |
62 | #include "udf_i.h" | 63 | #include "udf_i.h" |
63 | 64 | ||
@@ -84,22 +85,19 @@ static void udf_write_super(struct super_block *); | |||
84 | static int udf_remount_fs(struct super_block *, int *, char *); | 85 | static int udf_remount_fs(struct super_block *, int *, char *); |
85 | static int udf_check_valid(struct super_block *, int, int); | 86 | static int udf_check_valid(struct super_block *, int, int); |
86 | static int udf_vrs(struct super_block *sb, int silent); | 87 | static int udf_vrs(struct super_block *sb, int silent); |
87 | static int udf_load_partition(struct super_block *, kernel_lb_addr *); | ||
88 | static int udf_load_logicalvol(struct super_block *, struct buffer_head *, | ||
89 | kernel_lb_addr *); | ||
90 | static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad); | 88 | static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad); |
91 | static void udf_find_anchor(struct super_block *); | 89 | static void udf_find_anchor(struct super_block *); |
92 | static int udf_find_fileset(struct super_block *, kernel_lb_addr *, | 90 | static int udf_find_fileset(struct super_block *, kernel_lb_addr *, |
93 | kernel_lb_addr *); | 91 | kernel_lb_addr *); |
94 | static void udf_load_pvoldesc(struct super_block *, struct buffer_head *); | ||
95 | static void udf_load_fileset(struct super_block *, struct buffer_head *, | 92 | static void udf_load_fileset(struct super_block *, struct buffer_head *, |
96 | kernel_lb_addr *); | 93 | kernel_lb_addr *); |
97 | static int udf_load_partdesc(struct super_block *, struct buffer_head *); | ||
98 | static void udf_open_lvid(struct super_block *); | 94 | static void udf_open_lvid(struct super_block *); |
99 | static void udf_close_lvid(struct super_block *); | 95 | static void udf_close_lvid(struct super_block *); |
100 | static unsigned int udf_count_free(struct super_block *); | 96 | static unsigned int udf_count_free(struct super_block *); |
101 | static int udf_statfs(struct dentry *, struct kstatfs *); | 97 | static int udf_statfs(struct dentry *, struct kstatfs *); |
102 | static int udf_show_options(struct seq_file *, struct vfsmount *); | 98 | static int udf_show_options(struct seq_file *, struct vfsmount *); |
99 | static void udf_error(struct super_block *sb, const char *function, | ||
100 | const char *fmt, ...); | ||
103 | 101 | ||
104 | struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi) | 102 | struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi) |
105 | { | 103 | { |
@@ -587,48 +585,10 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options) | |||
587 | return 0; | 585 | return 0; |
588 | } | 586 | } |
589 | 587 | ||
590 | /* | ||
591 | * udf_set_blocksize | ||
592 | * | ||
593 | * PURPOSE | ||
594 | * Set the block size to be used in all transfers. | ||
595 | * | ||
596 | * DESCRIPTION | ||
597 | * To allow room for a DMA transfer, it is best to guess big when unsure. | ||
598 | * This routine picks 2048 bytes as the blocksize when guessing. This | ||
599 | * should be adequate until devices with larger block sizes become common. | ||
600 | * | ||
601 | * Note that the Linux kernel can currently only deal with blocksizes of | ||
602 | * 512, 1024, 2048, 4096, and 8192 bytes. | ||
603 | * | ||
604 | * PRE-CONDITIONS | ||
605 | * sb Pointer to _locked_ superblock. | ||
606 | * | ||
607 | * POST-CONDITIONS | ||
608 | * sb->s_blocksize Blocksize. | ||
609 | * sb->s_blocksize_bits log2 of blocksize. | ||
610 | * <return> 0 Blocksize is valid. | ||
611 | * <return> 1 Blocksize is invalid. | ||
612 | * | ||
613 | * HISTORY | ||
614 | * July 1, 1997 - Andrew E. Mileski | ||
615 | * Written, tested, and released. | ||
616 | */ | ||
617 | static int udf_set_blocksize(struct super_block *sb, int bsize) | ||
618 | { | ||
619 | if (!sb_min_blocksize(sb, bsize)) { | ||
620 | udf_debug("Bad block size (%d)\n", bsize); | ||
621 | printk(KERN_ERR "udf: bad block size (%d)\n", bsize); | ||
622 | return 0; | ||
623 | } | ||
624 | |||
625 | return sb->s_blocksize; | ||
626 | } | ||
627 | |||
628 | static int udf_vrs(struct super_block *sb, int silent) | 588 | static int udf_vrs(struct super_block *sb, int silent) |
629 | { | 589 | { |
630 | struct volStructDesc *vsd = NULL; | 590 | struct volStructDesc *vsd = NULL; |
631 | int sector = 32768; | 591 | loff_t sector = 32768; |
632 | int sectorsize; | 592 | int sectorsize; |
633 | struct buffer_head *bh = NULL; | 593 | struct buffer_head *bh = NULL; |
634 | int iso9660 = 0; | 594 | int iso9660 = 0; |
@@ -649,7 +609,8 @@ static int udf_vrs(struct super_block *sb, int silent) | |||
649 | sector += (sbi->s_session << sb->s_blocksize_bits); | 609 | sector += (sbi->s_session << sb->s_blocksize_bits); |
650 | 610 | ||
651 | udf_debug("Starting at sector %u (%ld byte sectors)\n", | 611 | udf_debug("Starting at sector %u (%ld byte sectors)\n", |
652 | (sector >> sb->s_blocksize_bits), sb->s_blocksize); | 612 | (unsigned int)(sector >> sb->s_blocksize_bits), |
613 | sb->s_blocksize); | ||
653 | /* Process the sequence (if applicable) */ | 614 | /* Process the sequence (if applicable) */ |
654 | for (; !nsr02 && !nsr03; sector += sectorsize) { | 615 | for (; !nsr02 && !nsr03; sector += sectorsize) { |
655 | /* Read a block */ | 616 | /* Read a block */ |
@@ -719,162 +680,140 @@ static int udf_vrs(struct super_block *sb, int silent) | |||
719 | } | 680 | } |
720 | 681 | ||
721 | /* | 682 | /* |
722 | * udf_find_anchor | 683 | * Check whether there is an anchor block in the given block |
723 | * | ||
724 | * PURPOSE | ||
725 | * Find an anchor volume descriptor. | ||
726 | * | ||
727 | * PRE-CONDITIONS | ||
728 | * sb Pointer to _locked_ superblock. | ||
729 | * lastblock Last block on media. | ||
730 | * | ||
731 | * POST-CONDITIONS | ||
732 | * <return> 1 if not found, 0 if ok | ||
733 | * | ||
734 | * HISTORY | ||
735 | * July 1, 1997 - Andrew E. Mileski | ||
736 | * Written, tested, and released. | ||
737 | */ | 684 | */ |
738 | static void udf_find_anchor(struct super_block *sb) | 685 | static int udf_check_anchor_block(struct super_block *sb, sector_t block, |
686 | bool varconv) | ||
739 | { | 687 | { |
740 | int lastblock; | ||
741 | struct buffer_head *bh = NULL; | 688 | struct buffer_head *bh = NULL; |
689 | tag *t; | ||
742 | uint16_t ident; | 690 | uint16_t ident; |
743 | uint32_t location; | 691 | uint32_t location; |
744 | int i; | ||
745 | struct udf_sb_info *sbi; | ||
746 | 692 | ||
747 | sbi = UDF_SB(sb); | 693 | if (varconv) { |
748 | lastblock = sbi->s_last_block; | 694 | if (udf_fixed_to_variable(block) >= |
695 | sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits) | ||
696 | return 0; | ||
697 | bh = sb_bread(sb, udf_fixed_to_variable(block)); | ||
698 | } | ||
699 | else | ||
700 | bh = sb_bread(sb, block); | ||
749 | 701 | ||
750 | if (lastblock) { | 702 | if (!bh) |
751 | int varlastblock = udf_variable_to_fixed(lastblock); | 703 | return 0; |
752 | int last[] = { lastblock, lastblock - 2, | ||
753 | lastblock - 150, lastblock - 152, | ||
754 | varlastblock, varlastblock - 2, | ||
755 | varlastblock - 150, varlastblock - 152 }; | ||
756 | |||
757 | lastblock = 0; | ||
758 | |||
759 | /* Search for an anchor volume descriptor pointer */ | ||
760 | |||
761 | /* according to spec, anchor is in either: | ||
762 | * block 256 | ||
763 | * lastblock-256 | ||
764 | * lastblock | ||
765 | * however, if the disc isn't closed, it could be 512 */ | ||
766 | |||
767 | for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) { | ||
768 | ident = location = 0; | ||
769 | if (last[i] >= 0) { | ||
770 | bh = sb_bread(sb, last[i]); | ||
771 | if (bh) { | ||
772 | tag *t = (tag *)bh->b_data; | ||
773 | ident = le16_to_cpu(t->tagIdent); | ||
774 | location = le32_to_cpu(t->tagLocation); | ||
775 | brelse(bh); | ||
776 | } | ||
777 | } | ||
778 | 704 | ||
779 | if (ident == TAG_IDENT_AVDP) { | 705 | t = (tag *)bh->b_data; |
780 | if (location == last[i] - sbi->s_session) { | 706 | ident = le16_to_cpu(t->tagIdent); |
781 | lastblock = last[i] - sbi->s_session; | 707 | location = le32_to_cpu(t->tagLocation); |
782 | sbi->s_anchor[0] = lastblock; | 708 | brelse(bh); |
783 | sbi->s_anchor[1] = lastblock - 256; | 709 | if (ident != TAG_IDENT_AVDP) |
784 | } else if (location == | 710 | return 0; |
785 | udf_variable_to_fixed(last[i]) - | 711 | return location == block; |
786 | sbi->s_session) { | 712 | } |
787 | UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); | ||
788 | lastblock = | ||
789 | udf_variable_to_fixed(last[i]) - | ||
790 | sbi->s_session; | ||
791 | sbi->s_anchor[0] = lastblock; | ||
792 | sbi->s_anchor[1] = lastblock - 256 - | ||
793 | sbi->s_session; | ||
794 | } else { | ||
795 | udf_debug("Anchor found at block %d, " | ||
796 | "location mismatch %d.\n", | ||
797 | last[i], location); | ||
798 | } | ||
799 | } else if (ident == TAG_IDENT_FE || | ||
800 | ident == TAG_IDENT_EFE) { | ||
801 | lastblock = last[i]; | ||
802 | sbi->s_anchor[3] = 512; | ||
803 | } else { | ||
804 | ident = location = 0; | ||
805 | if (last[i] >= 256) { | ||
806 | bh = sb_bread(sb, last[i] - 256); | ||
807 | if (bh) { | ||
808 | tag *t = (tag *)bh->b_data; | ||
809 | ident = le16_to_cpu( | ||
810 | t->tagIdent); | ||
811 | location = le32_to_cpu( | ||
812 | t->tagLocation); | ||
813 | brelse(bh); | ||
814 | } | ||
815 | } | ||
816 | 713 | ||
817 | if (ident == TAG_IDENT_AVDP && | 714 | /* Search for an anchor volume descriptor pointer */ |
818 | location == last[i] - 256 - | 715 | static sector_t udf_scan_anchors(struct super_block *sb, bool varconv, |
819 | sbi->s_session) { | 716 | sector_t lastblock) |
820 | lastblock = last[i]; | 717 | { |
821 | sbi->s_anchor[1] = last[i] - 256; | 718 | sector_t last[6]; |
822 | } else { | 719 | int i; |
823 | ident = location = 0; | 720 | struct udf_sb_info *sbi = UDF_SB(sb); |
824 | if (last[i] >= 312 + sbi->s_session) { | ||
825 | bh = sb_bread(sb, | ||
826 | last[i] - 312 - | ||
827 | sbi->s_session); | ||
828 | if (bh) { | ||
829 | tag *t = (tag *) | ||
830 | bh->b_data; | ||
831 | ident = le16_to_cpu( | ||
832 | t->tagIdent); | ||
833 | location = le32_to_cpu( | ||
834 | t->tagLocation); | ||
835 | brelse(bh); | ||
836 | } | ||
837 | } | ||
838 | 721 | ||
839 | if (ident == TAG_IDENT_AVDP && | 722 | last[0] = lastblock; |
840 | location == udf_variable_to_fixed(last[i]) - 256) { | 723 | last[1] = last[0] - 1; |
841 | UDF_SET_FLAG(sb, | 724 | last[2] = last[0] + 1; |
842 | UDF_FLAG_VARCONV); | 725 | last[3] = last[0] - 2; |
843 | lastblock = udf_variable_to_fixed(last[i]); | 726 | last[4] = last[0] - 150; |
844 | sbi->s_anchor[1] = lastblock - 256; | 727 | last[5] = last[0] - 152; |
845 | } | 728 | |
846 | } | 729 | /* according to spec, anchor is in either: |
847 | } | 730 | * block 256 |
731 | * lastblock-256 | ||
732 | * lastblock | ||
733 | * however, if the disc isn't closed, it could be 512 */ | ||
734 | |||
735 | for (i = 0; i < ARRAY_SIZE(last); i++) { | ||
736 | if (last[i] < 0) | ||
737 | continue; | ||
738 | if (last[i] >= sb->s_bdev->bd_inode->i_size >> | ||
739 | sb->s_blocksize_bits) | ||
740 | continue; | ||
741 | |||
742 | if (udf_check_anchor_block(sb, last[i], varconv)) { | ||
743 | sbi->s_anchor[0] = last[i]; | ||
744 | sbi->s_anchor[1] = last[i] - 256; | ||
745 | return last[i]; | ||
848 | } | 746 | } |
849 | } | ||
850 | 747 | ||
851 | if (!lastblock) { | 748 | if (last[i] < 256) |
852 | /* We haven't found the lastblock. check 312 */ | 749 | continue; |
853 | bh = sb_bread(sb, 312 + sbi->s_session); | ||
854 | if (bh) { | ||
855 | tag *t = (tag *)bh->b_data; | ||
856 | ident = le16_to_cpu(t->tagIdent); | ||
857 | location = le32_to_cpu(t->tagLocation); | ||
858 | brelse(bh); | ||
859 | 750 | ||
860 | if (ident == TAG_IDENT_AVDP && location == 256) | 751 | if (udf_check_anchor_block(sb, last[i] - 256, varconv)) { |
861 | UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); | 752 | sbi->s_anchor[1] = last[i] - 256; |
753 | return last[i]; | ||
862 | } | 754 | } |
863 | } | 755 | } |
864 | 756 | ||
757 | if (udf_check_anchor_block(sb, sbi->s_session + 256, varconv)) { | ||
758 | sbi->s_anchor[0] = sbi->s_session + 256; | ||
759 | return last[0]; | ||
760 | } | ||
761 | if (udf_check_anchor_block(sb, sbi->s_session + 512, varconv)) { | ||
762 | sbi->s_anchor[0] = sbi->s_session + 512; | ||
763 | return last[0]; | ||
764 | } | ||
765 | return 0; | ||
766 | } | ||
767 | |||
768 | /* | ||
769 | * Find an anchor volume descriptor. The function expects sbi->s_lastblock to | ||
770 | * be the last block on the media. | ||
771 | * | ||
772 | * Return 1 if not found, 0 if ok | ||
773 | * | ||
774 | */ | ||
775 | static void udf_find_anchor(struct super_block *sb) | ||
776 | { | ||
777 | sector_t lastblock; | ||
778 | struct buffer_head *bh = NULL; | ||
779 | uint16_t ident; | ||
780 | int i; | ||
781 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
782 | |||
783 | lastblock = udf_scan_anchors(sb, 0, sbi->s_last_block); | ||
784 | if (lastblock) | ||
785 | goto check_anchor; | ||
786 | |||
787 | /* No anchor found? Try VARCONV conversion of block numbers */ | ||
788 | /* Firstly, we try to not convert number of the last block */ | ||
789 | lastblock = udf_scan_anchors(sb, 1, | ||
790 | udf_variable_to_fixed(sbi->s_last_block)); | ||
791 | if (lastblock) { | ||
792 | UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); | ||
793 | goto check_anchor; | ||
794 | } | ||
795 | |||
796 | /* Secondly, we try with converted number of the last block */ | ||
797 | lastblock = udf_scan_anchors(sb, 1, sbi->s_last_block); | ||
798 | if (lastblock) | ||
799 | UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); | ||
800 | |||
801 | check_anchor: | ||
802 | /* | ||
803 | * Check located anchors and the anchor block supplied via | ||
804 | * mount options | ||
805 | */ | ||
865 | for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) { | 806 | for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) { |
866 | if (sbi->s_anchor[i]) { | 807 | if (!sbi->s_anchor[i]) |
867 | bh = udf_read_tagged(sb, sbi->s_anchor[i], | 808 | continue; |
868 | sbi->s_anchor[i], &ident); | 809 | bh = udf_read_tagged(sb, sbi->s_anchor[i], |
869 | if (!bh) | 810 | sbi->s_anchor[i], &ident); |
811 | if (!bh) | ||
812 | sbi->s_anchor[i] = 0; | ||
813 | else { | ||
814 | brelse(bh); | ||
815 | if (ident != TAG_IDENT_AVDP) | ||
870 | sbi->s_anchor[i] = 0; | 816 | sbi->s_anchor[i] = 0; |
871 | else { | ||
872 | brelse(bh); | ||
873 | if ((ident != TAG_IDENT_AVDP) && | ||
874 | (i || (ident != TAG_IDENT_FE && | ||
875 | ident != TAG_IDENT_EFE))) | ||
876 | sbi->s_anchor[i] = 0; | ||
877 | } | ||
878 | } | 817 | } |
879 | } | 818 | } |
880 | 819 | ||
@@ -971,27 +910,30 @@ static int udf_find_fileset(struct super_block *sb, | |||
971 | return 1; | 910 | return 1; |
972 | } | 911 | } |
973 | 912 | ||
974 | static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh) | 913 | static int udf_load_pvoldesc(struct super_block *sb, sector_t block) |
975 | { | 914 | { |
976 | struct primaryVolDesc *pvoldesc; | 915 | struct primaryVolDesc *pvoldesc; |
977 | time_t recording; | ||
978 | long recording_usec; | ||
979 | struct ustr instr; | 916 | struct ustr instr; |
980 | struct ustr outstr; | 917 | struct ustr outstr; |
918 | struct buffer_head *bh; | ||
919 | uint16_t ident; | ||
920 | |||
921 | bh = udf_read_tagged(sb, block, block, &ident); | ||
922 | if (!bh) | ||
923 | return 1; | ||
924 | BUG_ON(ident != TAG_IDENT_PVD); | ||
981 | 925 | ||
982 | pvoldesc = (struct primaryVolDesc *)bh->b_data; | 926 | pvoldesc = (struct primaryVolDesc *)bh->b_data; |
983 | 927 | ||
984 | if (udf_stamp_to_time(&recording, &recording_usec, | 928 | if (udf_disk_stamp_to_time(&UDF_SB(sb)->s_record_time, |
985 | lets_to_cpu(pvoldesc->recordingDateAndTime))) { | 929 | pvoldesc->recordingDateAndTime)) { |
986 | kernel_timestamp ts; | 930 | #ifdef UDFFS_DEBUG |
987 | ts = lets_to_cpu(pvoldesc->recordingDateAndTime); | 931 | timestamp *ts = &pvoldesc->recordingDateAndTime; |
988 | udf_debug("recording time %ld/%ld, %04u/%02u/%02u" | 932 | udf_debug("recording time %04u/%02u/%02u" |
989 | " %02u:%02u (%x)\n", | 933 | " %02u:%02u (%x)\n", |
990 | recording, recording_usec, | 934 | le16_to_cpu(ts->year), ts->month, ts->day, ts->hour, |
991 | ts.year, ts.month, ts.day, ts.hour, | 935 | ts->minute, le16_to_cpu(ts->typeAndTimezone)); |
992 | ts.minute, ts.typeAndTimezone); | 936 | #endif |
993 | UDF_SB(sb)->s_record_time.tv_sec = recording; | ||
994 | UDF_SB(sb)->s_record_time.tv_nsec = recording_usec * 1000; | ||
995 | } | 937 | } |
996 | 938 | ||
997 | if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) | 939 | if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) |
@@ -1005,6 +947,104 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh) | |||
1005 | if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128)) | 947 | if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128)) |
1006 | if (udf_CS0toUTF8(&outstr, &instr)) | 948 | if (udf_CS0toUTF8(&outstr, &instr)) |
1007 | udf_debug("volSetIdent[] = '%s'\n", outstr.u_name); | 949 | udf_debug("volSetIdent[] = '%s'\n", outstr.u_name); |
950 | |||
951 | brelse(bh); | ||
952 | return 0; | ||
953 | } | ||
954 | |||
955 | static int udf_load_metadata_files(struct super_block *sb, int partition) | ||
956 | { | ||
957 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
958 | struct udf_part_map *map; | ||
959 | struct udf_meta_data *mdata; | ||
960 | kernel_lb_addr addr; | ||
961 | int fe_error = 0; | ||
962 | |||
963 | map = &sbi->s_partmaps[partition]; | ||
964 | mdata = &map->s_type_specific.s_metadata; | ||
965 | |||
966 | /* metadata address */ | ||
967 | addr.logicalBlockNum = mdata->s_meta_file_loc; | ||
968 | addr.partitionReferenceNum = map->s_partition_num; | ||
969 | |||
970 | udf_debug("Metadata file location: block = %d part = %d\n", | ||
971 | addr.logicalBlockNum, addr.partitionReferenceNum); | ||
972 | |||
973 | mdata->s_metadata_fe = udf_iget(sb, addr); | ||
974 | |||
975 | if (mdata->s_metadata_fe == NULL) { | ||
976 | udf_warning(sb, __func__, "metadata inode efe not found, " | ||
977 | "will try mirror inode."); | ||
978 | fe_error = 1; | ||
979 | } else if (UDF_I(mdata->s_metadata_fe)->i_alloc_type != | ||
980 | ICBTAG_FLAG_AD_SHORT) { | ||
981 | udf_warning(sb, __func__, "metadata inode efe does not have " | ||
982 | "short allocation descriptors!"); | ||
983 | fe_error = 1; | ||
984 | iput(mdata->s_metadata_fe); | ||
985 | mdata->s_metadata_fe = NULL; | ||
986 | } | ||
987 | |||
988 | /* mirror file entry */ | ||
989 | addr.logicalBlockNum = mdata->s_mirror_file_loc; | ||
990 | addr.partitionReferenceNum = map->s_partition_num; | ||
991 | |||
992 | udf_debug("Mirror metadata file location: block = %d part = %d\n", | ||
993 | addr.logicalBlockNum, addr.partitionReferenceNum); | ||
994 | |||
995 | mdata->s_mirror_fe = udf_iget(sb, addr); | ||
996 | |||
997 | if (mdata->s_mirror_fe == NULL) { | ||
998 | if (fe_error) { | ||
999 | udf_error(sb, __func__, "mirror inode efe not found " | ||
1000 | "and metadata inode is missing too, exiting..."); | ||
1001 | goto error_exit; | ||
1002 | } else | ||
1003 | udf_warning(sb, __func__, "mirror inode efe not found," | ||
1004 | " but metadata inode is OK"); | ||
1005 | } else if (UDF_I(mdata->s_mirror_fe)->i_alloc_type != | ||
1006 | ICBTAG_FLAG_AD_SHORT) { | ||
1007 | udf_warning(sb, __func__, "mirror inode efe does not have " | ||
1008 | "short allocation descriptors!"); | ||
1009 | iput(mdata->s_mirror_fe); | ||
1010 | mdata->s_mirror_fe = NULL; | ||
1011 | if (fe_error) | ||
1012 | goto error_exit; | ||
1013 | } | ||
1014 | |||
1015 | /* | ||
1016 | * bitmap file entry | ||
1017 | * Note: | ||
1018 | * Load only if bitmap file location differs from 0xFFFFFFFF (DCN-5102) | ||
1019 | */ | ||
1020 | if (mdata->s_bitmap_file_loc != 0xFFFFFFFF) { | ||
1021 | addr.logicalBlockNum = mdata->s_bitmap_file_loc; | ||
1022 | addr.partitionReferenceNum = map->s_partition_num; | ||
1023 | |||
1024 | udf_debug("Bitmap file location: block = %d part = %d\n", | ||
1025 | addr.logicalBlockNum, addr.partitionReferenceNum); | ||
1026 | |||
1027 | mdata->s_bitmap_fe = udf_iget(sb, addr); | ||
1028 | |||
1029 | if (mdata->s_bitmap_fe == NULL) { | ||
1030 | if (sb->s_flags & MS_RDONLY) | ||
1031 | udf_warning(sb, __func__, "bitmap inode efe " | ||
1032 | "not found but it's ok since the disc" | ||
1033 | " is mounted read-only"); | ||
1034 | else { | ||
1035 | udf_error(sb, __func__, "bitmap inode efe not " | ||
1036 | "found and attempted read-write mount"); | ||
1037 | goto error_exit; | ||
1038 | } | ||
1039 | } | ||
1040 | } | ||
1041 | |||
1042 | udf_debug("udf_load_metadata_files Ok\n"); | ||
1043 | |||
1044 | return 0; | ||
1045 | |||
1046 | error_exit: | ||
1047 | return 1; | ||
1008 | } | 1048 | } |
1009 | 1049 | ||
1010 | static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh, | 1050 | static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh, |
@@ -1025,10 +1065,9 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh, | |||
1025 | int udf_compute_nr_groups(struct super_block *sb, u32 partition) | 1065 | int udf_compute_nr_groups(struct super_block *sb, u32 partition) |
1026 | { | 1066 | { |
1027 | struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; | 1067 | struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; |
1028 | return (map->s_partition_len + | 1068 | return DIV_ROUND_UP(map->s_partition_len + |
1029 | (sizeof(struct spaceBitmapDesc) << 3) + | 1069 | (sizeof(struct spaceBitmapDesc) << 3), |
1030 | (sb->s_blocksize * 8) - 1) / | 1070 | sb->s_blocksize * 8); |
1031 | (sb->s_blocksize * 8); | ||
1032 | } | 1071 | } |
1033 | 1072 | ||
1034 | static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index) | 1073 | static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index) |
@@ -1059,134 +1098,241 @@ static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index) | |||
1059 | return bitmap; | 1098 | return bitmap; |
1060 | } | 1099 | } |
1061 | 1100 | ||
1062 | static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh) | 1101 | static int udf_fill_partdesc_info(struct super_block *sb, |
1102 | struct partitionDesc *p, int p_index) | ||
1103 | { | ||
1104 | struct udf_part_map *map; | ||
1105 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
1106 | struct partitionHeaderDesc *phd; | ||
1107 | |||
1108 | map = &sbi->s_partmaps[p_index]; | ||
1109 | |||
1110 | map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */ | ||
1111 | map->s_partition_root = le32_to_cpu(p->partitionStartingLocation); | ||
1112 | |||
1113 | if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY)) | ||
1114 | map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY; | ||
1115 | if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE)) | ||
1116 | map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE; | ||
1117 | if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE)) | ||
1118 | map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE; | ||
1119 | if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE)) | ||
1120 | map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE; | ||
1121 | |||
1122 | udf_debug("Partition (%d type %x) starts at physical %d, " | ||
1123 | "block length %d\n", p_index, | ||
1124 | map->s_partition_type, map->s_partition_root, | ||
1125 | map->s_partition_len); | ||
1126 | |||
1127 | if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) && | ||
1128 | strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03)) | ||
1129 | return 0; | ||
1130 | |||
1131 | phd = (struct partitionHeaderDesc *)p->partitionContentsUse; | ||
1132 | if (phd->unallocSpaceTable.extLength) { | ||
1133 | kernel_lb_addr loc = { | ||
1134 | .logicalBlockNum = le32_to_cpu( | ||
1135 | phd->unallocSpaceTable.extPosition), | ||
1136 | .partitionReferenceNum = p_index, | ||
1137 | }; | ||
1138 | |||
1139 | map->s_uspace.s_table = udf_iget(sb, loc); | ||
1140 | if (!map->s_uspace.s_table) { | ||
1141 | udf_debug("cannot load unallocSpaceTable (part %d)\n", | ||
1142 | p_index); | ||
1143 | return 1; | ||
1144 | } | ||
1145 | map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE; | ||
1146 | udf_debug("unallocSpaceTable (part %d) @ %ld\n", | ||
1147 | p_index, map->s_uspace.s_table->i_ino); | ||
1148 | } | ||
1149 | |||
1150 | if (phd->unallocSpaceBitmap.extLength) { | ||
1151 | struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index); | ||
1152 | if (!bitmap) | ||
1153 | return 1; | ||
1154 | map->s_uspace.s_bitmap = bitmap; | ||
1155 | bitmap->s_extLength = le32_to_cpu( | ||
1156 | phd->unallocSpaceBitmap.extLength); | ||
1157 | bitmap->s_extPosition = le32_to_cpu( | ||
1158 | phd->unallocSpaceBitmap.extPosition); | ||
1159 | map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP; | ||
1160 | udf_debug("unallocSpaceBitmap (part %d) @ %d\n", p_index, | ||
1161 | bitmap->s_extPosition); | ||
1162 | } | ||
1163 | |||
1164 | if (phd->partitionIntegrityTable.extLength) | ||
1165 | udf_debug("partitionIntegrityTable (part %d)\n", p_index); | ||
1166 | |||
1167 | if (phd->freedSpaceTable.extLength) { | ||
1168 | kernel_lb_addr loc = { | ||
1169 | .logicalBlockNum = le32_to_cpu( | ||
1170 | phd->freedSpaceTable.extPosition), | ||
1171 | .partitionReferenceNum = p_index, | ||
1172 | }; | ||
1173 | |||
1174 | map->s_fspace.s_table = udf_iget(sb, loc); | ||
1175 | if (!map->s_fspace.s_table) { | ||
1176 | udf_debug("cannot load freedSpaceTable (part %d)\n", | ||
1177 | p_index); | ||
1178 | return 1; | ||
1179 | } | ||
1180 | |||
1181 | map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE; | ||
1182 | udf_debug("freedSpaceTable (part %d) @ %ld\n", | ||
1183 | p_index, map->s_fspace.s_table->i_ino); | ||
1184 | } | ||
1185 | |||
1186 | if (phd->freedSpaceBitmap.extLength) { | ||
1187 | struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index); | ||
1188 | if (!bitmap) | ||
1189 | return 1; | ||
1190 | map->s_fspace.s_bitmap = bitmap; | ||
1191 | bitmap->s_extLength = le32_to_cpu( | ||
1192 | phd->freedSpaceBitmap.extLength); | ||
1193 | bitmap->s_extPosition = le32_to_cpu( | ||
1194 | phd->freedSpaceBitmap.extPosition); | ||
1195 | map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP; | ||
1196 | udf_debug("freedSpaceBitmap (part %d) @ %d\n", p_index, | ||
1197 | bitmap->s_extPosition); | ||
1198 | } | ||
1199 | return 0; | ||
1200 | } | ||
1201 | |||
1202 | static int udf_load_vat(struct super_block *sb, int p_index, int type1_index) | ||
1203 | { | ||
1204 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
1205 | struct udf_part_map *map = &sbi->s_partmaps[p_index]; | ||
1206 | kernel_lb_addr ino; | ||
1207 | struct buffer_head *bh = NULL; | ||
1208 | struct udf_inode_info *vati; | ||
1209 | uint32_t pos; | ||
1210 | struct virtualAllocationTable20 *vat20; | ||
1211 | |||
1212 | /* VAT file entry is in the last recorded block */ | ||
1213 | ino.partitionReferenceNum = type1_index; | ||
1214 | ino.logicalBlockNum = sbi->s_last_block - map->s_partition_root; | ||
1215 | sbi->s_vat_inode = udf_iget(sb, ino); | ||
1216 | if (!sbi->s_vat_inode) | ||
1217 | return 1; | ||
1218 | |||
1219 | if (map->s_partition_type == UDF_VIRTUAL_MAP15) { | ||
1220 | map->s_type_specific.s_virtual.s_start_offset = 0; | ||
1221 | map->s_type_specific.s_virtual.s_num_entries = | ||
1222 | (sbi->s_vat_inode->i_size - 36) >> 2; | ||
1223 | } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) { | ||
1224 | vati = UDF_I(sbi->s_vat_inode); | ||
1225 | if (vati->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { | ||
1226 | pos = udf_block_map(sbi->s_vat_inode, 0); | ||
1227 | bh = sb_bread(sb, pos); | ||
1228 | if (!bh) | ||
1229 | return 1; | ||
1230 | vat20 = (struct virtualAllocationTable20 *)bh->b_data; | ||
1231 | } else { | ||
1232 | vat20 = (struct virtualAllocationTable20 *) | ||
1233 | vati->i_ext.i_data; | ||
1234 | } | ||
1235 | |||
1236 | map->s_type_specific.s_virtual.s_start_offset = | ||
1237 | le16_to_cpu(vat20->lengthHeader); | ||
1238 | map->s_type_specific.s_virtual.s_num_entries = | ||
1239 | (sbi->s_vat_inode->i_size - | ||
1240 | map->s_type_specific.s_virtual. | ||
1241 | s_start_offset) >> 2; | ||
1242 | brelse(bh); | ||
1243 | } | ||
1244 | return 0; | ||
1245 | } | ||
1246 | |||
1247 | static int udf_load_partdesc(struct super_block *sb, sector_t block) | ||
1063 | { | 1248 | { |
1249 | struct buffer_head *bh; | ||
1064 | struct partitionDesc *p; | 1250 | struct partitionDesc *p; |
1065 | int i; | ||
1066 | struct udf_part_map *map; | 1251 | struct udf_part_map *map; |
1067 | struct udf_sb_info *sbi; | 1252 | struct udf_sb_info *sbi = UDF_SB(sb); |
1253 | int i, type1_idx; | ||
1254 | uint16_t partitionNumber; | ||
1255 | uint16_t ident; | ||
1256 | int ret = 0; | ||
1257 | |||
1258 | bh = udf_read_tagged(sb, block, block, &ident); | ||
1259 | if (!bh) | ||
1260 | return 1; | ||
1261 | if (ident != TAG_IDENT_PD) | ||
1262 | goto out_bh; | ||
1068 | 1263 | ||
1069 | p = (struct partitionDesc *)bh->b_data; | 1264 | p = (struct partitionDesc *)bh->b_data; |
1070 | sbi = UDF_SB(sb); | 1265 | partitionNumber = le16_to_cpu(p->partitionNumber); |
1071 | 1266 | ||
1267 | /* First scan for TYPE1, SPARABLE and METADATA partitions */ | ||
1072 | for (i = 0; i < sbi->s_partitions; i++) { | 1268 | for (i = 0; i < sbi->s_partitions; i++) { |
1073 | map = &sbi->s_partmaps[i]; | 1269 | map = &sbi->s_partmaps[i]; |
1074 | udf_debug("Searching map: (%d == %d)\n", | 1270 | udf_debug("Searching map: (%d == %d)\n", |
1075 | map->s_partition_num, | 1271 | map->s_partition_num, partitionNumber); |
1076 | le16_to_cpu(p->partitionNumber)); | 1272 | if (map->s_partition_num == partitionNumber && |
1077 | if (map->s_partition_num == | 1273 | (map->s_partition_type == UDF_TYPE1_MAP15 || |
1078 | le16_to_cpu(p->partitionNumber)) { | 1274 | map->s_partition_type == UDF_SPARABLE_MAP15)) |
1079 | map->s_partition_len = | ||
1080 | le32_to_cpu(p->partitionLength); /* blocks */ | ||
1081 | map->s_partition_root = | ||
1082 | le32_to_cpu(p->partitionStartingLocation); | ||
1083 | if (p->accessType == | ||
1084 | cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY)) | ||
1085 | map->s_partition_flags |= | ||
1086 | UDF_PART_FLAG_READ_ONLY; | ||
1087 | if (p->accessType == | ||
1088 | cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE)) | ||
1089 | map->s_partition_flags |= | ||
1090 | UDF_PART_FLAG_WRITE_ONCE; | ||
1091 | if (p->accessType == | ||
1092 | cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE)) | ||
1093 | map->s_partition_flags |= | ||
1094 | UDF_PART_FLAG_REWRITABLE; | ||
1095 | if (p->accessType == | ||
1096 | cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE)) | ||
1097 | map->s_partition_flags |= | ||
1098 | UDF_PART_FLAG_OVERWRITABLE; | ||
1099 | |||
1100 | if (!strcmp(p->partitionContents.ident, | ||
1101 | PD_PARTITION_CONTENTS_NSR02) || | ||
1102 | !strcmp(p->partitionContents.ident, | ||
1103 | PD_PARTITION_CONTENTS_NSR03)) { | ||
1104 | struct partitionHeaderDesc *phd; | ||
1105 | |||
1106 | phd = (struct partitionHeaderDesc *) | ||
1107 | (p->partitionContentsUse); | ||
1108 | if (phd->unallocSpaceTable.extLength) { | ||
1109 | kernel_lb_addr loc = { | ||
1110 | .logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition), | ||
1111 | .partitionReferenceNum = i, | ||
1112 | }; | ||
1113 | |||
1114 | map->s_uspace.s_table = | ||
1115 | udf_iget(sb, loc); | ||
1116 | if (!map->s_uspace.s_table) { | ||
1117 | udf_debug("cannot load unallocSpaceTable (part %d)\n", i); | ||
1118 | return 1; | ||
1119 | } | ||
1120 | map->s_partition_flags |= | ||
1121 | UDF_PART_FLAG_UNALLOC_TABLE; | ||
1122 | udf_debug("unallocSpaceTable (part %d) @ %ld\n", | ||
1123 | i, map->s_uspace.s_table->i_ino); | ||
1124 | } | ||
1125 | if (phd->unallocSpaceBitmap.extLength) { | ||
1126 | struct udf_bitmap *bitmap = | ||
1127 | udf_sb_alloc_bitmap(sb, i); | ||
1128 | map->s_uspace.s_bitmap = bitmap; | ||
1129 | if (bitmap != NULL) { | ||
1130 | bitmap->s_extLength = | ||
1131 | le32_to_cpu(phd->unallocSpaceBitmap.extLength); | ||
1132 | bitmap->s_extPosition = | ||
1133 | le32_to_cpu(phd->unallocSpaceBitmap.extPosition); | ||
1134 | map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP; | ||
1135 | udf_debug("unallocSpaceBitmap (part %d) @ %d\n", | ||
1136 | i, bitmap->s_extPosition); | ||
1137 | } | ||
1138 | } | ||
1139 | if (phd->partitionIntegrityTable.extLength) | ||
1140 | udf_debug("partitionIntegrityTable (part %d)\n", i); | ||
1141 | if (phd->freedSpaceTable.extLength) { | ||
1142 | kernel_lb_addr loc = { | ||
1143 | .logicalBlockNum = le32_to_cpu(phd->freedSpaceTable.extPosition), | ||
1144 | .partitionReferenceNum = i, | ||
1145 | }; | ||
1146 | |||
1147 | map->s_fspace.s_table = | ||
1148 | udf_iget(sb, loc); | ||
1149 | if (!map->s_fspace.s_table) { | ||
1150 | udf_debug("cannot load freedSpaceTable (part %d)\n", i); | ||
1151 | return 1; | ||
1152 | } | ||
1153 | map->s_partition_flags |= | ||
1154 | UDF_PART_FLAG_FREED_TABLE; | ||
1155 | udf_debug("freedSpaceTable (part %d) @ %ld\n", | ||
1156 | i, map->s_fspace.s_table->i_ino); | ||
1157 | } | ||
1158 | if (phd->freedSpaceBitmap.extLength) { | ||
1159 | struct udf_bitmap *bitmap = | ||
1160 | udf_sb_alloc_bitmap(sb, i); | ||
1161 | map->s_fspace.s_bitmap = bitmap; | ||
1162 | if (bitmap != NULL) { | ||
1163 | bitmap->s_extLength = | ||
1164 | le32_to_cpu(phd->freedSpaceBitmap.extLength); | ||
1165 | bitmap->s_extPosition = | ||
1166 | le32_to_cpu(phd->freedSpaceBitmap.extPosition); | ||
1167 | map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP; | ||
1168 | udf_debug("freedSpaceBitmap (part %d) @ %d\n", | ||
1169 | i, bitmap->s_extPosition); | ||
1170 | } | ||
1171 | } | ||
1172 | } | ||
1173 | break; | 1275 | break; |
1174 | } | ||
1175 | } | 1276 | } |
1176 | if (i == sbi->s_partitions) | 1277 | |
1278 | if (i >= sbi->s_partitions) { | ||
1177 | udf_debug("Partition (%d) not found in partition map\n", | 1279 | udf_debug("Partition (%d) not found in partition map\n", |
1178 | le16_to_cpu(p->partitionNumber)); | 1280 | partitionNumber); |
1179 | else | 1281 | goto out_bh; |
1180 | udf_debug("Partition (%d:%d type %x) starts at physical %d, " | 1282 | } |
1181 | "block length %d\n", | 1283 | |
1182 | le16_to_cpu(p->partitionNumber), i, | 1284 | ret = udf_fill_partdesc_info(sb, p, i); |
1183 | map->s_partition_type, | 1285 | |
1184 | map->s_partition_root, | 1286 | /* |
1185 | map->s_partition_len); | 1287 | * Now rescan for VIRTUAL or METADATA partitions when SPARABLE and |
1186 | return 0; | 1288 | * PHYSICAL partitions are already set up |
1289 | */ | ||
1290 | type1_idx = i; | ||
1291 | for (i = 0; i < sbi->s_partitions; i++) { | ||
1292 | map = &sbi->s_partmaps[i]; | ||
1293 | |||
1294 | if (map->s_partition_num == partitionNumber && | ||
1295 | (map->s_partition_type == UDF_VIRTUAL_MAP15 || | ||
1296 | map->s_partition_type == UDF_VIRTUAL_MAP20 || | ||
1297 | map->s_partition_type == UDF_METADATA_MAP25)) | ||
1298 | break; | ||
1299 | } | ||
1300 | |||
1301 | if (i >= sbi->s_partitions) | ||
1302 | goto out_bh; | ||
1303 | |||
1304 | ret = udf_fill_partdesc_info(sb, p, i); | ||
1305 | if (ret) | ||
1306 | goto out_bh; | ||
1307 | |||
1308 | if (map->s_partition_type == UDF_METADATA_MAP25) { | ||
1309 | ret = udf_load_metadata_files(sb, i); | ||
1310 | if (ret) { | ||
1311 | printk(KERN_ERR "UDF-fs: error loading MetaData " | ||
1312 | "partition map %d\n", i); | ||
1313 | goto out_bh; | ||
1314 | } | ||
1315 | } else { | ||
1316 | ret = udf_load_vat(sb, i, type1_idx); | ||
1317 | if (ret) | ||
1318 | goto out_bh; | ||
1319 | /* | ||
1320 | * Mark filesystem read-only if we have a partition with | ||
1321 | * virtual map since we don't handle writing to it (we | ||
1322 | * overwrite blocks instead of relocating them). | ||
1323 | */ | ||
1324 | sb->s_flags |= MS_RDONLY; | ||
1325 | printk(KERN_NOTICE "UDF-fs: Filesystem marked read-only " | ||
1326 | "because writing to pseudooverwrite partition is " | ||
1327 | "not implemented.\n"); | ||
1328 | } | ||
1329 | out_bh: | ||
1330 | /* In case loading failed, we handle cleanup in udf_fill_super */ | ||
1331 | brelse(bh); | ||
1332 | return ret; | ||
1187 | } | 1333 | } |
1188 | 1334 | ||
1189 | static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, | 1335 | static int udf_load_logicalvol(struct super_block *sb, sector_t block, |
1190 | kernel_lb_addr *fileset) | 1336 | kernel_lb_addr *fileset) |
1191 | { | 1337 | { |
1192 | struct logicalVolDesc *lvd; | 1338 | struct logicalVolDesc *lvd; |
@@ -1194,12 +1340,21 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, | |||
1194 | uint8_t type; | 1340 | uint8_t type; |
1195 | struct udf_sb_info *sbi = UDF_SB(sb); | 1341 | struct udf_sb_info *sbi = UDF_SB(sb); |
1196 | struct genericPartitionMap *gpm; | 1342 | struct genericPartitionMap *gpm; |
1343 | uint16_t ident; | ||
1344 | struct buffer_head *bh; | ||
1345 | int ret = 0; | ||
1197 | 1346 | ||
1347 | bh = udf_read_tagged(sb, block, block, &ident); | ||
1348 | if (!bh) | ||
1349 | return 1; | ||
1350 | BUG_ON(ident != TAG_IDENT_LVD); | ||
1198 | lvd = (struct logicalVolDesc *)bh->b_data; | 1351 | lvd = (struct logicalVolDesc *)bh->b_data; |
1199 | 1352 | ||
1200 | i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps)); | 1353 | i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps)); |
1201 | if (i != 0) | 1354 | if (i != 0) { |
1202 | return i; | 1355 | ret = i; |
1356 | goto out_bh; | ||
1357 | } | ||
1203 | 1358 | ||
1204 | for (i = 0, offset = 0; | 1359 | for (i = 0, offset = 0; |
1205 | i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength); | 1360 | i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength); |
@@ -1223,12 +1378,12 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, | |||
1223 | u16 suf = | 1378 | u16 suf = |
1224 | le16_to_cpu(((__le16 *)upm2->partIdent. | 1379 | le16_to_cpu(((__le16 *)upm2->partIdent. |
1225 | identSuffix)[0]); | 1380 | identSuffix)[0]); |
1226 | if (suf == 0x0150) { | 1381 | if (suf < 0x0200) { |
1227 | map->s_partition_type = | 1382 | map->s_partition_type = |
1228 | UDF_VIRTUAL_MAP15; | 1383 | UDF_VIRTUAL_MAP15; |
1229 | map->s_partition_func = | 1384 | map->s_partition_func = |
1230 | udf_get_pblock_virt15; | 1385 | udf_get_pblock_virt15; |
1231 | } else if (suf == 0x0200) { | 1386 | } else { |
1232 | map->s_partition_type = | 1387 | map->s_partition_type = |
1233 | UDF_VIRTUAL_MAP20; | 1388 | UDF_VIRTUAL_MAP20; |
1234 | map->s_partition_func = | 1389 | map->s_partition_func = |
@@ -1238,7 +1393,6 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, | |||
1238 | UDF_ID_SPARABLE, | 1393 | UDF_ID_SPARABLE, |
1239 | strlen(UDF_ID_SPARABLE))) { | 1394 | strlen(UDF_ID_SPARABLE))) { |
1240 | uint32_t loc; | 1395 | uint32_t loc; |
1241 | uint16_t ident; | ||
1242 | struct sparingTable *st; | 1396 | struct sparingTable *st; |
1243 | struct sparablePartitionMap *spm = | 1397 | struct sparablePartitionMap *spm = |
1244 | (struct sparablePartitionMap *)gpm; | 1398 | (struct sparablePartitionMap *)gpm; |
@@ -1256,22 +1410,64 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, | |||
1256 | map->s_type_specific.s_sparing. | 1410 | map->s_type_specific.s_sparing. |
1257 | s_spar_map[j] = bh2; | 1411 | s_spar_map[j] = bh2; |
1258 | 1412 | ||
1259 | if (bh2 != NULL) { | 1413 | if (bh2 == NULL) |
1260 | st = (struct sparingTable *) | 1414 | continue; |
1261 | bh2->b_data; | 1415 | |
1262 | if (ident != 0 || strncmp( | 1416 | st = (struct sparingTable *)bh2->b_data; |
1263 | st->sparingIdent.ident, | 1417 | if (ident != 0 || strncmp( |
1264 | UDF_ID_SPARING, | 1418 | st->sparingIdent.ident, |
1265 | strlen(UDF_ID_SPARING))) { | 1419 | UDF_ID_SPARING, |
1266 | brelse(bh2); | 1420 | strlen(UDF_ID_SPARING))) { |
1267 | map->s_type_specific. | 1421 | brelse(bh2); |
1268 | s_sparing. | 1422 | map->s_type_specific.s_sparing. |
1269 | s_spar_map[j] = | 1423 | s_spar_map[j] = NULL; |
1270 | NULL; | ||
1271 | } | ||
1272 | } | 1424 | } |
1273 | } | 1425 | } |
1274 | map->s_partition_func = udf_get_pblock_spar15; | 1426 | map->s_partition_func = udf_get_pblock_spar15; |
1427 | } else if (!strncmp(upm2->partIdent.ident, | ||
1428 | UDF_ID_METADATA, | ||
1429 | strlen(UDF_ID_METADATA))) { | ||
1430 | struct udf_meta_data *mdata = | ||
1431 | &map->s_type_specific.s_metadata; | ||
1432 | struct metadataPartitionMap *mdm = | ||
1433 | (struct metadataPartitionMap *) | ||
1434 | &(lvd->partitionMaps[offset]); | ||
1435 | udf_debug("Parsing Logical vol part %d " | ||
1436 | "type %d id=%s\n", i, type, | ||
1437 | UDF_ID_METADATA); | ||
1438 | |||
1439 | map->s_partition_type = UDF_METADATA_MAP25; | ||
1440 | map->s_partition_func = udf_get_pblock_meta25; | ||
1441 | |||
1442 | mdata->s_meta_file_loc = | ||
1443 | le32_to_cpu(mdm->metadataFileLoc); | ||
1444 | mdata->s_mirror_file_loc = | ||
1445 | le32_to_cpu(mdm->metadataMirrorFileLoc); | ||
1446 | mdata->s_bitmap_file_loc = | ||
1447 | le32_to_cpu(mdm->metadataBitmapFileLoc); | ||
1448 | mdata->s_alloc_unit_size = | ||
1449 | le32_to_cpu(mdm->allocUnitSize); | ||
1450 | mdata->s_align_unit_size = | ||
1451 | le16_to_cpu(mdm->alignUnitSize); | ||
1452 | mdata->s_dup_md_flag = | ||
1453 | mdm->flags & 0x01; | ||
1454 | |||
1455 | udf_debug("Metadata Ident suffix=0x%x\n", | ||
1456 | (le16_to_cpu( | ||
1457 | ((__le16 *) | ||
1458 | mdm->partIdent.identSuffix)[0]))); | ||
1459 | udf_debug("Metadata part num=%d\n", | ||
1460 | le16_to_cpu(mdm->partitionNum)); | ||
1461 | udf_debug("Metadata part alloc unit size=%d\n", | ||
1462 | le32_to_cpu(mdm->allocUnitSize)); | ||
1463 | udf_debug("Metadata file loc=%d\n", | ||
1464 | le32_to_cpu(mdm->metadataFileLoc)); | ||
1465 | udf_debug("Mirror file loc=%d\n", | ||
1466 | le32_to_cpu(mdm->metadataMirrorFileLoc)); | ||
1467 | udf_debug("Bitmap file loc=%d\n", | ||
1468 | le32_to_cpu(mdm->metadataBitmapFileLoc)); | ||
1469 | udf_debug("Duplicate Flag: %d %d\n", | ||
1470 | mdata->s_dup_md_flag, mdm->flags); | ||
1275 | } else { | 1471 | } else { |
1276 | udf_debug("Unknown ident: %s\n", | 1472 | udf_debug("Unknown ident: %s\n", |
1277 | upm2->partIdent.ident); | 1473 | upm2->partIdent.ident); |
@@ -1296,7 +1492,9 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, | |||
1296 | if (lvd->integritySeqExt.extLength) | 1492 | if (lvd->integritySeqExt.extLength) |
1297 | udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt)); | 1493 | udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt)); |
1298 | 1494 | ||
1299 | return 0; | 1495 | out_bh: |
1496 | brelse(bh); | ||
1497 | return ret; | ||
1300 | } | 1498 | } |
1301 | 1499 | ||
1302 | /* | 1500 | /* |
@@ -1345,7 +1543,7 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc) | |||
1345 | * July 1, 1997 - Andrew E. Mileski | 1543 | * July 1, 1997 - Andrew E. Mileski |
1346 | * Written, tested, and released. | 1544 | * Written, tested, and released. |
1347 | */ | 1545 | */ |
1348 | static int udf_process_sequence(struct super_block *sb, long block, | 1546 | static noinline int udf_process_sequence(struct super_block *sb, long block, |
1349 | long lastblock, kernel_lb_addr *fileset) | 1547 | long lastblock, kernel_lb_addr *fileset) |
1350 | { | 1548 | { |
1351 | struct buffer_head *bh = NULL; | 1549 | struct buffer_head *bh = NULL; |
@@ -1354,19 +1552,25 @@ static int udf_process_sequence(struct super_block *sb, long block, | |||
1354 | struct generic_desc *gd; | 1552 | struct generic_desc *gd; |
1355 | struct volDescPtr *vdp; | 1553 | struct volDescPtr *vdp; |
1356 | int done = 0; | 1554 | int done = 0; |
1357 | int i, j; | ||
1358 | uint32_t vdsn; | 1555 | uint32_t vdsn; |
1359 | uint16_t ident; | 1556 | uint16_t ident; |
1360 | long next_s = 0, next_e = 0; | 1557 | long next_s = 0, next_e = 0; |
1361 | 1558 | ||
1362 | memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH); | 1559 | memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH); |
1363 | 1560 | ||
1364 | /* Read the main descriptor sequence */ | 1561 | /* |
1562 | * Read the main descriptor sequence and find which descriptors | ||
1563 | * are in it. | ||
1564 | */ | ||
1365 | for (; (!done && block <= lastblock); block++) { | 1565 | for (; (!done && block <= lastblock); block++) { |
1366 | 1566 | ||
1367 | bh = udf_read_tagged(sb, block, block, &ident); | 1567 | bh = udf_read_tagged(sb, block, block, &ident); |
1368 | if (!bh) | 1568 | if (!bh) { |
1369 | break; | 1569 | printk(KERN_ERR "udf: Block %Lu of volume descriptor " |
1570 | "sequence is corrupted or we could not read " | ||
1571 | "it.\n", (unsigned long long)block); | ||
1572 | return 1; | ||
1573 | } | ||
1370 | 1574 | ||
1371 | /* Process each descriptor (ISO 13346 3/8.3-8.4) */ | 1575 | /* Process each descriptor (ISO 13346 3/8.3-8.4) */ |
1372 | gd = (struct generic_desc *)bh->b_data; | 1576 | gd = (struct generic_desc *)bh->b_data; |
@@ -1432,41 +1636,31 @@ static int udf_process_sequence(struct super_block *sb, long block, | |||
1432 | } | 1636 | } |
1433 | brelse(bh); | 1637 | brelse(bh); |
1434 | } | 1638 | } |
1435 | for (i = 0; i < VDS_POS_LENGTH; i++) { | 1639 | /* |
1436 | if (vds[i].block) { | 1640 | * Now read interesting descriptors again and process them |
1437 | bh = udf_read_tagged(sb, vds[i].block, vds[i].block, | 1641 | * in a suitable order |
1438 | &ident); | 1642 | */ |
1439 | 1643 | if (!vds[VDS_POS_PRIMARY_VOL_DESC].block) { | |
1440 | if (i == VDS_POS_PRIMARY_VOL_DESC) { | 1644 | printk(KERN_ERR "udf: Primary Volume Descriptor not found!\n"); |
1441 | udf_load_pvoldesc(sb, bh); | 1645 | return 1; |
1442 | } else if (i == VDS_POS_LOGICAL_VOL_DESC) { | 1646 | } |
1443 | if (udf_load_logicalvol(sb, bh, fileset)) { | 1647 | if (udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block)) |
1444 | brelse(bh); | 1648 | return 1; |
1445 | return 1; | 1649 | |
1446 | } | 1650 | if (vds[VDS_POS_LOGICAL_VOL_DESC].block && udf_load_logicalvol(sb, |
1447 | } else if (i == VDS_POS_PARTITION_DESC) { | 1651 | vds[VDS_POS_LOGICAL_VOL_DESC].block, fileset)) |
1448 | struct buffer_head *bh2 = NULL; | 1652 | return 1; |
1449 | if (udf_load_partdesc(sb, bh)) { | 1653 | |
1450 | brelse(bh); | 1654 | if (vds[VDS_POS_PARTITION_DESC].block) { |
1451 | return 1; | 1655 | /* |
1452 | } | 1656 | * We rescan the whole descriptor sequence to find |
1453 | for (j = vds[i].block + 1; | 1657 | * partition descriptor blocks and process them. |
1454 | j < vds[VDS_POS_TERMINATING_DESC].block; | 1658 | */ |
1455 | j++) { | 1659 | for (block = vds[VDS_POS_PARTITION_DESC].block; |
1456 | bh2 = udf_read_tagged(sb, j, j, &ident); | 1660 | block < vds[VDS_POS_TERMINATING_DESC].block; |
1457 | gd = (struct generic_desc *)bh2->b_data; | 1661 | block++) |
1458 | if (ident == TAG_IDENT_PD) | 1662 | if (udf_load_partdesc(sb, block)) |
1459 | if (udf_load_partdesc(sb, | 1663 | return 1; |
1460 | bh2)) { | ||
1461 | brelse(bh); | ||
1462 | brelse(bh2); | ||
1463 | return 1; | ||
1464 | } | ||
1465 | brelse(bh2); | ||
1466 | } | ||
1467 | } | ||
1468 | brelse(bh); | ||
1469 | } | ||
1470 | } | 1664 | } |
1471 | 1665 | ||
1472 | return 0; | 1666 | return 0; |
@@ -1478,6 +1672,7 @@ static int udf_process_sequence(struct super_block *sb, long block, | |||
1478 | static int udf_check_valid(struct super_block *sb, int novrs, int silent) | 1672 | static int udf_check_valid(struct super_block *sb, int novrs, int silent) |
1479 | { | 1673 | { |
1480 | long block; | 1674 | long block; |
1675 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
1481 | 1676 | ||
1482 | if (novrs) { | 1677 | if (novrs) { |
1483 | udf_debug("Validity check skipped because of novrs option\n"); | 1678 | udf_debug("Validity check skipped because of novrs option\n"); |
@@ -1485,27 +1680,22 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent) | |||
1485 | } | 1680 | } |
1486 | /* Check that it is NSR02 compliant */ | 1681 | /* Check that it is NSR02 compliant */ |
1487 | /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */ | 1682 | /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */ |
1488 | else { | 1683 | block = udf_vrs(sb, silent); |
1489 | block = udf_vrs(sb, silent); | 1684 | if (block == -1) |
1490 | if (block == -1) { | 1685 | udf_debug("Failed to read byte 32768. Assuming open " |
1491 | struct udf_sb_info *sbi = UDF_SB(sb); | 1686 | "disc. Skipping validity check\n"); |
1492 | udf_debug("Failed to read byte 32768. Assuming open " | 1687 | if (block && !sbi->s_last_block) |
1493 | "disc. Skipping validity check\n"); | 1688 | sbi->s_last_block = udf_get_last_block(sb); |
1494 | if (!sbi->s_last_block) | 1689 | return !block; |
1495 | sbi->s_last_block = udf_get_last_block(sb); | ||
1496 | return 0; | ||
1497 | } else | ||
1498 | return !block; | ||
1499 | } | ||
1500 | } | 1690 | } |
1501 | 1691 | ||
1502 | static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) | 1692 | static int udf_load_sequence(struct super_block *sb, kernel_lb_addr *fileset) |
1503 | { | 1693 | { |
1504 | struct anchorVolDescPtr *anchor; | 1694 | struct anchorVolDescPtr *anchor; |
1505 | uint16_t ident; | 1695 | uint16_t ident; |
1506 | struct buffer_head *bh; | 1696 | struct buffer_head *bh; |
1507 | long main_s, main_e, reserve_s, reserve_e; | 1697 | long main_s, main_e, reserve_s, reserve_e; |
1508 | int i, j; | 1698 | int i; |
1509 | struct udf_sb_info *sbi; | 1699 | struct udf_sb_info *sbi; |
1510 | 1700 | ||
1511 | if (!sb) | 1701 | if (!sb) |
@@ -1515,6 +1705,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) | |||
1515 | for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) { | 1705 | for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) { |
1516 | if (!sbi->s_anchor[i]) | 1706 | if (!sbi->s_anchor[i]) |
1517 | continue; | 1707 | continue; |
1708 | |||
1518 | bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i], | 1709 | bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i], |
1519 | &ident); | 1710 | &ident); |
1520 | if (!bh) | 1711 | if (!bh) |
@@ -1553,76 +1744,6 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) | |||
1553 | } | 1744 | } |
1554 | udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]); | 1745 | udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]); |
1555 | 1746 | ||
1556 | for (i = 0; i < sbi->s_partitions; i++) { | ||
1557 | kernel_lb_addr uninitialized_var(ino); | ||
1558 | struct udf_part_map *map = &sbi->s_partmaps[i]; | ||
1559 | switch (map->s_partition_type) { | ||
1560 | case UDF_VIRTUAL_MAP15: | ||
1561 | case UDF_VIRTUAL_MAP20: | ||
1562 | if (!sbi->s_last_block) { | ||
1563 | sbi->s_last_block = udf_get_last_block(sb); | ||
1564 | udf_find_anchor(sb); | ||
1565 | } | ||
1566 | |||
1567 | if (!sbi->s_last_block) { | ||
1568 | udf_debug("Unable to determine Lastblock (For " | ||
1569 | "Virtual Partition)\n"); | ||
1570 | return 1; | ||
1571 | } | ||
1572 | |||
1573 | for (j = 0; j < sbi->s_partitions; j++) { | ||
1574 | struct udf_part_map *map2 = &sbi->s_partmaps[j]; | ||
1575 | if (j != i && | ||
1576 | map->s_volumeseqnum == | ||
1577 | map2->s_volumeseqnum && | ||
1578 | map->s_partition_num == | ||
1579 | map2->s_partition_num) { | ||
1580 | ino.partitionReferenceNum = j; | ||
1581 | ino.logicalBlockNum = | ||
1582 | sbi->s_last_block - | ||
1583 | map2->s_partition_root; | ||
1584 | break; | ||
1585 | } | ||
1586 | } | ||
1587 | |||
1588 | if (j == sbi->s_partitions) | ||
1589 | return 1; | ||
1590 | |||
1591 | sbi->s_vat_inode = udf_iget(sb, ino); | ||
1592 | if (!sbi->s_vat_inode) | ||
1593 | return 1; | ||
1594 | |||
1595 | if (map->s_partition_type == UDF_VIRTUAL_MAP15) { | ||
1596 | map->s_type_specific.s_virtual.s_start_offset = | ||
1597 | udf_ext0_offset(sbi->s_vat_inode); | ||
1598 | map->s_type_specific.s_virtual.s_num_entries = | ||
1599 | (sbi->s_vat_inode->i_size - 36) >> 2; | ||
1600 | } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) { | ||
1601 | uint32_t pos; | ||
1602 | struct virtualAllocationTable20 *vat20; | ||
1603 | |||
1604 | pos = udf_block_map(sbi->s_vat_inode, 0); | ||
1605 | bh = sb_bread(sb, pos); | ||
1606 | if (!bh) | ||
1607 | return 1; | ||
1608 | vat20 = (struct virtualAllocationTable20 *) | ||
1609 | bh->b_data + | ||
1610 | udf_ext0_offset(sbi->s_vat_inode); | ||
1611 | map->s_type_specific.s_virtual.s_start_offset = | ||
1612 | le16_to_cpu(vat20->lengthHeader) + | ||
1613 | udf_ext0_offset(sbi->s_vat_inode); | ||
1614 | map->s_type_specific.s_virtual.s_num_entries = | ||
1615 | (sbi->s_vat_inode->i_size - | ||
1616 | map->s_type_specific.s_virtual. | ||
1617 | s_start_offset) >> 2; | ||
1618 | brelse(bh); | ||
1619 | } | ||
1620 | map->s_partition_root = udf_get_pblock(sb, 0, i, 0); | ||
1621 | map->s_partition_len = | ||
1622 | sbi->s_partmaps[ino.partitionReferenceNum]. | ||
1623 | s_partition_len; | ||
1624 | } | ||
1625 | } | ||
1626 | return 0; | 1747 | return 0; |
1627 | } | 1748 | } |
1628 | 1749 | ||
@@ -1630,65 +1751,61 @@ static void udf_open_lvid(struct super_block *sb) | |||
1630 | { | 1751 | { |
1631 | struct udf_sb_info *sbi = UDF_SB(sb); | 1752 | struct udf_sb_info *sbi = UDF_SB(sb); |
1632 | struct buffer_head *bh = sbi->s_lvid_bh; | 1753 | struct buffer_head *bh = sbi->s_lvid_bh; |
1633 | if (bh) { | 1754 | struct logicalVolIntegrityDesc *lvid; |
1634 | kernel_timestamp cpu_time; | 1755 | struct logicalVolIntegrityDescImpUse *lvidiu; |
1635 | struct logicalVolIntegrityDesc *lvid = | 1756 | if (!bh) |
1636 | (struct logicalVolIntegrityDesc *)bh->b_data; | 1757 | return; |
1637 | struct logicalVolIntegrityDescImpUse *lvidiu = | ||
1638 | udf_sb_lvidiu(sbi); | ||
1639 | 1758 | ||
1640 | lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; | 1759 | lvid = (struct logicalVolIntegrityDesc *)bh->b_data; |
1641 | lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; | 1760 | lvidiu = udf_sb_lvidiu(sbi); |
1642 | if (udf_time_to_stamp(&cpu_time, CURRENT_TIME)) | ||
1643 | lvid->recordingDateAndTime = cpu_to_lets(cpu_time); | ||
1644 | lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN; | ||
1645 | 1761 | ||
1646 | lvid->descTag.descCRC = cpu_to_le16( | 1762 | lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; |
1647 | udf_crc((char *)lvid + sizeof(tag), | 1763 | lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; |
1648 | le16_to_cpu(lvid->descTag.descCRCLength), | 1764 | udf_time_to_disk_stamp(&lvid->recordingDateAndTime, |
1649 | 0)); | 1765 | CURRENT_TIME); |
1766 | lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN; | ||
1650 | 1767 | ||
1651 | lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); | 1768 | lvid->descTag.descCRC = cpu_to_le16( |
1652 | mark_buffer_dirty(bh); | 1769 | crc_itu_t(0, (char *)lvid + sizeof(tag), |
1653 | } | 1770 | le16_to_cpu(lvid->descTag.descCRCLength))); |
1771 | |||
1772 | lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); | ||
1773 | mark_buffer_dirty(bh); | ||
1654 | } | 1774 | } |
1655 | 1775 | ||
1656 | static void udf_close_lvid(struct super_block *sb) | 1776 | static void udf_close_lvid(struct super_block *sb) |
1657 | { | 1777 | { |
1658 | kernel_timestamp cpu_time; | ||
1659 | struct udf_sb_info *sbi = UDF_SB(sb); | 1778 | struct udf_sb_info *sbi = UDF_SB(sb); |
1660 | struct buffer_head *bh = sbi->s_lvid_bh; | 1779 | struct buffer_head *bh = sbi->s_lvid_bh; |
1661 | struct logicalVolIntegrityDesc *lvid; | 1780 | struct logicalVolIntegrityDesc *lvid; |
1781 | struct logicalVolIntegrityDescImpUse *lvidiu; | ||
1662 | 1782 | ||
1663 | if (!bh) | 1783 | if (!bh) |
1664 | return; | 1784 | return; |
1665 | 1785 | ||
1666 | lvid = (struct logicalVolIntegrityDesc *)bh->b_data; | 1786 | lvid = (struct logicalVolIntegrityDesc *)bh->b_data; |
1667 | 1787 | ||
1668 | if (lvid->integrityType == LVID_INTEGRITY_TYPE_OPEN) { | 1788 | if (lvid->integrityType != LVID_INTEGRITY_TYPE_OPEN) |
1669 | struct logicalVolIntegrityDescImpUse *lvidiu = | 1789 | return; |
1670 | udf_sb_lvidiu(sbi); | 1790 | |
1671 | lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; | 1791 | lvidiu = udf_sb_lvidiu(sbi); |
1672 | lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; | 1792 | lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; |
1673 | if (udf_time_to_stamp(&cpu_time, CURRENT_TIME)) | 1793 | lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; |
1674 | lvid->recordingDateAndTime = cpu_to_lets(cpu_time); | 1794 | udf_time_to_disk_stamp(&lvid->recordingDateAndTime, CURRENT_TIME); |
1675 | if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev)) | 1795 | if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev)) |
1676 | lvidiu->maxUDFWriteRev = | 1796 | lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION); |
1677 | cpu_to_le16(UDF_MAX_WRITE_VERSION); | 1797 | if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev)) |
1678 | if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev)) | 1798 | lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev); |
1679 | lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev); | 1799 | if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev)) |
1680 | if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev)) | 1800 | lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev); |
1681 | lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev); | 1801 | lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE); |
1682 | lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE); | 1802 | |
1683 | 1803 | lvid->descTag.descCRC = cpu_to_le16( | |
1684 | lvid->descTag.descCRC = cpu_to_le16( | 1804 | crc_itu_t(0, (char *)lvid + sizeof(tag), |
1685 | udf_crc((char *)lvid + sizeof(tag), | 1805 | le16_to_cpu(lvid->descTag.descCRCLength))); |
1686 | le16_to_cpu(lvid->descTag.descCRCLength), | 1806 | |
1687 | 0)); | 1807 | lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); |
1688 | 1808 | mark_buffer_dirty(bh); | |
1689 | lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); | ||
1690 | mark_buffer_dirty(bh); | ||
1691 | } | ||
1692 | } | 1809 | } |
1693 | 1810 | ||
1694 | static void udf_sb_free_bitmap(struct udf_bitmap *bitmap) | 1811 | static void udf_sb_free_bitmap(struct udf_bitmap *bitmap) |
@@ -1708,22 +1825,35 @@ static void udf_sb_free_bitmap(struct udf_bitmap *bitmap) | |||
1708 | vfree(bitmap); | 1825 | vfree(bitmap); |
1709 | } | 1826 | } |
1710 | 1827 | ||
1711 | /* | 1828 | static void udf_free_partition(struct udf_part_map *map) |
1712 | * udf_read_super | 1829 | { |
1713 | * | 1830 | int i; |
1714 | * PURPOSE | 1831 | struct udf_meta_data *mdata; |
1715 | * Complete the specified super block. | 1832 | |
1716 | * | 1833 | if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) |
1717 | * PRE-CONDITIONS | 1834 | iput(map->s_uspace.s_table); |
1718 | * sb Pointer to superblock to complete - never NULL. | 1835 | if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) |
1719 | * sb->s_dev Device to read suberblock from. | 1836 | iput(map->s_fspace.s_table); |
1720 | * options Pointer to mount options. | 1837 | if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) |
1721 | * silent Silent flag. | 1838 | udf_sb_free_bitmap(map->s_uspace.s_bitmap); |
1722 | * | 1839 | if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) |
1723 | * HISTORY | 1840 | udf_sb_free_bitmap(map->s_fspace.s_bitmap); |
1724 | * July 1, 1997 - Andrew E. Mileski | 1841 | if (map->s_partition_type == UDF_SPARABLE_MAP15) |
1725 | * Written, tested, and released. | 1842 | for (i = 0; i < 4; i++) |
1726 | */ | 1843 | brelse(map->s_type_specific.s_sparing.s_spar_map[i]); |
1844 | else if (map->s_partition_type == UDF_METADATA_MAP25) { | ||
1845 | mdata = &map->s_type_specific.s_metadata; | ||
1846 | iput(mdata->s_metadata_fe); | ||
1847 | mdata->s_metadata_fe = NULL; | ||
1848 | |||
1849 | iput(mdata->s_mirror_fe); | ||
1850 | mdata->s_mirror_fe = NULL; | ||
1851 | |||
1852 | iput(mdata->s_bitmap_fe); | ||
1853 | mdata->s_bitmap_fe = NULL; | ||
1854 | } | ||
1855 | } | ||
1856 | |||
1727 | static int udf_fill_super(struct super_block *sb, void *options, int silent) | 1857 | static int udf_fill_super(struct super_block *sb, void *options, int silent) |
1728 | { | 1858 | { |
1729 | int i; | 1859 | int i; |
@@ -1776,8 +1906,11 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) | |||
1776 | sbi->s_nls_map = uopt.nls_map; | 1906 | sbi->s_nls_map = uopt.nls_map; |
1777 | 1907 | ||
1778 | /* Set the block size for all transfers */ | 1908 | /* Set the block size for all transfers */ |
1779 | if (!udf_set_blocksize(sb, uopt.blocksize)) | 1909 | if (!sb_min_blocksize(sb, uopt.blocksize)) { |
1910 | udf_debug("Bad block size (%d)\n", uopt.blocksize); | ||
1911 | printk(KERN_ERR "udf: bad block size (%d)\n", uopt.blocksize); | ||
1780 | goto error_out; | 1912 | goto error_out; |
1913 | } | ||
1781 | 1914 | ||
1782 | if (uopt.session == 0xFFFFFFFF) | 1915 | if (uopt.session == 0xFFFFFFFF) |
1783 | sbi->s_session = udf_get_last_session(sb); | 1916 | sbi->s_session = udf_get_last_session(sb); |
@@ -1789,7 +1922,6 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) | |||
1789 | sbi->s_last_block = uopt.lastblock; | 1922 | sbi->s_last_block = uopt.lastblock; |
1790 | sbi->s_anchor[0] = sbi->s_anchor[1] = 0; | 1923 | sbi->s_anchor[0] = sbi->s_anchor[1] = 0; |
1791 | sbi->s_anchor[2] = uopt.anchor; | 1924 | sbi->s_anchor[2] = uopt.anchor; |
1792 | sbi->s_anchor[3] = 256; | ||
1793 | 1925 | ||
1794 | if (udf_check_valid(sb, uopt.novrs, silent)) { | 1926 | if (udf_check_valid(sb, uopt.novrs, silent)) { |
1795 | /* read volume recognition sequences */ | 1927 | /* read volume recognition sequences */ |
@@ -1806,7 +1938,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) | |||
1806 | sb->s_magic = UDF_SUPER_MAGIC; | 1938 | sb->s_magic = UDF_SUPER_MAGIC; |
1807 | sb->s_time_gran = 1000; | 1939 | sb->s_time_gran = 1000; |
1808 | 1940 | ||
1809 | if (udf_load_partition(sb, &fileset)) { | 1941 | if (udf_load_sequence(sb, &fileset)) { |
1810 | printk(KERN_WARNING "UDF-fs: No partition found (1)\n"); | 1942 | printk(KERN_WARNING "UDF-fs: No partition found (1)\n"); |
1811 | goto error_out; | 1943 | goto error_out; |
1812 | } | 1944 | } |
@@ -1856,12 +1988,12 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) | |||
1856 | } | 1988 | } |
1857 | 1989 | ||
1858 | if (!silent) { | 1990 | if (!silent) { |
1859 | kernel_timestamp ts; | 1991 | timestamp ts; |
1860 | udf_time_to_stamp(&ts, sbi->s_record_time); | 1992 | udf_time_to_disk_stamp(&ts, sbi->s_record_time); |
1861 | udf_info("UDF: Mounting volume '%s', " | 1993 | udf_info("UDF: Mounting volume '%s', " |
1862 | "timestamp %04u/%02u/%02u %02u:%02u (%x)\n", | 1994 | "timestamp %04u/%02u/%02u %02u:%02u (%x)\n", |
1863 | sbi->s_volume_ident, ts.year, ts.month, ts.day, | 1995 | sbi->s_volume_ident, le16_to_cpu(ts.year), ts.month, ts.day, |
1864 | ts.hour, ts.minute, ts.typeAndTimezone); | 1996 | ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone)); |
1865 | } | 1997 | } |
1866 | if (!(sb->s_flags & MS_RDONLY)) | 1998 | if (!(sb->s_flags & MS_RDONLY)) |
1867 | udf_open_lvid(sb); | 1999 | udf_open_lvid(sb); |
@@ -1890,21 +2022,9 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) | |||
1890 | error_out: | 2022 | error_out: |
1891 | if (sbi->s_vat_inode) | 2023 | if (sbi->s_vat_inode) |
1892 | iput(sbi->s_vat_inode); | 2024 | iput(sbi->s_vat_inode); |
1893 | if (sbi->s_partitions) { | 2025 | if (sbi->s_partitions) |
1894 | struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition]; | 2026 | for (i = 0; i < sbi->s_partitions; i++) |
1895 | if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) | 2027 | udf_free_partition(&sbi->s_partmaps[i]); |
1896 | iput(map->s_uspace.s_table); | ||
1897 | if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) | ||
1898 | iput(map->s_fspace.s_table); | ||
1899 | if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) | ||
1900 | udf_sb_free_bitmap(map->s_uspace.s_bitmap); | ||
1901 | if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) | ||
1902 | udf_sb_free_bitmap(map->s_fspace.s_bitmap); | ||
1903 | if (map->s_partition_type == UDF_SPARABLE_MAP15) | ||
1904 | for (i = 0; i < 4; i++) | ||
1905 | brelse(map->s_type_specific.s_sparing. | ||
1906 | s_spar_map[i]); | ||
1907 | } | ||
1908 | #ifdef CONFIG_UDF_NLS | 2028 | #ifdef CONFIG_UDF_NLS |
1909 | if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) | 2029 | if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) |
1910 | unload_nls(sbi->s_nls_map); | 2030 | unload_nls(sbi->s_nls_map); |
@@ -1920,8 +2040,8 @@ error_out: | |||
1920 | return -EINVAL; | 2040 | return -EINVAL; |
1921 | } | 2041 | } |
1922 | 2042 | ||
1923 | void udf_error(struct super_block *sb, const char *function, | 2043 | static void udf_error(struct super_block *sb, const char *function, |
1924 | const char *fmt, ...) | 2044 | const char *fmt, ...) |
1925 | { | 2045 | { |
1926 | va_list args; | 2046 | va_list args; |
1927 | 2047 | ||
@@ -1948,19 +2068,6 @@ void udf_warning(struct super_block *sb, const char *function, | |||
1948 | sb->s_id, function, error_buf); | 2068 | sb->s_id, function, error_buf); |
1949 | } | 2069 | } |
1950 | 2070 | ||
1951 | /* | ||
1952 | * udf_put_super | ||
1953 | * | ||
1954 | * PURPOSE | ||
1955 | * Prepare for destruction of the superblock. | ||
1956 | * | ||
1957 | * DESCRIPTION | ||
1958 | * Called before the filesystem is unmounted. | ||
1959 | * | ||
1960 | * HISTORY | ||
1961 | * July 1, 1997 - Andrew E. Mileski | ||
1962 | * Written, tested, and released. | ||
1963 | */ | ||
1964 | static void udf_put_super(struct super_block *sb) | 2071 | static void udf_put_super(struct super_block *sb) |
1965 | { | 2072 | { |
1966 | int i; | 2073 | int i; |
@@ -1969,21 +2076,9 @@ static void udf_put_super(struct super_block *sb) | |||
1969 | sbi = UDF_SB(sb); | 2076 | sbi = UDF_SB(sb); |
1970 | if (sbi->s_vat_inode) | 2077 | if (sbi->s_vat_inode) |
1971 | iput(sbi->s_vat_inode); | 2078 | iput(sbi->s_vat_inode); |
1972 | if (sbi->s_partitions) { | 2079 | if (sbi->s_partitions) |
1973 | struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition]; | 2080 | for (i = 0; i < sbi->s_partitions; i++) |
1974 | if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) | 2081 | udf_free_partition(&sbi->s_partmaps[i]); |
1975 | iput(map->s_uspace.s_table); | ||
1976 | if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) | ||
1977 | iput(map->s_fspace.s_table); | ||
1978 | if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) | ||
1979 | udf_sb_free_bitmap(map->s_uspace.s_bitmap); | ||
1980 | if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) | ||
1981 | udf_sb_free_bitmap(map->s_fspace.s_bitmap); | ||
1982 | if (map->s_partition_type == UDF_SPARABLE_MAP15) | ||
1983 | for (i = 0; i < 4; i++) | ||
1984 | brelse(map->s_type_specific.s_sparing. | ||
1985 | s_spar_map[i]); | ||
1986 | } | ||
1987 | #ifdef CONFIG_UDF_NLS | 2082 | #ifdef CONFIG_UDF_NLS |
1988 | if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) | 2083 | if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) |
1989 | unload_nls(sbi->s_nls_map); | 2084 | unload_nls(sbi->s_nls_map); |
@@ -1996,19 +2091,6 @@ static void udf_put_super(struct super_block *sb) | |||
1996 | sb->s_fs_info = NULL; | 2091 | sb->s_fs_info = NULL; |
1997 | } | 2092 | } |
1998 | 2093 | ||
1999 | /* | ||
2000 | * udf_stat_fs | ||
2001 | * | ||
2002 | * PURPOSE | ||
2003 | * Return info about the filesystem. | ||
2004 | * | ||
2005 | * DESCRIPTION | ||
2006 | * Called by sys_statfs() | ||
2007 | * | ||
2008 | * HISTORY | ||
2009 | * July 1, 1997 - Andrew E. Mileski | ||
2010 | * Written, tested, and released. | ||
2011 | */ | ||
2012 | static int udf_statfs(struct dentry *dentry, struct kstatfs *buf) | 2094 | static int udf_statfs(struct dentry *dentry, struct kstatfs *buf) |
2013 | { | 2095 | { |
2014 | struct super_block *sb = dentry->d_sb; | 2096 | struct super_block *sb = dentry->d_sb; |
@@ -2035,10 +2117,6 @@ static int udf_statfs(struct dentry *dentry, struct kstatfs *buf) | |||
2035 | return 0; | 2117 | return 0; |
2036 | } | 2118 | } |
2037 | 2119 | ||
2038 | static unsigned char udf_bitmap_lookup[16] = { | ||
2039 | 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 | ||
2040 | }; | ||
2041 | |||
2042 | static unsigned int udf_count_free_bitmap(struct super_block *sb, | 2120 | static unsigned int udf_count_free_bitmap(struct super_block *sb, |
2043 | struct udf_bitmap *bitmap) | 2121 | struct udf_bitmap *bitmap) |
2044 | { | 2122 | { |
@@ -2048,7 +2126,6 @@ static unsigned int udf_count_free_bitmap(struct super_block *sb, | |||
2048 | int block = 0, newblock; | 2126 | int block = 0, newblock; |
2049 | kernel_lb_addr loc; | 2127 | kernel_lb_addr loc; |
2050 | uint32_t bytes; | 2128 | uint32_t bytes; |
2051 | uint8_t value; | ||
2052 | uint8_t *ptr; | 2129 | uint8_t *ptr; |
2053 | uint16_t ident; | 2130 | uint16_t ident; |
2054 | struct spaceBitmapDesc *bm; | 2131 | struct spaceBitmapDesc *bm; |
@@ -2074,13 +2151,10 @@ static unsigned int udf_count_free_bitmap(struct super_block *sb, | |||
2074 | ptr = (uint8_t *)bh->b_data; | 2151 | ptr = (uint8_t *)bh->b_data; |
2075 | 2152 | ||
2076 | while (bytes > 0) { | 2153 | while (bytes > 0) { |
2077 | while ((bytes > 0) && (index < sb->s_blocksize)) { | 2154 | u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index); |
2078 | value = ptr[index]; | 2155 | accum += bitmap_weight((const unsigned long *)(ptr + index), |
2079 | accum += udf_bitmap_lookup[value & 0x0f]; | 2156 | cur_bytes * 8); |
2080 | accum += udf_bitmap_lookup[value >> 4]; | 2157 | bytes -= cur_bytes; |
2081 | index++; | ||
2082 | bytes--; | ||
2083 | } | ||
2084 | if (bytes) { | 2158 | if (bytes) { |
2085 | brelse(bh); | 2159 | brelse(bh); |
2086 | newblock = udf_get_lb_pblock(sb, loc, ++block); | 2160 | newblock = udf_get_lb_pblock(sb, loc, ++block); |
diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c index 6ec99221e50c..c3265e1385d4 100644 --- a/fs/udf/symlink.c +++ b/fs/udf/symlink.c | |||
@@ -23,7 +23,6 @@ | |||
23 | #include <asm/uaccess.h> | 23 | #include <asm/uaccess.h> |
24 | #include <linux/errno.h> | 24 | #include <linux/errno.h> |
25 | #include <linux/fs.h> | 25 | #include <linux/fs.h> |
26 | #include <linux/udf_fs.h> | ||
27 | #include <linux/time.h> | 26 | #include <linux/time.h> |
28 | #include <linux/mm.h> | 27 | #include <linux/mm.h> |
29 | #include <linux/stat.h> | 28 | #include <linux/stat.h> |
diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c index fe61be17cdab..65e19b4f9424 100644 --- a/fs/udf/truncate.c +++ b/fs/udf/truncate.c | |||
@@ -22,7 +22,6 @@ | |||
22 | #include "udfdecl.h" | 22 | #include "udfdecl.h" |
23 | #include <linux/fs.h> | 23 | #include <linux/fs.h> |
24 | #include <linux/mm.h> | 24 | #include <linux/mm.h> |
25 | #include <linux/udf_fs.h> | ||
26 | #include <linux/buffer_head.h> | 25 | #include <linux/buffer_head.h> |
27 | 26 | ||
28 | #include "udf_i.h" | 27 | #include "udf_i.h" |
@@ -180,6 +179,24 @@ void udf_discard_prealloc(struct inode *inode) | |||
180 | brelse(epos.bh); | 179 | brelse(epos.bh); |
181 | } | 180 | } |
182 | 181 | ||
182 | static void udf_update_alloc_ext_desc(struct inode *inode, | ||
183 | struct extent_position *epos, | ||
184 | u32 lenalloc) | ||
185 | { | ||
186 | struct super_block *sb = inode->i_sb; | ||
187 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
188 | |||
189 | struct allocExtDesc *aed = (struct allocExtDesc *) (epos->bh->b_data); | ||
190 | int len = sizeof(struct allocExtDesc); | ||
191 | |||
192 | aed->lengthAllocDescs = cpu_to_le32(lenalloc); | ||
193 | if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || sbi->s_udfrev >= 0x0201) | ||
194 | len += lenalloc; | ||
195 | |||
196 | udf_update_tag(epos->bh->b_data, len); | ||
197 | mark_buffer_dirty_inode(epos->bh, inode); | ||
198 | } | ||
199 | |||
183 | void udf_truncate_extents(struct inode *inode) | 200 | void udf_truncate_extents(struct inode *inode) |
184 | { | 201 | { |
185 | struct extent_position epos; | 202 | struct extent_position epos; |
@@ -187,7 +204,6 @@ void udf_truncate_extents(struct inode *inode) | |||
187 | uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc; | 204 | uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc; |
188 | int8_t etype; | 205 | int8_t etype; |
189 | struct super_block *sb = inode->i_sb; | 206 | struct super_block *sb = inode->i_sb; |
190 | struct udf_sb_info *sbi = UDF_SB(sb); | ||
191 | sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset; | 207 | sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset; |
192 | loff_t byte_offset; | 208 | loff_t byte_offset; |
193 | int adsize; | 209 | int adsize; |
@@ -224,35 +240,15 @@ void udf_truncate_extents(struct inode *inode) | |||
224 | if (indirect_ext_len) { | 240 | if (indirect_ext_len) { |
225 | /* We managed to free all extents in the | 241 | /* We managed to free all extents in the |
226 | * indirect extent - free it too */ | 242 | * indirect extent - free it too */ |
227 | if (!epos.bh) | 243 | BUG_ON(!epos.bh); |
228 | BUG(); | ||
229 | udf_free_blocks(sb, inode, epos.block, | 244 | udf_free_blocks(sb, inode, epos.block, |
230 | 0, indirect_ext_len); | 245 | 0, indirect_ext_len); |
231 | } else { | 246 | } else if (!epos.bh) { |
232 | if (!epos.bh) { | 247 | iinfo->i_lenAlloc = lenalloc; |
233 | iinfo->i_lenAlloc = | 248 | mark_inode_dirty(inode); |
234 | lenalloc; | 249 | } else |
235 | mark_inode_dirty(inode); | 250 | udf_update_alloc_ext_desc(inode, |
236 | } else { | 251 | &epos, lenalloc); |
237 | struct allocExtDesc *aed = | ||
238 | (struct allocExtDesc *) | ||
239 | (epos.bh->b_data); | ||
240 | int len = | ||
241 | sizeof(struct allocExtDesc); | ||
242 | |||
243 | aed->lengthAllocDescs = | ||
244 | cpu_to_le32(lenalloc); | ||
245 | if (!UDF_QUERY_FLAG(sb, | ||
246 | UDF_FLAG_STRICT) || | ||
247 | sbi->s_udfrev >= 0x0201) | ||
248 | len += lenalloc; | ||
249 | |||
250 | udf_update_tag(epos.bh->b_data, | ||
251 | len); | ||
252 | mark_buffer_dirty_inode( | ||
253 | epos.bh, inode); | ||
254 | } | ||
255 | } | ||
256 | brelse(epos.bh); | 252 | brelse(epos.bh); |
257 | epos.offset = sizeof(struct allocExtDesc); | 253 | epos.offset = sizeof(struct allocExtDesc); |
258 | epos.block = eloc; | 254 | epos.block = eloc; |
@@ -272,29 +268,14 @@ void udf_truncate_extents(struct inode *inode) | |||
272 | } | 268 | } |
273 | 269 | ||
274 | if (indirect_ext_len) { | 270 | if (indirect_ext_len) { |
275 | if (!epos.bh) | 271 | BUG_ON(!epos.bh); |
276 | BUG(); | ||
277 | udf_free_blocks(sb, inode, epos.block, 0, | 272 | udf_free_blocks(sb, inode, epos.block, 0, |
278 | indirect_ext_len); | 273 | indirect_ext_len); |
279 | } else { | 274 | } else if (!epos.bh) { |
280 | if (!epos.bh) { | 275 | iinfo->i_lenAlloc = lenalloc; |
281 | iinfo->i_lenAlloc = lenalloc; | 276 | mark_inode_dirty(inode); |
282 | mark_inode_dirty(inode); | 277 | } else |
283 | } else { | 278 | udf_update_alloc_ext_desc(inode, &epos, lenalloc); |
284 | struct allocExtDesc *aed = | ||
285 | (struct allocExtDesc *)(epos.bh->b_data); | ||
286 | aed->lengthAllocDescs = cpu_to_le32(lenalloc); | ||
287 | if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || | ||
288 | sbi->s_udfrev >= 0x0201) | ||
289 | udf_update_tag(epos.bh->b_data, | ||
290 | lenalloc + | ||
291 | sizeof(struct allocExtDesc)); | ||
292 | else | ||
293 | udf_update_tag(epos.bh->b_data, | ||
294 | sizeof(struct allocExtDesc)); | ||
295 | mark_buffer_dirty_inode(epos.bh, inode); | ||
296 | } | ||
297 | } | ||
298 | } else if (inode->i_size) { | 279 | } else if (inode->i_size) { |
299 | if (byte_offset) { | 280 | if (byte_offset) { |
300 | kernel_long_ad extent; | 281 | kernel_long_ad extent; |
diff --git a/fs/udf/udf_i.h b/fs/udf/udf_i.h index ccc52f16bf7d..4f86b1d98a5d 100644 --- a/fs/udf/udf_i.h +++ b/fs/udf/udf_i.h | |||
@@ -1,10 +1,32 @@ | |||
1 | #ifndef __LINUX_UDF_I_H | 1 | #ifndef _UDF_I_H |
2 | #define __LINUX_UDF_I_H | 2 | #define _UDF_I_H |
3 | |||
4 | struct udf_inode_info { | ||
5 | struct timespec i_crtime; | ||
6 | /* Physical address of inode */ | ||
7 | kernel_lb_addr i_location; | ||
8 | __u64 i_unique; | ||
9 | __u32 i_lenEAttr; | ||
10 | __u32 i_lenAlloc; | ||
11 | __u64 i_lenExtents; | ||
12 | __u32 i_next_alloc_block; | ||
13 | __u32 i_next_alloc_goal; | ||
14 | unsigned i_alloc_type : 3; | ||
15 | unsigned i_efe : 1; /* extendedFileEntry */ | ||
16 | unsigned i_use : 1; /* unallocSpaceEntry */ | ||
17 | unsigned i_strat4096 : 1; | ||
18 | unsigned reserved : 26; | ||
19 | union { | ||
20 | short_ad *i_sad; | ||
21 | long_ad *i_lad; | ||
22 | __u8 *i_data; | ||
23 | } i_ext; | ||
24 | struct inode vfs_inode; | ||
25 | }; | ||
3 | 26 | ||
4 | #include <linux/udf_fs_i.h> | ||
5 | static inline struct udf_inode_info *UDF_I(struct inode *inode) | 27 | static inline struct udf_inode_info *UDF_I(struct inode *inode) |
6 | { | 28 | { |
7 | return list_entry(inode, struct udf_inode_info, vfs_inode); | 29 | return list_entry(inode, struct udf_inode_info, vfs_inode); |
8 | } | 30 | } |
9 | 31 | ||
10 | #endif /* !defined(_LINUX_UDF_I_H) */ | 32 | #endif /* _UDF_I_H) */ |
diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h index 737d1c604eea..1c1c514a9725 100644 --- a/fs/udf/udf_sb.h +++ b/fs/udf/udf_sb.h | |||
@@ -1,10 +1,12 @@ | |||
1 | #ifndef __LINUX_UDF_SB_H | 1 | #ifndef __LINUX_UDF_SB_H |
2 | #define __LINUX_UDF_SB_H | 2 | #define __LINUX_UDF_SB_H |
3 | 3 | ||
4 | #include <linux/mutex.h> | ||
5 | |||
4 | /* Since UDF 2.01 is ISO 13346 based... */ | 6 | /* Since UDF 2.01 is ISO 13346 based... */ |
5 | #define UDF_SUPER_MAGIC 0x15013346 | 7 | #define UDF_SUPER_MAGIC 0x15013346 |
6 | 8 | ||
7 | #define UDF_MAX_READ_VERSION 0x0201 | 9 | #define UDF_MAX_READ_VERSION 0x0250 |
8 | #define UDF_MAX_WRITE_VERSION 0x0201 | 10 | #define UDF_MAX_WRITE_VERSION 0x0201 |
9 | 11 | ||
10 | #define UDF_FLAG_USE_EXTENDED_FE 0 | 12 | #define UDF_FLAG_USE_EXTENDED_FE 0 |
@@ -38,6 +40,111 @@ | |||
38 | #define UDF_PART_FLAG_REWRITABLE 0x0040 | 40 | #define UDF_PART_FLAG_REWRITABLE 0x0040 |
39 | #define UDF_PART_FLAG_OVERWRITABLE 0x0080 | 41 | #define UDF_PART_FLAG_OVERWRITABLE 0x0080 |
40 | 42 | ||
43 | #define UDF_MAX_BLOCK_LOADED 8 | ||
44 | |||
45 | #define UDF_TYPE1_MAP15 0x1511U | ||
46 | #define UDF_VIRTUAL_MAP15 0x1512U | ||
47 | #define UDF_VIRTUAL_MAP20 0x2012U | ||
48 | #define UDF_SPARABLE_MAP15 0x1522U | ||
49 | #define UDF_METADATA_MAP25 0x2511U | ||
50 | |||
51 | #pragma pack(1) /* XXX(hch): Why? This file just defines in-core structures */ | ||
52 | |||
53 | struct udf_meta_data { | ||
54 | __u32 s_meta_file_loc; | ||
55 | __u32 s_mirror_file_loc; | ||
56 | __u32 s_bitmap_file_loc; | ||
57 | __u32 s_alloc_unit_size; | ||
58 | __u16 s_align_unit_size; | ||
59 | __u8 s_dup_md_flag; | ||
60 | struct inode *s_metadata_fe; | ||
61 | struct inode *s_mirror_fe; | ||
62 | struct inode *s_bitmap_fe; | ||
63 | }; | ||
64 | |||
65 | struct udf_sparing_data { | ||
66 | __u16 s_packet_len; | ||
67 | struct buffer_head *s_spar_map[4]; | ||
68 | }; | ||
69 | |||
70 | struct udf_virtual_data { | ||
71 | __u32 s_num_entries; | ||
72 | __u16 s_start_offset; | ||
73 | }; | ||
74 | |||
75 | struct udf_bitmap { | ||
76 | __u32 s_extLength; | ||
77 | __u32 s_extPosition; | ||
78 | __u16 s_nr_groups; | ||
79 | struct buffer_head **s_block_bitmap; | ||
80 | }; | ||
81 | |||
82 | struct udf_part_map { | ||
83 | union { | ||
84 | struct udf_bitmap *s_bitmap; | ||
85 | struct inode *s_table; | ||
86 | } s_uspace; | ||
87 | union { | ||
88 | struct udf_bitmap *s_bitmap; | ||
89 | struct inode *s_table; | ||
90 | } s_fspace; | ||
91 | __u32 s_partition_root; | ||
92 | __u32 s_partition_len; | ||
93 | __u16 s_partition_type; | ||
94 | __u16 s_partition_num; | ||
95 | union { | ||
96 | struct udf_sparing_data s_sparing; | ||
97 | struct udf_virtual_data s_virtual; | ||
98 | struct udf_meta_data s_metadata; | ||
99 | } s_type_specific; | ||
100 | __u32 (*s_partition_func)(struct super_block *, __u32, __u16, __u32); | ||
101 | __u16 s_volumeseqnum; | ||
102 | __u16 s_partition_flags; | ||
103 | }; | ||
104 | |||
105 | #pragma pack() | ||
106 | |||
107 | struct udf_sb_info { | ||
108 | struct udf_part_map *s_partmaps; | ||
109 | __u8 s_volume_ident[32]; | ||
110 | |||
111 | /* Overall info */ | ||
112 | __u16 s_partitions; | ||
113 | __u16 s_partition; | ||
114 | |||
115 | /* Sector headers */ | ||
116 | __s32 s_session; | ||
117 | __u32 s_anchor[3]; | ||
118 | __u32 s_last_block; | ||
119 | |||
120 | struct buffer_head *s_lvid_bh; | ||
121 | |||
122 | /* Default permissions */ | ||
123 | mode_t s_umask; | ||
124 | gid_t s_gid; | ||
125 | uid_t s_uid; | ||
126 | |||
127 | /* Root Info */ | ||
128 | struct timespec s_record_time; | ||
129 | |||
130 | /* Fileset Info */ | ||
131 | __u16 s_serial_number; | ||
132 | |||
133 | /* highest UDF revision we have recorded to this media */ | ||
134 | __u16 s_udfrev; | ||
135 | |||
136 | /* Miscellaneous flags */ | ||
137 | __u32 s_flags; | ||
138 | |||
139 | /* Encoding info */ | ||
140 | struct nls_table *s_nls_map; | ||
141 | |||
142 | /* VAT inode */ | ||
143 | struct inode *s_vat_inode; | ||
144 | |||
145 | struct mutex s_alloc_mutex; | ||
146 | }; | ||
147 | |||
41 | static inline struct udf_sb_info *UDF_SB(struct super_block *sb) | 148 | static inline struct udf_sb_info *UDF_SB(struct super_block *sb) |
42 | { | 149 | { |
43 | return sb->s_fs_info; | 150 | return sb->s_fs_info; |
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h index 681dc2b66cdb..f3f45d029277 100644 --- a/fs/udf/udfdecl.h +++ b/fs/udf/udfdecl.h | |||
@@ -1,17 +1,37 @@ | |||
1 | #ifndef __UDF_DECL_H | 1 | #ifndef __UDF_DECL_H |
2 | #define __UDF_DECL_H | 2 | #define __UDF_DECL_H |
3 | 3 | ||
4 | #include <linux/udf_fs.h> | ||
5 | #include "ecma_167.h" | 4 | #include "ecma_167.h" |
6 | #include "osta_udf.h" | 5 | #include "osta_udf.h" |
7 | 6 | ||
8 | #include <linux/fs.h> | 7 | #include <linux/fs.h> |
9 | #include <linux/types.h> | 8 | #include <linux/types.h> |
10 | #include <linux/udf_fs_i.h> | ||
11 | #include <linux/udf_fs_sb.h> | ||
12 | #include <linux/buffer_head.h> | 9 | #include <linux/buffer_head.h> |
10 | #include <linux/udf_fs_i.h> | ||
13 | 11 | ||
12 | #include "udf_sb.h" | ||
14 | #include "udfend.h" | 13 | #include "udfend.h" |
14 | #include "udf_i.h" | ||
15 | |||
16 | #define UDF_PREALLOCATE | ||
17 | #define UDF_DEFAULT_PREALLOC_BLOCKS 8 | ||
18 | |||
19 | #define UDFFS_DEBUG | ||
20 | |||
21 | #ifdef UDFFS_DEBUG | ||
22 | #define udf_debug(f, a...) \ | ||
23 | do { \ | ||
24 | printk(KERN_DEBUG "UDF-fs DEBUG %s:%d:%s: ", \ | ||
25 | __FILE__, __LINE__, __func__); \ | ||
26 | printk(f, ##a); \ | ||
27 | } while (0) | ||
28 | #else | ||
29 | #define udf_debug(f, a...) /**/ | ||
30 | #endif | ||
31 | |||
32 | #define udf_info(f, a...) \ | ||
33 | printk(KERN_INFO "UDF-fs INFO " f, ##a); | ||
34 | |||
15 | 35 | ||
16 | #define udf_fixed_to_variable(x) ( ( ( (x) >> 5 ) * 39 ) + ( (x) & 0x0000001F ) ) | 36 | #define udf_fixed_to_variable(x) ( ( ( (x) >> 5 ) * 39 ) + ( (x) & 0x0000001F ) ) |
17 | #define udf_variable_to_fixed(x) ( ( ( (x) / 39 ) << 5 ) + ( (x) % 39 ) ) | 37 | #define udf_variable_to_fixed(x) ( ( ( (x) / 39 ) << 5 ) + ( (x) % 39 ) ) |
@@ -23,16 +43,24 @@ | |||
23 | #define UDF_NAME_LEN 256 | 43 | #define UDF_NAME_LEN 256 |
24 | #define UDF_PATH_LEN 1023 | 44 | #define UDF_PATH_LEN 1023 |
25 | 45 | ||
26 | #define udf_file_entry_alloc_offset(inode)\ | 46 | static inline size_t udf_file_entry_alloc_offset(struct inode *inode) |
27 | (UDF_I(inode)->i_use ?\ | 47 | { |
28 | sizeof(struct unallocSpaceEntry) :\ | 48 | struct udf_inode_info *iinfo = UDF_I(inode); |
29 | ((UDF_I(inode)->i_efe ?\ | 49 | if (iinfo->i_use) |
30 | sizeof(struct extendedFileEntry) :\ | 50 | return sizeof(struct unallocSpaceEntry); |
31 | sizeof(struct fileEntry)) + UDF_I(inode)->i_lenEAttr)) | 51 | else if (iinfo->i_efe) |
32 | 52 | return sizeof(struct extendedFileEntry) + iinfo->i_lenEAttr; | |
33 | #define udf_ext0_offset(inode)\ | 53 | else |
34 | (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ?\ | 54 | return sizeof(struct fileEntry) + iinfo->i_lenEAttr; |
35 | udf_file_entry_alloc_offset(inode) : 0) | 55 | } |
56 | |||
57 | static inline size_t udf_ext0_offset(struct inode *inode) | ||
58 | { | ||
59 | if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) | ||
60 | return udf_file_entry_alloc_offset(inode); | ||
61 | else | ||
62 | return 0; | ||
63 | } | ||
36 | 64 | ||
37 | #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset)) | 65 | #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset)) |
38 | 66 | ||
@@ -83,7 +111,6 @@ struct extent_position { | |||
83 | }; | 111 | }; |
84 | 112 | ||
85 | /* super.c */ | 113 | /* super.c */ |
86 | extern void udf_error(struct super_block *, const char *, const char *, ...); | ||
87 | extern void udf_warning(struct super_block *, const char *, const char *, ...); | 114 | extern void udf_warning(struct super_block *, const char *, const char *, ...); |
88 | 115 | ||
89 | /* namei.c */ | 116 | /* namei.c */ |
@@ -150,6 +177,8 @@ extern uint32_t udf_get_pblock_virt20(struct super_block *, uint32_t, uint16_t, | |||
150 | uint32_t); | 177 | uint32_t); |
151 | extern uint32_t udf_get_pblock_spar15(struct super_block *, uint32_t, uint16_t, | 178 | extern uint32_t udf_get_pblock_spar15(struct super_block *, uint32_t, uint16_t, |
152 | uint32_t); | 179 | uint32_t); |
180 | extern uint32_t udf_get_pblock_meta25(struct super_block *, uint32_t, uint16_t, | ||
181 | uint32_t); | ||
153 | extern int udf_relocate_blocks(struct super_block *, long, long *); | 182 | extern int udf_relocate_blocks(struct super_block *, long, long *); |
154 | 183 | ||
155 | /* unicode.c */ | 184 | /* unicode.c */ |
@@ -157,7 +186,7 @@ extern int udf_get_filename(struct super_block *, uint8_t *, uint8_t *, int); | |||
157 | extern int udf_put_filename(struct super_block *, const uint8_t *, uint8_t *, | 186 | extern int udf_put_filename(struct super_block *, const uint8_t *, uint8_t *, |
158 | int); | 187 | int); |
159 | extern int udf_build_ustr(struct ustr *, dstring *, int); | 188 | extern int udf_build_ustr(struct ustr *, dstring *, int); |
160 | extern int udf_CS0toUTF8(struct ustr *, struct ustr *); | 189 | extern int udf_CS0toUTF8(struct ustr *, const struct ustr *); |
161 | 190 | ||
162 | /* ialloc.c */ | 191 | /* ialloc.c */ |
163 | extern void udf_free_inode(struct inode *); | 192 | extern void udf_free_inode(struct inode *); |
@@ -191,11 +220,9 @@ extern struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, | |||
191 | extern long_ad *udf_get_filelongad(uint8_t *, int, uint32_t *, int); | 220 | extern long_ad *udf_get_filelongad(uint8_t *, int, uint32_t *, int); |
192 | extern short_ad *udf_get_fileshortad(uint8_t *, int, uint32_t *, int); | 221 | extern short_ad *udf_get_fileshortad(uint8_t *, int, uint32_t *, int); |
193 | 222 | ||
194 | /* crc.c */ | ||
195 | extern uint16_t udf_crc(uint8_t *, uint32_t, uint16_t); | ||
196 | |||
197 | /* udftime.c */ | 223 | /* udftime.c */ |
198 | extern time_t *udf_stamp_to_time(time_t *, long *, kernel_timestamp); | 224 | extern struct timespec *udf_disk_stamp_to_time(struct timespec *dest, |
199 | extern kernel_timestamp *udf_time_to_stamp(kernel_timestamp *, struct timespec); | 225 | timestamp src); |
226 | extern timestamp *udf_time_to_disk_stamp(timestamp *dest, struct timespec src); | ||
200 | 227 | ||
201 | #endif /* __UDF_DECL_H */ | 228 | #endif /* __UDF_DECL_H */ |
diff --git a/fs/udf/udfend.h b/fs/udf/udfend.h index c4bd1203f857..489f52fb428c 100644 --- a/fs/udf/udfend.h +++ b/fs/udf/udfend.h | |||
@@ -24,17 +24,6 @@ static inline lb_addr cpu_to_lelb(kernel_lb_addr in) | |||
24 | return out; | 24 | return out; |
25 | } | 25 | } |
26 | 26 | ||
27 | static inline kernel_timestamp lets_to_cpu(timestamp in) | ||
28 | { | ||
29 | kernel_timestamp out; | ||
30 | |||
31 | memcpy(&out, &in, sizeof(timestamp)); | ||
32 | out.typeAndTimezone = le16_to_cpu(in.typeAndTimezone); | ||
33 | out.year = le16_to_cpu(in.year); | ||
34 | |||
35 | return out; | ||
36 | } | ||
37 | |||
38 | static inline short_ad lesa_to_cpu(short_ad in) | 27 | static inline short_ad lesa_to_cpu(short_ad in) |
39 | { | 28 | { |
40 | short_ad out; | 29 | short_ad out; |
@@ -85,15 +74,4 @@ static inline kernel_extent_ad leea_to_cpu(extent_ad in) | |||
85 | return out; | 74 | return out; |
86 | } | 75 | } |
87 | 76 | ||
88 | static inline timestamp cpu_to_lets(kernel_timestamp in) | ||
89 | { | ||
90 | timestamp out; | ||
91 | |||
92 | memcpy(&out, &in, sizeof(timestamp)); | ||
93 | out.typeAndTimezone = cpu_to_le16(in.typeAndTimezone); | ||
94 | out.year = cpu_to_le16(in.year); | ||
95 | |||
96 | return out; | ||
97 | } | ||
98 | |||
99 | #endif /* __UDF_ENDIAN_H */ | 77 | #endif /* __UDF_ENDIAN_H */ |
diff --git a/fs/udf/udftime.c b/fs/udf/udftime.c index ce595732ba6f..5f811655c9b5 100644 --- a/fs/udf/udftime.c +++ b/fs/udf/udftime.c | |||
@@ -85,39 +85,38 @@ extern struct timezone sys_tz; | |||
85 | #define SECS_PER_HOUR (60 * 60) | 85 | #define SECS_PER_HOUR (60 * 60) |
86 | #define SECS_PER_DAY (SECS_PER_HOUR * 24) | 86 | #define SECS_PER_DAY (SECS_PER_HOUR * 24) |
87 | 87 | ||
88 | time_t *udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src) | 88 | struct timespec *udf_disk_stamp_to_time(struct timespec *dest, timestamp src) |
89 | { | 89 | { |
90 | int yday; | 90 | int yday; |
91 | uint8_t type = src.typeAndTimezone >> 12; | 91 | u16 typeAndTimezone = le16_to_cpu(src.typeAndTimezone); |
92 | u16 year = le16_to_cpu(src.year); | ||
93 | uint8_t type = typeAndTimezone >> 12; | ||
92 | int16_t offset; | 94 | int16_t offset; |
93 | 95 | ||
94 | if (type == 1) { | 96 | if (type == 1) { |
95 | offset = src.typeAndTimezone << 4; | 97 | offset = typeAndTimezone << 4; |
96 | /* sign extent offset */ | 98 | /* sign extent offset */ |
97 | offset = (offset >> 4); | 99 | offset = (offset >> 4); |
98 | if (offset == -2047) /* unspecified offset */ | 100 | if (offset == -2047) /* unspecified offset */ |
99 | offset = 0; | 101 | offset = 0; |
100 | } else { | 102 | } else |
101 | offset = 0; | 103 | offset = 0; |
102 | } | ||
103 | 104 | ||
104 | if ((src.year < EPOCH_YEAR) || | 105 | if ((year < EPOCH_YEAR) || |
105 | (src.year >= EPOCH_YEAR + MAX_YEAR_SECONDS)) { | 106 | (year >= EPOCH_YEAR + MAX_YEAR_SECONDS)) { |
106 | *dest = -1; | ||
107 | *dest_usec = -1; | ||
108 | return NULL; | 107 | return NULL; |
109 | } | 108 | } |
110 | *dest = year_seconds[src.year - EPOCH_YEAR]; | 109 | dest->tv_sec = year_seconds[year - EPOCH_YEAR]; |
111 | *dest -= offset * 60; | 110 | dest->tv_sec -= offset * 60; |
112 | 111 | ||
113 | yday = ((__mon_yday[__isleap(src.year)][src.month - 1]) + src.day - 1); | 112 | yday = ((__mon_yday[__isleap(year)][src.month - 1]) + src.day - 1); |
114 | *dest += (((yday * 24) + src.hour) * 60 + src.minute) * 60 + src.second; | 113 | dest->tv_sec += (((yday * 24) + src.hour) * 60 + src.minute) * 60 + src.second; |
115 | *dest_usec = src.centiseconds * 10000 + | 114 | dest->tv_nsec = 1000 * (src.centiseconds * 10000 + |
116 | src.hundredsOfMicroseconds * 100 + src.microseconds; | 115 | src.hundredsOfMicroseconds * 100 + src.microseconds); |
117 | return dest; | 116 | return dest; |
118 | } | 117 | } |
119 | 118 | ||
120 | kernel_timestamp *udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts) | 119 | timestamp *udf_time_to_disk_stamp(timestamp *dest, struct timespec ts) |
121 | { | 120 | { |
122 | long int days, rem, y; | 121 | long int days, rem, y; |
123 | const unsigned short int *ip; | 122 | const unsigned short int *ip; |
@@ -128,7 +127,7 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts) | |||
128 | if (!dest) | 127 | if (!dest) |
129 | return NULL; | 128 | return NULL; |
130 | 129 | ||
131 | dest->typeAndTimezone = 0x1000 | (offset & 0x0FFF); | 130 | dest->typeAndTimezone = cpu_to_le16(0x1000 | (offset & 0x0FFF)); |
132 | 131 | ||
133 | ts.tv_sec += offset * 60; | 132 | ts.tv_sec += offset * 60; |
134 | days = ts.tv_sec / SECS_PER_DAY; | 133 | days = ts.tv_sec / SECS_PER_DAY; |
@@ -151,7 +150,7 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts) | |||
151 | - LEAPS_THRU_END_OF(y - 1)); | 150 | - LEAPS_THRU_END_OF(y - 1)); |
152 | y = yg; | 151 | y = yg; |
153 | } | 152 | } |
154 | dest->year = y; | 153 | dest->year = cpu_to_le16(y); |
155 | ip = __mon_yday[__isleap(y)]; | 154 | ip = __mon_yday[__isleap(y)]; |
156 | for (y = 11; days < (long int)ip[y]; --y) | 155 | for (y = 11; days < (long int)ip[y]; --y) |
157 | continue; | 156 | continue; |
diff --git a/fs/udf/unicode.c b/fs/udf/unicode.c index e533b11703bf..9fdf8c93c58e 100644 --- a/fs/udf/unicode.c +++ b/fs/udf/unicode.c | |||
@@ -23,7 +23,7 @@ | |||
23 | #include <linux/kernel.h> | 23 | #include <linux/kernel.h> |
24 | #include <linux/string.h> /* for memset */ | 24 | #include <linux/string.h> /* for memset */ |
25 | #include <linux/nls.h> | 25 | #include <linux/nls.h> |
26 | #include <linux/udf_fs.h> | 26 | #include <linux/crc-itu-t.h> |
27 | 27 | ||
28 | #include "udf_sb.h" | 28 | #include "udf_sb.h" |
29 | 29 | ||
@@ -49,14 +49,16 @@ int udf_build_ustr(struct ustr *dest, dstring *ptr, int size) | |||
49 | { | 49 | { |
50 | int usesize; | 50 | int usesize; |
51 | 51 | ||
52 | if ((!dest) || (!ptr) || (!size)) | 52 | if (!dest || !ptr || !size) |
53 | return -1; | 53 | return -1; |
54 | BUG_ON(size < 2); | ||
54 | 55 | ||
55 | memset(dest, 0, sizeof(struct ustr)); | 56 | usesize = min_t(size_t, ptr[size - 1], sizeof(dest->u_name)); |
56 | usesize = (size > UDF_NAME_LEN) ? UDF_NAME_LEN : size; | 57 | usesize = min(usesize, size - 2); |
57 | dest->u_cmpID = ptr[0]; | 58 | dest->u_cmpID = ptr[0]; |
58 | dest->u_len = ptr[size - 1]; | 59 | dest->u_len = usesize; |
59 | memcpy(dest->u_name, ptr + 1, usesize - 1); | 60 | memcpy(dest->u_name, ptr + 1, usesize); |
61 | memset(dest->u_name + usesize, 0, sizeof(dest->u_name) - usesize); | ||
60 | 62 | ||
61 | return 0; | 63 | return 0; |
62 | } | 64 | } |
@@ -83,9 +85,6 @@ static int udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize) | |||
83 | * PURPOSE | 85 | * PURPOSE |
84 | * Convert OSTA Compressed Unicode to the UTF-8 equivalent. | 86 | * Convert OSTA Compressed Unicode to the UTF-8 equivalent. |
85 | * | 87 | * |
86 | * DESCRIPTION | ||
87 | * This routine is only called by udf_filldir(). | ||
88 | * | ||
89 | * PRE-CONDITIONS | 88 | * PRE-CONDITIONS |
90 | * utf Pointer to UTF-8 output buffer. | 89 | * utf Pointer to UTF-8 output buffer. |
91 | * ocu Pointer to OSTA Compressed Unicode input buffer | 90 | * ocu Pointer to OSTA Compressed Unicode input buffer |
@@ -99,43 +98,39 @@ static int udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize) | |||
99 | * November 12, 1997 - Andrew E. Mileski | 98 | * November 12, 1997 - Andrew E. Mileski |
100 | * Written, tested, and released. | 99 | * Written, tested, and released. |
101 | */ | 100 | */ |
102 | int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i) | 101 | int udf_CS0toUTF8(struct ustr *utf_o, const struct ustr *ocu_i) |
103 | { | 102 | { |
104 | uint8_t *ocu; | 103 | const uint8_t *ocu; |
105 | uint32_t c; | ||
106 | uint8_t cmp_id, ocu_len; | 104 | uint8_t cmp_id, ocu_len; |
107 | int i; | 105 | int i; |
108 | 106 | ||
109 | ocu = ocu_i->u_name; | ||
110 | |||
111 | ocu_len = ocu_i->u_len; | 107 | ocu_len = ocu_i->u_len; |
112 | cmp_id = ocu_i->u_cmpID; | ||
113 | utf_o->u_len = 0; | ||
114 | |||
115 | if (ocu_len == 0) { | 108 | if (ocu_len == 0) { |
116 | memset(utf_o, 0, sizeof(struct ustr)); | 109 | memset(utf_o, 0, sizeof(struct ustr)); |
117 | utf_o->u_cmpID = 0; | ||
118 | utf_o->u_len = 0; | ||
119 | return 0; | 110 | return 0; |
120 | } | 111 | } |
121 | 112 | ||
122 | if ((cmp_id != 8) && (cmp_id != 16)) { | 113 | cmp_id = ocu_i->u_cmpID; |
114 | if (cmp_id != 8 && cmp_id != 16) { | ||
115 | memset(utf_o, 0, sizeof(struct ustr)); | ||
123 | printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n", | 116 | printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n", |
124 | cmp_id, ocu_i->u_name); | 117 | cmp_id, ocu_i->u_name); |
125 | return 0; | 118 | return 0; |
126 | } | 119 | } |
127 | 120 | ||
121 | ocu = ocu_i->u_name; | ||
122 | utf_o->u_len = 0; | ||
128 | for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) { | 123 | for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) { |
129 | 124 | ||
130 | /* Expand OSTA compressed Unicode to Unicode */ | 125 | /* Expand OSTA compressed Unicode to Unicode */ |
131 | c = ocu[i++]; | 126 | uint32_t c = ocu[i++]; |
132 | if (cmp_id == 16) | 127 | if (cmp_id == 16) |
133 | c = (c << 8) | ocu[i++]; | 128 | c = (c << 8) | ocu[i++]; |
134 | 129 | ||
135 | /* Compress Unicode to UTF-8 */ | 130 | /* Compress Unicode to UTF-8 */ |
136 | if (c < 0x80U) { | 131 | if (c < 0x80U) |
137 | utf_o->u_name[utf_o->u_len++] = (uint8_t)c; | 132 | utf_o->u_name[utf_o->u_len++] = (uint8_t)c; |
138 | } else if (c < 0x800U) { | 133 | else if (c < 0x800U) { |
139 | utf_o->u_name[utf_o->u_len++] = | 134 | utf_o->u_name[utf_o->u_len++] = |
140 | (uint8_t)(0xc0 | (c >> 6)); | 135 | (uint8_t)(0xc0 | (c >> 6)); |
141 | utf_o->u_name[utf_o->u_len++] = | 136 | utf_o->u_name[utf_o->u_len++] = |
@@ -255,35 +250,32 @@ error_out: | |||
255 | } | 250 | } |
256 | 251 | ||
257 | static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, | 252 | static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, |
258 | struct ustr *ocu_i) | 253 | const struct ustr *ocu_i) |
259 | { | 254 | { |
260 | uint8_t *ocu; | 255 | const uint8_t *ocu; |
261 | uint32_t c; | ||
262 | uint8_t cmp_id, ocu_len; | 256 | uint8_t cmp_id, ocu_len; |
263 | int i; | 257 | int i; |
264 | 258 | ||
265 | ocu = ocu_i->u_name; | ||
266 | 259 | ||
267 | ocu_len = ocu_i->u_len; | 260 | ocu_len = ocu_i->u_len; |
268 | cmp_id = ocu_i->u_cmpID; | ||
269 | utf_o->u_len = 0; | ||
270 | |||
271 | if (ocu_len == 0) { | 261 | if (ocu_len == 0) { |
272 | memset(utf_o, 0, sizeof(struct ustr)); | 262 | memset(utf_o, 0, sizeof(struct ustr)); |
273 | utf_o->u_cmpID = 0; | ||
274 | utf_o->u_len = 0; | ||
275 | return 0; | 263 | return 0; |
276 | } | 264 | } |
277 | 265 | ||
278 | if ((cmp_id != 8) && (cmp_id != 16)) { | 266 | cmp_id = ocu_i->u_cmpID; |
267 | if (cmp_id != 8 && cmp_id != 16) { | ||
268 | memset(utf_o, 0, sizeof(struct ustr)); | ||
279 | printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n", | 269 | printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n", |
280 | cmp_id, ocu_i->u_name); | 270 | cmp_id, ocu_i->u_name); |
281 | return 0; | 271 | return 0; |
282 | } | 272 | } |
283 | 273 | ||
274 | ocu = ocu_i->u_name; | ||
275 | utf_o->u_len = 0; | ||
284 | for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) { | 276 | for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) { |
285 | /* Expand OSTA compressed Unicode to Unicode */ | 277 | /* Expand OSTA compressed Unicode to Unicode */ |
286 | c = ocu[i++]; | 278 | uint32_t c = ocu[i++]; |
287 | if (cmp_id == 16) | 279 | if (cmp_id == 16) |
288 | c = (c << 8) | ocu[i++]; | 280 | c = (c << 8) | ocu[i++]; |
289 | 281 | ||
@@ -463,7 +455,7 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, | |||
463 | } else if (newIndex > 250) | 455 | } else if (newIndex > 250) |
464 | newIndex = 250; | 456 | newIndex = 250; |
465 | newName[newIndex++] = CRC_MARK; | 457 | newName[newIndex++] = CRC_MARK; |
466 | valueCRC = udf_crc(fidName, fidNameLen, 0); | 458 | valueCRC = crc_itu_t(0, fidName, fidNameLen); |
467 | newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12]; | 459 | newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12]; |
468 | newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8]; | 460 | newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8]; |
469 | newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4]; | 461 | newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4]; |
diff --git a/include/asm-sh/i2c-sh7760.h b/include/asm-sh/i2c-sh7760.h new file mode 100644 index 000000000000..24182116711f --- /dev/null +++ b/include/asm-sh/i2c-sh7760.h | |||
@@ -0,0 +1,22 @@ | |||
1 | /* | ||
2 | * MMIO/IRQ and platform data for SH7760 I2C channels | ||
3 | */ | ||
4 | |||
5 | #ifndef _I2C_SH7760_H_ | ||
6 | #define _I2C_SH7760_H_ | ||
7 | |||
8 | #define SH7760_I2C_DEVNAME "sh7760-i2c" | ||
9 | |||
10 | #define SH7760_I2C0_MMIO 0xFE140000 | ||
11 | #define SH7760_I2C0_MMIOEND 0xFE14003B | ||
12 | #define SH7760_I2C0_IRQ 62 | ||
13 | |||
14 | #define SH7760_I2C1_MMIO 0xFE150000 | ||
15 | #define SH7760_I2C1_MMIOEND 0xFE15003B | ||
16 | #define SH7760_I2C1_IRQ 63 | ||
17 | |||
18 | struct sh7760_i2c_platdata { | ||
19 | unsigned int speed_khz; | ||
20 | }; | ||
21 | |||
22 | #endif | ||
diff --git a/include/linux/Kbuild b/include/linux/Kbuild index b3d9ccde0c27..cbb5ccb27de3 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild | |||
@@ -100,7 +100,7 @@ header-y += ixjuser.h | |||
100 | header-y += jffs2.h | 100 | header-y += jffs2.h |
101 | header-y += keyctl.h | 101 | header-y += keyctl.h |
102 | header-y += limits.h | 102 | header-y += limits.h |
103 | header-y += lock_dlm_plock.h | 103 | header-y += dlm_plock.h |
104 | header-y += magic.h | 104 | header-y += magic.h |
105 | header-y += major.h | 105 | header-y += major.h |
106 | header-y += matroxfb.h | 106 | header-y += matroxfb.h |
@@ -150,6 +150,7 @@ header-y += tiocl.h | |||
150 | header-y += tipc.h | 150 | header-y += tipc.h |
151 | header-y += tipc_config.h | 151 | header-y += tipc_config.h |
152 | header-y += toshiba.h | 152 | header-y += toshiba.h |
153 | header-y += udf_fs_i.h | ||
153 | header-y += ultrasound.h | 154 | header-y += ultrasound.h |
154 | header-y += un.h | 155 | header-y += un.h |
155 | header-y += utime.h | 156 | header-y += utime.h |
@@ -210,7 +211,9 @@ unifdef-y += hdlcdrv.h | |||
210 | unifdef-y += hdlc.h | 211 | unifdef-y += hdlc.h |
211 | unifdef-y += hdreg.h | 212 | unifdef-y += hdreg.h |
212 | unifdef-y += hdsmart.h | 213 | unifdef-y += hdsmart.h |
214 | unifdef-y += hid.h | ||
213 | unifdef-y += hiddev.h | 215 | unifdef-y += hiddev.h |
216 | unifdef-y += hidraw.h | ||
214 | unifdef-y += hpet.h | 217 | unifdef-y += hpet.h |
215 | unifdef-y += i2c.h | 218 | unifdef-y += i2c.h |
216 | unifdef-y += i2c-dev.h | 219 | unifdef-y += i2c-dev.h |
@@ -334,7 +337,6 @@ unifdef-y += time.h | |||
334 | unifdef-y += timex.h | 337 | unifdef-y += timex.h |
335 | unifdef-y += tty.h | 338 | unifdef-y += tty.h |
336 | unifdef-y += types.h | 339 | unifdef-y += types.h |
337 | unifdef-y += udf_fs_i.h | ||
338 | unifdef-y += udp.h | 340 | unifdef-y += udp.h |
339 | unifdef-y += uinput.h | 341 | unifdef-y += uinput.h |
340 | unifdef-y += uio.h | 342 | unifdef-y += uio.h |
diff --git a/include/linux/dlm.h b/include/linux/dlm.h index c743fbc769db..203a025e30e5 100644 --- a/include/linux/dlm.h +++ b/include/linux/dlm.h | |||
@@ -21,10 +21,7 @@ | |||
21 | 21 | ||
22 | /* Lock levels and flags are here */ | 22 | /* Lock levels and flags are here */ |
23 | #include <linux/dlmconstants.h> | 23 | #include <linux/dlmconstants.h> |
24 | 24 | #include <linux/types.h> | |
25 | |||
26 | #define DLM_RESNAME_MAXLEN 64 | ||
27 | |||
28 | 25 | ||
29 | typedef void dlm_lockspace_t; | 26 | typedef void dlm_lockspace_t; |
30 | 27 | ||
@@ -63,7 +60,7 @@ typedef void dlm_lockspace_t; | |||
63 | 60 | ||
64 | struct dlm_lksb { | 61 | struct dlm_lksb { |
65 | int sb_status; | 62 | int sb_status; |
66 | uint32_t sb_lkid; | 63 | __u32 sb_lkid; |
67 | char sb_flags; | 64 | char sb_flags; |
68 | char * sb_lvbptr; | 65 | char * sb_lvbptr; |
69 | }; | 66 | }; |
diff --git a/include/linux/dlm_device.h b/include/linux/dlm_device.h index 9642277a152a..c6034508fed9 100644 --- a/include/linux/dlm_device.h +++ b/include/linux/dlm_device.h | |||
@@ -11,10 +11,16 @@ | |||
11 | ******************************************************************************* | 11 | ******************************************************************************* |
12 | ******************************************************************************/ | 12 | ******************************************************************************/ |
13 | 13 | ||
14 | #ifndef _LINUX_DLM_DEVICE_H | ||
15 | #define _LINUX_DLM_DEVICE_H | ||
16 | |||
14 | /* This is the device interface for dlm, most users will use a library | 17 | /* This is the device interface for dlm, most users will use a library |
15 | * interface. | 18 | * interface. |
16 | */ | 19 | */ |
17 | 20 | ||
21 | #include <linux/dlm.h> | ||
22 | #include <linux/types.h> | ||
23 | |||
18 | #define DLM_USER_LVB_LEN 32 | 24 | #define DLM_USER_LVB_LEN 32 |
19 | 25 | ||
20 | /* Version of the device interface */ | 26 | /* Version of the device interface */ |
@@ -94,10 +100,9 @@ struct dlm_lock_result { | |||
94 | #define DLM_USER_PURGE 6 | 100 | #define DLM_USER_PURGE 6 |
95 | #define DLM_USER_DEADLOCK 7 | 101 | #define DLM_USER_DEADLOCK 7 |
96 | 102 | ||
97 | /* Arbitrary length restriction */ | ||
98 | #define MAX_LS_NAME_LEN 64 | ||
99 | |||
100 | /* Lockspace flags */ | 103 | /* Lockspace flags */ |
101 | #define DLM_USER_LSFLG_AUTOFREE 1 | 104 | #define DLM_USER_LSFLG_AUTOFREE 1 |
102 | #define DLM_USER_LSFLG_FORCEFREE 2 | 105 | #define DLM_USER_LSFLG_FORCEFREE 2 |
103 | 106 | ||
107 | #endif | ||
108 | |||
diff --git a/include/linux/dlm_plock.h b/include/linux/dlm_plock.h new file mode 100644 index 000000000000..18d5fdbceb74 --- /dev/null +++ b/include/linux/dlm_plock.h | |||
@@ -0,0 +1,50 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved. | ||
3 | * | ||
4 | * This copyrighted material is made available to anyone wishing to use, | ||
5 | * modify, copy, or redistribute it subject to the terms and conditions | ||
6 | * of the GNU General Public License v.2. | ||
7 | */ | ||
8 | |||
9 | #ifndef __DLM_PLOCK_DOT_H__ | ||
10 | #define __DLM_PLOCK_DOT_H__ | ||
11 | |||
12 | #define DLM_PLOCK_MISC_NAME "dlm_plock" | ||
13 | |||
14 | #define DLM_PLOCK_VERSION_MAJOR 1 | ||
15 | #define DLM_PLOCK_VERSION_MINOR 1 | ||
16 | #define DLM_PLOCK_VERSION_PATCH 0 | ||
17 | |||
18 | enum { | ||
19 | DLM_PLOCK_OP_LOCK = 1, | ||
20 | DLM_PLOCK_OP_UNLOCK, | ||
21 | DLM_PLOCK_OP_GET, | ||
22 | }; | ||
23 | |||
24 | struct dlm_plock_info { | ||
25 | __u32 version[3]; | ||
26 | __u8 optype; | ||
27 | __u8 ex; | ||
28 | __u8 wait; | ||
29 | __u8 pad; | ||
30 | __u32 pid; | ||
31 | __s32 nodeid; | ||
32 | __s32 rv; | ||
33 | __u32 fsid; | ||
34 | __u64 number; | ||
35 | __u64 start; | ||
36 | __u64 end; | ||
37 | __u64 owner; | ||
38 | }; | ||
39 | |||
40 | #ifdef __KERNEL__ | ||
41 | int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file, | ||
42 | int cmd, struct file_lock *fl); | ||
43 | int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, | ||
44 | struct file_lock *fl); | ||
45 | int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, | ||
46 | struct file_lock *fl); | ||
47 | #endif /* __KERNEL__ */ | ||
48 | |||
49 | #endif | ||
50 | |||
diff --git a/include/linux/dlmconstants.h b/include/linux/dlmconstants.h index fddb3d3ff321..47bf08dc7566 100644 --- a/include/linux/dlmconstants.h +++ b/include/linux/dlmconstants.h | |||
@@ -18,6 +18,10 @@ | |||
18 | * Constants used by DLM interface. | 18 | * Constants used by DLM interface. |
19 | */ | 19 | */ |
20 | 20 | ||
21 | #define DLM_LOCKSPACE_LEN 64 | ||
22 | #define DLM_RESNAME_MAXLEN 64 | ||
23 | |||
24 | |||
21 | /* | 25 | /* |
22 | * Lock Modes | 26 | * Lock Modes |
23 | */ | 27 | */ |
diff --git a/include/linux/hid.h b/include/linux/hid.h index 74ff57596eb1..d951ec411241 100644 --- a/include/linux/hid.h +++ b/include/linux/hid.h | |||
@@ -284,6 +284,7 @@ struct hid_item { | |||
284 | #define HID_QUIRK_2WHEEL_MOUSE_HACK_B8 0x02000000 | 284 | #define HID_QUIRK_2WHEEL_MOUSE_HACK_B8 0x02000000 |
285 | #define HID_QUIRK_HWHEEL_WHEEL_INVERT 0x04000000 | 285 | #define HID_QUIRK_HWHEEL_WHEEL_INVERT 0x04000000 |
286 | #define HID_QUIRK_MICROSOFT_KEYS 0x08000000 | 286 | #define HID_QUIRK_MICROSOFT_KEYS 0x08000000 |
287 | #define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000 | ||
287 | 288 | ||
288 | /* | 289 | /* |
289 | * Separate quirks for runtime report descriptor fixup | 290 | * Separate quirks for runtime report descriptor fixup |
@@ -296,6 +297,8 @@ struct hid_item { | |||
296 | #define HID_QUIRK_RDESC_MACBOOK_JIS 0x00000010 | 297 | #define HID_QUIRK_RDESC_MACBOOK_JIS 0x00000010 |
297 | #define HID_QUIRK_RDESC_BUTTON_CONSUMER 0x00000020 | 298 | #define HID_QUIRK_RDESC_BUTTON_CONSUMER 0x00000020 |
298 | #define HID_QUIRK_RDESC_SAMSUNG_REMOTE 0x00000040 | 299 | #define HID_QUIRK_RDESC_SAMSUNG_REMOTE 0x00000040 |
300 | #define HID_QUIRK_RDESC_MICROSOFT_RECV_1028 0x00000080 | ||
301 | #define HID_QUIRK_RDESC_SUNPLUS_WDESKTOP 0x00000100 | ||
299 | 302 | ||
300 | /* | 303 | /* |
301 | * This is the global environment of the parser. This information is | 304 | * This is the global environment of the parser. This information is |
@@ -320,7 +323,7 @@ struct hid_global { | |||
320 | * This is the local environment. It is persistent up the next main-item. | 323 | * This is the local environment. It is persistent up the next main-item. |
321 | */ | 324 | */ |
322 | 325 | ||
323 | #define HID_MAX_USAGES 8192 | 326 | #define HID_MAX_USAGES 12288 |
324 | #define HID_DEFAULT_NUM_COLLECTIONS 16 | 327 | #define HID_DEFAULT_NUM_COLLECTIONS 16 |
325 | 328 | ||
326 | struct hid_local { | 329 | struct hid_local { |
@@ -421,6 +424,7 @@ struct hid_control_fifo { | |||
421 | #define HID_RESET_PENDING 4 | 424 | #define HID_RESET_PENDING 4 |
422 | #define HID_SUSPENDED 5 | 425 | #define HID_SUSPENDED 5 |
423 | #define HID_CLEAR_HALT 6 | 426 | #define HID_CLEAR_HALT 6 |
427 | #define HID_DISCONNECTED 7 | ||
424 | 428 | ||
425 | struct hid_input { | 429 | struct hid_input { |
426 | struct list_head list; | 430 | struct list_head list; |
@@ -452,8 +456,6 @@ struct hid_device { /* device report descriptor */ | |||
452 | void *hidraw; | 456 | void *hidraw; |
453 | int minor; /* Hiddev minor number */ | 457 | int minor; /* Hiddev minor number */ |
454 | 458 | ||
455 | wait_queue_head_t wait; /* For sleeping */ | ||
456 | |||
457 | int open; /* is the device open by anyone? */ | 459 | int open; /* is the device open by anyone? */ |
458 | char name[128]; /* Device name */ | 460 | char name[128]; /* Device name */ |
459 | char phys[64]; /* Device physical location */ | 461 | char phys[64]; /* Device physical location */ |
@@ -530,14 +532,12 @@ int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int | |||
530 | int hidinput_mapping_quirks(struct hid_usage *, struct input_dev *, unsigned long **, int *); | 532 | int hidinput_mapping_quirks(struct hid_usage *, struct input_dev *, unsigned long **, int *); |
531 | int hidinput_event_quirks(struct hid_device *, struct hid_field *, struct hid_usage *, __s32); | 533 | int hidinput_event_quirks(struct hid_device *, struct hid_field *, struct hid_usage *, __s32); |
532 | int hidinput_apple_event(struct hid_device *, struct input_dev *, struct hid_usage *, __s32); | 534 | int hidinput_apple_event(struct hid_device *, struct input_dev *, struct hid_usage *, __s32); |
533 | void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, int interrupt); | ||
534 | void hid_output_report(struct hid_report *report, __u8 *data); | 535 | void hid_output_report(struct hid_report *report, __u8 *data); |
535 | void hid_free_device(struct hid_device *device); | 536 | void hid_free_device(struct hid_device *device); |
536 | struct hid_device *hid_parse_report(__u8 *start, unsigned size); | 537 | struct hid_device *hid_parse_report(__u8 *start, unsigned size); |
537 | 538 | ||
538 | /* HID quirks API */ | 539 | /* HID quirks API */ |
539 | u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct); | 540 | u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct); |
540 | int usbhid_modify_dquirk(const u16 idVendor, const u16 idProduct, const u32 quirks); | ||
541 | int usbhid_quirks_init(char **quirks_param); | 541 | int usbhid_quirks_init(char **quirks_param); |
542 | void usbhid_quirks_exit(void); | 542 | void usbhid_quirks_exit(void); |
543 | void usbhid_fixup_report_descriptor(const u16, const u16, char *, unsigned, char **); | 543 | void usbhid_fixup_report_descriptor(const u16, const u16, char *, unsigned, char **); |
@@ -546,6 +546,7 @@ void usbhid_fixup_report_descriptor(const u16, const u16, char *, unsigned, char | |||
546 | int hid_ff_init(struct hid_device *hid); | 546 | int hid_ff_init(struct hid_device *hid); |
547 | 547 | ||
548 | int hid_lgff_init(struct hid_device *hid); | 548 | int hid_lgff_init(struct hid_device *hid); |
549 | int hid_lg2ff_init(struct hid_device *hid); | ||
549 | int hid_plff_init(struct hid_device *hid); | 550 | int hid_plff_init(struct hid_device *hid); |
550 | int hid_tmff_init(struct hid_device *hid); | 551 | int hid_tmff_init(struct hid_device *hid); |
551 | int hid_zpff_init(struct hid_device *hid); | 552 | int hid_zpff_init(struct hid_device *hid); |
@@ -566,7 +567,11 @@ static inline int hid_ff_init(struct hid_device *hid) { return -1; } | |||
566 | #define dbg_hid_line(format, arg...) if (hid_debug) \ | 567 | #define dbg_hid_line(format, arg...) if (hid_debug) \ |
567 | printk(format, ## arg) | 568 | printk(format, ## arg) |
568 | #else | 569 | #else |
569 | #define dbg_hid(format, arg...) do {} while (0) | 570 | static inline int __attribute__((format(printf, 1, 2))) |
571 | dbg_hid(const char *fmt, ...) | ||
572 | { | ||
573 | return 0; | ||
574 | } | ||
570 | #define dbg_hid_line dbg_hid | 575 | #define dbg_hid_line dbg_hid |
571 | #endif | 576 | #endif |
572 | 577 | ||
diff --git a/include/linux/hidraw.h b/include/linux/hidraw.h index 0536f299f7ff..dbb5c8c374f0 100644 --- a/include/linux/hidraw.h +++ b/include/linux/hidraw.h | |||
@@ -16,6 +16,7 @@ | |||
16 | */ | 16 | */ |
17 | 17 | ||
18 | #include <linux/hid.h> | 18 | #include <linux/hid.h> |
19 | #include <linux/types.h> | ||
19 | 20 | ||
20 | struct hidraw_report_descriptor { | 21 | struct hidraw_report_descriptor { |
21 | __u32 size; | 22 | __u32 size; |
diff --git a/include/linux/i2c-algo-pca.h b/include/linux/i2c-algo-pca.h index fce47c051bb1..adcb3dc7ac26 100644 --- a/include/linux/i2c-algo-pca.h +++ b/include/linux/i2c-algo-pca.h | |||
@@ -1,14 +1,41 @@ | |||
1 | #ifndef _LINUX_I2C_ALGO_PCA_H | 1 | #ifndef _LINUX_I2C_ALGO_PCA_H |
2 | #define _LINUX_I2C_ALGO_PCA_H | 2 | #define _LINUX_I2C_ALGO_PCA_H |
3 | 3 | ||
4 | /* Clock speeds for the bus */ | ||
5 | #define I2C_PCA_CON_330kHz 0x00 | ||
6 | #define I2C_PCA_CON_288kHz 0x01 | ||
7 | #define I2C_PCA_CON_217kHz 0x02 | ||
8 | #define I2C_PCA_CON_146kHz 0x03 | ||
9 | #define I2C_PCA_CON_88kHz 0x04 | ||
10 | #define I2C_PCA_CON_59kHz 0x05 | ||
11 | #define I2C_PCA_CON_44kHz 0x06 | ||
12 | #define I2C_PCA_CON_36kHz 0x07 | ||
13 | |||
14 | /* PCA9564 registers */ | ||
15 | #define I2C_PCA_STA 0x00 /* STATUS Read Only */ | ||
16 | #define I2C_PCA_TO 0x00 /* TIMEOUT Write Only */ | ||
17 | #define I2C_PCA_DAT 0x01 /* DATA Read/Write */ | ||
18 | #define I2C_PCA_ADR 0x02 /* OWN ADR Read/Write */ | ||
19 | #define I2C_PCA_CON 0x03 /* CONTROL Read/Write */ | ||
20 | |||
21 | #define I2C_PCA_CON_AA 0x80 /* Assert Acknowledge */ | ||
22 | #define I2C_PCA_CON_ENSIO 0x40 /* Enable */ | ||
23 | #define I2C_PCA_CON_STA 0x20 /* Start */ | ||
24 | #define I2C_PCA_CON_STO 0x10 /* Stop */ | ||
25 | #define I2C_PCA_CON_SI 0x08 /* Serial Interrupt */ | ||
26 | #define I2C_PCA_CON_CR 0x07 /* Clock Rate (MASK) */ | ||
27 | |||
4 | struct i2c_algo_pca_data { | 28 | struct i2c_algo_pca_data { |
5 | int (*get_own) (struct i2c_algo_pca_data *adap); /* Obtain own address */ | 29 | void *data; /* private low level data */ |
6 | int (*get_clock) (struct i2c_algo_pca_data *adap); | 30 | void (*write_byte) (void *data, int reg, int val); |
7 | void (*write_byte) (struct i2c_algo_pca_data *adap, int reg, int val); | 31 | int (*read_byte) (void *data, int reg); |
8 | int (*read_byte) (struct i2c_algo_pca_data *adap, int reg); | 32 | int (*wait_for_completion) (void *data); |
9 | int (*wait_for_interrupt) (struct i2c_algo_pca_data *adap); | 33 | void (*reset_chip) (void *data); |
34 | /* i2c_clock values are defined in linux/i2c-algo-pca.h */ | ||
35 | unsigned int i2c_clock; | ||
10 | }; | 36 | }; |
11 | 37 | ||
12 | int i2c_pca_add_bus(struct i2c_adapter *); | 38 | int i2c_pca_add_bus(struct i2c_adapter *); |
39 | int i2c_pca_add_numbered_bus(struct i2c_adapter *); | ||
13 | 40 | ||
14 | #endif /* _LINUX_I2C_ALGO_PCA_H */ | 41 | #endif /* _LINUX_I2C_ALGO_PCA_H */ |
diff --git a/include/linux/i2c-pca-platform.h b/include/linux/i2c-pca-platform.h new file mode 100644 index 000000000000..3d191873f2d1 --- /dev/null +++ b/include/linux/i2c-pca-platform.h | |||
@@ -0,0 +1,12 @@ | |||
1 | #ifndef I2C_PCA9564_PLATFORM_H | ||
2 | #define I2C_PCA9564_PLATFORM_H | ||
3 | |||
4 | struct i2c_pca9564_pf_platform_data { | ||
5 | int gpio; /* pin to reset chip. driver will work when | ||
6 | * not supplied (negative value), but it | ||
7 | * cannot exit some error conditions then */ | ||
8 | int i2c_clock_speed; /* values are defined in linux/i2c-algo-pca.h */ | ||
9 | int timeout; /* timeout = this value * 10us */ | ||
10 | }; | ||
11 | |||
12 | #endif /* I2C_PCA9564_PLATFORM_H */ | ||
diff --git a/include/linux/lock_dlm_plock.h b/include/linux/lock_dlm_plock.h deleted file mode 100644 index fc3415113973..000000000000 --- a/include/linux/lock_dlm_plock.h +++ /dev/null | |||
@@ -1,41 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2005 Red Hat, Inc. All rights reserved. | ||
3 | * | ||
4 | * This copyrighted material is made available to anyone wishing to use, | ||
5 | * modify, copy, or redistribute it subject to the terms and conditions | ||
6 | * of the GNU General Public License v.2. | ||
7 | */ | ||
8 | |||
9 | #ifndef __LOCK_DLM_PLOCK_DOT_H__ | ||
10 | #define __LOCK_DLM_PLOCK_DOT_H__ | ||
11 | |||
12 | #define GDLM_PLOCK_MISC_NAME "lock_dlm_plock" | ||
13 | |||
14 | #define GDLM_PLOCK_VERSION_MAJOR 1 | ||
15 | #define GDLM_PLOCK_VERSION_MINOR 1 | ||
16 | #define GDLM_PLOCK_VERSION_PATCH 0 | ||
17 | |||
18 | enum { | ||
19 | GDLM_PLOCK_OP_LOCK = 1, | ||
20 | GDLM_PLOCK_OP_UNLOCK, | ||
21 | GDLM_PLOCK_OP_GET, | ||
22 | }; | ||
23 | |||
24 | struct gdlm_plock_info { | ||
25 | __u32 version[3]; | ||
26 | __u8 optype; | ||
27 | __u8 ex; | ||
28 | __u8 wait; | ||
29 | __u8 pad; | ||
30 | __u32 pid; | ||
31 | __s32 nodeid; | ||
32 | __s32 rv; | ||
33 | __u32 fsid; | ||
34 | __u64 number; | ||
35 | __u64 start; | ||
36 | __u64 end; | ||
37 | __u64 owner; | ||
38 | }; | ||
39 | |||
40 | #endif | ||
41 | |||
diff --git a/include/linux/udf_fs.h b/include/linux/udf_fs.h deleted file mode 100644 index aa88654eb76b..000000000000 --- a/include/linux/udf_fs.h +++ /dev/null | |||
@@ -1,51 +0,0 @@ | |||
1 | /* | ||
2 | * udf_fs.h | ||
3 | * | ||
4 | * PURPOSE | ||
5 | * Included by fs/filesystems.c | ||
6 | * | ||
7 | * DESCRIPTION | ||
8 | * OSTA-UDF(tm) = Optical Storage Technology Association | ||
9 | * Universal Disk Format. | ||
10 | * | ||
11 | * This code is based on version 2.50 of the UDF specification, | ||
12 | * and revision 3 of the ECMA 167 standard [equivalent to ISO 13346]. | ||
13 | * http://www.osta.org/ * http://www.ecma.ch/ | ||
14 | * http://www.iso.org/ | ||
15 | * | ||
16 | * COPYRIGHT | ||
17 | * This file is distributed under the terms of the GNU General Public | ||
18 | * License (GPL). Copies of the GPL can be obtained from: | ||
19 | * ftp://prep.ai.mit.edu/pub/gnu/GPL | ||
20 | * Each contributing author retains all rights to their own work. | ||
21 | * | ||
22 | * (C) 1999-2004 Ben Fennema | ||
23 | * (C) 1999-2000 Stelias Computing Inc | ||
24 | * | ||
25 | * HISTORY | ||
26 | * | ||
27 | */ | ||
28 | |||
29 | #ifndef _UDF_FS_H | ||
30 | #define _UDF_FS_H 1 | ||
31 | |||
32 | #define UDF_PREALLOCATE | ||
33 | #define UDF_DEFAULT_PREALLOC_BLOCKS 8 | ||
34 | |||
35 | #undef UDFFS_DEBUG | ||
36 | |||
37 | #ifdef UDFFS_DEBUG | ||
38 | #define udf_debug(f, a...) \ | ||
39 | do { \ | ||
40 | printk (KERN_DEBUG "UDF-fs DEBUG %s:%d:%s: ", \ | ||
41 | __FILE__, __LINE__, __FUNCTION__); \ | ||
42 | printk (f, ##a); \ | ||
43 | } while (0) | ||
44 | #else | ||
45 | #define udf_debug(f, a...) /**/ | ||
46 | #endif | ||
47 | |||
48 | #define udf_info(f, a...) \ | ||
49 | printk (KERN_INFO "UDF-fs INFO " f, ##a); | ||
50 | |||
51 | #endif /* _UDF_FS_H */ | ||
diff --git a/include/linux/udf_fs_i.h b/include/linux/udf_fs_i.h index ffaf05679ffb..3536965913b0 100644 --- a/include/linux/udf_fs_i.h +++ b/include/linux/udf_fs_i.h | |||
@@ -9,41 +9,10 @@ | |||
9 | * ftp://prep.ai.mit.edu/pub/gnu/GPL | 9 | * ftp://prep.ai.mit.edu/pub/gnu/GPL |
10 | * Each contributing author retains all rights to their own work. | 10 | * Each contributing author retains all rights to their own work. |
11 | */ | 11 | */ |
12 | |||
13 | #ifndef _UDF_FS_I_H | 12 | #ifndef _UDF_FS_I_H |
14 | #define _UDF_FS_I_H 1 | 13 | #define _UDF_FS_I_H 1 |
15 | 14 | ||
16 | #ifdef __KERNEL__ | ||
17 | |||
18 | struct udf_inode_info | ||
19 | { | ||
20 | struct timespec i_crtime; | ||
21 | /* Physical address of inode */ | ||
22 | kernel_lb_addr i_location; | ||
23 | __u64 i_unique; | ||
24 | __u32 i_lenEAttr; | ||
25 | __u32 i_lenAlloc; | ||
26 | __u64 i_lenExtents; | ||
27 | __u32 i_next_alloc_block; | ||
28 | __u32 i_next_alloc_goal; | ||
29 | unsigned i_alloc_type : 3; | ||
30 | unsigned i_efe : 1; | ||
31 | unsigned i_use : 1; | ||
32 | unsigned i_strat4096 : 1; | ||
33 | unsigned reserved : 26; | ||
34 | union | ||
35 | { | ||
36 | short_ad *i_sad; | ||
37 | long_ad *i_lad; | ||
38 | __u8 *i_data; | ||
39 | } i_ext; | ||
40 | struct inode vfs_inode; | ||
41 | }; | ||
42 | |||
43 | #endif | ||
44 | |||
45 | /* exported IOCTLs, we have 'l', 0x40-0x7f */ | 15 | /* exported IOCTLs, we have 'l', 0x40-0x7f */ |
46 | |||
47 | #define UDF_GETEASIZE _IOR('l', 0x40, int) | 16 | #define UDF_GETEASIZE _IOR('l', 0x40, int) |
48 | #define UDF_GETEABLOCK _IOR('l', 0x41, void *) | 17 | #define UDF_GETEABLOCK _IOR('l', 0x41, void *) |
49 | #define UDF_GETVOLIDENT _IOR('l', 0x42, void *) | 18 | #define UDF_GETVOLIDENT _IOR('l', 0x42, void *) |
diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h deleted file mode 100644 index 9bc47352b6b4..000000000000 --- a/include/linux/udf_fs_sb.h +++ /dev/null | |||
@@ -1,117 +0,0 @@ | |||
1 | /* | ||
2 | * udf_fs_sb.h | ||
3 | * | ||
4 | * This include file is for the Linux kernel/module. | ||
5 | * | ||
6 | * COPYRIGHT | ||
7 | * This file is distributed under the terms of the GNU General Public | ||
8 | * License (GPL). Copies of the GPL can be obtained from: | ||
9 | * ftp://prep.ai.mit.edu/pub/gnu/GPL | ||
10 | * Each contributing author retains all rights to their own work. | ||
11 | */ | ||
12 | |||
13 | #ifndef _UDF_FS_SB_H | ||
14 | #define _UDF_FS_SB_H 1 | ||
15 | |||
16 | #include <linux/mutex.h> | ||
17 | |||
18 | #pragma pack(1) | ||
19 | |||
20 | #define UDF_MAX_BLOCK_LOADED 8 | ||
21 | |||
22 | #define UDF_TYPE1_MAP15 0x1511U | ||
23 | #define UDF_VIRTUAL_MAP15 0x1512U | ||
24 | #define UDF_VIRTUAL_MAP20 0x2012U | ||
25 | #define UDF_SPARABLE_MAP15 0x1522U | ||
26 | |||
27 | struct udf_sparing_data | ||
28 | { | ||
29 | __u16 s_packet_len; | ||
30 | struct buffer_head *s_spar_map[4]; | ||
31 | }; | ||
32 | |||
33 | struct udf_virtual_data | ||
34 | { | ||
35 | __u32 s_num_entries; | ||
36 | __u16 s_start_offset; | ||
37 | }; | ||
38 | |||
39 | struct udf_bitmap | ||
40 | { | ||
41 | __u32 s_extLength; | ||
42 | __u32 s_extPosition; | ||
43 | __u16 s_nr_groups; | ||
44 | struct buffer_head **s_block_bitmap; | ||
45 | }; | ||
46 | |||
47 | struct udf_part_map | ||
48 | { | ||
49 | union | ||
50 | { | ||
51 | struct udf_bitmap *s_bitmap; | ||
52 | struct inode *s_table; | ||
53 | } s_uspace; | ||
54 | union | ||
55 | { | ||
56 | struct udf_bitmap *s_bitmap; | ||
57 | struct inode *s_table; | ||
58 | } s_fspace; | ||
59 | __u32 s_partition_root; | ||
60 | __u32 s_partition_len; | ||
61 | __u16 s_partition_type; | ||
62 | __u16 s_partition_num; | ||
63 | union | ||
64 | { | ||
65 | struct udf_sparing_data s_sparing; | ||
66 | struct udf_virtual_data s_virtual; | ||
67 | } s_type_specific; | ||
68 | __u32 (*s_partition_func)(struct super_block *, __u32, __u16, __u32); | ||
69 | __u16 s_volumeseqnum; | ||
70 | __u16 s_partition_flags; | ||
71 | }; | ||
72 | |||
73 | #pragma pack() | ||
74 | |||
75 | struct udf_sb_info | ||
76 | { | ||
77 | struct udf_part_map *s_partmaps; | ||
78 | __u8 s_volume_ident[32]; | ||
79 | |||
80 | /* Overall info */ | ||
81 | __u16 s_partitions; | ||
82 | __u16 s_partition; | ||
83 | |||
84 | /* Sector headers */ | ||
85 | __s32 s_session; | ||
86 | __u32 s_anchor[4]; | ||
87 | __u32 s_last_block; | ||
88 | |||
89 | struct buffer_head *s_lvid_bh; | ||
90 | |||
91 | /* Default permissions */ | ||
92 | mode_t s_umask; | ||
93 | gid_t s_gid; | ||
94 | uid_t s_uid; | ||
95 | |||
96 | /* Root Info */ | ||
97 | struct timespec s_record_time; | ||
98 | |||
99 | /* Fileset Info */ | ||
100 | __u16 s_serial_number; | ||
101 | |||
102 | /* highest UDF revision we have recorded to this media */ | ||
103 | __u16 s_udfrev; | ||
104 | |||
105 | /* Miscellaneous flags */ | ||
106 | __u32 s_flags; | ||
107 | |||
108 | /* Encoding info */ | ||
109 | struct nls_table *s_nls_map; | ||
110 | |||
111 | /* VAT inode */ | ||
112 | struct inode *s_vat_inode; | ||
113 | |||
114 | struct mutex s_alloc_mutex; | ||
115 | }; | ||
116 | |||
117 | #endif /* _UDF_FS_SB_H */ | ||
diff --git a/kernel/sched.c b/kernel/sched.c index 57ba7ea9b744..0014b03adaca 100644 --- a/kernel/sched.c +++ b/kernel/sched.c | |||
@@ -7035,6 +7035,7 @@ static int find_next_best_node(int node, nodemask_t *used_nodes) | |||
7035 | /** | 7035 | /** |
7036 | * sched_domain_node_span - get a cpumask for a node's sched_domain | 7036 | * sched_domain_node_span - get a cpumask for a node's sched_domain |
7037 | * @node: node whose cpumask we're constructing | 7037 | * @node: node whose cpumask we're constructing |
7038 | * @span: resulting cpumask | ||
7038 | * | 7039 | * |
7039 | * Given a node, construct a good cpumask for its sched_domain to span. It | 7040 | * Given a node, construct a good cpumask for its sched_domain to span. It |
7040 | * should be one that prevents unnecessary balancing, but also spreads tasks | 7041 | * should be one that prevents unnecessary balancing, but also spreads tasks |
diff --git a/security/selinux/avc.c b/security/selinux/avc.c index 1d69f6649bff..95a8ef4a5073 100644 --- a/security/selinux/avc.c +++ b/security/selinux/avc.c | |||
@@ -312,6 +312,7 @@ static inline int avc_reclaim_node(void) | |||
312 | if (!spin_trylock_irqsave(&avc_cache.slots_lock[hvalue], flags)) | 312 | if (!spin_trylock_irqsave(&avc_cache.slots_lock[hvalue], flags)) |
313 | continue; | 313 | continue; |
314 | 314 | ||
315 | rcu_read_lock(); | ||
315 | list_for_each_entry(node, &avc_cache.slots[hvalue], list) { | 316 | list_for_each_entry(node, &avc_cache.slots[hvalue], list) { |
316 | if (atomic_dec_and_test(&node->ae.used)) { | 317 | if (atomic_dec_and_test(&node->ae.used)) { |
317 | /* Recently Unused */ | 318 | /* Recently Unused */ |
@@ -319,11 +320,13 @@ static inline int avc_reclaim_node(void) | |||
319 | avc_cache_stats_incr(reclaims); | 320 | avc_cache_stats_incr(reclaims); |
320 | ecx++; | 321 | ecx++; |
321 | if (ecx >= AVC_CACHE_RECLAIM) { | 322 | if (ecx >= AVC_CACHE_RECLAIM) { |
323 | rcu_read_unlock(); | ||
322 | spin_unlock_irqrestore(&avc_cache.slots_lock[hvalue], flags); | 324 | spin_unlock_irqrestore(&avc_cache.slots_lock[hvalue], flags); |
323 | goto out; | 325 | goto out; |
324 | } | 326 | } |
325 | } | 327 | } |
326 | } | 328 | } |
329 | rcu_read_unlock(); | ||
327 | spin_unlock_irqrestore(&avc_cache.slots_lock[hvalue], flags); | 330 | spin_unlock_irqrestore(&avc_cache.slots_lock[hvalue], flags); |
328 | } | 331 | } |
329 | out: | 332 | out: |
@@ -821,8 +824,14 @@ int avc_ss_reset(u32 seqno) | |||
821 | 824 | ||
822 | for (i = 0; i < AVC_CACHE_SLOTS; i++) { | 825 | for (i = 0; i < AVC_CACHE_SLOTS; i++) { |
823 | spin_lock_irqsave(&avc_cache.slots_lock[i], flag); | 826 | spin_lock_irqsave(&avc_cache.slots_lock[i], flag); |
827 | /* | ||
828 | * With preemptable RCU, the outer spinlock does not | ||
829 | * prevent RCU grace periods from ending. | ||
830 | */ | ||
831 | rcu_read_lock(); | ||
824 | list_for_each_entry(node, &avc_cache.slots[i], list) | 832 | list_for_each_entry(node, &avc_cache.slots[i], list) |
825 | avc_node_delete(node); | 833 | avc_node_delete(node); |
834 | rcu_read_unlock(); | ||
826 | spin_unlock_irqrestore(&avc_cache.slots_lock[i], flag); | 835 | spin_unlock_irqrestore(&avc_cache.slots_lock[i], flag); |
827 | } | 836 | } |
828 | 837 | ||
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c index 1bf2543ea942..33af321f647b 100644 --- a/security/selinux/hooks.c +++ b/security/selinux/hooks.c | |||
@@ -755,9 +755,18 @@ static void selinux_sb_clone_mnt_opts(const struct super_block *oldsb, | |||
755 | int set_context = (oldsbsec->flags & CONTEXT_MNT); | 755 | int set_context = (oldsbsec->flags & CONTEXT_MNT); |
756 | int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT); | 756 | int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT); |
757 | 757 | ||
758 | /* we can't error, we can't save the info, this shouldn't get called | 758 | /* |
759 | * this early in the boot process. */ | 759 | * if the parent was able to be mounted it clearly had no special lsm |
760 | BUG_ON(!ss_initialized); | 760 | * mount options. thus we can safely put this sb on the list and deal |
761 | * with it later | ||
762 | */ | ||
763 | if (!ss_initialized) { | ||
764 | spin_lock(&sb_security_lock); | ||
765 | if (list_empty(&newsbsec->list)) | ||
766 | list_add(&newsbsec->list, &superblock_security_head); | ||
767 | spin_unlock(&sb_security_lock); | ||
768 | return; | ||
769 | } | ||
761 | 770 | ||
762 | /* how can we clone if the old one wasn't set up?? */ | 771 | /* how can we clone if the old one wasn't set up?? */ |
763 | BUG_ON(!oldsbsec->initialized); | 772 | BUG_ON(!oldsbsec->initialized); |
diff --git a/security/selinux/netif.c b/security/selinux/netif.c index c658b84c3196..b4e14bc0bf32 100644 --- a/security/selinux/netif.c +++ b/security/selinux/netif.c | |||
@@ -239,11 +239,13 @@ static void sel_netif_kill(int ifindex) | |||
239 | { | 239 | { |
240 | struct sel_netif *netif; | 240 | struct sel_netif *netif; |
241 | 241 | ||
242 | rcu_read_lock(); | ||
242 | spin_lock_bh(&sel_netif_lock); | 243 | spin_lock_bh(&sel_netif_lock); |
243 | netif = sel_netif_find(ifindex); | 244 | netif = sel_netif_find(ifindex); |
244 | if (netif) | 245 | if (netif) |
245 | sel_netif_destroy(netif); | 246 | sel_netif_destroy(netif); |
246 | spin_unlock_bh(&sel_netif_lock); | 247 | spin_unlock_bh(&sel_netif_lock); |
248 | rcu_read_unlock(); | ||
247 | } | 249 | } |
248 | 250 | ||
249 | /** | 251 | /** |