Merge tag 'staging-3.14-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

+8 -8

drivers/iio/accel/bma180.c

··· 447 447 { }, 448 448 }; 449 449 450 - #define BMA180_CHANNEL(_index) { \ 450 + #define BMA180_CHANNEL(_axis) { \ 451 451 .type = IIO_ACCEL, \ 452 - .indexed = 1, \ 453 - .channel = (_index), \ 452 + .modified = 1, \ 453 + .channel2 = IIO_MOD_##_axis, \ 454 454 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 455 455 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \ 456 456 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 457 - .scan_index = (_index), \ 457 + .scan_index = AXIS_##_axis, \ 458 458 .scan_type = { \ 459 459 .sign = 's', \ 460 460 .realbits = 14, \ ··· 465 465 } 466 466 467 467 static const struct iio_chan_spec bma180_channels[] = { 468 - BMA180_CHANNEL(AXIS_X), 469 - BMA180_CHANNEL(AXIS_Y), 470 - BMA180_CHANNEL(AXIS_Z), 471 - IIO_CHAN_SOFT_TIMESTAMP(4), 468 + BMA180_CHANNEL(X), 469 + BMA180_CHANNEL(Y), 470 + BMA180_CHANNEL(Z), 471 + IIO_CHAN_SOFT_TIMESTAMP(3), 472 472 }; 473 473 474 474 static irqreturn_t bma180_trigger_handler(int irq, void *p)

+1 -1

drivers/iio/adc/max1363.c

··· 1560 1560 st->client = client; 1561 1561 1562 1562 st->vref_uv = st->chip_info->int_vref_mv * 1000; 1563 - vref = devm_regulator_get(&client->dev, "vref"); 1563 + vref = devm_regulator_get_optional(&client->dev, "vref"); 1564 1564 if (!IS_ERR(vref)) { 1565 1565 int vref_uv; 1566 1566

+1

drivers/iio/imu/adis16400.h

··· 189 189 ADIS16300_SCAN_INCLI_X, 190 190 ADIS16300_SCAN_INCLI_Y, 191 191 ADIS16400_SCAN_ADC, 192 + ADIS16400_SCAN_TIMESTAMP, 192 193 }; 193 194 194 195 #ifdef CONFIG_IIO_BUFFER

+5 -5

drivers/iio/imu/adis16400_core.c

··· 632 632 ADIS16400_MAGN_CHAN(Z, ADIS16400_ZMAGN_OUT, 14), 633 633 ADIS16400_TEMP_CHAN(ADIS16400_TEMP_OUT, 12), 634 634 ADIS16400_AUX_ADC_CHAN(ADIS16400_AUX_ADC, 12), 635 - IIO_CHAN_SOFT_TIMESTAMP(12) 635 + IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP), 636 636 }; 637 637 638 638 static const struct iio_chan_spec adis16448_channels[] = { ··· 659 659 }, 660 660 }, 661 661 ADIS16400_TEMP_CHAN(ADIS16448_TEMP_OUT, 12), 662 - IIO_CHAN_SOFT_TIMESTAMP(11) 662 + IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP), 663 663 }; 664 664 665 665 static const struct iio_chan_spec adis16350_channels[] = { ··· 677 677 ADIS16400_MOD_TEMP_CHAN(X, ADIS16350_XTEMP_OUT, 12), 678 678 ADIS16400_MOD_TEMP_CHAN(Y, ADIS16350_YTEMP_OUT, 12), 679 679 ADIS16400_MOD_TEMP_CHAN(Z, ADIS16350_ZTEMP_OUT, 12), 680 - IIO_CHAN_SOFT_TIMESTAMP(11) 680 + IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP), 681 681 }; 682 682 683 683 static const struct iio_chan_spec adis16300_channels[] = { ··· 690 690 ADIS16400_AUX_ADC_CHAN(ADIS16300_AUX_ADC, 12), 691 691 ADIS16400_INCLI_CHAN(X, ADIS16300_PITCH_OUT, 13), 692 692 ADIS16400_INCLI_CHAN(Y, ADIS16300_ROLL_OUT, 13), 693 - IIO_CHAN_SOFT_TIMESTAMP(14) 693 + IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP), 694 694 }; 695 695 696 696 static const struct iio_chan_spec adis16334_channels[] = { ··· 701 701 ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 14), 702 702 ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 14), 703 703 ADIS16400_TEMP_CHAN(ADIS16350_XTEMP_OUT, 12), 704 - IIO_CHAN_SOFT_TIMESTAMP(8) 704 + IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP), 705 705 }; 706 706 707 707 static struct attribute *adis16400_attributes[] = {

+10 -6

drivers/iio/light/tsl2563.c

··· 460 460 { 461 461 struct tsl2563_chip *chip = iio_priv(indio_dev); 462 462 463 - if (chan->channel == IIO_MOD_LIGHT_BOTH) 463 + if (mask != IIO_CHAN_INFO_CALIBSCALE) 464 + return -EINVAL; 465 + if (chan->channel2 == IIO_MOD_LIGHT_BOTH) 464 466 chip->calib0 = calib_from_sysfs(val); 465 - else 467 + else if (chan->channel2 == IIO_MOD_LIGHT_IR) 466 468 chip->calib1 = calib_from_sysfs(val); 469 + else 470 + return -EINVAL; 467 471 468 472 return 0; 469 473 } ··· 476 472 struct iio_chan_spec const *chan, 477 473 int *val, 478 474 int *val2, 479 - long m) 475 + long mask) 480 476 { 481 477 int ret = -EINVAL; 482 478 u32 calib0, calib1; 483 479 struct tsl2563_chip *chip = iio_priv(indio_dev); 484 480 485 481 mutex_lock(&chip->lock); 486 - switch (m) { 482 + switch (mask) { 487 483 case IIO_CHAN_INFO_RAW: 488 484 case IIO_CHAN_INFO_PROCESSED: 489 485 switch (chan->type) { ··· 502 498 ret = tsl2563_get_adc(chip); 503 499 if (ret) 504 500 goto error_ret; 505 - if (chan->channel == 0) 501 + if (chan->channel2 == IIO_MOD_LIGHT_BOTH) 506 502 *val = chip->data0; 507 503 else 508 504 *val = chip->data1; ··· 514 510 break; 515 511 516 512 case IIO_CHAN_INFO_CALIBSCALE: 517 - if (chan->channel == 0) 513 + if (chan->channel2 == IIO_MOD_LIGHT_BOTH) 518 514 *val = calib_to_sysfs(chip->calib0); 519 515 else 520 516 *val = calib_to_sysfs(chip->calib1);

+9 -7

drivers/iio/magnetometer/ak8975.c

··· 85 85 #define AK8975_MAX_CONVERSION_TIMEOUT 500 86 86 #define AK8975_CONVERSION_DONE_POLL_TIME 10 87 87 #define AK8975_DATA_READY_TIMEOUT ((100*HZ)/1000) 88 + #define RAW_TO_GAUSS(asa) ((((asa) + 128) * 3000) / 256) 88 89 89 90 /* 90 91 * Per-instance context data for the device. ··· 266 265 * 267 266 * Since 1uT = 0.01 gauss, our final scale factor becomes: 268 267 * 269 - * Hadj = H * ((ASA + 128) / 256) * 3/10 * 100 270 - * Hadj = H * ((ASA + 128) * 30 / 256 268 + * Hadj = H * ((ASA + 128) / 256) * 3/10 * 1/100 269 + * Hadj = H * ((ASA + 128) * 0.003) / 256 271 270 * 272 271 * Since ASA doesn't change, we cache the resultant scale factor into the 273 272 * device context in ak8975_setup(). 274 273 */ 275 - data->raw_to_gauss[0] = ((data->asa[0] + 128) * 30) >> 8; 276 - data->raw_to_gauss[1] = ((data->asa[1] + 128) * 30) >> 8; 277 - data->raw_to_gauss[2] = ((data->asa[2] + 128) * 30) >> 8; 274 + data->raw_to_gauss[0] = RAW_TO_GAUSS(data->asa[0]); 275 + data->raw_to_gauss[1] = RAW_TO_GAUSS(data->asa[1]); 276 + data->raw_to_gauss[2] = RAW_TO_GAUSS(data->asa[2]); 278 277 279 278 return 0; 280 279 } ··· 429 428 case IIO_CHAN_INFO_RAW: 430 429 return ak8975_read_axis(indio_dev, chan->address, val); 431 430 case IIO_CHAN_INFO_SCALE: 432 - *val = data->raw_to_gauss[chan->address]; 433 - return IIO_VAL_INT; 431 + *val = 0; 432 + *val2 = data->raw_to_gauss[chan->address]; 433 + return IIO_VAL_INT_PLUS_MICRO; 434 434 } 435 435 return -EINVAL; 436 436 }

+7 -1

drivers/iio/magnetometer/mag3110.c

··· 106 106 107 107 while (n-- > 0) 108 108 len += scnprintf(buf + len, PAGE_SIZE - len, 109 - "%d.%d ", vals[n][0], vals[n][1]); 109 + "%d.%06d ", vals[n][0], vals[n][1]); 110 110 111 111 /* replace trailing space by newline */ 112 112 buf[len - 1] = '\n'; ··· 154 154 155 155 switch (mask) { 156 156 case IIO_CHAN_INFO_RAW: 157 + if (iio_buffer_enabled(indio_dev)) 158 + return -EBUSY; 159 + 157 160 switch (chan->type) { 158 161 case IIO_MAGN: /* in 0.1 uT / LSB */ 159 162 ret = mag3110_read(data, buffer); ··· 201 198 { 202 199 struct mag3110_data *data = iio_priv(indio_dev); 203 200 int rate; 201 + 202 + if (iio_buffer_enabled(indio_dev)) 203 + return -EBUSY; 204 204 205 205 switch (mask) { 206 206 case IIO_CHAN_INFO_SAMP_FREQ:

+26 -19

drivers/staging/android/ashmem.c

··· 295 295 296 296 /* If size is not set, or set to 0, always return EOF. */ 297 297 if (asma->size == 0) 298 - goto out; 298 + goto out_unlock; 299 299 300 300 if (!asma->file) { 301 301 ret = -EBADF; 302 - goto out; 302 + goto out_unlock; 303 303 } 304 304 305 + mutex_unlock(&ashmem_mutex); 306 + 307 + /* 308 + * asma and asma->file are used outside the lock here. We assume 309 + * once asma->file is set it will never be changed, and will not 310 + * be destroyed until all references to the file are dropped and 311 + * ashmem_release is called. 312 + */ 305 313 ret = asma->file->f_op->read(asma->file, buf, len, pos); 306 - if (ret < 0) 307 - goto out; 314 + if (ret >= 0) { 315 + /** Update backing file pos, since f_ops->read() doesn't */ 316 + asma->file->f_pos = *pos; 317 + } 318 + return ret; 308 319 309 - /** Update backing file pos, since f_ops->read() doesn't */ 310 - asma->file->f_pos = *pos; 311 - 312 - out: 320 + out_unlock: 313 321 mutex_unlock(&ashmem_mutex); 314 322 return ret; 315 323 } ··· 506 498 507 499 static int set_name(struct ashmem_area *asma, void __user *name) 508 500 { 501 + int len; 509 502 int ret = 0; 510 503 char local_name[ASHMEM_NAME_LEN]; 511 504 ··· 519 510 * variable that does not need protection and later copy the local 520 511 * variable to the structure member with lock held. 521 512 */ 522 - if (copy_from_user(local_name, name, ASHMEM_NAME_LEN)) 523 - return -EFAULT; 524 - 513 + len = strncpy_from_user(local_name, name, ASHMEM_NAME_LEN); 514 + if (len < 0) 515 + return len; 516 + if (len == ASHMEM_NAME_LEN) 517 + local_name[ASHMEM_NAME_LEN - 1] = '\0'; 525 518 mutex_lock(&ashmem_mutex); 526 519 /* cannot change an existing mapping's name */ 527 - if (unlikely(asma->file)) { 520 + if (unlikely(asma->file)) 528 521 ret = -EINVAL; 529 - goto out; 530 - } 531 - memcpy(asma->name + ASHMEM_NAME_PREFIX_LEN, 532 - local_name, ASHMEM_NAME_LEN); 533 - asma->name[ASHMEM_FULL_NAME_LEN-1] = '\0'; 534 - out: 535 - mutex_unlock(&ashmem_mutex); 522 + else 523 + strcpy(asma->name + ASHMEM_NAME_PREFIX_LEN, local_name); 536 524 525 + mutex_unlock(&ashmem_mutex); 537 526 return ret; 538 527 } 539 528

+22 -4

drivers/staging/android/ion/compat_ion.c

··· 35 35 compat_ulong_t arg; 36 36 }; 37 37 38 + struct compat_ion_handle_data { 39 + compat_int_t handle; 40 + }; 41 + 38 42 #define COMPAT_ION_IOC_ALLOC _IOWR(ION_IOC_MAGIC, 0, \ 39 43 struct compat_ion_allocation_data) 40 - #define COMPAT_ION_IOC_FREE _IOWR(ION_IOC_MAGIC, 1, struct ion_handle_data) 44 + #define COMPAT_ION_IOC_FREE _IOWR(ION_IOC_MAGIC, 1, \ 45 + struct compat_ion_handle_data) 41 46 #define COMPAT_ION_IOC_CUSTOM _IOWR(ION_IOC_MAGIC, 6, \ 42 47 struct compat_ion_custom_data) 43 48 ··· 64 59 err |= get_user(u, &data32->flags); 65 60 err |= put_user(u, &data->flags); 66 61 err |= get_user(i, &data32->handle); 62 + err |= put_user(i, &data->handle); 63 + 64 + return err; 65 + } 66 + 67 + static int compat_get_ion_handle_data( 68 + struct compat_ion_handle_data __user *data32, 69 + struct ion_handle_data __user *data) 70 + { 71 + compat_int_t i; 72 + int err; 73 + 74 + err = get_user(i, &data32->handle); 67 75 err |= put_user(i, &data->handle); 68 76 69 77 return err; ··· 150 132 } 151 133 case COMPAT_ION_IOC_FREE: 152 134 { 153 - struct compat_ion_allocation_data __user *data32; 154 - struct ion_allocation_data __user *data; 135 + struct compat_ion_handle_data __user *data32; 136 + struct ion_handle_data __user *data; 155 137 int err; 156 138 157 139 data32 = compat_ptr(arg); ··· 159 141 if (data == NULL) 160 142 return -EFAULT; 161 143 162 - err = compat_get_ion_allocation_data(data32, data); 144 + err = compat_get_ion_handle_data(data32, data); 163 145 if (err) 164 146 return err; 165 147

+6 -6

drivers/staging/android/ion/ion_dummy_driver.c

··· 17 17 #include <linux/err.h> 18 18 #include <linux/platform_device.h> 19 19 #include <linux/slab.h> 20 + #include <linux/init.h> 20 21 #include <linux/bootmem.h> 21 22 #include <linux/memblock.h> 22 23 #include <linux/sizes.h> 24 + #include <linux/io.h> 23 25 #include "ion.h" 24 26 #include "ion_priv.h" 25 27 ··· 59 57 }; 60 58 61 59 struct ion_platform_data dummy_ion_pdata = { 62 - .nr = 4, 60 + .nr = ARRAY_SIZE(dummy_heaps), 63 61 .heaps = dummy_heaps, 64 62 }; 65 63 ··· 71 69 heaps = kzalloc(sizeof(struct ion_heap *) * dummy_ion_pdata.nr, 72 70 GFP_KERNEL); 73 71 if (!heaps) 74 - return PTR_ERR(heaps); 72 + return -ENOMEM; 75 73 76 74 77 75 /* Allocate a dummy carveout heap */ ··· 130 128 } 131 129 return err; 132 130 } 131 + device_initcall(ion_dummy_init); 133 132 134 133 static void __exit ion_dummy_exit(void) 135 134 { ··· 155 152 156 153 return; 157 154 } 158 - 159 - module_init(ion_dummy_init); 160 - module_exit(ion_dummy_exit); 161 - 155 + __exitcall(ion_dummy_exit);

+1 -1

drivers/staging/android/ion/ion_heap.c

··· 243 243 init_waitqueue_head(&heap->waitqueue); 244 244 heap->task = kthread_run(ion_heap_deferred_free, heap, 245 245 "%s", heap->name); 246 - sched_setscheduler(heap->task, SCHED_IDLE, &param); 247 246 if (IS_ERR(heap->task)) { 248 247 pr_err("%s: creating thread for deferred free failed\n", 249 248 __func__); 250 249 return PTR_RET(heap->task); 251 250 } 251 + sched_setscheduler(heap->task, SCHED_IDLE, &param); 252 252 return 0; 253 253 } 254 254

+1

drivers/staging/android/ion/ion_priv.h

··· 17 17 #ifndef _ION_PRIV_H 18 18 #define _ION_PRIV_H 19 19 20 + #include <linux/device.h> 20 21 #include <linux/dma-direction.h> 21 22 #include <linux/kref.h> 22 23 #include <linux/mm_types.h>

+5 -1

drivers/staging/android/ion/ion_system_heap.c

··· 124 124 125 125 info->page = page; 126 126 info->order = orders[i]; 127 + INIT_LIST_HEAD(&info->list); 127 128 return info; 128 129 } 129 130 kfree(info); ··· 146 145 struct list_head pages; 147 146 struct page_info *info, *tmp_info; 148 147 int i = 0; 149 - long size_remaining = PAGE_ALIGN(size); 148 + unsigned long size_remaining = PAGE_ALIGN(size); 150 149 unsigned int max_order = orders[0]; 151 150 152 151 if (align > PAGE_SIZE) 153 152 return -EINVAL; 153 + 154 + if (size / PAGE_SIZE > totalram_pages / 2) 155 + return -ENOMEM; 154 156 155 157 INIT_LIST_HEAD(&pages); 156 158 while (size_remaining > 0) {

+17

drivers/staging/android/sw_sync.h

··· 35 35 u32 value; 36 36 }; 37 37 38 + #if IS_ENABLED(CONFIG_SW_SYNC) 38 39 struct sw_sync_timeline *sw_sync_timeline_create(const char *name); 39 40 void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc); 40 41 41 42 struct sync_pt *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value); 43 + #else 44 + static inline struct sw_sync_timeline *sw_sync_timeline_create(const char *name) 45 + { 46 + return NULL; 47 + } 48 + 49 + static inline void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc) 50 + { 51 + } 52 + 53 + static inline struct sync_pt *sw_sync_pt_create(struct sw_sync_timeline *obj, 54 + u32 value) 55 + { 56 + return NULL; 57 + } 58 + #endif /* IS_ENABLED(CONFIG_SW_SYNC) */ 42 59 43 60 #endif /* __KERNEL __ */ 44 61

+7 -7

drivers/staging/android/sync.c

··· 79 79 container_of(kref, struct sync_timeline, kref); 80 80 unsigned long flags; 81 81 82 - if (obj->ops->release_obj) 83 - obj->ops->release_obj(obj); 84 - 85 82 spin_lock_irqsave(&sync_timeline_list_lock, flags); 86 83 list_del(&obj->sync_timeline_list); 87 84 spin_unlock_irqrestore(&sync_timeline_list_lock, flags); 85 + 86 + if (obj->ops->release_obj) 87 + obj->ops->release_obj(obj); 88 88 89 89 kfree(obj); 90 90 } ··· 92 92 void sync_timeline_destroy(struct sync_timeline *obj) 93 93 { 94 94 obj->destroyed = true; 95 + smp_wmb(); 95 96 96 97 /* 97 - * If this is not the last reference, signal any children 98 - * that their parent is going away. 98 + * signal any children that their parent is going away. 99 99 */ 100 + sync_timeline_signal(obj); 100 101 101 - if (!kref_put(&obj->kref, sync_timeline_free)) 102 - sync_timeline_signal(obj); 102 + kref_put(&obj->kref, sync_timeline_free); 103 103 } 104 104 EXPORT_SYMBOL(sync_timeline_destroy); 105 105

-2

drivers/staging/comedi/drivers.c

··· 616 616 ret = driver->auto_attach(dev, context); 617 617 if (ret >= 0) 618 618 ret = comedi_device_postconfig(dev); 619 - if (ret < 0) 620 - comedi_device_detach(dev); 621 619 mutex_unlock(&dev->mutex); 622 620 623 621 if (ret < 0) {

+12 -5

drivers/staging/comedi/drivers/adv_pci1710.c

··· 494 494 struct comedi_insn *insn, unsigned int *data) 495 495 { 496 496 struct pci1710_private *devpriv = dev->private; 497 + unsigned int val; 497 498 int n, chan, range, ofs; 498 499 499 500 chan = CR_CHAN(insn->chanspec); ··· 510 509 outw(devpriv->da_ranges, dev->iobase + PCI171x_DAREF); 511 510 ofs = PCI171x_DA1; 512 511 } 512 + val = devpriv->ao_data[chan]; 513 513 514 - for (n = 0; n < insn->n; n++) 515 - outw(data[n], dev->iobase + ofs); 514 + for (n = 0; n < insn->n; n++) { 515 + val = data[n]; 516 + outw(val, dev->iobase + ofs); 517 + } 516 518 517 - devpriv->ao_data[chan] = data[n]; 519 + devpriv->ao_data[chan] = val; 518 520 519 521 return n; 520 522 ··· 683 679 struct comedi_insn *insn, unsigned int *data) 684 680 { 685 681 struct pci1710_private *devpriv = dev->private; 682 + unsigned int val; 686 683 int n, rangereg, chan; 687 684 688 685 chan = CR_CHAN(insn->chanspec); ··· 693 688 outb(rangereg, dev->iobase + PCI1720_RANGE); 694 689 devpriv->da_ranges = rangereg; 695 690 } 691 + val = devpriv->ao_data[chan]; 696 692 697 693 for (n = 0; n < insn->n; n++) { 698 - outw(data[n], dev->iobase + PCI1720_DA0 + (chan << 1)); 694 + val = data[n]; 695 + outw(val, dev->iobase + PCI1720_DA0 + (chan << 1)); 699 696 outb(0, dev->iobase + PCI1720_SYNCOUT); /* update outputs */ 700 697 } 701 698 702 - devpriv->ao_data[chan] = data[n]; 699 + devpriv->ao_data[chan] = val; 703 700 704 701 return n; 705 702 }

+4 -2

drivers/staging/comedi/drivers/usbduxsigma.c

··· 48 48 #include <linux/usb.h> 49 49 #include <linux/fcntl.h> 50 50 #include <linux/compiler.h> 51 + #include <asm/unaligned.h> 51 52 52 53 #include "comedi_fc.h" 53 54 #include "../comedidev.h" ··· 793 792 } 794 793 795 794 /* 32 bits big endian from the A/D converter */ 796 - val = be32_to_cpu(*((uint32_t *)((devpriv->insn_buf) + 1))); 795 + val = be32_to_cpu(get_unaligned((uint32_t 796 + *)(devpriv->insn_buf + 1))); 797 797 val &= 0x00ffffff; /* strip status byte */ 798 798 val ^= 0x00800000; /* convert to unsigned */ 799 799 ··· 1359 1357 return ret; 1360 1358 1361 1359 /* 32 bits big endian from the A/D converter */ 1362 - val = be32_to_cpu(*((uint32_t *)((devpriv->insn_buf)+1))); 1360 + val = be32_to_cpu(get_unaligned((uint32_t *)(devpriv->insn_buf + 1))); 1363 1361 val &= 0x00ffffff; /* strip status byte */ 1364 1362 val ^= 0x00800000; /* convert to unsigned */ 1365 1363

+155 -175

drivers/staging/dgrp/dgrp_net_ops.c

··· 2232 2232 return rtn; 2233 2233 } 2234 2234 2235 - /* 2236 - * Common Packet Handling code 2237 - */ 2238 - 2239 - static void handle_data_in_packet(struct nd_struct *nd, struct ch_struct *ch, 2240 - long dlen, long plen, int n1, u8 *dbuf) 2241 - { 2242 - char *error; 2243 - long n; 2244 - long remain; 2245 - u8 *buf; 2246 - u8 *b; 2247 - 2248 - remain = nd->nd_remain; 2249 - nd->nd_tx_work = 1; 2250 - 2251 - /* 2252 - * Otherwise data should appear only when we are 2253 - * in the CS_READY state. 2254 - */ 2255 - 2256 - if (ch->ch_state < CS_READY) { 2257 - error = "Data received before RWIN established"; 2258 - nd->nd_remain = 0; 2259 - nd->nd_state = NS_SEND_ERROR; 2260 - nd->nd_error = error; 2261 - } 2262 - 2263 - /* 2264 - * Assure that the data received is within the 2265 - * allowable window. 2266 - */ 2267 - 2268 - n = (ch->ch_s_rwin - ch->ch_s_rin) & 0xffff; 2269 - 2270 - if (dlen > n) { 2271 - error = "Receive data overrun"; 2272 - nd->nd_remain = 0; 2273 - nd->nd_state = NS_SEND_ERROR; 2274 - nd->nd_error = error; 2275 - } 2276 - 2277 - /* 2278 - * If we received 3 or less characters, 2279 - * assume it is a human typing, and set RTIME 2280 - * to 10 milliseconds. 2281 - * 2282 - * If we receive 10 or more characters, 2283 - * assume its not a human typing, and set RTIME 2284 - * to 100 milliseconds. 2285 - */ 2286 - 2287 - if (ch->ch_edelay != DGRP_RTIME) { 2288 - if (ch->ch_rtime != ch->ch_edelay) { 2289 - ch->ch_rtime = ch->ch_edelay; 2290 - ch->ch_flag |= CH_PARAM; 2291 - } 2292 - } else if (dlen <= 3) { 2293 - if (ch->ch_rtime != 10) { 2294 - ch->ch_rtime = 10; 2295 - ch->ch_flag |= CH_PARAM; 2296 - } 2297 - } else { 2298 - if (ch->ch_rtime != DGRP_RTIME) { 2299 - ch->ch_rtime = DGRP_RTIME; 2300 - ch->ch_flag |= CH_PARAM; 2301 - } 2302 - } 2303 - 2304 - /* 2305 - * If a portion of the packet is outside the 2306 - * buffer, shorten the effective length of the 2307 - * data packet to be the amount of data received. 2308 - */ 2309 - 2310 - if (remain < plen) 2311 - dlen -= plen - remain; 2312 - 2313 - /* 2314 - * Detect if receive flush is now complete. 2315 - */ 2316 - 2317 - if ((ch->ch_flag & CH_RX_FLUSH) != 0 && 2318 - ((ch->ch_flush_seq - nd->nd_seq_out) & SEQ_MASK) >= 2319 - ((nd->nd_seq_in - nd->nd_seq_out) & SEQ_MASK)) { 2320 - ch->ch_flag &= ~CH_RX_FLUSH; 2321 - } 2322 - 2323 - /* 2324 - * If we are ready to receive, move the data into 2325 - * the receive buffer. 2326 - */ 2327 - 2328 - ch->ch_s_rin = (ch->ch_s_rin + dlen) & 0xffff; 2329 - 2330 - if (ch->ch_state == CS_READY && 2331 - (ch->ch_tun.un_open_count != 0) && 2332 - (ch->ch_tun.un_flag & UN_CLOSING) == 0 && 2333 - (ch->ch_cflag & CF_CREAD) != 0 && 2334 - (ch->ch_flag & (CH_BAUD0 | CH_RX_FLUSH)) == 0 && 2335 - (ch->ch_send & RR_RX_FLUSH) == 0) { 2336 - 2337 - if (ch->ch_rin + dlen >= RBUF_MAX) { 2338 - n = RBUF_MAX - ch->ch_rin; 2339 - 2340 - memcpy(ch->ch_rbuf + ch->ch_rin, dbuf, n); 2341 - 2342 - ch->ch_rin = 0; 2343 - dbuf += n; 2344 - dlen -= n; 2345 - } 2346 - 2347 - memcpy(ch->ch_rbuf + ch->ch_rin, dbuf, dlen); 2348 - 2349 - ch->ch_rin += dlen; 2350 - 2351 - 2352 - /* 2353 - * If we are not in fastcook mode, or 2354 - * if there is a fastcook thread 2355 - * waiting for data, send the data to 2356 - * the line discipline. 2357 - */ 2358 - 2359 - if ((ch->ch_flag & CH_FAST_READ) == 0 || 2360 - ch->ch_inwait != 0) { 2361 - dgrp_input(ch); 2362 - } 2363 - 2364 - /* 2365 - * If there is a read thread waiting 2366 - * in select, and we are in fastcook 2367 - * mode, wake him up. 2368 - */ 2369 - 2370 - if (waitqueue_active(&ch->ch_tun.un_tty->read_wait) && 2371 - (ch->ch_flag & CH_FAST_READ) != 0) 2372 - wake_up_interruptible(&ch->ch_tun.un_tty->read_wait); 2373 - 2374 - /* 2375 - * Wake any thread waiting in the 2376 - * fastcook loop. 2377 - */ 2378 - 2379 - if ((ch->ch_flag & CH_INPUT) != 0) { 2380 - ch->ch_flag &= ~CH_INPUT; 2381 - wake_up_interruptible(&ch->ch_flag_wait); 2382 - } 2383 - } 2384 - 2385 - /* 2386 - * Fabricate and insert a data packet header to 2387 - * preced the remaining data when it comes in. 2388 - */ 2389 - 2390 - if (remain < plen) { 2391 - dlen = plen - remain; 2392 - b = buf; 2393 - 2394 - b[0] = 0x90 + n1; 2395 - put_unaligned_be16(dlen, b + 1); 2396 - 2397 - remain = 3; 2398 - if (remain > 0 && b != buf) 2399 - memcpy(buf, b, remain); 2400 - 2401 - nd->nd_remain = remain; 2402 - return; 2403 - } 2404 - } 2405 - 2406 2235 /** 2407 2236 * dgrp_receive() -- decode data packets received from the remote PortServer. 2408 2237 * @nd: pointer to a node structure ··· 2306 2477 plen = dlen + 1; 2307 2478 2308 2479 dbuf = b + 1; 2309 - handle_data_in_packet(nd, ch, dlen, plen, n1, dbuf); 2310 - break; 2480 + goto data; 2311 2481 2312 2482 /* 2313 2483 * Process 2-byte header data packet. ··· 2320 2492 plen = dlen + 2; 2321 2493 2322 2494 dbuf = b + 2; 2323 - handle_data_in_packet(nd, ch, dlen, plen, n1, dbuf); 2324 - break; 2495 + goto data; 2325 2496 2326 2497 /* 2327 2498 * Process 3-byte header data packet. ··· 2335 2508 2336 2509 dbuf = b + 3; 2337 2510 2511 + /* 2512 + * Common packet handling code. 2513 + */ 2514 + 2515 + data: 2516 + nd->nd_tx_work = 1; 2517 + 2518 + /* 2519 + * Otherwise data should appear only when we are 2520 + * in the CS_READY state. 2521 + */ 2522 + 2523 + if (ch->ch_state < CS_READY) { 2524 + error = "Data received before RWIN established"; 2525 + goto prot_error; 2526 + } 2527 + 2528 + /* 2529 + * Assure that the data received is within the 2530 + * allowable window. 2531 + */ 2532 + 2533 + n = (ch->ch_s_rwin - ch->ch_s_rin) & 0xffff; 2534 + 2535 + if (dlen > n) { 2536 + error = "Receive data overrun"; 2537 + goto prot_error; 2538 + } 2539 + 2540 + /* 2541 + * If we received 3 or less characters, 2542 + * assume it is a human typing, and set RTIME 2543 + * to 10 milliseconds. 2544 + * 2545 + * If we receive 10 or more characters, 2546 + * assume its not a human typing, and set RTIME 2547 + * to 100 milliseconds. 2548 + */ 2549 + 2550 + if (ch->ch_edelay != DGRP_RTIME) { 2551 + if (ch->ch_rtime != ch->ch_edelay) { 2552 + ch->ch_rtime = ch->ch_edelay; 2553 + ch->ch_flag |= CH_PARAM; 2554 + } 2555 + } else if (dlen <= 3) { 2556 + if (ch->ch_rtime != 10) { 2557 + ch->ch_rtime = 10; 2558 + ch->ch_flag |= CH_PARAM; 2559 + } 2560 + } else { 2561 + if (ch->ch_rtime != DGRP_RTIME) { 2562 + ch->ch_rtime = DGRP_RTIME; 2563 + ch->ch_flag |= CH_PARAM; 2564 + } 2565 + } 2566 + 2567 + /* 2568 + * If a portion of the packet is outside the 2569 + * buffer, shorten the effective length of the 2570 + * data packet to be the amount of data received. 2571 + */ 2572 + 2573 + if (remain < plen) 2574 + dlen -= plen - remain; 2575 + 2576 + /* 2577 + * Detect if receive flush is now complete. 2578 + */ 2579 + 2580 + if ((ch->ch_flag & CH_RX_FLUSH) != 0 && 2581 + ((ch->ch_flush_seq - nd->nd_seq_out) & SEQ_MASK) >= 2582 + ((nd->nd_seq_in - nd->nd_seq_out) & SEQ_MASK)) { 2583 + ch->ch_flag &= ~CH_RX_FLUSH; 2584 + } 2585 + 2586 + /* 2587 + * If we are ready to receive, move the data into 2588 + * the receive buffer. 2589 + */ 2590 + 2591 + ch->ch_s_rin = (ch->ch_s_rin + dlen) & 0xffff; 2592 + 2593 + if (ch->ch_state == CS_READY && 2594 + (ch->ch_tun.un_open_count != 0) && 2595 + (ch->ch_tun.un_flag & UN_CLOSING) == 0 && 2596 + (ch->ch_cflag & CF_CREAD) != 0 && 2597 + (ch->ch_flag & (CH_BAUD0 | CH_RX_FLUSH)) == 0 && 2598 + (ch->ch_send & RR_RX_FLUSH) == 0) { 2599 + 2600 + if (ch->ch_rin + dlen >= RBUF_MAX) { 2601 + n = RBUF_MAX - ch->ch_rin; 2602 + 2603 + memcpy(ch->ch_rbuf + ch->ch_rin, dbuf, n); 2604 + 2605 + ch->ch_rin = 0; 2606 + dbuf += n; 2607 + dlen -= n; 2608 + } 2609 + 2610 + memcpy(ch->ch_rbuf + ch->ch_rin, dbuf, dlen); 2611 + 2612 + ch->ch_rin += dlen; 2613 + 2614 + 2615 + /* 2616 + * If we are not in fastcook mode, or 2617 + * if there is a fastcook thread 2618 + * waiting for data, send the data to 2619 + * the line discipline. 2620 + */ 2621 + 2622 + if ((ch->ch_flag & CH_FAST_READ) == 0 || 2623 + ch->ch_inwait != 0) { 2624 + dgrp_input(ch); 2625 + } 2626 + 2627 + /* 2628 + * If there is a read thread waiting 2629 + * in select, and we are in fastcook 2630 + * mode, wake him up. 2631 + */ 2632 + 2633 + if (waitqueue_active(&ch->ch_tun.un_tty->read_wait) && 2634 + (ch->ch_flag & CH_FAST_READ) != 0) 2635 + wake_up_interruptible(&ch->ch_tun.un_tty->read_wait); 2636 + 2637 + /* 2638 + * Wake any thread waiting in the 2639 + * fastcook loop. 2640 + */ 2641 + 2642 + if ((ch->ch_flag & CH_INPUT) != 0) { 2643 + ch->ch_flag &= ~CH_INPUT; 2644 + 2645 + wake_up_interruptible(&ch->ch_flag_wait); 2646 + } 2647 + } 2648 + 2649 + /* 2650 + * Fabricate and insert a data packet header to 2651 + * preced the remaining data when it comes in. 2652 + */ 2653 + 2654 + if (remain < plen) { 2655 + dlen = plen - remain; 2656 + b = buf; 2657 + 2658 + b[0] = 0x90 + n1; 2659 + put_unaligned_be16(dlen, b + 1); 2660 + 2661 + remain = 3; 2662 + goto done; 2663 + } 2338 2664 break; 2339 2665 2340 2666 /*

+3

drivers/staging/gdm72xx/gdm_usb.c

··· 635 635 #endif /* CONFIG_WIMAX_GDM72XX_USB_PM */ 636 636 637 637 ret = register_wimax_device(phy_dev, &intf->dev); 638 + if (ret) 639 + release_usb(udev); 638 640 639 641 out: 640 642 if (ret) { 641 643 kfree(phy_dev); 642 644 kfree(udev); 645 + usb_put_dev(usbdev); 643 646 } else { 644 647 usb_set_intfdata(intf, phy_dev); 645 648 }

+3 -3

drivers/staging/iio/Documentation/iio_utils.h

··· 77 77 uint64_t mask; 78 78 unsigned be; 79 79 unsigned is_signed; 80 - unsigned enabled; 81 80 unsigned location; 82 81 }; 83 82 ··· 334 335 while (ent = readdir(dp), ent != NULL) { 335 336 if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), 336 337 "_en") == 0) { 338 + int current_enabled = 0; 337 339 current = &(*ci_array)[count++]; 338 340 ret = asprintf(&filename, 339 341 "%s/%s", scan_el_dir, ent->d_name); ··· 350 350 ret = -errno; 351 351 goto error_cleanup_array; 352 352 } 353 - fscanf(sysfsfp, "%u", &current->enabled); 353 + fscanf(sysfsfp, "%u", &current_enabled); 354 354 fclose(sysfsfp); 355 355 356 - if (!current->enabled) { 356 + if (!current_enabled) { 357 357 free(filename); 358 358 count--; 359 359 continue;

+10 -3

drivers/staging/iio/adc/ad799x_core.c

··· 393 393 }, { 394 394 .type = IIO_EV_TYPE_THRESH, 395 395 .dir = IIO_EV_DIR_FALLING, 396 - .mask_separate = BIT(IIO_EV_INFO_VALUE), 396 + .mask_separate = BIT(IIO_EV_INFO_VALUE) | 397 397 BIT(IIO_EV_INFO_ENABLE), 398 398 }, { 399 399 .type = IIO_EV_TYPE_THRESH, ··· 409 409 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 410 410 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 411 411 .scan_index = (_index), \ 412 - .scan_type = IIO_ST('u', _realbits, 16, 12 - (_realbits)), \ 412 + .scan_type = { \ 413 + .sign = 'u', \ 414 + .realbits = (_realbits), \ 415 + .storagebits = 16, \ 416 + .shift = 12 - (_realbits), \ 417 + .endianness = IIO_BE, \ 418 + }, \ 413 419 .event_spec = _ev_spec, \ 414 420 .num_event_specs = _num_ev_spec, \ 415 421 } ··· 594 588 return 0; 595 589 596 590 error_free_irq: 597 - free_irq(client->irq, indio_dev); 591 + if (client->irq > 0) 592 + free_irq(client->irq, indio_dev); 598 593 error_cleanup_ring: 599 594 ad799x_ring_cleanup(indio_dev); 600 595 error_disable_reg:

+1 -5

drivers/staging/iio/adc/mxs-lradc.c

··· 1035 1035 SHOW_SCALE_AVAILABLE_ATTR(5); 1036 1036 SHOW_SCALE_AVAILABLE_ATTR(6); 1037 1037 SHOW_SCALE_AVAILABLE_ATTR(7); 1038 - SHOW_SCALE_AVAILABLE_ATTR(8); 1039 - SHOW_SCALE_AVAILABLE_ATTR(9); 1040 1038 SHOW_SCALE_AVAILABLE_ATTR(10); 1041 1039 SHOW_SCALE_AVAILABLE_ATTR(11); 1042 1040 SHOW_SCALE_AVAILABLE_ATTR(12); ··· 1051 1053 &iio_dev_attr_in_voltage5_scale_available.dev_attr.attr, 1052 1054 &iio_dev_attr_in_voltage6_scale_available.dev_attr.attr, 1053 1055 &iio_dev_attr_in_voltage7_scale_available.dev_attr.attr, 1054 - &iio_dev_attr_in_voltage8_scale_available.dev_attr.attr, 1055 - &iio_dev_attr_in_voltage9_scale_available.dev_attr.attr, 1056 1056 &iio_dev_attr_in_voltage10_scale_available.dev_attr.attr, 1057 1057 &iio_dev_attr_in_voltage11_scale_available.dev_attr.attr, 1058 1058 &iio_dev_attr_in_voltage12_scale_available.dev_attr.attr, ··· 1609 1613 * of the array. 1610 1614 */ 1611 1615 scale_uv = ((u64)lradc->vref_mv[i] * 100000000) >> 1612 - (iio->channels[i].scan_type.realbits - s); 1616 + (LRADC_RESOLUTION - s); 1613 1617 lradc->scale_avail[i][s].nano = 1614 1618 do_div(scale_uv, 100000000) * 10; 1615 1619 lradc->scale_avail[i][s].integer = scale_uv;

+1 -1

drivers/staging/iio/impedance-analyzer/ad5933.c

··· 629 629 struct iio_buffer *buffer; 630 630 631 631 buffer = iio_kfifo_allocate(indio_dev); 632 - if (buffer) 632 + if (!buffer) 633 633 return -ENOMEM; 634 634 635 635 iio_device_attach_buffer(indio_dev, buffer);

+20 -35

drivers/staging/imx-drm/imx-drm-core.c

··· 88 88 89 89 imx_drm_device_put(); 90 90 91 - drm_vblank_cleanup(imxdrm->drm); 92 - drm_kms_helper_poll_fini(imxdrm->drm); 93 - drm_mode_config_cleanup(imxdrm->drm); 91 + drm_vblank_cleanup(drm); 92 + drm_kms_helper_poll_fini(drm); 93 + drm_mode_config_cleanup(drm); 94 94 95 95 return 0; 96 96 } ··· 142 142 143 143 int imx_drm_crtc_vblank_get(struct imx_drm_crtc *imx_drm_crtc) 144 144 { 145 - return drm_vblank_get(imx_drm_crtc->imxdrm->drm, imx_drm_crtc->pipe); 145 + return drm_vblank_get(imx_drm_crtc->crtc->dev, imx_drm_crtc->pipe); 146 146 } 147 147 EXPORT_SYMBOL_GPL(imx_drm_crtc_vblank_get); 148 148 149 149 void imx_drm_crtc_vblank_put(struct imx_drm_crtc *imx_drm_crtc) 150 150 { 151 - drm_vblank_put(imx_drm_crtc->imxdrm->drm, imx_drm_crtc->pipe); 151 + drm_vblank_put(imx_drm_crtc->crtc->dev, imx_drm_crtc->pipe); 152 152 } 153 153 EXPORT_SYMBOL_GPL(imx_drm_crtc_vblank_put); 154 154 155 155 void imx_drm_handle_vblank(struct imx_drm_crtc *imx_drm_crtc) 156 156 { 157 - drm_handle_vblank(imx_drm_crtc->imxdrm->drm, imx_drm_crtc->pipe); 157 + drm_handle_vblank(imx_drm_crtc->crtc->dev, imx_drm_crtc->pipe); 158 158 } 159 159 EXPORT_SYMBOL_GPL(imx_drm_handle_vblank); 160 160 ··· 370 370 } 371 371 372 372 /* 373 - * register a crtc to the drm core 374 - */ 375 - static int imx_drm_crtc_register(struct imx_drm_crtc *imx_drm_crtc) 376 - { 377 - struct imx_drm_device *imxdrm = __imx_drm_device(); 378 - int ret; 379 - 380 - ret = drm_mode_crtc_set_gamma_size(imx_drm_crtc->crtc, 256); 381 - if (ret) 382 - return ret; 383 - 384 - drm_crtc_helper_add(imx_drm_crtc->crtc, 385 - imx_drm_crtc->imx_drm_helper_funcs.crtc_helper_funcs); 386 - 387 - drm_crtc_init(imxdrm->drm, imx_drm_crtc->crtc, 388 - imx_drm_crtc->imx_drm_helper_funcs.crtc_funcs); 389 - 390 - drm_mode_group_reinit(imxdrm->drm); 391 - 392 - return 0; 393 - } 394 - 395 - /* 396 373 * Called by the CRTC driver when all CRTCs are registered. This 397 374 * puts all the pieces together and initializes the driver. 398 375 * Once this is called no more CRTCs can be registered since ··· 401 424 402 425 mutex_lock(&imxdrm->mutex); 403 426 404 - drm_kms_helper_poll_init(imxdrm->drm); 427 + drm_kms_helper_poll_init(drm); 405 428 406 429 /* setup the grouping for the legacy output */ 407 - ret = drm_mode_group_init_legacy_group(imxdrm->drm, 408 - &imxdrm->drm->primary->mode_group); 430 + ret = drm_mode_group_init_legacy_group(drm, 431 + &drm->primary->mode_group); 409 432 if (ret) 410 433 goto err_kms; 411 434 412 - ret = drm_vblank_init(imxdrm->drm, MAX_CRTC); 435 + ret = drm_vblank_init(drm, MAX_CRTC); 413 436 if (ret) 414 437 goto err_kms; 415 438 ··· 418 441 * by drm timer once a current process gives up ownership of 419 442 * vblank event.(after drm_vblank_put function is called) 420 443 */ 421 - imxdrm->drm->vblank_disable_allowed = true; 444 + drm->vblank_disable_allowed = true; 422 445 423 446 if (!imx_drm_device_get()) { 424 447 ret = -EINVAL; ··· 513 536 514 537 *new_crtc = imx_drm_crtc; 515 538 516 - ret = imx_drm_crtc_register(imx_drm_crtc); 539 + ret = drm_mode_crtc_set_gamma_size(imx_drm_crtc->crtc, 256); 517 540 if (ret) 518 541 goto err_register; 542 + 543 + drm_crtc_helper_add(crtc, 544 + imx_drm_crtc->imx_drm_helper_funcs.crtc_helper_funcs); 545 + 546 + drm_crtc_init(imxdrm->drm, crtc, 547 + imx_drm_crtc->imx_drm_helper_funcs.crtc_funcs); 548 + 549 + drm_mode_group_reinit(imxdrm->drm); 519 550 520 551 imx_drm_update_possible_crtcs(); 521 552

+9 -13

drivers/staging/imx-drm/imx-hdmi.c

··· 16 16 #include <linux/delay.h> 17 17 #include <linux/err.h> 18 18 #include <linux/clk.h> 19 + #include <linux/hdmi.h> 19 20 #include <linux/regmap.h> 20 21 #include <linux/mfd/syscon.h> 21 22 #include <linux/mfd/syscon/imx6q-iomuxc-gpr.h> ··· 51 50 YCbCr422_8B = 0x16, 52 51 YCbCr422_10B = 0x14, 53 52 YCbCr422_12B = 0x12, 54 - }; 55 - 56 - enum hdmi_colorimetry { 57 - ITU601, 58 - ITU709, 59 53 }; 60 54 61 55 enum imx_hdmi_devtype { ··· 485 489 486 490 if (is_color_space_conversion(hdmi)) { 487 491 if (hdmi->hdmi_data.enc_out_format == RGB) { 488 - if (hdmi->hdmi_data.colorimetry == ITU601) 492 + if (hdmi->hdmi_data.colorimetry == HDMI_COLORIMETRY_ITU_601) 489 493 csc_coeff = &csc_coeff_rgb_out_eitu601; 490 494 else 491 495 csc_coeff = &csc_coeff_rgb_out_eitu709; 492 496 } else if (hdmi->hdmi_data.enc_in_format == RGB) { 493 - if (hdmi->hdmi_data.colorimetry == ITU601) 497 + if (hdmi->hdmi_data.colorimetry == HDMI_COLORIMETRY_ITU_601) 494 498 csc_coeff = &csc_coeff_rgb_in_eitu601; 495 499 else 496 500 csc_coeff = &csc_coeff_rgb_in_eitu709; ··· 1136 1140 /* Set up colorimetry */ 1137 1141 if (hdmi->hdmi_data.enc_out_format == XVYCC444) { 1138 1142 colorimetry = HDMI_FC_AVICONF1_COLORIMETRY_EXTENDED_INFO; 1139 - if (hdmi->hdmi_data.colorimetry == ITU601) 1143 + if (hdmi->hdmi_data.colorimetry == HDMI_COLORIMETRY_ITU_601) 1140 1144 ext_colorimetry = 1141 1145 HDMI_FC_AVICONF2_EXT_COLORIMETRY_XVYCC601; 1142 - else /* hdmi->hdmi_data.colorimetry == ITU709 */ 1146 + else /*hdmi->hdmi_data.colorimetry == HDMI_COLORIMETRY_ITU_709*/ 1143 1147 ext_colorimetry = 1144 1148 HDMI_FC_AVICONF2_EXT_COLORIMETRY_XVYCC709; 1145 1149 } else if (hdmi->hdmi_data.enc_out_format != RGB) { 1146 - if (hdmi->hdmi_data.colorimetry == ITU601) 1150 + if (hdmi->hdmi_data.colorimetry == HDMI_COLORIMETRY_ITU_601) 1147 1151 colorimetry = HDMI_FC_AVICONF1_COLORIMETRY_SMPTE; 1148 - else /* hdmi->hdmi_data.colorimetry == ITU709 */ 1152 + else /*hdmi->hdmi_data.colorimetry == HDMI_COLORIMETRY_ITU_709*/ 1149 1153 colorimetry = HDMI_FC_AVICONF1_COLORIMETRY_ITUR; 1150 1154 ext_colorimetry = HDMI_FC_AVICONF2_EXT_COLORIMETRY_XVYCC601; 1151 1155 } else { /* Carries no data */ ··· 1375 1379 (hdmi->vic == 21) || (hdmi->vic == 22) || 1376 1380 (hdmi->vic == 2) || (hdmi->vic == 3) || 1377 1381 (hdmi->vic == 17) || (hdmi->vic == 18)) 1378 - hdmi->hdmi_data.colorimetry = ITU601; 1382 + hdmi->hdmi_data.colorimetry = HDMI_COLORIMETRY_ITU_601; 1379 1383 else 1380 - hdmi->hdmi_data.colorimetry = ITU709; 1384 + hdmi->hdmi_data.colorimetry = HDMI_COLORIMETRY_ITU_709; 1381 1385 1382 1386 if ((hdmi->vic == 10) || (hdmi->vic == 11) || 1383 1387 (hdmi->vic == 12) || (hdmi->vic == 13) ||

+3 -2

drivers/staging/lustre/TODO

··· 9 9 * Other minor misc cleanups... 10 10 11 11 Please send any patches to Greg Kroah-Hartman <greg@kroah.com>, Andreas Dilger 12 - <andreas.dilger@intel.com> and Peng Tao <tao.peng@emc.com>. CCing 13 - hpdd-discuss <hpdd-discuss@lists.01.org> would be great too. 12 + <andreas.dilger@intel.com>, Oleg Drokin <oleg.drokin@intel.com> and 13 + Peng Tao <tao.peng@emc.com>. CCing hpdd-discuss <hpdd-discuss@lists.01.org> 14 + would be great too.

+2

drivers/staging/lustre/include/linux/libcfs/libcfs_kernelcomm.h

··· 61 61 __u16 kuc_msglen; /* Including header */ 62 62 } __attribute__((aligned(sizeof(__u64)))); 63 63 64 + #define KUC_CHANGELOG_MSG_MAXSIZE (sizeof(struct kuc_hdr)+CR_MAXSIZE) 65 + 64 66 #define KUC_MAGIC 0x191C /*Lustre9etLinC */ 65 67 #define KUC_FL_BLOCK 0x01 /* Wait for send */ 66 68

+1 -1

drivers/staging/lustre/include/linux/libcfs/libcfs_private.h

··· 120 120 do { \ 121 121 LASSERT(!in_interrupt() || \ 122 122 ((size) <= LIBCFS_VMALLOC_SIZE && \ 123 - ((mask) & GFP_ATOMIC)) != 0); \ 123 + ((mask) & __GFP_WAIT) == 0)); \ 124 124 } while (0) 125 125 126 126 #define LIBCFS_ALLOC_POST(ptr, size) \

+1 -1

drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c

··· 529 529 { 530 530 struct page *page; 531 531 532 - if (is_vmalloc_addr(vaddr)) { 532 + if (is_vmalloc_addr((void *)vaddr)) { 533 533 page = vmalloc_to_page ((void *)vaddr); 534 534 LASSERT (page != NULL); 535 535 return page;

+3 -2

drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c

··· 924 924 int 925 925 ksocknal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg) 926 926 { 927 - int mpflag = 0; 927 + int mpflag = 1; 928 928 int type = lntmsg->msg_type; 929 929 lnet_process_id_t target = lntmsg->msg_target; 930 930 unsigned int payload_niov = lntmsg->msg_niov; ··· 993 993 994 994 /* The first fragment will be set later in pro_pack */ 995 995 rc = ksocknal_launch_packet(ni, tx, target); 996 - if (lntmsg->msg_vmflush) 996 + if (!mpflag) 997 997 cfs_memory_pressure_restore(mpflag); 998 + 998 999 if (rc == 0) 999 1000 return (0); 1000 1001

+2 -1

drivers/staging/lustre/lustre/include/lustre/lustre_user.h

··· 760 760 *flags |= (error << CLF_HSM_ERR_L); 761 761 } 762 762 763 - #define CR_MAXSIZE cfs_size_round(2*NAME_MAX + 1 + sizeof(struct changelog_rec)) 763 + #define CR_MAXSIZE cfs_size_round(2*NAME_MAX + 1 + \ 764 + sizeof(struct changelog_ext_rec)) 764 765 765 766 struct changelog_rec { 766 767 __u16 cr_namelen;

+1 -1

drivers/staging/lustre/lustre/llite/dir.c

··· 1086 1086 break; 1087 1087 case Q_GETQUOTA: 1088 1088 if (((type == USRQUOTA && 1089 - uid_eq(current_euid(), make_kuid(&init_user_ns, id))) || 1089 + !uid_eq(current_euid(), make_kuid(&init_user_ns, id))) || 1090 1090 (type == GRPQUOTA && 1091 1091 !in_egroup_p(make_kgid(&init_user_ns, id)))) && 1092 1092 (!cfs_capable(CFS_CAP_SYS_ADMIN) ||

+3 -3

drivers/staging/lustre/lustre/mdc/mdc_request.c

··· 1430 1430 { 1431 1431 struct kuc_hdr *lh = (struct kuc_hdr *)buf; 1432 1432 1433 - LASSERT(len <= CR_MAXSIZE); 1433 + LASSERT(len <= KUC_CHANGELOG_MSG_MAXSIZE); 1434 1434 1435 1435 lh->kuc_magic = KUC_MAGIC; 1436 1436 lh->kuc_transport = KUC_TRANSPORT_CHANGELOG; ··· 1503 1503 CDEBUG(D_CHANGELOG, "changelog to fp=%p start "LPU64"\n", 1504 1504 cs->cs_fp, cs->cs_startrec); 1505 1505 1506 - OBD_ALLOC(cs->cs_buf, CR_MAXSIZE); 1506 + OBD_ALLOC(cs->cs_buf, KUC_CHANGELOG_MSG_MAXSIZE); 1507 1507 if (cs->cs_buf == NULL) 1508 1508 GOTO(out, rc = -ENOMEM); 1509 1509 ··· 1540 1540 if (ctxt) 1541 1541 llog_ctxt_put(ctxt); 1542 1542 if (cs->cs_buf) 1543 - OBD_FREE(cs->cs_buf, CR_MAXSIZE); 1543 + OBD_FREE(cs->cs_buf, KUC_CHANGELOG_MSG_MAXSIZE); 1544 1544 OBD_FREE_PTR(cs); 1545 1545 return rc; 1546 1546 }

+5

drivers/staging/netlogic/xlr_net.c

··· 892 892 priv->mii_bus->write = xlr_mii_write; 893 893 priv->mii_bus->parent = &pdev->dev; 894 894 priv->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL); 895 + if (priv->mii_bus->irq == NULL) { 896 + pr_err("irq alloc failed\n"); 897 + mdiobus_free(priv->mii_bus); 898 + return -ENOMEM; 899 + } 895 900 priv->mii_bus->irq[priv->phy_addr] = priv->ndev->irq; 896 901 897 902 /* Scan only the enabled address */

+155 -196

drivers/staging/octeon-usb/octeon-hcd.c

··· 275 275 */ 276 276 #define MAX_TRANSFER_PACKETS ((1<<10)-1) 277 277 278 - enum { 279 - USB_CLOCK_TYPE_REF_12, 280 - USB_CLOCK_TYPE_REF_24, 281 - USB_CLOCK_TYPE_REF_48, 282 - USB_CLOCK_TYPE_CRYSTAL_12, 283 - }; 284 - 285 278 /** 286 279 * Logical transactions may take numerous low level 287 280 * transactions, especially when splits are concerned. This ··· 464 471 /* Returns the IO address to push/pop stuff data from the FIFOs */ 465 472 #define USB_FIFO_ADDRESS(channel, usb_index) (CVMX_USBCX_GOTGCTL(usb_index) + ((channel)+1)*0x1000) 466 473 467 - static int octeon_usb_get_clock_type(void) 468 - { 469 - switch (cvmx_sysinfo_get()->board_type) { 470 - case CVMX_BOARD_TYPE_BBGW_REF: 471 - case CVMX_BOARD_TYPE_LANAI2_A: 472 - case CVMX_BOARD_TYPE_LANAI2_U: 473 - case CVMX_BOARD_TYPE_LANAI2_G: 474 - case CVMX_BOARD_TYPE_UBNT_E100: 475 - return USB_CLOCK_TYPE_CRYSTAL_12; 476 - } 477 - return USB_CLOCK_TYPE_REF_48; 478 - } 479 - 480 474 /** 481 475 * Read a USB 32bit CSR. It performs the necessary address swizzle 482 476 * for 32bit CSRs and logs the value in a readable format if ··· 562 582 return 0; /* Data0 */ 563 583 } 564 584 565 - 566 - /** 567 - * Return the number of USB ports supported by this Octeon 568 - * chip. If the chip doesn't support USB, or is not supported 569 - * by this API, a zero will be returned. Most Octeon chips 570 - * support one usb port, but some support two ports. 571 - * cvmx_usb_initialize() must be called on independent 572 - * struct cvmx_usb_state. 573 - * 574 - * Returns: Number of port, zero if usb isn't supported 575 - */ 576 - static int cvmx_usb_get_num_ports(void) 577 - { 578 - int arch_ports = 0; 579 - 580 - if (OCTEON_IS_MODEL(OCTEON_CN56XX)) 581 - arch_ports = 1; 582 - else if (OCTEON_IS_MODEL(OCTEON_CN52XX)) 583 - arch_ports = 2; 584 - else if (OCTEON_IS_MODEL(OCTEON_CN50XX)) 585 - arch_ports = 1; 586 - else if (OCTEON_IS_MODEL(OCTEON_CN31XX)) 587 - arch_ports = 1; 588 - else if (OCTEON_IS_MODEL(OCTEON_CN30XX)) 589 - arch_ports = 1; 590 - else 591 - arch_ports = 0; 592 - 593 - return arch_ports; 594 - } 595 - 596 585 /** 597 586 * Initialize a USB port for use. This must be called before any 598 587 * other access to the Octeon USB port is made. The port starts ··· 577 628 * Returns: 0 or a negative error code. 578 629 */ 579 630 static int cvmx_usb_initialize(struct cvmx_usb_state *usb, 580 - int usb_port_number) 631 + int usb_port_number, 632 + enum cvmx_usb_initialize_flags flags) 581 633 { 582 634 union cvmx_usbnx_clk_ctl usbn_clk_ctl; 583 635 union cvmx_usbnx_usbp_ctl_status usbn_usbp_ctl_status; 584 - enum cvmx_usb_initialize_flags flags = 0; 585 636 int i; 586 637 587 638 /* At first allow 0-1 for the usb port number */ 588 639 if ((usb_port_number < 0) || (usb_port_number > 1)) 589 640 return -EINVAL; 590 - /* For all chips except 52XX there is only one port */ 591 - if (!OCTEON_IS_MODEL(OCTEON_CN52XX) && (usb_port_number > 0)) 592 - return -EINVAL; 593 - /* Try to determine clock type automatically */ 594 - if (octeon_usb_get_clock_type() == USB_CLOCK_TYPE_CRYSTAL_12) { 595 - /* Only 12 MHZ crystals are supported */ 596 - flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI; 597 - } else { 598 - flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND; 599 - 600 - switch (octeon_usb_get_clock_type()) { 601 - case USB_CLOCK_TYPE_REF_12: 602 - flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ; 603 - break; 604 - case USB_CLOCK_TYPE_REF_24: 605 - flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ; 606 - break; 607 - case USB_CLOCK_TYPE_REF_48: 608 - flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ; 609 - break; 610 - default: 611 - return -EINVAL; 612 - break; 613 - } 614 - } 615 641 616 642 memset(usb, 0, sizeof(*usb)); 617 643 usb->init_flags = flags; ··· 3355 3431 return 0; 3356 3432 } 3357 3433 3358 - 3359 3434 static const struct hc_driver octeon_hc_driver = { 3360 3435 .description = "Octeon USB", 3361 3436 .product_desc = "Octeon Host Controller", ··· 3371 3448 .hub_control = octeon_usb_hub_control, 3372 3449 }; 3373 3450 3374 - 3375 - static int octeon_usb_driver_probe(struct device *dev) 3451 + static int octeon_usb_probe(struct platform_device *pdev) 3376 3452 { 3377 3453 int status; 3378 - int usb_num = to_platform_device(dev)->id; 3379 - int irq = platform_get_irq(to_platform_device(dev), 0); 3454 + int initialize_flags; 3455 + int usb_num; 3456 + struct resource *res_mem; 3457 + struct device_node *usbn_node; 3458 + int irq = platform_get_irq(pdev, 0); 3459 + struct device *dev = &pdev->dev; 3380 3460 struct octeon_hcd *priv; 3381 3461 struct usb_hcd *hcd; 3382 3462 unsigned long flags; 3463 + u32 clock_rate = 48000000; 3464 + bool is_crystal_clock = false; 3465 + const char *clock_type; 3466 + int i; 3467 + 3468 + if (dev->of_node == NULL) { 3469 + dev_err(dev, "Error: empty of_node\n"); 3470 + return -ENXIO; 3471 + } 3472 + usbn_node = dev->of_node->parent; 3473 + 3474 + i = of_property_read_u32(usbn_node, 3475 + "refclk-frequency", &clock_rate); 3476 + if (i) { 3477 + dev_err(dev, "No USBN \"refclk-frequency\"\n"); 3478 + return -ENXIO; 3479 + } 3480 + switch (clock_rate) { 3481 + case 12000000: 3482 + initialize_flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ; 3483 + break; 3484 + case 24000000: 3485 + initialize_flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ; 3486 + break; 3487 + case 48000000: 3488 + initialize_flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ; 3489 + break; 3490 + default: 3491 + dev_err(dev, "Illebal USBN \"refclk-frequency\" %u\n", clock_rate); 3492 + return -ENXIO; 3493 + 3494 + } 3495 + 3496 + i = of_property_read_string(usbn_node, 3497 + "refclk-type", &clock_type); 3498 + 3499 + if (!i && strcmp("crystal", clock_type) == 0) 3500 + is_crystal_clock = true; 3501 + 3502 + if (is_crystal_clock) 3503 + initialize_flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI; 3504 + else 3505 + initialize_flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND; 3506 + 3507 + res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 3508 + if (res_mem == NULL) { 3509 + dev_err(dev, "found no memory resource\n"); 3510 + return -ENXIO; 3511 + } 3512 + usb_num = (res_mem->start >> 44) & 1; 3513 + 3514 + if (irq < 0) { 3515 + /* Defective device tree, but we know how to fix it. */ 3516 + irq_hw_number_t hwirq = usb_num ? (1 << 6) + 17 : 56; 3517 + irq = irq_create_mapping(NULL, hwirq); 3518 + } 3383 3519 3384 3520 /* 3385 3521 * Set the DMA mask to 64bits so we get buffers already translated for ··· 3446 3464 */ 3447 3465 dev->coherent_dma_mask = ~0; 3448 3466 dev->dma_mask = &dev->coherent_dma_mask; 3449 - 3450 - hcd = usb_create_hcd(&octeon_hc_driver, dev, dev_name(dev)); 3451 - if (!hcd) { 3452 - dev_dbg(dev, "Failed to allocate memory for HCD\n"); 3453 - return -1; 3454 - } 3455 - hcd->uses_new_polling = 1; 3456 - priv = (struct octeon_hcd *)hcd->hcd_priv; 3457 - 3458 - spin_lock_init(&priv->lock); 3459 - 3460 - tasklet_init(&priv->dequeue_tasklet, octeon_usb_urb_dequeue_work, (unsigned long)priv); 3461 - INIT_LIST_HEAD(&priv->dequeue_list); 3462 - 3463 - status = cvmx_usb_initialize(&priv->usb, usb_num); 3464 - if (status) { 3465 - dev_dbg(dev, "USB initialization failed with %d\n", status); 3466 - kfree(hcd); 3467 - return -1; 3468 - } 3469 - 3470 - /* This delay is needed for CN3010, but I don't know why... */ 3471 - mdelay(10); 3472 - 3473 - spin_lock_irqsave(&priv->lock, flags); 3474 - cvmx_usb_poll(&priv->usb); 3475 - spin_unlock_irqrestore(&priv->lock, flags); 3476 - 3477 - status = usb_add_hcd(hcd, irq, IRQF_SHARED); 3478 - if (status) { 3479 - dev_dbg(dev, "USB add HCD failed with %d\n", status); 3480 - kfree(hcd); 3481 - return -1; 3482 - } 3483 - device_wakeup_enable(hcd->self.controller); 3484 - 3485 - dev_dbg(dev, "Registered HCD for port %d on irq %d\n", usb_num, irq); 3486 - 3487 - return 0; 3488 - } 3489 - 3490 - static int octeon_usb_driver_remove(struct device *dev) 3491 - { 3492 - int status; 3493 - struct usb_hcd *hcd = dev_get_drvdata(dev); 3494 - struct octeon_hcd *priv = hcd_to_octeon(hcd); 3495 - unsigned long flags; 3496 - 3497 - usb_remove_hcd(hcd); 3498 - tasklet_kill(&priv->dequeue_tasklet); 3499 - spin_lock_irqsave(&priv->lock, flags); 3500 - status = cvmx_usb_shutdown(&priv->usb); 3501 - spin_unlock_irqrestore(&priv->lock, flags); 3502 - if (status) 3503 - dev_dbg(dev, "USB shutdown failed with %d\n", status); 3504 - 3505 - kfree(hcd); 3506 - 3507 - return 0; 3508 - } 3509 - 3510 - static struct device_driver octeon_usb_driver = { 3511 - .name = "OcteonUSB", 3512 - .bus = &platform_bus_type, 3513 - .probe = octeon_usb_driver_probe, 3514 - .remove = octeon_usb_driver_remove, 3515 - }; 3516 - 3517 - 3518 - #define MAX_USB_PORTS 10 3519 - static struct platform_device *pdev_glob[MAX_USB_PORTS]; 3520 - static int octeon_usb_registered; 3521 - static int __init octeon_usb_module_init(void) 3522 - { 3523 - int num_devices = cvmx_usb_get_num_ports(); 3524 - int device; 3525 - 3526 - if (usb_disabled() || num_devices == 0) 3527 - return -ENODEV; 3528 - 3529 - if (driver_register(&octeon_usb_driver)) 3530 - return -ENOMEM; 3531 - 3532 - octeon_usb_registered = 1; 3533 3467 3534 3468 /* 3535 3469 * Only cn52XX and cn56XX have DWC_OTG USB hardware and the ··· 3467 3569 cvmx_write_csr(CVMX_IOB_N2C_L2C_PRI_CNT, pri_cnt.u64); 3468 3570 } 3469 3571 3470 - for (device = 0; device < num_devices; device++) { 3471 - struct resource irq_resource; 3472 - struct platform_device *pdev; 3473 - memset(&irq_resource, 0, sizeof(irq_resource)); 3474 - irq_resource.start = (device == 0) ? OCTEON_IRQ_USB0 : OCTEON_IRQ_USB1; 3475 - irq_resource.end = irq_resource.start; 3476 - irq_resource.flags = IORESOURCE_IRQ; 3477 - pdev = platform_device_register_simple((char *)octeon_usb_driver. name, device, &irq_resource, 1); 3478 - if (IS_ERR(pdev)) { 3479 - driver_unregister(&octeon_usb_driver); 3480 - octeon_usb_registered = 0; 3481 - return PTR_ERR(pdev); 3482 - } 3483 - if (device < MAX_USB_PORTS) 3484 - pdev_glob[device] = pdev; 3485 - 3572 + hcd = usb_create_hcd(&octeon_hc_driver, dev, dev_name(dev)); 3573 + if (!hcd) { 3574 + dev_dbg(dev, "Failed to allocate memory for HCD\n"); 3575 + return -1; 3486 3576 } 3577 + hcd->uses_new_polling = 1; 3578 + priv = (struct octeon_hcd *)hcd->hcd_priv; 3579 + 3580 + spin_lock_init(&priv->lock); 3581 + 3582 + tasklet_init(&priv->dequeue_tasklet, octeon_usb_urb_dequeue_work, (unsigned long)priv); 3583 + INIT_LIST_HEAD(&priv->dequeue_list); 3584 + 3585 + status = cvmx_usb_initialize(&priv->usb, usb_num, initialize_flags); 3586 + if (status) { 3587 + dev_dbg(dev, "USB initialization failed with %d\n", status); 3588 + kfree(hcd); 3589 + return -1; 3590 + } 3591 + 3592 + /* This delay is needed for CN3010, but I don't know why... */ 3593 + mdelay(10); 3594 + 3595 + spin_lock_irqsave(&priv->lock, flags); 3596 + cvmx_usb_poll(&priv->usb); 3597 + spin_unlock_irqrestore(&priv->lock, flags); 3598 + 3599 + status = usb_add_hcd(hcd, irq, 0); 3600 + if (status) { 3601 + dev_dbg(dev, "USB add HCD failed with %d\n", status); 3602 + kfree(hcd); 3603 + return -1; 3604 + } 3605 + device_wakeup_enable(hcd->self.controller); 3606 + 3607 + dev_info(dev, "Registered HCD for port %d on irq %d\n", usb_num, irq); 3608 + 3487 3609 return 0; 3488 3610 } 3489 3611 3490 - static void __exit octeon_usb_module_cleanup(void) 3612 + static int octeon_usb_remove(struct platform_device *pdev) 3491 3613 { 3492 - int i; 3614 + int status; 3615 + struct device *dev = &pdev->dev; 3616 + struct usb_hcd *hcd = dev_get_drvdata(dev); 3617 + struct octeon_hcd *priv = hcd_to_octeon(hcd); 3618 + unsigned long flags; 3493 3619 3494 - for (i = 0; i < MAX_USB_PORTS; i++) 3495 - if (pdev_glob[i]) { 3496 - platform_device_unregister(pdev_glob[i]); 3497 - pdev_glob[i] = NULL; 3498 - } 3499 - if (octeon_usb_registered) 3500 - driver_unregister(&octeon_usb_driver); 3620 + usb_remove_hcd(hcd); 3621 + tasklet_kill(&priv->dequeue_tasklet); 3622 + spin_lock_irqsave(&priv->lock, flags); 3623 + status = cvmx_usb_shutdown(&priv->usb); 3624 + spin_unlock_irqrestore(&priv->lock, flags); 3625 + if (status) 3626 + dev_dbg(dev, "USB shutdown failed with %d\n", status); 3627 + 3628 + kfree(hcd); 3629 + 3630 + return 0; 3501 3631 } 3502 3632 3633 + static struct of_device_id octeon_usb_match[] = { 3634 + { 3635 + .compatible = "cavium,octeon-5750-usbc", 3636 + }, 3637 + {}, 3638 + }; 3639 + 3640 + static struct platform_driver octeon_usb_driver = { 3641 + .driver = { 3642 + .name = "OcteonUSB", 3643 + .owner = THIS_MODULE, 3644 + .of_match_table = octeon_usb_match, 3645 + }, 3646 + .probe = octeon_usb_probe, 3647 + .remove = octeon_usb_remove, 3648 + }; 3649 + 3650 + static int __init octeon_usb_driver_init(void) 3651 + { 3652 + if (usb_disabled()) 3653 + return 0; 3654 + 3655 + return platform_driver_register(&octeon_usb_driver); 3656 + } 3657 + module_init(octeon_usb_driver_init); 3658 + 3659 + static void __exit octeon_usb_driver_exit(void) 3660 + { 3661 + if (usb_disabled()) 3662 + return; 3663 + 3664 + platform_driver_unregister(&octeon_usb_driver); 3665 + } 3666 + module_exit(octeon_usb_driver_exit); 3667 + 3503 3668 MODULE_LICENSE("GPL"); 3504 - MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>"); 3505 - MODULE_DESCRIPTION("Cavium Networks Octeon USB Host driver."); 3506 - module_init(octeon_usb_module_init); 3507 - module_exit(octeon_usb_module_cleanup); 3669 + MODULE_AUTHOR("Cavium, Inc. <support@cavium.com>"); 3670 + MODULE_DESCRIPTION("Cavium Inc. OCTEON USB Host driver.");

+2 -1

drivers/staging/ozwpan/ozproto.c

··· 668 668 if (binding) { 669 669 binding->ptype.type = __constant_htons(OZ_ETHERTYPE); 670 670 binding->ptype.func = oz_pkt_recv; 671 - memcpy(binding->name, net_dev, OZ_MAX_BINDING_LEN); 672 671 if (net_dev && *net_dev) { 672 + memcpy(binding->name, net_dev, OZ_MAX_BINDING_LEN); 673 673 oz_dbg(ON, "Adding binding: %s\n", net_dev); 674 674 binding->ptype.dev = 675 675 dev_get_by_name(&init_net, net_dev); ··· 680 680 } 681 681 } else { 682 682 oz_dbg(ON, "Binding to all netcards\n"); 683 + memset(binding->name, 0, OZ_MAX_BINDING_LEN); 683 684 binding->ptype.dev = NULL; 684 685 } 685 686 if (binding) {

+8 -14

drivers/staging/rtl8188eu/core/rtw_wlan_util.c

··· 912 912 unsigned char *pbuf; 913 913 u32 wpa_ielen = 0; 914 914 u8 *pbssid = GetAddr3Ptr(pframe); 915 - u32 hidden_ssid = 0; 916 915 struct HT_info_element *pht_info = NULL; 917 916 struct rtw_ieee80211_ht_cap *pht_cap = NULL; 918 917 u32 bcn_channel; 919 918 unsigned short ht_cap_info; 920 919 unsigned char ht_info_infos_0; 920 + int ssid_len; 921 921 922 922 if (is_client_associated_to_ap(Adapter) == false) 923 923 return true; ··· 999 999 } 1000 1000 1001 1001 /* checking SSID */ 1002 + ssid_len = 0; 1002 1003 p = rtw_get_ie(bssid->IEs + _FIXED_IE_LENGTH_, _SSID_IE_, &len, bssid->IELength - _FIXED_IE_LENGTH_); 1003 - if (p == NULL) { 1004 - DBG_88E("%s marc: cannot find SSID for survey event\n", __func__); 1005 - hidden_ssid = true; 1006 - } else { 1007 - hidden_ssid = false; 1004 + if (p) { 1005 + ssid_len = *(p + 1); 1006 + if (ssid_len > NDIS_802_11_LENGTH_SSID) 1007 + ssid_len = 0; 1008 1008 } 1009 - 1010 - if ((NULL != p) && (false == hidden_ssid && (*(p + 1)))) { 1011 - memcpy(bssid->Ssid.Ssid, (p + 2), *(p + 1)); 1012 - bssid->Ssid.SsidLength = *(p + 1); 1013 - } else { 1014 - bssid->Ssid.SsidLength = 0; 1015 - bssid->Ssid.Ssid[0] = '\0'; 1016 - } 1009 + memcpy(bssid->Ssid.Ssid, (p + 2), ssid_len); 1010 + bssid->Ssid.SsidLength = ssid_len; 1017 1011 1018 1012 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("%s bssid.Ssid.Ssid:%s bssid.Ssid.SsidLength:%d " 1019 1013 "cur_network->network.Ssid.Ssid:%s len:%d\n", __func__, bssid->Ssid.Ssid,

+5 -7

drivers/staging/rtl8188eu/os_dep/ioctl_linux.c

··· 2500 2500 ("rtw_mp_ioctl_hdl: subcode [%d], len[%d], buffer_len[%d]\r\n", 2501 2501 poidparam->subcode, poidparam->len, len)); 2502 2502 2503 - if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) { 2503 + if (poidparam->subcode >= ARRAY_SIZE(mp_ioctl_hdl)) { 2504 2504 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("no matching drvext subcodes\r\n")); 2505 2505 ret = -EINVAL; 2506 2506 goto _rtw_mp_ioctl_hdl_exit; ··· 3164 3164 u8 *p2pie; 3165 3165 uint p2pielen = 0, attr_contentlen = 0; 3166 3166 u8 attr_content[100] = {0x00}; 3167 - 3168 - u8 go_devadd_str[17 + 10] = {0x00}; 3169 - /* +10 is for the str "go_devadd =", we have to clear it at wrqu->data.pointer */ 3167 + u8 go_devadd_str[17 + 12] = {}; 3170 3168 3171 3169 /* Commented by Albert 20121209 */ 3172 3170 /* The input data is the GO's interface address which the application wants to know its device address. */ ··· 3221 3223 spin_unlock_bh(&pmlmepriv->scanned_queue.lock); 3222 3224 3223 3225 if (!blnMatch) 3224 - sprintf(go_devadd_str, "\n\ndev_add = NULL"); 3226 + snprintf(go_devadd_str, sizeof(go_devadd_str), "\n\ndev_add = NULL"); 3225 3227 else 3226 - sprintf(go_devadd_str, "\n\ndev_add =%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", 3228 + snprintf(go_devadd_str, sizeof(go_devadd_str), "\n\ndev_add =%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", 3227 3229 attr_content[0], attr_content[1], attr_content[2], attr_content[3], attr_content[4], attr_content[5]); 3228 3230 3229 - if (copy_to_user(wrqu->data.pointer, go_devadd_str, 10 + 17)) 3231 + if (copy_to_user(wrqu->data.pointer, go_devadd_str, sizeof(go_devadd_str))) 3230 3232 return -EFAULT; 3231 3233 return ret; 3232 3234 }

+1 -1

drivers/staging/rtl8188eu/os_dep/usb_intf.c

··· 53 53 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0179)}, /* 8188ETV */ 54 54 /*=== Customer ID ===*/ 55 55 /****** 8188EUS ********/ 56 - {USB_DEVICE(0x8179, 0x07B8)}, /* Abocom - Abocom */ 56 + {USB_DEVICE(0x07b8, 0x8179)}, /* Abocom - Abocom */ 57 57 {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */ 58 58 {} /* Terminating entry */ 59 59 };

+1 -1

drivers/staging/rtl8821ae/Kconfig

··· 1 1 config R8821AE 2 2 tristate "RealTek RTL8821AE Wireless LAN NIC driver" 3 - depends on PCI && WLAN 3 + depends on PCI && WLAN && MAC80211 4 4 depends on m 5 5 select WIRELESS_EXT 6 6 select WEXT_PRIV

+1 -1

drivers/staging/rtl8821ae/wifi.h

··· 1414 1414 1415 1415 1416 1416 /*88e tx power tracking*/ 1417 - u8 bb_swing_idx_ofdm[2]; 1417 + u8 bb_swing_idx_ofdm[MAX_RF_PATH]; 1418 1418 u8 bb_swing_idx_ofdm_current; 1419 1419 u8 bb_swing_idx_ofdm_base[MAX_RF_PATH]; 1420 1420 bool bb_swing_flag_Ofdm;

+5 -5

drivers/staging/usbip/userspace/libsrc/names.c

··· 169 169 struct pool *p; 170 170 171 171 p = calloc(1, sizeof(struct pool)); 172 - if (!p) { 172 + if (!p) 173 + return NULL; 174 + 175 + p->mem = calloc(1, size); 176 + if (!p->mem) { 173 177 free(p); 174 178 return NULL; 175 179 } 176 - 177 - p->mem = calloc(1, size); 178 - if (!p->mem) 179 - return NULL; 180 180 181 181 p->next = pool_head; 182 182 pool_head = p;

+2 -1

drivers/staging/usbip/vhci_sysfs.c

··· 149 149 case USB_SPEED_WIRELESS: 150 150 break; 151 151 default: 152 - pr_err("speed %d\n", speed); 152 + pr_err("Failed attach request for unsupported USB speed: %s\n", 153 + usb_speed_string(speed)); 153 154 return -EINVAL; 154 155 } 155 156

+1 -1

drivers/staging/wlags49_h2/wl_wext.c

··· 1061 1061 goto out; 1062 1062 } 1063 1063 1064 - if (data->flags != 0 && data->length > HCF_MAX_NAME_LEN + 1) { 1064 + if (data->flags != 0 && data->length > HCF_MAX_NAME_LEN) { 1065 1065 ret = -EINVAL; 1066 1066 goto out; 1067 1067 }

Configure Feed

Configure Feed